org.springframework.core.ParameterizedTypeReference

Here are the examples of the java api org.springframework.core.ParameterizedTypeReference taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

440 Examples 7

19 Source : FakeApi.java
with Apache License 2.0
from OpenAPITools

/**
 * To test the collection format in query parameters
 * <p><b>200</b> - Success
 * @param pipe  (required)
 * @param ioutil  (required)
 * @param http  (required)
 * @param url  (required)
 * @param context  (required)
 * @return ResponseEnreplacedy<Void>
 * @throws RestClientException if an error occurs while attempting to invoke the API
 */
public ResponseEnreplacedy<Void> testQueryParameterCollectionFormatWithHttpInfo(List<String> pipe, List<String> ioutil, List<String> http, List<String> url, List<String> context) throws RestClientException {
    Object postBody = null;
    // verify the required parameter 'pipe' is set
    if (pipe == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'pipe' when calling testQueryParameterCollectionFormat");
    }
    // verify the required parameter 'ioutil' is set
    if (ioutil == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'ioutil' when calling testQueryParameterCollectionFormat");
    }
    // verify the required parameter 'http' is set
    if (http == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'http' when calling testQueryParameterCollectionFormat");
    }
    // verify the required parameter 'url' is set
    if (url == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'url' when calling testQueryParameterCollectionFormat");
    }
    // verify the required parameter 'context' is set
    if (context == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'context' when calling testQueryParameterCollectionFormat");
    }
    String path = apiClient.expandPath("/fake/test-query-paramters", Collections.<String, Object>emptyMap());
    final MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<String, String>();
    final HttpHeaders headerParams = new HttpHeaders();
    final MultiValueMap<String, String> cookieParams = new LinkedMultiValueMap<String, String>();
    final MultiValueMap<String, Object> formParams = new LinkedMultiValueMap<String, Object>();
    queryParams.putAll(apiClient.parameterToMultiValueMap(ApiClient.CollectionFormat.valueOf("csv".toUpperCase(Locale.ROOT)), "pipe", pipe));
    queryParams.putAll(apiClient.parameterToMultiValueMap(ApiClient.CollectionFormat.valueOf("csv".toUpperCase(Locale.ROOT)), "ioutil", ioutil));
    queryParams.putAll(apiClient.parameterToMultiValueMap(ApiClient.CollectionFormat.valueOf("ssv".toUpperCase(Locale.ROOT)), "http", http));
    queryParams.putAll(apiClient.parameterToMultiValueMap(ApiClient.CollectionFormat.valueOf("csv".toUpperCase(Locale.ROOT)), "url", url));
    queryParams.putAll(apiClient.parameterToMultiValueMap(ApiClient.CollectionFormat.valueOf("multi".toUpperCase(Locale.ROOT)), "context", context));
    final String[] localVarAccepts = {};
    final List<MediaType> localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
    final String[] contentTypes = {};
    final MediaType contentType = apiClient.selectHeaderContentType(contentTypes);
    String[] authNames = new String[] {};
    ParameterizedTypeReference<Void> returnType = new ParameterizedTypeReference<Void>() {
    };
    return apiClient.invokeAPI(path, HttpMethod.PUT, queryParams, postBody, headerParams, cookieParams, formParams, localVarAccept, contentType, authNames, returnType);
}

19 Source : FakeApi.java
with Apache License 2.0
from OpenAPITools

/**
 * Fake endpoint for testing various parameters  假端點  偽のエンドポイント  가짜 엔드 포인트
 * Fake endpoint for testing various parameters  假端點  偽のエンドポイント  가짜 엔드 포인트
 * <p><b>400</b> - Invalid username supplied
 * <p><b>404</b> - User not found
 * @param number None (required)
 * @param _double None (required)
 * @param patternWithoutDelimiter None (required)
 * @param _byte None (required)
 * @param integer None (optional)
 * @param int32 None (optional)
 * @param int64 None (optional)
 * @param _float None (optional)
 * @param string None (optional)
 * @param binary None (optional)
 * @param date None (optional)
 * @param dateTime None (optional)
 * @param preplacedword None (optional)
 * @param paramCallback None (optional)
 * @return ResponseEnreplacedy<Void>
 * @throws RestClientException if an error occurs while attempting to invoke the API
 */
public ResponseEnreplacedy<Void> testEndpointParametersWithHttpInfo(BigDecimal number, Double _double, String patternWithoutDelimiter, byte[] _byte, Integer integer, Integer int32, Long int64, Float _float, String string, File binary, LocalDate date, OffsetDateTime dateTime, String preplacedword, String paramCallback) throws RestClientException {
    Object postBody = null;
    // verify the required parameter 'number' is set
    if (number == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'number' when calling testEndpointParameters");
    }
    // verify the required parameter '_double' is set
    if (_double == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter '_double' when calling testEndpointParameters");
    }
    // verify the required parameter 'patternWithoutDelimiter' is set
    if (patternWithoutDelimiter == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'patternWithoutDelimiter' when calling testEndpointParameters");
    }
    // verify the required parameter '_byte' is set
    if (_byte == null) {
        throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter '_byte' when calling testEndpointParameters");
    }
    String path = apiClient.expandPath("/fake", Collections.<String, Object>emptyMap());
    final MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<String, String>();
    final HttpHeaders headerParams = new HttpHeaders();
    final MultiValueMap<String, String> cookieParams = new LinkedMultiValueMap<String, String>();
    final MultiValueMap<String, Object> formParams = new LinkedMultiValueMap<String, Object>();
    if (integer != null)
        formParams.add("integer", integer);
    if (int32 != null)
        formParams.add("int32", int32);
    if (int64 != null)
        formParams.add("int64", int64);
    if (number != null)
        formParams.add("number", number);
    if (_float != null)
        formParams.add("float", _float);
    if (_double != null)
        formParams.add("double", _double);
    if (string != null)
        formParams.add("string", string);
    if (patternWithoutDelimiter != null)
        formParams.add("pattern_without_delimiter", patternWithoutDelimiter);
    if (_byte != null)
        formParams.add("byte", _byte);
    if (binary != null)
        formParams.add("binary", new FileSystemResource(binary));
    if (date != null)
        formParams.add("date", date);
    if (dateTime != null)
        formParams.add("dateTime", dateTime);
    if (preplacedword != null)
        formParams.add("preplacedword", preplacedword);
    if (paramCallback != null)
        formParams.add("callback", paramCallback);
    final String[] localVarAccepts = {};
    final List<MediaType> localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
    final String[] contentTypes = { "application/x-www-form-urlencoded" };
    final MediaType contentType = apiClient.selectHeaderContentType(contentTypes);
    String[] authNames = new String[] { "http_basic_test" };
    ParameterizedTypeReference<Void> returnType = new ParameterizedTypeReference<Void>() {
    };
    return apiClient.invokeAPI(path, HttpMethod.POST, queryParams, postBody, headerParams, cookieParams, formParams, localVarAccept, contentType, authNames, returnType);
}

19 Source : ReactorTitusMasterClient.java
with Apache License 2.0
from Netflix

public clreplaced ReactorreplacedusMasterClient implements replacedusMasterClient {

    private static final ParameterizedTypeReference<List<ApplicationSlaRepresentation>> APPLICATION_SLA_LIST_TP = new ParameterizedTypeReference<List<ApplicationSlaRepresentation>>() {
    };

    private final WebClient client;

    public ReactorreplacedusMasterClient(String hostName, int port) {
        this.client = WebClient.builder().baseUrl(String.format("http://%s:%s", hostName, port)).defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON).build();
    }

    @Override
    public Observable<String> addApplicationSLA(ApplicationSlaRepresentation applicationSLA) {
        Mono<String> x = client.post().uri("/api/v2/management/applications").body(BodyInserters.fromObject(applicationSLA)).exchange().flatMap(response -> response.toEnreplacedy(String.clreplaced)).flatMap(response -> {
            if (!response.getStatusCode().is2xxSuccessful()) {
                return Mono.error(new IOException("Errored with HTTP status code " + response.getStatusCode()));
            }
            List<String> locationHeader = response.getHeaders().getOrDefault("Location", Collections.emptyList());
            if (locationHeader.isEmpty()) {
                return Mono.error(new IOException("Location header not found in response"));
            }
            return Mono.just(locationHeader.get(0));
        });
        return ReactorExt.toObservable(x);
    }

    @Override
    public Observable<List<ApplicationSlaRepresentation>> findAllApplicationSLA() {
        Mono<List<ApplicationSlaRepresentation>> x = client.get().uri("/api/v2/management/applications").retrieve().bodyToMono(APPLICATION_SLA_LIST_TP);
        return ReactorExt.toObservable(x);
    }
}

19 Source : ServerRequestWrapperTests.java
with MIT License
from mindcarver

@Test
public void bodyToMonoParameterizedTypeReference() {
    Mono<String> result = Mono.just("foo");
    ParameterizedTypeReference<String> reference = new ParameterizedTypeReference<String>() {
    };
    when(mockRequest.bodyToMono(reference)).thenReturn(result);
    replacedertSame(result, wrapper.bodyToMono(reference));
}

19 Source : ServerRequestWrapperTests.java
with MIT License
from mindcarver

@Test
public void bodyToFluxParameterizedTypeReference() {
    Flux<String> result = Flux.just("foo");
    ParameterizedTypeReference<String> reference = new ParameterizedTypeReference<String>() {
    };
    when(mockRequest.bodyToFlux(reference)).thenReturn(result);
    replacedertSame(result, wrapper.bodyToFlux(reference));
}

