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

 import com.spice.profitmandi.dao.repository.transaction.TransactionRepository;
 import com.spice.profitmandi.service.authentication.RoleManager;
 import com.spice.profitmandi.service.inventory.InventoryService;
 import com.spice.profitmandi.service.offers.OfferService;
 import com.spice.profitmandi.service.offers.PartnerCriteria;
+import com.spice.profitmandi.service.pricecircular.PriceCircularService;
 import com.spice.profitmandi.service.scheme.SchemeService;
 import com.spice.profitmandi.service.user.RetailerService;
 import com.spice.profitmandi.service.wallet.WalletService;
 import com.spice.profitmandi.web.model.LoginDetails;
 import com.spice.profitmandi.web.util.CookiesProcessor;
     private SamsungUpgradeOfferRepository samsungUpgradeOfferRepository;
     @Autowired
     private CsService csService;
     @Autowired
     private CategoryRepository categoryRepository;
+    @Autowired
+    PriceCircularService priceCircularService;
     @Autowired
     private Gson gson;
     private boolean getAccess(String emailId) {
             model.addAttribute("customRetailer", customRetailer);
+        }
         return "scheme-imei-history";
+    }
+    @Autowired
+    PriceDropController priceDropController;
     @RequestMapping(value = "/getSchemes", method = RequestMethod.GET)
     public String getSchemes(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,
                              @RequestParam(required = false) LocalDate date,
                              @RequestParam(name = "limit", required = false, defaultValue = "30") int limit,
                              @RequestParam(name = "searchModel", required = false, defaultValue = "0") int searchModel,
                 model.addAttribute("offerRequestMap", offerRequestMap);
                 model.addAttribute("inventoryItem", inventoryItem);
                 model.addAttribute("inventoryItem", inventoryItem);
+            }
-            model.addAttribute("netEarnings", netEarnings);
             model.addAttribute("fofoId", loginDetails.getFofoId());
             model.addAttribute("schemeMap", schemeMap);
             model.addAttribute("item", item);
             model.addAttribute("schemeInOut", schemeInOuts);
             return "schemes-partner";
         Map<String, Map<String, Double>> lastMonthPurchaseInMapPairMap = lastMonthPurchaseInImeis.stream()
                 .collect(Collectors.groupingBy(x -> x.getImei(),
                         Collectors.groupingBy(x -> x.getDescription(), Collectors.summingDouble(x -> x.getAmount()))));
         Map<String, LocalDate> imeiPurchaseDateMap = lastMonthPurchaseInImeis.stream().collect(Collectors.toMap(x -> x.getImei(), x -> x.getCreateTimeStamp().toLocalDate(), (x, y) -> x));
-        Map<String, LocalDate> imeiSaleDateMap = lastMonthCreditedImeis.stream().collect(Collectors.toMap(x -> x.getImei(), x -> x.getCreateTimeStamp().toLocalDate(), (x, y) -> x));
+        Map<String, LocalDate> imeiSaleDateMap = lastMonthFrontEndImeis.stream().collect(Collectors.toMap(x -> x.getImei(), x -> x.getCreated()));
         Map<String, Map<String, Double>> lastMonthCreditedMapPairMap = lastMonthCreditedImeis.stream()
                 .collect(Collectors.groupingBy(x -> x.getImei(),
                         Collectors.groupingBy(x -> x.getDescription(), Collectors.summingDouble(x -> x.getAmount()))));
         // descriptionSet.add("")
