Subversion Repositories SmartDukaan

package in.shop2020.payment.service.handler;

import in.shop2020.thrift.clients.config.ConfigClient;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.lang.reflect.Type;

import java.math.BigDecimal;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.http.HttpResponse;

import org.apache.http.NameValuePair;

import org.apache.http.client.HttpClient;

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

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

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

import org.apache.log4j.Logger;

import com.google.gson.Gson;

import com.google.gson.GsonBuilder;

import com.google.gson.JsonArray;

import com.google.gson.JsonDeserializationContext;

import com.google.gson.JsonDeserializer;

import com.google.gson.JsonElement;

import com.google.gson.JsonObject;

import com.google.gson.JsonPrimitive;

public class PayuPaymentHandler implements IPaymentHandler {

	private static Logger log = Logger.getLogger(Class.class);

	public static final String TXN_ID = "transactionId";

	public static final String PAYMENT_ID = "paymentId";

	public static final String AMOUNT = "amount";

	public static final String DATE_TIME = "dateTime";

	public static final String MODE = "mode";

	public static final String REF_NO = "referenceNo";

	public static final String TXN_TYPE = "transactionType";

	private static String apiUrl;

	private static String accountId;

	private static String secretKey;

	static {

		try {

			ConfigClient cc = ConfigClient.getClient();

			accountId = cc.get("payu_account_id");

			secretKey = cc.get("payu_secret_key");

			apiUrl = cc.get("payu_api_url");

		} catch (Exception e) {

			log.error("Could not initialize Payu Handler!");

		}

	}

	public Map<String, String> captureTransaction(String paymentId,

			String payuId) throws Exception {

		Map<String, String> params = new HashMap<String, String>();

		Map<String, String> resultMap = new HashMap<String, String>();

		params.put("key", accountId);

		params.put("command", "capture_transaction");

		params.put("var1", payuId);

		params.put("var2", new Date().getTime() + "");

		try {

			params.put("hash", getSecureHash(params));

		} catch (Exception e) {

			resultMap.put(ERR_CODE, Errors.CONN_FAILURE.code);

			resultMap.put(ERROR, Errors.CONN_FAILURE.message);

			return resultMap;

		}

		String postResponse = "";

		try {

			postResponse = executePost(apiUrl, getUrlParams(params));

		} catch (Exception e) {

			resultMap.put(ERR_CODE, Errors.CONN_FAILURE.code);

			resultMap.put(ERROR, Errors.CONN_FAILURE.message);

		}

		GsonBuilder gsonBuilder = new GsonBuilder();

		gsonBuilder

				.registerTypeAdapter(Object.class, new NaturalDeserializer());

		Gson gson = gsonBuilder.create();

		Map<String, Object> postMap = (Map<String, Object>) gson.fromJson(

				postResponse, Object.class);

		if ("1".equals(postMap.get("status"))) {

			resultMap.put(CAPTURE_TXN_ID, params.get("var2"));

			resultMap.put(PAYMENT_ID, paymentId);

			resultMap.put(REF_NO, (String) postMap.get("bank_ref_num"));

		}

		if ("0".equals(equals(postMap.get("status"))

				&& "Capture request failed".equals(postMap.get("status")))) {

			resultMap.put(ERR_CODE, Errors.CAPTURE_FAILURE.code);

			resultMap.put(ERROR, Errors.CAPTURE_FAILURE.message);

		}

		return resultMap;

	}

	private List<NameValuePair> getUrlParams(Map<String, String> params) {

		// TODO Auto-generated method stub

		return null;

	}

	private String getSecureHash(Map<String, String> params)

			throws NoSuchAlgorithmException {

		StringBuffer sb = new StringBuffer();

		String passString = sb.append(params.get("key")).append("|")

				.append(params.get("command")).append("|")

				.append(params.get("var1")).append("|").append(secretKey)

				.toString();

		MessageDigest md = MessageDigest.getInstance("SHA-512");

		md.update(passString.getBytes(), 0, passString.getBytes().length);

		byte[] mdbytes = md.digest();

		// convert the byte to hex format method

		StringBuffer sbNew = new StringBuffer();

		for (int i = 0; i < mdbytes.length; i++) {

			sb.append(Integer.toString((mdbytes[i] & 0xff) + 0x100, 16)

					.substring(1));

		}

		return sb.toString();

	}

	public static String executePost(String targetURL,

			List<NameValuePair> nameValuePairs) throws Exception {

		HttpClient client = new DefaultHttpClient();

		HttpPost post = new HttpPost(targetURL);

		post.setEntity(new UrlEncodedFormEntity(nameValuePairs));

		HttpResponse response = client.execute(post);

		BufferedReader rd = new BufferedReader(new InputStreamReader(response

				.getEntity().getContent()));

		String line = "";

		StringBuffer sb = new StringBuffer();

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

			sb.append(line);

		}

		return sb.toString();

	}

	private static class NaturalDeserializer implements

			JsonDeserializer<Object> {

		public Object deserialize(JsonElement json, Type typeOfT,

				JsonDeserializationContext context) {

			if (json.isJsonNull())

				return null;

			else if (json.isJsonPrimitive())

				return handlePrimitive(json.getAsJsonPrimitive());

			else if (json.isJsonArray())

				return handleArray(json.getAsJsonArray(), context);

			else

				return handleObject(json.getAsJsonObject(), context);

		}

		private Object handlePrimitive(JsonPrimitive json) {

			if (json.isBoolean())

				return json.getAsBoolean();

			else if (json.isString())

				return json.getAsString();

			else {

				BigDecimal bigDec = json.getAsBigDecimal();

				// Find out if it is an int type

				try {

					bigDec.toBigIntegerExact();

					try {

						return bigDec.intValueExact();

					} catch (ArithmeticException e) {

					}

					return bigDec.longValue();

				} catch (ArithmeticException e) {

				}

				// Just return it as a double

				return bigDec.doubleValue();

			}

		}

		private Object handleArray(JsonArray json,

				JsonDeserializationContext context) {

			Object[] array = new Object[json.size()];

			for (int i = 0; i < array.length; i++)

				array[i] = context.deserialize(json.get(i), Object.class);

			return array;

		}

		private Object handleObject(JsonObject json,

				JsonDeserializationContext context) {

			Map<String, Object> map = new HashMap<String, Object>();

			for (Map.Entry<String, JsonElement> entry : json.entrySet())

				map.put(entry.getKey(),

						context.deserialize(entry.getValue(), Object.class));

			return map;

		}

	}

}