Java Code Examples for org.springframework.web.client.RestTemplate

@Bean
public RestTemplate restTemplate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {

    SSLContext sslContext = SSLContexts.custom()
            .loadTrustMaterial(null, new TrustSelfSignedStrategy())
            .build();

    SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
    CloseableHttpClient httpClient = HttpClients.custom()
            .setSSLSocketFactory(sslConnectionSocketFactory)
            .build();

    HttpComponentsClientHttpRequestFactory requestFactory =
            new HttpComponentsClientHttpRequestFactory();

    requestFactory.setHttpClient(httpClient);

    return new RestTemplate(requestFactory);
}
 

/**
 * Gets all user's present in the twitch chat of a channel.
 *
 * @param channelName Channel to fetch the information for.
 * @return All chatters in a channel, separated into groups like admins, moderators and viewers.
 */
public Chatter getChatters(String channelName) {
	// Endpoint
	String requestUrl = String.format("%s/group/user/%s/chatters", Endpoints.TMI.getURL(), channelName);
	RestTemplate restTemplate = getTwitchClient().getRestClient().getRestTemplate();

	// REST Request
	try {
		if (!restObjectCache.containsKey(requestUrl)) {
			Logger.trace(this, "Rest Request to [%s]", requestUrl);
			ChatterResult responseObject = restTemplate.getForObject(requestUrl, ChatterResult.class);
			restObjectCache.put(requestUrl, responseObject, ExpirationPolicy.CREATED, 60, TimeUnit.SECONDS);
		}

		return ((ChatterResult) restObjectCache.get(requestUrl)).getChatters();

	} catch (RestException restException) {
		Logger.error(this, "RestException: " + restException.getRestError().toString());
	} catch (Exception ex) {
		Logger.error(this, "Request failed: " + ex.getMessage());
		Logger.trace(this, ExceptionUtils.getStackTrace(ex));
	}

	// OnError: Return empty result
	return new Chatter();
}
 

/**
 * This method activates the e-mail change using a token
 * @param token E-mail change activation token
 * @param uriComponentsBuilder {@link UriComponentsBuilder}
 * @return The ModelAndView for sign in
 */
@PreAuthorize("permitAll()")
@GetMapping(value = "changeEmail/thanks")
public
ModelAndView confirmEmail(
        @RequestParam final String token,
        final UriComponentsBuilder uriComponentsBuilder
) {
    SSLContextHelper.disable();

    final RestTemplate restTemplate = new RestTemplate();
    final HttpEntity<Object> entity = new HttpEntity<>(new HttpHeaders());

    final UriComponents uriComponents
            = uriComponentsBuilder.path("/api/v1.0/settings/changeEmail/token/{token}").buildAndExpand(token);

    ResponseEntity<Void> response;

    try {
        response = restTemplate
                .exchange(uriComponents.toUri(),
                          HttpMethod.PUT,
                          entity,
                          Void.class);
    } catch (HttpClientErrorException e) /* IF 404 */ {
        return new ModelAndView("tokenNotFound");
    }

    /* IF 200 */
    return new ModelAndView("redirect:/signIn");
}
 

private static void testExchange(RestTemplate template, String cseUrlPrefix) {
  HttpHeaders headers = new HttpHeaders();
  headers.add("Accept", MediaType.APPLICATION_JSON);
  Person person = new Person();
  person.setName("world");
  HttpEntity<Person> requestEntity = new HttpEntity<>(person, headers);
  ResponseEntity<Person> resEntity = template.exchange(cseUrlPrefix + "/compute/sayhello",
      HttpMethod.POST,
      requestEntity,
      Person.class);
  TestMgr.check("hello world", resEntity.getBody());

  ResponseEntity<String> resEntity2 =
      template.exchange(cseUrlPrefix + "/compute/addstring?s=abc&s=def", HttpMethod.DELETE, null, String.class);
  TestMgr.check("abcdef", resEntity2.getBody());
}
 

/**
 * Get Featured Streams
 * <p>
 * Gets a list of all featured live streams.
 * Requires Scope: none
 *
 * @param limit  Maximum number of most-recent objects to return. Default: 25. Maximum: 100.
 * @param offset Object offset for pagination of results. Default: 0.
 * @return The requested range/amount of featured streams.
 */