+        }
         for (Map.Entry<String, Map<String, Double>> entry : lastMonthCreditedMapPairMap.entrySet()) {
             Map<String, Double> descriptionAmountMap = entry.getValue();
             if (!imeiWiseIncomeMapOfMap.containsKey(entry.getKey())) {
-                ImeiWiseIncomePairAndMapModel modelImeiMap = new ImeiWiseIncomePairAndMapModel(entry.getKey(), null,
+                imeiWiseIncomeMapOfMap.put(entry.getKey(), new ImeiWiseIncomePairAndMapModel(entry.getKey(), null, null));
-                        imeiSaleDateMap.get(entry.getKey()));
-                imeiWiseIncomeMapOfMap.put(entry.getKey(), modelImeiMap);
-            } else {
-                ImeiWiseIncomePairAndMapModel modelImeiMap = imeiWiseIncomeMapOfMap.get(entry.getKey());
-                modelImeiMap.setSaleDate(imeiSaleDateMap.get(entry.getKey()));
+            }
+            ImeiWiseIncomePairAndMapModel modelImeiMap = imeiWiseIncomeMapOfMap.get(entry.getKey());
+            ;
+            modelImeiMap.setSaleDate(imeiSaleDateMap.get(entry.getKey()));
             double totalAmount = descriptionAmountMap.entrySet().stream()
                     .collect(Collectors.summingDouble(x -> x.getValue()));
             imeiWiseIncomeMapOfMap.get(entry.getKey())
                     .setTotalIncome(totalAmount + imeiWiseIncomeMapOfMap.get(entry.getKey()).getTotalIncome());
+        }
-        /*lastMonthFrontEndImeis.stream().forEach(x -> {
-            if (imeiWiseIncomeMapOfMap.containsKey(x.getImei())) {
-                ImeiWiseIncomePairAndMapModel imeiWiseIncomePairAndMapModel = imeiWiseIncomeMapOfMap
-                        .get(x.getImei());
-                imeiWiseIncomePairAndMapModel.setTotalIncome(imeiWiseIncomePairAndMapModel.getTotalIncome() + x.getAmount());
-                imeiWiseIncomePairAndMapModel.setFrontMargin(x.getAmount());
-            }
-        });*/
         //Imeis for pending activation
         lastMonthCreditedImeis.stream().filter(x -> x.getStatus().equals(SchemePayoutStatus.PENDING)).forEach(x -> {
             if (!imeiWiseIncomeMapOfMap.containsKey(x.getImei())) {
-                ImeiWiseIncomePairAndMapModel imeiWiseIncomePairAndMapModel = new ImeiWiseIncomePairAndMapModel(x.getImei(), null, null);
+                imeiWiseIncomeMapOfMap.put(x.getImei(), new ImeiWiseIncomePairAndMapModel(x.getImei()));
+            }
             ImeiWiseIncomePairAndMapModel imeiWiseIncomePairAndMapModel = imeiWiseIncomeMapOfMap
                     .get(x.getImei());
             imeiWiseIncomePairAndMapModel.setSaleDate(x.getCreateTimeStamp().toLocalDate());
             imeiWiseIncomePairAndMapModel.setTotalIncome(x.getPendingSaleAmount() + imeiWiseIncomePairAndMapModel.getTotalIncome());
         });
         lastMonthFrontEndImeis.stream().forEach(lastMonthFrontEndImeiModel -> {
-            if (imeiWiseIncomeMapOfMap.containsKey(lastMonthFrontEndImeiModel.getImei())) {
+            if (!imeiWiseIncomeMapOfMap.containsKey(lastMonthFrontEndImeiModel.getImei())) {
-                lastMonthFrontEndImeiModel.setNlc(lastMonthFrontEndImeiModel.getDp()
-                        - (float) imeiWiseIncomeMapOfMap.get(lastMonthFrontEndImeiModel.getImei()).getTotalIncome());
-                lastMonthFrontEndImeiModel.setNetIncome(lastMonthFrontEndImeiModel.getSellingPrice() - lastMonthFrontEndImeiModel.getNlc());
+                imeiWiseIncomeMapOfMap.put(lastMonthFrontEndImeiModel.getImei(), new ImeiWiseIncomePairAndMapModel(lastMonthFrontEndImeiModel.getImei()));
+            }
+            ImeiWiseIncomePairAndMapModel imeiWiseIncomePairAndMapModel = imeiWiseIncomeMapOfMap
+                    .get(lastMonthFrontEndImeiModel.getImei());
+            lastMonthFrontEndImeiModel.setNlc(lastMonthFrontEndImeiModel.getDp()
+                    - (float) imeiWiseIncomeMapOfMap.get(lastMonthFrontEndImeiModel.getImei()).getTotalIncome());
+            lastMonthFrontEndImeiModel.setNetIncome(lastMonthFrontEndImeiModel.getSellingPrice() - lastMonthFrontEndImeiModel.getNlc());
+            imeiWiseIncomePairAndMapModel.setSaleDate(lastMonthFrontEndImeiModel.getCreated());
         });
         model.addAttribute("imeiWisePendingSaleAmount", imeiWisePendingSaleAmount);
         model.addAttribute("month", month);
         model.addAttribute("purchaseList", purchaseList);
+    }
     @RequestMapping(value = "/brandWiseIncome", method = RequestMethod.GET)
     public String getBrandWiseIncome(HttpServletRequest request,
                                      @RequestParam(name = "brand", required = false, defaultValue = "") String brand,
-                                     @RequestParam(name = "status", required = false, defaultValue = "") String status,
+                                     @RequestParam(name = "month", required = false, defaultValue = "") int month,
-                                     @RequestParam(name = "month", required = false, defaultValue = "") int month, Model model)
+                                     Model model)
             throws ProfitMandiBusinessException {
         LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
         LOGGER.info("loginDetails {}", loginDetails);
         LOGGER.info("brand" + brand);
         LOGGER.info("month {}", month);
         LocalDateTime monthStart = LocalDate.now().minusMonths(month).withDayOfMonth(1).atStartOfDay();
         LocalDateTime monthEnd = monthStart.plusMonths(1);
         List<OfferPayoutImeiIncomeModel> offerPayoutImeiIncomeModels = offerPayoutRepository.getTotalPayoutsByPartnerPeriod(
                 YearMonth.of(monthStart.getYear(), monthStart.getMonth()), loginDetails.getFofoId(), brand, null);
+        LOGGER.info("offerPayoutImeiIncomeModels - {}", offerPayoutImeiIncomeModels);
-        Map<Integer, Double> additionalPurchasePayout = offerPayoutImeiIncomeModels.stream().collect(Collectors.groupingBy(x -> x.getCatalogId(), Collectors.summingDouble(x -> x.getPurchasePayout())));
+        Map<Integer, Double> additionalPurchasePayout = offerPayoutImeiIncomeModels.stream().filter(x -> x.getPurchasePayout() > 0).collect(Collectors.groupingBy(x -> x.getCatalogId(), Collectors.summingDouble(x -> x.getPurchasePayout())));
+        Map<Integer, Integer> additionalPurchaseQty = offerPayoutImeiIncomeModels.stream().filter(x -> x.getPurchasePayout() > 0).collect(Collectors.groupingBy(x -> x.getCatalogId(), Collectors.summingInt(x -> 1)));
-        Map<Integer, Double> additionalSalePayout = offerPayoutImeiIncomeModels.stream().collect(Collectors.groupingBy(x -> x.getCatalogId(), Collectors.summingDouble(x -> x.getSalePayout())));
+        Map<Integer, Double> additionalSalePayoutMap = offerPayoutImeiIncomeModels.stream().filter(x -> x.getSalePayout() > 0).collect(Collectors.groupingBy(x -> x.getCatalogId(), Collectors.summingDouble(x -> x.getSalePayout())));
+        Map<Integer, Integer> additionalSaleQty = offerPayoutImeiIncomeModels.stream().filter(x -> x.getSalePayout() > 0).collect(Collectors.groupingBy(x -> x.getCatalogId(), Collectors.summingInt(x -> 1)));
+        Set<Integer> allCatalogIds = offerPayoutImeiIncomeModels.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());
         boolean partnerTypeUpgraded = partnerTypeChangeService.isPartnerTypeUpgraded(loginDetails.getFofoId(),
                 YearMonth.now());
         LOGGER.info("partnerType" + partnerTypeUpgraded);
                     .stream().collect(Collectors.toMap(x -> x.getBrand(), x -> x.getAmount()));
