上报

zxl

2025-12-24 419fab9d84e6b2fbeb6d32b7d7253a6cd195200d

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

@@ -1,30 +1,53 @@
package com.ycl.service.impl;


import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.ycl.common.annotation.DataScope;
import com.ycl.common.base.Result;
import com.ycl.common.constant.ProcessOverTimeConstants;
import com.ycl.common.core.domain.BaseEntity;
import com.ycl.common.enums.business.CodingRulerCodeTypeEnum;
import com.ycl.common.enums.business.CodingRulerStatusEnum;
import com.ycl.common.enums.business.ProjectCategoryEnum;
import com.ycl.common.enums.business.ProjectStatusEnum;
import com.ycl.common.core.domain.entity.SysDept;
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.SecurityUtils;
import com.ycl.domain.entity.ProcessCoding;
import com.ycl.domain.entity.ProcessLog;
import com.ycl.domain.entity.ProjectInfo;
import com.ycl.domain.entity.ProjectProcess;
import com.ycl.domain.form.ProjectProgressStatisticsForm;
import com.ycl.domain.vo.ProjectInfoVO;
import com.ycl.domain.vo.ProjectVO;
import com.ycl.domain.query.WaitTodoQuery;
import com.ycl.domain.vo.*;
import com.ycl.factory.FlowServiceFactory;
import com.ycl.mapper.ProcessCodingMapper;
import com.ycl.mapper.ProcessLogMapper;
import com.ycl.mapper.ProjectInfoMapper;
import com.ycl.service.IndexHomeService;
import com.ycl.service.ProjectInfoService;
import com.ycl.service.ProjectProcessService;
import com.ycl.service.common.TaskCommonService;
import com.ycl.system.mapper.SysDeptMapper;
import com.ycl.system.service.ISysDeptService;
import com.ycl.system.service.ISysRoleService;
import com.ycl.system.service.ISysUserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.bpmn.model.Process;
import org.flowable.bpmn.model.UserTask;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.identitylink.api.IdentityLink;
import org.flowable.identitylink.api.IdentityLinkInfo;
import org.flowable.task.api.Task;
import org.flowable.task.api.TaskQuery;
import org.flowable.task.api.history.HistoricTaskInstance;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.text.DecimalFormat;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

@@ -37,49 +60,44 @@
 **/
@Service
@RequiredArgsConstructor
public class IndexHomeServiceImpl implements IndexHomeService {
@Slf4j
public class IndexHomeServiceImpl extends FlowServiceFactory implements IndexHomeService {

    private final SysDeptMapper sysDeptMapper;
    private final ProjectInfoMapper projectInfoMapper;

    private final ProjectProcessService projectProcessService;

    private final ProcessLogMapper processLogMapper;

    private final ProcessCodingMapper processCodingMapper;

    private final ISysUserService sysUserService;

    private final ISysDeptService sysDeptService;

    private final ISysRoleService sysRoleService;

    private final TaskCommonService taskCommonService;


