Java Examples for org.springframework.http.ResponseEntity

public ResponseEntity<?> query(String defaultGraphUri, String sparqlQuery, Integer outputFormat) throws Exception {
    EndPointManagerInterface endPointManager = endPointManagerProvider.getEndPointManager();
    try {
        return endPointManager.query(defaultGraphUri, sparqlQuery, outputFormat.intValue());
    } catch (Exception e) {
        return new ResponseEntity<String>(e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

public static ResponseEntity<byte[]> jcresponseFile(String fileExtension, String fileName, byte[] fileAsBytes) throws IllegalArgumentException {
    HttpHeaders headers = new HttpHeaders();
    headers.set("Content-Type", HeaderContentType.findByName(fileExtension).getContentType());
    headers.set("Content-disposition", "attachment;charset=utf-8; filename=" + fileName);
    headers.setContentLength(fileAsBytes.length);
    return new ResponseEntity<>(fileAsBytes, headers, HttpStatus.OK);
}

public Observable<ResponseEntity<EchoTransferObject>> callWith(Delay delay, Message message) {
    AsyncRestTemplate rest = new AsyncRestTemplate();
    ListenableFuture<ResponseEntity<EchoTransferObject>> first = rest.postForEntity("http://localhost:{port}/", echoTransferObject(delay, message), EchoTransferObject.class, EmbeddedServletContainer.PORT);
    return Observable.from(first);
}

@Test
public void contextLoaded() throws Throwable {
    RestTemplate restTemplate = this.restTemplateBuilder.basicAuthorization("pwebb", "boot").build();
    ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:" + this.port + "/hi", String.class);
    assertThat(response.getBody()).containsIgnoringCase("hello, pwebb");
    System.out.println("received: " + response.getBody());
}

@RequestMapping
public ResponseEntity<ApiError> handleErrorPage(@RequestParam("errorCode") final String errorCode, final WebRequest request) {
    final HttpStatus httpStatus = HttpStatus.valueOf((Integer) request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE, RequestAttributes.SCOPE_REQUEST));
    final ApiError apiError = apiErrorCreator.createApiError(request, errorCode, httpStatus.getReasonPhrase());
    return new ResponseEntity<>(apiError, httpStatus);
}

@Test
public void happyPathSuccess() throws Exception {
    // Curl the resource, which causes the external process to send a mail.
    ResponseEntity<Void> entity = new RestTemplate().getForEntity(RESOURCE_LOCATION, Void.class);
    assertThat(entity.getStatusCode(), equalTo(OK));
    assertTrue("Should have received a mail", greenMail.waitForIncomingEmail(200, 1));
    Message[] messages = greenMail.getReceivedMessages();
    assertThat(messages.length, equalTo(1));
    assertThat(messages[0].getFrom(), equalTo(new Address[] { MY_MAIL }));
}

/**
	 * Builds the ApiResponseObjectDoc from the method's return type and checks if the first type corresponds to a ResponseEntity class. In that case removes the "responseentity"
	 * string from the final list because it's not important to the documentation user.
	 * @param method
	 * @param apiResponseObjectDoc
	 * @return
	 */
public static ApiResponseObjectDoc buildResponse(Method method) {
    ApiResponseObjectDoc apiResponseObjectDoc = new ApiResponseObjectDoc(JSONDocTypeBuilder.build(new JSONDocType(), method.getReturnType(), method.getGenericReturnType()));
    if (method.getReturnType().isAssignableFrom(ResponseEntity.class)) {
        apiResponseObjectDoc.getJsondocType().getType().remove(0);
    }
    return apiResponseObjectDoc;
}

@RequestMapping(value = "/events", method = RequestMethod.POST, consumes = "application/json")
public ResponseEntity<String> processEventRequest(HttpServletRequest httpRequest) {
    EventService eventService = new EventService();
    EventHandlerStatus handlerStatus = eventService.dispatchEvent(httpRequest);
    if (handlerStatus.getMessage() == null) {
        return new ResponseEntity<String>(HttpStatus.valueOf(handlerStatus.getStatus()));
    } else {
        return new ResponseEntity<String>(handlerStatus.getMessage(), HttpStatus.valueOf(handlerStatus.getStatus()));
    }
}

// ...
@RequestMapping
public ResponseEntity<String> invalidRequestUriHandler(HttpServletRequest request) {
    IllegalArgumentException ex = new IllegalArgumentException(request.getRequestURI());
    logger.info("", ex);
    HttpHeaders httpHeaders = new HttpHeaders();
    httpHeaders.set(X_HTTP_STATUS_OVERRIDE, "230");
    return new ResponseEntity<>("", httpHeaders, HttpStatus.INTERNAL_SERVER_ERROR);
}

@Test
public void customGrant() throws Exception {
    LinkedMultiValueMap<String, String> form = new LinkedMultiValueMap<String, String>();
    form.set("grant_type", "custom");
    HttpHeaders headers = new HttpHeaders();
    headers.set("Authorization", "Basic " + new String(Base64.encode(("my-trusted-client:").getBytes())));
    @SuppressWarnings("rawtypes") ResponseEntity<Map> response = http.postForMap("/oauth/token", headers, form);
    assertEquals(HttpStatus.OK, response.getStatusCode());
}

@RequestMapping(method = RequestMethod.GET)
public ResponseEntity<UserAgentResource> userAgent(UserAgent userAgent) {
    Browser browser = userAgent.getBrowser();
    OperatingSystem operatingSystem = userAgent.getOperatingSystem();
    UserAgentResource resource = UserAgentResource.builder().browser(browser).browserGroup(browser.getGroup()).browserType(browser.getBrowserType()).operatingSystem(operatingSystem).operatingSystemGroup(operatingSystem.getGroup()).deviceType(operatingSystem.getDeviceType()).build();
    return ResponseEntity.ok(resource);
}

@GetMapping("/triggers/contests/autoPromotion")
public ResponseEntity<String> autoPromote(HttpServletResponse response) {
    int promotedProposals = ContestClientUtil.autoPromoteProposals();
    if (promotedProposals > 0) {
        log.info("Promoted {} proposals.", promotedProposals);
        ServiceRequestUtils.clearCache(CacheName.PROPOSAL_LIST);
        ServiceRequestUtils.clearCache(CacheName.PROPOSAL_LIST_CLOSED);
    }
    return ResponseEntity.ok("Promoted " + promotedProposals + " proposals.");
}

@Bean
public Docket createRestApi() {
    return new Docket(DocumentationType.SWAGGER_2).select().apis(RequestHandlerSelectors.any()).paths(PathSelectors.any()).build().host("www.tc.com").pathMapping("/").genericModelSubstitutes(ResponseEntity.class).useDefaultResponseMessages(false).globalResponseMessage(RequestMethod.GET, Lists.newArrayList(new ResponseMessageBuilder().code(HttpStatus.OK.value()).message("请求�功").responseModel(new ModelRef("TcR")).build())).globalResponseMessage(RequestMethod.POST, Lists.newArrayList(new ResponseMessageBuilder().code(HttpStatus.OK.value()).message("请求�功").responseModel(new ModelRef("TcR")).build())).protocols(Sets.newHashSet("http", "https"));
}

@GetMapping(value = "/dbs/{dbId}")
public WebAsyncTask<ResponseEntity<Resource>> getReport(@PathVariable Long dbId, @RequestParam(name = "sessionId", required = true) String sessionId, @RequestParam(name = "baseLineSessionId", required = false) String baseLineSessionId) throws IOException {
    // Given up to 10 minutes to generate a report before timeout failure.
    return new WebAsyncTask<>(1000 * 60 * 10, () -> {
        Resource reportResource = dynamicReportingService.generateReportFor(dbId, sessionId, baseLineSessionId);
        return ResponseEntity.ok().header(HttpHeaders.CONTENT_DISPOSITION, "inline; filename=\"" + reportResource.getFilename() + "\"").header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_PDF_VALUE).body(reportResource);
    });
}

@Test
public void test() {
    GlobalExceptionController controller = new GlobalExceptionController();
    ResponseEntity<?> response = controller.handleAllExceptions(new UnSupportedMethodException());
    assertEquals(HttpStatus.METHOD_NOT_ALLOWED, response.getStatusCode());
    assertEquals("This HTTP method is currently not supported.", response.getBody());
    response = controller.handleAllExceptions(new NoSuchTextConstantException("test.key", Language.GERMAN));
    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
    assertEquals("The requested language is not or at least not fully supported.", response.getBody());
    response = controller.handleAllExceptions(new BadRequestException("testMessage"));
    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
    assertEquals("The request is in a illegal state: testMessage", response.getBody());
    response = controller.handleAllExceptions(new WebLayerException("testMessage", HttpStatus.BAD_REQUEST));
    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
    assertEquals("testMessage", response.getBody());
    response = controller.handleAllExceptions(new NoSuchResourceException("testMessage"));
    assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
    assertEquals("There's no resource assigned to 'testMessage'", response.getBody());
    response = controller.handleAllExceptions(null);
    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
    assertTrue(((String) response.getBody()).startsWith("An internal server"));
}

@Test
public void processDefinitionTest() {
    // start process
    testRestTemplate.postForEntity("/rest/start/process", HttpEntity.EMPTY, String.class);
    ResponseEntity<ProcessDefinitionDto> entity = testRestTemplate.getForEntity("/rest/engine/{engineName}/process-definition/key/TestProcess/", ProcessDefinitionDto.class, camundaBpmProperties.getProcessEngineName());
    assertEquals(HttpStatus.OK, entity.getStatusCode());
    assertEquals("TestProcess", entity.getBody().getKey());
}

@Test
public void processDefinitionTest() {
    // start process
    testRestTemplate.postForEntity("/rest/start/process", HttpEntity.EMPTY, String.class);
    ResponseEntity<ProcessDefinitionDto> entity = testRestTemplate.getForEntity("/rest/engine/{engineName}/process-definition/key/TestProcess/", ProcessDefinitionDto.class, camundaBpmProperties.getProcessEngineName());
    assertEquals(HttpStatus.OK, entity.getStatusCode());
    assertEquals("TestProcess", entity.getBody().getKey());
}

@RequestMapping(value = "config.js", method = RequestMethod.GET)
public ResponseEntity<String> getConfigJs() throws JsonProcessingException {
    Map<String, String> config = configService.findAll().stream().collect(Collectors.toMap(Config::getConfigName, Config::getConfigValue));
    return ResponseEntity.ok().contentType(MediaType.parseMediaType("application/javascript")).body("window.Config = " + objectMapper.writeValueAsString(config) + ";");
}

@Test
public void testCorsHeadersInResponse_forRootPage() throws Exception {
    ResponseEntity<String> response = template.getForEntity(base.toString(), String.class);
    HttpHeaders headers = response.getHeaders();
    assertThat(headers.get("Access-Control-Allow-Origin"), equalTo(asList("*")));
    assertThat(headers.get("Access-Control-Allow-Methods"), equalTo(asList("POST, GET, OPTIONS, DELETE")));
    assertThat(headers.get("Access-Control-Max-Age"), equalTo(asList("3600")));
    assertThat(headers.get("Access-Control-Allow-Headers"), equalTo(asList("x-requested-with")));
}

@RequestMapping(value = "/checkUsername", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public ResponseEntity<CheckUsernameResponse> checkUsername(@RequestBody CheckUsernameRequest request) {
    log.debug("Request:{}", request);
    long count = userAccountService.countByUsername(request.getLoginName());
    CheckUsernameResponse response = new CheckUsernameResponse();
    Result result = getResult(count);
    response.setResult(result);
    log.debug("response:{}", response);
    return new ResponseEntity<CheckUsernameResponse>(response, HttpStatus.OK);
}

@RequestMapping(value = "/account", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<UserDetails> getAccount() {
    SecurityContext securityContext = SecurityContextHolder.getContext();
    Authentication authentication = securityContext.getAuthentication();
    UserDetails springSecurityUser = null;
    if (authentication != null) {
        if (authentication.getPrincipal() instanceof UserDetails) {
            springSecurityUser = (UserDetails) authentication.getPrincipal();
        }
    }
    if (springSecurityUser == null) {
        return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
    }
    log.debug("UserDetails {}", springSecurityUser);
    // log.debug("REST request to get UserDetail account {}", springSecurityUser);
    return new ResponseEntity<>(springSecurityUser, HttpStatus.OK);
}

@RequestMapping(method = RequestMethod.GET, value = "/{id}")
public ResponseEntity<Order> viewOrder(@PathVariable String id) {
    OrderDetailsEvent details = orderService.requestOrderDetails(new RequestOrderDetailsEvent(UUID.fromString(id)));
    if (!details.isEntityFound()) {
        return new ResponseEntity<Order>(HttpStatus.NOT_FOUND);
    }
    Order order = Order.fromOrderDetails(details.getOrderDetails());
    return new ResponseEntity<Order>(order, HttpStatus.OK);
}

@ExceptionHandler(value = InternalErrorException.class)
public ResponseEntity<String> defaultErrorHandler(HttpServletRequest req, InternalErrorException e) throws Exception {
    log.error("received error ({}) with message: {}", e.getFailureStatus(), e.getMessage());
    String responseBody = objectMapper.writer().writeValueAsString(e.getErrorMessageDto());
    MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
    headers.put("Content-Type", Arrays.asList(MediaType.APPLICATION_JSON_VALUE));
    ResponseEntity<String> response = new ResponseEntity<String>(responseBody, headers, e.getFailureStatus());
    return response;
}

@Test
public void shouldGetANCDetailsForAllANMs() throws Exception {
    when(httpAgent.get("http://dristhi_reporting_url/villages?anm-id=demo1")).thenReturn(new HttpResponse(true, new Gson().toJson(new VillagesDTO("district", "PHC X", "phc1", "Sub Center 1", asList("village1", "village2", "village3")))));
    when(userController.currentUser()).thenReturn(user);
    when(user.getUsername()).thenReturn("demo1");
    when(user.getRoles()).thenReturn(asList("User"));
    ResponseEntity<VillagesDTO> response = controller.villagesForANM();
    assertEquals(new VillagesDTO("district", "PHC X", "phc1", "Sub Center 1", asList("village1", "village2", "village3")), response.getBody());
    assertEquals(HttpStatus.OK, response.getStatusCode());
}

@RequestMapping(value = "/rest-api/orders/{orderNumber}/pod", method = POST, headers = ACCEPT_JSON)
public ResponseEntity<RestResponse> savePOD(@RequestBody OrderPOD orderPod, @PathVariable String orderNumber, Principal principal) {
    try {
        orderPod.setOrderNumber(orderNumber);
        restPODService.updatePOD(orderPod, loggedInUserId(principal));
        return RestResponse.success("message.success.pod.updated");
    } catch (DataException e) {
        return RestResponse.error(e.getOpenLmisMessage(), BAD_REQUEST);
    }
}

@Test
public void shouldCreateAndUpdateRestaurant() {
    RestaurantInfo restaurantInfo = RestaurantMother.makeRestaurant();
    ResponseEntity<CreateRestaurantResponse> createRestaurantResponse = restTemplate.postForEntity(baseUrl("/restaurants"), restaurantInfo, CreateRestaurantResponse.class);
    Assert.assertEquals(createRestaurantResponse.getStatusCode(), HttpStatus.OK);
    final String restaurantId = createRestaurantResponse.getBody().getRestaurantId();
    ResponseEntity<UpdateRestaurantResponse> updateRestaurantResponse = restTemplate.exchange(baseUrl("/restaurants/" + restaurantId), HttpMethod.PUT, new HttpEntity(restaurantInfo), UpdateRestaurantResponse.class);
    Assert.assertEquals(updateRestaurantResponse.getStatusCode(), HttpStatus.OK);
}

@Test
public void testMetricsExportedThroughPrometheusEndpoint() {
    // given:
    final Counter promCounter = Counter.build().name("foo_bar").help("a simple prometheus counter").labelNames("label1", "label2").register();
    // when:
    promCounter.labels("val1", "val2").inc(3);
    ResponseEntity<String> metricsResponse = template.getForEntity(getBaseUrl() + "/prometheus", String.class);
    // then:
    assertEquals(HttpStatus.OK, metricsResponse.getStatusCode());
    assertTrue(StringUtils.deleteWhitespace(TextFormat.CONTENT_TYPE_004).equals(metricsResponse.getHeaders().getContentType().toString()));
    List<String> responseLines = Arrays.asList(metricsResponse.getBody().split("\n"));
    assertThat(responseLines, CustomMatchers.<String>exactlyNItems(1, matchesPattern("foo_bar\\{label1=\"val1\",label2=\"val2\",?\\} 3.0")));
}

@RequestMapping(path = "/predict", method = RequestMethod.POST, consumes = { MediaType.APPLICATION_JSON_VALUE }, produces = { MediaType.APPLICATION_JSON_VALUE })
public ResponseEntity<CompanyPrediction> createUser(@RequestBody CompanyInfo companyInfo) {
    try {
        final CompanyPrediction prediction = qualitativeBankruptcyService.predict(companyInfo);
        return new ResponseEntity<>(prediction, HttpStatus.CREATED);
    } catch (Exception e) {
        logger.error("Cannot predict result for {}", companyInfo, e);
        return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
    }
}

@RequestMapping(value = "/info", method = RequestMethod.GET)
public ResponseEntity configView() {
    final SystemInfoService bbInfo = SystemInfoServiceFactory.getInstance();
    return new ResponseEntity(new Object() {

        public JvmInfo jvmInfo = bbInfo.getJvmInfo();

        public OsInfo osInfo = bbInfo.getOsInfo();

        public String app = "BbRest";

        public String version = "1.0.0-SNAPSHOT";

        public Date time = new Date();
    }, HttpStatus.OK);
}

@RequestMapping
public ResponseEntity<Map<String, Object>> error(HttpServletRequest aRequest) {
    RequestAttributes requestAttributes = new ServletRequestAttributes(aRequest);
    Map<String, Object> result = this.errorAttributes.getErrorAttributes(requestAttributes, false);
    HttpStatus statusCode = INTERNAL_SERVER_ERROR;
    Object status = result.get("status");
    if (status != null && status instanceof Integer) {
        statusCode = HttpStatus.valueOf(((Integer) status).intValue());
    }
    return new ResponseEntity<>(result, statusCode);
}

@Override
public MessageAcknowledgement sendMessage(Message message) {
    String pongServiceUrl = "http://samplepongdirect/message";
    HttpEntity<Message> requestEntity = new HttpEntity<>(message);
    ResponseEntity<MessageAcknowledgement> response = this.restTemplate.exchange(pongServiceUrl, HttpMethod.POST, requestEntity, MessageAcknowledgement.class, Maps.newHashMap());
    return response.getBody();
}

@Test
public void retornaUnidadeDoOrgao() throws Exception {
    String urlOrgao = "http://estruturaorganizacional.dados.gov.br/id/unidade-organizacional/1934";
    given(restTemplate.getForEntity(urlOrgao, Siorg.Orgao.class)).willReturn(new ResponseEntity<>(new Siorg.Orgao().withServico(new Siorg.Servico().withCodigoErro(0)).withUnidade(new Siorg.Unidade().withNome("Secretaria do Secretariado Secretarial").withSigla("SSS")), HttpStatus.OK));
    assertThat(siorg.findUnidade(urlOrgao).getNome(), is("Secretaria do Secretariado Secretarial"));
    assertThat(siorg.findUnidade(urlOrgao).getSigla(), is("SSS"));
}

@ExceptionHandler
default ResponseEntity<Problem> handleRequestMethodNotSupportedException(final HttpRequestMethodNotSupportedException exception, final NativeWebRequest request) {
    @WTF @Facepalm("Nullable arrays... great work from Spring :/") @Nullable final String[] methods = exception.getSupportedMethods();
    if (methods == null || methods.length == 0) {
        return create(Status.METHOD_NOT_ALLOWED, exception, request);
    }
    final HttpHeaders headers = new HttpHeaders();
    headers.setAllow(exception.getSupportedHttpMethods());
    return create(Status.METHOD_NOT_ALLOWED, exception, request, headers);
}

// util
private final ResponseEntity<Void> singularToPlural(final HttpServletRequest request) {
    final String correctUri = request.getRequestURL().toString() + "s";
    final HttpHeaders responseHeaders = new org.springframework.http.HttpHeaders();
    responseHeaders.add(org.apache.http.HttpHeaders.LOCATION, correctUri);
    final ResponseEntity<Void> redirectResponse = new ResponseEntity<Void>(responseHeaders, HttpStatus.MOVED_PERMANENTLY);
    return redirectResponse;
}

@Test
public void loadImage() {
    byte[] image = "animage".getBytes();
    given(guides.findMetadata(anyString())).willReturn(guide);
    given(guides.loadImage(guide, "welcome.png")).willReturn(image);
    ResponseEntity<byte[]> responseEntity = controller.loadImage("rest", "welcome.png");
    assertThat(responseEntity.getBody(), is(image));
}

// org.webjars.AssetLocator.getWebJarPath()
@ResponseBody
@RequestMapping("/webjarslocator/{webjar}/**")
public ResponseEntity<Object> locateWebjarAsset(@PathVariable String webjar, HttpServletRequest request) {
    try {
        // This prefix must match the mapping path!
        String mvcPrefix = "/webjarslocator/" + webjar + "/";
        String mvcPath = (String) request.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);
        String fullPath = assetLocator.getFullPath(webjar, mvcPath.substring(mvcPrefix.length()));
        return new ResponseEntity<>(new ClassPathResource(fullPath), HttpStatus.OK);
    } catch (Exception e) {
        return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }
}

@Override
public boolean matches(Object item) {
    if (!(item instanceof HttpEntity)) {
        return false;
    }
    if (item instanceof ResponseEntity && expected instanceof ResponseEntity) {
        ResponseEntity<?> left = (ResponseEntity<?>) expected;
        ResponseEntity<?> right = (ResponseEntity<?>) item;
        if (!left.getStatusCode().equals(right.getStatusCode())) {
            return false;
        }
    }
    HttpEntity<?> left = expected;
    HttpEntity<?> right = (HttpEntity<?>) item;
    return left.getBody().equals(right.getBody()) && left.getHeaders().equals(right.getHeaders());
}

@RequestMapping(method = RequestMethod.POST, headers = "Accept=application/json")
public ResponseEntity<String> createFromJson(@RequestBody String json) {
    Feedback feedback = Feedback.fromJsonToFeedback(json);
    Message message = new Message();
    message.setBody(feedback.getBody());
    message.setReceiverEmail("kiranreddy2004@gmail.com");
    message.setReceiverName("kiran");
    message.setSenderEmail(feedback.getEmail());
    message.setSubject("Todo : feedback");
    emailService.send(message);
    HttpHeaders headers = new HttpHeaders();
    headers.add("Content-Type", "application/json");
    return new ResponseEntity<String>(headers, HttpStatus.CREATED);
}

@Test
public void clientConnects() {
    ResponseEntity<String> response = new TestRestTemplate().getForEntity("http://localhost:" + port, String.class);
    assertNotNull("response was null", response);
    assertEquals("Wrong status code", HttpStatus.OK, response.getStatusCode());
    assertTrue(response.getBody().contains("<html"));
}

@Test
public void resourceLoads() {
    ResponseEntity<String> response = template.getForEntity("http://localhost:{port}/", String.class, port);
    assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
    String auth = response.getHeaders().getFirst("WWW-Authenticate");
    assertTrue("Wrong header: " + auth, auth.startsWith("Bearer"));
}

private ResponseEntity<OAuth2Exception> handleOAuth2Exception(OAuth2Exception e) throws IOException {
    int status = e.getHttpErrorCode();
    HttpHeaders headers = new HttpHeaders();
    headers.set("Cache-Control", "no-store");
    headers.set("Pragma", "no-cache");
    ResponseEntity<OAuth2Exception> response = new ResponseEntity<OAuth2Exception>(e, headers, HttpStatus.valueOf(status));
    return response;
}

@Test
public void vocabularies() {
    log.info("Testing vocabulary endpoint");
    final ResponseEntity<String> entity = getRestTemplate().getForEntity(this.endpointVocabularies, String.class);
    assertOK(entity);
    //or
    Vocabulary[] vocabularies = getRestTemplate().getForObject(this.endpointVocabularies, Vocabulary[].class);
    for (Vocabulary v : vocabularies) {
        log.debug("Vocab: " + v.vocabularyName);
    }
}

@PostMapping(value = REQUEST_URL + "/redeem")
public ResponseEntity<?> redeemCode(@RequestHeader(value = "X-AUTH-TOKEN") String userToken, @RequestParam String codeString) throws IpatException {
    User recipient = _tokenAuthenticationService.getUserFromToken(userToken);
    if (recipient != null) {
        _codeService.redeemCode(recipient, codeString);
        return new ResponseEntity<>(HttpStatus.OK);
    } else {
        return new ResponseEntity<>(HttpStatus.FORBIDDEN);
    }
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorVM> processException(Exception ex) {
    log.error(ex.getMessage(), ex);
    BodyBuilder builder;
    ErrorVM errorVM;
    ResponseStatus responseStatus = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);
    if (responseStatus != null) {
        builder = ResponseEntity.status(responseStatus.value());
        errorVM = new ErrorVM("error." + responseStatus.value().value(), responseStatus.reason());
    } else {
        builder = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR);
        errorVM = new ErrorVM(ErrorConstants.ERR_INTERNAL_SERVER_ERROR, "Internal server error");
    }
    return builder.body(errorVM);
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorVM> processException(Exception ex) {
    log.error(ex.getMessage(), ex);
    BodyBuilder builder;
    ErrorVM errorVM;
    ResponseStatus responseStatus = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);
    if (responseStatus != null) {
        builder = ResponseEntity.status(responseStatus.value());
        errorVM = new ErrorVM("error." + responseStatus.value().value(), responseStatus.reason());
    } else {
        builder = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR);
        errorVM = new ErrorVM(ErrorConstants.ERR_INTERNAL_SERVER_ERROR, "Internal server error");
    }
    return builder.body(errorVM);
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorVM> processException(Exception ex) {
    log.error(ex.getMessage(), ex);
    BodyBuilder builder;
    ErrorVM errorVM;
    ResponseStatus responseStatus = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);
    if (responseStatus != null) {
        builder = ResponseEntity.status(responseStatus.value());
        errorVM = new ErrorVM("error." + responseStatus.value().value(), responseStatus.reason());
    } else {
        builder = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR);
        errorVM = new ErrorVM(ErrorConstants.ERR_INTERNAL_SERVER_ERROR, "Internal server error");
    }
    return builder.body(errorVM);
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorVM> processException(Exception ex) {
    log.error(ex.getMessage(), ex);
    BodyBuilder builder;
    ErrorVM errorVM;
    ResponseStatus responseStatus = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);
    if (responseStatus != null) {
        builder = ResponseEntity.status(responseStatus.value());
        errorVM = new ErrorVM("error." + responseStatus.value().value(), responseStatus.reason());
    } else {
        builder = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR);
        errorVM = new ErrorVM(ErrorConstants.ERR_INTERNAL_SERVER_ERROR, "Internal server error");
    }
    return builder.body(errorVM);
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorVM> processException(Exception ex) {
    log.error(ex.getMessage(), ex);
    BodyBuilder builder;
    ErrorVM errorVM;
    ResponseStatus responseStatus = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);
    if (responseStatus != null) {
        builder = ResponseEntity.status(responseStatus.value());
        errorVM = new ErrorVM("error." + responseStatus.value().value(), responseStatus.reason());
    } else {
        builder = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR);
        errorVM = new ErrorVM(ErrorConstants.ERR_INTERNAL_SERVER_ERROR, "Internal server error");
    }
    return builder.body(errorVM);
}

