Subversion Repositories SmartDukaan

package in.shop2020.serving.controllers;

import in.shop2020.datalogger.EventType;
import in.shop2020.model.v1.order.Order;
import in.shop2020.model.v1.order.TransactionServiceException;
import in.shop2020.model.v1.user.Address;
import in.shop2020.model.v1.user.ShoppingCartException;
import in.shop2020.serving.interceptors.TrackingInterceptor;
import in.shop2020.serving.services.CodPaymentService;
import in.shop2020.serving.services.CommonPaymentService;
import in.shop2020.serving.services.EbsPaymentService;
import in.shop2020.serving.services.HdfcEmiPaymentService;
import in.shop2020.serving.services.HdfcPaymentService;
import in.shop2020.serving.services.IPaymentService;
import in.shop2020.serving.services.InnovitiPaymentService;
//import in.shop2020.serving.services.PayuPaymentService;
import in.shop2020.serving.utils.DesEncrypter;
import in.shop2020.serving.utils.Utils;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.thrift.clients.UserClient;
import in.shop2020.utils.DataLogger;

import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;
import org.apache.struts2.convention.annotation.InterceptorRef;
import org.apache.struts2.convention.annotation.InterceptorRefs;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransportException;
import nl.captcha.Captcha;

@SuppressWarnings("serial")
@InterceptorRefs({
    @InterceptorRef("myDefault"),
    @InterceptorRef("login")
})

@Results({
    @Result(name="shipping-redirect", type="redirectAction", params = {"actionName" , "shipping"}),
    @Result(name="proceed-to-pay-redirect", type="redirectAction", params = {"actionName" , "proceed-to-pay", "deliveryLocation", "${deliveryLocation}"}),
        @Result(name="ebs-pay-redirect", type="redirect", location="/ebs-pay/${paymentId}"),
        @Result(name="payu-pay-redirect", type="redirect", location="/payu-pay/${paymentId}"),
        @Result(name="innoviti-pay-redirect", type="redirect", location="/innoviti-pay/${paymentId}"),
        @Result(name="cod-redirect", type="redirect", location="/pay-success?paymentId=${paymentId}")
})
public class OrderController extends BaseController {
        
        public long getPaymentId() {
                return paymentId;
        }
        
        private static Logger log = Logger.getLogger(Class.class);
        
        private String id;
        private long txnId = 0;
        
        private long paymentId;
        
        private String redirectURL;
        private String deliveryLocation = "";
        
        public OrderController(){
                super();
        }
        
    // GET /order/ orderid
    public String show() {
        log.info("id=" + id);
        htmlSnippets.put("MYACCOUNT_HEADER", pageLoader.getMyaccountHeaderHtml());
        htmlSnippets.put("ORDER_DETAILS", pageLoader.getOrderDetailsHtml(Long.parseLong(id), userinfo));
        return "show";
    }

