Subversion Repositories SmartDukaan

package com.spice.profitmandi.common.web.client;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.http.HttpResponse;

import org.apache.http.NameValuePair;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.config.RequestConfig;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.client.methods.HttpUriRequest;

import org.apache.http.conn.HttpHostConnectException;

import org.apache.http.entity.ContentType;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.HttpClientBuilder;

import org.apache.http.impl.client.HttpClients;

import org.apache.http.message.BasicNameValuePair;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.stereotype.Component;

import org.springframework.web.util.UriComponentsBuilder;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.spice.profitmandi.common.ResponseCodeHolder;

import com.spice.profitmandi.common.enumuration.SchemeType;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

@Component

public class RestClient {

	private static final Logger LOGGER = LogManager.getLogger(RestClient.class);

	private HttpClient httpClient;

	@Autowired

	ObjectMapper objectMapper;

	public RestClient() {

		this.httpClient = HttpClients.createDefault();

	}

	public RestClient(int connectionTimeoutMillis) {

		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5 * 1000).build();

		this.httpClient = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).build();

	}

	public String get(SchemeType scheme, String hostName, int port, String uri, Map<String, String> params,

			Map<String, String> headers) throws ProfitMandiBusinessException, HttpHostConnectException {

		String url = scheme.getValue() == null ? SchemeType.HTTP.toString()

				: scheme.getValue() + hostName + ":" + port + "/" + uri;

		return this.get(url, params, headers);

	}

	public String get(String url, Map<String, String> params, Map<String, String> headers)

			throws ProfitMandiBusinessException, HttpHostConnectException {

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url);

		if(params!=null) {

			Set<String> keys = params.keySet();

			for (String key : keys) {

				builder.queryParam(key, params.get(key));

			}

		}

		HttpGet request = new HttpGet(builder.build().encode().toUri());

		for (Map.Entry<String, String> entry : headers.entrySet()) {

			request.setHeader(entry.getKey(), entry.getValue());

		}

		return this.execute(request);

	}

	public String get(SchemeType scheme, String hostName, int port, String uri, Map<String, String> params)

			throws ProfitMandiBusinessException, HttpHostConnectException {

		String url = scheme.getValue() == null ? SchemeType.HTTP.toString()

				: scheme.getValue() + hostName + ":" + port + "/" + uri;

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url);

		if (params != null) {

			Set<String> keys = params.keySet();

			for (String key : keys) {

				builder.queryParam(key, params.get(key));

			}

		}

		HttpGet request = new HttpGet(builder.build().encode().toUri());

		return this.execute(request);

	}

	public HttpResponse getResponse(String url, Map<String, String> params, Map<String, String> headers)

			throws ProfitMandiBusinessException, HttpHostConnectException {

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url);

		Set<String> keys = params.keySet();

		for (String key : keys) {

			builder.queryParam(key, params.get(key));

		}

		HttpGet request = new HttpGet(builder.build().encode().toUri());

		if (headers != null) {

			for (Map.Entry<String, String> entry : headers.entrySet()) {

				request.setHeader(entry.getKey(), entry.getValue());

			}

		}

		try {

			LOGGER.info("Request uri is  {}", request.getURI().toString());

			HttpResponse response = httpClient.execute(request);

			LOGGER.info("Got response from server with responseCode {}", response.getStatusLine().getStatusCode());

			if (response.getStatusLine().getStatusCode() == HttpStatus.OK.value()) {

				return response;

			} else {

				throw new ProfitMandiBusinessException("", "", "GE_1005");

			}

		} catch (HttpHostConnectException httpHostConnectException) {

			LOGGER.error("Connection Timeout Exception", httpHostConnectException);

			throw httpHostConnectException;

		} catch (ClientProtocolException e) {

			LOGGER.error("Client Error : ", e);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		} catch (IOException e) {

			LOGGER.error("IO Error : ", e);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		}

	}

	public String execute(HttpUriRequest request) throws ProfitMandiBusinessException, HttpHostConnectException {

		LOGGER.info("Connecting to server at url {}", request.getURI());

		try {

			HttpResponse response = httpClient.execute(request);

			String responseString = this.toString(response.getEntity().getContent());

			LOGGER.info("Got response from server with responseCode {}", response.getStatusLine().getStatusCode());

			if (response.getStatusLine().getStatusCode() == HttpStatus.OK.value()) {

				return responseString;

			} else {

				LOGGER.info("Response String {} ", responseString);

				throw new ProfitMandiBusinessException("", "", "GE_1005");

			}

		} catch (HttpHostConnectException httpHostConnectException) {

			LOGGER.error("Connection Timeout Exception", httpHostConnectException);

			throw httpHostConnectException;

		} catch (ClientProtocolException e) {

			LOGGER.error("Client Error : ", e);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		} catch (IOException e) {

			LOGGER.error("IO Error : ", e);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		}

	}

	public String executeJson(HttpUriRequest request) throws ProfitMandiBusinessException, HttpHostConnectException {

		LOGGER.info("Connecting to server at url {}", request.getURI());

		try {

			HttpResponse response = httpClient.execute(request);

			String responseString = this.toString(response.getEntity().getContent());

			LOGGER.info("Got response from server with responseCode {}", response.getStatusLine().getStatusCode());

			return responseString;

		} catch (HttpHostConnectException httpHostConnectException) {

			LOGGER.error("Connection Timeout Exception", httpHostConnectException);

			throw httpHostConnectException;

		} catch (ClientProtocolException e) {

			LOGGER.error("Client Error : ", e);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		} catch (IOException e) {

			LOGGER.error("IO Error : ", e);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		}

	}

	public String post(SchemeType scheme, String hostName, int port, String uri, Map<String, String> params,

			Map<String, String> headers) throws ProfitMandiBusinessException, HttpHostConnectException {

		String url = scheme.getValue() == null ? SchemeType.HTTP.toString()

				: scheme.getValue() + hostName + ":" + port + "/" + uri;

		return this.post(url, params, headers);

	}

	public String post(String url, Map<String, String> params, Map<String, String> headers)

			throws ProfitMandiBusinessException, HttpHostConnectException {

		// UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url);

		List<NameValuePair> bodyParameters = new ArrayList<NameValuePair>();

		for (Map.Entry<String, String> entry : params.entrySet()) {

			bodyParameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));

		}

		LOGGER.info("Body Parameters {}", params);

		HttpPost request = new HttpPost(url);

		for (Map.Entry<String, String> entry : headers.entrySet()) {

			request.setHeader(entry.getKey(), entry.getValue());

		}

		try {

			request.setEntity(new UrlEncodedFormEntity(bodyParameters));

		} catch (UnsupportedEncodingException unsupportedEncodingException) {

			LOGGER.error("Encoding error : ", unsupportedEncodingException);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		}

		return this.execute(request);

	}

	public String post(String url, String body, Map<String, String> headers)

			throws ProfitMandiBusinessException, HttpHostConnectException {

		HttpPost request = new HttpPost(url);

		for (Map.Entry<String, String> entry : headers.entrySet()) {

			request.setHeader(entry.getKey(), entry.getValue());

		}

		try {

			request.setEntity(new StringEntity(body));

		} catch (UnsupportedEncodingException unsupportedEncodingException) {

			LOGGER.error("Encoding error : ", unsupportedEncodingException);

			throw new RuntimeException(ResponseCodeHolder.getMessage("GE_1006"));

		}

		return this.execute(request);

	}

	public String postJson(String url, Object object, Map<String, String> headers)

			throws ProfitMandiBusinessException, HttpHostConnectException {

		String jsonString;

		try {

			if (object.getClass().equals(String.class)) {

				jsonString = (String) object;

			} else {

				jsonString = objectMapper.writeValueAsString(object);

			}

			LOGGER.info("JSON String - {}", jsonString);

		} catch (Exception e) {

			e.printStackTrace();

			throw new ProfitMandiBusinessException("Json Object", object.toString(), "Could not write as String");

		}

		StringEntity requestEntity = new StringEntity(jsonString, ContentType.APPLICATION_JSON);

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url);

		HttpPost request = new HttpPost(builder.build().encode().toUri());

		for (Map.Entry<String, String> entry : headers.entrySet()) {

			request.setHeader(entry.getKey(), entry.getValue());

		}

		request.setEntity(requestEntity);

		return this.executeJson(request);

	}

	private String toString(InputStream inputStream) {

		BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

		StringBuilder responseString = new StringBuilder();

		String line = null;

		try {

			while ((line = reader.readLine()) != null) {

				responseString.append(line);

			}

			inputStream.close();

		} catch (IOException e) {

			throw new RuntimeException();

		} finally {

		}

		return responseString.toString();

	}

}