feat: 优化任务里程统计

wlzboy

9 天以前 09faa36132c8cbada5327649875534ef01c1a3b1

 ruoyi-system/src/main/java/com/ruoyi/system/listener/TaskMessageListener.java

@@ -7,13 +7,24 @@
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;

/**
 * 任务消息监听器
@@ -32,6 +43,23 @@
    
    @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";

    /**
     * 监听任务创建事件
@@ -75,8 +103,11 @@
        }
    }



    /**
     * 监听任务分配事件
     * 创建通知任务，由通知分发服务决定发送渠道
     * 
     * @param event 任务分配事件
     */
@@ -92,10 +123,39 @@
                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();
            
            // 给每个执行人发送消息
            for (int i = 0; i < event.getAssigneeIds().size(); i++) {
                Long assigneeId = event.getAssigneeIds().get(i);
            // 仅在待准备状态下发送通知
            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);
@@ -104,24 +164,32 @@
                    continue;
                }
                
                // 创建消息
                SysMessage message = new SysMessage();
                message.setMessageType("PUSH");
                message.setMessageTitle("任务推送");
                message.setMessageContent("您有新的任务，请及时处理");
                message.setTaskId(event.getTaskId());
                message.setTaskCode(event.getTaskCode());
                message.setReceiverId(assigneeId);
                message.setReceiverName(assignee.getNickName());
                message.setSenderId(event.getAssignerId());
                message.setSenderName(event.getAssignerName() != null ? event.getAssignerName() : "系统");
                message.setIsRead("0");
                message.setCreateTime(DateUtils.getNowDate());
                message.setDelFlag("0");
                // 创建通知任务（带防重）
                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() : "系统");
                
                // 保存消息
                sysMessageMapper.insertSysMessage(message);
                log.info("任务分配消息已保存，消息ID：{}，接收人：{}", message.getMessageId(), assignee.getNickName());
                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) {
@@ -130,6 +198,43 @@
    }

    /**
     * 构建通知内容
     */
    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 任务状态变更事件