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

 package com.spice.profitmandi.service.catalog;
 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
-import com.spice.profitmandi.common.web.client.RestClient;
+import com.spice.profitmandi.common.model.ComboCancellationResult;
+import com.spice.profitmandi.common.model.ComboCancellationResult.ComboLinkedOrder;
 import com.spice.profitmandi.dao.entity.catalog.*;
 import com.spice.profitmandi.dao.entity.fofo.FofoStore;
+import com.spice.profitmandi.dao.entity.transaction.Order;
+import in.shop2020.model.v1.order.OrderStatus;
 import com.spice.profitmandi.dao.model.UserCart;
 import com.spice.profitmandi.dao.repository.catalog.*;
 import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
+import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
 import com.spice.profitmandi.dao.repository.user.CartLineRepository;
 import com.spice.profitmandi.dao.repository.user.UserRepository;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.springframework.beans.factory.annotation.Autowired;
     @Autowired
     ComboOptionRepository comboOptionRepository;
     @Autowired
     ComboMappedModelRepository comboMappedModelRepository;
+    @Autowired
+    OrderRepository orderRepository;
     private static final Logger LOGGER = LogManager.getLogger(ComboServiceImpl.class);
     @Override
     public boolean validateCombo(UserCart userCart) throws ProfitMandiBusinessException {
         Map<Integer, Integer> itemQtyMap = cartLineRepository.selectAllByCart(userCart.getCartId()).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getQuantity()));
                 throw new ProfitMandiBusinessException("FOC items cant be billed above Combo Qty", "FOC", "FOC items cant be billed above Combo Qty");
+            }
+        }
         return true;
