fix: 修复导出表头缺失、权限码不一致及生产链路断点

liu

2026-10-27 17ce55a3b038ed61d332bb54916de4fa55ba19c6

 yudao-module-crm/src/main/java/cn/iocoder/yudao/module/crm/service/contract/CrmContractServiceImpl.java

@@ -4,20 +4,28 @@
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.iocoder.yudao.framework.common.exception.ServiceException;
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.common.util.object.ObjectUtils;
import cn.iocoder.yudao.module.bpm.api.task.BpmProcessInstanceApi;
import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
import cn.iocoder.yudao.module.crm.controller.admin.contract.vo.contract.CrmContractImportExcelVO;
import cn.iocoder.yudao.module.crm.controller.admin.contract.vo.contract.CrmContractImportReqVO;
import cn.iocoder.yudao.module.crm.controller.admin.contract.vo.contract.CrmContractImportRespVO;
import cn.iocoder.yudao.module.crm.controller.admin.contract.vo.contract.CrmContractPageReqVO;
import cn.iocoder.yudao.module.crm.controller.admin.contract.vo.contract.CrmContractSaveReqVO;
import cn.iocoder.yudao.module.crm.controller.admin.contract.vo.contract.CrmContractTransferReqVO;
import cn.iocoder.yudao.module.crm.dal.dataobject.contract.CrmContractConfigDO;
import cn.iocoder.yudao.module.crm.dal.dataobject.contract.CrmContractDO;
import cn.iocoder.yudao.module.crm.dal.dataobject.contract.CrmContractProductDO;
import cn.iocoder.yudao.module.crm.dal.dataobject.customer.CrmCustomerDO;
import cn.iocoder.yudao.module.crm.dal.dataobject.quotation.CrmSaleQuotationDO;
import cn.iocoder.yudao.module.crm.dal.dataobject.quotation.CrmSaleQuotationProductDO;
import cn.iocoder.yudao.module.crm.dal.mysql.contract.CrmContractMapper;
import cn.iocoder.yudao.module.crm.dal.mysql.contract.CrmContractProductMapper;
import cn.iocoder.yudao.module.crm.dal.mysql.customer.CrmCustomerMapper;
import cn.iocoder.yudao.module.crm.dal.redis.no.CrmNoRedisDAO;
import cn.iocoder.yudao.module.crm.enums.common.CrmAuditStatusEnum;
import cn.iocoder.yudao.module.crm.enums.common.CrmBizTypeEnum;
@@ -25,18 +33,24 @@
import cn.iocoder.yudao.module.crm.framework.permission.core.annotations.CrmPermission;
import cn.iocoder.yudao.module.crm.service.business.CrmBusinessService;
import cn.iocoder.yudao.module.crm.service.contact.CrmContactService;
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
import cn.iocoder.yudao.module.crm.service.customer.CrmCustomerService;
import cn.iocoder.yudao.module.crm.service.permission.CrmPermissionService;
import cn.iocoder.yudao.module.crm.service.permission.bo.CrmPermissionCreateReqBO;
import cn.iocoder.yudao.module.crm.service.permission.bo.CrmPermissionTransferReqBO;
import cn.iocoder.yudao.module.crm.service.product.CrmProductService;
import cn.iocoder.yudao.module.crm.service.quotation.CrmSaleQuotationService;
import cn.iocoder.yudao.module.crm.service.receivable.CrmReceivableService;
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.enums.task.BpmTaskStatusEnum;
import cn.iocoder.yudao.module.erp.api.sale.ErpSaleOrderApi;
import cn.iocoder.yudao.module.erp.api.sale.dto.ErpSaleOrderCreateReqDTO;
import cn.iocoder.yudao.module.erp.api.sale.dto.ErpSaleOrderRespDTO;
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
import cn.iocoder.yudao.module.system.api.approval.ApprovalConfigApi;
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
import com.mzt.logapi.context.LogRecordContext;
import com.mzt.logapi.service.impl.DiffParseFunction;
import com.mzt.logapi.starter.annotation.LogRecord;
@@ -49,7 +63,11 @@

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -58,7 +76,7 @@
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.*;
import static cn.iocoder.yudao.module.crm.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.module.crm.enums.LogRecordConstants.*;
import static cn.iocoder.yudao.module.crm.util.CrmAuditStatusUtils.convertBpmResultToAuditStatus;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;

