org.hibernate.validator.constraints.NotBlank Java Examples

@Override
public Response toResponse(JerseyViolationException exception) {
    LOGGER.info(exception.getMessage());
    ConstraintViolation<?> firstException = exception.getConstraintViolations().iterator().next();
    String fieldName = getApiFieldName(firstException.getPropertyPath());
    
    PaymentError paymentError;
    if (firstException.getConstraintDescriptor() != null &&
            firstException.getConstraintDescriptor().getAnnotation() != null &&
            firstException.getConstraintDescriptor().getAnnotation().annotationType() == NotBlank.class ||
            firstException.getConstraintDescriptor().getAnnotation().annotationType() == NotEmpty.class ||
            firstException.getConstraintDescriptor().getAnnotation().annotationType() == NotNull.class) {
        paymentError = PaymentError.aPaymentError(fieldName, CREATE_PAYMENT_MISSING_FIELD_ERROR);
    } else {
        paymentError = PaymentError.aPaymentError(fieldName, CREATE_PAYMENT_VALIDATION_ERROR, firstException.getMessage());
    }
    
    return Response.status(422)
            .entity(paymentError)
            .build();
}
 

@RequestMapping(value="/groupsum", method={RequestMethod.POST, RequestMethod.GET})
public @ResponseBody Map<Integer, BigDecimal> groupsum(@NotBlank @RequestParam String indName, 
        @RequestParam(required=false) String filterDims,
        @RequestParam String groupbyDim,
        @NotBlank @RequestParam String... timeSeries) throws Throwable {
    
    LOGGER.info("Try to sum {} on {} with filter {}.", indName, ObjectUtils.getDisplayString(timeSeries), filterDims);
    long timing = System.currentTimeMillis();
    Map<String, List<Integer>> filter = (filterDims == null || "".equals(filterDims)) ? null
            : objectMapper.readValue(filterDims, new TypeReference<Map<String, List<Integer>>>() {});
    Map<Integer, BigDecimal> sum = manager.aggs(timeSeries).sum(indName, groupbyDim, filter);
    LOGGER.info("Sucess to sum {} on {} result size is {} using {}ms.", indName, timeSeries, sum.size(), System.currentTimeMillis() - timing);
    LOGGER.debug("Sucess to sum {} on {} result is {}.", indName, timeSeries, sum);
    
    return sum;
}
 

@Override
@Path("/{idFeature}")
@GET
@ValidationRequired(processor = RestViolationProcessor.class)
@ApiOperation(value = "Get a feature by id", httpMethod="GET", response=FeatureDTO.class)
@ApiResponses(value = {
		@ApiResponse(code = 200, message = "Feature was found", response=FeatureDTO.class),
		@ApiResponse(code = 400, message = "Invalid input parameter (header)"),
		@ApiResponse(code = 404, message = "Feature was not found")})
public Response getFeatureByID(@Auth BasicAuth principal,
		@ApiParam(value = "Application identifier", required = true) @NotBlank @NotNull @HeaderParam("api_key") String appIdentifier, 
		@ApiParam(required=true, value="Feature identifier") @NotBlank @NotNull @PathParam("idFeature") String idFeature) throws AssemblyException, FeatureNotExistException {
	// TODO Auto-generated method stub
	validations.checkIsNotNullAndNotBlank(appIdentifier,idFeature);
	Feature feature = featureManager.getFeatureByID(appIdentifier,idFeature);
	FeatureDTO featureDTO=featureAssembler.createDataTransferObject(feature);
	return Response.ok(featureDTO).build();
}
 

@RequestMapping(value="/groupcount", method={RequestMethod.POST, RequestMethod.GET})
public @ResponseBody Map<Integer, Long> groupcount(@NotBlank @RequestParam String indName, 
        @RequestParam(required=false) String filterDims,
        @RequestParam String groupbyDim,
        @NotBlank @RequestParam String... timeSeries) throws Throwable {
    
    LOGGER.info("Try to count {} on {} with filter {}.", indName, ObjectUtils.getDisplayString(timeSeries), filterDims);
    long timing = System.currentTimeMillis();
    Map<String, List<Integer>> filter = (filterDims == null || "".equals(filterDims)) ? null
            : objectMapper.readValue(filterDims, new TypeReference<Map<String, List<Integer>>>() {});
    Map<Integer, Long> count = manager.aggs(timeSeries).count(indName, groupbyDim, filter);
    LOGGER.info("Sucess to count {} on {} result size is {} using {}ms.", indName, timeSeries, count.size(), System.currentTimeMillis() - timing);
    LOGGER.debug("Sucess to count {} on {} result is {}.", indName, timeSeries, count);
    
    return count;
}
 

@Override
@Path("/{idFeature}")
@DELETE
@ValidationRequired(processor = RestViolationProcessor.class)
@ApiOperation(value = "Delete a feature", httpMethod="DELETE")
@ApiResponses(value = {
		@ApiResponse(code = 204, message = "Feature was deleted"),
		@ApiResponse(code = 400, message = "Invalid input parameter (header)"),
		@ApiResponse(code = 404, message = "Feature was not found")})
