package jnpf.flowable.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import jnpf.base.UserInfo;
import jnpf.base.entity.DictionaryDataEntity;
import jnpf.base.entity.SystemEntity;
import jnpf.base.entity.VisualdevEntity;
import jnpf.base.model.module.ModuleModel;
import jnpf.base.service.SuperServiceImpl;
import jnpf.constant.JnpfConst;
import jnpf.constant.MsgCode;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.entity.*;
import jnpf.flowable.enums.*;
import jnpf.flowable.mapper.*;
import jnpf.flowable.model.candidates.CandidateCheckFo;
import jnpf.flowable.model.candidates.CandidateCheckVo;
import jnpf.flowable.model.candidates.CandidateListModel;
import jnpf.flowable.model.candidates.CandidateUserVo;
import jnpf.flowable.model.flowable.FlowAbleUrl;
import jnpf.flowable.model.flowable.FlowableNodeModel;
import jnpf.flowable.model.flowable.NextOrPrevFo;
import jnpf.flowable.model.message.FlowMsgModel;
import jnpf.flowable.model.monitor.MonitorVo;
import jnpf.flowable.model.operator.OperatorVo;
import jnpf.flowable.model.record.NodeRecordModel;
import jnpf.flowable.model.task.*;
import jnpf.flowable.model.template.BeforeInfoVo;
import jnpf.flowable.model.templatejson.TemplateJsonInfoVO;
import jnpf.flowable.model.templatenode.ButtonModel;
import jnpf.flowable.model.templatenode.TaskNodeModel;
import jnpf.flowable.model.templatenode.nodejson.Assign;
import jnpf.flowable.model.templatenode.nodejson.CounterSignConfig;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.util.FlowNature;
import jnpf.flowable.service.RejectDataService;
import jnpf.flowable.service.TaskService;
import jnpf.flowable.util.*;
import jnpf.permission.entity.UserEntity;
import jnpf.permission.model.authorize.AuthorizeVO;
import jnpf.util.*;
import jnpf.util.context.RequestContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * 类的描述
 *
 * @author JNPF@YinMai Info. Co., Ltd
 * @version 5.0.x
 * @since 2024/4/17 15:09
 */
@Service
public class TaskServiceImpl extends SuperServiceImpl<TaskMapper, TaskEntity> implements TaskService {

    @Autowired
    private FlowAbleUrl flowAbleUrl;
    @Autowired
    private ServiceUtil serviceUtil;
    @Autowired
    private ConditionUtil conditionUtil;
    @Autowired
    private OperatorUtil operatorUtil;
    @Autowired
    private NodeUtil nodeUtil;
    @Autowired
    private MsgUtil msgUtil;
    @Autowired
    private ButtonUtil buttonUtil;
    @Autowired
    private RecordUtil recordUtil;
    @Autowired
    private FlowUtil flowUtil;

    @Autowired
    private TemplateMapper templateMapper;
    @Autowired
    private TemplateJsonMapper templateJsonMapper;
    @Autowired
    private TemplateNodeMapper templateNodeMapper;
    @Autowired
    private LaunchUserMapper launchUserMapper;
    @Autowired
    private CandidatesMapper candidatesMapper;
    @Autowired
    private OperatorMapper operatorMapper;
    @Autowired
    private RecordMapper recordMapper;
    @Autowired
    private CirculateMapper circulateMapper;
    @Autowired
    private CommentMapper commentMapper;
    @Autowired
    private RejectDataService rejectDataService;
    @Autowired
    private NodeRecordMapper nodeRecordMapper;
    @Autowired
    private TaskLineMapper taskLineMapper;
    @Autowired
    private RevokeMapper revokeMapper;
    @Autowired
    private TriggerTaskMapper triggerTaskMapper;
    @Autowired
    private TriggerRecordMapper triggerRecordMapper;
    @Autowired
    private EventLogMapper eventLogMapper;
    @Autowired
    private TemplateUseNumMapper templateUseNumMapper;

    @Override
    public TaskEntity getInfoSubmit(String id, SFunction<TaskEntity, ?>... columns) {
        return this.baseMapper.getInfoSubmit(id, columns);
    }

    @Override
    public List<TaskEntity> getInfosSubmit(String[] ids, SFunction<TaskEntity, ?>... columns) {
        return this.baseMapper.getInfosSubmit(ids, columns);
    }

    @Override
    public List<TaskVo> getList(TaskPagination pagination) {
        String userId = UserProvider.getUser().getUserId();
        List<Integer> templateStatusList = ImmutableList.of(TemplateStatueEnum.up.getCode(), TemplateStatueEnum.downContinue.getCode());
        List<Integer> taskStatusList = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(),
                TaskStatusEnum.RUNNING.getCode(), TaskStatusEnum.PAUSED.getCode(),
                TaskStatusEnum.BACKED.getCode(), TaskStatusEnum.RECALL.getCode());
        MPJLambdaWrapper<TaskEntity> queryWrapper = JoinWrappers.lambda(TaskEntity.class)
                .select(TaskEntity::getId, TaskEntity::getFullName, TaskEntity::getStartTime,
                        TaskEntity::getCurrentNodeName, TaskEntity::getFlowName, TaskEntity::getFlowType,
                        TaskEntity::getFlowVersion, TaskEntity::getParentId, TaskEntity::getStatus,
                        TaskEntity::getFlowCategory, TaskEntity::getFlowCode, TaskEntity::getFlowId,
                        TaskEntity::getInstanceId, TaskEntity::getTemplateId
                )
                .selectAs(TaskEntity::getDelegateUserId, TaskVo::getDelegateUser)
                .selectAs(TaskEntity::getUrgent, TaskVo::getFlowUrgent)
                .selectAs(TemplateEntity::getSystemId, TaskVo::getSystemName)
                .selectAs(TaskEntity::getCreatorUserId, TaskVo::getCreatorUser)
                .leftJoin(TemplateEntity.class, TemplateEntity::getId, TaskEntity::getTemplateId)
                .and(e -> e.in(TemplateEntity::getStatus, templateStatusList)
                        .or(t -> t.eq(TemplateEntity::getStatus, TemplateStatueEnum.downHidden.getCode()).notIn(TaskEntity::getStatus, taskStatusList))
                );

        List<DelegateEntity> delegateList = flowUtil.getByToUserId(userId, 0);
        queryWrapper.and(t -> {
            t.eq(TaskEntity::getCreatorUserId, userId);
            for (DelegateEntity delegate : delegateList) {
                if (StringUtil.isNotEmpty(delegate.getFlowId())) {
                    String[] flowIds = delegate.getFlowId().split(",");
                    t.or(tw -> tw.in(TaskEntity::getTemplateId, flowIds)
                            .eq(TaskEntity::getCreatorUserId, delegate.getUserId()).eq(TaskEntity::getDelegateUserId, userId)
                            .between(TaskEntity::getStartTime, delegate.getStartTime(), delegate.getEndTime())
                    );
                } else {
                    t.or().eq(TaskEntity::getCreatorUserId, delegate.getUserId()).eq(TaskEntity::getDelegateUserId, userId)
                            .between(TaskEntity::getStartTime, delegate.getStartTime(), delegate.getEndTime());
                }
            }
        });

