io.micronaut.http.HttpStatus Java Examples

public HttpResponse<String> toMicronautResponse(Response resp) {
    HttpStatus status = HttpStatus.valueOf(resp.getStatusCode());
    MutableHttpResponse<String> response = micronautResponseFactory.status(status);
    for (Map.Entry<String, List<String>> header : resp.getHeaders().entrySet()) {
        String name = header.getKey();
        for (String value : header.getValue()) {
            response.header(name, value);
        }
    }
    response.body(resp.getBody());
    response.contentType(resp.getContentType());
    if (resp.getBody() != null) {
        response.contentLength(resp.getBody().length());
    } else {
        response.contentLength(0);
    }
    return response;
}
 

/**
 *
 * @param handlerResponse Handler response object
 * @return If the handlerResponseType and the responseType are identical just returns the supplied object. However,
 * if the response type is of type {@link APIGatewayProxyResponseEvent} it attempts to serialized the handler response
 * as a JSON String and set it in the response body. If the object cannot be serialized, a 400 response is returned
 */
@Nullable
protected ResponseType createResponse(HandlerResponseType handlerResponse) {
    if (handlerResponseType == responseType) {
        logn(LogLevel.TRACE, "HandlerResponseType and ResponseType are identical");
        return (ResponseType) handlerResponse;

    } else if (responseType == APIGatewayProxyResponseEvent.class) {
        logn(LogLevel.TRACE, "response type is APIGatewayProxyResponseEvent");
        String json = serializeAsJsonString(handlerResponse);
        if (json != null) {
            return (ResponseType) respond(HttpStatus.OK, json, MediaType.APPLICATION_JSON);
        }
        return (ResponseType) respond(HttpStatus.BAD_REQUEST,
                "Could not serialize " + handlerResponse.toString() + " as json",
                MediaType.TEXT_PLAIN);
    }
    return null;
}
 

@SuppressWarnings("unchecked")
@Override
public <T> MutableHttpResponse<T> ok(T body) {
    final HttpRequest<Object> req = ServerRequestContext.currentRequest().orElse(null);
    if (req instanceof MicronautAwsProxyRequest) {
        final MicronautAwsProxyResponse<T> response = (MicronautAwsProxyResponse<T>) ((MicronautAwsProxyRequest<Object>) req).getResponse();
        return response.status(HttpStatus.OK).body(body);
    } else {
        if (ALTERNATE != null) {
            return ALTERNATE.ok(body);
        } else {
            throw new InternalServerException("No request present");
        }
    }
}
 

/**
 * The default constructor.
 * @param request The request
 * @param latch The latch to indicate request completion
 * @param environment The {@link MicronautLambdaContainerContext}
 */
MicronautAwsProxyResponse(
        AwsProxyRequest request,
        CountDownLatch latch,
        MicronautLambdaContainerContext environment) {
    this.responseEncodeLatch = latch;
    this.request = request;
    this.response.setMultiValueHeaders(multiValueHeaders);
    this.handler = environment;
    this.status = HttpStatus.OK;
    this.response.setStatusCode(HttpStatus.OK.getCode());
}
 

/**
 *
 * @param status HTTP Status of the response
 * @param body Body of the response
 * @param contentType HTTP Header Content-Type value
 * @return a {@link APIGatewayProxyResponseEvent} populated with the supplied status, body and content type
 */
protected APIGatewayProxyResponseEvent respond(HttpStatus status, String body, String contentType) {
    APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
    Map<String, String> headers = new HashMap<>();
    headers.put(HttpHeaders.CONTENT_TYPE, contentType);
    response.setHeaders(headers);
    response.setBody(body);
    response.setStatusCode(status.getCode());
    logn(LogLevel.TRACE, "response: " + status.getCode() + " content type: " + headers.get(HttpHeaders.CONTENT_TYPE) + " message " + body);
    return response;
}
 

@Test
public void cantLoginWithInvalidCredentials() {
    try {
        UsernamePasswordCredentials upc = new UsernamePasswordCredentials("jimmy.solid","secret111");
        HttpRequest loginRequest = HttpRequest.POST("/login", upc);
        HttpResponse<BearerAccessRefreshToken> rsp = httpClient.toBlocking().exchange(loginRequest, BearerAccessRefreshToken.class);
        fail();
    } catch (HttpClientResponseException ex) {
        assertThat(ex.getStatus().getCode()).isEqualTo(HttpStatus.UNAUTHORIZED.getCode());
    }
    
}
 

@Override
protected List<AnnotationValue<?>> mapInternal(AnnotationValue<Annotation> annotation, VisitorContext visitorContext) {
    try {
        final String code = annotation.getValue(String.class).orElse(annotation.get("code", String.class).orElse(null));
        final HttpStatus status = HttpStatus.valueOf(code);

        return Collections.singletonList(
                AnnotationValue.builder(Status.class).value(status).build()
        );
    } catch (IllegalArgumentException e) {
        // ignore
    }
    return Collections.emptyList();
}
 

@Get
public HttpStatus index() {
    return HttpStatus.OK;
}
 

public static MutableHttpResponse<?> get(HttpStatus status, String message, int code) {
    return HttpResponse.status(status).body(new Response(message, code));
}
 

public static MutableHttpResponse<?> get(HttpStatus status) {
    return HttpResponse.status(status).body(new Response("Unknown error", 0));
}
 

@Post("/{name}")
HttpStatus saveFeature(String name, FeaturesEndpoint.Feature feature);
 

@Delete("/{name}")
HttpStatus deleteFeature(String name);
 

@Test
public void testIndex() {
    assertEquals(HttpStatus.OK, client.index());
}
 

@Get
HttpStatus index();
 

/**
 * @return The HTTP status
 */
default HttpStatus getStatus() {
    return HttpStatus.valueOf(getStatusCode());
}
 

@Override
public HttpStatus getStatus() {
    return status;
}
 

@Delete("/{name}")
@Status(HttpStatus.NO_CONTENT)
void deletePet(String name) {
    petService.deletePet(name);
}
 

@Post(processes = APPLICATION_JSON)
@Status(HttpStatus.CREATED)
Pet savePet(String name, int age) {
    return petService.savePet(new Pet(name, age));
}