流程

hx-common/service-flow/src/main/java/com/fjhx/controller/process/ProcessInfoController.java

@@ -39,8 +39,7 @@ public class ProcessInfoController {
      */
     @PostMapping("/editSystem")
     public R editSystem(@RequestBody ProcessObject processObject) {
-
-
+        processInfoService.editSystem(processObject);
         return R.success();
     }
 

hx-common/service-flow/src/main/java/com/fjhx/mapper/process/ProcessNodeHandleMapper.java

@@ -1,6 +1,6 @@
 package com.fjhx.mapper.process;
 
-import com.fjhx.entity.process.ProcessNodeHandle;
+import com.fjhx.entity.process.ProcessNodeButton;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
 /**
@@ -11,6 +11,6 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  * @author ${author}
  * @since 2022-08-12
  */
-public interface ProcessNodeHandleMapper extends BaseMapper<ProcessNodeHandle> {
+public interface ProcessNodeHandleMapper extends BaseMapper<ProcessNodeButton> {
 
 }

hx-common/service-flow/src/main/java/com/fjhx/service/process/ProcessInfoService.java

@@ -16,4 +16,6 @@ public interface ProcessInfoService extends BaseService<ProcessInfo> {
 
     ProcessObject addSystem(ProcessInfo processInfo);
 
+    void editSystem(ProcessObject processObject);
+
 }

hx-common/service-flow/src/main/java/com/fjhx/service/process/ProcessNodeHandleService.java

@@ -1,7 +1,7 @@
 package com.fjhx.service.process;
 
 import com.fjhx.base.BaseService;
-import com.fjhx.entity.process.ProcessNodeHandle;
+import com.fjhx.entity.process.ProcessNodeButton;
 
 /**
  * <p>
@@ -11,6 +11,6 @@ import com.fjhx.entity.process.ProcessNodeHandle;
  * @author ${author}
  * @since 2022-08-12
  */
-public interface ProcessNodeHandleService extends BaseService<ProcessNodeHandle> {
+public interface ProcessNodeHandleService extends BaseService<ProcessNodeButton> {
 
 }

hx-common/service-flow/src/main/java/com/fjhx/service/process/ProcessNodeService.java

@@ -2,6 +2,9 @@ package com.fjhx.service.process;
 
 import com.fjhx.base.BaseService;
 import com.fjhx.entity.process.ProcessNode;
+import com.fjhx.params.process.ProcessNodeVo;
+
+import java.util.List;
 
 /**
  * <p>
@@ -13,4 +16,12 @@ import com.fjhx.entity.process.ProcessNode;
  */
 public interface ProcessNodeService extends BaseService<ProcessNode> {
 
+    /**
+     * 添加或编辑节点
+     *
+     * @param id              流程id
+     * @param processNodeList 节点列表
+     */
+    void addOrEditNodeList(Long id, List<ProcessNodeVo> processNodeList);
+
 }

hx-common/service-flow/src/main/java/com/fjhx/service/process/impl/ProcessInfoServiceImpl.java

@@ -3,8 +3,8 @@ package com.fjhx.service.process.impl;
 import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fjhx.constants.FlowConstant;
 import com.fjhx.constants.FlowExplainConstant;
-import com.fjhx.constants.ProcessConstant;
 import com.fjhx.constants.StatusConstant;
 import com.fjhx.entity.process.ProcessInfo;
 import com.fjhx.enums.ProcessInfoParallelRulesEnum;
@@ -19,6 +19,7 @@ import com.fjhx.utils.Assert;
 import org.springblade.common.constant.CommonConstant;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Arrays;
 
@@ -36,6 +37,7 @@ public class ProcessInfoServiceImpl extends ServiceImpl<ProcessInfoMapper, Proce
     @Autowired
     private ProcessNodeService processNodeService;
 
+    @Transactional(rollbackFor = Exception.class)
     @Override
     public ProcessObject addSystem(ProcessInfo processInfo) {
 
@@ -54,12 +56,12 @@ public class ProcessInfoServiceImpl extends ServiceImpl<ProcessInfoMapper, Proce
 
         // 版本号为空，设为默认值
         if (ObjectUtil.isEmpty(processInfo.getVersionNumber())) {
-            processInfo.setVersionNumber(ProcessConstant.DEFAULT_VERSION_NUMBER);
+            processInfo.setVersionNumber(FlowConstant.DEFAULT_VERSION_NUMBER);
         }
 
         // 并行规则
         if (ObjectUtil.isEmpty(processInfo.getParallelRules())) {
-            processInfo.setParallelRules(ProcessInfoParallelRulesEnum.no.getType());
+            processInfo.setParallelRules(ProcessInfoParallelRulesEnum.NO.getType());
         }
 
         // 创建流程
@@ -67,6 +69,21 @@ public class ProcessInfoServiceImpl extends ServiceImpl<ProcessInfoMapper, Proce
 
     }
 
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public void editSystem(ProcessObject processObject) {
+
+        ProcessInfo processInfo = processObject.getProcessInfo();
+
+        Long id = processInfo.getId();
+        Assert.notEmpty(id, FlowExplainConstant.PROCESS_INFO_ID_EMPTY);
+
+        verificationField(processInfo);
+
+        processNodeService.addOrEditNodeList(id, processObject.getProcessNodeList());
+
+    }
+
     /**
      * 验证字段
      */
@@ -103,22 +120,22 @@ public class ProcessInfoServiceImpl extends ServiceImpl<ProcessInfoMapper, Proce
 
         // 生成默认开始节点
         ProcessNodeVo startProcessNode = new ProcessNodeVo();
-        startProcessNode.setType(ProcessNodeTypeEnum.start.getType());
+        startProcessNode.setType(ProcessNodeTypeEnum.START.getType());
         startProcessNode.setProcessInfoId(processInfoId);
         startProcessNode.setParentId(CommonConstant.TOP_PARENT_ID);
-        startProcessNode.setName(ProcessConstant.START_NAME);
-        startProcessNode.setCode(ProcessConstant.START_CODE);
-        startProcessNode.setHandleObjectType(ProcessNodeHandleObjectTypeEnum.all.getType());
+        startProcessNode.setName(FlowConstant.START_NAME);
+        startProcessNode.setCode(FlowConstant.START_CODE);
+        startProcessNode.setHandleObjectType(ProcessNodeHandleObjectTypeEnum.ALL.getType());
         processNodeService.save(startProcessNode);
 
         // 生成默认结束节点
         Long startProcessNodeId = startProcessNode.getId();
         ProcessNodeVo endProcessNode = new ProcessNodeVo();
-        endProcessNode.setType(ProcessNodeTypeEnum.end.getType());
+        endProcessNode.setType(ProcessNodeTypeEnum.END.getType());
         endProcessNode.setProcessInfoId(processInfoId);
         endProcessNode.setParentId(startProcessNodeId);
-        endProcessNode.setName(ProcessConstant.END_NAME);
-        endProcessNode.setCode(ProcessConstant.END_CODE);
+        endProcessNode.setName(FlowConstant.END_NAME);
+        endProcessNode.setCode(FlowConstant.END_CODE);
         processNodeService.save(endProcessNode);
 
         ProcessObject processObject = new ProcessObject();
@@ -146,7 +163,7 @@ public class ProcessInfoServiceImpl extends ServiceImpl<ProcessInfoMapper, Proce
         );
 
         if (processInfo == null) {
-            return ProcessConstant.DEFAULT_VERSION_NUMBER;
+            return FlowConstant.DEFAULT_VERSION_NUMBER;
         }
 
         return processInfo.getVersionNumber() + 1;

hx-common/service-flow/src/main/java/com/fjhx/service/process/impl/ProcessNodeHandleServiceImpl.java

@@ -1,7 +1,7 @@
 package com.fjhx.service.process.impl;
 
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.fjhx.entity.process.ProcessNodeHandle;
+import com.fjhx.entity.process.ProcessNodeButton;
 import com.fjhx.mapper.process.ProcessNodeHandleMapper;
 import com.fjhx.service.process.ProcessNodeHandleService;
 import org.springframework.stereotype.Service;
@@ -15,6 +15,6 @@ import org.springframework.stereotype.Service;
  * @since 2022-08-12
  */
 @Service
-public class ProcessNodeHandleServiceImpl extends ServiceImpl<ProcessNodeHandleMapper, ProcessNodeHandle> implements ProcessNodeHandleService {
+public class ProcessNodeHandleServiceImpl extends ServiceImpl<ProcessNodeHandleMapper, ProcessNodeButton> implements ProcessNodeHandleService {
 
 }

hx-common/service-flow/src/main/java/com/fjhx/service/process/impl/ProcessNodeServiceImpl.java

@@ -1,11 +1,27 @@
 package com.fjhx.service.process.impl;
 
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fjhx.constants.FlowConstant;
+import com.fjhx.constants.FlowExplainConstant;
 import com.fjhx.entity.process.ProcessNode;
+import com.fjhx.entity.process.ProcessNodeButton;
+import com.fjhx.enums.ButtonNameEnum;
+import com.fjhx.enums.ProcessNodeHandleObjectTypeEnum;
+import com.fjhx.enums.ProcessNodeTypeEnum;
 import com.fjhx.mapper.process.ProcessNodeMapper;
+import com.fjhx.params.process.ProcessNodeVo;
 import com.fjhx.service.process.ProcessNodeService;
+import com.fjhx.utils.Assert;
+import org.springblade.core.log.exception.ServiceException;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 /**
  * <p>
  * 服务实现类
@@ -17,4 +33,212 @@ import org.springframework.stereotype.Service;
 @Service
 public class ProcessNodeServiceImpl extends ServiceImpl<ProcessNodeMapper, ProcessNode> implements ProcessNodeService {
 
+    @Override
+    public void addOrEditNodeList(Long id, List<ProcessNodeVo> processNodeVoList) {
+
+        // 节点集合
+        List<ProcessNode> processNodeList = processNodeVoList.stream().map(processNodeVo -> {
+            // 验证字段
+            verificationField(processNodeVo);
+            // 拷贝对象
+            ProcessNode processNode = BeanUtil.toBean(processNodeVo, ProcessNode.class);
+            // 赋值流程id
+            processNode.setProcessInfoId(id);
+            // 赋值处理对象id集合
+            processNode.setHandleObjectIdSet(String.join(",", processNodeVo.getHandleObjectIdList()));
+            return processNode;
+        }).collect(Collectors.toList());
+
+        // 添加或更新节点
+        saveOrUpdateBatch(processNodeList);
+
+        // 添加节点按钮
+        insertNodeButton(processNodeList);
+
+    }
+
+
+    /**
+     * 验证字段
+     */
+    private void verificationField(ProcessNodeVo processNodeVo) {
+
+        // 节点类型
+        Integer type = processNodeVo.getType();
+        Assert.notEmpty(type, FlowExplainConstant.NODE_TYPE);
+
+        // 父节点id
+        Long parentId = processNodeVo.getParentId();
+        Assert.notEmpty(parentId, FlowExplainConstant.NODE_PARENT_ID);
+
+        // 节点名称
+        String name = processNodeVo.getName();
+        Assert.notEmpty(name, FlowExplainConstant.NODE_NAME);
+
+        // 发起 / 处理对象类型
+        Integer handleObjectType = processNodeVo.getHandleObjectType();
+        Assert.notEmpty(handleObjectType, FlowExplainConstant.HANDLE_OBJECT_TYPE);
+
+        // 处理对象id集合
+        if (ObjectUtil.notEqual(handleObjectType, ProcessNodeHandleObjectTypeEnum.ALL.getType())) {
+            List<String> handleObjectIdList = processNodeVo.getHandleObjectIdList();
+            Assert.notEmpty(handleObjectIdList, FlowExplainConstant.HANDLE_OBJECT_ID_LIST);
+        }
+
+    }
+
+    /**
+     * 添加节点按钮
+     */
+    private void insertNodeButton(List<ProcessNode> processNodeList) {
+
+        // 按父级节点分组
+        Map<Long, List<ProcessNode>> ProcessNodeGroupByParentId = processNodeList.stream()
+                .collect(Collectors.groupingBy(ProcessNode::getParentId));
+
+        for (ProcessNode processNode : processNodeList) {
+            Integer type = processNode.getType();
+            // 获取节点类型枚举值
+            ProcessNodeTypeEnum processNodeTypeEnum = ProcessNodeTypeEnum.get(type);
+            Assert.notEmpty(processNodeTypeEnum, FlowExplainConstant.NODE_UNKNOWN);
+            // 根据节点类型生成功能按钮
+            List<ProcessNodeButton> processNodeButtonList = new ArrayList<>();
+            switch (processNodeTypeEnum) {
+                case START: // 开始
+                    startHandle(processNodeButtonList, ProcessNodeGroupByParentId, processNode);
+                    break;
+
+                case EXAMINED: // 审核
+                    examinedHandle(processNodeButtonList, ProcessNodeGroupByParentId, processNode);
+                    break;
+
+                case APPROVAL: // 审批
+                    approvalHandle(processNodeButtonList, ProcessNodeGroupByParentId, processNode);
+                    break;
+
+                case HANDLE: // 办理
+                    handle(processNodeButtonList, ProcessNodeGroupByParentId, processNode);
+                    break;
+
+                case END: // 结束
+                    break;
+
+            }
+        }
+    }
+
+    /**
+     * 开始节点处理
+     */
+    private void startHandle(List<ProcessNodeButton> processNodeButtonList,
+                             Map<Long, List<ProcessNode>> ProcessNodeGroupByParentId, ProcessNode processNode) {
+        // 下一步
+        ProcessNodeButton next = next(ProcessNodeGroupByParentId, processNode, ButtonNameEnum.ADOPT);
+        processNodeButtonList.add(next);
+    }
+
+    /**
+     * 审核处理
+     */
+    private void examinedHandle(List<ProcessNodeButton> processNodeButtonList,
+                                Map<Long, List<ProcessNode>> ProcessNodeGroupByParentId, ProcessNode processNode) {
+        // 通过
+        ProcessNodeButton next = next(ProcessNodeGroupByParentId, processNode, ButtonNameEnum.ADOPT);
+        processNodeButtonList.add(next);
+        // 驳回
+        ProcessNodeButton previous = previous(ProcessNodeGroupByParentId, processNode, ButtonNameEnum.FAIL);
+        processNodeButtonList.add(previous);
+    }
+
+    /**
+     * 审批处理
+     */
+    private void approvalHandle(List<ProcessNodeButton> processNodeButtonList,
+                                Map<Long, List<ProcessNode>> ProcessNodeGroupByParentId, ProcessNode processNode) {
+        // 同意
+        ProcessNodeButton next = next(ProcessNodeGroupByParentId, processNode, ButtonNameEnum.AGREE);
+        processNodeButtonList.add(next);
+        // 驳回
+        ProcessNodeButton over = over(processNode, ButtonNameEnum.REJECT);
+        processNodeButtonList.add(over);
+    }
+
+    /**
+     * 办理处理
+     */
+    private void handle(List<ProcessNodeButton> processNodeButtonList,
+                        Map<Long, List<ProcessNode>> ProcessNodeGroupByParentId, ProcessNode processNode) {
+        // 完成
+        ProcessNodeButton next = next(ProcessNodeGroupByParentId, processNode, ButtonNameEnum.complete);
+        processNodeButtonList.add(next);
+    }
+
+    /**
+     * 跳转下一节点
+     */
+    private ProcessNodeButton next(Map<Long, List<ProcessNode>> ProcessNodeGroupByParentId,
+                                   ProcessNode processNode, ButtonNameEnum buttonNameEnum) {
+
+        ProcessNodeButton processNodeButton = createProcessNodeButton(processNode, buttonNameEnum);
+
+        // 赋值跳转到下一节点
+        List<ProcessNode> nextProcessNodeList = ProcessNodeGroupByParentId.get(processNode.getId());
+        if (nextProcessNodeList == null) {
+            throw new ServiceException(String.format(FlowExplainConstant.JUMP_EMPTY, processNode.getName()));
+        }
+        if (nextProcessNodeList.size() == 1) {
+            ProcessNode itemProcessNode = nextProcessNodeList.get(0);
+            if (itemProcessNode.getType().equals(ProcessNodeTypeEnum.END.getType())) {
+                processNodeButton.setJumpNodeId(FlowConstant.OVER_PROCESS_FLAG);
+            } else {
+                processNodeButton.setJumpNodeId(itemProcessNode.getId());
+            }
+        }
+        return processNodeButton;
+    }
+
+
+    /**
+     * 跳转上一节点
+     */
+    private ProcessNodeButton previous(Map<Long, List<ProcessNode>> ProcessNodeGroupByParentId,
+                                       ProcessNode processNode, ButtonNameEnum buttonNameEnum) {
+
+        ProcessNodeButton processNodeButton = createProcessNodeButton(processNode, buttonNameEnum);
+
+        // 赋值跳转到上一节点
+        List<ProcessNode> previousProcessNodeList = ProcessNodeGroupByParentId.get(processNode.getParentId());
+
+        if (previousProcessNodeList == null || previousProcessNodeList.size() != 1) {
+            throw new ServiceException(String.format(FlowExplainConstant.PREVIOUS_ERROR, processNode.getName()));
+        }
+
+        processNodeButton.setJumpNodeId(previousProcessNodeList.get(0).getId());
+
+        return processNodeButton;
+    }
+
+    /**
+     * 结束流程
+     */
+    private ProcessNodeButton over(ProcessNode processNode, ButtonNameEnum buttonNameEnum) {
+
+        ProcessNodeButton processNodeButton = createProcessNodeButton(processNode, buttonNameEnum);
+
+        processNodeButton.setJumpNodeId(FlowConstant.OVER_PROCESS_FLAG);
+        return processNodeButton;
+    }
+
+    /**
+     * 创建按钮
+     */
+    private ProcessNodeButton createProcessNodeButton(ProcessNode processNode, ButtonNameEnum buttonNameEnum) {
+        ProcessNodeButton processNodeButton = new ProcessNodeButton();
+        processNodeButton.setProcessInfoId(processNode.getProcessInfoId());
+        processNodeButton.setProcessNodeId(processNode.getId());
+        processNodeButton.setProcessNodeCode(processNode.getCode());
+        processNodeButton.setNameType(buttonNameEnum.getType());
+        return processNodeButton;
+    }
+
 }

hx-service-api/service-flow-api/src/main/java/com/fjhx/constants/ProcessConstant.java → hx-service-api/service-flow-api/src/main/java/com/fjhx/constants/FlowConstant.java

@@ -3,7 +3,7 @@ package com.fjhx.constants;
 /**
  * 节点常量
  */
-public interface ProcessConstant {
+public interface FlowConstant {
 
     /**
      * 开始节点名称
@@ -30,4 +30,9 @@ public interface ProcessConstant {
      */
     Integer DEFAULT_VERSION_NUMBER = 1;
 
+    /**
+     * 跳转节点为结束标识
+     */
+    Long OVER_PROCESS_FLAG = -1L;
+
 }

hx-service-api/service-flow-api/src/main/java/com/fjhx/constants/FlowExplainConstant.java

@@ -5,7 +5,12 @@ package com.fjhx.constants;
  */
 public interface FlowExplainConstant {
 
-    String CODE_EMPTY = "编码不能为空";
+    /*
+    流程
+     */
+    String CODE_EMPTY = "流程编码不能为空";
+
+    String PROCESS_NAME = "流程名称不能为空";
 
     String PROCESS_EXIST = "流程已存在";
 
@@ -13,6 +18,28 @@ public interface FlowExplainConstant {
 
     String MODULE_NAME_EMPTY = "模块名称不能为空";
 
-    String PROCESS_NAME = "流程名称不能为空";
+    String PROCESS_INFO_ID_EMPTY = "流程id不能为空";
+
+    /*
+    节点
+     */
+    String NODE_TYPE = "节点类型不能为空";
+
+    String NODE_PARENT_ID = "父节点id不能为空";
+
+    String NODE_NAME = "节点名称不能为空";
+
+    String HANDLE_OBJECT_TYPE = "发起 / 处理对象类型不能为空";
+
+    String HANDLE_OBJECT_ID_LIST = "发起 / 处理对象id集合不能为空";
+
+    String NODE_UNKNOWN = "未知节点类型";
+
+    /*
+     按钮
+     */
+    String JUMP_EMPTY = "名称为 %s 的节点没有找到跳转节点";
+
+    String PREVIOUS_ERROR = "名称为 %s 的上级节点配置异常";
 
 }

hx-service-api/service-flow-api/src/main/java/com/fjhx/entity/process/ProcessNode.java

@@ -26,12 +26,12 @@ public class ProcessNode implements Serializable {
     private Long id;
 
     /**
-     * 类型 1开始 2流转 3结束
+     * 类型 0开始1审核 2审批 3办理 99结束
      */
     private Integer type;
 
     /**
-     * 流程id
+     * 所属流程id
      */
     private Long processInfoId;
 
@@ -41,12 +41,12 @@ public class ProcessNode implements Serializable {
     private Long parentId;
 
     /**
-     * 流程节点名称
+     * 节点名称
      */
     private String name;
 
     /**
-     * 流程节点编码
+     * 节点编码
      */
     private String code;
 

hx-service-api/service-flow-api/src/main/java/com/fjhx/entity/process/ProcessNodeHandle.java → hx-service-api/service-flow-api/src/main/java/com/fjhx/entity/process/ProcessNodeButton.java

@@ -15,7 +15,7 @@ import java.io.Serializable;
  * @since 2022-08-12
  */
 @Data
-public class ProcessNodeHandle implements Serializable {
+public class ProcessNodeButton implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
@@ -26,19 +26,29 @@ public class ProcessNodeHandle implements Serializable {
     private Long id;
 
     /**
-     * 流程id
+     * 所属流程id
      */
     private Long processInfoId;
 
     /**
-     * 流程节点id
+     * 所属节点id
      */
     private Long processNodeId;
 
     /**
+     * 所属节点编码
+     */
+    private String processNodeCode;
+
+    /**
+     * 按钮名称类型
+     */
+    private Integer nameType;
+
+    /**
      * 处理类型
      */
-    private Integer type;
+    private Long jumpNodeId;
 
     /**
      * 通知模板

hx-service-api/service-flow-api/src/main/java/com/fjhx/enums/ButtonNameEnum.java

@@ -0,0 +1,52 @@
+package com.fjhx.enums;
+
+import lombok.Getter;
+
+import java.util.HashMap;
+
+/**
+ * 按钮名称
+ */
+@Getter
+public enum ButtonNameEnum {
+
+    // 审核
+    ADOPT(1, "通过"),
+    FAIL(2, "不通过"),
+    // 审批
+    AGREE(3, "同意"),
+    REJECT(4, "驳回"),
+    // 办理
+    complete(5, "完成");
+
+    private final Integer type;
+    private final String name;
+
+    private static final HashMap<Integer, ButtonNameEnum> map = new HashMap<>();
+
+    ButtonNameEnum(Integer type, String name) {
+        this.type = type;
+        this.name = name;
+    }
+
+    static {
+        for (ButtonNameEnum value : ButtonNameEnum.values()) {
+            map.put(value.getType(), value);
+        }
+    }
+
+    /**
+     * 根据type获取枚举
+     */
+    public static ButtonNameEnum get(Integer type) {
+        return map.get(type);
+    }
+
+    /**
+     * 根据type值获取枚举
+     */
+    public static String getName(Integer type) {
+        return map.get(type).getName();
+    }
+
+}

hx-service-api/service-flow-api/src/main/java/com/fjhx/enums/ProcessInfoParallelRulesEnum.java

@@ -8,11 +8,11 @@ import lombok.Getter;
 @Getter
 public enum ProcessInfoParallelRulesEnum {
 
-    no(0), // 无规则
-    business(1), // 业务禁止并行
-    user(2), // 用户禁止并行
-    role(3), // 角色禁止并行
-    dept(4), // 部门禁止并行
+    NO(0), // 无规则
+    BUSINESS(1), // 业务禁止并行
+    USER(2), // 用户禁止并行
+    ROLE(3), // 角色禁止并行
+    DEPT(4), // 部门禁止并行
     ;
 
     private final Integer type;

hx-service-api/service-flow-api/src/main/java/com/fjhx/enums/ProcessNodeHandleObjectTypeEnum.java

@@ -8,10 +8,10 @@ import lombok.Getter;
 @Getter
 public enum ProcessNodeHandleObjectTypeEnum {
 
-    all(0), // 全部
-    user(1), // 指定用户
-    role(2), // 指定角色
-    dept(3), // 指定部门
+    ALL(0), // 全部
+    USER(1), // 指定用户
+    ROLE(2), // 指定角色
+    DEPT(3), // 指定部门
     ;
 
     private final Integer type;

hx-service-api/service-flow-api/src/main/java/com/fjhx/enums/ProcessNodeTypeEnum.java

@@ -2,21 +2,40 @@ package com.fjhx.enums;
 
 import lombok.Getter;
 
+import java.util.HashMap;
+
 /**
  * 流程节点类型枚举
  */
 @Getter
 public enum ProcessNodeTypeEnum {
 
-    start(1), // 开始节点
-    roam(2), // 流转流转节点
-    end(3) // 结束节点
+    START(0), // 开始节点
+    EXAMINED(1), // 审核（可以进行通过/不通过操作，通过后流程向下一节点流转，不通过则退回上一节点）
+    APPROVAL(2), // 审批（可以进行同意/驳回操作，同意后向下一节点流转，驳回则以驳回状态结束本流程）
+    HANDLE(3), // 办理（仅支持完成办理操作，操作后向下一节点流转）
+    END(99) // 结束节点
     ;
 
     private final Integer type;
 
+    private static final HashMap<Integer, ProcessNodeTypeEnum> map = new HashMap<>();
+
     ProcessNodeTypeEnum(Integer type) {
         this.type = type;
     }
 
+    static {
+        for (ProcessNodeTypeEnum value : ProcessNodeTypeEnum.values()) {
+            map.put(value.getType(), value);
+        }
+    }
+
+    /**
+     * 根据type值获取枚举
+     */
+    public static ProcessNodeTypeEnum get(Integer type) {
+        return map.get(type);
+    }
+
 }

hx-service-api/service-flow-api/src/main/java/com/fjhx/params/process/ProcessNodeVo.java

@@ -4,9 +4,15 @@ import com.fjhx.entity.process.ProcessNode;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
+import java.util.List;
+
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class ProcessNodeVo extends ProcessNode {
 
+    /**
+     * 处理对象id集合
+     */
+    private List<String> handleObjectIdList;
 
 }

hx-service-api/service-flow-api/src/main/java/com/fjhx/params/process/ProcessObject.java

@@ -6,7 +6,7 @@ import lombok.Data;
 import java.util.List;
 
 @Data
-public class ProcessObject {
+public class  ProcessObject {
 
     // 流程
     private ProcessInfo processInfo;