Java Code Examples for javax.ws.rs.HttpMethod#GET

protected JsonArray paginate(final Integer totalPerPage, Integer page, QueriableFields modelFilter) throws PagarMeException {
    final Map<String, Object> parameters = new HashMap<String, Object>();

    if (null != totalPerPage && totalPerPage > 0) {
        parameters.put("count", totalPerPage);
    }

    if (null != page && page > 0) {
        parameters.put("page", page);
    }
    
    String path = "/" + getClassName();
    final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET, path);
    request.getParameters().putAll(parameters);

    if(modelFilter != null){
        Map<String, Object> filter = modelFilter.toMap();
        request.getParameters().putAll(filter);
    }

    return request.execute();
}
 

@Test
public void getRequestShouldNotBeLogged() throws ExecutionException, InterruptedException {

    String url = "/getWithFilter200?param1=value1";
    WireMock.stubFor(get(urlEqualTo(url))
            .willReturn(okJson(stubRespBodyJson)));

    String requestMethod = HttpMethod.GET;

    Map<String, Collection<String>> headers = stubHeaders;

    ParsecAsyncHttpRequest request =
            new ParsecAsyncHttpRequest.Builder()
                    .setUrl(wireMockBaseUrl+url)
                    .setHeaders(headers)
                    .setRequestTimeout(30)
                    .setMethod(requestMethod)
                    .setBody("").setBodyEncoding("UTF-8").build();

    Response response = parsecHttpClient.criticalExecute(request).get();
    assertThat(response.getStatus(), equalTo(200));

    then(mockAppender).should(never()).doAppend(any());

}
 

@Override
public String getHttpMethod() {
    if (getRequest().getAuthorizationMethod() == null
            || getRequest().getAuthorizationMethod() == AuthorizationMethod.AUTHORIZATION_REQUEST_HEADER_FIELD
            || getRequest().getAuthorizationMethod() == AuthorizationMethod.FORM_ENCODED_BODY_PARAMETER) {
        return HttpMethod.POST;
    } else { // AuthorizationMethod.URL_QUERY_PARAMETER
        return HttpMethod.GET;
    }
}
 

public Customer find(int id) throws PagarMeException {

        final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET,
                String.format("/%s/%s", getClassName(), id));

        final Customer other = JSONUtils.getAsObject((JsonObject) request.execute(), Customer.class);
        copy(other);
        flush();

        return other;
    }
 

/**
 * Read Method annotations indicating HTTP Methods
 *
 * @param annotation
 */
private String getHTTPMethodAnnotation(Annotation annotation) {
    if (annotation.annotationType().getName().equals(GET.class.getName())) {
        return HttpMethod.GET;
    } else if (annotation.annotationType().getName().equals(POST.class.getName())) {
        return HttpMethod.POST;
    } else if (annotation.annotationType().getName().equals(OPTIONS.class.getName())) {
        return HttpMethod.OPTIONS;
    } else if (annotation.annotationType().getName().equals(DELETE.class.getName())) {
        return HttpMethod.DELETE;
    } else if (annotation.annotationType().getName().equals(PUT.class.getName())) {
        return HttpMethod.PUT;
    }
    return null;
}
 

private BulkAnticipationLimits getAnticipationLimits(DateTime paymentDate, Timeframe timeframe) throws PagarMeException{
    validateId();
    String path = String.format("/%s/%s/bulk_anticipations/limits", getClassName(), getId());
    final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET, path);
    Map<String, Object> parameters = new HashMap<String, Object>();
    parameters.put("payment_date", paymentDate.getMillis());
    parameters.put("timeframe", timeframe.name().toLowerCase());
    request.setParameters(parameters);
    JsonObject response = request.execute();
    BulkAnticipationLimits limits = JSONUtils.getAsObject(response, BulkAnticipationLimits.class);
    return limits;
}
 

/**
 * Retorna um objeto {@link Payable} informando os dados de um pagamento
 * referente a uma determinada transação.
 *
 * @param payableId
 *            ID do {@link Payable}
 * @return Um {@link Payable}
 * @throws PagarMeException
 */
public Payable payables(final Integer payableId) throws PagarMeException {
    validateId();

    final Payable splitRule = new Payable();

    final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET,
            String.format("/%s/%s/%s/%s", getClassName(), getId(), splitRule.getClassName(), payableId));

    return JSONUtils.getAsObject((JsonObject) request.execute(), Payable.class);
}
 