public List<StreamFeatured> getFeatured(Optional<Long> limit, Optional<Long> offset) {
	// Endpoint
	String requestUrl = String.format("%s/streams/featured", Endpoints.API.getURL());
	RestTemplate restTemplate = getTwitchClient().getRestClient().getRestTemplate();

	// Parameters
	restTemplate.getInterceptors().add(new QueryRequestInterceptor("limit", limit.orElse(25l).toString()));
	restTemplate.getInterceptors().add(new QueryRequestInterceptor("offset", offset.orElse(0l).toString()));

	// REST Request
	try {
		StreamFeaturedList responseObject = restTemplate.getForObject(requestUrl, StreamFeaturedList.class);

		return responseObject.getFeatured();
	} catch (Exception ex) {
		Logger.error(this, "Request failed: " + ex.getMessage());
		Logger.trace(this, ExceptionUtils.getStackTrace(ex));
	}

	return new ArrayList<StreamFeatured>();
}
 

@Test
public void restApiGetStatus() throws Exception {
  exit.expectSystemExitWithStatus(0);

  runner = WaggleDanceRunner
      .builder(configLocation)
      .primary("primary", localServer.getThriftConnectionUri(), READ_ONLY)
      .federate("waggle_remote", remoteServer.getThriftConnectionUri(), REMOTE_DATABASE)
      .build();

  runWaggleDance(runner);

  RestTemplate rest = new RestTemplateBuilder().build();
  PrimaryMetaStore primaryMetastore = rest.getForObject("http://localhost:18000/api/admin/federations/primary",
      PrimaryMetaStore.class);
  assertThat(primaryMetastore.getStatus(), is(MetaStoreStatus.AVAILABLE));
  FederatedMetaStore federatedMetastore = rest
      .getForObject("http://localhost:18000/api/admin/federations/waggle_remote", FederatedMetaStore.class);
  assertThat(federatedMetastore.getStatus(), is(MetaStoreStatus.AVAILABLE));
}
 

public TracingRestTemplateTest() {
    final RestTemplate restTemplate = new RestTemplate();
    restTemplate.setInterceptors(Collections.<ClientHttpRequestInterceptor>singletonList(
            new TracingRestTemplateInterceptor(mockTracer)));

    client = new Client<RestTemplate>() {
        @Override
        public <T> ResponseEntity<T> getForEntity(String url, Class<T> clazz) {
            return restTemplate.getForEntity(url, clazz);
        }

        @Override
        public RestTemplate template() {
            return restTemplate;
        }
    };

    mockServer = MockRestServiceServer.bindTo(client.template()).build();
}
 

public SimpleB2CAuthenticationService(
  final ClaimValidationService claimValidationService,
  final NonceService nonceService,
  final UrlService urlService,
  final RestTemplate restTemplate){

    Assert.notNull(
      claimValidationService,
      "Missing required parameter 'claimValidationService' " +
        "(org.xitikit.blue.noitacitnehtua.api.v2dot0.SimpleB2CAuthenticationService::new)");
    Assert.notNull(nonceService, "Missing required parameter 'nonceService' (org.xitikit.blue.noitacitnehtua.api.v2dot0.SimpleB2CAuthenticationService::new)");
    Assert.notNull(urlService, "Missing required parameter 'blueUrlService' (org.xitikit.blue.noitacitnehtua.api.v2dot0.SimpleB2CAuthenticationService::new)");
    Assert.notNull(restTemplate, "Missing required parameter 'restTemplate' (org.xitikit.blue.noitacitnehtua.api.v2dot0.SimpleB2CAuthenticationService::new)");

    this.claimValidationService = claimValidationService;
    this.nonceService = nonceService;
    this.urlService = urlService;
    this.restTemplate = restTemplate;
}
 

@Bean
@LoadBalanced // 自动负载均衡：他的机制是（通过）Application Name去寻找服务发现，然后去做负载均衡策略的
public RestTemplate restTemplate() {
    // HttpComponentsClientHttpRequestFactory httpRequestFactory = new
    // HttpComponentsClientHttpRequestFactory();
    // httpRequestFactory.setConnectionRequestTimeout(1000);
    // httpRequestFactory.setConnectTimeout(1000);
    // httpRequestFactory.setReadTimeout(3000);
    return new RestTemplate(httpRequestFactory());
}
 

/**
 * Get Followed Streams
 * <p>
 * Gets the list of online streams a user follows based on the OAuthTwitch token provided.
 * Requires Scope: user_read
 *
 * @param credential The user.
 * @return All streams as user follows.
 */
public List<Stream> getFollowed(OAuthCredential credential) {
	// Endpoint
	String requestUrl = String.format("%s/streams/followed", Endpoints.API.getURL());
	RestTemplate restTemplate = getTwitchClient().getRestClient().getPrivilegedRestTemplate(credential);

	// REST Request
	try {
		StreamList responseObject = restTemplate.getForObject(requestUrl, StreamList.class);

		return responseObject.getStreams();
	} catch (Exception ex) {
		Logger.error(this, "Request failed: " + ex.getMessage());
		Logger.trace(this, ExceptionUtils.getStackTrace(ex));
	}

	return new ArrayList<Stream>();
}
 

