package com.ruoyi.system.service.impl;
|
|
import com.ruoyi.common.config.LegacySystemConfig;
|
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.ITaskStatusPushService;
|
import com.ruoyi.system.utils.TaskStatusPushConverter;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
/**
|
* 任务状态推送Service业务层处理
|
* 负责将新系统的任务状态推送到旧系统
|
*
|
* @author ruoyi
|
* @date 2024-01-16
|
*/
|
@Service
|
public class TaskStatusPushServiceImpl implements ITaskStatusPushService {
|
|
private static final Logger log = LoggerFactory.getLogger(TaskStatusPushServiceImpl.class);
|
|
@Autowired
|
private LegacySystemConfig legacyConfig;
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private ISysTaskEmergencyService sysTaskEmergencyService;
|
|
@Autowired
|
private IDispatchOrdService dispatchOrdService;
|
|
/**
|
* 将单个任务状态推送到旧系统
|
*
|
* @param taskId 任务ID
|
* @return 是否推送成功
|
*/
|
@Override
|
@Transactional
|
public boolean pushTaskStatusToLegacy(Long taskId) {
|
if (!legacyConfig.isEnabled()) {
|
log.info("旧系统同步已禁用，跳过状态推送，任务ID: {}", taskId);
|
return false;
|
}
|
|
try {
|
// 查询任务信息
|
log.debug("【新推旧】查询任务ID: {}", taskId);
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
if (task == null) {
|
log.error("【新推旧】任务不存在，任务ID: {}", taskId);
|
return false;
|
}
|
|
// 只推送急救转运任务
|
if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) {
|
log.info("非急救转运任务，跳过状态推送，任务ID: {}", taskId);
|
return false;
|
}
|
|
// 查询急救转运扩展信息
|
SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
|
if (emergency == null) {
|
log.error("急救转运扩展信息不存在，任务ID: {}", taskId);
|
return false;
|
}
|
|
// 必须已经同步过调度单
|
if (emergency.getLegacyDispatchOrdId() == null || emergency.getLegacyDispatchOrdId() <= 0) {
|
log.warn("调度单未同步，无法推送状态，任务ID: {}", taskId);
|
return false;
|
}
|
|
// 获取新系统状态
|
TaskStatus newTaskStatus = TaskStatus.getByCode(task.getTaskStatus());
|
if (newTaskStatus == null) {
|
log.error("无效的任务状态，任务ID: {}, 状态码: {}", taskId, task.getTaskStatus());
|
return false;
|
}
|
|
// 转换为旧系统状态码
|
Integer targetStatusCode = TaskStatusPushConverter.convertToLegacyStatus(newTaskStatus);
|
if (targetStatusCode == null) {
|
log.debug("【新推旧】任务状态不需要推送到旧系统，任务ID: {}, 状态: {}",
|
taskId, newTaskStatus.getInfo());
|
return false;
|
}
|
|
// 查询旧系统当前状态
|
Integer currentLegacyStatus = dispatchOrdService.selectDispatchOrdStateByID(
|
emergency.getLegacyDispatchOrdId());
|
if (currentLegacyStatus == null) {
|
log.error("【新推旧】查询旧系统状态失败，任务ID: {}, DispatchOrdID: {}",
|
taskId, emergency.getLegacyDispatchOrdId());
|
return false;
|
}
|
|
// 判断是否需要更新（包含防止状态倒退的检查）
|
// 如果旧系统状态已经 >= 新系统要推送的状态，说明旧系统状态更新，新系统落后，不应该推送
|
if (!TaskStatusPushConverter.shouldUpdateLegacyStatus(targetStatusCode, currentLegacyStatus)) {
|
log.info("【新推旧】新系统状态落后或等于旧系统状态，跳过推送，任务ID: {}, 新系统状态: {} ({}→{}), 旧系统状态: {} ({})",
|
taskId,
|
task.getTaskStatus(), newTaskStatus.getInfo(), targetStatusCode,
|
currentLegacyStatus, TaskStatusPushConverter.getLegacyStatusDescription(currentLegacyStatus));
|
return true; // 返回true，因为这不算失败，只是不需要推送
|
}
|
|
// 推送状态到旧系统
|
boolean result = updateLegacyTaskStatus(emergency.getLegacyDispatchOrdId(), targetStatusCode);
|
|
if (result) {
|
log.info("【新推旧】任务状态推送成功，任务ID: {}, DispatchOrdID: {}, 旧状态: {} ({}), 新状态: {} ({})",
|
taskId, emergency.getLegacyDispatchOrdId(),
|
currentLegacyStatus, TaskStatusPushConverter.getLegacyStatusDescription(currentLegacyStatus),
|
targetStatusCode, TaskStatusPushConverter.getLegacyStatusDescription(targetStatusCode));
|
} else {
|
log.error("【新推旧】任务状态推送失败，任务ID: {}, DispatchOrdID: {}",
|
taskId, emergency.getLegacyDispatchOrdId());
|
}
|
|
return result;
|
|
} catch (Exception e) {
|
log.error("【新推旧】推送任务状态异常，任务ID: {}", taskId, e);
|
return false;
|
}
|
}
|
|
/**
|
* 批量推送任务状态到旧系统
|
* 使用分页查询，确保所有符合条件的任务都能被推送
|
*
|
* @return 成功推送的任务数量
|
*/
|
@Override
|
public int batchPushTaskStatusToLegacy() {
|
if (!legacyConfig.isEnabled()) {
|
log.info("旧系统同步已禁用");
|
return 0;
|
}
|
|
try {
|
int totalSuccessCount = 0;
|
int pageSize = 200; // 每页200条
|
int offset = 0;
|
|
while (true) {
|
// 分页查询已同步调度单且状态未完成的任务
|
List<SysTaskEmergency> syncedTasks = sysTaskEmergencyService.selectSyncedTasksForStatusUpdate(offset, pageSize);
|
|
if (syncedTasks == null || syncedTasks.isEmpty()) {
|
log.info("【新推旧】没有更多需要推送状态的任务，offset: {}", offset);
|
break; // 没有更多数据，退出循环
|
}
|
|
log.info("【新推旧】开始推送状态第 {} 页，任务数量: {}", (offset / pageSize) + 1, syncedTasks.size());
|
|
int pageSuccessCount = 0;
|
for (SysTaskEmergency emergency : syncedTasks) {
|
boolean result = pushTaskStatusToLegacy(emergency.getTaskId());
|
if (result) {
|
pageSuccessCount++;
|
}
|
|
// 避免过于频繁的请求
|
try {
|
Thread.sleep(200); // 每个请求间隔0.2秒
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.warn("【新推旧】推送状态被中断");
|
return totalSuccessCount + pageSuccessCount;
|
}
|
}
|
|
totalSuccessCount += pageSuccessCount;
|
log.info("状态第 {} 页推送完成，总数: {}, 成功: {}",
|
(offset / pageSize) + 1, syncedTasks.size(), pageSuccessCount);
|
|
// 如果本页数据少于每页大小，说明已经是最后一页
|
if (syncedTasks.size() < pageSize) {
|
log.info("【新推旧】已到达最后一页，状态推送结束");
|
break;
|
}
|
|
offset += pageSize; // 下一页
|
}
|
|
log.info("【新推旧】批量推送任务状态完成，总成功数: {}", totalSuccessCount);
|
return totalSuccessCount;
|
|
} catch (Exception e) {
|
log.error("【新推旧】批量推送任务状态异常", e);
|
return 0;
|
}
|
}
|
|
/**
|
* 更新旧系统调度单状态（直接操作SQL Server数据库）
|
*
|
* @param dispatchOrdId 调度单ID
|
* @param statusCode 目标状态码
|
* @return 是否成功
|
*/
|
private boolean updateLegacyTaskStatus(Long dispatchOrdId, Integer statusCode) {
|
try {
|
// 直接通过Service调用Mapper更新SQL Server数据库
|
int rows = dispatchOrdService.updateDispatchOrdState(dispatchOrdId, statusCode);
|
log.debug("更新旧系统状态，DispatchOrdID: {}, StateInt: {}", dispatchOrdId, statusCode);
|
if (rows > 0) {
|
log.debug("更新旧系统状态成功，DispatchOrdID: {}, StateInt: {}",
|
dispatchOrdId, statusCode);
|
return true;
|
} else {
|
log.warn("更新旧系统状态失败，未找到对应调度单，DispatchOrdID: {}", dispatchOrdId);
|
return false;
|
}
|
|
} catch (Exception e) {
|
log.error("更新旧系统状态异常，DispatchOrdID: {}", dispatchOrdId, e);
|
return false;
|
}
|
}
|
}
|
