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.FlowMainPush;
import com.idea.oa.flow2.service.FlowMainLogService;
import com.idea.oa.flow2.service.FlowMainService;
import com.rockstar.flow.dto.TaskDto;
import com.rockstar.flow.service.FlowService;
import com.rockstar.frame.model.FrameRoleData;
import com.rockstar.frame.model.FrameUser;
import com.rockstar.frame.service.FrameUserService;
import com.rockstar.system.model.SysDept;
import com.rockstar.system.model.SysDeptExample;
import com.rockstar.system.service.SysDeptService;
import com.rockstar.util.StringUtils;
import org.activiti.bpmn.model.*;
import org.activiti.engine.*;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
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.*;


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

    @Autowired
    private FrameUserService userService;

    @Autowired
    RuntimeService runtimeService;
    //
//    @Autowired
//    private FramePostService postService;
//
    @Autowired
    private SysDeptService sysDeptService;
//
//
//    @Autowired
//    private FrameUserDeptService frameUserDeptService;

    @Autowired
    private FrameUserService frameUserService;


    /**
     * 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) 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,businessId);
                }
            }
        }


        {
            //当前审核人/委托人代表的用户角色(只判断了是否是主管还是 分管领导的问题, 还没有判断是否是出纳的问题,不是哪里都适用的)
            String currRole = this.getCurrRole(myframeUser);
            //没有获取到角色,直接对到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,businessId);
                }
            }
            //当发现this.getCurrRole(myframeUser);获取的角色是普通员工的时候,就知道他作为审核人只是直接上级,并不是领导,所以把角色调上一级
            if (currRole.equals(ConstantFlowType.FLOW_ROLES_DEPT[0])) {
                currRole = ConstantFlowType.FLOW_ROLES_DEPT[1];
            }
            // 不是出纳的情况下进行的判断
            //1.如果当前角色是自己,就进行正常的审核流程 ok
            //2.先查看当前角色是不是自己,不是自己就移动到自己的角色,然后再进行正常的审核流程 ok
            if ("dept_head".equals(setRurrRole) || "flow_sjfgld".equals(setRurrRole) || setRurrRole.equals(currRole)) {//1.如果当前角色是自己,就进行正常的审核流程 ok
                return this.donaturalTask(deploymentid, myframeUser, task, conditionMap,businessId);
            } 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);
                }
            }
        }
    }


    /**
     * 通用方法 写一个正常流程,正常下审核到下一个环节
     *
     * @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, String businessId) throws com.rockstar.flow.exception.FlowException {
        {
            FrameUser targetUser = null;
            //可以开始正常走流程了 嘻嘻...
            {
                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 {
                                //发现有明确的判断条件,需要判断是否满足条件才能确认是否本流程就是下个节点
                                //原来计划会有多个条件判断,但是现在就一个,所以就先写死一个条件吧
                                //获取路径的判断条件
//                                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;
//                                    break;
//                                }
                                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如果是部门关系的查部门
                                {//统一到同一个方法中了:getTargerUser_FLOW_ROLES_DEPT
//                                if (s.equals(ConstantFlowType.FLOW_ROLES_DEPT[2])) {//发现下一个审核人是部门领导,要去找部门领导
//                                    String department = currUser.getDepartment();
//                                    SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
//                                    if (sysDept == null) {//没有部门信息
//
//                                    } else {
//                                        String changedBy = sysDept.getChangedBy();
//                                        if (StringUtils.isEmpty(changedBy)) {//没有找到部门主管
//
//                                        } else {
//                                            targetUser = userService.selectByPrimaryKey(changedBy);
//                                        }
//                                    }
//                                } else {
//                                    String leader = currUser.getLeader();
//                                    if (StringUtils.isEmpty(leader)) {//没有找到直接领导
//                                    } else {
//                                        targetUser = userService.selectByPrimaryKey(leader);
//                                    }
//                                }
//                                if (targetUser == null) {//没有找到目标人就都传到admin中去
////                                    return null;
//                                    targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
//                                    if (targetUser == null) {
//                                        System.err.println("异常,没有找到目标人");
//                                        return null;
//                                    }
//                                }
                                }
//                                写一个通用方法,专门根据条件获取部门领导是谁
                                targetUser = this.getTargerUser_FLOW_ROLES_DEPT(s, currUser,businessId);
                                if (targetUser == null) {
                                    return null;
                                }
                                //todo  SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
                                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,currUser.getGroupId());
                                    if (!targetUserList.isEmpty()) {
                                        if (targetUserList.size() >= 1) {
                                            targetUser = targetUserList.get(0);
                                        }
                                    }
                                    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("异常,没有找到目标人");
//                                            return null;
//                                        }
                                      return  this.jumpNextNode(task2,deploymentid,currUser,setRurrRole,conditionMap,businessId);
                                    }
                                    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,currUser.getGroupId());
                                    if (!targetUserList.isEmpty()) {
                                        if (targetUserList.size() >= 1) {
                                            targetUser = targetUserList.get(0);
                                        }
                                    }
                                    if (targetUser == null) {
//                                        return null;
                                        System.out.println("2没有找到对应人:" + "if (targetUser == null) {");
                                        targetUser = userService.selectByPrimaryKey(ConstantFlowType.ADMINID);
                                        if (targetUser == null) {
                                            System.err.println("异常,没有找到目标人");
                                            return null;
                                        }
                                    }
                                    boolean yes = flowService.runTask(task2.getId(), null, "yes", null, targetUser, currUser, conditionMap);
                                    end = true;
                                    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;
                    }
                }
            } else if (mycondition.contains("isProSales==")) {
                String isExchangeOnly = conditionMap.get("isProSales").toString();
                Double applyDay = Double.valueOf(conditionMap.get("preSales").toString());
                if (mycondition.contains("(isProSales=='no') or (preSales>=2000000)")) {
                    if ("no".equals(isExchangeOnly) && applyDay >= 2000000) {
                        isOk = true;
                    }
                } else if (mycondition.contains("(isProSales=='yes') or (preSales<2000000)")) {
                    if ("yes".equals(isExchangeOnly) || applyDay < 2000000) {
                        isOk = true;
                    }
                }
            }
            if (isOk) {
                isOkNum = isOkNum + 1;
            }
        }

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

    /**
     * 流程重新梳理 pany 2023/11/22
     * 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> startTask2(String processDefine, String deploymentid, String businessId, FrameUser currUser, Map<String, Object> conditionMap) throws com.rockstar.flow.exception.FlowException {
//        FrameUser targetUser = null;
//        List<UserTask> taskList = flowService.getTaskList(deploymentid);
//        for(UserTask userTask : taskList){
//            String s = userTask.getCandidateGroups().get(0);//s=dept_head_1_0_1-yes/curr_user-no
//            String setRurrRole = this.getSetRurrRole(s);
//        }
//
//    }

    /**
     * 根据用户位置启动信息启动流程
     * 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, 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);
//        返回为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 {
                                    //发现有明确的判断条件,需要判断是否满足条件才能确认是否本流程就是下个节点
                                    //原来计划会有多个条件判断,但是现在就一个,所以就先写死一个条件吧
                                    //获取路径的判断条件
//                                    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;
//                                        break;
//                                    }
                                    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如果是部门关系的查部门
//统一到同一个方法中了:getTargerUser_FLOW_ROLES_DEPT
//                                写一个通用方法,专门根据条件获取部门领导是谁
                                targetUser = this.getTargerUser_FLOW_ROLES_DEPT(s, currUser,businessId);
                                if (targetUser == null) {
                                    return null;
                                }
                                //todo   SysDept sysDept = sysDeptService.selectByPrimaryKey(department);

                                startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                                end = true;
                                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,currUser.getGroupId());
                                    if (!targetUserList.isEmpty()) {
                                        if (targetUserList.size() >= 1) {
                                            targetUser = targetUserList.get(0);
                                        }
                                    }
                                    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;
                                        }
                                    }
                                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                                    end = true;
                                    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,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;
                                        }
                                    }
                                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
                                    end = true;
                                    return startTask;
                                }
                            }
                        }
                        return null;
                    }
                    //走到这里就没有找到对应的流程节点,所以需要报错 返回null
                    System.out.println("异常错误,没有找到对应的流程节点");
                    return null;

                }
                //下面的要作废了================================================================
                //获取下个节点数据
//                {
//                    List<Object> nextCandidateGroupByDeploy = flowService.getNextCandidateGroupByDeploy(deploymentid, currentUserTask.getId(), false);
//                    if (!nextCandidateGroupByDeploy.isEmpty() && nextCandidateGroupByDeploy.size() >= 1) {
//                        UserTask userTask = (UserTask) nextCandidateGroupByDeploy.get(0);
//                        String candidateGroup = userTask.getCandidateGroups().get(0);//dept_superior_1_0_1-yes
//                        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;
//                                }
//                                startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                                end = true;
//                                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);
//                                    if (!targetUserList.isEmpty()) {
//                                        if (targetUserList.size() >= 1) {
//                                            targetUser = targetUserList.get(0);
//                                        }
//                                    }
//                                    if (targetUser == null) {
//                                        return null;
//                                    }
//                                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                                    end = true;
//                                    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);
//                                    if (!targetUserList.isEmpty()) {
//                                        if (targetUserList.size() >= 1) {
//                                            targetUser = targetUserList.get(0);
//                                        }
//                                    }
//                                    if (targetUser == null) {
//                                        return null;
//                                    }
//                                    startTask = flowService.startTask(processDefine, null, businessId, targetUser, currUser);
//                                    end = true;
//                                    return startTask;
//                                }
//                            }
//                        }
//                        return null;
//
//                    } else {
//                        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)) {
                        //可以开始正常走流程了 嘻嘻...
                        {
//                            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
//                                    //需要的角色
//                                    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, 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(task.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(task.getId(), null, "yes", null, targetUser, currUser, conditionMap);
//                                                end = true;
//                                                return new HashMap<>();
//                                            }
//                                        }
//                                    }
//                                    break;
//                                }
//                            } else {
//                                System.out.println("已经没有下个申请流程了,已经结束了");
//                                return null;
//                            }
                        }

                        Map<String, String> donaturalTaskMap = this.donaturalTask(deploymentid, currUser, task, conditionMap,businessId);
                        if (donaturalTaskMap == null) {
                            return null;
                        } else {
                            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);
                            if (getNextFlowMap == null) {
                                return null;
                            } else {
                                //todo 如果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 (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,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) 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)||"_5".equals(taskDefinitionKey2)||"_7".equals(taskDefinitionKey2)) {
                //可以开始正常走流程了 嘻嘻...
                {
//                    //可以开始正常走流程了 嘻嘻...
//                    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
//                            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;
//                        }
//                    } else {
//                        System.out.println("已经没有下个申请流程了,已经结束了");
//                        return null;
//                    }
//
                }
                return this.donaturalTask(deploymentid, currUser, task2, conditionMap,businessId);
            } else {
                //还不是自己的角色,还要遍历查找
                return getNextFlow(businessId, userPosition, deploymentid, currUser, conditionMap, task2);
            }

        }
//        return null;
    }

    /**
     * 共用方法 //当前用户的角色定义(如果判断下来还是""就是没有确认是否是部门主管),
     * 但是注意,这只是判断是否是主管还是 分管领导的问题, 还没有判断是否是出纳的问题,不是哪里都适用的
     *
     * @param currUser
     * @return
     */
    public String getCurrRole(FrameUser currUser) {
        //当前用户的角色定义(如果判断下来还是""就是没有确认是否是部门主管)
      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 = currUser.getDepartment();
                SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
                if (sysDept == null) {//没有部门信息
                    if (currRole.equals("")) {
                        currRole = "";
                        return null;
                    } else {
                        //是领导流程类型
                    }
                } else {
                    String changedBy = sysDept.getChangedBy();
                    if (StringUtils.isEmpty(changedBy)) {//没有找到部门主管
                        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 {//部门主管是别人,自己不是部门主管
                            //在用该用户作为部门负责人在部门表中再查一次，防止部门的负责人不在此部门中
                            SysDeptExample sysDeptExample = new SysDeptExample();
                            sysDeptExample.createCriteria().andChangedByLike(currUser.getId());
                            List<SysDept> sysDepts = sysDeptService.selectByExample(sysDeptExample);
                            if(CollectionUtils.isNotEmpty(sysDepts)){
                                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;
    }

    /**
     * 通过原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;
    }

    /**
     * 写一个通用方法,专门根据条件获取部门领导是谁
     * targetRole:下一个审核人的角色
     * currUser:当前的审核人角色
     */
    public FrameUser getTargerUser_FLOW_ROLES_DEPT(String targetRole, FrameUser currUser,String businessId) {
        FrameUser targetUser = null;
        FlowMain flowMain = flowMainService.selectByPrimaryKey(businessId);
        if(flowMain!=null){
            currUser = userService.selectByPrimaryKey(flowMain.getApplyUser());
        }

        if (targetRole.equals(ConstantFlowType.FLOW_ROLES_DEPT[2])) {//发现下一个审核人是部门领导,要去找部门领导
            String department = currUser.getDepartment();
            SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
            if (sysDept == null) {//没有部门信息

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

                } else {
                    targetUser = userService.selectByPrimaryKey(changedBy);
                }
            }
        } else {
            String leader = currUser.getLeader();
            if (StringUtils.isEmpty(leader)) {//没有找到直接领导
            } else {
                targetUser = userService.selectByPrimaryKey(leader);
            }
        }
        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 currUser
     * @return
     */
    public Boolean getHasCurrRole(FrameUser currUser) {
        //当前用户的角色定义(如果判断下来还是""就是没有确认是否是部门主管)
        String currRole = "";//flow_fgld", "flow_sjfgld", "flow_zyld或者curr_user,dept_head
        Boolean currRoleBo = false;
        {
            //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) {
                     if(Arrays.asList(flow_roles).contains(frameRoleData.getRoleKey())){
                         currRoleBo = true;
                     }
                }
                if(currRoleBo)return currRoleBo;
            }

            //2获取用户部门是否是主管
            {
                String department = currUser.getDepartment();
                SysDept sysDept = sysDeptService.selectByPrimaryKey(department);
                if (sysDept == null) {//没有部门信息
                    if (currRole.equals("")) {
                        currRole = "";
                        return currRoleBo;
                    } else {
                        //是领导流程类型
                    }
                } else {
                    String changedBy = sysDept.getChangedBy();
                    if (StringUtils.isEmpty(changedBy)) {//没有找到部门主管
                        if (currRole.equals("")) {
                            currRole = "";
                        } else {
                            //是领导流程类型
                        }
                        return currRoleBo;
                    } else {//找到部门主管
                        if (changedBy.equals(currUser.getId())) {//自己是部门主管
                            if (currRole.equals("")) {
                                currRole = ConstantFlowType.FLOW_ROLES_DEPT[2];//"dept_head";
                            } else {
                                //是领导流程类型
                            }
                        } else {//部门主管是别人,自己不是部门主管
                            //在用该用户作为部门负责人在部门表中再查一次，防止部门的负责人不在此部门中
                            SysDeptExample sysDeptExample = new SysDeptExample();
                            sysDeptExample.createCriteria().andChangedByLike(currUser.getId());
                            List<SysDept> sysDepts = sysDeptService.selectByExample(sysDeptExample);
                            if(CollectionUtils.isNotEmpty(sysDepts)){
                                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 currRoleBo;
    }

    /**
     * 当sourceTask 的审核人是空的话，跳过该任务节点
     * @param sourceTask  当前的任务节点
     * @param deploymentId 流程ID
     * @param currUser   当前操作人
     * @param currRole   当前角色
     * @param conditionMap
     * @param businessId  flowMainId
     * @return
     * @throws com.rockstar.flow.exception.FlowException
     */
    public  Map<String, String> jumpNextNode(Task sourceTask,String deploymentId,FrameUser currUser,String currRole, Map<String, Object> conditionMap, String businessId) throws com.rockstar.flow.exception.FlowException {
        List<UserTask> taskList = flowService.getTaskList(deploymentId);
        UserTask myuserTask2 = null;
        for (int i = 1; i < taskList.size(); i++) {
            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(taskSetRurrRole.equals(currRole)){
                myuserTask2 = myuserTask;
                break;
            }
        }
        //跳过当前节点
        jumpToTask(sourceTask,myuserTask2.getId());

        //获取新节点
        Task task = null;
        {
            List<Task> taskList2 = taskService.createTaskQuery().processInstanceBusinessKey(businessId).list();
            if (taskList == null || taskList.isEmpty()) {
                return new HashMap<>();
            }
            task = taskList2.get(0);
        }
        //继续正常审核
        return donaturalTask(deploymentId,currUser,task,conditionMap,businessId);
    }
    private  void jumpToTask(Task sourceTask,String targetTaskDefinitionKey){
        //取得当前节点的信息
        //取得指定节点的信息（TaskDefinitionKey）
        //保存当前节点的流向
        //新建流向，由当前节点指向新节点(指定节点)
        //当前节点完成任务=流向指定节点
        //将当前节点的流向还原


        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        TaskService taskService = processEngine.getTaskService();

        //获取该工作流的bpmn模板
        BpmnModel bpmnModel = repositoryService.getBpmnModel(sourceTask.getProcessDefinitionId());


        //  获取当前活动节点
        FlowNode currentFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(sourceTask.getTaskDefinitionKey());
        //  获取指定活动节点
        FlowNode lastFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(targetTaskDefinitionKey);



        //  临时保存当前活动的原始方向 ，最后需要用到他恢复正确的方向
        List<SequenceFlow> originalSequenceFlowList = new ArrayList<>();
        originalSequenceFlowList.addAll(currentFlowNode.getOutgoingFlows());
        //  清理当前活动方向
        currentFlowNode.getOutgoingFlows().clear();


        //  建立新方向
        SequenceFlow newSequenceFlow = new SequenceFlow();
        newSequenceFlow.setId("newSequenceFlowId");//这个可以随机
        newSequenceFlow.setSourceFlowElement(currentFlowNode);//源
        newSequenceFlow.setTargetFlowElement(lastFlowNode);//目标
        List<SequenceFlow> newSequenceFlowList = new ArrayList<>();
        newSequenceFlowList.add(newSequenceFlow);
        //  当前节点指向新的方向
        currentFlowNode.setOutgoingFlows(newSequenceFlowList);

        //  完成当前任务 = 跳转到指定的节点任务
        taskService.complete(sourceTask.getId());

        //  恢复原始方向
        currentFlowNode.setOutgoingFlows(originalSequenceFlowList);
    }

}