ref(flow-biz) 合并 flow-task 、flow-engine 模块

pigx-flow/pigx-flow-api/pom.xml

@@ -6,11 +6,11 @@
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>com.pig4cloud</groupId>
-        <artifactId>pigx-flow-task</artifactId>
-        <version>5.9.0</version>
+        <artifactId>pigx-flow</artifactId>
+        <version>5.10.2-SNAPSHOT</version>
     </parent>
 
-    <artifactId>pigx-flow-task-api</artifactId>
+    <artifactId>pigx-flow-api</artifactId>
 
     <dependencies>
         <!--core 工具类-->

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/api/feign/RemoteFlowApiFlowService.java

@@ -0,0 +1,72 @@
+package com.pig4cloud.pigx.flow.api.feign;
+
+import com.pig4cloud.pigx.common.core.constant.ServiceNameConstants;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.ProcessInstanceParamDto;
+import com.pig4cloud.pigx.flow.vo.FormGroupVo;
+import com.pig4cloud.pigx.flow.vo.ProcessVO;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.List;
+
+/**
+ * 远程流程API服务接口
+ * <p>
+ * 通过Feign客户端调用流程服务的远程接口，提供流程相关的核心功能。
+ * 主要包括流程查询、流程启动等操作。该接口用于微服务间的远程调用，
+ * 使其他服务能够便捷地使用流程引擎的功能。
+ * </p>
+ * 
+ * @author lengleng
+ * @date 2025/07/12
+ */
+@FeignClient(contextId = "remoteFlowApiFlowService", value = ServiceNameConstants.FLOW_SERVER)
+public interface RemoteFlowApiFlowService {
+
+	/**
+	 * 查询当前用户可发起的流程列表
+	 * <p>
+	 * 根据当前登录用户的权限，查询该用户有权发起的所有流程。
+	 * 返回结果按分组组织，方便前端展示。
+	 * </p>
+	 * 
+	 * @return 分组后的流程列表，包含分组信息和各分组下的流程
+	 */
+	@GetMapping("/combination/group/listCurrentUserStartGroup")
+	R<List<FormGroupVo>> listCurrentUserStartGroup();
+
+	/**
+	 * 获取流程详细信息
+	 * <p>
+	 * 根据流程ID获取流程的完整配置信息，包括：
+	 * - 流程基本信息（名称、图标、描述等）
+	 * - 表单配置（表单项定义、验证规则等）
+	 * - 流程配置（节点定义、流转规则等）
+	 * </p>
+	 * 
+	 * @param flowId 流程定义ID
+	 * @return 流程详细信息视图对象
+	 */
+	@GetMapping("/process/getDetail")
+	R<ProcessVO> getDetail(@RequestParam("flowId") String flowId);
+
+	/**
+	 * 启动流程实例
+	 * <p>
+	 * 根据流程定义创建新的流程实例。启动流程时需要提供：
+	 * - 流程ID
+	 * - 表单数据
+	 * - 需要自选的节点执行人信息
+	 * </p>
+	 * 
+	 * @param paramDto 流程实例启动参数，包含流程ID、表单数据等
+	 * @return 启动成功后的流程实例ID
+	 */
+	@PostMapping("/process-instance/startProcessInstance")
+	R<String> startProcessInstance(@RequestBody ProcessInstanceParamDto paramDto);
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/api/feign/packge-info.java

@@ -3,4 +3,4 @@
  * <p>
  * feign client 存放目录，注意 @EnablePigxFeignClients 的扫描范围
  */
-package com.pig4cloud.pigx.flow.task.api.feign;
+package com.pig4cloud.pigx.flow.api.feign;

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/constant/FormTypeEnum.java

@@ -0,0 +1,156 @@
+package com.pig4cloud.pigx.flow.constant;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.ArrayList;
+
+/**
+ * 表单类型枚举
+ * <p>
+ * 定义流程表单中支持的所有控件类型。每种类型对应不同的表单组件，
+ * 用于构建动态表单，收集流程执行过程中所需的各类数据。
+ * </p>
+ *
+ * @author pigx
+ * @since 2024/01/01
+ */
+@Getter
+@RequiredArgsConstructor
+public enum FormTypeEnum {
+
+	/**
+	 * 单行文本输入框
+	 * <p>
+	 * 用于输入简短的文本内容，如姓名、标题等。
+	 * 默认值为空字符串。
+	 * </p>
+	 */
+	INPUT("Input", "单行文本", ""),
+	
+	/**
+	 * 多行文本输入框
+	 * <p>
+	 * 用于输入较长的文本内容，如描述、备注等。
+	 * 支持换行输入，默认值为空字符串。
+	 * </p>
+	 */
+	TEXTAREA("Textarea", "多行文本", ""),
+	
+	/**
+	 * 数字输入框
+	 * <p>
+	 * 用于输入数字类型的数据，支持整数和小数。
+	 * 可设置最大值、最小值等限制。
+	 * </p>
+	 */
+	NUMBER("Number", "数字", null),
+	
+	/**
+	 * 日期选择器
+	 * <p>
+	 * 用于选择日期，格式为 yyyy-MM-dd。
+	 * 不包含时间部分。
+	 * </p>
+	 */
+	DATE("Date", "日期", null),
+	
+	/**
+	 * 日期时间选择器
+	 * <p>
+	 * 用于选择日期和时间，格式为 yyyy-MM-dd HH:mm:ss。
+	 * 包含完整的日期时间信息。
+	 * </p>
+	 */
+	DATE_TIME("DateTime", "日期时间", null),
+
+	/**
+	 * 序列号生成器
+	 * <p>
+	 * 自动生成唯一的序列号，如单据编号、流水号等。
+	 * 支持自定义前缀、后缀和序列规则。
+	 * </p>
+	 */
+	SEQUENCE("Sequence", "发号器", null),
+	
+	/**
+	 * 明细表格布局
+	 * <p>
+	 * 用于创建子表单，支持动态增减行。
+	 * 适用于需要录入多条明细数据的场景，如报销明细、订单明细等。
+	 * </p>
+	 */
+	LAYOUT("Layout", "明细", null),
+	
+	/**
+	 * 时间选择器
+	 * <p>
+	 * 用于选择时间，格式为 HH:mm:ss。
+	 * 仅包含时间部分，不包含日期。
+	 * </p>
+	 */
+	TIME("Time", "时间", null),
+	
+	/**
+	 * 金额输入框
+	 * <p>
+	 * 专门用于输入货币金额，支持千分位显示。
+	 * 自动保留两位小数，支持大写金额转换。
+	 * </p>
+	 */
+	MONEY("Money", "金额", null),
+	
+	/**
+	 * 单选下拉框
+	 * <p>
+	 * 从预定义选项中选择一个值。
+	 * 默认值为空列表，需要配置选项数据。
+	 * </p>
+	 */
+	SINGLE_SELECT("SingleSelect", "单选", new ArrayList<>()),
+	
+	/**
+	 * 部门选择器
+	 * <p>
+	 * 从组织架构中选择部门。
+	 * 支持树形结构展示，可配置单选或多选。
+	 * </p>
+	 */
+	SELECT_DEPT("SelectDept", "部门", new ArrayList<>()),
+	
+	/**
+	 * 用户选择器
+	 * <p>
+	 * 从系统用户中选择人员。
+	 * 支持按部门、角色筛选，可配置单选或多选。
+	 * </p>
+	 */
+	SELECT_USER("SelectUser", "用户", new ArrayList<>()),
+
+	;
+
+	/**
+	 * 表单类型标识
+	 * <p>
+	 * 前端组件类型的唯一标识符
+	 * </p>
+	 */
+	private final String type;
+
+	/**
+	 * 表单类型名称
+	 * <p>
+	 * 用于界面显示的中文名称
+	 * </p>
+	 */
+	private final String name;
+
+	/**
+	 * 默认值
+	 * <p>
+	 * 该类型表单项的默认值，可以是字符串、数字、列表等
+	 * </p>
+	 */
+	private final Object defaultValue;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/constant/IBaseEnum.java

@@ -0,0 +1,113 @@
+package com.pig4cloud.pigx.flow.constant;
+
+import cn.hutool.core.util.ObjectUtil;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+/**
+ * 枚举通用接口
+ * <p>
+ * 为所有业务枚举提供统一的接口规范，实现枚举值和标签的标准化管理。
+ * 提供了根据值获取枚举、根据值获取标签、根据标签获取值等通用方法。
+ * 所有业务枚举类都应实现此接口，以保证枚举使用的一致性。
+ * </p>
+ *
+ * @param <T> 枚举值的类型，通常为Integer或String
+ * @author haoxr
+ * @since 2022/3/27 12:06
+ */
+public interface IBaseEnum<T> {
+
+	/**
+	 * 获取枚举值
+	 * <p>
+	 * 返回枚举对应的实际值，通常用于数据库存储或接口传输
+	 * </p>
+	 *
+	 * @return 枚举对应的值
+	 */
+	T getValue();
+
+	/**
+	 * 获取枚举标签
+	 * <p>
+	 * 返回枚举对应的显示标签，通常用于界面展示
+	 * </p>
+	 *
+	 * @return 枚举对应的中文标签
+	 */
+	String getLabel();
+
+	/**
+	 * 根据值获取对应的枚举实例
+	 * <p>
+	 * 通过枚举值查找对应的枚举实例，常用于数据库查询结果的转换。
+	 * 如果找不到匹配的枚举，返回null。
+	 * </p>
+	 *
+	 * @param value 枚举值
+	 * @param clazz 枚举类的Class对象
+	 * @param <E>   枚举类型，必须实现IBaseEnum接口
+	 * @return 匹配的枚举实例，如果没有找到返回null
+	 */
+	static <E extends Enum<E> & IBaseEnum> E getEnumByValue(Object value, Class<E> clazz) {
+		Objects.requireNonNull(value);
+		EnumSet<E> allEnums = EnumSet.allOf(clazz); // 获取类型下的所有枚举
+		E matchEnum = allEnums.stream().filter(e -> ObjectUtil.equal(e.getValue(), value)).findFirst().orElse(null);
+		return matchEnum;
+	}
+
+	/**
+	 * 根据值获取对应的标签
+	 * <p>
+	 * 通过枚举值直接获取对应的显示标签，常用于列表展示时的值转换。
+	 * 如果找不到匹配的枚举，返回null。
+	 * </p>
+	 *
+	 * @param value 枚举值
+	 * @param clazz 枚举类的Class对象
+	 * @param <E>   枚举类型，必须实现IBaseEnum接口
+	 * @return 枚举对应的标签，如果没有找到返回null
+	 */
+	static <E extends Enum<E> & IBaseEnum> String getLabelByValue(Object value, Class<E> clazz) {
+		Objects.requireNonNull(value);
+		EnumSet<E> allEnums = EnumSet.allOf(clazz); // 获取类型下的所有枚举
+		E matchEnum = allEnums.stream().filter(e -> ObjectUtil.equal(e.getValue(), value)).findFirst().orElse(null);
+
+		String label = null;
+		if (matchEnum != null) {
+			label = matchEnum.getLabel();
+		}
+		return label;
+	}
+
+	/**
+	 * 根据标签获取对应的值
+	 * <p>
+	 * 通过枚举标签反向查找对应的枚举值，常用于表单提交时的数据转换。
+	 * 如果找不到匹配的枚举，返回null。
+	 * </p>
+	 *
+	 * @param label 枚举标签
+	 * @param clazz 枚举类的Class对象
+	 * @param <E>   枚举类型，必须实现IBaseEnum接口
+	 * @return 枚举对应的值，如果没有找到返回null
+	 */
+	static <E extends Enum<E> & IBaseEnum> Object getValueByLabel(String label, Class<E> clazz) {
+		Objects.requireNonNull(label);
+		EnumSet<E> allEnums = EnumSet.allOf(clazz); // 获取类型下的所有枚举
+		String finalLabel = label;
+		E matchEnum = allEnums.stream()
+			.filter(e -> ObjectUtil.equal(e.getLabel(), finalLabel))
+			.findFirst()
+			.orElse(null);
+
+		Object value = null;
+		if (matchEnum != null) {
+			value = matchEnum.getValue();
+		}
+		return value;
+	}
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/constant/NodeStatusEnum.java

@@ -0,0 +1,96 @@
+package com.pig4cloud.pigx.flow.constant;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+/**
+ * 流程节点状态枚举
+ * <p>
+ * 定义流程节点的执行状态，用于追踪每个节点在流程实例中的处理进度。
+ * 状态变化遵循：未开始 -> 进行中 -> 已结束的生命周期。
+ * </p>
+ *
+ * @author pigx
+ * @since 2024/01/01
+ */
+@Getter
+@RequiredArgsConstructor
+public enum NodeStatusEnum {
+
+    /**
+     * 未开始
+     * <p>
+     * 节点已创建但尚未开始执行。
+     * 表示流程已到达该节点的前置节点，但该节点还未被激活。
+     * </p>
+     */
+    WKS(0, "未开始"),
+    
+    /**
+     * 进行中
+     * <p>
+     * 节点正在执行中，等待审批人处理或系统任务完成。
+     * 对于审批节点，表示已分配给审批人但尚未完成审批。
+     * </p>
+     */
+    JXZ(1, "进行中"),
+    
+    /**
+     * 已结束
+     * <p>
+     * 节点已完成执行，流程可以继续流转到下一节点。
+     * 包括正常完成、跳过、驳回等所有结束状态。
+     * </p>
+     */
+    YJS(2, "已结束");
+
+    /**
+     * 状态编码
+     * <p>
+     * 节点状态的数字编码，用于数据库存储和状态比较
+     * </p>
+     */
+    private final int code;
+
+    /**
+     * 状态名称
+     * <p>
+     * 节点状态的中文描述，用于界面显示
+     * </p>
+     */
+    private final String name;
+
+    /**
+     * 根据状态编码获取枚举实例
+     *
+     * @param code 状态编码
+     * @return 对应的枚举实例，如果找不到返回null
+     */
+    public static NodeStatusEnum getByCode(int code) {
+        for (NodeStatusEnum status : values()) {
+            if (status.getCode() == code) {
+                return status;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 判断节点是否可以处理
+     *
+     * @return true表示节点可以被处理，false表示不能处理
+     */
+    public boolean canProcess() {
+        return this == JXZ;
+    }
+
+    /**
+     * 判断节点是否已完成
+     *
+     * @return true表示节点已完成，false表示未完成
+     */
+    public boolean isFinished() {
+        return this == YJS;
+    }
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/constant/NodeTypeEnum.java

@@ -0,0 +1,82 @@
+package com.pig4cloud.pigx.flow.constant;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Arrays;
+
+/**
+ * 流程节点类型枚举
+ * <p>
+ * 定义流程中所有可用的节点类型，每种节点类型在流程中有不同的作用和行为。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Getter
+@RequiredArgsConstructor
+public enum NodeTypeEnum {
+
+	/**
+	 * 根节点 - 流程的起始点，每个流程必须有且只有一个根节点
+	 */
+	ROOT("根节点", 0, false),
+	
+	/**
+	 * 结束节点 - 流程的终止点，标识流程执行完成
+	 */
+	END("结束节点", -1, false),
+
+	/**
+	 * 审批节点 - 需要用户进行审批操作的节点，支持单人或多人审批
+	 */
+	APPROVAL("审批节点", 1, false),
+	
+	/**
+	 * 抄送节点 - 仅用于通知，不阻塞流程执行，抄送人只需查看无需审批
+	 */
+	CC("抄送节点", 2, false),
+	
+	/**
+	 * 条件分支 - 根据表单数据或表达式判断流程走向，只会选择一条分支执行
+	 */
+	EXCLUSIVE_GATEWAY("条件分支", 4, true),
+
+	/**
+	 * 并行分支 - 同时执行多条分支，所有分支都完成后才能继续后续流程
+	 */
+	PARALLEL_GATEWAY("并行分支", 5, true),
+	
+	/**
+	 * 空节点 - 占位节点，用于流程设计时的过渡
+	 */
+	EMPTY("空", 3, false);
+
+	/**
+	 * 节点名称
+	 */
+	private final String name;
+
+	/**
+	 * 节点类型值
+	 */
+	private final Integer value;
+
+	/**
+	 * 是否为分支节点
+	 * true=分支节点（如条件分支、并行分支），false=普通节点
+	 */
+	private final Boolean branch;
+
+	/**
+	 * 根据节点类型值获取枚举实例
+	 * 
+	 * @param value 节点类型值
+	 * @return 对应的节点类型枚举，找不到返回null
+	 */
+
+	public static NodeTypeEnum getByValue(int value) {
+		return Arrays.stream(NodeTypeEnum.values()).filter(w -> w.getValue() == value).findAny().orElse(null);
+	}
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/constant/NodeUserTypeEnum.java

@@ -0,0 +1,19 @@
+package com.pig4cloud.pigx.flow.constant;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+/**
+ * 用户节点类型枚举
+ */
+@Getter
+@RequiredArgsConstructor
+public enum NodeUserTypeEnum {
+
+	USER("user", "用户"), DEPT("dept", "部门"), ROLE("role", "角色"), POST("post", "岗位");
+
+	private final String key;
+
+	private final String name;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/constant/packge-info.java

@@ -3,4 +3,4 @@
  * <p>
  * 常量和枚举定义
  */
-package com.pig4cloud.pigx.flow.task.constant;
+package com.pig4cloud.pigx.flow.constant;

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/CheckChildDto.java

@@ -0,0 +1,36 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 子部门检查数据传输对象
+ * <p>
+ * 该DTO用于检查指定的子部门是否属于给定的父部门列表中的任意一个。
+ * 主要用于流程中判断审批人是否在指定部门范围内的场景。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class CheckChildDto {
+
+	/**
+	 * 需要检查的子部门ID
+	 * <p>
+	 * 要验证是否为指定父部门子部门的部门ID
+	 * </p>
+	 */
+	private Long childId;
+
+	/**
+	 * 父部门ID列表
+	 * <p>
+	 * 包含所有需要检查的父部门ID。
+	 * 如果childId是这个列表中任意一个部门的子部门（直接或间接），则检查通过。
+	 * </p>
+	 */
+	private List<Long> deptIdList;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/CheckParentDto.java

@@ -0,0 +1,36 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 父部门检查数据传输对象
+ * <p>
+ * 该DTO用于检查指定的父部门是否为给定部门列表中任意一个的父部门。
+ * 主要用于流程中验证部门层级关系，判断审批人是否具有对某些部门的管辖权限。
+ * </p>
+ *
+ * @author pigx
+ */
+@Data
+public class CheckParentDto {
+
+	/**
+	 * 需要检查的父部门ID
+	 * <p>
+	 * 要验证是否为指定部门列表父部门的部门ID
+	 * </p>
+	 */
+	private Long parentId;
+
+	/**
+	 * 子部门ID列表
+	 * <p>
+	 * 包含所有需要检查的子部门ID。
+	 * 如果parentId是这个列表中任意一个部门的父部门（直接或间接），则检查通过。
+	 * </p>
+	 */
+	private List<Long> deptIdList;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/Condition.java

@@ -0,0 +1,67 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+/**
+ * 流程条件数据传输对象
+ * <p>
+ * 该DTO用于定义流程节点的单个执行条件。条件由键、表达式和值组成，
+ * 用于判断流程是否满足某个分支或节点的执行要求。
+ * 常用于条件分支节点，根据表单数据判断流程走向。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class Condition {
+
+	/**
+	 * 条件键（字段标识）
+	 * <p>
+	 * 对应表单中的字段ID或变量名，如 "amount"、"deptId" 等。
+	 * 用于标识需要判断的数据字段。
+	 * </p>
+	 */
+	private String key;
+
+	/**
+	 * 条件表达式
+	 * <p>
+	 * 定义判断逻辑的表达式，支持的表达式类型包括：
+	 * - EQ: 等于
+	 * - NE: 不等于
+	 * - GT: 大于
+	 * - GE: 大于等于
+	 * - LT: 小于
+	 * - LE: 小于等于
+	 * - IN: 包含在
+	 * - NOT_IN: 不包含在
+	 * - CONTAINS: 包含（字符串）
+	 * - NOT_CONTAINS: 不包含（字符串）
+	 * - EMPTY: 为空
+	 * - NOT_EMPTY: 不为空
+	 * </p>
+	 */
+	private String expression;
+
+	/**
+	 * 条件值
+	 * <p>
+	 * 与表达式配合使用的比较值。
+	 * 类型可以是字符串、数字、日期、数组等，具体取决于字段类型和表达式。
+	 * 例如：金额大于1000时，value=1000；部门包含在[1,2,3]时，value=[1,2,3]
+	 * </p>
+	 */
+	private Object value;
+
+	/**
+	 * 字段类型
+	 * <p>
+	 * 标识条件键对应的数据类型，用于正确解析和比较数据。
+	 * 常见类型：INPUT（输入框）、NUMBER（数字）、DATE（日期）、
+	 * SELECT_USER（选择用户）、SELECT_DEPT（选择部门）等
+	 * </p>
+	 */
+	private String keyType;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/GroupCondition.java

@@ -0,0 +1,40 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 分组条件数据传输对象
+ * <p>
+ * 该DTO用于定义一组条件的逻辑关系。可以将多个条件组合在一起，
+ * 通过AND（与）或OR（或）的方式进行逻辑运算，用于复杂的流程条件判断。
+ * 常用于条件分支节点，支持构建复杂的条件表达式。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class GroupCondition {
+
+	/**
+	 * 条件组合模式
+	 * <p>
+	 * 定义条件列表中各个条件之间的逻辑关系：
+	 * - true: AND模式，所有条件都必须满足（与关系）
+	 * - false: OR模式，满足任意一个条件即可（或关系）
+	 * </p>
+	 */
+	private Boolean mode;
+
+	/**
+	 * 条件列表
+	 * <p>
+	 * 包含该分组下的所有条件。
+	 * 这些条件会根据mode字段指定的逻辑关系进行组合判断。
+	 * 每个条件包含键、表达式、值等信息，用于具体的条件判断。
+	 * </p>
+	 */
+	private List<Condition> conditionList;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/IndexPageStatistics.java

@@ -0,0 +1,60 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 首页统计数据传输对象
+ * <p>
+ * 该DTO用于传输流程系统首页的统计数据，包括待办任务、已发起流程、
+ * 抄送任务和已完成任务的数量统计。主要用于首页仪表盘的数据展示，
+ * 帮助用户快速了解当前的工作状态和任务情况。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class IndexPageStatistics {
+
+	/**
+	 * 待办任务数量
+	 * <p>
+	 * 当前用户需要处理的待办任务总数。
+	 * 包括所有分配给当前用户但尚未完成的审批任务。
+	 * </p>
+	 */
+	private Long pendingNum;
+
+	/**
+	 * 已发起流程数量
+	 * <p>
+	 * 当前用户发起的所有流程实例总数。
+	 * 包括进行中、已完成和已终止的流程。
+	 * </p>
+	 */
+	private Long startedNum;
+
+	/**
+	 * 抄送任务数量
+	 * <p>
+	 * 抄送给当前用户的任务总数。
+	 * 这些任务仅供查看，不需要用户进行审批操作。
+	 * </p>
+	 */
+	private Long copyNum;
+
+	/**
+	 * 已完成任务数量
+	 * <p>
+	 * 当前用户已经完成的任务总数。
+	 * 包括所有已审批（同意或拒绝）的任务。
+	 * </p>
+	 */
+	private Long completedNum;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/Nobody.java

@@ -0,0 +1,43 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 无执行人处理策略数据传输对象
+ * <p>
+ * 该DTO用于定义当流程节点找不到执行人时的处理策略。
+ * 在实际流程执行中，可能因为人员离职、角色变更等原因导致节点无法找到执行人，
+ * 此时需要根据预定义的策略进行处理，如自动通过、转交管理员、指定默认审批人等。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class Nobody {
+
+	/**
+	 * 处理策略
+	 * <p>
+	 * 定义当节点找不到执行人时的处理方式：
+	 * - TO_PASS: 自动通过，节点自动完成
+	 * - TO_REFUSE: 自动拒绝，节点自动拒绝
+	 * - TO_ADMIN: 转交给管理员处理
+	 * - TO_USER: 转交给指定用户处理
+	 * - TO_END: 直接结束流程
+	 * </p>
+	 */
+	private String handler;
+
+	/**
+	 * 指定的处理人列表
+	 * <p>
+	 * 当handler为TO_USER时，指定接收任务的用户列表。
+	 * 包含用户的ID、名称、类型等信息。
+	 * 如果handler为其他值，此字段可为空。
+	 * </p>
+	 */
+	private List<NodeUser> assignedUser;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/Node.java

@@ -141,4 +141,13 @@ public class Node {
 	 */
 	private Refuse refuse;
 
+	/** 条件类型 */
+	private Integer conditionType;
+
+	/** 表达式文本 */
+	private String expressionText;
+
+	/** 规则名称 */
+	private String ruleName;
+
 }

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/NodeHttpResultVO.java

@@ -0,0 +1,40 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.Map;
+
+/**
+ * 节点HTTP请求结果数据传输对象
+ * <p>
+ * 该DTO用于封装流程节点执行HTTP请求后的返回结果。
+ * 在流程执行过程中，某些节点可能需要调用外部系统的接口（如获取审批人、
+ * 验证业务数据等），此对象用于统一封装这些HTTP请求的响应结果。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class NodeHttpResultVO {
+
+	/**
+	 * 请求是否成功
+	 * <p>
+	 * 标识HTTP请求是否执行成功：
+	 * - true: 请求成功，data字段包含返回的业务数据
+	 * - false: 请求失败，data字段可能包含错误信息
+	 * </p>
+	 */
+	private Boolean ok;
+
+	/**
+	 * 返回的数据内容
+	 * <p>
+	 * HTTP请求返回的业务数据，以Map形式存储，便于灵活处理各种数据结构。
+	 * 成功时包含业务数据，失败时可能包含错误码、错误信息等。
+	 * 具体内容取决于调用的接口定义。
+	 * </p>
+	 */
+	private Map<String, Object> data;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/NodeUser.java

@@ -0,0 +1,74 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 节点用户数据传输对象
+ * <p>
+ * 该DTO用于表示流程节点的执行人信息。可以代表具体的用户、角色或部门，
+ * 用于流程节点的审批人配置、抄送人配置等场景。
+ * 支持多种类型的执行人，如指定用户、角色成员、部门成员等。
+ * </p>
+ * 
+ * @author pigx
+ */
+@NoArgsConstructor
+@Data
+@Builder
+@AllArgsConstructor
+public class NodeUser {
+
+	/**
+	 * 用户/角色/部门ID
+	 * <p>
+	 * 根据type字段的不同，此ID可能代表：
+	 * - 用户ID（当type为USER时）
+	 * - 角色ID（当type为ROLE时）
+	 * - 部门ID（当type为DEPT时）
+	 * </p>
+	 */
+	private Long id;
+
+	/**
+	 * 名称
+	 * <p>
+	 * 显示名称，如用户姓名、角色名称、部门名称等。
+	 * 用于在界面上展示给用户看。
+	 * </p>
+	 */
+	private String name;
+
+	/**
+	 * 类型标识
+	 * <p>
+	 * 标识该对象的类型：
+	 * - USER: 用户
+	 * - ROLE: 角色
+	 * - DEPT: 部门
+	 * - VARIABLE: 流程变量
+	 * </p>
+	 */
+	private String type;
+
+	/**
+	 * 是否选中
+	 * <p>
+	 * 在用户界面中标识该项是否被选中。
+	 * 主要用于前端交互，如在审批人选择列表中标记已选项。
+	 * </p>
+	 */
+	private Boolean selected;
+
+	/**
+	 * 用户头像URL
+	 * <p>
+	 * 用户的头像地址，仅当type为USER时有效。
+	 * 用于在界面上展示用户头像，提升用户体验。
+	 * </p>
+	 */
+	private String avatar;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/ProcessCopyDto.java

@@ -0,0 +1,92 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 流程抄送数据传输对象
+ * <p>
+ * 该DTO用于创建流程抄送记录。当流程执行到某个节点时，
+ * 可以将该节点的信息抄送给相关人员，抄送人员可以查看但不需要审批。
+ * 常用于让相关人员了解流程进展，保持信息透明。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class ProcessCopyDto {
+
+	/**
+	 * 抄送时间
+	 * <p>
+	 * 记录抄送动作发生的时间，即当前节点的执行时间。
+	 * 用于追溯抄送记录的时间线。
+	 * </p>
+	 */
+	private LocalDateTime nodeTime;
+
+	/**
+	 * 流程发起人ID
+	 * <p>
+	 * 发起该流程实例的用户ID。
+	 * 用于标识流程的发起者，便于抄送人了解流程来源。
+	 * </p>
+	 */
+	private Long startUserId;
+
+	/**
+	 * 流程定义ID
+	 * <p>
+	 * 流程定义的唯一标识，标识这是哪个流程模板。
+	 * 如：leave_process（请假流程）、purchase_process（采购流程）等。
+	 * </p>
+	 */
+	private String flowId;
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 当前运行的流程实例的唯一标识。
+	 * 用于关联到具体的流程实例，便于查看详情。
+	 * </p>
+	 */
+	private String processInstanceId;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 触发抄送的流程节点ID。
+	 * 标识是在哪个节点产生的抄送记录。
+	 * </p>
+	 */
+	private String nodeId;
+
+	/**
+	 * 节点名称
+	 * <p>
+	 * 触发抄送的流程节点名称，如"部门经理审批"、"财务审核"等。
+	 * 用于在界面上显示，让抄送人了解流程进展到哪一步。
+	 * </p>
+	 */
+	private String nodeName;
+
+	/**
+	 * 表单数据
+	 * <p>
+	 * JSON格式的表单数据，包含流程实例的业务数据。
+	 * 如请假流程的请假事由、天数等信息，便于抄送人查看具体内容。
+	 * </p>
+	 */
+	private String formData;
+
+	/**
+	 * 抄送接收人ID
+	 * <p>
+	 * 接收抄送通知的用户ID。
+	 * 该用户将在抄送列表中看到此流程的信息。
+	 * </p>
+	 */
+	private Long userId;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/ProcessInstanceRecordParamDto.java

@@ -0,0 +1,68 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 流程实例记录参数数据传输对象
+ * <p>
+ * 该DTO用于创建或更新流程实例的执行记录。
+ * 记录流程实例的基本信息和表单数据，用于流程历史追溯和数据存储。
+ * 支持主流程和子流程的记录创建。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-07
+ */
+@Getter
+@Setter
+public class ProcessInstanceRecordParamDto {
+
+	/**
+	 * 用户ID
+	 * <p>
+	 * 执行此操作的用户ID，通常是流程发起人或当前任务处理人。
+	 * 用于记录操作人信息，便于审计和追溯。
+	 * </p>
+	 */
+	private Long userId;
+
+	/**
+	 * 流程定义ID
+	 * <p>
+	 * 流程模板的唯一标识。
+	 * 标识这条记录属于哪个流程定义。
+	 * </p>
+	 */
+	private String flowId;
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 当前流程实例的唯一标识。
+	 * 用于关联流程实例的所有相关记录。
+	 * </p>
+	 */
+	private String processInstanceId;
+
+	/**
+	 * 父流程实例ID
+	 * <p>
+	 * 如果当前流程是子流程，此字段存储父流程的实例ID。
+	 * 用于建立流程间的父子关系，支持流程嵌套场景。
+	 * 如果是主流程，此字段为空。
+	 * </p>
+	 */
+	private String parentProcessInstanceId;
+
+	/**
+	 * 表单数据
+	 * <p>
+	 * JSON格式的表单数据，存储流程实例的业务数据。
+	 * 包含用户填写的所有表单字段值，如申请内容、金额、日期等。
+	 * 这些数据会在流程执行过程中被各节点使用和展示。
+	 * </p>
+	 */
+	private String formData;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/ProcessNodeDataDto.java

@@ -0,0 +1,50 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+/**
+ * 流程节点数据传输对象
+ * <p>
+ * 该DTO用于存储和传输流程节点的配置数据。
+ * 每个流程节点可能有特定的配置信息，如审批人设置、表单权限、条件配置等，
+ * 这些配置数据以JSON格式存储在data字段中。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class ProcessNodeDataDto {
+
+	/**
+	 * 流程定义ID
+	 * <p>
+	 * 节点所属的流程定义唯一标识。
+	 * 标识该节点配置属于哪个流程模板。
+	 * </p>
+	 */
+	private String flowId;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 流程节点的唯一标识。
+	 * 用于定位具体的节点，每个流程中的节点ID是唯一的。
+	 * </p>
+	 */
+	private String nodeId;
+
+	/**
+	 * 节点配置数据
+	 * <p>
+	 * JSON格式的节点配置信息，可能包含：
+	 * - 审批人配置：指定用户、角色、部门主管等
+	 * - 表单权限：各字段的读写权限设置
+	 * - 条件配置：分支条件、跳转条件等
+	 * - 事件配置：超时提醒、自动处理等
+	 * - 其他自定义配置
+	 * 具体内容根据节点类型和业务需求而定。
+	 * </p>
+	 */
+	private String data;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/ProcessNodeRecordAssignUserParamDto.java

@@ -0,0 +1,120 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+/**
+ * 流程节点记录执行人参数数据传输对象
+ * <p>
+ * 该DTO用于记录流程节点的执行人信息。当任务分配给用户或用户处理任务时，
+ * 创建相应的执行人记录，用于追踪任务的处理过程和审批历史。
+ * 包含任务执行的完整上下文信息。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class ProcessNodeRecordAssignUserParamDto {
+
+	/**
+	 * 流程定义ID
+	 * <p>
+	 * 流程模板的唯一标识。
+	 * 标识该记录所属的流程定义。
+	 * </p>
+	 */
+	private String flowId;
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 运行中的流程实例唯一标识。
+	 * 用于关联到具体的流程实例。
+	 * </p>
+	 */
+	private String processInstanceId;
+
+	/**
+	 * 表单数据
+	 * <p>
+	 * JSON格式的表单数据，包含流程实例的业务数据。
+	 * 记录任务执行时的表单内容，便于历史查看。
+	 * </p>
+	 */
+	private String data;
+
+	/**
+	 * 节点本地数据
+	 * <p>
+	 * 节点级别的局部数据，仅在当前节点范围内有效。
+	 * 可能包含节点特定的配置或临时数据。
+	 * </p>
+	 */
+	private String localData;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 流程节点的唯一标识。
+	 * 标识任务所在的节点。
+	 * </p>
+	 */
+	private String nodeId;
+
+	/**
+	 * 执行人用户ID
+	 * <p>
+	 * 被分配执行该任务的用户ID。
+	 * 记录谁负责处理这个任务。
+	 * </p>
+	 */
+	private Long userId;
+
+	/**
+	 * 执行ID
+	 * <p>
+	 * Flowable引擎的执行ID。
+	 * 用于关联流程引擎中的执行实例。
+	 * </p>
+	 */
+	private String executionId;
+
+	/**
+	 * 任务ID
+	 * <p>
+	 * Flowable引擎生成的任务ID。
+	 * 用于唯一标识一个用户任务实例。
+	 * </p>
+	 */
+	private String taskId;
+
+	/**
+	 * 审批意见
+	 * <p>
+	 * 用户处理任务时填写的审批意见或备注。
+	 * 记录审批理由、建议等信息。
+	 * </p>
+	 */
+	private String approveDesc;
+
+	/**
+	 * 节点名称
+	 * <p>
+	 * 流程节点的显示名称，如"部门经理审批"。
+	 * 用于在界面上展示，提高可读性。
+	 * </p>
+	 */
+	private String nodeName;
+
+	/**
+	 * 任务类型
+	 * <p>
+	 * 标识任务的类型：
+	 * - APPROVAL: 审批任务
+	 * - COPY: 抄送任务
+	 * - NOTIFY: 通知任务
+	 * - CUSTOM: 自定义任务
+	 * </p>
+	 */
+	private String taskType;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/Refuse.java

@@ -0,0 +1,41 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+/**
+ * 拒绝处理策略数据传输对象
+ * <p>
+ * 该DTO用于定义流程节点被拒绝后的处理策略。
+ * 当审批人拒绝某个节点时，系统需要根据预定义的策略决定流程的后续走向，
+ * 如回退到指定节点、直接结束流程、转交其他人处理等。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class Refuse {
+
+	/**
+	 * 拒绝处理策略
+	 * <p>
+	 * 定义节点被拒绝后的处理方式：
+	 * - TO_END: 直接结束流程
+	 * - TO_NODE: 回退到指定节点
+	 * - TO_BEFORE: 回退到上一个节点
+	 * - TO_START: 回退到发起人
+	 * - CONTINUE: 继续流程（忽略拒绝）
+	 * </p>
+	 */
+	private String handler;
+
+	/**
+	 * 目标节点ID
+	 * <p>
+	 * 当handler为TO_NODE时，指定要回退到的目标节点ID。
+	 * 流程将回退到该节点重新执行。
+	 * 如果handler为其他值，此字段可为空。
+	 * </p>
+	 */
+	private String nodeId;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/SelectValue.java

@@ -0,0 +1,37 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+/**
+ * 选择项数据传输对象
+ * <p>
+ * 该DTO用于表示下拉选择、单选、多选等表单控件的选项。
+ * 提供键值对的数据结构，key用于存储和逻辑处理，value用于界面显示。
+ * 常用于表单配置、条件选择、数据字典等场景。
+ * </p>
+ * 
+ * @author Huijun Zhao
+ * @date 2023-07-28 10:36
+ */
+@Data
+public class SelectValue {
+
+	/**
+	 * 选项键
+	 * <p>
+	 * 选项的唯一标识，用于数据存储和逻辑处理。
+	 * 通常是编码、ID等不会改变的值，如"1"、"APPROVED"、"DEPT_001"等。
+	 * </p>
+	 */
+	private String key;
+
+	/**
+	 * 选项显示值
+	 * <p>
+	 * 选项的显示文本，用于在界面上展示给用户。
+	 * 通常是描述性的文字，如"已批准"、"销售部"、"紧急"等。
+	 * </p>
+	 */
+	private String value;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/TaskDto.java

@@ -0,0 +1,176 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * 任务数据传输对象
+ * <p>
+ * 该DTO用于传输流程任务的详细信息。包含任务的基本信息、
+ * 执行信息、关联的流程信息等。主要用于任务列表展示、
+ * 任务详情查看、任务处理等场景。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class TaskDto {
+
+	/**
+	 * 流程定义ID
+	 * <p>
+	 * 任务所属的流程定义唯一标识。
+	 * 标识该任务属于哪个流程模板。
+	 * </p>
+	 */
+	private String flowId;
+
+	/**
+	 * 流程变量集合
+	 * <p>
+	 * 存储流程执行过程中的各种变量。
+	 * 包含表单数据、控制变量、业务数据等。
+	 * 这些变量可用于任务处理和决策。
+	 * </p>
+	 */
+	private Map<String, Object> paramMap;
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 任务所属的流程实例唯一标识。
+	 * 用于关联到具体的流程实例。
+	 * </p>
+	 */
+	private String processInstanceId;
+
+	/**
+	 * 执行ID
+	 * <p>
+	 * Flowable引擎的执行ID。
+	 * 用于关联流程引擎中的执行实例。
+	 * </p>
+	 */
+	private String executionId;
+
+	/**
+	 * 任务耗时
+	 * <p>
+	 * 任务从创建到完成的时间，单位为毫秒。
+	 * 用于统计任务处理效率。
+	 * </p>
+	 */
+	private Long durationInMillis;
+
+	/**
+	 * 任务ID
+	 * <p>
+	 * Flowable引擎生成的任务唯一标识。
+	 * 用于任务的查询和操作。
+	 * </p>
+	 */
+	private String taskId;
+
+	/**
+	 * 任务执行人
+	 * <p>
+	 * 当前任务的执行人用户标识。
+	 * 可能是用户ID或用户名，取决于系统配置。
+	 * </p>
+	 */
+	private String assign;
+
+	/**
+	 * 任务名称
+	 * <p>
+	 * 任务的显示名称，如"部门经理审批"。
+	 * 对应流程节点的名称。
+	 * </p>
+	 */
+	private String taskName;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 任务对应的流程节点ID。
+	 * 用于定位任务在流程中的位置。
+	 * </p>
+	 */
+	private String nodeId;
+
+	/**
+	 * 任务创建时间
+	 * <p>
+	 * 任务在流程引擎中的创建时间。
+	 * 标记任务何时产生。
+	 * </p>
+	 */
+	private Date taskCreateTime;
+
+	/**
+	 * 任务结束时间
+	 * <p>
+	 * 任务完成或终止的时间。
+	 * 用于计算任务处理时长。
+	 * </p>
+	 */
+	private Date taskEndTime;
+
+	/**
+	 * 流程组名称
+	 * <p>
+	 * 流程所属分组的名称，如"行政类流程"、"财务类流程"。
+	 * 用于流程分类展示。
+	 * </p>
+	 */
+	private String groupName;
+
+	/**
+	 * 流程发起人ID
+	 * <p>
+	 * 发起该流程实例的用户ID。
+	 * 用于显示流程的发起者信息。
+	 * </p>
+	 */
+	private Long rootUserId;
+
+	/**
+	 * 流程发起人姓名
+	 * <p>
+	 * 发起该流程实例的用户姓名。
+	 * 用于界面显示，提高可读性。
+	 * </p>
+	 */
+	private String rootUserName;
+
+	/**
+	 * 流程发起人头像URL
+	 * <p>
+	 * 发起人的头像地址。
+	 * 用于在界面上展示发起人头像，提升用户体验。
+	 * </p>
+	 */
+	private String rootUserAvatarUrl;
+
+	/**
+	 * 流程发起时间
+	 * <p>
+	 * 流程实例的创建时间。
+	 * 记录流程何时开始。
+	 * </p>
+	 */
+	private LocalDateTime startTime;
+
+	/**
+	 * 流程名称
+	 * <p>
+	 * 流程定义的名称，如"请假申请流程"、"报销流程"。
+	 * 用于界面显示，便于用户理解。
+	 * </p>
+	 */
+	private String processName;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/TaskParamDto.java

@@ -0,0 +1,112 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 任务操作参数数据传输对象
+ * <p>
+ * 该DTO用于任务操作时传递参数，如完成任务、转办任务、委派任务等。 包含任务标识、操作人信息、流程变量、目标节点等信息。 支持单个任务操作和批量任务操作。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class TaskParamDto {
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 单个流程实例的唯一标识。 用于定位要操作的流程实例。
+	 * </p>
+	 */
+	private String processInstanceId;
+
+	/**
+	 * 流程实例ID列表
+	 * <p>
+	 * 批量操作时使用，包含多个流程实例ID。 支持批量完成、批量转办等操作。
+	 * </p>
+	 */
+	private List<String> processInstanceIdList;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 当前操作的节点ID。 用于标识任务所在的流程节点。
+	 * </p>
+	 */
+	private String nodeId;
+
+	/**
+	 * 是否添加子流程发起人
+	 * <p>
+	 * 标识是否需要在子流程中记录主流程的发起人信息。 true: 子流程会继承主流程的发起人信息 false: 子流程独立记录发起人
+	 * </p>
+	 */
+	private Boolean appendChildProcessRootId;
+
+	/**
+	 * 任务ID
+	 * <p>
+	 * Flowable引擎的任务唯一标识。 用于定位要操作的具体任务。
+	 * </p>
+	 */
+	private String taskId;
+
+	/**
+	 * 操作用户ID
+	 * <p>
+	 * 执行任务操作的用户ID。 记录是谁在操作这个任务。
+	 * </p>
+	 */
+	private String userId;
+
+	/**
+	 * 目标用户ID（已废弃）
+	 * <p>
+	 * 单个目标用户ID，用于转办等操作。 建议使用targetUserIdList代替。
+	 * </p>
+	 */
+	private String targetUserId;
+
+	/**
+	 * 流程变量参数
+	 * <p>
+	 * 任务完成时设置的流程变量。 这些变量会存储在流程实例中，供后续节点使用。 如审批意见、审批结果、业务数据等。
+	 * </p>
+	 */
+	private Map<String, Object> paramMap;
+
+	/**
+	 * 任务本地变量
+	 * <p>
+	 * 仅在当前任务范围内有效的变量。 任务完成后这些变量会被清除，不会传递到后续节点。 用于存储临时数据或任务特定的配置。
+	 * </p>
+	 */
+	private Map<String, Object> taskLocalParamMap;
+
+	/**
+	 * 表单数据
+	 */
+	private Map<String, Object> formData;
+
+	/**
+	 * 目标节点ID
+	 * <p>
+	 * 指定跳转的目标节点ID。 用于实现流程跳转、回退等功能。 如驳回到指定节点、跳过某些节点等。
+	 * </p>
+	 */
+	private String targetNodeId;
+
+	/**
+	 * 转办目标用户ID列表
+	 * <p>
+	 * 任务转办时的目标用户ID列表。 支持将任务转办给一个或多个用户。 转办后原执行人不再拥有该任务。
+	 * </p>
+	 */
+	private List<Long> targetUserIdList;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/TaskQueryParamDto.java

@@ -0,0 +1,81 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 用户任务查询参数数据传输对象
+ * <p>
+ * 该DTO用于查询用户任务列表时传递查询条件。
+ * 支持按执行人、流程名称、时间范围、任务状态等条件进行查询，
+ * 并支持分页功能。主要用于任务列表、待办事项等功能。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class TaskQueryParamDto {
+
+	/**
+	 * 任务执行人
+	 * <p>
+	 * 用于查询指定用户的任务。
+	 * 可以是用户ID或用户名，取决于系统实现。
+	 * 为空时查询所有用户的任务。
+	 * </p>
+	 */
+	private String assign;
+
+	/**
+	 * 当前页码
+	 * <p>
+	 * 分页查询的页码，从1开始。
+	 * 用于实现分页功能。
+	 * </p>
+	 */
+	private Integer current;
+
+	/**
+	 * 每页记录数
+	 * <p>
+	 * 分页查询时每页显示的记录数量。
+	 * 用于控制返回数据的大小。
+	 * </p>
+	 */
+	private Integer size;
+
+	/**
+	 * 流程名称
+	 * <p>
+	 * 用于按流程名称过滤任务。
+	 * 支持模糊查询，如输入"请假"可查询所有请假相关流程的任务。
+	 * </p>
+	 */
+	private String processName;
+
+	/**
+	 * 任务时间范围
+	 * <p>
+	 * 用于按任务创建时间范围查询。
+	 * 数组包含两个元素：[开始时间, 结束时间]。
+	 * 可用于查询特定时间段内的任务。
+	 * </p>
+	 */
+	private LocalDateTime[] taskTime;
+
+	/**
+	 * 任务状态
+	 * <p>
+	 * 用于按任务状态过滤：
+	 * - 0: 待处理
+	 * - 1: 已完成
+	 * - 2: 已拒绝
+	 * - 3: 已撤回
+	 * - 4: 已转办
+	 * 为空时查询所有状态的任务。
+	 * </p>
+	 */
+	private Integer status;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/TaskResultDto.java

@@ -0,0 +1,100 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.Map;
+
+/**
+ * 任务结果数据传输对象
+ * <p>
+ * 该DTO用于返回任务的详细信息和执行结果。
+ * 包含任务的当前状态、节点配置、流程变量、委派状态等信息。
+ * 主要用于任务详情展示、任务处理页面的数据渲染。
+ * </p>
+ *
+ * @author pigx
+ */
+@Data
+public class TaskResultDto {
+
+	/**
+	 * 是否为当前任务
+	 * <p>
+	 * 标识该任务是否为流程的当前活动任务。
+	 * true: 任务正在等待处理
+	 * false: 任务已完成或不是当前节点
+	 * </p>
+	 */
+	private Boolean currentTask;
+
+	/**
+	 * 流程定义ID
+	 * <p>
+	 * 任务所属的流程定义唯一标识。
+	 * 用于获取流程模板信息。
+	 * </p>
+	 */
+	private String flowId;
+
+	/**
+	 * 任务节点配置
+	 * <p>
+	 * 包含任务节点的完整配置信息。
+	 * 如节点类型、审批人设置、表单权限、条件配置等。
+	 * 用于渲染任务处理界面。
+	 * </p>
+	 */
+	private Node taskNode;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 任务对应的流程节点ID。
+	 * 用于定位任务在流程中的位置。
+	 * </p>
+	 */
+	private String nodeId;
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 任务所属的流程实例唯一标识。
+	 * 用于关联到具体的流程实例。
+	 * </p>
+	 */
+	private String processInstanceId;
+
+	/**
+	 * 委派状态
+	 * <p>
+	 * 标识任务的委派状态：
+	 * - PENDING: 待处理，委派任务等待被委派人处理
+	 * - RESOLVED: 已解决，委派任务已完成并返回给委派人
+	 * - null: 非委派任务
+	 * </p>
+	 */
+	private String delegationState;
+
+	/**
+	 * 是否允许继续委派
+	 * <p>
+	 * 控制任务是否可以被继续委派给其他人。
+	 * true: 允许当前处理人将任务委派给其他人
+	 * false: 不允许继续委派
+	 * </p>
+	 */
+	private Boolean delegate;
+
+	/**
+	 * 所有流程变量
+	 * <p>
+	 * 包含流程实例的所有变量，包括：
+	 * - 表单数据：用户填写的业务数据
+	 * - 系统变量：流程引擎设置的变量
+	 * - 控制变量：用于流程控制的变量
+	 * 这些变量可用于任务处理和页面展示。
+	 * </p>
+	 */
+	private Map<String, Object> variableAll;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/VariableQueryParamDto.java

@@ -0,0 +1,51 @@
+package com.pig4cloud.pigx.flow.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 变量查询参数数据传输对象
+ * <p>
+ * 该DTO用于查询流程变量或任务变量。
+ * 支持按任务ID或执行ID查询指定的变量，可以查询单个或多个变量。
+ * 主要用于获取流程执行过程中的数据，如表单数据、控制变量等。
+ * </p>
+ * 
+ * @author pigx
+ */
+@Data
+public class VariableQueryParamDto {
+
+	/**
+	 * 任务ID
+	 * <p>
+	 * Flowable引擎的任务唯一标识。
+	 * 用于查询特定任务的变量。
+	 * 与executionId二选一，优先使用taskId。
+	 * </p>
+	 */
+	private String taskId;
+
+	/**
+	 * 变量键列表
+	 * <p>
+	 * 需要查询的变量名称列表。
+	 * 如果为空，则查询所有变量；
+	 * 如果指定了具体的键，则只返回这些键对应的变量值。
+	 * 例如：["amount", "reason", "approver"]
+	 * </p>
+	 */
+	private List<String> keyList;
+
+	/**
+	 * 执行ID
+	 * <p>
+	 * Flowable引擎的执行实例ID。
+	 * 用于查询特定执行实例的变量。
+	 * 当没有taskId时使用此字段查询。
+	 * </p>
+	 */
+	private String executionId;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/dto/packge-info.java

@@ -3,4 +3,4 @@
  * <p>
  * DTO 存放目录
  */
-package com.pig4cloud.pigx.flow.task.dto;
+package com.pig4cloud.pigx.flow.dto;

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/ProcessCopy.java

@@ -1,4 +1,4 @@
-package com.pig4cloud.pigx.flow.task.entity;
+package com.pig4cloud.pigx.flow.entity;
 
 import com.baomidou.mybatisplus.annotation.*;
 import com.pig4cloud.pigx.common.core.util.TenantTable;
@@ -9,8 +9,11 @@ import lombok.experimental.Accessors;
 import java.time.LocalDateTime;
 
 /**
+ * 流程抄送记录实体类
  * <p>
- * 流程抄送数据
+ * 记录流程执行过程中的抄送信息。抄送是指将流程信息通知给相关人员，
+ * 但这些人员不需要进行审批操作，仅供查看和了解流程进展。
+ * 一个流程节点可以抄送给多个人员，每个抄送生成一条记录。
  * </p>
  *
  * @author Vincent
@@ -24,79 +27,92 @@ import java.time.LocalDateTime;
 public class ProcessCopy {
 
 	/**
-	 * 用户id
+	 * 主键ID
+	 * 使用雪花算法生成的分布式ID
 	 */
 	@TableId(value = "id", type = IdType.ASSIGN_ID)
 	private Long id;
 
 	/**
 	 * 流程发起时间
+	 * 记录流程实例的创建时间，用于追踪流程的开始时刻
 	 */
 	@TableField("start_time")
 	private LocalDateTime startTime;
 
 	/**
-	 * 当前节点时间
+	 * 抄送节点执行时间
+	 * 记录产生抄送的节点执行时间，即何时触发的抄送通知
 	 */
 	@TableField("node_time")
 	private LocalDateTime nodeTime;
 
 	/**
-	 * 发起人
+	 * 流程发起人ID
+	 * 记录启动流程实例的用户ID，方便追溯流程的发起者
 	 */
 	@TableField("start_user_id")
 	private Long startUserId;
 
 	/**
-	 * 流程id
+	 * 流程定义ID
+	 * 关联process表的flow_id，标识该抄送属于哪个流程定义
 	 */
 	@TableField("flow_id")
 	private String flowId;
 
 	/**
-	 * 实例id
+	 * 流程实例ID
+	 * 关联process_instance_record表，标识该抄送属于哪个流程实例
 	 */
 	@TableField("process_instance_id")
 	private String processInstanceId;
 
 	/**
-	 * 节点id
+	 * 流程节点ID
+	 * 标识在哪个节点产生的抄送，对应流程定义中的节点标识
 	 */
 	@TableField("node_id")
 	private String nodeId;
 
 	/**
-	 * 分组id
+	 * 流程分组ID
+	 * 流程所属的分组ID，继承自流程定义
 	 */
 	@TableField("group_id")
 	private Long groupId;
 
 	/**
-	 * 分组名称
+	 * 流程分组名称
+	 * 缓存流程分组的名称，方便查询展示，避免关联查询
 	 */
 	@TableField("group_name")
 	private String groupName;
 
 	/**
 	 * 流程名称
+	 * 缓存流程定义的名称，方便在抄送列表中直接展示
 	 */
 	@TableField("process_name")
 	private String processName;
 
 	/**
-	 * 节点 名称
+	 * 抄送节点名称
+	 * 产生抄送的节点名称，如"部门经理审批"、"财务审核"等
 	 */
 	@TableField("node_name")
 	private String nodeName;
 
 	/**
-	 * 表单数据
+	 * 表单数据快照
+	 * JSON格式存储抄送时的表单数据，确保抄送人看到的是当时的数据状态
 	 */
 	@TableField("form_data")
 	private String formData;
 
 	/**
-	 * 抄送人id
+	 * 抄送接收人ID
+	 * 接收抄送通知的用户ID，该用户可以查看但不能操作流程
 	 */
 	@TableField("user_id")
 	private Long userId;

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/ProcessGroup.java

@@ -0,0 +1,88 @@
+package com.pig4cloud.pigx.flow.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.pig4cloud.pigx.common.core.util.TenantTable;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+/**
+ * 流程分组实体类
+ * <p>
+ * 用于对流程进行分类管理，将相关的流程归类到同一个分组中，便于用户查找和管理。
+ * 支持按照分组名称和排序顺序来组织流程的展示结构。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-07-06
+ */
+@Getter
+@Setter
+@TenantTable
+@Accessors(chain = true)
+@TableName("process_group")
+public class ProcessGroup {
+
+	/**
+	 * 分组名称
+	 * <p>
+	 * 流程分组的显示名称，用于标识该分组的用途或类型。
+	 * 例如：人事管理、财务审批、行政事务等。
+	 * </p>
+	 */
+	@TableField("group_name")
+	private String groupName;
+
+	/**
+	 * 排序序号
+	 * <p>
+	 * 用于控制分组在列表中的显示顺序，数值越小越靠前。
+	 * 可以根据业务重要性或使用频率来设置排序值。
+	 * </p>
+	 */
+	@TableField("sort")
+	private Integer sort;
+
+	/**
+	 * 分组ID
+	 * <p>
+	 * 分组的唯一标识符，采用雪花算法生成。
+	 * 在Process实体中通过groupId字段引用此ID，建立流程与分组的关联关系。
+	 * </p>
+	 */
+	@TableId(value = "id", type = IdType.ASSIGN_ID)
+	private Long id;
+
+	/**
+	 * 逻辑删除标记
+	 * <p>
+	 * 用于软删除功能，删除时不会真正从数据库中移除记录，而是标记为已删除。
+	 * 0-正常，1-已删除。这样可以保留历史数据，便于数据恢复和审计。
+	 * </p>
+	 */
+	@TableLogic
+	@TableField(fill = FieldFill.INSERT)
+	private String delFlag;
+
+	/**
+	 * 创建时间
+	 * <p>
+	 * 记录分组的创建时间，自动填充，用于数据审计和追踪。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT)
+	private LocalDateTime createTime;
+
+	/**
+	 * 更新时间
+	 * <p>
+	 * 记录分组信息的最后更新时间，在创建和更新时自动填充。
+	 * 用于跟踪数据的变更历史。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT_UPDATE)
+	private LocalDateTime updateTime;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/ProcessInstanceRecord.java

@@ -1,4 +1,4 @@
-package com.pig4cloud.pigx.flow.task.entity;
+package com.pig4cloud.pigx.flow.entity;
 
 import com.baomidou.mybatisplus.annotation.*;
 import com.pig4cloud.pigx.common.core.util.TenantTable;
@@ -11,8 +11,10 @@ import java.time.LocalDateTime;
 import java.util.Date;
 
 /**
+ * 流程实例记录实体类
  * <p>
- * 流程记录
+ * 该实体记录每个流程实例的执行情况，包括发起人、表单数据、执行状态等。
+ * 一个流程定义(Process)可以创建多个流程实例记录。
  * </p>
  *
  * @author Vincent
@@ -27,79 +29,92 @@ import java.util.Date;
 public class ProcessInstanceRecord {
 
 	/**
-	 * 流程名字
+	 * 流程实例名称
+	 * 通常继承自流程定义的名称，也可以在创建时自定义
 	 */
 	@TableField("name")
 	private String name;
 
 	/**
-	 * 头像
+	 * 流程图标
+	 * 继承自流程定义的图标配置
 	 */
 	@TableField("logo")
 	private String logo;
 
 	/**
-	 * 用户id
+	 * 流程发起人ID
+	 * 记录该流程实例的创建者用户ID
 	 */
 	@TableField("user_id")
 	private Long userId;
 
 	/**
-	 * 流程id
+	 * 流程定义ID
+	 * 关联process表的flow_id，指明该实例属于哪个流程定义
 	 */
 	@TableField("flow_id")
 	private String flowId;
 
 	/**
-	 * 流程实例id
+	 * Flowable引擎流程实例ID
+	 * 对应Flowable引擎中的流程实例ID，用于与引擎交互
 	 */
 	@TableField("process_instance_id")
 	private String processInstanceId;
 
 	/**
 	 * 表单数据
+	 * JSON格式存储用户提交的表单数据，在流程执行过程中使用
 	 */
 	@TableField("form_data")
 	private String formData;
 
 	/**
-	 * 组id
+	 * 流程分组ID
+	 * 继承自流程定义的分组ID
 	 */
 	@TableField("group_id")
 	private Long groupId;
 
 	/**
-	 * 组名称
+	 * 流程分组名称
+	 * 缓存流程所属分组的名称，方便查询展示
 	 */
 	@TableField("group_name")
 	private String groupName;
 
 	/**
-	 * 状态
+	 * 流程实例状态
+	 * 1=进行中，2=已完成，3=已取消，4=已中止
 	 */
 	@TableField("status")
 	private Integer status;
 
-    /**
-     * 完成原因
-     */
-    @TableField("finish_reason")
-    private String finishReason;
+	/**
+	 * 流程结束原因
+	 * 记录流程完成、取消或中止的具体原因
+	 */
+	@TableField("finish_reason")
+	private String finishReason;
 
 	/**
-	 * 结束时间
+	 * 流程结束时间
+	 * 记录流程实例的完成、取消或中止时间
 	 */
 	@TableField("end_time")
 	private Date endTime;
 
 	/**
-	 * 上级流程实例id
+	 * 父流程实例ID
+	 * 当前流程是子流程时，记录父流程的实例ID，支持流程嵌套
 	 */
 	@TableField("parent_process_instance_id")
 	private String parentProcessInstanceId;
 
 	/**
-	 * 用户id
+	 * 主键ID
+	 * 使用雪花算法生成的分布式ID
 	 */
 	@TableId(value = "id", type = IdType.ASSIGN_ID)
 	private Long id;

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/ProcessNodeData.java

@@ -0,0 +1,100 @@
+package com.pig4cloud.pigx.flow.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.pig4cloud.pigx.common.core.util.TenantTable;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+/**
+ * 流程节点数据实体类
+ * <p>
+ * 用于存储流程节点的表单数据和配置信息。当流程实例运行时，每个节点可能需要填写表单或提交数据，
+ * 这些数据通过本实体进行持久化存储。支持JSON格式的灵活数据结构，可以适应不同类型节点的数据需求。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-07-06
+ */
+@Getter
+@Setter
+@TenantTable
+@Accessors(chain = true)
+@TableName("process_node_data")
+public class ProcessNodeData {
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 关联到具体的流程实例，标识这些节点数据属于哪个流程实例。
+	 * 对应ProcessInstanceRecord表的flowId字段。
+	 * </p>
+	 */
+	@TableField("flow_id")
+	private String flowId;
+
+	/**
+	 * 节点表单数据
+	 * <p>
+	 * 以JSON格式存储的节点表单数据，包含用户在该节点填写的所有表单字段值。
+	 * 数据结构根据节点配置的表单项动态变化，支持文本、数字、日期、选择等多种表单类型。
+	 * 例如：{"amount": 5000, "reason": "采购办公用品", "approver": "user123"}
+	 * </p>
+	 */
+	@TableField("data")
+	private String data;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 流程定义中的节点标识符，用于关联到具体的流程节点。
+	 * 通过此ID可以确定数据属于流程的哪个环节，如发起节点、审批节点、抄送节点等。
+	 * 与Node对象中的id字段对应。
+	 * </p>
+	 */
+	@TableField("node_id")
+	private String nodeId;
+
+	/**
+	 * 主键ID
+	 * <p>
+	 * 节点数据记录的唯一标识符，采用雪花算法生成。
+	 * </p>
+	 */
+	@TableId(value = "id", type = IdType.ASSIGN_ID)
+	private Long id;
+
+	/**
+	 * 逻辑删除标记
+	 * <p>
+	 * 用于软删除功能，删除时不会真正从数据库中移除记录，而是标记为已删除。
+	 * 0-正常，1-已删除。保留历史数据便于审计和数据恢复。
+	 * </p>
+	 */
+	@TableLogic
+	@TableField(fill = FieldFill.INSERT)
+	private String delFlag;
+
+	/**
+	 * 创建时间
+	 * <p>
+	 * 记录节点数据的创建时间，通常是用户提交表单的时间。
+	 * 自动填充，用于数据审计和流程追踪。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT)
+	private LocalDateTime createTime;
+
+	/**
+	 * 更新时间
+	 * <p>
+	 * 记录节点数据的最后更新时间，在创建和更新时自动填充。
+	 * 用于跟踪数据的修改历史，如表单数据的补充或修正。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT_UPDATE)
+	private LocalDateTime updateTime;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/ProcessNodeRecord.java

@@ -1,4 +1,4 @@
-package com.pig4cloud.pigx.flow.task.entity;
+package com.pig4cloud.pigx.flow.entity;
 
 import com.baomidou.mybatisplus.annotation.*;
 import com.pig4cloud.pigx.common.core.util.TenantTable;
@@ -10,8 +10,10 @@ import java.time.LocalDateTime;
 import java.util.Date;
 
 /**
+ * 流程节点记录实体类
  * <p>
- * 流程节点记录
+ * 记录流程实例中每个节点的执行情况。
+ * 一个流程实例在执行过程中会产生多个节点记录，用于跟踪和审计流程执行路径。
  * </p>
  *
  * @author Vincent
@@ -25,64 +27,78 @@ import java.util.Date;
 public class ProcessNodeRecord {
 
 	/**
-	 * 流程id
+	 * 流程定义ID
+	 * 关联process表的flow_id
 	 */
 	@TableField("flow_id")
 	private String flowId;
 
 	/**
-	 * 流程实例id
+	 * 流程实例ID
+	 * 关联process_instance_record表，标识该节点记录属于哪个流程实例
 	 */
 	@TableField("process_instance_id")
 	private String processInstanceId;
 
 	/**
-	 * 表单数据
+	 * 节点执行时的表单数据
+	 * JSON格式存储节点执行时的表单数据快照，用于记录和审计
 	 */
 	@TableField("data")
 	private String data;
 
+	/**
+	 * 节点ID
+	 * 流程定义中的节点唯一标识
+	 */
 	@TableField("node_id")
 	private String nodeId;
 
 	/**
 	 * 节点类型
+	 * 对应NodeTypeEnum中的值（审批节点、抄送节点、条件分支等）
 	 */
 	@TableField("node_type")
 	private String nodeType;
 
 	/**
-	 * 节点名字
+	 * 节点名称
+	 * 节点的显示名称，如“部门经理审批”、“财务审核”等
 	 */
 	@TableField("node_name")
 	private String nodeName;
 
 	/**
-	 * 节点状态
+	 * 节点执行状态
+	 * 1=进行中，2=已完成，3=已取消，4=已跳过
 	 */
 	@TableField("status")
 	private Integer status;
 
 	/**
-	 * 开始时间
+	 * 节点开始执行时间
+	 * 记录节点开始执行的时间
 	 */
 	@TableField("start_time")
 	private Date startTime;
 
 	/**
-	 * 结束时间
+	 * 节点结束执行时间
+	 * 记录节点完成、取消或跳过的时间
 	 */
 	@TableField("end_time")
 	private Date endTime;
 
 	/**
-	 * 执行id
+	 * Flowable引擎执行ID
+	 * 对应Flowable引擎中的execution_id，用于与引擎交互
 	 */
 	@TableField("execution_id")
 	private String executionId;
 
 	/**
-	 * 用户id
+	 * 主键ID
+	 * 使用雪花算法生成的分布式ID
 	 */
 	@TableId(value = "id", type = IdType.ASSIGN_ID)
 	private Long id;

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/ProcessNodeRecordAssignUser.java

@@ -0,0 +1,198 @@
+package com.pig4cloud.pigx.flow.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.pig4cloud.pigx.common.core.util.TenantTable;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+/**
+ * 流程节点记录分配用户实体类
+ * <p>
+ * 记录流程节点的执行人信息和执行详情。当一个流程节点需要由特定用户处理时， 系统会为每个被分配的用户创建一条记录。这个实体保存了用户的任务执行状态、
+ * 处理时间、审批意见等核心信息，是流程执行过程中的重要审计记录。
+ * </p>
+ * <p>
+ * 与ProcessNodeRecord的关系：ProcessNodeRecord记录节点的整体执行情况， 而本实体记录该节点分配给具体用户的执行情况。一个节点可能分配给多个用户
+ * （如会签、或签场景），因此一个ProcessNodeRecord可对应多个ProcessNodeRecordAssignUser。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-07-06
+ */
+@Getter
+@Setter
+@TenantTable
+@Accessors(chain = true)
+@TableName("process_node_record_assign_user")
+public class ProcessNodeRecordAssignUser {
+
+	/**
+	 * 流程定义ID
+	 * <p>
+	 * 关联到流程定义，标识该任务属于哪个流程模板。 对应Process表的flowId字段，用于追溯任务的流程来源。
+	 * </p>
+	 */
+	@TableField("flow_id")
+	private String flowId;
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * Flowable引擎中的流程实例标识符，用于关联到具体的流程实例。 通过此ID可以在Flowable引擎中查询流程实例的详细信息和运行状态。
+	 * </p>
+	 */
+	@TableField("process_instance_id")
+	private String processInstanceId;
+
+	/**
+	 * 节点表单数据
+	 * <p>
+	 * JSON格式存储的表单数据，记录用户在处理该节点时提交的所有表单信息。 与ProcessNodeData中的data字段类似，但这里专门记录该执行人提交的数据。
+	 * 在会签场景下，不同执行人可能提交不同的表单数据。
+	 * </p>
+	 */
+	@TableField("data")
+	private String data;
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 流程定义中的节点标识符，标识任务属于哪个流程节点。 与Node对象的id字段对应，用于定位流程图中的具体位置。
+	 * </p>
+	 */
+	@TableField("node_id")
+	private String nodeId;
+
+	/**
+	 * 执行用户ID
+	 * <p>
+	 * 被分配处理该节点任务的用户标识符。 对应系统用户表的用户ID，标识谁负责处理这个任务。 在任务分配时设置，用于权限控制和任务查询。
+	 * </p>
+	 */
+	@TableField("user_id")
+	private Long userId;
+
+	/**
+	 * 任务执行状态
+	 * <p>
+	 * 记录该用户对任务的处理状态，对应NodeStatusEnum枚举值： 0-待处理：任务已分配但用户还未处理 1-同意：用户已审批通过 2-拒绝：用户已审批拒绝
+	 * 3-撤销：任务已被撤销 4-转办：任务已转交他人处理 5-终止：流程已终止 6-跳过：任务被自动跳过 7-待执行：等待执行中
+	 * </p>
+	 */
+	@TableField("status")
+	private Integer status;
+
+	/**
+	 * 任务开始时间
+	 * <p>
+	 * 记录任务分配给用户的时间，即用户开始拥有该任务处理权的时间。 用于计算任务处理时长和监控任务时效性。
+	 * </p>
+	 */
+	@TableField("start_time")
+	private LocalDateTime startTime;
+
+	/**
+	 * 任务结束时间
+	 * <p>
+	 * 记录用户完成任务处理的时间，包括同意、拒绝、转办等操作的时间。 与startTime配合可计算任务处理耗时，用于绩效分析和流程优化。
+	 * </p>
+	 */
+	@TableField("end_time")
+	private LocalDateTime endTime;
+
+	/**
+	 * 流程执行ID
+	 * <p>
+	 * Flowable引擎中的执行实例标识符，用于精确定位流程执行路径。 在并行网关、子流程等复杂场景下，一个流程实例可能有多个执行实例。
+	 * </p>
+	 */
+	@TableField("execution_id")
+	private String executionId;
+
+	/**
+	 * Flowable任务ID
+	 * <p>
+	 * Flowable引擎中的任务实例标识符，是任务在工作流引擎中的唯一标识。 通过此ID可以调用Flowable API完成任务、查询任务详情等操作。
+	 * </p>
+	 */
+	@TableField("task_id")
+	private String taskId;
+
+	/**
+	 * 审批意见
+	 * <p>
+	 * 用户在处理任务时填写的文字意见或备注，如批准理由、拒绝原因等。 这是流程审批的重要记录，用于后续的审计追踪和决策参考。
+	 * </p>
+	 */
+	@TableField("approve_desc")
+	private String approveDesc;
+
+	/**
+	 * 节点名称
+	 * <p>
+	 * 流程节点的显示名称，如"部门经理审批"、"财务审核"等。 冗余存储以提高查询效率，避免每次都需要关联查询节点配置。
+	 * </p>
+	 */
+	@TableField("node_name")
+	private String nodeName;
+
+	/**
+	 * 任务类型
+	 * <p>
+	 * 标识任务的类型，对应NodeTypeEnum枚举值： 0-发起人节点、1-审批人节点、2-抄送人节点、3-条件节点、4-并行节点等。
+	 * 不同类型的任务有不同的处理逻辑和界面展示。
+	 * </p>
+	 */
+	@TableField("task_type")
+	private String taskType;
+
+	/**
+	 * 表单本地数据
+	 * <p>
+	 * 存储与该任务相关的本地化数据或临时数据，JSON格式。 可用于保存用户的草稿数据、中间计算结果或其他不需要提交到流程的辅助信息。
+	 * </p>
+	 */
+	@TableField("local_data")
+	private String localData;
+
+	/**
+	 * 主键ID
+	 * <p>
+	 * 任务分配记录的唯一标识符，采用雪花算法生成。
+	 * </p>
+	 */
+	@TableId(value = "id", type = IdType.ASSIGN_ID)
+	private Long id;
+
+	/**
+	 * 逻辑删除标记
+	 * <p>
+	 * 用于软删除功能，删除时不会真正从数据库中移除记录。 0-正常，1-已删除。保留完整的任务处理记录用于审计。
+	 * </p>
+	 */
+	@TableLogic
+	@TableField(fill = FieldFill.INSERT)
+	private String delFlag;
+
+	/**
+	 * 创建时间
+	 * <p>
+	 * 记录任务分配的创建时间，通常与startTime相同或接近。 自动填充，用于数据审计。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT)
+	private LocalDateTime createTime;
+
+	/**
+	 * 更新时间
+	 * <p>
+	 * 记录最后更新时间，在任务状态变更、审批意见填写等操作时更新。 用于跟踪任务处理的最新动态。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT_UPDATE)
+	private LocalDateTime updateTime;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/ProcessStarter.java

@@ -0,0 +1,107 @@
+package com.pig4cloud.pigx.flow.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.pig4cloud.pigx.common.core.util.TenantTable;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+/**
+ * 流程发起人配置实体类
+ * <p>
+ * 用于配置哪些用户或部门可以发起特定的流程。通过本实体，可以灵活控制流程的发起权限，
+ * 支持按用户或按部门进行权限配置。这是流程权限管理的重要组成部分，确保只有授权的
+ * 人员才能发起相应的流程申请。
+ * </p>
+ * <p>
+ * 与Process实体的关系：多个ProcessStarter可以关联到同一个Process，
+ * 表示该流程可以由多个用户或部门发起。通过processId字段与Process表建立关联。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-07-06
+ */
+@Getter
+@Setter
+@TenantTable
+@Accessors(chain = true)
+@TableName("process_starter")
+public class ProcessStarter {
+
+	/**
+	 * 类型关联ID
+	 * <p>
+	 * 根据type字段的值，此ID可能代表不同的含义：
+	 * - 当type为"user"时：表示用户ID，对应系统用户表的用户标识
+	 * - 当type为"dept"时：表示部门ID，对应组织架构中的部门标识
+	 * 通过这种设计，可以灵活配置个人权限或部门权限。
+	 * </p>
+	 */
+	@TableField("type_id")
+	private Long typeId;
+
+	/**
+	 * 发起人类型
+	 * <p>
+	 * 标识发起人的类型，支持以下值：
+	 * - "user"：表示按用户配置，typeId为具体的用户ID
+	 * - "dept"：表示按部门配置，typeId为部门ID，该部门下的所有用户都有发起权限
+	 * 这种设计支持精细化的权限控制和批量授权。
+	 * </p>
+	 */
+	@TableField("type")
+	private String type;
+
+	/**
+	 * 流程ID
+	 * <p>
+	 * 关联到Process表的主键ID，标识这个发起人配置属于哪个流程。
+	 * 通过此字段建立与流程定义的关联关系，一个流程可以配置多个发起人。
+	 * </p>
+	 */
+	@TableField("process_id")
+	private Long processId;
+
+	/**
+	 * 主键ID
+	 * <p>
+	 * 流程发起人配置的唯一标识符，采用雪花算法生成。
+	 * </p>
+	 */
+	@TableId(value = "id", type = IdType.ASSIGN_ID)
+	private Long id;
+
+	/**
+	 * 逻辑删除标记
+	 * <p>
+	 * 用于软删除功能，删除时不会真正从数据库中移除记录，而是标记为已删除。
+	 * 0-正常，1-已删除。保留历史配置数据便于审计和恢复。
+	 * </p>
+	 */
+	@TableLogic
+	@TableField(fill = FieldFill.INSERT)
+	private String delFlag;
+
+	/**
+	 * 创建时间
+	 * <p>
+	 * 记录发起人配置的创建时间，自动填充。
+	 * 用于追踪权限配置的时间线，便于审计和问题排查。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT)
+	private LocalDateTime createTime;
+
+	/**
+	 * 更新时间
+	 * <p>
+	 * 记录配置的最后更新时间，在创建和更新时自动填充。
+	 * 用于跟踪权限配置的变更历史。
+	 * </p>
+	 */
+	@TableField(fill = FieldFill.INSERT_UPDATE)
+	private LocalDateTime updateTime;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/entity/packge-info.java

@@ -3,4 +3,4 @@
  * <p>
  * 实体 存放目录
  */
-package com.pig4cloud.pigx.flow.task.entity;
+package com.pig4cloud.pigx.flow.entity;

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/vo/FormGroupVo.java

@@ -0,0 +1,121 @@
+package com.pig4cloud.pigx.flow.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 流程表单分组视图对象
+ * <p>
+ * 用于在流程列表页面按分组展示流程，提供流程的分类管理和展示功能。
+ * 支持将多个相关流程归类到同一分组中，便于用户查找和使用。
+ * </p>
+ *
+ * @author : willian fu
+ * @date : 2020/9/21
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class FormGroupVo {
+
+    /**
+     * 分组ID
+     * <p>
+     * 流程分组的唯一标识符
+     * </p>
+     */
+    private Long id;
+
+    /**
+     * 分组名称
+     * <p>
+     * 流程分组的显示名称，如"人事管理"、"财务审批"等
+     * </p>
+     */
+    private String name;
+
+    /**
+     * 流程列表
+     * <p>
+     * 该分组下包含的所有流程信息
+     * </p>
+     */
+    private List<FlowVo> items;
+
+    /**
+     * 流程视图对象
+     * <p>
+     * 表示单个流程的基本信息，用于在分组中展示流程列表
+     * </p>
+     */
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class FlowVo {
+
+        /**
+         * 流程ID
+         * <p>
+         * 流程的唯一标识符
+         * </p>
+         */
+        private String flowId;
+
+        /**
+         * 发起范围描述
+         * <p>
+         * 描述哪些用户或角色可以发起该流程，用于前端展示
+         * </p>
+         */
+        private String rangeShow;
+
+        /**
+         * 流程名称
+         * <p>
+         * 流程的显示名称，如"请假申请"、"报销申请"等
+         * </p>
+         */
+        private String name;
+
+        /**
+         * 流程图标
+         * <p>
+         * 流程的图标标识，用于在列表中展示
+         * </p>
+         */
+        private String logo;
+
+        /**
+         * 停用标识
+         * <p>
+         * 标识流程是否已停用，"1"表示已停用，其他表示正常
+         * </p>
+         */
+        private String stop;
+
+        /**
+         * 流程备注
+         * <p>
+         * 流程的详细说明或使用说明
+         * </p>
+         */
+        private String remark;
+
+        /**
+         * 更新时间
+         * <p>
+         * 流程最后更新的时间戳
+         * </p>
+         */
+        private LocalDateTime updated;
+
+    }
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/vo/FormItemVO.java

@@ -0,0 +1,240 @@
+package com.pig4cloud.pigx.flow.vo;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldNameConstants;
+
+/**
+ * 表单项视图对象
+ * <p>
+ * 用于定义流程表单中的各种表单项配置，包括输入框、选择框、日期选择器等各种表单控件。
+ * 支持动态表单的构建和渲染，提供丰富的表单项属性配置。
+ * </p>
+ */
+@Data
+@NoArgsConstructor
+@FieldNameConstants
+public class FormItemVO {
+
+    /**
+     * 表单项ID
+     * <p>
+     * 表单项的唯一标识符，用于表单数据的提交和绑定
+     * </p>
+     */
+    private String id;
+
+    /**
+     * 权限标识
+     * <p>
+     * 表单项的权限控制标识，如"write"（可写）、"read"（只读）、"hidden"（隐藏）
+     * </p>
+     */
+    private String perm;
+
+    /**
+     * 表单项图标
+     * <p>
+     * 表单项的图标类名，用于在界面上展示对应的图标
+     * </p>
+     */
+    private String icon;
+
+    /**
+     * 表单项名称
+     * <p>
+     * 表单项的显示名称，如"姓名"、"部门"、"金额"等
+     * </p>
+     */
+    private String name;
+
+    /**
+     * 表单项类型
+     * <p>
+     * 表单项的控件类型，如"input"（输入框）、"select"（选择框）、"date"（日期选择）等
+     * </p>
+     */
+    private String type;
+
+    /**
+     * 是否必填
+     * <p>
+     * 标识该表单项是否为必填项，true表示必填，false表示选填
+     * </p>
+     */
+    private Boolean required;
+
+    /**
+     * 类型名称
+     * <p>
+     * 表单项类型的中文名称，用于前端展示
+     * </p>
+     */
+    private String typeName;
+
+    /**
+     * 占位提示文本
+     * <p>
+     * 表单项的输入提示信息，显示在输入框内
+     * </p>
+     */
+    private String placeholder;
+
+    /**
+     * 表单项属性配置
+     * <p>
+     * 包含表单项的各种扩展属性配置
+     * </p>
+     */
+    private Props props = new Props();
+
+    /**
+     * 表单项属性配置对象
+     * <p>
+     * 封装了表单项的各种属性配置，支持不同类型表单项的特定属性
+     * </p>
+     */
+    @Data
+    @NoArgsConstructor
+    @FieldNameConstants
+    public static class Props {
+
+        /**
+         * 表单项默认值
+         * <p>
+         * 表单项的默认值，可以是字符串、数字、数组等类型
+         * </p>
+         */
+        private Object value;
+
+        /**
+         * 字典值
+         * <p>
+         * 当表单项类型为选择框时，指定使用的数据字典
+         * </p>
+         */
+        private Object dictValue;
+
+        /**
+         * 选项列表
+         * <p>
+         * 选择类表单项的选项数据，通常为数组格式
+         * </p>
+         */
+        private Object options;
+
+        /**
+         * 是否自定义
+         * <p>
+         * 标识是否允许用户自定义输入，通常用于选择框支持自定义选项
+         * </p>
+         */
+        private Boolean self;
+
+        /**
+         * 是否多选
+         * <p>
+         * 标识选择类表单项是否支持多选
+         * </p>
+         */
+        private Boolean multi;
+
+        /**
+         * 原始表单配置
+         * <p>
+         * 保存原始的表单配置信息，用于表单的动态生成
+         * </p>
+         */
+        private Object oriForm;
+
+        /**
+         * 最大长度
+         * <p>
+         * 输入类表单项的最大输入长度限制
+         * </p>
+         */
+        private Object maxLength;
+
+        /**
+         * 最小长度
+         * <p>
+         * 输入类表单项的最小输入长度限制
+         * </p>
+         */
+        private Object minLength;
+
+        /**
+         * 正则表达式
+         * <p>
+         * 用于输入验证的正则表达式
+         * </p>
+         */
+        private Object regex;
+
+        /**
+         * 正则验证说明
+         * <p>
+         * 正则表达式验证失败时的提示信息
+         * </p>
+         */
+        private Object regexDesc;
+
+        /**
+         * 前缀文本
+         * <p>
+         * 显示在输入框前的文本，如货币符号"¥"
+         * </p>
+         */
+        private String prefix;
+
+        /**
+         * 最小值
+         * <p>
+         * 数字类表单项的最小值限制
+         * </p>
+         */
+        private Long min;
+
+        /**
+         * 最大值
+         * <p>
+         * 数字类表单项的最大值限制
+         * </p>
+         */
+        private Long max;
+
+        /**
+         * 单位
+         * <p>
+         * 数字类表单项的单位，如"元"、"天"等
+         * </p>
+         */
+        private String unit;
+
+        /**
+         * 小数位数
+         * <p>
+         * 数字类表单项允许的小数位数
+         * </p>
+         */
+        private Integer radixNum;
+
+        /**
+         * 最大文件大小
+         * <p>
+         * 文件上传类表单项的文件大小限制，单位为MB
+         * </p>
+         */
+        private Integer maxSize;
+
+        /**
+         * 允许的文件后缀
+         * <p>
+         * 文件上传类表单项允许的文件类型后缀数组，如["jpg", "png", "pdf"]
+         * </p>
+         */
+        private String[] suffixArray;
+
+    }
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/vo/NodeFormatParamVo.java

@@ -0,0 +1,50 @@
+package com.pig4cloud.pigx.flow.vo;
+
+import lombok.Data;
+
+import java.util.Map;
+
+/**
+ * 节点格式化参数视图对象
+ * <p>
+ * 用于传递流程节点格式化所需的参数信息，包含流程实例、任务和动态参数等信息。
+ * 主要用于节点展示时的数据格式化和条件判断。
+ * </p>
+ */
+@Data
+public class NodeFormatParamVo {
+
+	/**
+	 * 流程ID
+	 * <p>
+	 * 流程定义的唯一标识符
+	 * </p>
+	 */
+	private String flowId;
+
+	/**
+	 * 流程实例ID
+	 * <p>
+	 * 流程实例的唯一标识符，用于定位具体的流程实例
+	 * </p>
+	 */
+	private String processInstanceId;
+
+	/**
+	 * 任务ID
+	 * <p>
+	 * 当前任务的唯一标识符，用于定位具体的待办任务
+	 * </p>
+	 */
+	private String taskId;
+
+	/**
+	 * 参数映射表
+	 * <p>
+	 * 包含节点格式化所需的动态参数，key为参数名，value为参数值。
+	 * 可用于条件判断、动态展示等场景。
+	 * </p>
+	 */
+	private Map<String, Object> paramMap;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/vo/NodeVo.java

@@ -0,0 +1,98 @@
+package com.pig4cloud.pigx.flow.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 流程节点显示视图对象
+ * <p>
+ * 用于在前端展示流程节点的详细信息，包括节点的基本属性、审批人员、状态等。
+ * 支持树形结构和分支结构的节点展示，可用于流程图的渲染和流程进度的追踪。
+ * </p>
+ */
+@Data
+public class NodeVo {
+
+	/**
+	 * 节点ID
+	 * <p>
+	 * 流程节点的唯一标识符，对应流程定义中的节点ID
+	 * </p>
+	 */
+	private String id;
+
+	/**
+	 * 节点审批人列表
+	 * <p>
+	 * 该节点的审批人员信息列表，包含已审批和待审批的人员
+	 * </p>
+	 */
+	private List<UserVo> userVoList;
+
+	/**
+	 * 节点占位提示
+	 * <p>
+	 * 用于在节点上显示的提示信息，如"请选择审批人"等
+	 * </p>
+	 */
+	private String placeholder;
+
+	/**
+	 * 节点状态
+	 * <p>
+	 * 节点的执行状态：1-进行中，2-已完成
+	 * </p>
+	 */
+	private Integer status;
+
+	/**
+	 * 节点名称
+	 * <p>
+	 * 节点的显示名称，如"部门经理审批"、"财务审核"等
+	 * </p>
+	 */
+	private String name;
+
+	/**
+	 * 节点类型
+	 * <p>
+	 * 节点的类型标识，如"审批节点"、"抄送节点"、"条件节点"等。
+	 * 使用Object类型以支持不同的类型表示方式
+	 * </p>
+	 */
+	private Object type;
+
+	/**
+	 * 是否需要发起人选择审批人
+	 * <p>
+	 * 标识该节点是否需要流程发起人指定审批人员
+	 * </p>
+	 */
+	private Boolean selectUser;
+
+	/**
+	 * 是否支持多选
+	 * <p>
+	 * 当需要选择审批人时，标识是否允许选择多个审批人
+	 * </p>
+	 */
+	private Boolean multiple;
+
+	/**
+	 * 子节点列表
+	 * <p>
+	 * 该节点的直接子节点列表，用于构建节点的树形结构
+	 * </p>
+	 */
+	private List<NodeVo> children;
+
+	/**
+	 * 分支节点列表
+	 * <p>
+	 * 条件分支或并行分支的节点列表，用于表示分支流程
+	 * </p>
+	 */
+	private List<NodeVo> branch;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/vo/ProcessCopyVo.java

@@ -0,0 +1,25 @@
+package com.pig4cloud.pigx.flow.vo;
+
+import com.pig4cloud.pigx.flow.entity.ProcessCopy;
+import lombok.Data;
+
+/**
+ * 流程抄送视图对象
+ * <p>
+ * 继承自ProcessCopy实体类，用于展示流程抄送信息时的扩展字段。
+ * 主要用于抄送列表的展示，包含抄送的基本信息和扩展的显示信息。
+ * </p>
+ */
+@Data
+public class ProcessCopyVo extends ProcessCopy {
+
+	/**
+	 * 发起人姓名
+	 * <p>
+	 * 流程发起人的姓名，用于在抄送列表中显示流程是由谁发起的。
+	 * 该字段是对基础实体的扩展，便于前端直接展示发起人信息。
+	 * </p>
+	 */
+	private String startUserName;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/vo/ProcessVO.java

@@ -0,0 +1,47 @@
+package com.pig4cloud.pigx.flow.vo;
+
+import com.pig4cloud.pigx.flow.entity.Process;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程视图对象
+ * <p>
+ * 继承自Process实体类，用于流程发起和展示时的扩展信息。
+ * 包含了流程发起时需要的额外配置信息，如需要选择审批人的节点、流程变量、表单权限等。
+ * </p>
+ */
+@Data
+public class ProcessVO extends Process {
+
+	/**
+	 * 需要发起人选择审批人的节点ID列表
+	 * <p>
+	 * 包含所有需要流程发起人指定审批人的节点ID。
+	 * 在流程发起时，前端需要根据这个列表展示审批人选择界面。
+	 * </p>
+	 */
+	private List<String> selectUserNodeId;
+
+	/**
+	 * 流程变量映射表
+	 * <p>
+	 * 包含流程运行时的变量信息，key为变量名，value为变量值。
+	 * 这些变量可用于流程条件判断、表单数据传递等场景。
+	 * </p>
+	 */
+	private Map<String, Object> variableMap;
+
+	/**
+	 * 发起人节点的表单权限配置
+	 * <p>
+	 * 定义了发起人在填写表单时各个字段的权限。
+	 * key为表单字段ID，value为权限标识（如"write"、"read"、"hidden"）。
+	 * 用于控制发起人对表单字段的操作权限。
+	 * </p>
+	 */
+	private Map<String,String> formPerms;
+
+}

pigx-flow/pigx-flow-api/src/main/java/com/pig4cloud/pigx/flow/vo/UserVo.java

@@ -0,0 +1,79 @@
+package com.pig4cloud.pigx.flow.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * 用户视图对象
+ * <p>
+ * 用于在流程处理过程中展示用户信息，包括审批人、抄送人等角色的信息展示。
+ * 主要用于流程节点的用户列表、审批记录等场景。
+ * </p>
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class UserVo {
+
+	/**
+	 * 用户ID
+	 * <p>
+	 * 用户的唯一标识符
+	 * </p>
+	 */
+	private Long id;
+
+	/**
+	 * 用户姓名
+	 * <p>
+	 * 用户的显示名称，通常为真实姓名
+	 * </p>
+	 */
+	private String name;
+
+	/**
+	 * 操作时间
+	 * <p>
+	 * 用户执行操作的时间，如审批时间、查看时间等
+	 * </p>
+	 */
+	private LocalDateTime showTime;
+
+	/**
+	 * 用户头像
+	 * <p>
+	 * 用户头像的URL地址，用于在界面上展示用户头像
+	 * </p>
+	 */
+	private String avatar;
+
+	/**
+	 * 审批意见
+	 * <p>
+	 * 用户在审批时填写的意见或备注信息
+	 * </p>
+	 */
+	private String approveDesc;
+
+	/**
+	 * 操作类型
+	 * <p>
+	 * 用户执行的操作类型，如"同意"、"拒绝"、"转办"、"加签"等
+	 * </p>
+	 */
+	private String operType;
+
+	/**
+	 * 处理状态
+	 * <p>
+	 * 用户的处理状态：0-待处理，1-处理中，2-已完成。默认为0
+	 * </p>
+	 */
+	private Integer status = 0;
+
+}

pigx-flow/pigx-flow-api/src/main/resources/META-INF/spring/org.springframework.cloud.openfeign.FeignClient.imports

@@ -0,0 +1 @@
+com.pig4cloud.pigx.flow.api.feign.RemoteFlowApiFlowService

pigx-flow/pigx-flow-biz/Dockerfile

@@ -8,12 +8,12 @@ ENV JAVA_OPTS="-Xms512m -Xmx1024m -Djava.security.egd=file:/dev/./urandom"
 
 RUN ln -sf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 
-RUN mkdir -p /pigx-flow-engine
+RUN mkdir -p /pigx-flow
 
-WORKDIR /pigx-flow-engine
+WORKDIR /pigx-flow
 
 EXPOSE 9020
 
-ADD ./target/pigx-flow-engine-biz.jar ./
+ADD ./target/pigx-flow-biz.jar ./
 
-CMD sleep 60;java $JAVA_OPTS -jar pigx-flow-engine-biz.jar
+CMD sleep 60;java $JAVA_OPTS -jar pigx-flow-biz.jar

pigx-flow/pigx-flow-biz/pom.xml

@@ -6,34 +6,13 @@
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>com.pig4cloud</groupId>
-        <artifactId>pigx-flow-engine</artifactId>
-        <version>5.9.0</version>
+        <artifactId>pigx-flow</artifactId>
+        <version>5.10.2-SNAPSHOT</version>
     </parent>
 
-    <artifactId>pigx-flow-engine-biz</artifactId>
+    <artifactId>pigx-flow-biz</artifactId>
 
     <dependencies>
-        <!-- flowable 核心依赖-->
-        <dependency>
-            <groupId>org.flowable</groupId>
-            <artifactId>flowable-bpmn-layout</artifactId>
-            <version>${flowable.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.flowable</groupId>
-            <artifactId>flowable-spring-boot-starter-process</artifactId>
-            <version>${flowable.version}</version>
-        </dependency>
-        <!--task 模块接口-->
-        <dependency>
-            <groupId>com.pig4cloud</groupId>
-            <artifactId>pigx-flow-task-api</artifactId>
-        </dependency>
-        <!--计算引擎-->
-        <dependency>
-            <groupId>com.googlecode.aviator</groupId>
-            <artifactId>aviator</artifactId>
-        </dependency>
         <!--必备: undertow容器-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -59,6 +38,37 @@
             <groupId>com.pig4cloud</groupId>
             <artifactId>pigx-common-data</artifactId>
         </dependency>
+        <!--选配： 发号器-->
+        <dependency>
+            <groupId>com.pig4cloud</groupId>
+            <artifactId>pigx-common-sequence</artifactId>
+        </dependency>
+        <!-- flowable 核心依赖-->
+        <dependency>
+            <groupId>org.flowable</groupId>
+            <artifactId>flowable-bpmn-layout</artifactId>
+            <version>${flowable.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.flowable</groupId>
+            <artifactId>flowable-spring-boot-starter-process</artifactId>
+            <version>${flowable.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>mybatis</artifactId>
+                    <groupId>org.mybatis</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <!--计算引擎-->
+        <dependency>
+            <groupId>com.googlecode.aviator</groupId>
+            <artifactId>aviator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-cache</artifactId>
+        </dependency>
         <!--必备：pigx安全模块-->
         <dependency>
             <groupId>com.pig4cloud</groupId>
@@ -74,11 +84,6 @@
             <groupId>com.pig4cloud</groupId>
             <artifactId>pigx-common-sentinel</artifactId>
         </dependency>
-        <!--必备:  API加解密 -->
-        <dependency>
-            <groupId>com.pig4cloud</groupId>
-            <artifactId>pigx-common-encrypt-api</artifactId>
-        </dependency>
         <!--必备: feign 依赖-->
         <dependency>
             <groupId>com.pig4cloud</groupId>
@@ -87,13 +92,18 @@
         <!--必备: 依赖api模块-->
         <dependency>
             <groupId>com.pig4cloud</groupId>
-            <artifactId>pigx-flow-engine-api</artifactId>
+            <artifactId>pigx-flow-api</artifactId>
         </dependency>
         <!--必备: log 依赖-->
         <dependency>
             <groupId>com.pig4cloud</groupId>
             <artifactId>pigx-common-log</artifactId>
         </dependency>
+        <!--必备:  API加解密 -->
+        <dependency>
+            <groupId>com.pig4cloud</groupId>
+            <artifactId>pigx-common-encrypt-api</artifactId>
+        </dependency>
         <!--选配: mybatis 依赖 -->
         <dependency>
             <groupId>com.baomidou</groupId>
@@ -114,10 +124,6 @@
             <groupId>com.pig4cloud</groupId>
             <artifactId>pigx-common-swagger</artifactId>
         </dependency>
-        <dependency>
-            <groupId>cn.hutool</groupId>
-            <artifactId>hutool-cache</artifactId>
-        </dependency>
         <!--测试: spring boot test-->
         <dependency>
             <groupId>org.springframework.boot</groupId>

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/PigxFlowApplication.java

@@ -0,0 +1,48 @@
+package com.pig4cloud.pigx.flow;
+
+import com.pig4cloud.pigx.common.feign.annotation.EnablePigxFeignClients;
+import com.pig4cloud.pigx.common.security.annotation.EnablePigxResourceServer;
+import com.pig4cloud.pigx.common.swagger.annotation.EnableOpenApi;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+
+/**
+ * 流程引擎服务启动类
+ * <p>
+ * PigX流程引擎微服务的主入口，基于Flowable工作流引擎构建。
+ * 提供完整的工作流管理功能，包括流程定义、流程实例管理、任务处理等。
+ * 主要特性：
+ * - 集成Flowable BPMN 2.0流程引擎
+ * - 支持动态表单和流程配置
+ * - 提供RESTful API接口
+ * - 支持多租户隔离
+ * - 集成Spring Cloud微服务架构
+ * </p>
+ * 
+ * @author pigx archetype
+ */
+@EnableOpenApi("task")
+@EnablePigxFeignClients
+@EnableDiscoveryClient
+@EnablePigxResourceServer
+@SpringBootApplication
+public class PigxFlowApplication {
+
+	/**
+	 * 流程引擎服务主方法
+	 * <p>
+	 * 启动Spring Boot应用，初始化流程引擎相关组件：
+	 * - 初始化Flowable流程引擎
+	 * - 注册到服务发现中心
+	 * - 启用OAuth2资源服务器保护
+	 * - 开启Swagger API文档
+	 * </p>
+	 * 
+	 * @param args 命令行参数
+	 */
+	public static void main(String[] args) {
+		SpringApplication.run(PigxFlowApplication.class, args);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/config/SequenceConfiguration.java

@@ -0,0 +1,57 @@
+package com.pig4cloud.pigx.flow.config;
+
+import cn.hutool.core.date.DateUtil;
+import com.pig4cloud.pigx.common.data.tenant.TenantContextHolder;
+import com.pig4cloud.pigx.common.sequence.builder.DbSeqBuilder;
+import com.pig4cloud.pigx.common.sequence.properties.BaseSequenceProperties;
+import com.pig4cloud.pigx.common.sequence.sequence.Sequence;
+import org.flowable.spring.SpringProcessEngineConfiguration;
+import org.flowable.spring.boot.EngineConfigurationConfigurer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import javax.sql.DataSource;
+
+/**
+ * 流程序列号生成器配置类
+ * <p>
+ * 配置流程模块专用的序列号生成器，用于生成各种业务编号。 支持多租户隔离，每个租户的序列号独立生成。 序列号格式：flow_租户ID_日期_序号，保证全局唯一性。 主要用于：
+ * - 流程实例编号生成 - 任务编号生成 - 其他需要唯一标识的业务场景
+ * </p>
+ * 
+ * @author lengleng
+ * @date 2023-07-19
+ */
+@Configuration
+public class SequenceConfiguration {
+
+	/**
+	 * 创建流程模块专用的序列号生成器
+	 * <p>
+	 * 基于数据库实现的分布式序列号生成器，特点： - 支持分布式环境下的并发生成 - 按租户和日期分段，避免序号过长 - 支持配置步长，提高生成性能 -
+	 * 失败重试机制，保证可靠性
+	 * </p>
+	 * @param dataSource 数据源，用于访问序列号表
+	 * @param properties 序列号配置属性，包含步长、重试次数等
+	 * @return 配置好的序列号生成器实例
+	 */
+	@Bean
+	public Sequence flowSequence(DataSource dataSource, BaseSequenceProperties properties) {
+		return DbSeqBuilder.create()
+			.bizName(() -> String.format("flow_%s_%s", TenantContextHolder.getTenantId(), DateUtil.today()))
+			.dataSource(dataSource)
+			.step(properties.getStep())
+			.retryTimes(properties.getDb().getRetryTimes())
+			.tableName(properties.getDb().getTableName())
+			.build();
+	}
+
+	@Bean
+	public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> configurer() {
+		return engineConfiguration -> {
+			engineConfiguration.setEnableDatabaseEventLogging(true);
+			engineConfiguration.setEnableVerboseExecutionTreeLogging(true);
+		};
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessCombinationController.java

@@ -0,0 +1,56 @@
+package com.pig4cloud.pigx.flow.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.service.ICombinationGroupService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 流程组聚合控制器
+ * <p>
+ * 该控制器负责处理流程组的聚合查询操作，主要功能包括： 1. 查询流程组及其包含的流程列表 2. 查询当前用户有权限发起的流程组
+ * </p>
+ * <p>
+ * 流程组是对多个相关流程的逻辑分组，便于用户快速找到和发起相关流程。 通过该控制器，前端可以展示流程分组导航，提升用户体验。
+ * </p>
+ *
+ * @author pigx
+ * @since 2023
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/combination/group")
+public class ProcessCombinationController {
+
+	private final ICombinationGroupService combinationGroupService;
+
+	/**
+	 * 分页查询流程组及其包含的流程列表
+	 * <p>
+	 * 该接口用于获取指定流程组的详细信息，包括组内的所有流程定义。 支持分页查询，适用于流程较多的场景。
+	 * </p>
+	 * @param page 分页参数对象，包含当前页码、每页大小等信息
+	 * @param groupId 流程组ID，用于查询特定组的流程；如果为空则查询所有组
+	 * @return R 统一响应对象，包含分页后的流程组及流程列表数据
+	 */
+	@GetMapping("listGroupWithProcess")
+	public R listGroupWithProcess(Page page, Long groupId) {
+		return combinationGroupService.listGroupWithProcess(page, groupId);
+	}
+
+	/**
+	 * 查询当前登录用户可以发起的所有流程组
+	 * <p>
+	 * 该接口根据当前用户的权限，返回其有权限发起流程的所有流程组。 用于在流程发起页面展示用户可用的流程分组，实现权限控制。
+	 * </p>
+	 * @return R 统一响应对象，包含当前用户可发起的流程组列表
+	 */
+	@GetMapping("listCurrentUserStartGroup")
+	public R listCurrentUserStartGroup() {
+		return combinationGroupService.listCurrentUserStartGroup();
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessController.java

@@ -0,0 +1,81 @@
+package com.pig4cloud.pigx.flow.controller;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.entity.Process;
+import com.pig4cloud.pigx.flow.service.IProcessService;
+import com.pig4cloud.pigx.flow.vo.ProcessVO;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * 流程定义控制器
+ * <p>
+ * 提供流程定义相关的REST API接口，包括流程的创建、查询、更新等操作。
+ * 所有接口都需要用户认证，并根据用户权限进行访问控制。
+ * </p>
+ * 
+ * @author pigx
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/process")
+public class ProcessController {
+
+	private final IProcessService processService;
+
+	/**
+	 * 获取流程详细信息
+	 * <p>
+	 * 根据流程ID获取流程的完整配置信息，包括：
+	 * - 基本信息（名称、图标、描述等）
+	 * - 表单配置（表单项定义、验证规则等）
+	 * - 流程配置（节点定义、流转规则等）
+	 * - 权限配置（管理员、发起人范围等）
+	 * </p>
+	 * 
+	 * @param flowId 流程定义ID
+	 * @return 流程详细信息
+	 */
+	@GetMapping("getDetail")
+	public R<ProcessVO> getDetail(String flowId) {
+		return processService.getDetail(flowId);
+	}
+
+	/**
+	 * 创建新流程定义
+	 * <p>
+	 * 创建新的流程定义，需要提供流程基本信息。
+	 * 系统会自动生成流程的唯一标识（flowId）和默认配置。
+	 * 创建者自动成为该流程的管理员。
+	 * </p>
+	 * 
+	 * @param process 流程定义实体（包含名称、分组、图标等信息）
+	 * @return 创建结果，成功时返回生成的flowId
+	 */
+	@PostMapping("create")
+	public R create(@RequestBody Process process) {
+		return processService.create(process);
+	}
+
+	/**
+	 * 更新流程状态或分组
+	 * <p>
+	 * 支持以下操作：
+	 * - stop: 停用流程（停用后不能创建新实例，但已有实例可继续执行）
+	 * - using: 启用流程（恢复流程的正常使用）
+	 * - delete: 删除流程（逻辑删除，可恢复）
+	 * - 修改分组：传入groupId参数可将流程移动到其他分组
+	 * </p>
+	 * 
+	 * @param flowId 流程定义ID
+	 * @param type 操作类型（stop/using/delete）
+	 * @param groupId 流程分组ID（可选，用于修改流程所属分组）
+	 * @return 操作结果
+	 */
+	@PutMapping("update/{flowId}")
+	public R update(@PathVariable String flowId, @RequestParam String type,
+			@RequestParam(required = false) Long groupId) {
+		return processService.update(flowId, type, groupId);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessCopyController.java

@@ -0,0 +1,49 @@
+package com.pig4cloud.pigx.flow.controller;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.service.IProcessCopyService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 流程抄送控制器
+ * <p>
+ * 该控制器负责管理流程抄送功能，处理抄送相关的查询操作。
+ * 流程抄送是工作流中的重要功能，允许将流程执行情况通知给相关人员，
+ * 这些人员无需参与审批，但需要了解流程进展。
+ * </p>
+ * <p>
+ * 主要应用场景：
+ * 1. 领导知晓 - 将重要流程的执行情况抄送给相关领导
+ * 2. 部门协同 - 将跨部门流程抄送给相关部门负责人
+ * 3. 信息共享 - 将流程信息共享给利益相关者
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-20
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/processCopy")
+public class ProcessCopyController {
+
+	private final IProcessCopyService processCopyService;
+
+	/**
+	 * 查询单个抄送记录的详细信息
+	 * <p>
+	 * 获取指定抄送记录的完整信息，包括抄送的流程信息、抄送时间、
+	 * 抄送人、被抄送人等详细数据。用于在抄送列表中查看具体抄送内容。
+	 * </p>
+	 *
+	 * @param id 抄送记录ID
+	 * @return R 统一响应对象，包含抄送记录的详细信息
+	 */
+	@GetMapping("querySingleDetail")
+	public R querySingleDetail(long id) {
+		return processCopyService.querySingleDetail(id);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessGroupController.java

@@ -1,13 +1,19 @@
-package com.pig4cloud.pigx.flow.task.controller;
+package com.pig4cloud.pigx.flow.controller;
 
 import com.pig4cloud.pigx.common.core.util.R;
-import com.pig4cloud.pigx.flow.task.entity.ProcessGroup;
-import com.pig4cloud.pigx.flow.task.service.IProcessGroupService;
+import com.pig4cloud.pigx.flow.entity.ProcessGroup;
+import com.pig4cloud.pigx.flow.service.IProcessGroupService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 
+/**
+ * 流程分组控制器：提供流程分组的增删查等操作
+ *
+ * @author lengleng
+ * @date 2025/07/14
+ */
 @RestController
 @RequiredArgsConstructor
 @RequestMapping("processGroup")
@@ -16,8 +22,8 @@ public class ProcessGroupController {
 	private final IProcessGroupService processGroupService;
 
 	/**
-	 * 组列表
-	 * @return
+	 * 查询流程组列表
+	 * @return 流程组列表
 	 */
 	@GetMapping("list")
 	public R<List<ProcessGroup>> queryList() {
@@ -25,9 +31,9 @@ public class ProcessGroupController {
 	}
 
 	/**
-	 * 新增流程分组
-	 * @param processGroup 分组名
-	 * @return 添加结果
+	 * 创建流程分组
+	 * @param processGroup 流程分组实体对象
+	 * @return 操作结果
 	 */
 	@PostMapping("create")
 	public R create(@RequestBody ProcessGroup processGroup) {
@@ -36,8 +42,8 @@ public class ProcessGroupController {
 
 	/**
 	 * 删除分组
-	 * @param id
-	 * @return
+	 * @param id 分组ID
+	 * @return 操作结果
 	 */
 	@DeleteMapping("delete/{id}")
 	public R delete(@PathVariable long id) {

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessInstanceController.java

@@ -0,0 +1,169 @@
+package com.pig4cloud.pigx.flow.controller;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.ProcessInstanceParamDto;
+import com.pig4cloud.pigx.flow.dto.TaskQueryParamDto;
+import com.pig4cloud.pigx.flow.service.IProcessInstanceService;
+import com.pig4cloud.pigx.flow.vo.NodeFormatParamVo;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * 流程实例管理控制器
+ * <p>
+ * 该控制器提供流程实例的全生命周期管理功能，是工作流系统的核心业务接口。
+ * 主要功能包括：
+ * 1. 流程启动 - 根据流程定义创建新的流程实例
+ * 2. 任务查询 - 查询待办、已办、我发起的、抄送给我的任务
+ * 3. 流程监控 - 查看流程实例详情和执行状态
+ * 4. 流程展示 - 格式化展示流程节点和执行路径
+ * </p>
+ * <p>
+ * 与EngineFlowController不同，该控制器提供的是面向业务的高级接口，
+ * 包含了业务逻辑处理、权限控制、数据格式化等功能。
+ * </p>
+ *
+ * @author pigx
+ * @since 2023
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/process-instance")
+public class ProcessInstanceController {
+
+	private final IProcessInstanceService processInstanceService;
+
+	/**
+	 * 启动新的流程实例
+	 * <p>
+	 * 根据流程定义启动一个新的流程实例。该接口会：
+	 * 1. 验证用户是否有启动该流程的权限
+	 * 2. 创建流程实例记录并保存表单数据
+	 * 3. 根据流程配置分配第一个任务节点
+	 * 4. 处理流程抄送和通知
+	 * </p>
+	 *
+	 * @param processInstanceParamDto 流程启动参数，包含：
+	 *                                - processId: 流程定义ID
+	 *                                - formData: 表单数据
+	 *                                - startUserId: 发起人用户ID
+	 *                                - copyUserList: 抄送人员列表
+	 * @return R 统一响应对象，成功返回流程实例ID
+	 */
+	@SneakyThrows
+	@PostMapping("startProcessInstance")
+	public R startProcessInstance(@RequestBody ProcessInstanceParamDto processInstanceParamDto) {
+		return processInstanceService.startProcessInstance(processInstanceParamDto);
+	}
+
+	/**
+	 * 分页查询当前用户的待办任务
+	 * <p>
+	 * 查询分配给当前登录用户的所有待处理任务。支持按流程名称、
+	 * 创建时间等条件过滤。返回的数据包含任务信息和关联的表单数据。
+	 * </p>
+	 *
+	 * @param queryParamDto 查询参数，包含：
+	 *                      - processName: 流程名称（可选）
+	 *                      - taskTime: 任务创建时间范围（可选）
+	 *                      - current: 当前页码
+	 *                      - size: 每页大小
+	 * @return R 统一响应对象，包含分页的待办任务列表
+	 */
+	@SneakyThrows
+	@PostMapping("queryMineTask")
+	public R queryMineTask(@RequestBody TaskQueryParamDto queryParamDto) {
+		return processInstanceService.queryMineTask(queryParamDto);
+	}
+
+	/**
+	 * 分页查询当前登录用户的已办任务
+	 * <p>
+	 * 查询当前用户已经完成处理的历史任务。包括审批通过、拒绝、
+	 * 转办等各种已完成状态的任务。返回数据包含任务处理结果和处理时间。
+	 * </p>
+	 *
+	 * @param taskQueryParamDto 查询参数，支持按流程名称、完成时间等条件过滤
+	 * @return R 统一响应对象，包含分页的已办任务列表
+	 */
+	@SneakyThrows
+	@PostMapping("queryMineEndTask")
+	public R queryMineEndTask(@RequestBody TaskQueryParamDto taskQueryParamDto) {
+		return processInstanceService.queryMineEndTask(taskQueryParamDto);
+	}
+
+	/**
+	 * 分页查询我发起的流程
+	 * <p>
+	 * 查询当前用户作为发起人创建的所有流程实例。
+	 * 包括运行中、已完成、已终止等各种状态的流程。
+	 * 用户可以查看自己发起流程的执行进度和当前状态。
+	 * </p>
+	 *
+	 * @param taskQueryParamDto 查询参数，支持按流程名称、发起时间等条件过滤
+	 * @return R 统一响应对象，包含分页的流程实例列表
+	 */
+	@SneakyThrows
+	@PostMapping("queryMineStarted")
+	public R queryMineStarted(@RequestBody TaskQueryParamDto taskQueryParamDto) {
+		return processInstanceService.queryMineStarted(taskQueryParamDto);
+	}
+
+	/**
+	 * 分页查询抄送给我的流程
+	 * <p>
+	 * 查询抄送给当前用户的流程信息。抄送是流程中的通知机制，
+	 * 被抄送人只需了解流程进展，无需处理任务。
+	 * 通常用于让相关人员知晓重要流程的执行情况。
+	 * </p>
+	 *
+	 * @param taskQueryParamDto 查询参数，支持按流程名称、抄送时间等条件过滤
+	 * @return R 统一响应对象，包含分页的抄送记录列表
+	 */
+	@SneakyThrows
+	@PostMapping("queryMineCC")
+	public R queryMineCC(@RequestBody TaskQueryParamDto taskQueryParamDto) {
+		return processInstanceService.queryMineCC(taskQueryParamDto);
+	}
+
+	/**
+	 * 格式化显示流程节点
+	 * <p>
+	 * 根据流程定义和表单数据，格式化显示流程节点信息。
+	 * 该接口主要用于流程发起页面，根据表单数据动态计算并展示：
+	 * 1. 各节点的审批人员
+	 * 2. 条件分支的走向
+	 * 3. 抄送人员列表
+	 * 帮助用户在发起流程前预览流程走向。
+	 * </p>
+	 *
+	 * @param nodeFormatParamVo 节点格式化参数，包含：
+	 *                          - processId: 流程定义ID
+	 *                          - formData: 表单数据
+	 * @return R 统一响应对象，包含格式化后的节点显示信息
+	 */
+	@PostMapping("formatStartNodeShow")
+	public R formatStartNodeShow(@RequestBody NodeFormatParamVo nodeFormatParamVo) {
+		return processInstanceService.formatStartNodeShow(nodeFormatParamVo);
+	}
+
+	/**
+	 * 查询流程实例详情
+	 * <p>
+	 * 获取指定流程实例的完整信息，包括：
+	 * 1. 流程基本信息 - 发起人、发起时间、当前状态等
+	 * 2. 表单数据 - 流程关联的业务表单数据
+	 * 3. 执行历史 - 各节点的审批记录、处理人、处理意见等
+	 * 4. 流程图 - 当前执行节点和路径高亮显示
+	 * </p>
+	 *
+	 * @param processInstanceId 流程实例ID
+	 * @return R 统一响应对象，包含流程实例的完整详情
+	 */
+	@GetMapping("detail")
+	public R detail(String processInstanceId) {
+		return processInstanceService.detail(processInstanceId);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessNodeDataController.java

@@ -0,0 +1,70 @@
+package com.pig4cloud.pigx.flow.controller;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.Node;
+import com.pig4cloud.pigx.flow.dto.ProcessNodeDataDto;
+import com.pig4cloud.pigx.flow.service.IProcessNodeDataService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * 流程节点数据管理控制器
+ * <p>
+ * 该控制器负责管理流程节点的配置数据，包括节点的保存和查询操作。
+ * 流程节点数据是流程定义的核心组成部分，定义了每个节点的属性、
+ * 审批人员、条件规则、表单权限等关键信息。
+ * </p>
+ * <p>
+ * 节点数据的主要内容：
+ * 1. 节点基本信息 - 节点类型、名称、描述等
+ * 2. 人员配置 - 审批人、抄送人的分配规则
+ * 3. 条件配置 - 分支条件、跳转规则等
+ * 4. 表单权限 - 节点对表单字段的查看、编辑权限
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-07
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/processNodeData")
+public class ProcessNodeDataController {
+
+	private final IProcessNodeDataService processNodeDataService;
+
+	/**
+	 * 保存或更新流程节点数据
+	 * <p>
+	 * 保存流程中某个节点的配置信息。如果节点已存在则更新，
+	 * 不存在则新增。该接口通常在流程设计器中保存节点配置时调用。
+	 * </p>
+	 *
+	 * @param processNodeDataDto 节点数据对象，包含：
+	 *                           - flowId: 流程定义ID
+	 *                           - nodeId: 节点ID
+	 *                           - nodeData: 节点配置数据（JSON格式）
+	 * @return R 统一响应对象，保存成功返回节点数据ID
+	 */
+	@PostMapping("saveNodeData")
+	public R saveNodeData(@RequestBody ProcessNodeDataDto processNodeDataDto) {
+		return processNodeDataService.saveNodeData(processNodeDataDto);
+	}
+
+	/**
+	 * 获取指定节点的配置数据
+	 * <p>
+	 * 查询流程中特定节点的详细配置信息。返回的数据包含节点的
+	 * 所有配置项，如审批人规则、条件设置、表单权限等。
+	 * 主要用于流程设计器加载节点配置或流程执行时获取节点规则。
+	 * </p>
+	 *
+	 * @param flowId 流程定义ID
+	 * @param nodeId 节点ID
+	 * @return R<Node> 统一响应对象，包含节点的完整配置信息
+	 */
+	@GetMapping("getNodeData")
+	public R<Node> getNodeData(String flowId, String nodeId) {
+		return processNodeDataService.getNodeData(flowId, nodeId);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessRemoteController.java

@@ -0,0 +1,201 @@
+package com.pig4cloud.pigx.flow.controller;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.*;
+import com.pig4cloud.pigx.flow.service.IRemoteService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 远程服务调用控制器
+ * <p>
+ * 该控制器作为流程模块的内部接口，主要供其他模块调用或流程引擎内部使用。 提供了一系列辅助功能接口，包括： 1. 用户和组织查询 - 根据角色、部门查询用户 2. 流程事件处理
+ * - 节点开始/结束、任务分配等事件 3. 抄送管理 - 保存流程抄送记录 4. 权限验证 - 检查用户组织关系
+ * </p>
+ * <p>
+ * 这些接口通常在流程执行过程中被引擎自动调用， 用于完成流程的各种业务逻辑。
+ * </p>
+ *
+ * @author pigx
+ * @since 2023
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/remote")
+public class ProcessRemoteController {
+
+	private final IRemoteService remoteService;
+
+	/**
+	 * 根据角色ID列表查询用户ID列表
+	 * <p>
+	 * 查询拥有指定角色的所有用户ID。该接口主要用于流程节点配置中 按角色分配任务时，获取对应角色下的所有用户。
+	 * </p>
+	 * @param roleIdList 角色ID列表
+	 * @return R<List<Long>> 统一响应对象，包含用户ID列表
+	 */
+	@PostMapping("queryUserIdListByRoleIdList")
+	public R<List<Long>> queryUserIdListByRoleIdList(@RequestBody List<Long> roleIdList) {
+		return remoteService.queryUserIdListByRoleIdList(roleIdList);
+	}
+
+	/**
+	 * 保存流程抄送记录
+	 * <p>
+	 * 在流程执行过程中，当节点配置了抄送人时， 调用此接口保存抄送记录。被抄送人可以在抄送列表中查看流程信息。
+	 * </p>
+	 * @param copyDto 抄送数据对象，包含流程实例ID、抄送人、被抄送人等信息
+	 * @return R 统一响应对象
+	 */
+	@PostMapping("savecc")
+	public R saveCC(@RequestBody ProcessCopyDto copyDto) {
+		return remoteService.saveCC(copyDto);
+	}
+
+	/**
+	 * 检查是否为所有父级部门
+	 * <p>
+	 * 验证指定部门是否包含了某些部门的所有父级部门。 用于流程中按部门层级分配任务时的权限验证。
+	 * </p>
+	 * @param checkParentDto 检查参数，包含需要验证的部门信息
+	 * @return R<Boolean> 统一响应对象，true-是所有父级，false-不是
+	 */
+	@PostMapping("checkIsAllParent")
+	public R<Boolean> checkIsAllParent(@RequestBody CheckParentDto checkParentDto) {
+		return remoteService.checkIsAllParent(checkParentDto);
+	}
+
+	/**
+	 * 根据部门ID列表查询用户ID列表
+	 * <p>
+	 * 查询指定部门下的所有用户ID。该接口主要用于流程节点配置中 按部门分配任务时，获取对应部门下的所有用户。
+	 * </p>
+	 * @param depIdList 部门ID列表
+	 * @return R<List<Long>> 统一响应对象，包含用户ID列表
+	 */
+	@PostMapping("queryUserIdListByDepIdList")
+	public R<List<Long>> queryUserIdListByDepIdList(@RequestBody List<Long> depIdList) {
+		return remoteService.queryUserIdListByDepIdList(depIdList);
+	}
+
+	/**
+	 * 检查是否为所有子级部门
+	 * <p>
+	 * 验证指定部门是否包含了某些部门的所有子级部门。 用于流程中按部门层级分配任务时的权限验证。
+	 * </p>
+	 * @param checkChildDto 检查参数，包含需要验证的部门信息
+	 * @return R<Boolean> 统一响应对象，true-是所有子级，false-不是
+	 */
+	@PostMapping("checkIsAllChild")
+	public R<Boolean> checkIsAllChild(@RequestBody CheckChildDto checkChildDto) {
+		return remoteService.checkIsAllChild(checkChildDto);
+	}
+
+	/**
+	 * 获取用户全部信息
+	 * <p>
+	 * 查询用户的完整信息，包括基本信息和扩展字段。 扩展字段可能包括部门、角色、上级领导等信息， 这些信息在流程执行中用于人员分配和权限判断。
+	 * </p>
+	 * @param userId 用户ID
+	 * @return R<Map<String, Object>> 统一响应对象，包含用户的所有信息
+	 */
+	@GetMapping("queryUserAllInfo")
+	public R<Map<String, Object>> queryUserAllInfo(long userId) {
+		return remoteService.queryUserAllInfo(userId);
+	}
+
+	/**
+	 * 处理节点开始事件
+	 * <p>
+	 * 当流程节点开始执行时触发此事件。 记录节点开始时间、状态等信息，并可执行相关业务逻辑。
+	 * </p>
+	 * @param recordParamDto 节点记录参数，包含节点ID、流程实例ID等
+	 * @return R 统一响应对象
+	 */
+	@PostMapping("startNodeEvent")
+	public R startNodeEvent(@RequestBody ProcessNodeRecordParamDto recordParamDto) {
+		return remoteService.startNodeEvent(recordParamDto);
+	}
+
+	/**
+	 * 处理流程创建事件
+	 * <p>
+	 * 当新的流程实例被创建时触发此事件。 记录流程实例的创建信息，包括发起人、发起时间、表单数据等。
+	 * </p>
+	 * @param processInstanceRecordParamDto 流程实例记录参数
+	 * @return R 统一响应对象
+	 */
+	@PostMapping("createProcessEvent")
+	public R createProcessEvent(@RequestBody ProcessInstanceRecordParamDto processInstanceRecordParamDto) {
+		return remoteService.createProcessEvent(processInstanceRecordParamDto);
+	}
+
+	/**
+	 * 处理节点结束事件
+	 * <p>
+	 * 当流程节点执行完成时触发此事件。 更新节点状态、结束时间等信息，并可执行后续业务逻辑。
+	 * </p>
+	 * @param recordParamDto 节点记录参数，包含节点ID、流程实例ID等
+	 * @return R 统一响应对象
+	 */
+	@PostMapping("endNodeEvent")
+	public R endNodeEvent(@RequestBody ProcessNodeRecordParamDto recordParamDto) {
+		return remoteService.endNodeEvent(recordParamDto);
+	}
+
+	/**
+	 * 设置任务执行人
+	 * <p>
+	 * 在任务创建时设置任务的执行人。 根据节点配置的人员分配规则，确定并记录任务的实际处理人。
+	 * </p>
+	 * @param processNodeRecordAssignUserParamDto 任务分配参数，包含任务ID、用户ID等
+	 * @return R 统一响应对象
+	 */
+	@PostMapping("startAssignUser")
+	public R startAssignUser(@RequestBody ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto) {
+		return remoteService.startAssignUser(processNodeRecordAssignUserParamDto);
+	}
+
+	/**
+	 * 处理任务结束事件
+	 * <p>
+	 * 当任务被完成时触发此事件。 更新任务状态、处理结果、处理时间等信息， 并可执行相关的业务通知或后续处理。
+	 * </p>
+	 * @param processNodeRecordAssignUserParamDto 任务结束参数，包含任务ID、处理结果等
+	 * @return R 统一响应对象
+	 */
+	@PostMapping("taskEndEvent")
+	public R taskEndEvent(@RequestBody ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto) {
+		return remoteService.taskEndEvent(processNodeRecordAssignUserParamDto);
+	}
+
+	/**
+	 * 处理流程实例结束事件
+	 * <p>
+	 * 当整个流程实例执行完成时触发此事件。 更新流程实例状态为已完成，记录结束时间， 并可执行流程结束后的业务处理。
+	 * </p>
+	 * @param processInstanceParamDto 流程实例参数
+	 * @return R 统一响应对象
+	 */
+	@PostMapping("endProcess")
+	public R endProcess(@RequestBody ProcessInstanceParamDto processInstanceParamDto) {
+		return remoteService.endProcess(processInstanceParamDto);
+	}
+
+	/**
+	 * 查询流程管理员
+	 * <p>
+	 * 获取指定流程的管理员用户ID。 流程管理员拥有该流程的特殊权限， 如强制终止流程、调整流程路径等。
+	 * </p>
+	 * @param flowId 流程定义ID
+	 * @return R<Long> 统一响应对象，包含管理员用户ID
+	 */
+	@GetMapping("queryProcessAdmin")
+	public R<Long> queryProcessAdmin(String flowId) {
+		return remoteService.queryProcessAdmin(flowId);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/controller/ProcessTaskController.java

@@ -0,0 +1,160 @@
+package com.pig4cloud.pigx.flow.controller;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.TaskParamDto;
+import com.pig4cloud.pigx.flow.service.ITaskService;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * 任务管理控制器
+ * <p>
+ * 该控制器提供任务操作的高级业务接口，是面向最终用户的任务处理入口。 与EngineTaskController不同，该控制器封装了完整的业务逻辑，包括： 1. 任务查询 -
+ * 查看任务详情、首页统计数据 2. 任务处理 - 完成任务、退回任务、终止流程 3. 高级操作 - 加签、委托、转办等特殊处理
+ * </p>
+ * <p>
+ * 所有操作都包含权限验证、业务校验、操作记录等完整的业务处理流程， 确保任务处理的合规性和可追溯性。
+ * </p>
+ *
+ * @author pigx
+ * @since 2023
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/task")
+public class ProcessTaskController {
+
+	private final ITaskService taskService;
+
+	/**
+	 * 查询任务统计数据看板
+	 * <p>
+	 * 获取当前登录用户的任务统计信息，用于首页或工作台展示。 返回的统计数据可能包括：待办数量、已办数量、超时任务数等。
+	 * </p>
+	 * @return R 统一响应对象，包含任务统计数据
+	 */
+	@SneakyThrows
+	@GetMapping("queryTaskData")
+	public R queryTaskData() {
+		return taskService.queryTaskData();
+	}
+
+	/**
+	 * 查询任务详情
+	 * <p>
+	 * 获取指定任务的完整信息，包括： 1. 任务基本信息 - 任务名称、创建时间、处理人等 2. 流程信息 - 所属流程、发起人、流程状态等 3. 表单数据 -
+	 * 与任务关联的业务表单信息 4. 操作权限 - 根据用户角色和任务状态判断可执行的操作
+	 * </p>
+	 * @param taskId 任务ID
+	 * @param view 是否为查看模式：true-仅查看，false-可编辑处理
+	 * @return R 统一响应对象，包含任务的完整信息和可操作项
+	 */
+	@SneakyThrows
+	@GetMapping("queryTask")
+	public R queryTask(String taskId, boolean view) {
+
+		return taskService.queryTask(taskId, view);
+
+	}
+
+	/**
+	 * 完成任务
+	 * <p>
+	 * 处理当前任务，支持多种完成方式： 1. 通过 - 同意任务审批，流程继续往下执行 2. 拒绝 - 不同意任务审批，流程可能结束或进入其他分支 3. 附带意见 -
+	 * 可以添加审批意见和附件 完成后会记录操作日志，并根据流程配置进行后续处理。
+	 * </p>
+	 * @param completeParamDto 任务完成参数，包含： - taskId: 任务ID - result: 处理结果（通过/拒绝） - comment:
+	 * 审批意见 - variables: 流程变量
+	 * @return R 统一响应对象，操作成功返回下一节点信息
+	 */
+	@SneakyThrows
+	@PostMapping("completeTask")
+	public R completeTask(@RequestBody TaskParamDto completeParamDto) {
+		return taskService.completeTask(completeParamDto);
+	}
+
+	/**
+	 * 前加签任务
+	 * <p>
+	 * 在任务处理前添加其他审批人。前加签是指在当前任务处理前， 先让其他人进行审批，审批完成后再回到当前处理人。 通常用于需要征求其他人意见或补充审批的场景。
+	 * </p>
+	 * @param completeParamDto 加签参数，包含： - taskId: 当前任务ID - targetUserIdList: 加签用户ID列表 -
+	 * comment: 加签说明
+	 * @return R 统一响应对象，操作成功返回加签任务信息
+	 */
+	@SneakyThrows
+	@PostMapping("delegateTask")
+	public R delegateTask(@RequestBody TaskParamDto completeParamDto) {
+
+		return taskService.delegateTask(completeParamDto);
+
+	}
+
+	/**
+	 * 加签完成任务
+	 * <p>
+	 * 加签人完成加签任务后，任务会返回给原处理人。 该接口用于处理加签任务的完成操作，支持添加审批意见。 完成后，原处理人可以继续处理该任务。
+	 * </p>
+	 * @param completeParamDto 加签完成参数，包含： - taskId: 加签任务ID - comment: 加签意见 - variables:
+	 * 需要传递的变量
+	 * @return R 统一响应对象，操作成功后任务返回给原处理人
+	 */
+	@SneakyThrows
+	@PostMapping("resolveTask")
+	public R resolveTask(@RequestBody TaskParamDto completeParamDto) {
+
+		return taskService.resolveTask(completeParamDto);
+
+	}
+
+	/**
+	 * 设置任务执行人（转办）
+	 * <p>
+	 * 将任务转办给其他用户处理。与加签不同，转办后任务不会返回给原处理人。 通常用于当前处理人无法处理该任务，需要其他人代为处理的场景。 转办后会保留转办记录。
+	 * </p>
+	 * @param completeParamDto 转办参数，包含： - taskId: 任务ID - targetUserIdList: 目标用户ID列表 -
+	 * comment: 转办说明
+	 * @return R 统一响应对象，操作成功返回转办信息
+	 */
+	@SneakyThrows
+	@PostMapping("setAssignee")
+	public R setAssignee(@RequestBody TaskParamDto completeParamDto) {
+
+		return taskService.setAssignee(completeParamDto);
+
+	}
+
+	/**
+	 * 终止流程实例
+	 * <p>
+	 * 强制终止当前流程实例的执行。该操作不可逆，流程终止后无法恢复。 通常用于： 1. 流程发起错误需要撤销 2. 业务变更导致流程无需继续 3. 紧急情况下的流程中止
+	 * 需要有相应权限才能执行此操作。
+	 * </p>
+	 * @param completeParamDto 终止参数，包含： - processInstanceId: 流程实例ID - reason: 终止原因
+	 * @return R 统一响应对象，操作成功返回终止信息
+	 */
+	@SneakyThrows
+	@PostMapping("stopProcessInstance")
+	public R stopProcessInstance(@RequestBody TaskParamDto completeParamDto) {
+
+		return taskService.stopProcessInstance(completeParamDto);
+
+	}
+
+	/**
+	 * 退回任务
+	 * <p>
+	 * 将当前任务退回到上一个或指定的节点重新处理。 退回操作会： 1. 撤销当前节点的处理 2. 流程返回到指定节点 3. 保留退回记录和原因
+	 * 退回后，被退回节点的处理人需要重新处理任务。
+	 * </p>
+	 * @param taskParamDto 退回参数，包含： - taskId: 当前任务ID - targetNodeId: 目标节点ID（可选，不指定则退回上一节点）
+	 * - reason: 退回原因
+	 * @return R 统一响应对象，操作成功返回退回信息
+	 */
+	@PostMapping("back")
+	public R back(@RequestBody TaskParamDto taskParamDto) {
+		return taskService.back(taskParamDto);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessCopyMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.ProcessCopy;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程抄送数据访问接口
+ * <p>
+ * 负责流程抄送表(wflow_process_copy)的数据访问操作
+ * 管理流程实例的抄送记录，包括抄送人、抄送时间、已读状态等信息
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-20
+ */
+@Mapper
+public interface ProcessCopyMapper extends BaseMapper<ProcessCopy> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessGroupMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.ProcessGroup;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程分组数据访问接口
+ * <p>
+ * 负责流程分组表(wflow_process_group)的数据访问操作
+ * 管理流程的分类分组信息，支持流程的分类展示和管理
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-25
+ */
+@Mapper
+public interface ProcessGroupMapper extends BaseMapper<ProcessGroup> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessInstanceRecordMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.ProcessInstanceRecord;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程实例记录数据访问接口
+ * <p>
+ * 负责流程实例记录表(wflow_process_instance_record)的数据访问操作
+ * 管理流程实例的执行记录，包括流程实例的创建、状态变更、完成等信息
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-07
+ */
+@Mapper
+public interface ProcessInstanceRecordMapper extends BaseMapper<ProcessInstanceRecord> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.Process;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程定义数据访问接口
+ * <p>
+ * 负责流程定义表(wflow_process)的数据访问操作
+ * 包含流程定义的基本信息管理，如流程名称、流程图、表单配置等
+ * </p>
+ *
+ * @author cxygzl
+ * @since 2023-05-25
+ */
+@Mapper
+public interface ProcessMapper extends BaseMapper<Process> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessNodeDataMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeData;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程节点数据访问接口
+ * <p>
+ * 负责流程节点数据表(wflow_process_node_data)的数据访问操作
+ * 管理流程各节点的表单数据，存储流程执行过程中各节点产生的业务数据
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-07
+ */
+@Mapper
+public interface ProcessNodeDataMapper extends BaseMapper<ProcessNodeData> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessNodeRecordAssignUserMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeRecordAssignUser;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程节点执行人记录数据访问接口
+ * <p>
+ * 负责流程节点执行人记录表(wflow_process_node_record_assign_user)的数据访问操作
+ * 管理流程节点的执行人分配记录，包括待办人员、实际执行人、执行状态等信息
+ * </p>
+ *
+ * @author cxygzl
+ * @since 2023-05-10
+ */
+@Mapper
+public interface ProcessNodeRecordAssignUserMapper extends BaseMapper<ProcessNodeRecordAssignUser> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessNodeRecordMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeRecord;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程节点记录数据访问接口
+ * <p>
+ * 负责流程节点记录表(wflow_process_node_record)的数据访问操作
+ * 管理流程执行过程中各节点的执行记录，包括节点的开始、结束时间、执行状态、审批意见等
+ * </p>
+ *
+ * @author cxygzl
+ * @since 2023-05-10
+ */
+@Mapper
+public interface ProcessNodeRecordMapper extends BaseMapper<ProcessNodeRecord> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/mapper/ProcessStarterMapper.java

@@ -0,0 +1,20 @@
+package com.pig4cloud.pigx.flow.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.pig4cloud.pigx.flow.entity.ProcessStarter;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 流程发起人数据访问接口
+ * <p>
+ * 负责流程发起人表(wflow_process_starter)的数据访问操作
+ * 管理流程的发起权限配置，定义哪些用户、角色或部门可以发起特定流程
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-30
+ */
+@Mapper
+public interface ProcessStarterMapper extends BaseMapper<ProcessStarter> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/ICombinationGroupService.java

@@ -0,0 +1,44 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.pig4cloud.pigx.common.core.util.R;
+
+/**
+ * 流程组合服务接口
+ * <p>
+ * 该服务负责管理流程表单组的聚合查询功能，提供了流程组与流程关联关系的查询，
+ * 以及用户权限范围内可发起流程组的查询等功能。主要用于流程发起页面的表单组展示
+ * 和流程选择等场景。
+ * </p>
+ *
+ * @author pig code generator
+ * @date 2023-07-11
+ */
+public interface ICombinationGroupService {
+
+	/**
+	 * 分页查询指定表单组下的流程列表
+	 * <p>
+	 * 根据表单组ID查询该组下所有关联的流程定义，支持分页查询。
+	 * 主要用于流程发起页面，展示某个表单组下可以发起的所有流程。
+	 * </p>
+	 *
+	 * @param page 分页参数，包含当前页码、每页大小等分页信息
+	 * @param groupId 表单组ID，用于查询该组下的所有流程
+	 * @return R 响应结果，包含分页后的流程列表数据，每个流程包含流程定义信息、表单配置等
+	 */
+	R listGroupWithProcess(Page page, Long groupId);
+
+	/**
+	 * 查询当前用户可发起的所有表单组
+	 * <p>
+	 * 根据当前登录用户的权限，查询其有权限发起的所有流程表单组。
+	 * 该接口会根据用户角色、部门等权限信息过滤表单组，确保用户只能看到
+	 * 自己有权限发起的流程组。通常用于流程发起入口页面的初始化展示。
+	 * </p>
+	 *
+	 * @return R 响应结果，包含当前用户可发起的表单组列表，每个表单组包含组名称、图标、包含的流程数量等信息
+	 */
+	R listCurrentUserStartGroup();
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IFlowableEngineService.java

@@ -0,0 +1,68 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.TaskParamDto;
+
+/**
+ * Flowable引擎核心服务接口
+ * <p>
+ * 该服务提供了对Flowable工作流引擎的核心操作封装，主要处理任务的委托、解决和退回等高级功能。
+ * 这些功能是对标准Flowable API的扩展，为业务层提供更便捷的工作流操作能力。
+ * 所有操作都基于Flowable引擎的任务服务（TaskService）和运行时服务（RuntimeService）实现。
+ * </p>
+ *
+ * @author pig code generator
+ * @date 2023-07-11
+ */
+public interface IFlowableEngineService {
+
+    /**
+     * 委托任务给其他用户处理
+     * <p>
+     * 将当前任务委托给指定的用户处理。委托后，原任务处理人仍保留任务的所有权，
+     * 被委托人完成任务后，任务会返回给原处理人进行确认。这种机制常用于任务处理人
+     * 临时无法处理任务，需要他人协助的场景。委托操作会记录在任务历史中。
+     * </p>
+     *
+     * @param taskParamDto 任务参数对象，必须包含：
+     *                     - taskId: 要委托的任务ID
+     *                     - userId: 被委托人的用户ID
+     *                     - comment: 委托说明（可选）
+     *                     - variables: 流程变量（可选）
+     * @return R 响应结果，成功返回委托后的任务信息，失败返回错误信息
+     */
+    R delegateTask(TaskParamDto taskParamDto);
+
+    /**
+     * 解决已委托的任务
+     * <p>
+     * 被委托人完成委托任务的处理。该操作将任务标记为已解决，并将任务控制权
+     * 返回给原任务处理人。原处理人可以查看被委托人的处理结果，并决定是否
+     * 继续推进流程。解决任务时可以添加处理意见和更新流程变量。
+     * </p>
+     *
+     * @param taskParamDto 任务参数对象，必须包含：
+     *                     - taskId: 要解决的委托任务ID
+     *                     - comment: 处理意见
+     *                     - variables: 更新的流程变量（可选）
+     * @return R 响应结果，成功返回解决后的任务状态，失败返回错误信息
+     */
+    R resolveTask(TaskParamDto taskParamDto);
+
+    /**
+     * 退回任务到上一节点
+     * <p>
+     * 将当前任务退回到流程的上一个处理节点。该功能用于审批不通过或需要
+     * 上一步骤重新处理的场景。退回操作会保留完整的流程历史记录，并且
+     * 可以配置是否清空后续节点的处理记录。支持跨多个节点的退回操作。
+     * </p>
+     *
+     * @param taskParamDto 任务参数对象，必须包含：
+     *                     - taskId: 要退回的任务ID
+     *                     - targetNodeId: 目标节点ID（可选，不指定则退回到上一节点）
+     *                     - comment: 退回原因
+     *                     - variables: 更新的流程变量（可选）
+     * @return R 响应结果，成功返回退回后的任务信息，失败返回错误信息（如无法退回的情况）
+     */
+    R back(TaskParamDto taskParamDto);
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessCopyService.java

@@ -0,0 +1,37 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.entity.ProcessCopy;
+
+/**
+ * 流程抄送服务接口
+ * <p>
+ * 该服务负责管理工作流程中的抄送功能，包括抄送记录的创建、查询和管理。
+ * 抄送是工作流中的重要功能，允许将流程信息同步给相关人员查看，但不需要其参与审批。
+ * 抄送人员可以查看流程的详细信息、表单数据和审批进度，实现流程的透明化管理。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-20
+ */
+public interface IProcessCopyService extends IService<ProcessCopy> {
+
+	/**
+	 * 查询单个抄送记录的详细信息
+	 * <p>
+	 * 根据抄送记录ID查询完整的抄送信息，包括流程实例信息、表单数据、
+	 * 抄送时间、抄送人信息等。该接口主要用于抄送接收人查看具体的抄送内容。
+	 * 返回的数据会包含流程的当前状态、审批历史和相关的业务表单数据。
+	 * </p>
+	 *
+	 * @param id 抄送记录的唯一标识ID
+	 * @return R 响应结果，包含抄送的详细信息：
+	 *         - 流程实例信息（流程名称、发起人、发起时间等）
+	 *         - 表单数据（业务表单的完整数据）
+	 *         - 抄送信息（抄送时间、抄送人、抄送节点等）
+	 *         - 流程进度（当前节点、审批历史等）
+	 */
+	R querySingleDetail(long id);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessGroupService.java

@@ -0,0 +1,69 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.entity.ProcessGroup;
+
+import java.util.List;
+
+/**
+ * 流程分组管理服务接口
+ * <p>
+ * 该服务负责管理流程的分组功能，提供流程分组的创建、查询、删除等操作。
+ * 流程分组是对流程进行分类管理的重要机制，可以将相似或相关的流程组织在一起，
+ * 便于用户快速找到和使用流程。分组支持层级结构，可以实现流程的树形分类管理。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-25
+ */
+public interface IProcessGroupService extends IService<ProcessGroup> {
+
+	/**
+	 * 查询所有流程分组列表
+	 * <p>
+	 * 获取系统中所有的流程分组信息，包括分组名称、图标、排序号等。
+	 * 返回的列表会按照排序号和创建时间进行排序，支持树形结构的展示。
+	 * 该接口通常用于流程管理页面的分组树展示和流程发起页面的分类导航。
+	 * </p>
+	 *
+	 * @return R<List<ProcessGroup>> 响应结果，包含所有流程分组的列表，每个分组包含：
+	 *                               - id: 分组ID
+	 *                               - groupName: 分组名称
+	 *                               - groupIcon: 分组图标
+	 *                               - sortOrder: 排序号
+	 *                               - parentId: 父分组ID（用于构建树形结构）
+	 */
+	R<List<ProcessGroup>> queryList();
+
+	/**
+	 * 创建新的流程分组
+	 * <p>
+	 * 添加一个新的流程分组到系统中。创建时会检查分组名称的唯一性，
+	 * 并自动设置默认的排序号。支持创建子分组，通过设置parentId实现。
+	 * 新创建的分组默认为启用状态，可以立即用于流程的分类。
+	 * </p>
+	 *
+	 * @param processGroup 流程分组对象，需要包含：
+	 *                     - groupName: 分组名称（必填，不能重复）
+	 *                     - groupIcon: 分组图标（可选）
+	 *                     - sortOrder: 排序号（可选，默认为最大值+1）
+	 *                     - parentId: 父分组ID（可选，用于创建子分组）
+	 * @return R 响应结果，成功返回创建的分组信息，失败返回错误信息（如名称重复等）
+	 */
+	R create(ProcessGroup processGroup);
+
+	/**
+	 * 删除流程分组
+	 * <p>
+	 * 根据分组ID删除指定的流程分组。删除前会检查该分组下是否存在流程，
+	 * 如果存在关联的流程则不允许删除。同时会检查是否有子分组，有子分组
+	 * 的情况下也不允许删除。删除操作是逻辑删除，保留历史记录。
+	 * </p>
+	 *
+	 * @param id 要删除的分组ID
+	 * @return R 响应结果，成功返回删除成功信息，失败返回错误原因（如分组下有流程、有子分组等）
+	 */
+	R delete(long id);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessInstanceRecordService.java

@@ -0,0 +1,19 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.flow.entity.ProcessInstanceRecord;
+
+/**
+ * 流程实例记录服务接口
+ * <p>
+ * 该服务负责管理流程实例的运行记录，记录每个流程实例从创建到结束的完整生命周期信息。
+ * 包括流程的启动时间、结束时间、当前状态、流程变量等核心数据。这些记录是流程审计、
+ * 统计分析和问题排查的重要依据。服务提供了对流程实例记录的基础CRUD操作。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-07
+ */
+public interface IProcessInstanceRecordService extends IService<ProcessInstanceRecord> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessInstanceService.java

@@ -0,0 +1,156 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.ProcessInstanceParamDto;
+import com.pig4cloud.pigx.flow.dto.TaskQueryParamDto;
+import com.pig4cloud.pigx.flow.vo.NodeFormatParamVo;
+
+/**
+ * 流程实例管理服务接口
+ * <p>
+ * 该服务提供流程实例的完整生命周期管理功能，包括流程的启动、查询、结束等操作。
+ * 同时提供了多维度的任务查询功能，支持查询待办任务、已办任务、我发起的流程、
+ * 抄送给我的流程等。还提供了流程节点的格式化显示和流程详情查询等辅助功能。
+ * </p>
+ *
+ * @author pig code generator
+ * @date 2023-07-11
+ */
+public interface IProcessInstanceService {
+
+	/**
+	 * 启动新的流程实例
+	 * <p>
+	 * 根据流程定义启动一个新的流程实例。启动时需要提供流程定义ID、业务关联ID、
+	 * 表单数据和流程变量等信息。系统会自动创建第一个任务节点，并根据配置分配
+	 * 给相应的处理人。启动成功后会返回流程实例ID供后续跟踪使用。
+	 * </p>
+	 *
+	 * @param processInstanceParamDto 流程实例参数对象，包含：
+	 *                                - processDefinitionId: 流程定义ID
+	 *                                - businessKey: 业务关联键
+	 *                                - formData: 表单数据（JSON格式）
+	 *                                - variables: 流程变量
+	 *                                - startUserId: 发起人ID（可选，默认当前用户）
+	 * @return R 响应结果，成功返回流程实例ID和首个任务信息，失败返回错误信息
+	 */
+	R startProcessInstance(ProcessInstanceParamDto processInstanceParamDto);
+
+	/**
+	 * 查询当前用户的待办任务
+	 * <p>
+	 * 查询分配给当前登录用户的所有待处理任务。支持分页查询和多条件筛选，
+	 * 包括流程类型、紧急程度、创建时间等。返回的任务列表包含任务的基本信息、
+	 * 所属流程信息、表单数据预览等，便于用户快速了解和处理任务。
+	 * </p>
+	 *
+	 * @param taskQueryParamDto 任务查询参数，支持：
+	 *                          - pageNum: 页码
+	 *                          - pageSize: 每页大小
+	 *                          - processDefinitionKey: 流程定义标识（可选）
+	 *                          - priority: 优先级（可选）
+	 *                          - createTimeBegin/End: 创建时间范围（可选）
+	 * @return R 响应结果，包含分页的待办任务列表，每个任务包含任务ID、名称、创建时间、流程信息等
+	 */
+	R queryMineTask(TaskQueryParamDto taskQueryParamDto);
+
+	/**
+	 * 查询当前用户的已办任务
+	 * <p>
+	 * 查询当前用户已经处理完成的历史任务。包括已审批、已转办、已委托完成的任务。
+	 * 支持按时间范围、流程类型等条件筛选，帮助用户追溯历史处理记录。
+	 * </p>
+	 *
+	 * @param taskQueryParamDto 任务查询参数，支持：
+	 *                          - pageNum: 页码
+	 *                          - pageSize: 每页大小
+	 *                          - processDefinitionKey: 流程定义标识（可选）
+	 *                          - completeTimeBegin/End: 完成时间范围（可选）
+	 * @return R 响应结果，包含分页的已办任务列表，包含任务处理时间、处理意见、处理结果等信息
+	 */
+	R queryMineEndTask(TaskQueryParamDto taskQueryParamDto);
+
+	/**
+	 * 强制结束流程实例
+	 * <p>
+	 * 管理员或流程发起人可以强制结束一个运行中的流程实例。结束时需要提供
+	 * 结束原因，系统会记录操作日志。该操作不可逆，结束后的流程无法恢复。
+	 * 通常用于流程异常或业务取消等场景。
+	 * </p>
+	 *
+	 * @param processInstanceParamDto 参数对象，必须包含：
+	 *                                - processInstanceId: 要结束的流程实例ID
+	 *                                - reason: 结束原因
+	 * @return R 响应结果，成功返回结束确认信息，失败返回错误原因（如权限不足等）
+	 */
+	R end(ProcessInstanceParamDto processInstanceParamDto);
+
+	/**
+	 * 查询我发起的流程
+	 * <p>
+	 * 查询当前用户发起的所有流程实例，包括运行中和已结束的流程。
+	 * 支持按流程状态、发起时间等条件筛选。用户可以查看流程的当前进度、
+	 * 处理人等信息，并可以对自己发起的流程进行撤回、催办等操作。
+	 * </p>
+	 *
+	 * @param taskQueryParamDto 查询参数，支持：
+	 *                          - pageNum: 页码
+	 *                          - pageSize: 每页大小
+	 *                          - processStatus: 流程状态（运行中/已结束）
+	 *                          - startTimeBegin/End: 发起时间范围
+	 * @return R 响应结果，包含我发起的流程列表，含流程状态、当前节点、处理人等信息
+	 */
+	R queryMineStarted(TaskQueryParamDto taskQueryParamDto);
+
+	/**
+	 * 查询抄送给我的流程
+	 * <p>
+	 * 查询所有抄送给当前用户的流程信息。抄送是流程中的知会功能，
+	 * 被抄送人可以查看流程详情但不参与审批。支持标记已读状态，
+	 * 便于用户管理和跟踪需要关注的流程。
+	 * </p>
+	 *
+	 * @param taskQueryParamDto 查询参数，支持：
+	 *                          - pageNum: 页码
+	 *                          - pageSize: 每页大小
+	 *                          - readStatus: 已读/未读状态
+	 *                          - copyTimeBegin/End: 抄送时间范围
+	 * @return R 响应结果，包含抄送流程列表，含抄送时间、抄送人、流程状态、已读标记等
+	 */
+	R queryMineCC(TaskQueryParamDto taskQueryParamDto);
+
+	/**
+	 * 格式化流程节点显示数据
+	 * <p>
+	 * 将流程定义的节点数据格式化为前端可展示的结构。包括节点的层级关系、
+	 * 条件分支、并行网关等复杂结构的可视化数据。该接口主要用于流程图的
+	 * 展示和流程设计器的数据渲染。
+	 * </p>
+	 *
+	 * @param nodeFormatParamVo 节点格式化参数，包含：
+	 *                          - processDefinitionId: 流程定义ID
+	 *                          - nodeData: 原始节点数据
+	 *                          - showType: 显示类型（设计/运行/历史）
+	 * @return R 响应结果，包含格式化后的节点树形结构，支持前端流程图渲染
+	 */
+	R formatStartNodeShow(NodeFormatParamVo nodeFormatParamVo);
+
+	/**
+	 * 查询流程实例详情
+	 * <p>
+	 * 获取指定流程实例的完整信息，包括流程基本信息、表单数据、审批历史、
+	 * 流程图当前状态等。该接口会整合多个数据源，提供流程的全景视图，
+	 * 支持流程追踪和问题排查。
+	 * </p>
+	 *
+	 * @param processInstanceId 流程实例ID
+	 * @return R 响应结果，包含：
+	 *         - 流程基本信息（名称、发起人、发起时间、当前状态等）
+	 *         - 表单数据（完整的业务表单数据）
+	 *         - 审批历史（所有节点的处理记录）
+	 *         - 流程图（带当前节点高亮的流程图数据）
+	 *         - 操作权限（当前用户对该流程的可操作项）
+	 */
+	R detail(String processInstanceId);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessNodeDataService.java

@@ -0,0 +1,62 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.Node;
+import com.pig4cloud.pigx.flow.dto.ProcessNodeDataDto;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeData;
+
+/**
+ * 流程节点数据管理服务接口
+ * <p>
+ * 该服务负责管理流程定义中每个节点的配置数据，包括节点的属性设置、审批人配置、
+ * 表单权限、条件表达式等。这些数据是流程引擎执行时的重要依据，决定了流程节点
+ * 的行为方式。服务提供了节点数据的保存和查询功能，支持流程的动态配置。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-07
+ */
+public interface IProcessNodeDataService extends IService<ProcessNodeData> {
+
+	/**
+	 * 保存或更新流程节点数据
+	 * <p>
+	 * 保存流程节点的完整配置信息，包括节点基本属性、审批人设置、表单字段权限、
+	 * 条件配置等。如果节点数据已存在则更新，不存在则新增。保存时会进行数据
+	 * 验证，确保配置的合法性和完整性。该接口通常在流程设计时调用。
+	 * </p>
+	 *
+	 * @param processNodeDataDto 节点数据传输对象，包含：
+	 *                           - flowId: 流程定义ID
+	 *                           - nodeId: 节点ID
+	 *                           - nodeName: 节点名称
+	 *                           - nodeType: 节点类型（审批/抄送/条件等）
+	 *                           - nodeUser: 节点处理人配置
+	 *                           - formPermission: 表单字段权限配置
+	 *                           - conditions: 条件表达式（条件节点使用）
+	 *                           - properties: 其他扩展属性
+	 * @return R 响应结果，成功返回保存后的节点数据ID，失败返回错误信息
+	 */
+	R saveNodeData(ProcessNodeDataDto processNodeDataDto);
+
+	/**
+	 * 获取指定节点的配置数据
+	 * <p>
+	 * 根据流程ID和节点ID查询节点的完整配置信息。返回的数据包括节点的所有
+	 * 配置项，可直接用于流程引擎的执行或流程设计器的回显。查询时会进行
+	 * 权限校验，确保调用者有权限访问该流程的节点数据。
+	 * </p>
+	 *
+	 * @param flowId 流程定义ID，标识节点所属的流程
+	 * @param nodeId 节点ID，流程中节点的唯一标识
+	 * @return R<Node> 响应结果，包含节点的完整配置信息：
+	 *                 - 基本信息（ID、名称、类型等）
+	 *                 - 处理人配置（固定人员、角色、部门负责人等）
+	 *                 - 表单权限（各字段的可见、可编辑权限）
+	 *                 - 条件配置（分支条件、跳转条件等）
+	 *                 - 其他属性（超时设置、多实例配置等）
+	 */
+	R<Node> getNodeData(String flowId, String nodeId);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessNodeRecordAssignUserService.java

@@ -0,0 +1,60 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.ProcessNodeRecordAssignUserParamDto;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeRecordAssignUser;
+
+/**
+ * 流程节点执行人管理服务接口
+ * <p>
+ * 该服务负责管理流程节点的执行人分配和任务完成状态。在流程执行过程中，
+ * 每个节点可能有多个执行人（如会签、或签场景），该服务记录每个执行人的
+ * 分配情况、处理状态和处理结果。同时提供任务完成事件的处理机制，支持
+ * 多人审批场景下的复杂业务逻辑。
+ * </p>
+ *
+ * @author cxygzl
+ * @since 2023-05-10
+ */
+public interface IProcessNodeRecordAssignUserService extends IService<ProcessNodeRecordAssignUser> {
+
+	/**
+	 * 为流程节点添加执行人
+	 * <p>
+	 * 在流程运行时动态分配任务执行人。该接口支持为单个节点分配多个执行人，
+	 * 适用于会签（所有人都需要审批）、或签（任意一人审批即可）等场景。
+	 * 分配时会记录执行人信息、分配时间和任务类型，并触发相应的任务通知。
+	 * </p>
+	 *
+	 * @param processNodeRecordAssignUserParamDto 执行人分配参数，包含：
+	 *                                            - processInstanceId: 流程实例ID
+	 *                                            - nodeId: 节点ID
+	 *                                            - nodeRecordId: 节点记录ID
+	 *                                            - userId: 执行人用户ID
+	 *                                            - taskType: 任务类型（审批/抄送/加签等）
+	 *                                            - multiInstanceType: 多实例类型（会签/或签）
+	 * @return R 响应结果，成功返回分配记录ID，失败返回错误信息（如用户不存在、重复分配等）
+	 */
+	R addAssignUser(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto);
+
+	/**
+	 * 处理任务完成事件
+	 * <p>
+	 * 当执行人完成任务时调用此接口，更新执行人的任务状态和处理结果。
+	 * 对于多人审批场景，会根据配置的审批规则（会签/或签）判断整个节点
+	 * 是否完成。如果节点完成，会自动推进流程到下一节点。同时记录审批
+	 * 意见、审批时间等信息，用于流程追溯。
+	 * </p>
+	 *
+	 * @param processNodeRecordAssignUserParamDto 任务完成参数，包含：
+	 *                                            - assignUserId: 执行人记录ID
+	 *                                            - taskId: Flowable任务ID
+	 *                                            - approved: 是否同意
+	 *                                            - comment: 审批意见
+	 *                                            - variables: 流程变量（可选）
+	 * @return R 响应结果，成功返回节点是否全部完成的状态，失败返回错误信息
+	 */
+	R completeTaskEvent(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessNodeRecordService.java

@@ -0,0 +1,61 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.ProcessNodeRecordParamDto;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeRecord;
+
+/**
+ * 流程节点执行记录服务接口
+ * <p>
+ * 该服务负责记录流程执行过程中每个节点的运行状态和执行历史。包括节点的开始时间、
+ * 结束时间、执行结果、执行人信息等。这些记录构成了流程的执行轨迹，是流程监控、
+ * 审计和问题排查的重要数据来源。服务提供了节点生命周期的管理功能。
+ * </p>
+ *
+ * @author cxygzl
+ * @since 2023-05-10
+ */
+public interface IProcessNodeRecordService extends IService<ProcessNodeRecord> {
+
+	/**
+	 * 记录节点开始执行
+	 * <p>
+	 * 当流程执行到某个节点时调用此接口，创建节点执行记录。记录节点的基本信息、
+	 * 开始时间、节点配置等。同时会根据节点类型（审批、抄送、网关等）执行相应的
+	 * 初始化逻辑，如分配执行人、发送通知等。该记录将作为节点执行的主记录。
+	 * </p>
+	 *
+	 * @param processNodeRecordParamDto 节点记录参数，包含：
+	 *                                  - processInstanceId: 流程实例ID
+	 *                                  - executionId: Flowable执行ID
+	 *                                  - nodeId: 节点ID
+	 *                                  - nodeName: 节点名称
+	 *                                  - nodeType: 节点类型
+	 *                                  - parentNodeId: 父节点ID（用于嵌套结构）
+	 *                                  - variables: 流程变量
+	 * @return R 响应结果，成功返回节点记录ID和初始化状态，失败返回错误信息
+	 */
+	R start(ProcessNodeRecordParamDto processNodeRecordParamDto);
+
+	/**
+	 * 记录节点执行完成
+	 * <p>
+	 * 当节点执行完成时调用此接口，更新节点记录的结束时间和执行结果。
+	 * 对于审批节点，会记录最终的审批结果（通过/拒绝）；对于网关节点，
+	 * 会记录选择的分支；对于服务节点，会记录执行状态。完成后会触发
+	 * 流程继续向下执行。
+	 * </p>
+	 *
+	 * @param processNodeRecordParamDto 节点记录参数，包含：
+	 *                                  - nodeRecordId: 节点记录ID
+	 *                                  - status: 执行状态（成功/失败/跳过等）
+	 *                                  - result: 执行结果（通过/拒绝/条件值等）
+	 *                                  - comment: 处理意见或说明
+	 *                                  - endTime: 结束时间
+	 *                                  - variables: 更新的流程变量
+	 * @return R 响应结果，成功返回更新状态和下一步节点信息，失败返回错误信息
+	 */
+	R complete(ProcessNodeRecordParamDto processNodeRecordParamDto);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessService.java

@@ -0,0 +1,72 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.entity.Process;
+import com.pig4cloud.pigx.flow.vo.ProcessVO;
+
+/**
+ * 流程定义服务接口
+ * <p>
+ * 提供流程定义的创建、编辑、查询、隐藏等核心功能。
+ * 该服务是流程管理的核心服务，负责管理流程的生命周期。
+ * </p>
+ *
+ * @author cxygzl
+ * @since 2023-05-25
+ */
+public interface IProcessService extends IService<Process> {
+
+	/**
+	 * 获取流程详细信息
+	 * 包括流程基本信息、表单配置、流程配置、权限信息等完整数据
+	 * 
+	 * @param flowId 流程定义ID
+	 * @return 流程详细信息VO对象
+	 */
+	R<ProcessVO> getDetail(String flowId);
+
+	/**
+	 * 根据流程ID获取流程定义实体
+	 * 
+	 * @param flowId 流程定义ID
+	 * @return 流程定义实体
+	 */
+	Process getByFlowId(String flowId);
+
+	/**
+	 * 根据流程ID更新流程定义
+	 * 用于更新流程的表单配置、流程配置等信息
+	 * 
+	 * @param process 包含更新信息的流程实体
+	 */
+	void updateByFlowId(Process process);
+
+	/**
+	 * 隐藏流程定义
+	 * 隐藏的流程不在列表中显示，但已创建的实例仍可继续执行
+	 * 
+	 * @param flowId 流程定义ID
+	 */
+	void hide(String flowId);
+
+	/**
+	 * 创建新的流程定义
+	 * 创建流程时会同时生成流程的唯一标识和默认配置
+	 * 
+	 * @param process 流程定义实体
+	 * @return 创建结果，包含生成的flowId
+	 */
+	R create(Process process);
+
+	/**
+	 * 更新流程状态或分组
+	 * 
+	 * @param flowId 流程定义ID
+	 * @param type 操作类型：stop（停用）、using（启用）、delete（删除）
+	 * @param groupId 流程分组ID（可选，用于修改流程分组）
+	 * @return 操作结果
+	 */
+	R update(String flowId, String type, Long groupId);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IProcessStarterService.java

@@ -0,0 +1,19 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.pig4cloud.pigx.flow.entity.ProcessStarter;
+
+/**
+ * 流程发起人权限管理服务接口
+ * <p>
+ * 该服务负责管理流程的发起权限配置，控制哪些用户、角色或部门可以发起特定的流程。
+ * 通过灵活的权限配置，实现流程发起的精细化控制。支持按用户、角色、部门、岗位等
+ * 多维度配置发起权限，确保流程只能被授权人员发起，提高流程管理的安全性。
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-30
+ */
+public interface IProcessStarterService extends IService<ProcessStarter> {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/IRemoteService.java

@@ -0,0 +1,213 @@
+
+package com.pig4cloud.pigx.flow.service;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 远程服务调用接口
+ * <p>
+ * 该接口定义了流程模块与其他业务模块之间的远程调用契约。主要包括用户组织架构查询、
+ * 流程事件通知、权限校验等功能。这些方法通过Feign客户端调用其他微服务，实现了
+ * 流程引擎与业务系统的解耦。所有远程调用都进行了统一的异常处理和降级处理。
+ * </p>
+ *
+ * @author pig code generator
+ * @date 2023-07-11
+ */
+public interface IRemoteService {
+
+	/**
+	 * 根据角色ID列表查询用户ID列表
+	 * <p>
+	 * 调用用户管理服务，查询指定角色下的所有用户。主要用于流程节点配置了
+	 * 角色审批时，动态获取该角色下的所有用户作为候选审批人。支持多个角色
+	 * 的联合查询，返回去重后的用户ID列表。
+	 * </p>
+	 *
+	 * @param roleIdList 角色ID列表，支持批量查询多个角色
+	 * @return R<List<Long>> 响应结果，包含角色下所有用户的ID列表（已去重）
+	 */
+	R<List<Long>> queryUserIdListByRoleIdList(List<Long> roleIdList);
+
+	/**
+	 * 保存流程抄送记录
+	 * <p>
+	 * 当流程执行到抄送节点时，调用此接口创建抄送记录。抄送记录会保存到
+	 * 独立的抄送表中，被抄送人可以在抄送列表中查看但不参与审批。该接口
+	 * 会同时发送抄送通知给相关人员。
+	 * </p>
+	 *
+	 * @param copyDto 抄送信息对象，包含：
+	 *                - processInstanceId: 流程实例ID
+	 *                - nodeId: 抄送节点ID
+	 *                - userId: 被抄送人ID
+	 *                - formData: 表单数据
+	 *                - copyTime: 抄送时间
+	 * @return R 响应结果，成功返回抄送记录ID
+	 */
+	R saveCC(ProcessCopyDto copyDto);
+
+	/**
+	 * 检查用户是否为指定用户的所有上级
+	 * <p>
+	 * 用于流程节点配置了"部门负责人"或"上级领导"审批时，验证候选人
+	 * 是否符合组织架构关系。通过递归查询组织树，判断是否存在上下级关系。
+	 * </p>
+	 *
+	 * @param checkParentDto 检查参数，包含：
+	 *                       - userId: 要检查的用户ID
+	 *                       - targetUserId: 目标用户ID
+	 *                       - checkType: 检查类型（直接上级/所有上级）
+	 * @return R<Boolean> 响应结果，true表示是上级关系，false表示不是
+	 */
+	R<Boolean> checkIsAllParent(CheckParentDto checkParentDto);
+
+	/**
+	 * 根据部门ID列表查询用户ID列表
+	 * <p>
+	 * 调用组织架构服务，查询指定部门下的所有用户。用于流程节点配置了
+	 * 部门审批时，获取该部门的所有成员作为候选审批人。支持多部门查询
+	 * 和递归查询子部门。
+	 * </p>
+	 *
+	 * @param depIdList 部门ID列表，支持批量查询多个部门
+	 * @return R<List<Long>> 响应结果，包含部门下所有用户的ID列表（已去重）
+	 */
+	R<List<Long>> queryUserIdListByDepIdList(List<Long> depIdList);
+
+	/**
+	 * 检查用户是否为指定用户的所有下级
+	 * <p>
+	 * 与checkIsAllParent相反，用于验证下级关系。主要用于某些特殊场景，
+	 * 如向下委托、逐级审批等。通过递归查询组织树判断层级关系。
+	 * </p>
+	 *
+	 * @param checkChildDto 检查参数，包含：
+	 *                      - userId: 要检查的用户ID
+	 *                      - targetUserId: 目标用户ID
+	 *                      - checkLevel: 检查层级（直接下级/所有下级）
+	 * @return R<Boolean> 响应结果，true表示是下级关系，false表示不是
+	 */
+	R<Boolean> checkIsAllChild(CheckChildDto checkChildDto);
+
+	/**
+	 * 获取用户的完整信息（包括扩展字段）
+	 * <p>
+	 * 查询用户的详细信息，除基本信息外，还包括部门、角色、岗位等扩展信息。
+	 * 这些信息用于流程执行时的条件判断、权限验证等。返回的Map结构便于
+	 * 在表达式中直接使用。
+	 * </p>
+	 *
+	 * @param userId 用户ID
+	 * @return R<Map<String, Object>> 响应结果，包含用户的所有信息：
+	 *                                - 基本信息（姓名、工号、邮箱等）
+	 *                                - 组织信息（部门、岗位、上级等）
+	 *                                - 权限信息（角色、权限标识等）
+	 *                                - 扩展字段（自定义属性）
+	 */
+	R<Map<String, Object>> queryUserAllInfo(long userId);
+
+	/**
+	 * 流程节点开始执行事件通知
+	 * <p>
+	 * 当流程节点开始执行时触发此事件，用于通知相关系统和人员。可以在此
+	 * 扩展自定义的业务逻辑，如发送消息、记录日志、触发其他流程等。
+	 * </p>
+	 *
+	 * @param recordParamDto 节点记录参数，包含节点执行的上下文信息
+	 * @return R 响应结果，事件处理状态
+	 */
+	R startNodeEvent(ProcessNodeRecordParamDto recordParamDto);
+
+	/**
+	 * 流程实例创建事件通知
+	 * <p>
+	 * 当新的流程实例被创建时触发此事件。用于初始化流程相关的业务数据，
+	 * 发送流程启动通知，记录审计日志等。是流程生命周期的起始事件。
+	 * </p>
+	 *
+	 * @param processInstanceRecordParamDto 流程实例参数，包含：
+	 *                                      - processInstanceId: 流程实例ID
+	 *                                      - processDefinitionId: 流程定义ID
+	 *                                      - businessKey: 业务关联键
+	 *                                      - startUserId: 发起人ID
+	 *                                      - variables: 流程变量
+	 * @return R 响应结果，事件处理状态
+	 */
+	R createProcessEvent(ProcessInstanceRecordParamDto processInstanceRecordParamDto);
+
+	/**
+	 * 流程节点结束事件通知
+	 * <p>
+	 * 当流程节点执行完成时触发此事件。可以在此处理节点完成后的业务逻辑，
+	 * 如更新业务状态、发送完成通知、触发下游系统等。
+	 * </p>
+	 *
+	 * @param recordParamDto 节点记录参数，包含节点执行结果等信息
+	 * @return R 响应结果，事件处理状态
+	 */
+	R endNodeEvent(ProcessNodeRecordParamDto recordParamDto);
+
+	/**
+	 * 开始分配任务执行人事件
+	 * <p>
+	 * 当系统开始为任务分配执行人时触发。用于发送任务通知、记录分配日志等。
+	 * 在多人审批场景下，会为每个执行人触发一次该事件。
+	 * </p>
+	 *
+	 * @param processNodeRecordAssignUserParamDto 执行人分配参数，包含：
+	 *                                            - userId: 被分配的用户ID
+	 *                                            - taskId: 任务ID
+	 *                                            - assignTime: 分配时间
+	 * @return R 响应结果，事件处理状态
+	 */
+	R startAssignUser(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto);
+
+	/**
+	 * 任务完成事件通知
+	 * <p>
+	 * 当用户完成分配给自己的任务时触发。用于更新业务状态、发送完成通知、
+	 * 记录操作日志等。对于会签场景，每个人完成都会触发一次。
+	 * </p>
+	 *
+	 * @param processNodeRecordAssignUserParamDto 任务完成参数，包含：
+	 *                                            - userId: 完成任务的用户ID
+	 *                                            - taskId: 任务ID
+	 *                                            - result: 处理结果
+	 *                                            - comment: 处理意见
+	 * @return R 响应结果，事件处理状态
+	 */
+	R taskEndEvent(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto);
+
+	/**
+	 * 流程实例结束事件通知
+	 * <p>
+	 * 当整个流程实例结束时触发，包括正常结束和异常终止。用于清理流程数据、
+	 * 更新最终业务状态、发送结束通知、归档流程数据等。
+	 * </p>
+	 *
+	 * @param processInstanceParamDto 流程实例参数，包含：
+	 *                                - processInstanceId: 流程实例ID
+	 *                                - endReason: 结束原因
+	 *                                - endType: 结束类型（正常/异常）
+	 * @return R 响应结果，事件处理状态
+	 */
+	R endProcess(ProcessInstanceParamDto processInstanceParamDto);
+
+	/**
+	 * 查询流程的管理员
+	 * <p>
+	 * 获取指定流程的管理员用户ID。流程管理员拥有该流程的最高权限，
+	 * 可以进行流程的编辑、删除、强制结束等操作。通常在权限校验时使用。
+	 * </p>
+	 *
+	 * @param flowId 流程定义ID
+	 * @return R<Long> 响应结果，包含流程管理员的用户ID，如果未设置则返回null
+	 */
+	R<Long> queryProcessAdmin(String flowId);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/ITaskService.java

@@ -0,0 +1,97 @@
+package com.pig4cloud.pigx.flow.service;
+
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.TaskParamDto;
+
+/**
+ * 任务处理服务接口
+ * <p>
+ * 提供流程任务的核心操作功能，包括任务的查询、完成、委托、退回等。 该服务是流程执行过程中最重要的接口，处理所有与任务相关的业务逻辑。
+ * </p>
+ * 
+ * @author pigx
+ */
+public interface ITaskService {
+
+	/**
+	 * 查询任务详情
+	 * <p>
+	 * 获取任务的详细信息，包括： - 任务基本信息（名称、创建时间、执行人等） - 所属流程信息 - 表单数据和权限 - 历史审批记录
+	 * </p>
+	 * @param taskId 任务ID
+	 * @param view 是否为查看模式（true=只查看，false=处理模式）
+	 * @return 任务详情信息
+	 */
+	R queryTask(String taskId, boolean view);
+
+	/**
+	 * 完成任务
+	 * <p>
+	 * 处理当前任务并使流程继续执行。根据不同的处理结果： - 同意：任务通过，流程按照定义继续执行 - 拒绝：根据拒绝策略结束流程或跳转到指定节点
+	 * </p>
+	 * @param taskParamDto 任务参数，包括任务ID、处理意见、表单数据等
+	 * @return 任务完成结果
+	 */
+	R completeTask(TaskParamDto taskParamDto);
+
+	/**
+	 * 委托任务（前加签）
+	 * <p>
+	 * 将当前任务委托给其他人处理。委托后： - 原执行人不再拥有该任务 - 新执行人完成任务后，需要原执行人确认（resolveTask） -
+	 * 通常用于审批人需要征求他人意见的场景
+	 * </p>
+	 * @param taskParamDto 任务参数，必须包含新执行人信息
+	 * @return 委托结果
+	 */
+	R delegateTask(TaskParamDto taskParamDto);
+
+	/**
+	 * 加签完成任务
+	 * <p>
+	 * 当任务被委托后，委托人完成任务，原执行人使用此方法确认并完成任务。 这是委托流程的最后一步，确认委托结果并使流程继续。
+	 * </p>
+	 * @param taskParamDto 任务参数
+	 * @return 任务完成结果
+	 */
+	R resolveTask(TaskParamDto taskParamDto);
+
+	/**
+	 * 设置任务执行人
+	 * <p>
+	 * 修改任务的执行人，通常用于： - 管理员重新分配任务 - 无执行人时指定执行人 - 任务转办
+	 * </p>
+	 * @param taskParamDto 任务参数，必须包含新执行人信息
+	 * @return 操作结果
+	 */
+	R setAssignee(TaskParamDto taskParamDto);
+
+	/**
+	 * 结束流程实例
+	 * <p>
+	 * 强制结束正在执行的流程实例。通常用于： - 流程异常需要终止 - 管理员强制结束 - 业务需求变更
+	 * </p>
+	 * @param taskParamDto 任务参数，包含结束原因
+	 * @return 操作结果
+	 */
+	R stopProcessInstance(TaskParamDto taskParamDto);
+
+	/**
+	 * 退回任务
+	 * <p>
+	 * 将当前任务退回到上一个节点或指定节点。通常用于： - 发现上一步审批有误 - 需要补充资料 - 业务流程需要回退重新处理
+	 * </p>
+	 * @param taskParamDto 任务参数，可指定退回到的节点
+	 * @return 操作结果
+	 */
+	R back(TaskParamDto taskParamDto);
+
+	/**
+	 * 查询首页数据看板
+	 * <p>
+	 * 获取当前用户的任务统计数据，包括： - 待办任务数量 - 已办任务数量 - 我发起的流程数量 - 抄送给我的数量
+	 * </p>
+	 * @return 任务统计数据
+	 */
+	R queryTaskData();
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/BpmOaLeaveServiceImpl.java

@@ -37,7 +37,7 @@ public class BpmOaLeaveServiceImpl extends ServiceImpl<BpmOaLeaveMapper, BpmOaLe
 	 */
 	@Override
 	public String getFlowId() {
-		return "QWE";
+		return "LEAVE";
 	}
 
 	/**

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/CombinationGroupServiceImpl.java

@@ -0,0 +1,191 @@
+package com.pig4cloud.pigx.flow.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.pig4cloud.pigx.common.core.constant.enums.YesNoEnum;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.common.security.service.PigxUser;
+import com.pig4cloud.pigx.common.security.util.SecurityUtils;
+import com.pig4cloud.pigx.flow.constant.NodeUserTypeEnum;
+import com.pig4cloud.pigx.flow.entity.Process;
+import com.pig4cloud.pigx.flow.entity.ProcessGroup;
+import com.pig4cloud.pigx.flow.entity.ProcessStarter;
+import com.pig4cloud.pigx.flow.service.ICombinationGroupService;
+import com.pig4cloud.pigx.flow.service.IProcessGroupService;
+import com.pig4cloud.pigx.flow.service.IProcessService;
+import com.pig4cloud.pigx.flow.service.IProcessStarterService;
+import com.pig4cloud.pigx.flow.vo.FormGroupVo;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 组合分组服务实现类
+ * <p>
+ * 该类负责处理流程分组相关的业务逻辑，主要包括： 1. 查询流程分组及其包含的流程信息 2. 根据用户权限过滤可发起的流程分组 3. 处理流程发起人权限验证
+ * </p>
+ *
+ * @author pigx code generator
+ * @date 2023-10-01
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class CombinationGroupServiceImpl implements ICombinationGroupService {
+
+	private final IProcessGroupService processGroupService;
+
+	private final IProcessService processService;
+
+	private final IProcessStarterService processStarterService;
+
+	/**
+	 * 查询表单组包含流程
+	 * <p>
+	 * 根据流程分组ID查询该分组下所有未隐藏的流程，按照排序值升序和创建时间降序排列
+	 * </p>
+	 * @param page 分页参数，用于控制查询结果的分页
+	 * @param groupId 流程分组ID
+	 * @return R 包含分页后的流程列表
+	 */
+	@Override
+	public R listGroupWithProcess(Page page, Long groupId) {
+		return R.ok(processService.lambdaQuery()
+			.eq(Process::getGroupId, groupId)
+			.eq(Process::getHidden, YesNoEnum.NO.getCode())
+			.orderByAsc(Process::getSort)
+			.orderByDesc(Process::getCreateTime)
+			.page(page));
+	}
+
+	/**
+	 * 查询所有我可以发起的表单组
+	 * <p>
+	 * 该方法会根据当前登录用户的权限，查询所有可发起的流程分组及其包含的流程。 主要处理逻辑包括： 1. 获取所有流程分组，按排序值升序排列 2.
+	 * 对每个分组查询其下的流程（未隐藏且未停用） 3. 根据流程发起人配置，判断当前用户是否有权限发起 4. 支持用户和部门两种发起人类型的权限判断 5.
+	 * 过滤掉用户无权发起的流程
+	 * </p>
+	 * @return R 包含FormGroupVo列表，每个FormGroupVo包含分组信息和该分组下用户可发起的流程列表
+	 */
+	@Override
+	public R listCurrentUserStartGroup() {
+		// 获取当前登录用户信息
+		PigxUser user = SecurityUtils.getUser();
+
+		// 存储所有流程分组及其可发起的流程
+		List<FormGroupVo> formGroupVos = new LinkedList<>();
+
+		// 查询所有流程分组，按排序值升序排列
+		List<ProcessGroup> processGroupList = processGroupService.lambdaQuery()
+			.orderByAsc(ProcessGroup::getSort)
+			.list();
+
+		// 遍历每个流程分组
+		processGroupList.forEach(group -> {
+			// 构建流程分组VO对象
+			FormGroupVo formGroupVo = FormGroupVo.builder()
+				.id(group.getId())
+				.name(group.getGroupName())
+				.items(new LinkedList<>())
+				.build();
+			formGroupVos.add(formGroupVo);
+
+			// 查询该分组下所有未隐藏且未停用的流程
+			List<Process> processList = processService.lambdaQuery()
+				.eq(Process::getGroupId, group.getId())
+				.eq(Process::getHidden, YesNoEnum.NO.getCode())
+				.eq(Process::getStop, YesNoEnum.NO.getCode())
+				.orderByAsc(Process::getSort)
+				.list();
+
+			// 用于存储每个流程是否允许当前用户发起的标识
+			Map<Long, Boolean> existMap = new HashMap<>();
+
+			if (!processList.isEmpty()) {
+				// 获取所有流程ID
+				List<Long> idList = processList.stream().map(Process::getId).toList();
+				// 批量查询流程发起人配置
+				List<ProcessStarter> processStarterList = processStarterService.lambdaQuery()
+					.in(ProcessStarter::getProcessId, idList)
+					.list();
+				// 按流程ID分组
+				Map<Long, List<ProcessStarter>> groupmap = processStarterList.stream()
+					.collect(Collectors.groupingBy(ProcessStarter::getProcessId));
+
+				// 判断每个流程是否允许当前用户发起
+				for (Process process : processList) {
+					List<ProcessStarter> processStarters = groupmap.get(process.getId());
+					// 如果没有配置发起人，则所有人都可以发起
+					if (processStarters == null) {
+						existMap.put(process.getId(), true);
+						continue;
+					}
+
+					// 检查是否配置了当前用户为发起人
+					boolean match = processStarters.stream()
+						.anyMatch(w -> w.getTypeId().longValue() == user.getId()
+								&& w.getType().equals(NodeUserTypeEnum.USER.getKey()));
+					if (match) {
+						existMap.put(process.getId(), true);
+						continue;
+					}
+					// 检查是否配置了当前用户所在部门为发起人
+					Set<Long> deptIdSet = processStarters.stream()
+						.filter(w -> w.getType().equals(NodeUserTypeEnum.DEPT.getKey()))
+						.map(ProcessStarter::getTypeId)
+						.collect(Collectors.toSet());
+
+					boolean contains = CollUtil.containsAny(deptIdSet, user.getDeptIds());
+
+					if (contains) {
+						existMap.put(process.getId(), true);
+						continue;
+					}
+
+					Set<Long> roleSet = processStarters.stream()
+						.filter(w -> w.getType().equals(NodeUserTypeEnum.ROLE.getKey()))
+						.map(ProcessStarter::getTypeId)
+						.collect(Collectors.toSet());
+
+					boolean roleContains = CollUtil.containsAny(roleSet, SecurityUtils.getRoleIds());
+					if (roleContains) {
+						existMap.put(process.getId(), true);
+						continue;
+					}
+
+					Set<Long> postSet = processStarters.stream()
+						.filter(w -> w.getType().equals(NodeUserTypeEnum.POST.getKey()))
+						.map(ProcessStarter::getTypeId)
+						.collect(Collectors.toSet());
+
+					boolean postContains = CollUtil.containsAny(postSet, user.getPostIds());
+					existMap.put(process.getId(), postContains);
+				}
+
+			}
+
+			// 将有权限发起的流程添加到分组中
+			processList.forEach(process -> {
+
+				if (!existMap.get(process.getId())) {
+					return;
+				}
+
+				formGroupVo.getItems()
+					.add(FormGroupVo.FlowVo.builder()
+						.flowId(process.getFlowId())
+						.name(process.getName())
+						.logo(process.getLogo())
+						.remark(process.getRemark())
+						.stop(process.getStop())
+						.updated(process.getUpdateTime())
+						.build());
+			});
+		});
+		return R.ok(formGroupVos);
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/FlowableEngineServiceImpl.java

@@ -0,0 +1,162 @@
+package com.pig4cloud.pigx.flow.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.TaskParamDto;
+import com.pig4cloud.pigx.flow.service.IFlowableEngineService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.engine.RuntimeService;
+import org.flowable.engine.TaskService;
+import org.flowable.task.api.Task;
+import org.springframework.stereotype.Service;
+
+import java.util.Map;
+
+/**
+ * Flowable引擎服务实现类
+ * <p>
+ * 该类提供了对Flowable工作流引擎的高级操作封装，主要包括：
+ * 1. 委托任务（delegate）：将任务委托给其他用户处理
+ * 2. 解决委托（resolve）：处理完委托任务后返回给原委托人
+ * 3. 任务退回（back）：将任务退回到指定节点重新处理
+ * 
+ * 这些功能扩展了Flowable原生的任务处理能力，为复杂的业务流程提供了更灵活的处理方式
+ * </p>
+ * 
+ * @author pigx code generator
+ * @date 2023-10-01
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class FlowableEngineServiceImpl implements IFlowableEngineService {
+
+    private final TaskService taskService;
+    private final RuntimeService runtimeService;
+
+    /**
+     * 委托任务
+     * <p>
+     * 将当前任务委托给其他用户处理。委托后，原任务的处理人变为被委托人，
+     * 但原委托人仍保留对任务的控制权，被委托人完成后需要resolve返回给原委托人
+     * </p>
+     * 
+     * @param taskParamDto 任务参数，包含：
+     *                     - taskId: 需要委托的任务ID
+     *                     - targetUserIdList: 被委托人用户ID列表
+     *                     - taskLocalParamMap: 任务本地变量
+     * @return R 操作结果，成功返回R.ok()，失败返回R.failed()及错误信息
+     */
+    @Override
+    public R delegateTask(TaskParamDto taskParamDto) {
+        try {
+            String taskId = taskParamDto.getTaskId();
+            Map<String, Object> taskLocalParamMap = taskParamDto.getTaskLocalParamMap();
+            
+            // 设置本地变量
+            if (CollUtil.isNotEmpty(taskLocalParamMap)) {
+                taskService.setVariablesLocal(taskId, taskLocalParamMap);
+            }
+            
+            // 设置委托标记
+            taskService.setVariableLocal(taskId, "delegate", true);
+            
+            // 委托任务给目标用户
+            for (Long targetUserId : taskParamDto.getTargetUserIdList()) {
+                taskService.delegateTask(taskId, targetUserId.toString());
+            }
+            
+            return R.ok();
+        } catch (Exception e) {
+            log.error("委托任务失败", e);
+            return R.failed("委托任务失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 解决委托任务
+     * <p>
+     * 被委托人完成任务处理后，通过此方法将任务返回给原委托人。
+     * 该方法会清除委托状态，恢复任务的正常流转
+     * </p>
+     * 
+     * @param taskParamDto 任务参数，包含：
+     *                     - taskId: 需要解决的委托任务ID
+     *                     - taskLocalParamMap: 任务本地变量
+     *                     - paramMap: 任务完成时的全局变量
+     * @return R 操作结果，成功返回R.ok()，失败返回R.failed()及错误信息
+     */
+    @Override
+    public R resolveTask(TaskParamDto taskParamDto) {
+        try {
+            String taskId = taskParamDto.getTaskId();
+            Map<String, Object> taskLocalParamMap = taskParamDto.getTaskLocalParamMap();
+            
+            // 设置本地变量
+            if (CollUtil.isNotEmpty(taskLocalParamMap)) {
+                taskService.setVariablesLocal(taskId, taskLocalParamMap);
+            }
+            
+            // 解决委托任务
+            taskService.resolveTask(taskId);
+            
+            // 完成任务
+            if (CollUtil.isNotEmpty(taskParamDto.getParamMap())) {
+                taskService.complete(taskId, taskParamDto.getParamMap());
+            }
+            
+            return R.ok();
+        } catch (Exception e) {
+            log.error("解决委托任务失败", e);
+            return R.failed("解决委托任务失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 退回任务
+     * <p>
+     * 将当前任务退回到指定的历史节点重新处理。
+     * 该功能常用于审批不通过需要重新修改的场景。
+     * 退回操作会保留退回原因和相关信息，便于追溯
+     * </p>
+     * 
+     * @param taskParamDto 任务参数，包含：
+     *                     - taskId: 需要退回的任务ID
+     *                     - targetNodeId: 目标节点ID（退回到的节点）
+     *                     - paramMap: 包含退回原因等参数
+     * @return R 操作结果，成功返回R.ok()，失败返回R.failed()及错误信息
+     */
+    @Override
+    public R back(TaskParamDto taskParamDto) {
+        try {
+            String taskId = taskParamDto.getTaskId();
+            String targetNodeId = taskParamDto.getTargetNodeId();
+            
+            // 获取当前任务
+            Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+            if (task == null) {
+                return R.failed("任务不存在");
+            }
+            
+            // 设置退回标记
+            Map<String, Object> variables = taskParamDto.getParamMap();
+            variables.put("isBack", true);
+            // 退回原因可以从paramMap中获取
+            if (variables.containsKey("comment")) {
+                variables.put("backReason", variables.get("comment"));
+            }
+            
+            // 使用流程跳转实现退回
+            runtimeService.createChangeActivityStateBuilder()
+                    .processInstanceId(task.getProcessInstanceId())
+                    .moveActivityIdTo(task.getTaskDefinitionKey(), targetNodeId)
+                    .changeState();
+            
+            return R.ok();
+        } catch (Exception e) {
+            log.error("退回任务失败", e);
+            return R.failed("退回任务失败: " + e.getMessage());
+        }
+    }
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/ProcessCopyServiceImpl.java

@@ -0,0 +1,90 @@
+package com.pig4cloud.pigx.flow.service.impl;
+
+import cn.hutool.core.lang.Dict;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.dto.Node;
+import com.pig4cloud.pigx.flow.entity.Process;
+import com.pig4cloud.pigx.flow.entity.ProcessCopy;
+import com.pig4cloud.pigx.flow.mapper.ProcessCopyMapper;
+import com.pig4cloud.pigx.flow.service.IProcessCopyService;
+import com.pig4cloud.pigx.flow.service.IProcessNodeDataService;
+import com.pig4cloud.pigx.flow.service.IProcessService;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import org.springframework.stereotype.Service;
+
+import java.util.Map;
+
+/**
+ * 流程抄送数据服务实现类
+ * <p>
+ * 该类负责处理流程抄送相关的业务逻辑，主要功能包括：
+ * 1. 管理流程抄送记录的增删改查
+ * 2. 查询抄送详情，包括流程表单、表单数据和权限信息
+ * 3. 为被抄送人提供查看流程执行情况的能力
+ * 
+ * 抄送功能允许流程在执行过程中通知相关人员，被抄送人可以查看但不参与流程审批
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-20
+ */
+@Service
+@RequiredArgsConstructor
+public class ProcessCopyServiceImpl extends ServiceImpl<ProcessCopyMapper, ProcessCopy> implements IProcessCopyService {
+
+    private final ObjectMapper objectMapper;
+
+    private final IProcessService processService;
+
+    private final IProcessNodeDataService nodeDataService;
+
+    /**
+     * 查询单个抄送详细信息
+     * <p>
+     * 根据抄送记录ID查询完整的抄送详情，包括：
+     * 1. 流程定义信息（process）
+     * 2. 表单项定义（formItems）
+     * 3. 表单数据（formData）- 流程实例的实际填写数据
+     * 4. 表单权限（formPerms）- 基于当前节点的表单字段权限设置
+     * 
+     * 该方法主要用于抄送人查看被抄送的流程详情
+     * </p>
+     * 
+     * @param id 抄送记录ID
+     * @return R 包含流程详情的响应对象，包括process、formItems、formData、formPerms
+     * @throws Exception 当解析JSON数据失败时抛出异常
+     */
+    @SneakyThrows
+    @Override
+    public R querySingleDetail(long id) {
+        // 获取抄送记录
+        ProcessCopy processCopy = this.getById(id);
+        String flowId = processCopy.getFlowId();
+        
+        // 查询流程定义
+        Process oaForms = processService.getByFlowId(flowId);
+        if (oaForms == null) {
+            return R.failed("流程不存在");
+        }
+        
+        // 获取表单数据和节点信息
+        String formData = processCopy.getFormData();
+        String nodeId = processCopy.getNodeId();
+
+        // 获取节点的表单权限配置
+        Node node = nodeDataService.getNodeData(flowId, nodeId).getData();
+        Map<String, String> formPerms = node.getFormPerms();
+
+        // 构建返回数据
+        Dict set = Dict.create()
+                .set("process", oaForms.getProcess())      // 流程定义
+                .set("formItems", oaForms.getFormItems())  // 表单项定义
+                .set("formData", formData)                  // 表单数据
+                .set("formPerms", formPerms);               // 表单权限
+        return R.ok(set);
+    }
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/ProcessGroupServiceImpl.java

@@ -0,0 +1,80 @@
+package com.pig4cloud.pigx.flow.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.entity.ProcessGroup;
+import com.pig4cloud.pigx.flow.mapper.ProcessGroupMapper;
+import com.pig4cloud.pigx.flow.service.IProcessGroupService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 流程分组服务实现类
+ * <p>
+ * 该类负责管理流程分组相关的业务逻辑，主要功能包括：
+ * 1. 流程分组的增删改查操作
+ * 2. 分组排序管理
+ * 3. 为流程提供分类组织功能
+ * 
+ * 流程分组用于将相似或相关的流程进行分类管理，便于用户查找和使用
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-25
+ */
+@Service
+public class ProcessGroupServiceImpl extends ServiceImpl<ProcessGroupMapper, ProcessGroup>
+		implements IProcessGroupService {
+
+	/**
+	 * 查询所有流程分组列表
+	 * <p>
+	 * 获取系统中所有的流程分组，按照排序值（sort）升序排列
+	 * </p>
+	 * 
+	 * @return R<List<ProcessGroup>> 包含所有流程分组的列表
+	 */
+	@Override
+	public R<List<ProcessGroup>> queryList() {
+		List<ProcessGroup> processGroupList = this.lambdaQuery().orderByAsc(ProcessGroup::getSort).list();
+
+		return R.ok(processGroupList);
+	}
+
+	/**
+	 * 新增表单分组
+	 * <p>
+	 * 创建一个新的流程分组，默认排序值为0
+	 * </p>
+	 * 
+	 * @param processGroup 分组对象，需要包含groupName（分组名称）
+	 * @return R 操作结果，成功返回R.ok()
+	 */
+	@Override
+	public R create(ProcessGroup processGroup) {
+		ProcessGroup pg = new ProcessGroup();
+		pg.setSort(0);
+		pg.setGroupName(processGroup.getGroupName());
+
+		this.save(pg);
+		return R.ok();
+	}
+
+	/**
+	 * 删除分组
+	 * <p>
+	 * 根据分组ID删除流程分组。
+	 * 注意：删除分组前应确保该分组下没有关联的流程，否则可能导致数据不一致
+	 * </p>
+	 * 
+	 * @param id 分组ID
+	 * @return R 操作结果，成功返回R.ok()
+	 */
+	@Override
+	public R delete(long id) {
+		this.removeById(id);
+		return R.ok();
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/ProcessInstanceRecordServiceImpl.java

@@ -0,0 +1,28 @@
+package com.pig4cloud.pigx.flow.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.pig4cloud.pigx.flow.entity.ProcessInstanceRecord;
+import com.pig4cloud.pigx.flow.mapper.ProcessInstanceRecordMapper;
+import com.pig4cloud.pigx.flow.service.IProcessInstanceRecordService;
+import org.springframework.stereotype.Service;
+
+/**
+ * 流程实例记录服务实现类
+ * <p>
+ * 该类负责管理流程实例的历史记录，主要功能包括：
+ * 1. 记录流程实例的创建、执行、完成等状态变化
+ * 2. 保存流程实例的快照信息，包括流程变量、表单数据等
+ * 3. 提供流程实例历史数据的查询功能
+ * 4. 支持流程追踪和审计需求
+ * 
+ * 该服务是流程执行历史的重要存储，用于流程回溯、统计分析等场景
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-07
+ */
+@Service
+public class ProcessInstanceRecordServiceImpl extends ServiceImpl<ProcessInstanceRecordMapper, ProcessInstanceRecord>
+		implements IProcessInstanceRecordService {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/ProcessNodeRecordAssignUserServiceImpl.java

@@ -1,21 +1,28 @@
-package com.pig4cloud.pigx.flow.task.service.impl;
+package com.pig4cloud.pigx.flow.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.pig4cloud.pigx.common.core.util.R;
-import com.pig4cloud.pigx.flow.task.constant.NodeStatusEnum;
-import com.pig4cloud.pigx.flow.task.dto.ProcessNodeRecordAssignUserParamDto;
-import com.pig4cloud.pigx.flow.task.entity.ProcessNodeRecordAssignUser;
-import com.pig4cloud.pigx.flow.task.mapper.ProcessNodeRecordAssignUserMapper;
-import com.pig4cloud.pigx.flow.task.service.IProcessNodeRecordAssignUserService;
+import com.pig4cloud.pigx.flow.constant.NodeStatusEnum;
+import com.pig4cloud.pigx.flow.dto.ProcessNodeRecordAssignUserParamDto;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeRecordAssignUser;
+import com.pig4cloud.pigx.flow.mapper.ProcessNodeRecordAssignUserMapper;
+import com.pig4cloud.pigx.flow.service.IProcessNodeRecordAssignUserService;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
 
 /**
+ * 流程节点记录-执行人服务实现类
  * <p>
- * 流程节点记录-执行人 服务实现类
+ * 该类负责管理流程节点的执行人记录，主要功能包括：
+ * 1. 记录每个节点的执行人分配情况
+ * 2. 跟踪执行人的任务处理状态（进行中、已完成）
+ * 3. 保存执行人的审批意见和处理时间
+ * 4. 处理任务完成事件，更新执行记录
+ * 
+ * 每个流程节点可能有多个执行人（如会签），该服务记录每个执行人的处理情况
  * </p>
  *
  * @author cxygzl
@@ -28,11 +35,25 @@ public class ProcessNodeRecordAssignUserServiceImpl
 
 	/**
 	 * 设置执行人
-	 * @param processNodeRecordAssignUserParamDto
-	 * @return
+	 * <p>
+	 * 为流程节点分配执行人，主要处理逻辑：
+	 * 1. 如果是带审批意见的操作（如委托、转办），更新上一条记录的审批意见和状态
+	 * 2. 创建新的执行人记录，状态为"进行中"
+	 * 3. 记录任务开始时间
+	 * 
+	 * 该方法支持任务的转办、委托等场景
+	 * </p>
+	 * 
+	 * @param processNodeRecordAssignUserParamDto 执行人参数，包含：
+	 *                                           - taskId: 任务ID
+	 *                                           - userId: 执行人ID
+	 *                                           - approveDesc: 审批意见（可选）
+	 *                                           - taskType: 任务类型（转办、委托等）
+	 * @return R 操作结果
 	 */
 	@Override
 	public R addAssignUser(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto) {
+		// 如果有审批意见，说明是转办、委托等操作，需要更新上一条记录
 		if (StrUtil.isNotBlank(processNodeRecordAssignUserParamDto.getApproveDesc())) {
 			ProcessNodeRecordAssignUser processNodeRecordAssignUser = this.lambdaQuery()
 				.eq(ProcessNodeRecordAssignUser::getTaskId, processNodeRecordAssignUserParamDto.getTaskId())
@@ -40,6 +61,7 @@ public class ProcessNodeRecordAssignUserServiceImpl
 				.last("limit 1")
 				.one();
 			if (processNodeRecordAssignUser != null) {
+				// 更新上一个执行人的记录为已完成
 				processNodeRecordAssignUser.setApproveDesc(processNodeRecordAssignUserParamDto.getApproveDesc());
 				processNodeRecordAssignUser.setTaskType(processNodeRecordAssignUserParamDto.getTaskType());
 				processNodeRecordAssignUser.setStatus(NodeStatusEnum.YJS.getCode());
@@ -49,10 +71,11 @@ public class ProcessNodeRecordAssignUserServiceImpl
 
 		}
 
+		// 创建新的执行人记录
 		ProcessNodeRecordAssignUser processNodeRecordAssignUser = BeanUtil
 			.copyProperties(processNodeRecordAssignUserParamDto, ProcessNodeRecordAssignUser.class);
 		processNodeRecordAssignUser.setStartTime(LocalDateTime.now());
-		processNodeRecordAssignUser.setStatus(NodeStatusEnum.JXZ.getCode());
+		processNodeRecordAssignUser.setStatus(NodeStatusEnum.JXZ.getCode());  // 进行中状态
 		processNodeRecordAssignUser.setApproveDesc("");
 		processNodeRecordAssignUser.setTaskType("");
 		this.save(processNodeRecordAssignUser);
@@ -62,11 +85,26 @@ public class ProcessNodeRecordAssignUserServiceImpl
 
 	/**
 	 * 任务完成通知
-	 * @param processNodeRecordAssignUserParamDto
-	 * @return
+	 * <p>
+	 * 处理任务完成事件，更新执行人记录的状态。主要功能：
+	 * 1. 根据任务ID和用户ID查找进行中的执行记录
+	 * 2. 更新记录状态为已完成
+	 * 3. 保存审批意见、结束时间和任务数据
+	 * 
+	 * 该方法在任务完成时被调用，记录任务的完成信息
+	 * </p>
+	 * 
+	 * @param processNodeRecordAssignUserParamDto 任务完成参数，包含：
+	 *                                           - taskId: 任务ID
+	 *                                           - userId: 执行人ID
+	 *                                           - approveDesc: 审批意见
+	 *                                           - data: 任务数据（JSON格式）
+	 *                                           - localData: 本地任务数据
+	 * @return R 操作结果
 	 */
 	@Override
 	public R completeTaskEvent(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto) {
+		// 查找进行中的执行人记录
 		ProcessNodeRecordAssignUser processNodeRecordAssignUser = this.lambdaQuery()
 			.eq(ProcessNodeRecordAssignUser::getTaskId, processNodeRecordAssignUserParamDto.getTaskId())
 			.eq(ProcessNodeRecordAssignUser::getUserId, processNodeRecordAssignUserParamDto.getUserId())
@@ -76,6 +114,8 @@ public class ProcessNodeRecordAssignUserServiceImpl
 			.orderByDesc(ProcessNodeRecordAssignUser::getId)
 			.last("limit 1")
 			.one();
+		
+		// 更新记录为已完成状态
 		processNodeRecordAssignUser.setStatus(NodeStatusEnum.YJS.getCode());
 		processNodeRecordAssignUser.setApproveDesc(processNodeRecordAssignUserParamDto.getApproveDesc());
 		processNodeRecordAssignUser.setEndTime(LocalDateTime.now());

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/ProcessNodeRecordServiceImpl.java

@@ -0,0 +1,88 @@
+package com.pig4cloud.pigx.flow.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.pig4cloud.pigx.common.core.util.R;
+import com.pig4cloud.pigx.flow.constant.NodeStatusEnum;
+import com.pig4cloud.pigx.flow.dto.ProcessNodeRecordParamDto;
+import com.pig4cloud.pigx.flow.entity.ProcessNodeRecord;
+import com.pig4cloud.pigx.flow.mapper.ProcessNodeRecordMapper;
+import com.pig4cloud.pigx.flow.service.IProcessNodeRecordService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.Date;
+
+/**
+ * 流程节点记录服务实现类
+ * <p>
+ * 该类负责管理流程节点的执行记录，主要功能包括：
+ * 1. 记录流程节点的开始和结束时间
+ * 2. 跟踪节点的执行状态（进行中、已完成）
+ * 3. 保存节点执行的历史记录，用于流程追踪
+ * 
+ * 每个流程实例的每个节点都会生成一条记录，记录节点的执行情况
+ * </p>
+ *
+ * @author cxygzl
+ * @since 2023-05-10
+ */
+@Slf4j
+@Service
+public class ProcessNodeRecordServiceImpl extends ServiceImpl<ProcessNodeRecordMapper, ProcessNodeRecord>
+		implements IProcessNodeRecordService {
+
+	/**
+	 * 节点开始
+	 * <p>
+	 * 记录流程节点的开始执行。当流程执行到某个节点时，
+	 * 创建该节点的执行记录，设置开始时间和进行中状态
+	 * </p>
+	 * 
+	 * @param processNodeRecordParamDto 节点记录参数，包含：
+	 *                                 - processInstanceId: 流程实例ID
+	 *                                 - nodeId: 节点ID
+	 *                                 - nodeName: 节点名称
+	 *                                 - nodeType: 节点类型
+	 * @return R 操作结果
+	 */
+	@Override
+	public R start(ProcessNodeRecordParamDto processNodeRecordParamDto) {
+
+		ProcessNodeRecord processNodeRecord = BeanUtil.copyProperties(processNodeRecordParamDto,
+				ProcessNodeRecord.class);
+		processNodeRecord.setStartTime(new Date());
+		processNodeRecord.setStatus(NodeStatusEnum.JXZ.getCode());
+
+		this.save(processNodeRecord);
+		return R.ok();
+	}
+
+	/**
+	 * 节点结束
+	 * <p>
+	 * 记录流程节点的结束执行。当节点上的所有任务都完成后，
+	 * 更新节点记录的状态为已完成，并设置结束时间
+	 * </p>
+	 * 
+	 * @param processNodeRecordParamDto 节点记录参数，包含：
+	 *                                 - processInstanceId: 流程实例ID
+	 *                                 - nodeId: 节点ID
+	 * @return R 操作结果
+	 */
+	@Override
+	public R complete(ProcessNodeRecordParamDto processNodeRecordParamDto) {
+
+		log.info("节点结束---{}", processNodeRecordParamDto);
+
+		// TODO 完成节点和完成任务要区分下
+		this.lambdaUpdate()
+			.set(ProcessNodeRecord::getStatus, NodeStatusEnum.YJS.getCode())
+			.set(ProcessNodeRecord::getEndTime, new Date())
+			.eq(ProcessNodeRecord::getProcessInstanceId, processNodeRecordParamDto.getProcessInstanceId())
+			.eq(ProcessNodeRecord::getNodeId, processNodeRecordParamDto.getNodeId())
+			.update(new ProcessNodeRecord());
+		return R.ok();
+	}
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/ProcessServiceImpl.java

@@ -10,6 +10,7 @@ import cn.hutool.core.util.StrUtil;
 import cn.hutool.json.JSONArray;
 import cn.hutool.json.JSONObject;
 import cn.hutool.json.JSONUtil;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -36,7 +37,6 @@ import org.flowable.bpmn.converter.BpmnXMLConverter;
 import org.flowable.bpmn.model.BpmnModel;
 import org.flowable.engine.RepositoryService;
 import org.flowable.engine.repository.Deployment;
-import org.flowable.engine.repository.ProcessDefinition;
 import org.springframework.stereotype.Service;
 
 import java.util.Date;
@@ -195,15 +195,6 @@ public class ProcessServiceImpl extends ServiceImpl<ProcessMapper, Process> impl
 		}
 
 		Process oldProcess = this.getByFlowId(flowId);
-		if (Objects.nonNull(oldProcess) && StrUtil.isNotBlank(oldProcess.getUniqueId())) {
-			// 挂起原有流程定义
-			String oldDeploymentId = oldProcess.getUniqueId();
-
-			ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
-				.deploymentId(oldDeploymentId)
-				.singleResult();
-			repositoryService.suspendProcessDefinitionById(processDefinition.getId(), true, null);
-		}
 
 		Deployment deployment = repositoryService.createDeployment()
 			.addBpmnModel(StrUtil.format("{}.bpmn20.xml", "pig"), bpmnModel)
@@ -268,10 +259,11 @@ public class ProcessServiceImpl extends ServiceImpl<ProcessMapper, Process> impl
 		p.setRangeShow(stringBuilder.toString());
 		this.saveOrUpdate(p);
 
-		// 保存范围
+		// 删除原有发起范围
+		processStarterService
+			.remove(Wrappers.<ProcessStarter>lambdaQuery().eq(ProcessStarter::getProcessId, p.getId()));
 		for (NodeUser nodeUserDto : nodeUserList) {
 			ProcessStarter processStarter = new ProcessStarter();
-
 			processStarter.setProcessId(p.getId());
 			processStarter.setTypeId(nodeUserDto.getId());
 			processStarter.setType(nodeUserDto.getType());

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/ProcessStarterServiceImpl.java

@@ -0,0 +1,28 @@
+package com.pig4cloud.pigx.flow.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.pig4cloud.pigx.flow.entity.ProcessStarter;
+import com.pig4cloud.pigx.flow.mapper.ProcessStarterMapper;
+import com.pig4cloud.pigx.flow.service.IProcessStarterService;
+import org.springframework.stereotype.Service;
+
+/**
+ * 流程发起人服务实现类
+ * <p>
+ * 该类负责管理流程的发起人权限配置，主要功能包括：
+ * 1. 配置哪些用户可以发起特定流程
+ * 2. 配置哪些部门可以发起特定流程
+ * 3. 支持按用户、部门等不同维度设置发起权限
+ * 4. 为流程列表的权限过滤提供数据支持
+ * 
+ * 通过该服务，可以精确控制流程的发起权限，确保只有授权的用户才能发起相应的流程
+ * </p>
+ *
+ * @author Vincent
+ * @since 2023-05-30
+ */
+@Service
+public class ProcessStarterServiceImpl extends ServiceImpl<ProcessStarterMapper, ProcessStarter>
+		implements IProcessStarterService {
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/RemoteServiceImpl.java

@@ -1,4 +1,4 @@
-package com.pig4cloud.pigx.flow.task.service.impl;
+package com.pig4cloud.pigx.flow.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
@@ -10,13 +10,13 @@ import com.pig4cloud.pigx.admin.api.feign.RemoteDeptService;
 import com.pig4cloud.pigx.admin.api.feign.RemoteUserService;
 import com.pig4cloud.pigx.admin.api.utils.DataUtil;
 import com.pig4cloud.pigx.common.core.util.R;
-import com.pig4cloud.pigx.flow.task.constant.NodeStatusEnum;
-import com.pig4cloud.pigx.flow.task.dto.*;
-import com.pig4cloud.pigx.flow.task.entity.Process;
-import com.pig4cloud.pigx.flow.task.entity.ProcessCopy;
-import com.pig4cloud.pigx.flow.task.entity.ProcessGroup;
-import com.pig4cloud.pigx.flow.task.entity.ProcessInstanceRecord;
-import com.pig4cloud.pigx.flow.task.service.*;
+import com.pig4cloud.pigx.flow.constant.NodeStatusEnum;
+import com.pig4cloud.pigx.flow.dto.*;
+import com.pig4cloud.pigx.flow.entity.Process;
+import com.pig4cloud.pigx.flow.entity.ProcessCopy;
+import com.pig4cloud.pigx.flow.entity.ProcessGroup;
+import com.pig4cloud.pigx.flow.entity.ProcessInstanceRecord;
+import com.pig4cloud.pigx.flow.service.*;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -25,6 +25,22 @@ import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
+/**
+ * 远程服务接口实现类
+ * <p>
+ * 该类为流程引擎提供远程调用接口，主要功能包括：
+ * 1. 用户和部门数据查询（角色、部门关联的用户等）
+ * 2. 流程事件处理（节点开始、结束、任务分配等）
+ * 3. 抄送功能的保存和处理
+ * 4. 部门层级关系的判断
+ * 5. 流程管理员查询
+ * 
+ * 该服务作为流程引擎与业务系统的桥梁，处理流程执行过程中的各种回调事件
+ * </p>
+ * 
+ * @author pigx code generator
+ * @date 2023-10-01
+ */
 @Service
 @Slf4j
 @RequiredArgsConstructor
@@ -50,8 +66,12 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 根据角色id集合查询用户id集合
-	 * @param roleIdList
-	 * @return
+	 * <p>
+	 * 查询拥有指定角色的所有用户ID，用于流程节点的角色审批人设置
+	 * </p>
+	 * 
+	 * @param roleIdList 角色ID列表
+	 * @return R<List<Long>> 拥有这些角色的用户ID列表
 	 */
 	@Override
 	public R<List<Long>> queryUserIdListByRoleIdList(List<Long> roleIdList) {
@@ -60,8 +80,14 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 保存抄送
-	 * @param copyDto
-	 * @return
+	 * <p>
+	 * 异步保存流程抄送记录。由于抄送可能在流程的第一个节点，
+	 * 此时流程实例记录可能还未创建，因此采用异步重试机制，
+	 * 最多重试10次，每次间隔5秒，确保抄送记录能正确保存
+	 * </p>
+	 * 
+	 * @param copyDto 抄送信息，包含流程实例ID、抄送人、节点信息等
+	 * @return R 操作结果
 	 */
 	@Override
 	public R saveCC(ProcessCopyDto copyDto) {
@@ -102,8 +128,13 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 检查是否是所有的父级
-	 * @param checkParentDto
-	 * @return
+	 * <p>
+	 * 判断给定的部门ID列表是否都是指定部门的父级部门。
+	 * 用于流程审批中的"部门主管"、"上级部门"等审批人设置
+	 * </p>
+	 * 
+	 * @param checkParentDto 包含父级部门ID和待检查的部门ID列表
+	 * @return R<Boolean> 如果所有部门都是父级返回true，否则返回false
 	 */
 	@Override
 	public R<Boolean> checkIsAllParent(CheckParentDto checkParentDto) {
@@ -114,7 +145,7 @@ public class RemoteServiceImpl implements IRemoteService {
 		List<SysDept> allDept = deptService.getAllDept(null).getData();
 		List<SysDept> childrenDeptList = DataUtil.selectChildrenByDept(parentId, allDept);
 
-		List<Long> childrenDeptIdList = childrenDeptList.stream().map(SysDept::getDeptId).toList();
+        List<Long> childrenDeptIdList = childrenDeptList.stream().map(SysDept::getDeptId).toList();
 		childrenDeptIdList.remove(parentId);
 
 		List<Long> remainIdList = CollUtil.removeAny(deptIdList, ArrayUtil.toArray(childrenDeptIdList, Long.class));
@@ -124,8 +155,12 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 根据部门id集合查询用户id集合
-	 * @param depIdList
-	 * @return
+	 * <p>
+	 * 查询指定部门下的所有用户ID，用于流程节点的部门审批人设置
+	 * </p>
+	 * 
+	 * @param depIdList 部门ID列表
+	 * @return R<List<Long>> 这些部门下的所有用户ID列表
 	 */
 	@Override
 	public R<List<Long>> queryUserIdListByDepIdList(List<Long> depIdList) {
@@ -139,8 +174,13 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 检查是否是所有的子级
-	 * @param checkChildDto
-	 * @return
+	 * <p>
+	 * 判断给定的部门ID列表是否都是指定部门的子级部门。
+	 * 用于流程审批中的下级部门相关的审批人设置
+	 * </p>
+	 * 
+	 * @param checkChildDto 包含子级部门ID和待检查的部门ID列表
+	 * @return R<Boolean> 如果所有部门都是子级返回true，否则返回false
 	 */
 	@Override
 	public R<Boolean> checkIsAllChild(CheckChildDto checkChildDto) {
@@ -149,7 +189,7 @@ public class RemoteServiceImpl implements IRemoteService {
 		// 查询父级包括自己
 		List<SysDept> allDept = deptService.getAllDept(null).getData();
 		List<SysDept> parentDeptList = DataUtil.selectParentByDept(childId, allDept);
-		List<Long> parentDeptIdList = parentDeptList.stream().map(SysDept::getDeptId).toList();
+        List<Long> parentDeptIdList = parentDeptList.stream().map(SysDept::getDeptId).toList();
 		parentDeptIdList.remove(childId);
 		List<Long> remainIdList = CollUtil.removeAny(deptIdList, ArrayUtil.toArray(parentDeptIdList, Long.class));
 		return R.ok(remainIdList.isEmpty());
@@ -157,8 +197,13 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 获取用户的信息-包括扩展字段
-	 * @param userId
-	 * @return
+	 * <p>
+	 * 查询用户的完整信息，包括基本信息和扩展字段。
+	 * 用于流程表单中需要获取用户详细信息的场景
+	 * </p>
+	 * 
+	 * @param userId 用户ID
+	 * @return R<Map<String, Object>> 用户信息的Map格式，包含所有字段
 	 */
 	@Override
 	public R<Map<String, Object>> queryUserAllInfo(long userId) {
@@ -168,8 +213,12 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 开始节点事件
-	 * @param recordParamDto
-	 * @return
+	 * <p>
+	 * 处理流程节点开始执行的事件，记录节点的开始时间和状态
+	 * </p>
+	 * 
+	 * @param recordParamDto 节点记录参数
+	 * @return R 操作结果
 	 */
 	@Override
 	public R startNodeEvent(ProcessNodeRecordParamDto recordParamDto) {
@@ -178,8 +227,13 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 流程创建了
-	 * @param processInstanceRecordParamDto
-	 * @return
+	 * <p>
+	 * 处理流程实例创建事件，保存流程实例的基本信息，包括：
+	 * 流程名称、所属分组、发起人、logo等信息
+	 * </p>
+	 * 
+	 * @param processInstanceRecordParamDto 流程实例参数，包含流程ID、实例ID、用户ID等
+	 * @return R 操作结果
 	 */
 	@Override
 	public R createProcessEvent(ProcessInstanceRecordParamDto processInstanceRecordParamDto) {
@@ -206,8 +260,12 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 完成节点事件
-	 * @param recordParamDto
-	 * @return
+	 * <p>
+	 * 处理流程节点完成事件，更新节点记录的结束时间和状态
+	 * </p>
+	 * 
+	 * @param recordParamDto 节点记录参数
+	 * @return R 操作结果
 	 */
 	@Override
 	public R endNodeEvent(ProcessNodeRecordParamDto recordParamDto) {
@@ -216,8 +274,12 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 开始设置执行人
-	 * @param processNodeRecordAssignUserParamDto
-	 * @return
+	 * <p>
+	 * 为流程节点分配执行人，记录任务的分配信息
+	 * </p>
+	 * 
+	 * @param processNodeRecordAssignUserParamDto 执行人分配参数
+	 * @return R 操作结果
 	 */
 	@Override
 	public R startAssignUser(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto) {
@@ -226,8 +288,12 @@ public class RemoteServiceImpl implements IRemoteService {
 
 	/**
 	 * 任务结束事件
-	 * @param processNodeRecordAssignUserParamDto
-	 * @return
+	 * <p>
+	 * 处理任务完成事件，更新执行人的任务完成状态和审批意见
+	 * </p>
+	 * 
+	 * @param processNodeRecordAssignUserParamDto 任务完成参数
+	 * @return R 操作结果
 	 */
 	@Override
 	public R taskEndEvent(ProcessNodeRecordAssignUserParamDto processNodeRecordAssignUserParamDto) {
@@ -235,20 +301,28 @@ public class RemoteServiceImpl implements IRemoteService {
 	}
 
 	/**
-     * 结束流程实例的方法
-     *
-     * @param processInstanceParamDto 包含流程实例标识的参数对象
-     * @return 流程实例结束操作的响应结果
+	 * 结束流程实例的方法
+	 * <p>
+	 * 处理流程实例结束事件，更新流程实例的结束时间、状态和结束原因
+	 * </p>
+	 *
+	 * @param processInstanceParamDto 包含流程实例标识的参数对象
+	 * @return R 流程实例结束操作的响应结果
 	 */
 	@Override
-    public R endProcess(ProcessInstanceParamDto processInstanceParamDto) {
-        return processInstanceService.end(processInstanceParamDto);
+	public R endProcess(ProcessInstanceParamDto processInstanceParamDto) {
+		return processInstanceService.end(processInstanceParamDto);
 	}
 
 	/**
 	 * 查询流程管理员
-	 * @param flowId
-	 * @return
+	 * <p>
+	 * 根据流程ID查询该流程的管理员ID。
+	 * 流程管理员拥有该流程的最高权限，可以进行流程的编辑、删除等操作
+	 * </p>
+	 * 
+	 * @param flowId 流程ID
+	 * @return R<Long> 流程管理员的用户ID
 	 */
 	@Override
 	public R<Long> queryProcessAdmin(String flowId) {

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/impl/TaskServiceImpl.java

@@ -256,6 +256,12 @@ public class TaskServiceImpl implements ITaskService {
 			taskService.setVariablesLocal(taskParamDto.getTaskId(), taskLocalParamMap);
 		}
 
+		if (CollUtil.isNotEmpty(taskParamDto.getFormData())) {
+			// 获取当前任务
+			Task task = taskService.createTaskQuery().taskId(taskParamDto.getTaskId()).singleResult();
+			runtimeService.setVariables(task.getExecutionId(), taskParamDto.getFormData());
+		}
+
 		taskService.complete(taskParamDto.getTaskId(), taskParamDto.getParamMap());
 
 		return R.ok();
@@ -315,6 +321,11 @@ public class TaskServiceImpl implements ITaskService {
 		for (Long targetUserId : taskParamDto.getTargetUserIdList()) {
 			taskService.setAssignee(taskParamDto.getTaskId(), targetUserId.toString());
 		}
+
+		// 更新表单
+		if (CollUtil.isNotEmpty(taskParamDto.getFormData())) {
+			runtimeService.setVariables(task.getExecutionId(), taskParamDto.getFormData());
+		}
 		return R.ok();
 	}
 

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/service/packge-info.java

@@ -0,0 +1,4 @@
+/*
+ * @author pigx archetype
+ */
+package com.pig4cloud.pigx.flow.service;

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/support/expression/ExpressionHandler.java

@@ -1,4 +1,4 @@
-package com.pig4cloud.pigx.flow.engine.expression;
+package com.pig4cloud.pigx.flow.support.expression;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.convert.Convert;
@@ -14,9 +14,9 @@ import com.googlecode.aviator.AviatorEvaluator;
 import com.pig4cloud.pigx.admin.api.entity.SysUser;
 import com.pig4cloud.pigx.admin.api.feign.RemoteUserService;
 import com.pig4cloud.pigx.common.core.util.R;
-import com.pig4cloud.pigx.flow.task.constant.NodeUserTypeEnum;
-import com.pig4cloud.pigx.flow.task.dto.NodeUser;
-import com.pig4cloud.pigx.flow.task.dto.SelectValue;
+import com.pig4cloud.pigx.flow.constant.NodeUserTypeEnum;
+import com.pig4cloud.pigx.flow.dto.NodeUser;
+import com.pig4cloud.pigx.flow.dto.SelectValue;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
@@ -27,7 +27,14 @@ import java.math.BigDecimal;
 import java.util.List;
 
 /**
- * 表达式解析
+ * 流程表达式处理器
+ * <p>
+ * 该类负责处理流程节点中的条件表达式，支持多种数据类型的比较和判断： 1. 日期时间类型的比较 2. 数字类型的比较和包含判断 3. 字符串的相等和包含判断 4.
+ * 单选/多选的判断 5. 部门和用户的归属判断
+ * <p>
+ * 使用Aviator表达式引擎进行动态表达式计算，支持在流程定义中配置灵活的条件判断逻辑
+ *
+ * @author pigx
  */
 @Slf4j
 @Component("expressionHandler")
@@ -38,6 +45,13 @@ public class ExpressionHandler {
 
 	private final ObjectMapper objectMapper;
 
+	/**
+	 * 从流程变量中获取用户ID
+	 * @param key 流程变量的键名
+	 * @param execution 流程执行上下文
+	 * @return 用户ID
+	 * @throws Exception 当JSON解析失败时抛出异常
+	 */
 	@SneakyThrows
 	public Long getUserId(String key, DelegateExecution execution) {
 		Object variable = execution.getVariable(key);
@@ -50,12 +64,14 @@ public class ExpressionHandler {
 
 	/**
 	 * 日期时间比较
-	 * @param key
-	 * @param symbol
-	 * @param param
-	 * @param execution
-	 * @param format 时间格式化模式
-	 * @return
+	 * <p>
+	 * 比较流程变量中的日期时间值与给定参数值的大小关系
+	 * @param key 流程变量的键名
+	 * @param symbol 比较符号（如：>, <, >=, <=, ==, !=）
+	 * @param param 比较的参数值
+	 * @param execution 流程执行上下文
+	 * @param format 时间格式化模式（如：yyyy-MM-dd HH:mm:ss）
+	 * @return 比较结果，true表示条件成立，false表示条件不成立
 	 */
 	public boolean dateTimeCompare(String key, String symbol, Object param, DelegateExecution execution,
 			String format) {
@@ -75,11 +91,13 @@ public class ExpressionHandler {
 
 	/**
 	 * 数字类型比较
-	 * @param key 表单key
-	 * @param symbol 比较符号
-	 * @param param 表单参数
-	 * @param execution
-	 * @return
+	 * <p>
+	 * 比较流程变量中的数字值与给定参数值的大小关系
+	 * @param key 表单key，对应流程变量的键名
+	 * @param symbol 比较符号（如：>, <, >=, <=, ==, !=）
+	 * @param param 比较的参数值
+	 * @param execution 流程执行上下文
+	 * @return 比较结果，true表示条件成立，false表示条件不成立
 	 */
 	public boolean numberCompare(String key, String symbol, Object param, DelegateExecution execution) {
 
@@ -94,6 +112,14 @@ public class ExpressionHandler {
 
 	}
 
+	/**
+	 * 通用比较方法
+	 * <p>
+	 * 使用Aviator表达式引擎执行比较表达式
+	 * @param symbol 包含比较符号的表达式字符串
+	 * @param value 包含变量值的字典
+	 * @return 比较结果
+	 */
 	private Boolean compare(String symbol, Dict value) {
 		Object result = AviatorEvaluator.getInstance().execute(symbol, value);
 		// 渲染结果
@@ -103,12 +129,14 @@ public class ExpressionHandler {
 
 	/**
 	 * 日期类型对比
-	 * @param key 表单key
-	 * @param symbol 比较符号
-	 * @param param 比较参数值
-	 * @param execution 上下午执行前
-	 * @param format 日期格式化字符串
-	 * @return
+	 * <p>
+	 * 比较流程变量中的日期值与给定参数日期的大小关系
+	 * @param key 表单key，对应流程变量的键名
+	 * @param symbol 比较符号（如：>, <, >=, <=, ==, !=）
+	 * @param param 比较的参数日期值
+	 * @param execution 流程执行上下文
+	 * @param format 日期格式化字符串（如：yyyy-MM-dd）
+	 * @return 比较结果，true表示条件成立，false表示条件不成立
 	 */
 	public boolean dateCompare(String key, String symbol, Object param, DelegateExecution execution, String format) {
 
@@ -134,9 +162,12 @@ public class ExpressionHandler {
 
 	/**
 	 * 判断数字数组包含
-	 * @param key 表单key
-	 * @param array 条件值
-	 * @return
+	 * <p>
+	 * 检查流程变量中的数字值是否在给定的数组中
+	 * @param key 表单key，对应流程变量的键名
+	 * @param execution 流程执行上下文
+	 * @param array 条件值数组
+	 * @return true表示包含，false表示不包含
 	 */
 	public boolean numberContain(String key, DelegateExecution execution, Object... array) {
 
@@ -149,6 +180,12 @@ public class ExpressionHandler {
 		return numberContain(value, array);
 	}
 
+	/**
+	 * 内部方法：检查数字值是否在数组中
+	 * @param value 要检查的值
+	 * @param array 目标数组
+	 * @return true表示包含，false表示不包含
+	 */
 	private static boolean numberContain(Object value, Object[] array) {
 		BigDecimal valueBigDecimal = Convert.toBigDecimal(value);
 
@@ -162,9 +199,12 @@ public class ExpressionHandler {
 
 	/**
 	 * 单选处理
-	 * @param key 表单key
-	 * @param array 条件值
-	 * @return
+	 * <p>
+	 * 检查单选表单的选中值是否在给定的数组中
+	 * @param key 表单key，对应流程变量的键名
+	 * @param execution 流程执行上下文
+	 * @param array 条件值数组
+	 * @return true表示选中值在数组中，false表示不在
 	 */
 	public boolean singleSelectHandler(String key, DelegateExecution execution, String... array) {
 		Object value = execution.getVariable(key);
@@ -181,9 +221,12 @@ public class ExpressionHandler {
 
 	/**
 	 * 字符串判断包含
-	 * @param key 表单key
-	 * @param param 参数
-	 * @return
+	 * <p>
+	 * 检查流程变量中的字符串值是否包含指定的子串
+	 * @param key 表单key，对应流程变量的键名
+	 * @param param 要查找的子串
+	 * @param execution 流程执行上下文
+	 * @return true表示包含，false表示不包含
 	 */
 	public boolean stringContain(String key, String param, DelegateExecution execution) {
 		Object value = execution.getVariable(key);
@@ -196,9 +239,12 @@ public class ExpressionHandler {
 
 	/**
 	 * 字符串判断相等
-	 * @param key 表单key
-	 * @param param 参数
-	 * @return
+	 * <p>
+	 * 检查流程变量中的字符串值是否与给定参数相等
+	 * @param key 表单key，对应流程变量的键名
+	 * @param param 比较的参数值
+	 * @param execution 流程执行上下文
+	 * @return true表示相等，false表示不相等
 	 */
 	public boolean stringEqual(String key, String param, DelegateExecution execution) {
 		Object value = execution.getVariable(key);
@@ -209,6 +255,17 @@ public class ExpressionHandler {
 		return StrUtil.equals(value.toString(), param);
 	}
 
+	/**
+	 * 部门比较
+	 * <p>
+	 * 检查流程变量中的部门是否满足给定的条件（属于或不属于指定部门列表）
+	 * @param key 表单key，对应流程变量的键名
+	 * @param param 部门列表参数（JSON格式）
+	 * @param symbol 比较符号（in/==：属于，notin/!=：不属于）
+	 * @param execution 流程执行上下文
+	 * @return 比较结果
+	 * @throws Exception 当JSON解析失败时抛出异常
+	 */
 	@SneakyThrows
 	public boolean deptCompare(String key, String param, String symbol, DelegateExecution execution) {
 		param = EscapeUtil.unescape(param);
@@ -235,12 +292,19 @@ public class ExpressionHandler {
 		List<NodeUser> paramDeptList = objectMapper.readValue(param, new TypeReference<List<NodeUser>>() {
 		});
 		Long deptId = nodeUserDto.getId();
-        List<Long> deptIdList = paramDeptList.stream().map(NodeUser::getId).toList();
+		List<Long> deptIdList = paramDeptList.stream().map(NodeUser::getId).toList();
 
 		return inCompare(symbol, deptId, deptIdList);
 
 	}
 
+	/**
+	 * 内部方法：判断ID是否在列表中
+	 * @param symbol 比较符号（in/==：属于，notin/!=：不属于）
+	 * @param deptId 要检查的ID
+	 * @param deptIdList ID列表
+	 * @return 比较结果
+	 */
 	private static boolean inCompare(String symbol, Long deptId, List<Long> deptIdList) {
 		if (StrUtil.equalsAny(symbol, "in", "==")) {
 			// 属于
@@ -255,10 +319,15 @@ public class ExpressionHandler {
 	}
 
 	/**
-	 * user判断
-	 * @param key 表单key
-	 * @param param 参数
-	 * @return
+	 * 用户比较
+	 * <p>
+	 * 检查流程变量中的用户是否满足给定的条件（属于或不属于指定用户/部门列表） 支持直接指定用户或通过部门查找用户
+	 * @param key 表单key，对应流程变量的键名
+	 * @param param 用户/部门列表参数（JSON格式）
+	 * @param symbol 比较符号（in/==：属于，notin/!=：不属于）
+	 * @param execution 流程执行上下文
+	 * @return 比较结果
+	 * @throws Exception 当JSON解析失败时抛出异常
 	 */
 	@SneakyThrows
 	public boolean userCompare(String key, String param, String symbol, DelegateExecution execution) {
@@ -291,12 +360,12 @@ public class ExpressionHandler {
 		List<Long> deptIdList = paramDeptList.stream()
 			.filter(w -> StrUtil.equals(w.getType(), NodeUserTypeEnum.DEPT.getKey()))
 			.map(NodeUser::getId)
-                .toList();
+			.toList();
 
 		List<Long> userIdList = paramDeptList.stream()
 			.filter(w -> StrUtil.equals(w.getType(), NodeUserTypeEnum.USER.getKey()))
 			.map(NodeUser::getId)
-                .toList();
+			.toList();
 
 		if (CollUtil.isNotEmpty(deptIdList)) {
 			R<List<SysUser>> r = remoteUserService.getUserIdListByDeptIdList(deptIdList);
@@ -307,4 +376,8 @@ public class ExpressionHandler {
 		return inCompare(symbol, Convert.toLong(nodeUserDto.getId()), userIdList);
 	}
 
+	public boolean days(DelegateExecution execution) {
+		return true;
+	}
+
 }

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/support/expression/condition/NodeConditionStrategy.java

@@ -0,0 +1,31 @@
+package com.pig4cloud.pigx.flow.support.expression.condition;
+
+import com.pig4cloud.pigx.flow.dto.Condition;
+
+/**
+ * 节点条件策略接口
+ * <p>
+ * 定义了流程节点条件处理的策略模式接口。
+ * 该接口是策略模式的核心，不同的表单控件类型（如文本、数字、日期、选择器等）
+ * 都需要实现该接口，以提供相应的条件表达式生成逻辑。
+ * <p>
+ * 实现类将根据不同的表单控件类型和条件配置，生成对应的SpEL表达式，
+ * 这些表达式将在流程执行时被Flowable引擎解析和执行，用于判断流程的走向。
+ *
+ * @author pigx
+ * @see com.pig4cloud.pigx.flow.dto.Condition 条件配置对象
+ */
+public interface NodeConditionStrategy {
+
+	/**
+	 * 处理条件表达式
+	 * <p>
+	 * 根据传入的条件配置对象，生成对应的SpEL（Spring Expression Language）表达式字符串。
+	 * 生成的表达式会在流程运行时被评估，用于决定流程的条件分支走向。
+	 *
+	 * @param condition 条件配置对象，包含字段名、操作符、比较值等信息
+	 * @return 生成的SpEL表达式字符串，例如："${expressionHandler.numberCompare('age', '>', 18, execution)}"
+	 */
+	String handle(Condition condition);
+
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/support/expression/condition/NodeExpressionStrategyFactory.java

@@ -1,19 +1,35 @@
-package com.pig4cloud.pigx.flow.engine.expression.condition;
+package com.pig4cloud.pigx.flow.support.expression.condition;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.extra.spring.SpringUtil;
-import com.pig4cloud.pigx.flow.task.dto.Condition;
-import com.pig4cloud.pigx.flow.task.dto.GroupCondition;
-import com.pig4cloud.pigx.flow.task.dto.Node;
+import com.pig4cloud.pigx.flow.dto.Condition;
+import com.pig4cloud.pigx.flow.dto.GroupCondition;
+import com.pig4cloud.pigx.flow.dto.Node;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 
+/**
+ * 节点表达式策略工厂
+ * <p>
+ * 负责管理和协调不同类型的节点条件策略，生成复杂的条件表达式。 该工厂类是整个条件表达式生成系统的核心，它将多个条件组合成完整的SpEL表达式。
+ * <p>
+ * 主要功能： 1. 根据条件类型动态选择对应的策略实现 2. 处理条件组内的逻辑关系（AND/OR） 3. 处理多个条件组之间的逻辑关系 4. 生成默认分支的条件表达式
+ *
+ * @author pigx
+ */
 public class NodeExpressionStrategyFactory {
 
+	/**
+	 * 处理单个条件
+	 * <p>
+	 * 根据条件的keyType（表单控件类型）动态选择对应的策略实现， 并调用其handle方法生成具体的表达式。
+	 * @param nodeConditionDto 单个条件配置对象
+	 * @return 生成的条件表达式字符串，如果找不到对应策略则返回"(1==1)"
+	 */
 	public static String handleSingleCondition(Condition nodeConditionDto) {
 		Map<String, NodeConditionStrategy> nodeConditionStrategyMap = SpringUtil
 			.getBeansOfType(NodeConditionStrategy.class);
@@ -26,7 +42,6 @@ public class NodeExpressionStrategyFactory {
 			}
 		});
 
-
 		if (nodeConditionHandler.get() == null) {
 			return "(1==1)";
 		}
@@ -34,9 +49,11 @@ public class NodeExpressionStrategyFactory {
 	}
 
 	/**
-	 * 组内处理表达式
-	 * @param groupDto
-	 * @return
+	 * 处理条件组表达式
+	 * <p>
+	 * 将一个条件组内的多个条件根据逻辑关系（AND/OR）组合成一个表达式。 mode为true时使用AND连接，为false时使用OR连接。
+	 * @param groupDto 条件组配置对象，包含多个条件和逻辑关系
+	 * @return 组合后的条件表达式，用括号包裹
 	 */
 	public static String handleGroupCondition(GroupCondition groupDto) {
 
@@ -59,10 +76,16 @@ public class NodeExpressionStrategyFactory {
 	}
 
 	/**
-	 * 处理单个分支表达式
-	 * @return
+	 * 处理节点的完整条件表达式
+	 * <p>
+	 * 将节点的所有条件组根据节点级别的逻辑关系组合成最终的SpEL表达式。 如果节点没有配置条件，返回永真表达式"${1==1}"。
+	 * @param node 节点配置对象，包含多个条件组
+	 * @return 完整的SpEL表达式，包含${}包裹
 	 */
 	public static String handle(Node node) {
+		if (1 == node.getConditionType()) {
+			return "${(" + node.getExpressionText() + ")}";
+		}
 
 		List<String> exps = new ArrayList<>();
 
@@ -84,6 +107,14 @@ public class NodeExpressionStrategyFactory {
 		return "${(" + join + ")}";
 	}
 
+	/**
+	 * 处理默认分支的条件表达式
+	 * <p>
+	 * 生成一个条件表达式，当其他所有分支条件都不满足时，该表达式为真。 实现方式是将其他分支的条件取反并用OR连接，然后整体取反。
+	 * @param branchs 所有分支节点列表
+	 * @param currentIndex 当前默认分支的索引位置
+	 * @return 默认分支的条件表达式
+	 */
 	public static String handleDefaultBranch(List<Node> branchs, int currentIndex) {
 
 		List<String> expList = new ArrayList<>();
@@ -105,4 +136,4 @@ public class NodeExpressionStrategyFactory {
 		return "${" + join + "}";
 	}
 
-}
+}

pigx-flow/pigx-flow-biz/src/main/java/com/pig4cloud/pigx/flow/support/expression/condition/impl/DateNodeConditionStrategy.java

@@ -0,0 +1,41 @@
+package com.pig4cloud.pigx.flow.support.expression.condition.impl;
+
+import cn.hutool.core.util.StrUtil;
+import com.pig4cloud.pigx.flow.support.expression.condition.NodeConditionStrategy;
+import com.pig4cloud.pigx.flow.dto.Condition;
+import org.springframework.stereotype.Component;
+
+/**
+ * 日期选择器类型条件处理器
+ * <p>
+ * 处理日期选择器类型表单控件的条件表达式生成。
+ * 支持日期比较操作：>, <, >=, <=, ==, !=
+ * 默认使用"yyyy-MM-dd"格式进行日期解析和比较。
+ *
+ * @author pigx
+ */
+@Component("datePickerNodeConditionStrategy")
+public class DateNodeConditionStrategy implements NodeConditionStrategy {
+
+	/**
+	 * 处理日期类型的条件表达式
+	 * <p>
+	 * 生成日期比较的SpEL表达式，将日期字符串转换为时间戳进行比较。
+	 * 固定使用"yyyy-MM-dd"格式解析日期。
+	 *
+	 * @param condition 条件配置对象，包含字段名、操作符、比较值等信息
+	 * @return SpEL表达式字符串，格式如："(expressionHandler.dateTimeCompare("birthday",">","2023-01-01",execution,"yyyy-MM-dd"))"
+	 */
+	@Override
+	public String handle(Condition condition) {
+
+		String compare = condition.getExpression();
+		String id = condition.getKey();
+		Object value = condition.getValue();
+
+		return StrUtil.format("(expressionHandler.dateTimeCompare(\"{}\",\"{}\",\"{}\",execution,\"yyyy-MM-dd\"))", id,
+				compare, value);
+
+	}
+
+}