修改超时时间显示

zxl

10 小时以前 5f14844e81dade9e55725642f42c76568c5ec908

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

@@ -507,17 +507,11 @@


        List<Task> allRunningTasks  = taskService.createTaskQuery().active().list();

        //这里 获得 当前用户 所属的 流程实例ids集合中 对应的正在运行的任务。
        List<Task> targetRunningTasks = allRunningTasks.stream()
                // 关键匹配：任务的流程定义ID 存在于 projectProcessList 的流程定义ID列表中
                // 关键匹配：任务的流程实例ID 存在于 targetProcessInsIds 列表中
                .filter(task -> targetProcessInsIds.contains(task.getProcessInstanceId()))
                .filter(task -> {
                    String assignee = task.getAssignee();
                    log.info("assignee:{}",assignee);
                    return assignee == null || userId.toString().equals(assignee);
                })
                .collect(Collectors.toList());

        List<TaskInfoVo> list = new ArrayList<>();
        // 按流程实例id分组
        if (!CollectionUtils.isEmpty(targetRunningTasks)){
@@ -529,6 +523,7 @@
                    .eq(ProcessCoding::getDeleted, Boolean.FALSE)
                    .in(ProcessCoding::getTaskId, taskIds)
                    .list();

            log.info("processCodingList.size():{}", processCodingList.size()); // 看日志是否为0
            Map<String, ProcessCoding> processCodingMap = new HashMap<>();
            //按taskId转换为map方面下面获取
@@ -554,6 +549,25 @@
                                }
                        ));
            }

            //为targetRunningTasks进行一次排序 按存在超时时间 由搞到低排序
            Map<String, ProcessCoding> finalProcessCodingMap = processCodingMap;
            targetRunningTasks.sort((t1, t2) -> {
                ProcessCoding pc1 = finalProcessCodingMap.get(t1.getId());
                ProcessCoding pc2 = finalProcessCodingMap.get(t2.getId());

                String status1 = (pc1 != null && pc1.getOvertimeStatus() != null) ? pc1.getOvertimeStatus() : ProcessOverTimeConstants.NORMAL;
                String status2 = (pc2 != null && pc2.getOvertimeStatus() != null) ? pc2.getOvertimeStatus() : ProcessOverTimeConstants.NORMAL;

                // 定义权重：overtime=3, willOvertime=2, normal=1
                int weight1 = ProcessOverTimeConstants.OVERTIME.equals(status1) ? 3 :
                        (ProcessOverTimeConstants.WILLOVERTIME.equals(status1) ? 2 : 1);
                int weight2 = ProcessOverTimeConstants.OVERTIME.equals(status2) ? 3 :
                        (ProcessOverTimeConstants.WILLOVERTIME.equals(status2) ? 2 : 1);

                return Integer.compare(weight2, weight1); // 由高到低排序
            });

            for (Task task : targetRunningTasks) {

                TaskInfoVo taskVo = new TaskInfoVo();
@@ -637,16 +651,33 @@
                }
                //超时时间和次数在 processCodingList中  这里需要更具taskId来获得对应信息
                ProcessCoding processCoding = processCodingMap.get(task.getId());

                //设置超时信息
                if (processCoding != null) {

                    log.error("当前处理processCoding的id:{}",processCoding.getId());
                    String overTimeTotalStr = processCoding.getOverTimeTotal();
                    long overTimeTotal = 0L;
                    log.error("当前处理超时时间：{}",overTimeTotalStr);
                    if (StringUtils.isNotBlank(overTimeTotalStr)) {
                        try {
                            overTimeTotal = Long.parseLong(overTimeTotalStr.trim());
                        } catch (NumberFormatException e) {

                        try {
                            // 第一步：先去除字符串两端空白
                            String trimStr = overTimeTotalStr.trim();
                            // 第二步：先转成Double处理小数，再转Long（可选择四舍五入或直接取整）
                            double doubleValue = Double.parseDouble(trimStr);
                            // 方式1：直接取整数部分（4778.3 → 4778）
                            overTimeTotal = (long) doubleValue;
                            // 方式2：四舍五入（4778.3 → 4778，4778.6 → 4779）
                            // overTimeTotal = Math.round(doubleValue);

                            log.error("打印超时总时长不为null的id:{}，对应值{}（原始值：{}）",
                                    processCoding.getId(), overTimeTotal, trimStr);
                        } catch (NumberFormatException e) {
                            // 关键：打印异常详情和原始值，方便排查
                            log.error("转换超时时间失败！id:{}，原始值：{}",
                                    processCoding.getId(), overTimeTotalStr, e);
                            // 可选：给默认值，避免后续使用overTimeTotal时出现空指针
                            overTimeTotal = 0L; // 或根据业务设置默认值，比如60000L（1分钟）
                        }
                    }
                    String overTimeDesc = convertHoursToDayHourStr(overTimeTotal);
@@ -674,8 +705,6 @@
                }
                list.add(taskVo);
            }


        }

        return Result.ok().data(list);
