Flowable根据任务id、参数，预测、获取下一任务节点集合、候选用户集合、候选组集合、参与用户id集合等

时间：2025-03-11 18:05:36

根据任务id、参数，预测、获取下一任务节点集合、候选用户集合、候选组集合、参与用户id集合等。

List<UserTaskVo> nextUserTasks = (taskId, variableMap);

  1. Service

1.1 NewProcessService
package ;

import ;

import ;
import ;

public interface NewProcessService {

    /**
     * 获取el表达式的值
     * @param exp el表达式
     * @param variableMap map参数
     * @return true/false
     */
    boolean getElValue(String exp, Map<String, Object> variableMap);

    /**
     * 获取el表达式的值
     * @param processInstanceId 流程实例id
     * @param exp el表达式
     * @param variableMap map参数
     * @return true/false
     */
    boolean getElValue(String processInstanceId, String exp, Map<String, Object> variableMap);

    /**
     * 获取el表达式的值
     * @param taskId 流程任务id
     * @param exp el表达式
     * @param variableMap map参数
     * @return true/false
     */
    boolean getElValueByTaskId(String taskId, String exp, Map<String, Object> variableMap);

    /**
     * 获取skip是否跳过节点el表达式的值
     * @param exp el表达式
     * @param variableMap map参数
     * @return true 跳过节点/false 不跳过节点
     */
    boolean getSkipElValue(String exp, Map<String, Object> variableMap);

    /**
     * 根据参数，预测、获取下一任务节点集合
     *
     * @param taskId 任务id
     * @param variables 参数
     * @return 下一任务节点集合
     */
    List<UserTaskVo> getNextUserTasks(String taskId, Map<String, Object> variables);

    /**
     * 根据参数，预测、获取下一任务节点集合
     *
     * @param taskId 任务id
     * @param code 业务ID
     * @param variables 参数
     * @return 下一任务节点集合
     */
    List<UserTaskVo> getNextUserTasks(String taskId, String code, Map<String, Object> variables);

}

  1. ServiceImpl

2.1 NewProcessServiceImpl
package ;

import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import org.;
import org.;
import ;
import ;
import ;
import ;
import ;

import ;
import ;
import ;
import ;
import ;
import ;

@Service
public class NewProcessServiceImpl implements NewProcessService {

    protected Logger log = (());

    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private HistoryService historyService;
    @Autowired
    private RepositoryService repositoryService;
    @Autowired
    private ProcessEngine processEngine;
    @Autowired
    private TaskService taskService;
    @Autowired
    private IdentityService identityService;

    @Autowired
    private VUserGroupMapper vUserGroupMapper;

    @Autowired
    private ActRuVariableMapper actRuVariableMapper;

    @Override
    public boolean getElValue(String exp, Map<String, Object> variableMap) {
        return (null, exp, variableMap);
    }

    @Override
    public boolean getElValue(String processInstanceId, String exp, Map<String, Object> variableMap) {
        if ((exp)) {
            return true;
        }

        ManagementService managementService = ();
        boolean flag = (new ExpressionCmd(processEngine, processInstanceId, exp, variableMap));

        //删除垃圾数据
        ();
        return flag;
    }

    @Override
    public boolean getElValueByTaskId(String taskId, String exp, Map<String, Object> variableMap) {
        if ((exp)) {
            return true;
        }

        Map<String, Object> variables = (taskId);
        (variableMap);

        ManagementService managementService = ();
        boolean flag = (new ExpressionCmd(exp, variables));

        //删除垃圾数据
        ();
        return flag;
    }

    @Override
    public boolean getSkipElValue(String exp, Map<String, Object> variableMap) {
        //表达式为空，节点不跳过
        if ((exp)) {
            return false;
        }

        //skip：true 跳过节点/false 不跳过节点
        boolean skip = false;
        Map<String, Object> variables = new HashMap<>(variableMap);
        Object flowableSkipExpressionEnabled = ("_FLOWABLE_SKIP_EXPRESSION_ENABLED");
        //流程参数含有_FLOWABLE_SKIP_EXPRESSION_ENABLED，且为true时，表示FLOWABLE跳过表达式已启用
        if (null != flowableSkipExpressionEnabled && "true".equals(())) {
            //返回true，表示跳过该任务节点；
            ManagementService managementService = ();
            skip = (new ExpressionCmd(exp, variables));

            //删除垃圾数据
            ();
        }

        return skip;
    }

