Subversion Repositories SmartDukaan

package in.shop2020.serving.controllers;

import in.shop2020.datalogger.EventType;

import in.shop2020.model.v1.order.OrderType;

import in.shop2020.model.v1.order.RechargeCoupon;

import in.shop2020.model.v1.order.RechargeOrder;

import in.shop2020.model.v1.order.RechargeOrderStatus;

import in.shop2020.model.v1.order.RechargePlan;

import in.shop2020.model.v1.order.RechargeType;

import in.shop2020.model.v1.order.UserWallet;

import in.shop2020.model.v1.user.User;

import in.shop2020.model.v1.user.UserContextException;

import in.shop2020.serving.utils.DesEncrypter;

import in.shop2020.serving.utils.Utils;

import in.shop2020.thrift.clients.HelperClient;

import in.shop2020.thrift.clients.PromotionClient;

import in.shop2020.thrift.clients.TransactionClient;

import in.shop2020.thrift.clients.UserClient;

import in.shop2020.utils.DataLogger;

import in.shop2020.utils.Mail;

import java.math.BigInteger;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Random;

import javax.mail.internet.AddressException;

import javax.mail.internet.InternetAddress;

import nl.captcha.Captcha;

import org.apache.log4j.Logger;

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;

@Results({

    @Result(name="recharge-pay-options-redirect", type="redirectAction", params = {"actionName" , "recharge-pay-options", "rechargeOrderId", "${rechargeOrderId}"}),

    @Result(name="create-recharge-redirect", type="redirectAction", params = {"actionName" , "wallet-only-payment", "rechargeOrderId", "${rechargeOrderId}"}),

    @Result(name="recharge-redirect", type="redirectAction", params = {"actionName" , "recharge", "error", "${errorMessage}"})

})

public class ConfirmController extends BaseController{

    /**

     * 

     */

    private static final long serialVersionUID = 1L;

    private long rechargeOrderId = 0;

    private String amount = "";

    private String walletAmountUsed = "0";

    private String operator = "";

    private String number = "";

    private String email = "";

    private String rechargeType = "";

    private DesEncrypter desEncrypter = new DesEncrypter("saholic");

    private List<String> couponIds = null;

    private List<RechargeCoupon> coupons = null;

    private String userId;

    private String message = "";

    private String errorMessage = "";

    private String totalAmount = "";

    private String plan = "";

    private String circleCode;

    private String couponCode = "";

    private String couponMessage = "";

    private String hiddenUserId = "";

    private long couponAmount = 0;

    private static final String chars = "abcdefghijklmonpqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

    private static final BigInteger key = new BigInteger("0333910847013829827302347601486730417451");

    private static final String COUPON_APPLIED_SUCCESSFULLY = "Coupon Applied";

    private static final Random random = new Random();

    private static final int LENGTH = 10;

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

    public String index() {

        return "index";

    }

    public String create() {

    	errorMessage = validateRecharge();

    	if(!errorMessage.equals("SUCCESS")){

    		DataLogger.logData(EventType.PROVIDER_FETCH_FAILURE, getSessionId(), userinfo.getUserId(), userinfo.getEmail(),

    				rechargeType.toString(), number, operator);

    		return "recharge-redirect";

    	}

    	setErrorMessage("");

        setTotalAmount(amount);

        if(userinfo.isLoggedIn()) {

            setUserId("" + userinfo.getUserId());

            calculateAmounts();

        } else {

            long tempUserId = createUserAndSendMail(email);

            if(tempUserId == -1)

            {

            	errorMessage = "Oops! There seems to be a problem. Please try after some time";

                return "recharge-redirect";

            } else {

                setUserId("" + tempUserId);

            }

        }

        setHash(encrypt(getUserId()));

        return index();

    }

    private void calculateAmounts() {

        try {

            TransactionClient tc = new TransactionClient();

            UserWallet wallet = tc.getClient().getUserWallet(userinfo.getUserId());

            long amountA = 0;

            if(wallet.getAmount() == 0){

                setAmount("" + (Long.parseLong(totalAmount) - couponAmount));

                setMessage("");

            } else if ((amountA = wallet.getAmount() - (Long.parseLong(totalAmount) - couponAmount)) >= 0) {

                setAmount("0");

                setWalletAmountUsed("" + (wallet.getAmount() - amountA));

                setMessage("Amount used from RechargeWallet : Rs. " + walletAmountUsed

                        + "<br>Amount left in your RechargeWallet : Rs. " + amountA);

            } else {

                setAmount("" + (0-amountA));

                setWalletAmountUsed("" + wallet.getAmount());

                setMessage("Amount used from RechargeWallet : Rs. " + walletAmountUsed

                        + "<br>Amount left in your RechargeWallet : Rs.0");

            }

        } catch (Exception e) {

            log.error("Unable to get user wallet", e);

        }

    }

