Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.spice.profitmandi.common.enumuration.BusinessType;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

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

import com.spice.profitmandi.dao.repository.onboarding.LoiBrandCommitmentRepository;

import com.spice.profitmandi.dao.repository.onboarding.LoiDocMasterRepository;

import com.spice.profitmandi.dao.repository.onboarding.LoiDocRepository;

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

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.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(PartnerOnBoardingPanelController.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 brandMasterRepository;

    @Autowired

    BrandsRepository brandsRepository;

    @Autowired

    BrandCategoryRepository brandCategoryRepository;

    @Autowired

    BillingAddressRepository billingAddressRepository;

    @Autowired

    LoiBrandCommitmentRepository brandCommitmentRepository;

    @Autowired

    PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

    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<BrandCommit> brandCommits = brandMasterRepository.selectAllBrand();

        List<BusinessType> businessTypes = Arrays.asList(BusinessType.Proprietorship, BusinessType.Partnership, BusinessType.Company);

        model.addAttribute("businessTypes", businessTypes);

        model.addAttribute("brandCommits", brandCommits);

        model.addAttribute("storeTypeFeePairs", storeTypeFeePairs);

        model.addAttribute("authUsersList", authUsersList);

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

        List<GstDetails.Pradr> adadr = gstDetails.getAdadr();

        adadr.add(gstDetails.getPradr());

        Collections.reverse(adadr);

        LOGGER.info("list_of_adadr-" + adadr);

        String status = gstDetails.getSts();

        if (status.equals("Active")) {

            return ResponseEntity.ok(gstDetails);

        } else {

            String errorMsg = "GSTIN - " + gstNo + " Not Active";

            return new ResponseEntity(errorMsg, HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }

    // bind the form data and save in fofo.Onboarding_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 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> authEmail = Arrays.asList("sm@smartdukaan.com", "tarun.verma@smartdukaan.com", "ashutosh.verma@smartdukaan.com");

        boolean isAuthUser = authEmail.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);

        return "pendingForm";

    }

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

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

    }

    // 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.selectAllByLoiFormId(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);

        loiFormService.sendPaymentStatusMailToLoiFormFilledBy(brandFeeCollection);

        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 String validateLoiAcceptanceOtp(@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);

        if (otpResponse.isResult()) {

            loiForm.setLoiSignOtp(provideOtp);

            loiForm.setLoiSignedOn(LocalDateTime.now());

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

        } else {

            throw new ProfitMandiBusinessException("Wrong OTP", "", "Your given Otp ->" + provideOtp + " is wrong , please check OTP and try again");

        }

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

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

        } else {

            loiForm.setLoiSignOtp("");

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

        double totalConfirmPayment = brandFeeCollectionRepository.selectAllConfirmPaymetByLoiId(brandFeeCollection1.getLoiFormId()).stream().mapToDouble(x -> x.getCollectedAmount()).sum() + brandFeeCollection.getCollectedAmount();

        double totalCollection = totalConfirmPayment + brandFeeCollection.getCollectedAmount();

        LoiForm loiForm = loiFormRepository.selectById(brandFeeCollection1.getLoiFormId());

        if (totalCollection <= loiForm.getAgreedBrandFees()) {

            brandFeeCollection1.setFeeCollectingTimeStamp(brandFeeCollection.getFeeCollectingTimeStamp());

            brandFeeCollection1.setCollectedAmount(brandFeeCollection.getCollectedAmount());

            brandFeeCollection1.setPaymentReferenceNo(brandFeeCollection.getPaymentReferenceNo());

            brandFeeCollection1.setPaymentMode(brandFeeCollection.getPaymentMode());

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

        } else {

            double differanceAmount = loiForm.getAgreedBrandFees() - totalConfirmPayment;

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

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

            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 = "/cancelLoi", method = RequestMethod.PUT)

//    public String loiCancellation(@RequestParam int loiId, Model model) throws Exception {

//        LoiForm loiForm = loiFormRepository.selectById(loiId);

//        loiForm.setStatus(LoiStatus.LOI_REJECT);

//        loiForm.setLoiApproved(false);

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

//        return "response";

//    }

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

                loiFormService.checkLoiDetailsCompletion(loiForm);

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

    }

}