19 Source : ClientResponseWrapperTests.java
with MIT License
from mindcarver

@Test
public void bodyToFluxParameterizedTypeReference() {
    Flux<String> result = Flux.just("foo");
    ParameterizedTypeReference<String> reference = new ParameterizedTypeReference<String>() {
    };
    when(mockResponse.bodyToFlux(reference)).thenReturn(result);
    replacedertSame(result, wrapper.bodyToFlux(reference));
}

19 Source : ClientResponseWrapperTests.java
with MIT License
from mindcarver

@Test
public void toEnreplacedyListParameterizedTypeReference() {
    Mono<ResponseEnreplacedy<List<String>>> result = Mono.just(new ResponseEnreplacedy<>(singletonList("foo"), HttpStatus.OK));
    ParameterizedTypeReference<String> reference = new ParameterizedTypeReference<String>() {
    };
    when(mockResponse.toEnreplacedyList(reference)).thenReturn(result);
    replacedertSame(result, wrapper.toEnreplacedyList(reference));
}

19 Source : ClientResponseWrapperTests.java
with MIT License
from mindcarver

@Test
public void bodyToMonoParameterizedTypeReference() {
    Mono<String> result = Mono.just("foo");
    ParameterizedTypeReference<String> reference = new ParameterizedTypeReference<String>() {
    };
    when(mockResponse.bodyToMono(reference)).thenReturn(result);
    replacedertSame(result, wrapper.bodyToMono(reference));
}

19 Source : RequestEntityTests.java
with MIT License
from mindcarver

// SPR-13154
@Test
public void types() throws URISyntaxException {
    URI url = new URI("http://example.com");
    List<String> body = Arrays.asList("foo", "bar");
    ParameterizedTypeReference<?> typeReference = new ParameterizedTypeReference<List<String>>() {
    };
    RequestEnreplacedy<?> enreplacedy = RequestEnreplacedy.post(url).body(body, typeReference.getType());
    replacedertEquals(typeReference.getType(), enreplacedy.getType());
}

19 Source : MappingJackson2HttpMessageConverterTests.java
with Apache License 2.0
from langtianya

// SPR-13318
@Test
public void writeSubTypeList() throws Exception {
    MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
    List<MyBean> beans = new ArrayList<MyBean>();
    MyBean foo = new MyBean();
    foo.setString("Foo");
    foo.setNumber(42);
    beans.add(foo);
    MyBean bar = new MyBean();
    bar.setString("Bar");
    bar.setNumber(123);
    beans.add(bar);
    ParameterizedTypeReference<List<MyInterface>> typeReference = new ParameterizedTypeReference<List<MyInterface>>() {
    };
    this.converter.writeInternal(beans, typeReference.getType(), outputMessage);
    String result = outputMessage.getBodyreplacedtring(Charset.forName("UTF-8"));
    replacedertTrue(result.contains("\"string\":\"Foo\""));
    replacedertTrue(result.contains("\"number\":42"));
    replacedertTrue(result.contains("\"string\":\"Bar\""));
    replacedertTrue(result.contains("\"number\":123"));
}

19 Source : WebReactiveHttpClient.java
with Apache License 2.0
from kptfh

public static WebReactiveHttpClient webClient(MethodMetadata methodMetadata, WebClient webClient) {
    final Type returnType = methodMetadata.returnType();
    Type returnPublisherType = ((ParameterizedType) returnType).getRawType();
    ParameterizedTypeReference<Object> returnActualType = ParameterizedTypeReference.forType(resolveLastTypeParameter(returnType, (Clreplaced<?>) returnPublisherType));
    ParameterizedTypeReference<Object> bodyActualType = ofNullable(getBodyActualType(methodMetadata.bodyType())).map(type -> ParameterizedTypeReference.forType(type)).orElse(null);
    return new WebReactiveHttpClient(webClient, bodyActualType, returnPublisherType, returnActualType);
}

19 Source : EdgeTemplate.java
with MIT License
from kingbbode

@Async
public void writeFeed(String message, String room) {
    ParameterizedTypeReference<MessageResponse> p = new ParameterizedTypeReference<MessageResponse>() {
    };
    post(Api.FEED_WRITE.getUrl() + (botProperties.isTestMode() ? teamUpProperties.getTestFeed() : room), new MessageRequest(message), p);
}

19 Source : EdgeTemplate.java
with MIT License
from kingbbode

@Async
public void sendMessage(String message, String room) {
    if (!room.equals("999999999999") && !StringUtils.isEmpty(message)) {
        ParameterizedTypeReference<MessageResponse> p = new ParameterizedTypeReference<MessageResponse>() {
        };
        post(Api.MESSAGE_SEND.getUrl() + (botProperties.isTestMode() ? teamUpProperties.getTestRoom() : room), new MessageRequest(message), p);
    }
}

19 Source : EdgeTemplate.java
with MIT License
from kingbbode

public FeedGroupsResponse readFeedGroupList() {
    ParameterizedTypeReference<FeedGroupsResponse> p = new ParameterizedTypeReference<FeedGroupsResponse>() {
    };
    return get(Api.FEED_LIST.getUrl(), p);
}

19 Source : EdgeTemplate.java
with MIT License
from kingbbode

@Async
public RoomCreateResponse openRoom(String userId) {
    ParameterizedTypeReference<RoomCreateResponse> p = new ParameterizedTypeReference<RoomCreateResponse>() {
    };
    return post(Api.ROOM.getUrl() + "1", new RoomCreateRequest(new int[] { Integer.parseInt(botProperties.isTestMode() ? teamUpProperties.getTestUser() : userId) }), p);
}

19 Source : EdgeTemplate.java
with MIT License
from kingbbode

@Async
public void sendImage(String fileId, String room) {
    if (!room.equals("999999999999") && !StringUtils.isEmpty(fileId)) {
        ParameterizedTypeReference<MessageResponse> p = new ParameterizedTypeReference<MessageResponse>() {
        };
        post(Api.MESSAGE_SEND.getUrl() + (botProperties.isTestMode() ? teamUpProperties.getTestRoom() : room) + "/2", new MessageRequest(fileId), p);
    }
}

19 Source : EdgeTemplate.java
with MIT License
from kingbbode

@Async
public MessageResponse readMessage(String message, String room) {
    ParameterizedTypeReference<MessageResponse> p = new ParameterizedTypeReference<MessageResponse>() {
    };
    return get(Api.MESSAGE_READ.getUrl() + room + "/1/0/" + message, p);
}

19 Source : EdgeTemplate.java
with MIT License
from kingbbode

public void outRoom(String room) {
    if (!room.equals("999999999999") && !StringUtils.isEmpty(room)) {
        ParameterizedTypeReference<MessageResponse> p = new ParameterizedTypeReference<MessageResponse>() {
        };
        delete(Api.ROOM.getUrl() + "/" + room + "/" + System.currentTimeMillis() + room, null, p);
    }
}

19 Source : AuthTemplate.java
with MIT License
from kingbbode

public OrganigrammeResponse readOrganigramme() {
    ParameterizedTypeReference<OrganigrammeResponse> p = new ParameterizedTypeReference<OrganigrammeResponse>() {
    };
    return get(Api.AUTH_ORGANIGRAMME.getUrl() + "1/all", p);
}

19 Source : AuthTemplate.java
with MIT License
from kingbbode

public RoomInfoResponse getMembersInRoom(String room) {
    ParameterizedTypeReference<RoomInfoResponse> r = new ParameterizedTypeReference<RoomInfoResponse>() {
    };
    return get(Api.ROOM.getUrl() + room, r);
}

19 Source : MessagingController.java
with Apache License 2.0
from jzheaux

private List<User> getUsers(OAuth2AuthorizedClient messagingClient) {
    ParameterizedTypeReference<List<User>> typeRef = new ParameterizedTypeReference<List<User>>() {
    };
    return this.webClient.get().uri(this.contactsBaseUri).attributes(oauth2AuthorizedClient(messagingClient)).retrieve().bodyToMono(typeRef).block();
}

19 Source : MessagingController.java
with Apache License 2.0
from jzheaux

private List<Message> getMessages(OAuth2AuthorizedClient messagingClient, String messagesUri) {
    ParameterizedTypeReference<List<Message>> typeRef = new ParameterizedTypeReference<List<Message>>() {
    };
    return this.webClient.get().uri(messagesUri).attributes(oauth2AuthorizedClient(messagingClient)).retrieve().bodyToMono(typeRef).block();
}

19 Source : CustomerClient.java
with Apache License 2.0
from joshlong

public Collection<Customer> getCustomers() {
    ParameterizedTypeReference<Collection<Customer>> ptr = new ParameterizedTypeReference<Collection<Customer>>() {
    };
    return restTemplate.exchange(this.uri + "/customers", GET, null, ptr).getBody();
}

19 Source : ApiSync.java
with GNU Affero General Public License v3.0
from jasonaowen

private List<RecurseProfile> fetchProfiles() {
    RestTemplate client = new RestTemplate();
    HttpEnreplacedy<String> enreplacedy = getAuthHeader();
    final ParameterizedTypeReference<List<RecurseProfile>> responseType = new ParameterizedTypeReference<>() {
    };
    List<RecurseProfile> profiles = new ArrayList<>();
    int offset = 0;
    List<RecurseProfile> page;
    do {
        page = Optional.ofNullable(client.exchange(PROFILES_URL, HttpMethod.GET, enreplacedy, responseType, PROFILES_PAGE_SIZE, offset).getBody()).orElse(Collections.emptyList());
        profiles.addAll(page);
        offset += PROFILES_PAGE_SIZE;
    } while (!page.isEmpty());
    return profiles;
}

