Example usage for org.springframework.http HttpStatus valueOf

List of usage examples for org.springframework.http HttpStatus valueOf

Introduction

In this page you can find the example usage for org.springframework.http HttpStatus valueOf.

Prototype

public static HttpStatus valueOf(int statusCode) 

Source Link

Document

Return the enum constant of this type with the specified numeric value.

Usage

From source file:io.github.howiefh.jeews.modules.oauth2.controller.AccessTokenController.java

private HttpEntity<String> buildInvalidRefreshTokenResponse() throws OAuthSystemException {
    OAuthResponse response = OAuthASResponse.errorResponse(HttpServletResponse.SC_BAD_REQUEST)
            .setError(OAuthError.TokenResponse.INVALID_GRANT)
            .setErrorDescription(Constants.INVALID_REFRESH_TOKEN).buildJSONMessage();
    return new ResponseEntity<String>(response.getBody(), HttpStatus.valueOf(response.getResponseStatus()));
}

From source file:eu.freme.eservices.pipelines.core.PipelineService.java

private PipelineResponse execute(final SerializedRequest request, final String body)
        throws UnirestException, IOException, ServiceException {
    switch (request.getMethod()) {
    case GET:/*from   w  w w . j a  v  a  2s  .  c om*/
        throw new UnsupportedOperationException("GET is not supported at this moment.");
    default:
        HttpRequestWithBody req = Unirest.post(request.getEndpoint());
        if (request.getHeaders() != null && !request.getHeaders().isEmpty()) {
            req.headers(request.getHeaders());
        }
        if (request.getParameters() != null && !request.getParameters().isEmpty()) {
            req.queryString(request.getParameters()); // encode as POST parameters
        }

        HttpResponse<String> response;
        if (body != null) {
            response = req.body(body).asString();
        } else {
            response = req.asString();
        }
        if (!HttpStatus.Series.valueOf(response.getStatus()).equals(HttpStatus.Series.SUCCESSFUL)) {
            String errorBody = response.getBody();
            HttpStatus status = HttpStatus.valueOf(response.getStatus());
            if (errorBody == null || errorBody.isEmpty()) {
                throw new ServiceException(new PipelineResponse(
                        "The service \"" + request.getEndpoint() + "\" reported HTTP status "
                                + status.toString() + ". No further explanation given by service.",
                        RDFConstants.RDFSerialization.PLAINTEXT.contentType()), status);
            } else {
                throw new ServiceException(
                        new PipelineResponse(errorBody, response.getHeaders().getFirst("content-type")),
                        status);
            }
        }
        return new PipelineResponse(response.getBody(), response.getHeaders().getFirst("content-type"));
    }
}

From source file:eu.freme.eservices.tilde.terminology.TildeETerminology.java

