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);

	}

    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.getChargeValue();

    		}

    	}

    	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());

    			schemeList.add(arrayMap);

    		}

    		return new Gson().toJson(schemeList);

    	} else {

    		return emiSchemesInJSON;

    	}

    }

}