    public void deleteException(){
        //删除垃圾数据
        ();
        ();
    }

    /**
     * 获取下一任务节点集合
     *
     * @param taskId 任务id
     * @param variables 参数
     * @return 下一任务节点集合
     */
    @Override
    public List<UserTaskVo> getNextUserTasks(String taskId, Map<String, Object> variables) {
        return (taskId, null, variables);
    }

    @Override
    public List<UserTaskVo> getNextUserTasks(String taskId, String code, Map<String, Object> variables) {
        if ((taskId)) {
            return new ArrayList<>();
        }

        Task task = ().taskId(taskId).singleResult();
        if (null == task) {
            return new ArrayList<>();
        }

        Map<String, Object> variableMap = (());
        (variables);

        String procId = "";
        ProcessDefinition processDefinition = ()
                .processDefinitionId(()).singleResult();
        if (null != processDefinition) {
            procId = ();
        }

        List<UserTaskVo> userTasks = new ArrayList<>();

        List<FlowElement> nextFlowNodes = (task, variableMap);
        for (FlowElement nextFlowNode : nextFlowNodes) {
            List<String> candidateUserIdList = new ArrayList<>(); //参与用户id
            List<CandidateUserVo> candidateUsers = new ArrayList<>(); //候选用户
            List<CandidateGroupVo> candidateGroups = new ArrayList<>(); //候选组

            UserTask flowElement = (UserTask) nextFlowNode;
            String flowId = ();
            String flowName = ();
            String assignee = ();

            if ((assignee)) {
                // 节点分配给了具体参与者
                String key = (assignee);
                Object userIdStr = (key);
                if (null != userIdStr && (())) {
                    // 节点分配给了具体参与者
                    String userId = ();
                    String userName = "";
                    User user = ().userId(userId).singleResult();
                    if (null != user) {
                        userName = ();
                    }
                    (userId);
                    (new CandidateUserVo(userId, userName));
                }

            } else {

                // 候选用户
                for (String candidateUser : ()) {
                    String key = (candidateUser);
                    Object userIdStr = (key);
                    if (null != userIdStr && (())) {
                        //value可能是集合
                        List<String> userIds = (userIdStr);
                        for (String userId : userIds) {
                            String userName = "";
                            User user = ().userId(userId).singleResult();
                            if (null != user) {
                                userName = ();
                            }
                            (userId);
                            (new CandidateUserVo(userId, userName));
                        }
                    }
                }

                //候选组
                for (String candidateGroup : ()) {
                    String key = (candidateGroup);
                    Object groupIdStr = (key);
                    if (null != groupIdStr && (())) {
                        //value可能是集合
                        List<String> groupIds = (groupIdStr);
                        for (String groupId : groupIds) {
                            String groupName = "";
                            Group group = ().groupId(groupId).singleResult();
                            if (null != group) {
                                groupName = ();
                            }

                            (new CandidateGroupVo(groupId, groupName));

                            // 查询候选组用户id
                             builderGroup = new ();
                            // 条件
                            Sqls sqlGroup = ();
                            ("groupId", groupId);
                            (sqlGroup);
                            List<VUserGroup> vUserGroupList = (());
                            if (!(vUserGroupList)) {
                                for (VUserGroup vUserGroup : vUserGroupList) {
                                    (());
                                }
                            }
                        }
                    }
                }
            }

            UserTaskVo userTask = new UserTaskVo(null, flowId, flowName, procId, code,
                    candidateUserIdList, candidateUsers, candidateGroups);
            (userTask);
        }

        return userTasks;
    }

    /**
     * 获取下一任务节点集合
     *
     * @param taskId 任务id
     * @param variables 参数
     * @return 下一任务节点集合
     */
    public List<FlowElement> getNextFlowNodes(String taskId, Map<String, Object> variables) {
        if ((taskId)) {
            return new ArrayList<>();
        }

        Task task = ().taskId(taskId).singleResult();
        if (null == task) {
            return new ArrayList<>();
        }

        Map<String, Object> variableMap = (());
        (variables);

        return (task, variableMap);
    }

