Subversion Repositories SmartDukaan

package com.smartdukaan.cron.scheduled.purchaseorder;

import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.inventory.InventoryWarehouse;
import com.spice.profitmandi.dao.entity.transaction.Order;
import com.spice.profitmandi.dao.entity.warehouse.Supplier;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseLineItem;
import com.spice.profitmandi.dao.entity.warehouse.WarehousePurchaseOrder;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseSupplierInvoice;
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
import com.spice.profitmandi.dao.enumuration.warehouse.WarehouseInvoiceStatus;
import com.spice.profitmandi.dao.repository.cs.CsService;
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.WarehouseLineItemRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseOrderRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseSupplierInvoiceRepository;
import com.spice.profitmandi.service.mail.MailOutboxService;
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.Transactional;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

@Component
@Transactional(rollbackFor = Throwable.class)
public class POScheduler {

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

    private static final int VENDOR_PO_OPEN_DAYS = 6;
    private static final int MOVEMENT_PO_ALERT_DAYS = 4;

    @Autowired
    WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;
    @Autowired
    SupplierRepository supplierRepository;
    @Autowired
    WarehouseLineItemRepository warehouseLineItemRepository;
    @Autowired
    WarehouseSupplierInvoiceRepository warehouseSupplierInvoiceRepository;
    @Autowired
    OrderRepository orderRepository;
    @Autowired
    InventoryWarehouseRepository inventoryWarehouseRepository;
    @Autowired
    CsService csService;
    @Autowired
    MailOutboxService mailOutboxService;

    // Closes vendor POs that have been open longer than their window. Movements are never closed here: one stays open
    // until it is received, its orders are cancelled, or it is closed by hand - see sendOpenMovementDigest.
    public void autoClosePurchaseOrders() {
        Set<Integer> internalSupplierIds = this.internalSupplierIds();
        LocalDate cutoff = LocalDate.now().minusDays(VENDOR_PO_OPEN_DAYS);
        List<WarehousePurchaseOrder> posToClose = this.openPurchaseOrders().stream()
                .filter(po -> !internalSupplierIds.contains(po.getSupplierId()))
                .filter(po -> po.getCreatedAt().toLocalDate().isBefore(cutoff))
                .collect(Collectors.toList());
        posToClose.forEach(po -> po.setStatus(POStatus.CLOSED));
        LOGGER.info("Auto-closed {} vendor POs", posToClose.size());
    }

    // Mails the warehouse team every movement PO still open after MOVEMENT_PO_ALERT_DAYS, with what is holding it.
    public void sendOpenMovementDigest() {
        Map<Integer, Supplier> internalSuppliers = supplierRepository.selectAll().stream().filter(Supplier::isInternal)
                .collect(Collectors.toMap(Supplier::getId, x -> x));
        LocalDate cutoff = LocalDate.now().minusDays(MOVEMENT_PO_ALERT_DAYS);
        List<WarehousePurchaseOrder> overdue = this.openPurchaseOrders().stream()
                .filter(po -> internalSuppliers.containsKey(po.getSupplierId()))
                .filter(po -> !po.getCreatedAt().toLocalDate().isAfter(cutoff))
                .sorted(Comparator.comparing(WarehousePurchaseOrder::getWarehouseId).thenComparing(WarehousePurchaseOrder::getCreatedAt))
                .collect(Collectors.toList());
        if (overdue.isEmpty()) {
            LOGGER.info("No movement PO open beyond {} days", MOVEMENT_PO_ALERT_DAYS);
            return;
        }

        String[] recipients = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_WAREHOUSE,
                Arrays.asList(EscalationType.L1, EscalationType.L2)).stream()
                .map(AuthUser::getEmailId).filter(Objects::nonNull).distinct().toArray(String[]::new);
        if (recipients.length == 0) {
            LOGGER.warn("No warehouse L1/L2 recipients for the open movement PO digest");
            return;
        }

