public static List<User> all() {
login();
return Arrays.asList(
template
.exchange(endpoint, HttpMethod.GET, new HttpEntity<>(null, credentials()), User[].class)
.getBody());
}
@Test
public void testCreateZoneWithNonUniqueSubdomain() {
IdentityZone idZone1 = new IdentityZone();
String id1 = UUID.randomUUID().toString();
idZone1.setId(id1);
idZone1.setSubdomain(id1 + "non-unique");
idZone1.setName("testCreateZone() " + id1);
ResponseEntity<Void> response1 =
client.exchange(
serverRunning.getUrl("/identity-zones"),
HttpMethod.POST,
new HttpEntity<>(idZone1),
new ParameterizedTypeReference<Void>() {},
id1);
assertEquals(HttpStatus.CREATED, response1.getStatusCode());
IdentityZone idZone2 = new IdentityZone();
String id2 = UUID.randomUUID().toString();
idZone2.setId(id2);
idZone2.setSubdomain(id1 + "non-unique");
idZone2.setName("testCreateZone() " + id2);
ResponseEntity<Map<String, String>> response2 =
client.exchange(
serverRunning.getUrl("/identity-zones"),
HttpMethod.POST,
new HttpEntity<>(idZone2),
new ParameterizedTypeReference<Map<String, String>>() {},
id2);
assertEquals(HttpStatus.CONFLICT, response2.getStatusCode());
Assert.assertTrue(
response2.getBody().get("error_description").toLowerCase().contains("subdomain"));
}
@RequestMapping("/{userPseudo}/validateStep4")
public ResponseEntity<Void> validateStep4(
@PathVariable("userPseudo") String userPseudo,
@RequestParam("userHostAndPort") String userHostAndPort) {
log.info("Validation step 4 for player {} with data {}", userPseudo, userHostAndPort);
ResponseEntity<Void> result = new ResponseEntity<Void>(HttpStatus.BAD_REQUEST);
String url = "http://" + userHostAndPort + "/zen/env";
ResponseEntity<String> responseEntityShouldFail =
restTemplate.exchange(
url, HttpMethod.GET, new HttpEntity<>(new HttpHeaders()), String.class);
byte[] encodedAuth = Base64.encodeBase64("zenika:technozaure".getBytes());
String authHeader = "Basic " + new String(encodedAuth);
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
headers.set("Authorization", authHeader);
HttpEntity<String> entity = new HttpEntity<>(headers);
ResponseEntity<String> responseEntityShouldSucceed =
restTemplate.exchange(url, HttpMethod.GET, entity, String.class);
if (responseEntityShouldFail.getStatusCode() != HttpStatus.OK
&& responseEntityShouldSucceed.getStatusCode() == HttpStatus.OK) {
gameStepRepository.save(new GameStep(userPseudo, Step._4));
result = new ResponseEntity<Void>(HttpStatus.OK);
broadcastGameStatus();
}
return result;
}
private void verifyAuthentication(ClientDetails config, HttpStatus finalStatus) {
String baseUrl = "http://localhost:" + this.context.getEmbeddedServletContainer().getPort();
RestTemplate rest = new TestRestTemplate();
// First, verify the web endpoint can't be reached
assertEndpointUnauthorized(baseUrl, rest);
// Since we can't reach it, need to collect an authorization token
HttpHeaders headers = getHeaders(config);
String url = baseUrl + "/oauth/token";
JsonNode tokenResponse =
rest.postForObject(
url, new HttpEntity<MultiValueMap<String, Object>>(getBody(), headers), JsonNode.class);
String authorizationToken = tokenResponse.findValue("access_token").asText();
String tokenType = tokenResponse.findValue("token_type").asText();
String scope = tokenResponse.findValues("scope").get(0).toString();
assertThat(tokenType, equalTo("bearer"));
assertThat(scope, equalTo("\"read\""));
// Now we should be able to see that endpoint.
headers.set("Authorization", "BEARER " + authorizationToken);
ResponseEntity<String> securedResponse =
rest.exchange(
new RequestEntity<Void>(headers, HttpMethod.GET, URI.create(baseUrl + "/securedFind")),
String.class);
assertThat(securedResponse.getStatusCode(), equalTo(HttpStatus.OK));
assertThat(
securedResponse.getBody(),
equalTo("You reached an endpoint " + "secured by Spring Security OAuth2"));
ResponseEntity<String> entity =
rest.exchange(
new RequestEntity<Void>(headers, HttpMethod.POST, URI.create(baseUrl + "/securedSave")),
String.class);
assertThat(entity.getStatusCode(), equalTo(finalStatus));
}
@Bean
public Token getToken() {
Token token;
String creds = authUser + ":" + authPassword;
byte[] credsBytes = creds.getBytes();
byte[] credsB64 = Base64.getEncoder().encode(credsBytes);
String credsStr = new String(credsB64);
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic " + credsStr);
headers.add("Content-Type", "application/x-www-form-urlencoded");
headers.add("Accept", "application/json");
headers.add("Accept-Charset", "UTF-8"); // не работает !
HttpEntity<String> request = new HttpEntity<String>(authParam, headers);
log.info("Request token from server...");
try {
ResponseEntity resp = rest.exchange(authUri, HttpMethod.POST, request, Token.class);
token = (Token) (resp.getBody());
} catch (HttpClientErrorException e) {
log.error(e.getMessage());
token = new Token();
}
log.debug("Token=" + token.access_token);
log.info("End of request token from server...");
return token;
}
public static User byId(String username) {
login();
return template
.exchange(
endpoint + username, HttpMethod.GET, new HttpEntity<>(null, credentials()), User.class)
.getBody();
}
public Map<String, Map<String, List<String>>>
getMapOfSenderAndRecieverValidationObjectivesWithReferenceFiles() {
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<GithubResponseWrapper> responseEntity =
restTemplate.exchange(
GITHUB_URL,
HttpMethod.GET,
null,
new ParameterizedTypeReference<GithubResponseWrapper>() {});
Map<String, Map<String, List<String>>> messageTypeValidationObjectiveReferenceFilesMap =
new HashMap<>();
for (TestDataTreeWrapper testDataTreeWrapper : responseEntity.getBody().getTree()) {
if (!(testDataTreeWrapper.getPath().equalsIgnoreCase("license")
|| testDataTreeWrapper.getPath().equalsIgnoreCase("README.md"))) {
if (isMessageTypeInMap(
messageTypeValidationObjectiveReferenceFilesMap, testDataTreeWrapper)) {
if (isValidationObjectiveInMap(
messageTypeValidationObjectiveReferenceFilesMap, testDataTreeWrapper)) {
addReferenceFileNameToListInValidationObjectiveMap(
messageTypeValidationObjectiveReferenceFilesMap, testDataTreeWrapper);
} else {
addValidationObjectiveToMap(
messageTypeValidationObjectiveReferenceFilesMap, testDataTreeWrapper);
}
} else {
addMessageTypeToMap(messageTypeValidationObjectiveReferenceFilesMap, testDataTreeWrapper);
}
}
}
return messageTypeValidationObjectiveReferenceFilesMap;
}
@Override
protected List<State> doInBackground(Void... params) {
try {
// The URL for making the GET request
final String url = getString(R.string.base_uri) + "/states";
// Set the Accept header for "application/json"
HttpHeaders requestHeaders = new HttpHeaders();
List<MediaType> acceptableMediaTypes = new ArrayList<MediaType>();
acceptableMediaTypes.add(MediaType.APPLICATION_JSON);
requestHeaders.setAccept(acceptableMediaTypes);
// Populate the headers in an HttpEntity object to use for the request
HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
// Create a new RestTemplate instance
RestTemplate restTemplate = new RestTemplate();
// Perform the HTTP GET request
ResponseEntity<State[]> responseEntity =
restTemplate.exchange(url, HttpMethod.GET, requestEntity, State[].class);
// convert the array to a list and return it
return Arrays.asList(responseEntity.getBody());
} catch (Exception e) {
Log.e(TAG, e.getMessage(), e);
}
return null;
}
public JHttpResponse execute(JHttpEndpoint endpoint) {
URI endpointURI = endpoint.getURI();
RequestEntity requestEntity = mapToRequestEntity(endpointURI);
ResponseEntity responseEntity =
restTemplate.exchange(endpointURI, HttpMethod.GET, requestEntity, byte[].class);
return mapToJHttpResponse(responseEntity);
}
@Override
public OrderDetailDTO payComplete(AliPayNotifyDTO notify) throws ApiLogicException {
ResponseEntity<Response<OrderDetailDTO>> responseEntity;
try {
responseEntity =
restTemplate.exchange(
this.buildBizAppURI(
APPURIConstant.Order.REQUEST_MAPPING,
APPURIConstant.Order.REQUEST_MAPPING_PAY_BACK),
HttpMethod.POST,
new HttpEntity<AliPayNotifyDTO>(notify),
new ParameterizedTypeReference<Response<OrderDetailDTO>>() {});
} catch (Exception e) {
log.error(e.getMessage(), e);
throw new ApiLogicException("未找到订单", HttpStatus.BAD_REQUEST);
}
Response<OrderDetailDTO> response = responseEntity.getBody();
if (!response.isSuccess() || response.getData() == null) {
throw new ApiLogicException("未找到订单", HttpStatus.BAD_REQUEST);
}
return response.getData();
}
public static void createDoctorListByAdmin() throws JsonProcessingException {
// speciality.setId(2);
// doctor.setSpeciality(speciality);
ObjectMapper mapper = new ObjectMapper();
RestTemplate restTemplate = new RestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.set("auth-token", StaticStrings.ADMIN_AUTH_TOKEN);
List<Integer> ids = new ArrayList<>();
ids.add(17);
ids.add(18);
doctor.setInstitutionIds(ids);
doctor2.setInstitutionIds(ids);
List<Doctor> list = new ArrayList<>();
list.add(doctor);
list.add(doctor2);
HttpEntity entity = new HttpEntity(list, headers);
// System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(entity.getBody()));
HttpEntity<Response> response =
restTemplate.exchange(
StaticStrings.CREATE_DOCTOR_LIST_URI, HttpMethod.POST, entity, Response.class);
mapper = new ObjectMapper();
System.out.println(
mapper.writerWithDefaultPrettyPrinter().writeValueAsString(entity.getBody()));
System.out.println(
mapper.writerWithDefaultPrettyPrinter().writeValueAsString(response.getBody()));
}
private TermList getTermlist() {
// TODO Auto-generated method stub
MultiValueMap<String, String> body = new LinkedMultiValueMap<String, String>();
ResponseEntity<TermList> responseEntity = null;
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.setAccept(Collections.singletonList(new MediaType("application", "xml")));
HttpEntity<?> requestEntity = new HttpEntity<Object>(body, requestHeaders);
String newurl = "http://www.dcapp.org/export/category.xml";
try {
RestTemplate restTemplate = new DCAppRestTemplate(10000);
SimpleXmlHttpMessageConverter converter = new SimpleXmlHttpMessageConverter();
HttpMessageConverter<?> formHttpMessageConverter = new FormHttpMessageConverter();
HttpMessageConverter<?> stringHttpMessageConverternew = new StringHttpMessageConverter();
restTemplate.getMessageConverters().add(converter);
restTemplate.getMessageConverters().add(formHttpMessageConverter);
restTemplate.getMessageConverters().add(stringHttpMessageConverternew);
// responseEntity = restTemplate.exchange(this.url, HttpMethod.POST, requestEntity,
// TermList.class);
responseEntity =
restTemplate.exchange(newurl, HttpMethod.GET, requestEntity, TermList.class);
} catch (RestClientException e) {
Log.e("DirectoryFragment", "Exception while retrieving terms listing.", e.getCause());
}
TermList terms = responseEntity.getBody();
terms.setIsParent();
return terms;
}
@Override
protected Message doInBackground(Void... params) {
final String url = getString(R.string.base_uri) + "/getmessage";
// Populate the HTTP Basic Authentitcation header with the username and password
HttpAuthentication authHeader = new HttpBasicAuthentication(username, password);
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.setAuthorization(authHeader);
requestHeaders.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
// Create a new RestTemplate instance
RestTemplate restTemplate = new RestTemplate();
restTemplate.getMessageConverters().add(new MappingJacksonHttpMessageConverter());
try {
// Make the network request
Log.d(TAG, url);
ResponseEntity<Message> response =
restTemplate.exchange(
url, HttpMethod.GET, new HttpEntity<Object>(requestHeaders), Message.class);
return response.getBody();
} catch (HttpClientErrorException e) {
Log.e(TAG, e.getLocalizedMessage(), e);
return new Message(0, e.getStatusText(), e.getLocalizedMessage());
} catch (ResourceAccessException e) {
Log.e(TAG, e.getLocalizedMessage(), e);
return new Message(0, e.getClass().getSimpleName(), e.getLocalizedMessage());
}
}
@Test
public void putTest() throws RestClientException, URISyntaxException {
String url = dirFrontEnd + "/empresa/nifPrueba";
String acceptHeaderValue = "application/json";
HttpHeaders requestHeaders = new HttpHeaders();
List<MediaType> mediaTypes = new ArrayList<MediaType>();
mediaTypes.add(MediaType.valueOf(acceptHeaderValue));
requestHeaders.setAccept(mediaTypes);
requestHeaders.setContentType(MediaType.valueOf(acceptHeaderValue));
HttpMethod put = HttpMethod.PUT;
String body = "{\"nombre\":\"nombrePruebaModificado\"}";
HttpEntity<String> entity = new HttpEntity<String>(body, requestHeaders);
ResponseEntity<String> response = restTemplate.exchange(url, put, entity, String.class);
assertTrue(response.getStatusCode().equals(HttpStatus.NO_CONTENT));
String nombreEmpresa =
(String)
jdbcTemplate.queryForObject(
"SELECT NOMBRE FROM EMPRESA WHERE NIF= ?",
new Object[] {"nifPrueba"},
String.class);
assertTrue(nombreEmpresa.equals("nombrePruebaModificado"));
}
/**
* Call recurly API.
*
* @param <T> the generic type
* @param <E> the element type
* @param path the path
* @param payload the payload
* @param responseClass the response class
* @param method the method
* @param headers the headers
* @return the t
* @throws RecurlyException the recurly exception
*/
protected <T, E> T call(
String path, E payload, Class<T> responseClass, HttpMethod method, HttpHeaders headers)
throws RecurlyException {
URI uri = null;
ResponseEntity<T> responseEntity = null;
T reponse = null;
HttpEntity<?> entity = null;
try {
if (headers == null) {
entity = new HttpEntity<>(payload, recurly.getRecurlyHeaders());
} else {
entity = new HttpEntity<>(payload, headers);
}
uri = new URI(URIUtil.encodeQuery(recurly.getRecurlyServerURL() + path, "UTF-8"));
getLogger().debug("Calling Recurly URL {}, method: {}", uri.toString(), method.toString());
responseEntity = restTemplate.exchange(uri, method, entity, responseClass);
if (responseEntity != null) reponse = responseEntity.getBody();
} catch (URIException | UnsupportedEncodingException | URISyntaxException e) {
throw new RecurlyException("Not able to reach recurly. Please check the URL.", e);
} catch (RestClientException e) {
String err = ((HttpStatusCodeException) e).getResponseBodyAsString();
int code = ((HttpStatusCodeException) e).getStatusCode().value();
publishError(uri.toString(), err, code);
RecurlyException ex = handleError(err, code, e);
throw ex;
}
return reponse;
}
private void getDCAppTerms() {
final String url = "http://www.dcapp.org/rest/taxonomy_vocabulary/getTree";
MultiValueMap<String, String> body = new LinkedMultiValueMap<String, String>();
body.add("vid", "12");
ResponseEntity<TermList> responseEntity = null;
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.setAccept(Collections.singletonList(new MediaType("application", "xml")));
HttpEntity<?> requestEntity = new HttpEntity<Object>(body, requestHeaders);
TermList termlist = null;
try {
RestTemplate restTemplate = new DCAppRestTemplate(10 * 1000);
SimpleXmlHttpMessageConverter converter = new SimpleXmlHttpMessageConverter();
HttpMessageConverter formHttpMessageConverter = new FormHttpMessageConverter();
HttpMessageConverter stringHttpMessageConverternew = new StringHttpMessageConverter();
restTemplate.getMessageConverters().add(converter);
restTemplate.getMessageConverters().add(formHttpMessageConverter);
restTemplate.getMessageConverters().add(stringHttpMessageConverternew);
responseEntity = restTemplate.exchange(url, HttpMethod.POST, requestEntity, TermList.class);
termlist = responseEntity.getBody();
} catch (RestClientException e) {
Log.e("DirectoryFragment", "Exception while retrieving terms listing.", e.getCause());
}
if (termlist != null) {
termlist.setIsParent();
DCAppApplication app = (DCAppApplication) getApplication();
app.setTermList(termlist);
}
}
@Override
public OrderDetailDTO findOne(String id) throws ApiLogicException {
ResponseEntity<Response<OrderDetailDTO>> responseEntity;
try {
responseEntity =
restTemplate.exchange(
this.buildBizAppURI(
APPURIConstant.Order.REQUEST_MAPPING,
APPURIConstant.Order.REQUEST_MAPPING_FIND_BY_ID),
HttpMethod.GET,
null,
new ParameterizedTypeReference<Response<OrderDetailDTO>>() {},
id);
} catch (Exception e) {
log.error(e.getMessage(), e);
throw new ApiLogicException("订单未找到", HttpStatus.NOT_FOUND);
}
Response<OrderDetailDTO> response = responseEntity.getBody();
if (!response.isSuccess() || response.getData() == null) {
throw new ApiLogicException("订单未找到", HttpStatus.NOT_FOUND);
}
return response.getData();
}
@Override
protected Object doInBackground(Object[] params) {
try {
RestTemplate restTemplate = new RestTemplate();
restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
HttpHeaders requestHeaders = new HttpHeaders();
String restUrl = ServerConstants.SERVER_API_URL + "user/login";
User user = new User(username, password);
SingleUser singleUser = new SingleUser();
singleUser.setUser(user);
HttpEntity<SingleUser> requestEntity = new HttpEntity<>(singleUser, requestHeaders);
ResponseEntity<Boolean> responseEntity =
restTemplate.exchange(restUrl, HttpMethod.POST, requestEntity, Boolean.class);
boolean loginSuccessful = responseEntity.getBody();
Log.d("Login", Boolean.toString(loginSuccessful));
return loginSuccessful;
} catch (Exception ex) {
ex.printStackTrace();
return false;
}
}
@Override
public Response<PageDTO<OrderDetailDTO>> listByAccount(
String account, String clientId, PageRequestDTO pageRequest) {
OrderRequestDTO requestDTO = new OrderRequestDTO();
requestDTO.setAccount(account);
requestDTO.setClientId(clientId);
requestDTO.setPageRequest(pageRequest);
ResponseEntity<Response<PageDTO<OrderDetailDTO>>> responseEntity;
try {
responseEntity =
restTemplate.exchange(
this.buildBizAppURI(
APPURIConstant.Order.REQUEST_MAPPING,
APPURIConstant.Order.REQUEST_MAPPING_FIND_BY_ACCOUNT_AND_APP_ID),
HttpMethod.POST,
new HttpEntity<OrderRequestDTO>(requestDTO),
new ParameterizedTypeReference<Response<PageDTO<OrderDetailDTO>>>() {});
} catch (Exception e) {
log.error(e.getMessage(), e);
throw new ApiLogicException("未找到订单", HttpStatus.BAD_REQUEST);
}
Response<PageDTO<OrderDetailDTO>> response = responseEntity.getBody();
if (!response.isSuccess() || response.getData() == null) {
throw new ApiLogicException("未找到订单", HttpStatus.BAD_REQUEST);
}
return response;
}
@Test
public void postTest() throws RestClientException, URISyntaxException {
String url = dirFrontEnd + "/empresa/";
String acceptHeaderValue = "application/json";
HttpHeaders requestHeaders = new HttpHeaders();
List<MediaType> mediaTypes = new ArrayList<MediaType>();
mediaTypes.add(MediaType.valueOf(acceptHeaderValue));
requestHeaders.setAccept(mediaTypes);
requestHeaders.setContentType(MediaType.valueOf(acceptHeaderValue));
HttpMethod post = HttpMethod.POST;
String body =
"{\"nif\":\"nifPrueba\",\"nombre\":\"nombrePrueba\",\"direccionFiscal\":\"DirPrueba\",\"fechaInicioActividades\":\"2014-01-10\",\"version\":\"0\"}";
HttpEntity<String> entity = new HttpEntity<String>(body, requestHeaders);
ResponseEntity<String> response = restTemplate.exchange(url, post, entity, String.class);
assertTrue(response.getStatusCode().equals(HttpStatus.CREATED));
String nombreEmpresa =
(String)
jdbcTemplate.queryForObject(
"SELECT NOMBRE FROM EMPRESA WHERE NIF= ?",
new Object[] {"nifPrueba"},
String.class);
assertTrue(nombreEmpresa.equals("nombrePrueba"));
}
@Test
public void testOverwriteContentTypeHeader() {
HttpMessageSender messageSender = new HttpMessageSender();
String requestUrl = "http://localhost:8088/test";
final String responseBody = "<TestResponse><Message>Hello World!</Message></TestResponse>";
messageSender.setReplyMessageHandler(replyMessageHandler);
messageSender.setRequestMethod(HttpMethod.POST);
messageSender.setRequestUrl(requestUrl);
messageSender.setContentType("text/xml");
messageSender.setCharset("ISO-8859-1");
Message<?> requestMessage =
MessageBuilder.withPayload("<TestRequest><Message>Hello World!</Message></TestRequest>")
.setHeader("Content-Type", "application/xml;charset=UTF-8")
.setHeader("Accept", "application/xml")
.build();
messageSender.setRestTemplate(restTemplate);
reset(restTemplate, replyMessageHandler);
restTemplate.setErrorHandler(anyObject(ResponseErrorHandler.class));
expectLastCall().once();
expect(
restTemplate.exchange(
eq(requestUrl), eq(HttpMethod.POST), anyObject(HttpEntity.class), eq(String.class)))
.andAnswer(
new IAnswer<ResponseEntity<String>>() {
public ResponseEntity<String> answer() throws Throwable {
HttpEntity<?> httpRequest = (HttpEntity<?>) getCurrentArguments()[2];
Assert.assertEquals(
httpRequest.getBody().toString(),
"<TestRequest><Message>Hello World!</Message></TestRequest>");
Assert.assertEquals(httpRequest.getHeaders().size(), 2);
Assert.assertEquals(
httpRequest.getHeaders().getContentType().toString(),
"application/xml;charset=UTF-8");
Assert.assertEquals(
httpRequest.getHeaders().getAccept().get(0).toString(), "application/xml");
return new ResponseEntity<String>(responseBody, HttpStatus.OK);
}
})
.once();
replyMessageHandler.onReplyMessage(anyObject(Message.class));
expectLastCall().once();
replay(restTemplate, replyMessageHandler);
messageSender.send(requestMessage);
verify(restTemplate, replyMessageHandler);
}
@Test
public void testRestTemplateClient() throws Exception {
String[] uriVariables = {"aaaa签名", "001"};
ResponseEntity<String> exchange =
restTemplate.exchange(TEST_URL_ONE, HttpMethod.POST, null, String.class, uriVariables);
log.info(exchange.getBody());
assertEquals(exchange.getStatusCode(), HttpStatus.OK);
}
@Override
public String delete(Customer entity) {
final String url = BASE_URL + "customer/delete/" + entity.getId().toString();
HttpEntity<Customer> requestEntity = new HttpEntity<Customer>(entity, requestHeaders);
ResponseEntity<String> responseEntity =
restTemplate.exchange(url, HttpMethod.PUT, requestEntity, String.class);
return responseEntity.getBody();
}
@Override
public JHttpResponse execute(JHttpEndpoint endpoint, JHttpQuery query) {
if (query == null) return execute(endpoint);
URI endpointURI = endpoint.getURI(query.getPath(), query.getQueryParams());
RequestEntity requestEntity = mapToRequestEntity(query, endpointURI);
ResponseEntity responseEntity;
if (query.getResponseBodyType() != null) {
responseEntity =
restTemplate.exchange(
endpointURI, query.getMethod(), requestEntity, query.getResponseBodyType());
} else {
responseEntity =
restTemplate.exchange(endpointURI, query.getMethod(), requestEntity, byte[].class);
}
return mapToJHttpResponse(responseEntity);
}
@Override
public T getById(String endpoint, Long id, Class clazz) {
RestTemplate template = new RestTemplate();
@SuppressWarnings("unchecked")
ResponseEntity<T> city =
template.exchange(endpoint + "/" + id, HttpMethod.GET, RequestEntity.EMPTY, clazz);
return city.getBody();
}
@Override
public String delete(Subject entity) {
final String url = BASE_URL + "subject/delete/" + entity.getId().toString();
HttpEntity<Subject> requestEntity = new HttpEntity<Subject>(entity, requestHeaders);
ResponseEntity<String> responseEntity =
restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, String.class);
return responseEntity.getBody();
}
@Override
public Customer get(Long id) {
final String url = BASE_URL + "customer/" + id.toString();
HttpEntity<Customer> requestEntity = new HttpEntity<Customer>(requestHeaders);
ResponseEntity<Customer> responseEntity =
restTemplate.exchange(url, HttpMethod.GET, requestEntity, Customer.class);
Customer subject = responseEntity.getBody();
return subject;
}
@Override
public String post(Customer entity) {
final String url = BASE_URL + "customer/create";
HttpEntity<Customer> requestEntity = new HttpEntity<Customer>(entity, requestHeaders);
ResponseEntity<String> responseEntity =
restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
String result = responseEntity.getBody();
return result;
}
@Override
public Subject get(Long id) {
final String url = BASE_URL + "subject/" + id.toString();
HttpEntity<Subject> requestEntity = new HttpEntity<Subject>(requestHeaders);
ResponseEntity<Subject> responseEntity =
restTemplate.exchange(url, HttpMethod.GET, requestEntity, Subject.class);
Subject subject = responseEntity.getBody();
return subject;
}
public int getEventCount() throws IOException {
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.set("Accept", "application/json");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
ResponseEntity<String> entity =
template.exchange(url, HttpMethod.GET, requestEntity, String.class);
return new ObjectMapper().readTree(entity.getBody()).get("count").getIntValue();
}