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.LoanReferenceType;

import com.spice.profitmandi.dao.enumuration.transaction.LoanSummaryType;

import com.spice.profitmandi.dao.enumuration.transaction.SanctionStatus;

import com.spice.profitmandi.dao.model.FofoReportingModel;

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.cs.CsService1;

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.service.user.UserService;

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.time.temporal.ChronoUnit;

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

    private UserService userService;

    @Autowired

    SDCreditRequirementRepository sdCreditRequirementRepository;

    @Autowired

    SanctionRequestRepository sanctionRequestRepository;

    @Autowired

    PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private CreditAccountRepository creditAccountRepository;

    @Autowired

    private SDCreditService sdCreditService;

    @Autowired

    private CsService1 csService1;

    @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> authIds = sanctionRequests.stream().map(x -> x.getAuthId()).collect(Collectors.toList());

            Map<Integer, String> authMap = authRepository.selectAllAuthUserByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x.getFullName()));

            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("authMap", authMap);

        }

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

        Map<Integer, String> authMap = new HashMap<Integer, String>();

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

        authMap.put(authUser.getId(), authUser.getFullName());

        model.addAttribute("authMap", authMap);

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

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

        }

        sanctionRequest.setFreeDays(sanctionRequestModel.getFreeDays());

        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 = csService1.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 = "/getPartnerWiseLoanSummary", method = RequestMethod.GET)

    public String getPartnerWiseLoanSummary(HttpServletRequest request, @RequestParam LoanSummaryType loanSummaryType, Model model) throws ProfitMandiBusinessException {

        Map<Integer, FofoReportingModel> fofoReportingModelMap = csService.getPartnerIdSalesHeaders();

        List<Loan> loans = new ArrayList<>();

        List<Loan> activeLoans = loanRepository.selectAllActiveLoan();

        if (loanSummaryType.equals(LoanSummaryType.TOTAL_LOAN)) {

            loans.addAll(activeLoans);

        } else if (loanSummaryType.equals(LoanSummaryType.DEFAULT_LOAN)) {

            for (Loan loan : activeLoans) {

                long noOfdaysBetween = ChronoUnit.DAYS.between(loan.getDueDate().toLocalDate(), LocalDateTime.now());

                if (noOfdaysBetween > 15) {

                    loans.add(loan);

                }

            }

        } else if (loanSummaryType.equals(LoanSummaryType.DUE_LOAN)) {

            for (Loan loan : activeLoans) {

                long noOfdaysBetween = ChronoUnit.DAYS.between(loan.getDueDate().toLocalDate(), LocalDateTime.now());

                if (noOfdaysBetween <= 15 && noOfdaysBetween >= 0) {

                    loans.add(loan);

                }

            }

        }

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

        Map<Integer, Double> fofoIdLoansMap = loans.stream().collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.summingDouble(x -> x.getPendingAmount().doubleValue())));

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

        model.addAttribute("customRetailerMap", customRetailerMap);

        model.addAttribute("loans", loans);

        model.addAttribute("fofoReportingModelMap", fofoReportingModelMap);

        model.addAttribute("fofoIdLoansMap", fofoIdLoansMap);

        return "partner-wise-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 = "/getSanctionUnholdOrder", method = RequestMethod.GET)

    public String getSanctionUnholdOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

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

        List<SanctionRequest> sanctionRequests = sanctionRequestRepository.selectHoldSanction();

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

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

            model.addAttribute("transactionAmountMap", transactionAmountMap);

            model.addAttribute("transactionOrdersMap", transactionOrdersMap);

        }

        model.addAttribute("sanctionRequests", sanctionRequests);

        model.addAttribute("customRetailerMap", customRetailerMap);

        return "sanction-order-unhold";

    }

    @RequestMapping(value = "/getSanctionHoldOrder", method = RequestMethod.GET)

    public String getSanctionHoldOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

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

        List<SanctionRequest> sanctionRequests = sanctionRequestRepository.selectHoldSanction();

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

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

            model.addAttribute("transactionAmountMap", transactionAmountMap);

            model.addAttribute("transactionOrdersMap", transactionOrdersMap);

        }

        model.addAttribute("sanctionRequests", sanctionRequests);

        model.addAttribute("customRetailerMap", customRetailerMap);

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

        SanctionRequest sanctionRequest = sanctionRequestRepository.selectByTransactionId(transactionId);

        LOGGER.info("orders" + orders);

        if (sanctionRequest != null) {

            sanctionRequest.setPendingAmount(BigDecimal.ZERO);

        }

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

    }

}