超时计算排除节假日，超时统计调整

xiangpei

2025-03-31 1698792d4299a0b81b9695d8a56e3d3088c7a7ee

超时计算排除节假日，超时统计调整

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

@@ -13,6 +13,7 @@
import com.ycl.common.core.domain.entity.SysRole;
import com.ycl.common.core.domain.entity.SysUser;
import com.ycl.common.enums.business.*;
import com.ycl.common.utils.DateUtils;
import com.ycl.common.utils.SecurityUtils;
import com.ycl.constant.TaskTypeConstant;
import com.ycl.domain.entity.*;
@@ -435,7 +436,7 @@
                    Long overtime = getTime(processCoding.getRedTime());
                    long durationTime = 0l;
                    if (Objects.nonNull(processCoding.getStartTaskTime())) {
                        durationTime = ((new Date()).getTime() - processCoding.getStartTaskTime().getTime()) / 1000;
                        durationTime = DateUtils.getWorkingSed(processCoding.getStartTaskTime(), new Date());
                    }
                    if (overtime > durationTime) {
                        order.setNum((overtime - durationTime) / 3600);
@@ -1616,6 +1617,81 @@
    }

    /**
     * 设置历史任务信息
     *
     * @param hisTask
     * @param vo
     * @param projectId
     * @param processInsId
     */
    private void setHisTaskInfo(HistoricTaskInstance hisTask, CustomerTaskVO vo, String projectId, String processInsId) {
        // 查出流程
        ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
        String deployId = "";
        String processName = "";
        String processDefinitionId = "";
        if (Objects.nonNull(process)) {
            deployId = process.getDeploymentId();
            processName = process.getProcessDefinitionName();
            processDefinitionId = process.getProcessDefinitionId();
        } else {
            HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInsId).singleResult();
            deployId = hisProcess.getDeploymentId();
            processName = hisProcess.getProcessDefinitionName();
            processDefinitionId = hisProcess.getProcessDefinitionId();
        }

        vo.setProcessInsId(processInsId);
        vo.setProcessDefId(processDefinitionId);
        vo.setDeployId(deployId);
        vo.setTaskName(hisTask.getName());
        vo.setProcessName(processName);

        // 一个任务可能有多个候选人/组，所以需要使用list
        List<Long> handlerIds = new ArrayList<>(2);
        List<String> handlerNames = new ArrayList<>(2);
        List<Long> handlerUnitIds = new ArrayList<>(2);
        List<String> handlerUnitNames = new ArrayList<>(2);
        List<String> promoterNames = new ArrayList<>(2);
        List<String> promoterUnitNames = new ArrayList<>(2);
        vo.setHandlerId(handlerIds);
        vo.setHandlerName(handlerNames);
        vo.setHandlerUnitId(handlerUnitIds);
        vo.setHandlerUnitName(handlerUnitNames);
        vo.setPromoterName(promoterNames);
        vo.setPromoterUnitName(promoterUnitNames);
        List<UserTask> targetUserTasks = this.getAllUserTaskElement(processDefinitionId).stream().filter(userTask -> hisTask.getTaskDefinitionKey().equals(userTask.getId())).collect(Collectors.toList());
        UserTask userTask = null;
        if (! CollectionUtils.isEmpty(targetUserTasks)) {
            userTask = targetUserTasks.get(0);
        }
        this.setCandidateInfo(userTask, vo, projectId, processInsId);


        vo.setTaskStatus(TaskStatusEnum.FINISHED);
        // 如果是已完成的，信息需要单独赋值
        vo.setTaskId(hisTask.getId());
        vo.setExecutionId(hisTask.getExecutionId());
        vo.setCreateTime(hisTask.getStartTime());

        // 查询实际处理人
        if (StringUtils.isNotBlank(hisTask.getAssignee())) {
            long handlerUserId = Long.parseLong(hisTask.getAssignee());
            SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
            if (Objects.nonNull(handlerUser)) {
                vo.getHandlerId().add(handlerUserId);
                vo.getHandlerName().add(this.getUserShowName(handlerUser));
                if (Objects.nonNull(handlerUser.getDept())) {
                    vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
                    vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
                }
            }
        }
        vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
        this.distinctVo(vo);
    }

    /**
     * 用户名称后面跟电话号码
     *
     * @param user
@@ -1664,36 +1740,16 @@
     * @return
     */
    private Long getOvertimeTaskNum(String processInsId) {
        // 查出运行在的任务key
        List<Task> taskList = taskService.createTaskQuery().processInstanceId(processInsId).list();

        if (CollectionUtils.isEmpty(taskList)) {
        // 查出已超时的任务id
        List<ProcessCoding> overtimeRecords = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .eq(ProcessCoding::getOvertimeStatus, ProcessOverTimeConstants.OVERTIME)
                .orderByDesc(ProcessCoding::getGmtCreate)
                .list();
        if (CollectionUtils.isEmpty(overtimeRecords)) {
            return 0L;
        }
        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> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, taskKeys)
                .list();
        List<Task> tList = new ArrayList<>();
        // 判断
        for (String key : taskMap.keySet()) {
            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());
        return Long.valueOf(overtimeRecords.size());
    }

    /**
@@ -1712,63 +1768,108 @@
        int startNum = pageSize * (pageNum - 1);
        int endNum = startNum + pageSize;

        // 查出运行在的任务key
        List<Task> taskList = new ArrayList<>(12);
        if (StringUtils.isNotBlank(taskName)) {
            taskList = taskService.createTaskQuery().processInstanceId(processInsId).taskNameLike(taskName).orderByTaskCreateTime().desc().list();
        } else {
            taskList = taskService.createTaskQuery().processInstanceId(processInsId).orderByTaskCreateTime().desc().list();
        }
        if (CollectionUtils.isEmpty(taskList)) {
        // 查出已超时的任务id
        List<ProcessCoding> overtimeRecords = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .eq(ProcessCoding::getOvertimeStatus, ProcessOverTimeConstants.OVERTIME)
                .orderByDesc(ProcessCoding::getGmtCreate)
                .list();
        if (CollectionUtils.isEmpty(overtimeRecords)) {
            result.total(0);
            return new ArrayList<>();
        }
        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> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
                .eq(ProcessCoding::getProcessInsId, processInsId)
                .in(ProcessCoding::getTaskDefKey, taskKeys)
                .list();
        List<Task> tList = new ArrayList<>();
        // 判断
        for (String key : taskMap.keySet()) {
            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));
                }
            }
        }

        if (startNum >= tList.size()) {
        if (startNum >= overtimeRecords.size()) {
            // 如果起始索引超出了列表的大小，返回一个空列表
            return new ArrayList<>();
        }
        result.total(tList.size());
        int end = Math.min(endNum, tList.size());
        List<Task> pageTaskList = tList.subList(startNum, end);
        List<String> taskDefs = pageTaskList.stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
        Map<String, Task> keyMap = pageTaskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
        result.total(overtimeRecords.size());
        int end = Math.min(endNum, overtimeRecords.size());
        List<ProcessCoding> pageOvertimeRecords = overtimeRecords.subList(startNum, end);

        // 得到目标任务对应的定义
        List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());

        // 查询任务相关信息
        List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
            Task task = keyMap.get(userTask.getId());
        List<CustomerTaskVO> vos = pageOvertimeRecords.stream().map(record -> {
            CustomerTaskVO vo = new CustomerTaskVO();
            this.setRuntimeTaskInfo(task, vo, projectId);
            return vo;
        }).collect(Collectors.toList());
            Task task = taskService.createTaskQuery().processInstanceId(processInsId).taskId(record.getTaskId()).singleResult();
            if (Objects.nonNull(task)) {
                this.setRuntimeTaskInfo(task, vo, projectId);
                vo.setTaskStatus(TaskStatusEnum.OVER_TIME);
                return vo;
            } else {
                List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
                        .finished()
                        .processInstanceId(processInsId)
                        .taskId(record.getTaskId())
                        .orderByHistoricTaskInstanceStartTime()
                        .desc()
                        .list();
                if (CollectionUtils.isEmpty(list)) {
                    return null;
                }
                List<HistoricTaskInstance> hisTask = this.distinctHisTask(list);
                this.setHisTaskInfo(hisTask.get(0), vo, projectId, processInsId);
                vo.setTaskStatus(TaskStatusEnum.OVER_TIME_FINISHED);
                return vo;
            }
        }).filter(Objects::nonNull).collect(Collectors.toList());
        result.data(vos);
        return vos;

//        // 查出运行在的任务key
//        List<Task> taskList = new ArrayList<>(12);
//        if (StringUtils.isNotBlank(taskName)) {
//            taskList = taskService.createTaskQuery().processInstanceId(processInsId).taskNameLike(taskName).orderByTaskCreateTime().desc().list();
//        } else {
//            taskList = taskService.createTaskQuery().processInstanceId(processInsId).orderByTaskCreateTime().desc().list();
//        }
//        if (CollectionUtils.isEmpty(taskList)) {
//            result.total(0);
//            return new ArrayList<>();
//        }
//        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> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
//                .eq(ProcessCoding::getProcessInsId, processInsId)
//                .in(ProcessCoding::getTaskDefKey, taskKeys)
//                .list();
//        List<Task> tList = new ArrayList<>();
//        // 判断
//        for (String key : taskMap.keySet()) {
//            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));
//                }
//            }
//        }
//
//        if (startNum >= tList.size()) {
//            // 如果起始索引超出了列表的大小，返回一个空列表
//            return new ArrayList<>();
//        }
//        result.total(tList.size());
//        int end = Math.min(endNum, tList.size());
//        List<Task> pageTaskList = tList.subList(startNum, end);
//        List<String> taskDefs = pageTaskList.stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
//        Map<String, Task> keyMap = pageTaskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
//
//        // 得到目标任务对应的定义
//        List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());
//
//        // 查询任务相关信息
//        List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
//            Task task = keyMap.get(userTask.getId());
//            CustomerTaskVO vo = new CustomerTaskVO();
//            this.setRuntimeTaskInfo(task, vo, projectId);
//            return vo;
//        }).collect(Collectors.toList());
//        result.data(vos);
//        return vos;
    }

    /**

 business/src/main/java/com/ycl/task/FlowableTask.java

@@ -5,6 +5,7 @@
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.ycl.common.enums.business.ProcessLogEventTypeEnum;
import com.ycl.common.enums.business.ProjectProcessTypeEnum;
import com.ycl.common.utils.DateUtils;
import com.ycl.domain.entity.ProcessCoding;
import com.ycl.domain.entity.ProcessLog;
import com.ycl.domain.entity.ProjectInfo;
@@ -111,8 +112,10 @@
//                Long yellowTime = getTime(processCoding.getYellowTime());
//                Long overtime = getTime(processCoding.getOvertime());
                if (startTime == null) continue;
                //节点处理时间
                long durationTime = (now.getTime() - startTime.getTime()) / 1000;

                //节点处理时间，需排除节假日
                long durationTime = DateUtils.getWorkingSed(startTime, now);

                //TODO：减去流程挂起时长

                //减去节点挂起时长

 common/src/main/java/com/ycl/common/enums/business/TaskStatusEnum.java

@@ -18,6 +18,8 @@
    WAIT("wait", "容缺"),
    HANGUP("HANGUP", "挂起"),
    JUMP("JUMP", "跳过"),
    OVER_TIME("OVER_TIME", "超时未完成"),
    OVER_TIME_FINISHED("OVER_TIME_FINISHED", "超时已完成"),
    ;

    private final String value;

 common/src/main/java/com/ycl/common/utils/DateUtils.java

@@ -4,11 +4,7 @@
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.*;
import java.util.Date;
import java.util.HashSet;
import java.util.Objects;
@@ -80,6 +76,52 @@
        return workingHours;
    }

    /**
     * 获取两个时间内，除去周末周日以及法定节假日的 秒总数。
     * @param startDate
     * @param endDate
     * @return
     */
    public static long getWorkingSed(Date startDate,Date endDate){

        long workingHours = 0;
        long workingMill = 0;
        //转换日期格式
        LocalDateTime startTime = startDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
        LocalDateTime endTime = endDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
        if(startTime.isAfter(endTime)){
            throw new RuntimeException("开始时间不能晚于结束时间");
        }
        LocalDateTime varTime = startTime;
        //节假日日期(2025为列)
        Set<LocalDate> holidays = new HashSet<>();
        String[] holiday = isHoliday.split(",");
        for (String str : holiday) {
            String[] md = str.split("-");
            int month = Integer.parseInt(md[0]);
            int day = Integer.parseInt(md[1]);
            holidays.add(LocalDate.of(2025,month,day));
        }
        while (varTime.isBefore(endTime)){
            boolean isWorkDay = varTime.getDayOfWeek().getValue() < 6
                    && !holidays.contains(varTime.toLocalDate());
            long diffMill = endTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli() - varTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
            // 判断是否是工作日（非周末 + 非节假日）
            if (isWorkDay){
                if (diffMill < 3600000) {
                    // 如果两个时间不到一小时差距
                    workingMill += diffMill;
                    break;
                }
                workingHours++;
                workingMill += 3600000;
            }

            varTime = varTime.plusHours(1);
        }
        return workingMill / 1000;
    }


    /**
     * 获取当前Date型日期