    // POST /order/
    public String create(){
        String addressIdString = this.request.getParameter("addressid");
        if(addressIdString == null){
                addActionError("Please specify shipping address to continue.");
                return "proceed-to-pay-redirect";
        }
        
        String paymentOption = request.getParameter("payment_option");
        log.info("Payment Option Selected: " + paymentOption);
        if(paymentOption == null || paymentOption.equals("")){
                addActionError("Please select a payment method to continue.");
                return "proceed-to-pay-redirect";
        }
        
        
        long addressId;
        try {
            addressId = Long.parseLong(addressIdString);   
        } catch(NumberFormatException nfe){
            log.error("Unable to get address id", nfe);
            addActionError("Invalid address. Please add an address to the cart.");
            return "shipping-redirect";
        }
         
        long currentCartId = userinfo.getCartId();
        long currentUserId = userinfo.getUserId();
        
        if(paymentOption.equals(IPaymentService.COD)){
            if(!verifyCaptcha()){
                addActionError("Invalid captcha");
                log.info("Invalid captcha error msg has been added");
                return "proceed-to-pay-redirect";    
            }
            
                //Check that this address is eligible for COD shipping.
            UserClient userServiceClient = null;
            try {
                userServiceClient = new UserClient();
                in.shop2020.model.v1.user.UserContextService.Client userClient = userServiceClient.getClient();
                Address address = userClient.getAddressById(addressId);
                
                if(!userClient.showCODOption(currentCartId, sourceId, address.getPin())){
                    addActionError("Cash on Delivery is currently not available for this pincode. Please choose a different payment option.");
                    return "proceed-to-pay-redirect";    
                }
            } catch (Exception e) {
                log.error("Unable to talk to the user context service.", e);
                addActionError("We are experiencing some problems. Please try later.");
                return "proceed-to-pay-redirect";
            }
        }
        
        try {
                if(!createOrders(addressId, currentCartId, currentUserId, Long.parseLong(paymentOption))) {
                        addActionError("We are experiencing some problems. Please try later.");
                        return "proceed-to-pay-redirect";
                }
        } catch (Exception e) {
                addActionError("We are experiencing some problems. Please try later.");
                log.error("Exception in createOrders function. Something went wrong.", e);
                return "proceed-to-pay-redirect";
                }
        
        int gatewayId = (int)findGatewayId(paymentOption);
        switch (gatewayId) {
        case 4:
                IPaymentService codPaymentService = new CodPaymentService();
            paymentId = codPaymentService.createPayment(userinfo.getUserId(), txnId, paymentOption, 4);
            if (paymentId == IPaymentService.PAYMENT_NOT_CREATED) {
                //Very unlikely. The only possible reason can be that the payment service is down.
                log.error("Unable to process the COD payment.");
                addActionError("We are experiencing some problems. Please try later.");
                return "proceed-to-pay-redirect";
            } else {
                CommonPaymentService.processCodTxn(txnId);
                return "cod-redirect";
            }

        case 5:
        case 10:
        case 11:
        case 12:
                        IPaymentService hdfcEmiPaymentService = new HdfcEmiPaymentService();
            paymentId = hdfcEmiPaymentService.createPayment(userinfo.getUserId(), txnId, paymentOption, gatewayId);
            if(paymentId == IPaymentService.PAYMENT_NOT_CREATED){
                addActionError("We are experiencing some problems. Please try later.");
                log.error("Unable to process payment through HDFC EMI.");
                return "proceed-to-pay-redirect";
            } else {
                this.redirectURL = ((HdfcEmiPaymentService)hdfcEmiPaymentService).getRedirectUrl();
                log.info(this.redirectURL);
                return "success";
            }
        
        case 13:
                        IPaymentService innovitiPaymentService = new InnovitiPaymentService();
                        paymentId = innovitiPaymentService.createPayment(userinfo.getUserId(), txnId, paymentOption, gatewayId);
                        if (paymentId == IPaymentService.PAYMENT_NOT_CREATED) {
                                //Very unlikely. The only possible reason can be that the payment service is down.
                                log.error("Unable to process the COD payment.");
                                addActionError("We are experiencing some problems. Please try later.");
                                return "proceed-to-pay-redirect";
                        } else {
                    log.info("Successfully created payment for Innoviti to process. Redirecting to /innoviti-pay/" + paymentId);
                                return "innoviti-pay-redirect";
                        }
                
        
                default:
                        break;
                }
        

                if(paymentOption.equals(IPaymentService.HDFC_MASTERCARD_CREDIT) || paymentOption.equals(IPaymentService.HDFC_MASTERCARD_DEBIT) || 
                        paymentOption.equals(IPaymentService.HDFC_VISA) || paymentOption.equals(IPaymentService.HDFC_VISA_ELECTRON)) {
            // User has selected Visa or MasterCard
            IPaymentService hdfcPaymentService = new HdfcPaymentService();
            paymentId = hdfcPaymentService.createPayment(userinfo.getUserId(), txnId, paymentOption, 1);
            if (paymentId == IPaymentService.PAYMENT_NOT_CREATED) {
                log.error("Unable to process payment through HDFC. Falling through to EBS.");
            } else {
                this.redirectURL = ((HdfcPaymentService)hdfcPaymentService).getRedirectUrl();
                log.info(this.redirectURL);
                return "success";
            }
        }

        if(paymentOption.equals(IPaymentService.HDFC_VISA))
            paymentOption = IPaymentService.EBS_VISA;
        else if(paymentOption.equals(IPaymentService.HDFC_MASTERCARD_DEBIT) || paymentOption.equals(IPaymentService.HDFC_MASTERCARD_CREDIT))
            paymentOption = IPaymentService.EBS_MASTERCARD;
        else if(paymentOption.equals(IPaymentService.HDFC_VISA_ELECTRON))
            paymentOption = null;           //Since we don't know the bank's name in this case, we'll let the user select the bank on the EBS page.
        
//        if(paymentOption.equals(IPaymentService.PAYU_CC)){
//              paymentOption = IPaymentService.PAYU_CC;
//              IPaymentService payuPaymentService = new PayuPaymentService();
//              paymentId = payuPaymentService.createPayment(userinfo.getUserId(), txnId, paymentOption, gatewayId);
//              return "payu-pay-redirect";
//        }
        
        IPaymentService ebsPaymentService = new EbsPaymentService();
        paymentId = ebsPaymentService.createPayment(userinfo.getUserId(), txnId, paymentOption, 2);
        if(paymentId == IPaymentService.PAYMENT_NOT_CREATED){
            addActionError("We are experiencing some problems. Please try later.");
            log.error("Unable to process payment through EBS.");
            return "proceed-to-pay-redirect";
        } else {
            log.info("Successfully created payment for EBS to process. Redirecting to /ebs-pay/" + paymentId);
            return "ebs-pay-redirect";
        }           
        }

