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

                                 list -> {
                                     list.sort(Integer::compareTo); // sort ascending
                                     return list;
                                 })));
+        // Batch fetch all schemeItems for all filtered schemes at once
+        Map<Integer, List<SchemeItem>> schemeItemsBySchemeId = schemeItemRepository.selectBySchemeIds(schemesMap.keySet())
+                .stream().collect(Collectors.groupingBy(SchemeItem::getSchemeId));
+        // Collect all catalogIds for batch fetching items
+        Set<Integer> allCatalogIdsForFetch = schemeItemsBySchemeId.values().stream()
+                .flatMap(List::stream)
+                .map(SchemeItem::getCatalogId)
+                .collect(Collectors.toSet());
+        // Batch fetch all items by catalogIds once
+        Map<Integer, List<Item>> itemsByCatalogId = allCatalogIdsForFetch.isEmpty()
+                ? Collections.emptyMap()
+                : itemRepository.selectAllByCatalogIds(allCatalogIdsForFetch).stream()
+                        .collect(Collectors.groupingBy(Item::getCatalogItemId));
         Map<List<Integer>, Map<String, List<Scheme>>> groupedByRegionDate = filteredSchemes.stream()
                 .collect(Collectors.groupingBy(s -> schemeIdRegionIdsMap.get(s.getId()), Collectors.groupingBy(s ->
                         String.valueOf(s.getStartDateTime()).substring(0, 10) + " - " +
                                 String.valueOf(s.getEndDateTime()).substring(0, 10)
                 )));
                         schemeTypeLabel = "Sellout Scheme";
                     } else if (scheme.getType().equals(SchemeType.SELLIN)) {
                         schemeTypeLabel = "Sellin Scheme";
+                    }
-                    List<SchemeItem> schemeItems =
+                    // Use pre-fetched schemeItems instead of N+1 query
-                            schemeItemRepository.selectBySchemeIds(Collections.singleton(scheme.getId()));
+                    List<SchemeItem> schemeItems = schemeItemsBySchemeId.getOrDefault(scheme.getId(), Collections.emptyList());
                     Set<Integer> catalogIds = schemeItems.stream()
                             .map(SchemeItem::getCatalogId)
                             .collect(Collectors.toSet());
                     allCatalogIds.addAll(catalogIds);
+                    // Use pre-fetched items instead of duplicate DB calls
+                    List<Item> catalogItems = catalogIds.stream()
+                            .flatMap(cid -> itemsByCatalogId.getOrDefault(cid, Collections.emptyList()).stream())
+                            .collect(Collectors.toList());
-                    List<String> itemBrand = itemRepository.selectAllByCatalogIds(catalogIds).stream()
+                    List<String> itemBrand = catalogItems.stream()
                             .map(Item::getBrand)
                             .filter(Objects::nonNull)
                             .distinct()
                             .collect(Collectors.toList());
                     allBrands.addAll(itemBrand);