@@ -695,8 +724,7 @@
        boolean isAdmin = SecurityUtils.getLoginUser().getUser().isAdmin(); // 是否管理员
        List<String> userGroups = taskCommonService.getCurrentUserGroups(); // 当前用户所属组
        List<ProjectInfo> targetProjectList = new ArrayList<>();
        String queryProjectId = baseQuery.getId();

        String queryProjectId = baseQuery.getProjectId();

        if ("all".equals(queryProjectId) || StringUtils.isBlank(queryProjectId)){
            // 查询全部
@@ -710,7 +738,6 @@
                    // 项目不存在，返回空数据
                    return Result.ok().data(buildEmptyResultMap());
                }
                //
                targetProjectList.add(projectInfo);
            } catch (NumberFormatException e) {
                // 项目ID格式错误，返回空数据
@@ -748,7 +775,7 @@
        }
        // 再填充流程信息（部署ID、流程名称等）
        for (ProjectProcess projectProcess : projectProcessList) {
            CheckPointVO checkPointVO = map.get(projectProcess.getProjectId());
            CheckPointVO checkPointVO = map.get(projectProcess.getProjectId().toString()); // 修复：projectId是Long，需转字符串
            if (checkPointVO == null) {
                continue; // 无匹配项目，跳过
            }
@@ -769,7 +796,7 @@
                    checkPointVO.setProcessName(hisProcess.getProcessDefinitionName());
                }
            }
            map.put(projectProcess.getProjectId(), checkPointVO);
            map.put(projectProcess.getProjectId().toString(), checkPointVO); // 修复：projectId转字符串
        }
        Map<String, CheckPointVO> processInfoMap = map.values().stream()
                .filter(Objects::nonNull)
