Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.common.enumuration.MessageType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CustomRetailer;
import com.spice.profitmandi.common.model.SendNotificationModel;
import com.spice.profitmandi.common.util.Utils;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.dtr.CreditAccount;
import com.spice.profitmandi.dao.entity.dtr.CreditStatus;
import com.spice.profitmandi.dao.entity.fofo.CurrentPartnerDailyInvestment;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;
import com.spice.profitmandi.dao.entity.transaction.*;
import com.spice.profitmandi.dao.entity.user.Address;
import com.spice.profitmandi.dao.enumuration.fofo.Gateway;
import com.spice.profitmandi.dao.enumuration.transaction.SanctionStatus;
import com.spice.profitmandi.dao.model.SDCreditResponseOut;
import com.spice.profitmandi.dao.model.SanctionRequestModel;
import com.spice.profitmandi.dao.model.SdCreditRequirementModel;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.dtr.CreditAccountRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
import com.spice.profitmandi.dao.repository.fofo.CurrentPartnerDailyInvestmentRepository;
import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;
import com.spice.profitmandi.dao.repository.transaction.*;
import com.spice.profitmandi.dao.repository.user.AddressRepository;
import com.spice.profitmandi.service.NotificationService;
import com.spice.profitmandi.service.transaction.SDCreditService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import com.spice.profitmandi.web.util.MVCResponseSender;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
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 javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;

@Controller
@Transactional(rollbackOn = Throwable.class)
public class SDCreditController {

        @Autowired
        private RetailerService retailerService;

        @Autowired
        SDCreditRequirementRepository sdCreditRequirementRepository;

        @Autowired
        SanctionRequestRepository sanctionRequestRepository;

        @Autowired
        PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        @Autowired
        private CreditAccountRepository creditAccountRepository;

        @Autowired
        private SDCreditService sdCreditService;

        @Autowired
        private NotificationService notificationService;

        @Autowired
        private AuthRepository authRepository;

        @Autowired
        private UserRepository userRepository;

        @Autowired
        private CurrentPartnerDailyInvestmentRepository currentPartnerDailyInvestmentRepository;

        @Autowired
        private UserWalletRepository userWalletRepository;

        @Autowired
        LoanRepository loanRepository;

        @Autowired
        private CookiesProcessor cookiesProcessor;

        @Autowired
        private CsService csService;

        @Autowired
        AddressRepository addressRepository;

        @Autowired
        OrderRepository orderRepository;

        @Autowired
        private LoanStatementRepository loanStatementRepository;

        @Autowired
        private com.spice.profitmandi.dao.repository.user.UserRepository userUserRepository;

        @Autowired
        private JavaMailSender mailSender;

        @Autowired
        private MVCResponseSender mvcResponseSender;

        private static final Logger LOGGER = LogManager.getLogger(SDCreditController.class);

