Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.dao.entity.inventory.SaholicInventorySnapshot;
import com.spice.profitmandi.dao.entity.transaction.Order;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseInvoiceItem;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseLineItem;
import com.spice.profitmandi.dao.entity.warehouse.WarehousePurchase;
import com.spice.profitmandi.dao.entity.warehouse.WarehousePurchaseOrder;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseScan;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseSupplierInvoice;
import in.shop2020.warehouse.ScanType;
import com.spice.profitmandi.dao.repository.GenericRepository;
import com.spice.profitmandi.dao.repository.inventory.SaholicInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseInvoiceItemRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseLineItemRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseOrderRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseSupplierInvoiceRepository;
import in.shop2020.purchase.POStatus;
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.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Undoes one internal GRN so the invoice can be received again cleanly.
 *
 * It removes only what receiving created - the scans, the inventory units, the invoice items, the purchase
 * and the supplier invoice - and puts back the two running figures receiving moved: the warehouse
 * availability it added to, and the quantity it took off the purchase order line.
 *
 * It refuses an invoice whose stock has been touched since. A unit that has been scanned out, split or
 * partly consumed is no longer ours to delete, and reversing around it would leave the warehouse holding
 * stock no record explains.
 *
 * Kept in its own bean so InternalGrnTask reaches it through the Spring proxy and the transaction below is
 * actually applied.
 */
@Component
public class InternalGrnReverser {

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

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private GenericRepository genericRepository;

    @Autowired
    private WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;

    @Autowired
    private WarehouseSupplierInvoiceRepository warehouseSupplierInvoiceRepository;

    @Autowired
    private WarehousePurchaseRepository warehousePurchaseRepository;

    @Autowired
    private WarehouseInvoiceItemRepository warehouseInvoiceItemRepository;

    @Autowired
    private WarehouseLineItemRepository warehouseLineItemRepository;

    @Autowired
    private WarehouseScanRepository warehouseScanRepository;

    @Autowired
    private SaholicInventorySnapshotRepository saholicInventorySnapshotRepository;

