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.LoanSummaryType;
import com.spice.profitmandi.dao.enumuration.transaction.SanctionStatus;
import com.spice.profitmandi.dao.model.*;
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.FofoOrderItemRepository;
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.*;

import javax.servlet.http.HttpServletRequest;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;

@Controller
@Transactional(rollbackFor = 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;

    @Autowired
    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired
    private com.spice.profitmandi.service.transaction.CreditBlockedExceptionPartnersRepository creditBlockedExceptionPartnersRepository;

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

    @RequestMapping(value = "/getSDCreditReq", method = RequestMethod.GET)
    public String getSDCreditReq(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isTarun = loginDetails.getEmailId().equals("tarun.verma@smartdukaan.com") || loginDetails.getEmailId().equals("kamini.sharma@smartdukaan.com");

        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 = 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);
        model.addAttribute("isTarun", isTarun);
        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());

        // sdCreditRequirement.setSecurityCheck(2);
        sdCreditRequirement.setSecurityCheck(sdCreditRequirementModel.getSecurityCheck());


        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isTarun = loginDetails.getEmailId().equals("tarun.verma@smartdukaan.com") || loginDetails.getEmailId().equals("kamini.sharma@smartdukaan.com");
        sdCreditRequirement.setInterestRate(sdCreditRequirementModel.getInterest());
        sdCreditRequirement.setFreeDays(sdCreditRequirementModel.getFreeDays());
        BigDecimal utilizedLimit = sdCreditService.getUtilizationAmount(fofoId);
        BigDecimal availableLimit = sdCreditRequirement.getLimit().subtract(utilizedLimit);
        sdCreditRequirement.setUtilizedAmount(utilizedLimit);
        if (isTarun) {
            if (sdCreditRequirement.getLimit() != sdCreditRequirementModel.getLimit()) {
                sdCreditRequirement.setLimit(sdCreditRequirementModel.getLimit());
                sdCreditRequirement.setHardLimit(true);
                sdCreditService.updateMinInvestmentForHardLimit(sdCreditRequirement, true);
            }
        }

        sdCreditRequirement.setLimit(sdCreditRequirementModel.getLimit());
        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);
        model.addAttribute("isTarun", isTarun);

        return "sd-credit-requirement-row";

    }

    @RequestMapping(value = "/resetHardLimit", method = RequestMethod.PUT)
    public String resetHardLimit(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        if (loginDetails.getEmailId().equals("tarun.verma@smartdukaan.com") || loginDetails.getEmailId().equals("kamini.sharma@smartdukaan.com")) {
            SDCreditRequirement sdCreditRequirement = sdCreditRequirementRepository.selectById(id);
            sdCreditRequirement.setHardLimit(false);
            FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(sdCreditRequirement.getFofoId());
            fofoStore.setMinimumInvestment(fofoStore.getMinimumInvestmentOld());
            sdCreditRequirement.setLimit(sdCreditRequirement.getSuggestedLimit());
        }
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
        return "response";
    }

    @RequestMapping(value = "/addCreditBlockedException", method = RequestMethod.POST)
    public String addCreditBlockedException(HttpServletRequest request, @RequestParam int fofoId, Model model) throws Exception {
        LOGGER.info("Adding credit blocked exception for fofoId: {} for today", fofoId);

        CreditBlockedExceptionPartner existingException = creditBlockedExceptionPartnersRepository.select(fofoId);
        if (existingException != null && existingException.getOnDate().equals(LocalDate.now())) {
            LOGGER.info("Exception already exists for fofoId: {} for today", fofoId);
            model.addAttribute("response1", mvcResponseSender.createResponseString(true));
            return "response";
        }

        CreditBlockedExceptionPartner exception = new CreditBlockedExceptionPartner();
        exception.setFofoId(fofoId);
        exception.setOnDate(LocalDate.now());
        creditBlockedExceptionPartnersRepository.persist(exception);

        LOGGER.info("Credit blocked exception added successfully for fofoId: {}", fofoId);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
        return "response";
    }

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

        List<SanctionRequest> sanctionRequests = sanctionRequestRepository.getL2ApprovedByDate(LocalDate.now(), SanctionStatus.APPROVED);


        if (!sanctionRequests.isEmpty()) {

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

            Map<Integer, String> authMap = authRepository.selectByIds(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<>();
            Map<Integer, Integer> partnerAverageCreditDaysMap = new HashMap<>();

            LocalDateTime curDate = LocalDate.now().atStartOfDay();

            /*Map<Integer, Double> lmtdSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(
                    curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1), 0, false);

            Map<Integer, Double> mtdSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), 0, false);

            Map<Integer, Double> lmsSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(
                    curDate.withDayOfMonth(1).minusMonths(1), curDate.withDayOfMonth(1), 0, false);*/

            Map<Integer, Double> secondaryMtd = orderRepository
                    .selectBillingDatesBetweenSumGroupByRetailerId(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX));
            Map<Integer, Double> secondaryLmtd = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                    curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1));
            Map<Integer, Double> secondaryLms = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                    curDate.withDayOfMonth(1).minusMonths(1), curDate.withDayOfMonth(1));

            List<Loan> loans = loanRepository.selectAllLoans(fofoIds, DateRangeModel.withStartDate(curDate.minusYears(2)));
            Map<Integer, List<Loan>> partnerClosedLoansMap = loans.stream().filter(x -> x.getPendingAmount().compareTo(BigDecimal.ZERO) == 0)
                    .collect(Collectors.groupingBy(x -> x.getFofoId()));


            Map<Integer, List<Loan>> activeLoansMap = loans.stream().filter(x -> x.getPendingAmount().compareTo(BigDecimal.ZERO) == 1).collect(Collectors.groupingBy(x -> x.getFofoId()));

            for (Integer fofoId : fofoIds) {
                LOGGER.info("Fofo Id - {}", fofoId);
                List<Loan> activeLoans = activeLoansMap.get(fofoId);
                if (activeLoans != null) {
                    partnerActiveLoanMap.put(fofoId, activeLoans.size());
                    Loan loan = activeLoans.stream().sorted(Comparator.comparing(Loan::getCreatedOn)).findFirst().get();
                    long daysBetween = Duration.between(loan.getCreatedOn(), LocalDateTime.now()).toDays();
                    partnerCreditDaysMap.put(fofoId, daysBetween);
                }
                List<Loan> closedLoans = partnerClosedLoansMap.get(fofoId);
                if (closedLoans != null) {
                    long averageCreditDays = Math.round(closedLoans.stream().mapToLong(x -> Duration.between(x.getCreatedOn(),
                            x.getSettledOn() == null ? x.getCreatedOn().plusDays(10) : x.getSettledOn()).toDays() + 1).average().orElse(0.0));
                    partnerAverageCreditDaysMap.put(fofoId, (int) averageCreditDays);
                }

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

            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));
            LOGGER.info("partnerDailyInvestmentMap {}", partnerDailyInvestmentMap);

            model.addAttribute("customRetailerMap", customRetailerMap);

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

            model.addAttribute("userWalletMap", userWalletMap);
            model.addAttribute("authMap", authMap);
            model.addAttribute("secondaryMtd", secondaryMtd);
            model.addAttribute("secondarylmtd", secondaryLmtd);
            model.addAttribute("secondarylms", secondaryLms);

            List<CreditAccount> creditAccounts = creditAccountRepository.selectByFofoIds(fofoIds);
            model.addAttribute("creditAccounts", creditAccounts.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x.getGateway())));
        }

        model.addAttribute("sanctionRequests", sanctionRequests);

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

    }


    @RequestMapping(value = "/getRbmL2SanctionRequest", method = RequestMethod.GET)
    public String getRbmL2SanctionRequest(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.selectByIds(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<>();
            Map<Integer, Integer> partnerAverageCreditDaysMap = new HashMap<>();

            LocalDateTime curDate = LocalDate.now().atStartOfDay();

            Map<Integer, Double> secondaryMtd = orderRepository
                    .selectBillingDatesBetweenSumGroupByRetailerId(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX));
            Map<Integer, Double> secondaryLmtd = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                    curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1));
            Map<Integer, Double> secondaryLms = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                    curDate.withDayOfMonth(1).minusMonths(1), curDate.withDayOfMonth(1));

            List<Loan> loans = loanRepository.selectAllLoans(fofoIds, DateRangeModel.withStartDate(curDate.minusYears(2)));
            Map<Integer, List<Loan>> partnerClosedLoansMap = loans.stream().filter(x -> x.getPendingAmount().compareTo(BigDecimal.ZERO) == 0)
                    .collect(Collectors.groupingBy(x -> x.getFofoId()));


            Map<Integer, List<Loan>> activeLoansMap = loans.stream().filter(x -> x.getPendingAmount().compareTo(BigDecimal.ZERO) == 1).collect(Collectors.groupingBy(x -> x.getFofoId()));

            for (Integer fofoId : fofoIds) {
                LOGGER.info("Fofo Id - {}", fofoId);
                List<Loan> activeLoans = activeLoansMap.get(fofoId);
                if (activeLoans != null) {
                    partnerActiveLoanMap.put(fofoId, activeLoans.size());
                    Loan loan = activeLoans.stream().sorted(Comparator.comparing(Loan::getCreatedOn)).findFirst().get();
                    long daysBetween = Duration.between(loan.getCreatedOn(), LocalDateTime.now()).toDays();
                    partnerCreditDaysMap.put(fofoId, daysBetween);
                }
                List<Loan> closedLoans = partnerClosedLoansMap.get(fofoId);
                if (closedLoans != null) {
                    long averageCreditDays = Math.round(closedLoans.stream().mapToLong(x -> Duration.between(x.getCreatedOn(),
                            x.getSettledOn() == null ? x.getCreatedOn().plusDays(10) : x.getSettledOn()).toDays() + 1).average().orElse(0.0));
                    partnerAverageCreditDaysMap.put(fofoId, (int) averageCreditDays);
                }

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

            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("secondaryMtd", secondaryMtd);
            model.addAttribute("secondarylmtd", secondaryLmtd);
            model.addAttribute("secondarylms", secondaryLms);

            List<CreditAccount> creditAccounts = creditAccountRepository.selectByFofoIds(fofoIds);
            model.addAttribute("creditAccounts", creditAccounts.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x.getGateway())));
        }

        model.addAttribute("sanctionRequests", sanctionRequests);

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

    }

    @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<>();
        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());
            //TODO-Whatsapp
            //notificationService.sendWhatsappMessage(message, title, address.getPhoneNumber());

            String empMessage = "Congratulations! Your Partner " + customRetailer.getBusinessName() + " credit limit is increased for today by Rs." + sanctionRequest.getApprovalAmount().setScale(2, RoundingMode.HALF_UP) + " and now the new 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());
        if (sanctionRequestModel.getApprovalAmount() == null) {
            sanctionRequest.setStatus(SanctionStatus.REJECTED);
            sanctionRequest.setRbmL2ApprovalStatus(SanctionStatus.REJECTED);
        } else {
            sanctionRequest.setStatus(sanctionRequestModel.getStatus());
        }

        sanctionRequest.setStockHold(sanctionRequestModel.isStockHold());

        LocalDateTime curDate = LocalDate.now().atStartOfDay();

        /*Map<Integer, Double> lmtdSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(
                curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1), sanctionRequest.getFofoId(), false);

        Map<Integer, Double> mtdSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), sanctionRequest.getFofoId(), false);

        Map<Integer, Double> lmsSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(
                curDate.withDayOfMonth(1).minusMonths(1), curDate.withDayOfMonth(1), sanctionRequest.getFofoId(), false);*/

        Map<Integer, Double> secondaryMtd = orderRepository
                .selectBillingDatesBetweenSumGroupByRetailerId(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX));
        Map<Integer, Double> secondarylmtd = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1));
        Map<Integer, Double> secondarylms = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                curDate.withDayOfMonth(1).minusMonths(1), curDate.withDayOfMonth(1));

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

        model.addAttribute("secondarylmtd", secondarylmtd);
        model.addAttribute("secondaryMtd", secondaryMtd);
        model.addAttribute("secondarylms", secondarylms);

        List<CreditAccount> creditAccounts = creditAccountRepository.selectByFofoIds(Arrays.asList(sanctionRequest.getFofoId()));
        model.addAttribute("creditAccounts", creditAccounts.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x.getGateway())));
        return "sanction-request-row";

    }

    @RequestMapping(value = "/rbmL2ApprovalSanctionRequest", method = RequestMethod.POST)
    public String rbmL2ApprovalSanctionRequest(HttpServletRequest request, @RequestBody SanctionRequestModel sanctionRequestModel, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        AuthUser approverAuthUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
        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<>();

        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)) {
            sanctionRequest.setRbmL2ApprovalTimestamp(LocalDateTime.now());
            sanctionRequest.setRbmL2ApproverEmail(approverAuthUser.getEmailId());
        }

        sanctionRequest.setFreeDays(sanctionRequestModel.getFreeDays());

        sanctionRequest.setApprovalAmount(sanctionRequestModel.getApprovalAmount());
        if (sanctionRequestModel.getApprovalAmount() == null) {

            sanctionRequest.setStatus(SanctionStatus.REJECTED);

            sanctionRequest.setRbmL2ApprovalStatus(SanctionStatus.REJECTED);
            sanctionRequest.setRbmL2ApprovalTimestamp(LocalDateTime.now());
            sanctionRequest.setRbmL2ApproverEmail(approverAuthUser.getEmailId());
        } else {
            sanctionRequest.setRbmL2ApprovalStatus(sanctionRequestModel.getStatus());
        }

        sanctionRequest.setStockHold(sanctionRequestModel.isStockHold());

        LocalDateTime curDate = LocalDate.now().atStartOfDay();


        Map<Integer, Double> secondaryMtd = orderRepository
                .selectBillingDatesBetweenSumGroupByRetailerId(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX));
        Map<Integer, Double> secondarylmtd = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1));
        Map<Integer, Double> secondarylms = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(
                curDate.withDayOfMonth(1).minusMonths(1), curDate.withDayOfMonth(1));

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

        model.addAttribute("secondarylmtd", secondarylmtd);
        model.addAttribute("secondaryMtd", secondaryMtd);
        model.addAttribute("secondarylms", secondarylms);

        List<CreditAccount> creditAccounts = creditAccountRepository.selectByFofoIds(Arrays.asList(sanctionRequest.getFofoId()));
        model.addAttribute("creditAccounts", creditAccounts.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x.getGateway())));
        return "rbm-l2-pending-sanction-request";

    }

    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<LoanCountByFofoIdModel> loanCountByFofoIdModels = loanRepository.getAllLoanCountByFofoId(fofoIds);
        Map<Integer, Long> loanCountMap = loanCountByFofoIdModels.stream().collect(Collectors.toMap(LoanCountByFofoIdModel::getFofoId, LoanCountByFofoIdModel::getLoanCount));

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

        List<Integer> loanFofoIds = loanCountByFofoIdModels.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()));
