programs_info/小艾协同/流程图地址/流程从三资开始和保障房合并后搬过来的/activiti/service/ProActiService.java

package com.idea.oa.activiti.service;


import com.idea.oa.activiti.exception.FlowException;
import com.idea.oa.activiti.model.UserTaskMore;
import com.idea.oa.apply.util.constant.ConstantFlowType;
import com.idea.oa.flow2.model.FlowMain;
import com.idea.oa.flow2.model.FlowMainLog;
import com.idea.oa.flow2.model.FlowMainPush;
import com.idea.oa.flow2.model.in.TagerUserAndFlowRole;
import com.idea.oa.flow2.service.FlowMainLogService;
import com.idea.oa.flow2.service.FlowMainService;
import com.rockstar.common.domain.AjaxResult;
import com.rockstar.common.support.Convert;
import com.rockstar.flow.dto.TaskDto;
import com.rockstar.flow.service.FlowService;
import com.rockstar.frame.model.*;
import com.rockstar.frame.service.*;
import com.rockstar.system.model.SysDept;
import com.rockstar.system.service.SysDeptService;
import com.rockstar.util.BeanUtils;
import com.rockstar.util.StringUtils;
import org.activiti.bpmn.model.*;
import org.activiti.bpmn.model.Process;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskInfo;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;


@Service
public class ProActiService {
    @Autowired
    private FlowMainLogService flowMainLogService;
    // 到时候如果先会签,串并联的问题,flowService.runTask和flowService.start判断一下,是否需要串联会签还是并联会签,如果是3的单人签核,1是并联会签,0是串联会签
    @Autowired
    private TaskService taskService;
    @Autowired
    private FlowService flowService;
    @Autowired
    private FlowMainService flowMainService;

    @Autowired
    private FrameUserService userService;
    //
//    @Autowired
//    private FramePostService postService;
//
    @Autowired
    private SysDeptService sysDeptService;
//
//
//    @Autowired
//    private FrameUserDeptService frameUserDeptService;

    @Autowired
    private FrameUserService frameUserService;

    @Autowired
    private FrameRoleDataService frameRoleDataService;

    @Autowired
    private FrameRoleDataUserService frameRoleDataUserService;


    /**
     * ok
     * 删除并结束指定活动实例
     *
     * @param processInstanceId 启动流程的流程对象id
     * @param comments          评论/备注
     */
    @Transactional
    public void endTaskProcess(String processInstanceId, String comments) {
        flowService.deleteInstance(processInstanceId, comments);
    }

    /**
     * ok
     * 启动流程
     * 启动方法时，ActiDto内的必须值是：processType, currentUserId 和 businessId
     *
     * @param actiDto
     * @return
     * @throws FlowException
     */
    @Transactional
    public Map<String, String> startAutoTask(Map<String, Object> actiDto) throws FlowException, com.rockstar.flow.exception.FlowException {
//        processDefine 流程定义 apply_pay
//        dataRole 角色??是传什么?
//        businessId 流程id,就用主流程的id flow_main
//        targetUser 目标人员
//        currUser 当前人员
        String processDefine = "apply_pay";
        FrameUser targetUser = userService.selectByPrimaryKey("1080517374995595264");
        FrameUser currUser = userService.selectByPrimaryKey("1");
//        String businessId="1088138622709792768";
//        String businessId="1088140716548292608";
        String businessId = "1088140517679562752";//主申请表id
        Map<String, String> startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//返回数据{processInstanceId=7501}{processInstanceId=12501}{processInstanceId=17501}
        String taskId = "任务ID:17516";
        String flow_id = startTask.get("processInstanceId").toString();
        ;
        return startTask;
    }


    /**
     * ok
     * 执行当前流程节点
     * 该方法中，ActiDto内除了businessId，其他都是必须值
     *
     * @param actiDto isEndSet,当业务发现可以结束审核的时候向方法外传送是否结束审核的信号
     * @return
     * @throws FlowException
     */
    @Transactional
    public Object runAutoTask(Map actiDto) throws FlowException, com.rockstar.flow.exception.FlowException {

        FrameUser targetUser = userService.selectByPrimaryKey("1080522875951120384");
        FrameUser currUser = userService.selectByPrimaryKey("1080517374995595264");
//        private String processType;
//        private String currentUserId;
//        private String operateUserId;
//        private String dataRole;
//        private String agree;==>yes/no
//        private String comments;===================>????
//        private String businessId;
//        private String taskId;===>在展示列表里面有taskId
//        flowDto.getTaskId(), flowDto.getDataRole(), flowDto.getAgree(), flowDto.getComments()
        Map<String, Object> map = new HashMap<>();
        map.put("billMoney", 1250);
        return flowService.runTask("12516", null, "yes", "zt omments", targetUser, currUser, null);
    }


    /**
     * 查询数据
     *
     * @param taskDto
     * @return
     * @throws FlowException
     */
    @Transactional
    public List findTask(TaskDto taskDto) throws FlowException {
        List<String> taskGroups = new ArrayList<>();

        return flowService.findTask(taskDto, taskGroups);
    }

    /**
     * 还不知道干什么用的,猜是查看备注用的
     *
     * @param taskId
     * @param isHistoric
     * @return
     * @throws FlowException
     */
    @Transactional
    public List getCommentsByTid(String taskId, Boolean isHistoric) throws FlowException {
        if (StringUtils.isEmpty(taskId))
            throw new FlowException("任务ID为空");

        if (null == isHistoric) {
            isHistoric = false;
        }
        return flowService.getComments(taskId, isHistoric);
    }

    /**
     * 通过taskId获取任务后续得任务组列表，任务组列表定义如下：
     * 1，任务组是有（'岗位'和yes） 或（'curr_user'和'no'）组合而成得字符串，具体如：director-yes,office_leader-yes或curr_user-no等
     * 2，一般来说curr_user-no都是被退回之后指向得任务组，而带-yes后缀的是同意所指向得任务组
     * <p>
     * 使用方式：
     * 1，在待审批列表中打开某个审批任务，先通过taskId（任务ID）获取该任务后续得任务组
     * 2，分析所拥有得任务组，一般是2个或者1个任务组
     * 3，根据所获得得任务组，来安排界面'同意'和'不同意'得按钮显示或隐藏
     * 4，任务组含curr_user-no，就具备'不同意'按钮，点击不同意按钮，传输值：agree值为no, dataRole:'-no'之前的
     * 5，任务组含带-yes后缀的，就具备'同意'按钮，点击同意按钮，传输值：agree值为yes, dataRole:'-yes'之前的
     * 6，任务组如果只含curr_user-no，没其他的，那就具备'不同意'和'结束'按钮，点结束按钮，传输值：agree值为yes即可
     *
     * @param taskId     任务ID
     * @param isHistoric 是否历史任务
     * @return
     */
    @Transactional
    public List<String> nextTaskGroups(String taskId, boolean isHistoric) throws FlowException {
        if (StringUtils.isEmpty(taskId))
            throw new FlowException("任务ID为空");

        List<String> strings = flowService.nextTaskGroups(taskId, isHistoric);
        List<UserTask> userTasks = flowService.nextTasks(taskId, isHistoric);
        System.out.println("nextTasks数据为:" + userTasks);


        return strings;
    }


//=======偏业务的,到时候要搬走的=========================================================================================================================================================

    public String getNodeName(FlowMainPush flowMainPush) {
        {
            Task task = null;
            List<Task> taskList = taskService.createTaskQuery().processInstanceBusinessKey(flowMainPush.getFlowMainId()).taskId(flowMainPush.getTaskId()).list();
            if (taskList == null || taskList.isEmpty()) {
                return null;
            }
            task = taskList.get(0);

            return task.getName();
        }
    }

    /**
     * 通用方法 //当前审核人/委托人代表的用户id
     *
     * @param flowMainPush
     * @return
     */
    public String getMyFrameUserId(FlowMainPush flowMainPush) {
        //当前审核人/委托人代表的用户id
        String myFrameUserId = null;
        {
            Integer pushRole = flowMainPush.getPushRole();
            if (new Integer(1).equals(pushRole)) {//'推送人身份:1本人审核,2被委托人(代理审核人审核权限)',
                myFrameUserId = flowMainPush.getPushUser();
            } else if (new Integer(2).equals(pushRole)) {//'推送人身份:1本人审核,2被委托人(代理审核人审核权限)',
                //因为是被委托人,所以查到这个委托人的信息
//                {//通过流程监控进行操的时候就会有问题,不能找到原来的审核用户id 第一种方式,通过关联查询进行被委托人查询
//                    FlowMainLog flowMainLog = flowMainLogService.selectByPrimaryKey(flowMainPush.getUpMainLogId());
//                    String auditResult = flowMainLog.getAuditResult();
//                    if (!"4".equals(auditResult)) {//  `audit_result` varchar(4) DEFAULT NULL COMMENT '审批结果(1同意或者2不同意驳回到申请人,3不同意驳回到上一个审核人,4,委托别人进行审核,null没有审核)',
//                        return null;//异常情况
//                    }
//                    myFrameUserId = flowMainLog.getAuditUser();
//                }
                {//第二种方式
//                    通过 flowMainPush.getFlowPost()来获取对应的被委托人的信息,只是还没有测试不知道 第二种方式是否好用
                    myFrameUserId = flowMainPush.getFlowPost();
                }
            } else {
                return null;//异常情况
            }
        }
        return myFrameUserId;
    }

    /**
     * 审核通过,进行下一步操作
     *
     * @return
     * @throws FlowException
     */
    @Transactional
    public Map<String, String> passToRunTask(FlowMainPush flowMainPush, String deploymentid, String businessId, Map<String, Object> conditionMap, FlowMain flowMain) throws com.rockstar.flow.exception.FlowException {
        // 发起流程引擎操作 并查看下一节点的操作要求
        //0,如果是收纳且匹配上角色就正常流程审核,没有匹配上就返回null,异常错误 ok,
        //1. 如果当前角色是自己,就进行正常的审核流程 ok
        //2. 先查看当前角色是不是自己,不是自己就移动到自己的角色,然后再进行正常的审核流程 ok

        //当前审核人/委托人代表的用户id
        String myFrameUserId = this.getMyFrameUserId(flowMainPush);
        if (myFrameUserId == null) {
            return null;
        }
//        {
//            Integer pushRole = flowMainPush.getPushRole();
//            if (new Integer(1).equals(pushRole)) {//'推送人身份:1本人审核,2被委托人(代理审核人审核权限)',
//                myFrameUserId = flowMainPush.getPushUser();
//            } else if (new Integer(2).equals(pushRole)) {//'推送人身份:1本人审核,2被委托人(代理审核人审核权限)',
//                //因为是被委托人,所以查到这个委托人的信息
//                {//第一种方式,通过关联查询进行被委托人查询
//                    FlowMainLog flowMainLog = flowMainLogService.selectByPrimaryKey(flowMainPush.getUpMainLogId());
//                    String auditResult = flowMainLog.getAuditResult();
//                    if (!"4".equals(auditResult)) {//  `audit_result` varchar(4) DEFAULT NULL COMMENT '审批结果(1同意或者2不同意驳回到申请人,3不同意驳回到上一个审核人,4,委托别人进行审核,null没有审核)',
//                        return null;//异常情况
//                    }
//                    myFrameUserId = flowMainLog.getAuditUser();
//                }
//                {//第二种方式
//                    //通过 flowMainPush.getFlowPost()来获取对应的被委托人的信息,只是还没有测试不知道 第二种方式是否好用
////                    myFrameUserId = flowMainPush.getFlowPost()
//                }
//            } else {
//                return null;//异常情况
//            }
//        }

        //当前审核人/委托人代表的用户
        FrameUser myframeUser = frameUserService.selectByPrimaryKey(myFrameUserId);
        //根据任务id获取任务信息
        //当前任务流程
        Task task = null;
        {
            List<Task> taskList = taskService.createTaskQuery().processInstanceBusinessKey(flowMainPush.getFlowMainId()).taskId(flowMainPush.getTaskId()).list();
            if (taskList == null || taskList.isEmpty()) {
                return null;
            }
            task = taskList.get(0);
        }
        //本节点的关键子 例如flow_cnjs_1_1_0-yes
        String pushUserKey = flowMainPush.getPushUserKey();
        //本节点的角色 例如cnjs
        String setRurrRole = this.getSetRurrRole(pushUserKey);

        //判断setRurrRole是不是出纳类的角色,如果是出纳的角色,就判断当前审核人是不是也是出纳,是就继续,不是就是异常错误,返回null
        //判断是否符合出纳类型的要求         ok
        {
            for (int i = 0; i < ConstantFlowType.FLOW_ROLES_CHECK.length; i++) {
                if (ConstantFlowType.FLOW_ROLES_CHECK[i].equals(setRurrRole)) {//1.1.3如果是出纳关系的查收纳
                    //查看谁是对应角色并查找对应的人
                    String role = ConstantFlowType.ROLES_CHECK[i];//找到是出纳类的角色
//                    List<FrameRoleData> FrameRoleDatas = flowMainService.findFrameRoleDatasByUserId(myFrameUserId, ConstantFlowType.ROLETYPE);//"FLOW"
//                    for (FrameRoleData frameRoleData : FrameRoleDatas) {
//                        String roleKey = frameRoleData.getRoleKey();
//                        if (roleKey.equals(role)) {
//                            //匹配到对应的人,用正常流程做审核
//                            return this.donaturalTask(deploymentid, myframeUser, task, conditionMap);
//                        }
//                    }
                    //如果没有匹配到就是异常错误,返回null
//                    return null;

                    //只所以注释掉上面的,是觉得原来订的审核人已经确认了,若中途改掉了也不需要校验了,确保流程的一致性,并能正常运行
                    return this.donaturalTask(deploymentid, myframeUser, task, conditionMap, flowMain);
                }
            }
        }


        {
            //当前审核人/委托人代表的用户角色(只判断了是否是主管还是 分管领导的问题, 还没有判断是否是出纳的问题,不是哪里都适用的)
            String currRole = this.getCurrRole(myframeUser, flowMain);
            //没有获取到角色,直接对到admin那里
            if (currRole == null || currRole.equals("")) {
                // 直接对到admin那里
                System.out.println("8没有找到对应人:" + " if (currRole == null || currRole.equals(\"\"))");
                FrameUser targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                if (targetUser == null) {
                    System.err.println("异常,没有找到目标人");
                    return null;
                }
                {//下面的替换这里的数据,来解决管理员无法结束流程的问题
//                boolean yes = flowService.runTask(task.getId(), null, "yes", null, targetUser, myframeUser, conditionMap);
//                return new HashMap<>();
                }
                {
                    return this.donaturalTask(deploymentid, myframeUser, task, conditionMap, flowMain);
                }
            }
            //当发现this.getCurrRole(myframeUser);获取的角色是普通员工的时候,就知道他作为审核人只是直接上级,并不是领导,所以把角色调上一级
            if (currRole.equals(ConstantFlowType.FLOW_ROLES_DEPT[0])) {
                currRole = ConstantFlowType.FLOW_ROLES_DEPT[1];
            }
            // 不是出纳的情况下进行的判断
            //1.如果当前角色是自己,就进行正常的审核流程 ok
            //2.先查看当前角色是不是自己,不是自己就移动到自己的角FlowException色,然后再进行正常的审核流程 ok
            if (setRurrRole.equals(currRole)) {//1.如果当前角色是自己,就进行正常的审核流程 ok
                return this.donaturalTask(deploymentid, myframeUser, task, conditionMap, flowMain);
            } else {//2.先查看当前角色是不是自己,不是自己就移动到自己的角色,然后再进行正常的审核流程 ok
                FrameUser targetUser = null;
                UserTaskMore userPosition = this.findUserPosition(currRole, deploymentid);
//        返回为null就直接提交到admin用户去审核,如果对象里面的nodeNum是1就是正常流程,如果大于1就是非正常流程需要把目标人填自己直到自己流转到自己流程上
                if (userPosition == null) {//没有找到数据
                    System.out.println("9没有找到对应人:" + "if (userPosition == null) {");
                    targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                    if (targetUser == null) {
                        System.err.println("异常,没有找到目标人");
                        return null;
                    }
                    boolean yes = flowService.runTask(task.getId(), null, "yes", null, targetUser, myframeUser, conditionMap);
                    return new HashMap<>();
                } else {//找到userPosition数据录了
                    //还不是自己的角色,还要遍历查找
                    return getNextFlow(businessId, userPosition, deploymentid, myframeUser, conditionMap, task, flowMain);
                }
            }
        }
    }


