Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import com.spice.profitmandi.common.enumuration.ItemType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.inventory.InventoryWarehouse;
import com.spice.profitmandi.dao.entity.inventory.SaholicInventorySnapshot;
import com.spice.profitmandi.dao.entity.transaction.Order;
import com.spice.profitmandi.dao.entity.warehouse.Supplier;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;
import com.spice.profitmandi.dao.entity.warehouse.WarehousePurchaseOrder;
import com.spice.profitmandi.dao.model.transaction.OrderBillingModel;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.inventory.InventoryWarehouseRepository;
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
import com.spice.profitmandi.dao.repository.warehouse.SupplierRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseOrderRepository;
import com.spice.profitmandi.service.inventory.SaholicInventoryService;
import com.spice.profitmandi.service.transaction.TransactionService;
import com.spice.profitmandi.service.warehouse.WarehouseServiceImpl;
import in.shop2020.model.v1.inventory.InventoryType;
import in.shop2020.model.v1.inventory.WarehouseType;
import in.shop2020.model.v1.order.OrderStatus;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Bills the orders an internal movement PO raised, the way a biller does it on the order management screen: an order
 * parked on the Dummy (its brand has no source mapping) is first pointed at the vendor warehouse that holds the stock,
 * serialized units are taken oldest first from that vendor warehouse - only IMEIs whose last scan leaves them in stock -
 * and the whole transaction is billed as one invoice through acceptOrders / addBillingDetailsForGrouppedOrders.
 *
 * The plan is worked out the same way for a dry run and a live one, and the live run re-plans inside its transaction,
 * so nothing is billed unless every order of the transaction can be. The dry run makes no billing calls at all:
 * billing opens a REQUIRES_NEW transaction of its own (createLoanForBilling) that a rollback would not undo.
 */
@Component
public class MovementBiller {

    private static final Logger LOGGER = LogManager.getLogger(MovementBiller.class);

    // NIC rejects an IRN with more than 1000 item lines; one order is one line.
    private static final int MAX_INVOICE_LINES = 900;

    @Autowired
    private WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;
    @Autowired
    private SupplierRepository supplierRepository;
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private TransactionService transactionService;
    @Autowired
    private SaholicInventoryService saholicInventoryService;
    @Autowired
    private InventoryWarehouseRepository inventoryWarehouseRepository;
    @Autowired
    private WarehouseInventoryItemRepository warehouseInventoryItemRepository;
    @Autowired
    private AuthRepository authRepository;

    /** One invoice line: an order, the vendor warehouse it bills from and the IMEIs it takes. */
    static class Line {
        int orderId;
        int itemId;
        String item;
        int qty;
        int fromWarehouseId;
        boolean repoint;
        boolean serialized;
        List<String> imeis = new ArrayList<>();
    }

    static class Plan {
        int transactionId;
        String poNumber;
        int sourceWarehouseId;
        int destinationWarehouseId;
        List<Line> lines = new ArrayList<>();
        List<String> problems = new ArrayList<>();
    }

    @Transactional(readOnly = true, rollbackFor = Throwable.class)
    public Plan describe(int transactionId) throws ProfitMandiBusinessException {
        return this.plan(transactionId);
    }

    /** Bills the whole transaction or nothing. Returns the invoice number. */
    @Transactional(rollbackFor = Throwable.class)
    public String bill(int transactionId, String operatorEmail, int logisticsProviderId) throws Exception {
        AuthUser operator = authRepository.selectByEmailOrMobile(operatorEmail);
        if (operator == null) {
            throw new ProfitMandiBusinessException("email", operatorEmail, "No auth user for " + operatorEmail);
        }
        Plan plan = this.plan(transactionId);
        if (!plan.problems.isEmpty()) {
            throw new ProfitMandiBusinessException("transaction", transactionId, String.join("; ", plan.problems));
        }

        // Point Dummy-parked orders at the vendor warehouse holding the stock, splitting an order whose quantity
        // comes from more than one vendor warehouse. The remainder of a split keeps the Dummy until its own chunk.
        Map<Integer, Integer> remainderOf = new HashMap<>();
        for (Line line : plan.lines) {
            if (!line.repoint) {
                continue;
            }
            int orderId = remainderOf.getOrDefault(line.orderId, line.orderId);
            Order order = orderRepository.selectById(orderId);
            int orderQty = order.getLineItem().getQuantity();
            if (line.qty < orderQty) {
                Order remainder = transactionService.splitOrder(orderId, orderQty - line.qty);
                remainderOf.put(line.orderId, remainder.getId());
            }
            transactionService.changeFulfillmentWarehouse(orderId, line.fromWarehouseId);
            line.orderId = orderId;
        }

        List<OrderBillingModel> models = new ArrayList<>();
        for (Line line : plan.lines) {
            OrderBillingModel model = new OrderBillingModel();
            model.setOrderId(line.orderId);
            model.setQuantityToBill(line.qty);
            model.setSerialNumbersToBill(line.imeis.stream().map(String::toLowerCase).collect(Collectors.toList()));
            model.setLogisticsProviderId(logisticsProviderId);
            model.setDistance("");
            models.add(model);
        }
        transactionService.acceptOrders(models);
        String invoiceNumber = transactionService.addBillingDetailsForGrouppedOrders(models, plan.sourceWarehouseId,
                operator.getFirstName());
        if (invoiceNumber != null) {
            transactionService.checkOrderDispatchEligibility(transactionId, invoiceNumber);
        }
        LOGGER.info("BILLED   txn {} PO {} {} -> {} : invoice {}, {} line(s), {} unit(s)", transactionId, plan.poNumber,
                plan.sourceWarehouseId, plan.destinationWarehouseId, invoiceNumber, plan.lines.size(),
                plan.lines.stream().mapToInt(x -> x.qty).sum());
        return invoiceNumber;
    }

