WebSVN – SmartDukaan – Diff – /trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/LoiFormController.java

 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.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;
     LoiDocRepository loiDocRepository;
     @Autowired
     MVCResponseSender mvcResponseSender;
     @Autowired
     private CookiesProcessor cookiesProcessor;
+    @Autowired
+    BrandCommitRepository brandMasterRepository;
+    @Autowired
+    BrandsRepository brandsRepository;
+    @Autowired
+    BrandCategoryRepository brandCategoryRepository;
+    @Autowired
+    BillingAddressRepository billingAddressRepository;
+    @Autowired
+    LoiBrandCommitmentRepository brandCommitmentRepository;
     // 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.getReferalAuthList();
         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<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);
-        model.addAttribute("selfAuth", selfAuth);
         return "partner-onboarding-form";
+    }
     // use to validate GSTIN
     @RequestMapping(value = "/gstValidate", method = RequestMethod.GET)
     @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());
-        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));
+        }
         boolean isAuthUser = false;
         List<String> authEmail = Arrays.asList("sm@smartdukaan.com", "gaurav.sharma@smartdukaan.com", "tejus.lohani@smartdukaan.com");
         isAuthUser = authEmail.stream().anyMatch(x -> x.equals(email));
         List<LoiFormModel> pendingFormList = loiFormService.pendingFormList(email);
-        LOGGER.info("pendingFormList {}", pendingFormList);
         model.addAttribute("isDocApprover", isDocApprover);
         model.addAttribute("isAuthUser", isAuthUser);
         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 {
+    public String generateLoi(@RequestParam int loiId, Model model) throws ProfitMandiBusinessException {
-        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
-        int authId = authRepository.selectByEmailOrMobile(loginDetails.getEmailId()).getId();
         LoiForm loiForm = loiFormRepository.selectById(loiId);
         String filledBy = authRepository.selectByEmailOrMobile(loiForm.getFilledBy()).getFullName();
-        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();
+        BillingAddress address = billingAddressRepository.selectByLoiFormId(loiId);
+        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllByLoiFormId(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();
-        double brandFeeAmount = loiForm.getBrandFeeCollection().stream().filter(x -> x.getPaymentStatus().equals(FeePaymentStatus.CONFIRM)).mapToDouble(x -> x.getCollectedAmount()).sum();
+        double brandFeeAmount = brandFeeCollections.stream().filter(x -> x.getPaymentStatus().equals(FeePaymentStatus.CONFIRM)).mapToDouble(x -> x.getCollectedAmount()).sum();
-        BrandFeeCollection brandFeeCollection = loiForm.getBrandFeeCollection().get(0);
+        BrandFeeCollection brandFeeCollection = brandFeeCollections.get(0);
+        model.addAttribute("totalCommitment", totalCommitment);
+        model.addAttribute("loiBrandCommitments", loiBrandCommitments);
         model.addAttribute("brandFeeAmount", brandFeeAmount);
         model.addAttribute("brandFee", brandFee);
         model.addAttribute("givenFee", givenFee);
         model.addAttribute("brandFeeCollection", brandFeeCollection);
         model.addAttribute("address", address);
-        model.addAttribute("pod", loiForm);
+        model.addAttribute("loiForm", loiForm);
         model.addAttribute("filledBy", filledBy);
         return "auto-Loi";
+    }
     @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);
-        LOGGER.info("loiForm - " + loiForm);
         int loiDoc = loiForm.getLoiDoc();
         if (loiDoc == 0) {
             loiForm.setLoiDoc(loiDocId);
             loiFormService.sendSignedLoiPdfToPartner(loiForm);
             model.addAttribute("response1", mvcResponseSender.createResponseString(true));
+        }
+    }
     // send Filled form for update purpose