    /**
     * 获取下一任务节点集合
     *
     * @param task 当前任务
     * @param variables 参数
     * @return 下一任务节点集合
     */
    public List<FlowElement> getNextFlowNodes(Task task, Map<String, Object> variables) {
        if (null == task) {
            return new ArrayList<>();
        }

        // 当前审批节点
        String currentActivityId = (); //当前环节id
        BpmnModel bpmnModel = (());

        //复制一份
        List<FlowElement> flowElements = new ArrayList<>(().getFlowElements());
        List<FlowElement> nextElements = new ArrayList<>();

        FlowNode flowNode = (FlowNode) (currentActivityId);
        // 输出连线
        List<SequenceFlow> outFlows = ();

        FlowElement targetElement;
        List<SequenceFlow> sequenceFlows = (variables, outFlows);
        for (SequenceFlow sequenceFlow : sequenceFlows) {
            targetElement = (flowElements, ());
            (nextElements, flowElements, targetElement, variables);
        }
        return nextElements;
    }

    /**
     * 获取下一环节任务节点集合
     */
    private void getNextElementList(List<FlowElement> nextElements, Collection<FlowElement> flowElements, FlowElement curFlowElement, Map<String, Object> variableMap) {
        if (null == curFlowElement) {
            return;
        }

        // 任务节点
        if (curFlowElement instanceof UserTask) {
            (nextElements, flowElements, curFlowElement, variableMap);
            return;
        }
        // 排他网关
        if (curFlowElement instanceof ExclusiveGateway) {
            (nextElements, flowElements, curFlowElement, variableMap);
            return;
        }
        // 并行网关
        if (curFlowElement instanceof ParallelGateway) {
            (nextElements, flowElements, curFlowElement, variableMap);
        }
        // 包含网关
        if (curFlowElement instanceof InclusiveGateway) {
            (nextElements, flowElements, curFlowElement, variableMap);
        }
        // 事件网关
        if (curFlowElement instanceof EventGateway) {
            (nextElements, flowElements, curFlowElement, variableMap);
        }
    }

    /**
     * 任务节点
     */
    private void dueUserTaskElement(List<FlowElement> nextElements, Collection<FlowElement> flowElements, FlowElement curFlowElement, Map<String, Object> variableMap) {
        UserTask userTask = (UserTask) curFlowElement;
        //skip：true 跳过节点/false 不跳过节点
        boolean skip = ((), variableMap);
        if (!skip) {
            //不跳过节点，
            (curFlowElement);
        } else {

            //跳过节点，查询下一节点
            List<SequenceFlow> outgoingFlows = ();
            if (() > 0) {
                String targetRef = (0).getTargetRef();
                if (() > 1) {
                    // 找到表达式成立的sequenceFlow
                    SequenceFlow sequenceFlow = getSequenceFlow(variableMap, outgoingFlows);
                    targetRef = ();
                }
                // 根据ID找到FlowElement
                FlowElement targetElement = (flowElements, targetRef);
                (nextElements, flowElements, targetElement, variableMap);
            }
        }
    }

    /**
     * 排他网关
     */
    private void dueExclusiveGateway(List<FlowElement> nextElements, Collection<FlowElement> flowElements, FlowElement curFlowElement, Map<String, Object> variableMap) {
        // 获取符合条件的sequenceFlow的目标FlowElement
        List<SequenceFlow> exclusiveGatewayOutgoingFlows = ((ExclusiveGateway) curFlowElement).getOutgoingFlows();
        (curFlowElement);
        // 找到表达式成立的sequenceFlow
        SequenceFlow sequenceFlow = (variableMap, exclusiveGatewayOutgoingFlows);
        // 根据ID找到FlowElement
        FlowElement targetElement = (flowElements, ());
        (nextElements, flowElements, targetElement, variableMap);
    }

    /**
     * 并行网关
     */
    private void dueParallelGateway(List<FlowElement> nextElements, Collection<FlowElement> flowElements, FlowElement curFlowElement, Map<String, Object> variableMap) {
        FlowElement targetElement;
        List<SequenceFlow> parallelGatewayOutgoingFlows = ((ParallelGateway) curFlowElement).getOutgoingFlows();
        for (SequenceFlow sequenceFlow : parallelGatewayOutgoingFlows) {
            targetElement = (flowElements, ());
            (nextElements, flowElements, targetElement, variableMap);
        }
    }

