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

                 LOGGER.info("chartMap" + gson.toJson(cm));
                 model.addAttribute("chartMap", gson.toJson(cm));
                 List<CreateOfferRequest> createOffers = offerService.getPublishedOffers(loginDetails.getFofoId(), YearMonth.from(LocalDateTime.now()));
-                List<CreateOfferRequest> publishedOffers = null;
+                // Batch fetch all catalog IDs to avoid N+1 queries
-                publishedOffers = createOffers.stream().filter(createOffer -> createOffer.getTargetSlabs().stream()
+                Set<Integer> allCatalogIds = createOffers.stream()
-                        .map(x -> x.getItemCriteriaPayouts())
+                        .flatMap(offer -> offer.getTargetSlabs().stream())
-                        .flatMap(List::stream)
+                        .flatMap(slab -> slab.getItemCriteriaPayouts().stream())
                         .map(ItemCriteriaPayout::getItemCriteria)
-                        .map(ItemCriteria::getCatalogIds)
+                        .flatMap(criteria -> criteria.getCatalogIds().stream())
-                        .flatMap(List::stream)
+                        .collect(Collectors.toSet());
+                final Map<Integer, String> catalogBrandMap = new HashMap<>();
+                if (!allCatalogIds.isEmpty()) {
+                    try {
-                        .noneMatch(catalogId -> catalogRepository.selectCatalogById(catalogId).getBrand().equals("Live Demo"))).collect(Collectors.toList());
+                        catalogBrandMap.putAll(catalogRepository.selectAllByIds(new ArrayList<>(allCatalogIds)).stream()
+                                .collect(Collectors.toMap(c -> c.getId(), c -> c.getBrand())));
+                    } catch (ProfitMandiBusinessException e) {
+                        LOGGER.error("Error fetching catalogs by IDs", e);
+                    }
+                }
+                List<CreateOfferRequest> publishedOffers = createOffers.stream()
+                        .filter(createOffer -> createOffer.getTargetSlabs().stream()
+                                .flatMap(slab -> slab.getItemCriteriaPayouts().stream())
+                                .map(ItemCriteriaPayout::getItemCriteria)
+                                .flatMap(criteria -> criteria.getCatalogIds().stream())
+                                .noneMatch(catalogId -> "Live Demo".equals(catalogBrandMap.get(catalogId))))
+                        .collect(Collectors.toList());
                 model.addAttribute("publishedOffers", publishedOffers);
                 model.addAttribute("investments", fofoUser.getInvestments(loginDetails.getFofoId()));
                 model.addAttribute("isInvestmentOk", partnerInvestmentService.isInvestmentOk(loginDetails.getFofoId(), ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE, ProfitMandiConstants.CUTOFF_INVESTMENT));
         LOGGER.info("params" + fofoId + brand + yearMonth);
         List<ActivationItemDetailModel> activationItemDetails = schemeInOutRepository.selectBrandPendingActivationItemDetails(fofoId, brand, yearMonth);
