Subversion Repositories SmartDukaan

package in.shop2020.payment.service.handler;

import in.shop2020.crm.CRMService.Client;

import in.shop2020.payment.domain.Refund;

import in.shop2020.payment.handler.PaymentGatewayHandler;

import in.shop2020.payment.handler.PaymentHandler;

import in.shop2020.payment.handler.RefundHandler;

import in.shop2020.payments.Attribute;

import in.shop2020.payments.Payment;

import in.shop2020.payments.PaymentException;

import in.shop2020.payments.PaymentGateway;

import in.shop2020.payments.PaymentService.Iface;

import in.shop2020.payments.PaymentStatus;

import in.shop2020.thrift.clients.CRMClient;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.thrift.TException;

import org.apache.thrift.transport.TTransportException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class PaymentServiceHandler implements Iface {

    private static Logger logger = LoggerFactory.getLogger(PaymentServiceHandler.class);

    /**

     * Enum of all statuses that can be returned by the HDFC gateway

     * 

     * @author Chandranshu

     * 

     */

    private enum HdfcPaymentReturnStatus{

        APPROVED("APPROVED"),

        NOT_APPROVED("NOT APPROVED"),

        CAPTURED("CAPTURED"),

        NOT_CAPTURED ("NOT CAPTURED"),

        CANCELLED ("CANCELLED"),

        DENIED_BY_RISK("DENIED BY RISK"),

        HOST_TIMEOUT("HOST TIMEOUT");

        private String value;

        HdfcPaymentReturnStatus(String value) {

            this.value = value;

        }

        public String value(){

            return this.value;

        }

    }

	public static final long PAYMENT_NOT_CREATED = -1;

	private static final long HDFC_GATEWAY_ID = 1;

	private static final long EBS_GATEWAY_ID = 2;

	ApplicationContext context = new ClassPathXmlApplicationContext("context.xml");

	PaymentHandler paymentHandler = (PaymentHandler) context.getBean("paymentHandler");

	PaymentGatewayHandler paymentGatewayHandler = (PaymentGatewayHandler) context.getBean("paymentGatewayHandler");

	RefundHandler refundHandler = (RefundHandler) context.getBean("refundHandler");

	@Override

	public void closeSession() throws TException {

		// TODO Auto-generated method stub		

	}

	@Override

	public long createPayment(long userId, double amount, long gatewayId, long txnId) throws PaymentException, TException {

	    logger.info("Creating payment corresponding to our txn id:" + txnId);

		in.shop2020.payment.domain.Payment payment = new in.shop2020.payment.domain.Payment();

		payment.setUserId(userId);

		payment.setAmount(amount);

		payment.setGatewayId(gatewayId);

		payment.setMerchantTxnId(txnId);

		payment.setStatus(PaymentStatus.INIT.getValue());

		return paymentHandler.insertPayment(payment);

	}

	@Override

	public List<Payment> getPaymentsForUser(long userId, long fromTime, long toTime, PaymentStatus status, long gatewayId) throws PaymentException, TException {

	    logger.info("Getting payments from " + fromTime + " to " + toTime + " for user: " + userId);

		int statusValue = -1;

		if(status != null)

			statusValue = status.getValue();

		else

			statusValue = -1;

		return getThriftPayments(paymentHandler.getPaymentsForUser(userId, fromTime, toTime, statusValue, gatewayId));

	}

	@Override

	public List<Payment> getPayments(long fromTime, long toTime, PaymentStatus status, long gatewayId) throws PaymentException,	TException {

	    logger.info("Getting payments from " + fromTime + " to " + toTime);

		int statusValue = -1;

		if(status != null)

			statusValue = status.getValue();

		else

			statusValue = -1;

		return getThriftPayments(paymentHandler.getPayments(fromTime, toTime, statusValue, gatewayId));

	}

	@Override

	public PaymentGateway getPaymentGateway(long id) throws PaymentException, TException {

	    logger.info("Getting payment gateway with id:" + id);

		return paymentGatewayHandler.getPaymentGateway(id).getThriftPaymentGateway();

	}

	@Override

	public Payment getPayment(long id) throws PaymentException, TException {

	    logger.info("Getting payment with id: " + id);

		return paymentHandler.getPayment(id).getThriftPayment();

	}

	@Override

	public List<Payment> getPaymentForTxnId(long txnId) throws PaymentException, TException {

	    logger.info("Getting payment for the txn id: " + txnId);

		return getThriftPayments(paymentHandler.getPaymentForTxn(txnId));

	}

	@Override

	public boolean updatePaymentDetails(long id, String gatewayPaymentId,

			String sessionId, String gatewayTxnStatus, String description,

			String gatewayTxnId, String authCode, String referenceCode,

			String errorCode, PaymentStatus status, String gatewayTxnDate,

			List<Attribute> attributes) throws PaymentException, TException {

	    logger.info("Updating details of payment id: " + id);

		in.shop2020.payment.domain.Payment payment = paymentHandler.getPayment(id);

		payment.setGatewayPaymentId(gatewayPaymentId);

		payment.setSessionId(sessionId);

		payment.setGatewayTxnStatus(gatewayTxnStatus);

		payment.setDescription(description);

		payment.setGatewayTxnId(gatewayTxnId);

		payment.setAuthCode(authCode);

		payment.setReferenceCode(referenceCode);

		payment.setErrorCode(errorCode);

		if(status!=null){

			payment.setStatus(status.getValue());

			if(status.equals(PaymentStatus.SUCCESS))

				payment.setSuccessTimestamp(new Date());

			else if(status.equals(PaymentStatus.FAILED)) {

			    payment.setErrorTimestamp(new Date());

			    createTicketForFailedPayment(payment);

			}

		}

		payment.setGatewayTxnDate(gatewayTxnDate);

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

		if(attributes != null){

			for(Attribute attribute : attributes){

				attrMap.put(attribute.getName(), attribute.getValue());

			}

		}

		paymentHandler.updatePayment(payment, attrMap);

		return true;

	}

	// Creates tickets for payment failures in CRM

	private void createTicketForFailedPayment(in.shop2020.payment.domain.Payment payment) {

        try {

            Client crmClient = new CRMClient().getClient();

            crmClient.processPaymentFailure(payment.getUserId());

        } catch (TTransportException e) {

            logger.error("Could not create CRM client", e);

        } catch (TException e) {

            logger.error("Could not process paymentId: " + payment.getId(), e);

        }

    }

    @Override

	public List<Double> getSuccessfulPaymentsAmountRange() throws TException {

	    logger.info("Getting the range of successful payments.");

		List<Double> minMaxAmounts = new ArrayList<Double>();

		Map<String, Float> minMax = paymentHandler.getMinMaxPaymentAmount();

		minMaxAmounts.add(Double.parseDouble(Float.toString(minMax.get("MIN"))));

		minMaxAmounts.add(Double.parseDouble(Float.toString(minMax.get("MAX"))));

		return minMaxAmounts;

	}

	@Override

	public String initializeHdfcPayment(long merchantPaymentId) throws PaymentException, TException {

	    logger.info("Initializing HDFC payment with id: " + merchantPaymentId);

		in.shop2020.payment.domain.Payment payment = paymentHandler.getPayment(merchantPaymentId);

		String redirectURL;

		try {

			redirectURL = HdfcPaymentHandler.initializeHdfcPayment(payment, this);

		} catch (Exception e) {

			throw new PaymentException(102, "Error while initiliazing payment. Check service log for more details.");

		}

		return redirectURL;

	}

	@Override

	public Map<String, String> captureHdfcPayment(long merchantPaymentId) throws PaymentException, TException {

	    logger.info("Capturing HDFC payment with id: " + merchantPaymentId);

		in.shop2020.payment.domain.Payment payment = paymentHandler.getPayment(merchantPaymentId);

		return HdfcPaymentHandler.capturePayment(payment);

	}

	@Override

	public Map<String, String> captureEbsPayment(long merchantPaymentId) throws PaymentException, TException {

	    logger.info("Capturing EBS payment with id: " + merchantPaymentId);

		in.shop2020.payment.domain.Payment payment = paymentHandler.getPayment(merchantPaymentId);

		return EbsPaymentHandler.capturePayment(payment);

	}

	@Override

    public long createRefund(long orderId, long merchantTxnId, double amount) throws PaymentException, TException{

	    logger.info("Attempting to create a refund for order: " + orderId);

		List<in.shop2020.payment.domain.Payment> payments = paymentHandler.getPaymentForTxn(merchantTxnId);

		if(payments ==null || payments.isEmpty())

			throw new PaymentException(104, "No payments found corresponding to the merchant txn " + merchantTxnId);

		in.shop2020.payment.domain.Payment payment = payments.get(0);

		if(payment.getStatus() != PaymentStatus.SUCCESS.getValue())

			throw new PaymentException(104, "No successful payments found corresponding to the merchant txn " + merchantTxnId);

		Refund refund = new Refund();

		refund.setOrderId(orderId);

		refund.setPaymentId(payment.getId());

		refund.setGatewayId(payment.getGatewayId());

		refund.setAmount(amount);

		refund.setAttempts(0);

		return refundHandler.createRefund(refund);

    }

    @Override

    public boolean capturePayment(long merchantTxnId) throws PaymentException, TException {

        logger.info("Attempting to capture payment corresponding to our transaction " + merchantTxnId);

        List<in.shop2020.payment.domain.Payment> payments = paymentHandler.getPaymentForTxn(merchantTxnId);

        if(payments ==null || payments.isEmpty())

            throw new PaymentException(104, "No payments found corresponding to the merchant txn " + merchantTxnId);

        in.shop2020.payment.domain.Payment payment = payments.get(0);

        switch(PaymentStatus.findByValue(payment.getStatus())){

        case PENDING:

            logger.error("Attempt to capture a non-authorized payment");

            return false;

        case INIT:

            logger.warn("Attempt to capture a non-authorized payment");

            return false;

        case AUTHORIZED:

            //Actual work to be done in this case. Let the call proceed.

            break;

        case SUCCESS:

            logger.warn("Attempting to capture an already captured payment but we can let the client proceed.");

            return true;

        case FAILED:

            logger.error("Attempting to capture a failed payment");

            return false;

        }

        long gatewayId = payment.getGatewayId();

        if(gatewayId == HDFC_GATEWAY_ID){

            //Capture and update the HDFC payment

            return captureAndUpdateHdfcPayment(payment);

        } else if (gatewayId == EBS_GATEWAY_ID){

            //Capture and update the EBS payment

            return captureAndUpdateEbsPayment(payment);

        }

        logger.error("We have an authorized payment from unknown gateway: " + gatewayId);

        return false;

    }

    /**

     * Capture the HDFC payment represented by the given payment object. If the

     * capture attempt is not successful, we mark this payment as failed. We

     * don't retry or anything. We'll add the support of multiple attempts later

     * on.

     * 

     * @param payment The payment which has to be captured.

     * @return True if the payment attempt is successful, false if not.

     */

    private boolean captureAndUpdateHdfcPayment(in.shop2020.payment.domain.Payment payment){

        long merchantPaymentId = payment.getId();

        logger.info("Capturing HDFC payment with id: " + merchantPaymentId);

        Map<String, String> captureResult = HdfcPaymentHandler.capturePayment(payment);

        String captureStatus = captureResult.get(IPaymentHandler.STATUS);

        String gatewayStatus = captureResult.get(IPaymentHandler.GATEWAY_STATUS);

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

        if (!captureStatus.trim().equals("0") 

                || !HdfcPaymentReturnStatus.CAPTURED.value().equals(gatewayStatus)) {

            // Failure

            logger.info("Capture attempt failed for HDFC payment with id: " + merchantPaymentId);

            String description = captureResult.get(IPaymentHandler.ERROR);

            String errorCode = captureResult.get(IPaymentHandler.ERR_CODE);

            payment.setDescription(description);

            payment.setErrorCode(errorCode);

            payment.setStatus(PaymentStatus.FAILED.getValue());

            payment.setErrorTimestamp(new Date());

            paymentHandler.updatePayment(payment, attrMap);

            createTicketForFailedPayment(payment);

            return false;

        } else {

            // Success

            logger.error("Capture attempt successful for HDFC payment with id: " + merchantPaymentId);

            payment.setDescription("Payment Captured");

            payment.setGatewayTxnStatus(gatewayStatus);

            payment.setStatus(PaymentStatus.SUCCESS.getValue());

            payment.setSuccessTimestamp(new Date());           

            attrMap.put(IPaymentHandler.CAPTURE_TXN_ID, captureResult.get(IPaymentHandler.CAPTURE_TXN_ID));

            attrMap.put(IPaymentHandler.CAPTURE_REF_ID, captureResult.get(IPaymentHandler.CAPTURE_REF_ID));

            attrMap.put(IPaymentHandler.CAPTURE_AUTH_ID, captureResult.get(IPaymentHandler.CAPTURE_AUTH_ID));

            SimpleDateFormat captureTimeDateFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            attrMap.put(HdfcPaymentHandler.CAPTURE_TIME, captureTimeDateFormatter.format(new Date()));

            paymentHandler.updatePayment(payment, attrMap);

            return true;

          }

    }

    /**

     * Capture the EBS payment represented by the given payment object. If the

     * capture attempt is not successful, we mark this payment as failed. We

     * don't retry or anything. We'll add the support of multiple attempts later

     * on.

     * 

     * @param payment The payment which has to be captured.

     * @return True if the payment attempt is successful, false if not.

     */

    private boolean captureAndUpdateEbsPayment(in.shop2020.payment.domain.Payment payment){

        Map<String, String> captureResult = EbsPaymentHandler.capturePayment(payment);

        String captureStatus = captureResult.get(EbsPaymentHandler.STATUS);

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

        if("".equals(captureStatus)){

            //Failure

            String description = captureResult.get(EbsPaymentHandler.ERROR);

            String errorCode = captureResult.get(EbsPaymentHandler.ERR_CODE);

            payment.setDescription(description);

            payment.setErrorCode(errorCode);

            payment.setStatus(PaymentStatus.FAILED.getValue());

            payment.setErrorTimestamp(new Date());

            paymentHandler.updatePayment(payment, attrMap);

            createTicketForFailedPayment(payment);

            return false;

        }else{

            //Success

            payment.setGatewayTxnStatus(captureStatus);

            payment.setStatus(PaymentStatus.SUCCESS.getValue());

            payment.setSuccessTimestamp(new Date());

            attrMap.put(IPaymentHandler.CAPTURE_TXN_ID, captureResult.get(IPaymentHandler.CAPTURE_TXN_ID));

            attrMap.put(IPaymentHandler.CAPTURE_TIME, captureResult.get(IPaymentHandler.CAPTURE_TIME));

            paymentHandler.updatePayment(payment, attrMap);

            return true;

        }

    }

    /**

     * Creates a list of thrift payment objects corresponding to a list of

     * payment data objects.

     * 

     * @param daoPayments

     *            A list of payment DAO.

     * @return A list of Thrift payment objects.

     */

    private List<Payment> getThriftPayments(List<in.shop2020.payment.domain.Payment> daoPayments){

        List<Payment> payments = new ArrayList<Payment>();

        for(in.shop2020.payment.domain.Payment payment : daoPayments){

            payments.add(payment.getThriftPayment());

        }

        return payments;

    }

	@Override

	public boolean isAlive() throws TException {

		// TODO Auto-generated method stub

		return true;

	}

}