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

         boolean noGST = false;
         int changedTotalBillAmount = 0;
         for (CustomPaymentOption cpo : createOrderRequest.getPaymentOptions()) {
             changedTotalBillAmount += cpo.getAmount();
+        }
+        // N+1 fix: Batch fetch all PendingOrderItems before the validation loop
+        List<Integer> validationPoiIds = createOrderRequest.getFofoOrderItems().stream()
+                .map(CustomFofoOrderItem::getPoiId)
+                .filter(id -> id > 0)
+                .collect(Collectors.toList());
+        Map<Integer, PendingOrderItem> pendingOrderItemMap = new HashMap<>();
+        if (!validationPoiIds.isEmpty()) {
+            List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByIds(validationPoiIds);
+            pendingOrderItemMap = pendingOrderItems.stream()
+                    .collect(Collectors.toMap(PendingOrderItem::getId, poi -> poi));
+        }
         for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
             if (customFofoOrderItem.getPoiId() > 0) {
+                // N+1 fix: Use pre-fetched map instead of querying per item
-                PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(customFofoOrderItem.getPoiId());
+                PendingOrderItem pendingOrderItem = pendingOrderItemMap.get(customFofoOrderItem.getPoiId());
+                if (pendingOrderItem == null) {
+                    throw new ProfitMandiBusinessException("poiId", customFofoOrderItem.getPoiId(), "Pending order item not found");
+                }
                 if (customFofoOrderItem.getQuantity() > pendingOrderItem.getQuantity()) {
                     throw new ProfitMandiBusinessException("itemIdQuantity", customFofoOrderItem.getItemId(), "Quantity should not be greater than order item quantity");
+                }
                 if (pendingOrderItem.getQuantity() > customFofoOrderItem.getQuantity()) {
                     pendingOrderService.duplicatePendingOrder(pendingOrderItem, customFofoOrderItem.getQuantity());
             } catch (Exception e) {
                 LOGGER.error("Unable to get state rates");
+            }
+        }
+        // N+1 fix: Pre-fetch tagListings and GST rates before the loop
+        Map<Integer, TagListing> tagListingMap = tagListingRepository.selectByItemIds(itemIdCustomFofoOrderItemMap.keySet());
+        Map<Integer, GstRate> gstRateMap = null;
+        if (stateId != null) {
+            gstRateMap = stateGstRateRepository.getStateTaxRate(new ArrayList<>(itemMap.keySet()), stateId);
+        } else {
+            gstRateMap = stateGstRateRepository.getIgstTaxRate(new ArrayList<>(itemMap.keySet()));
+        }
         for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
-            FofoOrderItem fofoOrderItem = this.createAndGetFofoOrderItem(customFofoOrderItem, fofoOrder.getId(), itemMap, inventoryItemsToBill.get(customFofoOrderItem.getItemId()), stateId);
+            FofoOrderItem fofoOrderItem = this.createAndGetFofoOrderItem(customFofoOrderItem, fofoOrder.getId(), itemMap, inventoryItemsToBill.get(customFofoOrderItem.getItemId()), tagListingMap, gstRateMap);
             Item item = itemMap.get(customFofoOrderItem.getItemId());
             if (item.getType().equals(ItemType.NON_SERIALIZED)) {
                 if (customFofoOrderItem.getCustomSerialNumbers() != null && !customFofoOrderItem.getCustomSerialNumbers().isEmpty()) {
                     persistNonSerializedWithCustomSerialNumber(customFofoOrderItem, fofoOrderItem.getId());
             this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed, fofoOrder.getId());
+        }
         List<FofoOrderItem> fofoItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