    /**
     * 通用方法 写一个正常流程,正常下审核到下一个环节
     *
     * @param deploymentid 流程任务唯一id
     * @param currUser     当前审核人/委托人代表的用户
     * @param task2        当前的任务Task
     * @param conditionMap 所需要用到的条件
     * @return
     */
    public Map<String, String> donaturalTask(String deploymentid, FrameUser currUser, Task task2, Map<String, Object> conditionMap, FlowMain flowMain) throws com.rockstar.flow.exception.FlowException {
        {
            FrameUser targetUser = null;//目标人信息
            String roleType = null; //流程节点详细信息:例如:dept_superior_1_0_1
            //可以开始正常走流程了 嘻嘻...
            {
                UserTask myNowUserTask = this.getUserTaskById(task2.getTaskDefinitionKey(), deploymentid);//id的值如:_9
                //获取到了出去的各条路径
                List<SequenceFlow> outgoingFlows = myNowUserTask.getOutgoingFlows();
                //我的下一个节点位置
                SequenceFlow myNextSequenceFlow = null;
                for (SequenceFlow outgoingFlow : outgoingFlows) {
                    String conditionExpression = outgoingFlow.getConditionExpression();

                    //如果是空就跳过
                    if (conditionExpression == null) {
                        continue;
                    } else
                        //只有是yes的时候才是需要往下运行的,如果
                        if (conditionExpression.contains("${agree=='no'}")) {//${agree=='yes'}
                            continue;
                        } else if (conditionExpression.contains("${agree=='back'}")) {//${agree=='yes'}
                            continue;
                        } else
                            //只有是yes的时候才是需要往下运行的,如果
                            if (conditionExpression.contains("${agree=='yes'}")) {//${agree=='yes'}//xxxx
                                //发现没有判断条件,那本流程就是下个节点
                                myNextSequenceFlow = outgoingFlow;
                            } else {
                                //发现有明确的判断条件,需要判断是否满足条件才能确认是否本流程就是下个节点
                                //原来计划会有多个条件判断,但是现在就一个,所以就先写死一个条件吧
                                //获取路径的判断条件

                                if (this.booleanConditionIsOk(conditionExpression, conditionMap)) {
                                    myNextSequenceFlow = outgoingFlow;

                                }

                            }
                    //如果没有找到下个流程节点就继续找
                    if (myNextSequenceFlow == null) {
                        continue;
                    }

                    {
                        //下面是找到了下个流程节点,需要进行正常的运行节点了
                        //================================================================
                        //TaskList.get(1).getOutgoingFlows().get(1).getTargetFlowElement().getCandidateGroups()
//                        TaskList.get(7).getOutgoingFlows().get(1).getTargetFlowElement().getClass().isInstance(EndEvent.class);
                        FlowElement targetFlowElement = myNextSequenceFlow.getTargetFlowElement();
                        if (targetFlowElement instanceof EndEvent) {//如果是的话就是最后审核状态
                            System.out.println("已经是结束流程了,直接完成审核就行了1");
                            boolean yes = flowService.runTask(task2.getId(), null, "yes", null, currUser, currUser, conditionMap);
                            HashMap<String, String> objectObjectHashMap = new HashMap<>();
                            objectObjectHashMap.put("isEnd", "1");
                            return objectObjectHashMap;
                        }
                        //class org.activiti.bpmn.model.EndEvent
                        String candidateGroup = ((UserTask) targetFlowElement).getCandidateGroups().get(0);//targetFlowElement.getCandidateGroups();
                        String setRurrRole = this.getSetRurrRole(candidateGroup);
                        boolean end = false;
                        for (String s : ConstantFlowType.FLOW_ROLES_DEPT) {

                            if (s.equals(setRurrRole)) {//1.1.1如果是部门关系的查部门

//                                写一个通用方法,专门根据条件获取部门领导是谁
                                TagerUserAndFlowRole targerUser_flow_roles_dept = this.getTargerUser_FLOW_ROLES_DEPT(s, currUser, flowMain);
                                targetUser = targerUser_flow_roles_dept.getFrameUser();
                                roleType = targerUser_flow_roles_dept.getFlowRole();
                                if (targetUser == null) {
                                    {// 统一到同一个方法中了:
                                        //如果没有找到目标人就肯定是要跳跃查找对应的目标人,如果都没有找到就在最全的节点中找但是(这时候该节点如果是会签也要改成并签)
//
                                        TagerUserAndFlowRole up_targerUser_flow_roles_dept = null;
                                        if (targerUser_flow_roles_dept.getFlowRole() == null) {
                                            //要进行从本角色(部门已经查过了,就是从领导角色开始查)开始的本流程的全角色查询
                                            boolean isTagerUserNull = false;//判断目标用户对应的节点是否存在
                                            {//这里是获取目标用户除去部门信息以外的第一个节点key值

                                                String[] flowStep = flowMainService.getOnlylowStepAll(flowMain.getFlowType());
                                                // 1先找到flowStep中部门的最大i值
                                                // 2 再判断没有就是flowStep的第一个值, 有就再判断是否是最大值,不是最大值就能获取第i+1的值,否则就没有找到
                                                Integer maxI = null;
                                                for (int i = 0; i < flowStep.length; i++) {
                                                    if (flowStep[i].startsWith(ConstantFlowType.FLOW_ROLES_DEPT[1])) {
                                                        maxI = i;
                                                    } else if (flowStep[i].startsWith(ConstantFlowType.FLOW_ROLES_DEPT[2])) {
                                                        maxI = i;
                                                        break;
                                                    }
                                                }
                                                if (maxI == null) {
                                                    targerUser_flow_roles_dept.setFlowRole(flowStep[0]);
                                                } else {
                                                    if (maxI >= (flowStep.length - 1)) {
                                                        isTagerUserNull = true;
                                                    } else {
                                                        targerUser_flow_roles_dept.setFlowRole(flowStep[maxI + 1]);
                                                    }
                                                }
                                            }
                                            if (isTagerUserNull) {
                                                up_targerUser_flow_roles_dept = new TagerUserAndFlowRole();
                                            } else {
                                                up_targerUser_flow_roles_dept = flowMainService.getAllUpRoleTargetUsers(flowMain, targerUser_flow_roles_dept.getFlowRole());
                                            }
                                        } else {
                                            //查询对应设置角色开始的角色
                                            up_targerUser_flow_roles_dept = flowMainService.getUpRoleTargetUsers(flowMain, targerUser_flow_roles_dept.getFlowRole(), targerUser_flow_roles_dept.getOnlyFlowFlowStep());
                                            if (up_targerUser_flow_roles_dept.getFrameUser() == null) {
                                                up_targerUser_flow_roles_dept = flowMainService.getAllUpRoleTargetUsers(flowMain, targerUser_flow_roles_dept.getFlowRole());
                                            }
                                        }
                                        targetUser = up_targerUser_flow_roles_dept.getFrameUser();
                                        roleType = up_targerUser_flow_roles_dept.getFlowRole();
                                    }
                                }
                                if (targetUser == null) {
//                                    return null;
                                    System.out.println("0没有找到对应人:" + "if (targetUser == null) {==>" + setRurrRole + "==>" + ConstantFlowType.ROLETYPE);
                                    targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                                    if (targetUser == null) {
                                        System.err.println("异常,没有找到目标人");
                                        throw new RuntimeException("异常,没有找到目标人");
//                                        return null;
                                    }
                                    roleType = candidateGroup;
                                }
                                //  SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
                                boolean yes = flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);

                                end = true;
                                Map<String, String> objectObjectHashMap = new HashMap<>();
                                objectObjectHashMap.put("roleType", roleType);
                                return objectObjectHashMap;
                            }
                        }
                        if (!end) {
                            for (int i = 0; i < ConstantFlowType.FLOW_ROLES.length; i++) {
                                if (ConstantFlowType.FLOW_ROLES[i].equals(setRurrRole)) {//1.1.2如果是领导关系的查领导
                                    //查看谁是对应角色并查找对应的人
                                    String role = ConstantFlowType.ROLES[i];
//                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
                                    // 在上面的方法基础上，增加groupId和用户状态的过滤
                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(
                                            role, ConstantFlowType.ROLETYPE, currUser.getGroupId());
                                    if (!targetUserList.isEmpty() && targetUserList.size() >= 1) {
                                        targetUser = targetUserList.get(0);

                                        roleType = candidateGroup;

                                        //进行串并联申请
                                        {
                                            targetUser = flowMainService.getFrameUsersId(roleType, targetUserList, targetUser);

                                        }
                                    }
                                    if (targetUser == null) {
                                        TagerUserAndFlowRole up_targerUser_flow_roles_dept = null;
                                        //查询对应设置角色开始的角色
                                        String nextRole = null;
                                        String[] onlyFlowFlowStep = flowMainService.getOnlyFlowFlowStep(flowMain);
                                        {//获取直接领导的下的流程节点是什么
                                            for (int iZT = 0; iZT < onlyFlowFlowStep.length; iZT++) {
                                                if (onlyFlowFlowStep[i].startsWith(setRurrRole)) {
                                                    if (iZT == (onlyFlowFlowStep.length - 1)) {
                                                        nextRole = null;
                                                    } else {
                                                        nextRole = onlyFlowFlowStep[iZT + 1];
                                                    }
                                                    break;
                                                }
                                            }
                                        }
                                        if (nextRole == null) {

                                        } else {
                                            up_targerUser_flow_roles_dept = flowMainService.getUpRoleTargetUsers(flowMain, nextRole, onlyFlowFlowStep);
                                            if (up_targerUser_flow_roles_dept.getFrameUser() == null) {
                                                up_targerUser_flow_roles_dept = flowMainService.getAllUpRoleTargetUsers(flowMain, nextRole);
                                            }
                                            targetUser = up_targerUser_flow_roles_dept.getFrameUser();
                                            roleType = up_targerUser_flow_roles_dept.getFlowRole();
                                        }

                                    }
                                    if (targetUser == null) {
//                                        return null;
                                        System.out.println("1没有找到对应人:" + "if (targetUser == null) {==>" + role + "==>" + ConstantFlowType.ROLETYPE);
                                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                                        if (targetUser == null) {
                                            System.err.println("异常,没有找到目标人");
                                            throw new RuntimeException("异常,没有找到目标人");
//                                        return null;
                                        }
                                        roleType = candidateGroup;
                                    }
                                    boolean yes = flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);
                                    end = true;
                                    Map<String, String> objectObjectHashMap = new HashMap<>();
                                    objectObjectHashMap.put("roleType", roleType);
                                    return objectObjectHashMap;
                                }
                            }

                        }
                        if (!end) {
                            for (int i = 0; i < ConstantFlowType.FLOW_ROLES_CHECK.length; i++) {
                                if (ConstantFlowType.FLOW_ROLES_CHECK[i].equals(setRurrRole)) {//1.1.3如果是收纳关系的查收纳
                                    //查看谁是对应角色并查找对应的人
                                    String role = ConstantFlowType.ROLES_CHECK[i];
//                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
                                    // 在上面的方法基础上，增加groupId和用户状态的过滤
                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(
                                            role, ConstantFlowType.ROLETYPE, currUser.getGroupId());
                                    if (!targetUserList.isEmpty() && targetUserList.size() >= 1) {
                                        targetUser = targetUserList.get(0);
                                        roleType = candidateGroup;
                                        //进行串并联申请
                                        {
                                            targetUser = flowMainService.getFrameUsersId(roleType, targetUserList, targetUser);
                                        }

                                    }
                                    if (targetUser == null) {
//                                        return null;
                                        System.out.println("2没有找到对应人:" + "if (targetUser == null) {");
                                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                                        if (targetUser == null) {
                                            System.err.println("异常,没有找到目标人");
                                            throw new RuntimeException("异常,没有找到目标人");
//                                        return null;
                                        }
                                        roleType = candidateGroup;
                                    }
                                    boolean yes = flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);
                                    end = true;
                                    Map<String, String> objectObjectHashMap = new HashMap<>();
                                    objectObjectHashMap.put("roleType", roleType);
                                    return objectObjectHashMap;
                                }
                            }
                        }
                        //采购流程相关都注释掉,以后模板不会用到的
//                        if (!end) {
//                            for (int i = 0; i < ConstantFlowType.PURCHASE_FLOW_ROLES_CHECK.length; i++) {
//                                if (ConstantFlowType.PURCHASE_FLOW_ROLES_CHECK[i].equals(setRurrRole)) {//1.1.3如果是收纳关系的查收纳
//                                    //查看谁是对应角色并查找对应的人
//                                    String role = ConstantFlowType.PURCHASE_ROLES_CHECK[i];
////                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
//                                    // 在上面的方法基础上，增加groupId和用户状态的过滤
//                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(
//                                            role, ConstantFlowType.ROLETYPE, currUser.getGroupId());
//                                    if (!targetUserList.isEmpty()) {
//                                        targetUser = targetUserList.get(0);
//                                    }
//                                    if (targetUser == null) {
//                                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//                                        if (targetUser == null) {
//                                            return null;
//                                        }
//                                    }
//                                    flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);
//                                    return new HashMap<>();
//                                }
//                            }
//                        }
                        break;

                    }


                }
                //都没有就是没有下个流程了,可以结束流程了
                System.out.println("已经没有下个申请流程了,已经结束了1");
                //
                boolean yes = flowService.runTask(task2.getId(), null, "yes", null, currUser, currUser, conditionMap);

