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

 import com.spice.profitmandi.common.model.SendNotificationModel;
 import com.spice.profitmandi.common.services.ReporticoService;
 import com.spice.profitmandi.common.util.FormattingUtils;
 import com.spice.profitmandi.common.util.StringUtils;
 import com.spice.profitmandi.common.util.Utils;
-import com.spice.profitmandi.dao.entity.catalog.Item;
+import com.spice.profitmandi.dao.entity.catalog.*;
-import com.spice.profitmandi.dao.entity.catalog.Scheme;
-import com.spice.profitmandi.dao.entity.catalog.SchemeRegion;
-import com.spice.profitmandi.dao.entity.catalog.SchemesImeisModel;
 import com.spice.profitmandi.dao.entity.fofo.*;
+import com.spice.profitmandi.dao.entity.inventory.PartnerAgeingModel;
 import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
 import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
 import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
 import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
 import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
 import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;
+import com.spice.profitmandi.dao.model.AmountModel;
 import com.spice.profitmandi.dao.model.CreateSchemeRequest;
 import com.spice.profitmandi.dao.repository.catalog.*;
 import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
 import com.spice.profitmandi.dao.repository.fofo.*;
 import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;
 import com.spice.profitmandi.dao.repository.transaction.UserWalletHistoryRepository;
 import com.spice.profitmandi.service.NotificationService;
 import com.spice.profitmandi.service.authentication.RoleManager;
+import com.spice.profitmandi.service.inventory.AgeingService;
 import com.spice.profitmandi.service.inventory.PurchaseService;
+import com.spice.profitmandi.service.pricecircular.CatalogSummaryModel;
+import com.spice.profitmandi.service.pricecircular.SchemeSummaryModel;
 import com.spice.profitmandi.service.wallet.WalletService;
 import in.shop2020.model.v1.order.WalletReferenceType;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.hibernate.Session;
 import java.text.MessageFormat;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.YearMonth;
 import java.util.*;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 @Component
 public class SchemeServiceImpl implements SchemeService {
+            }
+        }
         return inventoryItemSchemesMap;