/** Execute un WS sur LimeSurvey
 * @param obj
 * @return la ResponseEntity
 */
private ResponseEntity<String> executeWS(LimeSurveyRestObject obj){
	try {
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);						
		String serialized;
		ObjectMapper mapper = new ObjectMapper();
		serialized = mapper.writeValueAsString(obj);
		HttpEntity<String> requestEntity=new HttpEntity<String>(serialized,headers);
		RestTemplate restTemplate = new RestTemplate();
		ResponseEntity<String> response = restTemplate.exchange(URL,HttpMethod.POST,requestEntity,String.class);
		return response;
	} catch (Exception e) {
		logger.error("Erreur d'appel du web service "+obj.getMethod()+" sur LimeSurvey",e);
		return null;
	}
}
 

/**
 * Endpoint: Get OAuth Token Information
 * Gets information about the provided oAuthToken
 * Requires Scope: none
 *
 * @param credential The credential the information should be fetched for.
 * @return Information about the user, that issued the token - also provides info about scopes/valid/etc.
 * @see Token
 */
public Token getToken(OAuthCredential credential) {
	// Endpoint
	String requestUrl = String.format("%s", Endpoints.API.getURL());
	RestTemplate restTemplate = getTwitchClient().getRestClient().getPrivilegedRestTemplate(credential);

	// REST Request
	try {
		TokenResponse responseObject = restTemplate.getForObject(requestUrl, TokenResponse.class);

		return responseObject.getToken();
	} catch (RestException restException) {
		Logger.error(this, "RestException: " + restException.getRestError().toString());
	} catch (Exception ex) {
		Logger.error(this, "Request failed: " + ex.getMessage());
		Logger.trace(this, ExceptionUtils.getStackTrace(ex));
	}

	// Default Response: Invalid Token
	return new Token();
}
 

public void sendViaMailgunApi(EmailParams emailParams) {
    String apiUrl = jHipsterProperties.getMailgun().getApiUrl();
    String apiKey = jHipsterProperties.getMailgun().getApiKey();

    MultiValueMap<String, Object> vars = new LinkedMultiValueMap<>();
    vars.add("from", jHipsterProperties.getMailgun().getFrom());
    vars.add("to", emailParams.getTo());
    vars.add("subject", emailParams.getSubject());
    vars.add("html", emailParams.getContent());

    RestTemplate restTemplate = new BasicAuthRestTemplate(MAILGUN_USER_NAME, apiKey);
    restTemplate.postForLocation(apiUrl, vars);

    log.debug("Email sent successfully.");
}
 

private RestTemplate getRestTemplate ( long maxConnectionInMs, JsonNode user, JsonNode pass, String desc ) {

		logger.debug( "maxConnectionInMs: {} , user: {} , Pass: {} ", maxConnectionInMs, user, pass );

		HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();

		// "user" : "$csapUser1", "pass" : "$csapPass1"
		if ( user != null && pass != null ) {
			CredentialsProvider credsProvider = new BasicCredentialsProvider();
			credsProvider.setCredentials(
				new AuthScope( null, -1 ),
				new UsernamePasswordCredentials(
					user.asText(),
					csapApplication.decode( pass.asText(), desc ) ) );

			HttpClient httpClient = HttpClients
				.custom()
				.setDefaultCredentialsProvider( credsProvider )
				.build();
			factory.setHttpClient( httpClient );
			// factory = new HttpComponentsClientHttpRequestFactory(httpClient);
		}

		factory.setConnectTimeout( (int) maxConnectionInMs );
		factory.setReadTimeout( (int) maxConnectionInMs );

		RestTemplate restTemplate = new RestTemplate( factory );

		return restTemplate;
	}
 

private List<JsonContainer> getMore(final RestTemplate rt, final String url, final JsonContainer last)
        throws URISyntaxException, UnsupportedEncodingException {
    String params = url.contains("?") ? "&" : "?";
    String newUrl = url + params + "marker=" + URLEncoder.encode(last.getName(), "UTF-8");
    URI keystoneURI = new URI(newUrl);
    JsonContainer[] data = getResourcesFromGet(rt, keystoneURI);
    List<JsonContainer> list = new ArrayList<>();
    list.addAll(Arrays.asList(data));
    if (data.length != 0) {
        // check for more
        List<JsonContainer> extra = getMore(rt, url, data[data.length - 1]);
        list.addAll(extra);
    }
    return list;
}
 

