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

 import com.spice.profitmandi.common.util.FormattingUtils;
 import com.spice.profitmandi.common.util.StringUtils;
 import com.spice.profitmandi.common.util.Utils;
 import com.spice.profitmandi.common.web.client.RestClient;
 import com.spice.profitmandi.dao.cart.SmartCartService;
+import com.spice.profitmandi.dao.entity.catalog.Category;
 import com.spice.profitmandi.dao.entity.catalog.Item;
 import com.spice.profitmandi.dao.entity.catalog.TagListing;
 import com.spice.profitmandi.dao.entity.catalog.UpgradeOffer;
 import com.spice.profitmandi.dao.entity.dtr.*;
 import com.spice.profitmandi.dao.entity.fofo.*;
     @Autowired
     private OrderRepository orderRepository;
     @Autowired
+    private CategoryRepository categoryRepository;
+    @Autowired
     private HygieneDataRepository hygieneDataRepository;
     @Autowired
     private SessionFactory sessionFactory;
         Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();
         Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); // to keep track of inventoryitem quanity
         // used for scan records insertion
         LOGGER.info("itemMap keys {}", itemMap.keySet());
+        // N+1 fix: Fetch live demo serial numbers once before the loop (was being fetched per serialized item)
+        Set<String> liveDemoSerialNumbers = new HashSet<>(liveDemoBillingRespository.selectAllSerialNumber());
+        // Batch-fetch LiveDemoSerialNumber entities for all matching serialized inventory serials
+        List<String> matchingLiveDemoSerials = serializedInventoryItemMap.values().stream()
+                .flatMap(Set::stream)
+                .map(InventoryItem::getSerialNumber)
+                .filter(liveDemoSerialNumbers::contains)
+                .collect(Collectors.toList());
+        Map<String, LiveDemoSerialNumber> liveDemoSerialNumberMap = new HashMap<>();
+        if (!matchingLiveDemoSerials.isEmpty()) {
+            liveDemoSerialNumberMap = liveDemoBillingRespository.selectBySerialNumbers(matchingLiveDemoSerials).stream()
+                    .collect(Collectors.toMap(LiveDemoSerialNumber::getSerialNumber, ld -> ld, (a, b) -> a));
+        }
         // Lets reduce quantity and decide what inventory items to use.
         for (Item item : items) {
             if (item.getType().equals(ItemType.SERIALIZED)) {
                 // TODO:handle null
                 if (serializedInventoryItemMap.get(item.getId()) == null || itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().size() != serializedInventoryItemMap.get(item.getId()).size()) {
                     if (itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().size() != insuredModels.size()) {
                         List<String> invalidSerialNumbers = itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().stream().map(x -> x.getSerialNumber()).collect(Collectors.toList());
                         throw new ProfitMandiBusinessException("invalidSerialNumbers", invalidSerialNumbers, "FFORDR_1004");
+                    }
+                }
-                List<String> serialNumberList = liveDemoBillingRespository.selectAllSerialNumber();
                 Set<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(item.getId());
                 for (InventoryItem inventoryItem : inventoryItemsSerializedserialized) {
                     inventoryItem.setGoodQuantity(0);
                     inventoryItemIdQuantityUsed.put(inventoryItem.getId(), 1);
-                    if (serialNumberList.contains(inventoryItem.getSerialNumber())) {
+                    LiveDemoSerialNumber liveDemoSerialNumber = liveDemoSerialNumberMap.get(inventoryItem.getSerialNumber());
-                        LiveDemoSerialNumber liveDemoSerialNumber = liveDemoBillingRespository.selectBySerialNumber(inventoryItem.getSerialNumber());
+                    if (liveDemoSerialNumber != null) {
                         liveDemoBillingRespository.delete(liveDemoSerialNumber);
+                    }
+                }
                 inventoryItemsToBill.put(item.getId(), inventoryItemsSerializedserialized);
             } else {
             gstRateMap = stateGstRateRepository.getStateTaxRate(new ArrayList<>(itemMap.keySet()), stateId);
         } else {
             gstRateMap = stateGstRateRepository.getIgstTaxRate(new ArrayList<>(itemMap.keySet()));
+        }
+        // N+1 fix: Collect created FofoOrderItems during the loop instead of re-querying
+        List<FofoOrderItem> fofoItems = new ArrayList<>();
         for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
             FofoOrderItem fofoOrderItem = this.createAndGetFofoOrderItem(customFofoOrderItem, fofoOrder.getId(), itemMap, inventoryItemsToBill.get(customFofoOrderItem.getItemId()), tagListingMap, gstRateMap);
+            fofoItems.add(fofoOrderItem);
             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.updateCurrentInventorySnapshot(currentInventorySnapshots, fofoId, customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());
             this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed, fofoOrder.getId());
+        }
-        List<FofoOrderItem> fofoItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
         // Use existing itemMap instead of querying DB per item (N+1 fix)
         boolean smartPhone = items.stream().anyMatch(Item::isSmartPhone);
         if (smartPhone) {
             LOGGER.info("Smartphone found in order items");
         } else {
         // insurance calculation is insurance flag is enabled
         //
         if (insuredModels.size() > 0) {
             LOGGER.info("Processing insurane for serialNumbers");
             LOGGER.info("InsuranceModels {}", insuredModels);
+            if (createOrderRequest.getCustomer() == null || createOrderRequest.getCustomer().getDateOfBirth() == null) {
+                throw new ProfitMandiBusinessException("Order", "Customer Date of Birth", "Customer date of birth is required for insurance");
+            }
             LocalDate customerDateOfBirth = LocalDate.from(createOrderRequest.getCustomer().getDateOfBirth());
             fofoOrder.setDateOfBirth(customerDateOfBirth);
             for (InsuranceModel insuranceModel : insuredModels) {
                 LOGGER.info("G- {}", insuranceModel.getInsuranceId());
                 LOGGER.info("insuranceModel- {}", insuranceModel);
         pdfModel.setCustomer(getCustomCustomer(fofoOrder, customRetailer.getAddress()));
         pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
         pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
-        List<CustomOrderItem> customerFofoOrderItems = new ArrayList<>();
+        List<CustomOrderItem> regularFofoItems = new ArrayList<>();
+        List<CustomOrderItem> marginSchemeFofoItems = new ArrayList<>();
+        boolean hasMarginSchemeItems = false;
         for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
             float discount = fofoOrderItem.getDiscount();
             CustomOrderItem customFofoOrderItem = new CustomOrderItem();
             float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate() + fofoOrderItem.getCgstRate();
-            float taxableSellingPrice = (fofoOrderItem.getSellingPrice() + discount) / (1 + totalTaxRate / 100);
-            float taxableDiscountPrice = discount / (1 + totalTaxRate / 100);
-            customFofoOrderItem.setAmount(fofoOrderItem.getQuantity() * (taxableSellingPrice - taxableDiscountPrice));
             customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " " + fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
             Set<String> serialNumbers = this.toSerialNumbers(fofoOrderItem.getFofoLineItems());
             List<FofoNonSerializeSerial> nonSerializeSerials = fofoNonSerializeSerialRepository.selectByItemIdAndOrderId(fofoOrderItem.getId());
-            // Extract serial numbers from FofoNonSerializeSerial entities
             List<String> customSerialNumbers = nonSerializeSerials.stream().map(FofoNonSerializeSerial::getSerialNumber).collect(Collectors.toList());
             LOGGER.info("nonSerializeSerials {}", nonSerializeSerials);
             if (!serialNumbers.isEmpty()) {
                 customFofoOrderItem.setDescription(
                         customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
+            }
             if (!customSerialNumbers.isEmpty()) {
                 customFofoOrderItem.setDescription(
                         customFofoOrderItem.getDescription() + "\n SerialNumber - " + String.join(", ", customSerialNumbers));
+            }
-            customFofoOrderItem.setRate(taxableSellingPrice);
-            customFofoOrderItem.setDiscount(taxableDiscountPrice);
             customFofoOrderItem.setQuantity(fofoOrderItem.getQuantity());
-            customFofoOrderItem.setNetAmount(fofoOrderItem.getSellingPrice() * fofoOrderItem.getQuantity());
-            float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
-            float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
-            float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
-            customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
-            customFofoOrderItem.setIgstAmount(igstAmount);
-            customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
-            customFofoOrderItem.setCgstAmount(cgstAmount);
-            customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
-            customFofoOrderItem.setSgstAmount(sgstAmount);
             customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
+            // Check if this is a margin scheme item
+            boolean isMarginItem = false;
+            try {
+                Item item = itemRepository.selectById(fofoOrderItem.getItemId());
+                Category category = categoryRepository.selectById(item.getCategoryId());
+                isMarginItem = category.isMarginOnly() && !serialNumbers.isEmpty();
+            } catch (Exception e) {
+                LOGGER.warn("Could not check margin scheme for fofo order item {}", fofoOrderItem.getId(), e);
+            }
+            if (isMarginItem) {
+                // Margin Scheme: GST on margin only
+                // Purchase price = what FOFO paid (from fofo.inventory_item.unitPrice)
+                float purchasePrice = getFofoPurchasePrice(serialNumbers.iterator().next(), fofoOrder.getFofoId());
+                float sellingPrice = fofoOrderItem.getSellingPrice();
+                float margin = Math.max(0, sellingPrice - purchasePrice);
+                float taxableMargin = margin / (1 + totalTaxRate / 100);
+                customFofoOrderItem.setMarginScheme(true);
+                customFofoOrderItem.setPurchasePrice(purchasePrice);
+                customFofoOrderItem.setSellingPrice(sellingPrice);
+                customFofoOrderItem.setMargin(margin);
+                customFofoOrderItem.setRate(sellingPrice);
+                customFofoOrderItem.setDiscount(0);
+                customFofoOrderItem.setAmount(taxableMargin * fofoOrderItem.getQuantity());
+                customFofoOrderItem.setNetAmount(fofoOrderItem.getSellingPrice() * fofoOrderItem.getQuantity());
+                float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
+                float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
+                float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
+                customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
+                customFofoOrderItem.setIgstAmount(igstAmount);
+                customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
+                customFofoOrderItem.setCgstAmount(cgstAmount);
+                customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
+                customFofoOrderItem.setSgstAmount(sgstAmount);
+                marginSchemeFofoItems.add(customFofoOrderItem);
+                hasMarginSchemeItems = true;
+            } else {
+                // Regular: GST on full selling price
+                float taxableSellingPrice = (fofoOrderItem.getSellingPrice() + discount) / (1 + totalTaxRate / 100);
+                float taxableDiscountPrice = discount / (1 + totalTaxRate / 100);
+                customFofoOrderItem.setAmount(fofoOrderItem.getQuantity() * (taxableSellingPrice - taxableDiscountPrice));
+                customFofoOrderItem.setRate(taxableSellingPrice);
+                customFofoOrderItem.setDiscount(taxableDiscountPrice);
+                customFofoOrderItem.setNetAmount(fofoOrderItem.getSellingPrice() * fofoOrderItem.getQuantity());
+                float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
+                float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
+                float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
+                customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
+                customFofoOrderItem.setIgstAmount(igstAmount);
+                customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
+                customFofoOrderItem.setCgstAmount(cgstAmount);
+                customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
+                customFofoOrderItem.setSgstAmount(sgstAmount);
-            customerFofoOrderItems.add(customFofoOrderItem);
+                regularFofoItems.add(customFofoOrderItem);
+            }
         }
+        // Regular items first, then margin scheme items
+        List<CustomOrderItem> customerFofoOrderItems = new ArrayList<>(regularFofoItems);
+        customerFofoOrderItems.addAll(marginSchemeFofoItems);
         pdfModel.setOrderItems(customerFofoOrderItems);
+        pdfModel.setHasMarginSchemeItems(hasMarginSchemeItems);
+        if (hasMarginSchemeItems) {
+            List<String> declarations = new ArrayList<>();
+            declarations.add("Items marked under Margin Scheme are taxed under Rule 32(5) of CGST Rules, 2017.");
+            declarations.add("GST is charged on the margin (Selling Price - Purchase Price) and not on the full value of supply.");
+            declarations.add("Input Tax Credit is not available on margin scheme items.");
+            pdfModel.setMarginSchemeDeclarations(declarations);
+        }
         String customerAddressStateCode = "";
         String partnerAddressStateCode = stateRepository.selectByName(pdfModel.getRetailer().getAddress().getState()).getCode();
         if (pdfModel.getCustomer() != null && pdfModel.getCustomer().getAddress() != null &&
                 pdfModel.getCustomer().getAddress().getState() != null &&
                 !pdfModel.getCustomer().getAddress().getState().trim().isEmpty()) {
         pdfModel.setTncs(tncs);
         return pdfModel;
+    }
+    private float getFofoPurchasePrice(String serialNumber, int fofoId) {
+        try {
+            InventoryItem fofoInventoryItem = inventoryItemRepository.selectBySerialNumberFofoId(serialNumber, fofoId);
+            if (fofoInventoryItem != null) {
+                return fofoInventoryItem.getUnitPrice();
+            }
+        } catch (Exception e) {
+            LOGGER.error("Could not fetch FOFO purchase price for serial: {}, fofoId: {}", serialNumber, fofoId, e);
+        }
+        return 0;
+    }
     private CustomCustomer getCustomCustomer(FofoOrder fofoOrder, CustomAddress retailerAddress) throws
             ProfitMandiBusinessException {
         Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
         CustomCustomer customCustomer = new CustomCustomer();
         customCustomer.setFirstName(customer.getFirstName());
         List<CustomOrderItem> customerFofoOrderItems = new ArrayList<>();
         FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(creditNote.getFofoOrderItemId());
         float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate() + fofoOrderItem.getCgstRate();
-        float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
-        float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
         CustomOrderItem customFofoOrderItem = new CustomOrderItem();
-        customFofoOrderItem.setAmount(customerReturnItems.size() * (taxableSellingPrice - taxableDiscountPrice));
         customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " " + fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
+        List<String> serialNumbers = new ArrayList<>();
         if (ItemType.SERIALIZED.equals(itemRepository.selectById(fofoOrderItem.getItemId()).getType())) {
             Set<Integer> inventoryItemIds = customerReturnItems.stream().map(x -> x.getInventoryItemId()).collect(Collectors.toSet());
-            List<String> serialNumbers = inventoryItemRepository.selectByIds(inventoryItemIds).stream().map(x -> x.getSerialNumber()).collect(Collectors.toList());
+            serialNumbers = inventoryItemRepository.selectByIds(inventoryItemIds).stream().map(x -> x.getSerialNumber()).collect(Collectors.toList());
             customFofoOrderItem.setDescription(
                     customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
+        }
+        // Check if margin scheme item
+        boolean isMarginItem = false;
+        try {
+            Item item = itemRepository.selectById(fofoOrderItem.getItemId());
+            Category category = categoryRepository.selectById(item.getCategoryId());
+            isMarginItem = category.isMarginOnly() && !serialNumbers.isEmpty();
+        } catch (Exception e) {
+            LOGGER.warn("Could not check margin scheme for credit note item {}", fofoOrderItem.getId(), e);
+        }
+        if (isMarginItem) {
+            // Margin Scheme credit note: reverse GST on margin only
+            float purchasePrice = getFofoPurchasePrice(serialNumbers.get(0), fofoOrder.getFofoId());
+            float sellingPrice = fofoOrderItem.getSellingPrice();
+            float margin = Math.max(0, sellingPrice - purchasePrice);
+            float taxableMargin = margin / (1 + totalTaxRate / 100);
+            customFofoOrderItem.setMarginScheme(true);
+            customFofoOrderItem.setPurchasePrice(purchasePrice);
+            customFofoOrderItem.setSellingPrice(sellingPrice);
+            customFofoOrderItem.setMargin(margin);
+            customFofoOrderItem.setRate(sellingPrice);
+            customFofoOrderItem.setDiscount(0);
+            customFofoOrderItem.setAmount(taxableMargin * customerReturnItems.size());
+        } else {
+            float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
+            float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
+            customFofoOrderItem.setAmount(customerReturnItems.size() * (taxableSellingPrice - taxableDiscountPrice));
-        customFofoOrderItem.setRate(taxableSellingPrice);
+            customFofoOrderItem.setRate(taxableSellingPrice);
-        customFofoOrderItem.setDiscount(taxableDiscountPrice);
+            customFofoOrderItem.setDiscount(taxableDiscountPrice);
+        }
         customFofoOrderItem.setQuantity(customerReturnItems.size());
         customFofoOrderItem.setNetAmount(
                 (fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * customFofoOrderItem.getQuantity());
         float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
         pdfModel.setInvoiceDate(FormattingUtils.formatDate(fofoOrder.getCreateTimestamp()));
         pdfModel.setTitle("Credit Note");
         pdfModel.setRetailer(customRetailer);
         pdfModel.setTotalAmount(customFofoOrderItem.getNetAmount());
         pdfModel.setOrderItems(customerFofoOrderItems);
+        pdfModel.setHasMarginSchemeItems(isMarginItem);
         CreditNotePdfModel creditNotePdfModel = new CreditNotePdfModel();
         creditNotePdfModel.setCreditNoteDate(FormattingUtils.formatDate(creditNote.getCreateTimestamp()));
         creditNotePdfModel.setCreditNoteNumber(creditNote.getCreditNoteNumber());
         creditNotePdfModel.setPdfModel(pdfModel);

Subversion Repositories SmartDukaan

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