feat: 打通销售采购财务闭环并完成累计业务优化

gaoluyang

5 天以前 d39e4f7d839167c16425086dfa2f8747bccfdff9

 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/service/purchase/ErpPurchaseOrderServiceImpl.java

@@ -2,9 +2,12 @@

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.number.MoneyUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.framework.operatelog.core.util.OperateLogUtils;
import cn.iocoder.yudao.module.bpm.api.task.BpmProcessInstanceApi;
import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmCategoryDO;
@@ -14,6 +17,8 @@
import cn.iocoder.yudao.module.bpm.service.definition.BpmProcessDefinitionService;
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.order.ErpPurchaseOrderPageReqVO;
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.order.ErpPurchaseOrderSaveReqVO;
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.order.ErpPurchaseOrderImportExcelVO;
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.order.ErpPurchaseOrderImportRespVO;
import cn.iocoder.yudao.module.erp.dal.dataobject.purchase.ErpPurchaseOrderDO;
import cn.iocoder.yudao.module.erp.dal.dataobject.purchase.ErpPurchaseOrderItemDO;
import cn.iocoder.yudao.module.erp.dal.dataobject.purchase.ErpPurchaseRequestDO;
@@ -24,10 +29,17 @@
import cn.iocoder.yudao.module.erp.dal.mysql.purchase.ErpPurchaseRequestMapper;
import cn.iocoder.yudao.module.erp.dal.redis.no.ErpNoRedisDAO;
import cn.iocoder.yudao.module.erp.enums.ErpAuditStatus;
import cn.iocoder.yudao.module.erp.enums.ErpPaymentMethodEnum;
import cn.iocoder.yudao.module.erp.enums.ErpPurchaseOrderInStatusEnum;
import cn.iocoder.yudao.module.erp.enums.ErpPurchaseTypeEnum;
import cn.iocoder.yudao.module.erp.service.finance.ErpAccountService;
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
import cn.iocoder.yudao.module.srm.api.supplier.SrmSupplierApi;
import cn.iocoder.yudao.module.srm.api.supplier.dto.SrmSupplierRespDTO;
import cn.iocoder.yudao.module.mes.api.arrivalnotice.MesArrivalNoticeApi;
import cn.iocoder.yudao.module.system.api.storage.StorageAttachmentApi;
import com.mzt.logapi.starter.annotation.LogRecord;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.repository.ProcessDefinition;
@@ -37,12 +49,16 @@
import org.springframework.validation.annotation.Validated;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.*;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
import static cn.iocoder.yudao.module.erp.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.module.erp.enums.LogRecordConstants.*;