    /**
     * @return true when the invoice was reversed (or would be, on a dry run), false when it was left alone.
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Throwable.class)
    public boolean reverseInvoice(String invoiceNumber, boolean dryRun) throws ProfitMandiBusinessException {
        List<Order> orders = orderRepository.selectByInvoiceNumber(invoiceNumber);
        if (orders.isEmpty()) {
            LOGGER.info("SKIP     {} - no orders for this invoice", invoiceNumber);
            return false;
        }

        // Resolved the same way receiving resolved it, so the reversal cannot land on a different PO.
        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());
            return false;
        }
        WarehousePurchaseOrder purchaseOrder =
                warehousePurchaseOrderRepository.selectByTransactionId(transactionIds.iterator().next());
        if (purchaseOrder == null) {
            LOGGER.info("SKIP     {} - no purchase order mapped to the transaction", invoiceNumber);
            return false;
        }

        WarehouseSupplierInvoice invoice = warehouseSupplierInvoiceRepository
                .selectAllBySupplierInvoice(purchaseOrder.getSupplierId(), invoiceNumber);
        if (invoice == null) {
            LOGGER.info("SKIP     {} - not received, nothing to reverse", invoiceNumber);
            return false;
        }

        List<WarehousePurchase> purchases = warehousePurchaseRepository.selectByInvoiceId(invoice.getId());
        List<WarehouseInventoryItem> inventoryItems = new ArrayList<>();
        for (WarehousePurchase purchase : purchases) {
            inventoryItems.addAll(genericRepository.<WarehouseInventoryItem>selectAllByEqualOrderByDesc(
                    WarehouseInventoryItem.class, "purchaseId", purchase.getId(), "id"));
        }

        // Anything that moved since receiving is not ours to undo.
        for (WarehouseInventoryItem inventoryItem : inventoryItems) {
            if (inventoryItem.getCurrentQuantity() != inventoryItem.getInitialQuantity()) {
                LOGGER.info("REFUSE   {} - inventory item {} has moved ({} of {} left), reverse it by hand",
                        invoiceNumber, inventoryItem.getId(), inventoryItem.getCurrentQuantity(),
                        inventoryItem.getInitialQuantity());
                return false;
            }
            if (!ScanType.PURCHASE.equals(inventoryItem.getLastScanType())) {
                LOGGER.info("REFUSE   {} - inventory item {} was last scanned {}, not PURCHASE",
                        invoiceNumber, inventoryItem.getId(), inventoryItem.getLastScanType());
                return false;
            }
        }

        // What receiving added to availability, keyed the way it added it.
        Map<String, Integer> availabilityToRelease = new LinkedHashMap<>();
        // What receiving took off each PO line.
        Map<Integer, Integer> quantityToRestore = new LinkedHashMap<>();
        int units = 0;
        for (WarehouseInventoryItem inventoryItem : inventoryItems) {
            String key = inventoryItem.getCurrentWarehouseId() + ":" + inventoryItem.getItemId();
            Integer released = availabilityToRelease.get(key);
            availabilityToRelease.put(key, (released == null ? 0 : released) + inventoryItem.getInitialQuantity());
            Integer restored = quantityToRestore.get(inventoryItem.getItemId());
            quantityToRestore.put(inventoryItem.getItemId(),
                    (restored == null ? 0 : restored) + inventoryItem.getInitialQuantity());
            units += inventoryItem.getInitialQuantity();
        }

        List<WarehouseInvoiceItem> invoiceItems = warehouseInvoiceItemRepository.selectByInvoiceId(invoice.getId());

        if (dryRun) {
            LOGGER.info("WOULD REVERSE {} - invoice id {}, po {}, {} purchase(s), {} inventory row(s), {} unit(s), {} invoice item(s)",
                    invoiceNumber, invoice.getId(), purchaseOrder.getPoNumber(), purchases.size(),
                    inventoryItems.size(), units, invoiceItems.size());
            for (WarehouseInventoryItem inventoryItem : inventoryItems) {
                LOGGER.info("          delete inventory {} item {} qty {} serial {}",
                        inventoryItem.getId(), inventoryItem.getItemId(), inventoryItem.getInitialQuantity(),
                        inventoryItem.getSerialNumber() == null ? "-" : inventoryItem.getSerialNumber());
            }
            for (Map.Entry<String, Integer> entry : availabilityToRelease.entrySet()) {
                String[] key = entry.getKey().split(":");
                SaholicInventorySnapshot snapshot = saholicInventorySnapshotRepository
                        .selectByWarehouseIdandItemId(Integer.valueOf(key[0]), Integer.valueOf(key[1]));
                LOGGER.info("          availability warehouse {} item {} : {} -> {}",
                        key[0], key[1], snapshot == null ? "absent" : snapshot.getAvailability(),
                        snapshot == null ? "absent" : (snapshot.getAvailability() - entry.getValue()));
            }
            for (Map.Entry<Integer, Integer> entry : quantityToRestore.entrySet()) {
                WarehouseLineItem lineItem = warehouseLineItemRepository
                        .selectByPurchaseOrderIdItemId(purchaseOrder.getId(), entry.getKey());
                LOGGER.info("          po line item {} unfulfilled : {} -> {}", entry.getKey(),
                        lineItem == null ? "absent" : lineItem.getUnfulfilledQuantity(),
                        lineItem == null ? "absent" : (lineItem.getUnfulfilledQuantity() + entry.getValue()));
            }
            if (POStatus.CLOSED.equals(purchaseOrder.getStatus())) {
                LOGGER.info("          po {} would be reopened to READY", purchaseOrder.getPoNumber());
            }
            return true;
        }

        // Give back the availability receiving added.
        for (Map.Entry<String, Integer> entry : availabilityToRelease.entrySet()) {
            String[] key = entry.getKey().split(":");
            SaholicInventorySnapshot snapshot = saholicInventorySnapshotRepository
                    .selectByWarehouseIdandItemId(Integer.valueOf(key[0]), Integer.valueOf(key[1]));
            if (snapshot != null) {
                snapshot.setAvailability(snapshot.getAvailability() - entry.getValue());
            }
        }

        // Put back the quantity receiving took off the PO lines.
        for (Map.Entry<Integer, Integer> entry : quantityToRestore.entrySet()) {
            WarehouseLineItem lineItem = warehouseLineItemRepository
                    .selectByPurchaseOrderIdItemId(purchaseOrder.getId(), entry.getKey());
            if (lineItem != null) {
                lineItem.setUnfulfilledQuantity(lineItem.getUnfulfilledQuantity() + entry.getValue());
            }
        }

        // A PO closed by this receipt is open again now that the quantity is back on it.
        if (POStatus.CLOSED.equals(purchaseOrder.getStatus())) {
            purchaseOrder.setStatus(POStatus.READY);
        }

        for (WarehouseInventoryItem inventoryItem : inventoryItems) {
            for (WarehouseScan scan : warehouseScanRepository.selectAll(inventoryItem.getId(), ScanType.PURCHASE)) {
                warehouseScanRepository.delete(scan);
            }
            genericRepository.delete(inventoryItem);
        }
        for (WarehouseInvoiceItem invoiceItem : invoiceItems) {
            warehouseInvoiceItemRepository.delete(invoiceItem);
        }
        for (WarehousePurchase purchase : purchases) {
            genericRepository.delete(purchase);
        }
        warehouseSupplierInvoiceRepository.delete(invoice);

        LOGGER.info("REVERSED {} - invoice id {}, po {}, {} inventory row(s), {} unit(s) released",
                invoiceNumber, invoice.getId(), purchaseOrder.getPoNumber(), inventoryItems.size(), units);
        return true;
    }
}