@Test
public void testStatusReleaseNameFound() {
	RestTemplate restTemplate = new RestTemplate();
	SkipperClient skipperClient = new DefaultSkipperClient("", restTemplate);

	MockRestServiceServer mockServer = MockRestServiceServer.bindTo(restTemplate).build();
	mockServer.expect(requestTo("/release/status/mylog")).andRespond(withSuccess("{}", MediaType.APPLICATION_JSON));

	Info status = skipperClient.status("mylog");
	mockServer.verify();

	assertThat(status).isNotNull();
	assertThat(status).isInstanceOf(Info.class);
}
 

private PolicySet getPolicySet(final RestTemplate acs, final String policyName, final HttpHeaders headers,
        final String acsEndpointParam) {
    ResponseEntity<PolicySet> policySetResponse = acs.exchange(
            acsEndpointParam + PolicyHelper.ACS_POLICY_SET_API_PATH + policyName, HttpMethod.GET,
            new HttpEntity<>(headers), PolicySet.class);
    return policySetResponse.getBody();
}
 

RestTemplate getRestTemplate(String url) {
  for (AcceptableRestTemplate template : acceptableRestTemplates) {
    if (template.isAcceptable(url)) {
      return template;
    }
  }
  return defaultRestTemplate;
}
 

private void testUpload(RestTemplate template, String cseUrlPrefix) throws IOException {
  String file1Content = "hello world";
  File file1 = File.createTempFile("upload1", ".txt");
  FileUtils.writeStringToFile(file1, file1Content);

  String file2Content = " bonjour";
  File someFile = File.createTempFile("upload2", ".txt");
  FileUtils.writeStringToFile(someFile, file2Content);

  String expect = String.format("%s:%s:%s\n"
      + "%s:%s:%s",
      file1.getName(),
      MediaType.TEXT_PLAIN_VALUE,
      file1Content,
      someFile.getName(),
      MediaType.TEXT_PLAIN_VALUE,
      file2Content);

  String result = testRestTemplateUpload(template, cseUrlPrefix, file1, someFile);
  TestMgr.check(expect, result);

  result = uploadPartAndFile.fileUpload(new FilePart(null, file1), someFile);
  TestMgr.check(expect, result);

  expect = String.format("null:%s:%s\n"
      + "%s:%s:%s",
      MediaType.APPLICATION_OCTET_STREAM_VALUE,
      file1Content,
      someFile.getName(),
      MediaType.TEXT_PLAIN_VALUE,
      file2Content);
  result = uploadStreamAndResource
      .fileUpload(new ByteArrayInputStream(file1Content.getBytes(StandardCharsets.UTF_8)),
          new PathResource(someFile.getAbsolutePath()));
  TestMgr.check(expect, result);
}
 

@Primary
@Bean(name="testRestTemplate")
RestTemplate restTemplate() {
	RestTemplate template = new RestTemplate();
	template.setErrorHandler(getResponseErrorHandler());

	return template;
}
 

/**
 * 采用 RestTemplate 方式调用（HTTP方式调用，与 Spring Cloud 调用服务没有一点关系）
 * 
 * @param name
 * @return
 */
@RequestMapping(value = "callByHttpUrl", method = RequestMethod.GET)
public String callByHttpUrl(String name) {
	RestTemplate restTemplate = new RestTemplate();
	ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:8001/sayHello?name=" + name,
			String.class);
	return response.getBody();
}
 

public AddressCommand(AddressDTO addressDTO, RestTemplate restTemplate, boolean secondTry) {
    super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("AddressServiceClientGroup"))
        .andCommandKey(HystrixCommandKey.Factory.asKey("AddressServiceClient")));

    this.addressDTO = addressDTO;
    this.restTemplate = restTemplate;
    this.secondTry = secondTry;
}
 

@Override
public JsonNetworks createNetworks(final JsonNetworks networks) {
    String url = getUri();
    RestTemplate rt = getRestTemplate(jsonEndpoint.getProjectId());
    ResponseEntity<JsonNetworks> result = rt.postForEntity(url, networks, JsonNetworks.class);

    return result.getBody();
}
 

@Override
protected MultifactorAuthenticationTrustRecord setInternal(final MultifactorAuthenticationTrustRecord record) {
    final RestTemplate restTemplate = new RestTemplate();
    final ResponseEntity<Object> response = restTemplate.postForEntity(this.endpoint, record, Object.class);
    if (response != null && response.getStatusCode() == HttpStatus.OK) {
        return record;
    }
    return null;
}
 

