feat:同步状态优化

wlzboy

2026-04-01 b9e9cde65890851f4ca2d7b4809b802b88937ddf

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/TaskStatusSyncServiceImpl.java

@@ -1,14 +1,14 @@
package com.ruoyi.system.service.impl;

import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.LongUtil;
import com.ruoyi.system.domain.DispatchOrd;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.domain.enums.TaskStatus;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.service.IDispatchOrdService;
import com.ruoyi.system.service.ISysTaskEmergencyService;
import com.ruoyi.system.service.ITaskStatusSyncService;
import com.ruoyi.system.service.*;
import com.ruoyi.system.utils.TaskStatusConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -35,6 +35,9 @@
    
    @Autowired
    private SysTaskMapper sysTaskMapper;

    @Autowired
    private ISysTaskService taskService;
    
    @Autowired
    private ISysTaskEmergencyService sysTaskEmergencyService;
@@ -49,7 +52,6 @@
     * @return 是否同步成功
     */
    @Override
    @Transactional
    public boolean syncTaskStatusFromLegacy(Long taskId) {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过状态同步，任务ID: {}", taskId);
@@ -98,7 +100,9 @@
            return false;
        }
    }
    

    @Autowired
    private IServiceOrderService serviceOrderService;
    /**
     * 批量同步已同步调度单的任务状态（从旧系统到新系统）
     * 使用分页查询，批量查询SQL Server数据库，减少网络请求次数
@@ -108,13 +112,13 @@
    @Override
    public int batchSyncTaskStatusFromLegacy() {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用");
//            log.info("旧系统同步已禁用");
            return 0;
        }
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 200; // 每页200条
            int pageSize = 10; // 每页10条
            int offset = 0;
            
            while (true) {
@@ -122,87 +126,76 @@
                List<SysTaskEmergency> syncedTasks = sysTaskEmergencyService.selectSyncedTasksForStatusUpdate(offset, pageSize);
                
                if (syncedTasks == null || syncedTasks.isEmpty()) {
                    log.info("没有更多需要同步状态的任务，offset: {}", offset);
//                    log.info("没有更多需要同步状态的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                log.info("开始同步状态第 {} 页，任务数量: {}", (offset / pageSize) + 1, syncedTasks.size());
//                log.info("开始同步状态第 {} 页，任务数量: {}", (offset / pageSize) + 1, syncedTasks.size());
                
                // 2. 提取调度单ID列表
                List<Long> dispatchOrdIDs = new ArrayList<>();

                Map<Long, SysTaskEmergency> dispatchIdToTaskMap = new HashMap<>();
                


                for (SysTaskEmergency emergency : syncedTasks) {
                    Long dispatchOrdId = emergency.getLegacyDispatchOrdId();
                    if (dispatchOrdId != null && dispatchOrdId > 0) {
                        dispatchOrdIDs.add(dispatchOrdId);
                        dispatchIdToTaskMap.put(dispatchOrdId, emergency);
                    if (LongUtil.isNotEmpty(emergency.getTaskId())) {

                        if(!dispatchIdToTaskMap.containsKey(dispatchOrdId)) {
                            dispatchIdToTaskMap.put(emergency.getTaskId(), emergency);
                        }
                    }
                    Long serviceOrdId = emergency.getLegacyServiceOrdId();
                    if(LongUtil.isNotEmpty(serviceOrdId)){
                        if(!dispatchIdToTaskMap.containsKey(emergency.getTaskId())) {
                            dispatchIdToTaskMap.put(emergency.getTaskId(), emergency);
                        }
                    }
                }
                
                if (dispatchOrdIDs.isEmpty()) {
                    log.warn("本页没有有效的调度单ID");
                if (dispatchIdToTaskMap.size()<=0) {
//                    log.warn("本页没有有效的调度单ID");
                    offset += pageSize;
                    continue;
                }
                
                // 3. 批量查询旧系统调度单状态（直接查询SQL Server数据库）
                List<DispatchOrd> dispatchOrds = dispatchOrdService.selectDispatchOrdStatesByIDs(dispatchOrdIDs);
                
                if (dispatchOrds == null || dispatchOrds.isEmpty()) {
                    log.warn("未查询到旧系统调度单状态");
                    offset += pageSize;
                    continue;
                }
                
                // 4. 构建调度单ID到状态的映射
                Map<Long, Integer> dispatchIdToStateMap = new HashMap<>();
                for (DispatchOrd dispatchOrd : dispatchOrds) {
                    try {
                        Long dispatchOrdId = Long.parseLong(dispatchOrd.getDispatchOrdID());
                        Integer dispatchOrdState = Integer.parseInt(dispatchOrd.getDispatchOrdState());
                        if (dispatchOrdState != null) {
                            dispatchIdToStateMap.put(dispatchOrdId, dispatchOrdState);
                dispatchIdToTaskMap.forEach((taskId, emergency) -> {
                    Long dispatchOrdId = emergency.getLegacyDispatchOrdId();
                    Long serviceOrdId = emergency.getLegacyServiceOrdId();
                    if(LongUtil.isNotEmpty(dispatchOrdId)){
                       Integer state =dispatchOrdService.selectDispatchOrdStateByID(dispatchOrdId);
                        syncTaskStatusWithLegacyState(taskId, state);
                    }
                    else if(LongUtil.isNotEmpty(serviceOrdId)){
                        try {
                            Integer serviceOrdState = serviceOrderService.selectServiceOrderStateById(serviceOrdId);
                            if (serviceOrdState == 4) {
                                //取消
                                Map<String, Object> cancelInfo = serviceOrderService.selectCancelInfoById(serviceOrdId);
                                String cancelReasonText = (String) cancelInfo.get("ServiceOrdCancelReasonTXT");
                                String cancelReason = (String) cancelInfo.get("ServiceOrdCancelReason");
                                taskService.saveCancel(taskId, cancelReason, cancelReasonText, DateUtils.getNowDate());
                            }
                        }catch (Exception ex){
                            log.error("查询旧系统状态失败，任务ID: {}, ServiceOrdID: {}", taskId, serviceOrdId);
                        }
                    } catch (NumberFormatException e) {
                        log.error("解析调度单ID失败: {}", dispatchOrd.getDispatchOrdID(), e);

//                        syncTaskStatusWithLegacyState(taskId, state);
                    }
                }
                
                // 5. 遍历任务，同步状态
                int pageSuccessCount = 0;
                for (Map.Entry<Long, SysTaskEmergency> entry : dispatchIdToTaskMap.entrySet()) {
                    Long dispatchOrdId = entry.getKey();
                    SysTaskEmergency emergency = entry.getValue();
                    
                    // 获取旧系统状态
                    Integer legacyStatus = dispatchIdToStateMap.get(dispatchOrdId);
                    if (legacyStatus == null) {
                        log.warn("未找到调度单状态，DispatchOrdID: {}", dispatchOrdId);
                        continue;
                    }
                    
                    // 同步单个任务状态
                    boolean result = syncTaskStatusWithLegacyState(emergency.getTaskId(), legacyStatus);
                    if (result) {
                        pageSuccessCount++;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("状态第 {} 页同步完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, syncedTasks.size(), pageSuccessCount);
                
                });

//
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (syncedTasks.size() < pageSize) {
                    log.info("已到达最后一页，状态同步结束");
//                    log.info("已到达最后一页，状态同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量同步任务状态完成，总成功数: {}", totalSuccessCount);
//            log.info("批量同步任务状态完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
@@ -219,7 +212,6 @@
     * @param legacyStatus 旧系统状态码
     * @return 是否成功
     */
    @Transactional
    private boolean syncTaskStatusWithLegacyState(Long taskId, Integer legacyStatus) {
        try {
            // 查询任务信息
@@ -232,23 +224,23 @@
            // 转换为新系统状态
            TaskStatus newStatus = TaskStatusConverter.convertFromLegacyStatus(legacyStatus);
            if (newStatus == null) {
                log.debug("旧系统状态码 > 10 或无法转换，跳过同步，任务ID: {}, 状态码: {} ({})",
                    taskId, legacyStatus, TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
//                log.debug("旧系统状态码 > 10 或无法转换，跳过同步，任务ID: {}, 状态码: {} ({})",
//                    taskId, legacyStatus, TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                return false;
            }
            
            // 检查状态是否变化
            if (newStatus.getCode().equals(task.getTaskStatus())) {
                log.debug("任务状态未变化，任务ID: {}, 当前状态: {}", taskId, newStatus.getInfo());
                // log.debug("变化，任务ID: {}, 当前状态: {}", taskId, newStatus.getInfo());
                return true;
            }
            
            // 比较新旧系统状态的优先级，防止状态倒退
            TaskStatus currentStatus = TaskStatus.getByCode(task.getTaskStatus());
            if (currentStatus != null && !shouldSyncStatus(currentStatus, newStatus, legacyStatus)) {
                log.info("【旧系统更新到新系统】 旧系统状态落后于新系统状态，跳过同步，任务ID: {}, 新系统状态: {} ({}), 旧系统状态: {} ({})",
                    taskId, task.getTaskStatus(), currentStatus.getInfo(), 
                    newStatus.getCode(), TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                // log.info("【旧系统更新到新系统】 旧系统状态落后于新系统状态，跳过同步，任务ID: {}, 新系统状态: {} ({}), 旧系统状态: {} ({})",
                //     taskId, task.getTaskStatus(), currentStatus.getInfo(), 
                //     newStatus.getCode(), TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                return false;
            }
            
@@ -281,12 +273,13 @@
                default:
                    break;
            }

            
            sysTaskMapper.updateSysTask(task);
            
            log.info("任务状态同步成功，任务ID: {}, 旧状态: {}, 新状态: {}, 旧系统状态码: {} ({})", 
                taskId, oldStatus, newStatus.getCode(), legacyStatus, 
                TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
//            log.info("任务状态同步成功，任务ID: {}, 旧状态: {}, 新状态: {}, 旧系统状态码: {} ({})",
//                taskId, oldStatus, newStatus.getCode(), legacyStatus,
//                TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
            
            return true;