/**
 * CRM 合同 Service 实现类
@@ -71,14 +89,23 @@
public class CrmContractServiceImpl implements CrmContractService {

    /**
     * BPM 合同审批流程标识
     * CRM 合同审批的业务类型编码
     *
     * 与 system_approval_config.biz_type 对应，审批人在「系统管理 - 审批配置」中维护。
     */
    public static final String BPM_PROCESS_DEFINITION_KEY = "crm-contract-audit";
    private static final String CONTRACT_APPROVE_BIZ_TYPE = "contract_approve";

    /**
     * CRM 合同审批的 BPM 流程定义 Key
     */
    private static final String CONTRACT_APPROVE_PROCESS_KEY = "contract_approve";

    @Resource
    private CrmContractMapper contractMapper;
    @Resource
    private CrmContractProductMapper contractProductMapper;
    @Resource
    private CrmCustomerMapper customerMapper;

    @Resource
    private CrmNoRedisDAO noRedisDAO;
@@ -86,9 +113,9 @@
    @Resource
    private CrmPermissionService crmPermissionService;
    @Resource
    private CrmProductService productService;
    @Resource
    private CrmCustomerService customerService;
    @Resource
    private CrmCustomerApi customerApi;
    @Resource
    private CrmBusinessService businessService;
    @Resource
@@ -101,11 +128,16 @@
    @Resource
    private AdminUserApi adminUserApi;
    @Resource
    private ApprovalConfigApi approvalConfigApi;
    @Resource
    private BpmProcessInstanceApi bpmProcessInstanceApi;
    @Resource
    private ErpSaleOrderApi saleOrderApi;
    @Resource
    private MdmItemApi mdmItemApi;
    @Resource
    @Lazy // 延迟加载，避免循环依赖（quotation 内部引用了 contractService）
    private CrmSaleQuotationService crmSaleQuotationService;

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -123,7 +155,9 @@
        }

        // 2.1 插入合同
        CrmContractDO contract = BeanUtils.toBean(createReqVO, CrmContractDO.class).setNo(no);
        CrmContractDO contract = BeanUtils.toBean(createReqVO, CrmContractDO.class)
                .setNo(no)
                .setAuditStatus(CrmAuditStatusEnum.DRAFT.getStatus()); // 默认为未提交状态
        calculateTotalPrice(contract, contractProducts);
        contractMapper.insert(contract);
        // 2.2 插入合同关联商品
@@ -152,9 +186,9 @@
        updateReqVO.setOwnerUserId(null); // 不允许更新的字段
        // 1.1 校验存在
        CrmContractDO oldContract = validateContractExists(updateReqVO.getId());
        // 1.2 只有草稿、审批中，可以编辑；
        // 1.2 只有草稿、审核不通过，可以编辑；
        if (!ObjectUtils.equalsAny(oldContract.getAuditStatus(), CrmAuditStatusEnum.DRAFT.getStatus(),
                CrmAuditStatusEnum.PROCESS.getStatus())) {
                CrmAuditStatusEnum.REJECT.getStatus())) {
            throw exception(CONTRACT_UPDATE_FAIL_NOT_DRAFT);
        }
        // 1.3 校验产品项的有效性
@@ -248,13 +282,23 @@
    public void deleteContract(Long id) {
        // 1.1 校验存在
        CrmContractDO contract = validateContractExists(id);
        // 1.2 如果被 CrmReceivableDO 所使用，则不允许删除
        // 1.2 只有草稿、审核不通过，可以删除；
        if (!ObjectUtils.equalsAny(contract.getAuditStatus(), CrmAuditStatusEnum.DRAFT.getStatus(),
                CrmAuditStatusEnum.REJECT.getStatus())) {
            throw exception(CONTRACT_DELETE_FAIL_NOT_EDITABLE);
        }
        // 1.3 如果被 CrmReceivableDO 所使用，则不允许删除
        if (receivableService.getReceivableCountByContractId(contract.getId()) > 0) {
            throw exception(CONTRACT_DELETE_FAIL);
        }

        // 2.1 删除合同
        contractMapper.deleteById(id);
        // 2.2 删除合同时，解除关联的报价单引用
        CrmSaleQuotationDO quotation = crmSaleQuotationService.getByContractId(id);
        if (quotation != null) {
            crmSaleQuotationService.clearContractReference(quotation.getId());
        }
        // 2.2 删除数据权限
        crmPermissionService.deletePermission(CrmBizTypeEnum.CRM_CONTRACT.getType(), id);

@@ -268,6 +312,20 @@
            throw exception(CONTRACT_NOT_EXISTS);
        }
        return contract;
    }

    /**
     * 获取用户昵称
     *
     * @param userId 用户编号
     * @return 昵称，用户不存在时返回 null
     */
    private String getUserNickname(Long userId) {
        if (userId == null) {
            return null;
        }
        AdminUserRespDTO user = adminUserApi.getUser(userId);
        return user == null ? null : user.getNickname();
    }

    @Override
