Subversion Repositories SmartDukaan

package in.shop2020.serving.controllers;

import in.shop2020.datalogger.EventType;
import in.shop2020.model.v1.order.EmiScheme;
import in.shop2020.model.v1.order.TransactionService.Client;
import in.shop2020.model.v1.user.Address;
import in.shop2020.model.v1.user.Cart;
import in.shop2020.model.v1.user.PromotionService;
import in.shop2020.serving.utils.FormattingUtils;
import in.shop2020.serving.utils.Utils;
import in.shop2020.thrift.clients.PromotionClient;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.thrift.clients.UserClient;
import in.shop2020.utils.DataLogger;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;

import org.apache.commons.lang.StringUtils;
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 com.google.gson.Gson;

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

@Results({
    @Result(name="shipping-redirect", type="redirectAction", params = {"actionName" , "shipping"})
})

public class ProceedToPayController extends BaseController {
    
    private static Logger logger = Logger.getLogger(ProceedToPayController.class);
    private static final ResourceBundle resource = ResourceBundle.getBundle(ProceedToPayController.class.getName());
    private static final boolean SHOW_EBS_TEST_GATEWAY = Boolean.parseBoolean(resource.getString("show_ebs_test_gateway"));
    
    private static List<EmiScheme> emiSchemes;
    private static String emiSchemesInJSON;
    private boolean hasGiftVoucher = false;
    private long addressId = -1;
    private String totalAmount = "";
    private double totalAmountD = 0l;
    private boolean showCodOption = true;
    private boolean showEmiOption = false;
    private String errorMsg = "";
    private String deliveryLocation = ""; //This could be set as myLocation or HotSpot
    private boolean showStorePickUpOption = false;
    private long hotSpotAddressId = 1;
    private boolean amountZero = false;
    
    
    public String index(){
        return processPaymentOptions();
    }
    
    public String create(){
        String addressIdString = this.request.getParameter("addressid");
        if(addressIdString == null){
            addActionError("Please specify shipping address to continue.");
            return "shipping-redirect";
        }

        try {
            addressId = Long.parseLong(addressIdString);
        } catch(NumberFormatException nfe) {
            logger.error("Unable to parse address id", nfe);
            addActionError("Please specify shipping address to continue.");
            return "shipping-redirect";
        }
        return processPaymentOptions();
    }

    private String processPaymentOptions() {
        if(emiSchemes == null){
                populateEmiSchemes();
        }
        
        String showEmiOptionStr = this.request.getParameter("showEmiOption");
        if(showEmiOptionStr!=null){
            try{
                showEmiOption = Boolean.parseBoolean(showEmiOptionStr);
            }catch(Exception e){
                logger.info("A non-boolean value passed for showing EMI option");
            }
        }
        
        UserClient userContextServiceClient = null;
        in.shop2020.model.v1.user.UserContextService.Client userClient = null;
        
        Address address;
        String itemIdString = "";
        try {
            userContextServiceClient = new UserClient();
            userClient = userContextServiceClient.getClient();
            
            long cartId = userinfo.getCartId();
            if(deliveryLocation.equals("myLocation")) {
                userClient.addStoreToCart(cartId, 0);
            }
            // Validate the cart to ensure that we are not accepting payment for
            // an invalid order.
            errorMsg = userClient.validateCart(cartId, sourceId).get(0);
            
            Cart cart = userClient.getCart(cartId);
            String couponCode = cart.getCouponCode();
            logger.info("Coupon: " + couponCode);
            
            setTotalAmount(cart);
            itemIdString = Utils.getItemIdStringInCart(cart);
            
            PromotionService.Client pc = new PromotionClient().getClient();
            /*
             * If a gift voucher is used such that all of the amount is paid by the gift voucher then we
             * do not need set the hasGiftVoucher flag.
             */
            if(StringUtils.isNotEmpty(couponCode) && pc.isGiftVoucher(couponCode) && getTotalAmountL() > 0){
                hasGiftVoucher = true;
            }
            
            if (!hasGiftVoucher && deliveryLocation.equals("HotSpot")) {
                userClient.addStoreToCart(cartId, hotSpotAddressId);
                showStorePickUpOption = true;
            }
            
            // Get the address to check if COD option is available for this
            // address.
            if(addressId == -1){
                addressId = cart.getAddressId();
            }
            address = userClient.getAddressById(addressId);
            
            try {
                showCodOption = userClient.showCODOption(cartId, sourceId, address.getPin());
            } catch(Exception e) {
                logger.error("Error while checking if COD is available for: " + showCodOption, e);
                showCodOption = false; //Not a critical error, proceeding with defensive behaviour.
            }
            
            showStorePickUpOption = showStorePickUpOption && showCodOption;
            
            DataLogger.logData(EventType.PROCEED_TO_PAY, getSessionId(), userinfo.getUserId(), userinfo.getEmail(),
                    Long.toString(cartId), itemIdString);
        } catch(Exception e) {
            logger.error("Error while either validating the cart or getting the address", e);
            addActionError("We are experiencing some problem. Please try again.");
            return "shipping-redirect";
        }
        
        Collection<String> actionErrors = getActionErrors();
        if(actionErrors != null && !actionErrors.isEmpty()){
            for (String str : actionErrors) {
                errorMsg += str + "<BR/>";
            }
        }
        
        return "index";
    }