+        if (!activationItemDetails.isEmpty()) {
+            // Batch fetch to avoid N+1 queries
-        for (ActivationItemDetailModel activationItemDetail : activationItemDetails) {
+            List<Integer> inventoryItemIds = activationItemDetails.stream()
-            List<FofoLineItem> flis = fofoLineItemRepository.selectByInventoryItemId(activationItemDetail.getInventoryItemId());
+                    .map(ActivationItemDetailModel::getInventoryItemId)
-            LOGGER.info("flis" + flis);
+                    .collect(Collectors.toList());
+            Map<Integer, List<FofoLineItem>> lineItemsByInventoryId;
+            try {
+                lineItemsByInventoryId = fofoLineItemRepository
+                        .selectByInventoryItemIds(inventoryItemIds).stream()
-            int maxFofoOrderItemId = flis.stream().mapToInt(x -> x.getFofoOrderItemId()).max().orElseThrow(NoSuchElementException::new);
+                        .collect(Collectors.groupingBy(FofoLineItem::getInventoryItemId));
+            } catch (ProfitMandiBusinessException e) {
-            LOGGER.info("maxFofoOrderItemId" + maxFofoOrderItemId);
+                LOGGER.error("Error fetching FofoLineItems by inventory IDs", e);
-            FofoOrderItem foi = fofoOrderItemRepository.selectById(maxFofoOrderItemId);
+                lineItemsByInventoryId = new HashMap<>();
+            }
+            // Get max FofoOrderItemId for each inventory item
-            FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());
+            Set<Integer> fofoOrderItemIds = lineItemsByInventoryId.values().stream()
+                    .map(list -> list.stream().mapToInt(FofoLineItem::getFofoOrderItemId).max().orElse(-1))
+                    .filter(id -> id > 0)
+                    .collect(Collectors.toSet());
+            Map<Integer, FofoOrderItem> fofoOrderItemMap;
+            try {
+                fofoOrderItemMap = fofoOrderItemRepository
+                        .selectByIds(new ArrayList<>(fofoOrderItemIds)).stream()
+                        .collect(Collectors.toMap(FofoOrderItem::getId, foi -> foi));
+            } catch (ProfitMandiBusinessException e) {
+                LOGGER.error("Error fetching FofoOrderItems by IDs", e);
+                fofoOrderItemMap = new HashMap<>();
+            }
+            Set<Integer> orderIds = fofoOrderItemMap.values().stream()
+                    .map(FofoOrderItem::getOrderId)
+                    .collect(Collectors.toSet());
+            Map<Integer, FofoOrder> fofoOrderMap = new HashMap<>();
+            try {
+                fofoOrderMap = fofoOrderRepository
+                        .selectAllByOrderIds(new ArrayList<>(orderIds)).stream()
-            activationItemDetail.setInvoiceNumber(fo.getInvoiceNumber());
+                        .collect(Collectors.toMap(FofoOrder::getId, fo -> fo));
+            } catch (ProfitMandiBusinessException e) {
+                LOGGER.error("Error fetching FofoOrders by order IDs", e);
+            }
+            for (ActivationItemDetailModel activationItemDetail : activationItemDetails) {
+                List<FofoLineItem> flis = lineItemsByInventoryId.get(activationItemDetail.getInventoryItemId());
+                if (flis != null && !flis.isEmpty()) {
+                    int maxFofoOrderItemId = flis.stream().mapToInt(FofoLineItem::getFofoOrderItemId).max().orElse(-1);
+                    FofoOrderItem foi = fofoOrderItemMap.get(maxFofoOrderItemId);
+                    if (foi != null) {
+                        FofoOrder fo = fofoOrderMap.get(foi.getOrderId());
+                        if (fo != null) {
+                            activationItemDetail.setInvoiceNumber(fo.getInvoiceNumber());
+                        }
+                    }
+                }
+            }
+        }
         LOGGER.info("activationItemDetails" + activationItemDetails);
         model.addAttribute("activationItemDetails", activationItemDetails);
         LocalDateTime startOfMonth = curDate.withDayOfMonth(1).minusMonths(6);
         List<ActivationItemDetailModel> activationItemDetails = schemeInOutRepository.selectBrandPendingActivationItemDetailByYearMonth(fofoId, brand, startOfMonth);
