WebSVN – SmartDukaan – Diff – /trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/offers/OfferServiceImpl.java

         Map<String, Double> serialNumberPaid = offerPayouts.stream().filter(x -> x.getRejectTimestamp() == null).collect(Collectors.groupingBy(x -> x.getSerialNumber(), Collectors.summingDouble(x -> x.getSlabAmount())));
         Map<Integer, Map<Integer, List<FofoOrderItem>>> criteriaPartnerwiseTertiary = offerRepository.getCriteriaWisePartnerTertiary(createOfferRequest);
         Map<String, AgeingSummaryModel> ageingSummaryModelsMap = null;
-        final Map<String, LocalDateTime> activatedImeisActiovationDateMap;
+        final Map<String, LocalDateTime> activatedImeisActivationDateMap;
         if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {
             //All Serialnumbers for all eligible retailers
             List<String> serialNumbers = criteriaPartnerwiseTertiary.entrySet().stream().flatMap(x -> x.getValue().entrySet().stream().flatMap(foiList -> foiList.getValue().stream()))
                     .flatMap(y -> y.getFofoLineItems().stream()).filter(fli -> fli.getSerialNumber() != null)
                     .map(x -> x.getSerialNumber()).collect(Collectors.toList());
             if (serialNumbers.size() > 0) {
-                activatedImeisActiovationDateMap = activatedImeiRepository.selectBySerialNumbers(serialNumbers).stream()
+                activatedImeisActivationDateMap = activatedImeiRepository.selectBySerialNumbers(serialNumbers).stream()
                         .filter(x -> createOfferRequest.isWithinRange(x.getActivationTimestamp()))
                         .collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x.getActivationTimestamp()));
                 ageingSummaryModelsMap = warehouseInventoryItemRepository.findStockAgeingByFofoIdSerialNumbers(0, serialNumbers).stream().collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x, (u, v) -> v));
             } else {
-                activatedImeisActiovationDateMap = null;
+                activatedImeisActivationDateMap = null;
+            }
         } else {
-            activatedImeisActiovationDateMap = null;
+            activatedImeisActivationDateMap = null;
+        }
         Map<Integer, Integer> userBaseQtyMap = new HashMap<>();
         Map<Integer, Integer> userBaseValueMap = new HashMap<>();
         Map<Integer, Integer> eligibleBaseQtyMap = new HashMap<>();
                 if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {
                     Map<Integer, Integer> inventoryItemValueMap = new HashMap<>();
                     for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
                         fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(
                                 lineItem -> {
-                                    if (activatedImeisActiovationDateMap == null || activatedImeisActiovationDateMap.containsKey(lineItem.getSerialNumber())) {
+                                    if (activatedImeisActivationDateMap == null || activatedImeisActivationDateMap.containsKey(lineItem.getSerialNumber())) {
                                         inventoryItemValueMap.put(lineItem.getInventoryItemId(), (int) fofoOrderItem.getDp());
+                                    }
+                                }
                         );
+                    }
                 Map<FofoLineItem, Integer> lineItemValueMap = new HashMap<>();
                 if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {
                     for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
                         fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(
                                 lineItem -> {
-                                    if (activatedImeisActiovationDateMap == null) {
+                                    if (activatedImeisActivationDateMap == null) {
                                         lineItemValueMap.put(lineItem, (int) fofoOrderItem.getDp());
-                                    } else if (activatedImeisActiovationDateMap.containsKey(lineItem.getSerialNumber())) {
+                                    } else if (activatedImeisActivationDateMap.containsKey(lineItem.getSerialNumber())) {
-                                        if (itemCriteriaPayout.isWithinRange(activatedImeisActiovationDateMap.get(lineItem.getSerialNumber()))) {
+                                        if (itemCriteriaPayout.isWithinRange(activatedImeisActivationDateMap.get(lineItem.getSerialNumber()))) {
                                             lineItemValueMap.put(lineItem, (int) fofoOrderItem.getDp());
+                                        }
+                                    }
+                                }
+                }
                 int totalSale = totalBaseValue;
                 int eligibleSale = eligibleBaseValue;
-                int criteriaSale = totalValue;
                 int eligibleCriteriaSale = eligibleValue;
                 int eligibleCriteriaSaleDp = eligibleValue;
                 if (createOfferRequest.getTargetType().equals(AchievementType.QUANTITY)) {
                     totalSale = totalBaseQty;
                     eligibleSale = eligibleBaseQty;
-                    criteriaSale = totalQty;
                     eligibleCriteriaSale = eligibleQty;
+                }
                 offerRowModel.setTotalSale(totalSale);
                 offerRowModel.setEligibleSale(eligibleSale);
                 float eligiblePayoutValue = 0;
+                float previousPayoutValue = 0;
                 double finalPayout;
                 for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {
                     if (payoutSlab.getOnwardsAmount() <= eligibleSale) {
                         LOGGER.info("Eligible Sale {}", eligibleSale);
                         offerRowModel.setPayoutTargetAchieved(payoutSlab.getOnwardsAmount());
                         eligiblePayoutValue = payoutSlab.getPayoutAmount();
+                        previousPayoutValue = Math.min(eligiblePayoutValue, previousPayoutValue);
                         offerRowModel.setPayoutValue(eligiblePayoutValue);
+                    } else {
+                        break;
+                    }
+                }
                 if (AmountType.PERCENTAGE.equals(itemCriteriaPayout.getAmountType())) {
                     finalPayout = (eligiblePayoutValue * eligibleCriteriaSaleDp) / 100;
                 } else if (AmountType.FIXED.equals(itemCriteriaPayout.getAmountType())) {
                     Map<Integer, Double> fofoCriteriaMap = fixedSlabCriteriaPartnerMap.get(criteriaId);
                     LOGGER.info("fofoCriteriaMap {}", fofoCriteriaMap);
                     finalPayout = eligiblePayoutValue;
                     if (fofoCriteriaMap != null) {
                         if (fofoCriteriaMap.containsKey(fofoId)) {
-                            double totalPayout = fofoCriteriaMap.get(fofoId);
+                            //double totalPayout = fofoCriteriaMap.get(fofoId);
-                            finalPayout = eligiblePayoutValue - totalPayout;
+                            finalPayout = eligiblePayoutValue - previousPayoutValue;
                             if (Math.abs(finalPayout) < Utils.DOUBLE_EPSILON) {
                                 finalPayout = 0;
+                            }
+                        }
+                    }
                 LOGGER.info("Final Payout - {}", finalPayout);
                 if (finalPayout > 0) {
                     List<Integer> inventoryItemIds = lineItemValueMap.keySet().stream().map(x -> x.getInventoryItemId()).collect(Collectors.toList());
+                    int totalDpValue = lineItemValueMap.values().stream().collect(Collectors.summingInt(x -> x));
+                    LOGGER.info("Total DP Value {}", totalDpValue);
                     Map<Integer, InventoryItem> inventoryItemsMap = inventoryItemRepository.selectAllByIds(inventoryItemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
                     for (Map.Entry<FofoLineItem, Integer> lineItemValueEntry : lineItemValueMap.entrySet()) {
                         FofoLineItem fofoLineItem = lineItemValueEntry.getKey();
-                        if (ageingSummaryModelsMap.containsKey(fofoLineItem.getSerialNumber())) {
-                            if (ageingSummaryModelsMap.get(fofoLineItem.getSerialNumber()).isAgedAbove(300)) {
-                                continue;
-                            }
-                        }
                         double amount = 0;
-                        int totalDpValue = lineItemValueMap.values().stream().collect(Collectors.summingInt(x -> x));
-                        LOGGER.info("Total DP Value {}", totalDpValue);
                         if (AmountType.SLAB_FIXED.equals(itemCriteriaPayout.getAmountType())) {
                             amount = (eligiblePayoutValue * lineItemValueEntry.getValue()) / totalDpValue;
-                            LOGGER.info("Amount - {}", amount);
-                            //Fixed slab should be treated as fixed after payout
                         } else {
-                            amount = eligiblePayoutValue;
+                            if (ageingSummaryModelsMap.containsKey(fofoLineItem.getSerialNumber())) {
-                            //Fixed slab has already taken care of that amount;
+                                if (ageingSummaryModelsMap.get(fofoLineItem.getSerialNumber()).isAgedAbove(300)) {
-                            if (serialNumberPaid.containsKey(fofoLineItem.getSerialNumber())) {
+                                    continue;
-                                amount = amount - serialNumberPaid.get(fofoLineItem.getSerialNumber());
+                                }
+                            }
+                            amount = eligiblePayoutValue;
+                        }
+                        if (serialNumberPaid.containsKey(fofoLineItem.getSerialNumber())) {
+                            amount = amount - serialNumberPaid.get(fofoLineItem.getSerialNumber());
+                        }
                         LOGGER.info("Amount - {}", amount);
                         //ignore reasonably small
                         if (amount < Utils.DOUBLE_EPSILON) continue;
                         AmountModel amountModel = new AmountModel();
                 if (createOfferRequest.getTargetType().equals(AchievementType.VALUE)) {
                     purchasedValue = totalBaseValue;
                 } else {
                     purchasedValue = totalBaseQty;
+                }
-                PayoutSlab currentSlab = itemCriteriaPayout.getPayoutSlabs().stream()
-                        .filter(x -> x.getOnwardsAmount() <= purchasedValue).max(Comparator.comparing(x
-                                -> x.getOnwardsAmount())).orElse(null);
+                PayoutSlab eligibleSlab  = null;
+                PayoutSlab previousSlab  = null;
+                for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {
+                    if (payoutSlab.getOnwardsAmount() <= purchasedValue) {
-                //TODO-- payouts handling is here
+                        previousSlab = eligibleSlab;
-                if (currentSlab == null) continue;
+                        eligibleSlab = payoutSlab;
+                    } else {
+                        break;
+                    }
+                }
                 List<Integer> orderIds = orders.stream().map(x -> x.getId()).collect(Collectors.toList());
                 Map<Integer, LineItem> lineItemMap = orders.stream().collect(Collectors.toMap(x -> x.getLineItem().getId(), x -> x.getLineItem()));
                 List<WarehouseScan> warehouseScans = warehouseScanRepository.selectAllByOrderIds(orderIds);
                 LOGGER.info("Warehosue scans --> {}", warehouseScans);
                 List<Integer> warehouseInventoryItemIds = warehouseScans.stream().collect(Collectors.groupingBy(x -> x.getInventoryItemId())).entrySet()
                 Map<String, InventoryItem> serialNumberInventoryItemMap = this.getInventoryItemMap(fofoId, serialNumberMap);
                 //Continue if all imeis havent been grned
                 if (serialNumberInventoryItemMap.size() < serialNumberCountMap.size()) continue;
-                float eligiblePayoutValue = currentSlab.getPayoutAmount();
+                float eligiblePayoutValue = eligibleSlab.getPayoutAmount();
                 double finalPayout;
                 if (AmountType.PERCENTAGE.equals(itemCriteriaPayout.getAmountType())) {
                     finalPayout = (eligiblePayoutValue * purchasedValue) / 100;
                 } else if (AmountType.FIXED.equals(itemCriteriaPayout.getAmountType())) {
                     finalPayout = eligiblePayoutValue * purchasedValue;
                     LOGGER.info("fofoCriteriaMap {}", fofoCriteriaMap);
                     finalPayout = eligiblePayoutValue;
                     if (fofoCriteriaMap != null) {
                         if (fofoCriteriaMap.containsKey(fofoId)) {
                             double totalPayout = fofoCriteriaMap.get(fofoId);
-                            finalPayout = eligiblePayoutValue - totalPayout;
+                            finalPayout = eligiblePayoutValue - previousSlab.getPayoutAmount();
                             if (Math.abs(finalPayout) < Utils.DOUBLE_EPSILON) {
                                 finalPayout = 0;
+                            }
+                        }
+                    }
                         double amount = 0;
                         LOGGER.info("Total DP Value {}", totalDpValue);
                         if (AmountType.SLAB_FIXED.equals(itemCriteriaPayout.getAmountType())) {
                             amount = (eligiblePayoutValue * serialNumberInventoryItemEntry.getValue().getUnitPrice()) / totalDpValue;
                             LOGGER.info("Amount - {}", amount);
-                            //Fixed slab should be treated as fixed after payout
                         } else {
                             amount = eligiblePayoutValue;
-                            //Fixed slab has already taken care of that amount;
                             if (serialNumberPaid.containsKey(serialNumberInventoryItemEntry.getKey())) {
                                 amount = amount - serialNumberPaid.get(serialNumberInventoryItemEntry.getKey());
+                            }
+                        }
                         LOGGER.info("Amount - {}", amount);
                         //ignore reasonably small
-                        if (amount < Utils.DOUBLE_EPSILON) continue;
+                        if (Math.abs(amount) < Utils.DOUBLE_EPSILON) continue;
                         AmountModel amountModel = new AmountModel();
                         amountModel.setAmountType(itemCriteriaPayout.getAmountType());
                         amountModel.setAmount(amount);
                         amountModel.setDiscount(createOfferRequest.isDiscount());
                         InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(serialNumberInventoryItemEntry.getValue());

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/offers/OfferServiceImpl.java – Rev 33613 → 33662