        @RequestMapping(value = "/getSDCreditReq", method = RequestMethod.GET)
        public String getSDCreditReq(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

                Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(true);

                Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll().stream()
                                .collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
                for (Entry<Integer, CustomRetailer> customRetailerEntry : customRetailerMap.entrySet()) {
                        int fofoId = customRetailerEntry.getKey();

                        SDCreditRequirement sdCreditRequirement = sdCreditRequirementMap.get(customRetailerEntry.getKey());

                        if (sdCreditRequirement != null) {

                                BigDecimal utilizedLimit = new BigDecimal(sdCreditService.getUtilizationAmount(fofoId));

                                BigDecimal availableLimit = sdCreditRequirement.getLimit().subtract(utilizedLimit);

                                LOGGER.info("utilizedLimit {} ", utilizedLimit);

                                LOGGER.info("availableLimit {} ", availableLimit);

                                sdCreditRequirement.setUtilizedAmount(utilizedLimit);

                                sdCreditRequirement.setUpdateTimestamp(LocalDateTime.now());
                        }

                }

                model.addAttribute("customRetailerMap", customRetailerMap);
                model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);
                return "sd-credit";
        }

        @RequestMapping(value = "/creditRequirement", method = RequestMethod.POST)
        public String sdCredit(HttpServletRequest request, @RequestBody SdCreditRequirementModel sdCreditRequirementModel,
                        Model model) throws Exception {

                LOGGER.info("sdCreditRequirementModel {} ", sdCreditRequirementModel);

                int fofoId = sdCreditRequirementModel.getFofoId();

                SDCreditRequirement sdCreditRequirement = sdCreditRequirementRepository
                                .selectByFofoId(sdCreditRequirementModel.getFofoId());

                FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(sdCreditRequirementModel.getFofoId());
                sdCreditRequirement.setSecurityCheck(sdCreditRequirementModel.getSecurityCheck());
                // sdCreditRequirement.setSecurityCheck(2);

                sdCreditRequirement.setInterestRate(sdCreditRequirementModel.getInterest());
                sdCreditRequirement.setFreeDays(sdCreditRequirementModel.getFreeDays());
                sdCreditRequirement.setLimit(sdCreditRequirementModel.getLimit());
                BigDecimal utilizedLimit = new BigDecimal(sdCreditService.getUtilizationAmount(fofoId));

                BigDecimal availableLimit = sdCreditRequirement.getLimit().subtract(utilizedLimit);

                LOGGER.info("utilizedLimit {} ", utilizedLimit);

                LOGGER.info("availableLimit {} ", availableLimit);

                sdCreditRequirement.setUtilizedAmount(utilizedLimit);

                sdCreditRequirement.setCreditDays(15);
                sdCreditRequirement.setUpdateTimestamp(LocalDateTime.now());

                if (sdCreditRequirement.getSecurityCheck() > 0) {

                        CreditAccount creditAccount = creditAccountRepository
                                        .selectByFofoIdAndGateway(sdCreditRequirementModel.getFofoId(), Gateway.SDDIRECT);
                        if (creditAccount == null) {
                                creditAccount = new CreditAccount();
                                creditAccount.setFofoId(sdCreditRequirementModel.getFofoId());
                                creditAccount.setGateway(Gateway.SDDIRECT);
                                creditAccount.setCreditStatus(CreditStatus.SANCTIONED);
                                creditAccount.setActive(false);

                                creditAccount.setUpdatedOn(LocalDateTime.now());

                                creditAccountRepository.persist(creditAccount);
                        }

                        creditAccount.setInterestRate(sdCreditRequirement.getInterestRate().floatValue());
                        creditAccount.setSanctionedAmount(sdCreditRequirement.getLimit().floatValue());
                        creditAccount.setAvailableAmount(availableLimit.floatValue());
                        creditAccount.setFreeDays(sdCreditRequirement.getFreeDays());
                        creditAccount.setUpdatedOn(LocalDateTime.now());

                }
                LOGGER.info("sdCreditRequirement {} ", sdCreditRequirement);

                CustomRetailer customRetailer = retailerService.getFofoRetailer(sdCreditRequirementModel.getFofoId());

                sdCreditRequirement = sdCreditRequirementRepository.selectByFofoId(sdCreditRequirementModel.getFofoId());

                Map<Integer, SDCreditRequirement> sdCreditRequirementMap = new HashMap<>();
                sdCreditRequirementMap.put(sdCreditRequirement.getFofoId(), sdCreditRequirement);
                model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);
                model.addAttribute("customRetailer", customRetailer);

                return "sd-credit-requirement-row";

        }

        @RequestMapping(value = "/getSanctionRequest", method = RequestMethod.GET)
        public String getSanctionRequest(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

                List<SanctionRequest> sanctionRequests = sanctionRequestRepository.selectByDate(LocalDate.now());

                if (!sanctionRequests.isEmpty()) {

                        List<Integer> fofoIds = sanctionRequests.stream().map(x -> x.getFofoId()).collect(Collectors.toList());

                        Map<Integer, Long> partnerCreditDaysMap = new HashMap<>();

                        Map<Integer, Integer> partnerActiveLoanMap = new HashMap<>();

                        for (Integer fofoId : fofoIds) {
                                List<Loan> loans = loanRepository.selectActiveLoan(fofoId);

                                if (!loans.isEmpty()) {

                                        partnerActiveLoanMap.put(fofoId, loans.size());
                                        Loan loan = loans.get(loans.size() - 1);

                                        long daysBetween = Duration.between(loan.getCreatedOn(), LocalDateTime.now()).toDays();

                                        partnerCreditDaysMap.put(fofoId, daysBetween);

                                }
                                model.addAttribute("partnerCreditDaysMap", partnerCreditDaysMap);
                                model.addAttribute("partnerActiveLoanMap", partnerActiveLoanMap);

                        }

                        Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll()
                                        .stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

                        Map<Integer, UserWallet> userWalletMap = userWalletRepository.selectByRetailerIds(new HashSet<>(fofoIds))
                                        .stream().collect(Collectors.toMap(x -> x.getUserId(), x -> x));

                        Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(fofoIds);
                        Map<Integer, PartnerDailyInvestment> partnerDailyInvestmentMap = partnerDailyInvestmentRepository
                                        .selectAll(fofoIds, LocalDate.now().minusDays(1)).stream()
                                        .collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

                        model.addAttribute("customRetailerMap", customRetailerMap);

                        model.addAttribute("partnerDailyInvestmentMap", partnerDailyInvestmentMap);
                        model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);

                        model.addAttribute("userWalletMap", userWalletMap);

                }

                model.addAttribute("sanctionRequests", sanctionRequests);

                model.addAttribute("sanctionStatus", SanctionStatus.values());
                return "sanction-request";

        }

        @RequestMapping(value = "/sanctionRequest", method = RequestMethod.POST)
        public String sanctionRequest(HttpServletRequest request, @RequestBody SanctionRequestModel sanctionRequestModel,
                        Model model) throws Exception {

                LOGGER.info("sanctionRequestModel {} ", sanctionRequestModel);
                Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll().stream()
                                .collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

                SanctionRequest sanctionRequest = sanctionRequestRepository.selectById(sanctionRequestModel.getId());
                List<Integer> fofoIds = sanctionRequestRepository.selectByDate(LocalDate.now()).stream().map(x -> x.getFofoId())
                                .collect(Collectors.toList());

                Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(fofoIds);

                LOGGER.info("freeDays {} ", sdCreditRequirementMap.get(sanctionRequest.getFofoId()).getFreeDays());

                if (sanctionRequestModel.getStatus().equals(SanctionStatus.APPROVED)) {
                        CustomRetailer customRetailer = customRetailerMap.get(sanctionRequest.getFofoId());
                        sanctionRequest.setApprovalTimestamp(LocalDateTime.now());
                        BigDecimal availableAmount = sdCreditService.getAvailableAmount(sanctionRequest.getFofoId());

                        String title = "Sanction Request Approved";
                        String url = "http://app.smartdukaan.com/pages/home/credit";
                        String message = "Congratulations! Your credit limit is increased for today Rs."
                                        + sanctionRequest.getApprovalAmount().setScale(2, RoundingMode.HALF_UP)
                                        + ". Your total available limit is Rs." + availableAmount.setScale(2, RoundingMode.HALF_UP) + ".";
                        notificationService.sendNotification(sanctionRequest.getFofoId(), title, MessageType.notification, title,
                                        message, url);
                        com.spice.profitmandi.dao.entity.user.User user = userUserRepository
                                        .selectById(sanctionRequest.getFofoId());

                        Address address = addressRepository.selectById(user.getAddressId());

                        notificationService.sendWhatsappMessage(message, title, address.getPhoneNumber());

                        AuthUser authUser = authRepository.selectById(sanctionRequest.getAuthId());

                        String empMessage = "Congratulations! Your Partner " + customRetailer.getBusinessName()
                                        + " credit limit is increased for today Rs."
                                        + sanctionRequest.getApprovalAmount().setScale(2, RoundingMode.HALF_UP)
                                        + " and total available limit is Rs." + availableAmount.setScale(2, RoundingMode.HALF_UP) + ".";
                        SendNotificationModel sendNotificationModel = new SendNotificationModel();
                        sendNotificationModel.setCampaignName("Sanction Request");
                        sendNotificationModel.setTitle("title");
                        sendNotificationModel.setMessage(empMessage);
                        sendNotificationModel.setType("url");
                        sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/credit");
                        sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));
                        sendNotificationModel.setMessageType(MessageType.notification);
                        sendNotificationModel
                                        .setUserIds(Arrays.asList(userRepository.selectByEmailId(authUser.getEmailId()).getId()));
                        System.out.println(sendNotificationModel);
                        notificationService.sendNotification(sendNotificationModel);

                        notificationService.sendWhatsappMessage(empMessage, title, authUser.getMobileNumber());

                }

                if (sdCreditRequirementMap.get(sanctionRequest.getFofoId()).getFreeDays() >= sanctionRequestModel
                                .getFreeDays()) {
                        sanctionRequest.setFreeDays(sanctionRequestModel.getFreeDays());
                } else {
                        throw new ProfitMandiBusinessException("Free Days", "Free Days", "Free Days is not more than "
                                        + sdCreditRequirementMap.get(sanctionRequest.getFofoId()).getFreeDays() + " days ");
                }

                sanctionRequest.setApprovalAmount(sanctionRequestModel.getApprovalAmount());
                sanctionRequest.setStatus(sanctionRequestModel.getStatus());
                sanctionRequest.setStockHold(sanctionRequestModel.isStockHold());

                Map<Integer, PartnerDailyInvestment> partnerDailyInvestmentMap = partnerDailyInvestmentRepository
                                .selectAll(fofoIds, LocalDate.now().minusDays(1)).stream()
                                .collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

                Map<Integer, UserWallet> userWalletMap = userWalletRepository.selectByRetailerIds(new HashSet<>(fofoIds))
                                .stream().collect(Collectors.toMap(x -> x.getUserId(), x -> x));

                sanctionRequest = sanctionRequestRepository.selectById(sanctionRequestModel.getId());
                model.addAttribute("customRetailerMap", customRetailerMap);
                model.addAttribute("sanctionRequest", sanctionRequest);
                model.addAttribute("partnerDailyInvestmentMap", partnerDailyInvestmentMap);
                model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);
                model.addAttribute("userWalletMap", userWalletMap);

                model.addAttribute("sanctionStatus", SanctionStatus.values());

                return "sanction-request-row";

        }

        List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "neeraj.gupta@smartdukaan.com",
                        "amit.gupta@smartdukaan.com");

        @RequestMapping(value = "/getLoans", method = RequestMethod.GET)
        public String getLoans(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                String email = loginDetails.getEmailId();

                AuthUser authUser = authRepository.selectByEmailOrMobile(email);
                Set<Integer> fofoIds = csService.getAuthFofoIds(email, false);

                LOGGER.info("fofoIds" + fofoIds);
                if (fofoIds == null) {
                        throw new ProfitMandiBusinessException("you are not authorized", "", "you are not authorized" + " " + "");
                }

                List<Loan> loans = loanRepository.selectAllLoans(new ArrayList<>(fofoIds));

                List<Integer> loanFofoIds = loans.stream().map(x -> x.getFofoId()).collect(Collectors.toList());

                List<SDCreditRequirement> sdCreditRequirements = sdCreditRequirementRepository
                                .selectByFofoIds(new ArrayList<>(loanFofoIds));

                Map<Integer, Long> loanCountMap = loans.stream()
                                .collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

                Map<Integer, UserWallet> userWalletMap = userWalletRepository.selectByRetailerIds(fofoIds).stream()
                                .collect(Collectors.toMap(x -> x.getUserId(), x -> x));
                Map<Integer, CurrentPartnerDailyInvestment> currentPartnerDailyInvestmentMap = currentPartnerDailyInvestmentRepository
                                .selectAll().stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

                model.addAttribute("userWalletMap", userWalletMap);

                model.addAttribute("currentPartnerDailyInvestmentMap", currentPartnerDailyInvestmentMap);

                Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(new ArrayList<>(fofoIds));
                model.addAttribute("sdCreditRequirements", sdCreditRequirements);
                model.addAttribute("loanCountMap", loanCountMap);
                model.addAttribute("customRetailerMap", customRetailerMap);
                return "loan-summary";

        }

        @RequestMapping(value = "/getLoanSummary", method = RequestMethod.GET)
        public String getLoanSummary(HttpServletRequest request, @RequestParam int fofoId, Model model)
                        throws ProfitMandiBusinessException {

                SDCreditResponseOut sdCreditResponseOut = sdCreditService.sdDirectService(fofoId);
                CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

                model.addAttribute("customRetailer", customRetailer);
                model.addAttribute("loanSummary", sdCreditResponseOut.getLoans());

                return "loan-summary-detail";

        }

        @RequestMapping(value = "/getSanctionHoldOrder", method = RequestMethod.GET)
        public String getSanctionHoldOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

                List<Order> allOrders = orderRepository.selectHoldOrder();

                LOGGER.info("allOrders {}", allOrders);

                if (!allOrders.isEmpty()) {
                        Map<Integer, Double> transactionAmountMap = allOrders.stream().collect(
                                        Collectors.groupingBy(Order::getTransactionId, Collectors.summingDouble(x -> x.getTotalAmount())));

                        Map<Integer, List<Order>> transactionOrdersMap = allOrders.stream()
                                        .collect(Collectors.groupingBy(Order::getTransactionId, Collectors.toList()));

                        List<SanctionRequest> sanctionRequests = sanctionRequestRepository
                                        .selectByTransactionId(new ArrayList<>(transactionAmountMap.keySet()));

                        model.addAttribute("transactionAmountMap", transactionAmountMap);

                        model.addAttribute("transactionOrdersMap", transactionOrdersMap);

                        model.addAttribute("sanctionRequests", sanctionRequests);

                        Map<Integer, Double> transactionCreditMap = new HashMap<>();
                        for (Entry<Integer, List<Order>> transactionOrderEntry : transactionOrdersMap.entrySet()) {

                                List<Order> orders = transactionOrderEntry.getValue();

                                LocalDateTime createDate = orders.get(0).getCreateTimestamp();

                                int fofoId = orders.get(0).getRetailerId();

                                double loanSettleAmount = loanStatementRepository.selectByDateAndFofoId(createDate, fofoId).stream()
                                                .filter(x -> x.getAmount().doubleValue() > 0)
                                                .collect(Collectors.summingDouble(x -> x.getAmount().doubleValue()));

                                transactionCreditMap.put(transactionOrderEntry.getKey(), loanSettleAmount);

                        }

                        model.addAttribute("transactionCreditMap", transactionCreditMap);

                }

                return "sanction-order-hold";

        }

        @RequestMapping(value = "/unholdOrder", method = RequestMethod.POST)
        public String unholdOrder(HttpServletRequest request, @RequestParam int transactionId, Model model)
                        throws Exception {

                List<Order> orders = orderRepository.selectAllByTransactionId(transactionId);

                LOGGER.info("orders" + orders);

                if (!orders.isEmpty()) {
                        orders.forEach(x -> x.setShipmentHold(false));
                }

                double totalAmount = orders.stream().collect(Collectors.summingDouble(x -> x.getTotalAmount()));

                try {

                        List<String> authUserEmail = csService.getAuthUserIdByPartnerId(orders.get(0).getRetailerId()).stream()
                                        .map(x -> x.getEmailId()).collect(Collectors.toList());

                        authUserEmail.add("vinay.p@smartdukaan.com");
                        authUserEmail.add("shivam.gupta@smartdukaan.com");

                        String[] emailTo = authUserEmail.toArray(new String[authUserEmail.size()]);

                        String[] ccTo = { "tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com" };

                        String subject = "Dispatched " + (orders.get(0).getRetailerName());
                        String message = String.format("Dear Team, \n" + "Kindly note the meterial for the "
                                        + orders.get(0).getRetailerName() + "of Rs." + totalAmount + " is dispatched.");

                        LOGGER.info("message" + message);

                        Utils.sendMailWithAttachments(mailSender, emailTo, ccTo, subject, message);
                } catch (Exception e) {

                        e.printStackTrace();

                }

                model.addAttribute("response1", mvcResponseSender.createResponseString(true));

                return "response";

        }

}