    /**
     * 包含网关
     */
    private void dueInclusiveGateway(List<FlowElement> nextElements, Collection<FlowElement> flowElements, FlowElement curFlowElement, Map<String, Object> variableMap) {
        FlowElement targetElement;
        List<SequenceFlow> inclusiveGatewayOutgoingFlows = ((InclusiveGateway) curFlowElement).getOutgoingFlows();
        List<SequenceFlow> sequenceFlows = (variableMap, inclusiveGatewayOutgoingFlows);
        for (SequenceFlow sequenceFlow : sequenceFlows) {
            targetElement = (flowElements, ());
            (nextElements, flowElements, targetElement, variableMap);
        }
    }

    /**
     * 事件网关
     */
    private void dueEventGateway(List<FlowElement> nextElements, Collection<FlowElement> flowElements, FlowElement curFlowElement, Map<String, Object> variableMap) {
    }

    /**
     * 根据ID找到FlowElement
     * @param flowElements 流程节点集合
     * @param targetRef id
     * @return FlowElement
     */
    private FlowElement getFlowElement(Collection<FlowElement> flowElements, String targetRef) {
        return ().filter(flowElement -> (())).findFirst().orElse(null);
    }

    /**
     * 根据传入的变量，计算出表达式成立的那一条SequenceFlow
     *
     * @param variableMap   变量map
     * @param outgoingFlows 输出流
     * @return SequenceFlow连线
     */
    private SequenceFlow getSequenceFlow(Map<String, Object> variableMap, List<SequenceFlow> outgoingFlows) {
        List<SequenceFlow> sequenceFlows = (variableMap, outgoingFlows);
        if (null != sequenceFlows && () > 0) {
            return (0);
        }

        return (0);
    }

    /**
     * 根据传入的变量，计算出表达式成立的SequenceFlow连线集合
     *
     * @param variableMap   变量map
     * @param outgoingFlows 输出流
     * @return SequenceFlow连线集合
     */
    private List<SequenceFlow> getSequenceFlows(Map<String, Object> variableMap, List<SequenceFlow> outgoingFlows) {
        List<SequenceFlow> sequenceFlows;
        sequenceFlows = ().filter(item -> {
            try {
                return ((), variableMap);
            } catch (Exception e) {
                ();
                return false;
            }
        }).collect(());
        return sequenceFlows;
    }

}

  1. command

  1. ExpressionCmd
package ;

import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;

import ;
import ;
import ;

/**
 * 表达式
 */
public class ExpressionCmd implements Command<Boolean>, Serializable {

    protected ProcessEngine processEngine;

    protected String processInstanceId;

    protected String exp;

    protected Map<String, Object> variableMap;

    public ExpressionCmd(String exp, Map<String, Object> variableMap) {
         = exp;
         = variableMap;
    }

    public ExpressionCmd(ProcessEngine processEngine, String processInstanceId, String exp, Map<String, Object> variableMap) {
         = processEngine;
         = processInstanceId;
         = exp;
         = variableMap;
    }

    @Override
    public Boolean execute(CommandContext commandContext) {
        //表达式为空时，直接返回true
        if (()) {
            return ;
        }

        //复制一份
        Map<String, Object> variables = new HashMap<>();
        Expression expression = ().createExpression();

        //流程实例id不为空
        if (()) {
            RuntimeService runtimeService = ();
            ExecutionEntity processExecutionEntity = (ExecutionEntity) ().processInstanceId().includeProcessVariables().singleResult();
            if (null != processExecutionEntity) {
                //流程实例参数
                Map<String, Object> processVariables = ();
                if (null != processVariables) {
                    ();

                    variables = processVariables;
                }
            }
        }

        ExecutionEntity executionEntity = new ExecutionEntityImpl();
        (variables);

        Object value = (executionEntity);
        return value != null && "true".equals(());
    }

}

  1. mapper

  1. ActRuVariableMapper
package ;

import ;
import ;

public interface ActRuVariableMapper extends MyMapper<ActRuVariable> {

    /**
     * 删除运行变量（异常）
     */
    int deleteRuVariableException();

