Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.hash.Hashing;
import com.spice.profitmandi.common.enumuration.BusinessType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.web.util.ResponseSender;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.brandFee.BrandFee;
import com.spice.profitmandi.dao.entity.brandFee.BrandFeeCollection;
import com.spice.profitmandi.dao.entity.dtr.Otp;
import com.spice.profitmandi.dao.entity.onBoarding.*;
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
import com.spice.profitmandi.dao.enumuration.dtr.OtpType;
import com.spice.profitmandi.dao.enumuration.onBorading.onBoardingFormEnums.FeePaymentStatus;
import com.spice.profitmandi.dao.enumuration.onBorading.onBoardingFormEnums.LoiStatus;
import com.spice.profitmandi.dao.enumuration.onBorading.onBoardingFormEnums.StoreType;
import com.spice.profitmandi.dao.model.LoiFormModel;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.brandFee.BrandFeeCollectionRepository;
import com.spice.profitmandi.dao.repository.brandFee.BrandFeeRepository;
import com.spice.profitmandi.dao.repository.catalog.BrandCategoryRepository;
import com.spice.profitmandi.dao.repository.catalog.BrandsRepository;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.dtr.DistrictMasterRepository;
import com.spice.profitmandi.dao.repository.dtr.DocumentRepository;
import com.spice.profitmandi.dao.repository.dtr.OtpRepository;
import com.spice.profitmandi.dao.repository.dtr.PartnerOnBoardingPanelRepository;
import com.spice.profitmandi.dao.repository.inventory.PartnerOnboardingService;
import com.spice.profitmandi.dao.repository.inventory.StateRepository;
import com.spice.profitmandi.dao.repository.onboarding.*;
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
import com.spice.profitmandi.dao.repository.user.BillingAddressRepository;
import com.spice.profitmandi.dao.repository.user.LoiFormRepository;
import com.spice.profitmandi.dao.service.LoiDocModel;
import com.spice.profitmandi.dao.service.OTPResponse;
import com.spice.profitmandi.dao.service.OtpProcessor;
import com.spice.profitmandi.dao.service.loiForm.LoiFormService;
import com.spice.profitmandi.service.integrations.gstpro.GstProService;
import com.spice.profitmandi.service.integrations.gstpro.entity.GstDetails;
import com.spice.profitmandi.service.user.StoreTimelineTatService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import com.spice.profitmandi.web.util.MVCResponseSender;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
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 java.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@Controller
@Transactional(rollbackFor = Throwable.class)
public class LoiFormController {
    private static final Logger LOGGER = LogManager.getLogger(LoiFormController.class);
    @Autowired
    DocumentRepository documentRepository;
    @Autowired
    AuthRepository authRepository;
    @Autowired
    StateRepository stateRepository;
    @Autowired
    DistrictMasterRepository districtMasterRepository;
    @Autowired
    LoiFormRepository loiFormRepository;
    @Autowired
    GstProService gstProService;
    @Autowired
    ObjectMapper objectMapper;
    @Autowired
    OrderRepository orderRepository;
    @Autowired
    LoiFormService loiFormService;
    @Autowired
    BrandFeeCollectionRepository brandFeeCollectionRepository;
    @Autowired
    BrandFeeRepository brandFeeRepository;
    @Autowired
    OtpProcessor otpProcessor;
    @Autowired
    OtpRepository otpRepository;
    @Autowired
    JavaMailSender mailSender;
    @Autowired
    LoiDocMasterRepository loiDocMasterList;
    @Autowired
    CsService csService;
    @Autowired
    PartnerOnboardingService partnerOnboardingService;
    @Autowired
    StoreTimelineTatService storeTimelineTatService;
    @Autowired
    LoiDocRepository loiDocRepository;
    @Autowired
    MVCResponseSender mvcResponseSender;
    @Autowired
    private CookiesProcessor cookiesProcessor;
    @Autowired
    BrandCommitRepository brandCommitRepository;
    @Autowired
    BrandsRepository brandsRepository;
    @Autowired
    BrandCategoryRepository brandCategoryRepository;
    @Autowired
    BillingAddressRepository billingAddressRepository;
    @Autowired
    LoiBrandCommitmentRepository brandCommitmentRepository;
    @Autowired
    PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;
    @Autowired
    LoiAuditTrailRepository loiAuditTrailRepository;

