采购申请批量提交、订单导入重复校验；修复考勤异常申请字段不匹配

gaoluyang

3 天以前 25a40b9c4e6a1b650610b8b13088d486699532ce

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

@@ -17,6 +17,7 @@
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.request.ErpPurchaseRequestSaveReqVO;
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.request.ErpPurchaseRequestImportExcelVO;
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.request.ErpPurchaseRequestImportRespVO;
import cn.iocoder.yudao.module.erp.controller.admin.purchase.vo.request.ErpPurchaseRequestSubmitBatchRespVO;
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;
@@ -39,6 +40,8 @@
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.repository.ProcessDefinition;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
@@ -100,6 +103,13 @@
    private DeptApi deptApi;
    @Resource
    private StorageAttachmentApi storageAttachmentApi;

    /**
     * 自身代理：批量提交时逐单调用 {@link #submitPurchaseRequest}，保证每张申请独立事务
     */
    @Autowired
    @Lazy
    private ErpPurchaseRequestService self;

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -450,13 +460,17 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void submitPurchaseRequest(Long id, String processDefinitionKey, Long userId) {
        // 1. 校验存在 + 草稿状态
        ErpPurchaseRequestDO purchaseRequest = validatePurchaseRequestCanModify(id);
        // 1. 校验存在 + 草稿/驳回状态
        ErpPurchaseRequestDO purchaseRequest = validatePurchaseRequestExists(id);
        if (!ErpPurchaseRequestStatusEnum.DRAFT.getStatus().equals(purchaseRequest.getStatus())
                && !ErpPurchaseRequestStatusEnum.REJECT.getStatus().equals(purchaseRequest.getStatus())) {
            throw exception(PURCHASE_REQUEST_SUBMIT_FAIL_NOT_DRAFT, purchaseRequest.getNo());
        }

        // 2. 校验是否有明细
        List<ErpPurchaseRequestItemDO> items = purchaseRequestItemMapper.selectListByRequestId(id);
        if (CollUtil.isEmpty(items)) {
            throw exception(PURCHASE_REQUEST_NOT_EXISTS); // TODO: 添加明细为空的错误码
            throw exception(PURCHASE_REQUEST_ITEM_EMPTY, purchaseRequest.getNo());
        }

        // 3. 创建 BPM 流程实例
@@ -470,6 +484,52 @@
                .setId(id)
                .setStatus(ErpPurchaseRequestStatusEnum.PROCESS.getStatus())
                .setProcessInstanceId(processInstanceId));
    }

    @Override
    public ErpPurchaseRequestSubmitBatchRespVO submitPurchaseRequestBatch(List<Long> ids,
                                                                          String processDefinitionKey,
                                                                          Long userId) {
        ErpPurchaseRequestSubmitBatchRespVO respVO = ErpPurchaseRequestSubmitBatchRespVO.builder()
                .successIds(new ArrayList<>())
                .failureMap(new LinkedHashMap<>())
                .build();
        if (CollUtil.isEmpty(ids)) {
            return respVO;
        }
        List<Long> distinctIds = ids.stream().filter(Objects::nonNull).distinct().toList();
        if (CollUtil.isEmpty(distinctIds)) {
            return respVO;
        }

        // 1. 预热申请单号，失败时前端可直接看到是哪张申请单
        Map<Long, String> noMap = purchaseRequestMapper.selectRequestListByIds(distinctIds).stream()
                .filter(request -> request.getId() != null && StrUtil.isNotBlank(request.getNo()))
                .collect(java.util.stream.Collectors.toMap(ErpPurchaseRequestDO::getId, ErpPurchaseRequestDO::getNo,
                        (a, b) -> a));

        // 2. 逐单提交：单张失败不影响其它申请，通过 self 代理保证每张独立事务
        for (Long id : distinctIds) {
            String label = noMap.getOrDefault(id, "编号 " + id);
            try {
                self.submitPurchaseRequest(id, processDefinitionKey, userId);
                respVO.getSuccessIds().add(id);
            } catch (Exception ex) {
                String reason = resolveSubmitErrorMessage(ex);
                if (respVO.getFailureMap().containsKey(label)) {
                    label = label + "（编号 " + id + "）";
                }
                respVO.getFailureMap().put(label, reason);
            }
        }
        return respVO;
    }

    private String resolveSubmitErrorMessage(Exception ex) {
        if (ex instanceof cn.iocoder.yudao.framework.common.exception.ServiceException serviceException) {
            return serviceException.getMessage();
        }
        return StrUtil.blankToDefault(ex.getMessage(), "提交失败");
    }

    @Override