public Response deleteFeature(@Auth BasicAuth principal,
		@ApiParam(value = "Application identifier", required = true) @NotBlank @NotNull @HeaderParam("api_key") String appIdentifier, 
		@ApiParam(required=true, value="Feature identifier") @NotBlank @NotNull @PathParam("idFeature") String idFeature) throws FeatureNotExistException {
	// TODO Auto-generated method stub
	validations.checkIsNotNullAndNotBlank(appIdentifier,idFeature);
	featureManager.deleteFeature(appIdentifier, idFeature);
	return Response.noContent().build();
}
 

@Override
@POST		
@ValidationRequired(processor = RestViolationProcessor.class)
@ApiOperation(value = "Store a feature", httpMethod="POST", response=FeatureDTO.class)
@ApiResponses(value = {
		@ApiResponse(code = 200, message = "Feature was stored", response=FeatureDTO.class),
		@ApiResponse(code = 400, message = "Latitude range out of index"),
		@ApiResponse(code = 400, message = "Longitude range out of index"),
		@ApiResponse(code = 400, message = "Geometry is invalid"),
		@ApiResponse(code = 400, message = "Mongo GeoJSON format is not correct"),
		@ApiResponse(code = 400, message = "Invalid input parameter (header)")})
public Response storeFeature(@Auth BasicAuth principal,
		@ApiParam(value = "Application identifier", required = true) @NotBlank @NotNull @HeaderParam("api_key") String appIdentifier,
		@ApiParam(required=true, value="Feature") @Valid @NotNull FeatureDTO featureDTO) throws AssemblyException, MongoGeospatialException {
	validations.checkIsNotNullAndNotBlank(appIdentifier);
	validations.checkIsNotNull(featureDTO);
	Feature feature = featureManager.storeFeature(appIdentifier, featureAssembler.createDomainObject(featureDTO));		
	FeatureDTO featureResponseDTO=featureAssembler.createDataTransferObject(feature);		
	return Response.ok(featureResponseDTO).build();
}
 

@RequestMapping(value="/distinctcount", method={RequestMethod.POST, RequestMethod.GET})
public @ResponseBody Map<Integer, Integer> distinctCount(@NotBlank @RequestParam String indName,
        @NotBlank @RequestParam(required=false) Boolean isDim,
        @RequestParam(required=false) String filterDims,
        @RequestParam String groupbyDim,
        @NotBlank @RequestParam String... timeSeries) throws Throwable {
    
    LOGGER.info("Try to distinct-count {} on {} with filter {}.", indName, ObjectUtils.getDisplayString(timeSeries), filterDims);
    long timing = System.currentTimeMillis();
    Map<String, List<Integer>> filter = (filterDims == null || "".equals(filterDims)) ? null
            : objectMapper.readValue(filterDims, new TypeReference<Map<String, List<Integer>>>() {});
    Map<Integer, Integer> distinct = manager.aggs(timeSeries).discnt(indName, isDim == null ? true : isDim, groupbyDim, filter);
    LOGGER.info("Sucess to distinct-count {} on {} result size is {} using {}ms.", indName, timeSeries, distinct.size(), System.currentTimeMillis() - timing);
    LOGGER.debug("Sucess to distinct-count {} on {} result is {}.", indName, timeSeries, distinct);
    
    return distinct;
}
 

@Override			
@Path("/room")
@GET
@ValidationRequired(processor = RestViolationProcessor.class)
@ApiOperation(value = "Get room according to indoor location", httpMethod="GET",response=RoomDTO.class)
@ApiResponses(value = {
		@ApiResponse(code = 200, message = "Room belongs to location", response=RoomDTO.class),
		@ApiResponse(code = 400, message = "Invalid input parameter"),
		@ApiResponse(code = 404, message = "Room not found"),
		@ApiResponse(code = 500, message = "Problem in the system")})
public Response getRoomByLocation(@Auth BasicAuth principal,
		@ApiParam(value = "Application identifier", required = true) @NotBlank @NotNull @HeaderParam("api_key") String appIdentifier, 			
		@ApiParam(value="Longitude of location", required=true) @Min(-180) @Max(180) @NotNull @QueryParam("longitude") Double longitude,
		@ApiParam(value="Latitude of location", required=true) @Min(-90) @Max(90) @NotNull @QueryParam("latitude") Double latitude,
		@ApiParam(value = "Floor of location", required = true) @NotNull  @QueryParam("floor") Integer floor) throws AssemblyException, RoomNotFoundException{
	validations.checkIsNotNullAndNotBlank(appIdentifier);
	validations.checkMin(-180.0, longitude);
	validations.checkMax(180.0, longitude);
	validations.checkMin(-90.0, latitude);
	validations.checkMax(90.0, latitude);
	validations.checkIsNotNull(floor);
	
	Feature room=searchManager.getRoomByLocation(appIdentifier, longitude, latitude, floor);			
	RoomDTO roomDTO=roomAssembler.createDataTransferObject(room);				
	return Response.ok(roomDTO).build();		
}
 