+    }
+    @Autowired
+    OfferTargetSlabRepository offerTargetSlabRepository;
-    @Override
+    /*@Override
     public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
         LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);
         Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
         // TODO - SCHEME
         PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,
                 YearMonth.from(purchase.getCreateTimestamp()));
         // PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,
         // purchase.getCreateTimestamp().toLocalDate());
         for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap
                 .entrySet()) {
             float inventoryItemCashback = 0;
             for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {
                 InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
-                float cashback = this.createSchemeInOut(scheme, inventoryItem, partnerType);
+                float cashback = this.createSchemeInOut(null, inventoryItem, partnerType);
                 inventoryItemCashback += cashback;
+            }
             if (inventoryItemCashback > 0) {
                 totalCashback += inventoryItemCashback;
                 itemsCount++;
             LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
                     purchase.getPurchaseReference(), itemsCount);
             purchase.setCashback(purchase.getCashback() + totalCashback);
             purchaseRepository.persist(purchase);
+        }
-    }
+    }*/
     private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest) {
         Scheme scheme = new Scheme();
         scheme.setName(createSchemeRequest.getName());
         scheme.setDescription(createSchemeRequest.getDescription());
         scheme.setCreatedBy(creatorId);
         scheme.setCashback(createSchemeRequest.isCashback());
         return scheme;
+    }
+    @Autowired
+    OfferRepository offerRepository;
+    @Autowired
+    OfferPayoutRepository offerPayoutRepository;
+    @Autowired
+    AgeingService ageingService;
+    public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
+        Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
-    //Only in and activation margins are allowed to be rolled out more than twice
+        PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,
+                YearMonth.from(purchase.getCreateTimestamp()));
-    private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem, PartnerType partnerType) throws ProfitMandiBusinessException {
+        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
-        LOGGER.info("Scheme === {}", scheme);
+        //Remove imeis from blocked imeis list
-        if ((scheme.getId() == 411 || scheme.getId() == 612) && inventoryItem.getCreateTimestamp().isAfter(LocalDate.of(2021, 12, 1).atStartOfDay())) {
+        inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toList());
-            return 0;
+        if (inventoryItems.size() == 0) return;
-        }
+        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
-        List<SchemeInOut> sios = schemeInOutRepository.selectAllByType(scheme.getType(), inventoryItem.getId());
+        Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+        inventoryItems.stream().forEach(x -> x.setItem(itemsMap.get(x.getItemId())));
-        float actualCredit = 0;
+        LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchaseId);
+        Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()
-        if (sios.stream().filter(x -> x.getRolledBackTimestamp() == null && x.getSchemeId() == scheme.getId())
+                .filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())
-                .collect(Collectors.toList()).size() == 0) {
+                .collect(Collectors.toSet());
+        // Only consider inventory items that were not returned and not eol
-            sios = sios.stream().filter(x -> x.getRolledBackTimestamp() == null).collect(Collectors.toList());
+        inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))
-            //Rejected Scheme for types INVESTMENT and ACTIVATION are considered rolledback only if the item billing is cancelled.
+                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD))
-            float amountCredited = (float) sios.stream().mapToDouble(e -> e.getAmount()).sum();
+                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());
-            LOGGER.info("SIOS ===== {}", sios);
+        if (inventoryItems.size() == 0) return;
-            float amountToCredit = this.getAmount(inventoryItem, scheme);
+        Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));
-            //Activation and in scheme
-            if (!scheme.getType().equals(SchemeType.IN) && !scheme.getType().equals(SchemeType.ACTIVATION) &&
+        Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(retailerId,
-                    !scheme.getType().equals(SchemeType.SPECIAL_SUPPORT) && sios.size() > 0) {
+                partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), purchase.getCreateTimestamp());
-                if (sios.size() > 1) {
+        int itemsCount = 0;
+        float totalCashback = 0;
+        for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {
+            CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();
+            List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue();
+            schemeSummaryModels.stream().filter(x -> x.getSchemeType().equals(SchemeType.IN)).forEach(x -> x.setProcess(true));
+            if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;
+            List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());
+            for (InventoryItem inventoryItem : modelInventoryItems) {
-                    LOGGER.info("SAMESCHEMETYPE has already been credited twice for inventoryItem - {}", inventoryItem.getId());
+                float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem, partnerType);
+                if (inventoryItemCashback > 0) {
-                    return 0;
+                    itemsCount++;
+                    totalCashback += inventoryItemCashback;
+                }
+            }
+        }
-                if (amountToCredit > amountCredited + 1f) {
+        LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);
-                    for (SchemeInOut sio : sios) {
+        if (itemsCount > 0) {
-                        sio.setRolledBackTimestamp(LocalDateTime.now());
+            walletService.addAmountToWallet(
-                        sio.setStatus(SchemePayoutStatus.REJECTED);
+                    retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "
-                        sio.setStatusDescription("Partner Category upgraded to " + scheme.getPartnerType() + ", new entry for margin added");
+                            + purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",
-                    }
+                    totalCashback, purchase.getCreateTimestamp());
+            LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
-                    actualCredit = amountToCredit - amountCredited;
+                    purchase.getPurchaseReference(), itemsCount);
-                } else {
+        }
-                    return 0;            //Rejected Scheme for types INVESTMENT and ACTIVATION are considered rolledback only if the item billing is cancelled.
+    }
+    public InventoryPayoutModel getPayouts(InventoryItem inventoryItem) {
+        double paidPercentage = 0d;
+        double paidFixed = 0d;
+        double totalPaid = 0d;
+        List<SchemeInOut> sios = schemeInOutRepository.selectAll(inventoryItem.getId());
+        List<SchemeInOut> paidSios = sios.stream().filter(x -> x.getRolledBackTimestamp() == null).filter(x -> x.getStatus().equals(SchemePayoutStatus.CREDITED)).collect(Collectors.toList());
+        if (paidSios.size() > 0) {
+            List<Integer> schemeIds = sios.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
+            Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+            for (SchemeInOut paidSio : paidSios) {
+                Scheme scheme = schemesMap.get(paidSio.getSchemeId());
+                paidSio.setScheme(scheme);
+                if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {
+                    paidPercentage += scheme.getAmount();
+                } else {
+                    paidFixed += scheme.getAmount();
+                }
-            } else {
-                actualCredit = amountToCredit;
+                totalPaid += paidSio.getAmount();
+            }
-            LOGGER.info("Actual Credit ==== {}", actualCredit);
+        }
-            SchemeInOut schemeInOut = new SchemeInOut();
-            schemeInOut.setSchemeId(scheme.getId());
-            schemeInOut.setInventoryItemId(inventoryItem.getId());
+        List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllBySerialNumber(inventoryItem.getFofoId(), inventoryItem.getSerialNumber())
-            schemeInOut.setAmount(amountToCredit);
+                .stream().filter(x -> x.getStatus().equals(SchemePayoutStatus.CREDITED)).collect(Collectors.toList());
-            schemeInOutRepository.persist(schemeInOut);
+        if (offerPayouts.size() > 0) {
-            if (scheme.getType().equals(SchemeType.ACTIVATION)) {
+            Map<Integer, List<OfferPayout>> offerPayoutMap = offerPayouts.stream().collect(Collectors.groupingBy(x -> (int) x.getOfferId()));
-                schemeInOut.setStatus(SchemePayoutStatus.PENDING);
+            Map<Integer, Integer> offerCriteriaMap = offerPayouts.stream().collect(Collectors.toMap(x -> (int) x.getOfferId(), x -> (int) x.getCriteriaId(), (u, v) -> u));
-                schemeInOut.setStatusDescription("Activation pending for IMEI#" + inventoryItem.getSerialNumber());
+            List<TargetSlabEntity> targetSlabEntities = offerTargetSlabRepository.selectByOfferIds(new ArrayList<>(offerPayoutMap.keySet()));
-                return 0;
-            } else if (scheme.getType().equals(SchemeType.INVESTMENT) && !PartnerType.BRONZE.equals(partnerType)) {
+            Map<Integer, TargetSlabEntity> offerIdTargetSlabMap = targetSlabEntities.stream().filter(x -> offerCriteriaMap.get(x.getOfferId()) == x.getItemCriteriaId())
-                schemeInOut.setStatus(SchemePayoutStatus.PENDING);
+                    .collect(Collectors.toMap(x -> x.getOfferId(), x -> x, (u, v) -> u));
-                schemeInOut.setStatusDescription("Subject to investment days maintained");
+            for (Map.Entry<Integer, TargetSlabEntity> offerIdTargetSlabEntityEntry : offerIdTargetSlabMap.entrySet()) {
-                return 0;
+                int offerId = offerIdTargetSlabEntityEntry.getKey();
-            } else {
-                schemeInOut.setStatus(SchemePayoutStatus.CREDITED);
+                TargetSlabEntity targetSlabEntity = offerIdTargetSlabEntityEntry.getValue();
-                schemeInOut.setCreditTimestamp(LocalDateTime.now());
+                List<OfferPayout> payouts = offerPayoutMap.get(offerId);
-                if (scheme.getType().equals(SchemeType.IN)) {
+                if (targetSlabEntity.getAmountType().equals(AmountType.PERCENTAGE)) {
-                    schemeInOut.setStatusDescription("Credited for GRN of IMEI#" + inventoryItem.getSerialNumber());
+                    paidPercentage += payouts.stream().map(x -> x.getSlabAmount()).max(Comparator.comparing(Function.identity())).get();
-                } else if (SchemeType.INVESTMENT.equals(scheme.getType()) || SchemeService.OUT_SCHEME_TYPES.contains(scheme.getType())) {
+                } else {
-                    schemeInOut.setStatusDescription("Credited for sale of IMEI#" + inventoryItem.getSerialNumber());
+                    paidFixed += payouts.stream().collect(Collectors.summingDouble(x -> x.getSlabAmount()));
+                }
+                totalPaid += payouts.stream().collect(Collectors.summingDouble(x -> x.getAmount()));
+            }
+        }
+        InventoryPayoutModel inventoryPayoutModel = new InventoryPayoutModel(inventoryItem.getId(), paidSios, offerPayouts);
+        inventoryPayoutModel.setFixedAmount(paidFixed);
+        inventoryPayoutModel.setPaidAmount(totalPaid);
+        inventoryPayoutModel.setPercentageAmount(paidPercentage);
-        return actualCredit;
+        return inventoryPayoutModel;
+    }
     // We are maintaining price drop after grn
     private float getAmount(InventoryItem inventoryItem, Scheme scheme) throws ProfitMandiBusinessException {
         if (BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())) {
             amount = scheme.getAmount();
+        }
         return amount;
+    }
+    //Only in and activation margins are allowed to be rolled out more than twice
+    private float createSchemeInOut(List<SchemeSummaryModel> schemeSummaryModels, InventoryItem inventoryItem, PartnerType partnerType) throws ProfitMandiBusinessException {
+        InventoryPayoutModel inventoryPayoutModel = this.getPayouts(inventoryItem);
+        //Get all schemes
+        List<SchemeSummaryModel> inventoryPayoutModelToProcess = schemeSummaryModels.stream().filter(x -> x.isProcess()).collect(Collectors.toList());
+        float actualCredit = 0;
+        List<SchemeInOut> sios = inventoryPayoutModel.getSchemePayouts();
+        Map<SchemeType, List<SchemeInOut>> paidSchemeTypesMap = inventoryPayoutModel.getSchemePayouts().stream().collect(Collectors.groupingBy(x -> x.getScheme().getType()));
+        Map<Integer, SchemeInOut> paidSchemesMap = sios.stream().collect(Collectors.toMap(x -> x.getSchemeId(), x -> x));
+        double percentageToPay = 0d;
+        double fixedToPay = 0d;
+        Map<SchemeSummaryModel, AmountModel> payoutSchemeSummaryModelMap = new HashMap<>();
+        for (SchemeSummaryModel schemeSummaryModelToProcess : inventoryPayoutModelToProcess) {
+            if (paidSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId())) continue;
+            //If different type but on higher side provide the higher margin
+            if (Arrays.asList(SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT).contains(schemeSummaryModelToProcess.getSchemeType())) {
+                SchemeInOut sio = new SchemeInOut();
+                sio.setAmount(0);
+                sio.setInventoryItemId(inventoryItem.getId());
+                sio.setSchemeId(schemeSummaryModelToProcess.getSchemeId());
+                sio.setStatusDescription("Activation pending for IMEI#" + inventoryItem.getSerialNumber());
+                sio.setStatus(SchemePayoutStatus.PENDING);
+                schemeInOutRepository.persist(sio);
+            } else if (!SchemeType.IN.equals(schemeSummaryModelToProcess.getSchemeType())) {
+                //We have got non repeating scheme type
+                if (paidSchemeTypesMap.containsKey(schemeSummaryModelToProcess.getSchemeType())) {
+                    SchemeInOut sio = paidSchemeTypesMap.get(schemeSummaryModelToProcess.getSchemeType()).get(0);
+                    Scheme paidScheme = sio.getScheme();
+                    //Don't entertain if amount types do not match for same type
+                    if (paidScheme.getAmountType().equals(schemeSummaryModelToProcess.getAmountType()) &&
+                            schemeSummaryModelToProcess.getAmount() > paidScheme.getAmount() + Utils.DOUBLE_EPSILON) {
+                        sio.setRolledBackTimestamp(LocalDateTime.now());
+                        sio.setStatus(SchemePayoutStatus.REJECTED);
+                        sio.setStatusDescription("Eligible for higher margin for " + sio.getSchemeType() + " new entry added");
+                        if (paidScheme.getAmountType().equals(AmountType.PERCENTAGE)) {
+                            percentageToPay += schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount();
+                        } else {
+                            fixedToPay += schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount();
+                        }
+                        payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount(), schemeSummaryModelToProcess.getAmountType()));
+                    }
+                } else {
+                    if (schemeSummaryModelToProcess.getAmountType().equals(AmountType.PERCENTAGE)) {
+                        percentageToPay += schemeSummaryModelToProcess.getAmount();
+                    } else {
+                        fixedToPay += schemeSummaryModelToProcess.getAmount();
+                    }
+                    payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount(), schemeSummaryModelToProcess.getAmountType()));
+                }
+            } else {
+                if (schemeSummaryModelToProcess.getAmountType().equals(AmountType.PERCENTAGE)) {
+                    percentageToPay += schemeSummaryModelToProcess.getAmount();
+                } else {
+                    fixedToPay += schemeSummaryModelToProcess.getAmount();
+                }
+                payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount(), schemeSummaryModelToProcess.getAmountType()));
+            }
+        }
+        double walletCredit = 0d;
+        if (fixedToPay > 0) {
+            double fixedRollout = fixedToPay * (1 - inventoryPayoutModel.getPercentageAmount()) / (100 + inventoryPayoutModel.getPercentageAmount());
+            for (Map.Entry<SchemeSummaryModel, AmountModel> schemeSummaryModelAmountModelEntry : payoutSchemeSummaryModelMap.entrySet()) {
+                SchemeSummaryModel schemeSummaryModel = schemeSummaryModelAmountModelEntry.getKey();
+                AmountModel amountModel = schemeSummaryModelAmountModelEntry.getValue();
+                if (amountModel.getAmountType().equals(AmountType.FIXED)) {
+                    SchemeInOut sio = new SchemeInOut();
+                    sio.setSchemeId(schemeSummaryModel.getSchemeId());
+                    sio.setInventoryItemId(inventoryItem.getId());
+                    sio.setStatus(SchemePayoutStatus.CREDITED);
+                    sio.setCreditTimestamp(LocalDateTime.now());
+                    sio.setAmount((float) (fixedRollout * amountModel.getAmount() / fixedToPay));
+                    if (schemeSummaryModel.getSchemeType().equals(SchemeType.IN))
+                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());
+                    else
+                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());
+                    schemeInOutRepository.persist(sio);
+                }
+            }
+            walletCredit += fixedRollout;
+        }
+        if (percentageToPay > 0) {
+            double effectiveDP = inventoryItem.getUnitPrice() - Math.max(0, inventoryItem.getPriceDropAmount()) - (inventoryPayoutModel.getFixedAmount() + fixedToPay);
+            double totalPercentage = inventoryPayoutModel.getPercentageAmount() + percentageToPay;
+            double percentageRollout = effectiveDP * (totalPercentage / (100 + totalPercentage) - (inventoryPayoutModel.getPercentageAmount() / (100 + inventoryPayoutModel.getPercentageAmount())));
+            for (Map.Entry<SchemeSummaryModel, AmountModel> schemeSummaryModelAmountModelEntry : payoutSchemeSummaryModelMap.entrySet()) {
+                SchemeSummaryModel schemeSummaryModel = schemeSummaryModelAmountModelEntry.getKey();
+                AmountModel amountModel = schemeSummaryModelAmountModelEntry.getValue();
+                if (amountModel.getAmountType().equals(AmountType.PERCENTAGE)) {
+                    SchemeInOut sio = new SchemeInOut();
+                    sio.setInventoryItemId(inventoryItem.getId());
+                    sio.setSchemeId(schemeSummaryModel.getSchemeId());
+                    sio.setStatus(SchemePayoutStatus.CREDITED);
+                    sio.setCreditTimestamp(LocalDateTime.now());
+                    sio.setAmount((float) (percentageRollout * amountModel.getAmount() / percentageToPay));
+                    if (schemeSummaryModel.getSchemeType().equals(SchemeType.IN))
+                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());
+                    else
+                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());
+                    schemeInOutRepository.persist(sio);
+                }
+            }
+            walletCredit += percentageRollout;
+        }
+        return (float) walletCredit;
+    }
+    private Set<Integer> filterImeisByAgeing(Set<Integer> inventoryItemIds, FofoOrder fofoOrder) {
+        Set<Integer> filteredInventoryIds = new HashSet<>();
+        List<PartnerAgeingModel> partnerAgeingModels = ageingService.filterAgedInventory(inventoryItemIds);
+        for (PartnerAgeingModel partnerAgeingModel : partnerAgeingModels) {
+            LOGGER.info("Serial Number - {}", partnerAgeingModel.getSerialNumber());
+            if (partnerAgeingModel.getBrand().equalsIgnoreCase("Samsung")) {
+                ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(partnerAgeingModel.getSerialNumber());
+                if (activatedImei != null && activatedImei.getActivationTimestamp().toLocalDate()
+                        .isBefore(partnerAgeingModel.getBillingDate().plusDays(partnerAgeingModel.getMaxAgeingDays()))) {
+                    //Lets give money if activation is there and is before the ageing limit of that brand.
+                    filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());
+                } else {
+                    //If billing happens before ageing expiry
+                    if (fofoOrder.getCreateTimestamp().toLocalDate().isBefore(partnerAgeingModel.getBillingDate().plusDays(partnerAgeingModel.getMaxAgeingDays()))) {
+                        filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());
+                    }
+                }
+            } else {
+                filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());
+            }
+        }
+        return filteredInventoryIds;
+    }
     @Override
     public float processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
         float totalCashback = 0;
         FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);
         // Process only if order is not cancelled
             List<ScanRecord> scanRecords = scanRecordRepository.selectAllByOrderId(fofoOrderId);
             if (scanRecords.size() == 0) return 0;
             Set<Integer> inventoryItemIds = scanRecords.stream().map(x -> x.getInventoryItemId())
                     .collect(Collectors.toSet());