-        boolean smartPhone = false;
-        for (FofoOrderItem fofoOrderItem : fofoItems) {
+        // Use existing itemMap instead of querying DB per item (N+1 fix)
-            Item item = itemRepository.selectById(fofoOrderItem.getItemId());
+        boolean smartPhone = items.stream().anyMatch(Item::isSmartPhone);
-            if (item.isSmartPhone()) {
+        if (smartPhone) {
-                LOGGER.info("fofoItem {}", fofoOrderItem);
+            LOGGER.info("Smartphone found in order items");
-                smartPhone = true;
-            }
+        } else {
-        }
-        if (!smartPhone) {
             LOGGER.warn("No smartphones found in fofoItems.");
+        }
         if (smartPhone) {
         schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
         if (createOrderRequest.getPoId() != 0) {
             PendingOrder po = pendingOrderRepository.selectById(createOrderRequest.getPoId());
             po.setBilledAmount(po.getBilledAmount() + totalAmount);
+            // N+1 fix: Batch fetch pending order items instead of querying per item
-            for (CustomFofoOrderItem cfoi : createOrderRequest.getFofoOrderItems()) {
+            List<Integer> poiIds = createOrderRequest.getFofoOrderItems().stream()
+                    .map(CustomFofoOrderItem::getPoiId)
+                    .filter(id -> id != 0)
+                    .collect(Collectors.toList());
+            if (!poiIds.isEmpty()) {
-                PendingOrderItem poi = pendingOrderItemRepository.selectById(cfoi.getPoiId());
+                List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByIds(poiIds);
+                LocalDateTime now = LocalDateTime.now();
+                for (PendingOrderItem poi : pendingOrderItems) {
-                poi.setStatus(OrderStatus.BILLED);
+                    poi.setStatus(OrderStatus.BILLED);
-                poi.setBilledTimestamp(LocalDateTime.now());
+                    poi.setBilledTimestamp(now);
+                }
+            }
             po.setStatus(OrderStatus.BILLED);
+        }
         //Process scratch
         this.processScratchOffer(fofoOrder);
+                }
+            }
+        }
-//        enable it fo upsell call
+//        enable it fo upsell call - N+1 fix: smartPhone already determined, no need to re-query items
-        if (smartPhone) {
-            if (fofoOrder.getId() > 0) {
+        if (smartPhone && fofoOrder.getId() > 0) {
-                List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
+            List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
-                        .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());
+                    .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());
-                if (insurancePolicies.isEmpty()) {
+            if (insurancePolicies.isEmpty()) {
-                    List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
-                    for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
-                        Item item = itemRepository.selectById(fofoOrderItem.getItemId());
-                        if (item.isSmartPhone()) {
-                            UpSaleOrder upSaleOrder = new UpSaleOrder();
+                UpSaleOrder upSaleOrder = new UpSaleOrder();
-                            upSaleOrder.setCreatedTimestamp(LocalDateTime.now());
+                upSaleOrder.setCreatedTimestamp(LocalDateTime.now());
-                            upSaleOrder.setOrderId(fofoOrder.getId());
+                upSaleOrder.setOrderId(fofoOrder.getId());
-                            upSaleOrder.setFofoId(fofoOrder.getFofoId());
+                upSaleOrder.setFofoId(fofoOrder.getFofoId());
-                            upSaleOrderRepository.persist(upSaleOrder);
+                upSaleOrderRepository.persist(upSaleOrder);
-                            break; // Exit the loop after persisting the UpSaleOrder for the first smartphone
-                        }
-                    }
-                }
+            }
+        }
-        // Update Partner Opening Stock current qty
+        // Update Partner Opening Stock current qty - N+1 fix: use existing itemMap and batch update
         if (fofoOrder.getId() > 0) {
-            List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
+            Map<Integer, Integer> itemIdQuantityMap = new HashMap<>();
-            for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
+            for (FofoOrderItem fofoOrderItem : fofoItems) {
-                Item item = itemRepository.selectById(fofoOrderItem.getItemId());
-                smartCartService.minusOpeningStock(item.getId(), fofoOrder.getFofoId(), fofoOrderItem.getQuantity());
+                itemIdQuantityMap.merge(fofoOrderItem.getItemId(), fofoOrderItem.getQuantity(), Integer::sum);
+            }
+            smartCartService.minusOpeningStockBatch(itemIdQuantityMap, fofoOrder.getFofoId());
+        }
         return fofoOrder.getId();
+    }
     @Override
     public void processScratchOffer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
         boolean isSmartPhonePurchased = false;
         float maxPurchaseValue = 0;
         List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