    public String validateRecharge(){

    	TransactionClient tcl;

    	try {

    		tcl = new TransactionClient();

    		return tcl.getClient().validateRecharge(RechargeType.findByValue(Integer.parseInt(this.rechargeType)), number, Long.parseLong(operator));

    	} catch (Exception e) {

    		log.error("Unable to get service provider for Device number " + number + " and rechargeType : " +  rechargeType, e);

    	}

    	return "Oops! There seems to be a problem. Please try after some time";

    }

    private String validateFields() {

        if(amount == null || amount == "") {

            log.warn("Amount received is empty or null");

            return "Amount cannot be empty";

        }

        if(rechargeType == null || rechargeType == "") {

            log.warn("rechargeType received is empty or null");

            return "Oops! There seems to be a problem. Please try after some time";

        }

        if(email == null || email == "") {

            log.warn("Email received is empty or null");

            return "Email address cannot be empty";

        }

        try {

            InternetAddress emailAdd = new InternetAddress(email);

            emailAdd.validate();

        } catch (AddressException e1) {

            log.warn("Invalid email address : " + email, e1);

            return "ERROR : Invalid email address.";

        }

        if (RechargeType.findByValue(Integer.parseInt(this.rechargeType)) == RechargeType.DTH) {

            if (Long.parseLong(totalAmount) < 200 || Long.parseLong(totalAmount) > 2000) {

                return "DTH recharge amount should be between Rs.200 and Rs.2000";

            }

        } else if (RechargeType.findByValue(Integer.parseInt(this.rechargeType)) == RechargeType.MOBILE) {

            if (Long.parseLong(totalAmount) < 10 || Long.parseLong(totalAmount) > 1000) {

                return "Recharge amount should be between Rs.10 and Rs.1000";

            }

            if (number.length() != 10) {

                return "Number should be of 10 digits";

            }

        } else {

            log.warn("Invalid rechargeType : " + rechargeType);

            return "Oops! There seems to be a problem. Please try after some time";

        }

        if (operator == null || operator == "") {

            log.warn("Invalid operator : " + operator);

            return "Oops! There seems to be a problem. Please try after some time";

        }

        return "SUCCESS";

    }

    public boolean shouldPromptForWallet(){

        if(!isLoggedIn()) {

            try {

                TransactionClient tc = new TransactionClient();

                UserWallet wallet = tc.getClient().getUserWallet(Long.parseLong(userId));

                if(wallet.getAmount() != 0) {

                    return true;

                }

            } catch (Exception e) {

                log.error("Unable to get wallet for userId : " + userId, e);

            }

        }

        return false;

    }

    public String applyRechargeCoupon() {

        Map<Long, String> couponResult = null;

        try {

            PromotionClient pc = new PromotionClient();

            couponResult = pc.getClient().applyRechargeCoupon(couponCode, Long.parseLong(totalAmount), Long.parseLong(userId));

            if (couponResult != null) {

                for (long couponAmount : couponResult.keySet()) {

                    setCouponMessage(couponResult.get(couponAmount));

                    this.couponAmount = couponAmount;

                }

            }

            if(couponAmount == 0) {

                couponCode = "";

            }

            if(userinfo.isLoggedIn()) {

                calculateAmounts();

            } else {

                setAmount("" + (Long.parseLong(amount) - couponAmount));

            }

            return index();

        } catch (Exception e) {

            log.error("Unable to apply recharge coupon : " + couponCode, e);

            setCouponMessage("Currently this coupon is unavailable");

        }

        return index();

    }