+            //Check for ageing
+            inventoryItemIds = this.filterImeisByAgeing(inventoryItemIds, fofoOrder);
+            //ageingService.filterAgedInventory(inventoryItemIds);
             LOGGER.info("fofoOrderId --- {}", fofoOrderId);
             LOGGER.info("scanRecords --- {}", scanRecords);
             LOGGER.info("inventoryItemIds --- {}", inventoryItemIds);
+            if (inventoryItemIds.size() == 0) return 0;
             Set<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
                     .filter(x -> x.getSerialNumber() != null && !x.getSerialNumber().equals(""))
                     .collect(Collectors.toSet());
             inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toSet());
-            if (inventoryItems.size() == 0) {
-                return 0;
-            }
-            Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
-            // Remove Items that are eol now.
-            Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()
-                    .filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(fofoOrder.getCreateTimestamp()))
-                    .map(x -> x.getItemId()).collect(Collectors.toSet());
-            // Only consider inventory items that were not returned
+            if (inventoryItems.size() == 0) return 0;
-            //ItemCriteria itemCriteria = new ItemCriteria();
-            //itemCriteria.setItemIds(new ArrayList<>(itemIdsSet));
-            //List<Integer> catalogIds = itemRepository.getCatalogIds(itemCriteria);
-            inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))
-                    .collect(Collectors.toSet());
-            if (inventoryItems.size() == 0) {
+            Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));
+            Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(retailerId,
-                return 0;
+                    partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), fofoOrder.getCreateTimestamp());
-            }
-            int count = 0;
-            List<SchemeType> allOutSchemeTypes = new ArrayList<>();
+            int count = 0;
-            allOutSchemeTypes.addAll(Arrays.asList(SchemeType.ACTIVATION, SchemeType.INVESTMENT, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT));
+            for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {
-            allOutSchemeTypes.addAll(OUT_SCHEME_TYPES);
+                CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();
-            List<Scheme> allActiveSchemes = schemeRepository.selectActiveAll(allOutSchemeTypes, partnerType,
+                List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue();
-                    fofoOrder.getCreateTimestamp().toLocalDate(), false);
+                List<SchemeType> allOutSchemeTypes = new ArrayList<>();
-            List<Integer> validSchemeIds = schemeRepository.selectSchemesByRetailerIdsSchemeIds(retailerId, allActiveSchemes.stream().map(x -> x.getId()).collect(Collectors.toList()));
-            allActiveSchemes = allActiveSchemes.stream().filter(x -> validSchemeIds.contains(x.getId())).collect(Collectors.toList());
+                allOutSchemeTypes.addAll(Arrays.asList(SchemeType.ACTIVATION, SchemeType.INVESTMENT, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT));
-            for (InventoryItem inventoryItem : inventoryItems) {
-                float itemCashback = 0;
-                Set<Integer> schemeIds = new HashSet<>(
+                allOutSchemeTypes.addAll(OUT_SCHEME_TYPES);
-                        schemeItemRepository.selectSchemeIdByCatalogId(inventoryItem.getItem().getCatalogItemId()));
+                schemeSummaryModels.stream().filter(x -> allOutSchemeTypes.contains(x.getSchemeType())).forEach(x -> x.setProcess(true));
-                List<Scheme> itemActiveSchemes = allActiveSchemes.stream().filter(x -> schemeIds.contains(x.getId()))
+                if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;
-                        .collect(Collectors.toList());
-                List<Scheme> supportSchemes = itemActiveSchemes.stream().filter(x -> Arrays.asList(SchemeType.SPECIAL_SUPPORT, SchemeType.ACTIVATION, SchemeType.SELLOUT).contains(x.getType())).collect(Collectors.toList());
+                List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());
-                itemActiveSchemes = itemActiveSchemes.stream().filter(x -> !Arrays.asList(SchemeType.SPECIAL_SUPPORT, SchemeType.ACTIVATION, SchemeType.SELLOUT).contains(x.getType())).collect(Collectors.toList());
-                for (Scheme scheme : itemActiveSchemes) {
+                for (InventoryItem inventoryItem : modelInventoryItems) {
-                    LOGGER.info("Scheme ==== {}", scheme);
-                    itemCashback += this.createSchemeInOut(scheme, inventoryItem, partnerType);
+                    float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem, partnerType);
-                }
-                if (supportSchemes.size() > 0) {
+                    if (inventoryItemCashback > 0) {
-                    this.processSpecialSupport(fofoOrder, supportSchemes, inventoryItem, partnerType, fofoOrder.getCreateTimestamp());
-                }
+                        count++;
-                LOGGER.info("itemCashback ==== {}", itemCashback);
+                        totalCashback += inventoryItemCashback;
-                if (itemCashback > 0) {
-                    count++;
+                    }
-                    totalCashback += itemCashback;
+                }
+            }
             if (count > 0) {
                 walletService.addAmountToWallet(
                         retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT, "Sales margin for invoice number "
                                 + fofoOrder.getInvoiceNumber() + ". Total " + count + " pc(s)",
                         totalCashback, fofoOrder.getCreateTimestamp());
             float amountToCredit = scheme.getAmount() * (1 - (totalMargin / 100));
             List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
             SchemeInOut schemeInOut = schemeInOuts.stream().filter(x -> x.getRolledBackTimestamp() == null).findFirst().orElse(null);
             if (schemeInOut == null) {
                 schemeInOut = new SchemeInOut();
+                schemeInOut.setInventoryItemId(inventoryItem.getId());
                 schemeInOut.setSchemeId(scheme.getId());
                 schemeInOut.setInventoryItemId(inventoryItem.getId());
                 schemeInOut.setCreateTimestamp(LocalDateTime.now());
                 if (SchemeType.SELLOUT.equals(scheme.getType())) {
                     schemeInOut.setStatus(SchemePayoutStatus.CREDITED);
                                 .parseInt(FormattingUtils.getYearMonth(schemeTypeMap.get(SchemeType.INVESTMENT).getCreditTimestamp().minusMonths(1)));
+                    }
+                }
                 walletService.rollbackAmountFromWallet(fofoId, amountToRollback, reversalReference, walletReferenceType,
-                    reversalReason, LocalDateTime.now());
+                        reversalReason, LocalDateTime.now());
-        }
+            }
+    }
     @Override
     public double getTotalMargin(int itemId, PartnerType partnerType, LocalDateTime dateTime) {
         Session session = sessionFactory.getCurrentSession();
         itemCashbackMap.remove(30756);
         return itemCashbackMap;
+    }
     @Override
