feat: 任务增加统计、同步增加通知

wlzboy

3 天以前 40a8157440e3b906da8f52e07d939d78c3f4c313

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

@@ -1,11 +1,12 @@
package com.ruoyi.system.listener;

import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.config.WechatConfig;
import com.ruoyi.common.utils.DeptUtil;
import com.ruoyi.common.utils.LongUtil;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.event.TaskDispatchSyncEvent;
import com.ruoyi.system.service.ISysDeptService;
import com.ruoyi.system.service.ISysTaskAssigneeService;
import com.ruoyi.system.event.*;
import com.ruoyi.system.service.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@@ -14,16 +15,11 @@
import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
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.text.DateFormat;
import java.text.SimpleDateFormat;
@@ -62,6 +58,12 @@
    @Autowired
    private INotifyDispatchService notifyDispatchService;

    @Autowired
    private IQyWechatService qyWechatService;

    @Autowired
    private WechatConfig wechatConfig;

    /** 待准备状态 - 可以发送短信通知 */
    private static final String TASK_STATUS_PENDING = "PENDING";
    /** 待准备状态 - 可以发送短信通知 */
@@ -69,6 +71,9 @@

    @Autowired
    private ISysTaskAssigneeService taskAssigneeService;

    @Autowired
    private ITaskStatusPushService taskStatusPushService;

    @Async
    @EventListener
@@ -85,11 +90,30 @@
                   sendDispatchNotify(assigneeIds, task.getCreatorId(), event.getTaskId(),task.getShowTaskCode(), buildNotifyContent(task, emergency));
               }
            }
            syncDispatchActualStartTime(emergency, task);
            Long taskId= event.getTaskId();
            Long dispatchOrdId= event.getDispatchOrderId();
            Long serviceOrdId= event.getServiceOrderId();
            Integer oaUserID= event.getOaUserId();
            legacySystemSyncService.syncTaskAttachment(taskId, dispatchOrdId, serviceOrdId, oaUserID);

        }catch (Exception ex){
            log.error("处理任务派发同步事件失败", ex);
        }
    }

    private void syncDispatchActualStartTime(SysTaskEmergency emergency, SysTask task) {
        try {
            //这里也同步一下实际时间
            Long disatpchOrdId = emergency.getLegacyDispatchOrdId();
            Date actualTime = task.getActualStartTime();
            legacySystemSyncService.updateDispatchActualTime(disatpchOrdId, actualTime);
        }catch (Exception ex){
        log.error("同步实际时间失败", ex);
        }
    }


    /**
     * 监听任务创建事件
     * 
@@ -221,9 +245,35 @@
    }




    @Autowired
    private ILegacySystemSyncService legacySystemSyncService;

    @Async
    @EventListener
    public void handleTaskUpdateEvent(TaskUpdateEvent event){
        log.info("收到任务更新事件，任务ID：{}，任务编号：{}", event.getTaskId(), event.getTaskCode());
        legacySystemSyncService.resyncDispatchOrderToLegacy(event.getTaskId());

    }
    //在这里监听派发的事件
    @Async
    @EventListener
    public void handleTaskServiceOrderSyncEvent(TaskServiceOrderSyncEvent event) {
//        log.info("收到任务服务单同步事件，任务ID：{}，任务编号：{}，服务单ID：{}", event.getTaskId(), event.getTaskCode(), event.getServiceOrderId());
       Long dispatchOrderId= legacySystemSyncService.syncDispatchOrderToLegacy(event.getTaskId());
//       if(LongUtil.isNotEmpty(dispatchOrderId)){
//           //更新needsync为0
//
//       }
    }


    /**
     * 监听任务分配事件
     * 创建通知任务，由通知分发服务决定发送渠道
     * 同时直接发送企业微信通知
     * 
     * @param event 任务分配事件
     */