@PostMapping("/authenticate")
@Timed
public ResponseEntity authorize(@Valid @RequestBody LoginVM loginVM, HttpServletResponse response) {
    UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginVM.getUsername(), loginVM.getPassword());
    try {
        Authentication authentication = this.authenticationManager.authenticate(authenticationToken);
        SecurityContextHolder.getContext().setAuthentication(authentication);
        boolean rememberMe = (loginVM.isRememberMe() == null) ? false : loginVM.isRememberMe();
        String jwt = tokenProvider.createToken(authentication, rememberMe);
        response.addHeader(JWTConfigurer.AUTHORIZATION_HEADER, "Bearer " + jwt);
        return ResponseEntity.ok(new JWTToken(jwt));
    } catch (AuthenticationException ae) {
        log.trace("Authentication exception trace: {}", ae);
        return new ResponseEntity<>(Collections.singletonMap("AuthenticationException", ae.getLocalizedMessage()), HttpStatus.UNAUTHORIZED);
    }
}

@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorVM> processRuntimeException(Exception ex) throws Exception {
    BodyBuilder builder;
    ErrorVM errorVM;
    ResponseStatus responseStatus = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);
    if (responseStatus != null) {
        builder = ResponseEntity.status(responseStatus.value());
        errorVM = new ErrorVM("error." + responseStatus.value().value(), responseStatus.reason());
    } else {
        builder = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR);
        errorVM = new ErrorVM(ErrorConstants.ERR_INTERNAL_SERVER_ERROR, "Internal server error");
    }
    return builder.body(errorVM);
}