        //关键字（流程名称、流程编码）
        String keyWord = pagination.getKeyword();
        if (ObjectUtil.isNotEmpty(keyWord)) {
            queryWrapper.and(t -> t.like(TaskEntity::getEnCode, keyWord).or().like(TaskEntity::getFullName, keyWord));
        }
        //日期范围（近7天、近1月、近3月、自定义）
        if (ObjectUtil.isNotEmpty(pagination.getStartTime()) && ObjectUtil.isNotEmpty(pagination.getEndTime())) {
            queryWrapper.between(TaskEntity::getStartTime, new Date(pagination.getStartTime()), new Date(pagination.getEndTime()));
        }
        //所属流程
        String templateId = pagination.getTemplateId();
        if (ObjectUtil.isNotEmpty(templateId)) {
            queryWrapper.eq(TaskEntity::getTemplateId, templateId);
        }
        //流程状态
        Integer status = pagination.getStatus();
        if (ObjectUtil.isNotEmpty(status)) {
            if (status.equals(0)) {// 待提交
                List<Integer> list = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(), TaskStatusEnum.BACKED.getCode()
                        , TaskStatusEnum.RECALL.getCode());
                queryWrapper.in(TaskEntity::getStatus, list);
            } else if (status.equals(1)) { // 进行中
                List<Integer> list = ImmutableList.of(TaskStatusEnum.RUNNING.getCode(), TaskStatusEnum.PAUSED.getCode());
                queryWrapper.in(TaskEntity::getStatus, list);
            } else { // 已完成
                List<Integer> list = ImmutableList.of(TaskStatusEnum.PASSED.getCode(), TaskStatusEnum.REJECTED.getCode(),
                        TaskStatusEnum.CANCEL.getCode(), TaskStatusEnum.REVOKED.getCode());
                queryWrapper.in(TaskEntity::getStatus, list);
            }
        }
        //紧急程度
        Integer flowUrgent = pagination.getFlowUrgent();
        if (ObjectUtil.isNotEmpty(flowUrgent)) {
            queryWrapper.eq(TaskEntity::getUrgent, flowUrgent);
        }
        //所属分类
        String flowCategory = pagination.getFlowCategory();
        if (ObjectUtil.isNotEmpty(flowCategory)) {
            queryWrapper.eq(TaskEntity::getFlowCategory, flowCategory);
        }
        //应用主键
        String systemId = pagination.getSystemId();
        if (ObjectUtil.isNotEmpty(systemId)) {
            queryWrapper.eq(TemplateEntity::getSystemId, systemId);
        }
        //排序
        queryWrapper.orderByAsc(TaskEntity::getStatus).orderByDesc(TaskEntity::getStartTime);
        Page<TaskVo> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
        IPage<TaskVo> taskEntityPage = this.selectJoinListPage(page, TaskVo.class, queryWrapper);

        return pagination.setData(taskEntityPage.getRecords(), page.getTotal());
    }

    @Override
    public List<MonitorVo> getMonitorList(TaskPagination pagination) {
        return this.baseMapper.getMonitorList(pagination);
    }

    @Override
    public TaskEntity getInfo(String id) throws WorkFlowException {
        return this.baseMapper.getInfo(id);
    }

    // 发起、审批详情
    @Override
    public BeforeInfoVo getInfo(String id, FlowModel fo) throws WorkFlowException {
        BeforeInfoVo vo = new BeforeInfoVo();
        TemplateJsonInfoVO jsonInfoVO = null;
        TemplateEntity template = null;

        if (!StringUtil.equals(FlowNature.ParentId, id)) {
            TaskEntity taskEntity = this.getById(id);
            if (null != taskEntity) {
                jsonInfoVO = flowUtil.getInfoVo(taskEntity.getFlowId());
                template = templateMapper.getInfo(taskEntity.getTemplateId());
            }
            vo.setLineKeyList(taskLineMapper.getLineKeyList(id));
        }
        if (null == jsonInfoVO) {
            template = null == template ? templateMapper.getInfo(fo.getFlowId()) : template;
            jsonInfoVO = flowUtil.getInfoVo(template.getFlowId());
        }
        fo.setTemplateEntity(template);
        vo.setFlowInfo(jsonInfoVO);
        fo.setDeploymentId(jsonInfoVO.getFlowableId());

        // 节点
        List<TemplateNodeEntity> nodeEntities = templateNodeMapper.getList(jsonInfoVO.getFlowId());

        TemplateNodeEntity nodeEntity = null;
        OperatorEntity operatorEntity = new OperatorEntity();
        RecordEntity recordEntity = new RecordEntity();
        Map<String, Object> map = new HashMap<>();
        Map<String, Object> draft = new HashMap<>();
        String operatorId = ObjectUtil.isNotEmpty(fo.getOperatorId()) ? fo.getOperatorId() : "";
        OpTypeEnum type = OpTypeEnum.getType(fo.getOpType());
        switch (type) {
            case LaunchCreate:
            case Sign:// 待签
            case Todo:// 待办
            case Doing:// 在办
                OperatorEntity operator = operatorMapper.getInfo(operatorId);
                if (null != operator) {
                    nodeEntity = nodeEntities.stream()
                            .filter(e -> StringUtil.equals(operator.getNodeCode(), e.getNodeCode())).findFirst().orElse(null);
                    operatorEntity = operator;
                }
                break;
            case Done:// 已办
                RecordEntity record = recordMapper.getInfo(operatorId);
                if (null != record) {
                    nodeEntity = nodeEntities.stream()
                            .filter(e -> StringUtil.equals(record.getNodeCode(), e.getNodeCode()) && !Objects.equals(NodeEnum.outside.getType(), e.getNodeType())).findFirst().orElse(null);
                    if (StringUtil.isNotBlank(record.getOperatorId())) {
                        OperatorEntity op = operatorMapper.selectById(record.getOperatorId());
                        if (null != op) {
                            operatorEntity = op;
                        }
                    }
                    recordEntity = record;
                }
                break;
            case Circulate:// 抄送
                CirculateEntity circulateEntity = circulateMapper.selectById(operatorId);
                if (null != circulateEntity) {
                    nodeEntity = nodeEntities.stream()
                            .filter(e -> StringUtil.equals(circulateEntity.getNodeCode(), e.getNodeCode())).findFirst().orElse(null);
                    circulateEntity.setCirculateRead(1);
                    circulateMapper.updateById(circulateEntity);
                    if (StringUtil.isNotBlank(circulateEntity.getOperatorId())) {
                        OperatorEntity ope = operatorMapper.selectById(circulateEntity.getOperatorId());
                        if (null != ope) {
                            operatorEntity = ope;
                        }
                    }
                }
                break;
        }
        //发起流程添加使用次数
        if (Objects.equals(fo.getIsFlow(), 1)) {
            templateUseNumMapper.insertOrUpdateUseNum(fo.getFlowId());
        }

        if (null == nodeEntity) {
            // 默认获取开始节点
            nodeEntity = nodeEntities.stream()
                    .filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(null);
        }
        if (null == nodeEntity) {
            throw new WorkFlowException(MsgCode.WF076.get());
        }
        if (null != operatorEntity.getDraftData()) {
            Map<String, Object> draftData = JsonUtil.stringToMap(operatorEntity.getDraftData());
            draftData.forEach((k, v) -> {
                if (ObjectUtil.isNotEmpty(v) && !Objects.equals(TableFeildsEnum.VERSION.getField(), k)) {
                    map.put(k, v);
                }
            });
            draft.putAll(draftData);
        }
        String formId = nodeEntity.getFormId();
        NodeModel currentNode = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
        vo.setFormOperates(currentNode.getFormOperates());
        // 表单数据
        if (!StringUtil.equals(FlowNature.ParentId, id)) {
            Map<String, Object> formData = serviceUtil.infoData(formId, id);
            vo.setFormData(formData);
            fo.setFormData(formData);
            formData.putAll(map);
            draft.putAll(formData);

            String flowTaskID = Objects.nonNull(formData.get(FlowFormConstant.FLOWTASKID)) ? formData.get(FlowFormConstant.FLOWTASKID).toString() : "";
            id = StringUtil.isNotBlank(flowTaskID) ? flowTaskID : id;
            TaskEntity taskEntity = this.getById(id);
            if (null != taskEntity) {
                TaskVo taskVo = JsonUtil.getJsonToBean(taskEntity, TaskVo.class);
                taskVo.setFlowUrgent(taskEntity.getUrgent());
                UserEntity user = serviceUtil.getUserInfo(taskEntity.getCreatorUserId());
                taskVo.setCreatorUser(user.getRealName());
                taskVo.setHeadIcon(UploaderUtil.uploaderImg(user.getHeadIcon()));
                String flowCategory = taskEntity.getFlowCategory();
                // 分类名称
                List<String> categoryIds = ImmutableList.of(flowCategory);
                List<DictionaryDataEntity> dictionName = serviceUtil.getDictionName(categoryIds);
                taskVo.setFlowCategory(dictionName.stream().map(DictionaryDataEntity::getFullName).collect(Collectors.joining(",")));

                vo.setTaskInfo(taskVo);
                fo.setTaskEntity(taskEntity);

                // 流转记录
                List<RecordEntity> records = recordMapper.getList(taskEntity.getId());
                vo.setRecordList(recordUtil.getRecordList(records, nodeEntities));

                FlowModel flowModel = new FlowModel();
                flowModel.setFormData(formData);
                flowModel.setDeploymentId(fo.getDeploymentId());
                flowModel.setTaskEntity(taskEntity);
                flowModel.setNodeEntityList(nodeEntities);
                flowModel.setNodeEntity(nodeEntity);
                flowModel.setOpType(fo.getOpType());
                flowModel.setRecordEntity(recordEntity);
                // 节点
                List<TaskNodeModel> nodeList = nodeUtil.getNodeList(flowModel);
                vo.setNodeList(nodeList);
                fo.setNodeList(nodeList);

                vo.setFlowInfo(jsonInfoVO);
                Map<String, Object> nodeProperties = jsonInfoVO.getFlowNodes().get(nodeEntity.getNodeCode());
                nodeUtil.setFlowFile(currentNode, taskEntity, nodeProperties);
                vo.setNodeProperties(nodeProperties);

                vo.setProgressList(!Objects.equals(type, OpTypeEnum.Monitor) ? recordUtil.getProgressList(flowModel) : new ArrayList<>());
            }
        }
        // 判断按钮
        fo.setOperatorEntity(operatorEntity);
        fo.setNodeEntity(nodeEntity);
        fo.setRecordEntity(recordEntity);
        fo.setNodeEntityList(nodeEntities);
        fo.setFlowId(jsonInfoVO.getFlowId());
        ButtonModel model = buttonUtil.handleButton(fo);
        vo.setBtnInfo(model);
        //vo.setDraftData(draft);
        RevokeEntity revokeEntity = revokeMapper.getRevokeTask(id);
        if (null != revokeEntity) {
            Map<String, Object> revokeMap = JsonUtil.stringToMap(revokeEntity.getFormData());
            vo.setFormData(revokeMap);
            VisualdevEntity formInfo = new VisualdevEntity();
            formInfo.setEnCode(FlowNature.REVOKE_FORM_CODE);
            formInfo.setType(2);
            vo.setFormInfo(formInfo);
            TaskVo taskInfo = vo.getTaskInfo();
            if (null != taskInfo) {
                taskInfo.setIsRevokeTask(true);
            }
        } else {
            vo.setFormData(draft);
            // 获取表单
            if (null != formId) {
                VisualdevEntity formInfo = serviceUtil.getFormInfo(formId);
                vo.setFormInfo(formInfo);
            }
        }
        return vo;
    }

    @Override
    public CandidateCheckVo checkCandidates(String id, CandidateCheckFo fo) throws WorkFlowException {
        return operatorUtil.checkCandidates(id, fo);
    }

    public void getCandidateListModel(FlowMethod flowMethod, List<CandidateListModel> list) throws WorkFlowException {
        NodeModel nodeModel = flowMethod.getNodeModel();
        CandidateListModel listModel = list.stream().filter(e -> ObjectUtil.equals(nodeModel.getNodeId(), e.getNodeCode())).findFirst().orElse(null);
        if (null != listModel) {
            return;
        }
        CandidateListModel model = new CandidateListModel();
        model.setNodeCode(nodeModel.getNodeId());
        model.setNodeName(nodeModel.getNodeName());
        boolean isCandidate = nodeModel.getIsCandidates();
        model.setIsCandidates(isCandidate);
        if (isCandidate) {
            List<String> userIds = flowUtil.userListAll(flowMethod);
            List<UserEntity> users = serviceUtil.getUserName(userIds, true);
            model.setHasCandidates(!users.isEmpty());
            model.setSelectIdList(users.stream().map(UserEntity::getId).collect(Collectors.toList()));
        }
        list.add(model);
    }

    @Override
    public List<CandidateUserVo> getCandidateUser(String id, CandidateCheckFo fo) throws WorkFlowException {
        TemplateJsonEntity jsonEntity = templateJsonMapper.selectById(fo.getFlowId());
        if (null == jsonEntity) {
            TemplateEntity template = templateMapper.getInfo(fo.getFlowId());
            jsonEntity = templateJsonMapper.getInfo(template.getFlowId());
        }
        List<TemplateNodeEntity> nodeEntities = templateNodeMapper.getList(jsonEntity.getId());

        Map<String, NodeModel> nodes = new HashMap<>();
        for (TemplateNodeEntity nodeEntity : nodeEntities) {
            nodes.put(nodeEntity.getNodeCode(), JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class));
        }
        NodeModel nodeModel = nodes.get(fo.getNodeCode());
        if (null == nodeModel) {
            throw new WorkFlowException(MsgCode.WF076.get());
        }

        // 获取候选人
        CandidateCheckVo candidateCheckVo = checkCandidates(id, fo);
        List<CandidateListModel> list = candidateCheckVo.getList();
        Map<String, List<CandidateListModel>> nodeMap = list.stream().collect(Collectors.groupingBy(CandidateListModel::getNodeCode));
        List<CandidateListModel> candidateList = nodeMap.get(fo.getNodeCode()) != null ? nodeMap.get(fo.getNodeCode()) : new ArrayList<>();
        List<String> userIds = new ArrayList<>();
        for (CandidateListModel model : candidateList) {
            userIds.addAll(model.getSelectIdList());
        }

        // 候选人范围过滤
        UserInfo userInfo = UserProvider.getUser();
        UserEntity userEntity = serviceUtil.getUserInfo(userInfo.getUserId());
        OperatorEntity operator = operatorMapper.selectById(id);
        if (null != operator) {
            userEntity = serviceUtil.getUserInfo(operator.getHandleId());
        } else {
            if (StringUtil.isNotBlank(fo.getDelegateUser())) {
                userEntity = serviceUtil.getUserInfo(fo.getDelegateUser());
            }
        }
        LaunchUserEntity flowUser = new LaunchUserEntity();
        flowUtil.launchUser(flowUser, userEntity);
        flowUtil.rule(userIds, flowUser, nodeModel.getExtraRule());

        List<CandidateUserVo> vos = operatorUtil.getUserModel(userIds, fo);
        return vos;
    }

    @DSTransactional
    @Override
    public void batchSaveOrSubmit(FlowModel flowModel) throws Exception {
        operatorUtil.batchSaveOrSubmit(flowModel);
    }

    // 提交或暂存
    @Override
    public void saveOrSubmit(FlowModel flowModel) throws Exception {
        operatorUtil.saveOrSubmit(flowModel);
    }

    // 发起撤回
    @DSTransactional
    @Override
    public void recall(String id, FlowModel flowModel) throws WorkFlowException {
        flowUtil.setFlowModel(id, flowModel);
        TaskEntity taskEntity = flowModel.getTaskEntity();
        operatorUtil.checkTemplateHide(taskEntity.getTemplateId());
        List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();
        if (CollectionUtil.isEmpty(nodeEntityList)) {
            throw new WorkFlowException(MsgCode.WF076.get());
        }
        operatorUtil.addTask(ImmutableList.of(taskEntity.getId()));
        // 开始节点
        TemplateNodeEntity nodeEntity = nodeEntityList.stream()
                .filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(null);
        if (null == nodeEntity) {
            throw new WorkFlowException(MsgCode.WF076.get());
        }
        NodeModel start = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);

        flowModel.setNodeEntity(nodeEntity);
        flowModel.setIsException(true);
        if (!buttonUtil.checkRecall(flowModel)) {
            throw new WorkFlowException(MsgCode.WF077.get());
        }
        // 删除子流程(判断方法中，存在异步 或 同步子流程已提交 则不允许撤回)
        operatorUtil.deleteSubflow(taskEntity.getId(), null);
        // 删除外部节点
        eventLogMapper.delete(taskEntity.getId(), null);
        // 记录
        FlowMethod flowMethod = new FlowMethod();
        flowMethod.setType(RecordEnum.recall.getCode());
        flowMethod.setFlowModel(flowModel);
        OperatorEntity operatorEntity = new OperatorEntity();
        operatorEntity.setNodeCode(nodeEntity.getNodeCode());
        operatorEntity.setNodeName(start.getNodeName());
        operatorEntity.setTaskId(taskEntity.getId());
        operatorEntity.setHandleId(taskEntity.getCreatorUserId());
        operatorEntity.setHandleTime(new Date());
        flowMethod.setOperatorEntity(operatorEntity);
        recordMapper.createRecord(flowMethod);

        // 节点记录
        NodeRecordModel nodeRecordModel = new NodeRecordModel();
        nodeRecordModel.setTaskId(taskEntity.getId());
        nodeRecordModel.setNodeCode(nodeEntity.getNodeCode());
        nodeRecordModel.setNodeStatus(NodeStateEnum.recall.getCode());
        nodeRecordMapper.update(nodeRecordModel);

        // 删除经办
        QueryWrapper<OperatorEntity> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(OperatorEntity::getTaskId, taskEntity.getId());
        operatorMapper.delete(wrapper);

        // 删除候选人
        candidatesMapper.deleteByCodes(taskEntity.getId(), null);

        // 删除发起人
        launchUserMapper.delete(taskEntity.getId());

        // 删除引擎实例
        flowAbleUrl.deleteInstance(taskEntity.getInstanceId(), "retract");

        // 变更任务状态
        UpdateWrapper<TaskEntity> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(TaskEntity::getId, taskEntity.getId())
                .set(TaskEntity::getInstanceId, null)
                .set(TaskEntity::getRejectDataId, null)
                .set(TaskEntity::getCurrentNodeName, FlowNature.START_NAME)
                .set(TaskEntity::getCurrentNodeCode, FlowNature.START_CODE)
                .set(TaskEntity::getStatus, TaskStatusEnum.RECALL.getCode());
        this.update(updateWrapper);
        if (taskEntity.getRejectDataId() != null) {
            rejectDataService.removeById(taskEntity.getRejectDataId());
        }
    }

    // 催办
    @Override
    public boolean press(String id) throws WorkFlowException {
        FlowModel flowModel = new FlowModel();
        flowUtil.setFlowModel(id, flowModel);
        TaskEntity taskEntity = flowModel.getTaskEntity();
        List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();

        // 消息
        QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OperatorEntity::getTaskId, id).eq(OperatorEntity::getCompletion, FlowNature.Normal)
                .ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode())
                .isNull(OperatorEntity::getHandleStatus).isNotNull(OperatorEntity::getDuedate);
        List<OperatorEntity> operatorList = operatorMapper.selectList(queryWrapper);
        if (operatorList.isEmpty()) {
            return false;
        }
        FlowMsgModel flowMsgModel = new FlowMsgModel();
        flowMsgModel.setNodeList(nodeEntityList);
        flowMsgModel.setFlowModel(flowModel);
        flowMsgModel.setTaskEntity(taskEntity);
        flowMsgModel.setOperatorList(operatorList);
        flowMsgModel.setPress(true);
        msgUtil.message(flowMsgModel);
        return true;
    }

    @DSTransactional
    @Override
    public void revoke(String id, FlowModel flowModel) throws Exception {
        flowUtil.setFlowModel(id, flowModel);
        TaskEntity taskEntity = flowModel.getTaskEntity();
        if (!TaskStatusEnum.PASSED.getCode().equals(taskEntity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF078.get());
        }
        // 处理撤销表单的数据
        operatorUtil.submitOfRevoke(flowModel);
    }

    @DSTransactional
    @Override
    public List<TaskEntity> delete(String id) throws Exception {
        TaskEntity entity = this.getById(id);
        if (null == entity) {
            throw new WorkFlowException(MsgCode.FA001.get());
        }
        if (TaskStatusEnum.PAUSED.getCode().equals(entity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF114.get());
        }
        List<Integer> status = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(), TaskStatusEnum.RECALL.getCode());
        if (!status.contains(entity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF063.get());
        }
        if (StringUtil.isNotEmpty(entity.getParentId()) && !FlowNature.ParentId.equals(entity.getParentId())) {
            throw new WorkFlowException(entity.getFullName() + MsgCode.WF021.get());
        }

        List<String> idList = ImmutableList.of(entity.getId());
        this.delete(idList);
        List<TaskEntity> list = ImmutableList.of(entity);
        return list;
    }

    @DSTransactional
    @Override
    public void deleteBatch(List<String> ids) throws Exception {
        if (ids.isEmpty()) {
            return;
        }
        List<TaskEntity> taskList = this.baseMapper.getOrderStaList(ids);

        List<TaskEntity> child = taskList.stream()
                .filter(t -> StringUtil.isNotEmpty(t.getParentId()) && !FlowNature.ParentId.equals(t.getParentId())).collect(Collectors.toList());
        if (!child.isEmpty()) {
            throw new WorkFlowException(child.get(0).getFullName() + MsgCode.WF021.get());
        }

        List<TaskEntity> taskStatusList = new ArrayList<>();
        for (String id : ids) {
            List<String> childAllList = this.baseMapper.getChildAllList(id);
            taskStatusList.addAll(this.baseMapper.getOrderStaList(childAllList));
        }
        List<TaskEntity> taskStatus = taskStatusList.stream()
                .filter(t -> TaskStatusEnum.PAUSED.getCode().equals(t.getStatus())).collect(Collectors.toList());
        if (!taskStatus.isEmpty()) {
            throw new WorkFlowException(taskStatus.get(0).getFullName() + MsgCode.WF113.get());
        }

        this.delete(ids);
        operatorUtil.deleteFormData(taskStatusList);

        List<String> instanceIds = taskStatusList.stream()
                .filter(t -> TaskStatusEnum.RUNNING.getCode().equals(t.getStatus()) || TaskStatusEnum.CANCEL.getCode().equals(t.getStatus()))
                .map(TaskEntity::getInstanceId).distinct().collect(Collectors.toList());
        if (CollectionUtil.isNotEmpty(instanceIds)) {
            for (String instanceId : instanceIds) {
                flowAbleUrl.deleteInstance(instanceId, "monitor");
            }
        }
    }

    public void delete(List<String> idList) {
        List<String> idAll = new ArrayList<>();
        this.baseMapper.deleTaskAll(idList, idAll);
        List<String> revokeTaskIds = revokeMapper.getByTaskId(idAll);
        idAll.addAll(revokeTaskIds);
        if (!idAll.isEmpty()) {
            QueryWrapper<TaskEntity> task = new QueryWrapper<>();
            task.lambda().in(TaskEntity::getId, idAll);
            this.setIgnoreLogicDelete().removeByIds(this.list(task));
            this.clearIgnoreLogicDelete();
            // 候选人
            QueryWrapper<CandidatesEntity> candidates = new QueryWrapper<>();
            candidates.lambda().select(CandidatesEntity::getId);
            candidates.lambda().in(CandidatesEntity::getTaskId, idAll);
            candidatesMapper.setIgnoreLogicDelete().deleteByIds(candidatesMapper.selectList(candidates));
            candidatesMapper.clearIgnoreLogicDelete();
            // 发起人
            QueryWrapper<LaunchUserEntity> launchUser = new QueryWrapper<>();
            launchUser.lambda().select(LaunchUserEntity::getId);
            launchUser.lambda().in(LaunchUserEntity::getTaskId, idAll);
            launchUserMapper.setIgnoreLogicDelete().deleteByIds(launchUserMapper.selectList(launchUser));
            launchUserMapper.clearIgnoreLogicDelete();
            // 评论
            QueryWrapper<CommentEntity> comment = new QueryWrapper<>();
            comment.lambda().select(CommentEntity::getId);
            comment.lambda().in(CommentEntity::getTaskId, idAll);
            commentMapper.setIgnoreLogicDelete().deleteByIds(commentMapper.selectList(comment));
            commentMapper.clearIgnoreLogicDelete();
            // 经办
            QueryWrapper<OperatorEntity> operator = new QueryWrapper<>();
            operator.lambda().select(OperatorEntity::getId);
            operator.lambda().in(OperatorEntity::getTaskId, idAll);
            operatorMapper.setIgnoreLogicDelete().deleteByIds(operatorMapper.selectList(operator));
            operatorMapper.clearIgnoreLogicDelete();
            // 记录
            QueryWrapper<RecordEntity> record = new QueryWrapper<>();
            record.lambda().select(RecordEntity::getId);
            record.lambda().in(RecordEntity::getTaskId, idAll);
            recordMapper.setIgnoreLogicDelete().deleteByIds(recordMapper.selectList(record));
            recordMapper.clearIgnoreLogicDelete();
            // 退回信息
            List<TaskEntity> taskList = this.list(task);
            List<String> rejectDataIds = taskList.stream().map(TaskEntity::getRejectDataId).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(rejectDataIds)) {
                QueryWrapper<RejectDataEntity> rejectData = new QueryWrapper<>();
                rejectData.lambda().select(RejectDataEntity::getId);
                rejectData.lambda().in(RejectDataEntity::getId, rejectDataIds);
                rejectDataService.setIgnoreLogicDelete().removeByIds(rejectDataService.list(rejectData));
                rejectDataService.clearIgnoreLogicDelete();
            }
            // 抄送
            QueryWrapper<CirculateEntity> circulate = new QueryWrapper<>();
            circulate.lambda().select(CirculateEntity::getId);
            circulate.lambda().in(CirculateEntity::getTaskId, idAll);
            circulateMapper.setIgnoreLogicDelete().deleteByIds(circulateMapper.selectList(circulate));
            circulateMapper.clearIgnoreLogicDelete();
            // 任务条件
            QueryWrapper<TaskLineEntity> taskLine = new QueryWrapper<>();
            taskLine.lambda().select(TaskLineEntity::getId);
            taskLine.lambda().in(TaskLineEntity::getTaskId, idAll);
            taskLineMapper.setIgnoreLogicDelete().deleteByIds(taskLineMapper.selectList(taskLine));
            taskLineMapper.clearIgnoreLogicDelete();
            // 撤销
            QueryWrapper<RevokeEntity> revoke = new QueryWrapper<>();
            revoke.lambda().select(RevokeEntity::getId);
            revoke.lambda().in(RevokeEntity::getRevokeTaskId, idAll);
            revokeMapper.setIgnoreLogicDelete().deleteByIds(revokeMapper.selectList(revoke));
            revokeMapper.clearIgnoreLogicDelete();
            //节点流转
            QueryWrapper<NodeRecordEntity> nodeRecord = new QueryWrapper<>();
            nodeRecord.lambda().select(NodeRecordEntity::getId);
            nodeRecord.lambda().in(NodeRecordEntity::getTaskId, idAll);
            nodeRecordMapper.setIgnoreLogicDelete().deleteByIds(nodeRecordMapper.selectList(nodeRecord));
            nodeRecordMapper.clearIgnoreLogicDelete();
            //外部事件
            QueryWrapper<EventLogEntity> eventLog = new QueryWrapper<>();
            eventLog.lambda().select(EventLogEntity::getId);
            eventLog.lambda().in(EventLogEntity::getTaskId, idAll);
            eventLogMapper.setIgnoreLogicDelete().deleteByIds(eventLogMapper.selectList(eventLog));
            eventLogMapper.clearIgnoreLogicDelete();
            // 任务流程
            QueryWrapper<TriggerTaskEntity> triggerTask = new QueryWrapper<>();
            triggerTask.lambda().select(TriggerTaskEntity::getId);
            triggerTask.lambda().in(TriggerTaskEntity::getTaskId, idAll);
            List<TriggerTaskEntity> list = triggerTaskMapper.selectList(triggerTask);
            if (!list.isEmpty()) {
                List<String> ids = list.stream().map(TriggerTaskEntity::getId).collect(Collectors.toList());
                triggerTaskMapper.setIgnoreLogicDelete().deleteByIds(list);
                triggerTaskMapper.clearIgnoreLogicDelete();
                QueryWrapper<TriggerRecordEntity> triggerRecord = new QueryWrapper<>();
                triggerRecord.lambda().select(TriggerRecordEntity::getId);
                triggerRecord.lambda().in(TriggerRecordEntity::getTriggerId, ids);
                triggerRecordMapper.setIgnoreLogicDelete().deleteByIds(triggerRecordMapper.selectList(triggerRecord));
                triggerRecordMapper.clearIgnoreLogicDelete();
            }
        }
    }

    @Override
    public void deleTaskAll(List<String> idList, List<String> idAll) {
        this.baseMapper.deleTaskAll(idList, idAll);
    }

    // 终止与挂起的区别，就是能否在列表中查询到，撤销中不允许终止等操作
    @DSTransactional
    @Override
    public void cancel(String id, FlowModel flowModel, boolean isCancel) throws WorkFlowException {
        operatorUtil.cancel(id, flowModel, isCancel);
    }

    @Override
    public boolean checkAsync(String id) {
        return this.baseMapper.checkAsync(id);
    }

    // isSuspend: true 挂起、false 恢复
    @DSTransactional
    @Override
    public void pause(String id, FlowModel flowModel, Boolean isSuspend) throws WorkFlowException {
        List<String> idList = new ArrayList<>();
        idList.add(id);

        boolean pause = false;

        // 暂停的选项，0.全部  1：仅主流程，同时暂停同步子流程
        if (isSuspend) {
            pause = flowModel.getPause() == 1;
        } else {
            TaskEntity taskEntity = this.getInfo(id);
            if (ObjectUtil.equals(taskEntity.getIsRestore(), FlowNature.NotRestore)) {
                throw new WorkFlowException("无法恢复");
            }
            List<TaskEntity> childList = this.baseMapper.getChildList(id, TaskEntity::getId, TaskEntity::getIsRestore);
            // 存在 0（能恢复的），就只恢复 1（不能恢复的，即同步的）
            pause = childList.stream().anyMatch(e -> ObjectUtil.equals(e.getIsRestore(), FlowNature.Restore));
        }
        String userId = UserProvider.getLoginUserId();

        this.baseMapper.getChildList(id, pause, idList);

        List<TaskEntity> orderStaList = this.baseMapper.getOrderStaList(idList);

        this.pause(orderStaList, isSuspend, id);

        for (TaskEntity entity : orderStaList) {
            // 记录
            FlowMethod flowMethod = new FlowMethod();
            flowMethod.setFlowModel(flowModel);
            flowMethod.setType(isSuspend ? RecordEnum.pause.getCode() : RecordEnum.reboot.getCode());
            OperatorEntity operatorEntity = new OperatorEntity();
            operatorEntity.setNodeCode(StringUtil.isNotBlank(entity.getCurrentNodeCode()) ? entity.getCurrentNodeCode() : FlowNature.START_CODE);
            operatorEntity.setNodeName(StringUtil.isNotBlank(entity.getCurrentNodeName()) ? entity.getCurrentNodeName() : FlowNature.START_NAME);
            operatorEntity.setTaskId(entity.getId());
            operatorEntity.setHandleId(userId);
            flowMethod.setOperatorEntity(operatorEntity);
            recordMapper.createRecord(flowMethod);
            operatorUtil.addTask(ImmutableList.of(entity.getId()));
        }

    }

    public List<OperatorEntity> pause(List<TaskEntity> orderStaList, boolean isSuspend, String id) {
        List<OperatorEntity> operatorList = new ArrayList<>();
        for (TaskEntity taskEntity : orderStaList) {
            if (isSuspend) {
                // 暂停
                if (!ObjectUtil.equals(taskEntity.getStatus(), TaskStatusEnum.PAUSED.getCode())) {
                    taskEntity.setHisStatus(taskEntity.getStatus());
                    taskEntity.setStatus(TaskStatusEnum.PAUSED.getCode());
                }
                taskEntity.setIsRestore(ObjectUtil.equals(taskEntity.getId(), id) ? FlowNature.Restore : FlowNature.NotRestore);
                this.updateById(taskEntity);
            } else {
                // 恢复
                taskEntity.setStatus(taskEntity.getHisStatus());
                taskEntity.setHisStatus(TaskStatusEnum.PAUSED.getCode());
                taskEntity.setIsRestore(FlowNature.Restore);
                this.updateById(taskEntity);
            }
            // 过滤作废的经办
            List<OperatorEntity> list = operatorMapper.getList(taskEntity.getId()).stream()
                    .filter(e -> !e.getStatus().equals(OperatorStateEnum.Futility.getCode())).collect(Collectors.toList());
            operatorList.addAll(list);
        }
        return operatorList;
    }

    @DSTransactional
    @Override
    public void assign(String id, FlowModel flowModel) throws WorkFlowException {
        flowUtil.setFlowModel(id, flowModel);
        TaskEntity entity = flowModel.getTaskEntity();
        operatorUtil.isSuspend(entity);
        operatorUtil.isCancel(entity);

        String handleId = flowModel.getUserInfo() == null ? UserProvider.getLoginUserId() : flowModel.getUserInfo().getUserId();

        List<TemplateNodeEntity> nodeEntityList = flowModel.getNodeEntityList();

        // 作废原先的经办、生成指派的经办
        OperatorEntity operator = operatorUtil.handleAssign(flowModel);
        List<OperatorEntity> list = new ArrayList<>();
        list.add(operator);

        String nodeCode = flowModel.getNodeCode();
        NodeModel nodeModel = flowModel.getNodes().get(nodeCode);
        Boolean autoTransfer = flowModel.getAutoTransferFlag();
        boolean isProcessing = ObjectUtil.equals(nodeModel.getType(), NodeEnum.processing.getType());
        if (autoTransfer) {
            flowModel.setHandleOpinion(isProcessing ? "系统转办" : "系统转审");
        }

        //指派逐级审批失效
        if (StringUtil.isNotEmpty(nodeCode)) {
            launchUserMapper.delete(operator.getTaskId(), ImmutableList.of(nodeCode));
        }

        // 记录
        FlowMethod flowMethod = new FlowMethod();
        flowMethod.setFlowModel(flowModel);
        Integer transferType = isProcessing ? RecordEnum.transferProcessing.getCode() : RecordEnum.transfer.getCode();
        flowMethod.setType(autoTransfer ? transferType : RecordEnum.assign.getCode());
        OperatorEntity operatorEntity = new OperatorEntity();
        operatorEntity.setId(operator.getId());
        operatorEntity.setNodeCode(nodeCode);
        operatorEntity.setNodeId(operator.getNodeId());
        operatorEntity.setNodeName(nodeModel.getNodeName());
        operatorEntity.setTaskId(entity.getId());
        operatorEntity.setHandleId(autoTransfer ? FlowNature.SYSTEM_CODE : handleId);
        flowMethod.setOperatorEntity(operatorEntity);
        List<String> userIds = ImmutableList.of(flowModel.getHandleIds());
        flowMethod.setUserId(String.join(",", userIds));
        recordMapper.createRecord(flowMethod);

        // 消息
        FlowMsgModel flowMsgModel = new FlowMsgModel();
        flowMsgModel.setNodeList(nodeEntityList);
        flowMsgModel.setFlowModel(flowModel);
        flowMsgModel.setTaskEntity(entity);
        flowMsgModel.setOperatorList(list);
        if (flowModel.getAutoTransferFlag()) {
            flowMsgModel.setTransfer(true);
        } else {
            flowMsgModel.setAssign(true);
        }
        msgUtil.message(flowMsgModel);

        operatorUtil.addOperatorList(list, flowModel);
    }

    @Override
    public TaskUserListModel getTaskUserList(String taskId) {
        return flowUtil.getTaskUserList(taskId);
    }

    @Override
    public List<BeforeInfoVo> subFlowInfo(FlowModel flowModel) throws WorkFlowException {
        List<BeforeInfoVo> list = new ArrayList<>();
        List<TaskEntity> entityList = this.baseMapper.subFlowInfo(flowModel);
        if (CollectionUtil.isNotEmpty(entityList)) {
            for (TaskEntity entity : entityList) {
                FlowModel model = new FlowModel();
                model.setFlowId(entity.getFlowId());
                BeforeInfoVo info = this.getInfo(entity.getId(), model);
                list.add(info);
            }
        }
        return list;
    }

    // 消息跳转流程时，校验以及返回opType
    @Override
    public String checkInfo(String id) throws WorkFlowException {
        CirculateEntity circulate = circulateMapper.selectById(id);
        if (null != circulate) {
            return OpTypeEnum.Circulate.getType();
        }
        OperatorEntity operator = operatorMapper.getInfo(id);
        if (null == operator) {
            throw new WorkFlowException(MsgCode.FA001.get());
        }
        if (operator.getStatus().equals(OperatorStateEnum.Futility.getCode())) {
            throw new WorkFlowException("该流程无权限查看");
        }

        TaskEntity taskEntity = this.getById(operator.getTaskId());
        if (null == taskEntity) {
            throw new WorkFlowException(MsgCode.FA001.get());
        }
        if (TaskStatusEnum.CANCEL.getCode().equals(taskEntity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF041.get());
        }
        if (TaskStatusEnum.RECALL.getCode().equals(taskEntity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF042.get());
        }
        operatorUtil.checkTemplateHide(taskEntity.getTemplateId());

        String handleId = operator.getHandleId();
        String userId = UserProvider.getLoginUserId();
        List<String> delegateList = flowUtil.getToUser(handleId, taskEntity.getFlowId());
        delegateList.add(handleId);
        if (!delegateList.contains(userId)) {
            throw new WorkFlowException(MsgCode.FA021.get());
        }

        String opType = OpTypeEnum.LaunchDetail.getType();
        if (null == operator.getSignTime() && null == operator.getStartHandleTime() && null == operator.getHandleStatus()) {
            opType = OpTypeEnum.Sign.getType();
        }
        if (null != operator.getSignTime() && null == operator.getStartHandleTime() && null == operator.getHandleStatus()) {
            opType = OpTypeEnum.Todo.getType();
        }
        if (null != operator.getSignTime() && null != operator.getStartHandleTime() && null == operator.getHandleStatus()) {
            opType = OpTypeEnum.Doing.getType();
        }
        if (null != operator.getHandleStatus() || operator.getCompletion().equals(FlowNature.Action)) {
            opType = OpTypeEnum.Circulate.getType();
        }
        return opType;
    }

    @Override
    public void updateIsFile(String taskId) throws WorkFlowException {
        TaskEntity taskEntity = this.getInfo(taskId);
        if (null != taskEntity) {
            taskEntity.setIsFile(1);
            this.updateById(taskEntity);
        }
    }

    // 获取发起表单
    @Override
    public ViewFormModel getStartForm(String taskId) throws WorkFlowException {
        ViewFormModel model = new ViewFormModel();
        TaskEntity taskEntity = this.getInfo(taskId);
        List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(taskEntity.getFlowId());
        TemplateNodeEntity nodeEntity = nodeEntityList.stream()
                .filter(e -> ObjectUtil.equals(e.getNodeType(), NodeEnum.start.getType())).findFirst().orElse(null);
        if (null != nodeEntity) {
            String formId = nodeEntity.getFormId();
            VisualdevEntity formInfo = serviceUtil.getFormInfo(formId);
            model.setFormInfo(formInfo);
            Map<String, Object> map = serviceUtil.infoData(formId, taskId);
            model.setFormData(map);
        }
        return model;
    }

    @Override
    public TaskTo getFlowTodoCount(TaskTo taskTo) {
        TaskPagination pagination = new TaskPagination();
        pagination.setDelegateType(true);
        pagination.setPageSize(1L);
        pagination.setCurrentPage(1L);
        String appCode = RequestContext.getAppCode();
        boolean isMainSystem = Objects.equals(JnpfConst.MAIN_SYSTEM_CODE, appCode);
        SystemEntity systemEntity = serviceUtil.getInfoByEnCode(!isMainSystem ? appCode : JnpfConst.WORK_FLOW_CODE);
        if (!isMainSystem) {
            pagination.setSystemId(systemEntity.getId());
        }
        TaskTo vo = new TaskTo();
        boolean isPc = RequestContext.isOrignPc();
        String webType = isPc ? JnpfConst.WEB : JnpfConst.APP;
        List<ModuleModel> moduleListAll = taskTo.getModuleList() != null ? taskTo.getModuleList() : new ArrayList<>();
        List<ModuleModel> moduleList = moduleListAll.stream().
                filter(e -> Objects.equals(e.getSystemId(), systemEntity.getId()) && Objects.equals(webType, e.getCategory()))
                .collect(Collectors.toList());
        Map<String, List<ModuleModel>> encodeMap = moduleList.stream().collect(Collectors.groupingBy(ModuleModel::getEnCode));

        vo.setIsLaunch(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWLAUNCH)));
        if (vo.getIsLaunch()) {
            getList(pagination);
            vo.setFlowLaunch(pagination.getTotal());
        }

        vo.setIsToSign(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWSIGN)));
        if (vo.getIsToSign()) {
            if (ObjectUtil.isNotEmpty(taskTo.getFlowToSignType())) {
                pagination.setFlowCategory(String.join(",", taskTo.getFlowToSignType()));
            }
            pagination.setCategory(CategoryEnum.Sign.getType());
            flowUtil.getOperatorList(pagination);
            vo.setFlowToSign(pagination.getTotal());
        }

        vo.setIsTodo(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWTODO)));
        if (vo.getIsTodo()) {
            if (ObjectUtil.isNotEmpty(taskTo.getFlowTodoType())) {
                pagination.setFlowCategory(String.join(",", taskTo.getFlowTodoType()));
            }
            pagination.setCategory(CategoryEnum.Todo.getType());
            flowUtil.getOperatorList(pagination);
            vo.setFlowTodo(pagination.getTotal());
        }

        vo.setIsDoing(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWDOING)));
        if (vo.getIsDoing()) {
            if (ObjectUtil.isNotEmpty(taskTo.getFlowDoingType())) {
                pagination.setFlowCategory(String.join(",", taskTo.getFlowDoingType()));
            }
            pagination.setCategory(CategoryEnum.Doing.getType());
            flowUtil.getOperatorList(pagination);
            vo.setFlowDoing(pagination.getTotal());
        }

        vo.setIsDone(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWDONE)));
        if (vo.getIsDone()) {
            if (ObjectUtil.isNotEmpty(taskTo.getFlowDoneType())) {
                pagination.setFlowCategory(String.join(",", taskTo.getFlowDoneType()));
            }
            flowUtil.getRecordList(pagination);
            vo.setFlowDone(pagination.getTotal());
        }

        vo.setIsCirculate(ObjectUtil.isNotEmpty(encodeMap.get(JnpfConst.WORK_FLOWCIRCULATE)));
        if (vo.getIsCirculate()) {
            if (ObjectUtil.isNotEmpty(taskTo.getFlowCirculateType())) {
                pagination.setFlowCategory(String.join(",", taskTo.getFlowCirculateType()));
            }
            circulateMapper.getList(pagination);
            vo.setFlowCirculate(pagination.getTotal());
        }

        return vo;
    }

    @Override
    public FlowTodoVO getFlowTodo(TaskPagination pagination) {
        FlowTodoVO flowTodoVO = new FlowTodoVO();
        String appCode = RequestContext.getAppCode();
        String category = pagination.getCategory();
        pagination.setSystemId(serviceUtil.getSystemCodeById(appCode));
        if (Objects.equals(JnpfConst.MAIN_SYSTEM_CODE, appCode)) {
            appCode = JnpfConst.WORK_FLOW_CODE;
        }
        boolean isPc = RequestContext.isOrignPc();
        String webType = isPc ? JnpfConst.WEB : JnpfConst.APP;
        SystemEntity systemEntity = serviceUtil.getInfoByEnCode(appCode);
        AuthorizeVO authorize = serviceUtil.getAuthorizeByUser();
        List<ModuleModel> moduleList = authorize.getModuleList().stream().
                filter(e -> Objects.equals(e.getSystemId(), systemEntity.getId()) && Objects.equals(webType, e.getCategory()))
                .collect(Collectors.toList());
        Map<String, List<ModuleModel>> encodeMap = moduleList.stream().collect(Collectors.groupingBy(ModuleModel::getEnCode));
        Map<String, String> flowType = ImmutableMap.of(
                CategoryEnum.Sign.getType(), JnpfConst.WORK_FLOWSIGN,
                CategoryEnum.Todo.getType(), JnpfConst.WORK_FLOWTODO,
                CategoryEnum.Doing.getType(), JnpfConst.WORK_FLOWDOING
        );
        String module = flowType.get(category);
        flowTodoVO.setIsAuthorize(ObjectUtil.isNotEmpty(encodeMap.get(module)));
        if (flowTodoVO.getIsAuthorize()) {
            List<OperatorVo> waitList = flowUtil.getOperatorList(pagination);
            List<TaskFlowTodoVO> list = new ArrayList<>();
            for (OperatorVo operatorVo : waitList) {
                TaskFlowTodoVO vo = JsonUtil.getJsonToBean(operatorVo, TaskFlowTodoVO.class);
                vo.setTaskNodeId(operatorVo.getNodeCode());
                vo.setTaskOperatorId(operatorVo.getId());
                vo.setType(2);
                list.add(vo);
            }
            flowTodoVO.setList(list);
        }
        return flowTodoVO;
    }
}