-    @RequestMapping(value = "/updateOnboardingForm", method = RequestMethod.GET)
+    @RequestMapping(value = "/updateLoiForm", method = RequestMethod.GET)
     public String UpdateLoiForm(HttpServletRequest request,
                                 @RequestParam int loiId,
                                 Model model) throws ProfitMandiBusinessException {
         LoiForm loiForm = loiFormRepository.selectById(loiId);
-        List<AuthUser> salesAuthList = 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));
-            }
-        }
-        model.addAttribute("storeTypeFeePairs", storeTypeFeePairs);
-        model.addAttribute("authUsersList", salesAuthList);
+        model.addAttribute("updateForm", true);
-        model.addAttribute("onBoardingData", loiForm);
+        model.addAttribute("loiForm", loiForm);
-        return "partner-onboarding-form";
+        return "loiForm/update-loiForm";
+    }
     @RequestMapping(value = "/updateLoiFormData", method = RequestMethod.POST)
     public String UpdateLoiFormDetail(HttpServletRequest request,
                                       @RequestParam int loiId,
-                                      @RequestBody LoiFormData partnerOnBoardingFormData,
+                                      @RequestBody LoiFormData loiFormData,
                                       Model model) throws Exception {
-        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
-        String email = loginDetails.getEmailId();
-        loiFormService.updateLoiForm(partnerOnBoardingFormData, loiId);
+        loiFormService.updateLoiForm(loiFormData, 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();
+        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllByLoiFormId(loiId);
         double totatcollectedfee = brandFeeCollections.stream().filter(x -> x.getPaymentStatus().equals(FeePaymentStatus.CONFIRM) || x.getPaymentStatus().equals(FeePaymentStatus.PENDING)).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);
+            brandFeeCollection.setLoiFormId(loiId);
-            brandFeeCollections.add(brandFeeCollection);
+            brandFeeCollectionRepository.persist(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");
         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();
+        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllByLoiFormId(loiId);
         model.addAttribute("brandFeeCollections", brandFeeCollections);
         model.addAttribute("confirm", FeePaymentStatus.CONFIRM);
         model.addAttribute("isNiraj", isNiraj);
         return "payment-collection-details";
+    }
     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);
-        LoiForm loiForm = brandFeeCollection.getLoiData();
+        LoiForm loiForm = loiFormRepository.selectById(brandFeeCollection.getLoiFormId());
-        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllConfirmPaymetByLoiForm(loiForm);
+        List<BrandFeeCollection> brandFeeCollections = brandFeeCollectionRepository.selectAllConfirmPaymetByLoiForm(brandFeeCollection.getLoiFormId());
         brandFeeCollection.setApproverEmail(authEmail);
         brandFeeCollection.setPaymentStatus(feePaymentStatus);
         brandFeeCollection.setDescription(description);
         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;
         if (brandFeeCollection.getPaymentStatus().equals(FeePaymentStatus.REJECT)) {
             loiFormService.sendPaymentStatusMailToLoiFormFilledBy(brandFeeCollection);
             model.addAttribute("response1", mvcResponseSender.createResponseString(false));
         } else {
             loiFormService.sendPaymentStatusMailToLoiFormFilledBy(brandFeeCollection);
+        }
         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();
         LoiForm loiForm = loiFormRepository.selectById(loiId);
         LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
         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));
+        Map<Integer, LoiDoc> masterDocIdLoiDocMap = loiDocRepository.selectLoiFormId(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);
-        LOGGER.info("loiForm - " + loiForm);
-        LOGGER.info("loiDocModels - " + loiDocModels);
         loiFormService.setDocs(loiForm, loiDocModels);
         model.addAttribute("response1", mvcResponseSender.createResponseString("Document uploaded successfully"));
         return "response";
