package jnpf.flowable.service.impl;

import cn.hutool.core.bean.BeanUtil;
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.LambdaQueryWrapper;
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.flow.FlowFormDataModel;
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.TaskMapper;
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.FileConfig;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.util.FlowConstant;
import jnpf.flowable.model.util.FlowContextHolder;
import jnpf.flowable.model.util.FlowNature;
import jnpf.flowable.service.*;
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 TemplateService templateService;
    @Autowired
    private TemplateJsonService templateJsonService;
    @Autowired
    private TemplateNodeService templateNodeService;
    @Autowired
    private FlowAbleUrl flowAbleUrl;
    @Autowired
    private LaunchUserService launchUserService;
    @Autowired
    private ServiceUtil serviceUtil;
    @Autowired
    private ConditionService conditionService;
    @Autowired
    private CandidatesService candidatesService;
    @Autowired
    private OperatorService operatorService;
    @Autowired
    private RecordUtil recordUtil;
    @Autowired
    private RecordService recordService;
    @Autowired
    private CirculateService circulateService;
    @Autowired
    private NodeUtil nodeUtil;
    @Autowired
    private OperatorUtil operatorUtil;
    @Autowired
    private MsgUtil msgUtil;
    @Autowired
    private CommentService commentService;
    @Autowired
    private RejectDataService rejectDataService;
    @Autowired
    private TaskUtil taskUtil;
    @Autowired
    private ButtonUtil buttonUtil;
    @Autowired
    private DelegateService delegateService;
    @Autowired
    private NodeRecordService nodeRecordService;
    @Autowired
    private TaskLineService taskLineService;
    @Autowired
    private RevokeService revokeService;
    @Autowired
    private TriggerTaskService triggerTaskService;
    @Autowired
    private EventLogService eventLogService;
    @Autowired
    private TemplateUseNumService templateUseNumService;

    @Override
    public TaskEntity getInfoSubmit(String id, SFunction<TaskEntity, ?>... columns) {
        List<TaskEntity> list = getInfosSubmit(new String[]{id}, columns);
        if (list.isEmpty()) {
            return null;
        }
        return list.get(0);
    }

    @Override
    public List<TaskEntity> getInfosSubmit(String[] ids, SFunction<TaskEntity, ?>... columns) {
        List<TaskEntity> resultList = Collections.emptyList();
        if (ids == null || ids.length == 0) {
            return resultList;
        }
        LambdaQueryWrapper<TaskEntity> queryWrapper = new LambdaQueryWrapper<>();
        if (ids.length == 1) {
            queryWrapper.select(columns).and(
                    t -> t.eq(TaskEntity::getId, ids[0])
            );
            resultList = this.list(queryWrapper);
            if (resultList.isEmpty()) {
                queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.select(columns).and(
                        t -> t.eq(TaskEntity::getFlowId, ids[0])
                );
                resultList = this.list(queryWrapper);
            }
        } else {
            queryWrapper.select(TaskEntity::getId).and(t -> {
                t.in(TaskEntity::getId, ids).or().in(TaskEntity::getId, ids);
            });
            List<String> resultIds = this.listObjs(queryWrapper, Object::toString);
            if (!resultIds.isEmpty()) {
                queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.select(columns).in(TaskEntity::getId, resultIds);
                resultList = this.list(queryWrapper);
            }
        }
        return resultList;
    }

    @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 = delegateService.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) {
        // 定义变量判断是否需要使用修改时间倒序
        boolean flag = false;

        MPJLambdaWrapper<TaskEntity> wrapper = JoinWrappers.lambda(TaskEntity.class)
                .select(TaskEntity::getId, TaskEntity::getFullName, TaskEntity::getFlowName, TaskEntity::getStartTime,
                        TaskEntity::getCurrentNodeName, TaskEntity::getFlowCode, TaskEntity::getIsFile, TaskEntity::getFlowId,
                        TaskEntity::getFlowType, TaskEntity::getStatus, TaskEntity::getFlowType, TaskEntity::getFlowVersion
                )
                .selectAs(TaskEntity::getCreatorUserId, MonitorVo::getCreatorUser)
                .selectAs(TaskEntity::getUrgent, MonitorVo::getFlowUrgent)
                .selectAs(TaskEntity::getFlowName, MonitorVo::getFlowName)
                .selectAs(TemplateEntity::getSystemId, MonitorVo::getSystemName)
                .leftJoin(TemplateEntity.class, TemplateEntity::getId, TaskEntity::getTemplateId)
                .isNotNull(TaskEntity::getStartTime)
                .gt(TaskEntity::getStatus, TaskStatusEnum.TO_BE_SUBMIT.getCode());

        //关键字（流程名称、流程编码）
        String keyWord = pagination.getKeyword();
        if (ObjectUtil.isNotEmpty(keyWord)) {
            flag = true;
            wrapper.and(t -> t.like(TaskEntity::getEnCode, keyWord).or().like(TaskEntity::getFullName, keyWord));
        }
        //日期范围（近7天、近1月、近3月、自定义）
        if (ObjectUtil.isNotEmpty(pagination.getStartTime()) && ObjectUtil.isNotEmpty(pagination.getEndTime())) {
            wrapper.between(TaskEntity::getStartTime, new Date(pagination.getStartTime()), new Date(pagination.getEndTime()));
        }
        //所属流程
        String templateId = pagination.getTemplateId();
        if (ObjectUtil.isNotEmpty(templateId)) {
            flag = true;
            wrapper.eq(TaskEntity::getTemplateId, templateId);
        }
        //流程状态
        Integer status = pagination.getStatus();
        if (ObjectUtil.isNotEmpty(status)) {
            flag = true;
            wrapper.eq(TaskEntity::getStatus, status);
        }
        //紧急程度
        Integer flowUrgent = pagination.getFlowUrgent();
        if (ObjectUtil.isNotEmpty(flowUrgent)) {
            flag = true;
            wrapper.eq(TaskEntity::getUrgent, flowUrgent);
        }
        //所属分类
        String flowCategory = pagination.getFlowCategory();
        if (ObjectUtil.isNotEmpty(flowCategory)) {
            flag = true;
            wrapper.eq(TaskEntity::getFlowCategory, flowCategory);
        }
        // 发起人员
        String creatorUserId = pagination.getCreatorUserId();
        if (StringUtil.isNotBlank(creatorUserId)) {
            flag = true;
            wrapper.eq(TaskEntity::getCreatorUserId, creatorUserId);
        }
        //应用主建
        String systemId = pagination.getSystemId();
        if (ObjectUtil.isNotEmpty(systemId)) {
            wrapper.eq(TemplateEntity::getSystemId, systemId);
        }
        wrapper.orderByDesc(TaskEntity::getStartTime);
        if (flag) {
            wrapper.orderByDesc(TaskEntity::getLastModifyTime);
        }

        Page<MonitorVo> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
        Page<MonitorVo> iPage = this.selectJoinListPage(page, MonitorVo.class, wrapper);
        return pagination.setData(iPage.getRecords(), page.getTotal());
    }

    @Override
    public TaskEntity getInfo(String id) throws WorkFlowException {
        QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(TaskEntity::getId, id == null ? "" : id);
        TaskEntity entity = this.getOne(queryWrapper);
        if (null == entity) {
            throw new WorkFlowException(MsgCode.FA001.get());
        }
        return entity;
    }

    // 发起、审批详情
    @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 = templateJsonService.getInfoVo(taskEntity.getFlowId());
                template = templateService.getInfo(taskEntity.getTemplateId());
            }
            vo.setLineKeyList(taskLineService.getLineKeyList(id));
        }
        if (null == jsonInfoVO) {
            template = null == template ? templateService.getInfo(fo.getFlowId()) : template;
            jsonInfoVO = templateJsonService.getInfoVo(template.getFlowId());
        }
        fo.setTemplateEntity(template);
        vo.setFlowInfo(jsonInfoVO);
        fo.setDeploymentId(jsonInfoVO.getFlowableId());

        // 节点
        List<TemplateNodeEntity> nodeEntities = templateNodeService.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 = operatorService.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 = recordService.getInfo(operatorId);
                if (null != record) {
                    nodeEntity = nodeEntities.stream()
                            .filter(e -> StringUtil.equals(record.getNodeCode(), e.getNodeCode())).findFirst().orElse(null);
                    if (StringUtil.isNotBlank(record.getOperatorId())) {
                        OperatorEntity op = operatorService.getById(record.getOperatorId());
                        if (null != op) {
                            operatorEntity = op;
                        }
                    }
                    recordEntity = record;
                }
                break;
            case Circulate:// 抄送
                CirculateEntity circulateEntity = circulateService.getById(operatorId);
                if (null != circulateEntity) {
                    nodeEntity = nodeEntities.stream()
                            .filter(e -> StringUtil.equals(circulateEntity.getNodeCode(), e.getNodeCode())).findFirst().orElse(null);
                    circulateEntity.setCirculateRead(1);
                    circulateService.updateById(circulateEntity);
                    if (StringUtil.isNotBlank(circulateEntity.getOperatorId())) {
                        OperatorEntity ope = operatorService.getById(circulateEntity.getOperatorId());
                        if (null != ope) {
                            operatorEntity = ope;
                        }
                    }
                }
                break;
        }
        //发起流程添加使用次数
        if (Objects.equals(fo.getIsFlow(), 1)) {
            templateUseNumService.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 = recordService.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 = revokeService.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 {
        CandidateCheckVo vo = new CandidateCheckVo();
        List<CandidateListModel> list = new ArrayList<>();

        String flowId = fo.getFlowId();
        String nodeCode = null;
        Map<String, Object> formData = fo.getFormData();
        String taskId = fo.getId();

        TemplateEntity template;
        TemplateJsonEntity jsonEntity = templateJsonService.getById(flowId);
        if (null == jsonEntity) {
            template = templateService.getInfo(flowId);
            jsonEntity = templateJsonService.getInfo(template.getFlowId());
        } else {
            template = templateService.getInfo(jsonEntity.getTemplateId());
        }
        if (ObjectUtil.equals(id, FlowNature.ParentId)) {
            if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
                throw new WorkFlowException(MsgCode.WF140.get());
            }
        } else {
            List<Integer> templateStatus = ImmutableList.of(TemplateStatueEnum.up.getCode(), TemplateStatueEnum.downContinue.getCode());
            if (!templateStatus.contains(template.getStatus())) {
                throw new WorkFlowException(MsgCode.WF140.get());
            }
        }
        if (StringUtil.isNotBlank(fo.getDelegateUser())) {
            List<String> launchPermission = serviceUtil.getPermission(fo.getDelegateUser());
            if (ObjectUtil.equals(template.getVisibleType(), FlowNature.Authority) && !launchPermission.contains(template.getId())) {
                throw new WorkFlowException(MsgCode.WF129.get());
            }
        }

        List<TemplateNodeEntity> nodeEntities = templateNodeService.getList(jsonEntity.getId());

        Map<String, NodeModel> nodes = new HashMap<>();
        for (TemplateNodeEntity nodeEntity : nodeEntities) {
            nodes.put(nodeEntity.getNodeCode(), JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class));
        }
        NodeModel global = nodes.get(NodeEnum.global.getType());

        TemplateNodeEntity currentNode;
        OperatorEntity operatorEntity = new OperatorEntity();
        // 默认获取开始节点编码
        if (StringUtil.equals(id, FlowNature.ParentId)) {
            currentNode = nodeEntities.stream()
                    .filter(e -> StringUtil.equals(NodeEnum.start.getType(), e.getNodeType())).findFirst().orElse(null);
        } else {
            operatorEntity = operatorService.getInfo(id);
            if (operatorEntity == null) {
                throw new WorkFlowException(MsgCode.FA001.get());
            }
            // 加签的经办无需选择候选人
            if (!ObjectUtil.equals(operatorEntity.getParentId(), FlowNature.ParentId)) {
                vo.setList(list);
                return vo;
            }
            String finalNodeCode = operatorEntity.getNodeCode();
            currentNode = nodeEntities.stream().filter(e -> StringUtil.equals(finalNodeCode, e.getNodeCode())).findFirst().orElse(null);
            taskId = operatorEntity.getTaskId();
        }
        RevokeEntity revokeEntity = revokeService.getRevokeTask(taskId);
        if (null != revokeEntity) {
            vo.setList(list);
            return vo;
        }
        if (null == currentNode) {
            throw new WorkFlowException(MsgCode.WF076.get());
        }
        nodeCode = currentNode.getNodeCode();
        NodeModel currentNodeModel = nodes.get(nodeCode);
        String divideRule = currentNodeModel.getDivideRule();
        boolean branchFlow = ObjectUtil.equals(DivideRuleEnum.CHOOSE.getType(), divideRule);

        UserInfo userInfo = UserProvider.getUser();
        // 判断条件
        TaskEntity taskEntity = this.getById(taskId);
        if (taskEntity == null) {
            FlowModel flowModel = new FlowModel();
            flowModel.setFlowId(flowId);
            flowModel.setFormData(formData);
            flowModel.setDelegateUser(fo.getDelegateUser());
            flowModel.setUserInfo(userInfo);
            flowModel.setJsonEntity(jsonEntity);
            taskEntity = this.createEntity(flowModel, template, nodes);
        }
        if (ObjectUtil.isNotEmpty(taskEntity.getRejectDataId())) {
            return vo;
        }
        taskUtil.getGlobalParam(taskEntity, nodes.get(nodeCode), nodes.get(NodeEnum.global.getType()), formData);
        FlowMethod flowMethod = new FlowMethod();
        flowMethod.setDeploymentId(jsonEntity.getFlowableId());
        flowMethod.setNodeCode(nodeCode);
        flowMethod.setFormData(formData);
        flowMethod.setNodes(nodes);
        flowMethod.setTaskEntity(taskEntity);
        flowMethod.setUserInfo(userInfo);
        flowMethod.setIsCandidates(false);
        Map<String, Boolean> resMap = conditionService.handleCondition(flowMethod);

        CounterSignConfig counterSignConfig = currentNodeModel.getCounterSignConfig();
        boolean delay = ObjectUtil.equals(counterSignConfig.getCalculateType(), FlowNature.CALCULATE_TYPE_DELAY);
        // 全是false，说明没有分支可走
        if (!branchFlow && !delay) {
            // 拒绝 且 配置拒绝不允许继续流转 直接返回
            if (ObjectUtil.equals(fo.getHandleStatus(), FlowNature.RejectCompletion) && !global.getHasContinueAfterReject()) {
                vo.setList(list);
                return vo;
            }
            conditionService.checkCondition(resMap, nodes);
        } else {
            // 选择分支、且不是最后一个审批人，直接返回
            // 删除原先存在的下一级候选人
            NextOrPrevFo nextOrPrevFo = new NextOrPrevFo();
            nextOrPrevFo.setDeploymentId(jsonEntity.getFlowableId());
            nextOrPrevFo.setTaskKey(currentNode.getNodeCode());
            List<FlowableNodeModel> nextModels = flowAbleUrl.getNext(nextOrPrevFo);
            List<String> nextCodes = nextModels.stream().map(FlowableNodeModel::getId).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(nextCodes)) {
                candidatesService.deleteByCodes(taskId, nextCodes);
            }
            operatorEntity.setHandleStatus(fo.getHandleStatus());
            flowMethod.setOperatorEntity(operatorEntity);
            flowMethod.setNodeModel(currentNodeModel);
            flowMethod.setHandleStatus(fo.getHandleStatus());
            flowMethod.setAuditFlag(true);
            boolean auditRes = operatorUtil.checkAudit(flowMethod);
            if (!auditRes) {
                return vo;
            }
            if (ObjectUtil.equals(flowMethod.getHandleStatus(), FlowNature.RejectCompletion) && !global.getHasContinueAfterReject()) {
                return vo;
            }
        }
        List<String> typeList = ImmutableList.of(NodeEnum.eventTrigger.getType(), NodeEnum.timeTrigger.getType(),
                NodeEnum.noticeTrigger.getType(), NodeEnum.webhookTrigger.getType(), NodeEnum.trigger.getType());
        List<String> connectList = global.getConnectList();
        List<String> flows = flowMethod.getOutgoingFlows();
        // 判断排他
        boolean isExclusive = ObjectUtil.equals(currentNodeModel.getDivideRule(), DivideRuleEnum.EXCLUSIVE.getType());
        boolean exclusive = false;
        // 根据true的分支获取节点
        for (String key : flows) {
            if (!connectList.contains(key)) {
                continue;
            }
            if (!branchFlow) {
                if (!resMap.get(key)) {
                    continue;
                }
                if (exclusive) { // 标识为true，说明排他的第一个条件为true
                    break;
                }
                if (isExclusive) {// 排他网关 变更标识
                    exclusive = true;
                }
            }
            // 获取连接线的目标节点
            List<String> nodeKey = flowAbleUrl.getTaskKeyAfterFlow(jsonEntity.getFlowableId(), key);
            if (CollectionUtil.isEmpty(nodeKey)) {
                continue;
            }
            NodeModel nodeModel = nodes.get(nodeKey.get(0));
            if (null == nodeModel) {
                continue;
            }
            if (typeList.contains(nodeModel.getType())) {
                continue;
            }
            //处理全局的数据传递
            Map<String, Object> dataMap = new HashMap<>();
            for (String dataKey : formData.keySet()) {
                dataMap.put(dataKey, formData.get(dataKey));
                dataMap.put(dataKey + FlowNature.FORM_FIELD_SUFFIX, formData.get(dataKey));
            }
            FlowMethod jsonToBean = JsonUtil.getJsonToBean(flowMethod, FlowMethod.class);
            jsonToBean.setNodeModel(nodeModel);
            jsonToBean.setNodeEntityList(nodeEntities);
            jsonToBean.setDeploymentId(jsonEntity.getFlowableId());
            List<Assign> assignList = nodeModel.getAssignList().stream().filter(t -> t.getNodeId().equals(currentNode.getNodeCode())).collect(Collectors.toList());
            Map<String, Object> nodeDataAll = taskUtil.formData(dataMap, assignList, taskEntity, jsonToBean);
            taskUtil.getGlobalParam(taskEntity, nodeModel, nodes.get(NodeEnum.global.getType()), nodeDataAll);
            operatorEntity.setHandleId(StringUtil.isEmpty(operatorEntity.getHandleId()) ? taskEntity.getCreatorUserId() : operatorEntity.getHandleId());
            jsonToBean.setNodeEntityList(nodeEntities);
            jsonToBean.setNodeEntity(nodeEntities.stream().filter(t -> t.getNodeCode().equals(nodeKey.get(0))).findFirst().orElse(new TemplateNodeEntity()));
            FlowModel flowModel = new FlowModel();
            flowModel.setOperatorEntity(operatorEntity);
            flowModel.setDeploymentId(jsonEntity.getFlowableId());
            flowModel.setFormData(nodeDataAll);
            jsonToBean.setFlowModel(flowModel);
            getCandidateListModel(jsonToBean, list);
            List<String> nextTypeList = ImmutableList.of(NodeEnum.subFlow.getType(), NodeEnum.outside.getType());
            if (nextTypeList.contains(nodeModel.getType())) {
                // 判断子流程、外部节点，获取审批节点
                jsonToBean.setNodeCode(nodeModel.getNodeId());
                jsonToBean.setNextSubFlow(true);
                List<NodeModel> nextApprover = taskUtil.getNextApprover(jsonToBean);
                for (NodeModel node : nextApprover) {
                    List<Assign> nodeAssignList = node.getAssignList().stream().filter(t -> t.getNodeId().equals(currentNode.getNodeCode())).collect(Collectors.toList());
                    flowModel.setFormData(taskUtil.formData(dataMap, nodeAssignList, taskEntity, jsonToBean));
                    taskUtil.getGlobalParam(taskEntity, node, nodes.get(NodeEnum.global.getType()), nodeDataAll);
                    jsonToBean.setNodeModel(node);
                    jsonToBean.setNodeEntity(nodeEntities.stream().filter(t -> t.getNodeCode().equals(node.getNodeId())).findFirst().orElse(new TemplateNodeEntity()));
                    getCandidateListModel(jsonToBean, list);
                }
            }
        }
        // 获取已选择的候选人
        Integer counterSign = currentNodeModel.getCounterSign();
        if (StringUtil.isNotBlank(taskId) && !ObjectUtil.equals(counterSign, FlowNature.FixedApprover)) {
            for (CandidateListModel model : list) {
                List<CandidatesEntity> candidates = candidatesService.getList(taskId, model.getNodeCode());
                String candidateStr = candidates.stream().map(CandidatesEntity::getCandidates).collect(Collectors.joining(","));
                if (StringUtil.isNotEmpty(candidateStr)) {
                    List<String> selected = new ArrayList<>();
                    List<String> userIds = Arrays.stream(candidateStr.split(",")).distinct().collect(Collectors.toList());
                    List<UserEntity> userList = serviceUtil.getUserName(userIds);
                    for (UserEntity user : userList) {
                        selected.add(user.getRealName() + "/" + user.getAccount());
                    }
                    model.setSelected(String.join(";", selected));
                }
            }
        }
        if (branchFlow) {
            vo.setType(1);
            list = list.stream().peek(e -> e.setIsBranchFlow(true)).collect(Collectors.toList());
        } else {
            CandidateListModel listModel = list.stream().filter(e -> ObjectUtil.equals(e.getIsCandidates(), true)).findFirst().orElse(null);
            if (null != listModel) {
                vo.setType(2);
            }
        }
        vo.setList(list);
        return vo;
    }

    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 = taskUtil.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 = templateJsonService.getById(fo.getFlowId());
        if (null == jsonEntity) {
            TemplateEntity template = templateService.getInfo(fo.getFlowId());
            jsonEntity = templateJsonService.getInfo(template.getFlowId());
        }
        List<TemplateNodeEntity> nodeEntities = templateNodeService.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 = operatorService.getById(id);
        if (null != operator) {
            userEntity = serviceUtil.getUserInfo(operator.getHandleId());
        } else {
            if (StringUtil.isNotBlank(fo.getDelegateUser())) {
                userEntity = serviceUtil.getUserInfo(fo.getDelegateUser());
            }
        }
        LaunchUserEntity flowUser = new LaunchUserEntity();
        taskUtil.launchUser(flowUser, userEntity);
        taskUtil.rule(userIds, flowUser, nodeModel.getExtraRule());

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

    @DSTransactional
    @Override
    public void batchSaveOrSubmit(FlowModel flowModel) throws Exception {
        UserInfo userInfo = flowModel.getUserInfo();
        if (null == userInfo) {
            userInfo = UserProvider.getUser();
            flowModel.setUserInfo(userInfo);
        }

        String delegateUser = flowModel.getDelegateUser();
        if (StringUtil.isBlank(delegateUser)) {
            this.saveOrSubmit(flowModel);
        } else {
            FlowModel model = JsonUtil.getJsonToBean(flowModel, FlowModel.class);
            model.setDelegateUser(userInfo.getUserId());
            model.setUserId(delegateUser);
            UserEntity userEntity = serviceUtil.getUserInfo(delegateUser);
            if (null != userEntity) {
                UserInfo info = model.getUserInfo();
                info.setUserName(userEntity.getRealName());
                info.setUserAccount(userEntity.getAccount());
                info.setUserId(userEntity.getId());
                model.setUserInfo(info);
            }
            this.saveOrSubmit(model);
            // 赋值给原来的FlowModel
            BeanUtil.copyProperties(model, flowModel);
        }
        // 保存表单数据
        FlowContextHolder.deleteFormOperator();
        Map<String, Map<String, Object>> allData = FlowContextHolder.getAllData();
        Map<String, List<Map<String, Object>>> formOperates = FlowContextHolder.getFormOperates();
        List<String> writeIdList = FlowContextHolder.getWriteIdList();
        for (String idAll : writeIdList) {
            String[] idList = idAll.split(JnpfConst.SIDE_MARK);
            List<Map<String, Object>> operates = formOperates.get(idAll);
            Map<String, Object> formData = allData.get(idAll);
            formData = formData == null ? new HashMap<>() : formData;
            String flowId = (String) formData.get(FlowFormConstant.FLOWID);
            FlowFormDataModel formDataModel = FlowFormDataModel.builder().formId(idList[1]).id(idList[0]).map(formData).formOperates(operates).flowId(flowId).isTransfer(true).build();
            serviceUtil.saveOrUpdateFormData(formDataModel);
        }
        FlowContextHolder.clearAll();
    }

    // 提交或暂存
    @Override
    public void saveOrSubmit(FlowModel flowModel) throws Exception {
        TemplateEntity templateEntity = null;

        TemplateJsonEntity jsonEntity = templateJsonService.getById(flowModel.getFlowId());
        if (null == jsonEntity) {
            templateEntity = templateService.getInfo(flowModel.getFlowId());
            jsonEntity = templateJsonService.getInfo(templateEntity.getFlowId());
        } else {
            templateEntity = templateService.getInfo(jsonEntity.getTemplateId());
        }

        UserInfo userInfo = flowModel.getUserInfo();
        List<String> branchList = flowModel.getBranchList();
        //taskUtil.checkLaunchPermission(userInfo.getUserId(), templateEntity);

        // 获取节点
        List<TemplateNodeEntity> nodeEntityList = templateNodeService.getList(jsonEntity.getId());
        if (CollectionUtil.isEmpty(nodeEntityList)) {
            throw new WorkFlowException(MsgCode.WF076.get());
        }
        Map<String, NodeModel> nodes = new HashMap<>();
        for (TemplateNodeEntity nodeEntity : nodeEntityList) {
            nodes.put(nodeEntity.getNodeCode(), JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class));
        }

        flowModel.setJsonEntity(jsonEntity);
        TaskEntity entity = this.createEntity(flowModel, templateEntity, nodes);
        // 开始节点
        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());
        }
        String nodeCode = nodeEntity.getNodeCode();
        // 传递部署id、节点集合
        String deploymentId = jsonEntity.getFlowableId();
        flowModel.setDeploymentId(deploymentId);
        flowModel.setNodeEntityList(nodeEntityList);
        flowModel.setNodes(nodes);
        flowModel.setNodeEntity(nodeEntity);

        NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
        // 表单主键
        String formId = nodeEntity.getFormId();

        Map<String, Object> data = flowModel.getFormData();
        data.put(FlowFormConstant.FLOWID, jsonEntity.getId());
        FlowMethod flowMethod = new FlowMethod();
        flowMethod.setDeploymentId(deploymentId);
        flowMethod.setNodeCode(nodeCode);
        flowMethod.setFormData(data);
        flowMethod.setNodes(nodes);
        flowMethod.setTaskEntity(entity);