+    }
+    // Combo cancellation rules (linkage resolved via the catalog combo definition, NOT just shared transaction):
+    //   secondary is FOC      -> cancel main: auto-cancel the FOC (silent);  cancel FOC: standalone OK, main stays
+    //   secondary is non-FOC  -> cancel main: standalone OK, secondary stays; cancel secondary: force-cancel main (confirm)
+    @Override
+    public ComboCancellationResult checkOrderCancellationForCombo(List<Order> orders) {
+        ComboCancellationResult result = ComboCancellationResult.noCombo();
+        if (orders == null || orders.isEmpty()) {
+            return result;
+        }
+        Set<Integer> cancelledIds = orders.stream().map(Order::getId).collect(Collectors.toSet());
+        Map<Integer, List<Order>> cancelledByTransaction = orders.stream()
+                .filter(o -> o.getTransactionId() != null)
+                .collect(Collectors.groupingBy(Order::getTransactionId));
+        Set<Integer> autoCancelFocIds = new HashSet<>();
+        Set<Integer> linkedMainIds = new HashSet<>();
+        for (Map.Entry<Integer, List<Order>> entry : cancelledByTransaction.entrySet()) {
+            List<Order> cancelledInTransaction = entry.getValue();
+            List<Order> siblings = orderRepository.selectAllByTransactionId(entry.getKey());
+            if (siblings == null || siblings.isEmpty()) {
+                continue;
+            }
+            Integer warehouseId = resolveWarehouseId(siblings);
+            if (warehouseId == null) {
+                continue;
+            }
+            Map<Integer, Integer> orderIdToCatalogId = resolveOrderCatalogIds(siblings);
+            // main-catalog -> secondary-catalogs, from the combo definition for this warehouse
+            Map<Integer, Set<Integer>> mainToSecondaries =
+                    buildComboCatalogMap(new ArrayList<>(new HashSet<>(orderIdToCatalogId.values())), warehouseId);
+            if (mainToSecondaries.isEmpty()) {
+                continue;
+            }
+            // inverse: secondary-catalog -> main-catalogs
+            Map<Integer, Set<Integer>> secondaryToMains = new HashMap<>();
+            for (Map.Entry<Integer, Set<Integer>> e : mainToSecondaries.entrySet()) {
+                for (Integer secondaryCatalog : e.getValue()) {
+                    secondaryToMains.computeIfAbsent(secondaryCatalog, k -> new HashSet<>()).add(e.getKey());
+                }
+            }
+            // siblings indexed by their catalog id
+            Map<Integer, List<Order>> siblingsByCatalog = new HashMap<>();
+            for (Order sibling : siblings) {
+                Integer catalogId = orderIdToCatalogId.get(sibling.getId());
+                if (catalogId != null) {
+                    siblingsByCatalog.computeIfAbsent(catalogId, k -> new ArrayList<>()).add(sibling);
+                }
+            }
+            // mains that will be cancelled = user-selected mains + mains forced by a non-FOC secondary cancel
+            Set<Integer> mainOrderIdsToCancel = new HashSet<>();
+            for (Order cancelled : cancelledInTransaction) {
+                Integer catalogId = orderIdToCatalogId.get(cancelled.getId());
+                if (catalogId != null && mainToSecondaries.containsKey(catalogId)) {
+                    mainOrderIdsToCancel.add(cancelled.getId());
+                }
+            }
+            // Pass 1: a non-FOC secondary being cancelled mandatorily cancels its main(s) -> ask for confirmation
+            for (Order cancelled : cancelledInTransaction) {
+                Integer catalogId = orderIdToCatalogId.get(cancelled.getId());
+                if (catalogId == null || !secondaryToMains.containsKey(catalogId) || isFoc(cancelled)) {
+                    continue;
+                }
+                for (Integer mainCatalog : secondaryToMains.get(catalogId)) {
+                    for (Order mainOrder : siblingsByCatalog.getOrDefault(mainCatalog, Collections.emptyList())) {
+                        if (cancelledIds.contains(mainOrder.getId())
+                                || !OrderStatus.SUBMITTED_FOR_PROCESSING.equals(mainOrder.getStatus())) {
+                            continue;
+                        }
+                        mainOrderIdsToCancel.add(mainOrder.getId());
+                        if (linkedMainIds.add(mainOrder.getId())) {
+                            result.setConfirmationRequired(true);
+                            result.getLinkedMainOrders().add(new ComboLinkedOrder(
+                                    mainOrder.getId(),
+                                    mainOrder.getLineItem().getBrand() + " " + mainOrder.getLineItem().getModelName() + " " + mainOrder.getLineItem().getModelNumber(),
+                                    mainOrder.getLineItem().getQuantity()
+                            ));
+                        }
+                    }
+                }
+            }
+            // Pass 2: every main being cancelled auto-cancels its FOC secondaries (the free gift follows the main)
+            for (Integer mainOrderId : mainOrderIdsToCancel) {
+                Integer mainCatalog = orderIdToCatalogId.get(mainOrderId);
+                if (mainCatalog == null) {
+                    continue;
+                }
+                for (Integer secondaryCatalog : mainToSecondaries.getOrDefault(mainCatalog, Collections.emptySet())) {
+                    for (Order secondary : siblingsByCatalog.getOrDefault(secondaryCatalog, Collections.emptyList())) {
+                        if (!cancelledIds.contains(secondary.getId())
+                                && OrderStatus.SUBMITTED_FOR_PROCESSING.equals(secondary.getStatus())
+                                && isFoc(secondary)) {
+                            autoCancelFocIds.add(secondary.getId());
+                        }
+                    }
+                }
+            }
+        }
+        result.getAutoCancelFocOrderIds().addAll(autoCancelFocIds);
+        return result;
+    }
+    private boolean isFoc(Order order) {
+        return order.getLineItem() != null && "FOC".equals(order.getLineItem().getBrand());
+    }
+    private Integer resolveWarehouseId(List<Order> siblings) {
+        for (Order order : siblings) {
+            if (order.getRetailerId() == null) {
+                continue;
+            }
+            try {
+                FofoStore store = fofoStoreRepository.selectByRetailerId(order.getRetailerId());
+                if (store != null) {
+                    return store.getWarehouseId();
+                }
+            } catch (Exception e) {
+                LOGGER.warn("Combo cancel: unable to resolve warehouse for retailer {} - {}", order.getRetailerId(), e.getMessage());
+            }
+        }
+        return null;
+    }
+    private Map<Integer, Integer> resolveOrderCatalogIds(List<Order> siblings) {
+        Set<Integer> itemIds = siblings.stream()
+                .filter(o -> o.getLineItem() != null && o.getLineItem().getItemId() != null)
+                .map(o -> o.getLineItem().getItemId())
+                .collect(Collectors.toSet());
+        Map<Integer, Integer> itemIdToCatalogId = new HashMap<>();
+        if (!itemIds.isEmpty()) {
+            try {
+                for (Item item : itemRepository.selectByIds(itemIds)) {
+                    itemIdToCatalogId.put(item.getId(), item.getCatalogItemId());
+                }
+            } catch (Exception e) {
+                LOGGER.warn("Combo cancel: unable to resolve items - {}", e.getMessage());
+            }
+        }
+        Map<Integer, Integer> orderIdToCatalogId = new HashMap<>();
+        for (Order order : siblings) {
+            if (order.getLineItem() == null || order.getLineItem().getItemId() == null) {
+                continue;
+            }
+            Integer catalogId = itemIdToCatalogId.get(order.getLineItem().getItemId());
+            if (catalogId != null) {
+                orderIdToCatalogId.put(order.getId(), catalogId);
+            }
+        }
+        return orderIdToCatalogId;
+    }
+    private Map<Integer, Set<Integer>> buildComboCatalogMap(List<Integer> catalogIds, int warehouseId) {
+        Map<Integer, Set<Integer>> mainToSecondaries = new HashMap<>();
+        if (catalogIds.isEmpty()) {
+            return mainToSecondaries;
+        }
+        List<ComboModel> comboModels = comboModelRepository.selectByCatalogIdsAndWarehouseId(catalogIds, warehouseId);
+        for (ComboModel comboModel : comboModels) {
+            for (ComboOption comboOption : comboOptionRepository.selectByComboId(comboModel.getId())) {
+                for (ComboMappedModel mappedModel : comboMappedModelRepository.selectByComboOptionId(comboOption.getId())) {
+                    mainToSecondaries
+                            .computeIfAbsent(comboModel.getCatalogId(), k -> new HashSet<>())
+                            .add(mappedModel.getComboCatalogId());
+                }
+            }
+        }
+        return mainToSecondaries;
+    }
+}

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/catalog/ComboServiceImpl.java – Rev 33916 → 36960