public Card find(String id) throws PagarMeException {

        final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET,
                String.format("/%s/%s", getClassName(), id));

        final Card other = JSONUtils.getAsObject((JsonObject) request.execute(), Card.class);
        copy(other);
        flush();
        return other;
    }
 

public Collection<Transaction> transactions(Integer count, Integer page) throws PagarMeException {
    validateId();

    final Transaction transaction = new Transaction();

    final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET,
            String.format("/%s/%s/%s", getClassName(), getId(), transaction.getClassName()));
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("count", count);
        params.put("page", page);
        request.setParameters(params);
    return JSONUtils.getAsList((JsonArray) request.execute(), new TypeToken<Collection<Transaction>>() {
    }.getType());
}
 

/**
 * Retorna um array com objetos {@link Payable} informando os dados dos
 * pagamentos referentes a uma transação.
 *
 * @return Lista de {@link Payable}
 * @throws PagarMeException
 */
public Collection<Payable> payables() throws PagarMeException {
    validateId();

    final Payable payable = new Payable();

    final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET,
            String.format("/%s/%s/%s", getClassName(), getId(), payable.getClassName()));

    return JSONUtils.getAsList((JsonArray) request.execute(), new TypeToken<Collection<Payable>>() {
    }.getType());
}
 

protected JsonObject get(final PK id) throws PagarMeException {
    validateId();

    if (null == id) {
        throw new IllegalArgumentException("You must provide an ID to get this object data");
    }

    final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET, String.format("/%s/%s", className, id));

    return request.execute();
}
 

protected NodeResponse replicateRequest(final WebResource.Builder resourceBuilder, final NodeIdentifier nodeId, final String method, final URI uri, final String requestId,
                                        final Map<String, String> headers) {
    final ClientResponse clientResponse;
    final long startNanos = System.nanoTime();
    logger.debug("Replicating request to {} {}, request ID = {}, headers = {}", method, uri, requestId, headers);

    switch (method.toUpperCase()) {
        case HttpMethod.DELETE:
            clientResponse = resourceBuilder.delete(ClientResponse.class);
            break;
        case HttpMethod.GET:
            clientResponse = resourceBuilder.get(ClientResponse.class);
            break;
        case HttpMethod.HEAD:
            clientResponse = resourceBuilder.head();
            break;
        case HttpMethod.OPTIONS:
            clientResponse = resourceBuilder.options(ClientResponse.class);
            break;
        case HttpMethod.POST:
            clientResponse = resourceBuilder.post(ClientResponse.class);
            break;
        case HttpMethod.PUT:
            clientResponse = resourceBuilder.put(ClientResponse.class);
            break;
        default:
            throw new IllegalArgumentException("HTTP Method '" + method + "' not supported for request replication.");
    }

    return new NodeResponse(nodeId, method, uri, clientResponse, System.nanoTime() - startNanos, requestId);
}
 

@Override
public String getHttpMethod() {
    return HttpMethod.GET;
}
 

@Override
public String getHttpMethod() {
    return HttpMethod.GET;
}
 

public AtlasServer getServer(String serverName) throws AtlasServiceException {
    API api = new API(String.format(ADMIN_SERVER_TEMPLATE, BASE_URI, serverName), HttpMethod.GET, Response.Status.OK);
    return callAPI(api, AtlasServer.class, null);
}
 

