// 全局任务超时服务
|
import http from '../api/http';
|
|
// 任务超时服务类
|
class TaskTimeoutService {
|
constructor() {
|
this.taskStatusMap = {}; // 存储任务状态开始时间
|
this.taskTimeoutMinutes = 10; // 任务超时时间，单位为分钟，调整为10分钟便于测试
|
this.checkTaskStatusTimer = null;
|
this.apiTaskData = []; // 存储通过API获取的任务数据
|
this.apiRefreshTimer = null; // API数据刷新定时器
|
this.apiRefreshInterval = 10000; // API数据刷新间隔，调整为10秒便于测试
|
}
|
|
// 初始化任务超时服务
|
init(app) {
|
// 设置定时器，每10秒检查一次，调整为便于测试的频率
|
this.checkTaskStatusTimer = setInterval(() => {
|
this.checkTaskStatus();
|
}, 10000);
|
|
// 设置API数据刷新定时器，每10秒刷新一次任务数据
|
this.apiRefreshTimer = setInterval(() => {
|
this.refreshTaskDataFromApi();
|
}, this.apiRefreshInterval);
|
|
// 初始刷新一次任务数据
|
this.refreshTaskDataFromApi();
|
|
// 保存定时器引用，方便后续清理
|
if (app && app.config) {
|
app.config.globalProperties.$global.taskTimeoutTimer = this.checkTaskStatusTimer;
|
app.config.globalProperties.$global.taskTimeoutApiTimer = this.apiRefreshTimer;
|
}
|
|
// 方便手动测试，将check方法挂载到window对象
|
window.testTaskTimeout = () => {
|
this.checkTaskStatus();
|
};
|
}
|
|
// 从API刷新任务数据
|
async refreshTaskDataFromApi() {
|
try {
|
// 构建查询参数，获取所有任务，不限制状态，在后续处理中过滤
|
const requestData = {
|
Page: 1,
|
Rows: 9999,
|
Filter: [],
|
Wheres: '',
|
Sort: 'CreateDate',
|
Order: 'desc'
|
};
|
|
// 调用API获取任务数据
|
const apiData = await http.post('/api/Task/GetPageData', requestData);
|
|
if (apiData && apiData.rows) {
|
this.apiTaskData = apiData.rows;
|
} else {
|
this.apiTaskData = [];
|
}
|
} catch (error) {
|
console.error('从API获取任务数据失败:', error);
|
this.apiTaskData = [];
|
}
|
}
|
|
// 检查任务状态
|
checkTaskStatus() {
|
// 直接使用从API获取的数据
|
const allTaskData = this.apiTaskData || [];
|
|
// 去重，确保每个任务只处理一次
|
const uniqueTaskData = [];
|
const taskNumSet = new Set();
|
|
allTaskData.forEach(task => {
|
if (task && task.taskNum && !taskNumSet.has(task.taskNum)) {
|
uniqueTaskData.push(task);
|
taskNumSet.add(task.taskNum);
|
}
|
});
|
|
if (uniqueTaskData.length === 0) {
|
return;
|
}
|
|
const now = new Date();
|
|
// 获取全局对象
|
const globalObj = window.$global || {};
|
|
// 处理消息删除逻辑，重置对应任务的定时器
|
const deletedMessages = [...(globalObj.messageDeleted || [])];
|
|
if (deletedMessages.length > 0) {
|
// 清空已处理的删除消息列表，避免重复处理
|
globalObj.messageDeleted = [];
|
|
// 遍历被删除的消息ID，重置对应任务的定时器
|
deletedMessages.forEach(deletedId => {
|
// 不需要从messageList中查找，因为消息已经被删除
|
// 直接处理任务状态重置
|
// 这里不做任何操作，因为消息删除是用户主动行为
|
// 我们只需要清空messageDeleted数组即可
|
});
|
}
|
|
// 获取当前所有任务号和状态
|
const currentTaskStatuses = {};
|
uniqueTaskData.forEach(task => {
|
currentTaskStatuses[task.taskNum] = task.taskStatus;
|
});
|
|
// 检查任务状态
|
uniqueTaskData.forEach(task => {
|
if (task.taskStatus === 210) {
|
// 堆垛机执行中状态
|
if (!this.taskStatusMap[task.taskNum]) {
|
this.taskStatusMap[task.taskNum] = now;
|
} else {
|
// 计算持续时间（分钟）
|
const duration = (now - this.taskStatusMap[task.taskNum]) / 60000;
|
if (duration >= this.taskTimeoutMinutes) {
|
this.sendTaskWarningMessage(task, duration);
|
delete this.taskStatusMap[task.taskNum];
|
}
|
}
|
} else {
|
// 任务状态已改变，清除记录
|
delete this.taskStatusMap[task.taskNum];
|
}
|
});
|
|
// 清除已解决的任务超时消息
|
this.clearResolvedTaskMessages(currentTaskStatuses);
|
}
|
|
// 清除已解决的任务超时消息
|
clearResolvedTaskMessages(currentTaskStatuses) {
|
// 获取全局对象
|
const globalObj = window.$global || {};
|
|
// 获取全局消息列表
|
const globalMessageList = [...(globalObj.messageList || [])];
|
|
// 找出需要清除的任务超时消息
|
const taskTimeoutMessages = globalMessageList.filter(msg => msg.businessType === 'task_timeout');
|
|
// 遍历所有任务超时消息
|
taskTimeoutMessages.forEach(msg => {
|
const taskNum = msg.taskNum;
|
// 检查条件：
|
// 1. 任务不在当前任务列表中（已完成或被移除）
|
// 2. 任务在当前任务列表中，但状态已不再是堆垛机执行中
|
if (taskNum && (!currentTaskStatuses[taskNum] || currentTaskStatuses[taskNum] !== 210)) {
|
// 任务已完成或状态已改变，清除该消息
|
// 但要确保只在消息仍然存在时才删除
|
if (globalObj.messageList && Array.isArray(globalObj.messageList)) {
|
const index = globalObj.messageList.findIndex(m => m.id === msg.id);
|
if (index !== -1) {
|
globalObj.messageList.splice(index, 1);
|
}
|
}
|
}
|
});
|
}
|
|
|
|
// 发送任务警告消息
|
sendTaskWarningMessage(task, duration) {
|
// 创建唯一的消息ID
|
const messageId = Date.now() + Math.random().toString(36).substr(2, 9);
|
|
// 创建警告消息
|
const warningMessage = {
|
id: messageId,
|
title: '任务异常警告',
|
message: `任务号 ${task.taskNum} 已在堆垛机执行中状态超过${Math.round(duration)}分钟，请及时处理！`,
|
type: 'warning',
|
businessType: 'task_timeout',
|
taskNum: task.taskNum,
|
createTime: new Date().toLocaleString()
|
};
|
|
// 获取全局对象
|
const globalObj = window.$global || {};
|
|
// 检查是否已经存在相同的任务超时警告
|
const globalMessageList = globalObj.messageList || [];
|
|
const hasExistingWarning = globalMessageList.some(msg =>
|
msg.businessType === 'task_timeout' && msg.taskNum === task.taskNum
|
);
|
|
if (hasExistingWarning) return;
|
|
// 发送消息到全局消息列表
|
try {
|
if (globalObj.messageList) {
|
globalObj.messageList.push(warningMessage);
|
}
|
} catch (error) {
|
// 出错时使用浏览器原生alert作为最终备选
|
try {
|
alert(`任务异常警告: 任务号 ${task.taskNum} 已在堆垛机执行中状态超过${Math.round(duration)}分钟，请及时处理！`);
|
} catch (e) {
|
// 忽略所有错误
|
}
|
}
|
}
|
|
// 手动检查任务状态（用于外部调用）
|
manualCheckTaskStatus() {
|
this.checkTaskStatus();
|
}
|
|
// 设置任务超时时间
|
setTaskTimeoutMinutes(minutes) {
|
if (typeof minutes === 'number' && minutes > 0) {
|
this.taskTimeoutMinutes = minutes;
|
}
|
}
|
|
// 获取当前任务超时时间
|
getTaskTimeoutMinutes() {
|
return this.taskTimeoutMinutes;
|
}
|
|
// 清理资源
|
cleanup() {
|
if (this.checkTaskStatusTimer) {
|
clearInterval(this.checkTaskStatusTimer);
|
this.checkTaskStatusTimer = null;
|
}
|
|
if (this.apiRefreshTimer) {
|
clearInterval(this.apiRefreshTimer);
|
this.apiRefreshTimer = null;
|
}
|
|
this.taskStatusMap = {};
|
this.apiTaskData = [];
|
delete window.testTaskTimeout;
|
}
|
}
|
|
// 创建单例实例
|
const taskTimeoutService = new TaskTimeoutService();
|
|
export default taskTimeoutService;
|