@Override		
@POST	
@ValidationRequired(processor = RestViolationProcessor.class)
@ApiOperation(value = "Get features according to query", httpMethod="POST", response=FeatureDTO.class, responseContainer = "List")
@ApiResponses(value = {
		@ApiResponse(code = 200, message = "Features were found", response=FeatureDTO.class),
		@ApiResponse(code = 400, message = "Invalid input parameter (header)"),
		@ApiResponse(code = 400, message = "Query is not correct")})
public Response getFeaturesByQuery(@Auth BasicAuth principal,
		@ApiParam(value = "Application identifier", required = true) @NotBlank @NotNull @HeaderParam("api_key") String appIdentifier, 
		@ApiParam(value = "Query", required = true) @NotBlank @NotNull String query, 
		@ApiParam(required=false,value="Layer",allowableValues="ALL,MAP,FEATURES",defaultValue="ALL") @QueryParam("layer") @DefaultValue("ALL") LayerDTO layer,
		@ApiParam(required=false,value="Index of page",defaultValue="0") @QueryParam("pageIndex") @DefaultValue("0") Integer pageIndex, 
		@ApiParam(required=false,value="Size of page",defaultValue="20") @QueryParam("pageSize") @DefaultValue("20") Integer pageSize,
		@ApiParam(required=false,value="Order field") @QueryParam("orderField") String orderField, 
		@ApiParam(required=false,value="Order",allowableValues="ASC,DESC") @DefaultValue("ASC") @QueryParam("order") String order) throws AssemblyException, QueryException {
					
	validations.checkIsNotNullAndNotBlank(appIdentifier,query);
	validations.checkIsNotNull(layer);
	validations.checkMin(0, pageIndex);
	validations.checkMin(1, pageSize);
	
	Collection<Feature>  features = null;
	
	if(StringUtils.isEmpty(orderField)){
		features =  searchManager.getFeaturesByQuery(appIdentifier, query, layer, pageIndex, pageSize);				
	}else{
		features =  searchManager.getFeaturesByQuery(appIdentifier, query, layer, pageIndex, pageSize, orderField, order);
	}
	
	Collection<FeatureDTO> collectionFeatureDTO=featureAssembler.createDataTransferObjects(features);
	return Response.ok(collectionFeatureDTO).build();
}
 

@Override
@GET
@ValidationRequired(processor = RestViolationProcessor.class)
@ApiOperation(value = "Get .map file", httpMethod="GET", response=InputStream.class)
@ApiResponses(value = {
  @ApiResponse(code = 200, message = ".map file was found", response=InputStream.class),
  @ApiResponse(code = 400, message = "Invalid input parameter (header)"),
  @ApiResponse(code = 404, message = ".map file was not found")})
public Response getMapFile(@Auth BasicAuth principal,
  @ApiParam(value = "Application identifier", required = true) @NotBlank @NotNull @HeaderParam("api_key") String appIdentifier) throws MapFileNotExistsException{
 validations.checkIsNotNullAndNotBlank(appIdentifier);
 InputStream mapFile=mapFileManager.getMapFile(appIdentifier);
 return Response.ok(mapFile).build();
}
 

@NotBlank(message = "Collection name is required")
public String getCollection() {
    return collection;
}
 

@NotBlank
public String getTemporaryRemoteDir() {
	return this.temporaryRemoteDir;
}
 

@JsonCreator
public TagInput(@NotBlank @JsonProperty("name") String name) {
	this.name = name;
}
 

@NotBlank
@Pattern(regexp="^((?!-).)*$", message="{custom.validation.constraints.ParcelName.message}")
String getName();
 

@NotBlank
public String getLoginName() {
	return loginName;
}
 

@NotBlank
String getParcelName();
 

/** Name of the command. */
@NotBlank
String getName();
 

@Override
@NotBlank(message = "Multi-Valued attributes may not have empty values")
@org.hibernate.validator.constraints.Email(message = "${validatedValue} is not a valid e-mail address")
public String getValue() {
    return super.getValue();
}
 

@NotBlank
String getVersion();
 

/** Display name of the command. */
@NotBlank
String getLabel();
 

@NotBlank(message = "A valid key expression is required")
public String getKeyExpression() {
	return keyExpression;
}
 

@NotBlank(message = "A valid query string is required")
public String getQuery() {
	return query;
}
 

@NotBlank(message = "Region name is required")
public String getRegionName() {
	return regionName;
}
 

/** Role for which the steps are applied during rolling restart. */
@NotBlank
@Referencing(type=ReferenceType.ROLE)
String getRoleName();
 

@NotBlank
public String getName() {
    return name;
}
 

@NotBlank
String getLabel();
 

/**
 * First part of the principal.
 */
@NotBlank
@AvailableSubstitutions(type={PARAMETERS, PRINCIPAL})
String getPrimary();
 

@NotBlank
public String getRemoteDir() {
	return remoteDir;
}
 

@NotBlank
String getName();
 

@NotBlank(message="岗位名称不能为空")
@Length(min=0, max=100, message="岗位名称长度不能超过 100 个字符")
public String getPostName() {
	return postName;
}