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.common.model.ProfitMandiConstants;

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.fofo.PartnerOnBoardingPanel;

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.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.inventory.PartnerOnboardingService;

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

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

    // OnBoarding Form

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser selfAuth = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        List<AuthUser> authUsersList = loiFormService.getSalesAuthList();

        List<BrandFee> brandFee = brandFeeRepository.selectFeeOnDate(LocalDateTime.now());

        LOGGER.info("brandFee - " + brandFee);

        Set<Pair<StoreType, BrandFee>> storeTypeFeePairs = new HashSet<>();

        for (BrandFee fee : brandFee) {

            for (StoreType storeType : StoreType.values()) {

                storeTypeFeePairs.add(Pair.of(storeType, fee));

            }

        }

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

        model.addAttribute("businessTypes", businessTypes);

        model.addAttribute("storeTypeFeePairs", storeTypeFeePairs);

        model.addAttribute("authUsersList", authUsersList);

        model.addAttribute("selfAuth", selfAuth);

        return "partner-onboarding-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 = "/submitOnboardingForm", method = RequestMethod.POST)

    public String submitLoiForm(HttpServletRequest request, @RequestBody LoiFormData formData, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        boolean isDataCreated = loiFormService.createLoiForm(formData);

        List<LoiFormModel> formList = loiFormService.pendingFormList(loginDetails.getEmailId());

        model.addAttribute("formList", formList);

        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("/pendingOnboardingForm")

    public String pendingLoiForm(HttpServletRequest request, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String email = loginDetails.getEmailId();

        boolean isDocApprover = false;

        //todo:replace

        String approverEmail = "gaurav.sharma@smartdukaan.com";

        if (email.equals(approverEmail)) {

            isDocApprover = true;

        }

        List<LoiFormModel> pendingFormList = loiFormService.pendingFormList(email);

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

        model.addAttribute("isDocApprover", isDocApprover);

        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 {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int authId = authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getId();

        LoiForm loiForm = loiFormRepository.selectById(loiId);

        loiForm.setLoiGeneratedBy(authId);

        loiForm.setLoiGeneratedOn(LocalDateTime.now());

        loiForm.setStatus(LoiStatus.LOI_GENERATED);

        BrandFee brandFee = brandFeeRepository.selectById(1);

        BrandFee givenFee = brandFeeRepository.selectById(loiForm.getBrandFeeId());

        BillingAddress address = loiForm.getBillingAddress();

        double brandFeeAmount = loiForm.getBrandFeeCollection().stream().filter(x -> x.getPaymentStatus().equals(FeePaymentStatus.CONFIRM)).mapToDouble(x -> x.getCollectedAmount()).sum();

        BrandFeeCollection brandFeeCollection = loiForm.getBrandFeeCollection().get(0);

        model.addAttribute("brandFeeAmount", brandFeeAmount);

        model.addAttribute("brandFee", brandFee);

        model.addAttribute("givenFee", givenFee);

        model.addAttribute("brandFeeCollection", brandFeeCollection);

        model.addAttribute("address", address);

        model.addAttribute("pod", loiForm);

        return "auto-Loi";

    }

    @RequestMapping("saveLoiDoc")

    public String saveLoiDoc(@RequestParam int loiId, @RequestParam int loiDocId, Model model) throws Exception {

        LOGGER.info("loi_docId-" + loiDocId);

        LoiForm loiForm = loiFormRepository.selectById(loiId);

        LOGGER.info("loiForm - " + loiForm);

        int loiDoc = loiForm.getLoiDoc();

        if (loiDoc == 0) {

            loiForm.setLoiDoc(loiDocId);

            loiFormService.sendSignedLoiPdfToPartner(loiForm);

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

            return "response";

        } else {

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

            return "response";

        }

    }

    // send Filled form for update purpose

    @RequestMapping("/updateOnboardingForm")

    public String UpdateLoiForm(HttpServletRequest request,

                                @RequestParam int loiId,

                                Model model) throws ProfitMandiBusinessException {

        LoiForm loiForm = loiFormRepository.selectById(loiId);

        List<AuthUser> salesAuthList = loiFormService.getSalesAuthList();

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

            }

        }

        model.addAttribute("storeTypeFeePairs", storeTypeFeePairs);

        model.addAttribute("authUsersList", salesAuthList);

        model.addAttribute("onBoardingData", loiForm);

        return "partner-onboarding-form";

    }

    @RequestMapping(value = "/updateOnboardingFormData", method = RequestMethod.POST)

    public String UpdateLoiFormDetail(HttpServletRequest request,

                                      @RequestParam int loiId,

                                      @RequestBody LoiFormData partnerOnBoardingFormData,

                                      Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String email = loginDetails.getEmailId();

        loiFormService.updateLoiForm(partnerOnBoardingFormData, loiId);

        List<LoiFormModel> pendingFormList = loiFormService.pendingFormList(email);

        model.addAttribute("formList", pendingFormList);

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

        return "response";

    }

    // TODO , add paymnet if brand fee due

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

        List<BrandFeeCollection> brandFeeCollections = loiForm.getBrandFeeCollection();

        double totatcollectedfee = brandFeeCollections.stream().mapToDouble(x -> x.getCollectedAmount()).sum();

        double brandFee = loiForm.getAgreedBrandFees();

        double differanceAmount = brandFee - totatcollectedfee;

        if (totatcollectedfee + brandFeeCollection.getCollectedAmount() <= brandFee) {

            brandFeeCollection.setTimeStamp(LocalDateTime.now());

            brandFeeCollection.setPaymentStatus(FeePaymentStatus.PENDING);

            brandFeeCollection.setLoiData(loiForm);

            brandFeeCollections.add(brandFeeCollection);

            loiForm.setBrandFeeCollection(brandFeeCollections);

            loiFormService.sentMailToPaymentApprover(brandFeeCollection);

            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("/paymentsDetail")

    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;

        }

        LoiForm loiForm = loiFormRepository.selectById(loiId);

        List<BrandFeeCollection> brandFeeCollections = loiForm.getBrandFeeCollection();

        model.addAttribute("brandFeeCollections", brandFeeCollections);

        model.addAttribute("confirm", FeePaymentStatus.CONFIRM);

        model.addAttribute("isNiraj", isNiraj);

        return "payment-collection-details";

    }

    // bfcId - Brand Fee Collection Id

    @RequestMapping("/feePaymentApproval")

    public String feePaymentApproval(HttpServletRequest request, @RequestParam int bfcId, @RequestParam FeePaymentStatus feePaymentStatus, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String authEmail = loginDetails.getEmailId();

        BrandFeeCollection brandFeeCollection = brandFeeCollectionRepository.selectById(bfcId);

        LoiForm loiForm = brandFeeCollection.getLoiData();

        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllConfirmPaymetByLoiAuth(loiForm);

        brandFeeCollection.setApproverEmail(authEmail);

        brandFeeCollection.setPaymentStatus(feePaymentStatus);

        double agreedBrandFee = loiForm.getAgreedBrandFees();

        double totalBrandFeeCollection = brandFeeCollections.stream().mapToDouble(x -> x.getCollectedAmount()).sum() + brandFeeCollection.getCollectedAmount();

        LOGGER.info("agreedBrandeFee -" + agreedBrandFee);

        LOGGER.info("totalBrandFeeCollection -" + totalBrandFeeCollection);

        boolean b = agreedBrandFee == totalBrandFeeCollection && loiForm.getLoiSignOtp() != null;

        LOGGER.info("b -" + b);

        if (agreedBrandFee == totalBrandFeeCollection && loiForm.getLoiSignOtp() != null) {

            loiForm.setStatus(LoiStatus.PRE_ONBOARDING_DONE);

            // loiFormService.sendFinalMail(loiForm);

        }

        String msg = "Payment is confirmed";

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

        return "response";

    }

    @RequestMapping("/uploadDocumentForm")

    public String uploadDocumentForm(HttpServletRequest request, @RequestParam int loiId, Model model) throws ProfitMandiBusinessException {

        List<LoiDocMaster> activeDocMasterList = loiDocMasterList.getAllActiveDoc();

        LoiForm loiForm = loiFormRepository.selectById(loiId);

        //TODO:replace

        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 = loiForm.getLoiDocs().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);

        LOGGER.info("loiForm - " + loiForm);

        LOGGER.info("loiDocModels - " + loiDocModels);

        loiFormService.setDocs(loiForm, loiDocModels);

        model.addAttribute("response1", mvcResponseSender.createResponseString("Document uploaded successfully"));

        return "response";

    }

    @RequestMapping("/documentVerify")

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

            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 pod = loiFormRepository.selectById(loiId);

        String mobile = String.valueOf(pod.getMobile());

        otpProcessor.generateOtp(mobile, OtpType.LOI_ACCEPTANCE);

        String message = "OTP send to your register mobile number -";

        model.addAttribute("response1", mvcResponseSender.createResponseString(message + mobile));

        return "response";

    }

    @RequestMapping(value = "/validateLoiOtp", method = RequestMethod.PUT)

    public String validateLoiAcceptanceOtp(@RequestParam int loiId, @RequestParam String provideOtp, Model model) throws Exception {

        LOGGER.info("loiId -" + loiId);

        LOGGER.info("provideOtp -" + provideOtp);

        LoiForm pod = loiFormRepository.selectById(loiId);

        double brandFee = pod.getAgreedBrandFees();

        double totalCollectfee = pod.getBrandFeeCollection().stream().filter(x -> x.getPaymentStatus().equals(FeePaymentStatus.CONFIRM)).mapToDouble(x -> x.getCollectedAmount()).sum();

        String mobile = String.valueOf(pod.getMobile());

        Otp otp = otpRepository.selectAllByMobileWithTime(mobile).get(0);

        LOGGER.info("otp-" + otp);

        OTPResponse otpResponse = otpProcessor.validateOtp(otp.getId(), mobile, provideOtp);

        if (!otpResponse.isResult()) {

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

            throw new ProfitMandiBusinessException("Your given OTP ", provideOtp, " is wrong.");

        }

        if (otpResponse.isResult()) {

            pod.setLoiSignOtp(provideOtp);

            pod.setLoiSignedOn(LocalDateTime.now());

            if (brandFee == totalCollectfee && pod.getLoiSignOtp() != null) {

                pod.setStatus(LoiStatus.PRE_ONBOARDING_DONE);

            } else {

                pod.setStatus(LoiStatus.LOI_SIGNED);

            }

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

        }

        return "response";

    }

    @RequestMapping(value = "/completedLoiForms")

    public String completeLoiFormList(Model model) {

        List<LoiForm> loiForms = loiFormRepository.selectAllCompleteForm();

        List<EscalationType> EscalationTypeList = new ArrayList<>();

        EscalationTypeList.add(EscalationType.L2);

        EscalationTypeList.add(EscalationType.L1);

        EscalationTypeList.add(EscalationType.L4);

        List<AuthUser> authUsers = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_RBM,

                EscalationTypeList);

        model.addAttribute("loiForms", loiForms);

        model.addAttribute("authUsers", authUsers);

        return "loiForm/completed-loi-form";

    }

    @RequestMapping(value = "/createNewOnboardingPanel")

    public String CreateNewOnboardingPanel(@RequestParam int loiId, @RequestParam int authId, Model model) throws Exception {

        PartnerOnBoardingPanel partnerOnboardingPanel = loiFormService.createPartnerOnboardingPanel(loiId, authId);

        loiFormRepository.selectById(loiId).setStatus(LoiStatus.IN_ONBOARDING_PROCESS);

        if (partnerOnboardingPanel.getId() != 0)

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

        else

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

        return "response";

    }

}