+        // N+1 fix: batch fetch all items instead of querying per order item
+        Set<Integer> itemIds = fofoOrderItems.stream()
+                .map(FofoOrderItem::getItemId)
+                .collect(Collectors.toSet());
+        Map<Integer, Item> itemMap = itemRepository.selectByIds(itemIds).stream()
+                .collect(Collectors.toMap(Item::getId, item -> item));
         for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
-            Item item = itemRepository.selectById(fofoOrderItem.getItemId());
+            Item item = itemMap.get(fofoOrderItem.getItemId());
-            if (item.isSmartPhone()) {
+            if (item != null && item.isSmartPhone()) {
                 LOGGER.info("fofoItem {}", fofoOrderItem);
                 isSmartPhonePurchased = true;
                 maxPurchaseValue = Math.max(fofoOrderItem.getSellingPrice(), maxPurchaseValue);
+            }
+        }
         LocalDate startDate = ProfitMandiConstants.SCRATCH_OFFER_START_DATE;
         LocalDate endDate = ProfitMandiConstants.SCRATCH_OFFER_END_DATE;
         boolean specificPriceOffer = ProfitMandiConstants.SPECIFIC_PRICE_OFFER;
             fofoLineItemRepository.persist(fofoLineItem);
+        }
+    }
     private FofoOrderItem createAndGetFofoOrderItem(CustomFofoOrderItem customFofoOrderItem, int fofoOrderId, Map<
-            Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Integer stateId) throws
+            Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Map<Integer, TagListing> tagListingMap,
-            ProfitMandiBusinessException {
+            Map<Integer, GstRate> gstRateMap) throws ProfitMandiBusinessException {
         FofoOrderItem fofoOrderItem = new FofoOrderItem();
         fofoOrderItem.setItemId(customFofoOrderItem.getItemId());
         fofoOrderItem.setQuantity(customFofoOrderItem.getQuantity());
         fofoOrderItem.setSellingPrice(customFofoOrderItem.getSellingPrice());
         fofoOrderItem.setPendingOrderItemId(customFofoOrderItem.getPoiId());
         fofoOrderItem.setOrderId(fofoOrderId);
+        // N+1 fix: Use pre-fetched tagListingMap instead of querying per item
-        TagListing tl = tagListingRepository.selectByItemId(customFofoOrderItem.getItemId());
+        TagListing tl = tagListingMap.get(customFofoOrderItem.getItemId());
         // In case listing gets removed rebill it using the selling price
         if (tl != null) {
             fofoOrderItem.setDp(tl.getSellingPrice());
             fofoOrderItem.setMop(tl.getMop());
         } else {
             fofoOrderItem.setMop(customFofoOrderItem.getSellingPrice());
+        }
         fofoOrderItem.setDiscount(customFofoOrderItem.getDiscountAmount());
         Item item = itemMap.get(customFofoOrderItem.getItemId());
-        Map<Integer, GstRate> itemIdStateTaxRateMap = null;
-        if (stateId != null) {
-            itemIdStateTaxRateMap = stateGstRateRepository.getStateTaxRate(new ArrayList<>(itemMap.keySet()), stateId);
-        } else {
-            itemIdStateTaxRateMap = stateGstRateRepository.getIgstTaxRate(new ArrayList<>(itemMap.keySet()));
-        }
-        for (InventoryItem inventoryItem : inventoryItems) {
-            fofoOrderItem.setIgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getIgstRate());
-            fofoOrderItem.setCgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getCgstRate());
-            fofoOrderItem.setSgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getSgstRate());
+        // N+1 fix: Use pre-fetched gstRateMap instead of querying per item
+        for (InventoryItem inventoryItem : inventoryItems) {
+            GstRate gstRate = gstRateMap.get(inventoryItem.getItemId());
+            if (gstRate != null) {
+                fofoOrderItem.setIgstRate(gstRate.getIgstRate());
+                fofoOrderItem.setCgstRate(gstRate.getCgstRate());
+                fofoOrderItem.setSgstRate(gstRate.getSgstRate());
+            }
             fofoOrderItem.setHsnCode(inventoryItem.getHsnCode());
             break;
+        }
         fofoOrderItem.setBrand(item.getBrand());
         fofoOrderItem.setModelName(item.getModelName());

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/order/OrderServiceImpl.java – Rev 35236 → 35493