@@ -572,10 +632,20 @@
        // 1. 获取申请明细
        List<ErpPurchaseRequestItemDO> requestItems = purchaseRequestItemMapper.selectListByRequestId(id);
        if (CollUtil.isEmpty(requestItems)) {
            throw exception(PURCHASE_REQUEST_NOT_EXISTS);
            throw exception(PURCHASE_REQUEST_ITEM_EMPTY, purchaseRequest.getNo());
        }

        // 2. 生成采购订单号
        // 2. 先尝试复用系统内已存在且供应商、明细完全一致的已审核采购订单（通常来自采购订单导入），
        //    避免审批通过后又生成一张重复订单
        ErpPurchaseOrderDO reusableOrder = findReusablePurchaseOrder(purchaseRequest, requestItems);
        if (reusableOrder != null) {
            linkPurchaseRequestToOrder(purchaseRequest, requestItems, reusableOrder);
            log.info("[doGeneratePurchaseOrder] 采购申请({}) 复用已有采购订单({})，未重复生成",
                    id, reusableOrder.getNo());
            return reusableOrder.getId();
        }

        // 3. 生成采购订单号
        String orderNo = noRedisDAO.generate(ErpNoRedisDAO.PURCHASE_ORDER_NO_PREFIX);
        if (purchaseOrderMapper.selectByNo(orderNo) != null) {
            throw exception(PURCHASE_ORDER_NO_EXISTS);
@@ -628,6 +698,143 @@
    }

    /**
     * 查找可复用的采购订单：供应商相同，且明细（物料、数量、单价、税率）与申请完全一致。
     *
     * 只匹配已审核订单，避免把申请挂到尚未审核的订单上；优先选择尚未关联采购申请的导入订单，
     * 其次选择编号最小的订单。匹配到的订单会加行锁，防止并发审批时两张申请同时占用同一张订单。
     */
    private ErpPurchaseOrderDO findReusablePurchaseOrder(ErpPurchaseRequestDO purchaseRequest,
                                                         List<ErpPurchaseRequestItemDO> requestItems) {
        if (purchaseRequest.getSupplierId() == null || CollUtil.isEmpty(requestItems)) {
            return null;
        }
        String targetFingerprint = buildRequestFingerprint(purchaseRequest.getSupplierId(), requestItems);
        if (targetFingerprint == null) {
            return null;
        }

        // 1. 查询同供应商的已审核订单，按指纹筛选完全一致的
        List<ErpPurchaseOrderDO> orders = purchaseOrderMapper.selectList(
                purchaseRequest.getSupplierId(), ErpAuditStatus.APPROVE.getStatus());
        if (CollUtil.isEmpty(orders)) {
            return null;
        }
        Map<Long, List<ErpPurchaseOrderItemDO>> orderItemMap = purchaseOrderItemMapper.selectListByOrderIds(
                        orders.stream().map(ErpPurchaseOrderDO::getId).toList()).stream()
                .collect(java.util.stream.Collectors.groupingBy(ErpPurchaseOrderItemDO::getOrderId));
        List<ErpPurchaseOrderDO> candidates = orders.stream()
                .filter(order -> targetFingerprint.equals(
                        buildOrderFingerprint(order.getSupplierId(), orderItemMap.get(order.getId()))))
                // 已入库/已退货的订单说明这笔采购已经执行过，不能拿来顶新申请，否则新需求会被“吃掉”
                .filter(order -> order.getInCount() == null
                        || order.getInCount().compareTo(BigDecimal.ZERO) == 0)
                .filter(order -> order.getReturnCount() == null
                        || order.getReturnCount().compareTo(BigDecimal.ZERO) == 0)
                .sorted(Comparator
                        .comparing((ErpPurchaseOrderDO order) ->
                                hasLinkedRequestItem(orderItemMap.get(order.getId())) ? 1 : 0)
                        .thenComparing(ErpPurchaseOrderDO::getId))
                .toList();
        if (CollUtil.isEmpty(candidates)) {
            return null;
        }
        if (candidates.size() > 1) {
            log.warn("[findReusablePurchaseOrder] 采购申请({}) 匹配到 {} 张相同订单：{}，将复用最早的一张",
                    purchaseRequest.getId(), candidates.size(),
                    candidates.stream().map(ErpPurchaseOrderDO::getNo).toList());
        }

        // 2. 加行锁后重新加载，避免并发审批重复占用
        ErpPurchaseOrderDO candidate = purchaseOrderMapper.selectByIdForUpdate(candidates.get(0).getId());
        if (candidate == null || !ErpAuditStatus.APPROVE.getStatus().equals(candidate.getStatus())) {
            return null;
        }
        return candidate;
    }

    /**
     * 将采购申请关联到已存在的采购订单，并把订单明细回填申请明细编号。
     * 已被其它申请关联过的明细不重复回填，只建立申请单与订单的关联。
     */
    private void linkPurchaseRequestToOrder(ErpPurchaseRequestDO purchaseRequest,
                                            List<ErpPurchaseRequestItemDO> requestItems,
                                            ErpPurchaseOrderDO purchaseOrder) {
        List<ErpPurchaseOrderItemDO> orderItems = purchaseOrderItemMapper.selectListByOrderId(purchaseOrder.getId());
        List<ErpPurchaseOrderItemDO> remaining = new ArrayList<>(orderItems);
        List<ErpPurchaseOrderItemDO> updates = new ArrayList<>();
        for (ErpPurchaseRequestItemDO requestItem : requestItems) {
            ErpPurchaseOrderItemDO match = remaining.stream()
                    .filter(orderItem -> orderItem.getRequestItemId() == null)
                    .filter(orderItem -> Objects.equals(orderItem.getProductId(), requestItem.getProductId())
                            && numberEquals(orderItem.getCount(), requestItem.getCount())
                            && numberEquals(orderItem.getProductPrice(), requestItem.getProductPrice())
                            && numberEquals(orderItem.getTaxPercent(), requestItem.getTaxPercent()))
                    .findFirst().orElse(null);
            if (match != null) {
                match.setRequestItemId(requestItem.getId());
                updates.add(match);
                remaining.remove(match);
            }
        }
        if (CollUtil.isNotEmpty(updates)) {
            purchaseOrderItemMapper.updateBatch(updates);
        }

        purchaseRequestMapper.updateById(new ErpPurchaseRequestDO()
                .setId(purchaseRequest.getId())
                .setOrderId(purchaseOrder.getId())
                .setOrderNo(purchaseOrder.getNo()));
        log.info("[linkPurchaseRequestToOrder] 采购申请({}) 关联采购订单({})，回填明细 {} 条",
                purchaseRequest.getId(), purchaseOrder.getNo(), updates.size());
    }

    private String buildRequestFingerprint(Long supplierId, List<ErpPurchaseRequestItemDO> items) {
        if (supplierId == null || CollUtil.isEmpty(items)) {
            return null;
        }
        return buildFingerprint(supplierId, items.stream()
                .map(item -> fingerprintPart(item.getProductId(), item.getCount(),
                        item.getProductPrice(), item.getTaxPercent()))
                .toList());
    }

    private String buildOrderFingerprint(Long supplierId, List<ErpPurchaseOrderItemDO> items) {
        if (supplierId == null || CollUtil.isEmpty(items)) {
            return null;
        }
        return buildFingerprint(supplierId, items.stream()
                .map(item -> fingerprintPart(item.getProductId(), item.getCount(),
                        item.getProductPrice(), item.getTaxPercent()))
                .toList());
    }

    private String buildFingerprint(Long supplierId, List<String> parts) {
        return supplierId + "|" + parts.stream().sorted().collect(java.util.stream.Collectors.joining(","));
    }

    private String fingerprintPart(Long productId, BigDecimal count, BigDecimal productPrice,
                                   BigDecimal taxPercent) {
        return String.join(":", String.valueOf(productId), normalizeNumber(count),
                normalizeNumber(productPrice), normalizeNumber(taxPercent));
    }

    private String normalizeNumber(BigDecimal value) {
        return value == null ? "" : value.stripTrailingZeros().toPlainString();
    }

    private boolean numberEquals(BigDecimal left, BigDecimal right) {
        if (left == null) {
            return right == null;
        }
        return right != null && left.compareTo(right) == 0;
    }

    private boolean hasLinkedRequestItem(List<ErpPurchaseOrderItemDO> orderItems) {
        return CollUtil.isNotEmpty(orderItems)
                && orderItems.stream().anyMatch(item -> item.getRequestItemId() != null);
    }

    /**
     * 校验采购申请审批分类和流程定义是否存在
     */
    private void validatePurchaseRequestApproveCategoryAndProcessDefinition() {