Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.catalog.Item;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.entity.warehouse.Supplier;

import com.spice.profitmandi.dao.entity.warehouse.WarehousePurchaseOrder;

import com.spice.profitmandi.dao.model.CreateWarehousePurchaseOrderModel;

import com.spice.profitmandi.dao.model.InternalMovementAllocationModel;

import com.spice.profitmandi.dao.model.InternalMovementAvailabilityModel;

import com.spice.profitmandi.dao.model.ItemWisePurchaseModel;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.warehouse.SupplierRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseOrderRepository;

import com.spice.profitmandi.service.warehouse.InternalMovementPricingService;

import com.spice.profitmandi.service.warehouse.PurchaseOrderService;

import in.shop2020.model.v1.order.OrderStatus;

import in.shop2020.purchase.POStatus;

import org.apache.poi.ss.usermodel.CellType;

import org.apache.poi.ss.usermodel.Row;

import org.apache.poi.xssf.usermodel.XSSFRow;

import org.apache.poi.xssf.usermodel.XSSFSheet;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Transactional;

import java.io.FileInputStream;

import java.io.InputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.function.Function;

import java.util.stream.Collectors;

import java.util.stream.IntStream;

/**

 * Raises an internal movement PO from a PO-screen upload file (itemId, quantity on the first sheet) the way the PO

 * screen does - createPurchaseOrder, recorded as the operator, dated today - which also creates and pays the internal

 * order that MovementBiller then bills. {@link #preview} shows the POs it would raise without writing anything.

 */

@Component

public class MovementPoCreator {

    // createPurchaseOrder returns the first PO; its cost-split and margin-scheme siblings are raised right after it.

    private static final int SPLIT_ID_WINDOW = 50;

    @Autowired

    private PurchaseOrderService purchaseOrderService;

    @Autowired

    private InternalMovementPricingService internalMovementPricingService;

    @Autowired

    private SupplierRepository supplierRepository;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private OrderRepository orderRepository;

    public static class Preview {

        public String supplierName;

        public final List<String> problems = new ArrayList<>();

        /** One entry per PO that would be raised, each its priced lines. */

        public List<List<InternalMovementAllocationModel>> purchaseOrders = new ArrayList<>();

        public Map<Integer, Item> items = new LinkedHashMap<>();

    }

    /** itemId -> quantity, in file order. Same layout the PO screen's bulk upload reads. */

    public static Map<Integer, Integer> readFile(String path) throws Exception {

        Map<Integer, Integer> quantities = new LinkedHashMap<>();

        try (InputStream in = new FileInputStream(path); XSSFWorkbook workbook = new XSSFWorkbook(in)) {

            workbook.setMissingCellPolicy(Row.MissingCellPolicy.RETURN_BLANK_AS_NULL);

            XSSFSheet sheet = workbook.getSheetAt(0);

            for (int rowNumber = 1; rowNumber <= sheet.getLastRowNum(); rowNumber++) {

                XSSFRow row = sheet.getRow(rowNumber);

                if (row == null || row.getCell(0) == null) {

                    break;

                }

                if (row.getCell(0).getCellTypeEnum() != CellType.NUMERIC || row.getCell(1) == null

                        || row.getCell(1).getCellTypeEnum() != CellType.NUMERIC) {

                    throw new ProfitMandiBusinessException("row", rowNumber + 1, "itemId and quantity must be numbers");

                }

                int itemId = (int) row.getCell(0).getNumericCellValue();

                int quantity = (int) row.getCell(1).getNumericCellValue();

                if (quantity <= 0) {

                    throw new ProfitMandiBusinessException("row", rowNumber + 1, "quantity must be positive");

                }

                if (quantities.put(itemId, quantity) != null) {

                    throw new ProfitMandiBusinessException("itemId", itemId, "Item " + itemId + " appears twice");

                }

            }

        }

        return quantities;

    }

    /** Everything that would stop the PO, and the POs it would be raised as. Writes nothing. */

    @Transactional(readOnly = true, rollbackFor = Throwable.class)

    public Preview preview(int warehouseId, int supplierId, Map<Integer, Integer> quantities) throws ProfitMandiBusinessException {

        Preview preview = new Preview();

        Supplier supplier = supplierRepository.selectById(supplierId);

        if (supplier == null || !supplier.isInternal()) {

            preview.problems.add("supplier " + supplierId + " is not an internal supplier");

            return preview;

        }

        preview.supplierName = supplier.getName();

        if (supplier.getInternalWarehouseId() != null && supplier.getInternalWarehouseId() == warehouseId) {

            preview.problems.add(supplier.getName() + " cannot move stock to its own warehouse");

        }

        try {

            purchaseOrderService.checkSupplierMappedToWarehouse(supplier, warehouseId);

        } catch (ProfitMandiBusinessException e) {

            preview.problems.add(e.getCode());

        }

        List<Item> items = itemRepository.selectByIds(new ArrayList<>(quantities.keySet()));

        preview.items = items.stream().collect(Collectors.toMap(Item::getId, Function.identity(), (a, b) -> a, LinkedHashMap::new));

        List<Integer> unknown = quantities.keySet().stream().filter(x -> !preview.items.containsKey(x)).collect(Collectors.toList());

        if (!unknown.isEmpty()) {

            preview.problems.add("unknown item ids " + unknown);

        }

        Map<Integer, InternalMovementAvailabilityModel> availability = internalMovementPricingService.describeAvailability(supplier, items);

        for (Map.Entry<Integer, Integer> line : quantities.entrySet()) {

            InternalMovementAvailabilityModel movable = availability.get(line.getKey());

            int canMove = movable == null ? 0 : movable.getMovableAltogether();

            if (line.getValue() > canMove) {

                preview.problems.add("item " + line.getKey() + " asks " + line.getValue() + ", only " + canMove

                        + " can move (in stock " + (movable == null ? 0 : movable.getInStock()) + ")");

            }

        }

        if (preview.problems.isEmpty()) {

            preview.purchaseOrders = purchaseOrderService.previewMovementPurchaseOrders(supplier, toPurchaseItems(quantities));

        }

        return preview;

    }

