package com.ruoyi.system.listener;
|
|
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 com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.system.domain.SysMessage;
|
import com.ruoyi.system.domain.SysTask;
|
import com.ruoyi.system.domain.SysTaskEmergency;
|
import com.ruoyi.system.domain.NotifyTask;
|
import com.ruoyi.system.event.TaskCreatedEvent;
|
import com.ruoyi.system.event.TaskAssignedEvent;
|
import com.ruoyi.system.event.TaskStatusChangedEvent;
|
import com.ruoyi.system.mapper.SysMessageMapper;
|
import com.ruoyi.system.mapper.SysUserMapper;
|
import com.ruoyi.system.mapper.SysTaskMapper;
|
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.system.service.INotifyTaskService;
|
import com.ruoyi.system.service.INotifyDispatchService;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* 任务消息监听器
|
* 监听任务相关事件并保存消息到消息库
|
*
|
* @author ruoyi
|
* @date 2025-10-25
|
*/
|
@Component
|
public class TaskMessageListener {
|
|
private static final Logger log = LoggerFactory.getLogger(TaskMessageListener.class);
|
|
@Autowired
|
private SysMessageMapper sysMessageMapper;
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskEmergencyMapper sysTaskEmergencyMapper;
|
|
@Autowired
|
private INotifyTaskService notifyTaskService;
|
|
@Autowired
|
private INotifyDispatchService notifyDispatchService;
|
|
/** 待准备状态 - 可以发送短信通知 */
|
private static final String TASK_STATUS_PENDING = "PENDING";
|
/** 待准备状态 - 可以发送短信通知 */
|
private static final String TASK_STATUS_PREPARING = "PREPARING";
|
|
/**
|
* 监听任务创建事件
|
*
|
* @param event 任务创建事件
|
*/
|
@Async
|
@EventListener
|
public void handleTaskCreatedEvent(TaskCreatedEvent event) {
|
try {
|
log.info("收到任务创建事件，任务ID：{}，任务编号：{}", event.getTaskId(), event.getTaskCode());
|
|
// 获取创建人信息
|
SysUser creator = sysUserMapper.selectUserById(event.getCreatorId());
|
if (creator == null) {
|
log.warn("找不到创建人信息，用户ID：{}", event.getCreatorId());
|
return;
|
}
|
|
// 创建消息
|
SysMessage message = new SysMessage();
|
message.setMessageType("CREATE");
|
message.setMessageTitle("任务创建成功");
|
message.setMessageContent("您创建的任务已成功提交");
|
message.setTaskId(event.getTaskId());
|
message.setTaskCode(event.getTaskCode());
|
message.setReceiverId(event.getCreatorId());
|
message.setReceiverName(creator.getNickName());
|
message.setSenderId(event.getCreatorId());
|
message.setSenderName("系统");
|
message.setIsRead("0");
|
message.setCreateTime(DateUtils.getNowDate());
|
message.setDelFlag("0");
|
|
// 保存消息
|
sysMessageMapper.insertSysMessage(message);
|
log.info("任务创建消息已保存，消息ID：{}", message.getMessageId());
|
|
} catch (Exception e) {
|
log.error("处理任务创建事件失败", e);
|
}
|
}
|
|
|
|
/**
|
* 监听任务分配事件
|
* 创建通知任务，由通知分发服务决定发送渠道
|
*
|
* @param event 任务分配事件
|
*/
|
@Async
|
@EventListener
|
public void handleTaskAssignedEvent(TaskAssignedEvent event) {
|
try {
|
log.info("收到任务分配事件，任务ID：{}，任务编号：{}，执行人数量：{}",
|
event.getTaskId(), event.getTaskCode(),
|
event.getAssigneeIds() != null ? event.getAssigneeIds().size() : 0);
|
|
if (event.getAssigneeIds() == null || event.getAssigneeIds().isEmpty()) {
|
log.warn("执行人ID列表为空，无法推送消息");
|
return;
|
}
|
|
// 查询任务信息
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(event.getTaskId());
|
if (task == null) {
|
log.warn("任务不存在，taskId={}", event.getTaskId());
|
return;
|
}
|
|
// 查询急救扩展信息（用于构建通知内容）
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(event.getTaskId());
|
|
Long creatorId = task.getCreatorId();
|
String taskStatus = task.getTaskStatus();
|
|
// 仅在待准备状态下发送通知
|
if (!TASK_STATUS_PENDING.equals(taskStatus) && !TASK_STATUS_PREPARING.equals(taskStatus)) {
|
log.info("任务状态({})非待准备状态，跳过通知，taskId={}", taskStatus, event.getTaskId());
|
return;
|
}
|
|
// 构建通知内容
|
String notifyContent = buildNotifyContent(task, emergency);
|
|
// 收集创建的通知任务
|
List<NotifyTask> createdTasks = new ArrayList<>();
|
|
// 为每个执行人创建通知任务
|
for (Long assigneeId : event.getAssigneeIds()) {
|
// 排除创建人
|
if (creatorId != null && creatorId.equals(assigneeId)) {
|
log.debug("跳过创建人，不发送任务分配通知，userId={}", assigneeId);
|
continue;
|
}
|
|
// 获取执行人信息
|
SysUser assignee = sysUserMapper.selectUserById(assigneeId);
|
if (assignee == null) {
|
log.warn("找不到执行人信息，用户ID：{}", assigneeId);
|
continue;
|
}
|
|
// 创建通知任务（带防重）
|
NotifyTask notifyTask = new NotifyTask();
|
notifyTask.setTaskId(event.getTaskId());
|
notifyTask.setTaskCode(event.getTaskCode());
|
notifyTask.setNotifyType(NotifyTask.NOTIFY_TYPE_TASK_ASSIGN);
|
notifyTask.setUserId(assigneeId);
|
notifyTask.setUserName(assignee.getNickName());
|
notifyTask.setUserPhone(assignee.getPhonenumber());
|
notifyTask.setTitle("任务推送");
|
notifyTask.setContent(notifyContent);
|
notifyTask.setCreateBy(event.getAssignerName() != null ? event.getAssignerName() : "系统");
|
|
NotifyTask created = notifyTaskService.createNotifyTask(notifyTask);
|
if (created != null) {
|
createdTasks.add(created);
|
log.info("创建通知任务成功，id={}, userId={}", created.getId(), assigneeId);
|
} else {
|
log.info("通知任务已存在，跳过，taskId={}, userId={}", event.getTaskId(), assigneeId);
|
}
|
}
|
|
// 分发通知任务
|
if (!createdTasks.isEmpty()) {
|
int successCount = notifyDispatchService.dispatchNotifies(createdTasks);
|
log.info("通知分发完成，taskId={}，创建数量={}，成功数量={}",
|
event.getTaskId(), createdTasks.size(), successCount);
|
}
|
|
} catch (Exception e) {
|
log.error("处理任务分配事件失败", e);
|
}
|
}
|
|
/**
|
* 构建通知内容
|
*/
|
private String buildNotifyContent(SysTask task, SysTaskEmergency emergency) {
|
StringBuilder content = new StringBuilder("您有新的转运任务，请及时处理，任务单号:"+task.getTaskCode());
|
|
// 添加出发地信息
|
String departure = null;
|
if (emergency != null && StringUtils.isNotEmpty(emergency.getHospitalOutName())) {
|
departure = emergency.getHospitalOutName();
|
} else if (StringUtils.isNotEmpty(task.getDepartureAddress())) {
|
departure = task.getDepartureAddress();
|
}
|
|
// 添加目的地信息
|
String destination = null;
|
if (emergency != null && StringUtils.isNotEmpty(emergency.getHospitalInName())) {
|
destination = emergency.getHospitalInName();
|
} else if (StringUtils.isNotEmpty(task.getDestinationAddress())) {
|
destination = task.getDestinationAddress();
|
}
|
|
if (departure != null || destination != null) {
|
content = new StringBuilder();
|
if (departure != null) {
|
content.append("出发地：").append(departure);
|
}
|
if (destination != null) {
|
if (content.length() > 0) content.append("，");
|
content.append("目的地：").append(destination);
|
}
|
content.append("，请及时处理。");
|
}
|
|
return content.toString();
|
}
|
|
/**
|
* 监听任务状态变更事件
|
*
|
* @param event 任务状态变更事件
|
*/
|
@Async
|
@EventListener
|
public void handleTaskStatusChangedEvent(TaskStatusChangedEvent event) {
|
try {
|
log.info("收到任务状态变更事件，任务ID：{}，旧状态：{}，新状态：{}",
|
event.getTaskId(), event.getOldStatus(), event.getNewStatus());
|
|
// 构建状态变更内容
|
String statusContent = getStatusChangeContent(event.getNewStatus(), event.getNewStatusDesc());
|
|
// 收集所有需要通知的用户ID（执行人+创建人，去重）
|
java.util.Set<Long> receiverIds = new java.util.HashSet<>();
|
|
// 添加执行人
|
if (event.getAssigneeIds() != null) {
|
receiverIds.addAll(event.getAssigneeIds());
|
}
|
|
// 添加创建人（如果不是执行人）
|
if (event.getCreatorId() != null) {
|
receiverIds.add(event.getCreatorId());
|
}
|
|
// 给每个用户发送消息
|
for (Long receiverId : receiverIds) {
|
SysUser user = sysUserMapper.selectUserById(receiverId);
|
if (user == null) {
|
log.warn("找不到用户信息，用户ID：{}", receiverId);
|
continue;
|
}
|
|
// 创建消息
|
SysMessage message = new SysMessage();
|
message.setMessageType("STATUS");
|
message.setMessageTitle("任务状态变更");
|
message.setMessageContent(statusContent);
|
message.setTaskId(event.getTaskId());
|
message.setTaskCode(event.getTaskCode());
|
message.setReceiverId(receiverId);
|
message.setReceiverName(user.getNickName());
|
message.setSenderId(event.getCreatorId());
|
message.setSenderName("系统");
|
message.setIsRead("0");
|
message.setCreateTime(DateUtils.getNowDate());
|
message.setDelFlag("0");
|
|
// 保存消息
|
sysMessageMapper.insertSysMessage(message);
|
log.info("任务状态变更消息已保存，消息ID：{}，新状态：{}，接收人：{}",
|
message.getMessageId(), event.getNewStatus(), user.getNickName());
|
}
|
|
} catch (Exception e) {
|
log.error("处理任务状态变更事件失败", e);
|
}
|
}
|
|
/**
|
* 根据状态获取状态变更内容
|
*
|
* @param status 任务状态
|
* @param statusDesc 状态描述
|
* @return 状态变更内容
|
*/
|
private String getStatusChangeContent(String status, String statusDesc) {
|
if (statusDesc != null && !statusDesc.isEmpty()) {
|
return "任务状态变更为：" + statusDesc;
|
}
|
|
switch (status) {
|
case "PENDING":
|
return "任务状态变更为：待处理";
|
case "DEPARTING":
|
case "DEPARTED":
|
return "任务状态变更为：已出发";
|
case "ARRIVED":
|
return "任务状态变更为：已到达";
|
case "RETURNING":
|
return "任务状态变更为：返程中";
|
case "COMPLETED":
|
return "任务状态变更为：已完成";
|
case "CANCELLED":
|
return "任务状态变更为：已取消";
|
default:
|
return "任务状态已更新";
|
}
|
}
|
}
|
