Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import com.spice.profitmandi.common.enumuration.FofoType;
import com.spice.profitmandi.common.enumuration.ItemType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.GrnModel;
import com.spice.profitmandi.common.model.InvoiceItemModel;
import com.spice.profitmandi.common.model.WarehouseInvoiceModel;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.transaction.LineItem;
import com.spice.profitmandi.dao.entity.transaction.Order;
import com.spice.profitmandi.dao.entity.warehouse.WarehousePurchaseOrder;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseSupplierInvoice;
import com.spice.profitmandi.dao.enumuration.warehouse.WarehouseInvoiceStatus;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseOrderRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseSupplierInvoiceRepository;
import com.spice.profitmandi.service.warehouse.InvoiceService;
import com.spice.profitmandi.service.warehouse.PurchaseOrderService;
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.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Receives one internal transfer invoice into the destination warehouse, following the same sequence the
 * portal performs: record the supplier invoice, record its items, then GRN it through
 * PurchaseOrderService.grnPoModels - the call behind the portal's Create GRN button.
 *
 * The Excel upload path (addPORowModels) is deliberately not used. It persists a supplier invoice without a
 * status, which the column does not allow, so that route cannot complete a receipt at all.
 *
 * Kept in its own bean on purpose: InternalGrnTask calls this through the Spring proxy, so the transaction
 * below is actually applied. Calling it from inside the driver would be a self invocation, the proxy would
 * be bypassed and the work would run with no transaction at all.
 */
@Component
public class InternalGrnReceiver {

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

    /** The portal stores the scanned supplier invoice against the receipt; an internal transfer has none. */
    private static final int NO_INVOICE_DOCUMENT = 0;

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private ItemRepository itemRepository;

    @Autowired
    private FofoStoreRepository fofoStoreRepository;

    @Autowired
    private AuthRepository authRepository;

    @Autowired
    private WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;

    @Autowired
    private WarehouseSupplierInvoiceRepository warehouseSupplierInvoiceRepository;

    @Autowired
    private InvoiceService invoiceService;

    @Autowired
    private PurchaseOrderService purchaseOrderService;

    /** One item of an invoice, gathered across the orders that share it. */
    private static class ReceiptLine {
        private int itemId;
        private boolean serialized;
        private float rate;
        private int qty;
        private final List<String> serialNumbers = new ArrayList<>();
    }

