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

 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
 import com.spice.profitmandi.common.model.*;
 import com.spice.profitmandi.common.util.FileUtil;
 import com.spice.profitmandi.common.util.Utils;
 import com.spice.profitmandi.common.util.Utils.Attachment;
+import com.spice.profitmandi.common.web.util.ResponseSender;
 import com.spice.profitmandi.dao.entity.auth.AuthUser;
 import com.spice.profitmandi.dao.entity.catalog.Category;
 import com.spice.profitmandi.dao.entity.catalog.FocusedModel;
 import com.spice.profitmandi.dao.entity.catalog.Item;
 import com.spice.profitmandi.dao.entity.catalog.TagListing;
     @Autowired
     private JavaMailSender googleMailSender;
     @Autowired
+    private ResponseSender responseSender;
+    @Autowired
     private CookiesProcessor cookiesProcessor;
     @Autowired
     private UserWalletRepository userWalletRepository;
         CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
         Map<Integer, Integer> processingOrderMap = null;
         Map<Integer, Integer> catalogIdAndQtyMap = null;
         Map<Integer, Integer> grnPendingOrdersMap = null;
-        Map<String, Set<PartnerStockDescriptionModel>> brandToUniqueItemsMap = new HashMap<>();
+        Map<String, Set<PartnerStockDetailModel>> brandToUniqueItemsMap = new HashMap<>();
-        List<PartnerStockDescriptionModel> inStocks = new ArrayList<>();
+        List<PartnerStockDetailModel> inStocks = new ArrayList<>();
-        Map<String, PartnerStockDescriptionModel> inStocksDescriptionModelMap = new HashMap<>();
+        Map<String, PartnerStockDetailModel> inStocksDescriptionModelMap = new HashMap<>();
-        List<PartnerStockDescriptionModel> grnPendings = new ArrayList<>();
+        List<PartnerStockDetailModel> grnPendings = new ArrayList<>();
-        Map<String, PartnerStockDescriptionModel> grnPendingsDescriptionModelMap = new HashMap<>();
+        Map<String, PartnerStockDetailModel> grnPendingsDescriptionModelMap = new HashMap<>();
-        List<PartnerStockDescriptionModel> pendingIndents = new ArrayList<>();
+        List<PartnerStockDetailModel> pendingIndents = new ArrayList<>();
-        Map<String, PartnerStockDescriptionModel> pendingIndentsDescriptionModelMap = new HashMap<>();
+        Map<String, PartnerStockDetailModel> pendingIndentsDescriptionModelMap = new HashMap<>();
         Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)
                 .stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
         if (!currentInventorySnapshot.isEmpty()) {
             catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
                     .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
                             Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
-            inStocks.addAll(getBrandItemwiseDescription(brand, catalogIdAndQtyMap));
+            inStocks.addAll(getBrandItemwiseDetail(brand, catalogIdAndQtyMap));
             inStocksDescriptionModelMap = inStocks.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
+        }
         Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()
                 .collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
                         Collectors.summingInt(x -> x.getLineItem().getQuantity())));
         if (!grnPendingOrders.isEmpty()) {
             grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
                     .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
                             Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
-            grnPendings.addAll(getBrandItemwiseDescription(brand, grnPendingOrdersMap));
+            grnPendings.addAll(getBrandItemwiseDetail(brand, grnPendingOrdersMap));
             grnPendingsDescriptionModelMap = grnPendings.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
+        }
         Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoId, orderStatusList).stream()
                         Collectors.summingInt(x -> x.getLineItem().getQuantity())));
         if (!processingOrder.isEmpty()) {
             processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
                     .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
                             Collectors.summingInt(x -> processingOrder.get(x.getId()))));
-            pendingIndents.addAll(getBrandItemwiseDescription(brand, processingOrderMap));
+            pendingIndents.addAll(getBrandItemwiseDetail(brand, processingOrderMap));
             pendingIndentsDescriptionModelMap = pendingIndents.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
+        }
         List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
+            }
+        }
-        List<PartnerStockDescriptionModel> allStockItems = new ArrayList<>();
+        List<PartnerStockDetailModel> allStockItems = new ArrayList<>();
         allStockItems.addAll(inStocks);
         allStockItems.addAll(grnPendings);
         allStockItems.addAll(pendingIndents);
         LOGGER.info("allStockItems {}", allStockItems);
         brandToUniqueItemsMap =
                 allStockItems.stream().collect(
                         Collectors.groupingBy(
-                                PartnerStockDescriptionModel::getBrand,
+                                PartnerStockDetailModel::getBrand,
                                 Collectors.toSet()
+                        )
                 );
         model.addAttribute("inStocks", inStocks);
         model.addAttribute("inStocksDescriptionModelMap", inStocksDescriptionModelMap);
         model.addAttribute("brandToUniqueItemsMap", brandToUniqueItemsMap);