public void testCase3() throws Exception {
    String data = "public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.BasicErrorController.error(javax.servlet.http.HttpServletRequest)";
    assertEquals("org.springframework.boot.autoconfigure.web.BasicErrorController", getFQClassName(data));
    assertEquals("error", getMethodName(data));
}

@ExceptionHandler(Exception.class)
public ResponseEntity<Error> processRuntimeException(Exception ex) throws Exception {
    BodyBuilder builder;
    Error error;
    ResponseStatus responseStatus = AnnotationUtils.findAnnotation(ex.getClass(), ResponseStatus.class);
    if (responseStatus != null) {
        builder = ResponseEntity.status(responseStatus.value());
        error = new Error("error." + responseStatus.value().value(), responseStatus.reason());
    } else {
        builder = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR);
        error = new Error(ErrorConstants.ERR_INTERNAL_SERVER_ERROR, "Internal server error");
    }
    return builder.body(error);
}

@RequestMapping(value = "/repository/process-definitions/{processDefinitionId}/image", method = RequestMethod.GET)
public ResponseEntity<byte[]> getModelResource(@PathVariable String processDefinitionId) {
    ProcessDefinition processDefinition = getProcessDefinitionFromRequest(processDefinitionId);
    InputStream imageStream = repositoryService.getProcessDiagram(processDefinition.getId());
    if (imageStream != null) {
        HttpHeaders responseHeaders = new HttpHeaders();
        responseHeaders.set("Content-Type", "image/png");
        try {
            return new ResponseEntity<byte[]>(IOUtils.toByteArray(imageStream), responseHeaders, HttpStatus.OK);
        } catch (Exception e) {
            throw new ActivitiException("Error reading image stream", e);
        }
    } else {
        throw new ActivitiIllegalArgumentException("Process definition with id '" + processDefinition.getId() + "' has no image.");
    }
}