@RequestMapping(value = "/e-terminology/tilde", method = RequestMethod.POST)
public ResponseEntity<String> tildeTranslate(@RequestParam(value = "input", required = false) String input,
        @RequestParam(value = "i", required = false) String i,
        @RequestParam(value = "informat", required = false) String informat,
        @RequestParam(value = "f", required = false) String f,
        @RequestParam(value = "outformat", required = false) String outformat,
        @RequestParam(value = "o", required = false) String o,
        @RequestParam(value = "prefix", required = false) String prefix,
        @RequestParam(value = "p", required = false) String p,
        @RequestHeader(value = "Accept", required = false) String acceptHeader,
        @RequestHeader(value = "Content-Type", required = false) String contentTypeHeader,
        @RequestBody(required = false) String postBody, @RequestParam(value = "source-lang") String sourceLang,
        @RequestParam(value = "target-lang") String targetLang,
        @RequestParam(value = "domain", defaultValue = "") String domain,
        @RequestParam(value = "mode", defaultValue = "full") String mode,
        @RequestParam(value = "collection", required = false) String collection,
        @RequestHeader(value = "key", required = false) String key) {
    // merge long and short parameters - long parameters override short
    // parameters
    if (input == null) {
        input = i;// www .  ja  va 2  s. c  om
    }
    if (informat == null) {
        informat = f;
    }
    if (outformat == null) {
        outformat = o;
    }
    if (prefix == null) {
        prefix = p;
    }

    NIFParameterSet parameters = this.normalizeNif(input, informat, outformat, postBody, acceptHeader,
            contentTypeHeader, prefix);

    // create rdf model
    String plaintext = null;
    Model inputModel = ModelFactory.createDefaultModel();

    if (!parameters.getInformat().equals(RDFConstants.RDFSerialization.PLAINTEXT)) {
        // input is nif
        try {
            inputModel = this.unserializeNif(parameters.getInput(), parameters.getInformat());
        } catch (Exception e) {
            logger.error("failed", e);
            throw new BadRequestException("Error parsing NIF input");
        }
    } else {
        // input is plaintext
        plaintext = parameters.getInput();
        getRdfConversionService().plaintextToRDF(inputModel, plaintext, sourceLang, parameters.getPrefix());

    }

    // send request to tilde mt
    Model responseModel = null;
    try {
        //         String nifString = rdfConversionService.serializeRDF(inputModel,
        //               RDFSerialization.TURTLE);
        //         if( logger.isDebugEnabled() ){
        //            logger.debug( "send nif to tilde e-terminology: \n" + nifString);
        //         }
        HttpResponse<String> response = Unirest.post(endpoint).queryString("sourceLang", sourceLang)
                .queryString("targetLang", targetLang).queryString("domain", domain)
                .header("Accept", "application/turtle").header("Content-Type", "application/turtle")
                .queryString("mode", mode).queryString("collection", collection)
                .header("Authentication", "Basic RlJFTUU6dXxGcjNtM19zJGN1ciQ=").queryString("key", key)
                .body(getRdfConversionService().serializeRDF(inputModel, RDFSerialization.TURTLE)).asString();

        //         HttpResponse<String> response = Unirest
        //               .post(endpoint)
        //               .routeParam("source-lang", sourceLang)
        //               .routeParam("target-lang", targetLang)
        //               .header("Accept", "application/x-turtle")
        //               .header("Content-Type", "application/x-turtle")
        //               .queryString("system", system)
        //               .header("Authentication", "Basic RlJFTUU6dXxGcjNtM19zJGN1ciQ=")
        //               .queryString("domain", domain)
        //               .queryString("key", key)
        //               .body(getRdfConversionService().serializeRDF(inputModel,
        //                     RDFSerialization.TURTLE)).asString();

        if (response.getStatus() != HttpStatus.OK.value()) {
            throw new ExternalServiceFailedException("External service failed: " + response.getBody(),
                    HttpStatus.valueOf(response.getStatus()));
        }

        String translation = response.getBody();

        responseModel = getRdfConversionService().unserializeRDF(translation, RDFSerialization.TURTLE);

    } catch (Exception e) {
        if (e instanceof ExternalServiceFailedException) {
            throw new ExternalServiceFailedException(e.getMessage(),
                    ((ExternalServiceFailedException) e).getHttpStatusCode());
        } else {
            throw new ExternalServiceFailedException(e.getMessage());
        }
    }

    return createSuccessResponse(responseModel, parameters.getOutformat());

}

From source file:be.solidx.hot.rest.RestController.java