    /** Raises the PO and its siblings, all or nothing. Returns their PO numbers in the order raised. */

    @Transactional(rollbackFor = Throwable.class)

    public List<String> create(int warehouseId, int supplierId, Map<Integer, Integer> quantities, String operatorEmail)

            throws Exception {

        Preview preview = this.preview(warehouseId, supplierId, quantities);

        if (!preview.problems.isEmpty()) {

            throw new ProfitMandiBusinessException("file", supplierId, String.join("; ", preview.problems));

        }

        AuthUser operator = authRepository.selectByEmailOrMobile(operatorEmail);

        if (operator == null) {

            throw new ProfitMandiBusinessException("email", operatorEmail, "No auth user for " + operatorEmail);

        }

        CreateWarehousePurchaseOrderModel model = new CreateWarehousePurchaseOrderModel();

        model.setWarehouseId(warehouseId);

        model.setVendorId(supplierId);

        model.setPoDate(LocalDate.now());

        model.setCreatedBy(operator.getFullName());

        model.setRequesterAuthId(operator.getId());

        model.setItems(toPurchaseItems(quantities));

        int firstPoId = purchaseOrderService.createPurchaseOrder(model);

        List<Integer> window = IntStream.range(firstPoId, firstPoId + SPLIT_ID_WINDOW).boxed().collect(Collectors.toList());

        List<WarehousePurchaseOrder> raised = warehousePurchaseOrderRepository.selectAll(window).stream()

                .filter(x -> x.getSupplierId() == supplierId && x.getWarehouseId() == warehouseId

                        && operator.getFullName().equals(x.getCreatedBy())

                        && x.getCreatedAt() != null && LocalDate.now().equals(x.getCreatedAt().toLocalDate()))

                .sorted(Comparator.comparingInt(WarehousePurchaseOrder::getId))

                .collect(Collectors.toList());

        if (raised.size() != preview.purchaseOrders.size()) {

            throw new ProfitMandiBusinessException("po", firstPoId, "Expected " + preview.purchaseOrders.size()

                    + " PO(s) but found " + raised.size() + " near PO id " + firstPoId + " - rolled back, check by hand");

        }

        return raised.stream().map(WarehousePurchaseOrder::getPoNumber).collect(Collectors.toList());

    }

    /**

     * Closes a movement PO the way the PO screen's Close does (PurchaseOrderController.closePuchaseOrder): refuses if

     * any order has moved past submitted for processing, otherwise refunds every live order and pre-closes the PO.

     * Returns what it did, or would do when {@code live} is false.

     */

    @Transactional(rollbackFor = Throwable.class)

    public String close(String poNumber, String closedBy, boolean live) throws Exception {

        List<WarehousePurchaseOrder> found = warehousePurchaseOrderRepository.selectAllByPONumbers(Collections.singletonList(poNumber));

        if (found.size() != 1) {

            throw new ProfitMandiBusinessException("po", poNumber, "No single PO numbered " + poNumber);

        }

        WarehousePurchaseOrder po = found.get(0);

        if (po.getTransactionId() == null || po.getTransactionId() <= 0) {

            throw new ProfitMandiBusinessException("po", poNumber, poNumber + " raised no movement order");

        }

        List<Order> orders = orderRepository.selectAllByTransactionId(po.getTransactionId());

        int liveOrders = 0;

        int units = 0;

        for (Order order : orders) {

            if (order.getRefundTimestamp() != null) {

                continue;

            }

            if (!OrderStatus.SUBMITTED_FOR_PROCESSING.equals(order.getStatus())) {

                throw new ProfitMandiBusinessException("po", poNumber, "Order " + order.getId() + " is already "

                        + order.getStatus() + " - its stock has left, so " + poNumber + " cannot be closed");

            }

            liveOrders++;

            units += order.getLineItem().getQuantity();

        }

        String summary = poNumber + " (txn " + po.getTransactionId() + ", status " + po.getStatus() + "): " + liveOrders

                + " order(s), " + units + " unit(s) to refund, then PRECLOSED";

        if (!live) {

            return "WOULD CLOSE " + summary;

        }

        for (Order order : orders) {

            if (order.getRefundTimestamp() == null) {

                orderRepository.refundOrder(order.getId(), closedBy, "Movement purchase order " + poNumber + " closed",

                        OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY);

            }

        }

        po.setStatus(POStatus.PRECLOSED);

        po.setUpdatedAt(LocalDateTime.now());

        return "CLOSED " + summary;

    }

    private static List<ItemWisePurchaseModel> toPurchaseItems(Map<Integer, Integer> quantities) {

        List<ItemWisePurchaseModel> items = new ArrayList<>();

        for (Map.Entry<Integer, Integer> line : quantities.entrySet()) {

            ItemWisePurchaseModel item = new ItemWisePurchaseModel();

            item.setItemId(line.getKey());

            item.setAmendedQty(line.getValue());

            items.add(item);

        }

        return items;

    }

}