private void undeploy(final Deployment deployment) {
    log.info("Un-deploying deployment [{}] on cloud [{}]", deployment.getId(), deployment.getOrchestratorId());
    IOrchestratorPlugin orchestratorPlugin = orchestratorPluginService.getOrFail(deployment.getOrchestratorId());
    DeploymentTopology deployedTopology = deploymentRuntimeStateService.getRuntimeTopology(deployment.getId());
    PaaSDeploymentContext deploymentContext = new PaaSDeploymentContext(deployment, deployedTopology);
    orchestratorPlugin.undeploy(deploymentContext, new IPaaSCallback<ResponseEntity>() {

        @Override
        public void onSuccess(ResponseEntity data) {
            deploymentService.markUndeployed(deployment);
            log.info("Un-deployed deployment [{}] on cloud [{}]", deployment.getId(), deployment.getOrchestratorId());
        }

        @Override
        public void onFailure(Throwable throwable) {
            log.warn("Fail while Undeploying deployment [{}] on cloud [{}]", deployment.getId(), deployment.getOrchestratorId());
        }
    });
}

@ExceptionHandler({ SourceStringsParserException.class, TranslatedStringsBuilderException.class })
protected ResponseEntity<Object> handleInvalidRequest(RuntimeException e, WebRequest request) {
    if (e instanceof SourceStringsParserException)
        return handleSourceStringsParserException((SourceStringsParserException) e, request);
    else if (e instanceof TranslatedStringsBuilderException)
        return handleTranslatedStringsBuilderException((TranslatedStringsBuilderException) e, request);
    return super.handleException(e, request);
}