/**
 * ERP 采购订单 Service 实现类
@@ -95,11 +111,24 @@
    @Resource
    private StorageAttachmentApi storageAttachmentApi;

    @Resource
    private SrmSupplierApi srmSupplierApi;
    @Resource
    private MdmItemApi mdmItemApi;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createPurchaseOrder(ErpPurchaseOrderSaveReqVO createReqVO) {
        return createPurchaseOrder(createReqVO, true);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createPurchaseOrder(ErpPurchaseOrderSaveReqVO createReqVO, boolean submit) {
        // 1.1 校验订单项的有效性
        List<ErpPurchaseOrderItemDO> purchaseOrderItems = validatePurchaseOrderItems(createReqVO.getItems());
        // 1.1.1 校验采购台账字段
        validateLedgerFields(createReqVO);
        // 1.2 校验供应商
        supplierService.validateSupplier(createReqVO.getSupplierId());
        // 1.3 校验结算账户
@@ -112,9 +141,9 @@
            throw exception(PURCHASE_ORDER_NO_EXISTS);
        }

        // 2.1 插入订单（采购订单创建后为未审核状态，需要提交审批）
        // 2.1 插入订单（submit=false 时保存为草稿，等待业务确认后手动提交审批）
        ErpPurchaseOrderDO purchaseOrder = BeanUtils.toBean(createReqVO, ErpPurchaseOrderDO.class, in -> in
                .setNo(no).setStatus(ErpAuditStatus.PROCESS.getStatus())
                .setNo(no).setStatus(submit ? ErpAuditStatus.PROCESS.getStatus() : ErpAuditStatus.DRAFT.getStatus())
                .setInCount(BigDecimal.ZERO).setInStatus(ErpPurchaseOrderInStatusEnum.NOT_IN.getStatus()));
        calculateTotalPrice(purchaseOrder, purchaseOrderItems);
        purchaseOrderMapper.insert(purchaseOrder);
@@ -126,7 +155,9 @@
                purchaseOrder.getId(), createReqVO.getBlobIds());

        // 3. 创建后自动提交审批到协同办公（审批在协同办公完成，不在本页面审批）
        submitPurchaseOrder(purchaseOrder.getId(), PURCHASE_ORDER_APPROVE_PROCESS_DEFINITION_KEY, getLoginUserId());
        if (submit) {
            submitPurchaseOrder(purchaseOrder.getId(), PURCHASE_ORDER_APPROVE_PROCESS_DEFINITION_KEY, getLoginUserId());
        }

        return purchaseOrder.getId();
    }
@@ -148,6 +179,8 @@
        }
        // 1.4 校验订单项的有效性
        List<ErpPurchaseOrderItemDO> purchaseOrderItems = validatePurchaseOrderItems(updateReqVO.getItems());
        // 1.5 校验采购台账字段
        validateLedgerFields(updateReqVO);

        // 2.1 更新订单
        ErpPurchaseOrderDO updateObj = BeanUtils.toBean(updateReqVO, ErpPurchaseOrderDO.class);
@@ -159,11 +192,221 @@
        storageAttachmentApi.updateAttachments("file", "erp_purchase_order", updateReqVO.getId(), updateReqVO.getBlobIds());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @LogRecord(type = ERP_PURCHASE_ORDER_TYPE, subType = ERP_PURCHASE_ORDER_IMPORT_SUB_TYPE, bizNo = "0",
            success = ERP_PURCHASE_ORDER_IMPORT_SUCCESS)
    public ErpPurchaseOrderImportRespVO importPurchaseOrderList(List<ErpPurchaseOrderImportExcelVO> importList,
                                                               Boolean directApprove) {
        ErpPurchaseOrderImportRespVO respVO = ErpPurchaseOrderImportRespVO.builder()
                .createList(new ArrayList<>())
                .updateList(new ArrayList<>())
                .failureList(new LinkedHashMap<>())
                .build();
        if (CollUtil.isEmpty(importList)) {
            // 记录导入结果汇总，供 @LogRecord 的 success 文案引用
            OperateLogUtils.putImportSummary(respVO.getCreateList(), respVO.getUpdateList(), respVO.getFailureList());
            return respVO;
        }

        // 1. 预热“供应商名称/编码 -> 供应商编号”映射（ERP 供应商主数据在 SRM 模块）
        Map<String, Long> supplierIdMap = new HashMap<>();
        CommonResult<List<SrmSupplierRespDTO>> supplierResult = srmSupplierApi.getSupplierSimpleList();
        if (supplierResult != null && CollUtil.isNotEmpty(supplierResult.getData())) {
            supplierResult.getData().forEach(supplier -> {
                if (StrUtil.isNotBlank(supplier.getName())) {
                    supplierIdMap.put(supplier.getName().trim(), supplier.getId());
                }
                if (StrUtil.isNotBlank(supplier.getCode())) {
                    supplierIdMap.putIfAbsent(supplier.getCode().trim(), supplier.getId());
                }
            });
        }

        // 2. 按“采购单编号”分组：同编号多行 = 一张订单的多条明细；编号为空则每行独立成单
        Map<String, List<ErpPurchaseOrderImportExcelVO>> orderGroups = new LinkedHashMap<>();
        for (int i = 0; i < importList.size(); i++) {
            ErpPurchaseOrderImportExcelVO row = importList.get(i);
            if (row == null || (StrUtil.isBlank(row.getSupplierName()) && StrUtil.isBlank(row.getProductCode())
                    && StrUtil.isBlank(row.getNo()))) {
                continue; // 跳过空行
            }
            String key = StrUtil.isNotBlank(row.getNo()) ? row.getNo().trim() : "__row_" + (i + 2);
            orderGroups.computeIfAbsent(key, k -> new ArrayList<>()).add(row);
        }

        // 3. 逐个订单导入（单张订单失败不影响其它）
        for (Map.Entry<String, List<ErpPurchaseOrderImportExcelVO>> entry : orderGroups.entrySet()) {
            List<ErpPurchaseOrderImportExcelVO> rows = entry.getValue();
            String label = StrUtil.isNotBlank(rows.get(0).getNo()) ? rows.get(0).getNo().trim()
                    : "第 " + entry.getKey().substring("__row_".length()) + " 行";
            try {
                ErpPurchaseOrderDO purchaseOrder = createPurchaseOrderByImport(rows, supplierIdMap, directApprove);
                respVO.getCreateList().add(purchaseOrder.getNo());
            } catch (Exception ex) {
                respVO.getFailureList().put(label, resolveImportErrorMessage(ex));
            }
        }
        // 记录导入结果汇总，供 @LogRecord 的 success 文案引用
        OperateLogUtils.putImportSummary(respVO.getCreateList(), respVO.getUpdateList(), respVO.getFailureList());
        return respVO;
    }

    /**
     * 依据导入数据创建一张采购订单（含明细）。
     *
     * 注意：此处不调用 submitPurchaseOrder，因此不会创建 BPM 工作流；订单状态由 directApprove 直接决定：
     * 勾选“是否审核” => 已审核(20)，未勾选 => 未审核(10)。
     */
    private ErpPurchaseOrderDO createPurchaseOrderByImport(List<ErpPurchaseOrderImportExcelVO> rows,
                                                           Map<String, Long> supplierIdMap, Boolean directApprove) {
        // 1. 供应商（取该组首行）
        ErpPurchaseOrderImportExcelVO head = rows.get(0);
        if (StrUtil.isBlank(head.getSupplierName())) {
            throw new IllegalArgumentException("供应商名称不能为空");
        }
        Long supplierId = supplierIdMap.get(head.getSupplierName().trim());
        if (supplierId == null) {
            throw new IllegalArgumentException("供应商不存在：" + head.getSupplierName());
        }
        supplierService.validateSupplier(supplierId);

        // 2. 明细
        List<ErpPurchaseOrderSaveReqVO.Item> items = new ArrayList<>();
        for (ErpPurchaseOrderImportExcelVO row : rows) {
            if (StrUtil.isBlank(row.getProductCode())) {
                throw new IllegalArgumentException("产品编码不能为空");
            }
            CommonResult<MdmItemRespDTO> itemResult = mdmItemApi.getItemByCode(row.getProductCode().trim());
            MdmItemRespDTO item = itemResult == null ? null : itemResult.getData();
            if (item == null) {
                throw new IllegalArgumentException("产品不存在：" + row.getProductCode());
            }
            if (row.getCount() == null) {
                throw new IllegalArgumentException("产品[" + row.getProductCode() + "]的数量不能为空");
            }
            if (item.getUnitMeasureId() == null) {
                throw new IllegalArgumentException("产品[" + row.getProductCode() + "]未配置计量单位，请先在物料中维护");
            }
            ErpPurchaseOrderSaveReqVO.Item itemVO = new ErpPurchaseOrderSaveReqVO.Item();
            itemVO.setProductId(item.getId());
            itemVO.setProductCode(item.getCode());
            itemVO.setProductUnitId(item.getUnitMeasureId());
            itemVO.setProductPrice(row.getProductPrice() == null ? BigDecimal.ZERO : row.getProductPrice());
            itemVO.setCount(row.getCount());
            itemVO.setTaxPercent(row.getTaxPercent());
            itemVO.setRemark(row.getRemark());
            itemVO.setQcCheckFlag("是".equals(StrUtil.trim(row.getQcCheckFlag())));
            items.add(itemVO);
        }

        // 3. 单号：填了就用（校验唯一），没填自动生成
        String no = StrUtil.isNotBlank(head.getNo()) ? head.getNo().trim()
                : noRedisDAO.generate(ErpNoRedisDAO.PURCHASE_ORDER_NO_PREFIX);
        if (purchaseOrderMapper.selectByNo(no) != null) {
            throw new IllegalArgumentException("采购单编号已存在：" + no);
        }

        // 4. 组装主表：勾选“是否审核” => 已审核(20)，否则未审核(10)
        ErpPurchaseOrderDO purchaseOrder = new ErpPurchaseOrderDO();
        purchaseOrder.setNo(no);
        purchaseOrder.setSupplierId(supplierId);
        purchaseOrder.setOrderTime(parseImportOrderTime(head.getOrderTime()));
        purchaseOrder.setPurchaseType(parsePurchaseType(head.getPurchaseType()));
        purchaseOrder.setContractNo(StrUtil.trimToNull(head.getContractNo()));
        purchaseOrder.setProjectName(StrUtil.trimToNull(head.getProjectName()));
        purchaseOrder.setPaymentDate(parseImportDateTime(head.getPaymentDate(), "付款日期"));
        purchaseOrder.setPaymentMethod(parsePaymentMethod(head.getPaymentMethod()));
        purchaseOrder.setRemark(head.getRemark());
        purchaseOrder.setStatus(Boolean.TRUE.equals(directApprove)
                ? ErpAuditStatus.APPROVE.getStatus() : ErpAuditStatus.PROCESS.getStatus());
        purchaseOrder.setDepositPrice(BigDecimal.ZERO); // deposit_price 为 NOT NULL 且无默认值，必须显式赋值
        purchaseOrder.setInCount(BigDecimal.ZERO);
        purchaseOrder.setInStatus(ErpPurchaseOrderInStatusEnum.NOT_IN.getStatus());

        List<ErpPurchaseOrderItemDO> itemDOs = validatePurchaseOrderItems(items);
        calculateTotalPrice(purchaseOrder, itemDOs);
        purchaseOrderMapper.insert(purchaseOrder);
        itemDOs.forEach(item -> item.setOrderId(purchaseOrder.getId()));
        purchaseOrderItemMapper.insertBatch(itemDOs);
        return purchaseOrder;
    }

    /**
     * 解析导入的采购时间，兼容多种常见格式；为空取当前时间
     */
    private LocalDateTime parseImportOrderTime(String text) {
        LocalDateTime value = parseImportDateTime(text, "采购时间");
        return value != null ? value : LocalDateTime.now();
    }

    /**
     * 解析导入的日期时间，兼容多种常见格式；为空返回 null
     */
    private LocalDateTime parseImportDateTime(String text, String fieldName) {
        if (StrUtil.isBlank(text)) {
            return null;
        }
        String value = text.trim();
        for (String pattern : new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd HH:mm:ss"}) {
            try {
                return LocalDateTime.parse(value, DateTimeFormatter.ofPattern(pattern));
            } catch (Exception ignored) {
                // 继续尝试下一个格式
            }
        }
        for (String pattern : new String[]{"yyyy-MM-dd", "yyyy/M/d"}) {
            try {
                return LocalDate.parse(value, DateTimeFormatter.ofPattern(pattern)).atStartOfDay();
            } catch (Exception ignored) {
                // 继续尝试下一个格式
            }
        }
        throw new IllegalArgumentException(fieldName + "格式不正确：" + text + "，示例 2026-01-01 10:00:00");
    }

    /**
     * 解析导入的采购类型名称；为空或无法识别返回 null
     */
    private Integer parsePurchaseType(String text) {
        if (StrUtil.isBlank(text)) {
            return null;
        }
        String value = text.trim();
        return Arrays.stream(ErpPurchaseTypeEnum.values())
                .filter(item -> item.getName().equals(value))
                .map(ErpPurchaseTypeEnum::getType).findFirst().orElse(null);
    }

    /**
     * 解析导入的付款方式名称；为空或无法识别返回 null
     */
    private Integer parsePaymentMethod(String text) {
        if (StrUtil.isBlank(text)) {
            return null;
        }
        String value = text.trim();
        return Arrays.stream(ErpPaymentMethodEnum.values())
                .filter(item -> item.getName().equals(value))
                .map(ErpPaymentMethodEnum::getType).findFirst().orElse(null);
    }

    /**
     * 提取导入失败原因（ServiceException 取业务提示）
     */
    private String resolveImportErrorMessage(Exception ex) {
        if (ex instanceof cn.iocoder.yudao.framework.common.exception.ServiceException serviceException) {
            return serviceException.getMessage();
        }
        return StrUtil.blankToDefault(ex.getMessage(), "导入失败");
    }

    private void calculateTotalPrice(ErpPurchaseOrderDO purchaseOrder, List<ErpPurchaseOrderItemDO> purchaseOrderItems) {
        purchaseOrder.setTotalCount(getSumValue(purchaseOrderItems, ErpPurchaseOrderItemDO::getCount, BigDecimal::add));
        purchaseOrder.setTotalProductPrice(getSumValue(purchaseOrderItems, ErpPurchaseOrderItemDO::getTotalPrice, BigDecimal::add, BigDecimal.ZERO));
        purchaseOrder.setTotalTaxPrice(getSumValue(purchaseOrderItems, ErpPurchaseOrderItemDO::getTaxPrice, BigDecimal::add, BigDecimal.ZERO));
        purchaseOrder.setTotalPrice(purchaseOrder.getTotalProductPrice().add(purchaseOrder.getTotalTaxPrice()));
        // 单价为含税单价：价税合计 = 单价 * 数量，税额已包含在单价中，不再额外加税
        purchaseOrder.setTotalPrice(purchaseOrder.getTotalProductPrice());
        // 计算优惠价格
        if (purchaseOrder.getDiscountPercent() == null) {
            purchaseOrder.setDiscountPercent(BigDecimal.ZERO);
@@ -204,13 +447,29 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void submitPurchaseOrder(Long id, String processDefinitionKey, Long userId) {
        // 1. 校验存在 + 未审核状态
        // 1. 校验存在 + 未审核状态（草稿和未审核均可提交）
        ErpPurchaseOrderDO purchaseOrder = validatePurchaseOrderExists(id);
        if (!ErpAuditStatus.PROCESS.getStatus().equals(purchaseOrder.getStatus())) {
        boolean submitable = ErpAuditStatus.DRAFT.getStatus().equals(purchaseOrder.getStatus())
                || ErpAuditStatus.PROCESS.getStatus().equals(purchaseOrder.getStatus());
        if (!submitable) {
            throw exception(PURCHASE_ORDER_SUBMIT_FAIL_STATUS);
        }
        // 2. 付款日期必选：采购申请自动生成的草稿订单没有付款日期，提交前必须先编辑补齐
        if (purchaseOrder.getPaymentDate() == null) {
            throw exception(PURCHASE_ORDER_PAYMENT_DATE_REQUIRED);
        }

        // 2. 创建 BPM 流程实例
        // 3. 创建 BPM 流程实例
        // 全局免审批：业务校验通过后直接执行审批通过逻辑，无需流程模型。
        if (processInstanceApi.isGlobalAutoApprove()) {
            purchaseOrderMapper.updateById(new ErpPurchaseOrderDO()
                    .setId(id)
                    .setStatus(ErpAuditStatus.APPROVING.getStatus())
                    .setProcessInstanceId(""));
            updatePurchaseOrderAuditStatus(id, cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceStatusEnum.APPROVE.getStatus());
            return;
        }

        String processInstanceId = processInstanceApi.createProcessInstance(userId,
                new BpmProcessInstanceCreateReqDTO()
                        .setProcessDefinitionKey(processDefinitionKey)
@@ -306,15 +565,53 @@

    private List<ErpPurchaseOrderItemDO> validatePurchaseOrderItems(List<ErpPurchaseOrderSaveReqVO.Item> list) {
        // 转化为 ErpPurchaseOrderItemDO 列表（产品验证已移除）
        return convertList(list, o -> BeanUtils.toBean(o, ErpPurchaseOrderItemDO.class, item -> {
        List<ErpPurchaseOrderItemDO> items = convertList(list, o -> BeanUtils.toBean(o, ErpPurchaseOrderItemDO.class, item -> {
            item.setTotalPrice(MoneyUtils.priceMultiply(item.getProductPrice(), item.getCount()));
            if (item.getTotalPrice() == null) {
                return;
            }
            if (item.getTaxPercent() != null) {
                item.setTaxPrice(MoneyUtils.priceMultiplyPercent(item.getTotalPrice(), item.getTaxPercent()));
                // 单价为含税单价：税额从价税合计中反算，而不是在合计上再加税
                item.setTaxPrice(MoneyUtils.taxPriceIncluded(item.getTotalPrice(), item.getTaxPercent()));
            }
        }));
        // 采购台账：产品编号取 MDM 物料编码快照，保证列表/导出可直接展示
        fillProductCode(items);
        return items;
    }

    /**
     * 回填明细行的产品编号（MDM 物料编码）
     */
    private void fillProductCode(List<ErpPurchaseOrderItemDO> items) {
        if (CollUtil.isEmpty(items)) {
            return;
        }
        Map<Long, MdmItemRespDTO> itemMap = mdmItemApi.getItemMap(
                convertSet(items, ErpPurchaseOrderItemDO::getProductId));
        items.forEach(item -> {
            MdmItemRespDTO mdmItem = itemMap.get(item.getProductId());
            if (mdmItem == null) {
                return;
            }
            if (StrUtil.isBlank(mdmItem.getCode())) {
                throw exception(PURCHASE_ORDER_ITEM_PRODUCT_CODE_MISSING,
                        StrUtil.blankToDefault(mdmItem.getName(), "ID=" + mdmItem.getId()));
            }
            item.setProductCode(mdmItem.getCode());
        });
    }

    /**
     * 校验采购台账字段（采购类型、付款方式）
     */
    private void validateLedgerFields(ErpPurchaseOrderSaveReqVO reqVO) {
        if (!ErpPurchaseTypeEnum.isValid(reqVO.getPurchaseType())) {
            throw exception(PURCHASE_ORDER_PURCHASE_TYPE_INVALID, reqVO.getPurchaseType());
        }
        if (!ErpPaymentMethodEnum.isValid(reqVO.getPaymentMethod())) {
            throw exception(PURCHASE_ORDER_PAYMENT_METHOD_INVALID, reqVO.getPaymentMethod());
        }
    }

    private void updatePurchaseOrderItemList(Long id, List<ErpPurchaseOrderItemDO> newList) {