Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

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

import javax.servlet.http.HttpServletRequest;

import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.util.Utils;
import com.spice.profitmandi.common.web.util.ResponseSender;
import com.spice.profitmandi.dao.entity.dtr.User;
import com.spice.profitmandi.dao.entity.dtr.UserAccounts;
import com.spice.profitmandi.dao.enumuration.dtr.AccountType;
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
import com.spice.profitmandi.thrift.clients.PaymentClient;
import com.spice.profitmandi.thrift.clients.TransactionClient;
import com.spice.profitmandi.web.req.CreateRechargeRequest;
import com.spice.profitmandi.web.res.ConfirmRechargeResponse;
import com.spice.profitmandi.web.res.CreateRechargeResponse;
import com.spice.profitmandi.web.res.MyRechargesResponse;
import com.spice.profitmandi.web.res.RechargeResultPojo;

import in.shop2020.model.v1.order.DenominationType;
import in.shop2020.model.v1.order.DeviceNumberInfo;
import in.shop2020.model.v1.order.OrderType;
import in.shop2020.model.v1.order.RechargeDenomination;
import in.shop2020.model.v1.order.RechargeOrder;
import in.shop2020.model.v1.order.RechargeOrderStatus;
import in.shop2020.model.v1.order.RechargeType;
import in.shop2020.model.v1.order.TransactionServiceException;
import in.shop2020.model.v1.order.UserWallet;
import in.shop2020.payments.Payment;
import in.shop2020.payments.PaymentException;
import in.shop2020.payments.PaymentStatus;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;

@Controller
@Transactional(rollbackFor=Throwable.class)
public class RechargeController {

        private static final Logger log=LoggerFactory.getLogger(RechargeController.class);
        private static final String HEADER_X_FORWARDED_FOR = "X-FORWARDED-FOR";

        @Autowired
        private UserAccountRepository userAccountRepository;

        @Autowired
        private UserRepository userRepository;
        
        @Autowired
        private ResponseSender<?> responseSender;