    /**
     * 删除历史变量（异常）
     */
    int deleteHiVariableException();

}

  1. mapperXML

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/">
<mapper namespace="">
    <resultMap  type="">
        <!--
          WARNING - @
        -->
        <id column="ID_" jdbcType="VARCHAR" property="id"/>
        <result column="REV_" jdbcType="INTEGER" property="rev"/>
        <result column="TYPE_" jdbcType="VARCHAR" property="type"/>
        <result column="NAME_" jdbcType="VARCHAR" property="name"/>
        <result column="EXECUTION_ID_" jdbcType="VARCHAR" property="executionId"/>
        <result column="PROC_INST_ID_" jdbcType="VARCHAR" property="procInstId"/>
        <result column="TASK_ID_" jdbcType="VARCHAR" property="taskId"/>
        <result column="SCOPE_ID_" jdbcType="VARCHAR" property="scopeId"/>
        <result column="SUB_SCOPE_ID_" jdbcType="VARCHAR" property="subScopeId"/>
        <result column="SCOPE_TYPE_" jdbcType="VARCHAR" property="scopeType"/>
        <result column="BYTEARRAY_ID_" jdbcType="VARCHAR" property="bytearrayId"/>
        <result column="DOUBLE_" jdbcType="DOUBLE" property="double_"/>
        <result column="LONG_" jdbcType="BIGINT" property="long_"/>
        <result column="TEXT_" jdbcType="VARCHAR" property="text_"/>
        <result column="TEXT2_" jdbcType="VARCHAR" property="text2_"/>
    </resultMap>

    <delete >
        delete from ACT_RU_VARIABLE where EXECUTION_ID_ is null
    </delete>

    <delete >
        delete from act_hi_varinst where EXECUTION_ID_ is null
    </delete>

</mapper>

  1. model

  1. ActRuVariable
package ;

import ;
import ;
import ;
import ;
import ;

/**
 * 流程运行变量
 */
@Table(name = "act_ru_variable")
public class ActRuVariable implements Serializable {

    @Id
    @Column(name = "ID_")
    private String id;

    @Column(name = "REV_")
    private BigDecimal rev;

    @Column(name = "TYPE_")
    private String type;

    @Column(name = "NAME_")
    private String name;

    @Column(name = "EXECUTION_ID_")
    private String executionId;

    @Column(name = "PROC_INST_ID_")
    private String procInstId;

    @Column(name = "TASK_ID_")
    private String taskId;

    @Column(name = "SCOPE_ID_")
    private String scopeId;

    @Column(name = "SUB_SCOPE_ID_")
    private String subScopeId;

    @Column(name = "SCOPE_TYPE_")
    private String scopeType;

    @Column(name = "BYTEARRAY_ID_")
    private String bytearrayId;

    @Column(name = "DOUBLE_")
    private Double double_;

    @Column(name = "LONG_")
    private Long long_;

    @Column(name = "TEXT_")
    private String text_;

    @Column(name = "TEXT2_")
    private String text2_;

    /**
     * @return ID_
     */
    public String getId() {
        return id;
    }

    /**
     * @param id
     */
    public void setId(String id) {
         = id;
    }

    /**
     * @return REV_
     */
    public BigDecimal getRev() {
        return rev;
    }

    /**
     * @param rev
     */
    public void setRev(BigDecimal rev) {
         = rev;
    }

    /**
     * @return TYPE_
     */
    public String getType() {
        return type;
    }

    /**
     * @param type
     */
    public void setType(String type) {
         = type;
    }

    /**
     * @return NAME_
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     */
    public void setName(String name) {
         = name;
    }

    /**
     * @return EXECUTION_ID_
     */
    public String getExecutionId() {
        return executionId;
    }

    /**
     * @param executionId
     */
    public void setExecutionId(String executionId) {
         = executionId;
    }

    /**
     * @return PROC_INST_ID_
     */
    public String getProcInstId() {
        return procInstId;
    }

    /**
     * @param procInstId
     */
    public void setProcInstId(String procInstId) {
         = procInstId;
    }

    /**
     * @return TASK_ID_
     */
    public String getTaskId() {
        return taskId;
    }

    /**
     * @param taskId
     */
    public void setTaskId(String taskId) {
         = taskId;
    }

    /**
     * @return SCOPE_ID_
     */
    public String getScopeId() {
        return scopeId;
    }

    /**
     * @param scopeId
     */
    public void setScopeId(String scopeId) {
         = scopeId;
    }

    /**
     * @return SUB_SCOPE_ID_
     */
    public String getSubScopeId() {
        return subScopeId;
    }

    /**
     * @param subScopeId
     */
    public void setSubScopeId(String subScopeId) {
         = subScopeId;
    }

    /**
     * @return SCOPE_TYPE_
     */
    public String getScopeType() {
        return scopeType;
    }

    /**
     * @param scopeType
     */
    public void setScopeType(String scopeType) {
         = scopeType;
    }

    /**
     * @return BYTEARRAY_ID_
     */
    public String getBytearrayId() {
        return bytearrayId;
    }