    public String createRecharge(){

        if (amount.equals("0")) {

            if (!verifyCaptcha()) {

                setErrorMessage("Invalid captcha. Try Again.");

                log.info("Invalid captcha error msg has been added");

                return index();

            }

        }

        String decryptedUserId = decrypt(hiddenUserId);

        if(!userId.equals(decryptedUserId)) {

            log.warn("userId and hash do not match");

            errorMessage = "Oops! There seems to be a problem. Please try after some time";

            return "recharge-redirect";

        }

        errorMessage = validateFields();

        if (!errorMessage.equals("SUCCESS")) {

            return "recharge-redirect";

        }

        try {

            TransactionClient tc = new TransactionClient();

            List<RechargePlan> plans = tc.getClient().getPlansForOperator(Long.parseLong(operator));

            List<String> planNameList = new ArrayList<String>();

            if (plans == null || plans.isEmpty()) {

                setPlan("");

            } else {

                for (RechargePlan tempPlan : plans) {

                    planNameList.add(tempPlan.getName());

                }

                if (!planNameList.contains(plan)) {

                    errorMessage = "Oops! There seems to be a problem. Please try after some time";

                    log.warn("OperatorId : " + operator + " and plan : " + plan + " do not match");

                    return "recharge-redirect";

                }

            }

            if(userinfo.isLoggedIn()) {

                UserWallet wallet = tc.getClient().getUserWallet(userinfo.getUserId());

                if(wallet.getAmount() < Long.parseLong(walletAmountUsed)) {

                    errorMessage = "Oops! There seems to be a problem. Please try after some time";

                    log.warn("WalletAmount used : " + walletAmountUsed + " is greater than wallet Balance  : " + wallet.getAmount());

                    return "recharge-redirect";

                }

                if (userinfo.getUserId() != Long.parseLong(userId)) {

                    errorMessage = "Oops! There seems to be a problem. Please try after some time";

                    log.warn("Logged in user : " + userinfo.getUserId() + " does not match with userId sent by user  : " +  userId);

                    return "recharge-redirect";

                }

            }

            PromotionClient pc = new PromotionClient();

            Map<Long, String> couponResult = null;

            couponResult = pc.getClient().applyRechargeCoupon(couponCode, Long.parseLong(totalAmount), Long.parseLong(userId));

            if(couponResult != null) {

                if (!couponResult.containsValue(COUPON_APPLIED_SUCCESSFULLY)) {

                    couponCode = "";

                    couponAmount = 0;

                } else {

                    for (long couponAmount : couponResult.keySet()) {

                        this.couponAmount = couponAmount;

                    }

                }

            } else {

                couponCode = "";

                couponAmount = 0;

            }

            if (Long.parseLong(totalAmount) != Long.parseLong(amount) + Long.parseLong(walletAmountUsed) + couponAmount){

                errorMessage = "Oops! There seems to be a problem. Please try after some time";

                log.warn("WalletAmount : " + walletAmountUsed + " plus couponAmount : " + couponAmount + " plus amount to be paid : " +

                        amount + "do not match with rechargeAmount : " + totalAmount);

                return "recharge-redirect";

            }

            RechargeOrder rechargeOrder = new RechargeOrder();

            rechargeOrder.setTotalAmount(Long.parseLong(totalAmount));

            rechargeOrder.setUserEmailId(email);

            rechargeOrder.setUserId(Long.parseLong(userId));

            rechargeOrder.setDeviceNumber(number);

            rechargeOrder.setPlan(plan);

            rechargeOrder.setOperatorId(Long.parseLong(operator));

            rechargeOrder.setRechargeType(RechargeType.findByValue(Integer.parseInt(rechargeType)));

            rechargeOrder.setStatus(RechargeOrderStatus.PAYMENT_PENDING);

            rechargeOrder.setOrderType(OrderType.B2C);

            rechargeOrder.setWalletAmount(Long.parseLong(getWalletAmountUsed()));

            rechargeOrder.setCouponAmount(couponAmount);

            rechargeOrder.setCouponCode(couponCode);

            TransactionClient tc1 = new TransactionClient();

            rechargeOrder = tc1.getClient().createRechargeOrder(rechargeOrder);

            setRechargeOrderId(rechargeOrder.getId());

        } catch (Exception e) {

            log.error("Unable to create recharge order", e);

            errorMessage = "Oops! There seems to be a problem. Please try after some time";

            return "recharge-redirect";

        }

        if(amount.equals("0")) {

            return "create-recharge-redirect";

        } else {

            return "recharge-pay-options-redirect";

        }

    }

    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;

        }

    }

    private static String generateNewPassword() {

        char[] buf = new char[LENGTH];

        for (int i = 0; i < buf.length; i++) {

            buf[i] = chars.charAt(random.nextInt(chars.length()));

        }

        return new String(buf);

    }

    private long createUserAndSendMail(String email) {

        User user = null;

        String password = null;

        try{

        UserClient ucl = new UserClient();

        user = ucl.getClient().getUserByEmail(email);

        if(user.getUserId() == -1) {

            user.setEmail(email);

            password = generateNewPassword();

            String encryptedPassword = desEncrypter.encrypt(password);

            user.setPassword(encryptedPassword);

            user.setCommunicationEmail(email);

            UserClient userContextServiceClient = new UserClient();

            in.shop2020.model.v1.user.UserContextService.Client userClient = userContextServiceClient.getClient();

            user = userClient.createUser(user);

            List<String> toList = new ArrayList<String>();

            toList.add(email);

            HelperClient helperServiceClient = null;

                helperServiceClient = new HelperClient();

                in.shop2020.utils.HelperService.Client client = helperServiceClient.getClient();

                Mail mail = new Mail();

                mail.setSubject("Saholic Registration successful");

                mail.setTo(toList);

                mail.setData("Your have successfully registered with Saholic.com. Your user name is: " + email + " and your password is: " +  password);

                client.sendMail(mail);

            }

        }catch (UserContextException ux){

            return -1;               

        } catch (TTransportException e) {

            return -1;

        } catch (TException e) {

            return -1;

        } catch (Exception e) {

            log.error("Unexpected error while mailing the new password");

            return -1;

        }

        return user.getUserId();

    }

    public String getOperatorName() {

    	String operatorName = null;

    	if(rechargeType.equals("1")){

    		operatorName = Utils.getMobileProvidersMap().get(Long.parseLong(operator));	

    	}

    	if(rechargeType.equals("2")){

    		operatorName = Utils.getDthProvidersMap().get(Long.parseLong(operator));	

    	}

    	if(operatorName == null){

    		operatorName = "N/A";	

    	}

    	return operatorName;

    }

    public String encrypt(String strToEncrypt) {

        BigInteger strBigInt = new BigInteger(strToEncrypt.getBytes());

        System.out.println(strBigInt);

        BigInteger hashedPasswd = key.xor(strBigInt);

        System.out.println(hashedPasswd);

        return (hashedPasswd.toString(16));

    }

    public String decrypt(String encrypted) {

        try

        {

            BigInteger encryptedBigInt = new BigInteger(encrypted, 16);

            System.out.println(encryptedBigInt);

            BigInteger strBigInt = encryptedBigInt.xor(key);

            System.out.println(strBigInt);

            String decrypted = new String(strBigInt.toByteArray());

            return decrypted;

        } catch (Exception e) {

            System.out.println("oops");

            return "";

        }

    }

    public String getAmount() {

        return amount;

    }

    public void setAmount(String amount) {

        this.amount = amount;

    }

    public void setDthamount(String amount) {

    	this.amount = amount;

    }

    public String getOperator() {

        return operator;

    }

    public void setOperator(String operator) {

        this.operator = operator;

    }

    public String getNumber() {

        return number;

    }

    public void setNumber(String number) {

        this.number = number;

    }

    public void setDthnumber(String dthnumber) {

    	this.number = dthnumber;

    }

    public String getEmail() {

        return email;

    }

    public void setEmail(String email) {

        this.email = email;

    }

    public void setCouponIds(List<String> couponIds) {

        this.couponIds = couponIds;

    }

    public List<String> getCouponIds() {

        return couponIds;

    }

    public void setCoupons(List<RechargeCoupon> coupons) {

        this.coupons = coupons;

    }

    public List<RechargeCoupon> getCoupons() {

        return coupons;

    }

    public String getRechargeType() {

        return rechargeType;

    }

    public void setRechargeType(String rechargeType) {

        this.rechargeType = rechargeType;

    }

    public String getUserId() {

        return userId;

    }

    public void setUserId(String userId) {

        this.userId = userId;

    }

    public boolean isLoggedIn() {

        return userinfo.isLoggedIn();

    }

    public void setMessage(String message) {

        this.message = message;

    }

    public String getMessage() {

        return message;

    }

    public long getRechargeOrderId() {

        return rechargeOrderId;

    }

    public void setRechargeOrderId(long l) {

        this.rechargeOrderId = l;

    }

    public String getTotalAmount() {

        return totalAmount;

    }

    public void setTotalAmount(String amount) {

        this.totalAmount  = amount;

    }

    public String getWalletAmountUsed() {

        return walletAmountUsed;

    }

    public void setWalletAmountUsed(String walletAmountUsed) {

        this.walletAmountUsed = walletAmountUsed;

    }

    public String getPlan() {

        return plan;

    }

    public void setPlan(String plan) {

        this.plan = plan;

    }

    public String getErrorMessage() {

        return errorMessage;

    }

    public void setErrorMessage(String errorMessage) {

        this.errorMessage = errorMessage;

    }

    public String getCircleCode() {

        return circleCode;

    }

    public void setCircleCode(String circleCode) {

        this.circleCode = circleCode;

    }

    public void setDiscountCode(String discountCode) {

        this.couponCode = discountCode;

    }

    public String getCouponCode() {

        return couponCode;

    }

    public void setCouponCode(String couponCode) {

        this.couponCode = couponCode;

    }

    public void setCouponAmount(long couponAmount) {

        this.couponAmount = couponAmount;

    }

    public long getCouponAmount() {

        return couponAmount;

    }

    public void setCouponMessage(String couponMessage) {

        this.couponMessage = couponMessage;

    }

    public String getCouponMessage() {

        return couponMessage;

    }

    public void setHash(String hash) {

        this.hiddenUserId = hash;

    }

    public String getHiddenUserId() {

        return hiddenUserId;

    }

}