+        model.addAttribute("fofoId", fofoId);
         model.addAttribute("grnPendings", grnPendings);
         model.addAttribute("grnPendingsDescriptionModelMap", grnPendingsDescriptionModelMap);
         model.addAttribute("pendingIndents", pendingIndents);
         if (brand.equals("undefined")) {
             Map<String, List<FocusedModelShortageModel>> focusedModelShortageBrandMap = focusedModelShortageList
                     .stream().collect(Collectors.groupingBy(x -> x.getBrandName()));
-            Map<String, List<PartnerStockDescriptionModel>> inStockBrandMap = inStocks.stream()
+            Map<String, List<PartnerStockDetailModel>> inStockBrandMap = inStocks.stream()
                     .collect(Collectors.groupingBy(x -> x.getBrand()));
             LOGGER.info("inStockBrandMap" + inStockBrandMap);
-            Map<String, List<PartnerStockDescriptionModel>> grnPendingBrandMap = grnPendings.stream()
+            Map<String, List<PartnerStockDetailModel>> grnPendingBrandMap = grnPendings.stream()
                     .collect(Collectors.groupingBy(x -> x.getBrand()));
             LOGGER.info("grnPendingBrandMap" + grnPendingBrandMap);
-            Map<String, List<PartnerStockDescriptionModel>> pendingIndentBrandMap = pendingIndents.stream()
+            Map<String, List<PartnerStockDetailModel>> pendingIndentBrandMap = pendingIndents.stream()
                     .collect(Collectors.groupingBy(x -> x.getBrand()));
             LOGGER.info("pendingIndentBrandMap" + pendingIndentBrandMap);
             model.addAttribute("inStockBrandMap", inStockBrandMap);
         return "po-catalog-items";
+    }
+    @RequestMapping(value = "/getItemsByCatalog", method = RequestMethod.GET)
+    public ResponseEntity<?> getItemsByCatalog(HttpServletRequest request, @RequestParam int catalogId, @RequestParam int fofoId, Model model)
+            throws Exception {
+        List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);
+        Set<Integer> itemSet = items.stream().map(x -> x.getId()).collect(Collectors.toSet());
+        List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository.selectByFofoItemIds(fofoId, itemSet);
+        model.addAttribute("currentInventorySnapshots", currentInventorySnapshots);
+        return responseSender.ok(currentInventorySnapshots);
+    }
     @RequestMapping(value = "/getPartnerShortageStock", method = RequestMethod.GET)
     public String getPartnerShortageStock(HttpServletRequest request,
                                           @RequestParam(required = false, defaultValue = "") String brand, @RequestParam(required = false, defaultValue = "0") long shortInvest, @RequestParam int fofoId, Model model)
         List<Integer> catalogsList = new ArrayList<>(catalogIds);
         Map<Integer, TagListing> tagListingsMap = tagListingRepository.selectAllByCatalogIds(catalogsList);
-        List<DateWiseSoldCatalogQtyModel> sevenDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, catalogIds, presentDate.minusDays(7));
+        List<DateWiseSoldCatalogQtyModel> sevenDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, presentDate.minusDays(7));
-        List<DateWiseSoldCatalogQtyModel> fourteenDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, catalogIds, presentDate.minusDays(14));
+        List<DateWiseSoldCatalogQtyModel> fourteenDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, presentDate.minusDays(14));
-        List<DateWiseSoldCatalogQtyModel> twentyOneDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, catalogIds, presentDate.minusDays(21));
+        List<DateWiseSoldCatalogQtyModel> twentyOneDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, presentDate.minusDays(21));
         LOGGER.info("twentyOneDayAboveSoldsCatalogs {}", twentyOneDayAboveSoldsCatalogs);
-        List<DateWiseSoldCatalogQtyModel> twentyEightDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, catalogIds, presentDate.minusDays(28));
+        List<DateWiseSoldCatalogQtyModel> twentyEightDayAboveSoldsCatalogs = fofoOrderRepository.getDateWiseSoldCatalogQty(fofoId, presentDate.minusDays(28));
         List<CatalogAgingModel> catalogAgingModels = ageingService.getCatalogsAgingByWarehouse(catalogIds, fofoStore.getWarehouseId());
         Map<Integer, CatalogAgingModel> catalogAgingModelMap = catalogAgingModels.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
                             return sortedStatusMap;
                         },
                         (v1, v2) -> v1,
                         LinkedHashMap::new // Maintain order of brands
                 ));
+        LOGGER.info("brandToMtdMap {}", brandToMtdMap);
         List<String> sortedBrandsByMtd = brandToMtdMap.entrySet()
                 .stream()
                 .sorted((e1, e2) -> Long.compare(e2.getValue(), e1.getValue())) // Descending MTD
                 .map(Map.Entry::getKey)
                 .collect(Collectors.toList());
                 .filter(x -> !sortedBrandStatusWiseStockListMap.containsKey(x)) // no stock
                 .collect(Collectors.toList());
         List<String> finalSortedBrands = new ArrayList<>();
         finalSortedBrands.addAll(sortedBrandsByMtd);
-        finalSortedBrands.addAll(remainingBrands);
+//        finalSortedBrands.addAll(remainingBrands);
-        finalSortedBrands.addAll(remainingBrandsWithoutStock);
+//        finalSortedBrands.addAll(remainingBrandsWithoutStock);
         Map<Integer, Integer> processingOrderMap = null;
         List<PartnerStockDetailModel> pendingIndents = new ArrayList<>();
         Map<Integer, PartnerStockDetailModel> pendingIndentsDetailMap = new HashMap<>();

Subversion Repositories SmartDukaan

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