feat:显示问题

wlzboy

2025-12-26 c10b1e130ccbc94e6481a43e8e2d35cfc8fcf83b

 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,13 +118,18 @@
            // 判断是否需要更新（包含防止状态倒退的检查）
            // 如果旧系统状态已经 >= 新系统要推送的状态，说明旧系统状态更新，新系统落后，不应该推送
            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());
                }
            }
            // 推送状态到旧系统
            boolean result = updateLegacyTaskStatus(emergency.getLegacyDispatchOrdId(), targetStatusCode);
            
@@ -161,11 +174,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 +192,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 +218,52 @@
            return 0;
        }
    }
    


    private void cancelTask(Long serviceOrderId, String cancelReason, String cancelBy){
        // 取消任务，更新SQL Server中的ServiceOrder表
        try {
            if (serviceOrderId == null || serviceOrderId <= 0) {
                log.warn("ServiceOrderID为空，无法取消任务");
                return;
            }
            
            // 解析取消原因ID
            Integer cancelReasonId = null;
            String cancelReasonText = "";
            
            if (cancelReason != null && !cancelReason.isEmpty()) {
                try {
                    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.warn("取消原因ID格式错误: {}", cancelReason);
                    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 +275,13 @@
        try {
            // 直接通过Service调用Mapper更新SQL Server数据库
            int rows = dispatchOrdService.updateDispatchOrdState(dispatchOrdId, statusCode);
            log.debug("更新旧系统状态，DispatchOrdID: {}, StateInt: {}", dispatchOrdId, statusCode);
//            log.debug("更新旧系统状态，DispatchOrdID: {}, StateInt: {}", dispatchOrdId, statusCode);
            if (rows > 0) {
                log.debug("更新旧系统状态成功，DispatchOrdID: {}, StateInt: {}", 
                    dispatchOrdId, statusCode);
//                log.debug("更新旧系统状态成功，DispatchOrdID: {}, StateInt: {}",
//                    dispatchOrdId, statusCode);
                return true;
            } else {
                log.warn("更新旧系统状态失败，未找到对应调度单，DispatchOrdID: {}", dispatchOrdId);
//                log.warn("更新旧系统状态失败，未找到对应调度单，DispatchOrdID: {}", dispatchOrdId);
                return false;
            }