    /**
     * @param bytearrayId
     */
    public void setBytearrayId(String bytearrayId) {
         = bytearrayId;
    }

    /**
     * @return DOUBLE_
     */
    public Double getDouble_() {
        return double_;
    }

    /**
     * @param double_
     */
    public void setDouble_(Double double_) {
        this.double_ = double_;
    }

    /**
     * @return LONG_
     */
    public Long getLong_() {
        return long_;
    }

    /**
     * @param long_
     */
    public void setLong_(Long long_) {
        this.long_ = long_;
    }

    /**
     * @return TEXT_
     */
    public String getText_() {
        return text_;
    }

    /**
     * @param text_
     */
    public void setText_(String text_) {
        this.text_ = text_;
    }

    /**
     * @return TEXT2_
     */
    public String getText2_() {
        return text2_;
    }

    /**
     * @param text2_
     */
    public void setText2_(String text2_) {
        this.text2_ = text2_;
    }
}
  1. Tasklist
package ;

import ;
import ;
import ;
import ;
import ;
import ;
import ;

@Table(name = "v_tasklist")
public class Tasklist implements Serializable {
    private static final long serialVersionUID = 1L;
    @Column(name = "TASK_ID")
    private String taskId;
    @Column(name = "PROC_INST_ID")
    private String procInstId;
    @Column(name = "ACT_ID")
    private String actId;
    @Column(name = "ACT_NAME")
    private String actName;
    @Column(name = "ASSIGNEE")
    private String assignee;
    @Column(name = "DELEGATION_ID")
    private String delegationId;
    @Column(name = "DESCRIPTION")
    private String description;
    @Column(name = "CREATE_TIME")
    private Date createTime;
    @Column(name = "DUE_DATE")
    private Date dueDate;
    @Column(name = "CANDIDATE")
    private String candidate;
    @Column(name = "PROC_ID")
    private String procId;
    @Column(name = "CODE")
    private String code;
    @Column(name = "SUSPENSION_STATE")
    private Integer suspensionState;
    @Transient
    private Integer taskCount;
    @Transient
    private Set<String> authProjects;
    @Transient
    private Set<String> noAuthProjects;
    @Transient
    private List<Object> businessList;

    public Set<String> getAuthProjects() {
        return ;
    }

    public void setAuthProjects(Set<String> authProjects) {
         = authProjects;
    }

    public Set<String> getNoAuthProjects() {
        return ;
    }

    public void setNoAuthProjects(Set<String> noAuthProjects) {
         = noAuthProjects;
    }

    public Integer getTaskCount() {
        return ;
    }

    public void setTaskCount(Integer taskCount) {
         = taskCount;
    }

    public String getCode() {
        return ;
    }

    public void setCode(String code) {
         = code;
    }

    public String getTaskId() {
        return ;
    }

    public void setTaskId(String taskId) {
         = taskId;
    }

    public String getProcInstId() {
        return ;
    }

    public void setProcInstId(String procInstId) {
         = procInstId;
    }

    public String getActId() {
        return ;
    }

    public void setActId(String actId) {
         = actId;
    }

    public String getActName() {
        return ;
    }

    public void setActName(String actName) {
         = actName;
    }

    public String getAssignee() {
        return ;
    }

    public void setAssignee(String assignee) {
         = assignee;
    }

    public String getDelegationId() {
        return ;
    }

    public void setDelegationId(String delegationId) {
         = delegationId;
    }

    public String getDescription() {
        return ;
    }

    public void setDescription(String description) {
         = description;
    }

    public Date getCreateTime() {
        return ;
    }

    public void setCreateTime(Date createTime) {
         = createTime;
    }

    public Date getDueDate() {
        return ;
    }

    public void setDueDate(Date dueDate) {
         = dueDate;
    }

    public String getCandidate() {
        return ;
    }

    public void setCandidate(String candidate) {
         = candidate;
    }

    public String getProcId() {
        return ;
    }

    public void setProcId(String procId) {
         = procId;
    }

    public Integer getSuspensionState() {
        return ;
    }

    public void setSuspensionState(Integer suspensionState) {
         = suspensionState;
    }

    public List<Object> getBusinessList() {
        return ;
    }

    public void setBusinessList(List<Object> businessList) {
         = businessList;
    }
}

VUserGroup

package ;

import ;
import ;
import ;