protected ResponseEntity<byte[]> buildResponse(byte[] response, Map headers, Integer httpStatus) {
    try {/* ww w .java 2  s .c  o m*/
        HttpHeaders httpHeaders = buildHttpHeaders(headers);
        return new ResponseEntity<byte[]>(response, httpHeaders, HttpStatus.valueOf(httpStatus));
    } catch (ScriptException e) {
        return new ResponseEntity<byte[]>(e.getMessage().getBytes(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

From source file:be.solidx.hot.rest.RestController.java

protected ResponseEntity<byte[]> buildResponse(byte[] response, HttpHeaders httpHeaders, Integer httpStatus) {
    try {/*from   w  w  w .  jav a 2  s  . c o m*/
        return new ResponseEntity<byte[]>(response, httpHeaders, HttpStatus.valueOf(httpStatus));
    } catch (ScriptException e) {
        return new ResponseEntity<byte[]>(e.getMessage().getBytes(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

From source file:com.monarchapis.driver.spring.rest.ApiErrorResponseEntityExceptionHandler.java

private ResponseEntity<Object> errorResponse(String errorReason, HttpHeaders headers) {
    ApiError error = apiErrorFactory.error(errorReason);

    return new ResponseEntity<Object>(setErrorHolder(error), headers, HttpStatus.valueOf(error.getStatus()));
}

From source file:io.github.microcks.web.RestController.java

@RequestMapping(value = "/{service}/{version}/**")
public ResponseEntity<?> execute(@PathVariable("service") String serviceName,
        @PathVariable("version") String version, @RequestParam(value = "delay", required = false) Long delay,
        @RequestBody(required = false) String body, HttpServletRequest request) {

    log.info("Servicing mock response for service [{}, {}] on uri {} with verb {}", serviceName, version,
            request.getRequestURI(), request.getMethod());
    log.debug("Request body: " + body);

    long startTime = System.currentTimeMillis();

    // Extract resourcePath for matching with correct operation.
    String requestURI = request.getRequestURI();
    String serviceAndVersion = null;
    String resourcePath = null;//  w  ww. j a v  a  2 s. co m

    try {
        // Build the encoded URI fragment to retrieve simple resourcePath.
        serviceAndVersion = "/" + UriUtils.encodeFragment(serviceName, "UTF-8") + "/" + version;
        resourcePath = requestURI.substring(requestURI.indexOf(serviceAndVersion) + serviceAndVersion.length());
    } catch (UnsupportedEncodingException e1) {
        return new ResponseEntity<Object>(HttpStatus.INTERNAL_SERVER_ERROR);
    }
    log.info("Found resourcePath: " + resourcePath);

    Service service = serviceRepository.findByNameAndVersion(serviceName, version);
    Operation rOperation = null;
    for (Operation operation : service.getOperations()) {
        // Select operation based onto Http verb (GET, POST, PUT, etc ...)
        if (operation.getMethod().equals(request.getMethod().toUpperCase())) {
            // ... then check is we have a matching resource path.
            if (operation.getResourcePaths().contains(resourcePath)) {
                rOperation = operation;
                break;
            }
        }
    }

    if (rOperation != null) {
        log.debug("Found a valid operation {} with rules: {}", rOperation.getName(),
                rOperation.getDispatcherRules());

        Response response = null;
        String uriPattern = getURIPattern(rOperation.getName());
        String dispatchCriteria = null;

        // Depending on dispatcher, evaluate request with rules.
        if (DispatchStyles.SEQUENCE.equals(rOperation.getDispatcher())) {
            dispatchCriteria = DispatchCriteriaHelper.extractFromURIPattern(uriPattern, resourcePath);
        } else if (DispatchStyles.SCRIPT.equals(rOperation.getDispatcher())) {
            ScriptEngineManager sem = new ScriptEngineManager();
            try {
                // Evaluating request with script coming from operation dispatcher rules.
                ScriptEngine se = sem.getEngineByExtension("groovy");
                SoapUIScriptEngineBinder.bindSoapUIEnvironment(se, body, request);
                dispatchCriteria = (String) se.eval(rOperation.getDispatcherRules());
            } catch (Exception e) {
                log.error("Error during Script evaluation", e);
            }
        }
        // New cases related to services/operations/messages coming from a postman collection file.
        else if (DispatchStyles.URI_PARAMS.equals(rOperation.getDispatcher())) {
            String fullURI = request.getRequestURL() + "?" + request.getQueryString();
            dispatchCriteria = DispatchCriteriaHelper.extractFromURIParams(rOperation.getDispatcherRules(),
                    fullURI);
        } else if (DispatchStyles.URI_PARTS.equals(rOperation.getDispatcher())) {
            dispatchCriteria = DispatchCriteriaHelper.extractFromURIPattern(uriPattern, resourcePath);
        } else if (DispatchStyles.URI_ELEMENTS.equals(rOperation.getDispatcher())) {
            dispatchCriteria = DispatchCriteriaHelper.extractFromURIPattern(uriPattern, resourcePath);
            String fullURI = request.getRequestURL() + "?" + request.getQueryString();
            dispatchCriteria += DispatchCriteriaHelper.extractFromURIParams(rOperation.getDispatcherRules(),
                    fullURI);
        }

        log.debug("Dispatch criteria for finding response is {}", dispatchCriteria);
        List<Response> responses = responseRepository.findByOperationIdAndDispatchCriteria(
                IdBuilder.buildOperationId(service, rOperation), dispatchCriteria);
        if (!responses.isEmpty()) {
            response = responses.get(0);
        }

        if (response != null) {
            // Setting delay to default one if not set.
            if (delay == null && rOperation.getDefaultDelay() != null) {
                delay = rOperation.getDefaultDelay();
            }

            if (delay != null && delay > -1) {
                log.debug("Mock delay is turned on, waiting if necessary...");
                long duration = System.currentTimeMillis() - startTime;
                if (duration < delay) {
                    Object semaphore = new Object();
                    synchronized (semaphore) {
                        try {
                            semaphore.wait(delay - duration);
                        } catch (Exception e) {
                            log.debug("Delay semaphore was interrupted");
                        }
                    }
                }
                log.debug("Delay now expired, releasing response !");
            }

            // Publish an invocation event before returning.
            MockInvocationEvent event = new MockInvocationEvent(this, service.getName(), version,
                    response.getName(), new Date(startTime), startTime - System.currentTimeMillis());
            applicationContext.publishEvent(event);
            log.debug("Mock invocation event has been published");

            HttpStatus status = (response.getStatus() != null
                    ? HttpStatus.valueOf(Integer.parseInt(response.getStatus()))
                    : HttpStatus.OK);

            // Deal with specific headers (content-type and redirect directive).
            HttpHeaders responseHeaders = new HttpHeaders();
            if (response.getMediaType() != null) {
                responseHeaders.setContentType(MediaType.valueOf(response.getMediaType() + ";charset=UTF-8"));
            }

            // Adding other generic headers (caching directives and so on...)
            if (response.getHeaders() != null) {
                for (Header header : response.getHeaders()) {
                    if ("Location".equals(header.getName())) {
                        // We should process location in order to make relative URI specified an absolute one from
                        // the client perspective.
                        String location = "http://" + request.getServerName() + ":" + request.getServerPort()
                                + request.getContextPath() + "/rest" + serviceAndVersion
                                + header.getValues().iterator().next();
                        responseHeaders.add(header.getName(), location);
                    } else {
                        if (!HttpHeaders.TRANSFER_ENCODING.equalsIgnoreCase(header.getName())) {
                            responseHeaders.put(header.getName(), new ArrayList<>(header.getValues()));
                        }
                    }
                }
            }
            return new ResponseEntity<Object>(response.getContent(), responseHeaders, status);
        }
        return new ResponseEntity<Object>(HttpStatus.BAD_REQUEST);
    }
    return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
}

From source file:de.zib.gndms.gndmc.dspace.SliceClient.java

@Override
public ResponseEntity<Integer> listFileContent(final Specifier<Void> slice, final String fileName,
        final List<String> attrs, final String dn, final OutputStream out)
        throws NoSuchAlgorithmException, KeyManagementException, IOException {

    HTTPGetter httpGetter = new HTTPGetter();
    GNDMSResponseHeader headers = new GNDMSResponseHeader();

    if (dn != null)
        headers.setDN(dn);/*from  w  w w.j a va 2s.co  m*/

    EnhancedResponseExtractor responseExtractor = new DefaultResponseExtractor() {
        @Override
        public void extractData(String url, ClientHttpResponse response) throws IOException {
            super.extractData(url, response);
            FileCopyUtils.copy(getBody(), out);
        }
    };
    httpGetter.setExtractor(200, responseExtractor);

    httpGetter.get(makeFileNameFacet(slice.getUrl(), fileName), headers);

    return new ResponseEntity<Integer>(0, responseExtractor.getHeaders(),
            HttpStatus.valueOf(responseExtractor.getStatusCode()));
}

From source file:org.cloudfoundry.identity.uaa.oauth.approval.ApprovalsAdminEndpoints.java

@ExceptionHandler
public View handleException(Exception t) {
    UaaException e = t instanceof UaaException ? (UaaException) t
            : new UaaException("Unexpected error", "Error accessing user's approvals",
                    HttpStatus.INTERNAL_SERVER_ERROR.value());
    Class<?> clazz = t.getClass();
    for (Class<?> key : statuses.keySet()) {
        if (key.isAssignableFrom(clazz)) {
            e = new UaaException(t.getMessage(), "Error accessing user's approvals", statuses.get(key).value());
            break;
        }//from ww w. j av  a 2s  .com
    }
    return new ConvertingExceptionView(new ResponseEntity<ExceptionReport>(new ExceptionReport(e, false),
            HttpStatus.valueOf(e.getHttpStatus())), messageConverters);
}