feat：增加 bpm 工作流的能力

pom.xml

@@ -13,7 +13,7 @@
         <module>yudao-framework</module>
         <!--  各种 module 拓展 -->
 <!--        <module>yudao-module-member</module>-->
-<!--        <module>yudao-module-bpm</module>-->
+        <module>yudao-module-bpm</module>
         <module>yudao-module-system</module>
         <module>yudao-module-infra</module>
         <!--        <module>yudao-module-pay</module>-->

yudao-framework/yudao-spring-boot-starter-biz-tenant/src/main/java/cn/iocoder/yudao/framework/tenant/config/TenantProperties.java

@@ -3,6 +3,7 @@ package cn.iocoder.yudao.framework.tenant.config;
 import lombok.Data;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
+import java.util.Collections;
 import java.util.Set;
 
 /**
@@ -29,13 +30,13 @@ public class TenantProperties {
      *
      * 默认情况下，每个请求需要带上 tenant-id 的请求头。但是，部分请求是无需带上的，例如说短信回调、支付回调等 Open API！
      */
-    private Set<String> ignoreUrls;
+    private Set<String> ignoreUrls = Collections.emptySet();
 
     /**
      * 需要忽略多租户的表
      *
      * 即默认所有表都开启多租户的功能，所以记得添加对应的 tenant_id 字段哟
      */
-    private Set<String> ignoreTables;
+    private Set<String> ignoreTables = Collections.emptySet();
 
 }

yudao-framework/yudao-spring-boot-starter-flowable/src/main/java/cn/iocoder/yudao/framework/flowable/core/util/FlowableUtils.java

@@ -59,4 +59,15 @@ public class FlowableUtils {
         BpmnXMLConverter converter = new BpmnXMLConverter();
         return converter.convertToXML(model);
     }
+
+    // ========== Execution 相关的工具方法 ==========
+
+    public static String formatCollectionVariable(String activityId) {
+        return activityId + "_assignees";
+    }
+
+    public static String formatCollectionElementVariable(String activityId) {
+        return activityId + "_assignee";
+    }
+
 }

yudao-gateway/src/main/resources/application.yaml

@@ -23,3 +23,7 @@ spring:
           uri: grayLb://infra-server
           predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
             - Path=/app-api/infra/**
+        - id: bpm-admin-api # 路由的编号
+          uri: grayLb://bpm-server
+          predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
+            - Path=/admin-api/bpm/**

yudao-module-bpm/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>cn.iocoder.cloud</groupId>
+        <artifactId>yudao</artifactId>
+        <version>${revision}</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <modules>
+        <module>yudao-module-bpm-api</module>
+        <module>yudao-module-bpm-biz</module>
+    </modules>
+    <artifactId>yudao-module-bpm</artifactId>
+    <packaging>pom</packaging>
+
+    <name>${project.artifactId}</name>
+    <description>
+        bpm 包下，业务流程管理（Business Process Management），我们放工作流的功能。
+        例如说：流程定义、表单配置、审核中心（我的申请、我的待办、我的已办）等等
+        bpm 解释：https://baike.baidu.com/item/BPM/1933
+
+        工作流基于 Flowable 6 实现，分成流程定义、流程表单、流程实例、流程任务等功能模块。
+    </description>
+
+</project>

yudao-module-bpm/yudao-module-bpm-api/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>cn.iocoder.cloud</groupId>
+        <artifactId>yudao-module-bpm</artifactId>
+        <version>${revision}</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>yudao-module-bpm-api</artifactId>
+    <packaging>jar</packaging>
+
+    <name>${project.artifactId}</name>
+    <description>
+        bpm 模块 API，暴露给其它模块调用
+    </description>
+
+    <dependencies>
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-common</artifactId>
+        </dependency>
+
+        <!-- 参数校验 -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+            <optional>true</optional>
+        </dependency>
+    </dependencies>
+
+</project>

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/api/package-info.java

+/**
+ * bpm API 包，定义暴露给其它模块的 API
+ */
+package cn.iocoder.yudao.module.bpm.api;

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/api/task/BpmProcessInstanceApi.java

+package cn.iocoder.yudao.module.bpm.api.task;
+
+import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
+
+import javax.validation.Valid;
+
+/**
+ * 流程实例 Api 接口
+ *
+ * @author 芋道源码
+ */
+public interface BpmProcessInstanceApi {
+
+    /**
+     * 创建流程实例（提供给内部）
+     *
+     * @param userId 用户编号
+     * @param reqDTO 创建信息
+     * @return 实例的编号
+     */
+    String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqDTO reqDTO);
+
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/api/task/dto/BpmProcessInstanceCreateReqDTO.java