                HashMap<String, String> objectObjectHashMap = new HashMap<>();
                objectObjectHashMap.put("isEnd", "1");
                return objectObjectHashMap;
            }
            //下面的代码要替换掉==========================================================================================
//            {
//
//                //可以开始正常走流程了 嘻嘻...
//                List<Object> nextCandidateGroupByDeploy = flowService.getNextCandidateGroupByDeploy(deploymentid, task2.getTaskDefinitionKey(), false);
//                if (!nextCandidateGroupByDeploy.isEmpty() && nextCandidateGroupByDeploy.size() >= 1) {
//                    for (int ii = 0; ii < nextCandidateGroupByDeploy.size(); ii++) {
//                        UserTask myNextTask = null;//我要走的流程
//                        UserTask userTask = (UserTask) nextCandidateGroupByDeploy.get(ii);
//                        String candidateGroup = userTask.getCandidateGroups().get(0);//dept_superior_1_0_1-yes
//                        if (!"-yes".equals(candidateGroup.substring(candidateGroup.indexOf("-")))){
//                            continue;
//                        }
//                        String setRurrRole = this.getSetRurrRole(candidateGroup);
//                        {
//                            // 获取判断条件进行判断是否符合条件,符合就往下走,不符合就跳到下一个节点进行判断
//                            //获取路径的判断条件
//                            List<String> myconditionExpressions = new ArrayList<String>();
//                            List<SequenceFlow> outgoingFlows = userTask.getOutgoingFlows();
//                            for (SequenceFlow outgoingFlow : outgoingFlows) {
//                                String conditionExpression = outgoingFlow.getConditionExpression();
//                                if (conditionExpression == null) {
//                                    continue;
//                                }
//                                if (conditionExpression.contains("${agree==")) {
//                                    continue;
//                                }
//                                myconditionExpressions.add(conditionExpression);
//                            }
//                            if (myconditionExpressions.isEmpty()) {//没有条件就直接可以使用
//                                myNextTask = userTask;
//
//                            } else {//有条件就判断是否满足条件,不满足就运行下一个
//                                int isOkNum = 0;
//                                for (int i1 = 0; i1 < myconditionExpressions.size(); i1++) {
//                                    boolean isOk = false;
//                                    //这是我的判断条件(通过条件判断库去比对数据)
//                                    String mycondition = myconditionExpressions.get(i1);
//                                    if (mycondition.contains("billMoney")) {
////                                    ${billMoney>3000}
//                                        Double billMoney = Double.valueOf(conditionMap.get("billMoney").toString());
//                                        if (mycondition.contains("<=")) {
//                                            String substring = mycondition.substring(mycondition.indexOf("<=") + 2, mycondition.length() - 1);
//                                            if (billMoney <= Double.valueOf(substring)) {
////                                            ok
//                                                isOk = true;
//
//                                            }
//                                        } else if (mycondition.contains("<")) {
//                                            String substring = mycondition.substring(mycondition.indexOf("<") + 1, mycondition.length() - 1);
//                                            if (billMoney < Double.valueOf(substring)) {
////                                            ok
//                                                isOk = true;
//                                            }
//                                        } else if (mycondition.contains(">=")) {
//                                            String substring = mycondition.substring(mycondition.indexOf(">=") + 2, mycondition.length() - 1);
//                                            if (billMoney >= Double.valueOf(substring)) {
////                                            ok
//                                                isOk = true;
//                                            }
//                                        } else if (mycondition.contains(">")) {
//                                            String substring = mycondition.substring(mycondition.indexOf(">") + 1, mycondition.length() - 1);
//                                            if (billMoney > Double.valueOf(substring)) {
////                                            ok
//                                                isOk = true;
//                                            }
//                                        } else if (mycondition.contains("==")) {
//                                            String substring = mycondition.substring(mycondition.indexOf("==") + 2, mycondition.length() - 1);
//                                            BigDecimal data1 = new BigDecimal(billMoney);
//                                            BigDecimal data2 = new BigDecimal(substring);
//                                            int i2 = data1.compareTo(data2);
//                                            if (i2 == 0) {
////                                            ok
//                                                isOk = true;
//                                            }
//                                        }
//                                    }
//
//                                    if (isOk) {
//                                        isOkNum = isOkNum + 1;
//                                    }
//                                }
//                                if (isOkNum == myconditionExpressions.size()) {
//                                    myNextTask = userTask;
//                                }
//
//                                if (myNextTask == null) {
//                                    continue;
//                                }
//
//                            }
//                        }
//                        //================================================================
//                        boolean end = false;
//                        for (String s : ConstantFlowType.FLOW_ROLES_DEPT) {
//                            if (s.equals(setRurrRole)) {//1.1.1如果是部门关系的查部门
//                                String leader = currUser.getLeader();
//                                targetUser = userService.selectByPrimaryKey(leader);
//                                if (targetUser == null) {
//                                    return null;
//                                }
//                                boolean yes = flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);
//
//                                end = true;
//                                return new HashMap<>();
//                            }
//                        }
//                        if (!end) {
//                            for (int i = 0; i < ConstantFlowType.FLOW_ROLES.length; i++) {
//                                if (ConstantFlowType.FLOW_ROLES[i].equals(setRurrRole)) {//1.1.2如果是领导关系的查领导
//                                    //查看谁是对应角色并查找对应的人
//                                    String role = ConstantFlowType.ROLES[i];
//                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
//                                    if (!targetUserList.isEmpty()) {
//                                        if (targetUserList.size() >= 1) {
//                                            targetUser = targetUserList.get(0);
//                                        }
//                                    }
//                                    if (targetUser == null) {
//                                        return null;
//                                    }
//                                    boolean yes = flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);
//                                    end = true;
//                                    return new HashMap<>();
//                                }
//                            }
//
//                        }
//                        if (!end) {
//                            for (int i = 0; i < ConstantFlowType.FLOW_ROLES_CHECK.length; i++) {
//                                if (ConstantFlowType.FLOW_ROLES_CHECK[i].equals(setRurrRole)) {//1.1.3如果是收纳关系的查收纳
//                                    //查看谁是对应角色并查找对应的人
//                                    String role = ConstantFlowType.ROLES_CHECK[i];
//                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
//                                    if (!targetUserList.isEmpty()) {
//                                        if (targetUserList.size() >= 1) {
//                                            targetUser = targetUserList.get(0);
//                                        }
//                                    }
//                                    if (targetUser == null) {
//                                        return null;
//                                    }
//                                    boolean yes = flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);
//                                    end = true;
//                                    return new HashMap<>();
//                                }
//                            }
//                        }
//                        break;
//                    }
//                    //都没有就是没有下个流程了,可以结束流程了
//                    System.out.println("已经没有下个申请流程了,已经结束了");
//                    //
//                    boolean yes = flowService.runTask(task2.getId(), null, "yes", null, currUser, currUser, conditionMap);
//
//                    HashMap<String, String> objectObjectHashMap = new HashMap<>();
//                    objectObjectHashMap.put("isEnd","1");
//                    return objectObjectHashMap;
//                } else {
//                    System.out.println("已经没有下个申请流程了,已经结束了");
//                    //
//                    boolean yes = flowService.runTask(task2.getId(), null, "yes", null, currUser, currUser, conditionMap);
//
//                    HashMap<String, String> objectObjectHashMap = new HashMap<>();
//                    objectObjectHashMap.put("isEnd","1");
//                    return objectObjectHashMap;
//                }
//            }
        }
    }

    /**
     * 写一个通用方法判断流程中的条件是否符合要求
     * conditionExpression 判断的条件
     * conditionMap拥有的条件
     */
    public boolean booleanConditionIsOk(String conditionExpression, Map<String, Object> conditionMap) {
        //发现有明确的判断条件,需要判断是否满足条件才能确认是否本流程就是下个节点
        //原来计划会有多个条件判断,但是现在就一个,所以就先写死一个条件吧
        //获取路径的判断条件
        List<String> myconditionExpressions = new ArrayList<String>();
        myconditionExpressions.add(conditionExpression);
        int isOkNum = 0;
        for (int i1 = 0; i1 < myconditionExpressions.size(); i1++) {
            boolean isOk = false;
            //这是我的判断条件(通过条件判断库去比对数据)
            String mycondition = myconditionExpressions.get(i1);
            if (mycondition.contains("billMoney")) {
//                                  ${billMoney>3000}
                Double billMoney = Double.valueOf(conditionMap.get("billMoney").toString());
                if (mycondition.contains("<=")) {
                    String substring = mycondition.substring(mycondition.indexOf("<=") + 2, mycondition.length() - 1);
                    if (billMoney <= Double.valueOf(substring)) {
//                                            ok
                        isOk = true;

                    }
                } else if (mycondition.contains("<")) {
                    String substring = mycondition.substring(mycondition.indexOf("<") + 1, mycondition.length() - 1);
                    if (billMoney < Double.valueOf(substring)) {
//                                            ok
                        isOk = true;
                    }
                } else if (mycondition.contains(">=")) {
                    String substring = mycondition.substring(mycondition.indexOf(">=") + 2, mycondition.length() - 1);
                    if (billMoney >= Double.valueOf(substring)) {
//                                            ok
                        isOk = true;
                    }
                } else if (mycondition.contains(">")) {
                    String substring = mycondition.substring(mycondition.indexOf(">") + 1, mycondition.length() - 1);
                    if (billMoney > Double.valueOf(substring)) {
//                                            ok
                        isOk = true;
                    }
                } else if (mycondition.contains("==")) {
                    String substring = mycondition.substring(mycondition.indexOf("==") + 2, mycondition.length() - 1);
                    BigDecimal data1 = new BigDecimal(billMoney);
                    BigDecimal data2 = new BigDecimal(substring);
                    int i2 = data1.compareTo(data2);
                    if (i2 == 0) {
//                                            ok
                        isOk = true;
                    }
                }
            } else if (mycondition.contains("isExchangeOnly==")) {
                String isExchangeOnly = conditionMap.get("isExchangeOnly").toString();
                Integer applyDay = Integer.valueOf(conditionMap.get("applyDay").toString());
                if (mycondition.contains("(isExchangeOnly=='no') and (applyDay>3)")) {
                    if ("no".equals(isExchangeOnly) && applyDay > 3) {
                        isOk = true;
                    }
                } else if (mycondition.contains("(isExchangeOnly=='yes') or (applyDay<=3)")) {
                    if ("yes".equals(isExchangeOnly) || applyDay <= 3) {
                        isOk = true;
                    }
                }
            }
            if (isOk) {
                isOkNum = isOkNum + 1;
            }
        }

        if (isOkNum == myconditionExpressions.size()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 根据用户位置启动信息启动流程
     * processDefine 在ConstantFlowType中的PAYMEN_PROCESSDEFINE
     * String businessId = "1088140517679562752";//主申请表id
     * deploymentid 在ConstantFlowType.USE_MONEY_DEPLOYMENTID
     * conditionMap 是条件数据,比如目前需要的条件是${billMoney>3000}
     * return 返回的数据是flow_id字段,如果是null,说明异常有问题了 如果是end就是没有下个流程了,可以结束了
     */
    public Map<String, String> startTask(String processDefine, String deploymentid, FlowMain flowMain, FrameUser currUser, Map<String, Object> conditionMap, String tagerUserId) throws com.rockstar.flow.exception.FlowException {
        String businessId = flowMain.getId();
        FrameUser targetUser = null;//目标人信息
        String roleType = null; //流程节点详细信息:例如:dept_superior_1_0_1
        String currRole = this.getCurrRole(currUser, flowMain);
        UserTaskMore userPosition = this.findUserPosition(currRole, deploymentid);
//        返回为null就直接提交到admin用户去审核,如果对象里面的nodeNum是1就是正常流程,如果大于1就是非正常流程需要把目标人填自己直到自己流转到自己流程上
        Map<String, String> startTask = null;
        if (userPosition == null) {//没有找到数据
            System.out.println("7没有找到对应人:" + " if (userPosition == null) {");
            targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
            if (targetUser == null) {
                System.err.println("异常,没有找到目标人");
                return null;
            }
            startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
            return startTask;
        } else {//找到userPosition对象数据了
//            1.如果是1就正常网下写,如果发现目标审核人的角色不是正常角色,就要去找他的对应位置的角色,不管是谁都要审核通过才行, 所以开始的时候只要找到直接领导传下去就好了,在运行节点进行角色判断,将流程跳到自己的角色位置结束
            //1.1查看下个节点人员角色的需求
            //1.1.1如果是部门关系的查部门
            //1.1.2如果是领导关系的查领导
            //1.1.3如果是收纳关系的查收纳
            //2.如果大于1就是非正常流程需要把目标人填自己直到自己流转到自己流程上
            int nodeNum = userPosition.getNodeNum();
            UserTask currentUserTask = userPosition.getCurrentUserTask();
            if (nodeNum == 1) {
                {
                    List<SequenceFlow> outgoingFlows = currentUserTask.getOutgoingFlows();
                    //我的下一个节点位置
                    SequenceFlow myNextSequenceFlow = null;
                    for (SequenceFlow outgoingFlow : outgoingFlows) {
                        String conditionExpression = outgoingFlow.getConditionExpression();
//如果是空就跳过
                        if (conditionExpression == null) {
                            continue;
                        } else
                            //只有是yes的时候才是需要往下运行的,如果
                            if (conditionExpression.contains("${agree=='no'}")) {//${agree=='yes'}
                                continue;
                            } else if (conditionExpression.contains("${agree=='back'}")) {//${agree=='yes'}
                                continue;
                            } else
                                //只有是yes的时候才是需要往下运行的,如果
                                if (conditionExpression.contains("${agree=='yes'}")) {//${agree=='yes'}//xxxx
                                    //发现没有判断条件,那本流程就是下个节点
                                    myNextSequenceFlow = outgoingFlow;

                                } else {
                                    //发现有明确的判断条件,需要判断是否满足条件才能确认是否本流程就是下个节点
                                    //原来计划会有多个条件判断,但是现在就一个,所以就先写死一个条件吧
                                    //获取路径的判断条件

                                    if (this.booleanConditionIsOk(conditionExpression, conditionMap)) {
                                        myNextSequenceFlow = outgoingFlow;
                                    }
                                }
                        //如果没有找到下个流程节点就继续找
                        if (myNextSequenceFlow == null) {
                            continue;
                        }


                        //下面是找到了下个流程节点,需要进行正常的运行节点了
                        FlowElement targetFlowElement = myNextSequenceFlow.getTargetFlowElement();
                        if (targetFlowElement instanceof EndEvent) {//如果是的话就是最后审核状态
                            System.out.println("已经是结束流程了,直接完成审核就行了2");
                            return null;
                        }
                        String candidateGroup = ((UserTask) targetFlowElement).getCandidateGroups().get(0);//targetFlowElement.getCandidateGroups();
                        String setRurrRole = this.getSetRurrRole(candidateGroup);
                        boolean end = false;
                        for (String s : ConstantFlowType.FLOW_ROLES_DEPT) {
                            if (s.equals(setRurrRole)) {//1.1.1如果是部门关系的查部门

//                                写一个通用方法,专门根据条件获取部门领导是谁
                                TagerUserAndFlowRole targerUser_flow_roles_dept = this.getTargerUser_FLOW_ROLES_DEPT(s, currUser, flowMain);
                                targetUser = targerUser_flow_roles_dept.getFrameUser();
                                roleType = targerUser_flow_roles_dept.getFlowRole();
                                if (targetUser == null) {
                                    {// 统一到同一个方法中了:
                                        //如果没有找到目标人就肯定是要跳跃查找对应的目标人,如果都没有找到就在最全的节点中找但是(这时候该节点如果是会签也要改成并签)//
                                        TagerUserAndFlowRole up_targerUser_flow_roles_dept = null;
                                        if (targerUser_flow_roles_dept.getFlowRole() == null) {
                                            //要进行从本角色(部门已经查过了,就是从领导角色开始查)开始的本流程的全角色查询
                                            boolean isTagerUserNull = false;//判断目标用户对应的节点是否存在
                                            {//这里是获取目标用户除去部门信息以外的第一个节点key值
                                                String[] flowStep = flowMainService.getOnlylowStepAll(flowMain.getFlowType());
                                                for (int i = 0; i < flowStep.length; i++) {
                                                    if (ConstantFlowType.FLOW_ROLES_DEPT[2].equals(flowStep[i])) {
                                                        if (i >= (flowStep.length - 1)) {
                                                            isTagerUserNull = true;
                                                            break;
                                                        } else {
                                                            targerUser_flow_roles_dept.setFlowRole(flowStep[i + 1]);
                                                        }
                                                    }

                                                    if (isTagerUserNull) {
                                                        if (ConstantFlowType.FLOW_ROLES_DEPT[1].equals(flowStep[i])) {
                                                            if (i >= (flowStep.length - 1)) {
                                                                isTagerUserNull = true;
                                                                break;
                                                            } else {
                                                                targerUser_flow_roles_dept.setFlowRole(flowStep[i + 1]);
                                                            }
                                                        }
                                                    }

                                                }
                                            }
                                            if (isTagerUserNull) {
                                                up_targerUser_flow_roles_dept = new TagerUserAndFlowRole();
                                            } else {
                                                up_targerUser_flow_roles_dept = flowMainService.getAllUpRoleTargetUsers(flowMain, targerUser_flow_roles_dept.getFlowRole());
                                            }
                                        } else {
                                            //查询对应设置角色开始的角色
                                            up_targerUser_flow_roles_dept = flowMainService.getUpRoleTargetUsers(flowMain, targerUser_flow_roles_dept.getFlowRole(), targerUser_flow_roles_dept.getOnlyFlowFlowStep());
                                            if (up_targerUser_flow_roles_dept.getFrameUser() == null) {
                                                up_targerUser_flow_roles_dept = flowMainService.getAllUpRoleTargetUsers(flowMain, targerUser_flow_roles_dept.getFlowRole());
                                            }
                                        }
                                        targetUser = up_targerUser_flow_roles_dept.getFrameUser();
                                        roleType = up_targerUser_flow_roles_dept.getFlowRole();
                                    }
                                }

                                if (targetUser == null) {
                                    return null;
                                }
                                //   SysDept sysDept = sysDeptService.selectByPrimaryKey(department);

                                startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                                end = true;

                                startTask.put("roleType", roleType);
                                return startTask;
                            }
                        }
                        if (!end) {
                            for (int i = 0; i < ConstantFlowType.FLOW_ROLES.length; i++) {
                                if (ConstantFlowType.FLOW_ROLES[i].equals(setRurrRole)) {//1.1.2如果是领导关系的查领导
                                    //查看谁是对应角色并查找对应的人
                                    String role = ConstantFlowType.ROLES[i];
//                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
                                    // 在上面的方法基础上，增加groupId和用户状态的过滤
                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(
                                            role, ConstantFlowType.ROLETYPE, currUser.getGroupId());
                                    if (!targetUserList.isEmpty() && targetUserList.size() >= 1) {
                                        targetUser = targetUserList.get(0);

                                        roleType = candidateGroup;

                                        //进行串并联申请
                                        {
                                            targetUser = flowMainService.getFrameUsersId(roleType, targetUserList, targetUser);

                                        }
                                    }
                                    if (targetUser == null) {
                                        TagerUserAndFlowRole up_targerUser_flow_roles_dept = null;
                                        //查询对应设置角色开始的角色
                                        String nextRole = null;
                                        String[] onlyFlowFlowStep = flowMainService.getOnlyFlowFlowStep(flowMain);
                                        {//获取直接领导的下的流程节点是什么
                                            for (int iZT = 0; iZT < onlyFlowFlowStep.length; iZT++) {
                                                if (onlyFlowFlowStep[i].startsWith(setRurrRole)) {
                                                    if (iZT == (onlyFlowFlowStep.length - 1)) {
                                                        nextRole = null;
                                                    } else {
                                                        nextRole = onlyFlowFlowStep[iZT + 1];
                                                    }
                                                    break;
                                                }
                                            }
                                        }
                                        if (nextRole == null) {

                                        } else {
                                            up_targerUser_flow_roles_dept = flowMainService.getUpRoleTargetUsers(flowMain, nextRole, onlyFlowFlowStep);
                                            if (up_targerUser_flow_roles_dept.getFrameUser() == null) {
                                                up_targerUser_flow_roles_dept = flowMainService.getAllUpRoleTargetUsers(flowMain, nextRole);
                                            }
                                            targetUser = up_targerUser_flow_roles_dept.getFrameUser();
                                            roleType = up_targerUser_flow_roles_dept.getFlowRole();
                                        }

                                    }
                                    if (targetUser == null) {
//                                        return null;
                                        System.out.println("3没有找到对应人:" + "if (targetUser == null) {");
                                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                                        if (targetUser == null) {
                                            System.err.println("异常,没有找到目标人");
                                            return null;
                                        }
                                        roleType = candidateGroup;
                                    }
                                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                                    end = true;
                                    startTask.put("roleType", roleType);
                                    return startTask;
                                }
                            }

                        }
                        if (!end) {
                            for (int i = 0; i < ConstantFlowType.FLOW_ROLES_CHECK.length; i++) {
                                if (ConstantFlowType.FLOW_ROLES_CHECK[i].equals(setRurrRole)) {//1.1.3如果是收纳关系的查收纳
                                    //查看谁是对应角色并查找对应的人
                                    String role = ConstantFlowType.ROLES_CHECK[i];
//                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
                                    // 在上面的方法基础上，增加groupId和用户状态的过滤
                                    List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(
                                            role, ConstantFlowType.ROLETYPE, currUser.getGroupId());
                                    if (!targetUserList.isEmpty()) {
                                        if (targetUserList.size() >= 1) {
                                            targetUser = targetUserList.get(0);
                                        }
                                    }
                                    if (targetUser == null) {
//                                        return null;
                                        System.out.println("4没有找到对应人:" + "if (targetUser == null) {");
                                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                                        if (targetUser == null) {
                                            System.err.println("异常,没有找到目标人");
                                            return null;
                                        }
                                        roleType = candidateGroup;
                                    }
                                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                                    end = true;
                                    startTask.put("roleType", roleType);
                                    return startTask;
                                }
                            }
                        }
                        return null;
                    }
                    //走到这里就没有找到对应的流程节点,所以需要报错 返回null
                    System.out.println("异常错误,没有找到对应的流程节点");
                    return null;

                }


            } else if (nodeNum > 1) {
                //  2.如果大于1就是非正常流程需要把目标人填自己直到自己流转到自己流程上
                // 需要进行循环审核过程
                boolean isZhuYaoLingDao = "flow_zyld".equals(currRole) ? true : false; //2023年5月17日 章总修改,在开始申请的时候不判断身份是否是该节点本身份,而是必须要进行审核,所以注释掉下面的判断
                if (isZhuYaoLingDao) {//2023年7月5日 章总在第七批次又改回来了 //2023年5月17日 章总修改,在开始申请的时候不判断身份是否是该节点本身份,而是必须要进行审核,所以注释掉下面的判断
                    targetUser = currUser;
                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                    if (!startTask.isEmpty()) {
                        {
//                    String flow_id = startTask.get("processInstanceId").toString();//"流程实例ID：" + task.getProcessInstanceId());是会变化的所以没有用
                            List<Task> list = taskService.createTaskQuery().processInstanceBusinessKey(businessId)//创建任务查询对象
                                    .taskAssignee(targetUser.getId())//指定个人任务查询
//                .processInstanceId("12516")
                                    .list();
                            if (list == null || list.isEmpty() || list.size() <= 0) {
                                System.err.println("异常,没有找到任务对象");
                                return null;
                            }
                            //2.1通过flow_id和targetUser获取下一个UserTask
                            Task task = list.get(0);
                            //task是当前流程的信息
                            //如果发现task对应的角色就是自己的角色,就开始正常的走
                            //如果发现task对应的角色还不是,就需要再进行设置自己的操作
                            String taskDefinitionKey = task.getTaskDefinitionKey(); //id的值如:_9
                            String flowId = userPosition.getUserTask().getId();//流程唯一id(我猜的)
                            if (flowId.equals(taskDefinitionKey)) {
                                //可以开始正常走流程了 嘻嘻...

                                Map<String, String> donaturalTaskMap = this.donaturalTask(deploymentid, currUser, task, conditionMap, flowMain);
                                if (donaturalTaskMap == null) {
                                    return null;
                                } else {
                                    startTask.put("roleType", donaturalTaskMap.get("roleType"));
                                    return startTask;
                                }

                            } else {
                                //还不是自己的角色,还要遍历查找(但是要写在getNextFlow方法里面,且通过flowServiceNextFlow方法改造一下)
//                        boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
                                {//遍历对象
                                    Map<String, String> getNextFlowMap = getNextFlow(businessId, userPosition, deploymentid, currUser, conditionMap, task, flowMain);
                                    if (getNextFlowMap == null) {
                                        return null;
                                    } else {
                                        startTask.put("roleType", getNextFlowMap.get("roleType"));

                                        // 如果getNextFlowMap返回数据是:{isEnd=1} 需要特殊处理
                                        if (getNextFlowMap.get("isEnd") == null) {
                                            return startTask;
                                        } else {
                                            startTask.put("isEnd", getNextFlowMap.get("isEnd"));
                                            return startTask;
                                        }


                                    }
                                }
                            }
                        }
                    } else {
                        return null;
                    }
                } else { //2023年5月17日 章总修改,在开始申请的时候不判断身份是否是该节点本身份,而是必须要进行审核,所以新增掉下面的操作
                    if (ConstantFlowType.isMoreDept) {
                        String leader = null;
                        FrameUserDeptExample frameUserDeptExample = new FrameUserDeptExample();
                        frameUserDeptExample.createCriteria().andDeptIdEqualTo(flowMain.getDeptId()).andUserIdEqualTo(flowMain.getCreatedBy());
                        List<FrameUserDept> frameUserDepts = frameUserDeptService.selectByExample(frameUserDeptExample);
                        if (frameUserDepts.isEmpty()) {
                        } else {
//                            leader = frameUserDepts.get(0).getLeaderId();
                            if (leader != null) {
                                targetUser = userService.selectByPrimaryKey(leader);
                            }
                        }

                    } else {
                        if (currUser.getLeader() != null) {
                            targetUser = userService.selectByPrimaryKey(currUser.getLeader());
                        }

                    }
                    if (targetUser == null) {
                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                    }
                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                    if (!startTask.isEmpty()) {
                        return startTask;
                    } else {
                        return null;
                    }
                }
            } else {
                return null;
            }
//为了实现并联串联审核流程的方法需求
//要求:flowService.startTask(processDefine, null, businessId, targetUser, currUser);改成flowService.startTask(processDefine, null, businessId, targetUsers,totalnumber, currUser);(修改内容目标人改成数组targetUsers,审核通过数量totalnumber自己定义)
//要求2:flowService.runTask(taskId, null, agree, comments, targetUser, currUser, null);改成flowService.runTask(taskId, null, agree, comments, targetUsers,totalnumber, currUser, null);(修改内容目标人改成数组targetUsers,审核通过数量totalnumber自己定义)
        }
        //返回数据{processInstanceId=7501}{processInstanceId=12501}{processInstanceId=17501}
    }

    /**
     * 做一个通用方法,通过UserTask的id和deloymentId来获取指定的UserTask
     */
    public UserTask getUserTaskById(String id, String deloymentId) {

        List<UserTask> taskList = flowService.getTaskList(deloymentId);
        for (int i = 0; i < taskList.size(); i++) {
            if (taskList.get(i).getId().equals(id)) {
                return taskList.get(i);
            }
        }
        return null;
//        List<UserTask> collect = taskList.stream().filter(x -> x.getId().equals(id)).collect(Collectors.toList());
//        if (collect.isEmpty()){
//            return null;
//        }else{
//            return collect.get(0);
//        }
    }

    /**
     * 通过任务id获取userTask信息
     *
     * @param taskId
     * @return
     */
    public UserTask getUserTaskByTaskId(String taskId) {
        return (UserTask) flowService.getCurrentFlowNode(taskId);
    }

    /**
     * 写一个方法,当还不是自己的角色时,需要进入下个节点,若下个节点是收纳就可以结束运行,返回false,说明是end结束了,若返回true,说明正常继续运行
     *
     * @return
     */
    public Boolean flowServiceNextFlow(String deploymentid, Map<String, Object> conditionMap, FrameUser currUser, Task task) throws com.rockstar.flow.exception.FlowException {
        //获取到了我的userTask
        {
            UserTask myNowUserTask = this.getUserTaskById(task.getTaskDefinitionKey(), deploymentid);//id的值如:_9
            //获取到了出去的各条路径
            List<SequenceFlow> outgoingFlows = myNowUserTask.getOutgoingFlows();
            //我的下一个节点位置
            SequenceFlow myNextSequenceFlow = null;
            for (SequenceFlow outgoingFlow : outgoingFlows) {
                String conditionExpression = outgoingFlow.getConditionExpression();

                //如果是空就跳过
                if (conditionExpression == null) {
                    continue;
                } else
                    //只有是yes的时候才是需要往下运行的,如果
                    if (conditionExpression.contains("${agree=='no'}")) {//${agree=='yes'}
                        continue;
                    } else if (conditionExpression.contains("${agree=='back'}")) {//${agree=='yes'}
                        continue;
                    } else
                        //只有是yes的时候才是需要往下运行的,如果
                        if (conditionExpression.contains("${agree=='yes'}")) {//${agree=='yes'}//xxxx
                            //发现没有判断条件,那本流程就是下个节点
                            myNextSequenceFlow = outgoingFlow;

                        } else {
                            //发现有明确的判断条件,需要判断是否满足条件才能确认是否本流程就是下个节点
                            //原来计划会有多个条件判断,但是现在就一个,所以就先写死一个条件吧
                            //获取路径的判断条件
//                    List<String> myconditionExpressions = new ArrayList<String>();
//                    myconditionExpressions.add(conditionExpression);
//                    int isOkNum = 0;
//                    for (int i1 = 0; i1 < myconditionExpressions.size(); i1++) {
//                        boolean isOk = false;
//                        //这是我的判断条件(通过条件判断库去比对数据)
//                        String mycondition = myconditionExpressions.get(i1);
//                        if (mycondition.contains("billMoney")) {
////                                    ${billMoney>3000}
//                            Double billMoney = Double.valueOf(conditionMap.get("billMoney").toString());
//                            if (mycondition.contains("<=")) {
//                                String substring = mycondition.substring(mycondition.indexOf("<=") + 2, mycondition.length() - 1);
//                                if (billMoney <= Double.valueOf(substring)) {
////                                            ok
//                                    isOk = true;
//
//                                }
//                            } else if (mycondition.contains("<")) {
//                                String substring = mycondition.substring(mycondition.indexOf("<") + 1, mycondition.length() - 1);
//                                if (billMoney < Double.valueOf(substring)) {
////                                            ok
//                                    isOk = true;
//                                }
//                            } else if (mycondition.contains(">=")) {
//                                String substring = mycondition.substring(mycondition.indexOf(">=") + 2, mycondition.length() - 1);
//                                if (billMoney >= Double.valueOf(substring)) {
////                                            ok
//                                    isOk = true;
//                                }
//                            } else if (mycondition.contains(">")) {
//                                String substring = mycondition.substring(mycondition.indexOf(">") + 1, mycondition.length() - 1);
//                                if (billMoney > Double.valueOf(substring)) {
////                                            ok
//                                    isOk = true;
//                                }
//                            } else if (mycondition.contains("==")) {
//                                String substring = mycondition.substring(mycondition.indexOf("==") + 2, mycondition.length() - 1);
//                                BigDecimal data1 = new BigDecimal(billMoney);
//                                BigDecimal data2 = new BigDecimal(substring);
//                                int i2 = data1.compareTo(data2);
//                                if (i2 == 0) {
////                                            ok
//                                    isOk = true;
//                                }
//                            }
//                        }
//
//                        if (isOk) {
//                            isOkNum = isOkNum + 1;
//                        }
//                    }
//                    if (isOkNum == myconditionExpressions.size()) {
//                        myNextSequenceFlow = outgoingFlow;
//                    }
                            if (this.booleanConditionIsOk(conditionExpression, conditionMap)) {
                                myNextSequenceFlow = outgoingFlow;
                            }

                        }
                //如果没有找到下个流程节点就继续找
                if (myNextSequenceFlow == null) {
                    continue;
                }

                {//下面是找到了下个流程节点,需要进行正常的运行节点了
                    //================================================================================================
//                    TaskList.get(1).getOutgoingFlows().get(1).getTargetFlowElement().getCandidateGroups()
                    FlowElement targetFlowElement = myNextSequenceFlow.getTargetFlowElement();
                    if (targetFlowElement instanceof EndEvent) {//如果是的话就是最后审核状态
                        System.out.println("已经是结束流程了,直接完成审核就行了3");
                        boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
                        return null;
                    }
                    String candidateGroup = ((UserTask) targetFlowElement).getCandidateGroups().get(0);//targetFlowElement.getCandidateGroups();
                    String setRurrRole = this.getSetRurrRole(candidateGroup);
                    boolean end = false;
                    for (String s : ConstantFlowType.FLOW_ROLES_DEPT) {
                        if (s.equals(setRurrRole)) {//1.1.1如果是部门关系的查部门
//                        String leader = currUser.getLeader();
//                        targetUser = userService.selectByPrimaryKey(leader);
//                        if (targetUser == null) {
//                            return null;
//                        }
                            boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);

                            end = true;
                            return true;
                        }
                    }
                    if (!end) {
                        for (int i = 0; i < ConstantFlowType.FLOW_ROLES.length; i++) {
                            if (ConstantFlowType.FLOW_ROLES[i].equals(setRurrRole)) {//1.1.2如果是领导关系的查领导
                                //查看谁是对应角色并查找对应的人
//                            String role = ConstantFlowType.ROLES[i];
//                            List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
//                            if (!targetUserList.isEmpty()) {
//                                if (targetUserList.size() >= 1) {
//                                    targetUser = targetUserList.get(0);
//                                }
//                            }
//                            if (targetUser == null) {
//                                return null;
//                            }
                                boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
                                end = true;
                                return true;
                            }
                        }

                    }
                    if (!end) {
                        for (int i = 0; i < ConstantFlowType.FLOW_ROLES_CHECK.length; i++) {
                            if (ConstantFlowType.FLOW_ROLES_CHECK[i].equals(setRurrRole)) {//1.1.3如果是收纳关系的查收纳
                                //查看谁是对应角色并查找对应的人
                                String role = ConstantFlowType.ROLES_CHECK[i];
//                                List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
                                // 在上面的方法基础上，增加groupId和用户状态的过滤
                                List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(
                                        role, ConstantFlowType.ROLETYPE, currUser.getGroupId());
                                FrameUser targetUser = null;
                                if (!targetUserList.isEmpty()) {
                                    if (targetUserList.size() >= 1) {
                                        targetUser = targetUserList.get(0);
                                    }
                                }
                                if (targetUser == null) {
//                                    return null;
                                    System.out.println("5没有找到对应人:" + "if (targetUser == null) {");
                                    targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                                    if (targetUser == null) {
                                        System.err.println("异常,没有找到目标人");
                                        return null;
                                    }
                                }
                                boolean yes = flowService.runTask(task.getId(), null, "yes", null, targetUser, currUser, conditionMap);
                                end = true;
                                return false;
                            }
                        }
                    }
                    break;
                }


            }

            //如果运行找到这里就说明没有找到下个流程节点了,流程可以结束了
            System.out.println("已经没有下个申请流程了,已经结束了2");
            //
            boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
            return null;
        }

//        {
//            //下面的部分将会被淘汰掉.....................................................
//            List<Object> nextCandidateGroupByDeploy = flowService.getNextCandidateGroupByDeploy(deploymentid, task.getTaskDefinitionKey(), false);
//            if (!nextCandidateGroupByDeploy.isEmpty() && nextCandidateGroupByDeploy.size() >= 1) {
//                for (int ii = 0; ii < nextCandidateGroupByDeploy.size(); ii++) {
//                    UserTask myNextTask = null;//我要走的流程
//                    UserTask userTask = (UserTask) nextCandidateGroupByDeploy.get(ii);
//                    String candidateGroup = userTask.getCandidateGroups().get(0);//dept_superior_1_0_1-yes
//                    if (!"-yes".equals(candidateGroup.substring(candidateGroup.indexOf("-")))) {
//                        continue;
//                    }
//                    //需要的角色
//                    String setRurrRole = this.getSetRurrRole(candidateGroup);
//                    {
//                        // 获取判断条件进行判断是否符合条件,符合就往下走,不符合就跳到下一个节点进行判断
//                        //获取路径的判断条件
//                        List<String> myconditionExpressions = new ArrayList<String>();
//                        List<SequenceFlow> outgoingFlows = userTask.getOutgoingFlows();
//                        for (SequenceFlow outgoingFlow : outgoingFlows) {
//                            String conditionExpression = outgoingFlow.getConditionExpression();
//                            if (conditionExpression == null) {
//                                continue;
//                            }
//                            if (conditionExpression.contains("${agree==")) {
//                                continue;
//                            }
//                            myconditionExpressions.add(conditionExpression);
//                        }
//                        if (myconditionExpressions.isEmpty()) {//没有条件就直接可以使用
//                            myNextTask = userTask;
//
//                        } else {//有条件就判断是否满足条件,不满足就运行下一个
//                            int isOkNum = 0;
//                            for (int i1 = 0; i1 < myconditionExpressions.size(); i1++) {
//                                boolean isOk = false;
//                                //这是我的判断条件(通过条件判断库去比对数据)
//                                String mycondition = myconditionExpressions.get(i1);
//                                if (mycondition.contains("billMoney")) {
////                                    ${billMoney>3000}
//                                    Double billMoney = Double.valueOf(conditionMap.get("billMoney").toString());
//                                    if (mycondition.contains("<=")) {
//                                        String substring = mycondition.substring(mycondition.indexOf("<=") + 2, mycondition.length() - 1);
//                                        if (billMoney <= Double.valueOf(substring)) {
////                                            ok
//                                            isOk = true;
//
//                                        }
//                                    } else if (mycondition.contains("<")) {
//                                        String substring = mycondition.substring(mycondition.indexOf("<") + 1, mycondition.length() - 1);
//                                        if (billMoney < Double.valueOf(substring)) {
////                                            ok
//                                            isOk = true;
//                                        }
//                                    } else if (mycondition.contains(">=")) {
//                                        String substring = mycondition.substring(mycondition.indexOf(">=") + 2, mycondition.length() - 1);
//                                        if (billMoney >= Double.valueOf(substring)) {
////                                            ok
//                                            isOk = true;
//                                        }
//                                    } else if (mycondition.contains(">")) {
//                                        String substring = mycondition.substring(mycondition.indexOf(">") + 1, mycondition.length() - 1);
//                                        if (billMoney > Double.valueOf(substring)) {
////                                            ok
//                                            isOk = true;
//                                        }
//                                    } else if (mycondition.contains("==")) {
//                                        String substring = mycondition.substring(mycondition.indexOf("==") + 2, mycondition.length() - 1);
//                                        BigDecimal data1 = new BigDecimal(billMoney);
//                                        BigDecimal data2 = new BigDecimal(substring);
//                                        int i2 = data1.compareTo(data2);
//                                        if (i2 == 0) {
////                                            ok
//                                            isOk = true;
//                                        }
//                                    }
//                                }
//
//                                if (isOk) {
//                                    isOkNum = isOkNum + 1;
//                                }
//                            }
//                            if (isOkNum == myconditionExpressions.size()) {
//                                myNextTask = userTask;
//                            }
//
//                            if (myNextTask == null) {
//                                continue;
//                            }
//
//                        }
//                    }
//                    //================================================================
//                    boolean end = false;
//                    for (String s : ConstantFlowType.FLOW_ROLES_DEPT) {
//                        if (s.equals(setRurrRole)) {//1.1.1如果是部门关系的查部门
////                        String leader = currUser.getLeader();
////                        targetUser = userService.selectByPrimaryKey(leader);
////                        if (targetUser == null) {
////                            return null;
////                        }
//                            boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
//
//                            end = true;
//                            return true;
//                        }
//                    }
//                    if (!end) {
//                        for (int i = 0; i < ConstantFlowType.FLOW_ROLES.length; i++) {
//                            if (ConstantFlowType.FLOW_ROLES[i].equals(setRurrRole)) {//1.1.2如果是领导关系的查领导
//                                //查看谁是对应角色并查找对应的人
////                            String role = ConstantFlowType.ROLES[i];
////                            List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
////                            if (!targetUserList.isEmpty()) {
////                                if (targetUserList.size() >= 1) {
////                                    targetUser = targetUserList.get(0);
////                                }
////                            }
////                            if (targetUser == null) {
////                                return null;
////                            }
//                                boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
//                                end = true;
//                                return true;
//                            }
//                        }
//
//                    }
//                    if (!end) {
//                        for (int i = 0; i < ConstantFlowType.FLOW_ROLES_CHECK.length; i++) {
//                            if (ConstantFlowType.FLOW_ROLES_CHECK[i].equals(setRurrRole)) {//1.1.3如果是收纳关系的查收纳
//                                //查看谁是对应角色并查找对应的人
//                                String role = ConstantFlowType.ROLES_CHECK[i];
//                                List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKey(role, ConstantFlowType.ROLETYPE);
//                                FrameUser targetUser = null;
//                                if (!targetUserList.isEmpty()) {
//                                    if (targetUserList.size() >= 1) {
//                                        targetUser = targetUserList.get(0);
//                                    }
//                                }
//                                if (targetUser == null) {
//                                    return null;
//                                }
//                                boolean yes = flowService.runTask(task.getId(), null, "yes", null, targetUser, currUser, conditionMap);
//                                end = true;
//                                return false;
//                            }
//                        }
//                    }
//                    break;
//                }
//                System.out.println("已经没有下个申请流程了,已经结束了");
//                //
//                boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
//                return null;
//            } else {
//                System.out.println("已经没有下个申请流程了,已经结束了");
//                //
//                boolean yes = flowService.runTask(task.getId(), null, "yes", null, currUser, currUser, conditionMap);
//                return null;
//            }
//        }
    }

    /**
     * 遍历进行操作最终获取用户自己的角色
     *
     * @return
     */
    public Map<String, String> getNextFlow(String businessId, UserTaskMore userPosition, String deploymentid, FrameUser currUser, Map<String, Object> conditionMap, Task task, FlowMain flowMain) throws com.rockstar.flow.exception.FlowException {

        FrameUser targetUser = currUser;
        Boolean aBoolean = this.flowServiceNextFlow(deploymentid, conditionMap, currUser, task);
        if (aBoolean == null) {
            Map<String, String> objectObjectHashMap = new HashMap<>();
            objectObjectHashMap.put("isEnd", "1");
            return objectObjectHashMap;
        } else if (!aBoolean) {
            return new HashMap<>();
        } else if (aBoolean) {
            //继续运行下面的步骤
        }
        {//遍历对象
            List<Task> list2 = taskService.createTaskQuery().processInstanceBusinessKey(businessId)//创建任务查询对象
                    .taskAssignee(targetUser.getId())//指定个人任务查询
//                .processInstanceId("12516")
                    .list();
            if (list2 == null || list2.isEmpty() || list2.size() <= 0) {
                System.err.println("异常,没有找到任务对象2");
                return null;
            }
            //2.1通过flow_id和targetUser获取下一个UserTask
            Task task2 = list2.get(0);
            //task是当前流程的信息
            //如果发现task对应的角色就是自己的角色,就开始正常的走
            //如果发现task对应的角色还不是,就需要再进行设置自己的操作
            String taskDefinitionKey2 = task2.getTaskDefinitionKey(); //id的值如:_9
            String flowId2 = userPosition.getUserTask().getId();//流程唯一id(我猜的)
            if (flowId2.equals(taskDefinitionKey2)) {
                //可以开始正常走流程了 嘻嘻...
                {
//                    //可以开始正常走流程了 嘻嘻...

                }
                return this.donaturalTask(deploymentid, currUser, task2, conditionMap, flowMain);
            } else {
                //还不是自己的角色,还要遍历查找
                return getNextFlow(businessId, userPosition, deploymentid, currUser, conditionMap, task2, flowMain);
            }

        }
//        return null;
    }

    /**
     * 共用方法 //当前用户的角色定义(如果判断下来还是""就是没有确认是否是部门主管),
     * 但是注意,这只是判断是否是主管还是 分管领导的问题, 还没有判断是否是出纳的问题,不是哪里都适用的
     *
     * @param currUser
     * @return
     */
    public String getCurrRole(FrameUser currUser, FlowMain flowMain) {
        //当前用户的角色定义(如果判断下来还是""就是没有确认是否是部门主管)
        String currRole = "";//flow_fgld", "flow_sjfgld", "flow_zyld或者curr_user,dept_head
        {
            //1获取用户流程类型
            {
                String[] flow_roles = ConstantFlowType.FLOW_ROLES;//{"flow_fgld", "flow_sjfgld", "flow_zyld"};
                String[] roles = ConstantFlowType.ROLES;// {"fgld", "sjfgld", "zyld"};
//            frame_role_data
                List<FrameRoleData> FrameRoleDatas = flowMainService.findFrameRoleDatasByUserId(currUser.getId(), ConstantFlowType.ROLETYPE);//"FLOW"
                Integer c = null;
                //判断用户的最高用户流类型
                for (FrameRoleData frameRoleData : FrameRoleDatas) {
                    String roleKey = frameRoleData.getRoleKey();
                    for (int i = 0; i < roles.length; i++) {
                        if (roles[i].equals(roleKey)) {
                            if (c == null) {
                                c = i;
                            } else if (c < i) {
                                c = i;
                            }
                            break;
                        }
                    }
                }
                if (c != null) {
                    currRole = flow_roles[c];
                    return currRole;
                }
            }

            //2获取用户部门是否是主管
            {

                String department = flowMain.getDeptId();
                SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
                if (sysDept == null) {//没有部门信息
                    if (currRole.equals("")) {
                        currRole = "";
                        return null;
                    } else {
                        //是领导流程类型
                    }
                } else {
                    String changedBy = sysDept.getChangedBy();
                    if (StringUtils.isEmpty(changedBy)) {//没有找到部门主管
                        currRole = ConstantFlowType.FLOW_ROLES_DEPT[0];//"curr_user";
//                        if (currRole.equals("")) {
//                            currRole = "";
//                        } else {
//                            //是领导流程类型
//                        }
//                        return null;
                    } else {//找到部门主管
                        if (changedBy.equals(currUser.getId())) {//自己是部门主管
                            if (currRole.equals("")) {
                                currRole = ConstantFlowType.FLOW_ROLES_DEPT[2];//"dept_head";
                            } else {
                                //是领导流程类型
                            }
                        } else {//部门主管是别人,自己不是部门主管
                            if (currRole.equals("")) {
                                currRole = ConstantFlowType.FLOW_ROLES_DEPT[0];//"curr_user";
                            } else {
                                //是领导流程类型
                            }
                        }
                    }
                }
            }
        }
        return currRole;
    }

    /**
     * 写一个方法, 已知用户信息 zt ok
     * 申请付款时 通过用户信号获取用户在全流程中的位置,如果没有找到对象,返回为null就直接提交到admin用户去审核,如果对象里面的nodeNum是1就是正常流程,如果大于1就是非正常流程需要把目标人填自己直到自己流转到自己流程上
     */
    public UserTaskMore findUserPosition(String currRole, String deploymentid) {

        //当前用户的角色定义(如果判断下来还是""就是没有确认是否是部门主管)
//        String currRole = this.getCurrRole(currUser2);

        //没有获取到角色异常返回null
        if (currRole == null || currRole.equals("")) {
            return null;
        }
        //获取活动节点
        //这是流程排序编号
        int nodeNum = 0;
        List<UserTask> taskList = flowService.getTaskList(deploymentid);
        UserTask userTask = taskList.get(0);
        nodeNum = nodeNum + 1;
        String s = userTask.getCandidateGroups().get(0);//s=dept_head_1_0_1-yes/curr_user-no
        String setRurrRole = this.getSetRurrRole(s);
        if (currRole.equals(setRurrRole)) {//如果设置角色和当前用户角色一致,表示用户就是当前流程排序编号上
//            return userTask;
//            return nodeNum;
            return new UserTaskMore(userTask, nodeNum, userTask);
        } else {//要进行轮查获取用户位置
            UserTaskMore nextCandidateGroupByDeploy = this.getNextMyUserTask(taskList, currRole, nodeNum);
//            UserTaskMore nextCandidateGroupByDeploy = getNextCandidateGroupByDeploy(userTask, currRole, nodeNum, deploymentid);

            nextCandidateGroupByDeploy.setCurrentUserTask(userTask);
            return nextCandidateGroupByDeploy;
        }
    }

    /**
     * 申请付款时 通过传递的数据递归获取用户角色实际的运行节点
     *
     * @return
     */
    public UserTaskMore getNextMyUserTask(List<UserTask> taskList, String currRole, Integer nodeNum) {
        for (int i = 1; i < taskList.size(); i++) {
            nodeNum = 2;
            UserTask myuserTask = taskList.get(i);
            String taskKey = myuserTask.getCandidateGroups().get(0);//s=dept_head_1_0_1-yes/curr_user-no
            String taskSetRurrRole = this.getSetRurrRole(taskKey);
            if (currRole.equals(taskSetRurrRole)) {//如果设置角色和当前用户角色一致,表示用户就是当前流程排序编号上
                System.out.println("2结束节点" + nodeNum);
//                return userTask;
//                return nodeNum;
                return new UserTaskMore(myuserTask, nodeNum);
            }
        }
        return null;
    }


    /**
     * 这个方法有问题,不能获取自己想要的,放弃使用了
     * 申请付款时 通过传递的数据递归获取用户角色实际的运行节点
     *
     * @param newUserTask
     * @param currRole
     * @param nodeNum
     * @return
     */
    public UserTaskMore getNextCandidateGroupByDeploy(UserTask newUserTask, String currRole, Integer nodeNum, String deploymentid) {
        List<Object> nextCandidateGroupByDeploy = flowService.getNextCandidateGroupByDeploy(deploymentid, newUserTask.getId(), false);


        if (!nextCandidateGroupByDeploy.isEmpty() && nextCandidateGroupByDeploy.size() >= 1) {
//            //进行分支判断
//            for (int i = 0; i < nextCandidateGroupByDeploy.size(); i++) {
//                UserTask userTask = (UserTask) nextCandidateGroupByDeploy.get(i);
//                String taskKey = userTask.getCandidateGroups().get(0);//dept_head_1_0_1-yes
//                String yesNo = taskKey.substring(taskKey.indexOf("-"));
//                if (!"yes".equals(yesNo)) {
//                    continue;
//                }
//                String setRurrRole = this.getSetRurrRole(taskKey);//获取任务的角色
//
//            }


            nodeNum = nodeNum + 1;
            System.out.println("运行节点" + nodeNum);
            UserTask userTask = (UserTask) nextCandidateGroupByDeploy.get(0);
            String s = userTask.getCandidateGroups().get(0);//s=dept_head_1_0_1-yes/curr_user-no
            String setRurrRole = this.getSetRurrRole(s);
            if (currRole.equals(setRurrRole)) {//如果设置角色和当前用户角色一致,表示用户就是当前流程排序编号上
                System.out.println("1结束节点" + nodeNum);
//                return userTask;
//                return nodeNum;
                return new UserTaskMore(userTask, nodeNum);
            } else {
                getNextCandidateGroupByDeploy(userTask, currRole, nodeNum, deploymentid);
            }
        } else {
            return null;
        }
        return null;
    }


    @Autowired
    private FrameUserDeptService frameUserDeptService;

    /**
     * 获取部门领导
     *
     * @param currUser
     * @param flowMain
     * @return
     */
    public FrameUser getDepartmentChargedBy(FrameUser currUser, FlowMain flowMain) {
        FrameUser targetUser = null;
        String department = null;
        if (ConstantFlowType.isMoreDept) {
            department = flowMain.getDeptId();
        } else {
            department = currUser.getDepartment();
        }

        SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
        if (sysDept == null) {//没有部门信息

        } else {
            String chargedBy = sysDept.getChangedBy();
            if (StringUtils.isEmpty(chargedBy)) {//没有找到部门主管

            } else {
                targetUser = userService.selectByPrimaryKey(chargedBy);
            }
        }
        return targetUser;
    }

    /**
     * 写一个通用方法,专门根据条件获取部门领导是谁
     * targetRole:下一个审核人的角色
     * currUser:当前的审核人角色
     * 返回 部门的目标用户和对应的角色,如果部门的目标用户没有找到,就返回下个节点的角色信息(并且下个节点必定不是部门用户信息),目标用户为空
     */
    public TagerUserAndFlowRole getTargerUser_FLOW_ROLES_DEPT(String targetRole, FrameUser currUser, FlowMain flowMain) {
        TagerUserAndFlowRole tagerUserAndFlowRole = new TagerUserAndFlowRole();
        FrameUser targetUser = null;
        if (targetRole.equals(ConstantFlowType.FLOW_ROLES_DEPT[2])) {//发现下一个审核人是部门领导,要去找部门领导
            targetUser = this.getDepartmentChargedBy(currUser, flowMain);
            if (targetUser == null) {
                String nextRole = null;
                String[] onlyFlowFlowStep = flowMainService.getOnlyFlowFlowStep(flowMain);
                {//获取直接领导的下的流程节点是什么
                    for (int i = 0; i < onlyFlowFlowStep.length; i++) {
                        if (onlyFlowFlowStep[i].startsWith(ConstantFlowType.FLOW_ROLES_DEPT[2])) {
                            if (i == (onlyFlowFlowStep.length - 1)) {
                                nextRole = null;
                            } else {
                                nextRole = onlyFlowFlowStep[i + 1];
                            }
                            break;
                        }
                    }
                }
                if (nextRole == null) {
                    tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                    return tagerUserAndFlowRole;
                } else {
                    tagerUserAndFlowRole.setFlowRole(nextRole);
                    tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                    return tagerUserAndFlowRole;
                }
            } else {
                tagerUserAndFlowRole.setFlowRole(this.getAllFlowRole(ConstantFlowType.FLOW_ROLES_DEPT[2], flowMain.getFlowType()));
                tagerUserAndFlowRole.setFrameUser(targetUser);
//                tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                return tagerUserAndFlowRole;
            }
        } else {
            String leader = null;
            if (ConstantFlowType.isMoreDept) {
                FrameUserDeptExample frameUserDeptExample = new FrameUserDeptExample();
                frameUserDeptExample.createCriteria().andDeptIdEqualTo(flowMain.getDeptId()).andUserIdEqualTo(flowMain.getCreatedBy());
                List<FrameUserDept> frameUserDepts = frameUserDeptService.selectByExample(frameUserDeptExample);
                if (frameUserDepts.isEmpty()) {
                    String nextRole = null;
                    String[] onlyFlowFlowStep = flowMainService.getOnlyFlowFlowStep(flowMain);
                    int findSetpI = 0;
                    {//获取直接领导的下的流程节点是什么
                        for (int i = 0; i < onlyFlowFlowStep.length; i++) {
                            if (onlyFlowFlowStep[i].startsWith(ConstantFlowType.FLOW_ROLES_DEPT[1])) {
                                if (i == (onlyFlowFlowStep.length - 1)) {
                                    nextRole = null;
                                } else {
                                    nextRole = onlyFlowFlowStep[i + 1];
                                    findSetpI = i + 1;
                                }
                                break;
                            }
                        }
                    }
                    if (nextRole == null) {
                        tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                        return tagerUserAndFlowRole;
                    } else if (!nextRole.startsWith(ConstantFlowType.FLOW_ROLES_DEPT[2])) {
                        tagerUserAndFlowRole.setFlowRole(nextRole);
                        tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                        return tagerUserAndFlowRole;
                    } else {
                        if (findSetpI == (onlyFlowFlowStep.length - 1)) {
                            tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                            return tagerUserAndFlowRole;
                        } else {
                            tagerUserAndFlowRole.setFlowRole(onlyFlowFlowStep[findSetpI + 1]);
                            tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                            return tagerUserAndFlowRole;
                        }
                    }

                } else {
//                    leader = frameUserDepts.get(0).getLeaderId();
                }
            } else {
                leader = currUser.getLeader();
            }

            if (StringUtils.isEmpty(leader)) {//没有找到直接领导
                String nextRole = null;
                String[] onlyFlowFlowStep = flowMainService.getOnlyFlowFlowStep(flowMain);
                int findSetpI = 0;
                {//获取直接领导的下的流程节点是什么
                    for (int i = 0; i < onlyFlowFlowStep.length; i++) {
                        if (onlyFlowFlowStep[i].startsWith(ConstantFlowType.FLOW_ROLES_DEPT[1])) {
                            if (i == (onlyFlowFlowStep.length - 1)) {
                                nextRole = null;
                            } else {
                                nextRole = onlyFlowFlowStep[i + 1];
                                findSetpI = i + 1;
                            }
                            break;
                        }
                    }
                }
                if (nextRole == null) {
                    tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                    return tagerUserAndFlowRole;
                } else if (!nextRole.startsWith(ConstantFlowType.FLOW_ROLES_DEPT[2])) {
                    tagerUserAndFlowRole.setFlowRole(nextRole);
                    tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                    return tagerUserAndFlowRole;
                } else {
                    targetUser = this.getDepartmentChargedBy(currUser, flowMain);
                    if (targetUser == null) {
                        if (findSetpI == (onlyFlowFlowStep.length - 1)) {
                            tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                            return tagerUserAndFlowRole;
                        } else {
                            tagerUserAndFlowRole.setFlowRole(onlyFlowFlowStep[findSetpI + 1]);
                            tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                            return tagerUserAndFlowRole;
                        }

                    } else {
                        tagerUserAndFlowRole.setFlowRole(this.getAllFlowRole(ConstantFlowType.FLOW_ROLES_DEPT[2], flowMain.getFlowType()));
                        tagerUserAndFlowRole.setFrameUser(targetUser);
                        tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                        return tagerUserAndFlowRole;
                    }
                }


            } else {
                targetUser = userService.selectByPrimaryKey(leader);
                tagerUserAndFlowRole.setFlowRole(this.getAllFlowRole(ConstantFlowType.FLOW_ROLES_DEPT[1], flowMain.getFlowType()));
                tagerUserAndFlowRole.setFrameUser(targetUser);
//                tagerUserAndFlowRole.setOnlyFlowFlowStep(onlyFlowFlowStep);
                return tagerUserAndFlowRole;
            }
        }
//        if (targetUser == null) {//没有找到目标人就都传到admin中去
////                                    return null;
//            System.out.println("6没有找到对应人:" + "if (targetUser == null) {");
//            targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//            if (targetUser == null) {
//                System.err.println("异常,没有找到目标人");
//                return null;
//            }
//        }
//        return targetUser;
    }

    /**
     * 通过角色关键字,反查本流程节点全部信息,和下面的方法相反
     *
     * @param shortRole
     * @param flowType
     * @return
     */
    public String getAllFlowRole(String shortRole, String flowType) {
        String[] onlylowStepAll = flowMainService.getOnlylowStepAll(flowType);
        for (int i = 0; i < onlylowStepAll.length; i++) {
            if (onlylowStepAll[i].startsWith(shortRole)) {
                return onlylowStepAll[i];
            }
        }
        throw new RuntimeException("异常错误,没有获取到角色信息!");
//        return null;
    }

    /**
     * 通过原key获取角色数据
     *
     * @param s
     * @return
     */
    public static String getSetRurrRole(String s) {
//        String s="dept_head_1_0_1-yes";或者curr_user-no
        String[] s1 = s.contains("-") ? s.substring(0, s.indexOf("-")).split("_") : s.split("_");
        s = s1[0] + "_" + s1[1];
//        System.out.println(s);
        return s;
    }
    /**
     * 采购相关没有用到
     * @param targetRole
     * @param currUser
     * @return
     */
//    public FrameUser getTargerUser_FLOW_ROLES_DEPT_PLUS(String targetRole, FrameUser currUser) {
//        FrameUser targetUser = null;
//        if (targetRole.equals(ConstantFlowType.FLOW_ROLES_DEPT[2])) {//发现下一个审核人是部门领导,要去找部门领导
//            String department = currUser.getDepartment();
//            SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
//            if (sysDept == null) {//没有部门信息
//            } else {
//                String changedBy = sysDept.getChargedBy();
//                if (StringUtils.isEmpty(changedBy)) {//没有找到部门主管
//
//                } else {
//                    targetUser = userService.selectByPrimaryKey(changedBy);
//                }
//            }
//        } else {
//            String leader = currUser.getLeader();
//            if (StringUtils.isEmpty(leader)) {//没有找到直接领导
//                // 流转给子公司超管
//                FrameRoleDataExample example = new FrameRoleDataExample();
//                example.createCriteria().andRoleKeyEqualTo(ConstantFlowType.PURCHASE_ROLES_CHECK_PLUS)
//                        .andRoleTypeEqualTo(ConstantFlowType.ROLETYPE2);
//                List<FrameRoleData> frameRoleDataList = frameRoleDataService.selectByExample(example);
//                if(CollectionUtils.isNotEmpty(frameRoleDataList)) {
//                    FrameRoleData frameRoleData = frameRoleDataList.get(0);
//                    List<String> userIds = frameRoleDataUserService.selectUserByRoleDataId(frameRoleData.getId());
//                    if(CollectionUtils.isNotEmpty(userIds)) {
//                        FrameUserExample example1 = new FrameUserExample();
//                        example1.createCriteria().andIdIn(userIds).andGroupIdEqualTo(currUser.getGroupId())
//                                .andStatusEqualTo("1");
//                        List<FrameUser> frameUserList = frameUserService.selectByExample(example1);
//                        if(CollectionUtils.isNotEmpty(frameUserList)) {
//                            targetUser = frameUserList.get(0);
//                        }
//                    }
//                }
//            } else {
//                targetUser = userService.selectByPrimaryKey(leader);
//            }
//        }
//        if (targetUser == null) {//没有找到目标人就都传到admin中去
//            targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//            if (targetUser == null) {
//                return null;
//            }
//        }
//        return targetUser;
//    }

    /**
     * 没有用到
     * @param processDefine
     * @param deploymentid
     * @param businessId
     * @param currUser
     * @param conditionMap
     * @return
     * @throws com.rockstar.flow.exception.FlowException
     */
//    public Map<String, String> startPurchaseTask(String processDefine, String deploymentid, String businessId,
//                                                 FrameUser currUser, Map<String, Object> conditionMap)
//            throws com.rockstar.flow.exception.FlowException {
//        FrameUser targetUser = null;
//        String currRole = this.getCurrRole(currUser);
//        UserTaskMore userPosition = this.findUserPosition(currRole, deploymentid);
//        Map<String, String> startTask;
//        if (userPosition == null) {
//            targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//            if (targetUser == null) {
//                return null;
//            }
//            startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//            return startTask;
//        } else {
//            int nodeNum = userPosition.getNodeNum();
//            UserTask currentUserTask = userPosition.getCurrentUserTask();
//            if (nodeNum == 1) {
//                {
//                    List<SequenceFlow> outgoingFlows = currentUserTask.getOutgoingFlows();
//                    //我的下一个节点位置
//                    SequenceFlow myNextSequenceFlow = null;
//                    for (SequenceFlow outgoingFlow : outgoingFlows) {
//                        String conditionExpression = outgoingFlow.getConditionExpression();
//                        //如果是空就跳过
//                        if (conditionExpression == null) {
//                            continue;
//                        } else if (conditionExpression.contains("${agree=='no'}")) {//${agree=='yes'}
//                            continue;
//                        } else if (conditionExpression.contains("${agree=='back'}")) {//${agree=='yes'}
//                            continue;
//                        } else if (conditionExpression.contains("${agree=='yes'}")) {//${agree=='yes'}//xxxx
//                            //发现没有判断条件,那本流程就是下个节点
//                            myNextSequenceFlow = outgoingFlow;
//                        }
//                        //如果没有找到下个流程节点就继续找
//                        if (myNextSequenceFlow == null) {
//                            continue;
//                        }
//                        //下面是找到了下个流程节点,需要进行正常的运行节点了
//                        FlowElement targetFlowElement = myNextSequenceFlow.getTargetFlowElement();
//                        if (targetFlowElement instanceof EndEvent) {//如果是的话就是最后审核状态
//                            return null;
//                        }
//                        String candidateGroup = ((UserTask) targetFlowElement).getCandidateGroups().get(0);//targetFlowElement.getCandidateGroups();
//                        String setRurrRole = getSetRurrRole(candidateGroup);
//                        for (String s : ConstantFlowType.FLOW_ROLES_DEPT) {
//                            if (s.equals(setRurrRole)) {
//                                targetUser = this.getTargerUser_FLOW_ROLES_DEPT_PLUS(s, currUser);
//                                if (targetUser == null) {
//                                    return null;
//                                }
//                                startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                                return startTask;
//                            }
//                        }
//                        for (int i = 0; i < ConstantFlowType.FLOW_ROLES.length; i++) {
//                            if (ConstantFlowType.FLOW_ROLES[i].equals(setRurrRole)) {//1.1.2如果是领导关系的查领导
//                                //查看谁是对应角色并查找对应的人
//                                String role = ConstantFlowType.ROLES[i];
//                                List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(role,
//                                        ConstantFlowType.ROLETYPE, currUser.getGroupId());
//                                if (!targetUserList.isEmpty()) {
//                                    targetUser = targetUserList.get(0);
//                                }
//                                if (targetUser == null) {
//                                    targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//                                    if (targetUser == null) {
//                                        return null;
//                                    }
//                                }
//                                startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                                return startTask;
//                            }
//                        }
//                        for (int i = 0; i < ConstantFlowType.PURCHASE_FLOW_ROLES_CHECK.length; i++) {
//                            if (ConstantFlowType.PURCHASE_FLOW_ROLES_CHECK[i].equals(setRurrRole)) {
//                                //查看谁是对应角色并查找对应的人
//                                String role = ConstantFlowType.PURCHASE_ROLES_CHECK[i];
//                                List<FrameUser> targetUserList = flowMainService.findFrameUsersByRoleKeyAndGroup(role,
//                                        ConstantFlowType.ROLETYPE, currUser.getGroupId());
//                                if (!targetUserList.isEmpty()) {
//                                    targetUser = targetUserList.get(0);
//                                }
//                                if (targetUser == null) {
//                                    targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//                                    if (targetUser == null) {
//                                        return null;
//                                    }
//                                }
//                                startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                                return startTask;
//                            }
//                        }
//                        return null;
//                    }
//                    return null;
//                }
//            } else if (nodeNum > 1) {
//                //  2.如果大于1就是非正常流程需要把目标人填自己直到自己流转到自己流程上
//                // 需要进行循环审核过程
//                boolean isZhuYaoLingDao= "flow_zyld".equals(currRole);
//                if(isZhuYaoLingDao) {
//                    targetUser = currUser;
//                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                    if (!startTask.isEmpty()) {
//                        {
//                            List<Task> list = taskService.createTaskQuery().processInstanceBusinessKey(businessId)//创建任务查询对象
//                                    .taskAssignee(targetUser.getId())//指定个人任务查询
//                                    .list();
//                            if (list == null || list.isEmpty()) {
//                                return null;
//                            }
//                            //2.1通过flow_id和targetUser获取下一个UserTask
//                            Task task = list.get(0);
//                            //task是当前流程的信息
//                            //如果发现task对应的角色就是自己的角色,就开始正常的走
//                            //如果发现task对应的角色还不是,就需要再进行设置自己的操作
//                            String taskDefinitionKey = task.getTaskDefinitionKey();
//                            String flowId = userPosition.getUserTask().getId();
//                            if (flowId.equals(taskDefinitionKey)) {
//                                Map<String, String> donaturalTaskMap = this.donaturalTask(deploymentid, currUser, task,
//                                        conditionMap);
//                                if (donaturalTaskMap == null) {
//                                    return null;
//                                } else {
//                                    return startTask;
//                                }
//                            } else {
//                                {//遍历对象
//                                    Map<String, String> getNextFlowMap = getNextFlow(businessId, userPosition,
//                                            deploymentid, currUser, conditionMap, task);
//                                    if (getNextFlowMap == null) {
//                                        return null;
//                                    } else {
//                                        if (null != getNextFlowMap.get("isEnd")) {
//                                            startTask.put("isEnd", getNextFlowMap.get("isEnd"));
//                                        }
//                                        return startTask;
//                                    }
//                                }
//                            }
//                        }
//                    } else {
//                        return null;
//                    }
//                } else {
//                    if (currUser.getLeader()!=null) {
//                        targetUser = userService.selectByPrimaryKey(currUser.getLeader());
//                    }
//                    if (targetUser==null){
//                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//                    }
//                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                    if (!startTask.isEmpty()) {
//                        return startTask;
//                    } else {
//                        return null;
//                    }
//                }
//            } else {
//                return null;
//            }
//        }
//    }

    /**
     * 采购流程用,这里没有用到
     * @param flowMainPush
     * @param deploymentid
     * @param businessId
     * @param conditionMap
     * @return
     * @throws com.rockstar.flow.exception.FlowException
     */
//    public Map<String, String> passToRunPurchaseTask(FlowMainPush flowMainPush, String deploymentid, String businessId,
//                                                     Map<String, Object> conditionMap)
//            throws com.rockstar.flow.exception.FlowException {
//        // 发起流程引擎操作 并查看下一节点的操作要求
//        //0,如果是收纳且匹配上角色就正常流程审核,没有匹配上就返回null,异常错误 ok,
//        //1. 如果当前角色是自己,就进行正常的审核流程 ok
//        //2. 先查看当前角色是不是自己,不是自己就移动到自己的角色,然后再进行正常的审核流程 ok
//
//        //当前审核人/委托人代表的用户id
//        String myFrameUserId = this.getMyFrameUserId(flowMainPush);
//        if (myFrameUserId == null) {
//            return null;
//        }
//        //当前审核人/委托人代表的用户
//        FrameUser myframeUser = frameUserService.selectByPrimaryKey(myFrameUserId);
//        //根据任务id获取任务信息
//        //当前任务流程
//        Task task;
//        {
//            List<Task> taskList = taskService.createTaskQuery().processInstanceBusinessKey(flowMainPush.getFlowMainId())
//                    .taskId(flowMainPush.getTaskId()).list();
//            if (taskList == null || taskList.isEmpty()) {
//                return null;
//            }
//            task = taskList.get(0);
//        }
//        //本节点的关键子 例如flow_cnjs_1_1_0-yes
//        String pushUserKey = flowMainPush.getPushUserKey();
//        //本节点的角色 例如cnjs
//        String setRurrRole = getSetRurrRole(pushUserKey);
//
//        //判断setRurrRole是不是出纳类的角色,如果是出纳的角色,就判断当前审核人是不是也是出纳,是就继续,不是就是异常错误,返回null
//        //判断是否符合出纳类型的要求         ok
//        {
//            for (int i = 0; i < ConstantFlowType.PURCHASE_FLOW_ROLES_CHECK.length; i++) {
//                if (ConstantFlowType.PURCHASE_FLOW_ROLES_CHECK[i].equals(setRurrRole)) {
//                    return this.donaturalTask(deploymentid, myframeUser, task, conditionMap);
//                }
//            }
//        }
//        {
//            //当前审核人/委托人代表的用户角色(只判断了是否是主管还是 分管领导的问题, 还没有判断是否是出纳的问题,不是哪里都适用的)
//            String currRole = this.getCurrRole(myframeUser);
//            //没有获取到角色,直接对到admin那里
//            if (!StringUtils.isNotEmpty(currRole)) {
//                // 直接对到admin那里
//                FrameUser targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//                if (targetUser == null) {
//                    return null;
//                }
//                return this.donaturalTask(deploymentid, myframeUser, task, conditionMap);
//            }
//            //当发现this.getCurrRole(myframeUser);获取的角色是普通员工的时候,就知道他作为审核人只是直接上级,并不是领导,所以把角色调上一级
//            if (currRole.equals(ConstantFlowType.FLOW_ROLES_DEPT[0])) {
//                currRole = ConstantFlowType.FLOW_ROLES_DEPT[1];
//            }
//            // 不是出纳的情况下进行的判断
//            //1.如果当前角色是自己,就进行正常的审核流程 ok
//            //2.先查看当前角色是不是自己,不是自己就移动到自己的角色,然后再进行正常的审核流程 ok
//            if (setRurrRole.equals(currRole)) {//1.如果当前角色是自己,就进行正常的审核流程 ok
//                return this.donaturalTask(deploymentid, myframeUser, task, conditionMap);
//            } else {//2.先查看当前角色是不是自己,不是自己就移动到自己的角色,然后再进行正常的审核流程 ok
//                FrameUser targetUser = null;
//                UserTaskMore userPosition = this.findUserPosition(currRole, deploymentid);
////        返回为null就直接提交到admin用户去审核,如果对象里面的nodeNum是1就是正常流程,如果大于1就是非正常流程需要把目标人填自己直到自己流转到自己流程上
//                if (userPosition == null) {//没有找到数据
//                    targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//                    if (targetUser == null) {
//                        return null;
//                    }
//                    boolean yes = flowService.runTask(task.getId(), null, "yes", null, targetUser, myframeUser, conditionMap);
//                    return new HashMap<>();
//                } else {//找到userPosition数据录了
//                    //还不是自己的角色,还要遍历查找
//                    return getNextFlow(businessId, userPosition, deploymentid, myframeUser, conditionMap, task);
//                }
//            }
//        }
//    }

}