/**
     * Swagger Springfox configuration.
     */
@Bean
@Profile("!" + Constants.SPRING_PROFILE_FAST)
public Docket swaggerSpringfoxDocket(JHipsterProperties jHipsterProperties) {
    log.debug("Starting Swagger");
    StopWatch watch = new StopWatch();
    watch.start();
    ApiInfo apiInfo = new ApiInfo(jHipsterProperties.getSwagger().getTitle(), jHipsterProperties.getSwagger().getDescription(), jHipsterProperties.getSwagger().getVersion(), jHipsterProperties.getSwagger().getTermsOfServiceUrl(), jHipsterProperties.getSwagger().getContact(), jHipsterProperties.getSwagger().getLicense(), jHipsterProperties.getSwagger().getLicenseUrl());
    Docket docket = new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo).genericModelSubstitutes(ResponseEntity.class).forCodeGeneration(true).genericModelSubstitutes(ResponseEntity.class).ignoredParameterTypes(Pageable.class).directModelSubstitute(java.time.LocalDate.class, String.class).directModelSubstitute(java.time.ZonedDateTime.class, Date.class).directModelSubstitute(java.time.LocalDateTime.class, Date.class).select().paths(regex(DEFAULT_INCLUDE_PATTERN)).build();
    watch.stop();
    log.debug("Started Swagger in {} ms", watch.getTotalTimeMillis());
    return docket;
}

@ExceptionHandler(PsException.class)
public ResponseEntity<PsExceptionMessage> processPsException(PsException e) {
    log.error("Exception happened", e);
    HttpStatus status;
    PsErrorCode errorCode = e.getErrorCode();
    switch(errorCode) {
        case NOT_REGISTERED:
            status = HttpStatus.NOT_ACCEPTABLE;
            break;
        case AUTH_ATTEMPTS_EXCEEDED:
            status = HttpStatus.FORBIDDEN;
            break;
        default:
            status = HttpStatus.INTERNAL_SERVER_ERROR;
    }
    PsExceptionMessage msg = new PsExceptionMessage(DateTime.now(), errorCode, e.getMessage());
    return new ResponseEntity<>(msg, status);
}

@Ignore
@Test
public void homePageProtected() {
    ResponseEntity<String> response = template.getForEntity("http://localhost:" + port + "/uaa/", String.class);
    assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
    String auth = response.getHeaders().getFirst("WWW-Authenticate");
    assertTrue("Wrong header: " + auth, auth.startsWith("Bearer realm=\""));
}

@Override
public void process(State state) {
    int sleeptimeMs = 100 * (state.getProcessingStepNo());
    String url = SP_NON_BLOCKING_URL + "?minMs=" + sleeptimeMs + "&maxMs=" + sleeptimeMs;
    LOG.debug("Launch synch call");
    ResponseEntity<String> result = restTemplate.getForEntity(SP_NON_BLOCKING_URL + "?minMs={minMs}&maxMs={maxMs}", String.class, sleeptimeMs, sleeptimeMs);
    // TODO: Handle status codes other than 200...
    HttpStatus status = result.getStatusCode();
    LOG.debug("Synch call complete, hand over to the state machine for the next action");
    state.appendResult(result.getBody() + '\n');
    stateMachine.executeNextStep(state);
}

@Test
public void fetchInfo() {
    RestTemplate rest = new RestTemplate();
    ResponseEntity<String> response = rest.getForEntity("http://localhost:" + port + "/info", String.class);
    Assertions.assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
    Assertions.assertThat(response.getBody()).contains("\"version\":\"0.9.0-SNAPSHOT\"");
}

@SuppressWarnings("unchecked")
public static void test() {
    String casUrlPrefix = "http://login-test.his.com/tcgroup-sso-web";
    String username = "15372712873";
    String password = "123456";
    // GET TGT
    RestTemplate rest = new RestTemplate();
    rest.setMessageConverters(Arrays.asList(new StringHttpMessageConverter(), new FormHttpMessageConverter()));
    MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
    params.set("username", username);
    params.set("password", password);
    URI tgtUrl = rest.postForLocation(casUrlPrefix + "/v1/tickets", params, Collections.emptyMap());
    System.out.println("[" + tgtUrl + "]");
    // GET ST
    String service = "http://login-test.his.com/tcgroup-his-web/client/nop.do";
    params.clear();
    params.set("service", service);
    ResponseEntity<String> st = rest.postForEntity(tgtUrl, params, String.class);
    System.out.println("[" + st.getBody() + "]");
    // Using ST get data from SSO app(tcgroup-his-web).
    Map<String, Object> urlParams = new HashMap<String, Object>();
    urlParams.put("ticket", st.getBody());
    ResponseEntity<String> html = rest.getForEntity(service + "?ticket=" + st.getBody(), String.class, urlParams);
    System.out.println("[" + html.getBody() + "]");
}

/**
     * 根�pk找问题
     *
     * @param questionId
     * @return
     */
@ResponseBody
@RequestMapping(value = { "/{questionId}" }, method = RequestMethod.GET)
public ResponseEntity<?> findById(@PathVariable("questionId") Integer questionId) {
    Question question = new Question();
    try {
        question = questionService.findById(questionId);
    } catch (Exception e) {
        LogConstants.SERVICE_LOGGER.error("查找失败", e);
    }
    BaseResult<Question> result = ResultUtil.buildSuccessResult(question);
    return new ResponseEntity<BaseResult<Question>>(result, HttpStatus.OK);
}

