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

     TransactionService transactionService;
     @Autowired
     BulkOrderService bulkOrderService;
     @Autowired
     private CustomerRepository customerRepository;
-    private boolean accessoriesDeals = true;
+    private static final boolean accessoriesDeals = true;
     @Autowired
     private RoleManager roleManager;
     @Autowired
     private Gson gson;
     @Autowired
     @RequestMapping(value = "/wa-send-invoice", method = RequestMethod.GET)
     public String sendWhatsappMessage(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) {
         try {
             this.sendWhatsappInvoice(fofoOrderRepository.selectByOrderId(orderId));
         } catch (Exception e) {
-            LOGGER.info("Could not send whatsapp message");
+            LOGGER.error("Could not send whatsapp message for order {}", orderId, e);
-            e.printStackTrace();
+        }
         model.addAttribute("response1", true);
         return "response";
+    }
         Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this
                 .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);
         List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
                 .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());
         this.addInsuranceProvider(insurancePolicies);
-        Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {
+        Set<Integer> itemIds = fofoOrderItems.stream().map(FofoOrderItem::getItemId).collect(Collectors.toSet());
-            try {
-                return itemRepository.selectById(x.getItemId());
+        Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream()
-            } catch (ProfitMandiBusinessException e) {
+                .collect(Collectors.toMap(Item::getId, item -> item));
-                // TODO Auto-generated catch block
-                return null;
-            }
-        }));
         Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()
                 .collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));
-        Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()
+        Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = new HashMap<>();
-                .collect(Collectors.toMap(foi -> foi.getId(),
-                        foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));
         Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();
         for (FofoOrderItem foi : fofoOrderItems) {
+            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
+                    .selectAllByOrderItemId(foi.getId());
+            foiIdCustomerReturnInventoryItemsMap.put(foi.getId(), customerReturnItems);
             for (FofoLineItem fli : foi.getFofoLineItems()) {
                 inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());
+            }
-            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
-                    .selectAllByOrderItemId(foi.getId());
             this.markDoa(fofoOrder, foi, isAdmin);
             for (CustomerReturnItem customerReturnItem : customerReturnItems) {
                 inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),
                         inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);
+            }
         List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
         Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
         CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
         Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = paymentOptionRepository.selectActiveOption().stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
         List<Integer> fofoPartnerPaymentOptions = new ArrayList<>(paymentOptionIdPaymentOptionMap.keySet());
-        Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {
+        Set<Integer> searchItemIds = fofoOrderItems.stream().map(FofoOrderItem::getItemId).collect(Collectors.toSet());
-            try {
-                return itemRepository.selectById(x.getItemId());
+        Map<Integer, Item> itemsMap = itemRepository.selectByIds(searchItemIds).stream()
-            } catch (ProfitMandiBusinessException e) {
+                .collect(Collectors.toMap(Item::getId, item -> item));
-                // TODO Auto-generated catch block
-                return null;
-            }
-        }));
-        LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);
+        LOGGER.info("fofoPartnerPaymentOptions {}", fofoPartnerPaymentOptions);
         List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository
                 .selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
-        LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);
+        LOGGER.info("paymentOptionTransactions {}", paymentOptionTransactions);
         Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this
                 .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);
-        LOGGER.info("paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
+        LOGGER.info("paymentOptionIdPaymentOptionTransactionMap {}", paymentOptionIdPaymentOptionTransactionMap.keySet());
         List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
                 .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());
         this.addInsuranceProvider(insurancePolicies);
         model.addAttribute("fofoOrder", fofoOrder);
         for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
+        }
         Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()
                 .collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));
-        Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()
+        Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = new HashMap<>();
-                .collect(Collectors.toMap(foi -> foi.getId(),
-                        foi -> customerReturnItemRepository.selectAllByOrderItemId(foi.getId())));
         Map<Integer, Integer> inventoryItemBilledQtyMap = new HashMap<>();
         for (FofoOrderItem foi : fofoOrderItems) {
+            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
+                    .selectAllByOrderItemId(foi.getId());
+            foiIdCustomerReturnInventoryItemsMap.put(foi.getId(), customerReturnItems);
             for (FofoLineItem fli : foi.getFofoLineItems()) {
                 inventoryItemBilledQtyMap.put(fli.getInventoryItemId(), fli.getQuantity());
+            }
-            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
-                    .selectAllByOrderItemId(foi.getId());
             for (CustomerReturnItem customerReturnItem : customerReturnItems) {
                 inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),
                         inventoryItemBilledQtyMap.get(customerReturnItem.getInventoryItemId()) - 1);
+            }
+        }
         List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel
                 .getPaymentOptionTransactionModel();
         LOGGER.info(paymentOptionTransactionModels);
         FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, referenceId);
