Merge remote-tracking branch 'origin/master'

fuliqi

2025-02-19 ae347a6603c94f73462c9c3e39c3e04476556d6e

 business/src/main/java/com/ycl/service/impl/ProjectProcessServiceImpl.java

@@ -1,46 +1,41 @@
package com.ycl.service.impl;


import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.ycl.common.constant.ProcessConstants;
import com.ycl.common.constant.ProcessOverTimeConstants;
import com.ycl.common.core.domain.entity.SysDept;
import com.ycl.common.core.domain.entity.SysDictData;
import com.ycl.common.core.domain.entity.SysRole;
import com.ycl.common.core.domain.entity.SysUser;
import com.ycl.common.enums.business.HandlerTypeEnum;
import com.ycl.common.enums.business.ProcessLogEventTypeEnum;
import com.ycl.common.enums.business.TaskStatusEnum;
import com.ycl.common.enums.business.*;
import com.ycl.common.utils.SecurityUtils;
import com.ycl.constant.TaskTypeConstant;
import com.ycl.domain.entity.ProcessCoding;
import com.ycl.domain.entity.ProjectInfo;
import com.ycl.domain.entity.ProjectProcess;
import com.ycl.domain.entity.SysForm;
import com.ycl.domain.form.TaskDelegationForm;
import com.ycl.domain.form.TaskJumpForm;
import com.ycl.domain.json.DelegateData;
import com.ycl.domain.entity.*;
import com.ycl.domain.form.*;
import com.ycl.domain.json.*;
import com.ycl.domain.vo.CustomerTaskVO;
import com.ycl.domain.vo.IndexCustomerTaskVO;
import com.ycl.domain.vo.ProjectProcessDetailVO;
import com.ycl.event.event.TaskLogEvent;
import com.ycl.mapper.ProjectInfoMapper;
import com.ycl.mapper.ProjectProcessMapper;
import com.ycl.service.IFlowTaskService;
import com.ycl.service.ISysFormService;
import com.ycl.service.ProcessCodingService;
import com.ycl.service.ProjectProcessService;
import com.ycl.service.*;
import com.ycl.common.base.Result;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycl.domain.form.ProjectProcessForm;
import com.ycl.domain.vo.ProjectProcessVO;
import com.ycl.domain.query.ProjectProcessQuery;
import com.ycl.service.common.TaskCommonService;
import com.ycl.system.service.ISysDeptService;
import com.ycl.system.service.ISysDictTypeService;
import com.ycl.system.service.ISysRoleService;
import com.ycl.system.service.ISysUserService;
import lombok.Synchronized;
import org.apache.commons.lang3.StringUtils;
import org.flowable.bpmn.model.*;
import org.flowable.bpmn.model.Process;
@@ -92,6 +87,8 @@
    private final ProcessCodingService processCodingService;
    private final ApplicationEventPublisher publisher;
    private final ISysDeptService deptService;
    private final ProcessLogService processLogService;
    private final ISysDictTypeService dictTypeService;

    /**
     * 分页查询
@@ -142,22 +139,22 @@
            }
        }
        ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
                .select(ProjectInfo::getCreateBy)
                .select(ProjectInfo::getProjectOwnerUnit)
                .eq(ProjectInfo::getId, form.getProjectId())
                .one();
        if (Objects.isNull(project)) {
            throw new RuntimeException("项目不存在");
        }
        SysUser user = sysUserService.selectUserById(project.getCreateBy());
        if (Objects.isNull(user)) {
        SysDept dept = deptService.selectDeptById(project.getProjectOwnerUnit());
        if (Objects.isNull(dept)) {
            throw new RuntimeException("项目业主单位不存在");
        }
        String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId(), user.getDeptId());
        String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId(), dept.getDeptId());
        new LambdaUpdateChainWrapper<>(baseMapper)
                .eq(ProjectProcess::getProjectId, form.getProjectId())
                .set(ProjectProcess::getProcessDefId, form.getProcessDefId())
                .set(ProjectProcess::getProcessInsId, processInsId)
                .set(ProjectProcess::getDataLaunch, project.getCreateBy())
                .set(ProjectProcess::getDataLaunch, project.getProjectOwnerUnit())
                .update();

        return Result.ok("流程变更成功");
@@ -166,23 +163,20 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result startProcess(Long projectId, String processDefId) {
        ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
                .select(ProjectInfo::getCreateBy)
                .eq(ProjectInfo::getId, projectId)
                .one();
        ProjectInfo project = projectInfoMapper.selectById(projectId);
        if (Objects.isNull(project)) {
            throw new RuntimeException("项目不存在");
        }
        SysUser user = sysUserService.selectUserById(project.getCreateBy());
        if (Objects.isNull(user)) {
        SysDept dept = deptService.selectDeptById(project.getProjectOwnerUnit());
        if (Objects.isNull(dept)) {
            throw new RuntimeException("项目业主单位不存在");
        }
        String processInsId = this.startPro(projectId, processDefId, user.getDeptId());
        String processInsId = this.startPro(projectId, processDefId, dept.getDeptId());
        ProjectProcess entity = new ProjectProcess();
        entity.setProjectId(projectId);
        entity.setProcessDefId(processDefId);
        entity.setProcessInsId(processInsId);
        entity.setDataLaunch(project.getCreateBy());
        entity.setDataLaunch(project.getProjectOwnerUnit());
        baseMapper.insert(entity);

        return Result.ok("流程启动成功");
@@ -209,7 +203,7 @@
        identityService.setAuthenticatedUserId(sysUser.getUserId().toString());
        variables.put(ProcessConstants.PROCESS_INITIATOR, sysUser.getUserId());
        //测试容缺
        variables.put("miss",true);
        variables.put("miss", true);
        // 将该项目的申请人（业主方）作为流程中某些环节的处理人
        variables.put(ProcessConstants.DATA_LAUNCH, "dept:" + createBy);
        ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefId, projectId + "", variables);
@@ -315,7 +309,7 @@
        if (StringUtils.isNotBlank(taskName)) {
            taskQuery.processDefinitionNameLike(taskName);
        }
        if (! SecurityUtils.getLoginUser().getUser().isAdmin()) {
        if (!SecurityUtils.getLoginUser().getUser().isAdmin()) {
            taskQuery
                    .or()
                    .taskCandidateGroupIn(taskCommonService.getCurrentUserGroups())
@@ -340,7 +334,7 @@
                    .processDefinitionId(task.getProcessDefinitionId())
                    .singleResult();
            taskVO.setDeployId(pd.getDeploymentId());
            taskVO.setProcessName(pd.getName());
            taskVO.setProcessName(pd.getName() + "(v" + pd.getVersion() + ")");
            taskVO.setProcessInsId(task.getProcessInstanceId());
            taskVO.setTaskDefinitionKey(task.getTaskDefinitionKey());

@@ -408,7 +402,10 @@
                    }
                }
            }

            // 检查是否挂起
            if (processLogService.taskIsHangup(task.getId(), task.getProcessInstanceId())) {
                taskVO.setTaskStatus(TaskStatusEnum.HANGUP);
            }
            this.distinctVo(taskVO);
            vos.add(taskVO);
        }
@@ -609,7 +606,7 @@
        jsonData.setAfterHandlerIds(afterHandlerIds);
        jsonData.setAfterHandlerType(form.getPeopleType());
        // 发布转办事件
        publisher.publishEvent(new TaskLogEvent(this, form.getProjectId(), form.getProcessInsId(), task.getId(), ProcessLogEventTypeEnum.DELEGATE, jsonData));
        publisher.publishEvent(new TaskLogEvent(this, null,SecurityUtils.getUserId(), form.getProjectId(), form.getProcessInsId(), task.getId(), task.getName(),ProcessLogEventTypeEnum.DELEGATE, jsonData));

        return Result.ok("转办成功");
    }
@@ -620,7 +617,7 @@
        Task task = taskService.createTaskQuery().taskId(form.getTaskId()).processInstanceId(form.getProcessInsId()).singleResult();
        if (Objects.nonNull(task)) {
            // 添加跳过日志
            publisher.publishEvent(new TaskLogEvent(this, form.getProjectId(), form.getProcessInsId(), form.getTaskId(), ProcessLogEventTypeEnum.JUMP, null));
            publisher.publishEvent(new TaskLogEvent(this, null,SecurityUtils.getUserId(), form.getProjectId(), form.getProcessInsId(), form.getTaskId(), task.getName(),ProcessLogEventTypeEnum.JUMP, new JumpData(form.getDesc())));
            // 查出该任务绑定的表单

            Map<String, Object> data = new HashMap<>(1);
@@ -633,6 +630,142 @@
            // 完成任务
            flowTaskService.completeSubmitForm(form.getTaskId(), data);
        }
        return Result.ok("操作成功");
    }

    @Override
    public Result taskSupervise(TaskSuperviseForm form) {
        Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
        SuperviseData jsonData = new SuperviseData();
        jsonData.setCreateTime(new Date());
        jsonData.setContent(form.getContent());
        jsonData.setSenderId(SecurityUtils.getUserId() + "");
        jsonData.setSenderType(HandlerTypeEnum.USER);
        jsonData.setReceiverIds(form.getReceiverIds());
        jsonData.setReceiverType(form.getReceiverType());
        jsonData.setSuperviseType(form.getSuperviseType());
        QueryWrapper<ProcessLog> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("task_id", form.getTaskId());
        queryWrapper.eq("event_type", ProcessLogEventTypeEnum.SUPERVISE);
        queryWrapper.eq("process_ins_id", form.getProcessInsId());
        //查询督办日志
        ProcessLog processLog = processLogService.getOne(queryWrapper);
        List<SuperviseData> dataList;
        if (processLog != null) {
            String eventDataJson = processLog.getEventDataJson();
            dataList = JSONArray.parseArray(eventDataJson, SuperviseData.class);
        } else {
            processLog = new ProcessLog();
            processLog.setUserId(SecurityUtils.getUserId());
            dataList = new ArrayList<>();
        }
        dataList.add(jsonData);
        //添加督办日志
        publisher.publishEvent(new TaskLogEvent(this, processLog.getId(), processLog.getUserId(), form.getProjectId(), form.getProcessInsId(), form.getTaskId(), task.getName(),ProcessLogEventTypeEnum.SUPERVISE, dataList));
        return Result.ok("操作成功");
    }

    @Override
    @Synchronized
    public Result taskHangup(TaskHangupForm form) {
        Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
        if (Objects.isNull(task)) {
            throw new RuntimeException("任务不存在");
        }
        List<ProcessLog> logs = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getTaskId, form.getTaskId())
                .eq(ProcessLog::getProcessInsId, form.getProcessInsId())
                .eq(ProcessLog::getProjectId, form.getProjectId())
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.HANGUP, ProcessLogEventTypeEnum.CANCEL_HANGUP)
                .list();
        if (logs.size() % 2 != 0) {
            throw new RuntimeException("该任务正在挂起中，不能再次挂起");
        }
        // 任务挂起只需要存日志，查询待办时如果有这个日志记录，则禁用提交按钮，以此实现任务挂起
        publisher.publishEvent(new TaskLogEvent(this,
                null,
                SecurityUtils.getUserId(),
                form.getProjectId(),
                form.getProcessInsId(),
                form.getTaskId(),
                task.getName(),
                ProcessLogEventTypeEnum.HANGUP,
                new HangupData(form.getReason())
                ));
        return Result.ok("操作成功");
    }

    @Override
    @Synchronized
    public Result cancelTaskHangup(TaskHangupForm form) {
        Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
        if (Objects.isNull(task)) {
            throw new RuntimeException("任务不存在");
        }
        List<ProcessLog> logs = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
                .eq(ProcessLog::getTaskId, form.getTaskId())
                .eq(ProcessLog::getProcessInsId, form.getProcessInsId())
                .eq(ProcessLog::getProjectId, form.getProjectId())
                .in(ProcessLog::getEventType, ProcessLogEventTypeEnum.HANGUP, ProcessLogEventTypeEnum.CANCEL_HANGUP)
                .list();
        if (logs.size() % 2 == 0) {
            throw new RuntimeException("该任务未被挂起，不能取消挂起");
        }
        publisher.publishEvent(new TaskLogEvent(this,
                null,
                SecurityUtils.getUserId(),
                form.getProjectId(),
                form.getProcessInsId(),
                form.getTaskId(),
                task.getName(),
                ProcessLogEventTypeEnum.CANCEL_HANGUP,
                new HangupData(form.getReason())
        ));
        return Result.ok("操作成功");
    }

    @Override
    public Result taskTeamwork(TaskTeamWorkForm form) {
        Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
        if (Objects.isNull(task)) {
            return Result.error("任务不存在");
        }
        ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(projectProcessMapper)
                .eq(ProjectProcess::getProcessInsId, task.getProcessInstanceId())
                .eq(ProjectProcess::getProcessDefId, task.getProcessDefinitionId())
                .one();
        if (Objects.isNull(projectProcess)) {
            return Result.error("项目流程未绑定");
        }
        // 1. 保存发起人填写的表单数据，但不直接完成该任务。提交后任务处理人必须等到协同人处理完之后才能完成任务
        Map<String, Object> processVariables = new HashMap<>();
        //查出字典中需要注入的字段信息
        List<String> dictList = dictTypeService.selectDictDataByType("flow_variables").stream().map(SysDictData::getDictValue).collect(Collectors.toList());
        Map<String, Object> newV = new HashMap<>(2);
        if (!org.springframework.util.CollectionUtils.isEmpty(form.getVariables())) {
            for (String key : form.getVariables().keySet()) {
                newV.put(task.getTaskDefinitionKey() + "&" + key, form.getVariables().get(key));
                //字典里有就放入流程变量中
                if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(dictList) && dictList.contains(key)) {
                    processVariables.put(key,form.getVariables().get(key));
                }
            }
        }
        if( !processVariables.isEmpty() ) {
            taskService.setVariables(form.getTaskId(), processVariables);
        }

        // 2. 保存日志
        publisher.publishEvent(new TaskLogEvent(this,
                null,
                SecurityUtils.getUserId(),
                form.getProjectId(),
                form.getProcessInsId(),
                form.getTaskId(),
                task.getName(),
                ProcessLogEventTypeEnum.TEAM_WORK,
                new TeamWorkData(form.getHandlerType(), form.getHandlerIds(), TeamWorkStatusEnum.NOT_FINISHED)
        ));
        return Result.ok("操作成功");
    }

@@ -663,6 +796,10 @@
        for (Task task : taskList) {
            CustomerTaskVO taskVO = new CustomerTaskVO();
            this.setRuntimeTaskInfo(task, taskVO, projectId);
            // 检查是否挂起
            if (processLogService.taskIsHangup(task.getId(), task.getProcessInstanceId())) {
                taskVO.setTaskStatus(TaskStatusEnum.HANGUP);
            }
            vos.add(taskVO);
        }
        result.put("taskList", vos);
@@ -671,7 +808,7 @@
    /**
     * 获取所有任务
     *
     * @param projectId 项目id
     * @param projectId           项目id
     * @param processDefinitionId 流程运行id
     * @param processInsId        流程实例id
     * @param pageNum
@@ -757,8 +894,7 @@
                            if (groupId.contains(ProcessConstants.DATA_LAUNCH)) {
                                vo.setHandlerType(HandlerTypeEnum.DEPT);
                                this.varYzReview(vo, projectId, processInsId, HandlerTypeEnum.DEPT);
                            }
                            else if (groupId.startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                            } else if (groupId.startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                                vo.setHandlerType(HandlerTypeEnum.DEPT);
                                String[] split = groupId.split(":");
                                if (split.length > 1) {
@@ -819,7 +955,7 @@
    /**
     * 查询已完成的流程的任务信息
     *
     * @param userTasks 任务节点列表
     * @param userTasks    任务节点列表
     * @param processInsId 流程实例id
     * @param processDefId 流程定义id
     * @return
@@ -866,8 +1002,8 @@
    /**
     * 设置运行时任务的信息
     *
     * @param task 任务
     * @param taskVO 任务vo
     * @param task      任务
     * @param taskVO    任务vo
     * @param projectId 项目id
     */
    private void setRuntimeTaskInfo(Task task, CustomerTaskVO taskVO, Long projectId) {
@@ -966,8 +1102,8 @@
        List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInsId)
                .finished()
                .includeIdentityLinks()
                .list();
        hisTaskList = this.distinctHisTask(hisTaskList);
        if (CollectionUtils.isEmpty(hisTaskList)) {
            return 0L;
        }