private static Set<MultifactorAuthenticationTrustRecord> getResults(final String url) {
    final RestTemplate restTemplate = new RestTemplate();
    final ResponseEntity<MultifactorAuthenticationTrustRecord[]> responseEntity = restTemplate.getForEntity(url, MultifactorAuthenticationTrustRecord[].class);
    if (responseEntity.getStatusCode() == HttpStatus.OK) {
        final MultifactorAuthenticationTrustRecord[] results = responseEntity.getBody();
        return Stream.of(results).collect(Collectors.toSet());
    }
    return Collections.emptySet();
}

@GetMapping("/v2/service_instances/{instanceId}/last_operation")
ResponseEntity<?> lastOperation(@PathVariable String instanceId) {
    OperationType operationType = this.operations.get(instanceId);
    if (OperationType.DEPROVISION == operationType) {
        return ResponseEntity.status(HttpStatus.GONE).body(LastOperationDeprovisionResponse.builder().build());
    }
    return ResponseEntity.ok().body(LastOperationProvisionUpdateResponse.builder().state(State.SUCCEEDED).build());
}

@RequestMapping(method = RequestMethod.POST, value = "/state", consumes = MediaType.APPLICATION_JSON_VALUE)
ResponseEntity<?> changeState(@RequestBody Map<String, String> payload) {
    String value = payload.get(STATUS_KEY);
    if (value == null) {
        return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
    }
    try {
        set(State.valueOf(value.toUpperCase()));
        return new ResponseEntity<>(HttpStatus.OK);
    } catch (IllegalArgumentException e) {
        return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
    }
}

@RequestMapping("/names")
@HystrixCommand(fallbackMethod = "getReservationNamesFallback")
public Collection<String> getReservationNames() {
    ParameterizedTypeReference<Resources<Reservation>> parameterizedTypeReference = new ParameterizedTypeReference<Resources<Reservation>>() {
    };
    ResponseEntity<Resources<Reservation>> exchange = rt.exchange("http://reservation-service/reservations", HttpMethod.GET, null, parameterizedTypeReference);
    return exchange.getBody().getContent().stream().map(Reservation::getReservationName).collect(Collectors.toList());
}

@ExceptionHandler(value = Exception.class)
@ResponseBody
public ResponseEntity<Object> defaultErrorHandler(HttpServletRequest req, Exception e) throws Exception {
    // AnnotationUtils is a Spring Framework utility class.
    if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
        throw e;
    }
    HttpHeaders headers = new HttpHeaders();
    ErrorResponseMessage res = new ErrorResponseMessage();
    res.setErrorMessage(e.toString());
    //split different error messages accordingly.
    return new ResponseEntity<Object>(res, headers, HttpStatus.INTERNAL_SERVER_ERROR);
}

@Test
public void testJspWithEl() throws Exception {
    System.out.println("Sleeping...");
    ResponseEntity<String> entity = new TestRestTemplate().getForEntity("http://localhost:" + this.port, String.class);
    assertEquals(HttpStatus.OK, entity.getStatusCode());
    assertTrue("Wrong body:\n" + entity.getBody(), entity.getBody().contains("/resources/text.txt"));
}

@RequestMapping(value = "/send", method = RequestMethod.POST)
@ResponseBody
public ResponseEntity<Map<String, Object>> sendCode(@Valid CodeSendRequest codeSendRequest, BindingResult validResult) throws CException {
    if (validResult.hasErrors()) {
        throw CExceptionFactory.getException(DataValidationException.class, ResponseCode.INVALID_PARAMETER);
    }
    verifyCodeService.sendVerifyCode(codeSendRequest.getMobile(), codeSendRequest.getType());
    return ResponseUtil.jsonSucceed(null, HttpStatus.OK);
}

protected <R> ResponseEntity<Void> createResponseEntity(R returnedResource, String changeSetUri, String urlTemplate, UrlTemplateBinder<R> template) {
    String location = this.urlTemplateBindingCreator.bindResourceToUrlTemplate(template, returnedResource, urlTemplate);
    if (StringUtils.isNotBlank(changeSetUri)) {
        location = location + ("?" + URIHelperInterface.PARAM_CHANGESETCONTEXT + "=" + changeSetUri);
    }
    return this.createResponseEntity(location);
}

@RequestMapping(value = "/api/sourceinstance", method = RequestMethod.GET)
public ResponseEntity<String> getSourceInstance() throws JSONException {
    JSONObject resp = new JSONObject();
    resp.put("sourceInstance", instanceService.getSourceInstanceId());
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    return new ResponseEntity<String>(resp.toString(), headers, HttpStatus.OK);
}

@Test
public void shouldHaveStatusEndpoint() {
    final ResponseEntity<String> response = this.restTemplate.getForEntity("/internal/status.json", String.class);
    assertThat(response.getStatusCodeValue()).isEqualTo(200);
    assertThat(response.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_JSON_UTF8);
    assertThat(response.getBody()).startsWith("{");
}

@RequestMapping(value = "/editar/api/pagina/servico/{id}", method = PATCH)
ResponseEntity<Void> renomear(@PathVariable("id") String id, @RequestBody String novoNome) {
    ConteudoVersionado carta = factory.pagina(id, SERVICO);
    if (!carta.existe()) {
        throw new ConteudoInexistenteException(carta);
    }
    if (!usuarioPodeRealizarAcao(userProfiles, SERVICO, carta.getOrgaoId())) {
        throw new AccessDeniedException("Usuário sem permissão");
    }
    String novoId = carta.renomear(userProfiles.get(), novoNome);
    carta = factory.pagina(novoId, SERVICO);
    return new ResponseEntity<>(MetadadosUtils.metadados(carta), HttpStatus.OK);
}

