WebSVN – SmartDukaan – Diff – /trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/ScheduledTasks.java

         // throw new Exception();
+    }
     public void checkfocusedModelInPartnerStock() throws Exception {
-        //List<FofoStore> fofoStores = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive()).limit(20).collect(Collectors.toList());
+        // ========== PHASE 1: Batch fetch all data upfront ==========
-        Map<Integer, FofoStore> fofoStoreMap = fofoStoreRepository.selectActiveStores().stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+        Map<Integer, FofoStore> fofoStoreMap = fofoStoreRepository.selectActiveStores().stream()
+                .collect(Collectors.toMap(FofoStore::getId, x -> x));
+        List<Integer> allPartnerIds = new ArrayList<>(fofoStoreMap.keySet());
         Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap = saholicInventoryService.getSaholicStock();
         Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
         Map<Integer, FofoReportingModel> partnerIdSalesHeadersMap = this.getPartnerIdSalesHeaders();
-        Map<Integer, List<FocusedModel>> regionFocusedModelsMap = focusedModelRepository.selectAll().stream().collect(Collectors.groupingBy(x -> x.getRegionId()));
+        Map<Integer, List<FocusedModel>> regionFocusedModelsMap = focusedModelRepository.selectAll().stream()
+                .collect(Collectors.groupingBy(FocusedModel::getRegionId));
-        LOGGER.info("/ - {}", regionFocusedModelsMap);
+        LOGGER.info("regionFocusedModelsMap - {}", regionFocusedModelsMap);
         Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap = saholicInventoryService.getSaholicPOItems();
+        // Batch fetch all customRetailers upfront
+        Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(allPartnerIds);
+        LOGGER.info("Fetched {} customRetailers", customRetailerMap.size());
+        // Batch fetch all inventory snapshots upfront
+        Map<Integer, List<CurrentInventorySnapshot>> allInventorySnapshotsMap = currentInventorySnapshotRepository
+                .selectByFofoId(allPartnerIds).stream()
+                .collect(Collectors.groupingBy(CurrentInventorySnapshot::getFofoId));
+        LOGGER.info("Fetched inventory snapshots for {} partners", allInventorySnapshotsMap.size());
+        // Batch fetch all pending GRN orders upfront
+        Map<Integer, List<Order>> allGrnPendingOrdersMap = orderRepository.selectPendingGrnOrders(allPartnerIds).stream()
+                .collect(Collectors.groupingBy(Order::getRetailerId));
+        LOGGER.info("Fetched GRN pending orders for {} partners", allGrnPendingOrdersMap.size());
+        // Batch fetch all processing orders upfront
+        Map<Integer, List<Order>> allProcessingOrdersMap = orderRepository.selectOrders(allPartnerIds, orderStatusList).stream()
+                .collect(Collectors.groupingBy(Order::getRetailerId));
+        LOGGER.info("Fetched processing orders for {} partners", allProcessingOrdersMap.size());
+        // Collect all focused catalog IDs
-        Map<Integer, List<FocusedModelShortageModel>> focusedModelShortageReportMap = new HashMap<>();
+        Set<Integer> allFocusedCatalogIds = regionFocusedModelsMap.values().stream()
+                .flatMap(List::stream)
+                .map(FocusedModel::getCatalogId)
+                .collect(Collectors.toSet());
+        // Batch fetch all items by catalog IDs upfront
-        //Map<Integer,List<Integer>> partnerRegionMap = partnerRegionRepository.selectAll().stream().collect(Collectors.groupingBy(x->x.getFofoId(),Collectors.mapping(x->x.getRegionId(),Collectors.toList())));
+        Map<Integer, List<Item>> itemsByCatalogIdMap = itemRepository.selectAllByCatalogIds(allFocusedCatalogIds).stream()
+                .collect(Collectors.groupingBy(Item::getCatalogItemId));
+        LOGGER.info("Fetched items for {} catalog IDs", itemsByCatalogIdMap.size());
+        // Batch fetch all tagListings by catalog IDs upfront
+        Map<Integer, TagListing> tagListingByCatalogIdMap = tagListingRepository
+                .selectAllByCatalogIds(new ArrayList<>(allFocusedCatalogIds));
+        LOGGER.info("Fetched {} tagListings", tagListingByCatalogIdMap.size());
+        // Collect all item IDs from inventory, GRN orders, and processing orders for batch item lookup
+        Set<Integer> allItemIds = new HashSet<>();
+        allInventorySnapshotsMap.values().forEach(list ->
+                list.forEach(cis -> allItemIds.add(cis.getItemId())));
+        allGrnPendingOrdersMap.values().forEach(orders ->
+                orders.forEach(o -> allItemIds.add(o.getLineItem().getItemId())));
+        allProcessingOrdersMap.values().forEach(orders ->
+                orders.forEach(o -> allItemIds.add(o.getLineItem().getItemId())));
+        // Batch fetch all items and create itemId -> catalogId mapping
+        Map<Integer, Integer> itemIdToCatalogIdMap = new HashMap<>();
+        if (!allItemIds.isEmpty()) {
+            itemRepository.selectByIds(allItemIds).forEach(item ->
+                    itemIdToCatalogIdMap.put(item.getId(), item.getCatalogItemId()));
+        }
+        LOGGER.info("Built itemId->catalogId mapping for {} items", itemIdToCatalogIdMap.size());
+        // ========== PHASE 2: Build partner region mappings ==========
         Map<Integer, Set<Integer>> partnerToRegions = partnerRegionRepository.selectAll().stream()
                 .collect(Collectors.groupingBy(
                         pr -> pr.getFofoId(),
                         Collectors.mapping(pr -> pr.getRegionId(), Collectors.toSet())
                 ));
         Map<Set<Integer>, List<Integer>> regionPartnerMap = partnerToRegions.entrySet().stream()
                 .collect(Collectors.groupingBy(
                         Map.Entry::getValue,
                         Collectors.mapping(Map.Entry::getKey, Collectors.toList())
                 ));
-        LOGGER.info("regionPartnerMap  - {}", regionPartnerMap.keySet());
+        LOGGER.info("regionPartnerMap - {}", regionPartnerMap.keySet());
+        // ========== PHASE 3: Process partners using pre-fetched data ==========
+        Map<Integer, List<FocusedModelShortageModel>> focusedModelShortageReportMap = new HashMap<>();
         for (Map.Entry<Set<Integer>, List<Integer>> regionPartnerEntry : regionPartnerMap.entrySet()) {
-            //LOGGER.info("regionPartnerEntry - {}", regionPartnerEntry.getKey());
             Set<Integer> regionIds = regionPartnerEntry.getKey();
-            List<Integer> partnerIds = regionPartnerEntry.getValue();
+            List<Integer> partnerIds = new ArrayList<>(regionPartnerEntry.getValue());
             if (regionIds.stream().anyMatch(x -> !regionFocusedModelsMap.containsKey(x))) continue;
-            LOGGER.info("regionIds" + regionIds);
+            LOGGER.info("Processing regionIds: {}", regionIds);
-            if (regionIds == null || regionIds.size() == 0) {
+            if (regionIds == null || regionIds.isEmpty()) {
                 LOGGER.info("No region found for partner {}", partnerIds);
                 continue;
+            }
             if (regionIds.contains(5)) {
                 partnerIds.addAll(fofoStoreMap.keySet());
+            }
-            Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = regionIds.stream().map(regionFocusedModelsMap::get).flatMap(x -> x != null ? x.stream() : Stream.empty())
+            Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = regionIds.stream()
+                    .map(regionFocusedModelsMap::get)
+                    .flatMap(x -> x != null ? x.stream() : Stream.empty())
-                    .collect(groupingBy(FocusedModel::getCatalogId, mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));
+                    .collect(groupingBy(FocusedModel::getCatalogId,
-            //LOGGER.info("focusedCatalogIdAndQtyMap {}",focusedCatalogIdAndQtyMap);
+                            mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));
-            if (focusedCatalogIdAndQtyMap.size() == 0) continue;
+            if (focusedCatalogIdAndQtyMap.isEmpty()) continue;
             for (int partnerId : partnerIds) {
                 if (partnerId == 0) continue;
                 FofoStore fofoStore = fofoStoreMap.get(partnerId);
-                List<FocusedModelShortageModel> focusedModelShortageList = new ArrayList<>();
-                focusedModelShortageReportMap.put(fofoStore.getId(), focusedModelShortageList);
-                LOGGER.info("Before retailerService.getFofoRetailer(fofoId)");
-                CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoStore.getId());
-                LOGGER.info("After retailerService.getFofoRetailer(fofoId)");
-                Map<Integer, Integer> processingOrderMap = null;
-                Map<Integer, Integer> catalogIdAndQtyMap = null;
+                if (fofoStore == null) continue;
-                Map<Integer, Integer> grnPendingOrdersMap = null;
-                Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoStore.getId()).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
+                CustomRetailer customRetailer = customRetailerMap.get(partnerId);
+                if (customRetailer == null) continue;
-                if (!currentInventorySnapshot.isEmpty()) {
+                List<FocusedModelShortageModel> focusedModelShortageList = new ArrayList<>();
-                    catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream().collect(groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
+                focusedModelShortageReportMap.put(fofoStore.getId(), focusedModelShortageList);
+                // Build catalogIdAndQtyMap from pre-fetched inventory snapshots
+                Map<Integer, Integer> catalogIdAndQtyMap = new HashMap<>();
+                List<CurrentInventorySnapshot> inventorySnapshots = allInventorySnapshotsMap.get(partnerId);
+                if (inventorySnapshots != null) {
+                    Map<Integer, Integer> itemQtyMap = inventorySnapshots.stream()
+                            .collect(Collectors.toMap(CurrentInventorySnapshot::getItemId, CurrentInventorySnapshot::getAvailability));
+                    for (Map.Entry<Integer, Integer> e : itemQtyMap.entrySet()) {
+                        Integer catalogId = itemIdToCatalogIdMap.get(e.getKey());
+                        if (catalogId != null) {
+                            catalogIdAndQtyMap.merge(catalogId, e.getValue(), Integer::sum);
+                        }
+                    }
+                }
+                // Build grnPendingOrdersMap from pre-fetched orders
-                Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoStore.getId()).stream().collect(groupingBy(x -> x.getLineItem().getItemId(), Collectors.summingInt(x -> x.getLineItem().getQuantity())));
+                Map<Integer, Integer> grnPendingOrdersMap = new HashMap<>();
+                List<Order> grnOrders = allGrnPendingOrdersMap.get(partnerId);
-                if (!grnPendingOrders.isEmpty()) {
+                if (grnOrders != null) {
+                    for (Order order : grnOrders) {
+                        Integer catalogId = itemIdToCatalogIdMap.get(order.getLineItem().getItemId());
+                        if (catalogId != null) {
-                    grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream().collect(groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
+                            grnPendingOrdersMap.merge(catalogId, order.getLineItem().getQuantity(), Integer::sum);
+                        }
+                    }
+                }
+                // Build processingOrderMap from pre-fetched orders
+                Map<Integer, Integer> processingOrderMap = new HashMap<>();
-                Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoStore.getId(), orderStatusList).stream().collect(groupingBy(x -> x.getLineItem().getItemId(), Collectors.summingInt(x -> x.getLineItem().getQuantity())));
+                List<Order> processingOrders = allProcessingOrdersMap.get(partnerId);
-                if (!processingOrder.isEmpty()) {
+                if (processingOrders != null) {
+                    for (Order order : processingOrders) {
+                        Integer catalogId = itemIdToCatalogIdMap.get(order.getLineItem().getItemId());
+                        if (catalogId != null) {
-                    processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream().collect(groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> processingOrder.get(x.getId()))));
+                            processingOrderMap.merge(catalogId, order.getLineItem().getQuantity(), Integer::sum);
+                        }
+                    }
+                }
+                Map<Integer, List<SaholicCIS>> itemAvailabilityMap = warehouseItemAvailabilityMap.get(fofoStore.getWarehouseId());
-                //Map<String, RetailerBlockBrands> retailerBlockBrands = retailerBlockBrandsRepository.selectAllByRetailer(fofoId).stream().collect(Collectors.toMap(x -> x.getBlockBrands(), x -> x));
+                Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = warehousePoItemAvailabilityMap.get(fofoStore.getWarehouseId());
                 for (Entry<Integer, Optional<Integer>> entry : focusedCatalogIdAndQtyMap.entrySet()) {
-                    int minQty = entry.getValue().get();
+                    int catalogId = entry.getKey();
-                    int inStockQty = 0;
-                    int processingQty = 0;
-                    int grnPendingQty = 0;
+                    int minQty = entry.getValue().orElse(0);
-                    int allColorNetAvailability = 0;
+                    int inStockQty = catalogIdAndQtyMap.getOrDefault(catalogId, 0);
-                    int allColorPoAvailability = 0;
-                    if (processingOrderMap != null) {
-                        processingQty = (processingOrderMap.get(entry.getKey()) == null) ? 0 : processingOrderMap.get(entry.getKey());
+                    int processingQty = processingOrderMap.getOrDefault(catalogId, 0);
-                    }
-                    if (grnPendingOrdersMap != null) {
+                    int grnPendingQty = grnPendingOrdersMap.getOrDefault(catalogId, 0);
-                        grnPendingQty = (grnPendingOrdersMap.get(entry.getKey()) == null) ? 0 : grnPendingOrdersMap.get(entry.getKey());
-                    }
-                    if (catalogIdAndQtyMap != null) {
-                        inStockQty = (catalogIdAndQtyMap.get(entry.getKey()) == null) ? 0 : catalogIdAndQtyMap.get(entry.getKey());
-                    }
                     int grnStockQty = grnPendingQty + inStockQty;
                     int totalQty = processingQty + grnPendingQty + inStockQty;
                     int shortageQty = minQty - totalQty;
-                    List<Item> items = itemRepository.selectAllByCatalogItemId(entry.getKey());
-                    TagListing tagListing = tagListingRepository.selectByCatalogId(entry.getKey());
+                    // Use pre-fetched items
+                    List<Item> items = itemsByCatalogIdMap.get(catalogId);
+                    if (items == null || items.isEmpty()) continue;
+                    // Use pre-fetched tagListing
-                    Map<Integer, List<SaholicCIS>> itemAvailabilityMap = warehouseItemAvailabilityMap.get(fofoStore.getWarehouseId());
+                    TagListing tagListing = tagListingByCatalogIdMap.get(catalogId);
+                    if (tagListing == null) continue;
-                    Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = warehousePoItemAvailabilityMap.get(fofoStore.getWarehouseId());
+                    int allColorNetAvailability = 0;
+                    int allColorPoAvailability = 0;
                     for (Item item : items) {
-                        List<SaholicCIS> currentAvailability = null;
-                        List<SaholicPOItem> poItemAvailability = null;
                         if (itemAvailabilityMap != null) {
-                            currentAvailability = itemAvailabilityMap.get(item.getId());
+                            List<SaholicCIS> currentAvailability = itemAvailabilityMap.get(item.getId());
+                            if (currentAvailability != null) {
+                                allColorNetAvailability += currentAvailability.stream()
+                                        .mapToInt(SaholicCIS::getNetavailability).sum();
+                            }
+                        }
                         if (poItemAvailabilityMap != null) {
-                            poItemAvailability = poItemAvailabilityMap.get(item.getId());
+                            List<SaholicPOItem> poItemAvailability = poItemAvailabilityMap.get(item.getId());
-                        }
+                            if (poItemAvailability != null) {
-                        if (currentAvailability != null) {
+                                allColorPoAvailability += poItemAvailability.stream()
-                            allColorNetAvailability += currentAvailability.stream().collect(Collectors.summingInt(SaholicCIS::getNetavailability));
+                                        .mapToInt(SaholicPOItem::getUnfulfilledQty).sum();
-                        }
+                            }
-                        if (poItemAvailability != null) {
-                            allColorPoAvailability += poItemAvailability.stream().collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty));
+                        }
+                    }
                     FocusedModelShortageModel fm = new FocusedModelShortageModel();
                     fm.setFofoId(fofoStore.getId());
                     fm.setStoreCode(fofoStore.getCode());
                     fm.setPendingIndentQty(processingQty);
                     fm.setShortageQty(shortageQty);
                     fm.setPoAvailability(allColorPoAvailability);
                     fm.setDp(tagListing.getSellingPrice());
                     fm.setWarehouseName(warehouseMap.get(customRetailer.getWarehouseId()));
+                    // FIX: Use fofoStore.getId() instead of fofoStore object as key
-                    if (partnerIdSalesHeadersMap.get(fofoStore) != null) {
+                    FofoReportingModel reportingModel = partnerIdSalesHeadersMap.get(fofoStore.getId());
+                    if (reportingModel != null) {
-                        fm.setStateManager(partnerIdSalesHeadersMap.get(fofoStore).getRegionalManager());
+                        fm.setStateManager(reportingModel.getRegionalManager());
-                        fm.setTerritoryManager(partnerIdSalesHeadersMap.get(fofoStore).getTerritoryManager());
+                        fm.setTerritoryManager(reportingModel.getTerritoryManager());
                     } else {
                         fm.setStateManager("");
                         fm.setTerritoryManager("");
+                    }
                     fm.setItemName(items.get(0).getBrand() + items.get(0).getModelNumber() + items.get(0).getModelName());
                     fm.setAvailability(allColorNetAvailability);
                     focusedModelShortageList.add(fm);
+                }
+            }
+        }
+        // ========== PHASE 4: Send emails ==========
-        LOGGER.info("focusedModelShortageReportMap {}", focusedModelShortageReportMap);
+        LOGGER.info("focusedModelShortageReportMap size: {}", focusedModelShortageReportMap.size());
         if (!focusedModelShortageReportMap.isEmpty()) {
             String fileName = "Stock Alert-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv";
             Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();
             Map<String, List<List<?>>> emailRowsMap = new HashMap<>();
-            //String email = "tarun.verma@smartdukaan.com";
-            focusedModelShortageReportMap.entrySet().forEach(x -> {
-                storeGuyMap.entrySet().stream()
-                        //.filter(entry->entry.getKey().equals(email))
-                        .forEach(y -> {
-                            if (y.getValue().contains(x.getKey())) {
-                                if (!emailRowsMap.containsKey(y.getKey())) {
-                                    emailRowsMap.put(y.getKey(), new ArrayList<>());
-                                }
-                                List<List<? extends Serializable>> fms = x.getValue().stream().map(r -> Arrays.asList(r.getStoreCode(), r.getStoreName(), r.getBrandName(), r.getModelName(), r.getModelNumber(), r.getDp(), r.getWarehouseName(), r.getStateManager(), r.getTerritoryManager(), r.getPendingIndentQty(), r.getGrnStockQty(), r.getShortageQty(), r.getAvailability())).collect(Collectors.toList());
-                                emailRowsMap.get(y.getKey()).addAll(fms);
-                            }
-                        });
+            for (Map.Entry<Integer, List<FocusedModelShortageModel>> x : focusedModelShortageReportMap.entrySet()) {
-            });
+                for (Map.Entry<String, Set<Integer>> y : storeGuyMap.entrySet()) {
-            //LOGGER.info("emailRowsMap {}", emailRowsMap);
+                    if (y.getValue().contains(x.getKey())) {
-            List<String> headers = Arrays.asList("Store Code", "Store Name", "Brand", "Model Name", "Model Number", "DP", "Warehouse Name", "State Manager", "Territory Manager", "Pending Indent", "InStock", "Shortage Qty", "Availability");
+                        emailRowsMap.computeIfAbsent(y.getKey(), k -> new ArrayList<>());
-            emailRowsMap.entrySet().forEach(entry -> {
+                        List<List<? extends Serializable>> fms = x.getValue().stream()
-                ByteArrayOutputStream baos = null;
+                                .map(r -> Arrays.asList(r.getStoreCode(), r.getStoreName(), r.getBrandName(),
+                                        r.getModelName(), r.getModelNumber(), r.getDp(), r.getWarehouseName(),
-                try {
+                                        r.getStateManager(), r.getTerritoryManager(), r.getPendingIndentQty(),
-                    baos = FileUtil.getCSVByteStream(headers, entry.getValue());
+                                        r.getGrnStockQty(), r.getShortageQty(), r.getAvailability()))
-                } catch (Exception e2) {
+                                .collect(Collectors.toList());
+                        emailRowsMap.get(y.getKey()).addAll(fms);
-                    e2.printStackTrace();
+                    }
+                }
-                String[] sendToArray = new String[]{entry.getKey()};
+            }
+            List<String> headers = Arrays.asList("Store Code", "Store Name", "Brand", "Model Name", "Model Number",
+                    "DP", "Warehouse Name", "State Manager", "Territory Manager", "Pending Indent", "InStock",
+                    "Shortage Qty", "Availability");
+            for (Map.Entry<String, List<List<?>>> entry : emailRowsMap.entrySet()) {
                 try {
+                    ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, entry.getValue());
+                    String[] sendToArray = new String[]{entry.getKey()};
-                    Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Stock Alert", "PFA", fileName, new ByteArrayResource(baos.toByteArray()));
+                    Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Stock Alert", "PFA",
-                } catch (Exception e1) { // TODO Auto-generated catch block
+                            fileName, new ByteArrayResource(baos.toByteArray()));
-                    e1.printStackTrace();
+                } catch (Exception e) {
+                    LOGGER.error("Failed to send email to {}", entry.getKey(), e);
+                }
-            });
+            }
+        }
+    }
     private String getNotificationMessage(List<FocusedModelShortageModel> focusedModelShortageModel) {
         StringBuilder sb = new StringBuilder();

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/ScheduledTasks.java – Rev 35424 → 35442