    @Autowired
    ResponseSender responseSender;

    List<String> agreedBrandFeeChangerEmail = Arrays.asList("sm@smartdukaan.com");

    // Loi Form
    @RequestMapping(value = "/loiForm", method = RequestMethod.GET)
    public String loiForm(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
        List<AuthUser> authUsersList = loiFormService.getReferalAuthList();
        List<BrandFee> brandFee = brandFeeRepository.selectFeeOnDate(LocalDateTime.now());
        Set<Pair<StoreType, BrandFee>> storeTypeFeePairs = new HashSet<>();
        for (BrandFee fee : brandFee) {
            for (StoreType storeType : StoreType.values()) {
                storeTypeFeePairs.add(Pair.of(storeType, fee));
            }
        }
        List<AuthUser> stateHeadList = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_SALES, Arrays.asList(EscalationType.L2, EscalationType.L3));
        List<AuthUser> bdmList = csService.getAuthUserByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L1);
        List<AuthUser> abmHeadList = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_ABM, Arrays.asList(EscalationType.L2, EscalationType.L3));
        List<AuthUser> abmList = csService.getAuthUserByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_ABM, EscalationType.L1);
        bdmList.addAll(abmList);
        stateHeadList.addAll(abmHeadList);
        List<BrandCommit> brandCommits = brandCommitRepository.selectAllActiveBrand();
        model.addAttribute("businessTypes", BusinessType.values());
        model.addAttribute("brandCommits", brandCommits);
        model.addAttribute("storeTypeFeePairs", storeTypeFeePairs);
        model.addAttribute("authUsersList", authUsersList);
        model.addAttribute("stateHeadList", stateHeadList);
        model.addAttribute("bdmList", bdmList);
        return "loi-form";
    }

    // use to validate GSTIN
    @RequestMapping(value = "/gstValidate", method = RequestMethod.GET)
    public ResponseEntity<?> gstValidate(HttpServletRequest request, @RequestParam String gstNo) throws Exception {
        LOGGER.info("gstNo -" + gstNo);
        GstDetails gstDetails = gstProService.getGstDetails(gstNo);
        LOGGER.info("gstDetails -" + gstDetails);
        if (gstDetails != null) {
            List<GstDetails.Pradr> adadr = gstDetails.getAdadr();
            adadr.add(gstDetails.getPradr());
            Collections.reverse(adadr);
            LOGGER.info("list_of_adadr-" + adadr);
        }
        return ResponseEntity.ok(gstDetails);
    }

    // Save Loi data in fofo.loi_form table
    @RequestMapping(value = "/submitLoiForm", method = RequestMethod.POST)
    public String submitLoiForm(HttpServletRequest request, @RequestBody LoiFormData loiFormData, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        LOGGER.info("filledBy - " + loginDetails.getEmailId());
        boolean isDataCreated = loiFormService.createLoiForm(loiFormData, loginDetails.getEmailId());
        if (isDataCreated) {
            model.addAttribute("response1", mvcResponseSender.createResponseString(true));
            return "response";
        } else {
            model.addAttribute("response1", mvcResponseSender.createResponseString(false));
            return "response";
        }
    }

    // show all pending loi form to specific auth user who have filled the form(type based)
    @RequestMapping(value = "/pendingLoiForm", method = RequestMethod.GET)
    public String pendingLoiForm(HttpServletRequest request, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        String email = loginDetails.getEmailId();
        boolean isDocApprover = false;
        String approverEmail = "gaurav.sharma@smartdukaan.com";
        if (email.equals(approverEmail)) {
            isDocApprover = true;
        }
        boolean isAgreedBrandFeeChanger = agreedBrandFeeChangerEmail.stream().anyMatch(x -> x.equals(email));
        List<String> authEmails = Arrays.asList("sm@smartdukaan.com", "tarun.verma@smartdukaan.com", "ashutosh.verma@smartdukaan.com");
        boolean isAuthUser = authEmails.stream().anyMatch(x -> x.equals(email));
        List<LoiFormModel> pendingFormList = loiFormService.pendingFormList(email);
        model.addAttribute("isDocApprover", isDocApprover);
        model.addAttribute("isAuthUser", isAuthUser);
        model.addAttribute("isAgreedBrandFeeChanger", isAgreedBrandFeeChanger);
        model.addAttribute("pendingFormList", pendingFormList);
        model.addAttribute("brandType", StoreType.valueList);
        return "pendingForm";
    }