@Bean(MIRRORGATE_REST_TEMPLATE)
public RestTemplate getRestTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    MappingJackson2HttpMessageConverter jsonHttpMessageConverter = new MappingJackson2HttpMessageConverter();
    restTemplate.getMessageConverters().add(jsonHttpMessageConverter);
    if(mirrorGateUserName.isPresent() && !mirrorGateUserName.get().isEmpty()) {
        restTemplate.getInterceptors().add(
                new BasicAuthorizationInterceptor(mirrorGateUserName.get(), mirrorGatePassword.get()));
    }

    return restTemplate;
}
 

/**
 * Endpoint: Get Channel Editors
 * Gets a list of users who are editors for a specified channel.
 * Requires Scope: channel_read
 *
 * @return todo
 */
public List<User> getEditors() {
	// Check Scope
	Optional<OAuthCredential> twitchCredential = getTwitchClient().getCredentialManager().getTwitchCredentialsForChannel(getChannelId());
	if (twitchCredential.isPresent()) {
		Set<String> requiredScopes = new HashSet<String>();
		requiredScopes.add(TwitchScopes.CHANNEL_READ.getKey());

		checkScopePermission(twitchCredential.get().getOAuthScopes(), requiredScopes);
	} else {
		throw new ChannelCredentialMissingException(getChannelId());
	}

	// Endpoint
	String requestUrl = String.format("%s/channels/%s/editors", Endpoints.API.getURL(), getChannelId());
	RestTemplate restTemplate = getTwitchClient().getRestClient().getRestTemplate();

	// REST Request
	try {
		UserList responseObject = restTemplate.getForObject(requestUrl, UserList.class);

		return responseObject.getUsers();
	} catch (Exception ex) {
		Logger.error(this, "Request failed: " + ex.getMessage());
		Logger.trace(this, ExceptionUtils.getStackTrace(ex));
		return null;
	}
}
 

@Test
public void loginSucceeds() {
    RestTemplate template = new TestRestTemplate("user", "foo");
    ResponseEntity<String> response = template.getForEntity("http://localhost:" + port
            + "/user", String.class);
    assertEquals(HttpStatus.OK, response.getStatusCode());
}
 

public static List<Stat.Author> getContributorsByCommitsDesc() throws IOException {
    RestTemplate restTemplate = new RestTemplate();
    ResponseEntity<Stat[]> exchange = restTemplate.
            exchange("https://api.github.com/repos/"
                    + githubUsername + "/" + githubReponame + "/stats/contributors", HttpMethod.GET, null, Stat[].class);
    Stat[] stats = exchange.getBody();
    List<Stat.Author> contributors = new ArrayList<>(stats.length);
    for (Stat s : stats) {
        Stat.Author author = s.getAuthor();
        author.setCommits(s.getTotal());
        contributors.add(0, author);
    }
    return contributors;
}
 

public AzureGraphApiClient(
    final RestTemplate restTemplate,
    final IAzureCustomAttributeCacheService azureCustomAttributeCacheService,
    final GraphApiClientProperties graphApiClientProperties){

    this.restTemplate = restTemplate;
    this.azureCustomAttributeCacheService = azureCustomAttributeCacheService;
    this.graphApiClientProperties = graphApiClientProperties;
}
 

@Override
public RestTemplate getRestTemplate() {
    if (clientRestTemplate != null) {
        return clientRestTemplate;
    }
    return super.getRestTemplate();
}
 

protected void processNext(final R result, final RestTemplate rt) {
    String nextUrl = getNext(result);
    if (nextUrl != null) {
        R nextResults = getJsonResources(rt, nextUrl);
        addToResult(result, nextResults);
    }
}
 

private List<Visit> getPetVisits(int petId){
    List<Visit> visitList = new ArrayList<Visit>();
    RestTemplate restTemplate = new RestTemplate();
    Pet pet = restTemplate.getForObject("http://"+serviceEndpoint+"/pet/"+petId, Pet.class);
    logger.info(pet.getVisits().toString());
    return pet.getVisits();
}
 

@Test
public void testTestCustomEndpoint() {
	RestTemplate testRestTemplate = new RestTemplate();
	ResponseEntity<String> response = testRestTemplate
			.getForEntity("http://localhost:" + this.port + "/api/custom", String.class);
	assertEquals(HttpStatus.OK, response.getStatusCode());
	assertEquals(response.getBody(), "hello");
}
 

public boolean isValidCustomerId(long customerId) {
	RestTemplate restTemplate = new RestTemplate();
	try {
		ResponseEntity<String> entity = restTemplate.getForEntity(customerURL() + customerId, String.class);
		return entity.getStatusCode().is2xxSuccessful();
	} catch (final HttpClientErrorException e) {
		if (e.getStatusCode().value() == 404)
			return false;
		else
			throw e;
	}
}
 