@Table(name = "v_user_group")
public class VUserGroup implements Serializable {
    private static final long serialVersionUID = 1L;
    @Column(name = "id")
    private String id;
    @Column(name = "user_name")
    private String userName;
    @Column(name = "group_id")
    private String groupId;
    @Column(name = "group_name")
    private String groupName;
    private String type;

    public VUserGroup() {
    }

    public String getId() {
        return ;
    }

    public void setId(String id) {
         = id;
    }

    public String getUserName() {
        return ;
    }

    public void setUserName(String userName) {
         = userName;
    }

    public String getGroupId() {
        return ;
    }

    public void setGroupId(String groupId) {
         = groupId;
    }

    public String getGroupName() {
        return ;
    }

    public void setGroupName(String groupName) {
         = groupName;
    }

    public String getType() {
        return ;
    }

    public void setType(String type) {
         = type;
    }
}

  1. vo

  1. CandidateGroupVo
package ;

import ;

@SuppressWarnings("serial")
public class CandidateGroupVo implements Serializable {

    private String groupId; //候选组

    private String groupName; //候选组

    public CandidateGroupVo() {
        super();
    }

    public CandidateGroupVo(String groupId, String groupName) {
        super();
         = groupId;
         = groupName;
    }

    public String getGroupId() {
        return groupId;
    }

    public void setGroupId(String groupId) {
         = groupId;
    }

    public String getGroupName() {
        return groupName;
    }

    public void setGroupName(String groupName) {
         = groupName;
    }

}
  1. CandidateUserVo
package ;

import ;

@SuppressWarnings("serial")
public class CandidateUserVo implements Serializable {

    private String userId; //候选用户

    private String userName; //候选用户

    public CandidateUserVo() {
        super();
    }

    public CandidateUserVo(String userId, String userName) {
        super();
         = userId;
         = userName;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
         = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
         = userName;
    }

}
  1. UserTaskVo
package ;

import ;
import ;

import ;
import ;
import ;
import ;
import ;
import ;

@SuppressWarnings("serial")
public class UserTaskVo extends Tasklist {

    /**
     * 拼接任务数量（0）
     */
    @Transient
    private String actConcatName;

    @Transient
    private Long menuId;

    @Transient
    private List<String> candidateUserIdList; //参与用户id

    @Transient
    private List<CandidateUserVo> candidateUsers; //候选用户

    @Transient
    private List<CandidateGroupVo> candidateGroups; //候选组

    public UserTaskVo() {
        super();
    }

    public UserTaskVo(Tasklist tasklist) {
        super();
        (tasklist, this);
         = () + "（" + () + "）";
    }

    public UserTaskVo(String taskId, String actId, String actName, String procId, List<CandidateUserVo> candidateUsers, List<CandidateGroupVo> candidateGroups) {
        this(taskId, actId, actName, procId, null, candidateUsers, candidateGroups);
    }

    public UserTaskVo(String taskId, String actId, String actName, String procId, String code, List<CandidateUserVo> candidateUsers, List<CandidateGroupVo> candidateGroups) {
        this(taskId, actId, actName, procId, code, null, candidateUsers, candidateGroups);
    }

    public UserTaskVo(String taskId, String actId, String actName, String procId, String code, List<String> candidateUserIdList, List<CandidateUserVo> candidateUsers, List<CandidateGroupVo> candidateGroups) {
        super();
        (taskId);
        (actId);
        (actName);
        (procId);
        (code);

        //去重
        if (null != candidateUserIdList && () > 0) {
            candidateUserIdList = ().distinct().collect(());
        }
        if (null != candidateUsers && () > 0) {
            candidateUsers = ().collect(((() -> new TreeSet<>((CandidateUserVo::getUserId))), ArrayList::new));
        }
        if (null != candidateGroups && () > 0) {
            candidateGroups = ().collect(((() -> new TreeSet<>((CandidateGroupVo::getGroupId))), ArrayList::new));
        }
         = candidateUserIdList;
         = candidateUsers;
         = candidateGroups;
    }

    public String getActConcatName() {
        return actConcatName;
    }

    public void setActConcatName(String actConcatName) {
         = actConcatName;
    }

    public Long getMenuId() {
        return menuId;
    }

    public void setMenuId(Long menuId) {
         = menuId;
    }

    public List<String> getCandidateUserIdList() {
        return candidateUserIdList;
    }