        Map<Integer, String> warehouseNames = new HashMap<>();
        StringBuilder rows = new StringBuilder();
        for (WarehousePurchaseOrder po : overdue) {
            Supplier supplier = internalSuppliers.get(po.getSupplierId());
            List<WarehouseLineItem> lines = warehouseLineItemRepository.selectAllByPurchaseOrderId(po.getId());
            int openQty = lines.stream().filter(x -> !x.isDiscarded()).mapToInt(WarehouseLineItem::getUnfulfilledQuantity).sum();
            double openValue = lines.stream().filter(x -> !x.isDiscarded())
                    .mapToDouble(x -> x.getUnfulfilledQuantity() * (double) x.getUnitPrice()).sum();
            rows.append("<tr><td>").append(po.getPoNumber()).append("</td><td>")
                    .append(this.warehouseName(supplier.getInternalWarehouseId(), warehouseNames)).append("</td><td>")
                    .append(this.warehouseName(po.getWarehouseId(), warehouseNames)).append("</td><td>")
                    .append(po.getCreatedAt().toLocalDate().format(DateTimeFormatter.ofPattern("dd-MMM-yy"))).append("</td><td>")
                    .append(ChronoUnit.DAYS.between(po.getCreatedAt().toLocalDate(), LocalDate.now())).append("</td><td>")
                    .append(openQty).append("</td><td>").append(String.format("%,.0f", openValue)).append("</td><td>")
                    .append(this.holdingReason(po)).append("</td></tr>");
        }

        String body = "<p>Movement purchase orders open for " + MOVEMENT_PO_ALERT_DAYS + " days or more. Receive the billed "
                + "invoices against their own PO, or cancel orders that will not ship.</p>"
                + "<table border='1' cellpadding='4' cellspacing='0' style='border-collapse:collapse;font-family:Arial;font-size:12px'>"
                + "<tr style='background:#1F3864;color:#fff'><th>PO</th><th>From</th><th>To</th><th>PO date</th><th>Days open</th>"
                + "<th>Open qty</th><th>Open value (Rs)</th><th>Holding it</th></tr>" + rows + "</table>";
        mailOutboxService.queueMailViaGoogle(recipients, null,
                "Open movement POs (" + overdue.size() + ") - " + LocalDate.now().format(DateTimeFormatter.ofPattern("dd-MMM-yyyy")),
                body, true, "POScheduler.sendOpenMovementDigest");
        LOGGER.info("Open movement PO digest queued: {} POs to {}", overdue.size(), Arrays.toString(recipients));
    }

    private String holdingReason(WarehousePurchaseOrder po) {
        if (po.getTransactionId() == null || po.getTransactionId() <= 0) {
            return "Receive-only PO: invoice not yet received";
        }
        List<Order> live = orderRepository.selectAllByTransactionId(po.getTransactionId()).stream()
                .filter(o -> o.getRefundTimestamp() == null).collect(Collectors.toList());
        List<String> notBilled = live.stream().filter(o -> o.getBillingTimestamp() == null)
                .map(o -> String.valueOf(o.getId())).collect(Collectors.toList());
        List<String> invoices = live.stream().map(Order::getInvoiceNumber).filter(Objects::nonNull).distinct().collect(Collectors.toList());
        Set<String> received = invoices.isEmpty() ? Collections.<String>emptySet()
                : warehouseSupplierInvoiceRepository.selectAllBySupplierInvoice(po.getSupplierId(), invoices).stream()
                .filter(x -> WarehouseInvoiceStatus.received.equals(x.getStatus()))
                .map(WarehouseSupplierInvoice::getInvoiceNumber).collect(Collectors.toSet());
        List<String> reasons = new ArrayList<>();
        if (!notBilled.isEmpty()) {
            reasons.add("Not billed: order " + String.join(", ", notBilled));
        }
        List<String> pending = invoices.stream().filter(x -> !received.contains(x)).collect(Collectors.toList());
        if (!pending.isEmpty()) {
            reasons.add("Billed, not received: " + String.join(", ", pending));
        }
        return reasons.isEmpty() ? "No live order - open quantity will not arrive; close the PO" : String.join("<br>", reasons);
    }

    private String warehouseName(Integer warehouseId, Map<Integer, String> cache) {
        if (warehouseId == null) {
            return "-";
        }
        return cache.computeIfAbsent(warehouseId, id -> {
            InventoryWarehouse warehouse = inventoryWarehouseRepository.selectById(id);
            return warehouse == null ? String.valueOf(id) : id + " " + warehouse.getDisplayName();
        });
    }

    private List<WarehousePurchaseOrder> openPurchaseOrders() {
        List<WarehousePurchaseOrder> open = new ArrayList<>(warehousePurchaseOrderRepository.selectAllByStatus(POStatus.READY));
        open.addAll(warehousePurchaseOrderRepository.selectAllByStatus(POStatus.PARTIALLY_FULFILLED));
        return open;
    }

    private Set<Integer> internalSupplierIds() {
        return supplierRepository.selectAll().stream().filter(Supplier::isInternal).map(Supplier::getId).collect(Collectors.toSet());
    }
}