public RestGoogleAuthenticatorTokenCredentialRepository(final IGoogleAuthenticator googleAuthenticator,
                                                        final RestTemplate restTemplate,
                                                        final MultifactorAuthenticationProperties.GAuth gauth) {
    this.googleAuthenticator = googleAuthenticator;
    this.restTemplate = restTemplate;
    this.gauth = gauth;
}
 

/**
 * Create a {@link RestTemplate} configured for communication with a CredHub server.
 *
 * @param baseUri the base URI for the CredHub server
 * @param clientHttpRequestFactory the {@link ClientHttpRequestFactory} to use when
 * creating new connections
 * @return a configured {@link RestTemplate}
 */
public static RestTemplate createRestTemplate(String baseUri,
		ClientHttpRequestFactory clientHttpRequestFactory) {
	RestTemplate restTemplate = new RestTemplate();

	configureRestTemplate(restTemplate, baseUri, clientHttpRequestFactory);

	return restTemplate;
}
 

private void setRestTemplateInterceptor(final RestTemplate restTemplate) {
    restTemplate.setInterceptors(Collections.singletonList(
            new TraceRestTemplateInterceptor(this.tracer, new ZipkinHttpSpanInjector(),
                    new HttpTraceKeysInjector(this.tracer, new TraceKeys()))));
}
 

/**
 * This is the method that actually makes the http request
 *
 * @param url              request url
 * @param deconstructClass class of request object
 * @param <T>              type of request object this is
 * @return request object
 */
private <T> T request(final String url, final Class<T> deconstructClass) {
    final RestTemplate restTemplate = new RestTemplate();
    T deconstructedResponse = null;

    try {
        deconstructedResponse = restTemplate.getForObject(url, deconstructClass);
    } catch (HttpClientErrorException err) {
        logger.info("[FacebookReader] [request] Failure To Retrieve Facebook Resource (" + url + ")", err);
    }

    return deconstructedResponse;
}
 

@Bean
public JwtAccessTokenConverter jwtAccessTokenConverter(
        @Qualifier("loadBalancedRestTemplate") RestTemplate keyUriRestTemplate) throws CertificateException {

    JwtAccessTokenConverter converter = new DomainJwtAccessTokenConverter();
    converter.setVerifierKey(getKeyFromAuthorizationServer(keyUriRestTemplate));
    return converter;
}
 

public SearchBuilderImpl(final NodeReferenceBuilder nodeReferenceBuilder,
                         final String url,
                         final RestTemplate restTemplate) {
    this.nodeReferenceBuilder = nodeReferenceBuilder;
    this.url = url;
    this.restTemplate = restTemplate;
}
 

@Override
public JsonSubnets createSubnets(final JsonSubnets subnets) {
    String url = getUri();
    RestTemplate rt = getRestTemplate(jsonEndpoint.getProjectId());
    ResponseEntity<JsonSubnets> result = rt.postForEntity(url, subnets, JsonSubnets.class);

    return result.getBody();
}
 

@Autowired
public GameQueryService(SteamWebApiClient steamWebApiClient, SettingService settingService, RestTemplate restTemplate) {
    this.steamWebApiClient = steamWebApiClient;
    this.settingService = settingService;
    this.restTemplate = restTemplate;
    this.steamApps = new SteamApps(steamWebApiClient);
    this.steamUser = new SteamUser(steamWebApiClient);
    this.sourceQueryClient = new SourceQueryClient();
    this.sourceRconClient = new SourceRconClient();
}
 

public boolean isValidCustomerId(long customerId) {
	RestTemplate restTemplate = new RestTemplate();
	try {
		ResponseEntity<String> entity = restTemplate.getForEntity(customerURL() + customerId, String.class);
		return entity.getStatusCode().is2xxSuccessful();
	} catch (final HttpClientErrorException e) {
		if (e.getStatusCode().value() == 404)
			return false;
		else
			throw e;
	}
}
 

/**
 * Create workspace on the Che server with given URL.
 * 
 * @param cheServerUrl
 * @param keycloakToken
 * @param name
 * @param stackId
 * @param repo
 * @param branch
 * @return
 * @throws StackNotFoundException
 * @throws IOException
 * @throws URISyntaxException 
 */