@RolesAllowed({ "ROLE_ADMIN", "ROLE_USER" })
@RequestMapping(value = "/{regionId}", method = RequestMethod.GET)
public ResponseEntity getVolumesByRegion(@PathVariable("regionId") String region) {
    try {
        Set<VolumeDto> volumes = volumeService.getVolumesByRegion(Region.getRegion(Regions.fromName(region)));
        return new ResponseEntity(volumes, HttpStatus.OK);
    } catch (Exception e) {
        return new ResponseEntity("Failed to get volumes for region: " + region, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

@RequestMapping(value = "/CodeParser/{code}", method = RequestMethod.GET)
@ResponseBody
public ResponseEntity<?> getStandardVersion(@PathVariable String code, @RequestParam int gcpLength) {
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.add("Content-Type", "application/json; charset=utf-8");
    AICodeParser codeParser = new AICodeParser();
    JSONObject result = new JSONObject(codeParser.parse(code, gcpLength));
    return new ResponseEntity<>(result.toString(1), responseHeaders, HttpStatus.OK);
}

public static ResponseEntity<Boolean> getBooleanResponseEntityByHttpStatus(FeatureActions featureActions) {
    switch(featureActions) {
        case CREATED:
            return new ResponseEntity<Boolean>(TRUE, HttpStatus.CREATED);
        case UPDATED:
            return new ResponseEntity<Boolean>(TRUE, HttpStatus.ACCEPTED);
        default:
            return new ResponseEntity<Boolean>(FALSE, HttpStatus.NO_CONTENT);
    }
}

public static ResponseEntity<Boolean> getBooleanResponseEntityByHttpStatus(FeatureActions featureActions) {
    switch(featureActions) {
        case CREATED:
            return new ResponseEntity<Boolean>(TRUE, HttpStatus.CREATED);
        case UPDATED:
            return new ResponseEntity<Boolean>(TRUE, HttpStatus.ACCEPTED);
        default:
            return new ResponseEntity<Boolean>(FALSE, HttpStatus.NO_CONTENT);
    }
}

/**
     * Fetches the contacts.
     */
public void fetch() {
    setAcceptHeaderApplicationXml();
    HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
    restTemplate.getMessageConverters().add(new SimpleXmlHttpMessageConverter());
    // Perform the HTTP GET request
    ResponseEntity<ContactList> responseEntity = restTemplate.exchange(getUrl(), HttpMethod.GET, requestEntity, ContactList.class);
    contactList = responseEntity.getBody();
}

@ExceptionHandler(HodErrorException.class)
@ResponseBody
public ResponseEntity<HodErrorResponse> hodErrorHandler(final HodErrorException exception) {
    final HodErrorResponse hodErrorResponse = new HodErrorResponse("HOD Error", exception.getErrorCode());
    if (!userErrors.contains(exception.getErrorCode())) {
        log.error("Unhandled HodErrorException with uuid {}", hodErrorResponse.getUuid());
        log.error("Stack trace", exception);
    }
    return new ResponseEntity<>(hodErrorResponse, exception.isServerError() ? HttpStatus.INTERNAL_SERVER_ERROR : HttpStatus.BAD_REQUEST);
}

@Test
@Ignore("Integration test needs filtering and running with deployed app")
public void testSimpleSearch() {
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    HttpEntity<String> request = new HttpEntity<String>(requestBody, headers);
    ResponseEntity<String> entity = template.postForEntity("http://localhost:8081/fuzzydb-sample-webapp/autos/json/search", request, String.class);
    System.out.println(entity.getBody());
}

@Override
public T performRequest() {
    HttpEntity<T> requestEntity = new HttpEntity<>(getHeaders());
    RestTemplate restTemplate = getRestTemplate();
    ResponseEntity<T> requestResult = restTemplate.exchange(getUrl(), HttpMethod.GET, requestEntity, getResponseClass());
    T result = requestResult.getBody();
    return result;
}

@RequestMapping("/{orderedItemId}")
public ResponseEntity<Product> getOrderedItem(@PathVariable int orderId, @PathVariable int orderedItemId) {
    OrderModel order = orderBackend.getOrder(orderId);
    List<OrderedItemModel> orderedItems = order.getOrderedItems();
    OrderedItemModel found = null;
    for (OrderedItemModel orderedItem : orderedItems) {
        if (orderedItem.orderedItemId == orderedItemId) {
            found = orderedItem;
            break;
        }
    }
    Product product = null;
    if (found != null) {
        product = productAssembler.instantiateResource(found.orderedItem);
        product.add(linkTo(methodOn(this.getClass()).getOrderedItem(orderId, orderedItemId)).withSelfRel());
    }
    return new ResponseEntity<Product>(product, HttpStatus.OK);
}

@RequestMapping(value = "/registerUser", method = POST, consumes = JSON, produces = JSON)
public ResponseEntity<String> registerUser(@Valid @RequestBody AuthenticationRequest request) {
    try {
        return ResponseEntity.status(HttpStatus.OK).body(authenticationService.create(request.getUsername(), request.getPassword()));
    } catch (org.springframework.dao.DuplicateKeyException de) {
        return ResponseEntity.status(HttpStatus.OK).body("User already Exist");
    }
}

@Test
public void noBootVersion() {
    ResponseEntity<String> response = execute("/dependencies", String.class, null, "application/json");
    assertThat(response.getHeaders().getFirst(HttpHeaders.ETAG), not(nullValue()));
    validateContentType(response, CURRENT_METADATA_MEDIA_TYPE);
    validateDependenciesOutput("1.1.4", new JSONObject(response.getBody()));
}

protected String post() {
    RestTemplate rtp = getRestTemplate();
    HttpHeaders headers = getHeaders();
    String uriString = getUrl();
    Map<String, ?> params = getUrlParams();
    MultiValueMap<String, String> post = getPost();
    HttpEntity<?> req;
    if (null != post) {
        req = new HttpEntity<Object>(post, headers);
    } else {
        req = new HttpEntity<String>(headers);
    }
    ResponseEntity<String> res;
    String uri = Uris.expandQuery(uriString, params);
    res = rtp.exchange(uri, POST, req, String.class);
    return res.getBody();
}

@RequestMapping("/")
@ResponseBody
DeferredResult<String> home() {
    DeferredResult<String> result = new DeferredResult<>(5000);
    ListenableFuture<ResponseEntity<String>> creditRatingFuture = restTemplate.getForEntity("http://www.google.com", String.class);
    creditRatingFuture.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {

        @Override
        public void onSuccess(ResponseEntity<String> response) {
            log("Success");
            result.setResult(response.getBody());
        }

        @Override
        public void onFailure(Throwable t) {
            result.setErrorResult(t.getMessage());
        }
    });
    return result;
}

/**
	 * 处�JSR311 Validation异常.
	 */
@ExceptionHandler(value = { ConstraintViolationException.class })
public final ResponseEntity<?> handleException(ConstraintViolationException ex, WebRequest request) {
    Map<String, String> errors = BeanValidators.extractPropertyAndMessage(ex.getConstraintViolations());
    String body = jsonMapper.toJson(errors);
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.parseMediaType(MediaTypes.TEXT_PLAIN_UTF_8));
    return handleExceptionInternal(ex, body, headers, HttpStatus.BAD_REQUEST, request);
}

@ExceptionHandler(DomainException.class)
@ResponseBody
public ResponseEntity<TranslatedSimpleErrorResponse> handleDomainException(final DomainException ex, final WebRequest request) {
    final HttpStatus status = HttpStatus.BAD_REQUEST;
    final TranslatedSimpleErrorResponse errorResponse = new TranslatedSimpleErrorResponse(status.value(), i18n(request, ex.i18nKey(), ex.i18nArgs().toArray()));
    //note that domain exception do not use detail log
    logger.warn("{} {}", guessUri(request), ex.getClass().getSimpleName());
    return new ResponseEntity<>(errorResponse, status);
}

@RequestMapping(value = "/authorized", method = RequestMethod.POST, produces = "application/json")
@ResponseBody
public HttpEntity<Authorized> authorized(HttpSession session) throws AuthManager.AuthException {
    Authorized authorized = new Authorized();
    try {
        authorized.authorized = authManager.isAuthorized();
    } catch (AuthManager.AuthException e) {
        authorized.authorized = false;
    }
    if (!authorized.authorized) {
        session.invalidate();
    }
    return new ResponseEntity<Authorized>(authorized, HttpStatus.OK);
}

/**
	 * Check to see if the controller is online!
	 * 
	 * @param input
	 * @return
	 */
@RequestMapping(value = "loginusername")
public ResponseEntity<String> loginWithUsername(HttpServletRequest request, String username, final String password) {
    try {
        // check something to do with authentication
        return new ResponseEntity<String>(new String("blah!"), HttpStatus.OK);
    } catch (UsernameNotFoundException unfex) {
        return new ResponseEntity<String>(unfex.getMessage(), HttpStatus.UNAUTHORIZED);
    } catch (Exception ex) {
        return new ResponseEntity<String>(ex.getLocalizedMessage(), HttpStatus.UNAUTHORIZED);
    }
}

@Bean
public Docket learnyApi() {
    return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select().apis(RequestHandlerSelectors.withClassAnnotation(Api.class)).paths(PathSelectors.any()).build().pathMapping("/").directModelSubstitute(LocalDate.class, String.class).genericModelSubstitutes(ResponseEntity.class).useDefaultResponseMessages(false).securitySchemes(newArrayList(apiKey())).securityContexts(newArrayList(securityContext()));
}

@Test
public void testGetEntityWithColon() {
    EntityDescriptionController controller = new EntityDescriptionController() {

        {
            ServerContext context = new TestServerContext();
            super.setServerContext(context);
        }
    };
    CodeSystemVersionNameResolver resolver = Mockito.mock(CodeSystemVersionNameResolver.class);
    Mockito.when(resolver.getCodeSystemVersionNameFromVersionId(any(CodeSystemVersionReadService.class), anyString(), anyString(), any(ResolvedReadContext.class))).thenReturn("Automobiles-1.0");
    controller.setCodeSystemVersionNameResolver(resolver);
    controller.setEntityDescriptionReadService(this.lexEvsEntityReadService);
    MockHttpServletRequest request = new MockHttpServletRequest();
    ResponseEntity<EntityDescriptionMsg> result = (ResponseEntity) controller.getEntityDescriptionOfCodeSystemVersionByName(request, new RestReadContext(), "Automobiles", "Automobiles-1.0", "Has%3AColon");
    assertEquals("Has:Colon", ModelUtils.getEntity(result.getBody().getEntityDescription()).getEntityID().getName());
}

@RequestMapping(value = BASE_MAPPING + "/new", method = GET)
public ResponseEntity<Resource<?>> getItemResource(RootResourceInformation resourceInformation, PersistentEntityResourceAssembler assembler) throws HttpRequestMethodNotSupportedException {
    Constructor<?> constructor = getConstructorIfAvailable(resourceInformation.getDomainType());
    if (constructor == null) {
        return new ResponseEntity<Resource<?>>(NOT_IMPLEMENTED);
    }
    Object domainObj = BeanUtils.instantiateClass(constructor);
    return new ResponseEntity<Resource<?>>(assembler.toResource(domainObj), OK);
}

@Override
public Link createLink(String url) {
    MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
    parameters.add(URL_PARAMETER, url);
    ResponseEntity<Link> response;
    Link result = null;
    try {
        response = client.postForEntity(endpoint + "links", parameters, Link.class);
        HttpStatus responseStatusCode = response.getStatusCode();
        if (HttpStatus.CREATED == responseStatusCode || HttpStatus.OK == responseStatusCode) {
            result = response.getBody();
        } else {
            LOGGER.warn("Shorten request returned HTTP status: {}", responseStatusCode);
        }
    } catch (HttpStatusCodeException ex) {
        throw new RuntimeException(ex.getResponseBodyAsString());
    } catch (RestClientException ex) {
        throw new RuntimeException("Something went wrong, please try again in a bit.");
    }
    return result;
}

@RequestMapping("/")
@ResponseBody
DeferredResult<String> home() {
    // Create DeferredResult with timeout 5s
    final DeferredResult<String> result = new DeferredResult<>(5000);
    // Let's call the backend
    ListenableFuture<ResponseEntity<String>> future = restTemplate.getForEntity("http://www.google.com", String.class);
    future.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {

        @Override
        public void onSuccess(ResponseEntity<String> response) {
            // Will be called in HttpClient thread
            log("Success");
            result.setResult(response.getBody());
        }

        @Override
        public void onFailure(Throwable t) {
            result.setErrorResult(t.getMessage());
        }
    });
    // Return the thread to servlet container, the response will be processed by another thread.
    return result;
}