-        LOGGER.info("sdssd" + fofoOrder);
+        LOGGER.info("fofoOrder: {}", fofoOrder);
         fofoOrder.setTotalAmount(totalAmount);
         List<FofoItemIdAmountModel> fofoItemIdAmountModel = partnerOptionsAndItemAmountModel.getItemAmountModel();
-        for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {
-            LOGGER.info("fim" + fim.getFofoItemId());
+        Set<Integer> fimItemIds = fofoItemIdAmountModel.stream().map(FofoItemIdAmountModel::getItemId).collect(Collectors.toSet());
+        Map<Integer, Item> fimItemMap = itemRepository.selectByIds(fimItemIds).stream()
+                .collect(Collectors.toMap(Item::getId, item -> item));
+        Map<Integer, TagListing> fimTagMap = tagListingRepository.selectByItemIds(fimItemIds);
+        List<Integer> fimFofoItemIds = fofoItemIdAmountModel.stream().map(FofoItemIdAmountModel::getFofoItemId).collect(Collectors.toList());
+        Map<Integer, FofoOrderItem> fimFofoItemMap = fofoOrderItemRepository.selectByIds(fimFofoItemIds).stream()
+                .collect(Collectors.toMap(FofoOrderItem::getId, foi -> foi));
+        for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {
+            LOGGER.info("fim: {}", fim.getFofoItemId());
-            LOGGER.info("fimAmount" + fim.getAmount());
+            LOGGER.info("fimAmount: {}", fim.getAmount());
-            Item item = itemRepository.selectById(fim.getItemId());
+            Item item = fimItemMap.get(fim.getItemId());
-            TagListing tagListing = tagListingRepository.selectByItemId(item.getId());
+            TagListing tagListing = fimTagMap.get(item.getId());
-            FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(fim.getFofoItemId());
+            FofoOrderItem fofoOrderItem = fimFofoItemMap.get(fim.getFofoItemId());
-            LOGGER.info("category" + item.getCategoryId());
+            LOGGER.info("category: {}", item.getCategoryId());
             if (item.getCategoryId() == ProfitMandiConstants.MOBILE_CATEGORY_ID) {
                 if (fofoOrderItem.getMop() <= fim.getAmount()) {
                     if (fim.getAmount() <= tagListing.getMrp()) {
                         fofoOrderItem.setSellingPrice(fim.getAmount());
                     } else {
                         throw new ProfitMandiBusinessException("Amount", fim.getAmount(),
                                 "Sum of amount is not less than  to MRP");
+                    }
-                    LOGGER.info("fofoOrderItem2" + fofoOrderItem);
+                    LOGGER.info("fofoOrderItem2: {}", fofoOrderItem);
                 } else {
                     // TODO below mop condition need to added added
                     fofoOrderItem.setSellingPrice(fim.getAmount());
+                }
             } else {
                 fofoOrderItem.setSellingPrice(fim.getAmount());
-                LOGGER.info("fofoOrderItem1" + fofoOrderItem);
+                LOGGER.info("fofoOrderItem1: {}", fofoOrderItem);
+            }
-            LOGGER.info("fofoOrderItem" + fofoOrderItem);
+            LOGGER.info("fofoOrderItem: {}", fofoOrderItem);
+        }
         /*
          * for (PaymentOptionTransactionModel paymentOptionTransactionModel :
         if (paymentOptionTransactionModels.size() > 0) {
             List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository
                     .selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);
             Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this
                     .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);
-            LOGGER.info(
-                    "paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
+            LOGGER.info("paymentOptionIdPaymentOptionTransactionMap: {}", paymentOptionIdPaymentOptionTransactionMap.keySet());
             for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {
                 if (paymentOptionIdPaymentOptionTransactionMap
                         .containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {
                     PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap
         // List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new
         // HashSet<>(paymentOptionIds));
         List<PaymentOption> paymentOptions = paymentOptionRepository.selectActiveOption();
-        LOGGER.info("pendingOrder" + po);
+        LOGGER.info("pendingOrder: {}", po);
-        LOGGER.info("pendingOrderItem" + poi);
+        LOGGER.info("pendingOrderItem: {}", poi);
         int onlineSellingPrice = 0;
         Map<Integer, PendingOrderItem> itemIdAndPoiMap = new HashMap<>();
         if (po != null) {
             List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(po.getId());
+            Map<Integer, PendingOrderItem> poiByIdMap = pendingOrderItems.stream()
+                    .collect(Collectors.toMap(PendingOrderItem::getId, x -> x));
             if (!(po.getPayMethod().equals("EMIOD") || po.getPayMethod().equals("POD"))) {
                 for (CartFofo cartItem : cartItems) {
-                    PendingOrderItem pendingOItem = pendingOrderItemRepository.selectById(cartItem.getPoItemId());
+                    PendingOrderItem pendingOItem = poiByIdMap.get(cartItem.getPoItemId());
                     PendingOrderPlan pendingOrderPlan = pendingOrderPlanRepository.selectByPoid(cartItem.getPoItemId());
                     if (pendingOrderPlan != null) {
                         onlineSellingPrice += pendingOItem.getSellingPrice() * pendingOItem.getQuantity() + pendingOrderPlan.getPremiumPrice() * pendingOItem.getQuantity();
                     } else {
                         onlineSellingPrice += pendingOItem.getSellingPrice() * pendingOItem.getQuantity();
+                    }
+                }
+            }
-            itemIdAndPoiMap = pendingOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> pendingOrderItemRepository.selectById(x.getId())));
+            itemIdAndPoiMap = pendingOrderItems.stream().collect(Collectors.toMap(PendingOrderItem::getItemId, x -> x));
+        }
 //        get the list of customer item for every item code start here
 //        ...............................................................
             webOfferMap.put(item.getId(), webOffers);
         }*/
         Map<Integer, ItemWiseCustomerOfferSummaryModel> offerItemSummaryMap = new HashMap<>();
+        Map<Integer, Item> cartItemMap = itemRepository.selectByIds(itemIds).stream()
+                .collect(Collectors.toMap(Item::getId, item -> item));
         for (CartFofo cartItem : cartItems) {
-            Item item = itemRepository.selectById(cartItem.getItemId());
+            Item item = cartItemMap.get(cartItem.getItemId());
             List<CustomerOfferItem> customerOfferItems = null;
             if (customerOfferIds.size() > 0) {
                 customerOfferItems = customerOfferItemRepository
                         .selectByOfferIds(customerOfferIds, item.getCatalogItemId(), todayDate2)
                         .stream()
         Map<Integer, Item> itemMap = new HashMap<>();
         Map<Integer, CurrentInventorySnapshot> inventoryMap = new HashMap<>();
         PendingOrder pendingPO = pendingOrderRepository.selectById(orderId);
         Customer customer = customerRepository.selectById(pendingPO.getCustomerId());
         List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(orderId);
-        for (PendingOrderItem pendingOrderItem : pendingOrderItems) {
+        Set<Integer> poItemIds = pendingOrderItems.stream().map(PendingOrderItem::getItemId).collect(Collectors.toSet());
-            Item item = itemRepository.selectById(pendingOrderItem.getItemId());
+        itemMap = itemRepository.selectByIds(poItemIds).stream()
+                .collect(Collectors.toMap(Item::getId, item -> item));
-            CurrentInventorySnapshot cis = currentInventorySnapshotRepository
+        List<CurrentInventorySnapshot> snapshots = currentInventorySnapshotRepository
-                    .selectByItemAndFofoId(pendingOrderItem.getItemId(), pendingPO.getFofoId());
+                .selectByFofoItemIds(pendingPO.getFofoId(), poItemIds);
-            itemMap.put(pendingOrderItem.getItemId(), item);
+        for (CurrentInventorySnapshot cis : snapshots) {
-            LOGGER.info("cis" + cis);
+            LOGGER.info("cis: {}", cis);
-            inventoryMap.put(pendingOrderItem.getItemId(), cis);
+            inventoryMap.put(cis.getItemId(), cis);
+        }
-        LOGGER.info("inventoryMap" + inventoryMap);
+        LOGGER.info("inventoryMap: {}", inventoryMap);
         model.addAttribute("pendingOrderItems", pendingOrderItems);
         model.addAttribute("itemMap", itemMap);
         model.addAttribute("inventoryMap", inventoryMap);
         model.addAttribute("pendingPO", gson.toJson(pendingPO));
         model.addAttribute("pendingPOCustomer", gson.toJson(customer));
         Map<String, Object> emailModel = new HashMap<>();
         emailModel.put("customer", customerAddress);
         emailModel.put("pendingOrder", pendingOrder);
         emailModel.put("date", dateTimeFormatter);
-        LOGGER.info("emal" + customer.getEmailId());
+        LOGGER.info("email: {}", customer.getEmailId());
         String[] customerEmail = null;
         if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
             customerEmail = new String[]{customer.getEmailId()};
             List<String> bccTo = Arrays.asList("vikas.jangra@smartdukaan.com");
     // This method is use for sending all pending transaction to Transation Approval menu
     @RequestMapping(value = "/transaction/pendingApprovals", method = RequestMethod.GET)
     public String getTransactionApproval(HttpServletRequest request, Model model) throws Exception {
         List<TransactionApproval> transactionApprovals = transactionApprovalRepository.selectAllPending();
-        LOGGER.info("list of Approval transaction Id " + transactionApprovals);
+        LOGGER.info("list of Approval transaction Id: {}", transactionApprovals);
         List<TransactionApprovalModel> approvalModelList = bulkOrderService.getAllPendingTransactionApproval();
         model.addAttribute("approvalModelList", approvalModelList);
         return "transaction/transaction-approvals";
+    }

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/OrderController.java – Rev 35726 → 35737