//    @RequestMapping(value = "/pendingLoiFormList", method = RequestMethod.GET)
//    public String pendingLoiForm1(HttpServletRequest request, @RequestParam int pageSize, @RequestParam int pageNumber, Model model) throws Exception {
//        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
//        String email = loginDetails.getEmailId();
//        Map<String, Object> pendingFormMap = loiFormService.pendingFormList(email);
//        model.addAttribute("pendingFormList", pendingFormMap.get("pendingFormModelList"));
//        model.addAttribute("paginationInfo", this.getPaginationInfo(pageNumber,pageSize,(long)pendingFormMap.get("totalCount")));
//        return "loiData";
//    }
//    public String getPaginationInfo(int currentPage, int pageSize, long totalEntries) {
//        // Calculate the starting index
//        int start = (currentPage - 1) * pageSize + 1; // Start from 1
//        // Calculate the ending index
//        int end = Math.min(start + pageSize - 1, (int) totalEntries); // Ensure it doesn't exceed totalEntries
//
//        return "Showing " + start + " to " + end + " of " + totalEntries + " entries";
//    }

    // generate LOI for specific Form data
    @RequestMapping(value = "/generateLoi", method = RequestMethod.GET)
    public String generateLoi(HttpServletRequest request, @RequestParam int loiId, Model model) throws ProfitMandiBusinessException {
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        String filledBy = authRepository.selectByEmailOrMobile(loiForm.getFilledBy()).getFullName();
        loiForm.setLoiGeneratedOn(LocalDateTime.now());
        BrandFee brandFee = brandFeeRepository.selectById(1L);
        BillingAddress address = billingAddressRepository.selectByLoiFormId(loiId);
        List<LoiBrandCommitment> loiBrandCommitments = brandCommitmentRepository.selectByLoiId(loiId).stream().filter(x -> x.getAmount() > 0).collect(Collectors.toList());
        double totalCommitment = loiBrandCommitments.stream().mapToDouble(x -> x.getAmount()).sum();
        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllConfirmPaymetByLoiId(loiId);
        double brandFeeAmount = brandFeeCollections.stream().mapToDouble(x -> x.getCollectedAmount()).sum();
        BrandFeeCollection brandFeeCollection = brandFeeCollections.get(0);
        model.addAttribute("totalCommitment", totalCommitment);
        model.addAttribute("loiBrandCommitments", loiBrandCommitments);
        model.addAttribute("brandFeeAmount", brandFeeAmount);
        model.addAttribute("brandFee", brandFee);
        model.addAttribute("brandFeeCollection", brandFeeCollection);
        model.addAttribute("address", address);
        model.addAttribute("loiForm", loiForm);
        model.addAttribute("filledBy", filledBy);
        return "auto-Loi";

    }

    private String getHash256(String originalString) {
        String hashString = Hashing.sha256().hashString(originalString, StandardCharsets.UTF_8).toString();
        LOGGER.info("Hash String {}", hashString);
        return hashString;
    }

    // send Filled form for update purpose
    @RequestMapping(value = "/updateLoiForm", method = RequestMethod.GET)
    public String UpdateLoiForm(HttpServletRequest request,
                                @RequestParam int loiId,
                                Model model) throws ProfitMandiBusinessException {
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        model.addAttribute("updateForm", true);
        model.addAttribute("loiForm", loiForm);
        return "loiForm/update-loiForm";
    }

    @RequestMapping(value = "/updateLoiFormData", method = RequestMethod.POST)
    public String UpdateLoiFormDetail(HttpServletRequest request,
                                      @RequestParam int loiId,
                                      @RequestBody LoiFormData loiFormData,
                                      Model model) throws Exception {
        loiFormService.updateLoiForm(loiFormData, loiId);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
        return "response";
    }

    @RequestMapping(value = "/brandfeeCollection", method = RequestMethod.POST)
    public String addBrandFee(HttpServletRequest request, @RequestBody BrandFeeCollection brandFeeCollection, @RequestParam int loiId, Model model) throws Exception {
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        double totatcollectedfee = brandFeeCollectionRepository.selectAllConfirmPaymetByLoiId(loiId).stream().mapToDouble(x -> x.getCollectedAmount()).sum();
        double brandFee = loiForm.getAgreedBrandFees();
        double differanceAmount = brandFee - totatcollectedfee;
        if (totatcollectedfee + brandFeeCollection.getCollectedAmount() <= brandFee) {
            brandFeeCollection.setPaymentStatus(FeePaymentStatus.PENDING);
            brandFeeCollection.setLoiFormId(loiId);
            brandFeeCollectionRepository.persist(brandFeeCollection);
//            loiFormService.sentMailToPaymentApprover(brandFeeCollection, loiForm);
            model.addAttribute("response1", mvcResponseSender.createResponseString(true));
            return "response";
        } else {
            throw new ProfitMandiBusinessException("You need to add only due brand fee that is Only, " + differanceAmount + " INR", null, "Pay differance amount or less then differance amount");
        }
    }


    @RequestMapping(value = "/paymentsDetail", method = RequestMethod.GET)
    public String paymentsDetails(HttpServletRequest request, @RequestParam int loiId, Model model) throws ProfitMandiBusinessException {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        String email = loginDetails.getEmailId();
        boolean isNiraj = false;
        if (email.equals("neeraj.gupta@smartdukaan.com")) {
            isNiraj = true;
        }
        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllByLoiFormId(loiId);
        model.addAttribute("brandFeeCollections", brandFeeCollections);
        model.addAttribute("confirm", FeePaymentStatus.CONFIRM);
        model.addAttribute("isNiraj", isNiraj);
        return "payment-collection-details";
    }

    // bfcId - Brand Fee Collection Id
    @RequestMapping(value = "/feePaymentApproval", method = RequestMethod.PUT)
    public String feePaymentApproval(HttpServletRequest request, @RequestParam int bfcId, @RequestParam FeePaymentStatus feePaymentStatus, @RequestParam String description,
                                     Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        String authEmail = loginDetails.getEmailId();
        BrandFeeCollection brandFeeCollection = brandFeeCollectionRepository.selectById(bfcId);
        brandFeeCollection.setApproverEmail(authEmail);
        brandFeeCollection.setPaymentStatus(feePaymentStatus);
        brandFeeCollection.setDescription(description);
        brandFeeCollection.setApprovalTimeStamp(LocalDateTime.now());
        if (feePaymentStatus.equals(FeePaymentStatus.CONFIRM)) {
            loiFormService.checkLoiDetailsCompletion(loiFormRepository.selectById(brandFeeCollection.getLoiFormId()));
        }
        loiFormService.sendPaymentStatusMailToLoiFormFilledBy(brandFeeCollection);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
        return "response";

    }

    @RequestMapping(value = "/feePaymentDeletion", method = RequestMethod.PUT)
    public String feePaymentDeletion(HttpServletRequest request, @RequestParam int bfcId,
                                     Model model) throws Exception {
        brandFeeCollectionRepository.deleteById(bfcId);
        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
        return "response";

    }


    @RequestMapping(value = "/uploadDocumentForm", method = RequestMethod.GET)
    public String uploadDocumentForm(HttpServletRequest request, @RequestParam int loiId, Model model) throws ProfitMandiBusinessException {
        List<LoiDocMaster> activeDocMasterList = loiDocMasterList.getAllActiveDoc();
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        String authEmail = authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getEmailId();
        String approverEmail = "gaurav.sharma@smartdukaan.com";
        boolean isApprover = false;
        if (authEmail.equals(approverEmail)) {
            isApprover = true;
        }
        Map<Integer, LoiDoc> masterDocIdLoiDocMap = loiDocRepository.selectByLoiFormId(loiId).stream().collect(Collectors.toMap(x -> x.getMasterDocId(), x -> x));
        model.addAttribute("isApprover", isApprover);
        model.addAttribute("loiId", loiId);
        model.addAttribute("activeDocMasterList", activeDocMasterList);
        model.addAttribute("masterDocIdLoiDocMap", masterDocIdLoiDocMap);
        return "loiForm/document-upload";
    }

    @RequestMapping(value = "/uploadOnboardingDocument", method = RequestMethod.POST)
    public String uploadDocument(HttpServletRequest request, @RequestParam int loiId, @RequestBody List<LoiDocModel> loiDocModels, Model model) throws Exception {
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        loiFormService.setDocs(loiForm, loiDocModels);
        model.addAttribute("response1", mvcResponseSender.createResponseString("Document uploaded successfully"));
        return "response";

    }


    @RequestMapping(value = "/documentVerify", method = RequestMethod.PUT)
    public String docApproval(HttpServletRequest request, @RequestParam int loiId, @RequestParam int docMasterId, @RequestParam boolean flag, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        AuthUser auth = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
        LoiDoc loiDoc = loiDocRepository.selectByLoiIdAndMasterDocId(loiId, docMasterId);
        if (flag) {
            loiDoc.setOk(true);
            loiDoc.setVerifyBy(auth.getId());
            model.addAttribute("response1", mvcResponseSender.createResponseString(loiDoc.getDocType() + " is Accepted "));
            return "response";
        } else {
            loiDoc.setOk(false);
            loiDoc.setVerifyBy(auth.getId());
            loiFormService.sendDocRejectionMail(loiDoc);
            model.addAttribute("response1", mvcResponseSender.createResponseString(loiDoc.getDocType() + " is Rejected"));
            return "response";
        }
    }

    @RequestMapping(value = "/loiAcceptanceOtp", method = RequestMethod.POST)
    public String sentLoiAcceptanceOtp(@RequestParam int loiId, Model model) throws Exception {
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        String mobile = String.valueOf(loiForm.getMobile());
        OTPResponse otpResponse = otpProcessor.generateOtp(mobile, OtpType.LOI_ACCEPTANCE);
        String message = "OTP send on your register mobile and EmailId - ";
        LOGGER.info("OTPResponse Message - " + otpResponse.getMessage());
        if (otpResponse.isResult()) {
            model.addAttribute("response1", mvcResponseSender.createResponseString(message + mobile + " and " + loiForm.getEmail()));
            return "response";
        } else {
            model.addAttribute("response1", mvcResponseSender.createResponseString("Something went wrong.."));
            return "response";
        }
    }

    @RequestMapping(value = "/validateLoiOtp", method = RequestMethod.PUT)
    public ResponseEntity<?> validateLoiAcceptanceOtp(HttpServletRequest request, @RequestParam int loiId, @RequestParam String provideOtp, Model model) throws Exception {
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        String mobile = String.valueOf(loiForm.getMobile());
        Otp otp = otpRepository.selectAllByMobileWithTime(mobile).get(0);
        OTPResponse otpResponse = otpProcessor.validateOtp(otp.getId(), mobile, provideOtp);
        Map<String, Object> response = new HashMap<>();
        if (otpResponse.isResult()) {
            loiForm.setLoiSignOtp(provideOtp);
            loiForm.setLoiSignedOn(LocalDateTime.now());

            List<LoiBrandCommitment> loiBrandCommitments = brandCommitmentRepository.selectByLoiId(loiId).stream().filter(x -> x.getAmount() > 0).collect(Collectors.toList());
            double totalCommitment = loiBrandCommitments.stream().mapToDouble(x -> x.getAmount()).sum();
            List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllConfirmPaymetByLoiId(loiId);
            double brandFeeAmount = brandFeeCollections.stream().mapToDouble(x -> x.getCollectedAmount()).sum();
            BrandFeeCollection brandFeeCollection = brandFeeCollections.get(0);
            String prevHash = loiAuditTrailRepository.findDocumentHashByLoiId(loiId);
            String rawData = loiId + "|"
                    + loiForm.getCompanyName() + "|"
                    + loiForm.getBrandType() + "|"
                    + brandFeeAmount + "|"
                    + brandFeeCollection.getPaymentMode() + "|"
                    + totalCommitment;
            String hash = getHash256(rawData);

            LoiAuditTrail audit = new LoiAuditTrail();
            audit.setLoiId(loiId);
            audit.setCompanyName(loiForm.getCompanyName());
            audit.setReferBy(loiForm.getReferBy());
            audit.setReferId(loiForm.getReferId());
            audit.setFilledBy(loiForm.getFilledBy());
            audit.setFranchiseeName(loiForm.getFullName());
            audit.setBrandType(loiForm.getBrandType());
            audit.setBrandFeeAmount(brandFeeAmount);
            audit.setPaymentMode(brandFeeCollection.getPaymentMode());
            audit.setTotalCommitment(totalCommitment);
            audit.setLoiSignedOn(LocalDateTime.now());
            audit.setLoiGeneratedOn(loiForm.getLoiGeneratedOn());
            audit.setLoiOtp(provideOtp);
            if (prevHash != null) {
                audit.setPrevHash(prevHash);
            }
            audit.setIpAddress(request.getRemoteAddr());
            audit.setDocumentHash(hash);

            response.put("success", true);
            response.put("documentHash", audit.getDocumentHash());
            response.put("ipAddress", audit.getIpAddress());
            response.put("generatedAt", audit.getCreatedAt());
            response.put("loiId", loiId);
            loiAuditTrailRepository.persist(audit);

        } else {
            throw new ProfitMandiBusinessException("Wrong OTP", "", "Your given Otp ->" + provideOtp + " is wrong , please check OTP and try again");
        }
        return responseSender.ok(response);
    }

    @RequestMapping(value = "/saveLoiDoc", method = RequestMethod.POST)
    public String saveLoiDoc(@RequestParam int loiId, @RequestParam int loiDocId, Model model) throws Exception {
        LOGGER.info("loi_docId-" + loiDocId);
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        if (loiDocId > 0) {
            loiForm.setLoiDoc(loiDocId);
            loiFormService.sendSignedLoiPdfToPartner(loiForm);
            loiFormService.checkLoiDetailsCompletion(loiForm);
            model.addAttribute("response1", mvcResponseSender.createResponseString(true));
        } else {
            loiForm.setLoiSignOtp(null);
            loiForm.setLoiGeneratedOn(null);
            loiForm.setLoiSignedOn(null);
            model.addAttribute("response1", mvcResponseSender.createResponseString(false));
        }
        return "response";

    }

    @RequestMapping(value = "/downloadLoiFromReport", method = RequestMethod.GET)
    public ResponseEntity<?> downloadAllLoiForm(@RequestParam LocalDate from, @RequestParam LocalDate to) throws Exception {
        ResponseEntity<?> responseEntity = loiFormService.createLoiFormReport(from, to);
        return responseEntity;
    }

    @RequestMapping(value = "/updatePayment", method = RequestMethod.POST)
    public String updateForm(@RequestBody BrandFeeCollection brandFeeCollection, Model model) throws Exception {
        BrandFeeCollection brandFeeCollection1 = brandFeeCollectionRepository.selectById(brandFeeCollection.getId());
        LoiForm loiForm = loiFormRepository.selectById(brandFeeCollection1.getLoiFormId());
        brandFeeCollection1.setFeeCollectingTimeStamp(brandFeeCollection.getFeeCollectingTimeStamp());
        brandFeeCollection1.setCollectedAmount(brandFeeCollection.getCollectedAmount());
        brandFeeCollection1.setPaymentAttachment(brandFeeCollection.getPaymentAttachment());
        brandFeeCollection1.setPaymentReferenceNo(brandFeeCollection.getPaymentReferenceNo());
        brandFeeCollection1.setPaymentMode(brandFeeCollection.getPaymentMode());
        double totalCollectedFee = brandFeeCollectionRepository.selectAllByLoiFormId(loiForm.getId()).stream().mapToDouble(x -> x.getCollectedAmount()).sum();
        if (totalCollectedFee <= loiForm.getAgreedBrandFees()) {
            model.addAttribute("response1", mvcResponseSender.createResponseString(true));
        } else {
            double differanceAmount = totalCollectedFee - loiForm.getAgreedBrandFees();
            throw new ProfitMandiBusinessException("You need to add only due brand fee that is Only, " + differanceAmount + " INR", null, "Pay differance amount or less then differance amount");
        }
        return "response";
    }

    @RequestMapping(value = "/updateAgreedBrandFee", method = RequestMethod.PUT)
    public String updateAgreedBrandFee(HttpServletRequest request, @RequestParam int loiId, @RequestParam double brandFee, @RequestParam StoreType storeType, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        boolean isAgreedBrandFeeChanger = agreedBrandFeeChangerEmail.stream().anyMatch(x -> x.equals(loginDetails.getEmailId()));
        if (isAgreedBrandFeeChanger) {
            LoiForm loiForm = loiFormRepository.selectById(loiId);
            loiForm.setAgreedBrandFees(brandFee);
            loiForm.setBrandType(storeType);
            loiFormService.checkLoiDetailsCompletion(loiFormRepository.selectById(loiId));
            model.addAttribute("response1", mvcResponseSender.createResponseString(true));
            return "response";
        } else {
            throw new ProfitMandiBusinessException("failed in Authority check ", null, "Sorry " + authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getName() + " you have no authority to change agreed brand fee");
        }
    }

    @RequestMapping(value = "/approve-reject-Loi", method = RequestMethod.PUT)
    public String approveDetails(HttpServletRequest request, @RequestParam int loiId, @RequestParam boolean flag, Model model) throws Exception {
        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
        String email = loginDetails.getEmailId();
        LoiForm loiForm = loiFormRepository.selectById(loiId);
        AuthUser filledBy = authRepository.selectByEmailOrMobile(loiForm.getFilledBy());
        AuthUser manager = authRepository.selectById(filledBy.getManagerId());
        AuthUser upperManager = null;
        List<String> approverMail = new ArrayList<>();
        approverMail.add(manager.getEmailId());
        upperManager = authRepository.selectById(manager.getManagerId());
        approverMail.add(upperManager.getEmailId());

        LOGGER.info("approverMail-" + approverMail);
        // Approver - Manager or Upper manager of loi filledBy(BM)
        boolean isApprover = approverMail.contains(email);
        LOGGER.info("isApprover-" + isApprover);
        List<String> authEmail = Arrays.asList("sm@smartdukaan.com", "tarun.verma@smartdukaan.com", "ashutosh.verma@smartdukaan.com");
        boolean isAuthUser = authEmail.stream().anyMatch(x -> x.equals(email));
        if (flag) {
            if (isApprover || isAuthUser) {
                loiForm.setLoiApprover(email);
                loiForm.setLoiApproved(flag);
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
            } else {
                throw new ProfitMandiBusinessException("Failed in Authority check ", "Read", "Sorry " + authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getName() + " you have no authority to Approve this Loi Form ,Only reporting manager and upper can Approve");
            }
        } else {
            if (isApprover || isAuthUser) {
                loiForm.setLoiApprover(email);
                loiForm.setLoiApproved(flag);
                loiForm.setStatus(LoiStatus.LOI_REJECT);
                model.addAttribute("response1", mvcResponseSender.createResponseString(true));
            } else {
                throw new ProfitMandiBusinessException("Failed in Authority check ", "Read", "Sorry " + authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getName() + " you have no authority to Approve this Loi Form ,Only reporting manager and upper can Approve");
            }
        }
        return "response";
    }


}