Java ResponseEntity类代码示例

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
@CrossOrigin
@RequestMapping(value = "/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
@ApiOperation(value = "Find applicants of a given project", notes = "Returns a collection of projects")
@ApiResponses(value = {
        @ApiResponse(code = 404, message = "Applicants not found")
})
public ResponseEntity<List<UserDTO>> getApplicants(@ApiParam(value = "ID of project", required = true)
                                        @PathVariable("id") Integer projectId) {
    List<UserDTO> applicants = userService.getApplicants(projectId);

    if (!applicants.isEmpty()) {
       return ResponseEntity.ok().body(applicants);
    }else{
        throw new NotFoundException("Applicants not found");
    }
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * Gets all weather information in the database
 * @return the list of all weather information
 */
@RequestMapping(method = RequestMethod.GET, value = "/information", produces = "application/json")
public ResponseEntity getAllWeatherInformation() {
    List<WeatherInformation> weatherInformationList = this.weatherInformationService.getAllWeatherInformation();

    return ResponseEntity.ok(weatherInformationList);
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
@RequestMapping(method = RequestMethod.POST)
@ResponseBody
public ResponseEntity<?> addOrder(@RequestBody OrderDto orderDto) {
    LOGGER.info("Start addOrder: {}", orderDto);
    Order order = Order.toEntity(orderDto);
    orderService.saveOrUpdate(order);
    return new ResponseEntity<>(OrderDto.toDto(order), HttpStatus.CREATED);
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
@RequestMapping(value = "/{instanceId}/service_bindings/{bindingId}", method = RequestMethod.PUT)
public ResponseEntity<ServiceInstanceBindingResponse> bindServiceInstance(
		@PathVariable("instanceId") String instanceId, @PathVariable("bindingId") String bindingId,
		@Valid @RequestBody ServiceInstanceBindingRequest request)
				throws ServiceInstanceDoesNotExistException, ServiceInstanceBindingExistsException,
				ServiceBrokerException, ServiceDefinitionDoesNotExistException {

	log.debug("PUT: " + SERVICE_INSTANCE_BINDING_BASE_PATH + "/{bindingId}"
			+ ", bindServiceInstance(), instanceId = " + instanceId + ", bindingId = " + bindingId);

	Map<String, String> bindResource = request.getBindResource();
	String route = (bindResource != null) ? bindResource.get("route") : null;
	ServiceInstanceBindingResponse response = bindingService.createServiceInstanceBinding(bindingId, instanceId,
			request.getServiceDefinitionId(), request.getPlanId(), (request.getAppGuid() == null), route);

	log.debug("ServiceInstanceBinding Created: " + bindingId);

	return new ResponseEntity<ServiceInstanceBindingResponse>(response, HttpStatus.CREATED);
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * Function to create an Organisation
 *
 * Only a system administrator cna create an Organisation
 *
 * @param organisation
 * @return ResponseEntity
 */
@RequestMapping(value = "", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<?> create(@RequestBody final DtoOrganisation organisation) {
	try {
		LOGGER.debug(() -> "Creating Organisation " + organisation.getName());
		IUser actor = getLoggedInUser();
		return new ResponseEntity<>(convertToDtoOrganisation(actor, serviceOrganisation.createOrganisation(actor,
				organisation)), HttpStatus.OK);
	} catch (ServiceOrganisationExceptionNotAllowed ex) {
		return new ResponseEntity<>(ex, HttpStatus.FORBIDDEN);
	}
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * 执行POST请求
 *
 * @param url
 * @param contentType
 * @param requestBody
 * @return
 */
protected WebhookRequestResponse doPost(String url, String contentType, Object requestBody) {

    // 请求头
    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.setContentType(MediaType.parseMediaType(contentType));

    HttpEntity<?> requestEntity = new HttpEntity(requestBody, requestHeaders);

    try {
        // 执行请求
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
        // 返回响应结果
        return new WebhookRequestResponse(requestHeaders, requestBody, responseEntity);

    } catch (Exception e) {
        return new WebhookRequestResponse(requestHeaders, requestBody, e);
    }

}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
@ApiOperation(value = "getParticipantFromCGOR", nickname = "getParticipantFromCGOR")
@RequestMapping(value = "/CISConnector/getParticipantFromCGOR/{cgorName}", method = RequestMethod.GET)
@ApiImplicitParams({
       @ApiImplicitParam(name = "cgorName", value = "the CGOR name", required = true, dataType = "String", paramType = "path"),
       @ApiImplicitParam(name = "organisation", value = "the Organisation name", required = true, dataType = "String", paramType = "query")
     })
@ApiResponses(value = { 
           @ApiResponse(code = 200, message = "Success", response = Participant.class),
           @ApiResponse(code = 400, message = "Bad Request", response = Participant.class),
           @ApiResponse(code = 500, message = "Failure", response = Participant.class)})
public ResponseEntity<Participant> getParticipantFromCGOR(@PathVariable String cgorName, @QueryParam("organisation") String organisation) {
	log.info("--> getParticipantFromCGOR: " + cgorName);
	
	Participant participant;
	
	try {
		participant = connector.getParticipantFromCGOR(cgorName, organisation);
	} catch (CISCommunicationException e) {
		log.error("Error executing the request: Communication Error" , e);
		participant = null;
	}
	
	HttpHeaders responseHeaders = new HttpHeaders();
	
	log.info("getParticipantFromCGOR -->");
	return new ResponseEntity<Participant>(participant, responseHeaders, HttpStatus.OK);
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
private ResponseEntity<BaseResource> doPutResource(final BaseResource resource, final String resourceIdentifier) {
    try {
        boolean createdResource = this.service.upsertResource(resource);

        URI resourceUri = UriTemplateUtils.expand(MANAGED_RESOURCE_URL, "resourceIdentifier:" + resourceIdentifier);

        if (createdResource) {
            return created(resourceUri.getPath(), false);
        }

        // CHECK if path returns the right info
        return created(resourceUri.getPath(), true);
    } catch (Exception e) {
        throw new RestApiException(HttpStatus.UNPROCESSABLE_ENTITY, e);
    }
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * Gets all individual to do lists for a user
 * @param userId the uesr id to find by
 * @return the response entity with the to do lists
 */
@RequestMapping(method = RequestMethod.GET, value = "/individual/users/{userId}", produces = "application/json")
public ResponseEntity getAllIndividualTodoListsForUser(@PathVariable("userId") Long userId) {

    // check if the user for the to do list exists
    UserServiceCommunication userServiceCommunication = new UserServiceCommunication();
    UserPOJO userPOJO = userServiceCommunication.getUser(userId);
    if(userPOJO == null) {
        String message = "Could not find user with id " + userId;
        String url = "todolist/individual";

        throw new UserNotFoundException(message, url);
    }


    List<TodoList> todoLists = this.todoListService.getIndividualTodoListsForUser(userId);
    return ResponseEntity.ok(todoLists);
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
private void add(BuildInfo buildInfo) {
	URI uri = UriComponentsBuilder.fromUriString(this.uri).path("api/build")
			.buildAndExpand(NO_VARIABLES).encode().toUri();
	RequestEntity<BuildInfo> request = RequestEntity.put(uri)
			.contentType(MediaType.APPLICATION_JSON).body(buildInfo);
	ResponseEntity<Void> exchange = this.restTemplate.exchange(request, Void.class);
	exchange.getBody();
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * PUT  /users : Updates an existing User.
 *
 * @param managedUserVM the user to update
 * @return the ResponseEntity with status 200 (OK) and with body the updated user,
 * or with status 400 (Bad Request) if the login or email is already in use,
 * or with status 500 (Internal Server Error) if the user couldn't be updated
 */
@PutMapping("/users")
@Timed
@Secured(AuthoritiesConstants.ADMIN)
public ResponseEntity<ManagedUserVM> updateUser(@RequestBody ManagedUserVM managedUserVM) {
    log.debug("REST request to update User : {}", managedUserVM);
    Optional<User> existingUser = userRepository.findOneByEmail(managedUserVM.getEmail());
    if (existingUser.isPresent() && (!existingUser.get().getId().equals(managedUserVM.getId()))) {
        return ResponseEntity.badRequest().headers(HeaderUtil.createFailureAlert("userManagement", "emailexists", "E-mail already in use")).body(null);
    }
    existingUser = userRepository.findOneByLogin(managedUserVM.getLogin().toLowerCase());
    if (existingUser.isPresent() && (!existingUser.get().getId().equals(managedUserVM.getId()))) {
        return ResponseEntity.badRequest().headers(HeaderUtil.createFailureAlert("userManagement", "userexists", "Login already in use")).body(null);
    }
    userService.updateUser(managedUserVM.getId(), managedUserVM.getLogin(), managedUserVM.getFirstName(),
        managedUserVM.getLastName(), managedUserVM.getEmail(), managedUserVM.isActivated(),
        managedUserVM.getLangKey(), managedUserVM.getAuthorities());

    return ResponseEntity.ok()
        .headers(HeaderUtil.createAlert("A user is updated with identifier " + managedUserVM.getLogin(), managedUserVM.getLogin()))
        .body(new ManagedUserVM(userService.getUserWithAuthorities(managedUserVM.getId())));
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * Add booking with the specified information.
 *
 * @param bookingVO
 * @return A non-null booking.
 */
@RequestMapping(method = RequestMethod.POST)
public ResponseEntity<Booking> add(@RequestBody BookingVO bookingVO) {
    logger.info(String.format("booking-service add() invoked: %s for %s", bookingService.getClass().getName(), bookingVO.getName()));
    System.out.println(bookingVO);
    Booking booking = new Booking(null, null, null, null, null, null, null);
    BeanUtils.copyProperties(bookingVO, booking);
    try {
        bookingService.add(booking);
    } catch (Exception ex) {
        logger.log(Level.WARNING, "Exception raised add Booking REST Call {0}", ex);
        return new ResponseEntity<>(HttpStatus.UNPROCESSABLE_ENTITY);
    }
    return new ResponseEntity<>(HttpStatus.CREATED);
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * Adds a new service type to the database
 *
 * @param serviceTypeDTO the user dto to add
 * @param errors the errors list
 *
 * @return the service that was added
 */
@RequestMapping(method = RequestMethod.POST, value = "/types", produces = "application/json")
public ResponseEntity addServiceType(@RequestBody ServiceTypeDTO serviceTypeDTO, Errors errors) {
    logger.info("Adding new service type: " + serviceTypeDTO);

    ServiceTypeValidator serviceTypeValidator = new ServiceTypeValidator();
    serviceTypeValidator.validate(serviceTypeDTO, errors);

    ValidationError validationError = ValidationErrorBuilder.fromBindErrors(errors);


    if(errors.hasErrors()) {

        logger.error("Service type could not be created: " + validationError.getErrors());
        throw new IllegalRequestFormatException("Could not add service type.", "/service/type/", validationError);
    }

    ServiceType serviceType = new ServiceType(serviceTypeDTO);
    ServiceType savedServiceType = this.serviceTypeService.addServiceType(serviceType);
    logger.info("Successfully created new service type: " + savedServiceType);

    return ResponseEntity.ok(savedServiceType);
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
@Test
public void testModifySkillsSkillUnknown() {
  ResponseEntity<String> res = userController.updateSkills("aaaaaa", "UnknownSkill", "0", "0", false, "YWFhLmFhYUBleGFtcGxlLmNvbQ==|foo|bar");
  assertEquals(HttpStatus.BAD_REQUEST, res.getStatusCode());
  assertEquals(2, personRepo.findByIdIgnoreCase("aaaaaa").getSkillsExcludeHidden().get(0).getSkillLevel());
  assertEquals(3, personRepo.findByIdIgnoreCase("aaaaaa").getSkillsExcludeHidden().get(0).getWillLevel());
}
 

import org.springframework.http.ResponseEntity; //导入依赖的package包/类
/**
 * DELETE  /tasks/:id : delete the "id" task.
 *
 * @param id the id of the task to delete
 * @return the ResponseEntity with status 200 (OK)
 */
@DeleteMapping("/tasks/{id}")
@Timed
public ResponseEntity<Void> deleteTask(@PathVariable Long id) {
    log.debug("REST request to delete Task : {}", id);
    Task taskSaved = taskRepository.findOne(id);
    if (taskSaved != null && !SecurityUtils.isCurrentUserInRole(AuthoritiesConstants.ADMIN)
     && !SecurityUtils.getCurrentUserLogin().equals(taskSaved.getUser())) {
     return new ResponseEntity<>(HttpStatus.FORBIDDEN);
    }
    taskRepository.delete(id);
    return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(ENTITY_NAME, id.toString())).build();
}