//        flowMethod.setJsonEntity(jsonEntity);

        operatorUtil.addTask(ImmutableList.of(entity.getId()));
        FlowFormDataModel model = new FlowFormDataModel();
        model.setFormId(formId);
        model.setId(entity.getId());
        model.setFormOperates(nodeModel.getFormOperates());
        model.setMap(flowModel.getFormData());
        model.setFlowId(jsonEntity.getId());

        if (ObjectUtil.equals(TaskStatusEnum.TO_BE_SUBMIT.getCode(), flowModel.getStatus())) {
            // 生成任务，保存表单数据
            if (flowModel.getSubFlow()) {
                model.setIsTransfer(true);
            }
            // 菜单入口、编辑
            if (Objects.equals(flowModel.getIsFlow(), 0)) {
                serviceUtil.saveOrUpdateFormData(model);
                entity.setLastModifyTime(new Date());
                entity.setLastModifyUserId(null != userInfo ? userInfo.getUserId() : UserProvider.getLoginUserId());
                this.updateById(entity);
                flowModel.setTaskEntity(entity);
                return;
            }

            if (StringUtil.isEmpty(flowModel.getId())) {
                entity.setStatus(TaskStatusEnum.TO_BE_SUBMIT.getCode());
                if (this.save(entity)) {
                    // 保存表单数据
                    serviceUtil.saveOrUpdateFormData(model);
                }
            } else {
                // 我发起的暂存 直接修改表单数据
                serviceUtil.saveOrUpdateFormData(model);
            }
            flowModel.setTaskEntity(entity);
        } else if (ObjectUtil.equals(TaskStatusEnum.RUNNING.getCode(), flowModel.getStatus())) {
            // 退回到发起
            if (null != entity.getRejectDataId()) {
                serviceUtil.saveOrUpdateFormData(model);
                RejectDataEntity rejectData = rejectDataService.getInfo(entity.getRejectDataId());
                String taskJson = rejectData.getTaskJson();

                TaskEntity srcTask = JsonUtil.getJsonToBean(taskJson, TaskEntity.class);
                srcTask.setRejectDataId(rejectData.getId());

                OperatorEntity operator = new OperatorEntity();
                operator.setNodeCode(rejectData.getNodeCode());


                flowModel.setOperatorEntity(operator);
                flowModel.setTaskEntity(srcTask);
                operatorUtil.handleRejectData(flowModel);


                // 记录
                flowMethod.setFlowModel(flowModel);
                flowMethod.setType(RecordEnum.submit.getCode());
                OperatorEntity operatorEntity = new OperatorEntity();
                operatorEntity.setNodeCode(nodeEntity.getNodeCode());
                operatorEntity.setNodeName(nodeModel.getNodeName());
                operatorEntity.setTaskId(entity.getId());
                if (StringUtil.isNotBlank(flowModel.getUserId())) {
                    flowMethod.setHandId(flowModel.getUserId());
                }
                flowMethod.setOperatorEntity(operatorEntity);
                recordUtil.createRecord(flowMethod);

                return;
            }


            // 判断条件
            Map<String, Boolean> resMap = new HashMap<>();
            if (branchList.isEmpty()) {
                resMap = conditionService.handleCondition(flowMethod);
                // 全是false，说明没有分支可走
                conditionService.checkCondition(resMap, nodes);
                // 判断候选人
                //checkCandidateOfSubmit(flowModel.getCandidateList(), flowModel.getFlowId(), flowModel.getFormData(), entity.getId());
//                Map<String, List<String>> errorRuleUserList = flowModel.getErrorRuleUserList();
//                if (CollectionUtil.isEmpty(errorRuleUserList)) {
//                    List<NodeModel> nextApprover = taskUtil.getNextApprover(flowMethod);
//                    flowModel.setTaskEntity(entity);
//                    taskUtil.checkNextError(flowModel, nextApprover);
//                }
            } else {
                // 选择分支的处理
                resMap = conditionService.getForBranch(flowMethod, branchList);
            }
            // 引擎启动的变量
            Map<String, Object> variables = new HashMap<>(resMap);
            // 生成引擎实例
            String instanceId = entity.getInstanceId();
            if (entity.getInstanceId() == null) {
                taskLineService.create(entity.getId(), resMap);
                instanceId = flowAbleUrl.startInstance(jsonEntity.getFlowableId(), variables);
                entity.setInstanceId(instanceId);
            }
            entity.setEngineType(1);
            entity.setStatus(TaskStatusEnum.RUNNING.getCode());
            entity.setStartTime(new Date());
            // 生成任务
            try {
                TaskEntity task = this.getById(entity.getId());
                if (null == task) {
                    this.save(entity);
                } else {
                    entity.setStatus(TaskStatusEnum.RUNNING.getCode());
                    this.updateById(entity);
                }
                flowModel.setTaskEntity(entity);
                serviceUtil.saveOrUpdateFormData(model);
                data = serviceUtil.infoData(formId, entity.getId());
                // 表单数据存储
                data.put(FlowFormConstant.FLOWID, jsonEntity.getId());
                FlowContextHolder.addChildData(entity.getId(), nodeEntity.getFormId(), data, nodeModel.getFormOperates(), false);
                flowModel.setFormData(data);
                // 流程参数
                NodeModel global = nodes.get(NodeEnum.global.getType());
                taskUtil.updateGlobalParam(entity, nodeModel, global, flowModel.getFormData());
                // 记录
                flowMethod.setFlowModel(flowModel);
                flowMethod.setType(RecordEnum.submit.getCode());
                OperatorEntity operatorEntity = new OperatorEntity();
                operatorEntity.setNodeCode(nodeEntity.getNodeCode());
                operatorEntity.setNodeName(nodeModel.getNodeName());
                operatorEntity.setTaskId(entity.getId());
                if (StringUtil.isNotBlank(flowModel.getUserId())) {
                    flowMethod.setHandId(flowModel.getUserId());
                }
                operatorEntity.setHandleTime(entity.getStartTime());
                flowMethod.setOperatorEntity(operatorEntity);
                recordUtil.createRecord(flowMethod);
                // 节点记录
                NodeRecordModel nodeRecordModel = new NodeRecordModel();
                nodeRecordModel.setTaskId(entity.getId());
                nodeRecordModel.setNodeCode(nodeEntity.getNodeCode());
                nodeRecordModel.setNodeName(nodeModel.getNodeName());
                nodeRecordModel.setNodeStatus(NodeStateEnum.submit.getCode());
                nodeRecordService.create(nodeRecordModel);

                // 保存候选人、异常人
                candidatesService.create(flowModel, entity.getId(), nodeEntityList, null);
                // 保存发起用户信息
                launchUserService.createLaunchUser(entity.getId(), entity.getCreatorUserId());

                // 生成经办
                List<OperatorEntity> operatorEntities = operatorService.handleOperator(flowModel);

                // 系统审批
                operatorUtil.systemAudit();
                // 消息
                FlowMsgModel flowMsgModel = new FlowMsgModel();
                flowMsgModel.setNodeList(nodeEntityList);
                flowMsgModel.setTaskEntity(entity);
                flowMsgModel.setFlowModel(flowModel);
                flowMsgModel.setOperatorList(operatorEntities);
                flowMsgModel.setFormData(FlowContextHolder.getAllData());
                msgUtil.message(flowMsgModel);

            } catch (WorkFlowException e) {
                log.error("提交异常", e);
                // 异常，手动删除实例
                flowAbleUrl.deleteInstance(instanceId, "submitException");
                throw e;
            }
        }
    }

    public TaskEntity createEntity(FlowModel fo, TemplateEntity templateEntity, Map<String, NodeModel> nodes) throws WorkFlowException {
        UserInfo user = UserProvider.getUser();
        String userName = user.getUserName();
        String userId = user.getUserId();
        UserInfo userInfo = fo.getUserInfo();
        if (null != userInfo) {
            if (StringUtil.isBlank(fo.getUserId())) {
                fo.setUserId(userInfo.getUserId());
            }
            userName = userInfo.getUserName();
            userId = userInfo.getUserId();
        }
        Map<String, Object> data = fo.getFormData() == null ? new HashMap<>() : fo.getFormData();
        data.put(FlowConstant.FLOW_FULL_NAME, templateEntity.getFullName());
        data.put(FlowConstant.FLOW_FULL_CODE, templateEntity.getEnCode());
        data.put(FlowConstant.LAUNCH_USER_NAME, userName);
        data.put(FlowConstant.LAUNCH_TIME, DateUtil.daFormat(new Date()));
        data.put(FlowConstant.USER_NAME, userName);
        NodeModel global = nodes.get(NodeEnum.global.getType());
        String titleContent = !FlowNature.TitleType.equals(global.getTitleType()) ? global.getTitleContent() : global.getDefaultContent();
        if (StringUtil.isNotEmpty(fo.getId())) {
            TaskEntity taskEntity = this.getById(fo.getId());
            if (null != taskEntity) {
                data.put(FlowConstant.FLOW_NAME, taskEntity.getFullName());
                if (StringUtil.isNotBlank(fo.getDelegateUser())) {
                    taskEntity.setDelegateUserId(fo.getDelegateUser());
                }
                taskEntity.setCreatorUserId(StringUtil.isNotBlank(fo.getUserId()) ? fo.getUserId() : userId);
                // 流程名称
                if (ObjectUtil.equals(TaskStatusEnum.RUNNING.getCode(), fo.getStatus())
                        && ObjectUtil.equals(taskEntity.getStatus(), TaskStatusEnum.TO_BE_SUBMIT.getCode())) {
                    String fullName = FlowJsonUtil.field(titleContent, data, "1");
                    taskEntity.setFullName(fullName);
                }
                return taskEntity;
            }
        }
        TaskEntity entity = new TaskEntity();

        entity.setType(fo.getIsFlow());
        if (StringUtil.isNotEmpty(fo.getId())) {
            entity.setId(fo.getId());
        } else {
            entity.setId(RandomUtil.uuId());
        }
        entity.setUrgent(fo.getFlowUrgent());
        entity.setSortCode(0L);

        if (StringUtil.isNotBlank(fo.getDelegateUser())) {
            entity.setDelegateUserId(fo.getDelegateUser());
        }

        // 发起人就是创建人
        entity.setCreatorUserId(StringUtil.isNotBlank(fo.getUserId()) ? fo.getUserId() : userId);
        entity.setCreatorTime(new Date());

        FileConfig fileConfig = global.getFileConfig();
        entity.setIsFile(fileConfig.getOn() ? 0 : null);
        // 流程名称
        String fullName = templateEntity.getFullName();
        if (!ObjectUtil.equals(fo.getStatus(), TaskStatusEnum.TO_BE_SUBMIT.getCode())) {
            data.put(FlowConstant.FLOW_NAME, fullName);
            fullName = FlowJsonUtil.field(titleContent, data, "1");
        }
        entity.setParentId(fo.getParentId());
        if (!StringUtil.equals(FlowNature.ParentId, fo.getParentId())) {
            fullName += "(子流程)";
            entity.setSubCode(fo.getSubCode());
            entity.setSubParameter(JsonUtil.getObjectToString(fo.getSubParameter()));
            entity.setIsAsync(fo.getIsAsync());
        }
        entity.setFullName(fullName);

        entity.setDelegateUserId(fo.getDelegateUser());
        entity.setFlowCode(templateEntity.getEnCode());
        entity.setFlowName(templateEntity.getFullName());
        entity.setFlowCategory(templateEntity.getCategory());
        TemplateJsonEntity jsonEntity = fo.getJsonEntity();
        if (null != jsonEntity && StringUtil.isNotBlank(jsonEntity.getVersion())) {
            entity.setFlowVersion(jsonEntity.getVersion());
        } else {
            entity.setFlowVersion(templateEntity.getVersion());
        }
        entity.setTemplateId(templateEntity.getId());
        entity.setFlowId(templateEntity.getFlowId());
        // entity.setIsBatch(1);// 0：否，1：是

        if (templateEntity.getType() != null) {
            entity.setFlowType(templateEntity.getType());
        }
        return entity;
    }

    // 发起撤回
    @DSTransactional
    @Override
    public void recall(String id, FlowModel flowModel) throws WorkFlowException {
        taskUtil.setFlowModel(id, flowModel);
        TaskEntity taskEntity = flowModel.getTaskEntity();
        taskUtil.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());
        }
        // 删除子流程(判断方法中，存在异步 或 同步子流程已提交 则不允许撤回)
        taskUtil.deleteSubflow(taskEntity.getId(), null);
        // 删除外部节点
        eventLogService.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);
        recordUtil.createRecord(flowMethod);

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

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

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

        // 删除发起人
        launchUserService.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();
        taskUtil.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 = operatorService.list(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 {
        taskUtil.setFlowModel(id, flowModel);
        TaskEntity taskEntity = flowModel.getTaskEntity();
        if (!TaskStatusEnum.PASSED.getCode().equals(taskEntity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF078.get());
        }
        // 处理撤销表单的数据
        taskUtil.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 = taskUtil.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.getChildAllList(id);
            taskStatusList.addAll(taskUtil.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);
        taskUtil.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.deleTaskAll(idList, idAll);
        List<String> revokeTaskIds = revokeService.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);
            candidatesService.setIgnoreLogicDelete().removeByIds(candidatesService.list(candidates));
            candidatesService.clearIgnoreLogicDelete();
            // 发起人
            QueryWrapper<LaunchUserEntity> launchUser = new QueryWrapper<>();
            launchUser.lambda().select(LaunchUserEntity::getId);
            launchUser.lambda().in(LaunchUserEntity::getTaskId, idAll);
            launchUserService.setIgnoreLogicDelete().removeByIds(launchUserService.list(launchUser));
            launchUserService.clearIgnoreLogicDelete();
            // 评论
            QueryWrapper<CommentEntity> comment = new QueryWrapper<>();
            comment.lambda().select(CommentEntity::getId);
            comment.lambda().in(CommentEntity::getTaskId, idAll);
            commentService.setIgnoreLogicDelete().removeByIds(commentService.list(comment));
            commentService.clearIgnoreLogicDelete();
            // 经办
            QueryWrapper<OperatorEntity> operator = new QueryWrapper<>();
            operator.lambda().select(OperatorEntity::getId);
            operator.lambda().in(OperatorEntity::getTaskId, idAll);
            operatorService.setIgnoreLogicDelete().removeByIds(operatorService.list(operator));
            operatorService.clearIgnoreLogicDelete();
            // 记录
            QueryWrapper<RecordEntity> record = new QueryWrapper<>();
            record.lambda().select(RecordEntity::getId);
            record.lambda().in(RecordEntity::getTaskId, idAll);
            recordService.setIgnoreLogicDelete().removeByIds(recordService.list(record));
            recordService.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);
            circulateService.setIgnoreLogicDelete().removeByIds(circulateService.list(circulate));
            circulateService.clearIgnoreLogicDelete();
            // 任务条件
            QueryWrapper<TaskLineEntity> taskLine = new QueryWrapper<>();
            taskLine.lambda().select(TaskLineEntity::getId);
            taskLine.lambda().in(TaskLineEntity::getTaskId, idAll);
            taskLineService.setIgnoreLogicDelete().removeByIds(taskLineService.list(taskLine));
            taskLineService.clearIgnoreLogicDelete();
            // 撤销
            QueryWrapper<RevokeEntity> revoke = new QueryWrapper<>();
            revoke.lambda().select(RevokeEntity::getId);
            revoke.lambda().in(RevokeEntity::getRevokeTaskId, idAll);
            revokeService.setIgnoreLogicDelete().removeByIds(revokeService.list(revoke));
            revokeService.clearIgnoreLogicDelete();
            //节点流转
            QueryWrapper<NodeRecordEntity> nodeRecord = new QueryWrapper<>();
            nodeRecord.lambda().select(NodeRecordEntity::getId);
            nodeRecord.lambda().in(NodeRecordEntity::getTaskId, idAll);
            nodeRecordService.setIgnoreLogicDelete().removeByIds(nodeRecordService.list(nodeRecord));
            nodeRecordService.clearIgnoreLogicDelete();
            //外部事件
            QueryWrapper<EventLogEntity> eventLog = new QueryWrapper<>();
            eventLog.lambda().select(EventLogEntity::getId);
            eventLog.lambda().in(EventLogEntity::getTaskId, idAll);
            eventLogService.setIgnoreLogicDelete().removeByIds(eventLogService.list(eventLog));
            eventLogService.clearIgnoreLogicDelete();
            // 任务流程
            triggerTaskService.deleteByTaskId(idAll);
        }
    }

    @Override
    public void deleTaskAll(List<String> idList, List<String> idAll) {
        idAll.addAll(idList);
        for (String id : idList) {
            List<TaskEntity> taskAll = this.getChildList(id, TaskEntity::getId);
            List<String> list = taskAll.stream().map(TaskEntity::getId).collect(Collectors.toList());
            this.deleTaskAll(list, idAll);
        }
    }

    public List<TaskEntity> getChildList(String id, SFunction<TaskEntity, ?>... columns) {
        return getChildList(ImmutableList.of(id), columns);
    }

    public List<TaskEntity> getChildList(List<String> id, SFunction<TaskEntity, ?>... columns) {
        QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(columns).in(TaskEntity::getParentId, id);
        return this.list(queryWrapper);
    }

    public List<String> getChildAllList(String id) {
        List<String> idAll = new ArrayList<>();
        List<String> idList = ImmutableList.of(id);
        this.deleTaskAll(idList, idAll);
        return idAll;
    }

    public void getChildList(String id, boolean suspend, List<String> list) {
        List<TaskEntity> taskAll = this.getChildList(id, TaskEntity::getId, TaskEntity::getIsAsync);
        if (suspend) {
            taskAll = taskAll.stream().filter(t -> FlowNature.ChildSync.equals(t.getIsAsync())).collect(Collectors.toList());
        }
        for (TaskEntity entity : taskAll) {
            list.add(entity.getId());
            this.getChildList(entity.getId(), suspend, list);
        }
    }

    // 终止与挂起的区别，就是能否在列表中查询到，撤销中不允许终止等操作
    @DSTransactional
    @Override
    public void cancel(String id, FlowModel flowModel, boolean isCancel) throws WorkFlowException {
        if (isCancel) {
            // 任务流程的终止
            TriggerTaskEntity triggerTask = triggerTaskService.getById(id);
            if (null != triggerTask) {
                triggerTask.setStatus(TaskStatusEnum.CANCEL.getCode());
                triggerTaskService.updateById(triggerTask);
                return;
            }
        }
        taskUtil.setFlowModel(id, flowModel);
        TaskEntity taskEntity = flowModel.getTaskEntity();
        taskUtil.isSuspend(taskEntity);

        // 下架的判断
        if (!isCancel) {
            TemplateEntity template = templateService.getById(taskEntity.getTemplateId());
            if (null != template) {
                if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
                    throw new WorkFlowException(MsgCode.WF140.get());
                }
            }
        }

        List<String> idList = ImmutableList.of(id);

        List<TaskEntity> taskList = new ArrayList<>();
        // 递归获取子流程
        for (String taskId : idList) {
            List<String> childAllList = this.getChildAllList(taskId);
            taskList.addAll(taskUtil.getOrderStaList(childAllList));
        }

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

        for (TaskEntity entity : taskList) {
            taskUtil.isSuspend(entity);
            // 记录
            FlowMethod flowMethod = new FlowMethod();
            flowMethod.setFlowModel(flowModel);
            Integer type = isCancel ? RecordEnum.cancel.getCode() : RecordEnum.activate.getCode();
            flowMethod.setType(type);
            OperatorEntity operatorEntity = new OperatorEntity();
            String code = StringUtil.isNotEmpty(entity.getCurrentNodeCode()) ? entity.getCurrentNodeCode() : FlowNature.START_CODE;
            operatorEntity.setNodeCode(code);
            String name = StringUtil.isNotEmpty(entity.getCurrentNodeName()) ? entity.getCurrentNodeName() : FlowNature.START_NAME;
            operatorEntity.setNodeName(name);
            operatorEntity.setTaskId(entity.getId());
            operatorEntity.setHandleId(UserProvider.getLoginUserId());
            flowMethod.setOperatorEntity(operatorEntity);
            recordUtil.createRecord(flowMethod);

            if (isCancel) {
                // 终止，更新实例
                entity.setHisStatus(entity.getStatus());
                entity.setStatus(TaskStatusEnum.CANCEL.getCode());
                this.updateById(entity);

                // 消息
                FlowMsgModel flowMsgModel = new FlowMsgModel();
                flowMsgModel.setNodeList(nodeEntityList);
                flowMsgModel.setFlowModel(flowModel);
                flowMsgModel.setTaskEntity(entity);
                flowMsgModel.setEnd(true);
                msgUtil.message(flowMsgModel);
            } else {
                // 复活
                entity.setStatus(entity.getHisStatus());
                this.updateById(entity);
                operatorUtil.updateCreateTime(flowModel);
            }
            operatorUtil.addTask(ImmutableList.of(entity.getId()));
        }
    }

    @Override
    public boolean checkAsync(String id) {
        List<TaskEntity> childList = this.getChildList(id, TaskEntity::getId, TaskEntity::getIsAsync);
        return childList.stream().anyMatch(e -> FlowNature.ChildAsync.equals(e.getIsAsync()));
    }

    // 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.getChildList(id, TaskEntity::getId, TaskEntity::getIsRestore);
            // 存在 0（能恢复的），就只恢复 1（不能恢复的，即同步的）
            pause = childList.stream().anyMatch(e -> ObjectUtil.equals(e.getIsRestore(), FlowNature.Restore));
        }
        String userId = UserProvider.getLoginUserId();

        this.getChildList(id, pause, idList);

        List<TaskEntity> orderStaList = taskUtil.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);
            recordUtil.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 = operatorUtil.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 {
        taskUtil.setFlowModel(id, flowModel);
        TaskEntity entity = flowModel.getTaskEntity();
        taskUtil.isSuspend(entity);
        taskUtil.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)) {
            launchUserService.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));
        recordUtil.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) {
        Set<String> userIdSet = new HashSet<>();

        // 发起人
        TaskEntity taskEntity = this.getById(taskId);
        if (null != taskEntity) {
            userIdSet.add(taskEntity.getCreatorUserId());
        }

        // 审批人
        List<OperatorEntity> operatorList = operatorService.getList(taskId);
        if (CollectionUtil.isNotEmpty(operatorList)) {
            userIdSet.addAll(operatorList.stream().map(OperatorEntity::getHandleId).collect(Collectors.toList()));
        }

        // 抄送
        List<CirculateEntity> circulateList = circulateService.getList(taskId);
        if (CollectionUtil.isNotEmpty(circulateList)) {
            userIdSet.addAll(circulateList.stream().map(CirculateEntity::getUserId).collect(Collectors.toList()));
        }

        List<RecordEntity> recordList = recordService.getList(taskId);
        if (CollectionUtil.isNotEmpty(recordList)) {
            userIdSet.addAll(recordList.stream().map(RecordEntity::getHandleId).collect(Collectors.toList()));
        }

        TaskUserListModel model = new TaskUserListModel();
        model.setAllUserIdList(new ArrayList<>(userIdSet));
        model.setFlowTask(taskEntity);
        model.setOperatorList(operatorList);
        model.setCirculateList(circulateList);
        model.setOperatorRecordList(recordList);

        return model;
    }

    @Override
    public List<BeforeInfoVo> subFlowInfo(FlowModel flowModel) throws WorkFlowException {
        String taskId = flowModel.getTaskId();
        String nodeCode = flowModel.getNodeCode();
        List<BeforeInfoVo> list = new ArrayList<>();
        QueryWrapper<TaskEntity> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(TaskEntity::getParentId, taskId).eq(TaskEntity::getSubCode, nodeCode);
        List<TaskEntity> entityList = this.list(wrapper);
        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 = circulateService.getById(id);
        if (null != circulate) {
            return OpTypeEnum.Circulate.getType();
        }
        OperatorEntity operator = operatorService.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());
        }
        taskUtil.checkTemplateHide(taskEntity.getTemplateId());

        String handleId = operator.getHandleId();
        String userId = UserProvider.getLoginUserId();
        List<String> delegateList = delegateService.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 = templateNodeService.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());
            operatorService.getList(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());
            operatorService.getList(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());
            operatorService.getList(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()));
            }
            recordService.getList(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()));
            }
            circulateService.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 = operatorService.getList(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;
    }
}