@@ -308,39 +366,85 @@
    @Transactional(rollbackFor = Exception.class)
    @LogRecord(type = CRM_CONTRACT_TYPE, subType = CRM_CONTRACT_SUBMIT_SUB_TYPE, bizNo = "{{#id}}",
            success = CRM_CONTRACT_SUBMIT_SUCCESS)
    public void submitContract(Long id, Long userId) {
        // 1. 校验合同是否在审批
    @CrmPermission(bizType = CrmBizTypeEnum.CRM_CONTRACT, bizId = "#id", level = CrmPermissionLevelEnum.WRITE)
    public void submitContract(Long id) {
        // 1. 校验存在 + 可提交状态（未提交 / 审核不通过）
        CrmContractDO contract = validateContractExists(id);
        if (ObjUtil.notEqual(contract.getAuditStatus(), CrmAuditStatusEnum.DRAFT.getStatus())) {
            throw exception(CONTRACT_SUBMIT_FAIL_NOT_DRAFT);
        if (ObjUtil.notEqual(contract.getAuditStatus(), CrmAuditStatusEnum.DRAFT.getStatus())
                && ObjUtil.notEqual(contract.getAuditStatus(), CrmAuditStatusEnum.REJECT.getStatus())) {
            throw exception(CONTRACT_SUBMIT_FAIL_NOT_EDITABLE);
        }

        // 2. 创建合同审批流程实例
        String processInstanceId = bpmProcessInstanceApi.createProcessInstance(userId, new BpmProcessInstanceCreateReqDTO()
                .setProcessDefinitionKey(BPM_PROCESS_DEFINITION_KEY).setBusinessKey(String.valueOf(id)));
        // 2. 校验审批配置已启用且配置了有效审批人（未配置时抛出带明确提示的业务异常）
        approvalConfigApi.validateApprovalEnabledAndGetApprovers(CONTRACT_APPROVE_BIZ_TYPE);

        // 3. 更新合同工作流编号
        contractMapper.updateById(new CrmContractDO().setId(id).setProcessInstanceId(processInstanceId)
                .setAuditStatus(CrmAuditStatusEnum.PROCESS.getStatus()));
        // 3. 状态置为审批中，并清空上一轮审核结果，避免残留「审核不通过」的原因
        if (contractMapper.submitAndResetAuditInfo(id, CrmAuditStatusEnum.PROCESS.getStatus()) != 1) {
            throw exception(CONTRACT_SUBMIT_FAIL_NOT_EDITABLE);
        }

        // 3. 记录日志
        // 4. 创建 BPM 流程实例，使审批出现在「协同办公 - 我的流程」
        bpmProcessInstanceApi.createProcessInstance(getLoginUserId(),
                new BpmProcessInstanceCreateReqDTO()
                        .setProcessDefinitionKey(CONTRACT_APPROVE_PROCESS_KEY)
                        .setBusinessKey(String.valueOf(id)));

        // 5. 记录日志
        LogRecordContext.putVariable("contractName", contract.getName());
    }

    @Override
    public void updateContractAuditStatus(Long id, Integer bpmResult) {
        // 1.1 校验合同是否存在
        CrmContractDO contract = validateContractExists(id);
        // 1.2 只有审批中，可以更新审批结果
        if (ObjUtil.notEqual(contract.getAuditStatus(), CrmAuditStatusEnum.PROCESS.getStatus())) {
            log.error("[updateContractAuditStatus][contract({}) 不处于审批中，无法更新审批结果({})]",
                    contract.getId(), bpmResult);
            throw exception(CONTRACT_UPDATE_AUDIT_STATUS_FAIL_NOT_PROCESS);
        }
    public Set<Long> getContractApproverUserIds() {
        return approvalConfigApi.getApproverUserIds(CONTRACT_APPROVE_BIZ_TYPE);
    }

        // 2. 更新合同审批结果
        Integer auditStatus = convertBpmResultToAuditStatus(bpmResult);
        contractMapper.updateById(new CrmContractDO().setId(id).setAuditStatus(auditStatus));
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void auditContract(Long id, Boolean pass, String reviewRemark) {
        // 1. 校验存在
        CrmContractDO contract = validateContractExists(id);
        // 2. 校验处于审批中状态
        if (ObjUtil.notEqual(contract.getAuditStatus(), CrmAuditStatusEnum.PROCESS.getStatus())) {
            throw exception(CONTRACT_AUDIT_FAIL_NOT_PROCESS);
        }
        // 3. 校验当前登录用户是该业务类型的审批人（或签：任一人均可审核）
        Long userId = getLoginUserId();
        approvalConfigApi.validateApprover(CONTRACT_APPROVE_BIZ_TYPE, userId);
        // 4. 审核不通过：必须填写原因，状态置为审核不通过，退回提交人修改后可重新提交
        if (!Boolean.TRUE.equals(pass)) {
            if (StrUtil.isBlank(reviewRemark)) {
                throw exception(CONTRACT_AUDIT_REJECT_REASON_REQUIRED);
            }
            if (contractMapper.auditContract(id, CrmAuditStatusEnum.REJECT.getStatus(),
                    userId, getUserNickname(userId), reviewRemark) != 1) {
                throw exception(CONTRACT_AUDIT_FAIL_NOT_PROCESS);
            }
            return;
        }
        // 5. 审核通过：记录审核人与审核意见，状态置为审核通过
        if (contractMapper.auditContract(id, CrmAuditStatusEnum.APPROVE.getStatus(),
                userId, getUserNickname(userId), reviewRemark) != 1) {
            throw exception(CONTRACT_AUDIT_FAIL_NOT_PROCESS);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateContractAuditStatus(Long id, Integer bpmStatus, String reason) {
        // BPM 审批结果映射为合同审核状态：通过=20 / 不通过=30 / 取消=40
        Integer auditStatus;
        if (BpmTaskStatusEnum.APPROVE.getStatus().equals(bpmStatus)) {
            auditStatus = CrmAuditStatusEnum.APPROVE.getStatus();
        } else if (BpmTaskStatusEnum.REJECT.getStatus().equals(bpmStatus)) {
            auditStatus = CrmAuditStatusEnum.REJECT.getStatus();
        } else if (BpmTaskStatusEnum.CANCEL.getStatus().equals(bpmStatus)) {
            auditStatus = CrmAuditStatusEnum.CANCEL.getStatus();
        } else {
            return;
        }
        if (contractMapper.updateAuditStatusByBpm(id, auditStatus, reason) != 1) {
            log.warn("[updateContractAuditStatus] 合同({}) 不处于审批中状态，忽略 BPM 结果({})", id, bpmStatus);
        }
    }

    // ======================= 查询相关 =======================
@@ -377,8 +481,10 @@
                return PageResult.empty();
            }
        }
        // 2. 查询分页
        return contractMapper.selectPage(pageReqVO, userId, config);
        // 2. 获取用户有权限的客户 ID 列表
        List<Long> permittedCustomerIds = customerApi.getPermittedCustomerIds();
        // 3. 查询分页
        return contractMapper.selectPage(pageReqVO, userId, config, permittedCustomerIds);
    }

    @Override
@@ -462,7 +568,8 @@
        createReqDTO.setContractNo(contract.getNo());
        createReqDTO.setSaleUserId(contract.getOwnerUserId());
        createReqDTO.setOrderTime(LocalDateTime.now().toString());
        createReqDTO.setDiscountPercent(contract.getDiscountPercent());
        createReqDTO.setDiscountPercent(contract.getDiscountPercent() != null ? contract.getDiscountPercent() : BigDecimal.ZERO);
        createReqDTO.setDepositPrice(contract.getDepositPrice() != null ? contract.getDepositPrice() : BigDecimal.ZERO);
        createReqDTO.setRemark("由合同【" + contract.getNo() + "】自动生成");

        // 5. 构建订单项
@@ -472,6 +579,10 @@
                    item.setProductId(cp.getItemId());
                    item.setProductPrice(cp.getContractPrice());
                    item.setCount(cp.getCount());
                    // 合同产品默认需要生产：订单审批通过后才能自动创建 MPS，
                    // 否则「合同 → 订单 → 生产」链路在合同来源的订单上会断掉。
                    // 若个别产品为外购/转售，可在销售订单明细中把「需要生产」改为否。
                    item.setNeedProduction(1);
                    return item;
                })
                .toList();
