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

+                }
                 offerRowModel.setTotalSale(totalSale);
                 offerRowModel.setEligibleSale(eligibleSale);
                 float eligiblePayoutValue = 0;
-                double finalPayout = 0;
+                double finalPayout;
                 for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {
                     if (payoutSlab.getOnwardsAmount() <= eligibleSale) {
                         LOGGER.info("Eligible Sale {}", eligibleSale);
                         offerRowModel.setPayoutTargetAchieved(payoutSlab.getOnwardsAmount());
                         eligiblePayoutValue = payoutSlab.getPayoutAmount();
     @Override
     public void processSellin(CreateOfferRequest createOfferRequest) throws Exception {
         //List<OfferRowModel> offerRowModels = new ArrayList<>();
         List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllByOfferId(createOfferRequest.getId());
+        Map<String, Double> serialNumberPaid = offerPayouts.stream().filter(x -> x.getRejectTimestamp() == null).collect(Collectors.groupingBy(x -> x.getSerialNumber(), Collectors.summingDouble(x -> x.getSlabAmount())));
+        List<ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts();
+        Map<Integer, ItemCriteriaPayout> itemCriteriaPayoutMap = itemCriteriaPayouts.stream().collect(Collectors.toMap(x -> x.getItemCriteria().getId(), x -> x));
+        Map<Integer, Map<Integer, Double>> fixedSlabCriteriaPartnerMap = offerPayouts.stream().filter(x -> itemCriteriaPayoutMap.get((int) x.getCriteriaId()).getAmountType().equals(AmountType.SLAB_FIXED))
+                .collect(Collectors.groupingBy(x -> (int) x.getCriteriaId(), Collectors.groupingBy(x -> (int) x.getFofoId(), Collectors.summingDouble(x -> x.getSlabAmount()))));
         Set<Long> fofoIds = offerPayouts.stream().map(x -> x.getFofoId()).collect(Collectors.toSet());
         Map<Integer, Map<Integer, List<Order>>> criteriaOrdersMap = offerRepository.getPartnerWiseSellin(createOfferRequest, true);
         Map<Integer, List<Order>> userBaseCriteriaOrdersMap = null;
         if (criteriaOrdersMap.get(0) != null && criteriaOrdersMap.get(0).size() > 0) {
             userBaseCriteriaOrdersMap = criteriaOrdersMap.get(0).entrySet().stream()
                     .filter(x -> !fofoIds.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));
+        }
         Map<Integer, Integer> userBaseQtyMap = null;
         Map<Integer, Integer> userBaseValueMap = null;
         if (userBaseCriteriaOrdersMap != null) {
             userBaseQtyMap = new HashMap<>();
             userBaseValueMap = new HashMap<>();
                     .filter(x -> !fofoIds.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));
             for (Map.Entry<Integer, List<Order>> orderEntry : ordersMap.entrySet()) {
                 int fofoId = orderEntry.getKey();
                 //CustomRetailer retailer = retailerService.getAllFofoRetailers().get(fofoId);
                 List<Order> orders = orderEntry.getValue();
-                Set<String> returnedSerialNumbers = orders.stream().filter(x -> x.getSerialNumber() != null).flatMap(x -> x.getReturnedImeis().stream()).collect(Collectors.toSet());
+                //Set<String> returnedSerialNumbers = orders.stream().filter(x -> x.getSerialNumber() != null).flatMap(x -> x.getReturnedImeis().stream()).collect(Collectors.toSet());
                 int totalQty = orders.stream().collect(Collectors.summingInt(x -> (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty())));
                 int totalValue = orders.stream().collect(Collectors.summingInt(x -> Math.round(x.getLineItem().
                         getUnitPrice() * (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty()))));
                 int totalBaseQty = totalQty;
                 int totalBaseValue = totalValue;
                 if (currentSlab == null) continue;
                 //Need to remove hardcoding on tax
                 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);
-                List<Integer> inventoryItemIds = warehouseScans.stream().collect(Collectors.groupingBy(x -> x.getInventoryItemId())).entrySet()
+                List<Integer> warehouseInventoryItemIds = warehouseScans.stream().collect(Collectors.groupingBy(x -> x.getInventoryItemId())).entrySet()
                         .stream().filter(x -> x.getValue().size() == 1).map(x -> x.getKey()).collect(Collectors.toList());
                 Set<String> serialNumbers;
-                LOGGER.info("inventoryItemIds {}", inventoryItemIds);
+                LOGGER.info("warehouseInventoryItemIds {}", warehouseInventoryItemIds);
-                if (inventoryItemIds.size() > 0) {
+                if (warehouseInventoryItemIds.size() > 0) {
-                    List<WarehouseInventoryItem> warehouseInventoryItems = warehouseInventoryItemRepository.selectAllByIds(inventoryItemIds);
+                    List<WarehouseInventoryItem> warehouseInventoryItems = warehouseInventoryItemRepository.selectAllByIds(warehouseInventoryItemIds);
                     serialNumbers = warehouseInventoryItems.stream().map(x -> x.getSerialNumber()).collect(Collectors.toSet());
                 } else {
                     serialNumbers = new HashSet<>();
+                }
                 LOGGER.info("SerialNumbers {}", serialNumbers);
                 serialNumberMap = serialNumberMap.entrySet().stream().filter(x -> serialNumbers.contains(x.getKey())).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));
                 Map<String, InventoryItem> serialNumberInventoryItemMap = this.getInventoryItemMap(fofoId, serialNumberMap);
                 //Continue if all imeis havent been grned
-                if(serialNumberInventoryItemMap.size() < serialNumberCountMap.size()) continue;
+                if (serialNumberInventoryItemMap.size() < serialNumberCountMap.size()) continue;
                 LOGGER.info("serialNumberMap {}", serialNumberMap);
+                float eligiblePayoutValue = currentSlab.getPayoutAmount();
-                double amount = 0;
+                double finalPayout;
-                int lineItemsValue = serialNumberMap.values().stream().collect(Collectors.summingInt(x -> x.getUnitPrice().intValue()));
+                if (AmountType.PERCENTAGE.equals(itemCriteriaPayout.getAmountType())) {
-                LOGGER.info("lineItemsValue - {}, totalValue - {}", lineItemsValue, totalValue);
+                    finalPayout = (eligiblePayoutValue * purchasedValue) / 100;
-                for (Map.Entry<String, LineItem> entry : serialNumberMap.entrySet()) {
+                } else if (AmountType.FIXED.equals(itemCriteriaPayout.getAmountType())) {
+                    finalPayout = eligiblePayoutValue * purchasedValue;
+                } else {
+                    Map<Integer, Double> fofoCriteriaMap = fixedSlabCriteriaPartnerMap.get(criteriaId);
-                    LOGGER.info("Serial no - {}", entry.getKey());
+                    LOGGER.info("fofoCriteriaMap {}", fofoCriteriaMap);
-                    LineItem lineItem = entry.getValue();
+                    finalPayout = eligiblePayoutValue;
+                    if (fofoCriteriaMap != null) {
-                    if (AmountType.SLAB_FIXED.equals(itemCriteriaPayout.getAmountType())) {
+                        if (fofoCriteriaMap.containsKey(fofoId)) {
-                        float totalAmount = currentSlab.getPayoutAmount();
+                            double totalPayout = fofoCriteriaMap.get(fofoId);
-                        amount = Math.round((totalAmount / totalValue) * lineItem.getUnitPrice());
+                            finalPayout = eligiblePayoutValue - totalPayout;
-                        LOGGER.info("Serial no - {}, unitPrice - {}, amount - {}", entry.getKey(), lineItem.getUnitPrice(), amount);
+                            if (Math.abs(finalPayout) < Utils.DOUBLE_EPSILON) {
-                    } else {
+                                finalPayout = 0;
-                        //per unit amount
+                            }
-                        amount = currentSlab.getPayoutAmount();
+                        }
+                    }
+                }
+                LOGGER.info("Or - {}", finalPayout);
+                if (finalPayout > 0) {
+                    double totalRolloutAmount = 0;
+                    int totalDpValue = serialNumberInventoryItemMap.entrySet().stream().mapToInt(x -> (int) x.getValue().getUnitPrice()).sum();
+                    for (Map.Entry<String, InventoryItem> serialNumberInventoryItemEntry : serialNumberInventoryItemMap.entrySet()) {
+                        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;
-                    AmountModel amountModel = new AmountModel();
+                        AmountModel amountModel = new AmountModel();
-                    amountModel.setAmountType(itemCriteriaPayout.getAmountType());
+                        amountModel.setAmountType(itemCriteriaPayout.getAmountType());
-                    amountModel.setAmount(amount);
+                        amountModel.setAmount(amount);
-                    amountModel.setDiscount(createOfferRequest.isDiscount());
+                        amountModel.setDiscount(createOfferRequest.isDiscount());
-                    InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(serialNumberInventoryItemMap.get(entry.getKey()));
+                        InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(serialNumberInventoryItemEntry.getValue());
-                    double rolloutAmount = inventoryPayoutModel.getRolloutAmount(amountModel);
+                        double rolloutAmount = inventoryPayoutModel.getRolloutAmount(amountModel);
-                    if (fofoIds.contains(Long.valueOf(fofoId))) continue;
+                        totalRolloutAmount += rolloutAmount;
-                    OfferPayout offerPayout = new OfferPayout(fofoId, createOfferRequest.getId(), criteriaId, currentSlab.getPayoutAmount(), entry.getKey(), rolloutAmount, SchemePayoutStatus.CREDITED, createOfferRequest.getDescription(), LocalDateTime.now());
-                    //offerPayout.setLineItemId();
+                        OfferPayout offerPayout = new OfferPayout(fofoId, createOfferRequest.getId(), criteriaId, amount, serialNumberInventoryItemEntry.getKey(), rolloutAmount, SchemePayoutStatus.CREDITED, createOfferRequest.getDescription(), LocalDateTime.now());
-                    offerPayoutRepository.persist(offerPayout);
+                        offerPayoutRepository.persist(offerPayout);
-                    offerPayoutsNew.add(offerPayout);
+                    }
+                    walletService.addAmountToWallet((int) fofoId, createOfferRequest.getId(), WalletReferenceType.ADDITIONAL_SCHEME, createOfferRequest.getDescription(), (float) totalRolloutAmount, LocalDateTime.now());
+                }
+            }
+        }
-        Map<Long, Double> offerPayoutMap = offerPayoutsNew.stream().collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.summingDouble(x -> x.getAmount())));
-        for (Map.Entry<Long, Double> offerPayoutEntry : offerPayoutMap.entrySet()) {
-            long fofoId = offerPayoutEntry.getKey();
-            double amountToCredit = offerPayoutEntry.getValue();
-            walletService.addAmountToWallet((int) fofoId, createOfferRequest.getId(), WalletReferenceType.ADDITIONAL_SCHEME, createOfferRequest.getDescription(), (float) amountToCredit, LocalDateTime.now());
-        }
         Offer offer = offerRepository.selectById(createOfferRequest.getId());
         offer.setProcessedTimestamp(LocalDateTime.now());
+    }
     private Map<String, InventoryItem> getInventoryItemMap(int fofoId, Map<String, LineItem> serialNumberMap) {
         List<InventoryItem> inventoryItems = inventoryItemRepository.selectBySerialNumbers(serialNumberMap.keySet());
-        inventoryItems = inventoryItems.stream().filter(x->x.getFofoId()== fofoId).collect(Collectors.toList());
+        inventoryItems = inventoryItems.stream().filter(x -> x.getFofoId() == fofoId).collect(Collectors.toList());
-        Map<String,InventoryItem> inventoryItemMap = inventoryItems.stream().collect(Collectors.toMap(x->x.getSerialNumber(), x->x, (u,v)->v.getCreateTimestamp().isAfter(u.getCreateTimestamp()) ? v : u));
+        Map<String, InventoryItem> inventoryItemMap = inventoryItems.stream().collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x, (u, v) -> v.getCreateTimestamp().isAfter(u.getCreateTimestamp()) ? v : u));
         return inventoryItemMap;
+    }
+}

Subversion Repositories SmartDukaan

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