    private Plan plan(int transactionId) throws ProfitMandiBusinessException {
        Plan plan = new Plan();
        plan.transactionId = transactionId;

        WarehousePurchaseOrder po = warehousePurchaseOrderRepository.selectByTransactionId(transactionId);
        if (po == null) {
            plan.problems.add("no purchase order is raised on transaction " + transactionId);
            return plan;
        }
        plan.poNumber = po.getPoNumber();
        plan.destinationWarehouseId = po.getWarehouseId();
        Supplier supplier = supplierRepository.selectById(po.getSupplierId());
        if (supplier == null || !supplier.isInternal() || supplier.getInternalWarehouseId() == null
                || supplier.getInternalWarehouseId() <= 0) {
            plan.problems.add("PO " + po.getPoNumber() + " is not an internal movement");
            return plan;
        }
        plan.sourceWarehouseId = supplier.getInternalWarehouseId();

        List<Order> orders = orderRepository.selectAllByTransactionIdAndWarehouseId(transactionId, plan.sourceWarehouseId)
                .stream().filter(x -> OrderStatus.SUBMITTED_FOR_PROCESSING.equals(x.getStatus()))
                .sorted(Comparator.comparing(Order::getId)).collect(Collectors.toList());
        if (orders.isEmpty()) {
            plan.problems.add("nothing left to bill on transaction " + transactionId + " (no order awaiting billing)");
            return plan;
        }

        List<Integer> itemIds = orders.stream().map(x -> x.getLineItem().getItemId()).distinct().collect(Collectors.toList());
        Map<Integer, InventoryWarehouse> warehouses = new HashMap<>();
        // free = what a vendor warehouse can still give to an order parked elsewhere
        Map<String, Integer> free = new HashMap<>();
        Map<String, Integer> available = new HashMap<>();
        Map<Integer, List<Integer>> realWarehousesByItem = new HashMap<>();
        for (SaholicInventorySnapshot snapshot : saholicInventoryService.getByWarehouseIdItemIds(plan.sourceWarehouseId, itemIds)) {
            if (!this.isRealVendorWarehouse(snapshot.getWarehouseId(), plan.sourceWarehouseId, warehouses)) {
                continue;
            }
            String key = key(snapshot.getWarehouseId(), snapshot.getItemId());
            available.put(key, snapshot.getAvailability());
            free.put(key, Math.max(snapshot.getAvailability() - snapshot.getReserved(), 0));
            realWarehousesByItem.computeIfAbsent(snapshot.getItemId(), x -> new ArrayList<>()).add(snapshot.getWarehouseId());
        }

        Map<String, List<String>> serialPools = new HashMap<>();
        Map<String, Integer> lotPools = new HashMap<>();
        for (Order order : orders) {
            Item item = order.getLineItem().getItem();
            int itemId = item.getId();
            int qty = order.getLineItem().getQuantity();
            boolean serialized = ItemType.SERIALIZED.equals(item.getType());
            String description = item.getItemDescription() + " (" + itemId + ")";

            // where the units come from: the order's own vendor warehouse, or - when parked - the ones with free stock
            Map<Integer, Integer> chunks = new LinkedHashMap<>();
            boolean repoint = !this.isRealVendorWarehouse(order.getFulfilmentWarehouseId(), plan.sourceWarehouseId, warehouses);
            if (!repoint) {
                int fulfilment = order.getFulfilmentWarehouseId();
                if (available.getOrDefault(key(fulfilment, itemId), 0) < qty) {
                    plan.problems.add("order " + order.getId() + " " + description + ": billing snapshot of warehouse "
                            + fulfilment + " shows " + available.getOrDefault(key(fulfilment, itemId), 0) + ", needs " + qty);
                    continue;
                }
                chunks.put(fulfilment, qty);
            } else {
                List<Integer> candidates = new ArrayList<>(realWarehousesByItem.getOrDefault(itemId, Collections.emptyList()));
                candidates.sort(Comparator.comparing((Integer w) -> free.getOrDefault(key(w, itemId), 0)).reversed());
                int remaining = qty;
                for (Integer warehouseId : candidates) {
                    int take = Math.min(remaining, free.getOrDefault(key(warehouseId, itemId), 0));
                    if (take > 0) {
                        chunks.put(warehouseId, take);
                        free.put(key(warehouseId, itemId), free.get(key(warehouseId, itemId)) - take);
                        remaining -= take;
                    }
                    if (remaining == 0) {
                        break;
                    }
                }
                if (remaining > 0) {
                    plan.problems.add("order " + order.getId() + " " + description + ": only " + (qty - remaining)
                            + " of " + qty + " free in the source's vendor warehouses");
                    continue;
                }
            }

            for (Map.Entry<Integer, Integer> chunk : chunks.entrySet()) {
                Line line = new Line();
                line.orderId = order.getId();
                line.itemId = itemId;
                line.item = description;
                line.qty = chunk.getValue();
                line.fromWarehouseId = chunk.getKey();
                line.repoint = repoint;
                line.serialized = serialized;
                String poolKey = key(chunk.getKey(), itemId);
                if (serialized) {
                    List<String> pool = serialPools.computeIfAbsent(poolKey, x -> this.billableImeis(itemId, chunk.getKey()));
                    if (pool.size() < line.qty) {
                        plan.problems.add("order " + order.getId() + " " + description + ": " + pool.size()
                                + " billable IMEI(s) in warehouse " + chunk.getKey() + ", needs " + line.qty);
                        continue;
                    }
                    line.imeis.addAll(pool.subList(0, line.qty));
                    pool.subList(0, line.qty).clear();
                } else {
                    int lots = lotPools.computeIfAbsent(poolKey, x -> this.billableLotQuantity(itemId, chunk.getKey()));
                    if (lots < line.qty) {
                        plan.problems.add("order " + order.getId() + " " + description + ": " + lots
                                + " billable unit(s) in warehouse " + chunk.getKey() + ", needs " + line.qty);
                        continue;
                    }
                    lotPools.put(poolKey, lots - line.qty);
                }
                plan.lines.add(line);
            }
        }
        if (plan.lines.size() > MAX_INVOICE_LINES) {
            plan.problems.add(plan.lines.size() + " invoice lines exceed the " + MAX_INVOICE_LINES
                    + " allowed on one IRN; raise the movement as smaller POs");
        }
        return plan;
    }