@@ -253,20 +303,61 @@
            Long creatorId = task.getCreatorId();
            String taskStatus = task.getTaskStatus();
            task.setEmergencyInfo(emergency);
            // 仅在待准备状态下发送通知
            if (!TASK_STATUS_PENDING.equals(taskStatus) && !TASK_STATUS_PREPARING.equals(taskStatus)) {
                log.info("任务状态({})非待准备状态，跳过通知，taskId={}", taskStatus, event.getTaskId());
                return;
            }

            
            // 构建通知内容
            String notifyContent = buildNotifyContent(task, emergency);
            this.sendDispatchNotify(event.getAssigneeIds(), creatorId, event.getTaskId(),task.getShowTaskCode(), notifyContent);
            
            // 直接发送企业微信通知给执行人员
            sendQyWechatNotifyToAssignees(event.getAssigneeIds(), creatorId, event.getTaskId(), notifyContent);
            
            // 同时走原有通知分发流程（站内消息等）
            // 仅在待准备状态下发送其他通知
            if (TASK_STATUS_PENDING.equals(taskStatus) || TASK_STATUS_PREPARING.equals(taskStatus)) {
                this.sendDispatchNotify(event.getAssigneeIds(), creatorId, event.getTaskId(), task.getShowTaskCode(), notifyContent);
            }

            
        } catch (Exception e) {
            log.error("处理任务分配事件失败", e);
        }
    }

    /**
     * 直接发送企业微信通知给执行人员
     */
    private void sendQyWechatNotifyToAssignees(List<Long> assigneeIds, Long creatorId, Long taskId, String content) {
        String appId = wechatConfig.getAppId();
        String pathPage = "/pagesTask/detail?id=" + taskId;
        int successCount = 0;
        
        for (Long assigneeId : assigneeIds) {
            // 排除创建人
            if (creatorId != null && creatorId.equals(assigneeId)) {
                log.debug("跳过创建人，不发送企业微信通知，userId={}", assigneeId);
                continue;
            }
            
            try {
                boolean success = qyWechatService.sendNotifyMessage(
                        assigneeId,
                        "转运单任务派单通知",
                        content,
                        appId,
                        pathPage
                );
                
                if (success) {
                    successCount++;
                    log.info("企业微信派单通知发送成功，taskId={}, userId={}", taskId, assigneeId);
                } else {
                    log.warn("企业微信派单通知发送失败，taskId={}, userId={}", taskId, assigneeId);
                }
            } catch (Exception e) {
                log.error("企业微信派单通知发送异常，taskId={}, userId={}", taskId, assigneeId, e);
            }
        }
        
        log.info("企业微信派单通知发送完成，taskId={}, 成功数量={}/{}", taskId, successCount, assigneeIds.size());
    }

    /**
@@ -392,6 +483,8 @@
        return content.toString();
    }

    @Autowired
    private ITaskStatusSyncService taskStatusSyncService;
    /**
     * 监听任务状态变更事件
     * 
@@ -400,26 +493,44 @@
    @Async
    @EventListener
    public void handleTaskStatusChangedEvent(TaskStatusChangedEvent event) {

        sendTaskStatusToLocal(event);
        sendTaskStatusToLegacy(event.getTaskId());

    }

    private void sendTaskStatusToLegacy(Long taskId) {
        try{
            log.info("任务状态同步到旧系统开始 taskId:{}",taskId);
           taskStatusPushService.pushTaskStatusToLegacy(taskId);
        }catch (Exception e){
            log.error("任务状态同步到旧系统异常 taskId:{}",taskId, e);
        }
    }



    private  void sendTaskStatusToLocal(TaskStatusChangedEvent event) {
        try {
            log.info("收到任务状态变更事件，任务ID：{}，旧状态：{}，新状态：{}", 
            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);
@@ -427,7 +538,7 @@
                    log.warn("找不到用户信息，用户ID：{}", receiverId);
                    continue;
                }
                

                // 创建消息
                SysMessage message = new SysMessage();
                message.setMessageType("STATUS");
@@ -442,13 +553,13 @@
                message.setIsRead("0");
                message.setCreateTime(DateUtils.getNowDate());
                message.setDelFlag("0");
                

                // 保存消息
                sysMessageMapper.insertSysMessage(message);
                log.info("任务状态变更消息已保存，消息ID：{}，新状态：{}，接收人：{}", 
                log.info("任务状态变更消息已保存，消息ID：{}，新状态：{}，接收人：{}",
                        message.getMessageId(), event.getNewStatus(), user.getNickName());
            }
            

        } catch (Exception e) {
            log.error("处理任务状态变更事件失败", e);
        }