    @Override
    public Result projectCodingStatusCount() {
        //权限控制
        Long userId = SecurityUtils.getUserId();
        List<ProjectInfo> list;
        if (SecurityUtils.isAdmin(userId)){
            //查询全部
            list = new LambdaQueryChainWrapper<>(projectInfoMapper)
                    .eq(ProjectInfo::getDeleted, Boolean.FALSE)
                    .eq(ProjectInfo::getUsedStatus, 2) //审核通过
                    .list();
        }else{
            String ancestors = sysDeptMapper.selectAncestors(userId);
            String[] ancestorArr = ancestors.split(",");
            List<String> ancestorList = Arrays.stream(ancestorArr).collect(Collectors.toList());
            ancestorList.add(SecurityUtils.getDeptId() + "");
            //获得本单位以及其子单位deptId;
            list = new LambdaQueryChainWrapper<>(projectInfoMapper)
                    .eq(ProjectInfo::getDeleted, Boolean.FALSE)
                    .eq(ProjectInfo::getUsedStatus, 2) //审核通过
                    .in(ProjectInfo::getProjectOwnerUnit, ancestorList)
                    .list();
        }



        List<ProjectInfo> loginUserOwnProjectInfo = getLoginUserOwnProjectInfo();

        Map<String,Integer> map = new HashMap<>();
        map.put(ProcessOverTimeConstants.GREEN,0);
        map.put(ProcessOverTimeConstants.YELLOW,0);
        map.put(ProcessOverTimeConstants.RED,0);
        map.put("total",0);
        if (CollectionUtils.isEmpty(list)) {
        if (CollectionUtils.isEmpty(loginUserOwnProjectInfo)) {

            //返回默认值
            return Result.ok().data(map);
        }

        Map<String, List<ProjectInfo>> collect = list.stream()
        Map<String, List<ProjectInfo>> collect = loginUserOwnProjectInfo.stream()
                .filter(project -> project.getCoding() != null) // 过滤coding为null的情况
                .collect(Collectors.groupingBy(ProjectInfo::getCoding));

@@ -93,7 +111,7 @@
            map.put(ProcessOverTimeConstants.RED, collect.get(ProcessOverTimeConstants.RED).size());
        }

        map.put("total", list.size());
        map.put("total", loginUserOwnProjectInfo.size());
        return Result.ok().data(map);
    }

@@ -115,29 +133,849 @@
                finish+=1;
            }
        }
        Map<String,Integer> map = new HashMap<>();
        map.put(ProjectCategoryEnum.RESERVE.getCode(),reserve);
        map.put(ProjectCategoryEnum.PREVIOUS.getCode(),previous);
        map.put(ProjectCategoryEnum.IMPLEMENT.getCode(),implement);
        map.put(ProjectCategoryEnum.FINISH.getCode(),finish);


        Map<String,Object> map = new HashMap<>();
        Integer[] yData = new Integer[]{
                projectVOS.size(),
                reserve,
                previous,
                implement,
                finish
        };
        String[] xData = new String[]{
          "在库", "储备","前期","实施","竣工"
        };
        map.put("xData",xData);
        map.put("yData",yData);
        return Result.ok().data(map);
    }

    @Override
    public Result projectTaskStatus(ProjectProgressStatisticsForm form) {
        return null;
    public List<ProjectInfo> getLoginUserOwnProjectInfo(){
        //权限控制
        Long userId = SecurityUtils.getUserId();
        List<ProjectInfo> list;
        if (SecurityUtils.isAdmin(userId)){
            //查询全部
            list = new LambdaQueryChainWrapper<>(projectInfoMapper)
                    .eq(ProjectInfo::getDeleted, Boolean.FALSE)
                    .eq(ProjectInfo::getUsedStatus, 2)//审核通过
                    .orderBy(true, true, ProjectInfo::getId)
                    .list();
        }else{
            String ancestors = sysDeptMapper.selectAncestors(userId);
            String[] ancestorArr = ancestors.split(",");
            List<String> ancestorList = Arrays.stream(ancestorArr).collect(Collectors.toList());
            ancestorList.add(SecurityUtils.getDeptId() + "");
            //获得本单位以及其子单位deptId;
            list = new LambdaQueryChainWrapper<>(projectInfoMapper)
                    .eq(ProjectInfo::getDeleted, Boolean.FALSE)
                    .eq(ProjectInfo::getUsedStatus, 2) //审核通过
                    .in(ProjectInfo::getProjectOwnerUnit, ancestorList)
                    .orderBy(true, true, ProjectInfo::getId)
                    .list();
        }
        return list;
    }

    @Override
    @DataScope(deptAlias = "d")
    public Result projectFundingStatus( ) {
    public Result projectTaskStatus(ProjectProgressStatisticsForm form) {
        //获得是项目
        List<ProjectInfo> loginUserOwnProjectInfo = getLoginUserOwnProjectInfo();

        List<ProjectInfoVO> projectInfoAndFunding = projectInfoMapper.getProjectInfoAndFunding(new BaseEntity());

        if (CollectionUtils.isEmpty(loginUserOwnProjectInfo)) {
            return Result.ok().data(loginUserOwnProjectInfo);
        }
        Map<String, String> projectMap = loginUserOwnProjectInfo.stream()
                .collect(Collectors.toMap(
                        projectInfo -> String.valueOf(projectInfo.getId()),          // key: 项目ID
                        ProjectInfo::getProjectName,          // value: 项目对象本身
                        (existing, replacement) -> existing  // 处理重复ID的冲突策略（保留原有值）
                ));



        //获得项目ids
        List<Long> ids = loginUserOwnProjectInfo.stream().map(ProjectInfo::getId).collect(Collectors.toList());


        //更具项目ids获得所有对应流程信息 ProjectProcess  流程定义ID processDefId;流程实例id processInsId;
        List<ProjectProcess> projectProcessList = new LambdaQueryChainWrapper<>(projectProcessService.getBaseMapper())
                .eq(ProjectProcess::getDeleted, Boolean.FALSE)
                .in(ProjectProcess::getProjectId, ids).list();

        Date statisticsTime = form.getStartTime();
        if (statisticsTime == null) {
            statisticsTime = new Date(); // 如果未传入时间，默认使用当前时间
        }
        LocalDate statisticsLocalDate = statisticsTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        LocalDate firstDayOfMonth = statisticsLocalDate.with(TemporalAdjusters.firstDayOfMonth());
        LocalDate lastDayOfMonth = statisticsLocalDate.with(TemporalAdjusters.lastDayOfMonth());

        Date monthStart = Date.from(firstDayOfMonth.atStartOfDay(ZoneId.systemDefault()).toInstant());
        Date monthEnd = Date.from(lastDayOfMonth.atTime(23, 59, 59).atZone(ZoneId.systemDefault()).toInstant());

        // 存储每个流程实例的统计结果
        List<Map<String, Object>> processStatisticsList = new ArrayList<>();

        // 获得流程日志表中 任务信息 按流程实列id分组
        Map<String, List<ProcessLog>> groupMap = new LambdaQueryChainWrapper<>(processLogMapper)
                .eq(ProcessLog::getDeleted, Boolean.FALSE)
                .in(ProcessLog::getProjectId, ids).list()
                .stream().collect(Collectors.groupingBy(ProcessLog::getProcessInsId));


        for (ProjectProcess projectProcess : projectProcessList) {

            String processInstanceId = projectProcess.getProcessInsId();
            if (processInstanceId == null) {
                continue;
            }

            // 单个流程的统计结果
            Map<String, Object> processResult = new HashMap<>();
            processResult.put("id",projectProcess.getProjectId());
            processResult.put("projectName", projectMap.get(projectProcess.getProjectId()));

            int completedCount = 0;      // 已完成任务数
            int inProgressCount = 0;     // 进行中任务数
            int notStartedCount = 0;     // 未开始任务数

            try {
                // 1. 获取该流程实例的所有已完成任务
                List<HistoricTaskInstance> completedTasks = historyService.createHistoricTaskInstanceQuery()
                        .processInstanceId(processInstanceId)
                        .finished()
                        .list();
                // 去重历史信息 排除相同的任务key保留最新的任务
                completedTasks = projectProcessService.distinctHisTask(completedTasks);
                // 需要排除已完成任务中被驳回的任务数
                List<ProcessLog> taskLogs = groupMap.get(projectProcess.getProcessInsId());
                if ("144".equals(projectProcess.getProjectId())) {
                    for (ProcessLog processLog : taskLogs) {
                        System.out.println("打印信息");
                        System.out.println(processLog.toString());
                    }
                }
                if (!CollectionUtils.isEmpty(taskLogs)) {
                    //排除掉所有被驳回的任务
                    // 获取所有被驳回任务的ID列表
                    List<String> rejectedTaskIds = taskLogs.stream()
                            .filter(log -> {
                                // 判断是否为驳回类型的日志（根据你的枚举值调整）
                                return ProcessLogEventTypeEnum.REJECT.equals(log.getEventType());
                            })
                            .map(ProcessLog::getTaskId) // 假设日志中有taskId字段关联任务
                            .filter(Objects::nonNull)   // 过滤掉null的taskId
                            .collect(Collectors.toList());

                    // 排除被驳回的任务，生成新的已完成任务集合

                    // 将过滤后的集合赋值给原变量
                    completedTasks = completedTasks.stream()
                            .filter(task -> !rejectedTaskIds.contains(task.getId())) //保留不包含驳回的taskId
                            .collect(Collectors.toList());
                }


                // 本月最后一天完成的 属于已完成 after 之后 before 之前
                for (HistoricTaskInstance task : completedTasks) {
                    Date completionTime = task.getEndTime();
                    if (completionTime != null &&
                            completionTime.before(monthEnd)) {
                        completedCount++;
                    }
                }
                // 获得上一步未覆盖到查询条件的元素 完成时间是在本月之后
                List<HistoricTaskInstance> excessCompletedTasks  = completedTasks.stream().filter(
                        task -> { Date endTime = task.getEndTime();
                           return endTime != null && endTime.after(monthEnd);
                }).collect(Collectors.toList());

                // 循环完成时间是在本月之后的
                for (HistoricTaskInstance task : excessCompletedTasks) {
                    Date createTime = task.getCreateTime();
                    Date endTime = task.getEndTime();

                    // 本月创建，完成在本月之后 属于进行中
                    if (createTime != null && endTime != null) {
                        if (createTime.before(monthEnd) && createTime.after(monthStart) && endTime.after(monthEnd)) {
                            inProgressCount++;
                        }
                    }


                }
                // 2. 获取该流程实例的所有进行中任务
                List<Task> activeTasks = taskService.createTaskQuery()
                        .processInstanceId(processInstanceId)
                        .active()
                        .list();
                for (Task task : activeTasks) {
                    Date createTime = task.getCreateTime();
                    // 进行中的任务 判断创建时间是否在下个月之前 如果是本月则加1
                    if (createTime != null && createTime.before(monthEnd)) {
                        inProgressCount++;
                    }

                }




                // 5. 统计未开始任务（获取流程定义的总任务数 - 已统计的任务数）
                ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                        .processInstanceId(processInstanceId)
                        .singleResult();

                if (processInstance != null) {
                    BpmnModel bpmnModel = repositoryService.getBpmnModel(processInstance.getProcessDefinitionId());
                    Process mainProcess = bpmnModel.getMainProcess();
                    List<UserTask> userTasks = mainProcess.findFlowElementsOfType(UserTask.class);
                    int totalUserTaskCount = userTasks.size();

                    // 未开始任务数 = 总任务数 - 已完成 - 进行中
                    notStartedCount = totalUserTaskCount - completedCount - inProgressCount;

                    // 确保未开始任务数不为负数
                    if (notStartedCount < 0) {
                        notStartedCount = 0;
                    }
                }
            } catch (Exception e) {
                // 异常处理
                notStartedCount = 0;
            }

            // 设置当前流程的统计结果
            int totalTasks = completedCount + inProgressCount + notStartedCount;

            double completedPercent = totalTasks == 0 ? 0 : (completedCount * 100.0 / totalTasks);
            double inProgressPercent = totalTasks == 0 ? 0 : (inProgressCount * 100.0 / totalTasks);
            double notStartedPercent = totalTasks == 0 ? 0 : (notStartedCount * 100.0 / totalTasks);
            //四舍五入
            completedPercent = Math.round(completedPercent * 10) / 10.0;
            inProgressPercent = Math.round(inProgressPercent * 10) / 10.0;
            notStartedPercent = Math.round(notStartedPercent * 10) / 10.0;
            //保留一位
            DecimalFormat df = new DecimalFormat("#.#");

            // 格式化结果（可选：保留为字符串或转换为Double）
            String completedFormatted = df.format(completedPercent);
            String inProgressFormatted = df.format(inProgressPercent);
            String notStartedFormatted = df.format(notStartedPercent);

            processResult.put("completed", completedFormatted);
            processResult.put("co", completedCount);
            processResult.put("co2", inProgressCount);
            processResult.put("co3", notStartedCount);
            processResult.put("inProgress", inProgressFormatted);
            processResult.put("notStarted", notStartedFormatted);
            processResult.put("totalTasks",totalTasks) ;

            // 添加到结果列表
            processStatisticsList.add(processResult);
        }

        return Result.ok().data(processStatisticsList);
    }

    @Override
    public Result projectFundingStatus( ) {
        List<ProjectInvestmentFundingVO> projectInfoAndFunding = projectInfoMapper.getProjectInfoAndFunding(new BaseEntity());
        //排除空数据
        projectInfoAndFunding = projectInfoAndFunding.stream().filter(Objects::nonNull).collect(Collectors.toList());

        return Result.ok().data(projectInfoAndFunding);
    }
    @Override
    public int countWaitTask() {
        Long userId = SecurityUtils.getUserId();
        List<ProjectInfo> loginUserOwnProjectInfo = getLoginUserOwnProjectInfo();
        if (CollectionUtils.isEmpty(loginUserOwnProjectInfo)) {
            return 0;
        }
        List<Long> ids = loginUserOwnProjectInfo.stream()
                .filter(Objects::nonNull)
                .map(ProjectInfo::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(ids)) {
            return 0;
        }
        List<ProjectProcess> projectProcessList = new LambdaQueryChainWrapper<>(projectProcessService.getBaseMapper())
                .eq(ProjectProcess::getDeleted, Boolean.FALSE)
                .in(ProjectProcess::getProjectId, ids)
                .list();
        if (CollectionUtils.isEmpty(projectProcessList)) {
            return 0;
        }
        List<String> targetProcessInsIds = projectProcessList.stream()
                .filter(Objects::nonNull) // 过滤null的ProjectProcess对象
                .map(ProjectProcess::getProcessInsId)
                .filter(defId -> defId != null && !defId.trim().isEmpty()) // 先判null再trim，修复风险3
                .distinct()
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(targetProcessInsIds)) {
            return 0;
        }

        List<Task> allRunningTasks = taskService.createTaskQuery().active().list();
        if (CollectionUtils.isEmpty(allRunningTasks)) {
            return 0;
        }
        List<Task> targetRunningTasks = allRunningTasks.stream()
                .filter(Objects::nonNull)
                .filter(task -> {
                    // 先判null，再匹配，修复风险1
                    String processInsId = task.getProcessInstanceId();
                    return processInsId != null && targetProcessInsIds.contains(processInsId);
                })
                .filter(task -> {
                    String assignee = task.getAssignee();
                    return assignee == null || userId.toString().equals(assignee);//排除领取人
                })
                .collect(Collectors.toList());


        return targetRunningTasks.size();
    }

    @Override
    public Result projectAdvanceCheckPoint() {
        return null;
        List<ProjectInfo> loginUserOwnProjectInfo = getLoginUserOwnProjectInfo();
        if (CollectionUtils.isEmpty(loginUserOwnProjectInfo)) {
            return Result.ok().data(loginUserOwnProjectInfo);
        }
        //获得项目ids
        List<Long> ids = loginUserOwnProjectInfo.stream().map(ProjectInfo::getId).collect(Collectors.toList());
        List<ProjectProcess> projectProcessList = new LambdaQueryChainWrapper<>(projectProcessService.getBaseMapper())
                .eq(ProjectProcess::getDeleted, Boolean.FALSE)
                .in(ProjectProcess::getProjectId, ids).list();
        Long userId = SecurityUtils.getUserId();
        //流程实例id集合
        List<String> targetProcessInsIds = projectProcessList.stream()
                .map(ProjectProcess::getProcessInsId)
                .distinct()
                .filter(defId -> defId != null && !defId.trim().isEmpty())
                .collect(Collectors.toList());
        //组装项目流程信息 项目id为key
        Map<String,CheckPointVO> map = new HashMap<>();
        for (ProjectInfo projectInfo : loginUserOwnProjectInfo){
            CheckPointVO checkPointVO = new CheckPointVO();
            checkPointVO.setId(projectInfo.getId());
            checkPointVO.setProjectName(projectInfo.getProjectName());
            map.put(String.valueOf(projectInfo.getId()),checkPointVO);
        }
        //组装流程信息
        for (ProjectProcess projectProcess : projectProcessList) {

            CheckPointVO checkPointVO = map.get(projectProcess.getProjectId());
            checkPointVO.setProcessDefinitionId(projectProcess.getProcessDefId());
            checkPointVO.setProcessInstanceId(projectProcess.getProcessInsId());

            //获得流程部署id
            ProcessInstance process = runtimeService.createProcessInstanceQuery()
                    .processInstanceId(projectProcess.getProcessInsId()).singleResult();
            if (Objects.nonNull(process)) {
                checkPointVO.setDeployId(process.getDeploymentId()); // 运行中流程直接取部署ID
                checkPointVO.setProcessName(process.getProcessDefinitionName());
            } else {
                // 2. 运行中流程不存在（已结束），查历史流程实例
                HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery()
                        .processInstanceId(projectProcess.getProcessInsId()).singleResult();
                // 历史流程取部署ID
                checkPointVO.setDeployId(hisProcess.getDeploymentId());
                checkPointVO.setProcessName(hisProcess.getProcessDefinitionName());
            }
            map.put(projectProcess.getProjectId(),checkPointVO);
        }
        // 转换为list后按 流程实例id分组
        List<CheckPointVO> checkPointList = map.values().stream()
                .collect(Collectors.toList());
        // 获得组装好的 流程map 键为流程实例id，
        Map<String, CheckPointVO> processInfoMap = checkPointList.stream()
                .filter(Objects::nonNull) // 避免null元素导致异常（可选，按需保留）
                .filter(vo -> vo.getProcessInstanceId() != null) // 过滤流程定义ID为null的无效数据
                .collect(Collectors.toMap(
                        CheckPointVO::getProcessInstanceId, // key：流程定义ID（替换为你的实际方法名）
                        vo -> vo, // value：原始CheckPointVO对象
                        (oldVal, newVal) -> newVal // 冲突策略：存在重复ID时保留后者（按需调整）
                ));


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

        List<Task> targetRunningTasks = allRunningTasks.stream()
                // 关键匹配：任务的流程定义ID 存在于 projectProcessList 的流程定义ID列表中
                .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)){

            //查询到所有
            List<String> taskIds = targetRunningTasks.stream().map(Task::getId).collect(Collectors.toList());
            // 任务运行时不在 list中，可能任务没有设置超时时间
            List<ProcessCoding> processCodingList = new LambdaQueryChainWrapper<>(processCodingMapper)
                    .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方面下面获取
            if (!CollectionUtils.isEmpty(processCodingList)){
                processCodingMap = processCodingList.stream()
                        .filter(Objects::nonNull) // 避免null元素导致NPE（可选保留）
                        .filter(vo -> vo.getTaskId() != null) // 过滤taskId为null的无效数据
                        .collect(Collectors.toMap(
                                ProcessCoding::getTaskId, // key：仍为taskId
                                vo -> vo, // value：原始ProcessCoding对象
                                // 冲突策略：比较创建时间，保留更新的那个
                                (oldVal, newVal) -> {
                                    // 获取两者创建时间（根据实际方法名调整，如getGmtCreate()
                                    Date oldCreateTime = oldVal.getGmtCreate();
                                    Date newCreateTime = newVal.getGmtCreate();

                                    // 处理创建时间为null的情况（优先级：有时间>无时间，都无则保留后者）
                                    if (oldCreateTime == null) return newVal;
                                    if (newCreateTime == null) return oldVal;

                                    // 比较时间戳，返回更大的（更新的）对象
                                    return newCreateTime.getTime() > oldCreateTime.getTime() ? newVal : oldVal;
                                }
                        ));
            }
            for (Task task : targetRunningTasks) {

                TaskInfoVo taskVo = new TaskInfoVo();

                taskVo.setId(task.getId());
                taskVo.setTaskName(task.getName());
                taskVo.setStartTime(task.getCreateTime());
                taskVo.setEndTime(task.getDueDate());
//                    taskVo.setTaskType();

                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);
                CustomerTaskVO customerTaskVO = new CustomerTaskVO();
                customerTaskVO.setHandlerId(handlerIds);
                customerTaskVO.setHandlerName(handlerNames);
                customerTaskVO.setHandlerUnitId(handlerUnitIds);
                customerTaskVO.setHandlerUnitName(handlerUnitNames);
                customerTaskVO.setPromoterName(promoterNames);
                customerTaskVO.setPromoterUnitName(promoterUnitNames);

                // 流程处理人信息
                List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(task.getId());
                for (IdentityLinkInfo identityLink : identityLinksForTask) {
                    // 绑定的是用户，查出用户姓名、部门
                    if (StringUtils.isNotBlank(identityLink.getUserId())) {
                        // 处理变量表达式，运行中的任务无需再处理表达式了，flowable已经自动根据变量设置了
                        customerTaskVO.setHandlerType(HandlerTypeEnum.USER);
                        SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
                        if (Objects.nonNull(sysUser)) {
                            customerTaskVO.getHandlerId().add(sysUser.getUserId());
                            customerTaskVO.getHandlerName().add(this.getUserShowName(sysUser));
                            if (Objects.nonNull(sysUser.getDept())) {
                                customerTaskVO.getHandlerUnitId().add(sysUser.getDept().getDeptId());
                                customerTaskVO.getHandlerUnitName().add(sysUser.getDept().getDeptName());
                                customerTaskVO.getPromoterName().add(this.getUserShowName(sysUser));
                                String[] str = sysUser.getDept().getAncestors().split(",");
                                if (str.length >= 4){
                                    customerTaskVO.getPromoterUnitName().add(sysUser.getDept().getParentName() +"-"+sysUser.getDept().getDeptName());
                                }else {
                                    customerTaskVO.getPromoterUnitName().add(sysUser.getDept().getDeptName());
                                }

                            }
                        }
                        // 绑定的是角色或者部门
                    } else if (StringUtils.isNotBlank(identityLink.getGroupId())) {
                        if (identityLink.getGroupId().startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                            customerTaskVO.setHandlerType(HandlerTypeEnum.DEPT);
                            String[] split = identityLink.getGroupId().split(":");
                            if (split.length > 1) {
                                // 部门
                                SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
                                if (Objects.nonNull(dept)) {
                                    customerTaskVO.getHandlerUnitId().add(dept.getDeptId());
                                    customerTaskVO.getHandlerUnitName().add(dept.getDeptName());
                                    customerTaskVO.getPromoterName().add(this.getDeptLeaderShowName(dept));
                                    customerTaskVO.getPromoterUnitName().add(this.setDeptNameWithParentName(dept));
                                }
                            }
                        } else {
                            customerTaskVO.setHandlerType(HandlerTypeEnum.ROLE);
                            SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
                            if (Objects.nonNull(role)) {
                                customerTaskVO.getHandlerUnitId().add(Long.parseLong(identityLink.getGroupId()));
                                customerTaskVO.getHandlerUnitName().add(role.getRoleName());
                            }
                        }
                    }
                    this.distinctVo(customerTaskVO);
                }
                taskVo.setCustomerTaskInfo(customerTaskVO);

                //组装任务信息
                CheckPointVO checkPointVO = processInfoMap.get(task.getProcessInstanceId());
                if (checkPointVO != null) {
                    taskVo.setCheckPointInfo(checkPointVO);
                }
                //超时时间和次数在 processCodingList中  这里需要更具taskId来获得对应信息
                ProcessCoding processCoding = processCodingMap.get(task.getId());
                //设置超时信息
                if (processCoding != null) {

                    String overTimeTotalStr = processCoding.getOverTimeTotal();
                    long overTimeTotal = 0L;
                    if (StringUtils.isNotBlank(overTimeTotalStr)) {
                        try {
                            overTimeTotal = Long.parseLong(overTimeTotalStr.trim());
                        } catch (NumberFormatException e) {

                        }
                    }
                    String overTimeDesc = convertHoursToDayHourStr(overTimeTotal);
                    taskVo.setTotalOverTime(overTimeDesc);

                    // 2. 提取红码阈值 如： 0-22 天-小时 并转换为小时
                    String redTimeStr = processCoding.getRedTime();
                    Long redTimeSec = getTime(redTimeStr);
                    Double redTimeHour = null;
                    if (redTimeSec != null && redTimeSec > 0) {
                        redTimeHour = redTimeSec / 3600.0;
                    }
                    long overTimeCount = 0L;
                    // 判断超时次数
                    if (overTimeTotal > 0 && redTimeHour != null && redTimeHour > 0) {
                        overTimeCount = (long) (overTimeTotal / redTimeHour);
                    }


                    taskVo.setOverTimeCount(overTimeCount);
                }else {
                    //为null 说明未配置超时时间 默认未超时
                    taskVo.setOverTimeCount(0L);
                    taskVo.setTotalOverTime("0小时");
                }
                list.add(taskVo);
            }


        }

        return Result.ok().data(list);
    }

    public HashMap<String,Object> buildEmptyResultMap(){
        HashMap<String,Object> map = new HashMap<>();
        map.put("data", new ArrayList<>());
        map.put("total", 0L);
        return map;
    }
    @Override
    public Result getWaitTaskList(WaitTodoQuery baseQuery) {
        int pageNum = (int) baseQuery.getCurrentPage();
        int pageSize = (int) baseQuery.getPageSize();
        Long userId = SecurityUtils.getUserId(); // 当前用户ID
        boolean isAdmin = SecurityUtils.getLoginUser().getUser().isAdmin(); // 是否管理员
        List<String> userGroups = taskCommonService.getCurrentUserGroups(); // 当前用户所属组
        List<ProjectInfo> targetProjectList = new ArrayList<>();
        String queryProjectId = baseQuery.getProjectId();

        if ("all".equals(queryProjectId) || StringUtils.isBlank(queryProjectId)){
            // 查询全部
            targetProjectList = getLoginUserOwnProjectInfo();
        }else{
            try {
                Long projectId = Long.parseLong(queryProjectId);
                // ① 查询该项目基础信息（替换为实际查询方法）
                ProjectInfo projectInfo = projectInfoMapper.selectById(projectId);
                if (projectInfo == null) {
                    // 项目不存在，返回空数据
                    return Result.ok().data(buildEmptyResultMap());
                }
                targetProjectList.add(projectInfo);
            } catch (NumberFormatException e) {
                // 项目ID格式错误，返回空数据
                return Result.ok().data(buildEmptyResultMap());
            }
        }

        List<Long> projectIds = targetProjectList.stream().map(ProjectInfo::getId).collect(Collectors.toList());

        List<ProjectProcess> projectProcessList = new LambdaQueryChainWrapper<>(projectProcessService.getBaseMapper())
                .eq(ProjectProcess::getDeleted, Boolean.FALSE)
                .in(ProjectProcess::getProjectId, projectIds).list();
        // 4. 提取有效的流程实例ID（去重+非空过滤）
        List<String> targetProcessInsIds = projectProcessList.stream()
                .map(ProjectProcess::getProcessInsId)
                .distinct()
                .filter(defId -> defId != null && !defId.trim().isEmpty())
                .collect(Collectors.toList());

        if (CollectionUtils.isEmpty(targetProcessInsIds)) {
            return Result.ok().data(new HashMap<String, Object>() {{
                put("data", new ArrayList<>());
                put("total", 0L);
            }});
        }

        // 5. 构建processInfoMap（核心：项目ID→CheckPointVO，再关联流程信息）
        Map<String, CheckPointVO> map = new HashMap<>();
        // 先填充项目基础信息
        for (ProjectInfo projectInfo : targetProjectList) {
            CheckPointVO checkPointVO = new CheckPointVO();
            checkPointVO.setId(projectInfo.getId());
            checkPointVO.setProjectName(projectInfo.getProjectName());
            map.put(String.valueOf(projectInfo.getId()), checkPointVO);
        }
        // 再填充流程信息（部署ID、流程名称等）
        for (ProjectProcess projectProcess : projectProcessList) {
            CheckPointVO checkPointVO = map.get(projectProcess.getProjectId().toString()); // 修复：projectId是Long，需转字符串
            if (checkPointVO == null) {
                continue; // 无匹配项目，跳过
            }
            checkPointVO.setProcessDefinitionId(projectProcess.getProcessDefId());
            checkPointVO.setProcessInstanceId(projectProcess.getProcessInsId());

            // 获得流程部署id和流程名称（兼容运行中/已结束流程）
            ProcessInstance process = runtimeService.createProcessInstanceQuery()
                    .processInstanceId(projectProcess.getProcessInsId()).singleResult();
            if (Objects.nonNull(process)) {
                checkPointVO.setDeployId(process.getDeploymentId());
                checkPointVO.setProcessName(process.getProcessDefinitionName());
            } else {
                HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery()
                        .processInstanceId(projectProcess.getProcessInsId()).singleResult();
                if (Objects.nonNull(hisProcess)) { // 避免历史流程为null的NPE
                    checkPointVO.setDeployId(hisProcess.getDeploymentId());
                    checkPointVO.setProcessName(hisProcess.getProcessDefinitionName());
                }
            }
            map.put(projectProcess.getProjectId().toString(), checkPointVO); // 修复：projectId转字符串
        }
        Map<String, CheckPointVO> processInfoMap = map.values().stream()
                .filter(Objects::nonNull)
                .filter(vo -> vo.getProcessInstanceId() != null)
                .collect(Collectors.toMap(
                        CheckPointVO::getProcessInstanceId,
                        vo -> vo,
                        (oldVal, newVal) -> newVal // 重复流程实例ID保留后者
                ));

        TaskQuery query = getTaskService().createTaskQuery()
                .active() // 未完成、未挂起的活跃任务
                .processInstanceIdIn(targetProcessInsIds); // 仅查项目关联的流程实例任务

        // 权限过滤：非管理员仅查自己有权限的任务（已领取+候选）
        if (!isAdmin) {
            query.or()
                    .taskAssignee(userId+"") // 自己已领取的任务
                    .taskCandidateUser(userId+"") // 自己是候选用户的任务
                    .taskCandidateGroupIn(userGroups) // 自己在候选组的任务
                    .endOr();
        }

        query.orderByTaskCreateTime().desc();
        List<Task> allTaskList = query.list();
        // 排除领取人问题
        allTaskList = allTaskList.stream()
                .filter(Objects::nonNull) // 空任务防护
                .filter(task -> {
                    String assignee = task.getAssignee();
                    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);
            }
        }

        // ========== 修复点1：提前查询任务状态，过滤已完成任务（分页前执行） ==========
        // 查询任务状态
        final HashMap<String, ProcessLog> taskInfoMap = new HashMap<>();

        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, allTaskIds)
                    .list();

            // 3. 填充数据到taskInfoMap，引用未改变
            Map<String, ProcessLog> tempMap = processLogs.stream()
                    .filter(processLog -> processLog.getTaskId() != null && processLog.getGmtCreate() != null)
                    .collect(Collectors.toMap(
                            ProcessLog::getTaskId,
                            processLog -> processLog,
                            (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());
            taskVo.setTaskName(task.getName());
            taskVo.setStartTime(task.getCreateTime());
            taskVo.setEndTime(task.getDueDate());
            // 填充任务状态字段
            taskVo.setTaskType("待完成");
            ProcessLog processLog = taskInfoMap.get(task.getId());
            if (Objects.nonNull(processLog)) {
                taskVo.setTaskType(processLog.getEventType().getDesc());
            }

            CheckPointVO checkPointVO = processInfoMap.get(task.getProcessInstanceId());
            if (checkPointVO != null) {
                taskVo.setCheckPointInfo(checkPointVO);
            }

            taskInfoVoList.add(taskVo);
        }
        return Result.ok().data(taskInfoVoList).total(validTotal);
    }



    private String convertHoursToDayHourStr(long totalHours) {
        if (totalHours < 0) {
            return "0小时"; // 防御性处理负数场景
        }
        long days = totalHours / 24; // 计算天数
        long hours = totalHours % 24; // 计算剩余小时数

        StringBuilder sb = new StringBuilder();
        if (days > 0) {
            sb.append(days).append("天");
        }
        // 小时数无论是否为0，都展示（也可根据业务调整：如0小时时不展示）
        if (hours > 0 || days == 0) {
            sb.append(hours).append("小时");
        }
        return sb.toString();
    }
    // 对部门负责人集合信息进行去重
    private void distinctVo(CustomerTaskVO vo) {
        vo.setHandlerId(vo.getHandlerId().stream().distinct().collect(Collectors.toList()));
        vo.setHandlerName(vo.getHandlerName().stream().distinct().collect(Collectors.toList()));
        vo.setHandlerUnitId(vo.getHandlerUnitId().stream().distinct().collect(Collectors.toList()));
        vo.setHandlerUnitName(vo.getHandlerUnitName().stream().distinct().collect(Collectors.toList()));
    }
    //拼接用户昵称以及电话
    private String getUserShowName(SysUser user) {
        return user.getNickName() + (StringUtils.isNotBlank(user.getPhonenumber()) ? "(" + user.getPhonenumber() + ")" : "");
    }
    //拼接部门负责人以及电话
    private String getDeptLeaderShowName(SysDept dept) {
        return dept.getLeader() + (StringUtils.isNotBlank(dept.getPhone()) ? "(" + dept.getPhone() + ")" : "");
    }
    //拼接上级部门以及本部门名称
    private String setDeptNameWithParentName(SysDept dept) {
        String[] str = dept.getAncestors().split(",");
        if (str.length >= 4){
            return dept.getParentName() + "  /  " + dept.getDeptName();
        }else {
            return dept.getDeptName();
        }
    }
    private Long getTime(String timeStr) {
        Long time = null;
        if (StringUtils.isNotBlank(timeStr)) {
            String[] timeArr = timeStr.split("-");
            // 解析天数和小时数
            int days = Integer.parseInt(timeArr[0]);
            int hours = 0;
            if (timeArr.length > 1) {
                hours = Integer.parseInt(timeArr[1]);
            }
            time = (days * 24L + hours) * 3600L;
//            //分-秒
//            time= (days * 60L) + hours;
        }
        return time;
    }

    @Override
    public Result getProjectList(){
        List<ProjectInfo> loginUserOwnProjectInfo = getLoginUserOwnProjectInfo();
        return Result.ok().data(loginUserOwnProjectInfo);
    }

    @Override
    public Result getProjectSelectList() {
        List<ProjectInfo> loginUserOwnProjectInfo = getLoginUserOwnProjectInfo();
        if (CollectionUtils.isEmpty(loginUserOwnProjectInfo)) {
            return Result.ok().data(loginUserOwnProjectInfo);
        }

        Map<String, String> projectMap = loginUserOwnProjectInfo.stream()
                .collect(Collectors.toMap(
                        projectInfo -> String.valueOf(projectInfo.getId()),          // key: 项目ID
                        ProjectInfo::getProjectName,          // value: 项目对象本身
                        (existing, replacement) -> existing,  // 处理重复ID的冲突策略（保留原有值）
                        LinkedHashMap::new
                ));
        return Result.ok().data(projectMap);
    }


}