    private long findGatewayId(String paymentOption){
        long gatewayId = 0;
        gatewayId = ProceedToPayController.getGatewayId(Long.parseLong(paymentOption));
        if(gatewayId==0){
                if(paymentOption.equals(IPaymentService.COD)){
                        gatewayId = 4;
                }
        }
        return gatewayId;
    }
    
    /**
     * Verifies if the recaptcha response matches the recaptcha challenge.
     * 
     * @return True if the captcha was valid, false otherwise.
     */
    private boolean verifyCaptcha() {
        String cookieCaptchaAnswer = getCookie(Captcha.NAME, true, "saholic");
        String captchaReceived = (String) request.getParameter("captcha_response_field");
        
        if (captchaReceived.equalsIgnoreCase(cookieCaptchaAnswer)) {
                        try {
                                DataLogger.logData(EventType.CAPTCHA_SUCCESS, getSessionId(), userinfo.getUserId(), userinfo.getEmail());
                        } catch (Exception e1) {
                        log.warn("Unable to log orders through the datalogger", e1);
                }
                        return true;
                } 
                else {
                        try {
                                DataLogger.logData(EventType.CAPTCHA_FAILED, getSessionId(), userinfo.getUserId(), userinfo.getEmail());
                        } catch (Exception e1) {
                        log.warn("Unable to log orders through the datalogger", e1);
                }
                        return false;
                }
    }
    
        public String getId(){
                return id;
        }
        
        public void setId(String id){
                this.id = id;
        }
        
        public String getMyaccountHeaderSnippet(){
                return htmlSnippets.get("MYACCOUNT_HEADER");
        }
        
        public String getOrderDetailsSnippet(){
                return htmlSnippets.get("ORDER_DETAILS");
        }
        
        public long getTxn(){
                return this.txnId;
        }