+        if (!activationItemDetails.isEmpty()) {
+            // Batch fetch to avoid N+1 queries
-        for (ActivationItemDetailModel activationItemDetail : activationItemDetails) {
+            List<Integer> inventoryItemIds = activationItemDetails.stream()
-            List<FofoLineItem> flis = fofoLineItemRepository.selectByInventoryItemId(activationItemDetail.getInventoryItemId());
+                    .map(ActivationItemDetailModel::getInventoryItemId)
-            LOGGER.info("flis" + flis);
+                    .collect(Collectors.toList());
+            Map<Integer, List<FofoLineItem>> lineItemsByInventoryId;
+            try {
+                lineItemsByInventoryId = fofoLineItemRepository
+                        .selectByInventoryItemIds(inventoryItemIds).stream()
-            int maxFofoOrderItemId = flis.stream().mapToInt(x -> x.getFofoOrderItemId()).max().orElseThrow(NoSuchElementException::new);
+                        .collect(Collectors.groupingBy(FofoLineItem::getInventoryItemId));
+            } catch (ProfitMandiBusinessException e) {
-            LOGGER.info("maxFofoOrderItemId" + maxFofoOrderItemId);
+                LOGGER.error("Error fetching FofoLineItems by inventory IDs", e);
-            FofoOrderItem foi = fofoOrderItemRepository.selectById(maxFofoOrderItemId);
+                lineItemsByInventoryId = new HashMap<>();
+            }
-            FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());
+            Set<Integer> fofoOrderItemIds = lineItemsByInventoryId.values().stream()
+                    .map(list -> list.stream().mapToInt(FofoLineItem::getFofoOrderItemId).max().orElse(-1))
+                    .filter(id -> id > 0)
+                    .collect(Collectors.toSet());
+            Map<Integer, FofoOrderItem> fofoOrderItemMap;
+            try {
+                fofoOrderItemMap = fofoOrderItemRepository
+                        .selectByIds(new ArrayList<>(fofoOrderItemIds)).stream()
+                        .collect(Collectors.toMap(FofoOrderItem::getId, foi -> foi));
+            } catch (ProfitMandiBusinessException e) {
+                LOGGER.error("Error fetching FofoOrderItems by IDs", e);
+                fofoOrderItemMap = new HashMap<>();
+            }
+            Set<Integer> orderIds = fofoOrderItemMap.values().stream()
+                    .map(FofoOrderItem::getOrderId)
+                    .collect(Collectors.toSet());
+            Map<Integer, FofoOrder> fofoOrderMap = new HashMap<>();
+            try {
+                fofoOrderMap = fofoOrderRepository
+                        .selectAllByOrderIds(new ArrayList<>(orderIds)).stream()
-            activationItemDetail.setInvoiceNumber(fo.getInvoiceNumber());
+                        .collect(Collectors.toMap(FofoOrder::getId, fo -> fo));
+            } catch (ProfitMandiBusinessException e) {
+                LOGGER.error("Error fetching FofoOrders by order IDs", e);
+            }
+            for (ActivationItemDetailModel activationItemDetail : activationItemDetails) {
+                List<FofoLineItem> flis = lineItemsByInventoryId.get(activationItemDetail.getInventoryItemId());
+                if (flis != null && !flis.isEmpty()) {
+                    int maxFofoOrderItemId = flis.stream().mapToInt(FofoLineItem::getFofoOrderItemId).max().orElse(-1);
+                    FofoOrderItem foi = fofoOrderItemMap.get(maxFofoOrderItemId);
+                    if (foi != null) {
+                        FofoOrder fo = fofoOrderMap.get(foi.getOrderId());
+                        if (fo != null) {
+                            activationItemDetail.setInvoiceNumber(fo.getInvoiceNumber());
+                        }
+                    }
+                }
+            }
+        }
         LOGGER.info("activationItemDetails" + activationItemDetails);
         model.addAttribute("activationItemDetails", activationItemDetails);
         Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();
         Set<Integer> authfofoIds = storeGuyMap.get(email);
         AuthUser authUser = authRepository.selectByEmailOrMobile(email);
         if (authfofoIds == null) {
-            List<Position> positions1 = positionRepository.selectAll(authUser.getId());
+            List<Position> positions1 = positionRepository.selectAllByAuthUserId(authUser.getId());
             if (positions1.stream().filter(x -> x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_MASTER).count() > 0) {
                 authfofoIds = csService.getPositionCustomRetailerMap(positions1).values().stream().flatMap(x -> x.stream()).map(x -> x.getPartnerId()).collect(Collectors.toSet());
+            }
+        }
         List<WarehouseWiseBrandSaleModel> warehouseWiseBrandPartnerSales = fofoStoreRepository.selectGroupByWarehouseAccesoriesBrandWisePartnerSale(brand, new ArrayList<>(authfofoIds));
         Map<Integer, AuthUser> ticketIdAuthUser = new HashMap<>();
         CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
         List<Integer> ticketIds = ticketRepository.selectAllOpenTicketByRetailer(fofoId).stream().map(x -> x.getId()).collect(Collectors.toList());
         List<TicketAssigned> ticketAssigns = ticketAssignedRepository.selectByTicketIds(ticketIds);
+        if (!ticketAssigns.isEmpty()) {
+            // Batch fetch AuthUsers to avoid N+1 queries
+            Set<Integer> assigneeIds = ticketAssigns.stream()
+                    .map(TicketAssigned::getAssineeId)
+                    .collect(Collectors.toSet());
+            Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(new ArrayList<>(assigneeIds)).stream()
+                    .collect(Collectors.toMap(AuthUser::getId, au -> au));
-        for (TicketAssigned ticketAssign : ticketAssigns) {
+            for (TicketAssigned ticketAssign : ticketAssigns) {
-            AuthUser authUser = authRepository.selectById(ticketAssign.getAssineeId());
+                AuthUser authUser = authUserMap.get(ticketAssign.getAssineeId());
+                if (authUser != null) {
-            ticketIdAuthUser.put(ticketAssign.getTicketId(), authUser);
+                    ticketIdAuthUser.put(ticketAssign.getTicketId(), authUser);
+                }
+            }
+        }
         model.addAttribute("ticketIdAuthUser", ticketIdAuthUser);
         model.addAttribute("ticketAssigns", ticketAssigns);
         model.addAttribute("customRetailer", customRetailer);
         return "open-ticket";
             fofoIds = storeGuyMap.get("tarun.verma@smartdukaan.com");
             LOGGER.info("fofoIds" + fofoIds);
+        }
         if (fofoIds == null) {
-            List<Position> positions1 = positionRepository.selectAll(authUser.getId());
+            List<Position> positions1 = positionRepository.selectAllByAuthUserId(authUser.getId());
             if (positions1.stream().filter(x -> x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_MASTER).count() > 0) {
                 fofoIds = csService.getPositionCustomRetailerMap(positions1).values().stream().flatMap(x -> x.stream()).map(x -> x.getPartnerId()).collect(Collectors.toSet());
+            }
+        }
         return new ArrayList<>(fofoIds);

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/DashboardController.java – Rev 35340 → 35395