package com.ruoyi.system.listener;
|
|
import com.ruoyi.common.config.LegacySystemConfig;
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.system.domain.SysTask;
|
import com.ruoyi.system.domain.SysTaskEmergency;
|
import com.ruoyi.system.domain.enums.TaskStatus;
|
import com.ruoyi.system.event.TaskStatusChangedEvent;
|
import com.ruoyi.system.mapper.LegacyTransferSyncMapper;
|
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
|
import com.ruoyi.system.mapper.SysTaskMapper;
|
import com.ruoyi.system.mapper.SysUserMapper;
|
import com.ruoyi.system.utils.TaskStatusPushConverter;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.event.EventListener;
|
import org.springframework.scheduling.annotation.Async;
|
import org.springframework.stereotype.Component;
|
|
import java.util.Date;
|
|
/**
|
* 调度单状态变更记录监听器
|
* 监听任务状态变更事件，并将状态变更记录同步到SQL Server的DispatchOrd_Running表
|
*
|
* @author ruoyi
|
* @date 2025-12-05
|
*/
|
@Component
|
public class DispatchOrdRunningListener {
|
|
private static final Logger log = LoggerFactory.getLogger(DispatchOrdRunningListener.class);
|
|
@Autowired
|
private LegacySystemConfig legacyConfig;
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskEmergencyMapper sysTaskEmergencyMapper;
|
|
@Autowired
|
private LegacyTransferSyncMapper legacyTransferSyncMapper;
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
/**
|
* 监听任务状态变更事件
|
*
|
* @param event 任务状态变更事件
|
*/
|
@Async
|
@EventListener
|
public void handleTaskStatusChangedEvent(TaskStatusChangedEvent event) {
|
try {
|
log.info("收到任务状态变更事件，准备同步到DispatchOrd_Running，任务ID：{}，旧状态：{}，新状态：{}",
|
event.getTaskId(), event.getOldStatus(), event.getNewStatus());
|
|
// 检查旧系统同步是否启用
|
if (!legacyConfig.isEnabled()) {
|
log.debug("旧系统同步已禁用，跳过DispatchOrd_Running同步，任务ID: {}", event.getTaskId());
|
return;
|
}
|
|
// 查询任务信息
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(event.getTaskId());
|
if (task == null) {
|
log.error("任务不存在，任务ID: {}", event.getTaskId());
|
return;
|
}
|
|
// 只处理急救转运任务
|
if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) {
|
log.debug("非急救转运任务，跳过DispatchOrd_Running同步，任务ID: {}", event.getTaskId());
|
return;
|
}
|
|
// 查询急救转运扩展信息
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(event.getTaskId());
|
if (emergency == null) {
|
log.error("急救转运扩展信息不存在，任务ID: {}", event.getTaskId());
|
return;
|
}
|
|
// 必须已经同步过调度单
|
if (emergency.getLegacyDispatchOrdId() == null || emergency.getLegacyDispatchOrdId() <= 0) {
|
log.debug("调度单未同步到旧系统，跳过DispatchOrd_Running同步，任务ID: {}", event.getTaskId());
|
return;
|
}
|
|
// 获取新系统状态
|
TaskStatus newTaskStatus = TaskStatus.getByCode(event.getNewStatus());
|
if (newTaskStatus == null) {
|
log.error("无效的任务状态，任务ID: {}, 状态码: {}", event.getTaskId(), event.getNewStatus());
|
return;
|
}
|
|
SysUser user= sysUserMapper.selectUserById(event.getOperatorId());
|
if(user==null){
|
log.error("操作人不存在，任务ID: {}, 操作人ID: {}", event.getTaskId(), event.getOperatorId());
|
return;
|
}
|
Integer oaUserId=user.getOaUserId();
|
|
// 转换为旧系统状态码
|
Integer legacyStatusCode = TaskStatusPushConverter.convertToLegacyStatus(newTaskStatus);
|
if (legacyStatusCode == null) {
|
log.debug("任务状态不需要同步到旧系统，任务ID: {}, 状态: {}",
|
event.getTaskId(), newTaskStatus.getInfo());
|
return;
|
}
|
|
// 插入状态变更记录到DispatchOrd_Running表
|
syncDispatchOrdRunning(
|
emergency.getLegacyDispatchOrdId(),
|
legacyStatusCode,
|
new Date(), // 使用当前时间作为状态变更时
|
oaUserId.longValue(),
|
event.getLatitude(),
|
event.getLongitude(),
|
event.getAddress()
|
);
|
|
} catch (Exception e) {
|
log.error("处理任务状态变更事件并同步到DispatchOrd_Running失败，任务ID: {}", event.getTaskId(), e);
|
// 不抛出异常，避免影响主流程
|
}
|
}
|
|
/**
|
* 同步状态变更记录到DispatchOrd_Running表
|
*
|
* @param dispatchOrdId 调度单ID
|
* @param statusCode 状态码
|
* @param statusTime 状态时间
|
* @param operatorId 操作人ID
|
* @param latitude 纬度
|
* @param longitude 经度
|
* @param address 地址
|
*/
|
private void syncDispatchOrdRunning(Long dispatchOrdId, Integer statusCode,
|
Date statusTime, Long operatorId,
|
Double latitude, Double longitude, String address) {
|
try {
|
// 判断是否有GPS信息
|
boolean hasGps = (latitude != null && longitude != null);
|
if (hasGps) {
|
log.info("开始同步状态变更记录到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), GPS: [{}, {}]",
|
dispatchOrdId, statusCode, TaskStatusPushConverter.getLegacyStatusDescription(statusCode),
|
latitude, longitude);
|
} else {
|
log.info("开始同步状态变更记录到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), 无GPS信息",
|
dispatchOrdId, statusCode, TaskStatusPushConverter.getLegacyStatusDescription(statusCode));
|
}
|
|
// 调用Mapper插入记录
|
int rows = legacyTransferSyncMapper.insertDispatchOrdRunning(
|
dispatchOrdId,
|
statusCode,
|
statusTime,
|
operatorId,
|
latitude,
|
longitude,
|
address
|
);
|
|
if (rows > 0) {
|
if (hasGps) {
|
log.info("状态变更记录已同步到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), GPS: [{}, {}], 地址: {}",
|
dispatchOrdId,
|
statusCode,
|
TaskStatusPushConverter.getLegacyStatusDescription(statusCode),
|
latitude,
|
longitude,
|
address != null ? address : "无");
|
} else {
|
log.info("状态变更记录已同步到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), 无GPS信息",
|
dispatchOrdId,
|
statusCode,
|
TaskStatusPushConverter.getLegacyStatusDescription(statusCode));
|
}
|
} else {
|
log.warn("同步状态变更记录失败，未插入数据，DispatchOrdID: {}", dispatchOrdId);
|
}
|
|
} catch (Exception e) {
|
log.error("同步状态变更记录到DispatchOrd_Running异常，DispatchOrdID: {}, 状态码: {}",
|
dispatchOrdId, statusCode, e);
|
// 不抛出异常，避免影响主流程
|
}
|
}
|
}
|