        /**
         * 
         * @param addressId
         * @param currentCartId
         * @return
         */
        private boolean createOrders(long addressId, long currentCartId, long currentUserId, long emiSchemeId){
                UserClient userServiceClient = null;
                try {
                        userServiceClient = new UserClient();
                } catch (Exception e) {
                        log.error("Unable to talk to the user context service.", e);
                        return false;
                }
                
                in.shop2020.model.v1.user.UserContextService.Client userClient = userServiceClient.getClient();
                try {
                        userClient.addAddressToCart(currentCartId, addressId);
                } catch (ShoppingCartException e1) {
                        log.error("Not able to set address in the cart.", e1);
                        return false;
                } catch (TException e1) {
                        log.error("Thrift exception while setting address in cart.", e1);
                        return false;
                }
                
                
                try {
                        String errorMsg = userClient.validateCart(currentCartId, sourceId).get(0); 
                        if(!errorMsg.isEmpty()){
                                addActionError(errorMsg);
                                return false;
                        }
                } catch (ShoppingCartException e1) {
                        log.error("Error while validating shopping cart.", e1);
                        return false;
                } catch (TException e) {
                        log.error("Thrift exception while validating cart.", e);
                        return false;
                }
                
                
                try {
                    String sessionSrc = getCookie(TrackingInterceptor.SESSION_SRC_COOKIE, true, TrackingInterceptor.ENCRIPTION_STRING);
                    String firstSrc = getCookie(TrackingInterceptor.SRC_COOKIE, true, TrackingInterceptor.ENCRIPTION_STRING);
            
                    long sessionTime = 0;
            try {
                sessionTime = Long.parseLong(getCookie(TrackingInterceptor.SESSION_SRC_TIME_COOKIE, false, null));
            } catch (Exception e) {
                log.warn("Unable to parse session src time cookie.", e);
            }
            long firstSrcTime = 0;
            try {
                firstSrcTime = Long.parseLong(getCookie(TrackingInterceptor.SRC_TIME_COOKIE, false, null));
            } catch (Exception e) {
                log.warn("Unable to parse session src time cookie.", e);
            }
            txnId = userClient.createOrders(currentCartId, sessionSrc, sessionTime, firstSrc, firstSrcTime, currentUserId, emiSchemeId);
                } catch (ShoppingCartException e1) {
                        log.error("Error while creating orders from cart.", e1);
                        return false;
                } catch (TException e) {
                        log.error("Thrift exception while creating orders from cart.", e);
                        return false;
                }
                
                TransactionClient transactionServiceClient = null;

        try {
            transactionServiceClient = new TransactionClient();
            List<Order> orders = transactionServiceClient.getClient().getOrdersForTransaction(txnId, userinfo.getUserId());
            for (Order order : orders) {
                List<Order> tmpOrders = new ArrayList<Order>();
                tmpOrders.add(order);
                String itemIdString = Utils.getItemIdStringFromOrders(tmpOrders);
                DataLogger.logData(EventType.ORDER_CREATION, getSessionId(), userinfo.getUserId(), userinfo.getEmail(), 
                        Long.toString(order.getId()), Long.toString(currentCartId), itemIdString);
            }
        } catch (Exception e1) {
                log.warn("Unable to log orders through the datalogger", e1);
        }
                
                return true;
        }

        /**
         * This method updates address of a given order.
         *
         * @return
         */
        public String modifyAddress() {
        long orderId   = Long.parseLong(request.getParameter("orderId"));
        long addressId = Long.valueOf(request.getParameter("addressId"));

                try {
                    TransactionClient transactionServiceClient = new TransactionClient();
                        in.shop2020.model.v1.order.TransactionService.Client transactionClient
                            = transactionServiceClient.getClient();                     
                        transactionClient.updateShipmentAddress(orderId, addressId);
                } catch (TTransportException e) {
                    log.error("Could not update address: " + addressId + " for orderId: " + orderId, e);
                } catch (NumberFormatException e) {
                    log.error("Could not update address: " + addressId + " for orderId: " + orderId, e);
                } catch (TransactionServiceException e) {
                    log.error("Could not update address: " + addressId + " for orderId: " + orderId, e);
                } catch (TException e) {
                    log.error("Could not update address: " + addressId + " for orderId: " + orderId, e);
                }                       

                return "index";
        }

        public String getRedirectURL(){
                return this.redirectURL;
        }

    public String getDeliveryLocation() {
        return deliveryLocation;
    }

    public void setDeliveryLocation(String deliveryLocation) {
        this.deliveryLocation = deliveryLocation;
    }
    
    public static void main(String[] args) {
        DesEncrypter d = new DesEncrypter("shop2020");
        System.out.println(d.decrypt("pmkcWEzhf4IFRLyHce89Cg"));
    }
}