@Test
public void testUserLoginViaPasswordGrant() throws Exception {
    HttpHeaders headers = new HttpHeaders();
    headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
    headers.add("Authorization", ((UaaTestAccounts) testAccounts).getAuthorizationHeader("cf", ""));
    LinkedMultiValueMap<String, String> postBody = new LinkedMultiValueMap<>();
    postBody.add("grant_type", "password");
    postBody.add("username", testAccounts.getUserName());
    postBody.add("password", testAccounts.getPassword());
    ResponseEntity<Void> responseEntity = restOperations.exchange(baseUrl + "/oauth/token", HttpMethod.POST, new HttpEntity<>(postBody, headers), Void.class);
    Assert.assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
}

/**
	 * Gets the programs API.
	 *
	 * @param token the token
	 * @return the programs API
	 */
@RequestMapping(value = "api/elementList/")
public ResponseEntity<String> getElementsAPI(@RequestParam(value = "token") String token) {
    // Validate Token and retrieve email
    String email = getEmailOfToken(token);
    if (email != null) {
        List<ElementDTO> elementsDTO = elementService.getElementsDTO(elementService.getElementListReservable());
        String elementsJson = new Gson().toJson(elementsDTO);
        return new ResponseEntity<>(elementsJson, HttpStatus.OK);
    }
    return new ResponseEntity<>(null, HttpStatus.FORBIDDEN);
}

@Override
public String getPhotoListJson() {
    OAuth2AccessToken accessToken = oAuth2RestTemplate.getAccessToken();
    logger.debug("--------------------------->accessToken :" + accessToken.getValue());
    logger.debug("--------------------------->refreshToken :" + accessToken.getRefreshToken().getValue());
    logger.debug("--------------------------->jsonPhotoListURL :" + jsonPhotoListURL);
    ResponseEntity<String> responseEntity = oAuth2RestTemplate.getForEntity(URI.create(jsonPhotoListURL), String.class);
    //ResponseEntity<String> responseEntity = restTemplate.getForEntity(URI.create(jsonPhotoListURL),String.class);
    return responseEntity.getBody();
}

private ResponseEntity<String> sparqlInternal(String queryString) {
    ResponseEntity<String> responseEntity;
    String url = sparqlEndpoint.getUrl() + ((queryString != null) ? ("?" + queryString) : "");
    try {
        RestTemplate template = new RestTemplate();
        responseEntity = template.getForEntity(new URI(url), String.class);
        return responseEntity;
    } catch (HttpServerErrorExceptionHttpClientErrorException |  e) {
        throw new NextProtException(e.getResponseBodyAsString(), e);
    } catch (RestClientExceptionURISyntaxException |  e) {
        throw new NextProtException(e);
    }
}

@RequestMapping(value = "/fe/electronictaxreceipts/donate", method = RequestMethod.POST)
public ResponseEntity<String> donate(@RequestParam(value = "accessKey") String accessKey, @RequestParam(value = "total") double total) {
    HttpHeaders responseHeaders = super.createBasicHttpHeaderResponse(APPLICATION_JSON);
    Gson gson = new Gson();
    ResultResponse resultResponse;
    try {
        Assert.hasLength(accessKey);
        accessKey = removeNonNumeric(accessKey);
        Assert.isTrue(validateElectronicTaxReceiptAccessKey(accessKey));
        Assert.isTrue(total > 0.0);
        //Save to database
        ElectronicTaxReceipt receipt = new ElectronicTaxReceipt(accessKey, total);
        electronicTaxReceiptDAO.save(receipt);
        resultResponse = new ResultResponse(true);
    } catch (Exception ex) {
        ex.printStackTrace();
        resultResponse = new ResultResponse(false);
    }
    return new ResponseEntity<>(gson.toJson(resultResponse), responseHeaders, HttpStatus.OK);
}

/**
     * POST  /register -> register the user.
     */
@RequestMapping(value = "/adduser", method = RequestMethod.POST, produces = "application/json")
public ResponseEntity<?> addAccount(@RequestBody UserDTO userDTO, HttpServletRequest request) {
    //    	System.out.println("printing userdto, login: "+userDTO.getLogin()+"\npassword: "+userDTO.getPassword()+"\nname: "+userDTO.getFirstName());
    User newuser = userRepository.findByLogin(userDTO.getFirstName());
    //    	System.out.println(newuser);
    if (newuser == null) {
        newuser = userService.createUserInformation(userDTO.getLogin(), userDTO.getPassword(), userDTO.getFirstName(), userDTO.getLastName(), userDTO.getEmail().toLowerCase(), userDTO.getLangKey());
        return new ResponseEntity<>("successful created", HttpStatus.CREATED);
    } else {
        return new ResponseEntity<>("login already in use", HttpStatus.BAD_REQUEST);
    }
}