WebSVN – SmartDukaan – Diff – /trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/IndentController.java

         LOGGER.info("itemIds {}", itemIds);
         LOGGER.info("itemIdsWithBothStocks {}", itemIdsWithBothStocks);
         LOGGER.info("availableStockItemIds {}", availableStockItemIds);
         LOGGER.info("intransitItemIdsFiltered {}", intransitItemIdsFiltered);
+        List<Item> instockItems = new ArrayList<>();
+        if (itemIdsWithBothStocks.isEmpty() && availableStockItemIds.isEmpty() && intransitItemIdsFiltered.isEmpty()) {
+            instockItems = itemRepository.selectByIds(itemIds);
+        } else {
-        List<Item> instockItems = itemRepository.selectByIds(itemIdsWithBothStocks);
+            instockItems = itemRepository.selectByIds(itemIdsWithBothStocks);
+        }
         model.addAttribute("poItems", instockItems);
         model.addAttribute("price", price);
         return "po-catalog-items";
             return responseSender.ok(Collections.emptyList());
+        }
+    }
     @RequestMapping(value = "/indent/getOutOfStockDetails", method = RequestMethod.GET)
-    public ResponseEntity<?> getOutOfStockDetails(HttpServletRequest request, @RequestParam String brand, @RequestParam int warehouseId, Model model) throws Exception {
+    public ResponseEntity<?> getOutOfStockDetails(HttpServletRequest request, @RequestParam String brand, @RequestParam int warehouseId, @RequestParam int fofoId, Model model) throws Exception {
         try {
             // Get all catalogs for the brand with their movement status
             List<CategorisedCatalogListModel> catalogMovements = categorisedCatalogRepository.getBrandWiseCatalogMovement(brand);
             // Filter only HID, FASTMOVING, RUNNING status
             if (filteredCatalogs.isEmpty()) {
                 return responseSender.ok(Collections.emptyList());
+            }
+            // Get all catalog IDs for partner stock lookup
+            Set<Integer> allCatalogIds = filteredCatalogs.stream()
+                    .map(CategorisedCatalogListModel::getModelId)
+                    .collect(Collectors.toSet());
+            // Get partner stock for all catalogs - fetch all partner stock and map to catalog IDs
+            Map<Integer, Integer> partnerStockMap = new HashMap<>();
+            if (!allCatalogIds.isEmpty()) {
+                List<CurrentInventorySnapshot> partnerSnapshots = currentInventorySnapshotRepository.selectByFofoId(fofoId);
+                // Get item IDs from snapshots
+                Set<Integer> itemIds = partnerSnapshots.stream()
+                        .map(CurrentInventorySnapshot::getItemId)
+                        .collect(Collectors.toSet());
+                // Get items to map itemId -> catalogId
+                Map<Integer, Integer> itemToCatalogMap = new HashMap<>();
+                for (Integer itemId : itemIds) {
+                    Item item = itemRepository.selectById(itemId);
+                    if (item != null) {
+                        itemToCatalogMap.put(itemId, item.getCatalogItemId());
+                    }
+                }
+                // Group by catalog ID
+                for (CurrentInventorySnapshot snap : partnerSnapshots) {
+                    Integer catalogId = itemToCatalogMap.get(snap.getItemId());
+                    if (catalogId != null && allCatalogIds.contains(catalogId)) {
+                        partnerStockMap.merge(catalogId, snap.getAvailability(), Integer::sum);
+                    }
+                }
+            }
+            // Get GRN pending orders for partner
+            Map<Integer, Integer> grnPendingMap = new HashMap<>();
+            List<Order> pendingGrnOrders = orderRepository.selectPendingGrnOrders(fofoId);
+            for (Order order : pendingGrnOrders) {
+                int itemId = order.getLineItem().getItemId();
+                Item item = itemRepository.selectById(itemId);
+                if (item != null && allCatalogIds.contains(item.getCatalogItemId())) {
+                    grnPendingMap.merge(item.getCatalogItemId(), order.getLineItem().getQuantity(), Integer::sum);
+                }
+            }
+            // Get tag listings (DP prices) for all catalogs
+            List<Integer> catalogIdList = new ArrayList<>(allCatalogIds);
+            Map<Integer, TagListing> tagListingsMap = tagListingRepository.selectAllByCatalogIds(catalogIdList);
             List<Map<String, Object>> result = new ArrayList<>();
             for (CategorisedCatalogListModel catalogModel : filteredCatalogs) {
                 int catalogId = catalogModel.getModelId();
                 // Get all items for this catalog
                 List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);
                 List<Integer> itemIds = items.stream().map(Item::getId).collect(Collectors.toList());
+                // Get DP price from tag listings
+                TagListing tagListing = tagListingsMap.get(catalogId);
+                double dpPrice = tagListing != null ? tagListing.getSellingPrice() : 0;
                 if (itemIds.isEmpty()) {
                     // No items means out of stock for this model
                     Map<String, Object> itemDetail = new HashMap<>();
                     itemDetail.put("catalogId", catalogId);
                     itemDetail.put("modelNumber", catalogModel.getModelNumber());
                     itemDetail.put("status", catalogModel.getCurrentStatus().getValue());
                     itemDetail.put("qty", 0);
+                    itemDetail.put("partnerCurrentQty", partnerStockMap.getOrDefault(catalogId, 0) + grnPendingMap.getOrDefault(catalogId, 0));
+                    itemDetail.put("dp", dpPrice);
                     result.add(itemDetail);
                     continue;
+                }
                 // Get saholic stock for these items
                     Map<String, Object> itemDetail = new HashMap<>();
                     itemDetail.put("catalogId", catalogId);
                     itemDetail.put("modelNumber", catalogModel.getModelNumber());
                     itemDetail.put("status", catalogModel.getCurrentStatus().getValue());
                     itemDetail.put("qty", totalNetAvailability);
+                    itemDetail.put("partnerCurrentQty", partnerStockMap.getOrDefault(catalogId, 0) + grnPendingMap.getOrDefault(catalogId, 0));
+                    itemDetail.put("dp", dpPrice);
                     result.add(itemDetail);
+                }
+            }
             return responseSender.ok(result);
         } catch (Exception e) {
-            LOGGER.error("Error getting out of stock details for brand: {} warehouseId: {}", brand, warehouseId, e);
+            LOGGER.error("Error getting out of stock details for brand: {} warehouseId: {} fofoId: {}", brand, warehouseId, fofoId, e);
             return responseSender.ok(Collections.emptyList());
+        }
+    }
     @Autowired
                 partnerWarehouseStockAgingSummaryModelList.stream().collect(Collectors.groupingBy(
                         PartnerWarehouseStockAgingSummaryModel::getBrand,
                         Collectors.groupingBy(PartnerWarehouseStockAgingSummaryModel::getStatus)
                 ));
 //map of list as hid,fast,slow and other in last otherwise other is coming in start (here is using status order)
+        // Also sort items alphabetically by model number within each status group
         Map<String, Map<String, List<PartnerWarehouseStockAgingSummaryModel>>> sortedBrandStatusWiseStockListMap =
                 brandStatusWiseStockListMap.entrySet().stream().collect(Collectors.toMap(
                         Map.Entry::getKey, // Key (Brand)
                         entry -> {
                             Map<String, List<PartnerWarehouseStockAgingSummaryModel>> sortedStatusMap = entry.getValue().entrySet().stream()
                                             statusOrder.indexOf(e1.getKey()),
                                             statusOrder.indexOf(e2.getKey())
                                     ))
                                     .collect(Collectors.toMap(
                                             Map.Entry::getKey,
-                                            Map.Entry::getValue,
+                                            e -> e.getValue().stream()
+                                                    .sorted(Comparator.comparing(PartnerWarehouseStockAgingSummaryModel::getModelNumber, String.CASE_INSENSITIVE_ORDER))
+                                                    .collect(Collectors.toList()),
                                             (v1, v2) -> v1,
                                             LinkedHashMap::new // Ensure ordering is maintained
                                     ));
                             return sortedStatusMap;
                         },

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/IndentController.java – Rev 35776 → 35782