@@ -494,4 +605,119 @@
        return orderId;
    }

    @Override
    public void updateContractStatus(Long id, Integer status) {
        contractMapper.updateById(new CrmContractDO()
                .setId(id)
                .setAuditStatus(status));
    }

    @Override
    public void updateContractStatusByOrderId(Long orderId, Integer status) {
        CrmContractDO contract = contractMapper.selectByOrderId(orderId);
        if (contract != null) {
            contractMapper.updateById(new CrmContractDO()
                    .setId(contract.getId())
                    .setAuditStatus(status));
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public CrmContractImportRespVO importContractList(List<CrmContractImportExcelVO> importContracts,
                                                      CrmContractImportReqVO importReqVO) {
        // 1. 校验非空
        importContracts = filterList(importContracts, item -> StrUtil.isNotBlank(item.getName()));
        if (CollUtil.isEmpty(importContracts)) {
            throw exception(CONTRACT_IMPORT_LIST_IS_EMPTY);
        }
        // 2. 校验负责人（为空则默认当前操作人）
        Long ownerUserId = importReqVO.getOwnerUserId() != null ? importReqVO.getOwnerUserId() : getLoginUserId();
        adminUserApi.validateUser(ownerUserId);

        // 3. 逐条处理
        CrmContractImportRespVO respVO = CrmContractImportRespVO.builder()
                .createContractNames(new ArrayList<>())
                .updateContractNames(new ArrayList<>())
                .failureContractNames(new LinkedHashMap<>())
                .build();
        importContracts.forEach(importContract -> {
            try {
                // 3.1 解析客户
                CrmCustomerDO customer = customerMapper.selectByCustomerName(importContract.getCustomerName());
                if (customer == null) {
                    throw exception(CONTRACT_IMPORT_CUSTOMER_NOT_EXISTS, importContract.getCustomerName());
                }
                // 3.2 判断是否存在
                CrmContractDO existContract = contractMapper.selectByNameAndCustomerId(
                        importContract.getName(), customer.getId());
                if (existContract == null) {
                    // 3.2.1 新增
                    String no = noRedisDAO.generate(CrmNoRedisDAO.CONTRACT_NO_PREFIX);
                    if (contractMapper.selectByNo(no) != null) {
                        throw exception(CONTRACT_NO_EXISTS);
                    }
                    CrmContractDO contract = BeanUtils.toBean(importContract, CrmContractDO.class)
                            .setCustomerId(customer.getId()).setOwnerUserId(ownerUserId)
                            .setNo(no).setAuditStatus(CrmAuditStatusEnum.DRAFT.getStatus());
                    if (contract.getOrderDate() == null) {
                        contract.setOrderDate(LocalDateTime.now());
                    }
                    if (contract.getDiscountPercent() == null) {
                        contract.setDiscountPercent(BigDecimal.ZERO);
                    }
                    if (contract.getTotalPrice() == null) {
                        calculateTotalPrice(contract, Collections.emptyList());
                    }
                    contractMapper.insert(contract);
                    // 创建数据权限
                    crmPermissionService.createPermission(new CrmPermissionCreateReqBO()
                            .setBizType(CrmBizTypeEnum.CRM_CONTRACT.getType()).setBizId(contract.getId())
                            .setUserId(ownerUserId).setLevel(CrmPermissionLevelEnum.OWNER.getLevel()));
                    respVO.getCreateContractNames().add(importContract.getName());
                    // 记录操作日志
                    getSelf().importContractLog(contract, false);
                    return;
                }
                // 3.2.2 已存在，判断是否允许更新
                if (!importReqVO.getUpdateSupport()) {
                    respVO.getFailureContractNames().put(importContract.getName(),
                            StrUtil.format(CONTRACT_NAME_EXISTS.getMsg(), importContract.getName()));
                    return;
                }
                CrmContractDO updateContract = BeanUtils.toBean(importContract, CrmContractDO.class)
                        .setId(existContract.getId()).setCustomerId(customer.getId());
                contractMapper.updateById(updateContract);
                respVO.getUpdateContractNames().add(importContract.getName());
                // 记录操作日志
                getSelf().importContractLog(updateContract, true);
            } catch (ServiceException ex) {
                respVO.getFailureContractNames().put(importContract.getName(), ex.getMessage());
            }
        });
        return respVO;
    }

    /**
     * 记录导入合同时的操作日志
     *
     * @param contract 合同信息
     * @param isUpdate 是否更新；true - 更新，false - 新增
     */
    @LogRecord(type = CRM_CONTRACT_TYPE, subType = CRM_CONTRACT_IMPORT_SUB_TYPE, bizNo = "{{#contract.id}}",
            success = CRM_CONTRACT_IMPORT_SUCCESS)
    public void importContractLog(CrmContractDO contract, boolean isUpdate) {
        LogRecordContext.putVariable("contract", contract);
        LogRecordContext.putVariable("isUpdate", isUpdate);
    }

    /**
     * 获得自身的代理对象，解决 AOP 生效问题
     *
     * @return 自己
     */
    private CrmContractServiceImpl getSelf() {
        return SpringUtil.getBean(getClass());
    }

}