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.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.HttpClients;

import org.apache.http.message.BasicNameValuePair;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.http.HttpStatus;

import org.springframework.web.util.UriComponentsBuilder;

import com.spice.profitmandi.common.ResponseCodeHolder;

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

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

import com.spice.profitmandi.common.util.StringUtils;

public class RestClient {

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

	private HttpClient httpClient;

	private SchemeType scheme;

	private String hostName;

	private int port;

	private final String url;

	//private HttpHeaders headers;

	public RestClient(SchemeType scheme, String hostName, int port){

		this.scheme = scheme;

		this.hostName = hostName;

		this.port = port;

		this.url = scheme.getValue() == null ? SchemeType.HTTP.toString() : scheme.getValue()  + hostName + ":" + port + "/";

		//this.headers = new HttpHeaders();

		this.httpClient = HttpClients.createDefault();

		//headers.add("Content-Type", MediaType.APPLICATION_JSON_VALUE);

	}

	public SchemeType getScheme() {

		return scheme;

	}

	public String getHostName() {

		return hostName;

	}

	public int getPort() {

		return port;

	}

	public String getUrl() {

		return url;

	}

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

		throws ProfitMandiBusinessException, HttpHostConnectException{

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url + uri);

		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(String uri, Map<String, String> params)

			throws ProfitMandiBusinessException, HttpHostConnectException{

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url + uri);

		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 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{

				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 post(String uri, Map<String, String> params, Map<String, String> headers)

			throws ProfitMandiBusinessException, HttpHostConnectException{

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url + uri);

		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(builder.build().encode().toUri());

		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 postJson(String uri, Map<String, String> params, Map<String, String> headers)

			throws ProfitMandiBusinessException, HttpHostConnectException{

		UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url + uri);

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

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

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

		}

		String jsonString = null;

		try {

			jsonString = StringUtils.toString(params);

		} catch (Exception e) {

			e.printStackTrace();

		}

		StringEntity requestEntity = new StringEntity(

			    jsonString,

			    ContentType.APPLICATION_JSON);

		LOGGER.info("Body {}", jsonString);

		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.execute(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();

		}

		return responseString.toString();

	}

}