+        }
         List<LastMonthFrontEndBrandWiseIncome> modelWiseSalesMargins = schemeInOutRepository
                 .selectFrontIncomeBrandWise(loginDetails.getFofoId(), brand, monthStart, monthEnd);
+        Map<Integer, LastMonthFrontEndBrandWiseIncome> modelWiseSalesMarginsMap = modelWiseSalesMargins.stream().collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x));
         List<LastMonthBrandWiseIncomeModel> modelWiseSchemeOutMargins = schemeInOutRepository
                 .selectLastMonthBrandWiseIncome(loginDetails.getFofoId(), brand, monthStart, monthEnd);
         Map<Integer, LastMonthBrandWiseIncomeModel> modelWiseSchemeOutMarginsMap = modelWiseSchemeOutMargins.stream()
                 .collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x));
         List<LastMonthBrandWiseIncomeModel> modelWiseSchemeInMargins = schemeInOutRepository
                 .selectLastMonthPurchaseBrandWiseIncome(loginDetails.getFofoId(), brand, monthStart, monthEnd);
         Map<Integer, LastMonthBrandWiseIncomeModel> modelWiseSchemeInMarginsMap = modelWiseSchemeInMargins.stream()
                 .collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x));
+        allCatalogIds.addAll(modelWiseSalesMargins.stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet()));
+        allCatalogIds.addAll(modelWiseSchemeInMargins.stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet()));
+        allCatalogIds.addAll(modelWiseSchemeOutMargins.stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet()));
+        Map<Integer, String> modelNameMap = itemRepository.selectAllByCatalogIds(allCatalogIds).stream().collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x.getModel(), (u, v) -> u));
-        Map<Integer, Double> modelTotalIncomeMap = new HashMap<>();
+        Map<Integer, Double> modelIncomeMap = new HashMap<>();
+        Map<Integer, Integer> modelPurchaseQtyMap = new HashMap<>();
-        Map<Integer, String> modelNameMap = new HashMap<>();
+        Map<Integer, Integer> modelSaleQtyMap = new HashMap<>();
+        for (int catalogItemId : modelNameMap.keySet()) {
+            int saleQty = 0;
+            int purchaseQty = 0;
+            double income = 0;
-        offerPayoutImeiIncomeModels.stream().forEach(x -> {
+            if (modelWiseSchemeInMarginsMap.containsKey(catalogItemId)) {
+                income += modelWiseSchemeInMarginsMap.get(catalogItemId).getAmount() + modelWiseSchemeInMarginsMap.get(catalogItemId).getPendingSaleAmount();
+                purchaseQty += modelWiseSchemeInMarginsMap.get(catalogItemId).getQty();
+            }
-            if (!modelTotalIncomeMap.containsKey(x.getCatalogId())) {
+            if (modelWiseSchemeOutMarginsMap.containsKey(catalogItemId)) {
-                modelNameMap.put(x.getCatalogId(), (x.getModelNumber() + " " + x.getModelName()).trim());
+                income += modelWiseSchemeOutMarginsMap.get(catalogItemId).getAmount() + modelWiseSchemeOutMarginsMap.get(catalogItemId).getPendingSaleAmount();
+            }
+            if (additionalSalePayoutMap.containsKey(catalogItemId)) {
-                modelTotalIncomeMap.put(x.getCatalogId(), 0d);
+                income += additionalSalePayoutMap.get(catalogItemId);
+            }
+            if (additionalPurchasePayout.containsKey(catalogItemId)) {
+                income += additionalPurchasePayout.get(catalogItemId);
+            }
+            if (modelWiseSalesMarginsMap.containsKey(catalogItemId)) {
+                income += modelWiseSalesMarginsMap.get(catalogItemId).getAmount();
+                saleQty = (int) modelWiseSalesMarginsMap.get(catalogItemId).getQty();
             }
+            if (additionalPurchaseQty.containsKey(catalogItemId)) {
-            modelTotalIncomeMap.put(x.getCatalogId(), modelTotalIncomeMap.get(x.getCatalogId()) + x.getPurchasePayout() + x.getSalePayout());
+                purchaseQty = Math.max(additionalPurchaseQty.get(catalogItemId), purchaseQty);
-        });
+            }
+            modelIncomeMap.put(catalogItemId, income);
+            modelSaleQtyMap.put(catalogItemId, saleQty);
+            modelPurchaseQtyMap.put(catalogItemId, purchaseQty);
-        modelWiseSchemeOutMargins.stream().forEach(x -> {
-            if (!modelNameMap.containsKey(x.getCatalogItemId())) {
-                modelTotalIncomeMap.put(x.getCatalogItemId(), 0d);
-                modelNameMap.put(x.getCatalogItemId(), (x.getModelNumber() + " " + x.getModelName()).trim());
-            }
-            modelTotalIncomeMap.put(x.getCatalogItemId(), modelTotalIncomeMap.get(x.getCatalogItemId()) + x.getAmount() + x.getPendingSaleAmount());
-        });
-        LastMonthBrandWiseIncomeModel totalModel = new LastMonthBrandWiseIncomeModel();
-        modelWiseSalesMargins.stream().forEach(x -> {
-            if (!modelWiseSchemeOutMarginsMap.containsKey(x.getCatalogItemId())) {
-                LastMonthBrandWiseIncomeModel lmbwIncomeModel = new LastMonthBrandWiseIncomeModel();
-                lmbwIncomeModel.setModelName(x.getModelName());
-                lmbwIncomeModel.setModelNumber(x.getModelNumber());
-                lmbwIncomeModel.setBrand(x.getBrand());
-                lmbwIncomeModel.setCatalogItemId(x.getCatalogItemId());
-                modelWiseSchemeOutMarginsMap.put(x.getCatalogItemId(), lmbwIncomeModel);
-                totalModel.setQty(totalModel.getQty() + x.getQty());
-            }
-            modelNameMap.put(x.getCatalogItemId(), (x.getModelNumber() + x.getModelName()).trim());
-            LOGGER.info("Modelname {}, Model {}", modelNameMap.get(x.getCatalogItemId()), x.getQty());
-            LastMonthBrandWiseIncomeModel lmbwIncomeModel = modelWiseSchemeOutMarginsMap.get(x.getCatalogItemId());
-            lmbwIncomeModel.setAmount(lmbwIncomeModel.getAmount() + x.getAmount());
-            lmbwIncomeModel.setQty(x.getQty());
-            if (!modelTotalIncomeMap.containsKey(x.getCatalogItemId())) {
-                modelTotalIncomeMap.put(x.getCatalogItemId(), 0d);
-            }
-            modelTotalIncomeMap.put(x.getCatalogItemId(), x.getAmount() + modelTotalIncomeMap.get(x.getCatalogItemId()));
-            totalModel.setAmount(totalModel.getAmount() + x.getAmount());
-            totalModel.setPendingSaleAmount(totalModel.getPendingSaleAmount());
-        });
-        modelWiseSchemeInMargins.stream().forEach(x -> {
-            if (!modelTotalIncomeMap.containsKey(x.getCatalogItemId())) {
-                modelTotalIncomeMap.put(x.getCatalogItemId(), 0d);
-            }
-            modelTotalIncomeMap.put(x.getCatalogItemId(),
-                    modelTotalIncomeMap.get(x.getCatalogItemId()) + x.getAmount());
-            modelNameMap.put(x.getCatalogItemId(), (x.getModelNumber() + x.getModelName()).trim());
-            totalModel.setQty(totalModel.getQty() + x.getQty());
-            totalModel.setAmount(totalModel.getAmount() + x.getAmount());
-        });
+        }
         model.addAttribute("month", month);
+        model.addAttribute("modelWiseSalesMarginsMap", modelWiseSalesMarginsMap);
         model.addAttribute("modelWiseSchemeOutMarginsMap", modelWiseSchemeOutMarginsMap);
         model.addAttribute("modelWiseSchemeInMarginsMap", modelWiseSchemeInMarginsMap);
         model.addAttribute("modelNameMap", modelNameMap);
+        model.addAttribute("modelPurchaseQtyMap", modelPurchaseQtyMap);
+        model.addAttribute("modelSaleQtyMap", modelSaleQtyMap);
-        model.addAttribute("modelTotalIncomeMap", modelTotalIncomeMap);
+        model.addAttribute("modelIncomeMap", modelIncomeMap);
         model.addAttribute("categoryUpgradeBrandModelMap", categoryUpgradeBrandModelMap);
         model.addAttribute("additionalPurchasePayoutMap", additionalPurchasePayout);
-        model.addAttribute("additionalSalePayoutMap", additionalSalePayout);
+        model.addAttribute("additionalSalePayoutMap", additionalSalePayoutMap);
-        model.addAttribute("totalModel", totalModel);
         return "monthly-brand-wise-income";
+    }
                     .selectLastMonthCategoryUpgradeMarginByBrand(loginDetails.getFofoId(), startOfMonth,
                             lastMonthEnd)
                     .stream().collect(Collectors.toMap(x -> x.getBrand(), x -> x.getAmount()));