        @RequestMapping(value = ProfitMandiConstants.URL_GET_SERVICE_PROVIDER, method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        @ApiOperation(value = "")
        public ResponseEntity<?> getServiceProvider(HttpServletRequest request, @RequestParam(value="deviceNumber") String deviceNumber, @RequestParam(value="rechargeType") String rechargeType){
                DeviceNumberInfo deviceInfo = null;
                TransactionClient tcl;
                try {
                        tcl = new TransactionClient();
                        deviceInfo = tcl.getClient().getServiceProviderForDevice(RechargeType.valueOf(rechargeType), deviceNumber.substring(0,4));
                } catch (Exception e) {
                        log.error("Unable to get service provider for Device number " + deviceNumber + " and rechargeType : " +  rechargeType, e);
                }
                return responseSender.ok(deviceInfo);
        }

        @RequestMapping(value = ProfitMandiConstants.URL_GET_ALL_DENOMINATIONS, method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        @ApiOperation(value = "")
        public ResponseEntity<?> getAllDenominations(HttpServletRequest request, @RequestParam(value="operatorId") long operatorId, @RequestParam(value="circleCode") String circleCode, @RequestParam(value="denominationType") String denominationType){
                List<RechargeDenomination> rechargeDenominations = new ArrayList<RechargeDenomination>();
                TransactionClient tcl;
                try {
                        tcl = new TransactionClient();
                        rechargeDenominations =  tcl.getClient().getRechargeDenominations(operatorId, circleCode, DenominationType.valueOf(denominationType));
                } catch (Exception e) {
                        log.error("Unable to get rechargeDenominations for operatorId " + operatorId + " and circleCode : " +  circleCode + " and DenominationType : " + denominationType, e);
                }
                return responseSender.ok(rechargeDenominations);
        }

        @RequestMapping(value = ProfitMandiConstants.URL_MOBILE_OPERATORS, method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        @ApiOperation(value = "")
        public ResponseEntity<?> getAllMobileOperators(HttpServletRequest request){
                Map<Long, String> mobileProviderMap = Utils.getMobileProvidersMap();
                return responseSender.ok(mobileProviderMap);
        }

        @RequestMapping(value = ProfitMandiConstants.URL_DTH_OPERATORS, method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        @ApiOperation(value = "")
        public ResponseEntity<?> getAllDTHOperators(HttpServletRequest request){
                Map<Long, String> dthProviderMap = Utils.getDthProvidersMap();
                return responseSender.ok(dthProviderMap);
        }

        @RequestMapping(value = ProfitMandiConstants.URL_RECHARGE_CONFIRM, method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        @ApiOperation(value = "")
        public ResponseEntity<?> confirmRecharge(HttpServletRequest request, @RequestParam(value="rechargeAmount") long rechargeAmount)
                throws ProfitMandiBusinessException{
                int userId = (int)request.getAttribute("userId");
                UserAccounts userAccount = null;
                UserWallet wallet = null;
                if (rechargeAmount <=0){
                        return responseSender.badRequest(null);
                }

                userAccount = userAccountRepository.getUserAccountByType(userId, AccountType.saholic);
                
                try {
                        TransactionClient tc = new TransactionClient();
                        wallet = tc.getClient().getUserWallet(Long.valueOf(userAccount.getAccount_key()));
                } catch (NumberFormatException | TException e) {
                        return responseSender.internalServerError(e);           
                }

                ConfirmRechargeResponse crr = new ConfirmRechargeResponse();
                crr.setWalletAmount(wallet.getAmount());
                crr.setWalletAmountLeft(wallet.getAmount() - rechargeAmount);
                crr.setCanProceed(true);
                if (crr.getWalletAmountLeft() < 0){
                        crr.setCanProceed(false);
                        crr.setReason("You don't have sufficient wallet balance");
                }
                return responseSender.ok(crr);
        }

        @RequestMapping(value = ProfitMandiConstants.URL_CREATE_RECHARGE , method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        public ResponseEntity<?> createRecharge(HttpServletRequest request, @RequestBody CreateRechargeRequest createRechargeRequest)
                throws ProfitMandiBusinessException{
                String ipAddress  = remoteAddr(request);
                String errorMessage = validateRecharge(RechargeType.valueOf(createRechargeRequest.getRechargeType()), createRechargeRequest.getNumber(), createRechargeRequest.getOperatorId(), ipAddress);
                CreateRechargeResponse crr =  new CreateRechargeResponse();
                if(!errorMessage.equals("SUCCESS")){
                        crr.setReason(errorMessage);
                        crr.setResult(false);
                        return responseSender.badRequest(crr);
                }
                int userId = (int)request.getAttribute("userId");
                UserAccounts userAccount = null;
                UserWallet wallet = null;
                if (createRechargeRequest.getRechargeAmount() <=0){
                        crr.setReason("Illegal recharge amount");
                        crr.setResult(false);
                        return responseSender.badRequest(crr);
                }

                userAccount = userAccountRepository.getUserAccountByType(userId, AccountType.saholic);
                
                try {
                        TransactionClient tc = new TransactionClient();
                        wallet = tc.getClient().getUserWallet(Long.valueOf(userAccount.getAccount_key()));
                } catch (NumberFormatException | TException e) {
                        log.error("Unable to get user wallet ",e);
                        crr.setReason("We are experiencing some problem right now.");
                        crr.setResult(false);
                        return responseSender.internalServerError(e);
                }

                if (wallet.getAmount() < createRechargeRequest.getRechargeAmount()){
                        crr.setReason("You don't have sufficient wallet balance.");
                        crr.setResult(false);
                        return responseSender.badRequest(crr);
                }

                User user = null;
                try {
                        user = userRepository.selectById(userId);
                } catch (ProfitMandiBusinessException e) {
                        log.error("Unable to get user",e);
                        crr.setReason("We are experiencing some problem right now.");
                        crr.setResult(false);
                        return responseSender.internalServerError(e);
                }


                RechargeOrder t_rechargeOrder = new RechargeOrder();
                t_rechargeOrder.setTotalAmount(createRechargeRequest.getRechargeAmount());
                t_rechargeOrder.setUserEmailId(user.getEmailId());
                t_rechargeOrder.setUserId(Long.valueOf(userAccount.getAccount_key()));
                t_rechargeOrder.setDeviceNumber(createRechargeRequest.getNumber());
                t_rechargeOrder.setPlan(createRechargeRequest.getPlan()==null?"":createRechargeRequest.getPlan());
                t_rechargeOrder.setOperatorId(createRechargeRequest.getOperatorId());
                t_rechargeOrder.setRechargeType(RechargeType.valueOf(createRechargeRequest.getRechargeType()));
                t_rechargeOrder.setStatus(RechargeOrderStatus.PAYMENT_PENDING);
                t_rechargeOrder.setOrderType(OrderType.B2C);
                t_rechargeOrder.setWalletAmount(createRechargeRequest.getRechargeAmount());
                t_rechargeOrder.setCouponAmount(0);
                t_rechargeOrder.setCouponCode("");
                t_rechargeOrder.setIpAddress(ipAddress);
                TransactionClient tc = null;
                RechargeOrder rechargeOrder;
                try {
                        tc = new TransactionClient();
                        rechargeOrder = tc.getClient().createRechargeOrder(t_rechargeOrder);
                } catch (TransactionServiceException | TException e) {
                        log.error("Unable to create recharge order",e);
                        crr.setReason("We are experiencing some problem right now.");
                        crr.setResult(false);
                        return responseSender.internalServerError(e);
                }

                log.info("Recharge Order:" + rechargeOrder);
                PaymentClient paymentServiceClient = null;
                try {
                        paymentServiceClient = new PaymentClient();
                } catch (TTransportException e) {
                        log.error("Unable to create payment client",e);
                        crr.setReason("We are experiencing some problem right now.");
                        crr.setResult(false);
                        return responseSender.internalServerError(e);
                }
                try {
                        RechargeOrder d_rechargeOrder = tc.getClient().getRechargeOrder(rechargeOrder.getId());
                        List<Payment> payments = paymentServiceClient.getClient().getPaymentForRechargeTxnId(d_rechargeOrder.getTransactionId());
                        if(payments.size() > 0) {
                                throw new PaymentException(d_rechargeOrder.getId(), "Payment already exists for recharge");
                        }
                        Long merchantPaymentId = 0l;
                        if (d_rechargeOrder.getWalletAmount() +  d_rechargeOrder.getCouponAmount() != d_rechargeOrder.getTotalAmount()) {
                                log.error("Wallet amount : " + d_rechargeOrder.getWalletAmount() + ", coupon amount : " + d_rechargeOrder.getCouponAmount() + " and total amount : " + d_rechargeOrder.getTotalAmount());
                                merchantPaymentId = paymentServiceClient.getClient().createPayment(d_rechargeOrder.getUserId(), d_rechargeOrder.getTotalAmount(), 8, d_rechargeOrder.getTransactionId(), true);
                                paymentServiceClient.getClient().updatePaymentDetails(merchantPaymentId, "","", "0", "", "", "", "", "", PaymentStatus.FAILED, "", null);
                                tc.getClient().updateRechargeOrderStatus(d_rechargeOrder.getId(),  RechargeOrderStatus.PAYMENT_FAILED);
                        } else {
                                merchantPaymentId = paymentServiceClient.getClient().createPayment(d_rechargeOrder.getUserId(), d_rechargeOrder.getTotalAmount(), 8, d_rechargeOrder.getTransactionId(), true);
                                //Update payment status as authorized
                                paymentServiceClient.getClient().updatePaymentDetails(merchantPaymentId, "","", "0", "", "", "", "", "", PaymentStatus.SUCCESS, "", null);
                                tc.getClient().updateRechargeOrderStatus(d_rechargeOrder.getId(),  RechargeOrderStatus.PAYMENT_SUCCESSFUL);
                        }
                        crr.setRechargeOrderId(d_rechargeOrder.getId());
                        crr.setResult(true);
                } catch (Exception e) {
                        log.error("Unable to mark the payment as authorized", e);
                        crr.setReason("We are experiencing some problem right now.");
                        crr.setResult(false);
                        return responseSender.internalServerError(e);
                }
                return responseSender.ok(crr);
        }

        @RequestMapping(value = ProfitMandiConstants.URL_RECHARGE_RESULT , method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        public ResponseEntity<?> rechargeResult(HttpServletRequest request, @RequestParam(value="rechargeOrderId") long rechargeOrderId){
                TransactionClient tc=null;
                RechargeOrder rechargeOrder = null;
                RechargeResultPojo rrp = null;
                try {
                        tc = new TransactionClient();
                        rechargeOrder = tc.getClient().getRechargeOrder(rechargeOrderId);
                } catch (TransactionServiceException | TException e) {
                        // return with internal server error
                        e.printStackTrace();
                        rrp = new RechargeResultPojo();
                        rrp.setIsError(true);
                        rrp.setDetailDisplayMessage("We are experiencing some problem right now.");
                        return responseSender.internalServerError(e);
                }
                if (rechargeOrder == null){
                        rrp = new RechargeResultPojo();
                        rrp.setIsError(true);
                        rrp.setDetailDisplayMessage("Recharge order doesnot exist in our system.");
                        return responseSender.badRequest(rrp);
                }
                String[] os = Utils.getOrderStatus(rechargeOrder.getStatus());
                rrp = new RechargeResultPojo();
                rrp.setRechargeDeviceNumber(rechargeOrder.getDeviceNumber());
                rrp.setRechargeDisplayId(rechargeOrder.getDisplayId());
                rrp.setTotalAmount(rechargeOrder.getTotalAmount() + "");
                rrp.setRechargeProvider(Utils.getProvider(rechargeOrder.getOperatorId()));
                rrp.setIsError(Boolean.parseBoolean(os[0]));
                rrp.setRechargeStatus(os[1]);
                rrp.setDetailDisplayMessage(os[2]);
                if (rechargeOrder.getStatus().equals(RechargeOrderStatus.RECHARGE_UNKNOWN)){
                        rrp.setPoll(true);
                }
                return responseSender.ok(rrp);
        }

        @RequestMapping(value = ProfitMandiConstants.URL_POLL_RECHARGE , method=RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        public ResponseEntity<?> pollRechargeResult(HttpServletRequest request, @RequestParam(value="rechargeOrderId") long rechargeOrderId, @RequestParam(value="finalCall") boolean finalCall){
                TransactionClient transactionServiceClient = null;
                RechargeOrder t_rechargeOrder = null;
                RechargeResultPojo rrp = null;
                try{
                        transactionServiceClient = new TransactionClient();
                        t_rechargeOrder = transactionServiceClient.getClient().getRcgOrderStatus(rechargeOrderId, finalCall);
                }
                catch(Exception e){
                        rrp = new RechargeResultPojo();
                        rrp.setRechargeStatus("");
                        return responseSender.internalServerError(e);
                }
                if (t_rechargeOrder == null){
                        rrp = new RechargeResultPojo();
                        rrp.setRechargeStatus("");
                        return responseSender.badRequest(new RechargeResultPojo());
                }
                rrp = new RechargeResultPojo();
                String[] os = Utils.getOrderStatus(t_rechargeOrder.getStatus());
                rrp.setIsError(Boolean.parseBoolean(os[0]));
                rrp.setRechargeStatus(os[1]);
                rrp.setDetailDisplayMessage(os[2]);
                return responseSender.ok(rrp);
        }
        
        @RequestMapping(value = ProfitMandiConstants.URL_MY_RECHARGES , method=RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
        @ApiImplicitParams({
                @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", 
                                required = true, dataType = "string", paramType = "header")
        })
        public ResponseEntity<?> myRecharges(HttpServletRequest request, @RequestParam(value="offset") int offset, @RequestParam(value="limit") int limit) throws ProfitMandiBusinessException{
                TransactionClient tc=null;
                int userId = (int)request.getAttribute("userId");
                UserAccounts userAccount;
                List<RechargeOrder> rechargeOrders = null;
                
                userAccount = userAccountRepository.getUserAccountByType(userId, AccountType.saholic);
                
                try {
                        tc = new TransactionClient();
                        rechargeOrders = tc.getClient().getPaginatedRechargeOrders(Long.valueOf(userAccount.getAccount_key()), offset, limit);
                } catch (Exception e) {
                        log.error("Unable to get recharge order list",e);
                        return responseSender.internalServerError(e);
                }
                List<MyRechargesResponse> myRechargesList = new ArrayList<MyRechargesResponse>();
                for (RechargeOrder rechargeOrder : rechargeOrders){
                        MyRechargesResponse rp = new MyRechargesResponse();
                        if(rechargeOrder.getRechargeType() == RechargeType.MOBILE){
                        rp.setOperator(Utils.getProvider(rechargeOrder.getOperatorId()));
                        rp.setOperatorType("MOBILE");
                }
                if(rechargeOrder.getRechargeType() == RechargeType.DTH){
                        rp.setOperator(Utils.getProvider(rechargeOrder.getOperatorId()));
                        rp.setOperatorType("DTH");
                }
                rp.setOrderId(rechargeOrder.getId());
                rp.setOperatorId(rechargeOrder.getOperatorId());
                rp.setDate(rechargeOrder.getCreationTimestamp());
                rp.setNumber(rechargeOrder.getDeviceNumber());
                rp.setAmount(rechargeOrder.getTotalAmount());
                rp.setStatus(Utils.getRechargeDisplayStatus(rechargeOrder.getStatus()));
                rp.setDisplayOrderId(rechargeOrder.getDisplayId());
                myRechargesList.add(rp);
                }
                return responseSender.ok(myRechargesList);
        }

        
        private String remoteAddr(HttpServletRequest request) {
                String remoteAddr = "";
                String x;
                x = request.getHeader(HEADER_X_FORWARDED_FOR);
                log.info("Value of HEADER_X_FORWARDED_FOR is [{}]", x);
                if (x != null && !x.isEmpty()) {
                        remoteAddr = x;
                        int idx = remoteAddr.lastIndexOf(',');
                        if (idx > -1) {
                                remoteAddr = remoteAddr.substring(idx + 1).trim();
                        }
                } else {
                        remoteAddr = request.getRemoteAddr();
                        log.info("Value of remoteAddr is [{}]", remoteAddr);
                }
                return remoteAddr;
        }

        private String validateRecharge(RechargeType rechargeType, String number, long operatorId, String ipAddress){
                TransactionClient tcl;
                try {
                        tcl = new TransactionClient();
                        String result = tcl.getClient().validateRecharge(rechargeType, number, operatorId, ipAddress);
                        log.info("validateRecharge Called" + number + " and rechargeType : " +  rechargeType + ", IP:" + ipAddress + ", Operator:" + operatorId + ", Result:" + result);
                        return result;
                } 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";
        }


}