public Workspace createWorkspace(String cheServerURL, String keycloakToken, String stackId, String repo,
        String branch, String description) throws StackNotFoundException, IOException, URISyntaxException {
    String url = CheRestEndpoints.CREATE_WORKSPACE.generateUrl(cheServerURL);
    WorkspaceConfig wsConfig = stackClient.getStack(cheServerURL, stackId, keycloakToken).getWorkspaceConfig();

    String projectName = projectHelper.getProjectNameFromGitRepository(repo);
    String projectType = stackClient.getProjectTypeByStackId(stackId);

    LOG.info("Stack: {}", stackId);
    LOG.info("Project type: {}", projectType);

    Project project = projectHelper.initProject(projectName, repo, branch, projectType);

    wsConfig.setProjects(Collections.singletonList(project));
    wsConfig.setName(workspaceHelper.generateName(projectName));
    wsConfig.setDescription(description);

    RestTemplate template = new KeycloakRestTemplate(keycloakToken);
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);

    HttpEntity<WorkspaceConfig> entity = new HttpEntity<WorkspaceConfig>(wsConfig, headers);

    ResponseEntity<Workspace> workspaceResponse = template.exchange(url, HttpMethod.POST, entity, Workspace.class);
    Workspace workspace = workspaceResponse.getBody();

    LOG.info("Workspace has been created: {}", workspace);

    return workspace;
}
 

/**
 * Endpoint to get the UserId from the UserName
 * <p>
 * https://api.twitch.tv/kraken/users?login=USERNAME
 *
 * @param userName todo
 * @return todo
 */
public Optional<Long> getUserIdByUserName(String userName) {
	// Validate Arguments
	Assert.hasLength(userName, "Please provide a Username!");

	// REST Request
	String requestUrl = String.format("%s/users?login=%s", Endpoints.API.getURL(), userName);
	RestTemplate restTemplate = getTwitchClient().getRestClient().getRestTemplate();

	// REST Request
	if (!restObjectCache.containsKey(requestUrl)) {
		try {
			UserList responseObject = restTemplate.getForObject(requestUrl, UserList.class);
			restObjectCache.put(requestUrl, responseObject, 15, TimeUnit.MINUTES);
		} catch (RestException restException) {
			Logger.error(this, "RestException: " + restException.getRestError().toString());
		} catch (Exception ex) {
			Logger.error(this, "Request failed: " + ex.getMessage());
			Logger.trace(this, ExceptionUtils.getStackTrace(ex));
			return Optional.empty();
		}
	}

	List<User> userList = ((UserList) restObjectCache.get(requestUrl)).getUsers();

	// User found?
	if (userList.size() == 1) {
		return Optional.ofNullable(userList.get(0).getId());
	} else {
		return Optional.empty();
	}
}
 

public ApplicationTemplate(RestTemplate restTemplate, boolean isAuthorized) {
    super(restTemplate, isAuthorized);
}
 

public Authentication() {
    restTemplate = new RestTemplate();
    this.token = null;
}
 

@Test
public void dicoverEurekaTest() throws Exception {
	RestTemplate restTemplate = new RestTemplate();
	String retour = restTemplate.getForObject("http://localhost:8761/env", String.class);
	assertTrue(retour.contains("{\"local.server.port\":8761}"));
}
 

protected RestTemplate getRestTemplate(final String projectId) {
    return openstackApp.getRestTemplateWithScopedToken(projectId);
}
 

@Bean
public RestTemplate restTemplate(Environment ev) {
	return DataFlowTemplate.getDefaultDataflowRestTemplate();
}
 

public TargetHolder(RestTemplate restTemplate) {
	this.restTemplate = restTemplate;
}
 

public DefaultInitializrMetadataProvider(InitializrMetadata metadata,
		RestTemplate restTemplate) {
	this.metadata = metadata;
	this.restTemplate = restTemplate;
}
 

/**
 * Parse the content of the metadata at the specified url
 */
public EdorasoneMetadataReader(RestTemplate restTemplate, String url) {
	this.content = new JSONObject(restTemplate.getForObject(url, String.class));
}
 

protected void testRawJson(RestTemplate template, String cseUrlPrefix) {
  String input = "{\"name\" : \"zyy\"}";
  String output = template.postForObject(cseUrlPrefix + "rawJsonAnnotation", input, String.class);
  TestMgr.check("hello zyy", output);
}
 

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder.errorHandler(new RestTemplateErrorHandler()).build();
}
 

@Bean
public RestTemplate loadBalancedRestTemplate(RestTemplateCustomizer customizer) {
    RestTemplate restTemplate = new RestTemplate();
    customizer.customize(restTemplate);
    return restTemplate;
}
 