19 Source : ThreadRestService.java
with MIT License
from InnovateUKGitHub

public abstract clreplaced ThreadRestService<T> extends BaseRestService {

    private final String baseURL;

    private final ParameterizedTypeReference<List<T>> listType;

    private final Clreplaced<T> type;

    public ThreadRestService(String baseURL, Clreplaced<T> type, ParameterizedTypeReference<List<T>> listType) {
        this.baseURL = baseURL;
        this.type = type;
        this.listType = listType;
    }

    public RestResult<List<T>> findAll(final Long contextClreplacedId) {
        return getWithRestResult(baseURL + "/all/" + contextClreplacedId, listType);
    }

    public RestResult<T> findOne(final Long id) {
        return getWithRestResult(baseURL + "/" + id, type);
    }

    public RestResult<Long> create(T thread) {
        return postWithRestResult(baseURL, thread, Long.clreplaced);
    }

    public RestResult<Void> addPost(PostResource post, Long threadId) {
        return postWithRestResult(baseURL + "/" + threadId + "/post", post, Void.clreplaced);
    }

    public RestResult<Void> close(Long threadId) {
        return postWithRestResult((baseURL + "/thread/" + threadId + "/close"));
    }
}

19 Source : ReactiveCloudFoundrySecurityService.java
with Apache License 2.0
from hello-shf

/**
 * Reactive Cloud Foundry security service to handle REST calls to the cloud controller
 * and UAA.
 *
 * @author Madhura Bhave
 */
clreplaced ReactiveCloudFoundrySecurityService {

    private static final ParameterizedTypeReference<Map<String, Object>> STRING_OBJECT_MAP = new ParameterizedTypeReference<Map<String, Object>>() {
    };

    private final WebClient webClient;

    private final String cloudControllerUrl;

    private Mono<String> uaaUrl;

    ReactiveCloudFoundrySecurityService(WebClient.Builder webClientBuilder, String cloudControllerUrl, boolean skipSslValidation) {
        replacedert.notNull(webClientBuilder, "Webclient must not be null");
        replacedert.notNull(cloudControllerUrl, "CloudControllerUrl must not be null");
        if (skipSslValidation) {
            webClientBuilder.clientConnector(buildTrustAllSslConnector());
        }
        this.webClient = webClientBuilder.build();
        this.cloudControllerUrl = cloudControllerUrl;
    }

    protected ReactorClientHttpConnector buildTrustAllSslConnector() {
        return new ReactorClientHttpConnector((options) -> options.sslSupport((sslContextBuilder) -> sslContextBuilder.sslProvider(SslProvider.JDK).trustManager(InsecureTrustManagerFactory.INSTANCE)));
    }

    /**
     * Return a Mono of the access level that should be granted to the given token.
     *
     * @param token         the token
     * @param applicationId the cloud foundry application ID
     * @return a Mono of the access level that should be granted
     * @throws CloudFoundryAuthorizationException if the token is not authorized
     */
    public Mono<AccessLevel> getAccessLevel(String token, String applicationId) throws CloudFoundryAuthorizationException {
        String uri = getPermissionsUri(applicationId);
        return this.webClient.get().uri(uri).header("Authorization", "bearer " + token).retrieve().bodyToMono(Map.clreplaced).map(this::getAccessLevel).onErrorMap(this::mapError);
    }

    private Throwable mapError(Throwable throwable) {
        if (throwable instanceof WebClientResponseException) {
            HttpStatus statusCode = ((WebClientResponseException) throwable).getStatusCode();
            if (statusCode.equals(HttpStatus.FORBIDDEN)) {
                return new CloudFoundryAuthorizationException(Reason.ACCESS_DENIED, "Access denied");
            }
            if (statusCode.is4xxClientError()) {
                return new CloudFoundryAuthorizationException(Reason.INVALID_TOKEN, "Invalid token", throwable);
            }
        }
        return new CloudFoundryAuthorizationException(Reason.SERVICE_UNAVAILABLE, "Cloud controller not reachable");
    }

    private AccessLevel getAccessLevel(Map<?, ?> body) {
        if (Boolean.TRUE.equals(body.get("read_sensitive_data"))) {
            return AccessLevel.FULL;
        }
        return AccessLevel.RESTRICTED;
    }

    private String getPermissionsUri(String applicationId) {
        return this.cloudControllerUrl + "/v2/apps/" + applicationId + "/permissions";
    }

    /**
     * Return a Mono of all token keys known by the UAA.
     *
     * @return a Mono of token keys
     */
    public Mono<Map<String, String>> fetchTokenKeys() {
        return getUaaUrl().flatMap(this::fetchTokenKeys);
    }

    private Mono<? extends Map<String, String>> fetchTokenKeys(String url) {
        RequestHeadersSpec<?> uri = this.webClient.get().uri(url + "/token_keys");
        return uri.retrieve().bodyToMono(STRING_OBJECT_MAP).map(this::extractTokenKeys).onErrorMap(((ex) -> new CloudFoundryAuthorizationException(Reason.SERVICE_UNAVAILABLE, ex.getMessage())));
    }

    private Map<String, String> extractTokenKeys(Map<String, Object> response) {
        Map<String, String> tokenKeys = new HashMap<>();
        for (Object key : (List<?>) response.get("keys")) {
            Map<?, ?> tokenKey = (Map<?, ?>) key;
            tokenKeys.put((String) tokenKey.get("kid"), (String) tokenKey.get("value"));
        }
        return tokenKeys;
    }

    /**
     * Return a Mono of URL of the UAA.
     *
     * @return the UAA url Mono
     */
    public Mono<String> getUaaUrl() {
        this.uaaUrl = this.webClient.get().uri(this.cloudControllerUrl + "/info").retrieve().bodyToMono(Map.clreplaced).map((response) -> (String) response.get("token_endpoint")).cache().onErrorMap((ex) -> new CloudFoundryAuthorizationException(Reason.SERVICE_UNAVAILABLE, "Unable to fetch token keys from UAA."));
        return this.uaaUrl;
    }
}

19 Source : TacoCloudClient.java
with Apache License 2.0
from habuma

// 
// Traverson with RestTemplate examples
// 
public Iterable<Ingredient> getAllIngredientsWithTraverson() {
    ParameterizedTypeReference<Resources<Ingredient>> ingredientType = new ParameterizedTypeReference<Resources<Ingredient>>() {
    };
    Resources<Ingredient> ingredientRes = traverson.follow("ingredients").toObject(ingredientType);
    return ingredientRes.getContent();
}

19 Source : TacoCloudClient.java
with Apache License 2.0
from habuma

// 
// Traverson with RestTemplate examples
// 
public Iterable<Ingredient> getAllIngredientsWithTraverson() {
    ParameterizedTypeReference<Resources<Ingredient>> ingredientType = new ParameterizedTypeReference<Resources<Ingredient>>() {
    };
    Resources<Ingredient> ingredientRes = traverson.follow("ingredients").toObject(ingredientType);
    Collection<Ingredient> ingredients = ingredientRes.getContent();
    return ingredients;
}

19 Source : TacoCloudClient.java
with Apache License 2.0
from habuma

public Iterable<Taco> getRecentTacosWithTraverson() {
    ParameterizedTypeReference<Resources<Taco>> tacoType = new ParameterizedTypeReference<Resources<Taco>>() {
    };
    Resources<Taco> tacoRes = traverson.follow("tacos").follow("recents").toObject(tacoType);
    // Alternatively, list the two paths in the same call to follow()
    // Resources<Taco> tacoRes =
    // traverson
    // .follow("tacos", "recents")
    // .toObject(tacoType);
    return tacoRes.getContent();
}

19 Source : SpringRestTemplateEntityLoader.java
with Apache License 2.0
from fangjinuo

@Override
protected List<Object> loadInternal(AuditRequest request, ResourceDefinition resourceDefinition, List<Serializable> parreplacedionIds) {
    final List<Object> enreplacedies = Collects.emptyArrayList();
    String url = findHttpUrl(resourceDefinition);
    url = replaceAuditVariables(url, resourceDefinition, parreplacedionIds);
    Map<String, Object> urlVariables = findSpringRestUrlVariables(url, resourceDefinition, parreplacedionIds);
    HttpMethod httpMethod = findHttpMethod(resourceDefinition);
    HttpEnreplacedy httpEnreplacedy = httpRequestProvider.get(url, httpMethod, resourceDefinition, parreplacedionIds);
    ParameterizedTypeReference responseEnreplacedyClreplaced = parameterizedResponseClreplacedProvider.get(url, httpMethod, resourceDefinition);
    RestTemplate restTemplate = restTemplateProvider.get(url, httpMethod, resourceDefinition);
    Preconditions.checkNotNull(restTemplate, "the restTemplate is null");
    ResponseEnreplacedy responseEnreplacedy = restTemplate.exchange(url, httpMethod, httpEnreplacedy, responseEnreplacedyClreplaced, urlVariables);
    List<Object> objs = extractResult(responseEnreplacedy);
    enreplacedies.addAll(objs);
    return enreplacedies;
}

19 Source : List_POST.java
with MIT License
from FAIRDataTeam

