refactor(aftersales): 故障赔付/服务补偿单审核改为审批配置状态机

liu

22 小时以前 d58f6629879c457cd49fdb8d3cc7318c497c5dc3

refactor(aftersales): 故障赔付/服务补偿单审核改为审批配置状态机

- 提交/审核不再走 BPM 流程，移除 yudao-module-bpm 依赖与流程监听器
- 审核接口改为 pass + 审核意见（不通过必填），审核人/时间/意见字段更名 reviewer*/review*
- 新增 approver-ids 接口，读取审批配置中的审批人集合供前端按钮鉴权

Co-Authored-By: Claude <noreply@anthropic.com>

 yudao-module-aftersales/pom.xml

@@ -42,11 +42,6 @@
            <artifactId>yudao-module-infra</artifactId>
            <version>${revision}</version>
        </dependency>
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-bpm</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- MDM ä¸»æ•°æ®ç®¡ç† API -->
        <dependency>

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/compensation/AfterSaleCompensationController.java

@@ -29,7 +29,6 @@

import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;

@Tag(name = "管理后台 - å”®åŽèµ”付/服务补偿单")
@RestController
@@ -88,27 +87,27 @@
    }

    @PutMapping("/submit")
    @Operation(summary = "提交赔付/服务补偿单审批")
    @Operation(summary = "提交赔付/服务补偿单审批（未提交/审核不通过→审批中），审批人由审批配置统一指定")
    @Parameter(name = "id", description = "编号", required = true)
    @PreAuthorize("@ss.hasPermission('aftersales:compensation:submit')")
    public CommonResult<Boolean> submitCompensation(@RequestParam("id") Long id,
                                                    @RequestParam("processDefinitionKey") String processDefinitionKey) {
        compensationService.submitCompensation(id, processDefinitionKey, getLoginUserId());
    public CommonResult<Boolean> submitCompensation(@RequestParam("id") Long id) {
        compensationService.submitCompensation(id);
        return success(true);
    }

    @PutMapping("/audit")
    @Operation(summary = "审批赔付/服务补偿单（通过/驳回）")
    @Operation(summary = "审核赔付/服务补偿单（审批中→审核通过/审核不通过），仅审批人本人可操作")
    @PreAuthorize("@ss.hasPermission('aftersales:compensation:audit')")
    public CommonResult<Boolean> auditCompensation(@Valid @RequestBody AfterSaleCompensationAuditReqVO auditReqVO) {
        compensationService.auditCompensation(auditReqVO);
        compensationService.auditCompensation(auditReqVO.getId(), auditReqVO.getPass(), auditReqVO.getReviewRemark());
        return success(true);
    }

    @GetMapping("/approve-process-list")
    @Operation(summary = "获得赔付/服务补偿单审批流程定义列表")
    @GetMapping("/approver-ids")
    @Operation(summary = "获得审批人编号集合，供前端判断是否展示审核按钮")
    @PreAuthorize("@ss.hasPermission('aftersales:compensation:query')")
    public CommonResult<List<Map<String, Object>>> getCompensationApproveProcessDefinitionList() {
        return success(compensationService.getCompensationApproveProcessDefinitionList());
    public CommonResult<Set<Long>> getApproverUserIds() {
        return success(compensationService.getCompensationApproverUserIds());
    }

    // ========== å†…部方法：批量拼装关联名称 ==========

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/compensation/vo/AfterSaleCompensationAuditReqVO.java

@@ -5,9 +5,9 @@
import lombok.Data;

/**
 * å”®åŽèµ”付/服务补偿单 å®¡æ‰¹ Request VO
 * å”®åŽèµ”付/服务补偿单 å®¡æ ¸ Request VO
 */
@Schema(description = "售后赔付/服务补偿单 - å®¡æ‰¹ Request VO")
@Schema(description = "售后赔付/服务补偿单 - å®¡æ ¸ Request VO")
@Data
public class AfterSaleCompensationAuditReqVO {

@@ -15,11 +15,11 @@
    @NotNull(message = "赔付单编号不能为空")
    private Long id;

    @Schema(description = "审批结果（20 é€šè¿‡ / 30 é©³å›žï¼‰", requiredMode = Schema.RequiredMode.REQUIRED, example = "20")
    @NotNull(message = "审批结果不能为空")
    private Integer auditStatus;
    @Schema(description = "是否通过：true=审核通过 / false=审核不通过", requiredMode = Schema.RequiredMode.REQUIRED, example = "true")
    @NotNull(message = "请选择审核结果")
    private Boolean pass;

    @Schema(description = "审批备注", example = "同意赔付")
    private String remark;
    @Schema(description = "审核意见（通过时选填 / ä¸é€šè¿‡æ—¶å¿…填）", example = "金额需再次核对")
    private String reviewRemark;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/compensation/vo/AfterSaleCompensationRespVO.java

@@ -61,17 +61,17 @@
    @Schema(description = "审批状态名称", example = "未提交")
    private String auditStatusName;

    @Schema(description = "审批流程实例编号")
    private String processInstanceId;
    @Schema(description = "审核人用户编号", example = "1")
    private Long reviewerId;

    @Schema(description = "审核人", example = "1")
    private Long auditUserId;
    @Schema(description = "审核人姓名", example = "李工")
    private String reviewerName;

    @Schema(description = "审核时间")
    private LocalDateTime auditTime;
    private LocalDateTime reviewTime;

    @Schema(description = "审核备注")
    private String auditRemark;
    @Schema(description = "审核意见（审核通过时的意见 / å®¡æ ¸ä¸é€šè¿‡æ—¶çš„原因）", example = "金额需再次核对")
    private String reviewRemark;

    @Schema(description = "支付状态（账务联动预留）")
    private Integer payStatus;

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/dataobject/compensation/AfterSaleCompensationDO.java

@@ -65,25 +65,33 @@
    /**
     * å®¡æ‰¹çŠ¶æ€
     *
     * åªç”±ä¸šåŠ¡æµç¨‹é©±åŠ¨ï¼Œä¸æŽ¥å—前端直接赋值：创建时固定为未提交，提交审批后置为审批中，
     * å®¡æ ¸é€šè¿‡ / ä¸é€šè¿‡ç”±
     * {@link cn.iocoder.yudao.module.aftersales.service.compensation.AfterSaleCompensationService#auditCompensation}
     * æŽ¨è¿›ã€‚
     *
     * æžšä¸¾ {@link AfterSaleCompensationAuditStatusEnum}
     */
    private Integer auditStatus;
    /**
     * å®¡æ‰¹æµç¨‹å®žä¾‹ç¼–号
     * å®¡æ ¸äººç”¨æˆ·ç¼–号
     *
     * å®¡æ‰¹äººç”±ã€Œç³»ç»Ÿç®¡ç† - å®¡æ‰¹é…ç½®ã€æŒ‰ä¸šåŠ¡ç±»åž‹ç»Ÿä¸€é…ç½®ï¼ˆä¸šåŠ¡ç¼–码 compensation_approve），
     * æäº¤æ—¶ä¸æŒ‡å®šï¼›æ­¤å¤„记录实际执行审核的用户。
     */
    private String processInstanceId;
    private Long reviewerId;
    /**
     * å®¡æ ¸äºº
     * å®¡æ ¸äººå§“名（审核时冗余记录，避免列表展示再查用户）
     */
    private Long auditUserId;
    private String reviewerName;
    /**
     * å®¡æ ¸æ—¶é—´
     */
    private LocalDateTime auditTime;
    private LocalDateTime reviewTime;
    /**
     * å®¡æ ¸å¤‡æ³¨
     * å®¡æ ¸æ„è§ï¼ˆå®¡æ ¸é€šè¿‡æ—¶çš„意见 / å®¡æ ¸ä¸é€šè¿‡æ—¶çš„原因）
     */
    private String auditRemark;
    private String reviewRemark;
    /**
     * æ”¯ä»˜çŠ¶æ€ï¼ˆè´¦åŠ¡è”动预留，接财务后使用）
     */

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/mysql/compensation/AfterSaleCompensationMapper.java

@@ -5,7 +5,10 @@
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.aftersales.controller.admin.compensation.vo.AfterSaleCompensationPageReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.compensation.AfterSaleCompensationDO;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.apache.ibatis.annotations.Mapper;

import java.time.LocalDateTime;

/**
 * å”®åŽèµ”付/服务补偿单 Mapper
@@ -17,6 +20,49 @@
        return selectOne(AfterSaleCompensationDO::getCompensationNo, compensationNo);
    }

    /**
     * æäº¤å®¡æ‰¹ï¼šç½®ä¸ºå®¡æ‰¹ä¸­ï¼Œå¹¶æ¸…空上一轮审核结果
     *
     * ç”¨ UpdateWrapper è€Œéž updateById：MyBatis-Plus é»˜è®¤çš„字段更新策略会忽略 null，
     * ç›´æŽ¥ updateById æ— æ³•æŠŠå®¡æ ¸ä¸é€šè¿‡åŽæ®‹ç•™çš„审核人、审核时间、审核意见真正清空。
     *
     * @param id     èµ”付单编号
     * @param status ç›®æ ‡çŠ¶æ€ï¼ˆå®¡æ‰¹ä¸­ï¼‰
     * @return å½±å“è¡Œæ•°
     */
    default int submitAndResetAuditInfo(Long id, Integer status) {
        return update(null, new LambdaUpdateWrapper<AfterSaleCompensationDO>()
                .eq(AfterSaleCompensationDO::getId, id)
                .set(AfterSaleCompensationDO::getAuditStatus, status)
                .set(AfterSaleCompensationDO::getReviewerId, null)
                .set(AfterSaleCompensationDO::getReviewerName, null)
                .set(AfterSaleCompensationDO::getReviewTime, null)
                .set(AfterSaleCompensationDO::getReviewRemark, null));
    }

    /**
     * å®¡æ ¸ï¼šå†™å…¥å®¡æ ¸ç»“果、审核人与审核意见
     *
     * reviewRemark å…è®¸ä¸º null（审核通过时意见可选），故同样使用 UpdateWrapper ç›´å†™ã€‚
     *
     * @param id           èµ”付单编号
     * @param status       ç›®æ ‡çŠ¶æ€ï¼ˆå®¡æ ¸é€šè¿‡ / å®¡æ ¸ä¸é€šè¿‡ï¼‰
     * @param reviewerId   å®¡æ ¸äººç¼–号
     * @param reviewerName å®¡æ ¸äººå§“名
     * @param reviewRemark å®¡æ ¸æ„è§
     * @return å½±å“è¡Œæ•°
     */
    default int auditCompensation(Long id, Integer status, Long reviewerId,
                                  String reviewerName, String reviewRemark) {
        return update(null, new LambdaUpdateWrapper<AfterSaleCompensationDO>()
                .eq(AfterSaleCompensationDO::getId, id)
                .set(AfterSaleCompensationDO::getAuditStatus, status)
                .set(AfterSaleCompensationDO::getReviewerId, reviewerId)
                .set(AfterSaleCompensationDO::getReviewerName, reviewerName)
                .set(AfterSaleCompensationDO::getReviewTime, LocalDateTime.now())
                .set(AfterSaleCompensationDO::getReviewRemark, reviewRemark));
    }

    default PageResult<AfterSaleCompensationDO> selectPage(AfterSaleCompensationPageReqVO reqVO) {
        return selectPage(reqVO, new LambdaQueryWrapperX<AfterSaleCompensationDO>()
                .likeIfPresent(AfterSaleCompensationDO::getCompensationNo, reqVO.getCompensationNo())

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/ErrorCodeConstants.java

@@ -38,10 +38,10 @@
    // ========== èµ”付/服务补偿单 1-022-004-000 ==========
    ErrorCode COMPENSATION_NOT_EXISTS = new ErrorCode(1_022_004_000, "赔付/服务补偿单不存在");
    ErrorCode COMPENSATION_NO_EXISTS = new ErrorCode(1_022_004_001, "生成赔付单号重复，请重试");
    ErrorCode COMPENSATION_SUBMIT_FAIL_NOT_DRAFT = new ErrorCode(1_022_004_002, "提交赔付单审批失败，原因：赔付单不是草稿状态");
    ErrorCode COMPENSATION_BPM_PROCESS_DEFINITION_NOT_EXISTS = new ErrorCode(1_022_004_003, "赔付单审批流程不存在或未激活，请检查 BPM é…ç½®");
    ErrorCode COMPENSATION_UPDATE_AUDIT_STATUS_FAIL_NOT_PROCESS = new ErrorCode(1_022_004_004, "更新赔付单审批状态失败，原因：赔付单不处于审批中");
    ErrorCode COMPENSATION_DELETE_FAIL_NOT_DRAFT = new ErrorCode(1_022_004_005, "赔付单不是草稿状态，无法删除");
    ErrorCode COMPENSATION_TICKET_NOT_EXISTS = new ErrorCode(1_022_004_006, "关联的售后工单不存在");
    ErrorCode COMPENSATION_SUBMIT_FAIL_NOT_EDITABLE = new ErrorCode(1_022_004_002, "只有未提交或审核不通过状态的赔付单才能提交审批");
    ErrorCode COMPENSATION_AUDIT_FAIL_NOT_PROCESS = new ErrorCode(1_022_004_003, "只有审批中状态的赔付单才能审核");
    ErrorCode COMPENSATION_DELETE_FAIL_NOT_DRAFT = new ErrorCode(1_022_004_004, "赔付单不是草稿状态，无法删除");
    ErrorCode COMPENSATION_TICKET_NOT_EXISTS = new ErrorCode(1_022_004_005, "关联的售后工单不存在");
    ErrorCode COMPENSATION_AUDIT_REJECT_REASON_REQUIRED = new ErrorCode(1_022_004_006, "审核不通过时必须填写不通过原因");

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/compensation/AfterSaleCompensationService.java

@@ -1,13 +1,11 @@
package cn.iocoder.yudao.module.aftersales.service.compensation;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.aftersales.controller.admin.compensation.vo.AfterSaleCompensationAuditReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.compensation.vo.AfterSaleCompensationPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.compensation.vo.AfterSaleCompensationSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.compensation.AfterSaleCompensationDO;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * å”®åŽèµ”付/服务补偿单 Service æŽ¥å£
@@ -25,23 +23,28 @@
    PageResult<AfterSaleCompensationDO> getCompensationPage(AfterSaleCompensationPageReqVO pageReqVO);

    /**
     * æäº¤èµ”付单审批
     * æäº¤èµ”付单审批（未提交 / å®¡æ ¸ä¸é€šè¿‡ â†’ å®¡æ‰¹ä¸­ï¼‰
     *
     * å®¡æ‰¹äººç”±ã€Œç³»ç»Ÿç®¡ç† - å®¡æ‰¹é…ç½®ã€æŒ‰ä¸šåŠ¡ç±»åž‹ compensation_approve ç»Ÿä¸€æŒ‡å®šï¼Œæäº¤æ—¶ä¸é€‰äººã€‚
     *
     * @param id èµ”付单编号
     */
    void submitCompensation(Long id, String processDefinitionKey, Long userId);
    void submitCompensation(Long id);

    /**
     * å®¡æ‰¹èµ”付单（通过/驳回）
     * èŽ·å¾—赔付单审批人编号集合，供前端判断是否展示审核按钮
     *
     * @return å®¡æ‰¹äººç”¨æˆ·ç¼–号集合
     */
    void auditCompensation(AfterSaleCompensationAuditReqVO auditReqVO);
    Set<Long> getCompensationApproverUserIds();

    /**
     * æ›´æ–°èµ”付单审批状态（BPM ç›‘听回调）
     * å®¡æ ¸èµ”付单（审批中 â†’ å®¡æ ¸é€šè¿‡ / å®¡æ ¸ä¸é€šè¿‡ï¼‰
     *
     * @param id           èµ”付单编号
     * @param pass         æ˜¯å¦é€šè¿‡
     * @param reviewRemark å®¡æ ¸æ„è§ï¼Œå®¡æ ¸ä¸é€šè¿‡æ—¶å¿…å¡«
     */
    void updateCompensationAuditStatus(Long id, Integer bpmResult);

    /**
     * èŽ·å¾—赔付单审批流程定义列表
     */
    List<Map<String, Object>> getCompensationApproveProcessDefinitionList();
    void auditCompensation(Long id, Boolean pass, String reviewRemark);

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/compensation/AfterSaleCompensationServiceImpl.java

@@ -1,43 +1,31 @@
package cn.iocoder.yudao.module.aftersales.service.compensation;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.controller.admin.compensation.vo.AfterSaleCompensationAuditReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.compensation.vo.AfterSaleCompensationPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.compensation.vo.AfterSaleCompensationSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.compensation.AfterSaleCompensationDO;
import cn.iocoder.yudao.module.aftersales.dal.mysql.compensation.AfterSaleCompensationMapper;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleCompensationAuditStatusEnum;
import cn.iocoder.yudao.module.aftersales.enums.ErrorCodeConstants;
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.BpmProcessDefinitionInfoDO;
import cn.iocoder.yudao.module.bpm.service.definition.BpmCategoryService;
import cn.iocoder.yudao.module.bpm.service.definition.BpmProcessDefinitionService;
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 jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.repository.ProcessDefinition;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
import static cn.iocoder.yudao.module.aftersales.util.AfterSaleCompensationStatusUtils.convertBpmResultToAuditStatus;

/**
 * å”®åŽèµ”付/服务补偿单 Service å®žçŽ°ç±»
@@ -47,22 +35,19 @@
@Slf4j
public class AfterSaleCompensationServiceImpl implements AfterSaleCompensationService {

    private static final Integer AUDIT_DRAFT = 0;
    private static final Integer AUDIT_PASS = 20;

    /**
     * BPM èµ”付审批分类编码
     * èµ”付单审批的业务类型编码
     *
     * ä¸Ž system_approval_config.biz_type å¯¹åº”，审批人在「系统管理 - å®¡æ‰¹é…ç½®ã€ä¸­ç»´æŠ¤ã€‚
     */
    private static final String COMPENSATION_APPROVE_CATEGORY_CODE = "compensation_approve";
    private static final String COMPENSATION_APPROVE_BIZ_TYPE = "compensation_approve";

    @Resource
    private AfterSaleCompensationMapper compensationMapper;
    @Resource
    private BpmProcessInstanceApi bpmProcessInstanceApi;
    private ApprovalConfigApi approvalConfigApi;
    @Resource
    private BpmCategoryService bpmCategoryService;
    @Resource
    private BpmProcessDefinitionService bpmProcessDefinitionService;
    private AdminUserApi adminUserApi;

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -73,7 +58,7 @@
        }
        AfterSaleCompensationDO entity = BeanUtils.toBean(createReqVO, AfterSaleCompensationDO.class, req -> req
                .setCompensationNo(compensationNo)
                .setAuditStatus(AUDIT_DRAFT));
                .setAuditStatus(AfterSaleCompensationAuditStatusEnum.DRAFT.getStatus()));
        compensationMapper.insert(entity);
        return entity.getId();
    }
@@ -84,7 +69,7 @@
        if (exists == null) {
            throw exception(ErrorCodeConstants.COMPENSATION_NOT_EXISTS);
        }
        if (ObjUtil.notEqual(exists.getAuditStatus(), AUDIT_DRAFT)) {
        if (ObjUtil.notEqual(exists.getAuditStatus(), AfterSaleCompensationAuditStatusEnum.DRAFT.getStatus())) {
            throw exception(ErrorCodeConstants.COMPENSATION_DELETE_FAIL_NOT_DRAFT);
        }
        AfterSaleCompensationDO entity = BeanUtils.toBean(updateReqVO, AfterSaleCompensationDO.class, req -> req
@@ -100,7 +85,7 @@
        if (exists == null) {
            throw exception(ErrorCodeConstants.COMPENSATION_NOT_EXISTS);
        }
        if (ObjUtil.notEqual(exists.getAuditStatus(), AUDIT_DRAFT)) {
        if (ObjUtil.notEqual(exists.getAuditStatus(), AfterSaleCompensationAuditStatusEnum.DRAFT.getStatus())) {
            throw exception(ErrorCodeConstants.COMPENSATION_DELETE_FAIL_NOT_DRAFT);
        }
        compensationMapper.deleteById(id);
@@ -117,130 +102,75 @@
    }

    @Override
    public void submitCompensation(Long id, String processDefinitionKey, Long userId) {
        // 1. æ ¡éªŒèµ”付单是否在草稿状态
        AfterSaleCompensationDO compensation = compensationMapper.selectById(id);
        if (compensation == null) {
            throw exception(ErrorCodeConstants.COMPENSATION_NOT_EXISTS);
        }
        if (ObjUtil.notEqual(compensation.getAuditStatus(), AfterSaleCompensationAuditStatusEnum.DRAFT.getStatus())) {
            throw exception(ErrorCodeConstants.COMPENSATION_SUBMIT_FAIL_NOT_DRAFT);
    @Transactional(rollbackFor = Exception.class)
    public void submitCompensation(Long id) {
        // 1. æ ¡éªŒå­˜åœ¨ + å¯æäº¤çŠ¶æ€ï¼ˆæœªæäº¤ / å®¡æ ¸ä¸é€šè¿‡ï¼‰
        AfterSaleCompensationDO compensation = validateCompensationExists(id);
        if (ObjUtil.notEqual(compensation.getAuditStatus(), AfterSaleCompensationAuditStatusEnum.DRAFT.getStatus())
                && ObjUtil.notEqual(compensation.getAuditStatus(), AfterSaleCompensationAuditStatusEnum.REJECT.getStatus())) {
            throw exception(ErrorCodeConstants.COMPENSATION_SUBMIT_FAIL_NOT_EDITABLE);
        }

        // 2. æ ¡éªŒèµ”付审批分类和流程定义是否存在，且传入的流程定义处于激活状态
        validateCompensationApproveCategoryAndProcessDefinition();
        ProcessDefinition processDefinition = bpmProcessDefinitionService.getActiveProcessDefinition(processDefinitionKey);
        if (processDefinition == null) {
            throw exception(ErrorCodeConstants.COMPENSATION_BPM_PROCESS_DEFINITION_NOT_EXISTS);
        }
        // 2. æ ¡éªŒå®¡æ‰¹é…ç½®å·²å¯ç”¨ä¸”配置了有效审批人（未配置时抛出带明确提示的业务异常）
        approvalConfigApi.validateApprovalEnabledAndGetApprovers(COMPENSATION_APPROVE_BIZ_TYPE);

        // 3. åˆ›å»ºèµ”付审批流程实例
        String processInstanceId = bpmProcessInstanceApi.createProcessInstance(userId,
                new BpmProcessInstanceCreateReqDTO().setProcessDefinitionKey(processDefinitionKey)
                        .setBusinessKey(String.valueOf(id)));

        // 4. æ›´æ–°èµ”付单流程编号与审批状态
        compensationMapper.updateById(new AfterSaleCompensationDO().setId(id).setProcessInstanceId(processInstanceId)
                .setAuditStatus(AfterSaleCompensationAuditStatusEnum.PROCESS.getStatus()));
        // 3. çŠ¶æ€ç½®ä¸ºå®¡æ‰¹ä¸­ï¼Œå¹¶æ¸…空上一轮审核结果，避免残留「审核不通过」的原因
        compensationMapper.submitAndResetAuditInfo(id, AfterSaleCompensationAuditStatusEnum.PROCESS.getStatus());
    }

    @Override
    public void auditCompensation(AfterSaleCompensationAuditReqVO auditReqVO) {
        AfterSaleCompensationDO exists = compensationMapper.selectById(auditReqVO.getId());
        if (exists == null) {
            throw exception(ErrorCodeConstants.COMPENSATION_NOT_EXISTS);
        }
        AfterSaleCompensationDO update = new AfterSaleCompensationDO();
        update.setId(exists.getId());
        update.setAuditStatus(auditReqVO.getAuditStatus());
        update.setAuditUserId(getLoginUserId());
        update.setAuditTime(LocalDateTime.now());
        if (StrUtil.isNotBlank(auditReqVO.getRemark())) {
            update.setAuditRemark(auditReqVO.getRemark());
        }
        compensationMapper.updateById(update);
    public Set<Long> getCompensationApproverUserIds() {
        return approvalConfigApi.getApproverUserIds(COMPENSATION_APPROVE_BIZ_TYPE);
    }

    @Override
    public void updateCompensationAuditStatus(Long id, Integer bpmResult) {
        // 1.1 æ ¡éªŒèµ”付单是否存在
        AfterSaleCompensationDO compensation = compensationMapper.selectById(id);
        if (compensation == null) {
            throw exception(ErrorCodeConstants.COMPENSATION_NOT_EXISTS);
        }
        // 1.2 åªæœ‰å®¡æ‰¹ä¸­ï¼Œå¯ä»¥æ›´æ–°å®¡æ‰¹ç»“æžœ
    @Transactional(rollbackFor = Exception.class)
    public void auditCompensation(Long id, Boolean pass, String reviewRemark) {
        // 1. æ ¡éªŒå­˜åœ¨
        AfterSaleCompensationDO compensation = validateCompensationExists(id);
        // 2. æ ¡éªŒå¤„于审批中状态
        if (ObjUtil.notEqual(compensation.getAuditStatus(), AfterSaleCompensationAuditStatusEnum.PROCESS.getStatus())) {
            log.error("[updateCompensationAuditStatus][compensation({}) ä¸å¤„于审批中，无法更新审批结果({})]", compensation.getId(), bpmResult);
            throw exception(ErrorCodeConstants.COMPENSATION_UPDATE_AUDIT_STATUS_FAIL_NOT_PROCESS);
            throw exception(ErrorCodeConstants.COMPENSATION_AUDIT_FAIL_NOT_PROCESS);
        }
        // 3. æ ¡éªŒå½“前登录用户是该业务类型的审批人（或签：任一人均可审核）
        Long userId = getLoginUserId();
        approvalConfigApi.validateApprover(COMPENSATION_APPROVE_BIZ_TYPE, userId);
        // 4. å®¡æ ¸ä¸é€šè¿‡ï¼šå¿…须填写原因，状态置为审核不通过，退回提交人修改后可重新提交
        if (!Boolean.TRUE.equals(pass)) {
            if (StrUtil.isBlank(reviewRemark)) {
                throw exception(ErrorCodeConstants.COMPENSATION_AUDIT_REJECT_REASON_REQUIRED);
            }
            compensationMapper.auditCompensation(id, AfterSaleCompensationAuditStatusEnum.REJECT.getStatus(),
                    userId, getUserNickname(userId), reviewRemark);
            return;
        }
        // 5. å®¡æ ¸é€šè¿‡ï¼šè®°å½•å®¡æ ¸äººä¸Žå®¡æ ¸æ„è§ï¼ŒçŠ¶æ€ç½®ä¸ºå®¡æ ¸é€šè¿‡
        compensationMapper.auditCompensation(id, AfterSaleCompensationAuditStatusEnum.APPROVE.getStatus(),
                userId, getUserNickname(userId), reviewRemark);
        // 6. å®¡æ ¸é€šè¿‡åŽçš„后置业务逻辑：当前赔付单审批通过后无自动生成下游单据的动作，
        //    æ”¯ä»˜çŠ¶æ€ï¼ˆpayStatus）待后续接入财务模块时再联动。
        }

        // 2. æ›´æ–°èµ”付单审批结果
        Integer auditStatus = convertBpmResultToAuditStatus(bpmResult);
        compensationMapper.updateById(new AfterSaleCompensationDO().setId(id).setAuditStatus(auditStatus));
    private AfterSaleCompensationDO validateCompensationExists(Long id) {
        AfterSaleCompensationDO compensation = compensationMapper.selectById(id);
        if (compensation == null) {
            throw exception(ErrorCodeConstants.COMPENSATION_NOT_EXISTS);
    }

    @Override
    public List<Map<String, Object>> getCompensationApproveProcessDefinitionList() {
        // 1. æ ¡éªŒèµ”付审批分类和流程定义是否存在
        validateCompensationApproveCategoryAndProcessDefinition();

        // 2. èŽ·å–分类下的流程定义信息
        List<BpmProcessDefinitionInfoDO> definitionInfoList = bpmProcessDefinitionService
                .getProcessDefinitionInfoListByCategory(COMPENSATION_APPROVE_CATEGORY_CODE);

        // 3. èŽ·å–流程定义详情
        Set<String> processDefinitionIds = convertSet(definitionInfoList, BpmProcessDefinitionInfoDO::getProcessDefinitionId);
        List<ProcessDefinition> processDefinitions = bpmProcessDefinitionService.getProcessDefinitionList(processDefinitionIds);

        // 4. è¿‡æ»¤ï¼šåªä¿ç•™æ¿€æ´»çŠ¶æ€ï¼Œä¸”相同 key åªä¿ç•™æœ€æ–°ç‰ˆæœ¬
        Map<String, ProcessDefinition> latestVersionMap = new HashMap<>();
        for (ProcessDefinition pd : processDefinitions) {
            if (pd.isSuspended()) {
                continue;
            }
            ProcessDefinition existing = latestVersionMap.get(pd.getKey());
            if (existing == null || pd.getVersion() > existing.getVersion()) {
                latestVersionMap.put(pd.getKey(), pd);
            }
        }

        // 5. è¿”回流程定义列表
        List<Map<String, Object>> result = new ArrayList<>();
        for (ProcessDefinition pd : latestVersionMap.values()) {
            Map<String, Object> item = new HashMap<>();
            item.put("id", pd.getId());
            item.put("key", pd.getKey());
            item.put("name", pd.getName());
            item.put("version", pd.getVersion());
            result.add(item);
        }
        return result;
        return compensation;
    }

    /**
     * æ ¡éªŒ BPM èµ”付审批分类和流程定义是否存在
     * èŽ·å–用户昵称
     *
     * @param userId ç”¨æˆ·ç¼–号
     * @return æ˜µç§°ï¼Œç”¨æˆ·ä¸å­˜åœ¨æ—¶è¿”回 null
     */
    private void validateCompensationApproveCategoryAndProcessDefinition() {
        // 1. æ ¡éªŒåˆ†ç±»æ˜¯å¦å­˜åœ¨
        Map<String, ?> categoryMap = bpmCategoryService.getCategoryMap(Collections.singletonList(COMPENSATION_APPROVE_CATEGORY_CODE));
        if (!categoryMap.containsKey(COMPENSATION_APPROVE_CATEGORY_CODE)) {
            throw exception(ErrorCodeConstants.COMPENSATION_BPM_PROCESS_DEFINITION_NOT_EXISTS);
    private String getUserNickname(Long userId) {
        if (userId == null) {
            return null;
        }

        // 2. æ ¡éªŒåˆ†ç±»ä¸‹æ˜¯å¦æœ‰å¯ç”¨çš„流程定义
        List<BpmProcessDefinitionInfoDO> definitionInfoList = bpmProcessDefinitionService
                .getProcessDefinitionInfoListByCategory(COMPENSATION_APPROVE_CATEGORY_CODE);
        if (CollUtil.isEmpty(definitionInfoList)) {
            throw exception(ErrorCodeConstants.COMPENSATION_BPM_PROCESS_DEFINITION_NOT_EXISTS);
        }

        // 3. æ ¡éªŒæ˜¯å¦æœ‰æ¿€æ´»çŠ¶æ€çš„流程定义
        Set<String> processDefinitionIds = convertSet(definitionInfoList, BpmProcessDefinitionInfoDO::getProcessDefinitionId);
        List<ProcessDefinition> processDefinitions = bpmProcessDefinitionService.getProcessDefinitionList(processDefinitionIds);
        boolean hasActiveDefinition = processDefinitions.stream().anyMatch(pd -> !pd.isSuspended());
        if (!hasActiveDefinition) {
            throw exception(ErrorCodeConstants.COMPENSATION_BPM_PROCESS_DEFINITION_NOT_EXISTS);
        }
        AdminUserRespDTO user = adminUserApi.getUser(userId);
        return user == null ? null : user.getNickname();
    }

    private String generateCompensationNo() {

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/compensation/listener/AfterSaleCompensationStatusListener.java

ÎļþÒÑɾ³ý

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/util/AfterSaleCompensationStatusUtils.java

ÎļþÒÑɾ³ý