feat: 增加日志记录历史消息

wlzboy

2026-03-24 6676a35122fd9c97d1b1679c211bc8a9b97f08f2

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

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

import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.common.utils.LongUtil;
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.IServiceOrderService;
import com.ruoyi.system.service.ISysDictDataService;
import com.ruoyi.system.service.ISysTaskEmergencyService;
import com.ruoyi.system.service.ITaskStatusPushService;
import com.ruoyi.system.utils.TaskStatusPushConverter;
@@ -41,6 +44,12 @@
    @Autowired
    private IDispatchOrdService dispatchOrdService;
    
    @Autowired
    private IServiceOrderService serviceOrderService;
    
    @Autowired
    private ISysDictDataService sysDictDataService;
    
    /**
     * 将单个任务状态推送到旧系统
     * 
@@ -48,16 +57,15 @@
     * @return 是否推送成功
     */
    @Override
    @Transactional
    public boolean pushTaskStatusToLegacy(Long taskId) {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过状态推送，任务ID: {}", taskId);
//            log.info("旧系统同步已禁用，跳过状态推送，任务ID: {}", taskId);
            return false;
        }
        
        try {
            // 查询任务信息
            log.debug("【新推旧】查询任务ID: {}", taskId);
//            log.debug("【新推旧】查询任务ID: {}", taskId);
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
            if (task == null) {
                log.error("【新推旧】任务不存在，任务ID: {}", taskId);
@@ -66,7 +74,7 @@
            
            // 只推送急救转运任务
            if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) {
                log.info("非急救转运任务，跳过状态推送，任务ID: {}", taskId);
//                log.info("非急救转运任务，跳过状态推送，任务ID: {}", taskId);
                return false;
            }
            
@@ -110,11 +118,41 @@
            // 判断是否需要更新（包含防止状态倒退的检查）
            // 如果旧系统状态已经 >= 新系统要推送的状态，说明旧系统状态更新，新系统落后，不应该推送
            if (!TaskStatusPushConverter.shouldUpdateLegacyStatus(targetStatusCode, currentLegacyStatus)) {
                log.info("【新推旧】新系统状态落后或等于旧系统状态，跳过推送，任务ID: {}, 新系统状态: {} ({}→{}), 旧系统状态: {} ({})",
                    taskId, 
                    task.getTaskStatus(), newTaskStatus.getInfo(), targetStatusCode,
                    currentLegacyStatus, TaskStatusPushConverter.getLegacyStatusDescription(currentLegacyStatus));
//                log.info("【新推旧】新系统状态落后或等于旧系统状态，跳过推送，任务ID: {}, 新系统状态: {} ({}→{}), 旧系统状态: {} ({})",
//                    taskId,
//                    task.getTaskStatus(), newTaskStatus.getInfo(), targetStatusCode,
//                    currentLegacyStatus, TaskStatusPushConverter.getLegacyStatusDescription(currentLegacyStatus));
                return true; // 返回true，因为这不算失败，只是不需要推送
            }
            if(newTaskStatus.equals(TaskStatus.CANCELLED)){
                if(LongUtil.isNotEmpty(emergency.getLegacyServiceOrdId()) ) {
                    log.info("取消转运任务: {}", emergency.getLegacyServiceOrdId());
                    cancelTask(emergency.getLegacyServiceOrdId(), emergency.getCancelReason(), emergency.getCancelBy());
                }
                if(LongUtil.isNotEmpty(emergency.getLegacyDispatchOrdId())){
                    log.info("取消调度单: {}", emergency.getLegacyDispatchOrdId());
                    cancelDispatch(emergency.getLegacyDispatchOrdId(), emergency.getCancelReason(), emergency.getCancelBy());
                }
            }
            
            // 判断是否需要更新实际开始时间：从待处理转到其他状态（除取消外）
            if ( targetStatusCode != 10 && task.getActualStartTime() != null) {
                try {
                    int rows = dispatchOrdService.updateDispatchOrdActualDate(
                        emergency.getLegacyDispatchOrdId(), 
                        task.getActualStartTime());
                    if (rows > 0) {
                        log.info("【新推旧】更新实际开始时间成功，任务ID: {}, DispatchOrdID: {}, 实际开始时间: {}",
                            taskId, emergency.getLegacyDispatchOrdId(), task.getActualStartTime());
                    } else {
                        log.warn("【新推旧】更新实际开始时间失败，未找到对应调度单，DispatchOrdID: {}", 
                            emergency.getLegacyDispatchOrdId());
                    }
                } catch (Exception e) {
                    log.error("【新推旧】更新实际开始时间异常，DispatchOrdID: {}", 
                        emergency.getLegacyDispatchOrdId(), e);
                    // 不抛出异常，继续执行状态推送
                }
            }
            
            // 推送状态到旧系统
@@ -137,7 +175,11 @@
            return false;
        }
    }
    

    private void cancelDispatch(Long legacyDispatchOrdId, String cancelReason, String cancelReasonText) {
        dispatchOrdService.cancelDispatchOrd(legacyDispatchOrdId, Integer.parseInt(cancelReason), cancelReasonText);
    }

    /**
     * 批量推送任务状态到旧系统
     * 使用分页查询，确保所有符合条件的任务都能被推送
@@ -153,7 +195,7 @@
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 200; // 每页200条
            int pageSize = 5; // 每页10条
            int offset = 0;
            
            while (true) {
@@ -161,11 +203,11 @@
                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());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : syncedTasks) {
@@ -179,25 +221,25 @@
                        Thread.sleep(200); // 每个请求间隔0.2秒
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        log.warn("【新推旧】推送状态被中断");
//                        log.warn("【新推旧】推送状态被中断");
                        return totalSuccessCount + pageSuccessCount;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("状态第 {} 页推送完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, syncedTasks.size(), 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) {
@@ -205,7 +247,53 @@
            return 0;
        }
    }
    


    private void cancelTask(Long serviceOrderId, String cancelReason, String cancelBy){
        // 取消任务，更新SQL Server中的ServiceOrder表
        try {
            if (LongUtil.isEmpty(serviceOrderId)) {
                log.warn("ServiceOrderID为空，无法取消任务");
                return;
            }
            
            // 解析取消原因ID
            Integer cancelReasonId = null;
            String cancelReasonText = "";
            
            if (cancelReason != null && !cancelReason.isEmpty()) {
                try {
                    log.info("取消原因 cancelReason:{},取消人:{}", cancelReason, cancelBy);
                    cancelReasonId = Integer.parseInt(cancelReason);
                    // 从数据字典查询取消原因文本
                    String dictLabel = sysDictDataService.selectDictLabel("task_cancel_reason", cancelReason);
                    if (dictLabel != null && !dictLabel.isEmpty()) {
                        cancelReasonText = "[取消操作:" + (cancelBy != null ? cancelBy : "系统") + "] " + dictLabel;
                    } else {
                        cancelReasonText = "[取消操作:" + (cancelBy != null ? cancelBy : "系统") + "]";
                    }
                } catch (NumberFormatException e) {
                    log.error("取消原因ID格式错误: {}", cancelReason,e);
                    cancelReasonText = "[取消操作:" + (cancelBy != null ? cancelBy : "系统") + "] " + cancelReason;
                }
            } else {
                cancelReasonText = "[取消操作:" + (cancelBy != null ? cancelBy : "系统") + "]";
            }
            
            // 调用Service更新ServiceOrder表
            int rows = serviceOrderService.updateServiceOrderCancelInfo(serviceOrderId, cancelReasonId, cancelReasonText);
            
            if (rows > 0) {
                log.info("成功更新旧系统ServiceOrder取消信息，ServiceOrdID: {}, 取消原因ID: {}, 取消原因文本: {}", 
                    serviceOrderId, cancelReasonId, cancelReasonText);
            } else {
                log.warn("更新旧系统ServiceOrder取消信息失败，未找到对应订单，ServiceOrdID: {}", serviceOrderId);
            }
            
        } catch (Exception e) {
            log.error("更新旧系统ServiceOrder取消信息异常，ServiceOrdID: {}", serviceOrderId, e);
        }
    }
    /**
     * 更新旧系统调度单状态（直接操作SQL Server数据库）
     * 
@@ -217,13 +305,13 @@
        try {
            // 直接通过Service调用Mapper更新SQL Server数据库
            int rows = dispatchOrdService.updateDispatchOrdState(dispatchOrdId, statusCode);
            log.debug("更新旧系统状态，DispatchOrdID: {}, StateInt: {}", dispatchOrdId, statusCode);
            log.debug("更新旧系统状态，DispatchOrdID: {}, statusCode: {}", dispatchOrdId, statusCode);
            if (rows > 0) {
                log.debug("更新旧系统状态成功，DispatchOrdID: {}, StateInt: {}", 
                log.debug("更新旧系统状态成功，DispatchOrdID: {}, statusCode: {}",
                    dispatchOrdId, statusCode);
                return true;
            } else {
                log.warn("更新旧系统状态失败，未找到对应调度单，DispatchOrdID: {}", dispatchOrdId);
//                log.warn("更新旧系统状态失败，未找到对应调度单，DispatchOrdID: {}", dispatchOrdId);
                return false;
            }