@Test
@DisplayName("HTTP 200")
public void res200() {
    // GIVEN:
    RequestEnreplacedy<UserCreateDTO> request = RequestEnreplacedy.post(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).body(reqDto());
    ParameterizedTypeReference<UserDTO> responseType = new ParameterizedTypeReference<>() {
    };
    // WHEN:
    ResponseEnreplacedy<UserDTO> result = client.exchange(request, responseType);
    // THEN:
    replacedertThat(result.getStatusCode(), is(equalTo(HttpStatus.OK)));
    Common.compare(reqDto(), result.getBody());
}

19 Source : List_POST.java
with MIT License
from FAIRDataTeam

@Test
@DisplayName("HTTP 200")
public void res200() {
    // GIVEN: Prepare data
    Shape shape = shapeFixtures.customShape();
    ShapeChangeDTO reqDto = reqDto(shape);
    // AND: Prepare request
    RequestEnreplacedy<ShapeChangeDTO> request = RequestEnreplacedy.post(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).body(reqDto);
    ParameterizedTypeReference<ShapeDTO> responseType = new ParameterizedTypeReference<>() {
    };
    // WHEN:
    ResponseEnreplacedy<ShapeDTO> result = client.exchange(request, responseType);
    // THEN:
    replacedertThat(result.getStatusCode(), is(equalTo(HttpStatus.OK)));
    Common.compare(reqDto, result.getBody());
}

19 Source : Detail_PUT.java
with MIT License
from FAIRDataTeam

@Test
@DisplayName("HTTP 200")
public void res200() {
    // GIVEN: Prepare data
    Shape shape = shapeFixtures.customShapeEdited();
    ShapeChangeDTO reqDto = reqDto(shape);
    // AND: Prepare request
    RequestEnreplacedy<ShapeChangeDTO> request = RequestEnreplacedy.put(url(shape.getUuid())).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).body(reqDto);
    ParameterizedTypeReference<ShapeDTO> responseType = new ParameterizedTypeReference<>() {
    };
    // AND: Prepare DB
    shapeRepository.save(shape);
    // WHEN:
    ResponseEnreplacedy<ShapeDTO> result = client.exchange(request, responseType);
    // THEN:
    replacedertThat(result.getStatusCode(), is(equalTo(HttpStatus.OK)));
    Common.compare(reqDto, result.getBody());
}

19 Source : Detail_PUT.java
with MIT License
from FAIRDataTeam

@Test
@DisplayName("HTTP 400: Edit INTERNAL shape")
public void res400() {
    // GIVEN:
    Shape shape = shapeFixtures.repositoryShape();
    ShapeChangeDTO reqDto = reqDto(shape);
    RequestEnreplacedy<ShapeChangeDTO> request = RequestEnreplacedy.put(url(shape.getUuid())).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).body(reqDto);
    ParameterizedTypeReference<ErrorDTO> responseType = new ParameterizedTypeReference<>() {
    };
    // WHEN:
    ResponseEnreplacedy<ErrorDTO> result = client.exchange(request, responseType);
    // THEN:
    replacedertThat(result.getStatusCode(), is(equalTo(HttpStatus.BAD_REQUEST)));
}

19 Source : List_POST.java
with MIT License
from FAIRDataTeam

@Test
@DisplayName("HTTP 200")
public void res200() {
    // GIVEN: Prepare data
    ResourceDefinition resourceDefinition = resourceDefinitionFixtures.ontologyDefinition();
    ResourceDefinitionChangeDTO reqDto = reqDto(resourceDefinition);
    // AND: Prepare request
    RequestEnreplacedy<ResourceDefinitionChangeDTO> request = RequestEnreplacedy.post(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).body(reqDto);
    ParameterizedTypeReference<ResourceDefinition> responseType = new ParameterizedTypeReference<>() {
    };
    // WHEN:
    ResponseEnreplacedy<ResourceDefinition> result = client.exchange(request, responseType);
    // THEN:
    replacedertThat(result.getStatusCode(), is(equalTo(HttpStatus.OK)));
    replacedertThat(result.getBody().getName(), is(equalTo(reqDto.getName())));
}

19 Source : Detail_PUT.java
with MIT License
from FAIRDataTeam

@Test
@DisplayName("HTTP 200")
public void res200() {
    // GIVEN: Prepare data
    ResourceDefinition resourceDefinition = resourceDefinitionFixtures.catalogDefinition();
    ResourceDefinitionChangeDTO reqDto = reqDto(resourceDefinition);
    // AND: Prepare request
    RequestEnreplacedy<ResourceDefinitionChangeDTO> request = RequestEnreplacedy.put(url(resourceDefinition.getUuid())).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).body(reqDto);
    ParameterizedTypeReference<ResourceDefinition> responseType = new ParameterizedTypeReference<>() {
    };
    // WHEN:
    ResponseEnreplacedy<ResourceDefinition> result = client.exchange(request, responseType);
    // THEN:
    replacedertThat(result.getStatusCode(), is(equalTo(HttpStatus.OK)));
    replacedertThat(result.getBody().getName(), is(equalTo(reqDto.getName())));
    replacedertThat(result.getBody().getUrlPrefix(), is(equalTo(reqDto.getUrlPrefix())));
}

19 Source : List_PUT.java
with MIT License
from FAIRDataTeam