//        LOGGER.info("loanCountMap" + loanCountMap);

        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 = loanRepository.selectAllActiveLoan();
        if (loanSummaryType.equals(LoanSummaryType.DEFAULT_LOAN)) {
            loans = loans.stream().filter(x -> x.isDefault()).collect(Collectors.toList());
        } else if (loanSummaryType.equals(LoanSummaryType.DUE_LOAN)) {
            loans = loans.stream().filter(x -> x.isOverdue()).collect(Collectors.toList());
        }
        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);
        Map<Integer, Long> loanCountMap = loans.stream().collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));
        model.addAttribute("customRetailerMap", customRetailerMap);
        model.addAttribute("loans", loans);
        model.addAttribute("fofoReportingModelMap", fofoReportingModelMap);
        model.addAttribute("fofoIdLoansMap", fofoIdLoansMap);
        model.addAttribute("loanCountMap", loanCountMap);
        return "partner-wise-loan-summary";
    }

    @RequestMapping(value = "/getPartnerStateWiseLoanSummary", method = RequestMethod.GET)
    public String getPartnerStateWiseLoanSummary(HttpServletRequest request, @RequestParam LoanSummaryType loanSummaryType, @RequestParam String stateName, @RequestParam(required = false) Integer fromDays, @RequestParam(required = false) Integer toDays, Model model) throws ProfitMandiBusinessException {
        Map<Integer, FofoReportingModel> fofoReportingModelMap = csService.getPartnerIdSalesHeaders();
        List<Loan> loans = loanRepository.selectAllStateWiseActiveLoan(stateName);
        if (loanSummaryType.equals(LoanSummaryType.DEFAULT_LOAN)) {
            loans = loans.stream().filter(x -> x.isDefault()).collect(Collectors.toList());
        } else if (loanSummaryType.equals(LoanSummaryType.DUE_LOAN)) {
            loans = loans.stream().filter(x -> x.isOverdue()).collect(Collectors.toList());
        }

        // Apply aging filter
        if (fromDays != null && toDays != null) {
            loans = loans.stream()
                    .filter(x -> x.getLoanAgeInDays() >= fromDays &&
                            x.getLoanAgeInDays() <= toDays)
                    .collect(Collectors.toList());

        } else if (fromDays != null) {
            loans = loans.stream()
                    .filter(x -> x.getLoanAgeInDays() >= fromDays)
                    .collect(Collectors.toList());

        }

        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);
        Map<Integer, Long> loanCountMap = loans.stream().collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));
        model.addAttribute("customRetailerMap", customRetailerMap);
        model.addAttribute("loans", loans);
        model.addAttribute("fofoReportingModelMap", fofoReportingModelMap);
        model.addAttribute("fofoIdLoansMap", fofoIdLoansMap);
        model.addAttribute("loanCountMap", loanCountMap);
        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";

    }