+        }
-        String status = "CREDITED";
         List<LastMonthCreditedIncomeModel> lastMonthPendingIncomeModels = schemeInOutRepository
                 .selectLastMonthPendingIncomeByFofoId(loginDetails.getFofoId(), startOfMonth, lastMonthEnd);
         List<LastMonthCreditedIncomeModel> lastMonthCreditedIncomeModels = schemeInOutRepository
                 .selectLastMonthCreditedIncomeByFofoId(loginDetails.getFofoId(), startOfMonth, lastMonthEnd);
         List<LastMonthCreditedIncomeModel> lastMonthPurchaseInMargins = schemeInOutRepository
                 .selectLastMonthPurchaseInMarginByFofoId(loginDetails.getFofoId(), startOfMonth, lastMonthEnd);
         List<LastMonthCreditedIncomeModel> lastMonthFrontEndIncomes = schemeInOutRepository
                 .selectFrontIncomeByBrand(loginDetails.getFofoId(), startOfMonth, lastMonthEnd);
+        Map<String, LastMonthCreditedIncomeModel> lastMonthFrontEndIncomeMap = lastMonthFrontEndIncomes.stream().collect(Collectors.toMap(x -> x.getBrand(), x -> x));
         List<OfferPayoutImeiIncomeModel> offerPayoutImeiIncomeModels = offerPayoutRepository.getTotalPayoutsByPartnerPeriod(
                 YearMonth.of(startOfMonth.getYear(), startOfMonth.getMonth()), loginDetails.getFofoId(), null, null);
         Map<String, Double> additionalPurchasePayout = offerPayoutImeiIncomeModels.stream().collect(Collectors.groupingBy(OfferPayoutImeiIncomeModel::getBrand, Collectors.summingDouble(OfferPayoutImeiIncomeModel::getPurchasePayout)));
         Map<String, LastMonthCreditedIncomeModel> lastMonthPendingIncomeMap = lastMonthPendingIncomeModels.stream()
                 .collect(Collectors.toMap(x -> x.getBrand(), x -> x));