+    }
             model.addAttribute("response1", mvcResponseSender.createResponseString(loiDoc.getDocType() + " is Accepted "));
             return "response";
         } else {
             loiDoc.setOk(false);
             loiDoc.setVerifyBy(auth.getId());
-            loiFormService.sendDocApprovalMail(loiDoc);
+            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 pod = loiFormRepository.selectById(loiId);
+        LoiForm loiForm = loiFormRepository.selectById(loiId);
-        String mobile = String.valueOf(pod.getMobile());
+        String mobile = String.valueOf(loiForm.getMobile());
         OTPResponse otpResponse = otpProcessor.generateOtp(mobile, OtpType.LOI_ACCEPTANCE);
-        String message = "OTP send to your register mobile number -";
+        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));
+            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 {
-        LOGGER.info("loiId -" + loiId);
-        LOGGER.info("provideOtp -" + provideOtp);
-        LoiForm pod = loiFormRepository.selectById(loiId);
+        LoiForm loiForm = loiFormRepository.selectById(loiId);
-        double brandFee = pod.getAgreedBrandFees();
+        double agreedBrandFees = loiForm.getAgreedBrandFees();
-        double totalCollectfee = pod.getBrandFeeCollection().stream().filter(x -> x.getPaymentStatus().equals(FeePaymentStatus.CONFIRM)).mapToDouble(x -> x.getCollectedAmount()).sum();
+        double totalCollectfee = brandFeeCollectionRepository.selectAllByLoiFormId(loiId).stream().filter(x -> x.getPaymentStatus().equals(FeePaymentStatus.CONFIRM)).mapToDouble(x -> x.getCollectedAmount()).sum();
-        String mobile = String.valueOf(pod.getMobile());
+        String mobile = String.valueOf(loiForm.getMobile());
         Otp otp = otpRepository.selectAllByMobileWithTime(mobile).get(0);
-        LOGGER.info("otp-" + otp);
         OTPResponse otpResponse = otpProcessor.validateOtp(otp.getId(), mobile, provideOtp);
         if (!otpResponse.isResult()) {
             throw new ProfitMandiBusinessException("Wrong OTP", provideOtp, "Your given Otp ->" + provideOtp + " is wrong , please check OTP and try again");
+        }
         if (otpResponse.isResult()) {
-            pod.setLoiSignOtp(provideOtp);
+            loiForm.setLoiSignOtp(provideOtp);
-            pod.setLoiSignedOn(LocalDateTime.now());
+            loiForm.setLoiSignedOn(LocalDateTime.now());
-            if (brandFee == totalCollectfee && pod.getLoiSignOtp() != null) {
+            if (agreedBrandFees == totalCollectfee && loiForm.getLoiSignOtp() != null) {
-                pod.setStatus(LoiStatus.PRE_ONBOARDING_DONE);
+                loiForm.setStatus(LoiStatus.PRE_ONBOARDING_DONE);
             } else {
-                pod.setStatus(LoiStatus.LOI_SIGNED);
+                loiForm.setStatus(LoiStatus.LOI_SIGNED);
+            }
             model.addAttribute("response1", mvcResponseSender.createResponseString(true));
+        }
         return "response";
+    }
             loiFormModel.setId(loiForm.getId());
             loiFormModel.setLoiFormFilledBy(authRepository.selectByEmailOrMobile(loiForm.getFilledBy()).getFullName());
             loiFormModel.setCompanyName(loiForm.getCompanyName());
             loiFormModel.setOwnerName(loiForm.getFullName());
             loiFormModel.setMobile(loiForm.getMobile());
-            loiFormModel.setCity(loiForm.getBillingAddress().getLoc());
+            loiFormModel.setCity(billingAddressRepository.selectByLoiFormId(loiForm.getId()).getLoc());
             loiFormModels.add(loiFormModel);
+        }
         List<EscalationType> EscalationTypeList = new ArrayList<>();
         EscalationTypeList.add(EscalationType.L2);
         EscalationTypeList.add(EscalationType.L1);
         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());
+        brandFeeCollection1.setFeeCollectingTimeStamp(brandFeeCollection.getFeeCollectingTimeStamp());
+        brandFeeCollection1.setCollectedAmount(brandFeeCollection.getCollectedAmount());
+        brandFeeCollection1.setPaymentReferenceNo(brandFeeCollection.getPaymentReferenceNo());
+        brandFeeCollection1.setPaymentMode(brandFeeCollection.getPaymentMode());
+        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
+        return "response";
+    }
+}

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/LoiFormController.java – Rev 33630 → 33658