-    public List<Scheme> selectSchemeByPartnerTypeFofoId(PartnerType partnerType, LocalDate onDate, int catalogId, int fofoId, int offset, int limit) throws ProfitMandiBusinessException {
+    public List<Scheme> selectSchemeByPartnerTypeFofoId(PartnerType partnerType, LocalDate onDate, int catalogId,
+                                                        int fofoId, int offset, int limit) throws ProfitMandiBusinessException {
         Session session = sessionFactory.getCurrentSession();
         final TypedQuery<Scheme> typedQuery = session.createNamedQuery(
                 "Scheme.selectSchemeByModelsPartnerTypeFofoId", Scheme.class);
         typedQuery.setParameter("catalogIds", Arrays.asList(catalogId));
         typedQuery.setParameter("fofoIds", Arrays.asList(fofoId, 0));
                 FofoOrder fofoOrder = validOrdersMap.get(schemesImeisModel.getOrderId());
                 PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(fofoOrder.getFofoId(),
                         YearMonth.from(fofoOrder.getCreateTimestamp()));
                 this.processSpecialSupport(fofoOrder, supportSchemes, inventoryItem, partnerType, fofoOrder.getCreateTimestamp());
+            }
+        }
+    }
+}

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/scheme/SchemeServiceImpl.java – Rev 31610 → 31903