+package cn.iocoder.yudao.module.bpm.api.task.dto;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import java.util.Map;
+
+/**
+ * 流程实例的创建 Request DTO
+ *
+ * @author 芋道源码
+ */
+@Data
+public class BpmProcessInstanceCreateReqDTO {
+
+    /**
+     * 流程定义的标识
+     */
+    @NotEmpty(message = "流程定义的标识不能为空")
+    private String processDefinitionKey;
+    /**
+     * 变量实例
+     */
+    private Map<String, Object> variables;
+
+    /**
+     * 业务的唯一标识
+     *
+     * 例如说，请假申请的编号。通过它，可以查询到对应的实例
+     */
+    @NotEmpty(message = "业务的唯一标识")
+    private String businessKey;
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/DictTypeConstants.java

+package cn.iocoder.yudao.module.bpm.enums;
+
+/**
+ * BPM 字典类型的枚举类
+ *
+ * @author 芋道源码
+ */
+public interface DictTypeConstants {
+
+    String TASK_ASSIGN_RULE_TYPE = "bpm_task_assign_rule_type"; // 任务分配规则类型
+    String TASK_ASSIGN_SCRIPT = "bpm_task_assign_script"; // 任务分配自定义脚本
+
+}

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

+package cn.iocoder.yudao.module.bpm.enums;
+
+import cn.iocoder.yudao.framework.common.exception.ErrorCode;
+
+/**
+ * 工作流 错误码枚举类
+ *
+ * 工作流系统，使用 1-009-000-000 段
+ */
+public interface ErrorCodeConstants {
+
+    // ==========  通用流程处理 模块 1-009-000-000 ==========
+    ErrorCode HIGHLIGHT_IMG_ERROR = new ErrorCode(1009000002, "获取高亮流程图异常");
+
+    // ========== OA 流程模块 1-009-001-000 ==========
+    ErrorCode OA_LEAVE_NOT_EXISTS = new ErrorCode(1009001001, "请假申请不存在");
+    ErrorCode OA_PM_POST_NOT_EXISTS = new ErrorCode(1009001002, "项目经理岗位未设置");
+    ErrorCode OA_DEPART_PM_POST_NOT_EXISTS = new ErrorCode(1009001009, "部门的项目经理不存在");
+    ErrorCode OA_BM_POST_NOT_EXISTS = new ErrorCode(1009001004, "部门经理岗位未设置");
+    ErrorCode OA_DEPART_BM_POST_NOT_EXISTS = new ErrorCode(1009001005, "部门的部门经理不存在");
+    ErrorCode OA_HR_POST_NOT_EXISTS = new ErrorCode(1009001006, "HR岗位未设置");
+    ErrorCode OA_DAY_LEAVE_ERROR = new ErrorCode(1009001007, "请假天数必须>=1");
+
+    // ========== 流程模型 1-009-002-000 ==========
+    ErrorCode MODEL_KEY_EXISTS = new ErrorCode(1009002000, "已经存在流程标识为【{}】的流程");
+    ErrorCode MODEL_NOT_EXISTS = new ErrorCode(1009002001, "流程模型不存在");
+    ErrorCode MODEL_KEY_VALID = new ErrorCode(1009002002, "流程标识格式不正确，需要以字母或下划线开头，后接任意字母、数字、中划线、下划线、句点！");
+    ErrorCode MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG = new ErrorCode(1009002003, "部署流程失败，原因：流程表单未配置，请点击【修改流程】按钮进行配置");
+    ErrorCode MODEL_DEPLOY_FAIL_TASK_ASSIGN_RULE_NOT_CONFIG = new ErrorCode(1009002004, "部署流程失败，" +
+            "原因：用户任务({})未配置分配规则，请点击【修改流程】按钮进行配置");
+    ErrorCode MODEL_DEPLOY_FAIL_TASK_INFO_EQUALS = new ErrorCode(1009003005, "流程定义部署失败，原因：信息未发生变化");
+
+    // ========== 流程定义 1-009-003-000 ==========
+    ErrorCode PROCESS_DEFINITION_KEY_NOT_MATCH = new ErrorCode(1009003000, "流程定义的标识期望是({})，当前是({})，请修改 BPMN 流程图");
+    ErrorCode PROCESS_DEFINITION_NAME_NOT_MATCH = new ErrorCode(1009003001, "流程定义的名字期望是({})，当前是({})，请修改 BPMN 流程图");
+    ErrorCode PROCESS_DEFINITION_NOT_EXISTS = new ErrorCode(1009003002, "流程定义不存在");
+    ErrorCode PROCESS_DEFINITION_IS_SUSPENDED = new ErrorCode(1009003003, "流程定义处于挂起状态");
+    ErrorCode PROCESS_DEFINITION_BPMN_MODEL_NOT_EXISTS = new ErrorCode(1009003004, "流程定义的模型不存在");
+
+    // ========== 流程实例 1-009-004-000 ==========
+    ErrorCode PROCESS_INSTANCE_NOT_EXISTS = new ErrorCode(1009004000, "流程实例不存在");
+    ErrorCode PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS = new ErrorCode(1009004001, "流程取消失败，流程不处于运行中");
+    ErrorCode PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF = new ErrorCode(1009004002, "流程取消失败，该流程不是你发起的");
+
+    // ========== 流程任务 1-009-005-000 ==========
+    ErrorCode TASK_COMPLETE_FAIL_NOT_EXISTS = new ErrorCode(1009005000, "审批任务失败，原因：该任务不处于未审批");
+    ErrorCode TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF = new ErrorCode(1009005001, "审批任务失败，原因：该任务的审批人不是你");
+
+    // ========== 流程任务分配规则 1-009-006-000 ==========
+    ErrorCode TASK_ASSIGN_RULE_EXISTS = new ErrorCode(1009006000, "流程({}) 的任务({}) 已经存在分配规则");
+    ErrorCode TASK_ASSIGN_RULE_NOT_EXISTS = new ErrorCode(1009006001, "流程任务分配规则不存在");
+    ErrorCode TASK_UPDATE_FAIL_NOT_MODEL = new ErrorCode(1009006002, "只有流程模型的任务分配规则，才允许被修改");
+    ErrorCode TASK_CREATE_FAIL_NO_CANDIDATE_USER = new ErrorCode(1009006003, "操作失败，原因：找不到任务的审批人！");
+    ErrorCode TASK_ASSIGN_SCRIPT_NOT_EXISTS = new ErrorCode(1009006004, "操作失败，原因：任务分配脚本({}) 不存在");
+
+    // ========== 动态表单模块 1-009-010-000 ==========
+    ErrorCode FORM_NOT_EXISTS = new ErrorCode(1009010000, "动态表单不存在");
+    ErrorCode FORM_FIELD_REPEAT = new ErrorCode(1009010001, "表单项({}) 和 ({}) 使用了相同的字段名({})");
+
+    // ========== 用户组模块 1-009-011-000 ==========
+    ErrorCode USER_GROUP_NOT_EXISTS = new ErrorCode(1009011000, "用户组不存在");
+    ErrorCode USER_GROUP_IS_DISABLE = new ErrorCode(1009011001, "名字为【{}】的用户组已被禁用");
+
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/definition/BpmModelFormTypeEnum.java

+package cn.iocoder.yudao.module.bpm.enums.definition;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * BPM 模型的表单类型的枚举
+ *
+ * @author 芋道源码
+ */
+@Getter
+@AllArgsConstructor
+public enum BpmModelFormTypeEnum {
+
+    NORMAL(10, "流程表单"), // 对应 BpmFormDO
+    CUSTOM(20, "业务表单") // 业务自己定义的表单，自己进行数据的存储
+    ;
+
+    private final Integer type;
+    private final String desc;
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/definition/BpmTaskAssignRuleTypeEnum.java

+package cn.iocoder.yudao.module.bpm.enums.definition;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * BPM 任务分配规则的类型枚举
+ *
+ * @author 芋道源码
+ */
+@Getter
+@AllArgsConstructor
+public enum BpmTaskAssignRuleTypeEnum {
+
+    ROLE(10, "角色"),
+    DEPT_MEMBER(20, "部门的成员"), // 包括负责人
+    DEPT_LEADER(21, "部门的负责人"),
+    POST(22, "岗位"),
+    USER(30, "用户"),
+    USER_GROUP(40, "用户组"),
+    SCRIPT(50, "自定义脚本"), // 例如说，发起人所在部门的领导、发起人所在部门的领导的领导
+    ;
+
+    /**
+     * 类型
+     */
+    private final Integer type;
+    /**
+     * 描述
+     */
+    private final String desc;
+
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/definition/BpmTaskRuleScriptEnum.java

+package cn.iocoder.yudao.module.bpm.enums.definition;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * BPM 任务规则的脚本枚举
+ * 目前暂时通过 TODO 芋艿：硬编码，未来可以考虑 Groovy 动态脚本的方式
+ *
+ * @author 芋道源码
+ */
+@Getter
+@AllArgsConstructor
+public enum BpmTaskRuleScriptEnum {
+
+    START_USER(10L, "流程发起人"),
+
+    LEADER_X1(20L, "流程发起人的一级领导"),
+    LEADER_X2(21L, "流程发起人的二级领导");
+
+    /**
+     * 脚本编号
+     */
+    private final Long id;
+    /**
+     * 脚本描述
+     */
+    private final String desc;
+
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/message/BpmMessageEnum.java

+package cn.iocoder.yudao.module.bpm.enums.message;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * Bpm 消息的枚举
+ *
+ * @author 芋道源码
+ */
+@AllArgsConstructor
+@Getter
+public enum BpmMessageEnum {
+
+    PROCESS_INSTANCE_APPROVE("bpm_process_instance_approve"), // 流程任务被审批通过时，发送给申请人
+    PROCESS_INSTANCE_REJECT("bpm_process_instance_reject"), // 流程任务被审批不通过时，发送给申请人
+    TASK_ASSIGNED("bpm_task_assigned"); // 任务被分配时，发送给审批人
+
+    /**
+     * 短信模板的标识
+     *
+     * 关联 SmsTemplateDO 的 code 属性
+     */
+    private final String smsTemplateCode;
+
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmProcessInstanceDeleteReasonEnum.java

+package cn.iocoder.yudao.module.bpm.enums.task;
+
+import cn.hutool.core.util.StrUtil;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 流程实例的删除原因
+ *
+ * @author 芋道源码
+ */
+@Getter
+@AllArgsConstructor
+public enum BpmProcessInstanceDeleteReasonEnum {
+
+    REJECT_TASK("不通过任务，原因：{}"), // 修改文案时，需要注意 isRejectReason 方法
+    CANCEL_TASK("主动取消任务，原因：{}"),
+
+    // ========== 流程任务的独有原因 ==========
+    MULTI_TASK_END("系统自动取消，原因：多任务审批已经满足条件，无需审批该任务"), // 多实例满足 condition 而结束时，其它任务实例任务会被取消，对应的删除原因是 MI_END
+
+    ;
+
+    private final String reason;
+
+    /**
+     * 格式化理由
+     *
+     * @param args 参数
+     * @return 理由
+     */
+    public String format(Object... args) {
+        return StrUtil.format(reason, args);
+    }
+
+    // ========== 逻辑 ==========
+
+    public static boolean isRejectReason(String reason) {
+        return StrUtil.startWith(reason, "不通过任务，原因：");
+    }
+
+    /**
+     * 将 Flowable 的删除原因，翻译成对应的中文原因
+     *
+     * @param reason 原始原因
+     * @return 原因
+     */
+    public static String translateReason(String reason) {
+        if (StrUtil.isEmpty(reason)) {
+            return reason;
+        }
+        switch (reason) {
+            case "MI_END": return MULTI_TASK_END.getReason();
+            default: return reason;
+        }
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmProcessInstanceResultEnum.java

+package cn.iocoder.yudao.module.bpm.enums.task;
+
+import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 流程实例的结果
+ *
+ * @author jason
+ */
+@Getter
+@AllArgsConstructor
+public enum BpmProcessInstanceResultEnum {
+
+    PROCESS(1, "处理中"),
+    APPROVE(2, "通过"),
+    REJECT(3, "不通过"),
+    CANCEL(4, "已取消"),
+
+    // ========== 流程任务独有的状态 ==========
+
+    BACK(5, "退回/驳回");
+
+    /**
+     * 结果
+     *
+     * 如果新增时，注意 {@link #isEndResult(Integer)} 是否需要变更
+     */
+    private final Integer result;
+    /**
+     * 描述
+     */
+    private final String desc;
+
+    /**
+     * 判断该结果是否已经处于 End 最终结果
+     *
+     * 主要用于一些结果更新的逻辑，如果已经是最终结果，就不再进行更新
+     *
+     * @param result 结果
+     * @return 是否
+     */
+    public static boolean isEndResult(Integer result) {
+        return ObjectUtils.equalsAny(result, APPROVE.getResult(), REJECT.getResult(), CANCEL.getResult(), BACK.getResult());
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/task/BpmProcessInstanceStatusEnum.java

+package cn.iocoder.yudao.module.bpm.enums.task;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 流程实例的状态
+ *
+ * @author 芋道源码
+ */
+@Getter
+@AllArgsConstructor
+public enum BpmProcessInstanceStatusEnum {
+
+    RUNNING(1, "进行中"),
+    FINISH(2, "已完成");
+
+    /**
+     * 状态
+     */
+    private final Integer status;
+    /**
+     * 描述
+     */
+    private final String desc;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>cn.iocoder.cloud</groupId>
+        <artifactId>yudao-module-bpm</artifactId>
+        <version>${revision}</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>yudao-module-bpm-biz</artifactId>
+
+    <name>${project.artifactId}</name>
+    <description>
+        bpm-base 模块，实现公用的工作流的逻辑，提供给 bpm-activiti 和 bpm-flowable 复用
+    </description>
+
+    <dependencies>
+        <!-- Spring Cloud 基础 -->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-bootstrap</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-module-bpm-api</artifactId>
+            <version>${revision}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-module-system-api</artifactId>
+            <version>${revision}</version>
+        </dependency>
+
+        <!-- 业务组件 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-biz-operatelog</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-biz-data-permission</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-biz-tenant</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-biz-error-code</artifactId>
+        </dependency>
+
+        <!-- Web 相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-security</artifactId>
+        </dependency>
+
+        <!-- DB 相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-mybatis</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-redis</artifactId>
+        </dependency>
+
+        <!-- RPC 远程调用相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-rpc</artifactId>
+        </dependency>
+
+        <!-- Registry 注册中心相关 -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
+        </dependency>
+
+        <!-- Config 配置中心相关 -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
+        </dependency>
+
+        <!-- Job 定时任务相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-job</artifactId>
+        </dependency>
+
+        <!-- 消息队列相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-mq</artifactId>
+        </dependency>
+
+        <!-- 服务保障相关 TODO 芋艿：暂时去掉 -->
+        <!--        <dependency>-->
+        <!--            <groupId>cn.iocoder.cloud</groupId>-->
+        <!--            <artifactId>yudao-spring-boot-starter-protection</artifactId>-->
+        <!--        </dependency>-->
+
+        <!-- Test 测试相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-test</artifactId>
+        </dependency>
+
+        <!-- 监控相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-monitor</artifactId>
+        </dependency>
+
+        <!-- 工作流相关 -->
+        <dependency>
+            <groupId>cn.iocoder.cloud</groupId>
+            <artifactId>yudao-spring-boot-starter-flowable</artifactId>
+        </dependency>
+    </dependencies>
+</project>

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/BpmServerApplication.java

+package cn.iocoder.yudao.module.bpm;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * 项目的启动类
+ *
+ * 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+ * 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+ * 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+ *
+ * @author 芋道源码
+ */
+@SpringBootApplication
+public class BpmServerApplication {
+
+    public static void main(String[] args) {
+        // 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+        // 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+        // 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+
+        SpringApplication.run(BpmServerApplication.class, args);
+
+        // 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+        // 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+        // 如果你碰到启动的问题，请认真阅读 https://cloud.iocoder.cn/quick-start/ 文章
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/api/package-info.java

+/**
+ * bpm API 实现类，定义暴露给其它模块的 API
+ */
+package cn.iocoder.yudao.module.bpm.api;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/api/task/BpmProcessInstanceApiImpl.java

+package cn.iocoder.yudao.module.bpm.api.task;
+
+import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
+import cn.iocoder.yudao.module.bpm.service.task.BpmProcessInstanceService;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+
+/**
+ * Flowable 流程实例 Api 实现类
+ *
+ * @author 芋道源码
+ * @author jason
+ */
+@Service
+@Validated
+public class BpmProcessInstanceApiImpl implements BpmProcessInstanceApi {
+
+    @Resource
+    private BpmProcessInstanceService processInstanceService;
+
+    @Override
+    public String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqDTO reqDTO) {
+        return processInstanceService.createProcessInstance(userId, reqDTO);
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/BpmFormController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.*;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmFormConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmFormService;
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Api(tags = "管理后台 - 动态表单")
+@RestController
+@RequestMapping("/bpm/form")
+@Validated
+public class BpmFormController {
+
+    @Resource
+    private BpmFormService formService;
+
+    @PostMapping("/create")
+    @ApiOperation("创建动态表单")
+    @PreAuthorize("@ss.hasPermission('bpm:form:create')")
+    public CommonResult<Long> createForm(@Valid @RequestBody BpmFormCreateReqVO createReqVO) {
+        return success(formService.createForm(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @ApiOperation("更新动态表单")
+    @PreAuthorize("@ss.hasPermission('bpm:form:update')")
+    public CommonResult<Boolean> updateForm(@Valid @RequestBody BpmFormUpdateReqVO updateReqVO) {
+        formService.updateForm(updateReqVO);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @ApiOperation("删除动态表单")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, dataTypeClass = Long.class)
+    @PreAuthorize("@ss.hasPermission('bpm:form:delete')")
+    public CommonResult<Boolean> deleteForm(@RequestParam("id") Long id) {
+        formService.deleteForm(id);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @ApiOperation("获得动态表单")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
+    @PreAuthorize("@ss.hasPermission('bpm:form:query')")
+    public CommonResult<BpmFormRespVO> getForm(@RequestParam("id") Long id) {
+        BpmFormDO form = formService.getForm(id);
+        return success(BpmFormConvert.INSTANCE.convert(form));
+    }
+
+    @GetMapping("/list-all-simple")
+    @ApiOperation(value = "获得动态表单的精简列表", notes = "用于表单下拉框")
+    public CommonResult<List<BpmFormSimpleRespVO>> getSimpleForms() {
+        List<BpmFormDO> list = formService.getFormList();
+        return success(BpmFormConvert.INSTANCE.convertList2(list));
+    }
+
+    @GetMapping("/page")
+    @ApiOperation("获得动态表单分页")
+    @PreAuthorize("@ss.hasPermission('bpm:form:query')")
+    public CommonResult<PageResult<BpmFormRespVO>> getFormPage(@Valid BpmFormPageReqVO pageVO) {
+        PageResult<BpmFormDO> pageResult = formService.getFormPage(pageVO);
+        return success(BpmFormConvert.INSTANCE.convertPage(pageResult));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/BpmModelController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.io.IoUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model.*;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmModelConvert;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmModelService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+
+import java.io.IOException;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Api(tags = "管理后台 - 流程模型")
+@RestController
+@RequestMapping("/bpm/model")
+@Validated
+public class BpmModelController {
+
+    @Resource
+    private BpmModelService modelService;
+
+    @GetMapping("/page")
+    @ApiOperation(value = "获得模型分页")
+    public CommonResult<PageResult<BpmModelPageItemRespVO>> getModelPage(BpmModelPageReqVO pageVO) {
+        return success(modelService.getModelPage(pageVO));
+    }
+
+    @GetMapping("/get")
+    @ApiOperation("获得模型")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = String.class)
+    @PreAuthorize("@ss.hasPermission('bpm:model:query')")
+    public CommonResult<BpmModelRespVO> getModel(@RequestParam("id") String id) {
+        BpmModelRespVO model = modelService.getModel(id);
+        return success(model);
+    }
+
+    @PostMapping("/create")
+    @ApiOperation(value = "新建模型")
+    @PreAuthorize("@ss.hasPermission('bpm:model:create')")
+    public CommonResult<String> createModel(@Valid @RequestBody BpmModelCreateReqVO createRetVO) {
+        return success(modelService.createModel(createRetVO, null));
+    }
+
+    @PutMapping("/update")
+    @ApiOperation(value = "修改模型")
+    @PreAuthorize("@ss.hasPermission('bpm:model:update')")
+    public CommonResult<Boolean> updateModel(@Valid @RequestBody BpmModelUpdateReqVO modelVO) {
+        modelService.updateModel(modelVO);
+        return success(true);
+    }
+
+    @PostMapping("/import")
+    @ApiOperation(value = "导入模型")
+    @PreAuthorize("@ss.hasPermission('bpm:model:import')")
+    public CommonResult<String> importModel(@Valid BpmModeImportReqVO importReqVO) throws IOException {
+        BpmModelCreateReqVO createReqVO = BpmModelConvert.INSTANCE.convert(importReqVO);
+        // 读取文件
+        String bpmnXml = IoUtils.readUtf8(importReqVO.getBpmnFile().getInputStream(), false);
+        return success(modelService.createModel(createReqVO, bpmnXml));
+    }
+
+    @PostMapping("/deploy")
+    @ApiOperation(value = "部署模型")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = String.class)
+    @PreAuthorize("@ss.hasPermission('bpm:model:deploy')")
+    public CommonResult<Boolean> deployModel(@RequestParam("id") String id) {
+        modelService.deployModel(id);
+        return success(true);
+    }
+
+    @PutMapping("/update-state")
+    @ApiOperation(value = "修改模型的状态", notes = "实际更新的部署的流程定义的状态")
+    @PreAuthorize("@ss.hasPermission('bpm:model:update')")
+    public CommonResult<Boolean> updateModelState(@Valid @RequestBody BpmModelUpdateStateReqVO reqVO) {
+        modelService.updateModelState(reqVO.getId(), reqVO.getState());
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @ApiOperation("删除模型")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = String.class)
+    @PreAuthorize("@ss.hasPermission('bpm:model:delete')")
+    public CommonResult<Boolean> deleteModel(@RequestParam("id") String id) {
+        modelService.deleteModel(id);
+        return success(true);
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/BpmProcessDefinitionController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionListReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionPageItemRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionRespVO;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmProcessDefinitionService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Api(tags = "管理后台 - 流程定义")
+@RestController
+@RequestMapping("/bpm/process-definition")
+@Validated
+public class BpmProcessDefinitionController {
+
+    @Resource
+    private BpmProcessDefinitionService bpmDefinitionService;
+
+    @GetMapping("/page")
+    @ApiOperation(value = "获得流程定义分页")
+    @PreAuthorize("@ss.hasPermission('bpm:process-definition:query')")
+    public CommonResult<PageResult<BpmProcessDefinitionPageItemRespVO>> getProcessDefinitionPage(
+            BpmProcessDefinitionPageReqVO pageReqVO) {
+        return success(bpmDefinitionService.getProcessDefinitionPage(pageReqVO));
+    }
+
+    @GetMapping ("/list")
+    @ApiOperation(value = "获得流程定义列表")
+    @PreAuthorize("@ss.hasPermission('bpm:process-definition:query')")
+    public CommonResult<List<BpmProcessDefinitionRespVO>> getProcessDefinitionList(
+            BpmProcessDefinitionListReqVO listReqVO) {
+        return success(bpmDefinitionService.getProcessDefinitionList(listReqVO));
+    }
+
+    @GetMapping ("/get-bpmn-xml")
+    @ApiOperation(value = "获得流程定义的 BPMN XML")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = String.class)
+    @PreAuthorize("@ss.hasPermission('bpm:process-definition:query')")
+    public CommonResult<String> getProcessDefinitionBpmnXML(@RequestParam("id") String id) {
+        String bpmnXML = bpmDefinitionService.getProcessDefinitionBpmnXML(id);
+        return success(bpmnXML);
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/BpmTaskAssignRuleController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmTaskAssignRuleService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiImplicitParams;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Api(tags = "管理后台 - 任务分配规则")
+@RestController
+@RequestMapping("/bpm/task-assign-rule")
+@Validated
+public class BpmTaskAssignRuleController {
+
+    @Resource
+    private BpmTaskAssignRuleService taskAssignRuleService;
+
+    @GetMapping("/list")
+    @ApiOperation(value = "获得任务分配规则列表")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "modelId", value = "模型编号", example = "1024", dataTypeClass = String.class),
+            @ApiImplicitParam(name = "processDefinitionId", value = "流程定义的编号", example = "2048", dataTypeClass = String.class)
+    })
+    @PreAuthorize("@ss.hasPermission('bpm:task-assign-rule:query')")
+    public CommonResult<List<BpmTaskAssignRuleRespVO>> getTaskAssignRuleList(
+            @RequestParam(value = "modelId", required = false) String modelId,
+            @RequestParam(value = "processDefinitionId", required = false) String processDefinitionId) {
+        return success(taskAssignRuleService.getTaskAssignRuleList(modelId, processDefinitionId));
+    }
+
+    @PostMapping("/create")
+    @ApiOperation(value = "创建任务分配规则")
+    @PreAuthorize("@ss.hasPermission('bpm:task-assign-rule:create')")
+    public CommonResult<Long> createTaskAssignRule(@Valid @RequestBody BpmTaskAssignRuleCreateReqVO reqVO) {
+        return success(taskAssignRuleService.createTaskAssignRule(reqVO));
+    }
+
+    @PutMapping("/update")
+    @ApiOperation(value = "更新任务分配规则")
+    @PreAuthorize("@ss.hasPermission('bpm:task-assign-rule:update')")
+    public CommonResult<Boolean> updateTaskAssignRule(@Valid @RequestBody BpmTaskAssignRuleUpdateReqVO reqVO) {
+        taskAssignRuleService.updateTaskAssignRule(reqVO);
+        return success(true);
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/BpmUserGroupController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmUserGroupConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmUserGroupService;
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Api(tags = "管理后台 - 用户组")
+@RestController
+@RequestMapping("/bpm/user-group")
+@Validated
+public class BpmUserGroupController {
+
+    @Resource
+    private BpmUserGroupService userGroupService;
+
+    @PostMapping("/create")
+    @ApiOperation("创建用户组")
+    @PreAuthorize("@ss.hasPermission('bpm:user-group:create')")
+    public CommonResult<Long> createUserGroup(@Valid @RequestBody BpmUserGroupCreateReqVO createReqVO) {
+        return success(userGroupService.createUserGroup(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @ApiOperation("更新用户组")
+    @PreAuthorize("@ss.hasPermission('bpm:user-group:update')")
+    public CommonResult<Boolean> updateUserGroup(@Valid @RequestBody BpmUserGroupUpdateReqVO updateReqVO) {
+        userGroupService.updateUserGroup(updateReqVO);
+        return success(true);
+    }
+
+    @DeleteMapping("/delete")
+    @ApiOperation("删除用户组")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, dataTypeClass = Long.class)
+    @PreAuthorize("@ss.hasPermission('bpm:user-group:delete')")
+    public CommonResult<Boolean> deleteUserGroup(@RequestParam("id") Long id) {
+        userGroupService.deleteUserGroup(id);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @ApiOperation("获得用户组")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
+    @PreAuthorize("@ss.hasPermission('bpm:user-group:query')")
+    public CommonResult<BpmUserGroupRespVO> getUserGroup(@RequestParam("id") Long id) {
+        BpmUserGroupDO userGroup = userGroupService.getUserGroup(id);
+        return success(BpmUserGroupConvert.INSTANCE.convert(userGroup));
+    }
+
+    @GetMapping("/page")
+    @ApiOperation("获得用户组分页")
+    @PreAuthorize("@ss.hasPermission('bpm:user-group:query')")
+    public CommonResult<PageResult<BpmUserGroupRespVO>> getUserGroupPage(@Valid BpmUserGroupPageReqVO pageVO) {
+        PageResult<BpmUserGroupDO> pageResult = userGroupService.getUserGroupPage(pageVO);
+        return success(BpmUserGroupConvert.INSTANCE.convertPage(pageResult));
+    }
+
+    @GetMapping("/list-all-simple")
+    @ApiOperation(value = "获取用户组精简信息列表", notes = "只包含被开启的用户组，主要用于前端的下拉选项")
+    public CommonResult<List<BpmUserGroupRespVO>> getSimpleUserGroups() {
+        // 获用户门列表，只要开启状态的
+        List<BpmUserGroupDO> list = userGroupService.getUserGroupListByStatus(CommonStatusEnum.ENABLE.getStatus());
+        // 排序后，返回给前端
+        return success(BpmUserGroupConvert.INSTANCE.convertList2(list));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/form/BpmFormBaseVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form;
+
+import lombok.*;
+import io.swagger.annotations.*;
+import javax.validation.constraints.*;
+
+/**
+* 动态表单 Base VO，提供给添加、修改、详细的子 VO 使用
+* 如果子 VO 存在差异的字段，请不要添加到这里，影响 Swagger 文档生成
+*/
+@Data
+public class BpmFormBaseVO {
+
+    @ApiModelProperty(value = "表单名称", required = true, example = "芋道")
+    @NotNull(message = "表单名称不能为空")
+    private String name;
+
+    @ApiModelProperty(value = "表单状态", required = true, notes = "参见 CommonStatusEnum 枚举", example = "1")
+    @NotNull(message = "表单状态不能为空")
+    private Integer status;
+
+    @ApiModelProperty(value = "备注", example = "我是备注")
+    private String remark;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/form/BpmFormCreateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form;
+
+import lombok.*;
+import io.swagger.annotations.*;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+@ApiModel("管理后台 - 动态表单创建 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmFormCreateReqVO extends BpmFormBaseVO {
+
+    @ApiModelProperty(value = "表单的配置", required = true, notes = "JSON 字符串")
+    @NotNull(message = "表单的配置不能为空")
+    private String conf;
+
+    @ApiModelProperty(value = "表单项的数组", required = true, notes = "JSON 字符串的数组")
+    @NotNull(message = "表单项的数组不能为空")
+    private List<String> fields;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/form/BpmFormPageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@ApiModel("管理后台 - 动态表单分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmFormPageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "表单名称", example = "芋道")
+    private String name;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/form/BpmFormRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import javax.validation.constraints.NotNull;
+import java.util.Date;
+import java.util.List;
+
+@ApiModel("管理后台 - 动态表单 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmFormRespVO extends BpmFormBaseVO {
+
+    @ApiModelProperty(value = "表单编号", required = true, example = "1024")
+    private Long id;
+
+    @ApiModelProperty(value = "表单的配置", required = true, notes = "JSON 字符串")
+    @NotNull(message = "表单的配置不能为空")
+    private String conf;
+
+    @ApiModelProperty(value = "表单项的数组", required = true, notes = "JSON 字符串的数组")
+    @NotNull(message = "表单项的数组不能为空")
+    private List<String> fields;
+
+    @ApiModelProperty(value = "创建时间", required = true)
+    private Date createTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/form/BpmFormSimpleRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@ApiModel("管理后台 - 流程表单精简 Response VO")
+@Data
+public class BpmFormSimpleRespVO {
+
+    @ApiModelProperty(value = "表单编号", required = true, example = "1024")
+    private Long id;
+
+    @ApiModelProperty(value = "表单名称", required = true, example = "芋道")
+    private String name;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/form/BpmFormUpdateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form;
+
+import lombok.*;
+import io.swagger.annotations.*;
+import javax.validation.constraints.*;
+import java.util.List;
+
+@ApiModel("管理后台 - 动态表单更新 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmFormUpdateReqVO extends BpmFormBaseVO {
+
+    @ApiModelProperty(value = "表单编号", required = true, example = "1024")
+    @NotNull(message = "表单编号不能为空")
+    private Long id;
+
+    @ApiModelProperty(value = "表单的配置", required = true, notes = "JSON 字符串")
+    @NotNull(message = "表单的配置不能为空")
+    private String conf;
+
+    @ApiModelProperty(value = "表单项的数组", required = true, notes = "JSON 字符串的数组")
+    @NotNull(message = "表单项的数组不能为空")
+    private List<String> fields;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/group/BpmUserGroupBaseVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group;
+
+import lombok.*;
+import java.util.*;
+import io.swagger.annotations.*;
+import javax.validation.constraints.*;
+
+/**
+* 用户组 Base VO，提供给添加、修改、详细的子 VO 使用
+* 如果子 VO 存在差异的字段，请不要添加到这里，影响 Swagger 文档生成
+*/
+@Data
+public class BpmUserGroupBaseVO {
+
+    @ApiModelProperty(value = "组名", required = true, example = "芋道")
+    @NotNull(message = "组名不能为空")
+    private String name;
+
+    @ApiModelProperty(value = "描述", required = true, example = "芋道源码")
+    @NotNull(message = "描述不能为空")
+    private String description;
+
+    @ApiModelProperty(value = "成员编号数组", required = true, example = "1,2,3")
+    @NotNull(message = "成员编号数组不能为空")
+    private Set<Long> memberUserIds;
+
+    @ApiModelProperty(value = "状态", required = true, example = "1")
+    @NotNull(message = "状态不能为空")
+    private Integer status;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/group/BpmUserGroupCreateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group;
+
+import lombok.*;
+import io.swagger.annotations.*;
+
+@ApiModel("管理后台 - 用户组创建 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmUserGroupCreateReqVO extends BpmUserGroupBaseVO {
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/group/BpmUserGroupPageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import cn.iocoder.yudao.framework.common.util.date.DateUtils;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.util.Date;
+
+@ApiModel("管理后台 - 用户组分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmUserGroupPageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "组名", example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "状态", example = "1")
+    private Integer status;
+
+    @DateTimeFormat(pattern = DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    @ApiModelProperty(value = "创建时间")
+    private Date[] createTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/group/BpmUserGroupRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group;
+
+import lombok.*;
+import java.util.*;
+import io.swagger.annotations.*;
+
+@ApiModel("管理后台 - 用户组 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmUserGroupRespVO extends BpmUserGroupBaseVO {
+
+    @ApiModelProperty(value = "编号", required = true, example = "1024")
+    private Long id;
+
+    @ApiModelProperty(value = "创建时间", required = true)
+    private Date createTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/group/BpmUserGroupSimpleRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@ApiModel("管理后台 - 用户组精简信息 Response VO")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class BpmUserGroupSimpleRespVO {
+
+    @ApiModelProperty(value = "用户组编号", required = true, example = "1024")
+    private Long id;
+
+    @ApiModelProperty(value = "用户组名字", required = true, example = "芋道")
+    private String name;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/group/BpmUserGroupUpdateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group;
+
+import lombok.*;
+import io.swagger.annotations.*;
+import javax.validation.constraints.*;
+
+@ApiModel("管理后台 - 用户组更新 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmUserGroupUpdateReqVO extends BpmUserGroupBaseVO {
+
+    @ApiModelProperty(value = "编号", required = true, example = "1024")
+    @NotNull(message = "编号不能为空")
+    private Long id;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModeImportReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.validation.constraints.NotNull;
+
+@ApiModel(value = "管理后台 - 流程模型的导入 Request VO", description = "相比流程模型的新建来说，只是多了一个 bpmnFile 文件")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmModeImportReqVO extends BpmModelCreateReqVO {
+
+    @ApiModelProperty(value = "BPMN 文件", required = true)
+    @NotNull(message = "BPMN 文件不能为空")
+    private MultipartFile bpmnFile;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModelBaseVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+
+/**
+* 流程模型 Base VO，提供给添加、修改、详细的子 VO 使用
+* 如果子 VO 存在差异的字段，请不要添加到这里，影响 Swagger 文档生成
+*/
+@Data
+public class BpmModelBaseVO {
+
+    @ApiModelProperty(value = "流程标识", required = true, example = "process_yudao")
+    @NotEmpty(message = "流程标识不能为空")
+    private String key;
+
+    @ApiModelProperty(value = "流程名称", required = true, example = "芋道")
+    @NotEmpty(message = "流程名称不能为空")
+    private String name;
+
+    @ApiModelProperty(value = "流程描述", example = "我是描述")
+    private String description;
+
+    @ApiModelProperty(value = "流程分类", notes = "参见 bpm_model_category 数据字典", example = "1")
+    @NotEmpty(message = "流程分类不能为空")
+    private String category;
+
+    @ApiModelProperty(value = "表单类型", notes = "参见 bpm_model_form_type 数据字典", example = "1")
+    private Integer formType;
+    @ApiModelProperty(value = "表单编号", example = "1024", notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private Long formId;
+    @ApiModelProperty(value = "自定义表单的提交路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/create",
+            notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private String formCustomCreatePath;
+    @ApiModelProperty(value = "自定义表单的查看路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/view",
+            notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private String formCustomViewPath;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModelCreateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import javax.validation.constraints.NotEmpty;
+
+@ApiModel("管理后台 - 流程模型的创建 Request VO")
+@Data
+public class BpmModelCreateReqVO {
+
+    @ApiModelProperty(value = "流程标识", required = true, example = "process_yudao")
+    @NotEmpty(message = "流程标识不能为空")
+    private String key;
+
+    @ApiModelProperty(value = "流程名称", required = true, example = "芋道")
+    @NotEmpty(message = "流程名称不能为空")
+    private String name;
+
+    @ApiModelProperty(value = "流程描述", example = "我是描述")
+    private String description;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModelPageItemRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import java.util.Date;
+
+@ApiModel("管理后台 - 流程模型的分页的每一项 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmModelPageItemRespVO extends BpmModelBaseVO {
+
+    @ApiModelProperty(value = "编号", required = true, example = "1024")
+    private String id;
+
+    @ApiModelProperty(value = "表单名字", example = "请假表单")
+    private String formName;
+
+    @ApiModelProperty(value = "创建时间", required = true)
+    private Date createTime;
+
+    /**
+     * 最新部署的流程定义
+     */
+    private ProcessDefinition processDefinition;
+
+    @ApiModel("流程定义")
+    @Data
+    public static class ProcessDefinition {
+
+        @ApiModelProperty(value = "编号", required = true, example = "1024")
+        private String id;
+
+        @ApiModelProperty(value = "版本", required = true, example = "1")
+        private Integer version;
+
+        @ApiModelProperty(value = "部署时间", required = true)
+        private Date deploymentTime;
+
+        @ApiModelProperty(value = "中断状态", required = true, example = "1", notes = "参见 SuspensionState 枚举")
+        private Integer suspensionState;
+
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModelPageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+
+@ApiModel("管理后台 - 流程模型分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmModelPageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "标识", example = "process1641042089407", notes = "精准匹配")
+    private String key;
+
+    @ApiModelProperty(value = "名字", example = "芋道", notes = "模糊匹配")
+    private String name;
+
+    @ApiModelProperty(value = "流程分类", notes = "参见 bpm_model_category 数据字典", example = "1")
+    private String category;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModelRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import java.util.Date;
+
+@ApiModel("管理后台 - 流程模型的创建 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmModelRespVO extends BpmModelBaseVO {
+
+    @ApiModelProperty(value = "编号", required = true, example = "1024")
+    private String id;
+
+    @ApiModelProperty(value = "BPMN XML", required = true)
+    private String bpmnXml;
+
+    @ApiModelProperty(value = "创建时间", required = true)
+    private Date createTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModelUpdateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+
+@ApiModel("管理后台 - 流程模型的更新 Request VO")
+@Data
+public class BpmModelUpdateReqVO {
+
+    @ApiModelProperty(value = "编号", required = true, example = "1024")
+    @NotEmpty(message = "编号不能为空")
+    private String id;
+
+    @ApiModelProperty(value = "流程名称", example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "流程描述", example = "我是描述")
+    private String description;
+
+    @ApiModelProperty(value = "流程分类", notes = "参见 bpm_model_category 数据字典", example = "1")
+    private String category;
+
+    @ApiModelProperty(value = "BPMN XML", required = true)
+    private String bpmnXml;
+
+    @ApiModelProperty(value = "表单类型", notes = "参见 bpm_model_form_type 数据字典", example = "1")
+    private Integer formType;
+    @ApiModelProperty(value = "表单编号", example = "1024", notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private Long formId;
+    @ApiModelProperty(value = "自定义表单的提交路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/create",
+            notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private String formCustomCreatePath;
+    @ApiModelProperty(value = "自定义表单的查看路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/view",
+            notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private String formCustomViewPath;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/model/BpmModelUpdateStateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+
+@ApiModel("管理后台 - 流程模型更新状态 Request VO")
+@Data
+public class BpmModelUpdateStateReqVO {
+
+    @ApiModelProperty(value = "编号", required = true, example = "1024")
+    @NotNull(message = "编号不能为空")
+    private String id;
+
+    @ApiModelProperty(value = "状态", required = true, example = "1", notes = "见 SuspensionState 枚举")
+    @NotNull(message = "状态不能为空")
+    private Integer state;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/process/BpmProcessDefinitionListReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@ApiModel("管理后台 - 流程定义列表 Request VO")
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class BpmProcessDefinitionListReqVO extends PageParam {
+
+    @ApiModelProperty(value = "中断状态", example = "1", notes = "参见 SuspensionState 枚举")
+    private Integer suspensionState;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/process/BpmProcessDefinitionPageItemRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import java.util.Date;
+
+@ApiModel("管理后台 - 流程定义的分页的每一项 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmProcessDefinitionPageItemRespVO extends BpmProcessDefinitionRespVO {
+
+    @ApiModelProperty(value = "表单名字", example = "请假表单")
+    private String formName;
+
+    @ApiModelProperty(value = "部署时间", required = true)
+    private Date deploymentTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/process/BpmProcessDefinitionPageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@ApiModel("管理后台 - 流程定义分页 Request VO")
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class BpmProcessDefinitionPageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "标识", example = "process1641042089407", notes = "精准匹配")
+    private String key;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/process/BpmProcessDefinitionRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+@ApiModel("管理后台 - 流程定义 Response VO")
+@Data
+public class BpmProcessDefinitionRespVO {
+
+    @ApiModelProperty(value = "编号", required = true, example = "1024")
+    private String id;
+
+    @ApiModelProperty(value = "版本", required = true, example = "1")
+    private Integer version;
+
+    @ApiModelProperty(value = "流程名称", required = true, example = "芋道")
+    @NotEmpty(message = "流程名称不能为空")
+    private String name;
+
+    @ApiModelProperty(value = "流程描述", example = "我是描述")
+    private String description;
+
+    @ApiModelProperty(value = "流程分类", notes = "参见 bpm_model_category 数据字典", example = "1")
+    @NotEmpty(message = "流程分类不能为空")
+    private String category;
+
+    @ApiModelProperty(value = "表单类型", notes = "参见 bpm_model_form_type 数据字典", example = "1")
+    private Integer formType;
+    @ApiModelProperty(value = "表单编号", example = "1024", notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private Long formId;
+    @ApiModelProperty(value = "表单的配置", required = true,
+            notes = "JSON 字符串。在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private String formConf;
+    @ApiModelProperty(value = "表单项的数组", required = true,
+            notes = "JSON 字符串的数组。在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private List<String> formFields;
+    @ApiModelProperty(value = "自定义表单的提交路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/create",
+            notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private String formCustomCreatePath;
+    @ApiModelProperty(value = "自定义表单的查看路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/view",
+            notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+    private String formCustomViewPath;
+
+    @ApiModelProperty(value = "中断状态", required = true, example = "1", notes = "参见 SuspensionState 枚举")
+    private Integer suspensionState;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/rule/BpmTaskAssignRuleBaseVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.Set;
+
+/**
+ * 流程任务分配规则 Base VO，提供给添加、修改、详细的子 VO 使用
+ * 如果子 VO 存在差异的字段，请不要添加到这里，影响 Swagger 文档生成
+ */
+@Data
+public class BpmTaskAssignRuleBaseVO {
+
+    @ApiModelProperty(value = "规则类型", required = true, example = "bpm_task_assign_rule_type")
+    @NotNull(message = "规则类型不能为空")
+    private Integer type;
+
+    @ApiModelProperty(value = "规则值数组", required = true, example = "1,2,3")
+    @NotNull(message = "规则值数组不能为空")
+    private Set<Long> options;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/rule/BpmTaskAssignRuleCreateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import javax.validation.constraints.NotEmpty;
+
+@ApiModel("管理后台 - 流程任务分配规则的创建 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskAssignRuleCreateReqVO extends BpmTaskAssignRuleBaseVO {
+
+    @ApiModelProperty(value = "流程模型的编号", required = true, example = "1024")
+    @NotEmpty(message = "流程模型的编号不能为空")
+    private String modelId;
+
+    @ApiModelProperty(value = "流程任务定义的编号", required = true, example = "2048")
+    @NotEmpty(message = "流程任务定义的编号不能为空")
+    private String taskDefinitionKey;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/rule/BpmTaskAssignRuleRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@ApiModel("管理后台 - 流程任务分配规则的 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskAssignRuleRespVO extends BpmTaskAssignRuleBaseVO {
+
+    @ApiModelProperty(value = "任务分配规则的编号", required = true, example = "1024")
+    private Long id;
+
+    @ApiModelProperty(value = "流程模型的编号", required = true, example = "2048")
+    private String modelId;
+
+    @ApiModelProperty(value = "流程定义的编号", required = true, example = "4096")
+    private String processDefinitionId;
+
+    @ApiModelProperty(value = "流程任务定义的编号", required = true, example = "2048")
+    private String taskDefinitionKey;
+    @ApiModelProperty(value = "流程任务定义的名字", required = true, example = "关注芋道")
+    private String taskDefinitionName;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/definition/vo/rule/BpmTaskAssignRuleUpdateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import javax.validation.constraints.NotNull;
+
+@ApiModel("管理后台 - 流程任务分配规则的更新 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskAssignRuleUpdateReqVO extends BpmTaskAssignRuleBaseVO {
+
+    @ApiModelProperty(value = "任务分配规则的编号", required = true, example = "1024")
+    @NotNull(message = "任务分配规则的编号不能为空")
+    private Long id;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/oa/BpmOALeaveController.http

+### 请求 /bpm/oa/leave/create 接口 => 成功
+POST {{baseUrl}}/bpm/oa/leave/create
+Content-Type: application/json
+tenant-id: 1
+Authorization: Bearer {{token}}
+
+{
+  "startTime": "2022-03-01",
+  "endTime": "2022-03-05",
+  "type": 1,
+  "reason": "我要请假啦啦啦！"
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/oa/BpmOALeaveController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.oa;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeaveCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeavePageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeaveRespVO;
+import cn.iocoder.yudao.module.bpm.convert.oa.BpmOALeaveConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.oa.BpmOALeaveDO;
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.bpm.service.oa.BpmOALeaveService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
+
+/**
+ * OA 请假申请 Controller，用于演示自己存储数据，接入工作流的例子
+ *
+ * @author jason
+ * @author 芋道源码
+ */
+@Api(tags = "管理后台 - OA 请假申请")
+@RestController
+@RequestMapping("/bpm/oa/leave")
+@Validated
+public class BpmOALeaveController {
+
+    @Resource
+    private BpmOALeaveService leaveService;
+
+    @PostMapping("/create")
+    @PreAuthorize("@ss.hasPermission('bpm:oa-leave:create')")
+    @ApiOperation("创建请求申请")
+    public CommonResult<Long> createLeave(@Valid @RequestBody BpmOALeaveCreateReqVO createReqVO) {
+        return success(leaveService.createLeave(getLoginUserId(), createReqVO));
+    }
+
+    @GetMapping("/get")
+    @PreAuthorize("@ss.hasPermission('bpm:oa-leave:query')")
+    @ApiOperation("获得请假申请")
+    @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
+    public CommonResult<BpmOALeaveRespVO> getLeave(@RequestParam("id") Long id) {
+        BpmOALeaveDO leave = leaveService.getLeave(id);
+        return success(BpmOALeaveConvert.INSTANCE.convert(leave));
+    }
+
+    @GetMapping("/page")
+    @PreAuthorize("@ss.hasPermission('bpm:oa-leave:query')")
+    @ApiOperation("获得请假申请分页")
+    public CommonResult<PageResult<BpmOALeaveRespVO>> getLeavePage(@Valid BpmOALeavePageReqVO pageVO) {
+        PageResult<BpmOALeaveDO> pageResult = leaveService.getLeavePage(getLoginUserId(), pageVO);
+        return success(BpmOALeaveConvert.INSTANCE.convertPage(pageResult));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/oa/package-info.java

+/**
+ * OA 示例，用于演示外部业务接入 BPM 工作流的示例
+ * 一般的接入方式，只需要调用 接口，后续 Admin 用户在管理后台的【待办事务】进行审批
+ */
+package cn.iocoder.yudao.module.bpm.controller.admin.oa;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/oa/vo/BpmOALeaveBaseVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.oa.vo;
+
+import lombok.*;
+import java.util.*;
+import io.swagger.annotations.*;
+import javax.validation.constraints.*;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+/**
+* 请假申请 Base VO，提供给添加、修改、详细的子 VO 使用
+* 如果子 VO 存在差异的字段，请不要添加到这里，影响 Swagger 文档生成
+*/
+@Data
+public class BpmOALeaveBaseVO {
+
+    @ApiModelProperty(value = "请假的开始时间", required = true)
+    @NotNull(message = "开始时间不能为空")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date startTime;
+    @ApiModelProperty(value = "请假的结束时间", required = true)
+    @NotNull(message = "结束时间不能为空")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date endTime;
+
+    @ApiModelProperty(value = "请假类型", required = true, example = "1", notes = "参见 bpm_oa_type 枚举")
+    private Integer type;
+
+    @ApiModelProperty(value = "原因", required = true, example = "阅读芋道源码")
+    private String reason;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/oa/vo/BpmOALeaveCreateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.oa.vo;
+
+import io.swagger.annotations.ApiModel;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import javax.validation.constraints.AssertTrue;
+
+@ApiModel("管理后台 - 请假申请创建 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmOALeaveCreateReqVO extends BpmOALeaveBaseVO {
+
+    @AssertTrue(message = "结束时间，需要在开始时间之后")
+    public boolean isEndTimeValid() {
+        return !getEndTime().before(getStartTime());
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/oa/vo/BpmOALeavePageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.oa.vo;
+
+import lombok.*;
+import java.util.*;
+import io.swagger.annotations.*;
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@ApiModel("管理后台 - 请假申请分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmOALeavePageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "状态", example = "1", notes = "参见 bpm_process_instance_result 枚举")
+    private Integer result;
+
+    @ApiModelProperty(value = "请假类型", example = "1", notes = "参见 bpm_oa_type")
+    private Integer type;
+
+    @ApiModelProperty(value = "原因", example = "阅读芋道源码", notes = "模糊匹配")
+    private String reason;
+
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    @ApiModelProperty(value = "申请时间")
+    private Date[] createTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/oa/vo/BpmOALeaveRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.oa.vo;
+
+import lombok.*;
+import io.swagger.annotations.*;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import javax.validation.constraints.NotNull;
+import java.util.Date;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@ApiModel("管理后台 - 请假申请 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmOALeaveRespVO extends BpmOALeaveBaseVO {
+
+    @ApiModelProperty(value = "请假表单主键", required = true, example = "1024")
+    private Long id;
+
+    @ApiModelProperty(value = "状态", required = true, example = "1", notes = "参见 bpm_process_instance_result 枚举")
+    private Integer result;
+
+    @ApiModelProperty(value = "申请时间", required = true)
+    @NotNull(message = "申请时间不能为空")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date createTime;
+
+    @ApiModelProperty(value = "流程id")
+    private String processInstanceId;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/BpmActivityController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.activity.BpmActivityRespVO;
+import cn.iocoder.yudao.module.bpm.service.task.BpmActivityService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+
+@Api(tags = "管理后台 - 流程活动实例")
+@RestController
+@RequestMapping("/bpm/activity")
+@Validated
+public class BpmActivityController {
+
+    @Resource
+    private BpmActivityService activityService;
+
+    @GetMapping("/list")
+    @ApiOperation(value = "生成指定流程实例的高亮流程图",
+            notes = "只高亮进行中的任务。不过要注意，该接口暂时没用，通过前端的 ProcessViewer.vue 界面的 highlightDiagram 方法生成")
+    @ApiImplicitParam(name = "processInstanceId", value = "流程实例的编号", required = true, dataTypeClass = String.class)
+    @PreAuthorize("@ss.hasPermission('bpm:task:query')")
+    public CommonResult<List<BpmActivityRespVO>> getActivityList(
+            @RequestParam("processInstanceId") String processInstanceId) {
+        return success(activityService.getActivityListByProcessInstanceId(processInstanceId));
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/BpmProcessInstanceController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance.*;
+import cn.iocoder.yudao.module.bpm.service.task.BpmProcessInstanceService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
+
+@Api(tags = "管理后台 - 流程实例") // 流程实例，通过流程定义创建的一次“申请”
+@RestController
+@RequestMapping("/bpm/process-instance")
+@Validated
+public class BpmProcessInstanceController {
+
+    @Resource
+    private BpmProcessInstanceService processInstanceService;
+
+    @GetMapping("/my-page")
+    @ApiOperation(value = "获得我的实例分页列表", notes = "在【我的流程】菜单中，进行调用")
+    @PreAuthorize("@ss.hasPermission('bpm:process-instance:query')")
+    public CommonResult<PageResult<BpmProcessInstancePageItemRespVO>> getMyProcessInstancePage(
+            @Valid BpmProcessInstanceMyPageReqVO pageReqVO) {
+        return success(processInstanceService.getMyProcessInstancePage(getLoginUserId(), pageReqVO));
+    }
+
+    @PostMapping("/create")
+    @ApiOperation("新建流程实例")
+    @PreAuthorize("@ss.hasPermission('bpm:process-instance:query')")
+    public CommonResult<String> createProcessInstance(@Valid @RequestBody BpmProcessInstanceCreateReqVO createReqVO) {
+        return success(processInstanceService.createProcessInstance(getLoginUserId(), createReqVO));
+    }
+
+    @GetMapping("/get")
+    @ApiOperation(value = "获得指定流程实例", notes = "在【流程详细】界面中，进行调用")
+    @ApiImplicitParam(name = "id", value = "流程实例的编号", required = true, dataTypeClass = String.class)
+    @PreAuthorize("@ss.hasPermission('bpm:process-instance:query')")
+    public CommonResult<BpmProcessInstanceRespVO> getProcessInstance(@RequestParam("id") String id) {
+        return success(processInstanceService.getProcessInstanceVO(id));
+    }
+
+    @DeleteMapping("/cancel")
+    @ApiOperation(value = "取消流程实例", notes = "撤回发起的流程")
+    @PreAuthorize("@ss.hasPermission('bpm:process-instance:cancel')")
+    public CommonResult<Boolean> cancelProcessInstance(@Valid @RequestBody BpmProcessInstanceCancelReqVO cancelReqVO) {
+        processInstanceService.cancelProcessInstance(getLoginUserId(), cancelReqVO);
+        return success(true);
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/BpmTaskController.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
+import cn.iocoder.yudao.module.bpm.service.task.BpmTaskService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+
+import java.util.List;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+import static cn.iocoder.yudao.framework.web.core.util.WebFrameworkUtils.getLoginUserId;
+
+@Api(tags = "管理后台 - 流程任务实例")
+@RestController
+@RequestMapping("/bpm/task")
+@Validated
+public class BpmTaskController {
+
+    @Resource
+    private BpmTaskService taskService;
+
+    @GetMapping("todo-page")
+    @ApiOperation("获取 Todo 待办任务分页")
+    @PreAuthorize("@ss.hasPermission('bpm:task:query')")
+    public CommonResult<PageResult<BpmTaskTodoPageItemRespVO>> getTodoTaskPage(@Valid BpmTaskTodoPageReqVO pageVO) {
+        return success(taskService.getTodoTaskPage(getLoginUserId(), pageVO));
+    }
+
+    @GetMapping("done-page")
+    @ApiOperation("获取 Done 已办任务分页")
+    @PreAuthorize("@ss.hasPermission('bpm:task:query')")
+    public CommonResult<PageResult<BpmTaskDonePageItemRespVO>> getDoneTaskPage(@Valid BpmTaskDonePageReqVO pageVO) {
+        return success(taskService.getDoneTaskPage(getLoginUserId(), pageVO));
+    }
+
+    @GetMapping("/list-by-process-instance-id")
+    @ApiOperation(value = "获得指定流程实例的任务列表", notes = "包括完成的、未完成的")
+    @ApiImplicitParam(name = "processInstanceId", value = "流程实例的编号", required = true, dataTypeClass = String.class)
+    @PreAuthorize("@ss.hasPermission('bpm:task:query')")
+    public CommonResult<List<BpmTaskRespVO>> getTaskListByProcessInstanceId(
+        @RequestParam("processInstanceId") String processInstanceId) {
+        return success(taskService.getTaskListByProcessInstanceId(processInstanceId));
+    }
+
+    @PutMapping("/approve")
+    @ApiOperation("通过任务")
+    @PreAuthorize("@ss.hasPermission('bpm:task:update')")
+    public CommonResult<Boolean> approveTask(@Valid @RequestBody BpmTaskApproveReqVO reqVO) {
+        taskService.approveTask(getLoginUserId(), reqVO);
+        return success(true);
+    }
+
+    @PutMapping("/reject")
+    @ApiOperation("不通过任务")
+    @PreAuthorize("@ss.hasPermission('bpm:task:update')")
+    public CommonResult<Boolean> rejectTask(@Valid @RequestBody BpmTaskRejectReqVO reqVO) {
+        taskService.rejectTask(getLoginUserId(), reqVO);
+        return success(true);
+    }
+
+    @PutMapping("/update-assignee")
+    @ApiOperation(value = "更新任务的负责人", notes = "用于【流程详情】的【转派】按钮")
+    @PreAuthorize("@ss.hasPermission('bpm:task:update')")
+    public CommonResult<Boolean> updateTaskAssignee(@Valid @RequestBody BpmTaskUpdateAssigneeReqVO reqVO) {
+        taskService.updateTaskAssignee(getLoginUserId(), reqVO);
+        return success(true);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/activity/BpmActivityRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.activity;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+@ApiModel("管理后台 - 流程活动的 Response VO")
+@Data
+public class BpmActivityRespVO {
+
+    @ApiModelProperty(value = "流程活动的标识", required = true, example = "1024")
+    private String key;
+    @ApiModelProperty(value = "流程活动的类型", required = true, example = "StartEvent")
+    private String type;
+
+    @ApiModelProperty(value = "流程活动的开始时间", required = true)
+    private Date startTime;
+    @ApiModelProperty(value = "流程活动的结束时间", required = true)
+    private Date endTime;
+
+    @ApiModelProperty(value = "关联的流程任务的编号", example = "2048", notes = "关联的流程任务，只有 UserTask 等类型才有")
+    private String taskId;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/instance/BpmProcessInstanceCancelReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.Map;
+
+@ApiModel("管理后台 - 流程实例的取消 Request VO")
+@Data
+public class BpmProcessInstanceCancelReqVO {
+
+    @ApiModelProperty(value = "流程实例的编号", required = true, example = "1024")
+    @NotEmpty(message = "流程实例的编号不能为空")
+    private String id;
+
+    @ApiModelProperty(value = "取消原因", required = true, example = "不请假了！")
+    @NotEmpty(message = "取消原因不能为空")
+    private String reason;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/instance/BpmProcessInstanceCreateReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import java.util.Map;
+
+@ApiModel("管理后台 - 流程实例的创建 Request VO")
+@Data
+public class BpmProcessInstanceCreateReqVO {
+
+    @ApiModelProperty(value = "流程定义的编号", required = true, example = "1024")
+    @NotEmpty(message = "流程定义编号不能为空")
+    private String processDefinitionId;
+
+    @ApiModelProperty(value = "变量实例")
+    private Map<String, Object> variables;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/instance/BpmProcessInstanceMyPageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.util.Date;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@ApiModel("管理后台 - 流程实例的分页 Item Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmProcessInstanceMyPageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "流程名称", example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "流程定义的编号", example = "2048")
+    private String processDefinitionId;
+
+    @ApiModelProperty(value = "流程实例的状态", notes = "参见 bpm_process_instance_status", example = "1")
+    private Integer status;
+
+    @ApiModelProperty(value = "流程实例的结果", notes = "参见 bpm_process_instance_result", example = "2")
+    private Integer result;
+
+    @ApiModelProperty(value = "流程分类", notes = "参见 bpm_model_category 数据字典", example = "1")
+    private String category;
+
+    @ApiModelProperty(value = "创建时间")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date[] createTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/instance/BpmProcessInstancePageItemRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+import java.util.List;
+
+@ApiModel("管理后台 - 流程实例的分页 Item Response VO")
+@Data
+public class BpmProcessInstancePageItemRespVO {
+
+    @ApiModelProperty(value = "流程实例的编号", required = true, example = "1024")
+    private String id;
+
+    @ApiModelProperty(value = "流程名称", required = true, example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "流程定义的编号", required = true, example = "2048")
+    private String processDefinitionId;
+
+    @ApiModelProperty(value = "流程分类", required = true, notes = "参见 bpm_model_category 数据字典", example = "1")
+    private String category;
+
+    @ApiModelProperty(value = "流程实例的状态", required = true, notes = "参见 bpm_process_instance_status", example = "1")
+    private Integer status;
+
+    @ApiModelProperty(value = "流程实例的结果", required = true, notes = "参见 bpm_process_instance_result", example = "2")
+    private Integer result;
+
+    @ApiModelProperty(value = "提交时间", required = true)
+    private Date createTime;
+
+    @ApiModelProperty(value = "结束时间", required = true)
+    private Date endTime;
+
+    /**
+     * 当前任务
+     */
+    private List<Task> tasks;
+
+    @ApiModel("流程任务")
+    @Data
+    public static class Task {
+
+        @ApiModelProperty(value = "流程任务的编号", required = true, example = "1024")
+        private String id;
+
+        @ApiModelProperty(value = "任务名称", required = true, example = "芋道")
+        private String name;
+
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/instance/BpmProcessInstanceRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@ApiModel("管理后台 - 流程实例的 Response VO")
+@Data
+public class BpmProcessInstanceRespVO {
+
+    @ApiModelProperty(value = "流程实例的编号", required = true, example = "1024")
+    private String id;
+
+    @ApiModelProperty(value = "流程名称", required = true, example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "流程分类", required = true, notes = "参见 bpm_model_category 数据字典", example = "1")
+    private String category;
+
+    @ApiModelProperty(value = "流程实例的状态", required = true, notes = "参见 bpm_process_instance_status", example = "1")
+    private Integer status;
+
+    @ApiModelProperty(value = "流程实例的结果", required = true, notes = "参见 bpm_process_instance_result", example = "2")
+    private Integer result;
+
+    @ApiModelProperty(value = "提交时间", required = true)
+    private Date createTime;
+
+    @ApiModelProperty(value = "结束时间", required = true)
+    private Date endTime;
+
+    @ApiModelProperty(value = "提交的表单值", required = true)
+    private Map<String, Object> formVariables;
+
+    @ApiModelProperty(value = "业务的唯一标识", example = "1", notes = "例如说，请假申请的编号")
+    private String businessKey;
+
+    /**
+     * 发起流程的用户
+     */
+    private User startUser;
+
+    /**
+     * 流程定义
+     */
+    private ProcessDefinition processDefinition;
+
+    @ApiModel("用户信息")
+    @Data
+    public static class User {
+
+        @ApiModelProperty(value = "用户编号", required = true, example = "1")
+        private Long id;
+        @ApiModelProperty(value = "用户昵称", required = true, example = "芋艿")
+        private String nickname;
+
+        @ApiModelProperty(value = "部门编号", required = true, example = "1")
+        private Long deptId;
+        @ApiModelProperty(value = "部门名称", required = true, example = "研发部")
+        private String deptName;
+
+    }
+
+    @ApiModel("流程定义信息")
+    @Data
+    public static class ProcessDefinition {
+
+        @ApiModelProperty(value = "编号", required = true, example = "1024")
+        private String id;
+
+        @ApiModelProperty(value = "表单类型", notes = "参见 bpm_model_form_type 数据字典", example = "1")
+        private Integer formType;
+        @ApiModelProperty(value = "表单编号", example = "1024", notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+        private Long formId;
+        @ApiModelProperty(value = "表单的配置", required = true,
+                notes = "JSON 字符串。在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+        private String formConf;
+        @ApiModelProperty(value = "表单项的数组", required = true,
+                notes = "JSON 字符串的数组。在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+        private List<String> formFields;
+        @ApiModelProperty(value = "自定义表单的提交路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/create",
+                notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+        private String formCustomCreatePath;
+        @ApiModelProperty(value = "自定义表单的查看路径，使用 Vue 的路由地址", example = "/bpm/oa/leave/view",
+                notes = "在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时，必须非空")
+        private String formCustomViewPath;
+
+        @ApiModelProperty(value = "BPMN XML", required = true)
+        private String bpmnXml;
+
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskApproveReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+
+@ApiModel("管理后台 - 通过流程任务的 Request VO")
+@Data
+public class BpmTaskApproveReqVO {
+
+    @ApiModelProperty(value = "任务编号", required = true, example = "1024")
+    @NotEmpty(message = "任务编号不能为空")
+    private String id;
+
+    @ApiModelProperty(value = "审批意见", required = true, example = "不错不错！")
+    @NotEmpty(message = "审批意见不能为空")
+    private String reason;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskDonePageItemRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import java.util.Date;
+
+@ApiModel("管理后台 - 流程任务的 Done 已完成的分页项 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskDonePageItemRespVO extends BpmTaskTodoPageItemRespVO {
+
+    @ApiModelProperty(value = "结束时间", required = true)
+    private Date endTime;
+    @ApiModelProperty(value = "持续时间", required = true, example = "1000")
+    private Long durationInMillis;
+
+    @ApiModelProperty(value = "任务结果", required = true, notes = "参见 bpm_process_instance_result", example = "2")
+    private Integer result;
+    @ApiModelProperty(value = "审批建议", required = true, example = "不请假了！")
+    private String reason;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskDonePageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.util.Date;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@ApiModel("管理后台 - 流程任务的 Done 已办的分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskDonePageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "流程任务名", example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "开始的创建收间")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date beginCreateTime;
+
+    @ApiModelProperty(value = "结束的创建时间")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date endCreateTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskRejectReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+
+@ApiModel("管理后台 - 不通过流程任务的 Request VO")
+@Data
+public class BpmTaskRejectReqVO {
+
+    @ApiModelProperty(value = "任务编号", required = true, example = "1024")
+    @NotEmpty(message = "任务编号不能为空")
+    private String id;
+
+    @ApiModelProperty(value = "审批意见", required = true, example = "不错不错！")
+    @NotEmpty(message = "审批意见不能为空")
+    private String reason;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@ApiModel("管理后台 - 流程任务的 Response VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskRespVO extends BpmTaskDonePageItemRespVO {
+
+    @ApiModelProperty(value = "任务定义的标识", required = true, example = "user-001")
+    private String definitionKey;
+
+    /**
+     * 审核的用户信息
+     */
+    private User assigneeUser;
+
+    @ApiModel("用户信息")
+    @Data
+    public static class User {
+
+        @ApiModelProperty(value = "用户编号", required = true, example = "1")
+        private Long id;
+        @ApiModelProperty(value = "用户昵称", required = true, example = "芋艿")
+        private String nickname;
+
+        @ApiModelProperty(value = "部门编号", required = true, example = "1")
+        private Long deptId;
+        @ApiModelProperty(value = "部门名称", required = true, example = "研发部")
+        private String deptName;
+
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskTodoPageItemRespVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+@ApiModel("管理后台 - 流程任务的 Running 进行中的分页项 Response VO")
+@Data
+public class BpmTaskTodoPageItemRespVO {
+
+    @ApiModelProperty(value = "任务编号", required = true, example = "1024")
+    private String id;
+
+    @ApiModelProperty(value = "任务名字", required = true, example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "接收时间", required = true)
+    private Date claimTime;
+
+    @ApiModelProperty(value = "创建时间", required = true)
+    private Date createTime;
+
+    @ApiModelProperty(value = "激活状态", required = true, example = "1", notes = "参见 SuspensionState 枚举")
+    private Integer suspensionState;
+
+    /**
+     * 所属流程实例
+     */
+    private ProcessInstance processInstance;
+
+    @Data
+    @ApiModel("流程实例")
+    public static class ProcessInstance {
+
+        @ApiModelProperty(value = "流程实例编号", required = true, example = "1024")
+        private String id;
+
+        @ApiModelProperty(value = "流程实例名称", required = true, example = "芋道")
+        private String name;
+
+        @ApiModelProperty(value = "发起人的用户编号", required = true, example = "1024")
+        private Long startUserId;
+
+        @ApiModelProperty(value = "发起人的用户昵称", required = true, example = "芋艿")
+        private String startUserNickname;
+
+        @ApiModelProperty(value = "流程定义的编号", required = true, example = "2048")
+        private String processDefinitionId;
+
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskTodoPageReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import cn.iocoder.yudao.framework.common.pojo.PageParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.util.Date;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@ApiModel("管理后台 - 流程任务的 TODO 待办的分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskTodoPageReqVO extends PageParam {
+
+    @ApiModelProperty(value = "流程任务名", example = "芋道")
+    private String name;
+
+    @ApiModelProperty(value = "开始的创建收间")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date beginCreateTime;
+
+    @ApiModelProperty(value = "结束的创建时间")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private Date endCreateTime;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/admin/task/vo/task/BpmTaskUpdateAssigneeReqVO.java

+package cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import net.bytebuddy.implementation.bind.annotation.Empty;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+@ApiModel("管理后台 - 流程任务的更新负责人的 Request VO")
+@Data
+public class BpmTaskUpdateAssigneeReqVO {
+
+    @ApiModelProperty(value = "任务编号", required = true, example = "1024")
+    @NotEmpty(message = "任务编号不能为空")
+    private String id;
+
+    @ApiModelProperty(value = "新审批人的用户编号", required = true, example = "2048")
+    @NotNull(message = "新审批人的用户编号不能为空")
+    private Long assigneeUserId;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/app/package-info.java

+/**
+ * 占位
+ */
+package cn.iocoder.yudao.module.bpm.controller.app;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/controller/package-info.java

+/**
+ * 提供 RESTful API 给前端：
+ * 1. admin 包：提供给管理后台 yudao-ui-admin 前端项目
+ * 2. app 包：提供给用户 APP yudao-ui-app 前端项目，它的 Controller 和 VO 都要添加 App 前缀，用于和管理后台进行区分
+ */
+package cn.iocoder.yudao.module.bpm.controller;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/definition/BpmFormConvert.java

+package cn.iocoder.yudao.module.bpm.convert.definition;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormSimpleRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import org.mapstruct.Mapper;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+
+/**
+ * 动态表单 Convert
+ *
+ * @author 芋艿
+ */
+@Mapper
+public interface BpmFormConvert {
+
+    BpmFormConvert INSTANCE = Mappers.getMapper(BpmFormConvert.class);
+
+    BpmFormDO convert(BpmFormCreateReqVO bean);
+
+    BpmFormDO convert(BpmFormUpdateReqVO bean);
+
+    BpmFormRespVO convert(BpmFormDO bean);
+
+    List<BpmFormSimpleRespVO> convertList2(List<BpmFormDO> list);
+
+    PageResult<BpmFormRespVO> convertPage(PageResult<BpmFormDO> page);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/definition/BpmModelConvert.java

+package cn.iocoder.yudao.module.bpm.convert.definition;
+
+import cn.hutool.core.util.StrUtil;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model.*;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmModelMetaInfoRespDTO;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmProcessDefinitionCreateReqDTO;
+import org.flowable.common.engine.impl.db.SuspensionState;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.engine.repository.Model;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.mapstruct.Mapper;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * 流程模型 Convert
+ *
+ * @author yunlongn
+ */
+@Mapper
+public interface BpmModelConvert {
+
+    BpmModelConvert INSTANCE = Mappers.getMapper(BpmModelConvert.class);
+
+    default List<BpmModelPageItemRespVO> convertList(List<Model> list, Map<Long, BpmFormDO> formMap,
+                                                     Map<String, Deployment> deploymentMap,
+                                                     Map<String, ProcessDefinition> processDefinitionMap) {
+        return CollectionUtils.convertList(list, model -> {
+            BpmModelMetaInfoRespDTO metaInfo = JsonUtils.parseObject(model.getMetaInfo(), BpmModelMetaInfoRespDTO.class);
+            BpmFormDO form = metaInfo != null ? formMap.get(metaInfo.getFormId()) : null;
+            Deployment deployment = model.getDeploymentId() != null ? deploymentMap.get(model.getDeploymentId()) : null;
+            ProcessDefinition processDefinition = model.getDeploymentId() != null ? processDefinitionMap.get(model.getDeploymentId()) : null;
+            return convert(model, form, deployment, processDefinition);
+        });
+    }
+
+    default BpmModelPageItemRespVO convert(Model model, BpmFormDO form, Deployment deployment, ProcessDefinition processDefinition) {
+        BpmModelPageItemRespVO modelRespVO = new BpmModelPageItemRespVO();
+        modelRespVO.setId(model.getId());
+        modelRespVO.setCreateTime(model.getCreateTime());
+        // 通用 copy
+        copyTo(model, modelRespVO);
+        // Form
+        if (form != null) {
+            modelRespVO.setFormId(form.getId());
+            modelRespVO.setFormName(form.getName());
+        }
+        // ProcessDefinition
+        modelRespVO.setProcessDefinition(this.convert(processDefinition));
+        if (modelRespVO.getProcessDefinition() != null) {
+            modelRespVO.getProcessDefinition().setSuspensionState(processDefinition.isSuspended() ?
+                    SuspensionState.SUSPENDED.getStateCode() : SuspensionState.ACTIVE.getStateCode());
+            modelRespVO.getProcessDefinition().setDeploymentTime(deployment.getDeploymentTime());
+        }
+        return modelRespVO;
+    }
+
+    default BpmModelRespVO convert(Model model) {
+        BpmModelRespVO modelRespVO = new BpmModelRespVO();
+        modelRespVO.setId(model.getId());
+        modelRespVO.setCreateTime(model.getCreateTime());
+        // 通用 copy
+        copyTo(model, modelRespVO);
+        return modelRespVO;
+    }
+
+    default void copyTo(Model model, BpmModelBaseVO to) {
+        to.setName(model.getName());
+        to.setKey(model.getKey());
+        to.setCategory(model.getCategory());
+        // metaInfo
+        BpmModelMetaInfoRespDTO metaInfo = JsonUtils.parseObject(model.getMetaInfo(), BpmModelMetaInfoRespDTO.class);
+        copyTo(metaInfo, to);
+    }
+
+    BpmModelCreateReqVO convert(BpmModeImportReqVO bean);
+
+    default BpmProcessDefinitionCreateReqDTO convert2(Model model, BpmFormDO form) {
+        BpmProcessDefinitionCreateReqDTO createReqDTO = new BpmProcessDefinitionCreateReqDTO();
+        createReqDTO.setModelId(model.getId());
+        createReqDTO.setName(model.getName());
+        createReqDTO.setKey(model.getKey());
+        createReqDTO.setCategory(model.getCategory());
+        BpmModelMetaInfoRespDTO metaInfo = JsonUtils.parseObject(model.getMetaInfo(), BpmModelMetaInfoRespDTO.class);
+        // metaInfo
+        copyTo(metaInfo, createReqDTO);
+        // form
+        if (form != null) {
+            createReqDTO.setFormConf(form.getConf());
+            createReqDTO.setFormFields(form.getFields());
+        }
+        return createReqDTO;
+    }
+
+    void copyTo(BpmModelMetaInfoRespDTO from, @MappingTarget BpmProcessDefinitionCreateReqDTO to);
+
+    void copyTo(BpmModelMetaInfoRespDTO from, @MappingTarget BpmModelBaseVO to);
+
+    BpmModelPageItemRespVO.ProcessDefinition convert(ProcessDefinition bean);
+
+    default void copy(Model model, BpmModelCreateReqVO bean) {
+        model.setName(bean.getName());
+        model.setKey(bean.getKey());
+        model.setMetaInfo(buildMetaInfoStr(null, bean.getDescription(), null, null,
+                null, null));
+    }
+
+    default void copy(Model model, BpmModelUpdateReqVO bean) {
+        model.setName(bean.getName());
+        model.setCategory(bean.getCategory());
+        model.setMetaInfo(buildMetaInfoStr(JsonUtils.parseObject(model.getMetaInfo(), BpmModelMetaInfoRespDTO.class),
+                bean.getDescription(), bean.getFormType(), bean.getFormId(),
+                bean.getFormCustomCreatePath(), bean.getFormCustomViewPath()));
+    }
+
+    default String buildMetaInfoStr(BpmModelMetaInfoRespDTO metaInfo, String description, Integer formType,
+                                    Long formId, String formCustomCreatePath, String formCustomViewPath) {
+        if (metaInfo == null) {
+            metaInfo = new BpmModelMetaInfoRespDTO();
+        }
+        // 只有非空，才进行设置，避免更新时的覆盖
+        if (StrUtil.isNotEmpty(description)) {
+            metaInfo.setDescription(description);
+        }
+        if (Objects.nonNull(formType)) {
+            metaInfo.setFormType(formType);
+            metaInfo.setFormId(formId);
+            metaInfo.setFormCustomCreatePath(formCustomCreatePath);
+            metaInfo.setFormCustomViewPath(formCustomViewPath);
+        }
+        return JsonUtils.toJsonString(metaInfo);
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/definition/BpmProcessDefinitionConvert.java

+package cn.iocoder.yudao.module.bpm.convert.definition;
+
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionPageItemRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionRespVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmProcessDefinitionExtDO;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmProcessDefinitionCreateReqDTO;
+import org.flowable.common.engine.impl.db.SuspensionState;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.Named;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Bpm 流程定义的 Convert
+ *
+ * @author yunlong.li
+ */
+@Mapper
+public interface BpmProcessDefinitionConvert {
+
+    BpmProcessDefinitionConvert INSTANCE = Mappers.getMapper(BpmProcessDefinitionConvert.class);
+
+    BpmProcessDefinitionPageItemRespVO convert(ProcessDefinition bean);
+
+    BpmProcessDefinitionExtDO convert2(BpmProcessDefinitionCreateReqDTO bean);
+
+    default List<BpmProcessDefinitionPageItemRespVO> convertList(List<ProcessDefinition> list, Map<String, Deployment> deploymentMap,
+                                                                 Map<String, BpmProcessDefinitionExtDO> processDefinitionDOMap, Map<Long, BpmFormDO> formMap) {
+        return CollectionUtils.convertList(list, definition -> {
+            Deployment deployment = definition.getDeploymentId() != null ? deploymentMap.get(definition.getDeploymentId()) : null;
+            BpmProcessDefinitionExtDO definitionDO = processDefinitionDOMap.get(definition.getId());
+            BpmFormDO form = definitionDO != null ? formMap.get(definitionDO.getFormId()) : null;
+            return convert(definition, deployment, definitionDO, form);
+        });
+    }
+
+    default List<BpmProcessDefinitionRespVO> convertList3(List<ProcessDefinition> list,
+                                                          Map<String, BpmProcessDefinitionExtDO> processDefinitionDOMap) {
+        return CollectionUtils.convertList(list, processDefinition -> {
+            BpmProcessDefinitionRespVO respVO = convert3(processDefinition);
+            BpmProcessDefinitionExtDO processDefinitionExtDO = processDefinitionDOMap.get(processDefinition.getId());
+            // 复制通用属性
+            copyTo(processDefinitionExtDO, respVO);
+            return respVO;
+        });
+    }
+
+    @Mapping(source = "suspended", target = "suspensionState", qualifiedByName = "convertSuspendedToSuspensionState")
+    BpmProcessDefinitionRespVO convert3(ProcessDefinition bean);
+
+    @Named("convertSuspendedToSuspensionState")
+    default Integer convertSuspendedToSuspensionState(boolean suspended) {
+        return suspended ? SuspensionState.SUSPENDED.getStateCode() :
+                SuspensionState.ACTIVE.getStateCode();
+    }
+
+    default BpmProcessDefinitionPageItemRespVO convert(ProcessDefinition bean, Deployment deployment,
+                                                       BpmProcessDefinitionExtDO processDefinitionExtDO, BpmFormDO form) {
+        BpmProcessDefinitionPageItemRespVO respVO = convert(bean);
+        respVO.setSuspensionState(bean.isSuspended() ? SuspensionState.SUSPENDED.getStateCode() : SuspensionState.ACTIVE.getStateCode());
+        if (deployment != null) {
+            respVO.setDeploymentTime(deployment.getDeploymentTime());
+        }
+        if (form != null) {
+            respVO.setFormName(form.getName());
+        }
+        // 复制通用属性
+        copyTo(processDefinitionExtDO, respVO);
+        return respVO;
+    }
+
+    @Mapping(source = "from.id", target = "to.id", ignore = true)
+    void copyTo(BpmProcessDefinitionExtDO from, @MappingTarget BpmProcessDefinitionRespVO to);
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/definition/BpmTaskAssignRuleConvert.java

+package cn.iocoder.yudao.module.bpm.convert.definition;
+
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmTaskAssignRuleDO;
+import org.flowable.bpmn.model.UserTask;
+import org.mapstruct.Mapper;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface BpmTaskAssignRuleConvert {
+    BpmTaskAssignRuleConvert INSTANCE = Mappers.getMapper(BpmTaskAssignRuleConvert.class);
+
+    default List<BpmTaskAssignRuleRespVO> convertList(List<UserTask> tasks, List<BpmTaskAssignRuleDO> rules) {
+        Map<String, BpmTaskAssignRuleDO> ruleMap = CollectionUtils.convertMap(rules, BpmTaskAssignRuleDO::getTaskDefinitionKey);
+        // 以 UserTask 为主维度，原因是：流程图编辑后，一些规则实际就没用了。
+        return CollectionUtils.convertList(tasks, task -> {
+            BpmTaskAssignRuleRespVO respVO = convert(ruleMap.get(task.getId()));
+            if (respVO == null) {
+                respVO = new BpmTaskAssignRuleRespVO();
+                respVO.setTaskDefinitionKey(task.getId());
+            }
+            respVO.setTaskDefinitionName(task.getName());
+            return respVO;
+        });
+    }
+
+    BpmTaskAssignRuleRespVO convert(BpmTaskAssignRuleDO bean);
+
+    BpmTaskAssignRuleDO convert(BpmTaskAssignRuleCreateReqVO bean);
+
+    BpmTaskAssignRuleDO convert(BpmTaskAssignRuleUpdateReqVO bean);
+
+    List<BpmTaskAssignRuleDO> convertList2(List<BpmTaskAssignRuleRespVO> list);
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/definition/BpmUserGroupConvert.java

+package cn.iocoder.yudao.module.bpm.convert.definition;
+
+import java.util.*;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.Named;
+import org.mapstruct.factory.Mappers;
+
+/**
+ * 用户组 Convert
+ *
+ * @author 芋道源码
+ */
+@Mapper
+public interface BpmUserGroupConvert {
+
+    BpmUserGroupConvert INSTANCE = Mappers.getMapper(BpmUserGroupConvert.class);
+
+    BpmUserGroupDO convert(BpmUserGroupCreateReqVO bean);
+
+    BpmUserGroupDO convert(BpmUserGroupUpdateReqVO bean);
+
+    BpmUserGroupRespVO convert(BpmUserGroupDO bean);
+
+    List<BpmUserGroupRespVO> convertList(List<BpmUserGroupDO> list);
+
+    PageResult<BpmUserGroupRespVO> convertPage(PageResult<BpmUserGroupDO> page);
+
+    @Named("convertList2")
+    List<BpmUserGroupRespVO> convertList2(List<BpmUserGroupDO> list);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/message/BpmMessageConvert.java

+package cn.iocoder.yudao.module.bpm.convert.message;
+
+import cn.iocoder.yudao.module.system.api.sms.dto.send.SmsSendSingleToUserReqDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.factory.Mappers;
+
+import java.util.Map;
+
+@Mapper
+public interface BpmMessageConvert {
+
+    BpmMessageConvert INSTANCE = Mappers.getMapper(BpmMessageConvert.class);
+
+    SmsSendSingleToUserReqDTO convert(Long userId, String templateCode, Map<String, Object> templateParams);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/oa/BpmOALeaveConvert.java

+package cn.iocoder.yudao.module.bpm.convert.oa;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeaveCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeaveRespVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.oa.BpmOALeaveDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import org.mapstruct.Mapper;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+
+/**
+ * 请假申请 Convert
+ *
+ * @author 芋艿
+ */
+@Mapper
+public interface BpmOALeaveConvert {
+
+    BpmOALeaveConvert INSTANCE = Mappers.getMapper(BpmOALeaveConvert.class);
+
+    BpmOALeaveDO convert(BpmOALeaveCreateReqVO bean);
+
+    BpmOALeaveRespVO convert(BpmOALeaveDO bean);
+
+    List<BpmOALeaveRespVO> convertList(List<BpmOALeaveDO> list);
+
+    PageResult<BpmOALeaveRespVO> convertPage(PageResult<BpmOALeaveDO> page);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/package-info.java

+/**
+ * 提供 POJO 类的实体转换
+ *
+ * 目前使用 MapStruct 框架
+ */
+package cn.iocoder.yudao.module.bpm.convert;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/task/BpmActivityConvert.java

+package cn.iocoder.yudao.module.bpm.convert.task;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.activity.BpmActivityRespVO;
+import org.flowable.engine.history.HistoricActivityInstance;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.Mappings;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+
+/**
+ * BPM 活动 Convert
+ *
+ * @author 芋道源码
+ */
+@Mapper
+public interface BpmActivityConvert {
+
+    BpmActivityConvert INSTANCE = Mappers.getMapper(BpmActivityConvert.class);
+
+    List<BpmActivityRespVO> convertList(List<HistoricActivityInstance> list);
+
+    @Mappings({
+            @Mapping(source = "activityId", target = "key"),
+            @Mapping(source = "activityType", target = "type")
+    })
+    BpmActivityRespVO convert(HistoricActivityInstance bean);
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/task/BpmProcessInstanceConvert.java

+package cn.iocoder.yudao.module.bpm.convert.task;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance.BpmProcessInstancePageItemRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance.BpmProcessInstanceRespVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmProcessDefinitionExtDO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmProcessInstanceExtDO;
+import cn.iocoder.yudao.module.bpm.framework.bpm.core.event.BpmProcessInstanceResultEvent;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenProcessInstanceApproveReqDTO;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenProcessInstanceRejectReqDTO;
+import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
+import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.flowable.task.api.Task;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程实例 Convert
+ *
+ * @author 芋道源码
+ */
+@Mapper
+public interface BpmProcessInstanceConvert {
+
+    BpmProcessInstanceConvert INSTANCE = Mappers.getMapper(BpmProcessInstanceConvert.class);
+
+    default PageResult<BpmProcessInstancePageItemRespVO> convertPage(PageResult<BpmProcessInstanceExtDO> page,
+                                                                     Map<String, List<Task>> taskMap) {
+        List<BpmProcessInstancePageItemRespVO> list = convertList(page.getList());
+        list.forEach(respVO -> respVO.setTasks(convertList2(taskMap.get(respVO.getId()))));
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    List<BpmProcessInstancePageItemRespVO> convertList(List<BpmProcessInstanceExtDO> list);
+
+    @Mapping(source = "processInstanceId", target = "id")
+    BpmProcessInstancePageItemRespVO convert(BpmProcessInstanceExtDO bean);
+
+    List<BpmProcessInstancePageItemRespVO.Task> convertList2(List<Task> tasks);
+
+    default BpmProcessInstanceRespVO convert2(HistoricProcessInstance processInstance, BpmProcessInstanceExtDO processInstanceExt,
+                                              ProcessDefinition processDefinition, BpmProcessDefinitionExtDO processDefinitionExt,
+                                              String bpmnXml, AdminUserRespDTO startUser, DeptRespDTO dept) {
+        BpmProcessInstanceRespVO respVO = convert2(processInstance);
+        copyTo(processInstanceExt, respVO);
+        // definition
+        respVO.setProcessDefinition(convert2(processDefinition));
+        copyTo(processDefinitionExt, respVO.getProcessDefinition());
+        respVO.getProcessDefinition().setBpmnXml(bpmnXml);
+        // user
+        if (startUser != null) {
+            respVO.setStartUser(convert2(startUser));
+            if (dept != null) {
+                respVO.getStartUser().setDeptName(dept.getName());
+            }
+        }
+        return respVO;
+    }
+
+    BpmProcessInstanceRespVO convert2(HistoricProcessInstance bean);
+
+    @Mapping(source = "from.id", target = "to.id", ignore = true)
+    void copyTo(BpmProcessInstanceExtDO from, @MappingTarget BpmProcessInstanceRespVO to);
+
+    BpmProcessInstanceRespVO.ProcessDefinition convert2(ProcessDefinition bean);
+
+    @Mapping(source = "from.id", target = "to.id", ignore = true)
+    void copyTo(BpmProcessDefinitionExtDO from, @MappingTarget BpmProcessInstanceRespVO.ProcessDefinition to);
+
+    BpmProcessInstanceRespVO.User convert2(AdminUserRespDTO bean);
+
+    default BpmProcessInstanceResultEvent convert(Object source, HistoricProcessInstance instance, Integer result) {
+        BpmProcessInstanceResultEvent event = new BpmProcessInstanceResultEvent(source);
+        event.setId(instance.getId());
+        event.setProcessDefinitionKey(instance.getProcessDefinitionKey());
+        event.setBusinessKey(instance.getBusinessKey());
+        event.setResult(result);
+        return event;
+    }
+
+    default BpmProcessInstanceResultEvent convert(Object source, ProcessInstance instance, Integer result) {
+        BpmProcessInstanceResultEvent event = new BpmProcessInstanceResultEvent(source);
+        event.setId(instance.getId());
+        event.setProcessDefinitionKey(instance.getProcessDefinitionKey());
+        event.setBusinessKey(instance.getBusinessKey());
+        event.setResult(result);
+        return event;
+    }
+
+    default BpmMessageSendWhenProcessInstanceApproveReqDTO convert2ApprovedReq(ProcessInstance instance){
+        return  new BpmMessageSendWhenProcessInstanceApproveReqDTO()
+                .setStartUserId(NumberUtils.parseLong(instance.getStartUserId()))
+                .setProcessInstanceId(instance.getId())
+                .setProcessInstanceName(instance.getName());
+    }
+
+    default BpmMessageSendWhenProcessInstanceRejectReqDTO convert2RejectReq(ProcessInstance instance, String reason) {
+        return new BpmMessageSendWhenProcessInstanceRejectReqDTO()
+            .setProcessInstanceName(instance.getName())
+            .setProcessInstanceId(instance.getId())
+            .setReason(reason)
+            .setStartUserId(NumberUtils.parseLong(instance.getStartUserId()));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/task/BpmTaskConvert.java

+package cn.iocoder.yudao.module.bpm.convert.task;
+
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.BpmTaskDonePageItemRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.BpmTaskRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.BpmTaskTodoPageItemRespVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenTaskCreatedReqDTO;
+import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
+import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
+import org.flowable.common.engine.impl.db.SuspensionState;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.flowable.task.api.Task;
+import org.flowable.task.api.history.HistoricTaskInstance;
+import org.mapstruct.*;
+import org.mapstruct.factory.Mappers;
+import org.springframework.beans.BeanUtils;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Bpm 任务 Convert
+ *
+ * @author 芋道源码
+ */
+@Mapper
+public interface BpmTaskConvert {
+
+    BpmTaskConvert INSTANCE = Mappers.getMapper(BpmTaskConvert.class);
+
+    /**
+     * 复制对象
+     *
+     * @param source 源 要复制的对象
+     * @param target 目标 复制到此对象
+     * @param <T>
+     *
+     * @return
+     */
+    public static <T> T copy(Object source, Class<T> target) {
+        if (source == null || target == null) {
+            return null;
+        }
+        try {
+            T newInstance = target.newInstance();
+            BeanUtils.copyProperties(source, newInstance);
+            return newInstance;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    default <T, K> List<K> copyList(List<T> source, Class<K> target) {
+        if (null == source || source.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return source.stream().map(e -> copy(e, target)).collect(Collectors.toList());
+    }
+
+    default List<BpmTaskTodoPageItemRespVO> convertList1(List<Task> tasks,
+        Map<String, ProcessInstance> processInstanceMap, Map<Long, AdminUserRespDTO> userMap) {
+        return CollectionUtils.convertList(tasks, task -> {
+            BpmTaskTodoPageItemRespVO respVO = convert1(task);
+            ProcessInstance processInstance = processInstanceMap.get(task.getProcessInstanceId());
+            if (processInstance != null) {
+                AdminUserRespDTO startUser = userMap.get(NumberUtils.parseLong(processInstance.getStartUserId()));
+                respVO.setProcessInstance(convert(processInstance, startUser));
+            }
+            return respVO;
+        });
+    }
+
+    @Mapping(source = "suspended", target = "suspensionState", qualifiedByName = "convertSuspendedToSuspensionState")
+    BpmTaskTodoPageItemRespVO convert1(Task bean);
+
+    @Named("convertSuspendedToSuspensionState")
+    default Integer convertSuspendedToSuspensionState(boolean suspended) {
+        return suspended ? SuspensionState.SUSPENDED.getStateCode() : SuspensionState.ACTIVE.getStateCode();
+    }
+
+    default List<BpmTaskDonePageItemRespVO> convertList2(List<HistoricTaskInstance> tasks,
+        Map<String, BpmTaskExtDO> bpmTaskExtDOMap, Map<String, HistoricProcessInstance> historicProcessInstanceMap,
+        Map<Long, AdminUserRespDTO> userMap) {
+        return CollectionUtils.convertList(tasks, task -> {
+            BpmTaskDonePageItemRespVO respVO = convert2(task);
+            BpmTaskExtDO taskExtDO = bpmTaskExtDOMap.get(task.getId());
+            copyTo(taskExtDO, respVO);
+            HistoricProcessInstance processInstance = historicProcessInstanceMap.get(task.getProcessInstanceId());
+            if (processInstance != null) {
+                AdminUserRespDTO startUser = userMap.get(NumberUtils.parseLong(processInstance.getStartUserId()));
+                respVO.setProcessInstance(convert(processInstance, startUser));
+            }
+            return respVO;
+        });
+    }
+
+    BpmTaskDonePageItemRespVO convert2(HistoricTaskInstance bean);
+
+    @Mappings({@Mapping(source = "processInstance.id", target = "id"),
+        @Mapping(source = "processInstance.name", target = "name"),
+        @Mapping(source = "processInstance.startUserId", target = "startUserId"),
+        @Mapping(source = "processInstance.processDefinitionId", target = "processDefinitionId"),
+        @Mapping(source = "startUser.nickname", target = "startUserNickname")})
+    BpmTaskTodoPageItemRespVO.ProcessInstance convert(ProcessInstance processInstance, AdminUserRespDTO startUser);
+
+    default List<BpmTaskRespVO> convertList3(List<HistoricTaskInstance> tasks,
+        Map<String, BpmTaskExtDO> bpmTaskExtDOMap, HistoricProcessInstance processInstance,
+        Map<Long, AdminUserRespDTO> userMap, Map<Long, DeptRespDTO> deptMap) {
+        return CollectionUtils.convertList(tasks, task -> {
+            BpmTaskRespVO respVO = convert3(task);
+            BpmTaskExtDO taskExtDO = bpmTaskExtDOMap.get(task.getId());
+            copyTo(taskExtDO, respVO);
+            if (processInstance != null) {
+                AdminUserRespDTO startUser = userMap.get(NumberUtils.parseLong(processInstance.getStartUserId()));
+                respVO.setProcessInstance(convert(processInstance, startUser));
+            }
+            AdminUserRespDTO assignUser = userMap.get(NumberUtils.parseLong(task.getAssignee()));
+            if (assignUser != null) {
+                respVO.setAssigneeUser(convert3(assignUser));
+                DeptRespDTO dept = deptMap.get(assignUser.getDeptId());
+                if (dept != null) {
+                    respVO.getAssigneeUser().setDeptName(dept.getName());
+                }
+            }
+            return respVO;
+        });
+    }
+
+    @Mapping(source = "taskDefinitionKey", target = "definitionKey")
+    BpmTaskRespVO convert3(HistoricTaskInstance bean);
+
+    BpmTaskRespVO.User convert3(AdminUserRespDTO bean);
+
+    @Mapping(target = "id", ignore = true)
+    void copyTo(BpmTaskExtDO from, @MappingTarget BpmTaskDonePageItemRespVO to);
+
+    @Mappings({@Mapping(source = "processInstance.id", target = "id"),
+        @Mapping(source = "processInstance.name", target = "name"),
+        @Mapping(source = "processInstance.startUserId", target = "startUserId"),
+        @Mapping(source = "processInstance.processDefinitionId", target = "processDefinitionId"),
+        @Mapping(source = "startUser.nickname", target = "startUserNickname")})
+    BpmTaskTodoPageItemRespVO.ProcessInstance convert(HistoricProcessInstance processInstance,
+        AdminUserRespDTO startUser);
+
+    default BpmTaskExtDO convert2TaskExt(Task task) {
+        BpmTaskExtDO taskExtDO = new BpmTaskExtDO().setTaskId(task.getId())
+            .setAssigneeUserId(NumberUtils.parseLong(task.getAssignee())).setName(task.getName())
+            .setProcessDefinitionId(task.getProcessDefinitionId()).setProcessInstanceId(task.getProcessInstanceId());
+        taskExtDO.setCreateTime(task.getCreateTime());
+        return taskExtDO;
+    }
+
+    default BpmMessageSendWhenTaskCreatedReqDTO convert(ProcessInstance processInstance, AdminUserRespDTO startUser,
+        Task task) {
+        BpmMessageSendWhenTaskCreatedReqDTO reqDTO = new BpmMessageSendWhenTaskCreatedReqDTO();
+        reqDTO.setProcessInstanceId(processInstance.getProcessInstanceId())
+            .setProcessInstanceName(processInstance.getName()).setStartUserId(startUser.getId())
+            .setStartUserNickname(startUser.getNickname()).setTaskId(task.getId()).setTaskName(task.getName())
+            .setAssigneeUserId(NumberUtils.parseLong(task.getAssignee()));
+        return reqDTO;
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/task/package-info.java

+package cn.iocoder.yudao.module.bpm.convert.task;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/convert/《芋道 Spring Boot 对象转换 MapStruct 入门》.md

+<http://www.iocoder.cn/Spring-Boot/MapStruct/?yudao>

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/definition/BpmFormDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.definition;
+
+import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import lombok.*;
+
+import java.util.List;
+
+/**
+ * 工作流的表单定义
+ * 用于工作流的申请表单，需要动态配置的场景
+ *
+ * @author 芋道源码
+ */
+@TableName(value = "bpm_form", autoResultMap = true)
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BpmFormDO extends BaseDO {
+
+    /**
+     * 编号
+     */
+    @TableId
+    private Long id;
+    /**
+     * 表单名
+     */
+    private String name;
+    /**
+     * 状态
+     */
+    private Integer status;
+    /**
+     * 表单的配置
+     */
+    private String conf;
+    /**
+     * 表单项的数组
+     *
+     * 目前直接将 https://github.com/JakHuang/form-generator 生成的 JSON 串，直接保存
+     * 定义：https://github.com/JakHuang/form-generator/issues/46
+     */
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private List<String> fields;
+    /**
+     * 备注
+     */
+    private String remark;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/definition/BpmProcessDefinitionExtDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.definition;
+
+import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmModelFormTypeEnum;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import lombok.*;
+
+import java.util.List;
+
+/**
+ * Bpm 流程定义的拓展表
+ * 主要解决 Activiti {@link ProcessDefinition} 不支持拓展字段，所以新建拓展表
+ *
+ * @author 芋道源码
+ */
+@TableName(value = "bpm_process_definition_ext", autoResultMap = true)
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BpmProcessDefinitionExtDO extends BaseDO {
+
+    /**
+     * 编号
+     */
+    @TableId
+    private Long id;
+    /**
+     * 流程定义的编号
+     *
+     * 关联 ProcessDefinition 的 id 属性
+     */
+    private String processDefinitionId;
+    /**
+     * 流程模型的编号
+     *
+     * 关联 Model 的 id 属性
+     */
+    private String modelId;
+    /**
+     * 描述
+     */
+    private String description;
+
+    /**
+     * 表单类型
+     *
+     * 关联 {@link BpmModelFormTypeEnum}
+     */
+    private Integer formType;
+    /**
+     * 动态表单编号
+     * 在表单类型为 {@link BpmModelFormTypeEnum#NORMAL} 时
+     *
+     * 关联 {@link BpmFormDO#getId()}
+     */
+    private Long formId;
+    /**
+     * 表单的配置
+     * 在表单类型为 {@link BpmModelFormTypeEnum#NORMAL} 时
+     *
+     * 冗余 {@link BpmFormDO#getConf()}
+     */
+    private String formConf;
+    /**
+     * 表单项的数组
+     * 在表单类型为 {@link BpmModelFormTypeEnum#NORMAL} 时
+     *
+     * 冗余 {@link BpmFormDO#getFields()} ()}
+     */
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private List<String> formFields;
+    /**
+     * 自定义表单的提交路径，使用 Vue 的路由地址
+     * 在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时
+     */
+    private String formCustomCreatePath;
+    /**
+     * 自定义表单的查看路径，使用 Vue 的路由地址
+     * 在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时
+     */
+    private String formCustomViewPath;
+
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/definition/BpmTaskAssignRuleDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.definition;
+
+import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
+import cn.iocoder.yudao.framework.mybatis.core.type.JsonLongSetTypeHandler;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskAssignRuleTypeEnum;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskRuleScriptEnum;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.*;
+
+import java.util.Set;
+
+/**
+ * Bpm 任务分配的规则表，用于自定义配置每个任务的负责人、候选人的分配规则。
+ * 也就是说，废弃 BPMN 原本的 UserTask 设置的 assignee、candidateUsers 等配置，而是通过使用该规则进行计算对应的负责人。
+ *
+ * 1. 默认情况下，{@link #processDefinitionId} 为 {@link #PROCESS_DEFINITION_ID_NULL} 值，表示贵改则与流程模型关联
+ * 2. 在流程模型部署后，会将他的所有规则记录，复制出一份新部署出来的流程定义，通过设置 {@link #processDefinitionId} 为新的流程定义的编号进行关联
+ *
+ * @author 芋道源码
+ */
+@TableName(value = "bpm_task_assign_rule", autoResultMap = true)
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BpmTaskAssignRuleDO extends BaseDO {
+
+    /**
+     * {@link #processDefinitionId} 空串，用于标识属于流程模型，而不属于流程定义
+     */
+    public static final String PROCESS_DEFINITION_ID_NULL = "";
+
+    /**
+     * 编号
+     */
+    @TableId
+    private Long id;
+
+    /**
+     * 流程模型编号
+     *
+     * 关联 Model 的 id 属性
+     */
+    private String modelId;
+    /**
+     * 流程定义编号
+     *
+     * 关联 ProcessDefinition 的 id 属性
+     */
+    private String processDefinitionId;
+    /**
+     * 流程任务的定义 Key
+     *
+     * 关联 Task 的 taskDefinitionKey 属性
+     */
+    private String taskDefinitionKey;
+
+    /**
+     * 规则类型
+     *
+     * 枚举 {@link BpmTaskAssignRuleTypeEnum}
+     */
+    @TableField("`type`")
+    private Integer type;
+    /**
+     * 规则值数组，一般关联指定表的编号
+     * 根据 type 不同，对应的值是不同的：
+     *
+     * 1. {@link BpmTaskAssignRuleTypeEnum#ROLE} 时：角色编号
+     * 2. {@link BpmTaskAssignRuleTypeEnum#DEPT_MEMBER} 时：部门编号
+     * 3. {@link BpmTaskAssignRuleTypeEnum#DEPT_LEADER} 时：部门编号
+     * 4. {@link BpmTaskAssignRuleTypeEnum#USER} 时：用户编号
+     * 5. {@link BpmTaskAssignRuleTypeEnum#USER_GROUP} 时：用户组编号
+     * 6. {@link BpmTaskAssignRuleTypeEnum#SCRIPT} 时：脚本编号，目前通过 {@link BpmTaskRuleScriptEnum#getId()} 标识
+     */
+    @TableField(typeHandler = JsonLongSetTypeHandler.class)
+    private Set<Long> options;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/definition/BpmTaskMessageRuleDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.definition;
+
+// TODO 芋艿：先埋个坑。任务消息的配置规则。说白了，就是不同的
+public class BpmTaskMessageRuleDO {
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/definition/BpmUserGroupDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.definition;
+
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
+import cn.iocoder.yudao.framework.mybatis.core.type.JsonLongSetTypeHandler;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.*;
+
+import java.util.Set;
+
+/**
+ * Bpm 用户组
+ *
+ * @author 芋道源码
+ */
+@TableName(value = "bpm_user_group", autoResultMap = true)
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BpmUserGroupDO extends BaseDO {
+
+    /**
+     * 编号，自增
+     */
+    @TableId
+    private Long id;
+    /**
+     * 组名
+     */
+    private String name;
+    /**
+     * 描述
+     */
+    private String description;
+    /**
+     * 状态
+     *
+     * 枚举 {@link CommonStatusEnum}
+     */
+    private Integer status;
+    /**
+     * 成员用户编号数组
+     */
+    @TableField(typeHandler = JsonLongSetTypeHandler.class)
+    private Set<Long> memberUserIds;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/oa/BpmOALeaveDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.oa;
+
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;
+import lombok.*;
+import java.util.*;
+import com.baomidou.mybatisplus.annotation.*;
+import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
+
+/**
+ * OA 请假申请 DO
+ *
+ * {@link #day} 请假天数，目前先简单做。一般是分成请假上午和下午，可以是 1 整天，可以是 0.5 半天
+ *
+ * @author jason
+ * @author 芋道源码
+ */
+@TableName("bpm_oa_leave")
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BpmOALeaveDO extends BaseDO {
+
+    /**
+     * 请假表单主键
+     */
+    @TableId
+    private Long id;
+    /**
+     * 申请人的用户编号
+     *
+     * 关联 AdminUserDO 的 id 属性
+     */
+    private Long userId;
+    /**
+     * 请假类型
+     */
+    @TableField("`type`")
+    private String type;
+    /**
+     * 原因
+     */
+    private String reason;
+    /**
+     * 开始时间
+     */
+    private Date startTime;
+    /**
+     * 结束时间
+     */
+    private Date endTime;
+    /**
+     * 请假天数
+     */
+    private Long day;
+    /**
+     * 请假的结果
+     *
+     * 枚举 {@link BpmProcessInstanceResultEnum}
+     * 考虑到简单，所以直接复用了 BpmProcessInstanceResultEnum 枚举，也可以自己定义一个枚举哈
+     */
+    private Integer result;
+
+    /**
+     * 对应的流程编号
+     *
+     * 关联 ProcessInstance 的 id 属性
+     */
+    private String processInstanceId;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/task/BpmActivityDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.task;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.*;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.util.Date;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.TIME_ZONE_DEFAULT;
+
+/**
+ * 任务流程关联表
+ *
+ * @author kemengkai
+ * @create 2022-05-09 10:33
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class BpmActivityDO {
+
+    /**
+     * 任务流程关联id
+     */
+    private String id;
+
+    /**
+     * 审批结果
+     */
+    private Integer rev;
+
+    /**
+     * 任务流程部署id
+     */
+    private String procDefId;
+
+    /**
+     * 任务流程id
+     */
+    private String processInstanceId;
+
+    /**
+     * 任务执行id
+     */
+    private String executionId;
+
+    /**
+     * 任务key
+     */
+    private String activityId;
+
+    /**
+     * 任务id
+     */
+    private String taskId;
+
+    /**
+     * 调用流程id
+     */
+    private String callProcInstId;
+
+    /**
+     * 任务名称
+     */
+    private String activityName;
+
+    /**
+     * 任务类型
+     */
+    private String activityType;
+
+    /**
+     * 任务审批人id
+     */
+    private String assignee;
+
+    /**
+     * 任务开始时间
+     */
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    @JsonFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND, timezone = TIME_ZONE_DEFAULT)
+    private Date startTime;
+
+    /**
+     * 任务结束时间
+     */
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    @JsonFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND, timezone = TIME_ZONE_DEFAULT)
+    private Date endTime;
+
+    private Integer transactionOrder;
+
+    private Long duration;
+
+    /**
+     * 删除结果
+     */
+    private String deleteReason;
+
+    /**
+     * 租户id
+     */
+    private String tenantId;
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/task/BpmProcessInstanceExtDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.task;
+
+import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceStatusEnum;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * Bpm 流程实例的拓展表
+ * 主要解决 Activiti ProcessInstance 和 HistoricProcessInstance 不支持拓展字段，所以新建拓展表
+ *
+ * @author 芋道源码
+ */
+@TableName(value = "bpm_process_instance_ext", autoResultMap = true)
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmProcessInstanceExtDO extends BaseDO {
+
+    /**
+     * 编号，自增
+     */
+    @TableId
+    private Long id;
+    /**
+     * 发起流程的用户编号
+     *
+     * 冗余 HistoricProcessInstance 的 startUserId 属性
+     */
+    private Long startUserId;
+    /**
+     * 流程实例的名字
+     *
+     * 冗余 ProcessInstance 的 name 属性，用于筛选
+     */
+    private String name;
+    /**
+     * 流程实例的编号
+     *
+     * 关联 ProcessInstance 的 id 属性
+     */
+    private String processInstanceId;
+    /**
+     * 流程定义的编号
+     *
+     * 关联 ProcessDefinition 的 id 属性
+     */
+    private String processDefinitionId;
+    /**
+     * 流程分类
+     *
+     * 冗余 ProcessDefinition 的 category 属性
+     * 数据字典 bpm_model_category
+     */
+    private String category;
+    /**
+     * 流程实例的状态
+     *
+     * 枚举 {@link BpmProcessInstanceStatusEnum}
+     */
+    private Integer status;
+    /**
+     * 流程实例的结果
+     *
+     * 枚举 {@link BpmProcessInstanceResultEnum}
+     */
+    private Integer result;
+    /**
+     * 结束时间
+     *
+     * 冗余 HistoricProcessInstance 的 endTime 属性
+     */
+    private Date endTime;
+
+    /**
+     * 提交的表单值
+     */
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private Map<String, Object> formVariables;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/dataobject/task/BpmTaskExtDO.java

+package cn.iocoder.yudao.module.bpm.dal.dataobject.task;
+
+import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import java.util.Date;
+
+/**
+ * Bpm 流程任务的拓展表
+ * 主要解决 Flowable Task 和 HistoricTaskInstance 不支持拓展字段，所以新建拓展表
+ *
+ * @author 芋道源码
+ */
+@TableName(value = "bpm_task_ext", autoResultMap = true)
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmTaskExtDO extends BaseDO {
+
+    /**
+     * 编号，自增
+     */
+    @TableId
+    private Long id;
+
+    /**
+     * 任务的审批人
+     *
+     * 冗余 Task 的 assignee 属性
+     */
+    private Long assigneeUserId;
+    /**
+     * 任务的名字
+     *
+     * 冗余 Task 的 name 属性，为了筛选
+     */
+    private String name;
+    /**
+     * 任务的编号
+     *
+     * 关联 Task 的 id 属性
+     */
+    private String taskId;
+//    /**
+//     * 任务的标识
+//     *
+//     * 关联 {@link Task#getTaskDefinitionKey()}
+//     */
+//    private String definitionKey;
+    /**
+     * 任务的结果
+     *
+     * 枚举 {@link BpmProcessInstanceResultEnum}
+     */
+    private Integer result;
+    /**
+     * 审批建议
+     */
+    private String reason;
+    /**
+     * 任务的结束时间
+     *
+     * 冗余 HistoricTaskInstance 的 endTime  属性
+     */
+    private Date endTime;
+
+    /**
+     * 流程实例的编号
+     *
+     * 关联 ProcessInstance 的 id 属性
+     */
+    private String processInstanceId;
+    /**
+     * 流程定义的编号
+     *
+     * 关联 ProcessDefinition 的 id 属性
+     */
+    private String processDefinitionId;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/definition/BpmFormMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.definition;
+
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormPageReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.framework.mybatis.core.query.QueryWrapperX;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 动态表单 Mapper
+ *
+ * @author 风里雾里
+ */
+@Mapper
+public interface BpmFormMapper extends BaseMapperX<BpmFormDO> {
+
+    default PageResult<BpmFormDO> selectPage(BpmFormPageReqVO reqVO) {
+        return selectPage(reqVO, new QueryWrapperX<BpmFormDO>()
+                .likeIfPresent("name", reqVO.getName())
+                .orderByDesc("id"));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/definition/BpmProcessDefinitionExtMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.definition;
+
+import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmProcessDefinitionExtDO;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.Collection;
+import java.util.List;
+
+@Mapper
+public interface BpmProcessDefinitionExtMapper extends BaseMapperX<BpmProcessDefinitionExtDO> {
+
+    default List<BpmProcessDefinitionExtDO> selectListByProcessDefinitionIds(Collection<String> processDefinitionIds) {
+        return selectList("process_definition_id", processDefinitionIds);
+    }
+
+    default BpmProcessDefinitionExtDO selectByProcessDefinitionId(String processDefinitionId) {
+        return selectOne("process_definition_id", processDefinitionId);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/definition/BpmTaskAssignRuleMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.definition;
+
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmTaskAssignRuleDO;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.framework.mybatis.core.query.QueryWrapperX;
+import org.apache.ibatis.annotations.Mapper;
+import org.springframework.lang.Nullable;
+
+import java.util.List;
+
+@Mapper
+public interface BpmTaskAssignRuleMapper extends BaseMapperX<BpmTaskAssignRuleDO> {
+
+    default List<BpmTaskAssignRuleDO> selectListByProcessDefinitionId(String processDefinitionId,
+                                                                      @Nullable String taskDefinitionKey) {
+        return selectList(new QueryWrapperX<BpmTaskAssignRuleDO>()
+                .eq("process_definition_id", processDefinitionId)
+                .eqIfPresent("task_definition_key", taskDefinitionKey));
+    }
+
+    default List<BpmTaskAssignRuleDO> selectListByModelId(String modelId) {
+        return selectList(new QueryWrapperX<BpmTaskAssignRuleDO>()
+                .eq("model_id", modelId)
+                .eq("process_definition_id", BpmTaskAssignRuleDO.PROCESS_DEFINITION_ID_NULL));
+    }
+
+    default BpmTaskAssignRuleDO selectListByModelIdAndTaskDefinitionKey(String modelId,
+                                                                        String taskDefinitionKey) {
+        return selectOne(new QueryWrapperX<BpmTaskAssignRuleDO>()
+                .eq("model_id", modelId)
+                .eq("process_definition_id", BpmTaskAssignRuleDO.PROCESS_DEFINITION_ID_NULL)
+                .eq("task_definition_key", taskDefinitionKey));
+    }
+
+
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/definition/BpmUserGroupMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.definition;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupPageReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+ * 用户组 Mapper
+ *
+ * @author 芋道源码
+ */
+@Mapper
+public interface BpmUserGroupMapper extends BaseMapperX<BpmUserGroupDO> {
+
+    default PageResult<BpmUserGroupDO> selectPage(BpmUserGroupPageReqVO reqVO) {
+        return selectPage(reqVO, new LambdaQueryWrapperX<BpmUserGroupDO>()
+                .likeIfPresent(BpmUserGroupDO::getName, reqVO.getName())
+                .eqIfPresent(BpmUserGroupDO::getStatus, reqVO.getStatus())
+                .betweenIfPresent(BpmUserGroupDO::getCreateTime, reqVO.getCreateTime())
+                .orderByDesc(BpmUserGroupDO::getId));
+    }
+
+    default List<BpmUserGroupDO> selectListByStatus(Integer status) {
+        return selectList(BpmUserGroupDO::getStatus, status);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/oa/BpmOALeaveMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.oa;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeavePageReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.oa.BpmOALeaveDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 请假申请 Mapper
+ *
+ * @author jason
+ * @author 芋道源码
+ */
+@Mapper
+public interface BpmOALeaveMapper extends BaseMapperX<BpmOALeaveDO> {
+
+    default PageResult<BpmOALeaveDO> selectPage(Long userId, BpmOALeavePageReqVO reqVO) {
+        return selectPage(reqVO, new LambdaQueryWrapperX<BpmOALeaveDO>()
+                .eqIfPresent(BpmOALeaveDO::getUserId, userId)
+                .eqIfPresent(BpmOALeaveDO::getResult, reqVO.getResult())
+                .eqIfPresent(BpmOALeaveDO::getType, reqVO.getType())
+                .likeIfPresent(BpmOALeaveDO::getReason, reqVO.getReason())
+                .betweenIfPresent(BpmOALeaveDO::getCreateTime, reqVO.getCreateTime())
+                .orderByDesc(BpmOALeaveDO::getId));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/task/BpmActivityMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.task;
+
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmActivityDO;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+@Mapper
+public interface BpmActivityMapper extends BaseMapperX<BpmActivityDO> {
+
+
+    // TODO @ke：可以试试，把 activiti 的表，映射成对应的实体，然后读取下。我们尽量避免 xml 操作，因为要做多 db 类型的支持，例如说 oracle 等。通过 mybatis plus 帮助我们生成不同数据库的表操作
+    /**
+     * 获取指定流程的历史任务
+     *
+     * @param procInstId 流程id
+     *
+     * @return 返回历史任务
+     */
+    List<BpmActivityDO> listAllByProcInstIdAndDelete(@Param("procInstId") String procInstId);
+
+    /**
+     * 逻辑删除hiActInst表任务
+     *
+     * @param taskIdList 任务列表
+     *
+     * @return 返回是否成功
+     */
+    Boolean delHiActInstByTaskId(@Param("taskIdList") List<String> taskIdList);
+
+    /**
+     * 逻辑删除hiTaskInst任务
+     *
+     * @param taskIdList 任务列表
+     *
+     * @return 返回是否成功
+     */
+    Boolean delHiTaskInstByTaskId(@Param("taskIdList") List<String> taskIdList);
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/task/BpmProcessInstanceExtMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.task;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance.BpmProcessInstanceMyPageReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmProcessInstanceExtDO;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface BpmProcessInstanceExtMapper extends BaseMapperX<BpmProcessInstanceExtDO> {
+
+    default PageResult<BpmProcessInstanceExtDO> selectPage(Long userId, BpmProcessInstanceMyPageReqVO reqVO) {
+        return selectPage(reqVO, new LambdaQueryWrapperX<BpmProcessInstanceExtDO>()
+                .eqIfPresent(BpmProcessInstanceExtDO::getStartUserId, userId)
+                .likeIfPresent(BpmProcessInstanceExtDO::getName, reqVO.getName())
+                .eqIfPresent(BpmProcessInstanceExtDO::getProcessDefinitionId, reqVO.getProcessDefinitionId())
+                .eqIfPresent(BpmProcessInstanceExtDO::getCategory, reqVO.getCategory())
+                .eqIfPresent(BpmProcessInstanceExtDO::getStatus, reqVO.getStatus())
+                .eqIfPresent(BpmProcessInstanceExtDO::getResult, reqVO.getResult())
+                .betweenIfPresent(BpmProcessInstanceExtDO::getCreateTime, reqVO.getCreateTime())
+                .orderByDesc(BpmProcessInstanceExtDO::getId));
+    }
+
+    default BpmProcessInstanceExtDO selectByProcessInstanceId(String processInstanceId) {
+        return selectOne(BpmProcessInstanceExtDO::getProcessInstanceId, processInstanceId);
+    }
+
+    default void updateByProcessInstanceId(BpmProcessInstanceExtDO updateObj) {
+        update(updateObj, new LambdaQueryWrapperX<BpmProcessInstanceExtDO>()
+                .eq(BpmProcessInstanceExtDO::getProcessInstanceId, updateObj.getProcessInstanceId()));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/dal/mysql/task/BpmTaskExtMapper.java

+package cn.iocoder.yudao.module.bpm.dal.mysql.task;
+
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.Collection;
+import java.util.List;
+
+@Mapper
+public interface BpmTaskExtMapper extends BaseMapperX<BpmTaskExtDO> {
+
+    default void updateByTaskId(BpmTaskExtDO entity) {
+        update(entity, new LambdaQueryWrapper<BpmTaskExtDO>().eq(BpmTaskExtDO::getTaskId, entity.getTaskId()));
+    }
+
+    default List<BpmTaskExtDO> selectListByTaskIds(Collection<String> taskIds) {
+        return selectList(BpmTaskExtDO::getTaskId, taskIds);
+    }
+
+    default BpmTaskExtDO selectByTaskId(String taskId) {
+        return selectOne(BpmTaskExtDO::getTaskId, taskId);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/config/BpmCommonConfiguration.java

+package cn.iocoder.yudao.module.bpm.framework.bpm.config;
+
+import cn.iocoder.yudao.module.bpm.framework.bpm.core.event.BpmProcessInstanceResultEventPublisher;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * BPM 通用的 Configuration 配置类，提供给 Activiti 和 Flowable
+ */
+@Configuration
+public class BpmCommonConfiguration {
+
+    @Bean
+    public BpmProcessInstanceResultEventPublisher processInstanceResultEventPublisher(ApplicationEventPublisher publisher) {
+        return new BpmProcessInstanceResultEventPublisher(publisher);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/config/BpmSecurityConfiguration.java

+package cn.iocoder.yudao.module.bpm.framework.bpm.config;
+
+import cn.iocoder.yudao.framework.security.config.AuthorizeRequestsCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configurers.ExpressionUrlAuthorizationConfigurer;
+
+/**
+ * @author kemengkai
+ * @create 2022-05-07 08:15
+ */
+@Configuration("bpmSecurityConfiguration")
+public class BpmSecurityConfiguration {
+
+    @Bean("bpmAuthorizeRequestsCustomizer")
+    public AuthorizeRequestsCustomizer authorizeRequestsCustomizer() {
+        return new AuthorizeRequestsCustomizer() {
+
+            @Override
+            public void customize(ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry) {
+                // 任务回退接口
+                registry.antMatchers(buildAdminApi("/bpm/task/back")).permitAll();
+            }
+
+        };
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/core/event/BpmProcessInstanceResultEvent.java

+package cn.iocoder.yudao.module.bpm.framework.bpm.core.event;
+
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmProcessInstanceExtDO;
+import lombok.Data;
+import org.springframework.context.ApplicationEvent;
+
+import javax.validation.constraints.NotNull;
+
+/**
+ * 流程实例的结果发生变化的 Event
+ * 定位：由于额外增加了 {@link BpmProcessInstanceExtDO#getResult()} 结果，所以增加该事件
+ *
+ * @author 芋道源码
+ */
+@SuppressWarnings("ALL")
+@Data
+public class BpmProcessInstanceResultEvent extends ApplicationEvent {
+
+    /**
+     * 流程实例的编号
+     */
+    @NotNull(message = "流程实例的编号不能为空")
+    private String id;
+    /**
+     * 流程实例的 key
+     */
+    @NotNull(message = "流程实例的 key 不能为空")
+    private String processDefinitionKey;
+    /**
+     * 流程实例的结果
+     */
+    @NotNull(message = "流程实例的结果不能为空")
+    private Integer result;
+    /**
+     * 流程实例对应的业务标识
+     * 例如说，请假
+     */
+    private String businessKey;
+
+    public BpmProcessInstanceResultEvent(Object source) {
+        super(source);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/core/event/BpmProcessInstanceResultEventListener.java

+package cn.iocoder.yudao.module.bpm.framework.bpm.core.event;
+
+import cn.hutool.core.util.StrUtil;
+import org.springframework.context.ApplicationListener;
+
+/**
+ * {@link BpmProcessInstanceResultEvent} 的监听器
+ *
+ * @author 芋道源码
+ */
+public abstract class BpmProcessInstanceResultEventListener
+        implements ApplicationListener<BpmProcessInstanceResultEvent> {
+
+    @Override
+    public final void onApplicationEvent(BpmProcessInstanceResultEvent event) {
+        if (!StrUtil.equals(event.getProcessDefinitionKey(), getProcessDefinitionKey())) {
+            return;
+        }
+        onEvent(event);
+    }
+
+    /**
+     * @return 返回监听的流程定义 Key
+     */
+    protected abstract String getProcessDefinitionKey();
+
+    /**
+     * 处理事件
+     *
+     * @param event 事件
+     */
+    protected abstract void onEvent(BpmProcessInstanceResultEvent event);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/core/event/BpmProcessInstanceResultEventPublisher.java

+package cn.iocoder.yudao.module.bpm.framework.bpm.core.event;
+
+import lombok.AllArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.validation.annotation.Validated;
+
+import javax.validation.Valid;
+
+/**
+ * {@link BpmProcessInstanceResultEvent} 的生产者
+ *
+ * @author 芋道源码
+ */
+@AllArgsConstructor
+@Validated
+public class BpmProcessInstanceResultEventPublisher {
+
+    private final ApplicationEventPublisher publisher;
+
+    public void sendProcessInstanceResultEvent(@Valid BpmProcessInstanceResultEvent event) {
+        publisher.publishEvent(event);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/core/event/package-info.java

+/**
+ * 自定义 Event 实现，提供方便业务接入的 Listener！
+ *
+ * @author 芋道源码
+ */
+package cn.iocoder.yudao.module.bpm.framework.bpm.core.event;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/core/package-info.java

+/**
+ * 占位
+ */
+package cn.iocoder.yudao.module.bpm.framework.bpm.core;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/bpm/package-info.java

+/**
+ * 提供给 Activiti 和 Flowable 的通用封装
+ *
+ * @author 芋道源码
+ */
+package cn.iocoder.yudao.module.bpm.framework.bpm;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/config/BpmFlowableConfiguration.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.config;
+
+import cn.hutool.core.collection.ListUtil;
+import cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.BpmActivityBehaviorFactory;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmTaskAssignRuleService;
+import org.flowable.common.engine.api.delegate.event.FlowableEventListener;
+import org.flowable.spring.SpringProcessEngineConfiguration;
+import org.flowable.spring.boot.EngineConfigurationConfigurer;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * BPM 模块的 Flowable 配置类
+ *
+ * @author jason
+ */
+@Configuration
+public class BpmFlowableConfiguration {
+
+    /**
+     * BPM 模块的 ProcessEngineConfigurationConfigurer 实现类：
+     *
+     * 1. 设置各种监听器
+     * 2. 设置自定义的 ActivityBehaviorFactory 实现
+     */
+    @Bean
+    public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> bpmProcessEngineConfigurationConfigurer(
+            ObjectProvider<FlowableEventListener> listeners,
+            BpmActivityBehaviorFactory bpmActivityBehaviorFactory) {
+        return configuration -> {
+            // 注册监听器，例如说 BpmActivityEventListener
+            configuration.setEventListeners(ListUtil.toList(listeners.iterator()));
+            // 设置 ActivityBehaviorFactory 实现类，用于流程任务的审核人的自定义
+            configuration.setActivityBehaviorFactory(bpmActivityBehaviorFactory);
+        };
+    }
+
+    @Bean
+    public BpmActivityBehaviorFactory bpmActivityBehaviorFactory(BpmTaskAssignRuleService taskRuleService) {
+        BpmActivityBehaviorFactory bpmActivityBehaviorFactory = new BpmActivityBehaviorFactory();
+        bpmActivityBehaviorFactory.setBpmTaskRuleService(taskRuleService);
+        return bpmActivityBehaviorFactory;
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/BpmActivityBehaviorFactory.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior;
+
+import cn.iocoder.yudao.module.bpm.service.definition.BpmTaskAssignRuleService;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.Setter;
+import lombok.ToString;
+import org.flowable.bpmn.model.Activity;
+import org.flowable.bpmn.model.UserTask;
+import org.flowable.engine.impl.bpmn.behavior.AbstractBpmnActivityBehavior;
+import org.flowable.engine.impl.bpmn.behavior.ParallelMultiInstanceBehavior;
+import org.flowable.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
+import org.flowable.engine.impl.bpmn.parser.factory.DefaultActivityBehaviorFactory;
+
+/**
+ * 自定义的 ActivityBehaviorFactory 实现类，目的如下：
+ * 1. 自定义 {@link #createUserTaskActivityBehavior(UserTask)}：实现自定义的流程任务的 assignee 负责人的分配
+ *
+ * @author 芋道源码
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
+public class BpmActivityBehaviorFactory extends DefaultActivityBehaviorFactory {
+
+    @Setter
+    private BpmTaskAssignRuleService bpmTaskRuleService;
+
+    @Override
+    public UserTaskActivityBehavior createUserTaskActivityBehavior(UserTask userTask) {
+        return new BpmUserTaskActivityBehavior(userTask)
+                .setBpmTaskRuleService(bpmTaskRuleService);
+    }
+
+    @Override
+    public ParallelMultiInstanceBehavior createParallelMultiInstanceBehavior(Activity activity,
+                                                                             AbstractBpmnActivityBehavior innerActivityBehavior) {
+        return new BpmParallelMultiInstanceBehavior(activity, innerActivityBehavior)
+                .setBpmTaskRuleService(bpmTaskRuleService);
+    }
+
+    // TODO @ke：SequentialMultiInstanceBehavior 这个抽空也可以看看
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/BpmParallelMultiInstanceBehavior.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior;
+
+import cn.iocoder.yudao.framework.flowable.core.util.FlowableUtils;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmTaskAssignRuleService;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.bpmn.model.Activity;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.impl.bpmn.behavior.AbstractBpmnActivityBehavior;
+import org.flowable.engine.impl.bpmn.behavior.ParallelMultiInstanceBehavior;
+
+import java.util.Set;
+
+/**
+ * 自定义的【并行】的【多个】流程任务的 assignee 负责人的分配
+ * 第一步，基于分配规则，计算出分配任务的【多个】候选人们。
+ * 第二步，将【多个】任务候选人们，设置到 DelegateExecution 的 collectionVariable 变量中，以便 BpmUserTaskActivityBehavior 使用它
+ *
+ * @author kemengkai
+ * @date 2022-04-21 16:57
+ */
+@Slf4j
+public class BpmParallelMultiInstanceBehavior extends ParallelMultiInstanceBehavior {
+
+    @Setter
+    private BpmTaskAssignRuleService bpmTaskRuleService;
+
+    public BpmParallelMultiInstanceBehavior(Activity activity,
+                                            AbstractBpmnActivityBehavior innerActivityBehavior) {
+        super(activity, innerActivityBehavior);
+    }
+
+    /**
+     * 重写该方法，主要实现两个功能：
+     * 1. 忽略原有的 collectionVariable、collectionElementVariable 表达式，而是采用自己定义的
+     * 2. 获得任务的处理人，并设置到 collectionVariable 中，用于 BpmUserTaskActivityBehavior 从中可以获取任务的处理人
+     *
+     * 注意，多个任务实例，每个任务实例对应一个处理人，所以返回的数量就是任务处理人的数量
+     *
+     * @param execution 执行任务
+     * @return 数量
+     */
+    @Override
+    protected int resolveNrOfInstances(DelegateExecution execution) {
+        // 第一步，设置 collectionVariable 和 CollectionVariable
+        // 从  execution.getVariable() 读取所有任务处理人的 key
+        super.collectionExpression = null; // collectionExpression 和 collectionVariable 是互斥的
+        super.collectionVariable = FlowableUtils.formatCollectionVariable(execution.getCurrentActivityId());
+        // 从 execution.getVariable() 读取当前所有任务处理的人的 key
+        super.collectionElementVariable = FlowableUtils.formatCollectionElementVariable(execution.getCurrentActivityId());
+
+        // 第二步，获取任务的所有处理人
+        Set<Long> assigneeUserIds = bpmTaskRuleService.calculateTaskCandidateUsers(execution);
+        execution.setVariable(super.collectionVariable, assigneeUserIds);
+        return assigneeUserIds.size();
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/BpmUserTaskActivityBehavior.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.RandomUtil;
+import cn.iocoder.yudao.module.bpm.service.definition.BpmTaskAssignRuleService;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.bpmn.model.UserTask;
+import org.flowable.common.engine.impl.el.ExpressionManager;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
+import org.flowable.engine.impl.cfg.ProcessEngineConfigurationImpl;
+import org.flowable.engine.impl.util.TaskHelper;
+import org.flowable.task.service.TaskService;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 自定义的【单个】流程任务的 assignee 负责人的分配
+ * 第一步，基于分配规则，计算出分配任务的【单个】候选人。如果找不到，则直接报业务异常，不继续执行后续的流程；
+ * 第二步，随机选择一个候选人，则选择作为 assignee 负责人。
+ *
+ * @author 芋道源码
+ */
+@Slf4j
+public class BpmUserTaskActivityBehavior extends UserTaskActivityBehavior {
+
+    @Setter
+    private BpmTaskAssignRuleService bpmTaskRuleService;
+
+    public BpmUserTaskActivityBehavior(UserTask userTask) {
+        super(userTask);
+    }
+
+    @Override
+    protected void handleAssignments(TaskService taskService, String assignee, String owner,
+        List<String> candidateUsers, List<String> candidateGroups, TaskEntity task, ExpressionManager expressionManager,
+        DelegateExecution execution, ProcessEngineConfigurationImpl processEngineConfiguration) {
+        // 第一步，获得任务的候选用户
+        Long assigneeUserId = calculateTaskCandidateUsers(execution);
+        Assert.notNull(assigneeUserId, "任务处理人不能为空");
+        // 第二步，设置作为负责人
+        TaskHelper.changeTaskAssignee(task, String.valueOf(assigneeUserId));
+    }
+
+    private Long calculateTaskCandidateUsers(DelegateExecution execution) {
+        // 情况一，如果是多实例的任务，例如说会签、或签等情况，则从 Variable 中获取。它的任务处理人在 BpmParallelMultiInstanceBehavior 中已经被分配了
+        if (super.multiInstanceActivityBehavior != null) {
+            return execution.getVariable(super.multiInstanceActivityBehavior.getCollectionElementVariable(), Long.class);
+        }
+
+        // 情况二，如果非多实例的任务，则计算任务处理人
+        // 第一步，先计算可处理该任务的处理人们
+        Set<Long> candidateUserIds = bpmTaskRuleService.calculateTaskCandidateUsers(execution);
+        // 第二步，后随机选择一个任务的处理人
+        // 疑问：为什么一定要选择一个任务处理人？
+        // 解答：项目对 bpm 的任务是责任到人，所以每个任务有且仅有一个处理人。
+        //      如果希望一个任务可以同时被多个人处理，可以考虑使用 BpmParallelMultiInstanceBehavior 实现的会签 or 或签。
+        int index = RandomUtil.randomInt(candidateUserIds.size());
+        return CollUtil.get(candidateUserIds, index);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/script/BpmTaskAssignScript.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script;
+
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskRuleScriptEnum;
+import org.flowable.engine.delegate.DelegateExecution;
+
+import java.util.Set;
+
+/**
+ * Bpm 任务分配的自定义 Script 脚本
+ * 使用场景：
+ * 1. 设置审批人为发起人
+ * 2. 设置审批人为发起人的 Leader
+ * 3. 甚至审批人为发起人的 Leader 的 Leader
+ *
+ * @author 芋道源码
+ */
+public interface BpmTaskAssignScript {
+
+    /**
+     * 基于执行任务，获得任务的候选用户们
+     *
+     * @param execution 执行任务
+     * @return 候选人用户的编号数组
+     */
+    Set<Long> calculateTaskCandidateUsers(DelegateExecution execution);
+
+    /**
+     * 获得枚举值
+     *
+     * @return 枚举值
+     */
+    BpmTaskRuleScriptEnum getEnum();
+}
+

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/script/impl/BpmTaskAssignLeaderAbstractScript.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.impl;
+
+import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
+import cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.BpmTaskAssignScript;
+import cn.iocoder.yudao.module.bpm.service.task.BpmProcessInstanceService;
+import cn.iocoder.yudao.module.system.api.dept.DeptApi;
+import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
+import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
+import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.util.Assert;
+
+import javax.annotation.Resource;
+import java.util.Set;
+
+import static cn.iocoder.yudao.framework.common.util.collection.SetUtils.asSet;
+import static java.util.Collections.emptySet;
+
+/**
+ * 分配给发起人的 Leader 审批的 Script 实现类
+ * 目前 Leader 的定义是，
+ *
+ * @author 芋道源码
+ */
+public abstract class BpmTaskAssignLeaderAbstractScript implements BpmTaskAssignScript {
+
+    @Resource
+    private AdminUserApi adminUserApi;
+    @Resource
+    private DeptApi deptApi;
+    @Resource
+    @Lazy // 解决循环依赖
+    private BpmProcessInstanceService bpmProcessInstanceService;
+
+    protected Set<Long> calculateTaskCandidateUsers(DelegateExecution execution, int level) {
+        Assert.isTrue(level > 0, "level 必须大于 0");
+        // 获得发起人
+        ProcessInstance processInstance = bpmProcessInstanceService.getProcessInstance(execution.getProcessInstanceId());
+        Long startUserId = NumberUtils.parseLong(processInstance.getStartUserId());
+        // 获得对应 leve 的部门
+        DeptRespDTO dept = null;
+        for (int i = 0; i < level; i++) {
+            // 获得 level 对应的部门
+            if (dept == null) {
+                dept = getStartUserDept(startUserId);
+                if (dept == null) { // 找不到发起人的部门，所以无法使用该规则
+                    return emptySet();
+                }
+            } else {
+                DeptRespDTO parentDept = deptApi.getDept(dept.getParentId()).getCheckedData();
+                if (parentDept == null) { // 找不到父级部门，所以只好结束寻找。原因是：例如说，级别比较高的人，所在部门层级比较少
+                    break;
+                }
+                dept = parentDept;
+            }
+        }
+        return dept.getLeaderUserId() != null ? asSet(dept.getLeaderUserId()) : emptySet();
+    }
+
+    private DeptRespDTO getStartUserDept(Long startUserId) {
+        AdminUserRespDTO startUser = adminUserApi.getUser(startUserId).getCheckedData();
+        if (startUser.getDeptId() == null) { // 找不到部门，所以无法使用该规则
+            return null;
+        }
+        return deptApi.getDept(startUser.getDeptId()).getCheckedData();
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/script/impl/BpmTaskAssignLeaderX1Script.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.impl;
+
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskRuleScriptEnum;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.stereotype.Component;
+
+import java.util.Set;
+
+/**
+ * 分配给发起人的一级 Leader 审批的 Script 实现类
+ *
+ * @author 芋道源码
+ */
+@Component
+public class BpmTaskAssignLeaderX1Script extends BpmTaskAssignLeaderAbstractScript {
+
+    @Override
+    public Set<Long> calculateTaskCandidateUsers(DelegateExecution execution) {
+        return calculateTaskCandidateUsers(execution, 1);
+    }
+
+    @Override
+    public BpmTaskRuleScriptEnum getEnum() {
+        return BpmTaskRuleScriptEnum.LEADER_X1;
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/script/impl/BpmTaskAssignLeaderX2Script.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.impl;
+
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskRuleScriptEnum;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.stereotype.Component;
+
+import java.util.Set;
+
+/**
+ * 分配给发起人的二级 Leader 审批的 Script 实现类
+ *
+ * @author 芋道源码
+ */
+@Component
+public class BpmTaskAssignLeaderX2Script extends BpmTaskAssignLeaderAbstractScript {
+
+    @Override
+    public Set<Long> calculateTaskCandidateUsers(DelegateExecution execution) {
+        return calculateTaskCandidateUsers(execution, 2);
+    }
+
+    @Override
+    public BpmTaskRuleScriptEnum getEnum() {
+        return BpmTaskRuleScriptEnum.LEADER_X2;
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/script/impl/BpmTaskAssignStartUserScript.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.impl;
+
+import cn.iocoder.yudao.framework.common.util.collection.SetUtils;
+import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskRuleScriptEnum;
+import cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.BpmTaskAssignScript;
+import cn.iocoder.yudao.module.bpm.service.task.BpmProcessInstanceService;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.Set;
+
+/**
+ * 分配给发起人审批的 Script 实现类
+ *
+ * @author 芋道源码
+ */
+@Component
+public class BpmTaskAssignStartUserScript implements BpmTaskAssignScript {
+
+    @Resource
+    @Lazy // 解决循环依赖
+    private BpmProcessInstanceService bpmProcessInstanceService;
+
+    @Override
+    public Set<Long> calculateTaskCandidateUsers(DelegateExecution execution) {
+        ProcessInstance processInstance = bpmProcessInstanceService.getProcessInstance(execution.getProcessInstanceId());
+        Long startUserId = NumberUtils.parseLong(processInstance.getStartUserId());
+        return SetUtils.asSet(startUserId);
+    }
+
+    @Override
+    public BpmTaskRuleScriptEnum getEnum() {
+        return BpmTaskRuleScriptEnum.START_USER;
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/listener/BpmProcessInstanceEventListener.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.listener;
+
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmProcessInstanceExtDO;
+import cn.iocoder.yudao.module.bpm.service.task.BpmProcessInstanceService;
+import com.google.common.collect.ImmutableSet;
+import org.flowable.common.engine.api.delegate.event.FlowableEngineEntityEvent;
+import org.flowable.common.engine.api.delegate.event.FlowableEngineEventType;
+import org.flowable.engine.delegate.event.AbstractFlowableEngineEventListener;
+import org.flowable.engine.delegate.event.FlowableCancelledEvent;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.Set;
+
+/**
+ * 监听 {@link ProcessInstance} 的开始与完成，创建与更新对应的 {@link BpmProcessInstanceExtDO} 记录
+ *
+ * @author jason
+ */
+@Component
+public class BpmProcessInstanceEventListener extends AbstractFlowableEngineEventListener {
+
+    @Resource
+    @Lazy
+    private BpmProcessInstanceService processInstanceService;
+
+    public static final Set<FlowableEngineEventType> PROCESS_INSTANCE_EVENTS = ImmutableSet.<FlowableEngineEventType>builder()
+                     .add(FlowableEngineEventType.PROCESS_CREATED)
+                     .add(FlowableEngineEventType.PROCESS_CANCELLED)
+                     .add(FlowableEngineEventType.PROCESS_COMPLETED)
+                     .build();
+
+    public BpmProcessInstanceEventListener(){
+        super(PROCESS_INSTANCE_EVENTS);
+    }
+
+    @Override
+    protected void processCreated(FlowableEngineEntityEvent event) {
+        processInstanceService.createProcessInstanceExt((ProcessInstance)event.getEntity());
+    }
+
+    @Override
+    protected void processCancelled(FlowableCancelledEvent event) {
+        processInstanceService.updateProcessInstanceExtCancel(event);
+    }
+
+    @Override
+    protected void processCompleted(FlowableEngineEntityEvent event) {
+        processInstanceService.updateProcessInstanceExtComplete((ProcessInstance)event.getEntity());
+    }
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/listener/BpmTaskEventListener.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.listener;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
+import cn.iocoder.yudao.module.bpm.service.task.BpmActivityService;
+import cn.iocoder.yudao.module.bpm.service.task.BpmTaskService;
+import com.google.common.collect.ImmutableSet;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.common.engine.api.delegate.event.FlowableEngineEntityEvent;
+import org.flowable.common.engine.api.delegate.event.FlowableEngineEventType;
+import org.flowable.engine.delegate.event.AbstractFlowableEngineEventListener;
+import org.flowable.engine.delegate.event.FlowableActivityCancelledEvent;
+import org.flowable.engine.history.HistoricActivityInstance;
+import org.flowable.task.api.Task;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 监听 {@link org.flowable.task.api.Task} 的开始与完成，创建与更新对应的 {@link BpmTaskExtDO} 记录
+ *
+ * @author jason
+ */
+@Component
+@Slf4j
+public class BpmTaskEventListener extends AbstractFlowableEngineEventListener {
+
+    @Resource
+    @Lazy // 解决循环依赖
+    private BpmTaskService taskService;
+
+    @Resource
+    @Lazy // 解决循环依赖
+    private BpmActivityService activityService;
+
+    public static final Set<FlowableEngineEventType> TASK_EVENTS = ImmutableSet.<FlowableEngineEventType>builder()
+            .add(FlowableEngineEventType.TASK_CREATED)
+            .add(FlowableEngineEventType.TASK_ASSIGNED)
+            .add(FlowableEngineEventType.TASK_COMPLETED)
+            .add(FlowableEngineEventType.ACTIVITY_CANCELLED)
+            .build();
+
+    public BpmTaskEventListener(){
+        super(TASK_EVENTS);
+    }
+
+    @Override
+    protected void taskCreated(FlowableEngineEntityEvent event) {
+        taskService.createTaskExt((Task) event.getEntity());
+    }
+
+    @Override
+    protected void taskCompleted(FlowableEngineEntityEvent event) {
+        taskService.updateTaskExtComplete((Task)event.getEntity());
+    }
+
+    @Override
+    protected void taskAssigned(FlowableEngineEntityEvent event) {
+        taskService.updateTaskExtAssign((Task)event.getEntity());
+    }
+
+    @Override
+    protected void activityCancelled(FlowableActivityCancelledEvent event) {
+        List<HistoricActivityInstance> activityList = activityService.getHistoricActivityListByExecutionId(event.getExecutionId());
+        if (CollUtil.isEmpty(activityList)) {
+            log.error("[activityCancelled][使用 executionId({}) 查找不到对应的活动实例]", event.getExecutionId());
+            return;
+        }
+        // 遍历处理
+        activityList.forEach(activity -> {
+            if (StrUtil.isEmpty(activity.getTaskId())) {
+                return;
+            }
+            taskService.updateTaskExtCancel(activity.getTaskId());
+        });
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/package-info.java

+/**
+ * 属于 bpm 模块的 framework 封装
+ *
+ * @author 芋道源码
+ */
+package cn.iocoder.yudao.module.bpm.framework;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/rpc/config/RpcConfiguration.java

+package cn.iocoder.yudao.module.bpm.framework.rpc.config;
+
+import cn.iocoder.yudao.module.system.api.dept.DeptApi;
+import cn.iocoder.yudao.module.system.api.dept.PostApi;
+import cn.iocoder.yudao.module.system.api.dict.DictDataApi;
+import cn.iocoder.yudao.module.system.api.permission.RoleApi;
+import cn.iocoder.yudao.module.system.api.sms.SmsSendApi;
+import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration(proxyBeanMethods = false)
+@EnableFeignClients(clients = {RoleApi.class, DeptApi.class, PostApi.class, AdminUserApi.class, SmsSendApi.class, DictDataApi.class})
+public class RpcConfiguration {
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/framework/rpc/package-info.java

+/**
+ * 占位
+ */
+package cn.iocoder.yudao.module.bpm.framework.rpc;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/package-info.java

+/**
+ * bpm 包下，业务流程管理（Business Process Management），我们放工作流的功能，基于 activiti 7 版本实现。
+ * 例如说：流程定义、表单配置、审核中心（我的申请、我的待办、我的已办）等等
+ *
+ * bpm 解释：https://baike.baidu.com/item/BPM/1933
+ *
+ * 1. Controller URL：以 /bpm/ 开头，避免和其它 Module 冲突
+ * 2. DataObject 表名：以 bpm_ 开头，方便在数据库中区分
+ *
+ * 注意，由于 Bpm 模块下，容易和其它模块重名，所以类名都加载 Bpm 的前缀~
+ */
+package cn.iocoder.yudao.module.bpm;

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmFormService.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+
+import javax.validation.Valid;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * 动态表单 Service 接口
+ *
+ * @author  @风里雾里
+ */
+public interface BpmFormService {
+
+    /**
+     * 创建动态表单
+     *
+     * @param createReqVO 创建信息
+     * @return 编号
+     */
+    Long createForm(@Valid BpmFormCreateReqVO createReqVO);
+
+    /**
+     * 更新动态表单
+     *
+     * @param updateReqVO 更新信息
+     */
+    void updateForm(@Valid BpmFormUpdateReqVO updateReqVO);
+
+    /**
+     * 删除动态表单
+     *
+     * @param id 编号
+     */
+    void deleteForm(Long id);
+
+    /**
+     * 获得动态表单
+     *
+     * @param id 编号
+     * @return 动态表单
+     */
+    BpmFormDO getForm(Long id);
+
+    /**
+     * 获得动态表单列表
+     *
+     * @return 动态表单列表
+     */
+    List<BpmFormDO> getFormList();
+
+    /**
+     * 获得动态表单列表
+     *
+     * @param ids 编号
+     * @return 动态表单列表
+     */
+    List<BpmFormDO> getFormList(Collection<Long> ids);
+
+    /**
+     * 获得动态表单 Map
+     *
+     * @param ids 编号
+     * @return 动态表单 Map
+     */
+    default Map<Long, BpmFormDO> getFormMap(Collection<Long> ids) {
+        if (CollUtil.isEmpty(ids)) {
+            return Collections.emptyMap();
+        }
+        return CollectionUtils.convertMap(this.getFormList(ids), BpmFormDO::getId);
+    }
+
+    /**
+     * 获得动态表单分页
+     *
+     * @param pageReqVO 分页查询
+     * @return 动态表单分页
+     */
+    PageResult<BpmFormDO> getFormPage(BpmFormPageReqVO pageReqVO);
+
+    /**
+     * 校验流程表单已配置
+     *
+     * @param configStr  configStr 字段
+     * @return 流程表单
+     */
+    BpmFormDO checkFormConfig(String  configStr);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmFormServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.hutool.core.lang.Assert;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
+import cn.iocoder.yudao.framework.common.util.validation.ValidationUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmFormConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.definition.BpmFormMapper;
+import cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmModelFormTypeEnum;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmFormFieldRespDTO;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmModelMetaInfoRespDTO;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import java.util.*;
+
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.*;
+
+/**
+ * 动态表单 Service 实现类
+ *
+ * @author 风里雾里
+ */
+@Service
+@Validated
+public class BpmFormServiceImpl implements BpmFormService {
+
+    @Resource
+    private BpmFormMapper formMapper;
+
+    @Override
+    public Long createForm(BpmFormCreateReqVO createReqVO) {
+        this.checkFields(createReqVO.getFields());
+        // 插入
+        BpmFormDO form = BpmFormConvert.INSTANCE.convert(createReqVO);
+        formMapper.insert(form);
+        // 返回
+        return form.getId();
+    }
+
+    @Override
+    public void updateForm(BpmFormUpdateReqVO updateReqVO) {
+        this.checkFields(updateReqVO.getFields());
+        // 校验存在
+        this.validateFormExists(updateReqVO.getId());
+        // 更新
+        BpmFormDO updateObj = BpmFormConvert.INSTANCE.convert(updateReqVO);
+        formMapper.updateById(updateObj);
+    }
+
+    @Override
+    public void deleteForm(Long id) {
+        // 校验存在
+        this.validateFormExists(id);
+        // 删除
+        formMapper.deleteById(id);
+    }
+
+    private void validateFormExists(Long id) {
+        if (formMapper.selectById(id) == null) {
+            throw exception(ErrorCodeConstants.FORM_NOT_EXISTS);
+        }
+    }
+
+    @Override
+    public BpmFormDO getForm(Long id) {
+        return formMapper.selectById(id);
+    }
+
+    @Override
+    public List<BpmFormDO> getFormList() {
+        return formMapper.selectList();
+    }
+
+    @Override
+    public List<BpmFormDO> getFormList(Collection<Long> ids) {
+        return formMapper.selectBatchIds(ids);
+    }
+
+    @Override
+    public PageResult<BpmFormDO> getFormPage(BpmFormPageReqVO pageReqVO) {
+        return formMapper.selectPage(pageReqVO);
+    }
+
+
+    @Override
+    public BpmFormDO checkFormConfig(String configStr) {
+        BpmModelMetaInfoRespDTO metaInfo = JsonUtils.parseObject(configStr, BpmModelMetaInfoRespDTO.class);
+        if (metaInfo == null || metaInfo.getFormType() == null) {
+            throw exception(MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG);
+        }
+        // 校验表单存在
+        if (Objects.equals(metaInfo.getFormType(), BpmModelFormTypeEnum.NORMAL.getType())) {
+            BpmFormDO form = getForm(metaInfo.getFormId());
+            if (form == null) {
+                throw exception(FORM_NOT_EXISTS);
+            }
+            return form;
+        }
+        return null;
+    }
+
+    private void checkKeyNCName(String key) {
+        if (!ValidationUtils.isXmlNCName(key)) {
+            throw exception(MODEL_KEY_VALID);
+        }
+    }
+    /**
+     * 校验 Field，避免 field 重复
+     *
+     * @param fields field 数组
+     */
+    private void checkFields(List<String> fields) {
+        Map<String, String> fieldMap = new HashMap<>(); // key 是 vModel，value 是 label
+        for (String field : fields) {
+            BpmFormFieldRespDTO fieldDTO = JsonUtils.parseObject(field, BpmFormFieldRespDTO.class);
+            Assert.notNull(fieldDTO);
+            String oldLabel = fieldMap.put(fieldDTO.getVModel(), fieldDTO.getLabel());
+            // 如果不存在，则直接返回
+            if (oldLabel == null) {
+                continue;
+            }
+            // 如果存在，则报错
+            throw exception(ErrorCodeConstants.FORM_FIELD_REPEAT, oldLabel, fieldDTO.getLabel(), fieldDTO.getVModel());
+        }
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmModelService.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model.*;
+import org.flowable.bpmn.model.BpmnModel;
+
+import javax.validation.Valid;
+
+/**
+ * Flowable流程模型接口
+ *
+ * @author yunlongn
+ */
+public interface BpmModelService {
+    /**
+     * 获得流程模型分页
+     *
+     * @param pageVO 分页查询
+     * @return 流程模型分页
+     */
+    PageResult<BpmModelPageItemRespVO> getModelPage(BpmModelPageReqVO pageVO);
+
+    /**
+     * 创建流程模型
+     *
+     * @param modelVO 创建信息
+     * @param bpmnXml BPMN XML
+     * @return 创建的流程模型的编号
+     */
+    String createModel(@Valid BpmModelCreateReqVO modelVO, String bpmnXml);
+
+    /**
+     * 获得流程模块
+     *
+     * @param id 编号
+     * @return 流程模型
+     */
+    BpmModelRespVO getModel(String id);
+
+    /**
+     * 修改流程模型
+     *
+     * @param updateReqVO 更新信息
+     */
+    void updateModel(@Valid BpmModelUpdateReqVO updateReqVO);
+
+    /**
+     * 将流程模型，部署成一个流程定义
+     *
+     * @param id 编号
+     */
+    void deployModel(String id);
+
+    /**
+     * 删除模型
+     *
+     * @param id 编号
+     */
+    void deleteModel(String id);
+
+    /**
+     * 修改模型的状态，实际更新的部署的流程定义的状态
+     *
+     * @param id 编号
+     * @param state 状态
+     */
+    void updateModelState(String id, Integer state);
+
+    /**
+     * 获得流程模型编号对应的 BPMN Model
+     *
+     * @param id 流程模型编号
+     * @return BPMN Model
+     */
+    BpmnModel getBpmnModel(String id);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmModelServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.hutool.core.util.ArrayUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
+import cn.iocoder.yudao.framework.common.util.object.PageUtils;
+import cn.iocoder.yudao.framework.common.util.validation.ValidationUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.model.*;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmModelConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmModelFormTypeEnum;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmModelMetaInfoRespDTO;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmProcessDefinitionCreateReqDTO;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.bpmn.converter.BpmnXMLConverter;
+import org.flowable.bpmn.model.BpmnModel;
+import org.flowable.common.engine.impl.db.SuspensionState;
+import org.flowable.common.engine.impl.util.io.BytesStreamSource;
+import org.flowable.engine.RepositoryService;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.engine.repository.Model;
+import org.flowable.engine.repository.ModelQuery;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.ObjectUtils;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+import java.util.*;
+
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.*;
+
+/**
+ * Flowable流程模型实现
+ * 主要进行 Flowable {@link Model} 的维护
+ *
+ * @author yunlongn
+ * @author 芋道源码
+ * @author jason
+ */
+@Service
+@Validated
+@Slf4j
+public class BpmModelServiceImpl implements BpmModelService {
+
+    @Resource
+    private RepositoryService repositoryService;
+    @Resource
+    private BpmProcessDefinitionService processDefinitionService;
+    @Resource
+    private BpmFormService bpmFormService;
+    @Resource
+    private BpmTaskAssignRuleService taskAssignRuleService;
+
+    @Override
+    public PageResult<BpmModelPageItemRespVO> getModelPage(BpmModelPageReqVO pageVO) {
+        ModelQuery modelQuery = repositoryService.createModelQuery();
+        if (StrUtil.isNotBlank(pageVO.getKey())) {
+            modelQuery.modelKey(pageVO.getKey());
+        }
+        if (StrUtil.isNotBlank(pageVO.getName())) {
+            modelQuery.modelNameLike("%" + pageVO.getName() + "%"); // 模糊匹配
+        }
+        if (StrUtil.isNotBlank(pageVO.getCategory())) {
+            modelQuery.modelCategory(pageVO.getCategory());
+        }
+        // 执行查询
+        List<Model> models = modelQuery.orderByCreateTime().desc()
+                .listPage(PageUtils.getStart(pageVO), pageVO.getPageSize());
+
+        // 获得 Form Map
+        Set<Long> formIds = CollectionUtils.convertSet(models, model -> {
+            BpmModelMetaInfoRespDTO metaInfo = JsonUtils.parseObject(model.getMetaInfo(), BpmModelMetaInfoRespDTO.class);
+            return metaInfo != null ? metaInfo.getFormId() : null;
+        });
+        Map<Long, BpmFormDO> formMap = bpmFormService.getFormMap(formIds);
+
+        // 获得 Deployment Map
+        Set<String> deploymentIds = new HashSet<>();
+        models.forEach(model -> CollectionUtils.addIfNotNull(deploymentIds, model.getDeploymentId()));
+        Map<String, Deployment> deploymentMap = processDefinitionService.getDeploymentMap(deploymentIds);
+        // 获得 ProcessDefinition Map
+        List<ProcessDefinition> processDefinitions = processDefinitionService.getProcessDefinitionListByDeploymentIds(deploymentIds);
+        Map<String, ProcessDefinition> processDefinitionMap = convertMap(processDefinitions, ProcessDefinition::getDeploymentId);
+
+        // 拼接结果
+        long modelCount = modelQuery.count();
+        return new PageResult<>(BpmModelConvert.INSTANCE.convertList(models, formMap, deploymentMap, processDefinitionMap), modelCount);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public String createModel(@Valid BpmModelCreateReqVO createReqVO, String bpmnXml) {
+        checkKeyNCName(createReqVO.getKey());
+        // 校验流程标识已经存在
+        Model keyModel = getModelByKey(createReqVO.getKey());
+        if (keyModel != null) {
+            throw exception(MODEL_KEY_EXISTS, createReqVO.getKey());
+        }
+
+        // 创建流程定义
+        Model model = repositoryService.newModel();
+        BpmModelConvert.INSTANCE.copy(model, createReqVO);
+        // 保存流程定义
+        repositoryService.saveModel(model);
+        // 保存 BPMN XML
+        saveModelBpmnXml(model, bpmnXml);
+        return model.getId();
+    }
+
+    private Model getModelByKey(String key) {
+        return repositoryService.createModelQuery().modelKey(key).singleResult();
+    }
+
+    @Override
+    public BpmModelRespVO getModel(String id) {
+        Model model = repositoryService.getModel(id);
+        if (model == null) {
+            return null;
+        }
+        BpmModelRespVO modelRespVO = BpmModelConvert.INSTANCE.convert(model);
+        // 拼接 bpmn XML
+        byte[] bpmnBytes = repositoryService.getModelEditorSource(id);
+        modelRespVO.setBpmnXml(StrUtil.utf8Str(bpmnBytes));
+        return modelRespVO;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class) // 因为进行多个操作，所以开启事务
+    public void updateModel(@Valid BpmModelUpdateReqVO updateReqVO) {
+        // 校验流程模型存在
+        Model model = repositoryService.getModel(updateReqVO.getId());
+        if (model == null) {
+            throw exception(MODEL_NOT_EXISTS);
+        }
+
+        // 修改流程定义
+        BpmModelConvert.INSTANCE.copy(model, updateReqVO);
+        // 更新模型
+        repositoryService.saveModel(model);
+        // 更新 BPMN XML
+        saveModelBpmnXml(model, updateReqVO.getBpmnXml());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class) // 因为进行多个操作，所以开启事务
+    public void deployModel(String id) {
+        // 1.1 校验流程模型存在
+        Model model = repositoryService.getModel(id);
+        if (ObjectUtils.isEmpty(model)) {
+            throw exception(MODEL_NOT_EXISTS);
+        }
+        // 1.2 校验流程图
+        // TODO 芋艿：校验流程图的有效性；例如说，是否有开始的元素，是否有结束的元素；
+        byte[] bpmnBytes = repositoryService.getModelEditorSource(model.getId());
+        if (bpmnBytes == null) {
+            throw exception(MODEL_NOT_EXISTS);
+        }
+        // 1.3 校验表单已配
+        BpmFormDO form = checkFormConfig(model.getMetaInfo());
+        // 1.4 校验任务分配规则已配置
+        taskAssignRuleService.checkTaskAssignRuleAllConfig(id);
+
+        // 1.5 校验模型是否发生修改。如果未修改，则不允许创建
+        BpmProcessDefinitionCreateReqDTO definitionCreateReqDTO = BpmModelConvert.INSTANCE.convert2(model, form).setBpmnBytes(bpmnBytes);
+        if (processDefinitionService.isProcessDefinitionEquals(definitionCreateReqDTO)) { // 流程定义的信息相等
+            ProcessDefinition oldProcessDefinition = processDefinitionService.getProcessDefinitionByDeploymentId(model.getDeploymentId());
+            if (oldProcessDefinition != null && taskAssignRuleService.isTaskAssignRulesEquals(model.getId(), oldProcessDefinition.getId())) {
+                throw exception(MODEL_DEPLOY_FAIL_TASK_INFO_EQUALS);
+            }
+        }
+
+        // 2.1 创建流程定义
+        String definitionId = processDefinitionService.createProcessDefinition(definitionCreateReqDTO);
+
+        // 2.2 将老的流程定义进行挂起。也就是说，只有最新部署的流程定义，才可以发起任务。
+        updateProcessDefinitionSuspended(model.getDeploymentId());
+
+        // 2.3 更新 model 的 deploymentId，进行关联
+        ProcessDefinition definition = processDefinitionService.getProcessDefinition(definitionId);
+        model.setDeploymentId(definition.getDeploymentId());
+        repositoryService.saveModel(model);
+
+        // 2.4 复制任务分配规则
+        taskAssignRuleService.copyTaskAssignRules(id, definition.getId());
+    }
+
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteModel(String id) {
+        // 校验流程模型存在
+        Model model = repositoryService.getModel(id);
+        if (model == null) {
+            throw exception(MODEL_NOT_EXISTS);
+        }
+        // 执行删除
+        repositoryService.deleteModel(id);
+        // 禁用流程实例
+        updateProcessDefinitionSuspended(model.getDeploymentId());
+    }
+
+    @Override
+    public void updateModelState(String id, Integer state) {
+        // 校验流程模型存在
+        Model model = repositoryService.getModel(id);
+        if (model == null) {
+            throw exception(MODEL_NOT_EXISTS);
+        }
+        // 校验流程定义存在
+        ProcessDefinition definition = processDefinitionService.getProcessDefinitionByDeploymentId(model.getDeploymentId());
+        if (definition == null) {
+            throw exception(PROCESS_DEFINITION_NOT_EXISTS);
+        }
+
+        // 更新状态
+        processDefinitionService.updateProcessDefinitionState(definition.getId(), state);
+    }
+
+    @Override
+    public BpmnModel getBpmnModel(String id) {
+        byte[] bpmnBytes = repositoryService.getModelEditorSource(id);
+        if (ArrayUtil.isEmpty(bpmnBytes)) {
+            return null;
+        }
+        BpmnXMLConverter converter = new BpmnXMLConverter();
+        return converter.convertToBpmnModel(new BytesStreamSource(bpmnBytes), true, true);
+    }
+
+    private void checkKeyNCName(String key) {
+        if (!ValidationUtils.isXmlNCName(key)) {
+            throw exception(MODEL_KEY_VALID);
+        }
+    }
+
+    /**
+     * 校验流程表单已配置
+     *
+     * @param metaInfoStr 流程模型 metaInfo 字段
+     * @return 流程表单
+     */
+    private BpmFormDO checkFormConfig(String  metaInfoStr) {
+        BpmModelMetaInfoRespDTO metaInfo = JsonUtils.parseObject(metaInfoStr, BpmModelMetaInfoRespDTO.class);
+        if (metaInfo == null || metaInfo.getFormType() == null) {
+            throw exception(MODEL_DEPLOY_FAIL_FORM_NOT_CONFIG);
+        }
+        // 校验表单存在
+        if (Objects.equals(metaInfo.getFormType(), BpmModelFormTypeEnum.NORMAL.getType())) {
+            BpmFormDO form = bpmFormService.getForm(metaInfo.getFormId());
+            if (form == null) {
+                throw exception(FORM_NOT_EXISTS);
+            }
+            return form;
+        }
+        return null;
+    }
+
+    private void saveModelBpmnXml(Model model, String bpmnXml) {
+        if (StrUtil.isEmpty(bpmnXml)) {
+            return;
+        }
+        repositoryService.addModelEditorSource(model.getId(), StrUtil.utf8Bytes(bpmnXml));
+    }
+
+    /**
+     * 挂起 deploymentId 对应的流程定义。 这里一个deploymentId 只关联一个流程定义
+     * @param deploymentId 流程发布Id.
+     */
+    private void updateProcessDefinitionSuspended(String deploymentId) {
+        if (StrUtil.isEmpty(deploymentId)) {
+            return;
+        }
+        ProcessDefinition oldDefinition = processDefinitionService.getProcessDefinitionByDeploymentId(deploymentId);
+        if (oldDefinition == null) {
+            return;
+        }
+        processDefinitionService.updateProcessDefinitionState(oldDefinition.getId(), SuspensionState.SUSPENDED.getStateCode());
+    }
+
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmProcessDefinitionService.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionListReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionPageItemRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionRespVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmProcessDefinitionExtDO;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmProcessDefinitionCreateReqDTO;
+import org.flowable.bpmn.model.BpmnModel;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.engine.repository.ProcessDefinition;
+
+import javax.validation.Valid;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+/**
+ * Flowable流程定义接口
+ *
+ * @author yunlong.li
+ * @author ZJQ
+ * @author 芋道源码
+ */
+public interface BpmProcessDefinitionService {
+
+    /**
+     * 获得流程定义分页
+     *
+     * @param pageReqVO 分页入参
+     * @return 流程定义 Page
+     */
+    PageResult<BpmProcessDefinitionPageItemRespVO> getProcessDefinitionPage(BpmProcessDefinitionPageReqVO pageReqVO);
+
+    /**
+     * 获得流程定义列表
+     *
+     * @param listReqVO 列表入参
+     * @return 流程定义列表
+     */
+    List<BpmProcessDefinitionRespVO> getProcessDefinitionList(BpmProcessDefinitionListReqVO listReqVO);
+
+    /**
+     * 创建流程定义
+     *
+     * @param createReqDTO 创建信息
+     * @return 流程编号
+     */
+    String createProcessDefinition(@Valid BpmProcessDefinitionCreateReqDTO createReqDTO);
+
+    /**
+     * 更新流程定义状态
+     *
+     * @param id 流程定义的编号
+     * @param state 状态
+     */
+    void updateProcessDefinitionState(String id, Integer state);
+
+    /**
+     * 获得流程定义对应的 BPMN XML
+     *
+     * @param id 流程定义编号
+     * @return BPMN XML
+     */
+    String getProcessDefinitionBpmnXML(String id);
+
+    /**
+     * 获得需要创建的流程定义，是否和当前激活的流程定义相等
+     *
+     * @param createReqDTO 创建信息
+     * @return 是否相等
+     */
+    boolean isProcessDefinitionEquals(@Valid BpmProcessDefinitionCreateReqDTO createReqDTO);
+
+    /**
+     * 获得编号对应的 BpmProcessDefinitionExtDO
+     *
+     * @param id 编号
+     * @return 流程定义拓展
+     */
+    BpmProcessDefinitionExtDO getProcessDefinitionExt(String id);
+
+    /**
+     * 获得编号对应的 ProcessDefinition
+     *
+     * @param id 编号
+     * @return 流程定义
+     */
+    ProcessDefinition getProcessDefinition(String id);
+
+    /**
+     * 获得编号对应的 ProcessDefinition
+     *
+     * 相比 {@link #getProcessDefinition(String)} 方法，category 的取值是正确
+     *
+     * @param id 编号
+     * @return 流程定义
+     */
+    ProcessDefinition getProcessDefinition2(String id);
+
+    /**
+     * 获得 deploymentId 对应的 ProcessDefinition
+     *
+     * @param deploymentId 部署编号
+     * @return 流程定义
+     */
+    ProcessDefinition getProcessDefinitionByDeploymentId(String deploymentId);
+
+    /**
+     * 获得 deploymentIds 对应的 ProcessDefinition 数组
+     *
+     * @param deploymentIds 部署编号的数组
+     * @return 流程定义的数组
+     */
+    List<ProcessDefinition> getProcessDefinitionListByDeploymentIds(Set<String> deploymentIds);
+
+    /**
+     * 获得流程定义标识对应的激活的流程定义
+     *
+     * @param key 流程定义的标识
+     * @return 流程定义
+     */
+    ProcessDefinition getActiveProcessDefinition(String key);
+
+    /**
+     * 获得 ids 对应的 Deployment Map
+     *
+     * @param ids 部署编号的数组
+     * @return 流程部署 Map
+     */
+    default Map<String, Deployment> getDeploymentMap(Set<String> ids) {
+        return CollectionUtils.convertMap(getDeployments(ids), Deployment::getId);
+    }
+
+    /**
+     * 获得 ids 对应的 Deployment 数组
+     *
+     * @param ids 部署编号的数组
+     * @return 流程部署的数组
+     */
+    List<Deployment> getDeployments(Set<String> ids);
+
+    /**
+     * 获得 id 对应的 Deployment
+     *
+     * @param id 部署编号
+     * @return 流程部署
+     */
+    Deployment getDeployment(String id);
+
+    /**
+     * 获得 Bpmn 模型
+     *
+     * @param processDefinitionId 流程定义的编号
+     * @return Bpmn 模型
+     */
+    BpmnModel getBpmnModel(String processDefinitionId);
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmProcessDefinitionServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+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.PageResult;
+import cn.iocoder.yudao.framework.common.util.object.PageUtils;
+import cn.iocoder.yudao.framework.flowable.core.util.FlowableUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionListReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionPageItemRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.process.BpmProcessDefinitionRespVO;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmProcessDefinitionConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmProcessDefinitionExtDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.definition.BpmProcessDefinitionExtMapper;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmProcessDefinitionCreateReqDTO;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.bpmn.converter.BpmnXMLConverter;
+import org.flowable.bpmn.model.BpmnModel;
+import org.flowable.common.engine.impl.db.SuspensionState;
+import org.flowable.common.engine.impl.util.io.BytesStreamSource;
+import org.flowable.engine.RepositoryService;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.flowable.engine.repository.ProcessDefinitionQuery;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+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.common.util.collection.CollectionUtils.convertMap;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.PROCESS_DEFINITION_KEY_NOT_MATCH;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.PROCESS_DEFINITION_NAME_NOT_MATCH;
+import static java.util.Collections.emptyList;
+
+/**
+ * 流程定义实现
+ * 主要进行 Flowable {@link ProcessDefinition} 和 {@link Deployment} 的维护
+ *
+ * @author yunlongn
+ * @author ZJQ
+ * @author 芋道源码
+ */
+@Service
+@Validated
+@Slf4j
+public class BpmProcessDefinitionServiceImpl implements BpmProcessDefinitionService {
+
+    private static final String BPMN_FILE_SUFFIX = ".bpmn";
+
+    @Resource
+    private RepositoryService repositoryService;
+
+    @Resource
+    private BpmProcessDefinitionExtMapper processDefinitionMapper;
+
+    @Resource
+    private BpmFormService formService;
+
+    @Override
+    public ProcessDefinition getProcessDefinition(String id) {
+        return repositoryService.getProcessDefinition(id);
+    }
+
+    @Override
+    public ProcessDefinition getProcessDefinition2(String id) {
+        return repositoryService.createProcessDefinitionQuery().processDefinitionId(id).singleResult();
+    }
+
+    @Override
+    public ProcessDefinition getProcessDefinitionByDeploymentId(String deploymentId) {
+        if (StrUtil.isEmpty(deploymentId)) {
+            return null;
+        }
+        return repositoryService.createProcessDefinitionQuery().deploymentId(deploymentId).singleResult();
+    }
+
+    @Override
+    public List<ProcessDefinition> getProcessDefinitionListByDeploymentIds(Set<String> deploymentIds) {
+        if (CollUtil.isEmpty(deploymentIds)) {
+            return emptyList();
+        }
+        return repositoryService.createProcessDefinitionQuery().deploymentIds(deploymentIds).list();
+    }
+
+    @Override
+    public ProcessDefinition getActiveProcessDefinition(String key) {
+        return repositoryService.createProcessDefinitionQuery().processDefinitionKey(key).active().singleResult();
+    }
+
+    @Override
+    public List<Deployment> getDeployments(Set<String> ids) {
+        if (CollUtil.isEmpty(ids)) {
+            return emptyList();
+        }
+        List<Deployment> list = new ArrayList<>(ids.size());
+        for (String id : ids) {
+            addIfNotNull(list, getDeployment(id));
+        }
+        return list;
+    }
+
+    @Override
+    public Deployment getDeployment(String id) {
+        if (StrUtil.isEmpty(id)) {
+            return null;
+        }
+        return repositoryService.createDeploymentQuery().deploymentId(id).singleResult();
+    }
+
+    @Override
+    public BpmnModel getBpmnModel(String processDefinitionId) {
+        return repositoryService.getBpmnModel(processDefinitionId);
+    }
+
+    @Override
+    public String createProcessDefinition(@Valid BpmProcessDefinitionCreateReqDTO createReqDTO) {
+        // 创建 Deployment 部署
+        Deployment deploy = repositoryService.createDeployment()
+                .key(createReqDTO.getKey()).name(createReqDTO.getName()).category(createReqDTO.getCategory())
+                .addBytes(createReqDTO.getKey() + BPMN_FILE_SUFFIX, createReqDTO.getBpmnBytes())
+                .deploy();
+
+        // 设置 ProcessDefinition 的 category 分类
+        ProcessDefinition definition = repositoryService.createProcessDefinitionQuery()
+                .deploymentId(deploy.getId()).singleResult();
+        repositoryService.setProcessDefinitionCategory(definition.getId(), createReqDTO.getCategory());
+        // 注意 1，ProcessDefinition 的 key 和 name 是通过 BPMN 中的 <bpmn2:process /> 的 id 和 name 决定
+        // 注意 2，目前该项目的设计上，需要保证 Model、Deployment、ProcessDefinition 使用相同的 key，保证关联性。
+        //          否则，会导致 ProcessDefinition 的分页无法查询到。
+        if (!Objects.equals(definition.getKey(), createReqDTO.getKey())) {
+            throw exception(PROCESS_DEFINITION_KEY_NOT_MATCH, createReqDTO.getKey(), definition.getKey());
+        }
+        if (!Objects.equals(definition.getName(), createReqDTO.getName())) {
+            throw exception(PROCESS_DEFINITION_NAME_NOT_MATCH, createReqDTO.getName(), definition.getName());
+        }
+
+        // 插入拓展表
+        BpmProcessDefinitionExtDO definitionDO = BpmProcessDefinitionConvert.INSTANCE.convert2(createReqDTO)
+                .setProcessDefinitionId(definition.getId());
+        processDefinitionMapper.insert(definitionDO);
+        return definition.getId();
+    }
+
+    @Override
+    public void updateProcessDefinitionState(String id, Integer state) {
+        // 激活
+        if (Objects.equals(SuspensionState.ACTIVE.getStateCode(), state)) {
+            repositoryService.activateProcessDefinitionById(id, false, null);
+            return;
+        }
+        // 挂起
+        if (Objects.equals(SuspensionState.SUSPENDED.getStateCode(), state)) {
+            // suspendProcessInstances = false，进行中的任务，不进行挂起。
+            // 原因：只要新的流程不允许发起即可，老流程继续可以执行。
+            repositoryService.suspendProcessDefinitionById(id, false, null);
+            return;
+        }
+        log.error("[updateProcessDefinitionState][流程定义({}) 修改未知状态({})]", id, state);
+    }
+
+    @Override
+    public String getProcessDefinitionBpmnXML(String id) {
+        BpmnModel bpmnModel = repositoryService.getBpmnModel(id);
+        if (bpmnModel == null) {
+            return null;
+        }
+        BpmnXMLConverter converter = new BpmnXMLConverter();
+        return StrUtil.utf8Str(converter.convertToXML(bpmnModel));
+    }
+
+    @Override
+    public boolean isProcessDefinitionEquals(@Valid BpmProcessDefinitionCreateReqDTO createReqDTO) {
+        // 校验 name、description 是否更新
+        ProcessDefinition oldProcessDefinition = getActiveProcessDefinition(createReqDTO.getKey());
+        if (oldProcessDefinition == null) {
+            return false;
+        }
+        BpmProcessDefinitionExtDO oldProcessDefinitionExt = getProcessDefinitionExt(oldProcessDefinition.getId());
+        if (!StrUtil.equals(createReqDTO.getName(), oldProcessDefinition.getName())
+                || !StrUtil.equals(createReqDTO.getDescription(), oldProcessDefinitionExt.getDescription())
+                || !StrUtil.equals(createReqDTO.getCategory(), oldProcessDefinition.getCategory())) {
+            return false;
+        }
+        // 校验 form 信息是否更新
+        if (!ObjectUtil.equal(createReqDTO.getFormType(), oldProcessDefinitionExt.getFormType())
+                || !ObjectUtil.equal(createReqDTO.getFormId(), oldProcessDefinitionExt.getFormId())
+                || !ObjectUtil.equal(createReqDTO.getFormConf(), oldProcessDefinitionExt.getFormConf())
+                || !ObjectUtil.equal(createReqDTO.getFormFields(), oldProcessDefinitionExt.getFormFields())
+                || !ObjectUtil.equal(createReqDTO.getFormCustomCreatePath(), oldProcessDefinitionExt.getFormCustomCreatePath())
+                || !ObjectUtil.equal(createReqDTO.getFormCustomViewPath(), oldProcessDefinitionExt.getFormCustomViewPath())) {
+            return false;
+        }
+        // 校验 BPMN XML 信息
+        BpmnModel newModel = buildBpmnModel(createReqDTO.getBpmnBytes());
+        BpmnModel oldModel = getBpmnModel(oldProcessDefinition.getId());
+        // TODO  貌似 flowable 不修改这个也不同。需要看看。 sourceSystemId 不同
+        if (FlowableUtils.equals(oldModel, newModel)) {
+            return false;
+        }
+        // 最终发现都一致，则返回 true
+        return true;
+    }
+
+    /**
+     * 构建对应的 BPMN Model
+     *
+     * @param bpmnBytes 原始的 BPMN XML 字节数组
+     * @return BPMN Model
+     */
+    private  BpmnModel buildBpmnModel(byte[] bpmnBytes) {
+        // 转换成 BpmnModel 对象
+        BpmnXMLConverter converter = new BpmnXMLConverter();
+        return converter.convertToBpmnModel(new BytesStreamSource(bpmnBytes), true, true);
+    }
+
+    @Override
+    public BpmProcessDefinitionExtDO getProcessDefinitionExt(String id) {
+        return processDefinitionMapper.selectByProcessDefinitionId(id);
+    }
+
+    @Override
+    public List<BpmProcessDefinitionRespVO> getProcessDefinitionList(BpmProcessDefinitionListReqVO listReqVO) {
+        // 拼接查询条件
+        ProcessDefinitionQuery definitionQuery = repositoryService.createProcessDefinitionQuery();
+        if (Objects.equals(SuspensionState.SUSPENDED.getStateCode(), listReqVO.getSuspensionState())) {
+            definitionQuery.suspended();
+        } else if (Objects.equals(SuspensionState.ACTIVE.getStateCode(), listReqVO.getSuspensionState())) {
+            definitionQuery.active();
+        }
+        // 执行查询
+        List<ProcessDefinition> processDefinitions = definitionQuery.list();
+        if (CollUtil.isEmpty(processDefinitions)) {
+            return Collections.emptyList();
+        }
+
+        // 获得 BpmProcessDefinitionDO Map
+        List<BpmProcessDefinitionExtDO> processDefinitionDOs = processDefinitionMapper.selectListByProcessDefinitionIds(
+                convertList(processDefinitions, ProcessDefinition::getId));
+        Map<String, BpmProcessDefinitionExtDO> processDefinitionDOMap = convertMap(processDefinitionDOs,
+                BpmProcessDefinitionExtDO::getProcessDefinitionId);
+        // 执行查询，并返回
+        return BpmProcessDefinitionConvert.INSTANCE.convertList3(processDefinitions, processDefinitionDOMap);
+    }
+
+    @Override
+    public PageResult<BpmProcessDefinitionPageItemRespVO> getProcessDefinitionPage(BpmProcessDefinitionPageReqVO pageVO) {
+        ProcessDefinitionQuery definitionQuery = repositoryService.createProcessDefinitionQuery();
+        if (StrUtil.isNotBlank(pageVO.getKey())) {
+            definitionQuery.processDefinitionKey(pageVO.getKey());
+        }
+
+        // 执行查询
+        List<ProcessDefinition> processDefinitions = definitionQuery.orderByProcessDefinitionVersion().desc()
+                .listPage(PageUtils.getStart(pageVO), pageVO.getPageSize());
+
+        if (CollUtil.isEmpty(processDefinitions)) {
+            return new PageResult<>(emptyList(), definitionQuery.count());
+        }
+        // 获得 Deployment Map
+        Set<String> deploymentIds = new HashSet<>();
+        processDefinitions.forEach(definition -> addIfNotNull(deploymentIds, definition.getDeploymentId()));
+        Map<String, Deployment> deploymentMap = getDeploymentMap(deploymentIds);
+
+        // 获得 BpmProcessDefinitionDO Map
+        List<BpmProcessDefinitionExtDO> processDefinitionDOs = processDefinitionMapper.selectListByProcessDefinitionIds(
+                convertList(processDefinitions, ProcessDefinition::getId));
+        Map<String, BpmProcessDefinitionExtDO> processDefinitionDOMap = convertMap(processDefinitionDOs,
+                BpmProcessDefinitionExtDO::getProcessDefinitionId);
+
+        // 获得 Form Map
+        Set<Long> formIds = convertSet(processDefinitionDOs, BpmProcessDefinitionExtDO::getFormId);
+        Map<Long, BpmFormDO> formMap = formService.getFormMap(formIds);
+
+        // 拼接结果
+        long definitionCount = definitionQuery.count();
+        return new PageResult<>(BpmProcessDefinitionConvert.INSTANCE.convertList(processDefinitions, deploymentMap,
+                processDefinitionDOMap, formMap), definitionCount);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmTaskAssignRuleService.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmTaskAssignRuleDO;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.lang.Nullable;
+
+import javax.validation.Valid;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * BPM 任务分配规则 Service 接口
+ *
+ * @author 芋道源码
+ */
+public interface BpmTaskAssignRuleService {
+
+    /**
+     * 获得流程定义的任务分配规则数组
+     *
+     * @param processDefinitionId 流程定义的编号
+     * @param taskDefinitionKey 流程任务定义的 Key。允许空
+     * @return 任务规则数组
+     */
+    List<BpmTaskAssignRuleDO> getTaskAssignRuleListByProcessDefinitionId(String processDefinitionId,
+                                                                         @Nullable String taskDefinitionKey);
+
+    /**
+     * 获得流程模型的任务规则数组
+     *
+     * @param modelId 流程模型的编号
+     * @return 任务规则数组
+     */
+    List<BpmTaskAssignRuleDO> getTaskAssignRuleListByModelId(String modelId);
+
+    /**
+     * 获得流程定义的任务分配规则数组
+     *
+     * @param modelId 流程模型的编号
+     * @param processDefinitionId 流程定义的编号
+     * @return 任务规则数组
+     */
+    List<BpmTaskAssignRuleRespVO> getTaskAssignRuleList(String modelId, String processDefinitionId);
+
+    /**
+     * 创建任务分配规则
+     *
+     * @param reqVO 创建信息
+     * @return 规则编号
+     */
+    Long createTaskAssignRule(@Valid BpmTaskAssignRuleCreateReqVO reqVO);
+
+    /**
+     * 更新任务分配规则
+     *
+     * @param reqVO 创建信息
+     */
+    void updateTaskAssignRule(@Valid BpmTaskAssignRuleUpdateReqVO reqVO);
+
+    /**
+     * 判断指定流程模型和流程定义的分配规则是否相等
+     *
+     * @param modelId 流程模型编号
+     * @param processDefinitionId 流程定义编号
+     * @return 是否相等
+     */
+    boolean isTaskAssignRulesEquals(String modelId, String processDefinitionId);
+
+    /**
+     * 将流程流程模型的任务分配规则，复制一份给流程定义
+     * 目的：每次流程模型部署时，都会生成一个新的流程定义，此时考虑到每次部署的流程不可变性，所以需要复制一份给该流程定义
+     *
+     * @param fromModelId 流程模型编号
+     * @param toProcessDefinitionId 流程定义编号
+     */
+    void copyTaskAssignRules(String fromModelId, String toProcessDefinitionId);
+
+    /**
+     * 校验流程模型的任务分配规则全部都配置了
+     * 目的：如果有规则未配置，会导致流程任务找不到负责人，进而流程无法进行下去！
+     *
+     * @param id 流程模型编号
+     */
+    void checkTaskAssignRuleAllConfig(String id);
+
+    /**
+     * 计算当前执行任务的处理人
+     *
+     * @param execution 执行任务
+     * @return 处理人的编号数组
+     */
+    Set<Long> calculateTaskCandidateUsers(DelegateExecution execution);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmTaskAssignRuleServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
+import cn.iocoder.yudao.framework.datapermission.core.annotation.DataPermission;
+import cn.iocoder.yudao.framework.flowable.core.util.FlowableUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleRespVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.rule.BpmTaskAssignRuleUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmTaskAssignRuleConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmTaskAssignRuleDO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.definition.BpmTaskAssignRuleMapper;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskAssignRuleTypeEnum;
+import cn.iocoder.yudao.module.bpm.enums.DictTypeConstants;
+import cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.BpmTaskAssignScript;
+import cn.iocoder.yudao.module.system.api.dept.DeptApi;
+import cn.iocoder.yudao.module.system.api.dept.PostApi;
+import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
+import cn.iocoder.yudao.module.system.api.dict.DictDataApi;
+import cn.iocoder.yudao.module.system.api.permission.PermissionApi;
+import cn.iocoder.yudao.module.system.api.permission.RoleApi;
+import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
+import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
+import com.google.common.annotations.VisibleForTesting;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.bpmn.model.BpmnModel;
+import org.flowable.bpmn.model.UserTask;
+import org.flowable.common.engine.api.FlowableException;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+import java.util.*;
+
+import static cn.hutool.core.text.CharSequenceUtil.format;
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap;
+import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
+import static cn.iocoder.yudao.framework.common.util.json.JsonUtils.toJsonString;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.*;
+
+/**
+ * BPM 任务分配规则 Service 实现类
+ */
+@Service
+@Validated
+@Slf4j
+public class BpmTaskAssignRuleServiceImpl implements BpmTaskAssignRuleService {
+
+    @Resource
+    private BpmTaskAssignRuleMapper taskRuleMapper;
+    @Resource
+    @Lazy // 解决循环依赖
+    private BpmModelService modelService;
+    @Resource
+    @Lazy // 解决循环依赖
+    private BpmProcessDefinitionService processDefinitionService;
+    @Resource
+    private BpmUserGroupService userGroupService;
+    @Resource
+    private RoleApi roleApi;
+    @Resource
+    private DeptApi deptApi;
+    @Resource
+    private PostApi postApi;
+    @Resource
+    private AdminUserApi adminUserApi;
+    @Resource
+    private DictDataApi dictDataApi;
+    @Resource
+    private PermissionApi permissionApi;
+    /**
+     * 任务分配脚本
+     */
+    private Map<Long, BpmTaskAssignScript> scriptMap = Collections.emptyMap();
+
+    @Resource
+    public void setScripts(List<BpmTaskAssignScript> scripts) {
+        this.scriptMap = convertMap(scripts, script -> script.getEnum().getId());
+    }
+
+    @Override
+    public List<BpmTaskAssignRuleDO> getTaskAssignRuleListByProcessDefinitionId(String processDefinitionId,
+        String taskDefinitionKey) {
+        return taskRuleMapper.selectListByProcessDefinitionId(processDefinitionId, taskDefinitionKey);
+    }
+
+    @Override
+    public List<BpmTaskAssignRuleDO> getTaskAssignRuleListByModelId(String modelId) {
+        return taskRuleMapper.selectListByModelId(modelId);
+    }
+
+    @Override
+    public List<BpmTaskAssignRuleRespVO> getTaskAssignRuleList(String modelId, String processDefinitionId) {
+        // 获得规则
+        List<BpmTaskAssignRuleDO> rules = Collections.emptyList();
+        BpmnModel model = null;
+        if (StrUtil.isNotEmpty(modelId)) {
+            rules = getTaskAssignRuleListByModelId(modelId);
+            model = modelService.getBpmnModel(modelId);
+        } else if (StrUtil.isNotEmpty(processDefinitionId)) {
+            rules = getTaskAssignRuleListByProcessDefinitionId(processDefinitionId, null);
+            model = processDefinitionService.getBpmnModel(processDefinitionId);
+        }
+        if (model == null) {
+            return Collections.emptyList();
+        }
+        // 获得用户任务，只有用户任务才可以设置分配规则
+        List<UserTask> userTasks = FlowableUtils.getBpmnModelElements(model, UserTask.class);
+        if (CollUtil.isEmpty(userTasks)) {
+            return Collections.emptyList();
+        }
+        // 转换数据
+        return BpmTaskAssignRuleConvert.INSTANCE.convertList(userTasks, rules);
+    }
+
+    @Override
+    public Long createTaskAssignRule(@Valid BpmTaskAssignRuleCreateReqVO reqVO) {
+        // 校验参数
+        validTaskAssignRuleOptions(reqVO.getType(), reqVO.getOptions());
+        // 校验是否已经配置
+        BpmTaskAssignRuleDO existRule =
+            taskRuleMapper.selectListByModelIdAndTaskDefinitionKey(reqVO.getModelId(), reqVO.getTaskDefinitionKey());
+        if (existRule != null) {
+            throw exception(TASK_ASSIGN_RULE_EXISTS, reqVO.getModelId(), reqVO.getTaskDefinitionKey());
+        }
+
+        // 存储
+        BpmTaskAssignRuleDO rule = BpmTaskAssignRuleConvert.INSTANCE.convert(reqVO)
+            .setProcessDefinitionId(BpmTaskAssignRuleDO.PROCESS_DEFINITION_ID_NULL); // 只有流程模型，才允许新建
+        taskRuleMapper.insert(rule);
+        return rule.getId();
+    }
+
+    @Override
+    public void updateTaskAssignRule(@Valid BpmTaskAssignRuleUpdateReqVO reqVO) {
+        // 校验参数
+        validTaskAssignRuleOptions(reqVO.getType(), reqVO.getOptions());
+        // 校验是否存在
+        BpmTaskAssignRuleDO existRule = taskRuleMapper.selectById(reqVO.getId());
+        if (existRule == null) {
+            throw exception(TASK_ASSIGN_RULE_NOT_EXISTS);
+        }
+        // 只允许修改流程模型的规则
+        if (!Objects.equals(BpmTaskAssignRuleDO.PROCESS_DEFINITION_ID_NULL, existRule.getProcessDefinitionId())) {
+            throw exception(TASK_UPDATE_FAIL_NOT_MODEL);
+        }
+
+        // 执行更新
+        taskRuleMapper.updateById(BpmTaskAssignRuleConvert.INSTANCE.convert(reqVO));
+    }
+
+    @Override
+    public boolean isTaskAssignRulesEquals(String modelId, String processDefinitionId) {
+        // 调用 VO 接口的原因是，过滤掉流程模型不需要的规则，保持和 copyTaskAssignRules 方法的一致性
+        List<BpmTaskAssignRuleRespVO> modelRules = getTaskAssignRuleList(modelId, null);
+        List<BpmTaskAssignRuleRespVO> processInstanceRules = getTaskAssignRuleList(null, processDefinitionId);
+        if (modelRules.size() != processInstanceRules.size()) {
+            return false;
+        }
+
+        // 遍历，匹配对应的规则
+        Map<String, BpmTaskAssignRuleRespVO> processInstanceRuleMap =
+            CollectionUtils.convertMap(processInstanceRules, BpmTaskAssignRuleRespVO::getTaskDefinitionKey);
+        for (BpmTaskAssignRuleRespVO modelRule : modelRules) {
+            BpmTaskAssignRuleRespVO processInstanceRule = processInstanceRuleMap.get(modelRule.getTaskDefinitionKey());
+            if (processInstanceRule == null) {
+                return false;
+            }
+            if (!ObjectUtil.equals(modelRule.getType(), processInstanceRule.getType()) || !ObjectUtil.equal(
+                modelRule.getOptions(), processInstanceRule.getOptions())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void copyTaskAssignRules(String fromModelId, String toProcessDefinitionId) {
+        List<BpmTaskAssignRuleRespVO> rules = getTaskAssignRuleList(fromModelId, null);
+        if (CollUtil.isEmpty(rules)) {
+            return;
+        }
+        // 开始复制
+        List<BpmTaskAssignRuleDO> newRules = BpmTaskAssignRuleConvert.INSTANCE.convertList2(rules);
+        newRules.forEach(rule -> rule.setProcessDefinitionId(toProcessDefinitionId).setId(null).setCreateTime(null)
+            .setUpdateTime(null));
+        taskRuleMapper.insertBatch(newRules);
+    }
+
+    @Override
+    public void checkTaskAssignRuleAllConfig(String id) {
+        // 一个用户任务都没配置，所以无需配置规则
+        List<BpmTaskAssignRuleRespVO> taskAssignRules = getTaskAssignRuleList(id, null);
+        if (CollUtil.isEmpty(taskAssignRules)) {
+            return;
+        }
+        // 校验未配置规则的任务
+        taskAssignRules.forEach(rule -> {
+            if (CollUtil.isEmpty(rule.getOptions())) {
+                throw exception(MODEL_DEPLOY_FAIL_TASK_ASSIGN_RULE_NOT_CONFIG, rule.getTaskDefinitionName());
+            }
+        });
+    }
+
+    private void validTaskAssignRuleOptions(Integer type, Set<Long> options) {
+        if (Objects.equals(type, BpmTaskAssignRuleTypeEnum.ROLE.getType())) {
+            roleApi.validRoles(options);
+        } else if (ObjectUtils.equalsAny(type, BpmTaskAssignRuleTypeEnum.DEPT_MEMBER.getType(),
+            BpmTaskAssignRuleTypeEnum.DEPT_LEADER.getType())) {
+            deptApi.validDepts(options);
+        } else if (Objects.equals(type, BpmTaskAssignRuleTypeEnum.POST.getType())) {
+            postApi.validPosts(options);
+        } else if (Objects.equals(type, BpmTaskAssignRuleTypeEnum.USER.getType())) {
+            adminUserApi.validUsers(options);
+        } else if (Objects.equals(type, BpmTaskAssignRuleTypeEnum.USER_GROUP.getType())) {
+            userGroupService.validUserGroups(options);
+        } else if (Objects.equals(type, BpmTaskAssignRuleTypeEnum.SCRIPT.getType())) {
+            dictDataApi.validDictDatas(DictTypeConstants.TASK_ASSIGN_SCRIPT,
+                CollectionUtils.convertSet(options, String::valueOf));
+        } else {
+            throw new IllegalArgumentException(format("未知的规则类型({})", type));
+        }
+    }
+
+    @Override
+    @DataPermission(enable = false) // 忽略数据权限，不然分配会存在问题
+    public Set<Long> calculateTaskCandidateUsers(DelegateExecution execution) {
+        BpmTaskAssignRuleDO rule = getTaskRule(execution);
+        return calculateTaskCandidateUsers(execution, rule);
+    }
+
+    @VisibleForTesting
+    BpmTaskAssignRuleDO getTaskRule(DelegateExecution execution) {
+        List<BpmTaskAssignRuleDO> taskRules = getTaskAssignRuleListByProcessDefinitionId(
+                execution.getProcessDefinitionId(), execution.getCurrentActivityId());
+        if (CollUtil.isEmpty(taskRules)) {
+            throw new FlowableException(format("流程任务({}/{}/{}) 找不到符合的任务规则",
+                    execution.getId(), execution.getProcessDefinitionId(), execution.getCurrentActivityId()));
+        }
+        if (taskRules.size() > 1) {
+            throw new FlowableException(format("流程任务({}/{}/{}) 找到过多任务规则({})",
+                    execution.getId(), execution.getProcessDefinitionId(), execution.getCurrentActivityId()));
+        }
+        return taskRules.get(0);
+    }
+
+    @VisibleForTesting
+    Set<Long> calculateTaskCandidateUsers(DelegateExecution execution, BpmTaskAssignRuleDO rule) {
+        Set<Long> assigneeUserIds = null;
+        if (Objects.equals(BpmTaskAssignRuleTypeEnum.ROLE.getType(), rule.getType())) {
+            assigneeUserIds = calculateTaskCandidateUsersByRole(rule);
+        } else if (Objects.equals(BpmTaskAssignRuleTypeEnum.DEPT_MEMBER.getType(), rule.getType())) {
+            assigneeUserIds = calculateTaskCandidateUsersByDeptMember(rule);
+        } else if (Objects.equals(BpmTaskAssignRuleTypeEnum.DEPT_LEADER.getType(), rule.getType())) {
+            assigneeUserIds = calculateTaskCandidateUsersByDeptLeader(rule);
+        } else if (Objects.equals(BpmTaskAssignRuleTypeEnum.POST.getType(), rule.getType())) {
+            assigneeUserIds = calculateTaskCandidateUsersByPost(rule);
+        } else if (Objects.equals(BpmTaskAssignRuleTypeEnum.USER.getType(), rule.getType())) {
+            assigneeUserIds = calculateTaskCandidateUsersByUser(rule);
+        } else if (Objects.equals(BpmTaskAssignRuleTypeEnum.USER_GROUP.getType(), rule.getType())) {
+            assigneeUserIds = calculateTaskCandidateUsersByUserGroup(rule);
+        } else if (Objects.equals(BpmTaskAssignRuleTypeEnum.SCRIPT.getType(), rule.getType())) {
+            assigneeUserIds = calculateTaskCandidateUsersByScript(execution, rule);
+        }
+
+        // 移除被禁用的用户
+        removeDisableUsers(assigneeUserIds);
+        // 如果候选人为空，抛出异常
+        if (CollUtil.isEmpty(assigneeUserIds)) {
+            log.error("[calculateTaskCandidateUsers][流程任务({}/{}/{}) 任务规则({}) 找不到候选人]", execution.getId(),
+                    execution.getProcessDefinitionId(), execution.getCurrentActivityId(), toJsonString(rule));
+            throw exception(TASK_CREATE_FAIL_NO_CANDIDATE_USER);
+        }
+        return assigneeUserIds;
+    }
+
+    private Set<Long> calculateTaskCandidateUsersByRole(BpmTaskAssignRuleDO rule) {
+        return permissionApi.getUserRoleIdListByRoleIds(rule.getOptions()).getCheckedData();
+    }
+
+    private Set<Long> calculateTaskCandidateUsersByDeptMember(BpmTaskAssignRuleDO rule) {
+        List<AdminUserRespDTO> users = adminUserApi.getUsersByDeptIds(rule.getOptions()).getCheckedData();
+        return convertSet(users, AdminUserRespDTO::getId);
+    }
+
+    private Set<Long> calculateTaskCandidateUsersByDeptLeader(BpmTaskAssignRuleDO rule) {
+        List<DeptRespDTO> depts = deptApi.getDepts(rule.getOptions()).getCheckedData();
+        return convertSet(depts, DeptRespDTO::getLeaderUserId);
+    }
+
+    private Set<Long> calculateTaskCandidateUsersByPost(BpmTaskAssignRuleDO rule) {
+        List<AdminUserRespDTO> users = adminUserApi.getUsersByPostIds(rule.getOptions()).getCheckedData();
+        return convertSet(users, AdminUserRespDTO::getId);
+    }
+
+    private Set<Long> calculateTaskCandidateUsersByUser(BpmTaskAssignRuleDO rule) {
+        return rule.getOptions();
+    }
+
+    private Set<Long> calculateTaskCandidateUsersByUserGroup(BpmTaskAssignRuleDO rule) {
+        List<BpmUserGroupDO> userGroups = userGroupService.getUserGroupList(rule.getOptions());
+        Set<Long> userIds = new HashSet<>();
+        userGroups.forEach(group -> userIds.addAll(group.getMemberUserIds()));
+        return userIds;
+    }
+
+    private Set<Long> calculateTaskCandidateUsersByScript(DelegateExecution execution, BpmTaskAssignRuleDO rule) {
+        // 获得对应的脚本
+        List<BpmTaskAssignScript> scripts = new ArrayList<>(rule.getOptions().size());
+        rule.getOptions().forEach(id -> {
+            BpmTaskAssignScript script = scriptMap.get(id);
+            if (script == null) {
+                throw exception(TASK_ASSIGN_SCRIPT_NOT_EXISTS, id);
+            }
+            scripts.add(script);
+        });
+        // 逐个计算任务
+        Set<Long> userIds = new HashSet<>();
+        scripts.forEach(script -> CollUtil.addAll(userIds, script.calculateTaskCandidateUsers(execution)));
+        return userIds;
+    }
+
+    @VisibleForTesting
+    void removeDisableUsers(Set<Long> assigneeUserIds) {
+        if (CollUtil.isEmpty(assigneeUserIds)) {
+            return;
+        }
+        Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(assigneeUserIds);
+        assigneeUserIds.removeIf(id -> {
+            AdminUserRespDTO user = userMap.get(id);
+            return user == null || !CommonStatusEnum.ENABLE.getStatus().equals(user.getStatus());
+        });
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmUserGroupService.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import java.util.*;
+import javax.validation.*;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+
+/**
+ * 用户组 Service 接口
+ *
+ * @author 芋道源码
+ */
+public interface BpmUserGroupService {
+
+    /**
+     * 创建用户组
+     *
+     * @param createReqVO 创建信息
+     * @return 编号
+     */
+    Long createUserGroup(@Valid BpmUserGroupCreateReqVO createReqVO);
+
+    /**
+     * 更新用户组
+     *
+     * @param updateReqVO 更新信息
+     */
+    void updateUserGroup(@Valid BpmUserGroupUpdateReqVO updateReqVO);
+
+    /**
+     * 删除用户组
+     *
+     * @param id 编号
+     */
+    void deleteUserGroup(Long id);
+
+    /**
+     * 获得用户组
+     *
+     * @param id 编号
+     * @return 用户组
+     */
+    BpmUserGroupDO getUserGroup(Long id);
+
+    /**
+     * 获得用户组列表
+     *
+     * @param ids 编号
+     * @return 用户组列表
+     */
+    List<BpmUserGroupDO> getUserGroupList(Collection<Long> ids);
+
+    /**
+     * 获得指定状态的用户组列表
+     *
+     * @param status 状态
+     * @return 用户组列表
+     */
+    List<BpmUserGroupDO> getUserGroupListByStatus(Integer status);
+
+    /**
+     * 获得用户组分页
+     *
+     * @param pageReqVO 分页查询
+     * @return 用户组分页
+     */
+    PageResult<BpmUserGroupDO> getUserGroupPage(BpmUserGroupPageReqVO pageReqVO);
+
+    /**
+     * 校验用户组们是否有效。如下情况，视为无效：
+     * 1. 用户组编号不存在
+     * 2. 用户组被禁用
+     *
+     * @param ids 用户组编号数组
+     */
+    void validUserGroups(Set<Long> ids);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/BpmUserGroupServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.convert.definition.BpmUserGroupConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.definition.BpmUserGroupMapper;
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import java.util.Collection;
+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.module.bpm.enums.ErrorCodeConstants.*;
+
+/**
+ * 用户组 Service 实现类
+ *
+ * @author 芋道源码
+ */
+@Service
+@Validated
+public class BpmUserGroupServiceImpl implements BpmUserGroupService {
+
+    @Resource
+    private BpmUserGroupMapper userGroupMapper;
+
+    @Override
+    public Long createUserGroup(BpmUserGroupCreateReqVO createReqVO) {
+        // 插入
+        BpmUserGroupDO userGroup = BpmUserGroupConvert.INSTANCE.convert(createReqVO);
+        userGroupMapper.insert(userGroup);
+        // 返回
+        return userGroup.getId();
+    }
+
+    @Override
+    public void updateUserGroup(BpmUserGroupUpdateReqVO updateReqVO) {
+        // 校验存在
+        this.validateUserGroupExists(updateReqVO.getId());
+        // 更新
+        BpmUserGroupDO updateObj = BpmUserGroupConvert.INSTANCE.convert(updateReqVO);
+        userGroupMapper.updateById(updateObj);
+    }
+
+    @Override
+    public void deleteUserGroup(Long id) {
+        // 校验存在
+        this.validateUserGroupExists(id);
+        // 删除
+        userGroupMapper.deleteById(id);
+    }
+
+    private void validateUserGroupExists(Long id) {
+        if (userGroupMapper.selectById(id) == null) {
+            throw ServiceExceptionUtil.exception(USER_GROUP_NOT_EXISTS);
+        }
+    }
+
+    @Override
+    public BpmUserGroupDO getUserGroup(Long id) {
+        return userGroupMapper.selectById(id);
+    }
+
+    @Override
+    public List<BpmUserGroupDO> getUserGroupList(Collection<Long> ids) {
+        return userGroupMapper.selectBatchIds(ids);
+    }
+
+
+    @Override
+    public List<BpmUserGroupDO> getUserGroupListByStatus(Integer status) {
+        return userGroupMapper.selectListByStatus(status);
+    }
+
+    @Override
+    public PageResult<BpmUserGroupDO> getUserGroupPage(BpmUserGroupPageReqVO pageReqVO) {
+        return userGroupMapper.selectPage(pageReqVO);
+    }
+
+    @Override
+    public void validUserGroups(Set<Long> ids) {
+        if (CollUtil.isEmpty(ids)) {
+            return;
+        }
+        // 获得用户组信息
+        List<BpmUserGroupDO> userGroups = userGroupMapper.selectBatchIds(ids);
+        Map<Long, BpmUserGroupDO> userGroupMap = CollectionUtils.convertMap(userGroups, BpmUserGroupDO::getId);
+        // 校验
+        ids.forEach(id -> {
+            BpmUserGroupDO userGroup = userGroupMap.get(id);
+            if (userGroup == null) {
+                throw ServiceExceptionUtil.exception(USER_GROUP_NOT_EXISTS);
+            }
+            if (!CommonStatusEnum.ENABLE.getStatus().equals(userGroup.getStatus())) {
+                throw exception(USER_GROUP_IS_DISABLE, userGroup.getName());
+            }
+        });
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/dto/BpmFormFieldRespDTO.java

+package cn.iocoder.yudao.module.bpm.service.definition.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+/**
+ * Bpm 表单的 Field 表单项 Response DTO
+ * 字段的定义，可见 https://github.com/JakHuang/form-generator/issues/46 文档
+ *
+ * @author 芋道源码
+ */
+@Data
+public class BpmFormFieldRespDTO {
+
+    /**
+     * 表单标题
+     */
+    private String label;
+    /**
+     * 表单字段的属性名，可自定义
+     */
+    @JsonProperty(value = "vModel")
+    private String vModel;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/dto/BpmModelMetaInfoRespDTO.java

+package cn.iocoder.yudao.module.bpm.service.definition.dto;
+
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmModelFormTypeEnum;
+import lombok.Data;
+
+/**
+ * BPM 流程 MetaInfo Response DTO
+ * 主要用于 { Model#setMetaInfo(String)} 的存储
+ *
+ * @author 芋道源码
+ */
+@Data
+public class BpmModelMetaInfoRespDTO {
+
+    /**
+     * 流程描述
+     */
+    private String description;
+    /**
+     * 表单类型
+     */
+    private Integer formType;
+    /**
+     * 表单编号
+     * 在表单类型为 {@link BpmModelFormTypeEnum#NORMAL} 时
+     */
+    private Long formId;
+    /**
+     * 自定义表单的提交路径，使用 Vue 的路由地址
+     * 在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时
+     */
+    private String formCustomCreatePath;
+    /**
+     * 自定义表单的查看路径，使用 Vue 的路由地址
+     * 在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时
+     */
+    private String formCustomViewPath;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/definition/dto/BpmProcessDefinitionCreateReqDTO.java

+package cn.iocoder.yudao.module.bpm.service.definition.dto;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmModelFormTypeEnum;
+import lombok.Data;
+
+import javax.validation.constraints.AssertTrue;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 流程定义创建 Request DTO
+ */
+@Data
+public class BpmProcessDefinitionCreateReqDTO {
+
+    // ========== 模型相关 ==========
+
+    /**
+     * 流程模型的编号
+     */
+    @NotEmpty(message = "流程模型编号不能为空")
+    private String modelId;
+    /**
+     * 流程标识
+     */
+    @NotEmpty(message = "流程标识不能为空")
+    private String key;
+    /**
+     * 流程名称
+     */
+    @NotEmpty(message = "流程名称不能为空")
+    private String name;
+    /**
+     * 流程描述
+     */
+    private String description;
+    /**
+     * 流程分类
+     * 参见 bpm_model_category 数据字典
+     */
+    @NotEmpty(message = "流程分类不能为空")
+    private String category;
+    /**
+     * BPMN XML
+     */
+    @NotEmpty(message = "BPMN XML 不能为空")
+    private byte[] bpmnBytes;
+
+    // ========== 表单相关 ==========
+
+    /**
+     * 表单类型
+     */
+    @NotNull(message = "表单类型不能为空")
+    private Integer formType;
+    /**
+     * 动态表单编号
+     * 在表单类型为 {@link BpmModelFormTypeEnum#NORMAL} 时
+     */
+    private Long formId;
+    /**
+     * 表单的配置
+     * 在表单类型为 {@link BpmModelFormTypeEnum#NORMAL} 时
+     */
+    private String formConf;
+    /**
+     * 表单项的数组
+     * 在表单类型为 {@link BpmModelFormTypeEnum#NORMAL} 时
+     */
+    private List<String> formFields;
+    /**
+     * 自定义表单的提交路径，使用 Vue 的路由地址
+     * 在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时
+     */
+    private String formCustomCreatePath;
+    /**
+     * 自定义表单的查看路径，使用 Vue 的路由地址
+     * 在表单类型为 {@link BpmModelFormTypeEnum#CUSTOM} 时
+     */
+    private String formCustomViewPath;
+
+    @AssertTrue(message = "流程表单信息不全")
+    public boolean isNormalFormTypeValid() {
+        // 如果非业务表单，则直接通过
+        if (!Objects.equals(formType, BpmModelFormTypeEnum.NORMAL.getType())) {
+            return true;
+        }
+        return formId != null && StrUtil.isNotEmpty(formConf) && CollUtil.isNotEmpty(formFields);
+    }
+
+    @AssertTrue(message = "业务表单信息不全")
+    public boolean isNormalCustomTypeValid() {
+        // 如果非业务表单，则直接通过
+        if (!Objects.equals(formType, BpmModelFormTypeEnum.CUSTOM.getType())) {
+            return true;
+        }
+        return StrUtil.isNotEmpty(formCustomCreatePath) && StrUtil.isNotEmpty(formCustomViewPath);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/message/BpmMessageService.java

+package cn.iocoder.yudao.module.bpm.service.message;
+
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenProcessInstanceApproveReqDTO;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenProcessInstanceRejectReqDTO;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenTaskCreatedReqDTO;
+
+import javax.validation.Valid;
+
+/**
+ * BPM 消息 Service 接口
+ *
+ * TODO 芋艿：未来支持消息的可配置；不同的流程，在什么场景下，需要发送什么消息，消息的内容是什么；
+ *
+ * @author 芋道源码
+ */
+public interface BpmMessageService {
+
+    /**
+     * 发送流程实例被通过的消息
+     *
+     * @param reqDTO 发送信息
+     */
+    void sendMessageWhenProcessInstanceApprove(@Valid BpmMessageSendWhenProcessInstanceApproveReqDTO reqDTO);
+
+    /**
+     * 发送流程实例被不通过的消息
+     *
+     * @param reqDTO 发送信息
+     */
+    void sendMessageWhenProcessInstanceReject(@Valid BpmMessageSendWhenProcessInstanceRejectReqDTO reqDTO);
+
+    /**
+     * 发送任务被分配的消息
+     *
+     * @param reqDTO 发送信息
+     */
+    void sendMessageWhenTaskAssigned(@Valid BpmMessageSendWhenTaskCreatedReqDTO reqDTO);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/message/BpmMessageServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.message;
+
+import cn.iocoder.yudao.framework.web.config.WebProperties;
+import cn.iocoder.yudao.module.bpm.convert.message.BpmMessageConvert;
+import cn.iocoder.yudao.module.bpm.enums.message.BpmMessageEnum;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenProcessInstanceApproveReqDTO;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenProcessInstanceRejectReqDTO;
+import cn.iocoder.yudao.module.bpm.service.message.dto.BpmMessageSendWhenTaskCreatedReqDTO;
+import cn.iocoder.yudao.module.system.api.sms.SmsSendApi;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * BPM 消息 Service 实现类
+ *
+ * @author 芋道源码
+ */
+@Service
+@Validated
+@Slf4j
+public class BpmMessageServiceImpl implements BpmMessageService {
+
+    @Resource
+    private SmsSendApi smsSendApi;
+
+    @Resource
+    private WebProperties webProperties;
+
+    @Override
+    public void sendMessageWhenProcessInstanceApprove(BpmMessageSendWhenProcessInstanceApproveReqDTO reqDTO) {
+        Map<String, Object> templateParams = new HashMap<>();
+        templateParams.put("processInstanceName", reqDTO.getProcessInstanceName());
+        templateParams.put("detailUrl", getProcessInstanceDetailUrl(reqDTO.getProcessInstanceId()));
+        smsSendApi.sendSingleSmsToAdmin(BpmMessageConvert.INSTANCE.convert(reqDTO.getStartUserId(),
+                BpmMessageEnum.PROCESS_INSTANCE_APPROVE.getSmsTemplateCode(), templateParams));
+    }
+
+    @Override
+    public void sendMessageWhenProcessInstanceReject(BpmMessageSendWhenProcessInstanceRejectReqDTO reqDTO) {
+        Map<String, Object> templateParams = new HashMap<>();
+        templateParams.put("processInstanceName", reqDTO.getProcessInstanceName());
+        templateParams.put("reason", reqDTO.getReason());
+        templateParams.put("detailUrl", getProcessInstanceDetailUrl(reqDTO.getProcessInstanceId()));
+        smsSendApi.sendSingleSmsToAdmin(BpmMessageConvert.INSTANCE.convert(reqDTO.getStartUserId(),
+                BpmMessageEnum.PROCESS_INSTANCE_REJECT.getSmsTemplateCode(), templateParams));
+    }
+
+    @Override
+    public void sendMessageWhenTaskAssigned(BpmMessageSendWhenTaskCreatedReqDTO reqDTO) {
+        Map<String, Object> templateParams = new HashMap<>();
+        templateParams.put("processInstanceName", reqDTO.getProcessInstanceName());
+        templateParams.put("taskName", reqDTO.getTaskName());
+        templateParams.put("startUserNickname", reqDTO.getStartUserNickname());
+        templateParams.put("detailUrl", getProcessInstanceDetailUrl(reqDTO.getProcessInstanceId()));
+        smsSendApi.sendSingleSmsToAdmin(BpmMessageConvert.INSTANCE.convert(reqDTO.getStartUserId(),
+                BpmMessageEnum.TASK_ASSIGNED.getSmsTemplateCode(), templateParams));
+    }
+
+    private String getProcessInstanceDetailUrl(String taskId) {
+        return webProperties.getAdminUi().getUrl() + "/bpm/process-instance/detail?id=" + taskId;
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/message/dto/BpmMessageSendWhenProcessInstanceApproveReqDTO.java

+package cn.iocoder.yudao.module.bpm.service.message.dto;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+/**
+ * BPM 发送流程实例被通过 Request DTO
+ */
+@Data
+public class BpmMessageSendWhenProcessInstanceApproveReqDTO {
+
+    /**
+     * 流程实例的编号
+     */
+    @NotEmpty(message = "流程实例的编号不能为空")
+    private String processInstanceId;
+    /**
+     * 流程实例的名字
+     */
+    @NotEmpty(message = "流程实例的名字不能为空")
+    private String processInstanceName;
+    @NotNull(message = "发起人的用户编号")
+    private Long startUserId;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/message/dto/BpmMessageSendWhenProcessInstanceRejectReqDTO.java

+package cn.iocoder.yudao.module.bpm.service.message.dto;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+/**
+ * BPM 发送流程实例被不通过 Request DTO
+ */
+@Data
+public class BpmMessageSendWhenProcessInstanceRejectReqDTO {
+
+    /**
+     * 流程实例的编号
+     */
+    @NotEmpty(message = "流程实例的编号不能为空")
+    private String processInstanceId;
+    /**
+     * 流程实例的名字
+     */
+    @NotEmpty(message = "流程实例的名字不能为空")
+    private String processInstanceName;
+    @NotNull(message = "发起人的用户编号")
+    private Long startUserId;
+
+    /**
+     * 不通过理由
+     */
+    @NotEmpty(message = "不通过理由不能为空")
+    private String reason;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/message/dto/BpmMessageSendWhenTaskCreatedReqDTO.java

+package cn.iocoder.yudao.module.bpm.service.message.dto;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+/**
+ * BPM 发送任务被分配 Request DTO
+ */
+@Data
+public class BpmMessageSendWhenTaskCreatedReqDTO {
+
+    /**
+     * 流程实例的编号
+     */
+    @NotEmpty(message = "流程实例的编号不能为空")
+    private String processInstanceId;
+    /**
+     * 流程实例的名字
+     */
+    @NotEmpty(message = "流程实例的名字不能为空")
+    private String processInstanceName;
+    @NotNull(message = "发起人的用户编号")
+    private Long startUserId;
+    @NotEmpty(message = "发起人的昵称")
+    private String startUserNickname;
+
+    /**
+     * 流程任务的编号
+     */
+    @NotEmpty(message = "流程任务的编号不能为空")
+    private String taskId;
+    /**
+     * 流程任务的名字
+     */
+    @NotEmpty(message = "流程任务的名字不能为空")
+    private String taskName;
+
+    /**
+     * 审批人的用户编号
+     */
+    @NotNull(message = "审批人的用户编号不能为空")
+    private Long assigneeUserId;
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/oa/BpmOALeaveService.java

+package cn.iocoder.yudao.module.bpm.service.oa;
+
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeaveCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeavePageReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.oa.BpmOALeaveDO;
+
+import javax.validation.Valid;
+
+/**
+ * 请假申请 Service 接口
+ *
+ * @author jason
+ * @author 芋道源码
+ */
+public interface BpmOALeaveService {
+
+    /**
+     * 创建请假申请
+     *
+     * @param userId 用户编号
+     * @param createReqVO 创建信息
+     * @return 编号
+     */
+    Long createLeave(Long userId, @Valid BpmOALeaveCreateReqVO createReqVO);
+
+    /**
+     * 更新请假申请的状态
+     *
+     * @param id 编号
+     * @param result 结果
+     */
+    void updateLeaveResult(Long id, Integer result);
+
+    /**
+     * 获得请假申请
+     *
+     * @param id 编号
+     * @return 请假申请
+     */
+    BpmOALeaveDO getLeave(Long id);
+
+    /**
+     * 获得请假申请分页
+     *
+     * @param userId 用户编号
+     * @param pageReqVO 分页查询
+     * @return 请假申请分页
+     */
+    PageResult<BpmOALeaveDO> getLeavePage(Long userId, BpmOALeavePageReqVO pageReqVO);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/oa/BpmOALeaveServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.oa;
+
+import cn.hutool.core.date.DateUtil;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+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.controller.admin.oa.vo.BpmOALeaveCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.oa.vo.BpmOALeavePageReqVO;
+import cn.iocoder.yudao.module.bpm.convert.oa.BpmOALeaveConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.oa.BpmOALeaveDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.oa.BpmOALeaveMapper;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.Map;
+
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.OA_LEAVE_NOT_EXISTS;
+
+/**
+ * OA 请假申请 Service 实现类
+ *
+ * @author jason
+ * @author 芋道源码
+ */
+@Service
+@Validated
+public class BpmOALeaveServiceImpl implements BpmOALeaveService {
+
+    /**
+     * OA 请假对应的流程定义 KEY
+     */
+    public static final String PROCESS_KEY = "oa_leave";
+
+    @Resource
+    private BpmOALeaveMapper leaveMapper;
+
+    @Resource
+    private BpmProcessInstanceApi processInstanceApi;
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Long createLeave(Long userId, BpmOALeaveCreateReqVO createReqVO) {
+        // 插入 OA 请假单
+        long day = DateUtil.betweenDay(createReqVO.getStartTime(), createReqVO.getEndTime(), false);
+        BpmOALeaveDO leave = BpmOALeaveConvert.INSTANCE.convert(createReqVO).setUserId(userId).setDay(day)
+                .setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
+        leaveMapper.insert(leave);
+
+        // 发起 BPM 流程
+        Map<String, Object> processInstanceVariables = new HashMap<>();
+        processInstanceVariables.put("day", day);
+        String processInstanceId = processInstanceApi.createProcessInstance(userId,
+                new BpmProcessInstanceCreateReqDTO().setProcessDefinitionKey(PROCESS_KEY)
+                        .setVariables(processInstanceVariables).setBusinessKey(String.valueOf(leave.getId())));
+
+        // 将工作流的编号，更新到 OA 请假单中
+        leaveMapper.updateById(new BpmOALeaveDO().setId(leave.getId()).setProcessInstanceId(processInstanceId));
+        return leave.getId();
+    }
+
+    @Override
+    public void updateLeaveResult(Long id, Integer result) {
+        validateLeaveExists(id);
+        leaveMapper.updateById(new BpmOALeaveDO().setId(id).setResult(result));
+    }
+
+    private void validateLeaveExists(Long id) {
+        if (leaveMapper.selectById(id) == null) {
+            throw exception(OA_LEAVE_NOT_EXISTS);
+        }
+    }
+
+    @Override
+    public BpmOALeaveDO getLeave(Long id) {
+        return leaveMapper.selectById(id);
+    }
+
+    @Override
+    public PageResult<BpmOALeaveDO> getLeavePage(Long userId, BpmOALeavePageReqVO pageReqVO) {
+        return leaveMapper.selectPage(userId, pageReqVO);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/oa/listener/BpmOALeaveResultListener.java

+package cn.iocoder.yudao.module.bpm.service.oa.listener;
+
+import cn.iocoder.yudao.module.bpm.framework.bpm.core.event.BpmProcessInstanceResultEvent;
+import cn.iocoder.yudao.module.bpm.framework.bpm.core.event.BpmProcessInstanceResultEventListener;
+import cn.iocoder.yudao.module.bpm.service.oa.BpmOALeaveService;
+import cn.iocoder.yudao.module.bpm.service.oa.BpmOALeaveServiceImpl;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+
+/**
+ * OA 请假单的结果的监听器实现类
+ *
+ * @author 芋道源码
+ */
+@Component
+public class BpmOALeaveResultListener extends BpmProcessInstanceResultEventListener {
+
+    @Resource
+    private BpmOALeaveService leaveService;
+
+    @Override
+    protected String getProcessDefinitionKey() {
+        return BpmOALeaveServiceImpl.PROCESS_KEY;
+    }
+
+    @Override
+    protected void onEvent(BpmProcessInstanceResultEvent event) {
+        leaveService.updateLeaveResult(Long.parseLong(event.getBusinessKey()), event.getResult());
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmActivityService.java

+package cn.iocoder.yudao.module.bpm.service.task;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.activity.BpmActivityRespVO;
+import org.flowable.engine.history.HistoricActivityInstance;
+
+import java.util.List;
+
+/**
+ * BPM 活动实例 Service 接口
+ *
+ * @author 芋道源码
+ */
+public interface BpmActivityService {
+
+    /**
+     * 获得指定流程实例的活动实例列表
+     *
+     * @param processInstanceId 流程实例的编号
+     * @return 活动实例列表
+     */
+    List<BpmActivityRespVO> getActivityListByProcessInstanceId(String processInstanceId);
+
+    /**
+     * 获得执行编号对应的活动实例
+     *
+     * @param executionId 执行编号
+     * @return 活动实例
+     */
+    List<HistoricActivityInstance> getHistoricActivityListByExecutionId(String executionId);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmActivityServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.task;
+
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.activity.BpmActivityRespVO;
+import cn.iocoder.yudao.module.bpm.convert.task.BpmActivityConvert;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.engine.HistoryService;
+import org.flowable.engine.history.HistoricActivityInstance;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+
+/**
+ * BPM 活动实例 Service 实现类
+ *
+ * @author 芋道源码
+ */
+@Service
+@Slf4j
+@Validated
+public class BpmActivityServiceImpl implements BpmActivityService {
+
+    @Resource
+    private HistoryService historyService;
+
+    @Override
+    public List<BpmActivityRespVO> getActivityListByProcessInstanceId(String processInstanceId) {
+        List<HistoricActivityInstance> activityList = historyService.createHistoricActivityInstanceQuery()
+                .processInstanceId(processInstanceId).list();
+        return BpmActivityConvert.INSTANCE.convertList(activityList);
+    }
+
+    @Override
+    public List<HistoricActivityInstance> getHistoricActivityListByExecutionId(String executionId) {
+        return historyService.createHistoricActivityInstanceQuery().executionId(executionId).list();
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmProcessInstanceService.java

+package cn.iocoder.yudao.module.bpm.service.task;
+
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance.*;
+import org.flowable.engine.delegate.event.FlowableCancelledEvent;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.engine.runtime.ProcessInstance;
+
+import javax.validation.Valid;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 流程实例 Service 接口
+ *
+ * @author 芋道源码
+ */
+public interface BpmProcessInstanceService {
+
+    /**
+     * 获得流程实例
+     *
+     * @param id 流程实例的编号
+     * @return 流程实例
+     */
+    ProcessInstance getProcessInstance(String id);
+
+    /**
+     * 获得流程实例列表
+     *
+     * @param ids 流程实例的编号集合
+     * @return 流程实例列表
+     */
+    List<ProcessInstance> getProcessInstances(Set<String> ids);
+
+    /**
+     * 获得流程实例 Map
+     *
+     * @param ids 流程实例的编号集合
+     * @return 流程实例列表 Map
+     */
+    default Map<String, ProcessInstance> getProcessInstanceMap(Set<String> ids) {
+        return CollectionUtils.convertMap(getProcessInstances(ids), ProcessInstance::getProcessInstanceId);
+    }
+
+    /**
+     * 获得流程实例的分页
+     *
+     * @param userId 用户编号
+     * @param pageReqVO 分页请求
+     * @return 流程实例的分页
+     */
+    PageResult<BpmProcessInstancePageItemRespVO> getMyProcessInstancePage(Long userId,
+                                                                          @Valid BpmProcessInstanceMyPageReqVO pageReqVO);
+    /**
+     * 创建流程实例（提供给前端）
+     *
+     * @param userId 用户编号
+     * @param createReqVO 创建信息
+     * @return 实例的编号
+     */
+    String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqVO createReqVO);
+
+    /**
+     * 创建流程实例（提供给内部）
+     *
+     * @param userId 用户编号
+     * @param createReqDTO 创建信息
+     * @return 实例的编号
+     */
+    String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqDTO createReqDTO);
+
+    /**
+     * 获得流程实例 VO 信息
+     *
+     * @param id 流程实例的编号
+     * @return 流程实例
+     */
+    BpmProcessInstanceRespVO getProcessInstanceVO(String id);
+
+    /**
+     * 取消流程实例
+     *
+     * @param userId 用户编号
+     * @param cancelReqVO 取消信息
+     */
+    void cancelProcessInstance(Long userId, @Valid BpmProcessInstanceCancelReqVO cancelReqVO);
+
+    /**
+     * 获得历史的流程实例
+     *
+     * @param id 流程实例的编号
+     * @return 历史的流程实例
+     */
+    HistoricProcessInstance getHistoricProcessInstance(String id);
+
+    /**
+     * 获得历史的流程实例列表
+     *
+     * @param ids 流程实例的编号集合
+     * @return 历史的流程实例列表
+     */
+    List<HistoricProcessInstance> getHistoricProcessInstances(Set<String> ids);
+
+    /**
+     * 获得历史的流程实例 Map
+     *
+     * @param ids 流程实例的编号集合
+     * @return 历史的流程实例列表 Map
+     */
+    default Map<String, HistoricProcessInstance> getHistoricProcessInstanceMap(Set<String> ids) {
+        return CollectionUtils.convertMap(getHistoricProcessInstances(ids), HistoricProcessInstance::getId);
+    }
+
+    /**
+     * 创建 ProcessInstance 拓展记录
+     *
+     * @param instance 流程任务
+     */
+    void createProcessInstanceExt(ProcessInstance instance);
+
+    /**
+     * 更新 ProcessInstance 拓展记录为取消
+     *
+     * @param event 流程取消事件
+     */
+    void updateProcessInstanceExtCancel(FlowableCancelledEvent event);
+
+    /**
+     * 更新 ProcessInstance 拓展记录为完成
+     *
+     * @param instance 流程任务
+     */
+    void updateProcessInstanceExtComplete(ProcessInstance instance);
+
+    /**
+     * 更新 ProcessInstance 拓展记录为不通过
+     *
+     * @param id 流程编号
+     * @param reason 理由。例如说，审批不通过时，需要传递该值
+     */
+    void updateProcessInstanceExtReject(String id, String reason);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmProcessInstanceServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.task;
import cn.hutool.core.collection.CollUtil;import cn.hutool.core.lang.Assert;import cn.hutool.core.util.StrUtil;import cn.iocoder.yudao.framework.common.pojo.PageResult;import cn.iocoder.yudao.framework.common.util.number.NumberUtils;import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.instance.*;import cn.iocoder.yudao.module.bpm.convert.task.BpmProcessInstanceConvert;import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmProcessDefinitionExtDO;import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmProcessInstanceExtDO;import cn.iocoder.yudao.module.bpm.dal.mysql.task.BpmProcessInstanceExtMapper;import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceDeleteReasonEnum;import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceStatusEnum;import cn.iocoder.yudao.module.bpm.framework.bpm.core.event.BpmProcessInstanceResultEventPublisher;import cn.iocoder.yudao.module.bpm.service.definition.BpmProcessDefinitionService;import cn.iocoder.yudao.module.bpm.service.message.BpmMessageService;import cn.iocoder.yudao.module.system.api.dept.DeptApi;import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;import cn.iocoder.yudao.module.system.api.user.AdminUserApi;import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;import lombok.extern.slf4j.Slf4j;import org.flowable.engine.HistoryService;import org.flowable.engine.RuntimeService;import org.flowable.engine.delegate.event.FlowableCancelledEvent;import org.flowable.engine.history.HistoricProcessInstance;import org.flowable.engine.repository.ProcessDefinition;import org.flowable.engine.runtime.ProcessInstance;import org.flowable.task.api.Task;import org.springframework.context.annotation.Lazy;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource;import javax.validation.Valid;import java.util.*;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertList;import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.*;
/**
 * 流程实例 Service 实现类
 *
 * ProcessDefinition & ProcessInstance & Execution & Task 的关系：
 *     1. <a href="https://blog.csdn.net/bobozai86/article/details/105210414" />
 *
 * HistoricProcessInstance & ProcessInstance 的关系：
 *     1. <a href=" https://my.oschina.net/843294669/blog/71902" />
 *
 * 简单来说，前者 = 历史 + 运行中的流程实例，后者仅是运行中的流程实例
 *
 * @author 芋道源码
 */@Service@Validated@Slf4jpublic class BpmProcessInstanceServiceImpl implements BpmProcessInstanceService {

    @Resource
    private RuntimeService runtimeService;
    @Resource
    private BpmProcessInstanceExtMapper processInstanceExtMapper;
    @Resource
    @Lazy // 解决循环依赖
    private BpmTaskService taskService;
    @Resource
    private BpmProcessDefinitionService processDefinitionService;
    @Resource
    private HistoryService historyService;
    @Resource
    private AdminUserApi adminUserApi;
    @Resource
    private DeptApi deptApi;
    @Resource
    private BpmProcessInstanceResultEventPublisher processInstanceResultEventPublisher;
    @Resource
    private BpmMessageService messageService;
    @Override
    public ProcessInstance getProcessInstance(String id) {
        return runtimeService.createProcessInstanceQuery().processInstanceId(id).singleResult();
    }

    @Override
    public List<ProcessInstance> getProcessInstances(Set<String> ids) {
        return runtimeService.createProcessInstanceQuery().processInstanceIds(ids).list();
    }

    @Override
    public PageResult<BpmProcessInstancePageItemRespVO> getMyProcessInstancePage(Long userId,
                                                                                 BpmProcessInstanceMyPageReqVO pageReqVO) {
        // 通过 BpmProcessInstanceExtDO 表，先查询到对应的分页
        PageResult<BpmProcessInstanceExtDO> pageResult = processInstanceExtMapper.selectPage(userId, pageReqVO);
        if (CollUtil.isEmpty(pageResult.getList())) {
            return new PageResult<>(pageResult.getTotal());
        }

        // 获得流程 Task Map
        List<String> processInstanceIds = convertList(pageResult.getList(), BpmProcessInstanceExtDO::getProcessInstanceId);
        Map<String, List<Task>> taskMap = taskService.getTaskMapByProcessInstanceIds(processInstanceIds);
        // 转换返回
        return BpmProcessInstanceConvert.INSTANCE.convertPage(pageResult, taskMap);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqVO createReqVO) {
        // 获得流程定义
        ProcessDefinition definition = processDefinitionService.getProcessDefinition(createReqVO.getProcessDefinitionId());
        // 发起流程
        return createProcessInstance0(userId, definition, createReqVO.getVariables(), null);
    }

    @Override
    public String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqDTO createReqDTO) {
        // 获得流程定义
        ProcessDefinition definition = processDefinitionService.getActiveProcessDefinition(createReqDTO.getProcessDefinitionKey());
        // 发起流程
        return createProcessInstance0(userId, definition, createReqDTO.getVariables(), createReqDTO.getBusinessKey());
    }

    @Override
    public BpmProcessInstanceRespVO getProcessInstanceVO(String id) {
        // 获得流程实例
        HistoricProcessInstance processInstance = getHistoricProcessInstance(id);
        if (processInstance == null) {
            return null;
        }
        BpmProcessInstanceExtDO processInstanceExt = processInstanceExtMapper.selectByProcessInstanceId(id);
        Assert.notNull(processInstanceExt, "流程实例拓展({}) 不存在", id);

        // 获得流程定义
        ProcessDefinition processDefinition = processDefinitionService
                                                    .getProcessDefinition(processInstance.getProcessDefinitionId());
        Assert.notNull(processDefinition, "流程定义({}) 不存在", processInstance.getProcessDefinitionId());
        BpmProcessDefinitionExtDO processDefinitionExt = processDefinitionService.getProcessDefinitionExt(
                processInstance.getProcessDefinitionId());
        Assert.notNull(processDefinitionExt, "流程定义拓展({}) 不存在", id);
        String bpmnXml = processDefinitionService.getProcessDefinitionBpmnXML(processInstance.getProcessDefinitionId());

        // 获得 User
        AdminUserRespDTO startUser = adminUserApi.getUser(NumberUtils.parseLong(processInstance.getStartUserId())).getCheckedData();
        DeptRespDTO dept = null;
        if (startUser != null) {
            dept = deptApi.getDept(startUser.getDeptId()).getCheckedData();
        }

        // 拼接结果
        return BpmProcessInstanceConvert.INSTANCE.convert2(processInstance, processInstanceExt,
                processDefinition, processDefinitionExt, bpmnXml, startUser, dept);
    }

    @Override
    public void cancelProcessInstance(Long userId, @Valid BpmProcessInstanceCancelReqVO cancelReqVO) {
        // 校验流程实例存在
        ProcessInstance instance = getProcessInstance(cancelReqVO.getId());
        if (instance == null) {
            throw exception(PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS);
        }
        // 只能取消自己的
        if (!Objects.equals(instance.getStartUserId(), String.valueOf(userId))) {
            throw exception(PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF);
        }

        // 通过删除流程实例，实现流程实例的取消,
        // 删除流程实例，正则执行任务 ACT_RU_TASK. 任务会被删除。通过历史表查询
        deleteProcessInstance(cancelReqVO.getId(),
                BpmProcessInstanceDeleteReasonEnum.CANCEL_TASK.format(cancelReqVO.getReason()));
    }

    /**
     * 获得历史的流程实例
     *
     * @param id 流程实例的编号
     * @return 历史的流程实例
     */
    @Override
    public HistoricProcessInstance getHistoricProcessInstance(String id) {
        return historyService.createHistoricProcessInstanceQuery().processInstanceId(id).singleResult();
    }

    @Override
    public List<HistoricProcessInstance> getHistoricProcessInstances(Set<String> ids) {
        return historyService.createHistoricProcessInstanceQuery().processInstanceIds(ids).list();
    }

    @Override
    public void createProcessInstanceExt(ProcessInstance instance) {
        // 获得流程定义
        ProcessDefinition definition = processDefinitionService.getProcessDefinition2(instance.getProcessDefinitionId());
        // 插入 BpmProcessInstanceExtDO 对象
        BpmProcessInstanceExtDO instanceExtDO = new BpmProcessInstanceExtDO()
                .setProcessInstanceId(instance.getId())
                .setProcessDefinitionId(definition.getId())
                .setName(instance.getProcessDefinitionName())
                .setStartUserId(Long.valueOf(instance.getStartUserId()))
                .setCategory(definition.getCategory())
                .setStatus(BpmProcessInstanceStatusEnum.RUNNING.getStatus())
                .setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());

        processInstanceExtMapper.insert(instanceExtDO);
    }

    @Override
    public void updateProcessInstanceExtCancel(FlowableCancelledEvent event) {
        // 判断是否为 Reject 不通过。如果是，则不进行更新.
        // 因为，updateProcessInstanceExtReject 方法，已经进行更新了
        if (BpmProcessInstanceDeleteReasonEnum.isRejectReason((String)event.getCause())) {
            return;
        }

        // 需要主动查询，因为 instance 只有 id 属性
        // 另外，此时如果去查询 ProcessInstance 的话，字段是不全的，所以去查询了 HistoricProcessInstance
        HistoricProcessInstance processInstance = getHistoricProcessInstance(event.getProcessInstanceId());
        // 更新拓展表
        BpmProcessInstanceExtDO instanceExtDO = new BpmProcessInstanceExtDO()
                .setProcessInstanceId(event.getProcessInstanceId())
                .setEndTime(new Date()) // 由于 ProcessInstance 里没有办法拿到 endTime，所以这里设置
                .setStatus(BpmProcessInstanceStatusEnum.FINISH.getStatus())
                .setResult(BpmProcessInstanceResultEnum.CANCEL.getResult());
        processInstanceExtMapper.updateByProcessInstanceId(instanceExtDO);

        // 发送流程实例的状态事件
        processInstanceResultEventPublisher.sendProcessInstanceResultEvent(
                BpmProcessInstanceConvert.INSTANCE.convert(this, processInstance, instanceExtDO.getResult()));
    }

    @Override
    public void updateProcessInstanceExtComplete(ProcessInstance instance) {
        // 需要主动查询，因为 instance 只有 id 属性
        // 另外，此时如果去查询 ProcessInstance 的话，字段是不全的，所以去查询了 HistoricProcessInstance
        HistoricProcessInstance processInstance = getHistoricProcessInstance(instance.getId());
        // 更新拓展表
        BpmProcessInstanceExtDO instanceExtDO = new BpmProcessInstanceExtDO()
                .setProcessInstanceId(instance.getProcessInstanceId())
                .setEndTime(new Date()) // 由于 ProcessInstance 里没有办法拿到 endTime，所以这里设置
                .setStatus(BpmProcessInstanceStatusEnum.FINISH.getStatus())
                .setResult(BpmProcessInstanceResultEnum.APPROVE.getResult()); // 如果正常完全，说明审批通过
        processInstanceExtMapper.updateByProcessInstanceId(instanceExtDO);

        // 发送流程被通过的消息
        messageService.sendMessageWhenProcessInstanceApprove(BpmProcessInstanceConvert.INSTANCE.convert2ApprovedReq(instance));

        // 发送流程实例的状态事件
        processInstanceResultEventPublisher.sendProcessInstanceResultEvent(
                BpmProcessInstanceConvert.INSTANCE.convert(this, processInstance, instanceExtDO.getResult()));
    }

    @Transactional(rollbackFor = Exception.class)
    public void updateProcessInstanceExtReject(String id, String reason) {
        // 需要主动查询，因为 instance 只有 id 属性
        ProcessInstance processInstance = getProcessInstance(id);
        // 删除流程实例，以实现驳回任务时，取消整个审批流程
        deleteProcessInstance(id, StrUtil.format(BpmProcessInstanceDeleteReasonEnum.REJECT_TASK.format(reason)));

        // 更新 status + result
        // 注意，不能和上面的逻辑更换位置。因为 deleteProcessInstance 会触发流程的取消，进而调用 updateProcessInstanceExtCancel 方法，
        // 设置 result 为 BpmProcessInstanceStatusEnum.CANCEL，显然和 result 不一定是一致的
        BpmProcessInstanceExtDO instanceExtDO = new BpmProcessInstanceExtDO().setProcessInstanceId(id)
                .setStatus(BpmProcessInstanceStatusEnum.FINISH.getStatus())
                .setResult(BpmProcessInstanceResultEnum.REJECT.getResult());
        processInstanceExtMapper.updateByProcessInstanceId(instanceExtDO);

        // 发送流程被不通过的消息
        messageService.sendMessageWhenProcessInstanceReject(BpmProcessInstanceConvert.INSTANCE.convert2RejectReq(processInstance, reason));

        // 发送流程实例的状态事件
        processInstanceResultEventPublisher.sendProcessInstanceResultEvent(
                BpmProcessInstanceConvert.INSTANCE.convert(this, processInstance, instanceExtDO.getResult()));
    }

    private void deleteProcessInstance(String id, String reason) {
        runtimeService.deleteProcessInstance(id, reason);
    }

    private String createProcessInstance0(Long userId, ProcessDefinition definition,
                                          Map<String, Object> variables, String businessKey) {
        // 校验流程定义
        if (definition == null) {
            throw exception(PROCESS_DEFINITION_NOT_EXISTS);
        }
        if (definition.isSuspended()) {
            throw exception(PROCESS_DEFINITION_IS_SUSPENDED);
        }

        // 创建流程实例
        ProcessInstance instance = runtimeService.startProcessInstanceById(definition.getId(), businessKey, variables);
        // 设置流程名字
        runtimeService.setProcessInstanceName(instance.getId(), definition.getName());

        // 补全流程实例的拓展表
        processInstanceExtMapper.updateByProcessInstanceId(new BpmProcessInstanceExtDO().setProcessInstanceId(instance.getId())
                .setFormVariables(variables));
        return instance.getId();
    }

}
\ No newline at end of file

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskService.java

+package cn.iocoder.yudao.module.bpm.service.task;
+
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
+import org.flowable.task.api.Task;
+
+import javax.validation.Valid;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程任务实例 Service 接口
+ *
+ * @author jason
+ * @author 芋道源码
+ */
+public interface BpmTaskService {
+
+    /**
+     * 获得待办的流程任务分页
+     *
+     * @param userId    用户编号
+     * @param pageReqVO 分页请求
+     *
+     * @return 流程任务分页
+     */
+    PageResult<BpmTaskTodoPageItemRespVO> getTodoTaskPage(Long userId, BpmTaskTodoPageReqVO pageReqVO);
+
+    /**
+     * 获得已办的流程任务分页
+     *
+     * @param userId    用户编号
+     * @param pageReqVO 分页请求
+     *
+     * @return 流程任务分页
+     */
+    PageResult<BpmTaskDonePageItemRespVO> getDoneTaskPage(Long userId, BpmTaskDonePageReqVO pageReqVO);
+
+    /**
+     * 获得流程任务 Map
+     *
+     * @param processInstanceIds 流程实例的编号数组
+     *
+     * @return 流程任务 Map
+     */
+    default Map<String, List<Task>> getTaskMapByProcessInstanceIds(List<String> processInstanceIds) {
+        return CollectionUtils.convertMultiMap(getTasksByProcessInstanceIds(processInstanceIds),
+            Task::getProcessInstanceId);
+    }
+
+    /**
+     * 获得流程任务列表
+     *
+     * @param processInstanceIds 流程实例的编号数组
+     *
+     * @return 流程任务列表
+     */
+    List<Task> getTasksByProcessInstanceIds(List<String> processInstanceIds);
+
+    /**
+     * 获得指令流程实例的流程任务列表，包括所有状态的
+     *
+     * @param processInstanceId 流程实例的编号
+     *
+     * @return 流程任务列表
+     */
+    List<BpmTaskRespVO> getTaskListByProcessInstanceId(String processInstanceId);
+
+    /**
+     * 通过任务
+     *
+     * @param userId 用户编号
+     * @param reqVO  通过请求
+     */
+    void approveTask(Long userId, @Valid BpmTaskApproveReqVO reqVO);
+
+    /**
+     * 不通过任务
+     *
+     * @param userId 用户编号
+     * @param reqVO  不通过请求
+     */
+    void rejectTask(Long userId, @Valid BpmTaskRejectReqVO reqVO);
+
+    /**
+     * 将流程任务分配给指定用户
+     *
+     * @param userId 用户编号
+     * @param reqVO  分配请求
+     */
+    void updateTaskAssignee(Long userId, BpmTaskUpdateAssigneeReqVO reqVO);
+
+    /**
+     * 将流程任务分配给指定用户
+     *
+     * @param id     流程任务编号
+     * @param userId 用户编号
+     */
+    void updateTaskAssignee(String id, Long userId);
+
+    /**
+     * 创建 Task 拓展记录
+     *
+     * @param task 任务实体
+     */
+    void createTaskExt(Task task);
+
+    /**
+     * 更新 Task 拓展记录为完成
+     *
+     * @param task 任务实体
+     */
+    void updateTaskExtComplete(Task task);
+
+    /**
+     * 更新 Task 拓展记录为已取消
+     *
+     * @param taskId 任务的编号
+     */
+    void updateTaskExtCancel(String taskId);
+
+    /**
+     * 更新 Task 拓展记录，并发送通知
+     *
+     * @param task 任务实体
+     */
+    void updateTaskExtAssign(Task task);
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/BpmTaskServiceImpl.java

+package cn.iocoder.yudao.module.bpm.service.task;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.number.NumberUtils;
+import cn.iocoder.yudao.framework.common.util.object.PageUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.task.vo.task.*;
+import cn.iocoder.yudao.module.bpm.convert.task.BpmTaskConvert;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.task.BpmTaskExtDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.task.BpmTaskExtMapper;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceDeleteReasonEnum;
+import cn.iocoder.yudao.module.bpm.enums.task.BpmProcessInstanceResultEnum;
+import cn.iocoder.yudao.module.bpm.service.message.BpmMessageService;
+import cn.iocoder.yudao.module.system.api.dept.DeptApi;
+import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
+import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
+import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.engine.HistoryService;
+import org.flowable.engine.TaskService;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.flowable.task.api.Task;
+import org.flowable.task.api.TaskQuery;
+import org.flowable.task.api.history.HistoricTaskInstance;
+import org.flowable.task.api.history.HistoricTaskInstanceQuery;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
+
+import javax.annotation.Resource;
+import javax.validation.Valid;
+import java.util.*;
+
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap;
+import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.*;
+
+/**
+ * 流程任务实例 Service 实现类
+ *
+ * @author 芋道源码
+ * @author jason
+ */
+@Slf4j
+@Service
+public class BpmTaskServiceImpl implements BpmTaskService {
+
+    @Resource
+    private TaskService taskService;
+    @Resource
+    private HistoryService historyService;
+
+    @Resource
+    private BpmProcessInstanceService processInstanceService;
+    @Resource
+    private AdminUserApi adminUserApi;
+    @Resource
+    private DeptApi deptApi;
+    @Resource
+    private BpmTaskExtMapper taskExtMapper;
+    @Resource
+    private BpmMessageService messageService;
+
+    @Override
+    public PageResult<BpmTaskTodoPageItemRespVO> getTodoTaskPage(Long userId, BpmTaskTodoPageReqVO pageVO) {
+        // 查询待办任务
+        TaskQuery taskQuery = taskService.createTaskQuery().taskAssignee(String.valueOf(userId)) // 分配给自己
+            .orderByTaskCreateTime().desc(); // 创建时间倒序
+        if (StrUtil.isNotBlank(pageVO.getName())) {
+            taskQuery.taskNameLike("%" + pageVO.getName() + "%");
+        }
+        if (pageVO.getBeginCreateTime() != null) {
+            taskQuery.taskCreatedAfter(pageVO.getBeginCreateTime());
+        }
+        if (pageVO.getEndCreateTime() != null) {
+            taskQuery.taskCreatedBefore(pageVO.getEndCreateTime());
+        }
+        // 执行查询
+        List<Task> tasks = taskQuery.listPage(PageUtils.getStart(pageVO), pageVO.getPageSize());
+        if (CollUtil.isEmpty(tasks)) {
+            return PageResult.empty(taskQuery.count());
+        }
+
+        // 获得 ProcessInstance Map
+        Map<String, ProcessInstance> processInstanceMap =
+            processInstanceService.getProcessInstanceMap(convertSet(tasks, Task::getProcessInstanceId));
+        // 获得 User Map
+        Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(
+            convertSet(processInstanceMap.values(), instance -> Long.valueOf(instance.getStartUserId())));
+        // 拼接结果
+        return new PageResult<>(BpmTaskConvert.INSTANCE.convertList1(tasks, processInstanceMap, userMap),
+            taskQuery.count());
+    }
+
+    @Override
+    public PageResult<BpmTaskDonePageItemRespVO> getDoneTaskPage(Long userId, BpmTaskDonePageReqVO pageVO) {
+        // 查询已办任务
+        HistoricTaskInstanceQuery taskQuery = historyService.createHistoricTaskInstanceQuery().finished() // 已完成
+            .taskAssignee(String.valueOf(userId)) // 分配给自己
+            .orderByHistoricTaskInstanceEndTime().desc(); // 审批时间倒序
+        if (StrUtil.isNotBlank(pageVO.getName())) {
+            taskQuery.taskNameLike("%" + pageVO.getName() + "%");
+        }
+        if (pageVO.getBeginCreateTime() != null) {
+            taskQuery.taskCreatedAfter(pageVO.getBeginCreateTime());
+        }
+        if (pageVO.getEndCreateTime() != null) {
+            taskQuery.taskCreatedBefore(pageVO.getEndCreateTime());
+        }
+        // 执行查询
+        List<HistoricTaskInstance> tasks = taskQuery.listPage(PageUtils.getStart(pageVO), pageVO.getPageSize());
+        if (CollUtil.isEmpty(tasks)) {
+            return PageResult.empty(taskQuery.count());
+        }
+
+        // 获得 TaskExtDO Map
+        List<BpmTaskExtDO> bpmTaskExtDOs =
+            taskExtMapper.selectListByTaskIds(convertSet(tasks, HistoricTaskInstance::getId));
+        Map<String, BpmTaskExtDO> bpmTaskExtDOMap = convertMap(bpmTaskExtDOs, BpmTaskExtDO::getTaskId);
+        // 获得 ProcessInstance Map
+        Map<String, HistoricProcessInstance> historicProcessInstanceMap =
+            processInstanceService.getHistoricProcessInstanceMap(
+                convertSet(tasks, HistoricTaskInstance::getProcessInstanceId));
+        // 获得 User Map
+        Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(
+            convertSet(historicProcessInstanceMap.values(), instance -> Long.valueOf(instance.getStartUserId())));
+        // 拼接结果
+        return new PageResult<>(
+            BpmTaskConvert.INSTANCE.convertList2(tasks, bpmTaskExtDOMap, historicProcessInstanceMap, userMap),
+            taskQuery.count());
+    }
+
+    @Override
+    public List<Task> getTasksByProcessInstanceIds(List<String> processInstanceIds) {
+        if (CollUtil.isEmpty(processInstanceIds)) {
+            return Collections.emptyList();
+        }
+        return taskService.createTaskQuery().processInstanceIdIn(processInstanceIds).list();
+    }
+
+    @Override
+    public List<BpmTaskRespVO> getTaskListByProcessInstanceId(String processInstanceId) {
+        // 获得任务列表
+        List<HistoricTaskInstance> tasks = historyService.createHistoricTaskInstanceQuery()
+                .processInstanceId(processInstanceId)
+                .orderByHistoricTaskInstanceStartTime().desc() // 创建时间倒序
+                .list();
+        if (CollUtil.isEmpty(tasks)) {
+            return Collections.emptyList();
+        }
+
+        // 获得 TaskExtDO Map
+        List<BpmTaskExtDO> bpmTaskExtDOs = taskExtMapper.selectListByTaskIds(convertSet(tasks, HistoricTaskInstance::getId));
+        Map<String, BpmTaskExtDO> bpmTaskExtDOMap = convertMap(bpmTaskExtDOs, BpmTaskExtDO::getTaskId);
+        // 获得 ProcessInstance Map
+        HistoricProcessInstance processInstance = processInstanceService.getHistoricProcessInstance(processInstanceId);
+        // 获得 User Map
+        Set<Long> userIds = convertSet(tasks, task -> NumberUtils.parseLong(task.getAssignee()));
+        userIds.add(NumberUtils.parseLong(processInstance.getStartUserId()));
+        Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(userIds);
+        // 获得 Dept Map
+        Map<Long, DeptRespDTO> deptMap = deptApi.getDeptMap(convertSet(userMap.values(), AdminUserRespDTO::getDeptId));
+
+        // 拼接数据
+        return BpmTaskConvert.INSTANCE.convertList3(tasks, bpmTaskExtDOMap, processInstance, userMap, deptMap);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void approveTask(Long userId, @Valid BpmTaskApproveReqVO reqVO) {
+        // 校验任务存在
+        Task task = checkTask(userId, reqVO.getId());
+        // 校验流程实例存在
+        ProcessInstance instance = processInstanceService.getProcessInstance(task.getProcessInstanceId());
+        if (instance == null) {
+            throw exception(PROCESS_INSTANCE_NOT_EXISTS);
+        }
+
+        // 完成任务，审批通过
+        taskService.complete(task.getId(), instance.getProcessVariables());
+
+        // 更新任务拓展表为通过
+        taskExtMapper.updateByTaskId(
+            new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.APPROVE.getResult())
+                .setReason(reqVO.getReason()));
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void rejectTask(Long userId, @Valid BpmTaskRejectReqVO reqVO) {
+        Task task = checkTask(userId, reqVO.getId());
+        // 校验流程实例存在
+        ProcessInstance instance = processInstanceService.getProcessInstance(task.getProcessInstanceId());
+        if (instance == null) {
+            throw exception(PROCESS_INSTANCE_NOT_EXISTS);
+        }
+
+        // 更新流程实例为不通过
+        processInstanceService.updateProcessInstanceExtReject(instance.getProcessInstanceId(), reqVO.getReason());
+
+        // 更新任务拓展表为不通过
+        taskExtMapper.updateByTaskId(
+            new BpmTaskExtDO().setTaskId(task.getId()).setResult(BpmProcessInstanceResultEnum.REJECT.getResult())
+                    .setEndTime(new Date()).setReason(reqVO.getReason()));
+    }
+
+    @Override
+    public void updateTaskAssignee(Long userId, BpmTaskUpdateAssigneeReqVO reqVO) {
+        // 校验任务存在
+        Task task = checkTask(userId, reqVO.getId());
+        // 更新负责人
+        updateTaskAssignee(task.getId(), reqVO.getAssigneeUserId());
+    }
+
+    @Override
+    public void updateTaskAssignee(String id, Long userId) {
+        taskService.setAssignee(id, String.valueOf(userId));
+    }
+
+    /**
+     * 校验任务是否存在， 并且是否是分配给自己的任务
+     *
+     * @param userId 用户 id
+     * @param taskId task id
+     */
+    private Task checkTask(Long userId, String taskId) {
+        Task task = getTask(taskId);
+        if (task == null) {
+            throw exception(TASK_COMPLETE_FAIL_NOT_EXISTS);
+        }
+        if (!Objects.equals(userId, NumberUtils.parseLong(task.getAssignee()))) {
+            throw exception(TASK_COMPLETE_FAIL_ASSIGN_NOT_SELF);
+        }
+        return task;
+    }
+
+    @Override
+    public void createTaskExt(Task task) {
+        BpmTaskExtDO taskExtDO =
+            BpmTaskConvert.INSTANCE.convert2TaskExt(task).setResult(BpmProcessInstanceResultEnum.PROCESS.getResult());
+        taskExtMapper.insert(taskExtDO);
+    }
+
+    @Override
+    public void updateTaskExtComplete(Task task) {
+        BpmTaskExtDO taskExtDO = BpmTaskConvert.INSTANCE.convert2TaskExt(task)
+                .setResult(BpmProcessInstanceResultEnum.APPROVE.getResult()) // 不设置也问题不大，因为 Complete 一般是审核通过，已经设置
+                .setEndTime(new Date());
+        taskExtMapper.updateByTaskId(taskExtDO);
+    }
+
+    @Override
+    public void updateTaskExtCancel(String taskId) {
+        // 需要在事务提交后，才进行查询。不然查询不到历史的原因
+        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+
+            @Override
+            public void afterCommit() {
+                // 可能只是活动，不是任务，所以查询不到
+                HistoricTaskInstance task = getHistoricTask(taskId);
+                if (task == null) {
+                    return;
+                }
+
+                // 如果任务拓展表已经是完成的状态，则跳过
+                BpmTaskExtDO taskExt = taskExtMapper.selectByTaskId(taskId);
+                if (taskExt == null) {
+                    log.error("[updateTaskExtCancel][taskId({}) 查找不到对应的记录，可能存在问题]", taskId);
+                    return;
+                }
+                // 如果已经是最终的结果，则跳过
+                if (BpmProcessInstanceResultEnum.isEndResult(taskExt.getResult())) {
+                    log.error("[updateTaskExtCancel][taskId({}) 处于结果({})，无需进行更新]", taskId, taskExt.getResult());
+                    return;
+                }
+
+                // 更新任务
+                taskExtMapper.updateById(new BpmTaskExtDO().setId(taskExt.getId()).setResult(BpmProcessInstanceResultEnum.CANCEL.getResult())
+                        .setEndTime(new Date()).setReason(BpmProcessInstanceDeleteReasonEnum.translateReason(task.getDeleteReason())));
+            }
+
+        });
+    }
+
+    @Override
+    public void updateTaskExtAssign(Task task) {
+        BpmTaskExtDO taskExtDO =
+            new BpmTaskExtDO().setAssigneeUserId(NumberUtils.parseLong(task.getAssignee())).setTaskId(task.getId());
+        taskExtMapper.updateByTaskId(taskExtDO);
+        // 发送通知。在事务提交时，批量执行操作，所以直接查询会无法查询到 ProcessInstance，所以这里是通过监听事务的提交来实现。
+        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+            @Override
+            public void afterCommit() {
+                ProcessInstance processInstance =
+                    processInstanceService.getProcessInstance(task.getProcessInstanceId());
+                AdminUserRespDTO startUser = adminUserApi.getUser(Long.valueOf(processInstance.getStartUserId())).getCheckedData();
+                messageService.sendMessageWhenTaskAssigned(
+                    BpmTaskConvert.INSTANCE.convert(processInstance, startUser, task));
+            }
+        });
+    }
+
+    private Task getTask(String id) {
+        return taskService.createTaskQuery().taskId(id).singleResult();
+    }
+
+    private HistoricTaskInstance getHistoricTask(String id) {
+        return historyService.createHistoricTaskInstanceQuery().taskId(id).singleResult();
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/main/java/cn/iocoder/yudao/module/bpm/service/task/package-info.java

+package cn.iocoder.yudao.module.bpm.service.task;

yudao-module-bpm/yudao-module-bpm-biz/src/main/resources/application-dev.yaml

+--- #################### 数据库相关配置 ####################
+spring:
+  # 数据源配置项
+  autoconfigure:
+    exclude:
+      - com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure # 排除 Druid 的自动配置，使用 dynamic-datasource-spring-boot-starter 配置多数据源
+  datasource:
+    druid: # Druid 【监控】相关的全局配置
+      web-stat-filter:
+        enabled: true
+      stat-view-servlet:
+        enabled: true
+        allow: # 设置白名单，不填则允许所有访问
+        url-pattern: /druid/*
+        login-username: # 控制台管理用户名和密码
+        login-password:
+      filter:
+        stat:
+          enabled: true
+          log-slow-sql: true # 慢 SQL 记录
+          slow-sql-millis: 100
+          merge-sql: true
+        wall:
+          config:
+            multi-statement-allow: true
+    dynamic: # 多数据源配置
+      druid: # Druid 【连接池】相关的全局配置
+        initial-size: 5 # 初始连接数
+        min-idle: 10 # 最小连接池数量
+        max-active: 20 # 最大连接池数量
+        max-wait: 600000 # 配置获取连接等待超时的时间，单位：毫秒
+        time-between-eviction-runs-millis: 60000 # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位：毫秒
+        min-evictable-idle-time-millis: 300000 # 配置一个连接在池中最小生存的时间，单位：毫秒
+        max-evictable-idle-time-millis: 900000 # 配置一个连接在池中最大生存的时间，单位：毫秒
+        validation-query: SELECT 1 FROM DUAL # 配置检测连接是否有效
+        test-while-idle: true
+        test-on-borrow: false
+        test-on-return: false
+      primary: master
+      datasource:
+        master:
+          name: ruoyi-vue-pro
+          url: jdbc:mysql://400-infra.server.iocoder.cn:3306/${spring.datasource.dynamic.datasource.master.name}?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=CTT&nullCatalogMeansCurrent=true
+          driver-class-name: com.mysql.jdbc.Driver
+          username: root
+          password: 3WLiVUBEwTbvAfsh
+        slave: # 模拟从库，可根据自己需要修改 # 模拟从库，可根据自己需要修改
+          name: ruoyi-vue-pro
+          url: jdbc:mysql://400-infra.server.iocoder.cn:3306/${spring.datasource.dynamic.datasource.slave.name}?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=CTT&nullCatalogMeansCurrent=true
+          driver-class-name: com.mysql.jdbc.Driver
+          username: root
+          password: 3WLiVUBEwTbvAfsh
+
+  # Redis 配置。Redisson 默认的配置足够使用，一般不需要进行调优
+  redis:
+    host: 400-infra.server.iocoder.cn # 地址
+    port: 6379 # 端口
+    database: 1 # 数据库索引
+#    password: 123456 # 密码，建议生产环境开启
+
+jasypt:
+  encryptor:
+    password: yuanma # 加解密的秘钥
+
+--- #################### MQ 消息队列相关配置 ####################
+spring:
+  cloud:
+    stream:
+      rocketmq:
+        # RocketMQ Binder 配置项，对应 RocketMQBinderConfigurationProperties 类
+        binder:
+          name-server: 127.0.0.1:9876 # RocketMQ Namesrv 地址
+
+--- #################### 定时任务相关配置 ####################
+xxl:
+  job:
+    admin:
+      addresses: http://127.0.0.1:9090/xxl-job-admin # 调度中心部署跟地址
+
+--- #################### 服务保障相关配置 ####################
+
+# Lock4j 配置项
+lock4j:
+  acquire-timeout: 3000 # 获取分布式锁超时时间，默认为 3000 毫秒
+  expire: 30000 # 分布式锁的超时时间，默认为 30 毫秒
+
+--- #################### 监控相关配置 ####################
+
+# Actuator 监控端点的配置项
+management:
+  endpoints:
+    web:
+      base-path: /actuator # Actuator 提供的 API 接口的根目录。默认为 /actuator
+      exposure:
+        include: '*' # 需要开放的端点。默认值只打开 health 和 info 两个端点。通过设置 * ，可以开放所有端点。
+
+# Spring Boot Admin 配置项
+spring:
+  boot:
+    admin:
+      # Spring Boot Admin Client 客户端的相关配置
+      client:
+        url: http://127.0.0.1:${server.port}/${spring.boot.admin.context-path} # 设置 Spring Boot Admin Server 地址
+        instance:
+          service-host-type: IP # 注册实例时，优先使用 IP [IP, HOST_NAME, CANONICAL_HOST_NAME]
+
+--- #################### 芋道相关配置 ####################
+
+# 芋道配置项，设置当前项目所有自定义的配置
+yudao:
+  xss:
+    enable: false
+    exclude-urls: # 如下两个 url，仅仅是为了演示，去掉配置也没关系
+      - ${spring.boot.admin.context-path}/** # 不处理 Spring Boot Admin 的请求
+      - ${management.endpoints.web.base-path}/** # 不处理 Actuator 的请求
+  demo: true # 开启演示模式

yudao-module-bpm/yudao-module-bpm-biz/src/main/resources/application-local.yaml

+--- #################### 数据库相关配置 ####################
+spring:
+  # 数据源配置项
+  autoconfigure:
+    exclude:
+      - com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure # 排除 Druid 的自动配置，使用 dynamic-datasource-spring-boot-starter 配置多数据源
+  datasource:
+    druid: # Druid 【监控】相关的全局配置
+      web-stat-filter:
+        enabled: true
+      stat-view-servlet:
+        enabled: true
+        allow: # 设置白名单，不填则允许所有访问
+        url-pattern: /druid/*
+        login-username: # 控制台管理用户名和密码
+        login-password:
+      filter:
+        stat:
+          enabled: true
+          log-slow-sql: true # 慢 SQL 记录
+          slow-sql-millis: 100
+          merge-sql: true
+        wall:
+          config:
+            multi-statement-allow: true
+    dynamic: # 多数据源配置
+      druid: # Druid 【连接池】相关的全局配置
+        initial-size: 5 # 初始连接数
+        min-idle: 10 # 最小连接池数量
+        max-active: 20 # 最大连接池数量
+        max-wait: 600000 # 配置获取连接等待超时的时间，单位：毫秒
+        time-between-eviction-runs-millis: 60000 # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位：毫秒
+        min-evictable-idle-time-millis: 300000 # 配置一个连接在池中最小生存的时间，单位：毫秒
+        max-evictable-idle-time-millis: 900000 # 配置一个连接在池中最大生存的时间，单位：毫秒
+        validation-query: SELECT 1 FROM DUAL # 配置检测连接是否有效
+        test-while-idle: true
+        test-on-borrow: false
+        test-on-return: false
+      primary: master
+      datasource:
+        master:
+          name: ruoyi-vue-pro
+          url: jdbc:mysql://127.0.0.1:3306/${spring.datasource.dynamic.datasource.master.name}?allowMultiQueries=true&useUnicode=true&useSSL=false&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&nullCatalogMeansCurrent=true # MySQL Connector/J 8.X 连接的示例
+#          url: jdbc:mysql://127.0.0.1:3306/${spring.datasource.dynamic.datasource.master.name}?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=CTT # MySQL Connector/J 5.X 连接的示例
+#          url: jdbc:postgresql://127.0.0.1:5432/${spring.datasource.dynamic.datasource.slave.name} # PostgreSQL 连接的示例
+#          url: jdbc:oracle:thin:@127.0.0.1:1521:xe # Oracle 连接的示例
+#          url: jdbc:sqlserver://127.0.0.1:1433;DatabaseName=${spring.datasource.dynamic.datasource.master.name} # SQLServer 连接的示例
+          username: root
+          password: 123456
+#          username: sa
+#          password: JSm:g(*%lU4ZAkz06cd52KqT3)i1?H7W
+        slave: # 模拟从库，可根据自己需要修改
+          name: ruoyi-vue-pro
+          url: jdbc:mysql://127.0.0.1:3306/${spring.datasource.dynamic.datasource.slave.name}?allowMultiQueries=true&useUnicode=true&useSSL=false&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&nullCatalogMeansCurrent=true # MySQL Connector/J 8.X 连接的示例
+#          url: jdbc:mysql://127.0.0.1:3306/${spring.datasource.dynamic.datasource.slave.name}?useSSL=false&allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=CTT # MySQL Connector/J 5.X 连接的示例
+#          url: jdbc:postgresql://127.0.0.1:5432/${spring.datasource.dynamic.datasource.slave.name} # PostgreSQL 连接的示例
+#          url: jdbc:oracle:thin:@127.0.0.1:1521:xe # Oracle 连接的示例
+#          url: jdbc:sqlserver://127.0.0.1:1433;DatabaseName=${spring.datasource.dynamic.datasource.slave.name} # SQLServer 连接的示例
+          username: root
+          password: 123456
+#          username: sa
+#          password: JSm:g(*%lU4ZAkz06cd52KqT3)i1?H7W
+
+  # Redis 配置。Redisson 默认的配置足够使用，一般不需要进行调优
+  redis:
+    host: 127.0.0.1 # 地址
+    port: 6379 # 端口
+    database: 0 # 数据库索引
+#    password: 123456 # 密码，建议生产环境开启
+
+jasypt:
+  encryptor:
+    password: yuanma # 加解密的秘钥
+
+--- #################### MQ 消息队列相关配置 ####################
+spring:
+  cloud:
+    stream:
+      rocketmq:
+        # RocketMQ Binder 配置项，对应 RocketMQBinderConfigurationProperties 类
+        binder:
+          name-server: 127.0.0.1:9876 # RocketMQ Namesrv 地址
+
+--- #################### 定时任务相关配置 ####################
+
+xxl:
+  job:
+    admin:
+      addresses: http://127.0.0.1:9090/xxl-job-admin # 调度中心部署跟地址
+
+--- #################### 服务保障相关配置 ####################
+
+# Lock4j 配置项
+lock4j:
+  acquire-timeout: 3000 # 获取分布式锁超时时间，默认为 3000 毫秒
+  expire: 30000 # 分布式锁的超时时间，默认为 30 毫秒
+
+--- #################### 监控相关配置 ####################
+
+# Actuator 监控端点的配置项
+management:
+  endpoints:
+    web:
+      base-path: /actuator # Actuator 提供的 API 接口的根目录。默认为 /actuator
+      exposure:
+        include: '*' # 需要开放的端点。默认值只打开 health 和 info 两个端点。通过设置 * ，可以开放所有端点。
+
+# Spring Boot Admin 配置项
+spring:
+  boot:
+    admin:
+      # Spring Boot Admin Client 客户端的相关配置
+      client:
+        url: http://127.0.0.1:${server.port}/${spring.boot.admin.context-path} # 设置 Spring Boot Admin Server 地址
+        instance:
+          service-host-type: IP # 注册实例时，优先使用 IP [IP, HOST_NAME, CANONICAL_HOST_NAME]
+
+# 日志文件配置
+logging:
+  level:
+    # 配置自己写的 MyBatis Mapper 打印日志
+    cn.iocoder.yudao.module.bpm.dal.mysql: debug
+
+--- #################### 芋道相关配置 ####################
+
+# 芋道配置项，设置当前项目所有自定义的配置
+yudao:
+  env: # 多环境的配置项
+    tag: ${HOSTNAME}
+  captcha:
+    enable: false # 本地环境，暂时关闭图片验证码，方便登录等接口的测试
+  security:
+    mock-enable: true
+  xss:
+    enable: false
+    exclude-urls: # 如下两个 url，仅仅是为了演示，去掉配置也没关系
+      - ${spring.boot.admin.context-path}/** # 不处理 Spring Boot Admin 的请求
+      - ${management.endpoints.web.base-path}/** # 不处理 Actuator 的请求
+  access-log: # 访问日志的配置项
+    enable: false
+  error-code: # 错误码相关配置项
+    enable: false
+  demo: false # 关闭演示模式

yudao-module-bpm/yudao-module-bpm-biz/src/main/resources/application.yaml

+spring:
+  main:
+    allow-circular-references: true # 允许循环依赖，因为项目是三层架构，无法避免这个情况。
+    allow-bean-definition-overriding: true # 允许 Bean 覆盖，例如说 Dubbo 或者 Feign 等会存在重复定义的服务
+
+  # Servlet 配置
+  servlet:
+    # 文件上传相关配置项
+    multipart:
+      max-file-size: 16MB # 单个文件大小
+      max-request-size: 32MB # 设置总上传的文件大小
+  mvc:
+    pathmatch:
+      matching-strategy: ANT_PATH_MATCHER # 解决 SpringFox 与 SpringBoot 2.6.x 不兼容的问题，参见 SpringFoxHandlerProviderBeanPostProcessor 类
+
+  # Jackson 配置项
+  jackson:
+    serialization:
+      write-dates-as-timestamps: true # 设置 Date 的格式，使用时间戳
+      write-date-timestamps-as-nanoseconds: false # 设置不使用 nanoseconds 的格式。例如说 1611460870.401，而是直接 1611460870401
+      write-durations-as-timestamps: true # 设置 Duration 的格式，使用时间戳
+      fail-on-empty-beans: false # 允许序列化无属性的 Bean
+
+  # Cache 配置项
+  cache:
+    type: REDIS
+    redis:
+      time-to-live: 1h # 设置过期时间为 1 小时
+
+# 工作流 Flowable 配置
+flowable:
+  # 1. false: 默认值，Flowable 启动时，对比数据库表中保存的版本，如果不匹配。将抛出异常
+  # 2. true: 启动时会对数据库中所有表进行更新操作，如果表存在，不做处理，反之，自动创建表
+  # 3. create_drop: 启动时自动创建表，关闭时自动删除表
+  # 4. drop_create: 启动时，删除旧表，再创建新表
+  database-schema-update: true # 设置为 false，可通过 https://github.com/flowable/flowable-sql 初始化
+  db-history-used: true # flowable6 默认 true 生成信息表，无需手动设置
+  check-process-definitions: false # 设置为 false，禁用 /resources/processes 自动部署 BPMN XML 流程
+  history-level: full # full：保存历史数据的最高级别，可保存全部流程相关细节，包括流程流转各节点参数
+
+# MyBatis Plus 的配置项
+mybatis-plus:
+  configuration:
+    map-underscore-to-camel-case: true # 虽然默认为 true ，但是还是显示去指定下。
+  global-config:
+    db-config:
+      id-type: NONE # “智能”模式，基于 IdTypeEnvironmentPostProcessor + 数据源的类型，自动适配成 AUTO、INPUT 模式。
+#      id-type: AUTO # 自增 ID，适合 MySQL 等直接自增的数据库
+#      id-type: INPUT # 用户输入 ID，适合 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库
+#      id-type: ASSIGN_ID # 分配 ID，默认使用雪花算法。注意，Oracle、PostgreSQL、Kingbase、DB2、H2 数据库时，需要去除实体类上的 @KeySequence 注解
+      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
+      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
+  type-aliases-package: ${yudao.info.base-package}.dal.dataobject
+
+--- #################### RPC 远程调用相关配置 ####################
+dubbo:
+  scan:
+    base-packages: ${yudao.info.base-package}.api # 指定 Dubbo 服务实现类的扫描基准包
+  protocol:
+    name: dubbo # 协议名称
+    port: -1 # 协议端口，-1 表示自增端口，从 20880 开始
+  registry:
+    address: spring-cloud://localhost # 设置使用 Spring Cloud 注册中心
+
+--- #################### MQ 消息队列相关配置 ####################
+
+spring:
+  cloud:
+    # Spring Cloud Stream 配置项，对应 BindingServiceProperties 类
+    stream:
+      # Spring Cloud Stream RocketMQ 配置项
+      rocketmq:
+        # RocketMQ Binder 配置项，对应 RocketMQBinderConfigurationProperties 类
+        binder:
+          name-server: 127.0.0.1:9876 # RocketMQ Namesrv 地址
+        default: # 默认 bindings 全局配置
+          producer: # RocketMQ Producer 配置项，对应 RocketMQProducerProperties 类
+            group: bpm_producer_group # 生产者分组
+            send-type: SYNC # 发送模式，SYNC 同步
+
+    # Spring Cloud Bus 配置项，对应 BusProperties 类
+    bus:
+      enabled: true # 是否开启，默认为 true
+      id: ${spring.application.name}:${server.port} # 编号，Spring Cloud Alibaba 建议使用“应用:端口”的格式
+      destination: springCloudBus # 目标消息队列，默认为 springCloudBus
+
+--- #################### 定时任务相关配置 ####################
+
+xxl:
+  job:
+    executor:
+      appname: ${spring.application.name} # 执行器 AppName
+      logpath: ${user.home}/logs/xxl-job/${spring.application.name} # 执行器运行日志文件存储磁盘路径
+    accessToken: default_token # 执行器通讯TOKEN
+
+--- #################### 芋道相关配置 ####################
+
+yudao:
+  info:
+    version: 1.0.0
+    base-package: cn.iocoder.yudao.module.bpm
+  web:
+    admin-ui:
+      url: http://dashboard.yudao.iocoder.cn # Admin 管理后台 UI 的地址
+  swagger:
+    title: 管理后台
+    description: 提供管理员管理的所有功能
+    version: ${yudao.info.version}
+    base-package: ${yudao.info.base-package}
+  captcha:
+    timeout: 5m
+    width: 160
+    height: 60
+  error-code: # 错误码相关配置项
+    constants-class-list:
+      - cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants
+  tenant: # 多租户相关配置项
+    enable: true
+
+debug: false

yudao-module-bpm/yudao-module-bpm-biz/src/main/resources/bootstrap-local.yaml

+--- #################### 注册中心相关配置 ####################
+
+spring:
+  cloud:
+    nacos:
+      server-addr: 127.0.0.1:8848
+      discovery:
+        namespace: dev # 命名空间。这里使用 dev 开发环境
+        metadata:
+          version: 1.0.0 # 服务实例的版本号，可用于灰度发布
+
+--- #################### 配置中心相关配置 ####################
+
+spring:
+  cloud:
+    nacos:
+      # Nacos Config 配置项，对应 NacosConfigProperties 配置属性类
+      config:
+        server-addr: 127.0.0.1:8848 # Nacos 服务器地址
+        namespace: dev # 命名空间。这里使用 dev 开发环境
+        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
+        name: # 使用的 Nacos 配置集的 dataId，默认为 spring.application.name
+        file-extension: yaml # 使用的 Nacos 配置集的 dataId 的文件拓展名，同时也是 Nacos 配置集的配置格式，默认为 properties

yudao-module-bpm/yudao-module-bpm-biz/src/main/resources/bootstrap.yaml

+spring:
+  application:
+    name: bpm-server
+
+  profiles:
+    active: local
+
+server:
+  port: 48083
+
+# 日志文件配置。注意，如果 logging.file.name 不放在 bootstrap.yaml 配置文件，而是放在 application.yaml 中，会导致出现 LOG_FILE_IS_UNDEFINED 文件
+logging:
+  file:
+    name: ${user.home}/logs/${spring.application.name}.log # 日志文件名，全路径

yudao-module-bpm/yudao-module-bpm-biz/src/main/resources/logback-spring.xml

+<configuration>
+    <!-- 引用 Spring Boot 的 logback 基础配置 -->
+    <include resource="org/springframework/boot/logging/logback/defaults.xml" />
+    <!-- 变量 yudao.info.base-package，基础业务包 -->
+    <springProperty scope="context" name="yudao.info.base-package" source="yudao.info.base-package"/>
+    <!-- 格式化输出：%d 表示日期，%X{tid} SkWalking 链路追踪编号，%thread 表示线程名，%-5level：级别从左显示 5 个字符宽度，%msg：日志消息，%n是换行符 -->
+    <property name="PATTERN_DEFAULT" value="%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}} ${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%thread] [%tid] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>
+
+    <!-- 控制台 Appender -->
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">　　　　　
+        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
+            <layout class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.TraceIdPatternLogbackLayout">
+                <pattern>${PATTERN_DEFAULT}</pattern>
+            </layout>
+        </encoder>
+    </appender>
+
+    <!-- 文件 Appender -->
+    <!-- 参考 Spring Boot 的 file-appender.xml 编写 -->
+    <appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
+            <layout class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.TraceIdPatternLogbackLayout">
+                <pattern>${PATTERN_DEFAULT}</pattern>
+            </layout>
+        </encoder>
+        <!-- 日志文件名 -->
+        <file>${LOG_FILE}</file>
+        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <!-- 滚动后的日志文件名 -->
+            <fileNamePattern>${LOGBACK_ROLLINGPOLICY_FILE_NAME_PATTERN:-${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz}</fileNamePattern>
+            <!-- 启动服务时，是否清理历史日志，一般不建议清理 -->
+            <cleanHistoryOnStart>${LOGBACK_ROLLINGPOLICY_CLEAN_HISTORY_ON_START:-false}</cleanHistoryOnStart>
+            <!-- 日志文件，到达多少容量，进行滚动 -->
+            <maxFileSize>${LOGBACK_ROLLINGPOLICY_MAX_FILE_SIZE:-10MB}</maxFileSize>
+            <!-- 日志文件的总大小，0 表示不限制 -->
+            <totalSizeCap>${LOGBACK_ROLLINGPOLICY_TOTAL_SIZE_CAP:-0}</totalSizeCap>
+            <!-- 日志文件的保留天数 -->
+            <maxHistory>${LOGBACK_ROLLINGPOLICY_MAX_HISTORY:-30}</maxHistory>
+        </rollingPolicy>
+    </appender>
+    <!-- 异步写入日志，提升性能 -->
+    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
+        <!-- 不丢失日志。默认的，如果队列的 80% 已满,则会丢弃 TRACT、DEBUG、INFO 级别的日志 -->
+        <discardingThreshold>0</discardingThreshold>
+        <!-- 更改默认的队列的深度，该值会影响性能。默认值为 256 -->
+        <queueSize>256</queueSize>
+        <appender-ref ref="FILE"/>
+    </appender>
+
+    <!-- SkyWalking GRPC 日志收集，实现日志中心。注意：SkyWalking 8.4.0 版本开始支持 -->
+    <appender name="GRPC" class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.log.GRPCLogClientAppender">
+        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
+            <layout class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.TraceIdPatternLogbackLayout">
+                <pattern>${PATTERN_DEFAULT}</pattern>
+            </layout>
+        </encoder>
+    </appender>
+
+    <!-- 本地环境 -->
+    <springProfile name="local">
+        <root level="INFO">
+            <appender-ref ref="STDOUT"/>
+            <appender-ref ref="GRPC"/> <!-- 本地环境下，如果不想接入 SkyWalking 日志服务，可以注释掉本行 -->
+            <appender-ref ref="ASYNC"/>  <!-- 本地环境下，如果不想打印日志，可以注释掉本行 -->
+        </root>
+    </springProfile>
+    <!-- 其它环境 -->
+    <springProfile name="dev,default">
+        <root level="INFO">
+            <appender-ref ref="STDOUT"/>
+            <appender-ref ref="ASYNC"/>
+            <appender-ref ref="GRPC"/>
+        </root>
+    </springProfile>
+
+</configuration>

yudao-module-bpm/yudao-module-bpm-biz/src/test/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/behavior/script/impl/BpmTaskAssignLeaderX2ScriptTest.java

+package cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.impl;
+
+import cn.iocoder.yudao.framework.test.core.ut.BaseMockitoUnitTest;
+import cn.iocoder.yudao.module.bpm.service.task.BpmProcessInstanceService;
+import cn.iocoder.yudao.module.system.api.dept.DeptApi;
+import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
+import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
+import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.impl.persistence.entity.ExecutionEntityImpl;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.util.Set;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+import static cn.iocoder.yudao.framework.common.util.collection.SetUtils.asSet;
+import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
+import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomString;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+public class BpmTaskAssignLeaderX2ScriptTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskAssignLeaderX2Script script;
+
+    @Mock
+    private AdminUserApi adminUserApi;
+    @Mock
+    private DeptApi deptApi;
+    @Mock
+    private BpmProcessInstanceService bpmProcessInstanceService;
+
+    @Test
+    public void testCalculateTaskCandidateUsers_noDept() {
+        // 准备参数
+        DelegateExecution execution = mockDelegateExecution(1L);
+        // mock 方法(startUser)
+        AdminUserRespDTO startUser = randomPojo(AdminUserRespDTO.class, o -> o.setDeptId(10L));
+        when(adminUserApi.getUser(eq(1L))).thenReturn(success(startUser));
+
+        // 调用
+        Set<Long> result = script.calculateTaskCandidateUsers(execution);
+        // 断言
+        assertEquals(0, result.size());
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_noParentDept() {
+        // 准备参数
+        DelegateExecution execution = mockDelegateExecution(1L);
+        // mock 方法(startUser)
+        AdminUserRespDTO startUser = randomPojo(AdminUserRespDTO.class, o -> o.setDeptId(10L));
+        when(adminUserApi.getUser(eq(1L))).thenReturn(success(startUser));
+        DeptRespDTO startUserDept = randomPojo(DeptRespDTO.class, o -> o.setId(10L).setParentId(100L)
+                .setLeaderUserId(20L));
+        when(deptApi.getDept(eq(10L))).thenReturn(success(startUserDept));
+
+        // 调用
+        Set<Long> result = script.calculateTaskCandidateUsers(execution);
+        // 断言
+        assertEquals(asSet(20L), result);
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_existParentDept() {
+        // 准备参数
+        DelegateExecution execution = mockDelegateExecution(1L);
+        // mock 方法(startUser)
+        AdminUserRespDTO startUser = randomPojo(AdminUserRespDTO.class, o -> o.setDeptId(10L));
+        when(adminUserApi.getUser(eq(1L))).thenReturn(success(startUser));
+        DeptRespDTO startUserDept = randomPojo(DeptRespDTO.class, o -> o.setId(10L).setParentId(100L)
+                .setLeaderUserId(20L));
+        when(deptApi.getDept(eq(10L))).thenReturn(success(startUserDept));
+        // mock 方法（父 dept）
+        DeptRespDTO parentDept = randomPojo(DeptRespDTO.class, o -> o.setId(100L).setParentId(1000L)
+                .setLeaderUserId(200L));
+        when(deptApi.getDept(eq(100L))).thenReturn(success(parentDept));
+
+        // 调用
+        Set<Long> result = script.calculateTaskCandidateUsers(execution);
+        // 断言
+        assertEquals(asSet(200L), result);
+    }
+
+    @SuppressWarnings("SameParameterValue")
+    private DelegateExecution mockDelegateExecution(Long startUserId) {
+        ExecutionEntityImpl execution = new ExecutionEntityImpl();
+        execution.setProcessInstanceId(randomString());
+        // mock 返回 startUserId
+        ExecutionEntityImpl processInstance = new ExecutionEntityImpl();
+        processInstance.setStartUserId(String.valueOf(startUserId));
+        when(bpmProcessInstanceService.getProcessInstance(eq(execution.getProcessInstanceId())))
+                .thenReturn(processInstance);
+        return execution;
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/test/java/cn/iocoder/yudao/module/bpm/service/definition/BpmFormServiceTest.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.hutool.core.util.RandomUtil;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
+import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.form.BpmFormUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmFormDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.definition.BpmFormMapper;
+import cn.iocoder.yudao.module.bpm.service.definition.dto.BpmFormFieldRespDTO;
+import org.junit.jupiter.api.Test;
+import org.springframework.context.annotation.Import;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.cloneIgnoreId;
+import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertPojoEquals;
+import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertServiceException;
+import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomLongId;
+import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.FORM_NOT_EXISTS;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * {@link BpmFormServiceImpl} 的单元测试类
+ *
+ * @author 芋道源码
+ */
+@Import(BpmFormServiceImpl.class)
+public class BpmFormServiceTest extends BaseDbUnitTest {
+
+    @Resource
+    private BpmFormServiceImpl formService;
+
+    @Resource
+    private BpmFormMapper formMapper;
+
+    @Test
+    public void testCreateForm_success() {
+        // 准备参数
+        BpmFormCreateReqVO reqVO = randomPojo(BpmFormCreateReqVO.class, o -> {
+            o.setConf("{}");
+            o.setFields(randomFields());
+        });
+
+        // 调用
+        Long formId = formService.createForm(reqVO);
+        // 断言
+        assertNotNull(formId);
+        // 校验记录的属性是否正确
+        BpmFormDO form = formMapper.selectById(formId);
+        assertPojoEquals(reqVO, form);
+    }
+
+    @Test
+    public void testUpdateForm_success() {
+        // mock 数据
+        BpmFormDO dbForm = randomPojo(BpmFormDO.class, o -> {
+            o.setConf("{}");
+            o.setFields(randomFields());
+        });
+        formMapper.insert(dbForm);// @Sql: 先插入出一条存在的数据
+        // 准备参数
+        BpmFormUpdateReqVO reqVO = randomPojo(BpmFormUpdateReqVO.class, o -> {
+            o.setId(dbForm.getId()); // 设置更新的 ID
+            o.setConf("{'yudao': 'yuanma'}");
+            o.setFields(randomFields());
+        });
+
+        // 调用
+        formService.updateForm(reqVO);
+        // 校验是否更新正确
+        BpmFormDO form = formMapper.selectById(reqVO.getId()); // 获取最新的
+        assertPojoEquals(reqVO, form);
+    }
+
+    @Test
+    public void testUpdateForm_notExists() {
+        // 准备参数
+        BpmFormUpdateReqVO reqVO = randomPojo(BpmFormUpdateReqVO.class, o -> {
+            o.setConf("{'yudao': 'yuanma'}");
+            o.setFields(randomFields());
+        });
+
+        // 调用, 并断言异常
+        assertServiceException(() -> formService.updateForm(reqVO), FORM_NOT_EXISTS);
+    }
+
+    @Test
+    public void testDeleteForm_success() {
+        // mock 数据
+        BpmFormDO dbForm = randomPojo(BpmFormDO.class);
+        formMapper.insert(dbForm);// @Sql: 先插入出一条存在的数据
+        // 准备参数
+        Long id = dbForm.getId();
+
+        // 调用
+        formService.deleteForm(id);
+        // 校验数据不存在了
+        assertNull(formMapper.selectById(id));
+    }
+
+    @Test
+    public void testDeleteForm_notExists() {
+        // 准备参数
+        Long id = randomLongId();
+
+        // 调用, 并断言异常
+        assertServiceException(() -> formService.deleteForm(id), FORM_NOT_EXISTS);
+    }
+
+    @Test
+    public void testGetFormPage() {
+        // mock 数据
+        BpmFormDO dbForm = randomPojo(BpmFormDO.class, o -> { // 等会查询到
+            o.setName("芋道源码");
+        });
+        formMapper.insert(dbForm);
+        // 测试 name 不匹配
+        formMapper.insert(cloneIgnoreId(dbForm, o -> o.setName("源码")));
+        // 准备参数
+        BpmFormPageReqVO reqVO = new BpmFormPageReqVO();
+        reqVO.setName("芋道");
+
+        // 调用
+        PageResult<BpmFormDO> pageResult = formService.getFormPage(reqVO);
+        // 断言
+        assertEquals(1, pageResult.getTotal());
+        assertEquals(1, pageResult.getList().size());
+        assertPojoEquals(dbForm, pageResult.getList().get(0));
+    }
+
+    private List<String> randomFields() {
+        int size = RandomUtil.randomInt(1, 3);
+        return Stream.iterate(0, i -> i).limit(size)
+                .map(i -> JsonUtils.toJsonString(randomPojo(BpmFormFieldRespDTO.class)))
+                .collect(Collectors.toList());
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/test/java/cn/iocoder/yudao/module/bpm/service/definition/BpmTaskAssignRuleServiceImplTest.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.hutool.core.map.MapUtil;
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
+import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmTaskAssignRuleDO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskAssignRuleTypeEnum;
+import cn.iocoder.yudao.module.bpm.enums.definition.BpmTaskRuleScriptEnum;
+import cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.BpmTaskAssignScript;
+import cn.iocoder.yudao.module.bpm.framework.flowable.core.behavior.script.impl.BpmTaskAssignStartUserScript;
+import cn.iocoder.yudao.module.system.api.dept.DeptApi;
+import cn.iocoder.yudao.module.system.api.dept.PostApi;
+import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
+import cn.iocoder.yudao.module.system.api.dict.DictDataApi;
+import cn.iocoder.yudao.module.system.api.permission.PermissionApi;
+import cn.iocoder.yudao.module.system.api.permission.RoleApi;
+import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
+import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.context.annotation.Import;
+
+import javax.annotation.Resource;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
+import static cn.iocoder.yudao.framework.common.util.collection.SetUtils.asSet;
+import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
+import static java.util.Collections.singleton;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+/**
+ * {@link BpmTaskAssignRuleService} 的单元测试
+ *
+ * @author 芋道源码
+ */
+@Import({BpmTaskAssignRuleServiceImpl.class, BpmTaskAssignStartUserScript.class}) // Import 引入 BpmTaskAssignStartUserScript 目的是保证不报错
+public class BpmTaskAssignRuleServiceImplTest extends BaseDbUnitTest {
+
+    @Resource
+    private BpmTaskAssignRuleServiceImpl bpmTaskRuleService;
+
+    @MockBean
+    private BpmUserGroupService userGroupService;
+    @MockBean
+    private DeptApi deptApi;
+    @MockBean
+    private AdminUserApi adminUserApi;
+    @MockBean
+    private PermissionApi permissionApi;
+    @MockBean
+    private RoleApi roleApi;
+    @MockBean
+    private PostApi postApi;
+    @MockBean
+    private DictDataApi dictDataApi;
+
+    @Test
+    public void testCalculateTaskCandidateUsers_Role() {
+        // 准备参数
+        BpmTaskAssignRuleDO rule = new BpmTaskAssignRuleDO().setOptions(asSet(1L, 2L))
+                .setType(BpmTaskAssignRuleTypeEnum.ROLE.getType());
+        // mock 方法
+        when(permissionApi.getUserRoleIdListByRoleIds(eq(rule.getOptions())))
+                .thenReturn(success(asSet(11L, 22L)));
+        mockGetUserMap(asSet(11L, 22L));
+
+        // 调用
+        Set<Long> results = bpmTaskRuleService.calculateTaskCandidateUsers(null, rule);
+        // 断言
+        assertEquals(asSet(11L, 22L), results);
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_DeptMember() {
+        // 准备参数
+        BpmTaskAssignRuleDO rule = new BpmTaskAssignRuleDO().setOptions(asSet(1L, 2L))
+                .setType(BpmTaskAssignRuleTypeEnum.DEPT_MEMBER.getType());
+        // mock 方法
+        List<AdminUserRespDTO> users = CollectionUtils.convertList(asSet(11L, 22L),
+                id -> new AdminUserRespDTO().setId(id));
+        when(adminUserApi.getUsersByDeptIds(eq(rule.getOptions()))).thenReturn(success(users));
+        mockGetUserMap(asSet(11L, 22L));
+
+        // 调用
+        Set<Long> results = bpmTaskRuleService.calculateTaskCandidateUsers(null, rule);
+        // 断言
+        assertEquals(asSet(11L, 22L), results);
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_DeptLeader() {
+        // 准备参数
+        BpmTaskAssignRuleDO rule = new BpmTaskAssignRuleDO().setOptions(asSet(1L, 2L))
+                .setType(BpmTaskAssignRuleTypeEnum.DEPT_LEADER.getType());
+        // mock 方法
+        DeptRespDTO dept1 = randomPojo(DeptRespDTO.class, o -> o.setLeaderUserId(11L));
+        DeptRespDTO dept2 = randomPojo(DeptRespDTO.class, o -> o.setLeaderUserId(22L));
+        when(deptApi.getDepts(eq(rule.getOptions()))).thenReturn(success(Arrays.asList(dept1, dept2)));
+        mockGetUserMap(asSet(11L, 22L));
+
+        // 调用
+        Set<Long> results = bpmTaskRuleService.calculateTaskCandidateUsers(null, rule);
+        // 断言
+        assertEquals(asSet(11L, 22L), results);
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_Post() {
+        // 准备参数
+        BpmTaskAssignRuleDO rule = new BpmTaskAssignRuleDO().setOptions(asSet(1L, 2L))
+                .setType(BpmTaskAssignRuleTypeEnum.POST.getType());
+        // mock 方法
+        List<AdminUserRespDTO> users = CollectionUtils.convertList(asSet(11L, 22L),
+                id -> new AdminUserRespDTO().setId(id));
+        when(adminUserApi.getUsersByPostIds(eq(rule.getOptions()))).thenReturn(success(users));
+        mockGetUserMap(asSet(11L, 22L));
+
+        // 调用
+        Set<Long> results = bpmTaskRuleService.calculateTaskCandidateUsers(null, rule);
+        // 断言
+        assertEquals(asSet(11L, 22L), results);
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_User() {
+        // 准备参数
+        BpmTaskAssignRuleDO rule = new BpmTaskAssignRuleDO().setOptions(asSet(1L, 2L))
+                .setType(BpmTaskAssignRuleTypeEnum.USER.getType());
+        // mock 方法
+        mockGetUserMap(asSet(1L, 2L));
+
+        // 调用
+        Set<Long> results = bpmTaskRuleService.calculateTaskCandidateUsers(null, rule);
+        // 断言
+        assertEquals(asSet(1L, 2L), results);
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_UserGroup() {
+        // 准备参数
+        BpmTaskAssignRuleDO rule = new BpmTaskAssignRuleDO().setOptions(asSet(1L, 2L))
+                .setType(BpmTaskAssignRuleTypeEnum.USER_GROUP.getType());
+        // mock 方法
+        BpmUserGroupDO userGroup1 = randomPojo(BpmUserGroupDO.class, o -> o.setMemberUserIds(asSet(11L, 12L)));
+        BpmUserGroupDO userGroup2 = randomPojo(BpmUserGroupDO.class, o -> o.setMemberUserIds(asSet(21L, 22L)));
+        when(userGroupService.getUserGroupList(eq(rule.getOptions()))).thenReturn(Arrays.asList(userGroup1, userGroup2));
+        mockGetUserMap(asSet(11L, 12L, 21L, 22L));
+
+        // 调用
+        Set<Long> results = bpmTaskRuleService.calculateTaskCandidateUsers(null, rule);
+        // 断言
+        assertEquals(asSet(11L, 12L, 21L, 22L), results);
+    }
+
+    @Test
+    public void testCalculateTaskCandidateUsers_Script() {
+        // 准备参数
+        BpmTaskAssignRuleDO rule = new BpmTaskAssignRuleDO().setOptions(asSet(20L, 21L))
+                .setType(BpmTaskAssignRuleTypeEnum.SCRIPT.getType());
+        // mock 方法
+        BpmTaskAssignScript script1 = new BpmTaskAssignScript() {
+
+            @Override
+            public Set<Long> calculateTaskCandidateUsers(DelegateExecution task) {
+                return singleton(11L);
+            }
+
+            @Override
+            public BpmTaskRuleScriptEnum getEnum() {
+                return BpmTaskRuleScriptEnum.LEADER_X1;
+            }
+        };
+        BpmTaskAssignScript script2 = new BpmTaskAssignScript() {
+
+            @Override
+            public Set<Long> calculateTaskCandidateUsers(DelegateExecution task) {
+                return singleton(22L);
+            }
+
+            @Override
+            public BpmTaskRuleScriptEnum getEnum() {
+                return BpmTaskRuleScriptEnum.LEADER_X2;
+            }
+        };
+        bpmTaskRuleService.setScripts(Arrays.asList(script1, script2));
+        mockGetUserMap(asSet(11L, 22L));
+
+        // 调用
+        Set<Long> results = bpmTaskRuleService.calculateTaskCandidateUsers(null, rule);
+        // 断言
+        assertEquals(asSet(11L, 22L), results);
+    }
+
+    @Test
+    public void testRemoveDisableUsers() {
+        // 准备参数. 1L 可以找到；2L 是禁用的；3L 找不到
+        Set<Long> assigneeUserIds = asSet(1L, 2L, 3L);
+        // mock 方法
+        AdminUserRespDTO user1 = randomPojo(AdminUserRespDTO.class, o -> o.setId(1L)
+                .setStatus(CommonStatusEnum.ENABLE.getStatus()));
+        AdminUserRespDTO user2 = randomPojo(AdminUserRespDTO.class, o -> o.setId(2L)
+                .setStatus(CommonStatusEnum.DISABLE.getStatus()));
+        Map<Long, AdminUserRespDTO> userMap = MapUtil.builder(user1.getId(), user1)
+                .put(user2.getId(), user2).build();
+        when(adminUserApi.getUserMap(eq(assigneeUserIds))).thenReturn(userMap);
+
+        // 调用
+        bpmTaskRuleService.removeDisableUsers(assigneeUserIds);
+        // 断言
+        assertEquals(asSet(1L), assigneeUserIds);
+    }
+
+    private void mockGetUserMap(Set<Long> assigneeUserIds) {
+        Map<Long, AdminUserRespDTO> userMap = CollectionUtils.convertMap(assigneeUserIds, id -> id,
+                id -> new AdminUserRespDTO().setId(id).setStatus(CommonStatusEnum.ENABLE.getStatus()));
+        when(adminUserApi.getUserMap(eq(assigneeUserIds))).thenReturn(userMap);
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/test/java/cn/iocoder/yudao/module/bpm/service/definition/BpmUserGroupServiceTest.java

+package cn.iocoder.yudao.module.bpm.service.definition;
+
+import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
+import cn.iocoder.yudao.framework.common.pojo.PageResult;
+import cn.iocoder.yudao.framework.common.util.date.DateUtils;
+import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
+import cn.iocoder.yudao.framework.test.core.util.AssertUtils;
+import cn.iocoder.yudao.framework.test.core.util.RandomUtils;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupCreateReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupPageReqVO;
+import cn.iocoder.yudao.module.bpm.controller.admin.definition.vo.group.BpmUserGroupUpdateReqVO;
+import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmUserGroupDO;
+import cn.iocoder.yudao.module.bpm.dal.mysql.definition.BpmUserGroupMapper;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.context.annotation.Import;
+
+import javax.annotation.Resource;
+
+import java.util.Date;
+
+import static cn.iocoder.yudao.framework.common.util.date.DateUtils.buildTime;
+import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.cloneIgnoreId;
+import static cn.iocoder.yudao.module.bpm.enums.ErrorCodeConstants.USER_GROUP_NOT_EXISTS;
+
+/**
+* {@link BpmUserGroupServiceImpl} 的单元测试类
+*
+* @author 芋道源码
+*/
+@Import(BpmUserGroupServiceImpl.class)
+public class BpmUserGroupServiceTest extends BaseDbUnitTest {
+
+    @Resource
+    private BpmUserGroupServiceImpl userGroupService;
+
+    @Resource
+    private BpmUserGroupMapper userGroupMapper;
+
+    @Test
+    public void testCreateUserGroup_success() {
+        // 准备参数
+        BpmUserGroupCreateReqVO reqVO = RandomUtils.randomPojo(BpmUserGroupCreateReqVO.class);
+
+        // 调用
+        Long userGroupId = userGroupService.createUserGroup(reqVO);
+        // 断言
+        Assertions.assertNotNull(userGroupId);
+        // 校验记录的属性是否正确
+        BpmUserGroupDO userGroup = userGroupMapper.selectById(userGroupId);
+        AssertUtils.assertPojoEquals(reqVO, userGroup);
+    }
+
+    @Test
+    public void testUpdateUserGroup_success() {
+        // mock 数据
+        BpmUserGroupDO dbUserGroup = RandomUtils.randomPojo(BpmUserGroupDO.class);
+        userGroupMapper.insert(dbUserGroup);// @Sql: 先插入出一条存在的数据
+        // 准备参数
+        BpmUserGroupUpdateReqVO reqVO = RandomUtils.randomPojo(BpmUserGroupUpdateReqVO.class, o -> {
+            o.setId(dbUserGroup.getId()); // 设置更新的 ID
+        });
+
+        // 调用
+        userGroupService.updateUserGroup(reqVO);
+        // 校验是否更新正确
+        BpmUserGroupDO userGroup = userGroupMapper.selectById(reqVO.getId()); // 获取最新的
+        AssertUtils.assertPojoEquals(reqVO, userGroup);
+    }
+
+    @Test
+    public void testUpdateUserGroup_notExists() {
+        // 准备参数
+        BpmUserGroupUpdateReqVO reqVO = RandomUtils.randomPojo(BpmUserGroupUpdateReqVO.class);
+
+        // 调用, 并断言异常
+        AssertUtils.assertServiceException(() -> userGroupService.updateUserGroup(reqVO), USER_GROUP_NOT_EXISTS);
+    }
+
+    @Test
+    public void testDeleteUserGroup_success() {
+        // mock 数据
+        BpmUserGroupDO dbUserGroup = RandomUtils.randomPojo(BpmUserGroupDO.class);
+        userGroupMapper.insert(dbUserGroup);// @Sql: 先插入出一条存在的数据
+        // 准备参数
+        Long id = dbUserGroup.getId();
+
+        // 调用
+        userGroupService.deleteUserGroup(id);
+       // 校验数据不存在了
+       Assertions.assertNull(userGroupMapper.selectById(id));
+    }
+
+    @Test
+    public void testDeleteUserGroup_notExists() {
+        // 准备参数
+        Long id = RandomUtils.randomLongId();
+
+        // 调用, 并断言异常
+        AssertUtils.assertServiceException(() -> userGroupService.deleteUserGroup(id), USER_GROUP_NOT_EXISTS);
+    }
+
+    @Test
+    public void testGetUserGroupPage() {
+       // mock 数据
+       BpmUserGroupDO dbUserGroup = RandomUtils.randomPojo(BpmUserGroupDO.class, o -> { // 等会查询到
+           o.setName("芋道源码");
+           o.setStatus(CommonStatusEnum.ENABLE.getStatus());
+           o.setCreateTime(DateUtils.buildTime(2021, 11, 11));
+       });
+       userGroupMapper.insert(dbUserGroup);
+       // 测试 name 不匹配
+       userGroupMapper.insert(cloneIgnoreId(dbUserGroup, o -> o.setName("芋道")));
+       // 测试 status 不匹配
+       userGroupMapper.insert(cloneIgnoreId(dbUserGroup, o -> o.setStatus(CommonStatusEnum.DISABLE.getStatus())));
+       // 测试 createTime 不匹配
+       userGroupMapper.insert(cloneIgnoreId(dbUserGroup, o -> o.setCreateTime(DateUtils.buildTime(2021, 12, 12))));
+       // 准备参数
+       BpmUserGroupPageReqVO reqVO = new BpmUserGroupPageReqVO();
+       reqVO.setName("源码");
+       reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
+       reqVO.setCreateTime((new Date[]{buildTime(2021, 11, 10),buildTime(2021, 11, 12)}));
+
+       // 调用
+       PageResult<BpmUserGroupDO> pageResult = userGroupService.getUserGroupPage(reqVO);
+       // 断言
+       Assertions.assertEquals(1, pageResult.getTotal());
+       Assertions.assertEquals(1, pageResult.getList().size());
+       AssertUtils.assertPojoEquals(dbUserGroup, pageResult.getList().get(0));
+    }
+
+}

yudao-module-bpm/yudao-module-bpm-biz/src/test/resources/application-unit-test.yaml

+spring:
+  main:
+    lazy-initialization: true # 开启懒加载，加快速度
+    banner-mode: off # 单元测试，禁用 Banner
+
+--- #################### 数据库相关配置 ####################
+
+spring:
+  # 数据源配置项
+  datasource:
+    name: ruoyi-vue-pro
+    url: jdbc:h2:mem:testdb;MODE=MYSQL;DATABASE_TO_UPPER=false; # MODE 使用 MySQL 模式；DATABASE_TO_UPPER 配置表和字段使用小写
+    driver-class-name: org.h2.Driver
+    username: sa
+    password:
+    druid:
+      async-init: true # 单元测试，异步初始化 Druid 连接池，提升启动速度
+      initial-size: 1 # 单元测试，配置为 1，提升启动速度
+  sql:
+    init:
+      schema-locations: classpath:/sql/create_tables.sql
+
+mybatis-plus:
+  lazy-initialization: true # 单元测试，设置 MyBatis Mapper 延迟加载，加速每个单元测试
+  type-aliases-package: ${yudao.info.base-package}.module.*.dal.dataobject
+
+--- #################### 定时任务相关配置 ####################
+
+--- #################### 配置中心相关配置 ####################
+
+--- #################### 服务保障相关配置 ####################
+
+# Lock4j 配置项（单元测试，禁用 Lock4j）
+
+# Resilience4j 配置项
+
+--- #################### 监控相关配置 ####################
+
+--- #################### 芋道相关配置 ####################
+
+# 芋道配置项，设置当前项目所有自定义的配置
+yudao:
+  info:
+    base-package: cn.iocoder.yudao.module

yudao-module-bpm/yudao-module-bpm-biz/src/test/resources/logback.xml

+<configuration>
+    <!-- 引用 Spring Boot 的 logback 基础配置 -->
+    <include resource="org/springframework/boot/logging/logback/defaults.xml" />
+</configuration>

yudao-module-bpm/yudao-module-bpm-biz/src/test/resources/sql/clean.sql

+DELETE FROM "bpm_form";
+DELETE FROM "bpm_user_group";

yudao-module-bpm/yudao-module-bpm-biz/src/test/resources/sql/create_tables.sql

+CREATE TABLE IF NOT EXISTS "bpm_user_group" (
+    "id" bigint NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+    "name" varchar(63) NOT NULL,
+    "description" varchar(255) NOT NULL,
+    "status" tinyint NOT NULL,
+    "member_user_ids" varchar(255) NOT NULL,
+    "creator" varchar(64) DEFAULT '',
+    "create_time" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updater" varchar(64) DEFAULT '',
+    "update_time" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "deleted" bit NOT NULL DEFAULT FALSE,
+    PRIMARY KEY ("id")
+) COMMENT '用户组';
+
+CREATE TABLE IF NOT EXISTS "bpm_form" (
+    "id" bigint NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+    "name" varchar(63) NOT NULL,
+    "status" tinyint NOT NULL,
+    "fields" varchar(255) NOT NULL,
+    "conf" varchar(255) NOT NULL,
+    "remark" varchar(255),
+    "creator" varchar(64) DEFAULT '',
+    "create_time" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updater" varchar(64) DEFAULT '',
+    "update_time" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "deleted" bit NOT NULL DEFAULT FALSE,
+    PRIMARY KEY ("id")
+) COMMENT '动态表单';

yudao-module-infra/yudao-module-infra-biz/src/main/resources/application.yaml

@@ -75,7 +75,7 @@ spring:
           name-server: 127.0.0.1:9876 # RocketMQ Namesrv 地址
         default: # 默认 bindings 全局配置
           producer: # RocketMQ Producer 配置项，对应 RocketMQProducerProperties 类
-            group: system_producer_group # 生产者分组
+            group: infra_producer_group # 生产者分组
             send-type: SYNC # 发送模式，SYNC 同步
 
     # Spring Cloud Bus 配置项，对应 BusProperties 类