//    adjusting loan for specific loan if loan is not adjusting and other loan is adjusting

    @RequestMapping(value = "/settle-loan/{fofoId}/{loanId}", method = RequestMethod.GET)
    public String settleAndCreateLoanById(HttpServletRequest request, @PathVariable int loanId, @PathVariable int fofoId, Model model) throws Exception {
        Loan loan = loanRepository.selectByLoanId(loanId);
        double loanAmount = loan.getPendingAmount().doubleValue();

        if (loanAmount > 0) {
            sdCreditService.createLoan(fofoId, loanAmount, 0, "Amount added for loan adjustment");
            sdCreditService.settleLoan(loan);
        }


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

        return "response";

    }

    @RequestMapping(value = "/settle-negative-wallet/{fofoId}", method = RequestMethod.GET)
    public String settleNegativeWalletCreateLoanById(HttpServletRequest request, @PathVariable int fofoId, Model model) throws Exception {
        this.sdCreditService.fundWallet(fofoId);

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

        return "response";

    }

    private void sendUnholdEmail(List<Order> orders) throws Exception {


        orders.forEach(x -> x.setShipmentHold(false));
        orders = orders.stream().filter(x -> x.getRefundTimestamp() != null).collect(Collectors.toList());
        if (orders.size() > 0) {

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

            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 = "Dispatch held orders of - " + (orders.get(0).getRetailerName());
            String message = String.format("Dear Team, \n" + "kindly note the material for the " + orders.get(0).getRetailerName() + "of Rs." + totalAmount + "is unhold now and needs to be dispatched.");
            Utils.sendMailWithAttachments(mailSender, emailTo, ccTo, subject, message);
        }


    }

}