@@ -803,53 +830,76 @@
                    return assignee == null || userId.toString().equals(assignee);
                })
                .collect(Collectors.toList());
        // 任务去重
        Set<String> taskIdSet = new HashSet<>();
        List<Task> distinctAllTaskList = new ArrayList<>();
        for (Task task : allTaskList) {
            if (!taskIdSet.contains(task.getId())) {
                taskIdSet.add(task.getId());
                distinctAllTaskList.add(task);
                //
            }
        }

        long distinctTotal = distinctAllTaskList.size();
        System.out.println("去重后总数：" + distinctTotal);
        // ========== 修复点1：提前查询任务状态，过滤已完成任务（分页前执行） ==========
        // 查询任务状态
        final HashMap<String, ProcessLog> taskInfoMap = new HashMap<>();


        int startIndex = (pageNum - 1) * pageSize;
        List<Task> pageTaskList = new ArrayList<>();
        if (startIndex < distinctAllTaskList.size()) {
            int endIndex = Math.min(startIndex + pageSize, distinctAllTaskList.size());
            pageTaskList = distinctAllTaskList.subList(startIndex, endIndex);
        }


        List<TaskInfoVo> taskInfoVoList = new ArrayList<>();
        //查询任务状态
        List<String> taskIds = pageTaskList.stream().map(Task::getId).collect(Collectors.toList());
        HashMap<String,ProcessLog> taskInfoMap = new HashMap<>();
        if (!CollectionUtils.isEmpty(taskIds)) {
            taskInfoMap = new LambdaQueryChainWrapper<>(processLogMapper)
        List<String> allTaskIds = distinctAllTaskList.stream().map(Task::getId).collect(Collectors.toList());
        if (!CollectionUtils.isEmpty(allTaskIds)) {
            // 2. 不再重新赋值，而是先查询出结果，再放入已初始化的map中
            List<ProcessLog> processLogs = new LambdaQueryChainWrapper<>(processLogMapper)
                    .eq(ProcessLog::getDeleted, Boolean.FALSE)
                    .in(ProcessLog::getTaskId, taskIds).list()
                    .stream()
                    .in(ProcessLog::getTaskId, allTaskIds)
                    .list();

            // 3. 填充数据到taskInfoMap，引用未改变
            Map<String, ProcessLog> tempMap = processLogs.stream()
                    .filter(processLog -> processLog.getTaskId() != null && processLog.getGmtCreate() != null)
                    .collect(Collectors.toMap(
                            // Key：taskId转字符串
                            ProcessLog::getTaskId,
                            // Value：ProcessLog对象本身
                            processLog -> processLog,
                            // 冲突策略：保留gmtCreate更新的那条记录
                            (existing, replacement) -> {
                                return replacement.getGmtCreate().after(existing.getGmtCreate())
                                        ? replacement : existing;
                            },
                            (existing, replacement) -> replacement.getGmtCreate().after(existing.getGmtCreate()) ? replacement : existing,
                            HashMap::new
                    ));
            taskInfoMap.putAll(tempMap);
        }

        // 过滤已完成任务，得到有效任务列表（分页的依据）
        List<Task> validTaskList = distinctAllTaskList.stream()
                .filter(task -> {
                    ProcessLog processLog = taskInfoMap.get(task.getId());
                    // 未查询到日志 → 待完成；日志状态不是FINISHED → 有效
                    return processLog == null || !ProcessLogEventTypeEnum.FINISHED.getDesc().equals(processLog.getEventType().getDesc());
                })
                .collect(Collectors.toList());

        // 有效数据总条数
        long validTotal = validTaskList.size();
        System.out.println("有效任务总数（排除已完成）：" + validTotal);

        // ========== 修复点2：分页合法性校验 ==========
        // 计算最大有效页码
        int maxPageNum = (int) (validTotal % pageSize == 0 ? validTotal / pageSize : (validTotal / pageSize) + 1);
        // 若总条数为0，直接返回空数据
        if (validTotal == 0) {
            return Result.ok().data(new HashMap<String, Object>() {{
                put("data", new ArrayList<>());
                put("total", 0L);
            }});
        }
        // 若请求页码超过最大页码，默认返回最后一页
        if (pageNum > maxPageNum) {
            pageNum = maxPageNum;
        }

        // ========== 修复点3：优化内存分页 ==========
        int startIndex = (pageNum - 1) * pageSize;
        int endIndex = Math.min(startIndex + pageSize, validTaskList.size());
        // 转为新列表，避免subList视图的风险
        List<Task> pageTaskList = new ArrayList<>(validTaskList.subList(startIndex, endIndex));

        // 组装返回VO
        List<TaskInfoVo> taskInfoVoList = new ArrayList<>();
        for (Task task : pageTaskList) {
            TaskInfoVo taskVo = new TaskInfoVo();
            taskVo.setId(task.getId());
@@ -870,17 +920,7 @@

            taskInfoVoList.add(taskVo);
        }
        //排除 已完成的
        taskInfoVoList = taskInfoVoList.stream().filter(taskInfoVo -> {
            if (ProcessLogEventTypeEnum.FINISHED.getDesc().equals(taskInfoVo.getTaskType())){
                return false;
            }
            return true;
        }).collect(Collectors.toList());
        HashMap<String, Object> resultMap = new HashMap<>();
        resultMap.put("data", taskInfoVoList);
        resultMap.put("total", distinctTotal);
        return Result.ok().data(resultMap);
        return Result.ok().data(taskInfoVoList).total(validTotal);
    }