@DisplayName("PUT /index/settings")
public clreplaced List_PUT extends WebIntegrationTest {

    @Autowired
    private IndexSettingsRepository indexSettingsRepository;

    private final ParameterizedTypeReference<IndexSettingsDTO> responseType = new ParameterizedTypeReference<>() {
    };

    private URI url() {
        return URI.create("/index/settings");
    }

    private IndexSettings customSettings1() {
        return new IndexSettings().toBuilder().ping(new IndexSettingsPing().toBuilder().denyList(Collections.singletonList("http://localhost.*$")).rateLimitDuration(Duration.ofMinutes(17)).validDuration(Duration.ofDays(5)).rateLimitHits(666).build()).retrieval(new IndexSettingsRetrieval().toBuilder().rateLimitWait(Duration.ofHours(16)).timeout(Duration.ofSeconds(55)).build()).build();
    }

    private IndexSettings customSettings2() {
        IndexSettings settings = customSettings1();
        settings.getPing().setValidDuration(Duration.ofDays(14));
        settings.getRetrieval().setTimeout(Duration.ofMinutes(2));
        return settings;
    }

    private IndexSettingsUpdateDTO customSettingsUpdateDTO() {
        IndexSettings customSettings = customSettings1();
        IndexSettingsUpdateDTO dto = new IndexSettingsUpdateDTO();
        IndexSettingsPingDTO pingDTO = new IndexSettingsPingDTO();
        pingDTO.setDenyList(customSettings.getPing().getDenyList());
        pingDTO.setRateLimitDuration(customSettings.getPing().getRateLimitDuration().toString());
        pingDTO.setValidDuration(customSettings.getPing().getValidDuration().toString());
        pingDTO.setRateLimitHits(customSettings.getPing().getRateLimitHits());
        dto.setPing(pingDTO);
        IndexSettingsRetrievalDTO retrievalDTO = new IndexSettingsRetrievalDTO();
        retrievalDTO.setRateLimitWait(customSettings.getRetrieval().getRateLimitWait().toString());
        retrievalDTO.setTimeout(customSettings.getRetrieval().getTimeout().toString());
        dto.setRetrieval(retrievalDTO);
        return dto;
    }

    private IndexSettingsUpdateDTO invalidUpdateDTO1() {
        IndexSettingsUpdateDTO dto = customSettingsUpdateDTO();
        dto.getPing().setValidDuration("666");
        return dto;
    }

    private IndexSettingsUpdateDTO invalidUpdateDTO2() {
        IndexSettingsUpdateDTO dto = customSettingsUpdateDTO();
        dto.getPing().setDenyList(null);
        return dto;
    }

    @Test
    @DisplayName("HTTP 200: update settings from defaults")
    public void res200_updateSettingsFromDefaults() {
        // GIVEN: prepare data
        IndexSettings settings = customSettings1();
        indexSettingsRepository.deleteAll();
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.put(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).body(customSettingsUpdateDTO());
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("Settings are created", indexSettingsRepository.findAll().size(), is(equalTo(1)));
        replacedertThat("Correct response code is received", result.getStatusCode(), is(equalTo(HttpStatus.OK)));
        replacedertThat("Response body is not null", result.getBody(), is(notNullValue()));
        replacedertThat("Response contains default valid duration", Objects.requireNonNull(result.getBody()).getPing().getValidDuration(), is(equalTo(settings.getPing().getValidDuration().toString())));
        replacedertThat("Response contains default rate limit duration", Objects.requireNonNull(result.getBody()).getPing().getRateLimitDuration(), is(equalTo(settings.getPing().getRateLimitDuration().toString())));
        replacedertThat("Response contains default rate limit hits", Objects.requireNonNull(result.getBody()).getPing().getRateLimitHits(), is(equalTo(settings.getPing().getRateLimitHits())));
        replacedertThat("Response contains default deny list", Objects.requireNonNull(result.getBody()).getPing().getDenyList(), is(equalTo(settings.getPing().getDenyList())));
        replacedertThat("Response contains default timeout", Objects.requireNonNull(result.getBody()).getRetrieval().getTimeout(), is(equalTo(settings.getRetrieval().getTimeout().toString())));
        replacedertThat("Response contains default rate limit wait", Objects.requireNonNull(result.getBody()).getRetrieval().getRateLimitWait(), is(equalTo(settings.getRetrieval().getRateLimitWait().toString())));
    }

    @Test
    @DisplayName("HTTP 200: update settings from custom")
    public void res200_updateSettingsFromCustom() {
        // GIVEN: prepare data
        IndexSettingsUpdateDTO reqDTO = customSettingsUpdateDTO();
        IndexSettings settings = customSettings1();
        indexSettingsRepository.deleteAll();
        indexSettingsRepository.insert(customSettings2());
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.put(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).body(reqDTO);
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("Settings are created", indexSettingsRepository.findAll().size(), is(equalTo(1)));
        replacedertThat("Correct response code is received", result.getStatusCode(), is(equalTo(HttpStatus.OK)));
        replacedertThat("Response body is not null", result.getBody(), is(notNullValue()));
        replacedertThat("Response contains default valid duration", Objects.requireNonNull(result.getBody()).getPing().getValidDuration(), is(equalTo(settings.getPing().getValidDuration().toString())));
        replacedertThat("Response contains default rate limit duration", Objects.requireNonNull(result.getBody()).getPing().getRateLimitDuration(), is(equalTo(settings.getPing().getRateLimitDuration().toString())));
        replacedertThat("Response contains default rate limit hits", Objects.requireNonNull(result.getBody()).getPing().getRateLimitHits(), is(equalTo(settings.getPing().getRateLimitHits())));
        replacedertThat("Response contains default deny list", Objects.requireNonNull(result.getBody()).getPing().getDenyList(), is(equalTo(settings.getPing().getDenyList())));
        replacedertThat("Response contains default timeout", Objects.requireNonNull(result.getBody()).getRetrieval().getTimeout(), is(equalTo(settings.getRetrieval().getTimeout().toString())));
        replacedertThat("Response contains default rate limit wait", Objects.requireNonNull(result.getBody()).getRetrieval().getRateLimitWait(), is(equalTo(settings.getRetrieval().getRateLimitWait().toString())));
    }

    @Test
    @DisplayName("HTTP 400: invalid duration format")
    public void res400_invalidDurationFormat() {
        // GIVEN: prepare data
        IndexSettingsUpdateDTO reqDTO = invalidUpdateDTO1();
        indexSettingsRepository.deleteAll();
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.put(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).body(reqDTO);
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It indicates bad request", result.getStatusCode(), is(equalTo(HttpStatus.BAD_REQUEST)));
        replacedertThat("No settings are created", indexSettingsRepository.findAll().size(), is(equalTo(0)));
    }

    @Test
    @DisplayName("HTTP 400: invalid list")
    public void res400_invalidList() {
        // GIVEN: prepare data
        IndexSettingsUpdateDTO reqDTO = invalidUpdateDTO2();
        indexSettingsRepository.deleteAll();
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.put(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).body(reqDTO);
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It indicates bad request", result.getStatusCode(), is(equalTo(HttpStatus.BAD_REQUEST)));
        replacedertThat("No settings are created", indexSettingsRepository.findAll().size(), is(equalTo(0)));
    }

    @Test
    @DisplayName("HTTP 403: no token")
    public void res403_noToken() {
        // GIVEN: prepare data
        IndexSettingsUpdateDTO reqDTO = customSettingsUpdateDTO();
        indexSettingsRepository.deleteAll();
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.put(url()).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).body(reqDTO);
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It is forbidden without auth", result.getStatusCode(), is(equalTo(HttpStatus.FORBIDDEN)));
        replacedertThat("No settings are created", indexSettingsRepository.findAll().size(), is(equalTo(0)));
    }

    @Test
    @DisplayName("HTTP 403: not admin")
    public void res403_notAdmin() {
        // GIVEN: prepare data
        IndexSettingsUpdateDTO reqDTO = customSettingsUpdateDTO();
        indexSettingsRepository.deleteAll();
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.put(url()).header(HttpHeaders.AUTHORIZATION, NIKOLA_TOKEN).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).body(reqDTO);
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It is forbidden for non-admin users", result.getStatusCode(), is(equalTo(HttpStatus.FORBIDDEN)));
        replacedertThat("No settings are created", indexSettingsRepository.findAll().size(), is(equalTo(0)));
    }
}

19 Source : List_GET.java
with MIT License
from FAIRDataTeam

