Subversion Repositories SmartDukaan

package in.shop2020.serving.controllers;

import in.shop2020.config.ConfigException;
import in.shop2020.model.v1.order.RechargeOrder;
import in.shop2020.model.v1.order.RechargeOrderStatus;
import in.shop2020.model.v1.order.TransactionServiceException;
import in.shop2020.payments.Payment;
import in.shop2020.payments.PaymentException;
import in.shop2020.payments.PaymentStatus;
import in.shop2020.serving.utils.ebs.Base64;
import in.shop2020.serving.utils.ebs.RC4;
import in.shop2020.thrift.clients.PaymentClient;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.thrift.clients.UserClient;
import in.shop2020.thrift.clients.config.ConfigClient;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;
import org.apache.thrift.TException;

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

    private static final String FLAG_KEY = "IsFlagged";
    private static final String TXN_KEY = "TransactionID";
    private static final String AUTH_TXN_ID = "AuthTxnId";

    private static String successUrl;
    private static String errorUrl;
    private static String rechargeResultUri;
    private RechargeOrder rechargeOrder = null;

    /**
     * The secret key used to decode RC4 encoded data.
     */
    private static String accountKey;

    private String redirectUrl;

    static{
        try {
            successUrl = ConfigClient.getClient().get("ebs_success_url");
            errorUrl = ConfigClient.getClient().get("ebs_error_url");
            rechargeResultUri = ConfigClient.getClient().get("recharge_success_url");
            accountKey = ConfigClient.getClient().get("ebs_secret_key");
        } catch (ConfigException e) {
            log.error("Unable to get success and error usr info from config server.");
        }
    }

    private Map<String, String> paymentParams = new TreeMap<String, String>();

    private String rechargeOrderId;

    private HttpServletRequest request;

    public String index() {
        StringBuffer data1 = new StringBuffer(rechargeOrderId);
        log.info("Received rechargeORder Id : " + data1.toString());
        //byte[] result = decodeRecvdData(data1);

        //String recvString = parseRecvdData(result);
        //updatePaymentParams(recvString);

        PaymentClient paymentServiceClient = null;
        TransactionClient transactionServiceClient = null;
        UserClient userServiceClient = null;
        try {
            paymentServiceClient = new PaymentClient();
            transactionServiceClient = new TransactionClient();
            userServiceClient = new UserClient();
        } catch (Exception e) {
            log.error("Unable to initialize one of the clients", e);
        }


        //long merchantPaymentId = Long.parseLong(paymentParams.get("MerchantRefNo"));
        //String gatewayPaymentId = paymentParams.get("PaymentID");
        //double amount = Double.parseDouble(paymentParams.get("Amount"));
//        String isFlagged = paymentParams.get(FLAG_KEY);
//        String gatewayTxnStatus = paymentParams.get("ResponseCode");
//        String description = paymentParams.get("ResponseMessage");
//        String authTxnId = paymentParams.get(TXN_KEY);

        Payment payment = null;
        Long txnId = null;
        try {
            //payment = paymentServiceClient.getClient().getPayment(merchantPaymentId);
            //txnId = payment.getMerchantTxnId();
            /**
             * CREATE PAYMENT
             */
            rechargeOrder = transactionServiceClient.getClient().getRechargeOrder(Long.parseLong(rechargeOrderId));
            Long merchantPaymentId = paymentServiceClient.getClient().createPayment(rechargeOrder.getUserId(), 0, 8, rechargeOrder.getTransactionId(), true);
            //Update payment status as authorized
            paymentServiceClient.getClient().updatePaymentDetails(merchantPaymentId, "",
                    "", "0", "", "", "", "", "", PaymentStatus.SUCCESS, "", null);
            transactionServiceClient.getClient().updateRechargeOrderStatus(rechargeOrder.getId(),  RechargeOrderStatus.PAYMENT_SUCCESSFUL);
            this.redirectUrl = rechargeResultUri + "?paymentId=" + merchantPaymentId;
        } catch (PaymentException e) {
            log.error("Unable to mark the payment as authorized", e);
        } catch (TException e) {
            log.error("Unable to mark the payment as authorized", e);
        } catch (TransactionServiceException e) {
            // TODO Auto-generated catch block
            log.error("Unable to recharge");
        }

            //DataLogger.logData(EventType.PAYMENT_FAILURE, getSessionId(), userinfo.getUserId(), userinfo.getEmail(), Long.toString(merchantPaymentId), gatewayPaymentId,
            //        gatewayTxnStatus, description);
        log.info("User will be redirected to: " + this.redirectUrl);
        return "index";
    }


    private boolean validatePaymentParams(double returnedAmount, Payment payment){
        if(!(payment != null && Math.abs(payment.getAmount() - returnedAmount) <= 0.50)){
            // We did not request this payment or the authorised amount is different.
            log.error("Checks and balance failed on returned data");
            return false;
        }
        return true;
    }

    private byte[] decodeRecvdData(StringBuffer data1) {
        for (int i = 0; i < data1.length(); i++) {
            if (data1.charAt(i) == ' ')
                data1.setCharAt(i, '+');
        }

        Base64 base64 = new Base64();
        byte[] data = base64.decode(data1.toString());
        RC4 rc4 = new RC4(accountKey);
        byte[] result = rc4.rc4(data);
        return result;
    }

    private String parseRecvdData(byte[] result) {
        ByteArrayInputStream byteIn = new ByteArrayInputStream(result, 0, result.length);
        BufferedReader reader = new BufferedReader(new InputStreamReader(byteIn));
        String recvString1 = "";
        String recvString = "";
        try {
            recvString1 = reader.readLine();
            int lineCount = 0;
            while (recvString1 != null) {
                lineCount++;
                if (lineCount > 705)
                    break;
                recvString += recvString1 + "\n";
                recvString1 = reader.readLine();
            }
        } catch (IOException e) {
            log.error("Unable to read from Ebs response", e);
        }
        recvString = recvString.replace("=&", "=--&");
        return recvString;
    }

    private void updatePaymentParams(String str){
        StringTokenizer st = new StringTokenizer(str, "=&");
        String key, value;
        while(st.hasMoreTokens()) {
            key = st.nextToken();
            value = st.nextToken();
            log.info("Key: " + key + ", Value: " + value);
            paymentParams.put(key, value);
        }
    }

    public String getRedirectUrl(){
        return this.redirectUrl;
    }

    public void setServletRequest(HttpServletRequest request) {
        this.request = request;
    }

    public Map<String, String> getPaymentParams() {
        return paymentParams;
    }


    public static String getRechargeResultUri() {
        return rechargeResultUri;
    }

    public String getRechargeOrderId() {
        return rechargeOrderId;
    }

    public void setRechargeOrderId(String rechargeOrderId) {
        this.rechargeOrderId = rechargeOrderId;
    }

}