@Test
public void testResourceWithSubresource() {
    Bus bus = BusFactory.getDefaultBus(true);

    ResourceMethodInfoDTO[] resourceMethodInfoDTOS =
        ClassIntrospector.getResourceMethodInfos(
            ResourceWithSubResource.class, bus
        ).toArray(
            new ResourceMethodInfoDTO[0]
        );

    assertEquals(5, resourceMethodInfoDTOS.length);

    List<ResourceMethodInfoDTOWrapper> wrappers = Arrays.stream(
        resourceMethodInfoDTOS
    ).map(
        ResourceMethodInfoDTOWrapper::new
    ).collect(
        Collectors.toList()
    );

    ResourceMethodInfoDTO resourceMethodInfoDTO =
        new ResourceMethodInfoDTO();

    resourceMethodInfoDTO.method = HttpMethod.GET;
    resourceMethodInfoDTO.consumingMimeType = null;
    resourceMethodInfoDTO.producingMimeType =
        new String[]{MediaType.APPLICATION_XML};
    resourceMethodInfoDTO.path = "/resource";
    resourceMethodInfoDTO.nameBindings = null;

    assertTrue(
        wrappers.remove(
            new ResourceMethodInfoDTOWrapper(resourceMethodInfoDTO)));

    resourceMethodInfoDTO = new ResourceMethodInfoDTO();

    resourceMethodInfoDTO.method = HttpMethod.GET;
    resourceMethodInfoDTO.consumingMimeType =
        new String[]{MediaType.APPLICATION_JSON};
    resourceMethodInfoDTO.producingMimeType =
        new String[]{MediaType.APPLICATION_JSON};
    resourceMethodInfoDTO.path = "/resource/subresource";
    resourceMethodInfoDTO.nameBindings = null;

    assertTrue(
        wrappers.remove(
            new ResourceMethodInfoDTOWrapper(resourceMethodInfoDTO)));

    resourceMethodInfoDTO = new ResourceMethodInfoDTO();

    resourceMethodInfoDTO.method = HttpMethod.POST;
    resourceMethodInfoDTO.consumingMimeType =
        new String[]{MediaType.APPLICATION_XML};
    resourceMethodInfoDTO.producingMimeType =
        new String[]{
            MediaType.TEXT_PLAIN,
            MediaType.APPLICATION_JSON
        };
    resourceMethodInfoDTO.path = "/resource/subresource";
    resourceMethodInfoDTO.nameBindings = null;

    assertTrue(
        wrappers.remove(
            new ResourceMethodInfoDTOWrapper(resourceMethodInfoDTO)));

    resourceMethodInfoDTO = new ResourceMethodInfoDTO();

    resourceMethodInfoDTO.method = HttpMethod.GET;
    resourceMethodInfoDTO.consumingMimeType =
        new String[]{MediaType.APPLICATION_JSON};
    resourceMethodInfoDTO.producingMimeType =
        new String[]{MediaType.APPLICATION_JSON};
    resourceMethodInfoDTO.path = "/resource/subresource/{path}";
    resourceMethodInfoDTO.nameBindings = null;

    assertTrue(
        wrappers.remove(
            new ResourceMethodInfoDTOWrapper(resourceMethodInfoDTO)));

    resourceMethodInfoDTO = new ResourceMethodInfoDTO();

    resourceMethodInfoDTO.method = HttpMethod.POST;
    resourceMethodInfoDTO.consumingMimeType =
        new String[]{MediaType.APPLICATION_XML};
    resourceMethodInfoDTO.producingMimeType = new String[]{
        MediaType.TEXT_PLAIN,
        MediaType.APPLICATION_JSON
    };
    resourceMethodInfoDTO.path = "/resource/subresource/{path}";
    resourceMethodInfoDTO.nameBindings = null;

    assertTrue(
        wrappers.remove(
            new ResourceMethodInfoDTOWrapper(resourceMethodInfoDTO)));

    assertTrue(wrappers.isEmpty());
}
 

private <T> T getTypeDefByName(final String name, Class<T> typeDefClass) throws AtlasServiceException {
    String atlasPath = getAtlasPath(typeDefClass);
    APIInfo apiInfo = new APIInfo(String.format(GET_BY_NAME_TEMPLATE, atlasPath, name), HttpMethod.GET, Response.Status.OK);
    return callAPI(apiInfo, typeDefClass, null);
}
 

public Balance refresh() throws PagarMeException {
    final PagarMeRequest request = new PagarMeRequest(HttpMethod.GET, String.format("/%s", getClass().getName()));
    final Balance other = JSONUtils.getAsObject((JsonObject) request.execute(), Balance.class);
    copy(other);
    return other;
}
 

/**
 * GETメソッドとしてDcRequestオブジェクトを生成する.
 * @param url URL
 * @return req DcRequestオブジェクト
 */
public static DcRequest get(String url) {
    DcRequest req = new DcRequest(url);
    req.method = HttpMethod.GET;
    return req;
}
 

@Override
public String getHttpMethod() {
    return HttpMethod.GET;
}