@@ -975,20 +1111,24 @@
        List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
        // 查出时间正常的任务key
        List<ProcessCoding> taskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
        List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, hisTaskKeys)
                .list();
        Map<String, ProcessCoding> codingMap = taskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
        List<HistoricTaskInstance> finishedTaskList = new ArrayList<>();
        // 判断
        for (String key : hisTaskMap.keySet()) {
            ProcessCoding processCoding = codingMap.get(key);
            List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
            // 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
            if (Objects.isNull(processCoding)) {
            if (CollectionUtils.isEmpty(targetProcessCodings)) {
                finishedTaskList.add(hisTaskMap.get(key));
            } else if (ProcessOverTimeConstants.NORMAL.equals(processCoding.getOvertimeStatus()) || StringUtils.isBlank(processCoding.getOvertimeStatus())) {
                finishedTaskList.add(hisTaskMap.get(key));
            } else {
                // 按照时间降序排列
                targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
                ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
                if (ProcessOverTimeConstants.NORMAL.equals(latestProjectProcess.getOvertimeStatus()) || StringUtils.isBlank(latestProjectProcess.getOvertimeStatus())) {
                    finishedTaskList.add(hisTaskMap.get(key));
                }
            }
        }
        return Long.valueOf(finishedTaskList.size());
@@ -998,8 +1138,8 @@
     * 查询按时完成的任务
     *
     * @param processDefinitionId 流程定义id
     * @param processInsId 流程实例id
     * @param taskName 任务名称--搜索条件
     * @param processInsId        流程实例id
     * @param taskName            任务名称--搜索条件
     * @param pageNum
     * @param pageSize
     * @param result
@@ -1024,22 +1164,26 @@
        }

        List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
        Map<String, HistoricTaskInstance> hisTaskMap = this.distinctHisTask(hisTaskList).stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
        // 查出时间正常的任务key
        List<ProcessCoding> taskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
        List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, hisTaskKeys)
                .list();
        Map<String, ProcessCoding> codingMap = taskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
        List<HistoricTaskInstance> finishedTaskList = new ArrayList<>();
        // 判断
        for (String key : hisTaskMap.keySet()) {
            ProcessCoding processCoding = codingMap.get(key);
            List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
            // 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
            if (Objects.isNull(processCoding)) {
            if (CollectionUtils.isEmpty(targetProcessCodings)) {
                finishedTaskList.add(hisTaskMap.get(key));
            } else if (ProcessOverTimeConstants.NORMAL.equals(processCoding.getOvertimeStatus()) || StringUtils.isBlank(processCoding.getOvertimeStatus())) {
                finishedTaskList.add(hisTaskMap.get(key));
            } else {
                // 按照时间降序排列
                targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
                ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
                if (ProcessOverTimeConstants.NORMAL.equals(latestProjectProcess.getOvertimeStatus()) || StringUtils.isBlank(latestProjectProcess.getOvertimeStatus())) {
                    finishedTaskList.add(hisTaskMap.get(key));
                }
            }
        }

@@ -1117,6 +1261,27 @@
        return vos;
    }

    /**
     * 根据任务key去重历史任务，相同情况下取最新的一条
     *
     * @param hisTaskList
     * @return
     */
    private List<HistoricTaskInstance> distinctHisTask(List<HistoricTaskInstance> hisTaskList) {
        Map<String, HistoricTaskInstance> uniqueTasks = new HashMap<>();
        for (HistoricTaskInstance task : hisTaskList) {
            String taskDefinitionKey = task.getTaskDefinitionKey();
            HistoricTaskInstance existingTask = uniqueTasks.get(taskDefinitionKey);

            // 如果任务key重复（可能被驳回过，重新提交导致key重复），取最近的一条
            if (existingTask == null || task.getCreateTime().after(existingTask.getCreateTime())) {
                uniqueTasks.put(taskDefinitionKey, task);
            }
        }
        // 最终去重后的任务列表
        return new ArrayList<>(uniqueTasks.values());
    }


    /**
     * 统计超时的任务数
@@ -1134,31 +1299,36 @@
        List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
        // 查出数据库的任务key
        List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
        List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, taskKeys)
                .list();
        Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
        List<Task> tList = new ArrayList<>();
        // 判断
        for (String key : taskMap.keySet()) {
            ProcessCoding processCoding = codingMap.get(key);
            // 如果运行中的任务没从数据库查找出来，说明该任务没配置赋码等时间，不算超时
            if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.OVERTIME.equals(processCoding.getOvertimeStatus())) {
            List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
            // 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
            if (CollectionUtils.isEmpty(targetProcessCodings)) {
                tList.add(taskMap.get(key));
            } else {
                // 按照时间降序排列
                targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
                ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
                if (Objects.nonNull(latestProjectProcess) && ProcessOverTimeConstants.OVERTIME.equals(latestProjectProcess.getOvertimeStatus())) {
                    tList.add(taskMap.get(key));
                }
            }
        }

        return Long.valueOf(taskList.size());
    }

    /**
     * 查询超时的任务
     *
     * @param projectId 项目id
     * @param projectId           项目id
     * @param processDefinitionId 流程定义id
     * @param processInsId 流程实例id
     * @param taskName 任务名称--搜索条件
     * @param processInsId        流程实例id
     * @param taskName            任务名称--搜索条件
     * @param pageNum
     * @param pageSize
     * @param result
@@ -1182,18 +1352,24 @@
        List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
        // 查出数据库的任务key
        List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
        List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, taskKeys)
                .list();
        Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
        List<Task> tList = new ArrayList<>();
        // 判断
        for (String key : taskMap.keySet()) {
            ProcessCoding processCoding = codingMap.get(key);
            // 如果运行中的任务没从数据库查找出来，说明该任务没配置赋码等时间，不算超时
            if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.OVERTIME.equals(processCoding.getOvertimeStatus())) {
            List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
            // 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
            if (CollectionUtils.isEmpty(targetProcessCodings)) {
                tList.add(taskMap.get(key));
            } else {
                // 按照时间降序排列
                targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
                ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
                if (Objects.nonNull(latestProjectProcess) && ProcessOverTimeConstants.OVERTIME.equals(latestProjectProcess.getOvertimeStatus())) {
                    tList.add(taskMap.get(key));
                }
            }
        }

@@ -1236,18 +1412,24 @@
        List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
        // 查出数据库的任务key
        List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
        List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, taskKeys)
                .list();
        Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
        List<Task> tList = new ArrayList<>();
        // 判断
        for (String key : taskMap.keySet()) {
            ProcessCoding processCoding = codingMap.get(key);
            // 如果运行中的任务没从数据库查找出来，说明该任务没配置赋码等时间，不算即将超时
            if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.WILLOVERTIME.equals(processCoding.getOvertimeStatus())) {
            List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
            // 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
            if (CollectionUtils.isEmpty(targetProcessCodings)) {
                tList.add(taskMap.get(key));
            } else {
                // 按照时间降序排列
                targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
                ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
                if (Objects.nonNull(latestProjectProcess) && ProcessOverTimeConstants.WILLOVERTIME.equals(latestProjectProcess.getOvertimeStatus())) {
                    tList.add(taskMap.get(key));
                }
            }
        }
        return Long.valueOf(tList.size());
@@ -1256,10 +1438,10 @@
    /**
     * 查询即将超时的任务
     *
     * @param projectId 项目id
     * @param projectId           项目id
     * @param processDefinitionId 流程定义id
     * @param processInsId 流程实例id
     * @param taskName 任务名称--搜索条件
     * @param processInsId        流程实例id
     * @param taskName            任务名称--搜索条件
     * @param pageNum
     * @param pageSize
     * @param result
@@ -1283,18 +1465,24 @@
        List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
        Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
        // 查出数据库的任务key
        List<ProcessCoding> databaseTaskList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
        List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, taskKeys)
                .list();
        Map<String, ProcessCoding> codingMap = databaseTaskList.stream().collect(Collectors.toMap(ProcessCoding::getTaskDefKey, pro -> pro));
        List<Task> tList = new ArrayList<>();
        // 判断
        for (String key : taskMap.keySet()) {
            ProcessCoding processCoding = codingMap.get(key);
            // 如果运行中的任务没从数据库查找出来，说明该任务没配置赋码等时间，不算即将超时
            if (Objects.nonNull(processCoding) && ProcessOverTimeConstants.WILLOVERTIME.equals(processCoding.getOvertimeStatus())) {
            List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
            // 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
            if (CollectionUtils.isEmpty(targetProcessCodings)) {
                tList.add(taskMap.get(key));
            } else {
                // 按照时间降序排列
                targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
                ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
                if (Objects.nonNull(latestProjectProcess) && ProcessOverTimeConstants.WILLOVERTIME.equals(latestProjectProcess.getOvertimeStatus())) {
                    tList.add(taskMap.get(key));
                }
            }
        }

@@ -1325,7 +1513,7 @@
    /**
     * 查询剩余事项（未开始的任务）
     *
     * @param projectId 项目id
     * @param projectId           项目id
     * @param processDefinitionId
     * @param processInsId
     * @param taskName
@@ -1371,7 +1559,6 @@
        List<UserTask> userTasks = allUserTaskElement.subList(startNum, end);



        // 判断任务状态，构建vo
        List<CustomerTaskVO> vos = new ArrayList<>(48);
        for (UserTask userTask : userTasks) {
@@ -1411,8 +1598,7 @@
                    if (groupId.contains(ProcessConstants.DATA_LAUNCH)) {
                        vo.setHandlerType(HandlerTypeEnum.DEPT);
                        this.varYzReview(vo, projectId, processInsId, HandlerTypeEnum.DEPT);
                    }
                    else if (groupId.startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                    } else if (groupId.startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                        vo.setHandlerType(HandlerTypeEnum.DEPT);
                        String[] split = groupId.split(":");
                        if (split.length > 1) {
@@ -1537,7 +1723,7 @@
        if (TaskStatusEnum.TODO.equals(taskVO.getTaskStatus())) {
            List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(taskVO.getTaskId());
            for (IdentityLink identityLink : identityLinksForTask) {
                if (StringUtils.isBlank(((IdentityLinkEntityImpl)identityLink).getId())) {
                if (StringUtils.isBlank(((IdentityLinkEntityImpl) identityLink).getId())) {
                    continue;
                }
                // 绑定的是用户，查出用户姓名、部门
@@ -1632,7 +1818,7 @@
                    .orderByHistoricTaskInstanceStartTime()
                    .desc()
                    .list(); // 之所以用list是因为如果某个任务被驳回过，且如果该任务再次执行时会有多条数据，取最新的一条
            if (! CollectionUtils.isEmpty(historicTaskInstances)) {
            if (!CollectionUtils.isEmpty(historicTaskInstances)) {
                // 实际领取这个任务的人，也就是处理人
                String assignee = historicTaskInstances.get(0).getAssignee();
                SysUser startUser = sysUserService.selectUserById(Long.parseLong(assignee));
@@ -1645,10 +1831,18 @@
            taskVO.setPromoterName("暂无");
            taskVO.setPromoterUnitName("暂无");
        } else {
            taskVO.setPromoterId(userList.stream().map(user -> { return user.getUserId() + ""; }).collect(Collectors.joining("、")));
            taskVO.setPromoterName(userList.stream().map(user -> { return user.getNickName(); }).collect(Collectors.joining("、")));
            taskVO.setPromoterUnitId(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> { return user.getDept().getDeptId() + "";}).collect(Collectors.joining("、")));
            taskVO.setPromoterUnitName(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> { return user.getDept().getDeptName() + "";}).collect(Collectors.joining("、")));
            taskVO.setPromoterId(userList.stream().map(user -> {
                return user.getUserId() + "";
            }).collect(Collectors.joining("、")));
            taskVO.setPromoterName(userList.stream().map(user -> {
                return user.getNickName();
            }).collect(Collectors.joining("、")));
            taskVO.setPromoterUnitId(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> {
                return user.getDept().getDeptId() + "";
            }).collect(Collectors.joining("、")));
            taskVO.setPromoterUnitName(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> {
                return user.getDept().getDeptName() + "";
            }).collect(Collectors.joining("、")));
        }
    }