    // Billing takes an IMEI only at quantity 1 with a last scan that leaves it in stock (WarehouseServiceImpl billing).
    private List<String> billableImeis(int itemId, int vendorWarehouseId) {
        return warehouseInventoryItemRepository.selectBillableStock(itemId, vendorWarehouseId).stream()
                .filter(x -> x.getCurrentQuantity() == 1 && x.getSerialNumber() != null && !x.getSerialNumber().trim().isEmpty())
                .filter(x -> WarehouseServiceImpl.GOOD_SCAN_TYPES.contains(x.getLastScanType()))
                .sorted(Comparator.comparing(WarehouseInventoryItem::getCreated, Comparator.nullsFirst(Comparator.naturalOrder())))
                .map(WarehouseInventoryItem::getSerialNumber)
                .collect(Collectors.toCollection(ArrayList::new));
    }

    private int billableLotQuantity(int itemId, int vendorWarehouseId) {
        return warehouseInventoryItemRepository.selectBillableStock(itemId, vendorWarehouseId).stream()
                .filter(x -> x.getCurrentQuantity() > 0)
                .mapToInt(WarehouseInventoryItem::getCurrentQuantity).sum();
    }

    // A vendor warehouse the source bills from: its own OURS/GOOD stock, not the Dummy phantom target.
    private boolean isRealVendorWarehouse(Integer warehouseId, int sourceWarehouseId, Map<Integer, InventoryWarehouse> cache) {
        if (warehouseId == null) {
            return false;
        }
        InventoryWarehouse warehouse = cache.computeIfAbsent(warehouseId, inventoryWarehouseRepository::selectById);
        return warehouse != null && warehouse.getBillingWarehouseId() == sourceWarehouseId
                && warehouse.getVendorId() != ProfitMandiConstants.DEFAULT_FALLBACK_VENDOR_ID
                && InventoryType.GOOD.equals(warehouse.getInventoryType())
                && WarehouseType.OURS.equals(warehouse.getWarehouseType());
    }

    private static String key(int warehouseId, int itemId) {
        return warehouseId + ":" + itemId;
    }
}