-        lastMonthFrontEndIncomes.stream().forEach(x -> {
-            if (lastMonthSaleMarginMap.containsKey(x.getBrand())) {
-                x.setAmount(lastMonthSaleMarginMap.get(x.getBrand()).getAmount() + x.getAmount());
-                lastMonthSaleMarginMap.put(x.getBrand(), x);
-            } else {
-                lastMonthSaleMarginMap.put(x.getBrand(), x);
-            }
-        });
         Map<String, Float> totalAmountMap = lastMonthSaleMarginMap.entrySet().stream()
                 .collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue().getAmount()));
         Set<String> brandSet = new HashSet<>();
         brandSet.addAll(lastMonthPurchaseInMarginMap.keySet());
         brandSet.addAll(lastMonthSaleMarginMap.keySet());
             totalAmountMap.put(brand,
                     (lastMonthSaleMarginMap.get(brand) == null ? 0 : lastMonthSaleMarginMap.get(brand).getAmount()) +
                             (lastMonthPurchaseInMarginMap.get(brand) == null ? 0 : lastMonthPurchaseInMarginMap.get(brand).getAmount()) +
                             (lastMonthPendingIncomeMap.get(brand) == null ? 0 : lastMonthPendingIncomeMap.get(brand).getAmount()) +
                             (additionalPurchasePayout.get(brand) == null ? 0 : additionalPurchasePayout.get(brand).longValue()) +
-                            (additionSalePayout.get(brand) == null ? 0 : additionSalePayout.get(brand).longValue())
+                            (additionSalePayout.get(brand) == null ? 0 : additionSalePayout.get(brand).longValue()) +
+                            (lastMonthFrontEndIncomeMap.get(brand) == null ? 0 : lastMonthFrontEndIncomeMap.get(brand).getAmount())
             );
         });
         Map<Integer, String> monthValueMap = new HashMap<>();
         for (int i = 0; i <= 5; i++) {
             LocalDateTime monthStart = LocalDateTime.now().withDayOfMonth(1).minusMonths(i);
             monthValueMap.put(i, monthStart.format(DateTimeFormatter.ofPattern("MMM''uu")));
+        }
         model.addAttribute("monthValueMap", monthValueMap);
-        model.addAttribute("keySet", brandSet);
+        model.addAttribute("brandSet", brandSet);
         model.addAttribute("lastMonthPurchaseInMarginMap", lastMonthPurchaseInMarginMap);
         model.addAttribute("lastMonthSaleMarginMap", lastMonthSaleMarginMap);
         model.addAttribute("lastMonthPendingIncomeMap", lastMonthPendingIncomeMap);
         model.addAttribute("additionalPurchasePayoutMap", additionalPurchasePayout);
         model.addAttribute("additionalSalePayoutMap", additionSalePayout);
+        model.addAttribute("lastMonthFrontEndIncomeMap", lastMonthFrontEndIncomeMap);
         model.addAttribute("totalAmountMap", totalAmountMap);
-        model.addAttribute("status", status);
         model.addAttribute("month", yearMonth);
         model.addAttribute("lastMonthCategoryUpgradeMarginMap", lastMonthCategoryUpgradeMarginMap);
         LOGGER.info("totalAmountMap {}", totalAmountMap);
         LOGGER.info("lastMonthSaleMarginMap {}", lastMonthSaleMarginMap);

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/SchemeController.java – Rev 31762 → 32232