public static void main(String[] args) throws Exception {
        RestTemplate rt = new RestTemplate();
        ResponseEntity<String> response = rt.getForEntity("http://aft.users-api.test.paas/health", String.class);

        StandardEvaluationContext ctx = new StandardEvaluationContext(response);
        ctx.registerFunction("extractFromJson", SpelExtensions.class.getMethod("extractFromJson", String.class, String.class));

        System.out.println(evaluate(ctx, "#root.statusCodeValue == 200"));
        System.out.println(evaluate(ctx, "#extractFromJson(#root.body, 'status') == 'UP'"));
        System.out.println(evaluate(ctx, "#root.headers['X-RID'] != null"));




//        System.out.println(read);
    }
 

@LoadBalanced
@Bean
RestTemplate restTemplate() {
    return new RestTemplate();
}
 

public Controller(RestTemplate restTemplate) {
  this.restTemplate = restTemplate;
}
 

@Test
@Sql(scripts = "/controller/test-itemset.sql", executionPhase = ExecutionPhase.BEFORE_TEST_METHOD)
@Sql(scripts = "/controller/cleanup.sql", executionPhase = ExecutionPhase.AFTER_TEST_METHOD)
public void testItemSetUpdated() {
  String appId = "someAppId";
  AppDTO app =
      restTemplate.getForObject("http://localhost:" + port + "/apps/" + appId, AppDTO.class);

  ClusterDTO cluster = restTemplate.getForObject(
      "http://localhost:" + port + "/apps/" + app.getAppId() + "/clusters/default",
      ClusterDTO.class);

  NamespaceDTO namespace =
      restTemplate.getForObject("http://localhost:" + port + "/apps/" + app.getAppId()
          + "/clusters/" + cluster.getName() + "/namespaces/application", NamespaceDTO.class);

  Assert.assertEquals("someAppId", app.getAppId());
  Assert.assertEquals("default", cluster.getName());
  Assert.assertEquals("application", namespace.getNamespaceName());

  ItemChangeSets createChangeSet = new ItemChangeSets();
  createChangeSet.setDataChangeLastModifiedBy("created");
  RestTemplate createdRestTemplate = new TestRestTemplate("created", "");
  createdRestTemplate.setMessageConverters(restTemplate.getMessageConverters());
  
  int createdSize = 3;
  for (int i = 0; i < createdSize; i++) {
    ItemDTO item = new ItemDTO();
    item.setNamespaceId(namespace.getId());
    item.setKey("key_" + i);
    item.setValue("created_value_" + i);
    createChangeSet.addCreateItem(item);
  }

  ResponseEntity<Void> response = createdRestTemplate.postForEntity(
      "http://localhost:" + port + "/apps/" + app.getAppId() + "/clusters/" + cluster.getName()
          + "/namespaces/" + namespace.getNamespaceName() + "/itemset",
      createChangeSet, Void.class);
  Assert.assertEquals(HttpStatus.OK, response.getStatusCode());

  ItemDTO[] items =
      createdRestTemplate.getForObject(
          "http://localhost:" + port + "/apps/" + app.getAppId() + "/clusters/"
              + cluster.getName() + "/namespaces/" + namespace.getNamespaceName() + "/items",
          ItemDTO[].class);

  ItemChangeSets updateChangeSet = new ItemChangeSets();
  updateChangeSet.setDataChangeLastModifiedBy("updated");

  RestTemplate updatedRestTemplate = new TestRestTemplate("updated", "");
  updatedRestTemplate.setMessageConverters(restTemplate.getMessageConverters());
  
  int updatedSize = 2;
  for (int i = 0; i < updatedSize; i++) {
    items[i].setValue("updated_value_" + i);
    updateChangeSet.addUpdateItem(items[i]);
  }

  response = updatedRestTemplate.postForEntity(
      "http://localhost:" + port + "/apps/" + app.getAppId() + "/clusters/" + cluster.getName()
          + "/namespaces/" + namespace.getNamespaceName() + "/itemset",
      updateChangeSet, Void.class);
  Assert.assertEquals(HttpStatus.OK, response.getStatusCode());
  List<Item> savedItems = itemRepository.findByNamespaceIdOrderByLineNumAsc(namespace.getId());
  Assert.assertEquals(createdSize, savedItems.size());
  Item item0 = savedItems.get(0);
  Assert.assertEquals("key_0", item0.getKey());
  Assert.assertEquals("updated_value_0", item0.getValue());
  Assert.assertEquals("created", item0.getDataChangeCreatedBy());
  Assert.assertEquals("updated", item0.getDataChangeLastModifiedBy());
  Assert.assertNotNull(item0.getDataChangeCreatedTime());
  Assert.assertNotNull(item0.getDataChangeLastModifiedTime());
}