    public void setCandidateUserIdList(List<String> candidateUserIdList) {
        //去重
        if (null != candidateUserIdList && () > 0) {
            candidateUserIdList = ().distinct().collect(());
        }
         = candidateUserIdList;
    }

    public List<CandidateUserVo> getCandidateUsers() {
        return candidateUsers;
    }

    public void setCandidateUsers(List<CandidateUserVo> candidateUsers) {
        //去重
        if (null != candidateUsers && () > 0) {
            candidateUsers = ().collect(((() -> new TreeSet<>((CandidateUserVo::getUserId))), ArrayList::new));
        }
         = candidateUsers;
    }

    public List<CandidateGroupVo> getCandidateGroups() {
        return candidateGroups;
    }

    public void setCandidateGroups(List<CandidateGroupVo> candidateGroups) {
        //去重
        if (null != candidateGroups && () > 0) {
            candidateGroups = ().collect(((() -> new TreeSet<>((CandidateGroupVo::getGroupId))), ArrayList::new));
        }
         = candidateGroups;
    }

}

  1. utils

  1. CastUtils
package ;

import ;
import ;

/**
 * 转换工具类
 */
public class CastUtils {

    /**
     * 将obj转换为字符串列表
     * @param obj obj
     * @return 字符串列表
     */
    public static List<String> castObjToStringList(Object obj) {
        if (null == obj) {
            return null;
        }

        List<String> result = new ArrayList<>();
        if (obj instanceof List<?>) {
            for (Object o : (List<?>) obj) {
                (());
            }
        } else if (obj instanceof String) {
            (());
        }

        return result;
    }

    /**
     * obj转list
     * @param obj obj
     * @param clazz clazz
     * @param <T> T
     * @return T
     */
    public static <T> List<T> castList(Object obj, Class<T> clazz) {
        if (null == obj) {
            return null;
        }

        if (obj instanceof List<?>) {
            List<T> result = new ArrayList<>();
            for (Object o : (List<?>) obj) {
                ((o));
            }
            return result;
        }

        return null;
    }

}
  1. VariableUtils
package ;

import ;
import ;

import ;
import ;
import ;

/**
 * 变量工具类
 */
public class VariableUtils {

    /**
     * 格式化变量名，去除${}符号
     * @param variableName 变量名
     * @return 变量名
     */
    public static String formatVariableName(String variableName) {
        variableName = ("[${}]", "").trim();
        return variableName;
    }

    /**
     * 获取格式化后的变量值
     * @param variableType 变量类型
     * @param variableValue 变量值
     * @return 格式化后的变量值
     */
    public static Object getFormatVariableValue(String variableType, String variableValue) {
        if ((variableType)) {
            throw new RuntimeException("变量类型为空！");
        }
        if (!"".equals(variableType) && (variableValue)) {
            throw new RuntimeException("变量值为空！");
        }

        Object value;
        try {
            switch (variableType) {
                case "": //字符串
                    value = variableValue;
                    break;
                case "": //整数
                    value = new Integer(variableValue);
                    break;
                case "": //金额
                    value = new BigDecimal(variableValue);
                    break;
                case "": //列表
                    String[] split = (",");
                    value = new ArrayList<>((split));
                    break;
                default:
                    // 不是以上的类型！但愿可以通过反射注入吧！
                    Class<?> aClass = (variableType);
//                    Constructor<?> constructor = ();
//                    value = (variableValue);

                    value = (variableValue, aClass);
                    break;
            }
        } catch (Exception e) {
            ();

            throw new RuntimeException((), e);
        }

        return value;
    }

}

  1. Test

package ;

import ;
import ;
import ;
import ;
import ;
import ;
import .junit4.SpringJUnit4ClassRunner;

import ;
import ;
import ;

@RunWith()
@SpringBootTest
public class TestFlowable {

    @Autowired
    private NewProcessService newProcessService;

    @Test
    public void getElValueTest() {
        String exp = "${abc == 1}";
        Map<String, Object> variableMap = new HashMap<>();
        ("abc", "1");

        boolean flag = (exp, variableMap);
        (flag);
    }

    @Test
    public void getElValueTest2() {
        String exp = "${halt == 'B'}";
        String taskId = "00b55b40-5904-11ed-acc1-005056b2814b";
        Map<String, Object> variableMap = new HashMap<>();
        ("halt", "B");

        List<UserTaskVo> nextUserTasks = (taskId, variableMap);
        (());
    }

}

相关文章