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.DispatchOrdMapper;
|
import com.ruoyi.system.mapper.LegacyTransferSyncMapper;
|
import com.ruoyi.system.mapper.SysDictDataMapper;
|
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;
|
|
@Autowired
|
private DispatchOrdMapper dispatchOrdMapper;
|
|
@Autowired
|
private SysDictDataMapper sysDictDataMapper;
|
|
/**
|
* 监听任务状态变更事件
|
*
|
* @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表
|
if (TaskStatus.CANCELLED.equals(newTaskStatus) && emergency.getCancelReason() != null) {
|
syncCancelReasonToDispatchOrd(emergency.getLegacyDispatchOrdId(), emergency.getCancelReason());
|
}
|
|
// 插入状态变更记录到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);
|
// 不抛出异常，避免影响主流程
|
}
|
}
|
|
/**
|
* 同步取消原因到DispatchOrd表
|
*
|
* @param dispatchOrdId 调度单ID
|
* @param cancelReason 取消原因（字典value）
|
*/
|
private void syncCancelReasonToDispatchOrd(Long dispatchOrdId, String cancelReason) {
|
try {
|
if (cancelReason == null || cancelReason.isEmpty()) {
|
log.debug("取消原因为空，跳过同步，DispatchOrdID: {}", dispatchOrdId);
|
return;
|
}
|
|
// 将cancelReason（字典value）转换为Integer
|
Integer cancelReasonId = null;
|
try {
|
cancelReasonId = Integer.valueOf(cancelReason);
|
} catch (NumberFormatException e) {
|
log.error("取消原因格式错误，无法转换为数字，cancelReason: {}, DispatchOrdID: {}", cancelReason, dispatchOrdId);
|
return;
|
}
|
|
// 从数据字典中查询取消原因文本
|
String cancelReasonText = sysDictDataMapper.selectDictLabel("task_cancel_reason", cancelReason);
|
if (cancelReasonText == null || cancelReasonText.isEmpty()) {
|
log.warn("未找到取消原因对应的文本，cancelReason: {}, DispatchOrdID: {}", cancelReason, dispatchOrdId);
|
cancelReasonText = cancelReason; // 使用原值作为预备
|
}
|
|
log.info("开始同步取消原因到DispatchOrd，DispatchOrdID: {}, 取消原因ID: {}, 取消原因文本: {}",
|
dispatchOrdId, cancelReasonId, cancelReasonText);
|
|
// 调用Mapper更新DispatchOrd表
|
int rows = dispatchOrdMapper.updateDispatchOrdCancelReason(dispatchOrdId, cancelReasonId, cancelReasonText);
|
|
if (rows > 0) {
|
log.info("成功同步取消原因到DispatchOrd，DispatchOrdID: {}, 取消原因: {} ({})",
|
dispatchOrdId, cancelReasonText, cancelReasonId);
|
} else {
|
log.warn("同步取消原因失败，未找到对应的调度单，DispatchOrdID: {}", dispatchOrdId);
|
}
|
|
} catch (Exception e) {
|
log.error("同步取消原因到DispatchOrd异常，DispatchOrdID: {}, 取消原因: {}",
|
dispatchOrdId, cancelReason, e);
|
// 不抛出异常，避免影响主流程
|
}
|
}
|
}
|