-                    List<String> itemDescriptions = itemRepository.selectAllByCatalogIds(catalogIds).stream()
+                    List<String> itemDescriptions = catalogItems.stream()
                             .filter(Utils.distinctByKey(Item::getCatalogItemId))
                             .map(Item::getItemDescriptionNoColor)
                             .collect(Collectors.toList());
                     messageBuilder.append(String.format("%s of Rs.%s on Models: %s\n",
                     List<SchemeType> rejectedCDTypes = HALF_DAYS_CD_REJECT_SCHEME_TYPES;
                     if (loan.getCdFreeDays() == ProfitMandiConstants.LOAN_FULL_CREDIT_DAYS) {
                         rejectedCDTypes = FULL_DAYS_CD_SCHEME_TYPES;
+                    }
                     for (SchemeType rejectedCDType : rejectedCDTypes) {
+                        // Fixed: single DB call instead of duplicate calls
-                        SchemeInOut sio = schemeInOutRepository.selectAllByType(rejectedCDType, inventoryItem.getId()).size() > 0 ?
+                        List<SchemeInOut> cdSios = schemeInOutRepository.selectAllByType(rejectedCDType, inventoryItem.getId());
-                                schemeInOutRepository.selectAllByType(rejectedCDType, inventoryItem.getId()).get(0) : null;
+                        SchemeInOut sio = cdSios.isEmpty() ? null : cdSios.get(0);
                         if (sio == null) continue;
                         sio.setStatus(SchemePayoutStatus.REJECTED);
                         //Noone should change this
                         sio.setStatusDescription("Rejected due to free days availed");
                         sio.setRolledBackTimestamp(LocalDateTime.now());
+    }
     private Set<Integer> filterImeisByAgeing(Set<Integer> inventoryItemIds, FofoOrder fofoOrder) {
         Set<Integer> filteredInventoryIds = new HashSet<>();
         List<PartnerAgeingModel> partnerAgeingModels = ageingService.filterAgedInventory(inventoryItemIds);
+        // Batch fetch all Samsung activated imeis at once to avoid N+1 queries
+        List<String> samsungSerialNumbers = partnerAgeingModels.stream()
+                .filter(p -> "Samsung".equalsIgnoreCase(p.getBrand()))
+                .map(PartnerAgeingModel::getSerialNumber)
+                .collect(Collectors.toList());
+        Map<String, ActivatedImei> activatedImeiMap = samsungSerialNumbers.isEmpty()
+                ? Collections.emptyMap()
+                : activatedImeiRepository.selectBySerialNumbers(samsungSerialNumbers).stream()
+                        .collect(Collectors.toMap(ActivatedImei::getSerialNumber, x -> x, (a, b) -> a));
         for (PartnerAgeingModel partnerAgeingModel : partnerAgeingModels) {
             LOGGER.info("Serial Number - {}", partnerAgeingModel.getSerialNumber());
             if (partnerAgeingModel.getBrand().equalsIgnoreCase("Samsung")) {
-                ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(partnerAgeingModel.getSerialNumber());
+                ActivatedImei activatedImei = activatedImeiMap.get(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 {
             LOGGER.info("scanRecords --- {}", scanRecords);
             LOGGER.info("inventoryItemIds --- {}", inventoryItemIds);
             if (inventoryItemIds.size() == 0) return 0;
+            // Cache blocked imeis to avoid repeated DB calls inside stream
+            Set<String> blockedImeisSet = new HashSet<>(this.getBlockedImeis());
             Set<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
                     .filter(x -> x.getSerialNumber() != null && !x.getSerialNumber().equals(""))
                     .collect(Collectors.toSet());
-            inventoryItems = inventoryItems.stream().filter(inventoryItem -> !this.getBlockedImeis().contains(inventoryItem.getSerialNumber())).collect(Collectors.toSet());
+            inventoryItems = inventoryItems.stream().filter(inventoryItem -> !blockedImeisSet.contains(inventoryItem.getSerialNumber())).collect(Collectors.toSet());
             //Do not consider imei above 90 days for samsung
             List<String> samsungSerialNumbers = inventoryItems.stream().filter(x -> x.getItem().getBrand().equalsIgnoreCase("samsung")).map(x -> x.getSerialNumber()).collect(Collectors.toList());
             if (samsungSerialNumbers.size() > 0) {
                 List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue().stream().filter(x -> x != null).collect(Collectors.toList());
                 schemeSummaryModels.stream().filter(x -> x.getSchemeType().getTransactionType().equals(StockTransactionType.OUT)).forEach(x -> x.setProcess(true));
                 if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;
+                // Create map once per catalog instead of per inventoryItem
+                Map<Integer, SchemeSummaryModel> schemeSummaryModelMap = schemeSummaryModels.stream().collect(Collectors.toMap(x -> x.getSchemeId(), x -> x));
                 List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());
                 for (InventoryItem inventoryItem : modelInventoryItems) {
-                    Map<Integer, SchemeSummaryModel> schemeSummaryModelMap = schemeSummaryModels.stream().collect(Collectors.toMap(x -> x.getSchemeId(), x -> x));
                     List<SchemeInOut> sios = schemeInOutRepository.selectAll(inventoryItem.getId());
                     List<Integer> creditedSchemeIds = sios.stream()
                             .filter(x -> x.getStatus().equals(SchemePayoutStatus.CREDITED))
                             .map(x -> x.getSchemeId()).collect(Collectors.toList());
                             //Reject invalid scheme payouts due to upgrade in Category or any change in schemes historically
                             //Lets not touchs
+                        }
                         for (SchemeInOut sio : sios) {
                             if (schemeIdsToReject.contains(sio.getSchemeId()) && !schemeSummaryModelMap.containsKey(sio.getSchemeId())) {
-                                Scheme scheme = schemeRepository.selectById(sio.getSchemeId());
+                                // Removed unused schemeRepository.selectById call
                                 sio.setStatusDescription("Rolledback due to Category upgrade/invalid scheme");
                                 sio.setStatus(SchemePayoutStatus.REJECTED);
                                 sio.setRolledBackTimestamp(LocalDateTime.now());
                                 sioRejectedValue += sio.getAmount();
+                            }
         LOGGER.info("Total Size - " + schemesImeisModels.size());
         List<Integer> orderIds = schemesImeisModels.stream().map(x -> x.getOrderId()).collect(Collectors.toList());
         List<FofoOrder> fofoOrders = fofoOrderRepository.selectAllByOrderIds(orderIds);
         Map<Integer, FofoOrder> validOrdersMap = fofoOrders.stream().filter(x -> x.getCancelledTimestamp() == null).collect(Collectors.toMap(x -> x.getId(), x -> x));
         Map<String, List<SchemesImeisModel>> validImeiSchemesModelMap = schemesImeisModels.stream().filter(x -> validOrdersMap.containsKey(x.getOrderId())).collect(Collectors.groupingBy(x -> x.getImei()));
+        // Batch fetch all inventoryItems to avoid N+1 queries
+        Set<Integer> inventoryItemIds = validImeiSchemesModelMap.values().stream()
+                .map(list -> list.get(0).getInventoryItemId())
+                .collect(Collectors.toSet());
+        Map<Integer, InventoryItem> inventoryItemsMap = inventoryItemIds.isEmpty()
+                ? Collections.emptyMap()
+                : inventoryItemRepository.selectAllByIds(new ArrayList<>(inventoryItemIds)).stream()
+                        .collect(Collectors.toMap(InventoryItem::getId, x -> x));
         for (Map.Entry<String, List<SchemesImeisModel>> imeiListEntry : validImeiSchemesModelMap.entrySet()) {
             SchemesImeisModel schemesImeisModel = imeiListEntry.getValue().get(0);
             List<Integer> schemeIds = imeiListEntry.getValue().stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
             LOGGER.info("Serial Number  - {}, Scheme IDs - {}", schemesImeisModel.getImei(), schemeIds);
-            InventoryItem inventoryItem = inventoryItemRepository.selectById(schemesImeisModel.getInventoryItemId());
+            InventoryItem inventoryItem = inventoryItemsMap.get(schemesImeisModel.getInventoryItemId());
+            if (inventoryItem == null) continue;
             List<Scheme> schemes = schemeRepository.selectBySchemeIds(schemeIds);
             List<Scheme> supportSchemes = schemes.stream().filter(x -> Arrays.asList(SchemeType.SPECIAL_SUPPORT).contains(x.getType())).collect(Collectors.toList());
             if (supportSchemes.size() > 0) {
                 for (Scheme scheme : supportSchemes) {
                     List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());

Subversion Repositories SmartDukaan

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