/** * Make an HTTP request */ protected <T,U> ListenableFuture<T> request(HttpMethod method, String url, HttpHeaders httpHeaders, U body, Class<T> responseType) { if (httpHeaders == null) { httpHeaders = getRequestHeaders(url); } HttpEntity<U> requestEntity = new HttpEntity<>(body, httpHeaders); ListenableFuture<ResponseEntity<T>> future = asyncRestTemplate.exchange(url, method, requestEntity, responseType); return new ListenableFutureAdapter<T, ResponseEntity<T>>(future) { @Override protected T adapt(ResponseEntity<T> result) throws ExecutionException { return result.getBody(); } }; }
/** * @return the list of supported operations under /v2 */ public ListenableFuture<Map<String, String>> getV2() { ListenableFuture<ResponseEntity<JsonNode>> responseFuture = request(HttpMethod.GET, baseURL + "v2", null, JsonNode.class); return new ListenableFutureAdapter<Map<String, String>, ResponseEntity<JsonNode>>(responseFuture) { @Override protected Map<String, String> adapt(ResponseEntity<JsonNode> result) throws ExecutionException { Map<String, String> services = new HashMap<>(); result.getBody().fields().forEachRemaining(entry -> services.put(entry.getKey(), entry.getValue().textValue())); return services; } }; }
/** * Retrieve the list of all Registrations * @return a list of registrations */ public ListenableFuture<List<Registration>> getRegistrations() { UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL); builder.path("v2/registrations"); ListenableFuture<ResponseEntity<Registration[]>> e = request(HttpMethod.GET, builder.toUriString(), null, Registration[].class); return new ListenableFutureAdapter<List<Registration>, ResponseEntity<Registration[]>>(e) { @Override protected List<Registration> adapt(ResponseEntity<Registration[]> result) throws ExecutionException { return new ArrayList<>(Arrays.asList(result.getBody())); } }; }
/** * Create a new subscription * @param subscription the Subscription to add * @return subscription Id */ public ListenableFuture<String> addSubscription(Subscription subscription) { ListenableFuture<ResponseEntity<Void>> s = request(HttpMethod.POST, UriComponentsBuilder.fromHttpUrl(baseURL).path("v2/subscriptions").toUriString(), subscription, Void.class); return new ListenableFutureAdapter<String, ResponseEntity<Void>>(s) { @Override protected String adapt(ResponseEntity<Void> result) throws ExecutionException { return extractId(result); } }; }
private <T> ListenableFuture<T> adapt(ListenableFuture<ResponseEntity<T>> responseEntityListenableFuture) { return new ListenableFutureAdapter<T, ResponseEntity<T>>(responseEntityListenableFuture) { @Override protected T adapt(ResponseEntity<T> result) throws ExecutionException { return result.getBody(); } }; }
private <T> ListenableFuture<Paginated<T>> adaptPaginated(ListenableFuture<ResponseEntity<T[]>> responseEntityListenableFuture, int offset, int limit) { return new ListenableFutureAdapter<Paginated<T>, ResponseEntity<T[]>>(responseEntityListenableFuture) { @Override protected Paginated<T> adapt(ResponseEntity<T[]> result) throws ExecutionException { return new Paginated<>(Arrays.asList(result.getBody()), offset, limit, extractTotalCount(result)); } }; }
public <S, T> ListenableFuture<T> adaptFuture(ListenableFuture<S> futureToAdapt, FunctionalFutureAdapter<S, T> adapter) { return new ListenableFutureAdapter<T, S>(futureToAdapt) { @Override protected T adapt(S objectToAdapt) throws ExecutionException { return adapter.adapt(objectToAdapt); } }; }
protected <T> ListenableFutureAdapter<T, ResponseEntity<T>> adaptResponseEntityFuture( final ListenableFuture<ResponseEntity<T>> responseEntity) { ListenableFutureAdapter<T, ResponseEntity<T>> returnFuture; returnFuture = new ListenableFutureAdapter<T, ResponseEntity<T>>(responseEntity) { @Override protected T adapt(ResponseEntity<T> adapteeResult) throws ExecutionException { return adapteeResult.getBody(); } }; return returnFuture; }
/** * Build an Http request * * @param method Http method * @param url Url * @param body Request body * @param responseType Response type * @param <T> Type to deserialize for the response * @param <U> Type to serialize for the body * @return Listenable for request */ private <T, U> ListenableFuture<T> request(HttpMethod method, String url, U body, Class<T> responseType) { HttpEntity<U> requestEntity = new HttpEntity<>(body, getHttpHeaders(body != null)); ListenableFuture<ResponseEntity<T>> future = asyncRestTemplate.exchange(url, method, requestEntity, responseType); return new ListenableFutureAdapter<T, ResponseEntity<T>>(future) { @Override protected T adapt(ResponseEntity<T> result) throws ExecutionException { return result.getBody(); } }; }