    /**
     * Each invoice commits or rolls back on its own so one bad invoice cannot undo those already received.
     *
     * @return true when the invoice was received (or would be, on a dry run), false when it was skipped.
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Throwable.class)
    public boolean grnInvoice(String invoiceNumber, String operatorEmail, boolean dryRun) throws ProfitMandiBusinessException {
        List<Order> orders = orderRepository.selectByInvoiceNumber(invoiceNumber);
        if (orders.isEmpty()) {
            LOGGER.info("SKIP    {} - no orders for this invoice", invoiceNumber);
            return false;
        }

        // Only our own stock moving between our own warehouses - never auto-receive a partner's goods.
        FofoStore buyer = fofoStoreRepository.selectByRetailerId(orders.get(0).getRetailerId());
        if (buyer == null || !FofoType.INTERNAL.equals(buyer.getFofoType())) {
            LOGGER.info("SKIP    {} - buyer {} is not an INTERNAL store", invoiceNumber, orders.get(0).getRetailerId());
            return false;
        }

        WarehousePurchaseOrder purchaseOrder = resolvePurchaseOrder(invoiceNumber, orders);
        if (purchaseOrder == null) {
            return false;
        }

        WarehouseSupplierInvoice existing = warehouseSupplierInvoiceRepository
                .selectAllBySupplierInvoice(purchaseOrder.getSupplierId(), invoiceNumber);
        if (existing != null) {
            LOGGER.info("SKIP    {} - already received (invoice id {}, status {})",
                    invoiceNumber, existing.getId(), existing.getStatus());
            return false;
        }

        // grnPoModels takes one entry per item, carrying every serial of that item, so gather the orders by item.
        Map<Integer, ReceiptLine> linesByItem = new LinkedHashMap<>();
        for (Order order : orders) {
            LineItem lineItem = order.getLineItem();
            if (lineItem == null) {
                LOGGER.info("SKIP    {} - order {} has no line item", invoiceNumber, order.getId());
                return false;
            }
            Item item = itemRepository.selectById(lineItem.getItemId());
            if (item == null) {
                LOGGER.info("SKIP    {} - item {} not found", invoiceNumber, lineItem.getItemId());
                return false;
            }

            boolean serialized = ItemType.SERIALIZED.equals(item.getType());
            int quantity = lineItem.getQuantity();

            // A line item carries one serial per unit, comma separated - never a single serial for the line.
            // Handing the whole field over as one serial stores a string no scan can match and records the
            // line as one unit, so the serials are split out and counted against the quantity here.
            List<String> serialNumbers = new ArrayList<>();
            if (serialized) {
                String serialField = lineItem.getSerialNumber();
                if (serialField != null) {
                    for (String serialNumber : serialField.split(",")) {
                        if (!serialNumber.trim().isEmpty()) {
                            serialNumbers.add(serialNumber.trim());
                        }
                    }
                }
                if (serialNumbers.size() != quantity) {
                    LOGGER.info("SKIP    {} - serialized item {} on order {} has {} serial(s) for {} unit(s)",
                            invoiceNumber, item.getId(), order.getId(), serialNumbers.size(), quantity);
                    return false;
                }
            }

            ReceiptLine line = linesByItem.get(lineItem.getItemId());
            if (line == null) {
                line = new ReceiptLine();
                line.itemId = lineItem.getItemId();
                line.serialized = serialized;
                line.rate = lineItem.getUnitPrice();
                linesByItem.put(line.itemId, line);
            }
            line.qty += quantity;
            line.serialNumbers.addAll(serialNumbers);
        }

        int numItems = 0;
        int serialisedUnits = 0;
        BigDecimal value = BigDecimal.ZERO;
        for (ReceiptLine line : linesByItem.values()) {
            numItems += line.qty;
            serialisedUnits += line.serialNumbers.size();
            value = value.add(BigDecimal.valueOf(line.rate).multiply(BigDecimal.valueOf(line.qty)));
        }

        if (dryRun) {
            LOGGER.info("WOULD GRN {} - po {} (id {}), warehouse {}, supplier {}, {} item(s), {} unit(s), {} serialized, value {}",
                    invoiceNumber, purchaseOrder.getPoNumber(), purchaseOrder.getId(), purchaseOrder.getWarehouseId(),
                    purchaseOrder.getSupplierId(), linesByItem.size(), numItems, serialisedUnits, value.toPlainString());
            for (ReceiptLine line : linesByItem.values()) {
                LOGGER.info("          item {} qty {} rate {} serials {}",
                        line.itemId, line.qty, line.rate,
                        line.serialNumbers.isEmpty() ? "-" : line.serialNumbers);
            }
            return true;
        }

        // 1. Record the supplier invoice, as the portal's Receive Invoice screen does.
        AuthUser operator = authRepository.selectByEmailOrMobile(operatorEmail);
        WarehouseSupplierInvoice invoice = new WarehouseSupplierInvoice();
        invoice.setInvoiceNumber(invoiceNumber);
        invoice.setInvoiceDate(orders.get(0).getBillingTimestamp());
        invoice.setSupplierId(purchaseOrder.getSupplierId());
        invoice.setWarehouseId(purchaseOrder.getWarehouseId());
        invoice.setCreateDate(LocalDateTime.now());
        invoice.setReceivedFrom(operator.getFullName());
        invoice.setNumItems(numItems);
        invoice.setTotalValue(value.floatValue());
        invoice.setStatus(WarehouseInvoiceStatus.init);
        invoice.setInvoiceDocId(NO_INVOICE_DOCUMENT);
        warehouseSupplierInvoiceRepository.persist(invoice);

        // 2. Record its items, as the Add Item screen does - the buying reports read these rows.
        WarehouseInvoiceModel invoiceModel = new WarehouseInvoiceModel();
        invoiceModel.setInvoiceId(invoice.getId());
        invoiceModel.setSupplierId(purchaseOrder.getSupplierId());
        invoiceModel.setWarehouseId(purchaseOrder.getWarehouseId());
        List<InvoiceItemModel> invoiceItems = new ArrayList<>();
        for (ReceiptLine line : linesByItem.values()) {
            InvoiceItemModel invoiceItem = new InvoiceItemModel();
            invoiceItem.setItemId(line.itemId);
            invoiceItem.setQty(line.qty);
            invoiceItem.setRate(line.rate);
            invoiceItems.add(invoiceItem);
        }
        invoiceModel.setInvoiceItems(invoiceItems);
        invoiceService.createInvoiceItem(invoiceModel);

        // 3. GRN it, exactly as the portal's Create GRN button does.
        List<GrnModel> grnModels = new ArrayList<>();
        for (ReceiptLine line : linesByItem.values()) {
            GrnModel grnModel = new GrnModel();
            grnModel.setPoId(purchaseOrder.getId());
            grnModel.setInvoiceId(invoice.getId());
            grnModel.setItemId(line.itemId);
            grnModel.setQty(line.qty);
            grnModel.setInvoicePrice(line.rate);
            grnModel.setSerialNumbers(line.serialized ? line.serialNumbers : new ArrayList<String>());
            grnModels.add(grnModel);
        }
        Map<Integer, Map<Integer, List<GrnModel>>> grnModelsMap = Collections.singletonMap(
                purchaseOrder.getId(), Collections.singletonMap(invoice.getId(), grnModels));
        purchaseOrderService.grnPoModels(operatorEmail, grnModelsMap);

        LOGGER.info("GRNED   {} - po {}, warehouse {}, invoice id {}, {} item(s), {} unit(s), {} serialized, value {}",
                invoiceNumber, purchaseOrder.getPoNumber(), purchaseOrder.getWarehouseId(), invoice.getId(),
                linesByItem.size(), numItems, serialisedUnits, value.toPlainString());
        return true;
    }

    /**
     * Creating an internal PO raises one transaction and records it on the order
     * (PurchaseOrderServiceImpl: warehousePurchaseOrder.setTransactionId), so that is the mapping back from
     * an invoice to its PO. order.purchase_order_id is not it - nothing populates it on this route.
     *
     * The invoice's orders all belong to that one transaction; if they ever did not, the PO is ambiguous and
     * the invoice is left alone rather than guessed at.
     */
    private WarehousePurchaseOrder resolvePurchaseOrder(String invoiceNumber, List<Order> orders) {
        Set<Integer> transactionIds = new HashSet<>();
        for (Order order : orders) {
            transactionIds.add(order.getTransactionId());
        }
        if (transactionIds.size() > 1) {
            LOGGER.info("SKIP    {} - spans {} transactions {}", invoiceNumber, transactionIds.size(), transactionIds);
            return null;
        }
        int transactionId = transactionIds.iterator().next();
        WarehousePurchaseOrder purchaseOrder = warehousePurchaseOrderRepository.selectByTransactionId(transactionId);
        if (purchaseOrder == null) {
            LOGGER.info("SKIP    {} - no purchase order mapped to transaction {}", invoiceNumber, transactionId);
            return null;
        }
        return purchaseOrder;
    }
}