    public static void populateEmiSchemes(){
        try {
                        Client tClient = new TransactionClient().getClient();
                        emiSchemes = tClient.getAvailableEmiSchemes();
                } catch (TTransportException e) {
                        logger.error("Error while getting EMI schemes: ", e);
                } catch (TException e) {
                        logger.error("Error while getting EMI schemes: ", e);
                }
    }
    
    private void setTotalAmount(Cart cart) {
        String couponCode = cart.getCouponCode();
        if(couponCode == null || "".equals(couponCode))
                totalAmountD = cart.getTotalPrice();
        else
            totalAmountD = cart.getDiscountedPrice();
        
        FormattingUtils formattingUtils = new FormattingUtils();
        totalAmount = formattingUtils.formatPrice(totalAmountD);
        if(totalAmountD == 0) {
            amountZero = true;
        }
    }

    public long getAddressId(){
        return this.addressId;
    }
    
    public String getErrorMsg(){
        logger.info("added error msg:" + this.errorMsg);
        return this.errorMsg;
    }
    
    public boolean shouldShowCodOption() {
        return showCodOption;
    }

    public boolean shouldShowEmiOption() {
        return showEmiOption;
    }

    public String getTotalAmount(){
        return totalAmount;
    }
    
    public double getTotalAmountL(){
        return totalAmountD;
    }
    
    public boolean shouldShowEbsTestGateway() {
        return SHOW_EBS_TEST_GATEWAY;
    }
    
        @Override
        public String getHeaderSnippet() {
                String url = request.getQueryString();
                if (url == null) {
                        url = "";
                } else {
                        url = "?" + url;
                }
                url = request.getRequestURI() + url;
                return pageLoader.getHeaderHtml(userinfo.isLoggedIn(), userinfo.getEmail(), userinfo.getTotalItems(), url , 0, false, userinfo.isPrivateDealUser());
        }

    public String getDeliveryLocation() {
        return deliveryLocation;
    }

    public void setDeliveryLocation(String deliveryLocation) {
        this.deliveryLocation = deliveryLocation;
    }

    public long getHotSpotAddressId() {
        return hotSpotAddressId;
    }

    public void setHotSpotAddressId(long hotSpotAddressId) {
        this.hotSpotAddressId = hotSpotAddressId;
    }

    public boolean shouldShowStorePickUpOption() {
        return showStorePickUpOption;
    }
    
    public String getJSONEmiSchemes(){
        getEmiSchemes();
        Double totalAmount = getTotalAmountL();
        List<EmiScheme> schemes = new ArrayList<EmiScheme>();
        for(EmiScheme emiScheme : emiSchemes) {
                if(emiScheme.getMinAmount() <= totalAmount ) {
                        schemes.add(emiScheme);
                }
        }
        Gson gson  = new Gson();
        return gson.toJson(schemes);
    }
    
    public String getJSONEmiDiscountSchemes(){
        try {
        PromotionService.Client pc = new PromotionClient().getClient();
        Gson gson  = new Gson();
        return gson.toJson(pc.getEmiDiscount(userinfo.getCartId()));
        }catch (Exception e){
                logger.warn("Could not retrive emi based promotions for cart: " + userinfo.getCartId() + ".\n" + e);
                return "{}";
        }
    }
    
    public static List<EmiScheme> getEmiSchemes(){
        if (emiSchemes != null) { 
                return emiSchemes;
        } else {
                populateEmiSchemes();
                return emiSchemes;
        }
    }
    
    public static long getGatewayId(long emiSchemeId){
        for(EmiScheme scheme: emiSchemes){
                if(scheme.getId() == emiSchemeId){
                        return scheme.getGatewayId();
                }
        }
        return 0;
    }
    
    public static double getInterestRate(long emiSchemeId){
        for(EmiScheme scheme: emiSchemes){
                if(scheme.getId() == emiSchemeId){
                        return scheme.getInterestRate();
                }
        }
        return 0;
    }

    public void setAmountZero(boolean amountZero) {
        this.amountZero = amountZero;
    }

    public boolean isAmountZero() {
        return amountZero;
    }
    
    public static String getEmiSchemesInJSON(){
        if(emiSchemesInJSON==null){
                List<Map<String, Object>> schemeList = new ArrayList<Map<String,Object>>();
                for(EmiScheme scheme: getEmiSchemes()){
                        Map<String,Object> arrayMap = new HashMap<String, Object>();
                        arrayMap.put("bankId",scheme.getBankId());
                        arrayMap.put("bankName",scheme.getBankName());
                        arrayMap.put("chargeType",scheme.getChargeType());
                        arrayMap.put("chargeValue",scheme.getChargeValue());
                        arrayMap.put("gatewayId",scheme.getGatewayId());
                        arrayMap.put("minAmount",scheme.getMinAmount());
                        arrayMap.put("tenure",scheme.getTenure());
                        arrayMap.put("tenureDescription",scheme.getTenureDescription());
                        arrayMap.put("id",scheme.getId());
                        arrayMap.put("interestRate",scheme.getInterestRate());
                        schemeList.add(arrayMap);
                }
                return new Gson().toJson(schemeList);
        } else {
                return emiSchemesInJSON;
        }
    }
}