@DisplayName("GET /index/settings")
public clreplaced List_GET extends WebIntegrationTest {

    @Autowired
    private IndexSettingsRepository indexSettingsRepository;

    private final ParameterizedTypeReference<IndexSettingsDTO> responseType = new ParameterizedTypeReference<>() {
    };

    private URI url() {
        return URI.create("/index/settings");
    }

    private IndexSettings customSettings() {
        return new IndexSettings().toBuilder().ping(new IndexSettingsPing().toBuilder().denyList(Collections.singletonList("http://localhost.*$")).rateLimitDuration(Duration.ofMinutes(17)).validDuration(Duration.ofDays(5)).rateLimitHits(666).build()).retrieval(new IndexSettingsRetrieval().toBuilder().rateLimitWait(Duration.ofHours(16)).timeout(Duration.ofSeconds(55)).build()).build();
    }

    @Test
    @DisplayName("HTTP 200: default settings")
    public void res200_defaultSettings() {
        // GIVEN: prepare data
        IndexSettings settings = IndexSettings.getDefault();
        indexSettingsRepository.deleteAll();
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.get(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("No settings are created", indexSettingsRepository.findAll().size(), is(equalTo(0)));
        replacedertThat("Correct response code is received", result.getStatusCode(), is(equalTo(HttpStatus.OK)));
        replacedertThat("Response body is not null", result.getBody(), is(notNullValue()));
        replacedertThat("Response contains default valid duration", Objects.requireNonNull(result.getBody()).getPing().getValidDuration(), is(equalTo(settings.getPing().getValidDuration().toString())));
        replacedertThat("Response contains default rate limit duration", Objects.requireNonNull(result.getBody()).getPing().getRateLimitDuration(), is(equalTo(settings.getPing().getRateLimitDuration().toString())));
        replacedertThat("Response contains default rate limit hits", Objects.requireNonNull(result.getBody()).getPing().getRateLimitHits(), is(equalTo(settings.getPing().getRateLimitHits())));
        replacedertThat("Response contains default deny list", Objects.requireNonNull(result.getBody()).getPing().getDenyList(), is(equalTo(settings.getPing().getDenyList())));
        replacedertThat("Response contains default timeout", Objects.requireNonNull(result.getBody()).getRetrieval().getTimeout(), is(equalTo(settings.getRetrieval().getTimeout().toString())));
        replacedertThat("Response contains default rate limit wait", Objects.requireNonNull(result.getBody()).getRetrieval().getRateLimitWait(), is(equalTo(settings.getRetrieval().getRateLimitWait().toString())));
        replacedertThat("Response indicated default settings", Objects.requireNonNull(result.getBody()).getIsDefault(), is(Boolean.TRUE));
    }

    @Test
    @DisplayName("HTTP 200: custom settings")
    public void res200_customSettings() {
        // GIVEN: prepare data
        IndexSettings settings = customSettings();
        indexSettingsRepository.deleteAll();
        indexSettingsRepository.insert(settings);
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.get(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("No settings are created", indexSettingsRepository.findAll().size(), is(equalTo(1)));
        replacedertThat("Correct response code is received", result.getStatusCode(), is(equalTo(HttpStatus.OK)));
        replacedertThat("Response body is not null", result.getBody(), is(notNullValue()));
        replacedertThat("Response contains custom valid duration", Objects.requireNonNull(result.getBody()).getPing().getValidDuration(), is(equalTo(settings.getPing().getValidDuration().toString())));
        replacedertThat("Response contains custom rate limit duration", Objects.requireNonNull(result.getBody()).getPing().getRateLimitDuration(), is(equalTo(settings.getPing().getRateLimitDuration().toString())));
        replacedertThat("Response contains custom rate limit hits", Objects.requireNonNull(result.getBody()).getPing().getRateLimitHits(), is(equalTo(settings.getPing().getRateLimitHits())));
        replacedertThat("Response contains custom deny list", Objects.requireNonNull(result.getBody()).getPing().getDenyList(), is(equalTo(settings.getPing().getDenyList())));
        replacedertThat("Response contains custom timeout", Objects.requireNonNull(result.getBody()).getRetrieval().getTimeout(), is(equalTo(settings.getRetrieval().getTimeout().toString())));
        replacedertThat("Response contains custom rate limit wait", Objects.requireNonNull(result.getBody()).getRetrieval().getRateLimitWait(), is(equalTo(settings.getRetrieval().getRateLimitWait().toString())));
        replacedertThat("Response indicated non-default settings", Objects.requireNonNull(result.getBody()).getIsDefault(), is(Boolean.FALSE));
    }

    @Test
    @DisplayName("HTTP 403: no token")
    public void res403_noToken() {
        // GIVEN
        RequestEnreplacedy<?> request = RequestEnreplacedy.get(url()).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It is forbidden without auth", result.getStatusCode(), is(equalTo(HttpStatus.FORBIDDEN)));
    }

    @Test
    @DisplayName("HTTP 403: not admin")
    public void res403_notAdmin() {
        // GIVEN
        RequestEnreplacedy<?> request = RequestEnreplacedy.get(url()).header(HttpHeaders.AUTHORIZATION, NIKOLA_TOKEN).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It is forbidden for non-admin users", result.getStatusCode(), is(equalTo(HttpStatus.FORBIDDEN)));
    }
}

19 Source : List_DELETE.java
with MIT License
from FAIRDataTeam

@DisplayName("DELETE /index/settings")
public clreplaced List_DELETE extends WebIntegrationTest {

    @Autowired
    private IndexSettingsRepository indexSettingsRepository;

    private final ParameterizedTypeReference<IndexSettingsDTO> responseType = new ParameterizedTypeReference<>() {
    };

    private URI url() {
        return URI.create("/index/settings");
    }

    private IndexSettings customSettings() {
        return new IndexSettings().toBuilder().ping(new IndexSettingsPing().toBuilder().denyList(Collections.singletonList("http://localhost.*$")).rateLimitDuration(Duration.ofMinutes(17)).validDuration(Duration.ofDays(5)).rateLimitHits(666).build()).retrieval(new IndexSettingsRetrieval().toBuilder().rateLimitWait(Duration.ofHours(16)).timeout(Duration.ofSeconds(55)).build()).build();
    }

    @Test
    @DisplayName("HTTP 200: default settings")
    public void res200_defaultSettings() {
        // GIVEN: prepare data
        IndexSettings settings = IndexSettings.getDefault();
        indexSettingsRepository.deleteAll();
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.delete(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("Correct response code is received", result.getStatusCode(), is(equalTo(HttpStatus.OK)));
        replacedertThat("Response body is not null", result.getBody(), is(notNullValue()));
        replacedertThat("Response contains default valid duration", Objects.requireNonNull(result.getBody()).getPing().getValidDuration(), is(equalTo(settings.getPing().getValidDuration().toString())));
        replacedertThat("Response contains default rate limit duration", Objects.requireNonNull(result.getBody()).getPing().getRateLimitDuration(), is(equalTo(settings.getPing().getRateLimitDuration().toString())));
        replacedertThat("Response contains default rate limit hits", Objects.requireNonNull(result.getBody()).getPing().getRateLimitHits(), is(equalTo(settings.getPing().getRateLimitHits())));
        replacedertThat("Response contains default deny list", Objects.requireNonNull(result.getBody()).getPing().getDenyList(), is(equalTo(settings.getPing().getDenyList())));
        replacedertThat("Response contains default timeout", Objects.requireNonNull(result.getBody()).getRetrieval().getTimeout(), is(equalTo(settings.getRetrieval().getTimeout().toString())));
        replacedertThat("Response contains default rate limit wait", Objects.requireNonNull(result.getBody()).getRetrieval().getRateLimitWait(), is(equalTo(settings.getRetrieval().getRateLimitWait().toString())));
        replacedertThat("Response indicated default settings", Objects.requireNonNull(result.getBody()).getIsDefault(), is(Boolean.TRUE));
    }

    @Test
    @DisplayName("HTTP 200: custom settings")
    public void res200_customSettings() {
        // GIVEN: prepare data
        IndexSettings settings = IndexSettings.getDefault();
        IndexSettings customSettings = customSettings();
        indexSettingsRepository.deleteAll();
        indexSettingsRepository.insert(customSettings);
        // AND: prepare request
        RequestEnreplacedy<?> request = RequestEnreplacedy.delete(url()).header(HttpHeaders.AUTHORIZATION, ADMIN_TOKEN).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("Correct response code is received", result.getStatusCode(), is(equalTo(HttpStatus.OK)));
        replacedertThat("Response body is not null", result.getBody(), is(notNullValue()));
        replacedertThat("Response contains default valid duration", Objects.requireNonNull(result.getBody()).getPing().getValidDuration(), is(equalTo(settings.getPing().getValidDuration().toString())));
        replacedertThat("Response contains default rate limit duration", Objects.requireNonNull(result.getBody()).getPing().getRateLimitDuration(), is(equalTo(settings.getPing().getRateLimitDuration().toString())));
        replacedertThat("Response contains default rate limit hits", Objects.requireNonNull(result.getBody()).getPing().getRateLimitHits(), is(equalTo(settings.getPing().getRateLimitHits())));
        replacedertThat("Response contains default deny list", Objects.requireNonNull(result.getBody()).getPing().getDenyList(), is(equalTo(settings.getPing().getDenyList())));
        replacedertThat("Response contains default timeout", Objects.requireNonNull(result.getBody()).getRetrieval().getTimeout(), is(equalTo(settings.getRetrieval().getTimeout().toString())));
        replacedertThat("Response contains default rate limit wait", Objects.requireNonNull(result.getBody()).getRetrieval().getRateLimitWait(), is(equalTo(settings.getRetrieval().getRateLimitWait().toString())));
        replacedertThat("Response indicated default settings", Objects.requireNonNull(result.getBody()).getIsDefault(), is(Boolean.TRUE));
    }

    @Test
    @DisplayName("HTTP 403: no token")
    public void res403_noToken() {
        // GIVEN
        RequestEnreplacedy<?> request = RequestEnreplacedy.delete(url()).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It is forbidden without auth", result.getStatusCode(), is(equalTo(HttpStatus.FORBIDDEN)));
    }

    @Test
    @DisplayName("HTTP 403: not admin")
    public void res403_notAdmin() {
        // GIVEN
        RequestEnreplacedy<?> request = RequestEnreplacedy.delete(url()).header(HttpHeaders.AUTHORIZATION, NIKOLA_TOKEN).accept(MediaType.APPLICATION_JSON).build();
        // WHEN
        ResponseEnreplacedy<IndexSettingsDTO> result = client.exchange(request, responseType);
        // THEN
        replacedertThat("It is forbidden for non-admin users", result.getStatusCode(), is(equalTo(HttpStatus.FORBIDDEN)));
    }
}

19 Source : JiraRestClient.java
with Apache License 2.0
from Decathlon

/**
 * Get Jira search results from a header and an url
 * @param header the Jira header
 * @param url the Jira REST API url
 * @return the search results containing the issues
 * @throws BadRequestException thrown if (one of) the API call(s) returned an error code
 */
private JiraIssueSearchResults getSearchResultsFromHeaderAndUrl(HttpHeaders header, String url) throws BadRequestException {
    log.info("[Jira] Searching issues... ({})", url);
    HttpEnreplacedy<JiraIssueSearchResults> request = new HttpEnreplacedy<>(header);
    final ParameterizedTypeReference<JiraIssueSearchResults> responseType = new ParameterizedTypeReference<JiraIssueSearchResults>() {
    };
    ResponseEnreplacedy<JiraIssueSearchResults> response = restTemplate.exchange(url, HttpMethod.GET, request, responseType);
    HttpStatus httpStatus = response.getStatusCode();
    Boolean responseIsNotOK = !HttpStatus.OK.equals(httpStatus);
    if (responseIsNotOK) {
        String errorMessage = String.format("[Jira] The Jira request [%s] %s returned an error status code -> %s", HttpMethod.GET, url, httpStatus);
        log.error(errorMessage);
        throw new BadRequestException(errorMessage, Enreplacedies.SETTING, "jira_request_error");
    }
    return response.getBody();
}

19 Source : FluxSinkApplication.java
with MIT License
from daggerok

@Bean
RouterFunction<ServerResponse> routes(final Flux<ServerSentEvent<Map>> processor, final Consumer<String> distributeEvent) {
    final ParameterizedTypeReference<Map<String, String>> type = new ParameterizedTypeReference<Map<String, String>>() {
    };
    return route(GET("/**"), request -> ok().contentType(request.headers().accept().contains(TEXT_EVENT_STREAM) ? TEXT_EVENT_STREAM : APPLICATION_STREAM_JSON).body(processor.map(s -> s), ServerSentEvent.clreplaced)).andRoute(POST("/**"), request -> accepted().body(request.bodyToMono(type).map(map -> map.getOrDefault("message", "")).map(String::valueOf).map(String::trim).filter(s -> s.length() > 0).doOnNext(distributeEvent).map(m -> format("message '%s' accepted.", m)).map(message -> singletonMap("response", message)).subscribeOn(Schedulers.elastic()).flatMap(Mono::just), Map.clreplaced));
}

19 Source : CartController.java
with Apache License 2.0
from cero-t

@RequestMapping(value = "/{cartId}/detail", method = RequestMethod.GET)
public CartDetail findCartDetailById(@PathVariable String cartId) {
    // Create cart
    Cart cart = cartRepository.findOne(cartId);
    if (cart == null) {
        throw new RuntimeException("Cart not found");
    }
    CartDetail cartDetail = new CartDetail();
    cartDetail.cartId = cart.cartId;
    // Find items in cart and convert to map
    String pathKey = cart.items.keySet().stream().map(id -> id.toString()).collect(Collectors.joining(","));
    ParameterizedTypeReference<List<Item>> type = new ParameterizedTypeReference<List<Item>>() {
    };
    List<Item> items = restTemplate.exchange(ITEM_URL + "/" + pathKey, HttpMethod.GET, null, type).getBody();
    Map<Long, Item> itemMap = items.stream().collect(Collectors.toMap(i -> i.id, i -> i));
    // Resolve cart items
    cartDetail.items = cart.items.entrySet().stream().map(i -> {
        Item item = itemMap.get(i.getKey());
        if (item == null) {
            return null;
        }
        Carreplacedem carreplacedem = new Carreplacedem();
        carreplacedem.itemId = item.id;
        carreplacedem.name = item.name;
        carreplacedem.author = item.author;
        carreplacedem.release = item.release;
        carreplacedem.unitPrice = item.unitPrice;
        carreplacedem.image = item.image;
        carreplacedem.quanreplacedy = i.getValue();
        return carreplacedem;
    }).collect(Collectors.toMap(i -> i.itemId, i -> i));
    // Count amount
    cartDetail.amount = cartDetail.items.values().stream().map(i -> i.unitPrice.multiply(new BigDecimal(i.quanreplacedy))).reduce((b1, b2) -> b1.add(b2)).orElse(BigDecimal.ZERO);
    return cartDetail;
}

19 Source : JaxrsIntegrationTestBase.java
with Apache License 2.0
from apache

@Test
public void ablePostMap() {
    Map<String, User> users = new HashMap<>();
    users.put("user1", userOfNames("name11", "name12"));
    users.put("user2", userOfNames("name21", "name22"));
    ParameterizedTypeReference<Map<String, User>> reference = new ParameterizedTypeReference<Map<String, User>>() {
    };
    for (String url : urls) {
        ResponseEnreplacedy<Map<String, User>> responseEnreplacedy = restTemplate.exchange(url + "testUserMap", POST, jsonRequest(users), reference);
        replacedertThat(responseEnreplacedy.getStatusCode(), is(OK));
        Map<String, User> body = responseEnreplacedy.getBody();
        replacedertArrayEquals(body.get("user1").getNames(), new String[] { "name11", "name12" });
        replacedertArrayEquals(body.get("user2").getNames(), new String[] { "name21", "name22" });
    }
}

19 Source : TicketControllerIT.java
with MIT License
from AlicanAkkus

@IT
public clreplaced TicketControllerIT extends Abstracreplaced {

    private final ParameterizedTypeReference<Response<TicketResponse>> responseType = new ParameterizedTypeReference<>() {
    };

    @Test
    void should_buy_ticket() {
        // given
        BuyTicketRequest buyTicketRequest = BuyTicketRequest.builder().count(3).eventId(100L).accountId(2021L).referenceCode("ref2021").build();
        // when
        ResponseEnreplacedy<Response<TicketResponse>> responseEnreplacedy = testRestTemplate.exchange("/api/v1/tickets", HttpMethod.POST, new HttpEnreplacedy(buyTicketRequest), responseType);
        // then
        replacedertThat(responseEnreplacedy).isNotNull();
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        replacedertThat(responseEnreplacedy.getBody().getData().getAccountId()).isEqualTo(2021L);
        replacedertThat(responseEnreplacedy.getBody().getData().getEventId()).isEqualTo(100L);
        replacedertThat(responseEnreplacedy.getBody().getData().getCount()).isEqualTo(3);
        replacedertThat(responseEnreplacedy.getBody().getData().getBoughtDate().toLocalDate()).isToday();
        replacedertThat(responseEnreplacedy.getBody().getData().getPrice()).isEqualTo(new BigDecimal("119.99").multiply(BigDecimal.valueOf(3)));
    }
}

19 Source : InclusiveGatewayAuditProducerIT.java
with Apache License 2.0
from Activiti

private ResponseEnreplacedy<PagedResources<CloudProcessDefinition>> getProcessDefinitions() {
    ParameterizedTypeReference<PagedResources<CloudProcessDefinition>> responseType = new ParameterizedTypeReference<PagedResources<CloudProcessDefinition>>() {
    };
    return restTemplate.exchange(PROCESS_DEFINITIONS_URL, HttpMethod.GET, null, responseType);
}

19 Source : TaskVariablesIT.java
with Apache License 2.0
from Activiti

private ResponseEnreplacedy<PagedResources<CloudProcessDefinition>> getProcessDefinitions() {
    ParameterizedTypeReference<PagedResources<CloudProcessDefinition>> responseType = new ParameterizedTypeReference<PagedResources<CloudProcessDefinition>>() {
    };
    return restTemplate.exchange(ProcessDefinitionIT.PROCESS_DEFINITIONS_URL, HttpMethod.GET, null, responseType);
}

19 Source : TaskRestTemplate.java
with Apache License 2.0
from Activiti

@TestComponent
public clreplaced TaskRestTemplate {

    private static final String TASK_VAR_RELATIVE_URL = "/v1/tasks/";

    private static final String ADMIN_TASK_VAR_RELATIVE_URL = "/admin/v1/tasks/";

    private static final ParameterizedTypeReference<CloudTask> TASK_RESPONSE_TYPE = new ParameterizedTypeReference<CloudTask>() {
    };

    private static final ParameterizedTypeReference<PagedResources<CloudTask>> PAGED_TASKS_RESPONSE_TYPE = new ParameterizedTypeReference<PagedResources<CloudTask>>() {
    };

    private static final ParameterizedTypeReference<Resources<Resource<CandidateUser>>> CANDIDATE_USERS_RESPONSE_TYPE = new ParameterizedTypeReference<Resources<Resource<CandidateUser>>>() {
    };

    private static final ParameterizedTypeReference<Resources<Resource<CandidateGroup>>> CANDIDATES_GROUPS_RESPONSE_TYPE = new ParameterizedTypeReference<Resources<Resource<CandidateGroup>>>() {
    };

    private static final ParameterizedTypeReference<Void> VOID_RESPONSE_TYPE = new ParameterizedTypeReference<Void>() {
    };

    private TestRestTemplate testRestTemplate;

    public TaskRestTemplate(TestRestTemplate testRestTemplate) {
        this.testRestTemplate = testRestTemplate;
    }

    public ResponseEnreplacedy<CloudTask> complete(Task task) {
        return complete(task, null);
    }

    public ResponseEnreplacedy<CloudTask> adminComplete(Task task) {
        return adminComplete(task, null);
    }

    public ResponseEnreplacedy<CloudTask> complete(Task task, CompleteTaskPayload completeTaskPayload) {
        return complete(task, TASK_VAR_RELATIVE_URL, completeTaskPayload);
    }

    public ResponseEnreplacedy<CloudTask> adminComplete(Task task, CompleteTaskPayload completeTaskPayload) {
        return complete(task, ADMIN_TASK_VAR_RELATIVE_URL, completeTaskPayload);
    }

    private ResponseEnreplacedy<CloudTask> complete(Task task, String baseURL, CompleteTaskPayload completeTaskPayload) {
        ResponseEnreplacedy<CloudTask> responseEnreplacedy = testRestTemplate.exchange(baseURL + task.getId() + "/complete", HttpMethod.POST, completeTaskPayload != null ? new HttpEnreplacedy<>(completeTaskPayload) : null, TASK_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCodeValue()).isEqualTo(HttpStatus.OK.value());
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<CloudTask> delete(Task task) {
        return delete(task, TASK_VAR_RELATIVE_URL);
    }

    public ResponseEnreplacedy<CloudTask> adminDelete(Task task) {
        return delete(task, ADMIN_TASK_VAR_RELATIVE_URL);
    }

    private ResponseEnreplacedy<CloudTask> delete(Task task, String taskVarRelativeUrl) {
        ResponseEnreplacedy<CloudTask> responseEnreplacedy = testRestTemplate.exchange(taskVarRelativeUrl + task.getId(), HttpMethod.DELETE, null, TASK_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCodeValue()).isEqualTo(HttpStatus.OK.value());
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<CloudTask> claim(Task task) {
        return claim(task.getId());
    }

    public ResponseEnreplacedy<CloudTask> claim(String taskId) {
        ResponseEnreplacedy<CloudTask> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + taskId + "/claim", HttpMethod.POST, null, TASK_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<CloudTask> release(Task task) {
        return release(task.getId());
    }

    public ResponseEnreplacedy<CloudTask> release(String taskId) {
        ResponseEnreplacedy<CloudTask> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + taskId + "/release", HttpMethod.POST, null, TASK_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<CloudTask> adminreplacedignTask(replacedignTaskPayload replacedignTask) {
        return testRestTemplate.exchange(ADMIN_TASK_VAR_RELATIVE_URL + replacedignTask.getTaskId() + "/replacedign", HttpMethod.POST, new HttpEnreplacedy<>(replacedignTask), TASK_RESPONSE_TYPE);
    }

    public ResponseEnreplacedy<Resources<Resource<CandidateUser>>> getUserCandidates(String taskId) {
        ResponseEnreplacedy<Resources<Resource<CandidateUser>>> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + taskId + "/candidate-users", HttpMethod.GET, null, CANDIDATE_USERS_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> addUserCandidates(CandidateUsersPayload candidateUsers) {
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + candidateUsers.getTaskId() + "/candidate-users", HttpMethod.POST, new HttpEnreplacedy<>(candidateUsers), VOID_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> deleteUserCandidates(CandidateUsersPayload candidateUsers) {
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + candidateUsers.getTaskId() + "/candidate-users", HttpMethod.DELETE, new HttpEnreplacedy<>(candidateUsers), VOID_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Resources<Resource<CandidateGroup>>> getGroupCandidates(String taskId) {
        ResponseEnreplacedy<Resources<Resource<CandidateGroup>>> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + taskId + "/candidate-groups", HttpMethod.GET, null, CANDIDATES_GROUPS_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> addGroupCandidates(CandidateGroupsPayload candidateGroups) {
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + candidateGroups.getTaskId() + "/candidate-groups", HttpMethod.POST, new HttpEnreplacedy<>(candidateGroups), VOID_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> deleteGroupCandidates(CandidateGroupsPayload candidateGroups) {
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + candidateGroups.getTaskId() + "/candidate-groups", HttpMethod.DELETE, new HttpEnreplacedy<>(candidateGroups), VOID_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public PagedResources<CloudTask> getSubTasks(CloudTask parentTask) {
        ResponseEnreplacedy<PagedResources<CloudTask>> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + parentTask.getId() + "/subtasks", HttpMethod.GET, null, new ParameterizedTypeReference<PagedResources<CloudTask>>() {
        });
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy.getBody();
    }

    public CloudTask createTask(CreateTaskPayload createTask) {
        ResponseEnreplacedy<CloudTask> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL, HttpMethod.POST, new HttpEnreplacedy<>(createTask), TASK_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy.getBody();
    }

    public ResponseEnreplacedy<PagedResources<CloudTask>> getTasks() {
        return getTasks(TASK_VAR_RELATIVE_URL);
    }

    public ResponseEnreplacedy<PagedResources<CloudTask>> adminGetTasks() {
        return getTasks(ADMIN_TASK_VAR_RELATIVE_URL);
    }

    private ResponseEnreplacedy<PagedResources<CloudTask>> getTasks(String baseURL) {
        return testRestTemplate.exchange(baseURL, HttpMethod.GET, null, PAGED_TASKS_RESPONSE_TYPE);
    }

    public ResponseEnreplacedy<CloudTask> getTask(String taskId) {
        return getTask(taskId, TASK_VAR_RELATIVE_URL);
    }

    public ResponseEnreplacedy<CloudTask> adminGetTask(String taskId) {
        return getTask(taskId, ADMIN_TASK_VAR_RELATIVE_URL);
    }

    private ResponseEnreplacedy<CloudTask> getTask(String taskId, String baseURL) {
        ResponseEnreplacedy<CloudTask> responseEnreplacedy = testRestTemplate.exchange(baseURL + taskId, HttpMethod.GET, null, TASK_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public void updateTask(UpdateTaskPayload updateTask) {
        updateTask(updateTask, TASK_VAR_RELATIVE_URL);
    }

    public void adminUpdateTask(UpdateTaskPayload updateTask) {
        updateTask(updateTask, ADMIN_TASK_VAR_RELATIVE_URL);
    }

    private void updateTask(UpdateTaskPayload updateTask, String baseURL) {
        updateTask(updateTask.getTaskId(), updateTask, baseURL);
    }

    public void updateTask(String taskId, UpdateTaskPayload updateTask) {
        updateTask(taskId, updateTask, TASK_VAR_RELATIVE_URL);
    }

    public void adminUpdateTask(String taskId, UpdateTaskPayload updateTask) {
        updateTask(taskId, updateTask, ADMIN_TASK_VAR_RELATIVE_URL);
    }

    private void updateTask(String taskId, UpdateTaskPayload updateTask, String baseURL) {
        ResponseEnreplacedy<CloudTask> responseEnreplacedy = testRestTemplate.exchange(baseURL + taskId, HttpMethod.PUT, new HttpEnreplacedy<>(updateTask), TASK_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
    }

    public ResponseEnreplacedy<Void> createVariable(String taskId, String name, Object value) {
        CreateTaskVariablePayload createTaskVariablePayload = TaskPayloadBuilder.createVariable().withVariable(name, value).build();
        HttpEnreplacedy<CreateTaskVariablePayload> requestEnreplacedy = new HttpEnreplacedy<>(createTaskVariablePayload, null);
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TaskRestTemplate.TASK_VAR_RELATIVE_URL + taskId + "/variables/", HttpMethod.POST, requestEnreplacedy, VOID_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> updateVariable(String taskId, String name, Object value) {
        UpdateTaskVariablePayload updateTaskVariablePayload = TaskPayloadBuilder.updateVariable().withVariable(name, value).build();
        HttpEnreplacedy<UpdateTaskVariablePayload> requestEnreplacedy = new HttpEnreplacedy<>(updateTaskVariablePayload, null);
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TaskRestTemplate.TASK_VAR_RELATIVE_URL + taskId + "/variables/{variableName}", HttpMethod.PUT, requestEnreplacedy, VOID_RESPONSE_TYPE, name);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Resources<CloudVariableInstance>> getVariables(String taskId) {
        ResponseEnreplacedy<Resources<CloudVariableInstance>> responseEnreplacedy = testRestTemplate.exchange(TaskRestTemplate.TASK_VAR_RELATIVE_URL + taskId + "/variables/", HttpMethod.GET, null, new ParameterizedTypeReference<Resources<CloudVariableInstance>>() {
        });
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> adminCreateVariable(String taskId, String name, Object value) {
        CreateTaskVariablePayload createTaskVariablePayload = TaskPayloadBuilder.createVariable().withVariable(name, value).build();
        HttpEnreplacedy<CreateTaskVariablePayload> requestEnreplacedy = new HttpEnreplacedy<>(createTaskVariablePayload, null);
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TaskRestTemplate.ADMIN_TASK_VAR_RELATIVE_URL + taskId + "/variables/", HttpMethod.POST, requestEnreplacedy, VOID_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> adminUpdateVariable(String taskId, String name, Object value) {
        UpdateTaskVariablePayload updateTaskVariablePayload = TaskPayloadBuilder.updateVariable().withVariable(name, value).build();
        HttpEnreplacedy<UpdateTaskVariablePayload> requestEnreplacedy = new HttpEnreplacedy<>(updateTaskVariablePayload, null);
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TaskRestTemplate.ADMIN_TASK_VAR_RELATIVE_URL + taskId + "/variables/{variableName}", HttpMethod.PUT, requestEnreplacedy, VOID_RESPONSE_TYPE, name);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Resources<CloudVariableInstance>> adminGetVariables(String taskId) {
        ResponseEnreplacedy<Resources<CloudVariableInstance>> responseEnreplacedy = testRestTemplate.exchange(TaskRestTemplate.ADMIN_TASK_VAR_RELATIVE_URL + taskId + "/variables/", HttpMethod.GET, null, new ParameterizedTypeReference<Resources<CloudVariableInstance>>() {
        });
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }

    public ResponseEnreplacedy<Void> save(Task task, SaveTaskPayload saveTaskPayload) {
        ResponseEnreplacedy<Void> responseEnreplacedy = testRestTemplate.exchange(TASK_VAR_RELATIVE_URL + task.getId() + "/save", HttpMethod.POST, saveTaskPayload != null ? new HttpEnreplacedy<>(saveTaskPayload) : null, VOID_RESPONSE_TYPE);
        return responseEnreplacedy;
    }
}

19 Source : ProcessDefinitionRestTemplate.java
with Apache License 2.0
from Activiti

@TestComponent
public clreplaced ProcessDefinitionRestTemplate {

    private static final String PROCESS_DEFINITIONS_URL = "/v1/process-definitions/";

    private static final ParameterizedTypeReference<PagedResources<CloudProcessDefinition>> PAGED_DEFINITIONS_RESPONSE_TYPE = new ParameterizedTypeReference<PagedResources<CloudProcessDefinition>>() {
    };

    private TestRestTemplate testRestTemplate;

    public ProcessDefinitionRestTemplate(TestRestTemplate testRestTemplate) {
        this.testRestTemplate = testRestTemplate;
    }

    public ResponseEnreplacedy<PagedResources<CloudProcessDefinition>> getProcessDefinitions() {
        ResponseEnreplacedy<PagedResources<CloudProcessDefinition>> responseEnreplacedy = testRestTemplate.exchange(PROCESS_DEFINITIONS_URL, HttpMethod.GET, null, PAGED_DEFINITIONS_RESPONSE_TYPE);
        replacedertThat(responseEnreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
        return responseEnreplacedy;
    }
}

19 Source : ProcessDefinitionIT.java
with Apache License 2.0
from Activiti

@Test
public void shouldReturnProcessDefinitionMetadata() {
    // given
    ParameterizedTypeReference<ProcessDefinitionMeta> responseType = new ParameterizedTypeReference<ProcessDefinitionMeta>() {
    };
    ProcessDefinition aProcessDefinition = getProcessDefinition(PROCESS_WITH_VARIABLES_2);
    // when
    ResponseEnreplacedy<ProcessDefinitionMeta> enreplacedy = restTemplate.exchange(PROCESS_DEFINITIONS_URL + aProcessDefinition.getId() + "/meta", HttpMethod.GET, null, responseType);
    // then
    replacedertThat(enreplacedy).isNotNull();
    replacedertThat(enreplacedy.getBody()).isNotNull();
    replacedertThat(enreplacedy.getBody().getVariables()).hreplacedize(3);
    replacedertThat(enreplacedy.getBody().getUsers()).hreplacedize(4);
    replacedertThat(enreplacedy.getBody().getGroups()).hreplacedize(4);
    replacedertThat(enreplacedy.getBody().getUserTasks()).hreplacedize(2);
    replacedertThat(enreplacedy.getBody().getServiceTasks()).hreplacedize(2);
}

19 Source : ProcessDefinitionIT.java
with Apache License 2.0
from Activiti

private ResponseEnreplacedy<PagedResources<CloudProcessDefinition>> getProcessDefinitions(String url) {
    ParameterizedTypeReference<PagedResources<CloudProcessDefinition>> responseType = new ParameterizedTypeReference<PagedResources<CloudProcessDefinition>>() {
    };
    return restTemplate.exchange(url, HttpMethod.GET, null, responseType);
}

See More Examples