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.PORowModel;
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.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.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.List;
import java.util.Map;
import java.util.Set;

/**
 * Receives stock into the destination warehouse for internal transfer invoices that were billed but never
 * GRNed. Per invoice it builds the rows the Excel GRN upload would have carried and hands them to
 * PurchaseOrderService.addPORowModels, which creates the supplier invoice, the purchase and the inventory
 * items in one call - the same path the portal uses, so nothing here reimplements receiving.
 *
 * Deliberately narrow: only INTERNAL buyers, only invoices not already received, and a serialized line with
 * no serial number aborts its invoice rather than creating stock that cannot be traced to a unit.
 */
@Component
public class InternalGrnTask {

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

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private ItemRepository itemRepository;

    @Autowired
    private FofoStoreRepository fofoStoreRepository;

    @Autowired
    private WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;

    @Autowired
    private WarehouseSupplierInvoiceRepository warehouseSupplierInvoiceRepository;

    @Autowired
    private PurchaseOrderService purchaseOrderService;

    /**
     * Drives the run without holding a transaction of its own, so one invoice failing cannot roll back the
     * invoices already received - each invoice commits or rolls back on its own inside grnInvoice.
     */
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void grnInternalInvoices(List<String> invoiceNumbers, String operatorEmail, boolean dryRun) {
        LOGGER.info("=== Internal GRN {} : {} invoice(s), operator {} ===",
                dryRun ? "DRY RUN (no writes)" : "LIVE RUN", invoiceNumbers.size(), operatorEmail);
        int received = 0;
        int skipped = 0;
        int failed = 0;
        for (String invoiceNumber : invoiceNumbers) {
            try {
                if (grnInvoice(invoiceNumber.trim(), operatorEmail, dryRun)) {
                    received++;
                } else {
                    skipped++;
                }
            } catch (Exception e) {
                failed++;
                LOGGER.error("FAILED  {} - {}", invoiceNumber, e.getMessage(), e);
            }
        }
        LOGGER.info("=== Internal GRN {} complete : {} {}, {} skipped, {} failed ===",
                dryRun ? "DRY RUN" : "LIVE RUN", received, dryRun ? "would be received" : "received",
                skipped, failed);
    }

    /**
     * @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;
        }

        // An internal PO reaches its orders through the transaction it raised, not through order.purchase_order_id.
        Set<Integer> transactionIds = new HashSet<>();
        for (Order order : orders) {
            transactionIds.add(order.getTransactionId());
        }
        Set<Integer> poIds = new HashSet<>();
        WarehousePurchaseOrder purchaseOrder = null;
        for (Integer transactionId : transactionIds) {
            WarehousePurchaseOrder po = warehousePurchaseOrderRepository.selectByTransactionId(transactionId);
            if (po != null && poIds.add(po.getId())) {
                purchaseOrder = po;
            }
        }
        if (purchaseOrder == null) {
            LOGGER.info("SKIP    {} - no purchase order found for transaction(s) {}", invoiceNumber, transactionIds);
            return false;
        }
        // addPORowModels resolves a single PO for the whole map, so an invoice spanning POs cannot be trusted to it.
        if (poIds.size() > 1) {
            LOGGER.info("SKIP    {} - spans {} purchase orders {}", invoiceNumber, poIds.size(), poIds);
            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;
        }

        LocalDateTime receivedDate = LocalDateTime.now();
        List<PORowModel> rows = new ArrayList<>();
        BigDecimal value = BigDecimal.ZERO;
        int serials = 0;
        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;
            }

            String serialNumber = lineItem.getSerialNumber();
            boolean serialized = ItemType.SERIALIZED.equals(item.getType());
            // Receiving a serialized unit without its serial would create stock no scan could ever match.
            if (serialized && (serialNumber == null || serialNumber.trim().isEmpty())) {
                LOGGER.info("SKIP    {} - serialized item {} on order {} has no serial number",
                        invoiceNumber, item.getId(), order.getId());
                return false;
            }
            if (serialized) {
                serials++;
            }

            PORowModel row = new PORowModel();
            row.setPoNumber(purchaseOrder.getPoNumber());
            row.setInvoiceNumber(invoiceNumber);
            row.setInvoiceDate(order.getBillingTimestamp());
            row.setReceivedDate(receivedDate);
            row.setItemId(lineItem.getItemId());
            row.setQuantity(lineItem.getQuantity());
            row.setUnitPrice(lineItem.getUnitPrice());
            row.setImeiNumber(serialized ? serialNumber.trim() : null);
            rows.add(row);

            value = value.add(BigDecimal.valueOf(lineItem.getUnitPrice())
                    .multiply(BigDecimal.valueOf(lineItem.getQuantity())));
        }

        if (dryRun) {
            LOGGER.info("WOULD GRN {} - po {} (id {}), warehouse {}, supplier {}, {} line(s), {} serialized, value {}, receivedDate {}",
                    invoiceNumber, purchaseOrder.getPoNumber(), purchaseOrder.getId(), purchaseOrder.getWarehouseId(),
                    purchaseOrder.getSupplierId(), rows.size(), serials, value.toPlainString(), receivedDate);
            for (PORowModel row : rows) {
                LOGGER.info("          item {} qty {} price {} serial {}",
                        row.getItemId(), row.getQuantity(), row.getUnitPrice(),
                        row.getImeiNumber() == null ? "-" : row.getImeiNumber());
            }
            return true;
        }

        // One PO and one invoice per call - addPORowModels applies the first PO it resolves to every entry.
        Map<String, Map<String, List<PORowModel>>> poRowModelsMap = Collections.singletonMap(
                purchaseOrder.getPoNumber(), Collections.singletonMap(invoiceNumber, rows));
        purchaseOrderService.addPORowModels(operatorEmail, poRowModelsMap);

        LOGGER.info("GRNED   {} - po {}, warehouse {}, {} line(s), {} serialized, value {}",
                invoiceNumber, purchaseOrder.getPoNumber(), purchaseOrder.getWarehouseId(),
                rows.size(), serials, value.toPlainString());
        return true;
    }
}