增加任务异常提示和空托数量预警

liulijun

2026-03-05 98a69d51981ee6a49136024c8b005f134d3313cd

 ÏîÄ¿´úÂë/WMS/WMSClient/src/extension/taskinfo/task.js

@@ -1,10 +1,10 @@

//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码

import gridHeader from './extend/relocationTask.vue'
let extension = {
    components: {
      //查询界面扩展组件
      gridHeader: '',
      gridHeader: gridHeader,
      gridBody: '',
      gridFooter: '',
      //新建、编辑弹出框扩展组件
@@ -50,7 +50,7 @@
                if (rows.length > 1) return this.$error("请选择一条数据!");
                var param = rows[0].taskNum;
                this.http
                .post("api/Task/TaskCompleted?taskNum="+param, "数据处理中...")
                .post("api/Task/TaskCompleted?taskNum="+param, "")
                .then((x) => {
                    if (x.status) {
                    this.$Message.success('任务手动完成');
@@ -62,6 +62,217 @@
              });
        }
      }
      let ResendTaskBtn = this.buttons.find(x => x.value == 'ResendTask');
      if (ResendTaskBtn) {
        ResendTaskBtn.onClick = function () {
          this.$confirm("是否确认重新下发任务","重新下发任务警告",{
              confirmButtonText: "确定",
              cancelButtonText: "取消",
              type: "warning",
              center: true,
              }).then(() => {
                let rows = this.$refs.table.getSelected();
                if (rows.length == 0) return this.$error("请选择数据!");
                if (rows.length > 1) return this.$error("请选择一条数据!");
                var param = rows[0].taskNum;
                this.http
                .post("api/Task/ResendTask?taskNum="+param, "")
                .then((x) => {
                    if (x.status) {
                    this.$Message.success('任务重新下发');
                    this.refresh();
                  } else {
                    return this.$error(x.message);
                  }
                });
              });
        }
      }
      let relocationBtn = this.buttons.find(x => x.value == 'Relocation');
      if (relocationBtn) {
        relocationBtn.onClick = function () {
          this.$refs.gridHeader.open();
        }
      }
      
      // åˆå§‹åŒ–任务状态检查定时器
      this.taskStatusMap = {}; // å­˜å‚¨ä»»åŠ¡çŠ¶æ€å¼€å§‹æ—¶é—´
      this.taskTimeoutMinutes = 1; // ä»»åŠ¡è¶…时时间，单位为分钟
      this.checkTaskStatusTimer = setInterval(() => {
        this.checkTaskStatus();
      }, 1000); // æ¯1秒检查一次，提高检查精度，减少延迟
      },
      
      // æ£€æŸ¥ä»»åŠ¡çŠ¶æ€
      checkTaskStatus() {
        // èŽ·å–当前所有任务数据
        const taskData = this.$refs.table?.rowData || this.$refs.table?.tableData || [];
        const now = new Date();
        
        // èŽ·å–全局对象和store
        const globalObj = this.$global || window.$global || {};
        const store = this.$store || window.$store;
        
        // å¤„理消息删除逻辑，重置对应任务的定时器
        const deletedMessages = globalObj.messageDeleted || [];
        
        if (deletedMessages.length > 0) {
          const storeMessageList = store?.state?.messageList || [];
          
          // éåŽ†è¢«åˆ é™¤çš„消息ID，重置对应任务的定时器
          deletedMessages.forEach(deletedId => {
            const deletedMessage = storeMessageList.find(msg => msg.id === deletedId);
            if (deletedMessage?.businessType === 'task_timeout' && deletedMessage.taskNum && this.taskStatusMap[deletedMessage.taskNum]) {
              this.taskStatusMap[deletedMessage.taskNum] = now;
            }
          });
          
          // æ¸…空已处理的删除消息列表
          globalObj.messageDeleted = [];
        }
        
        // èŽ·å–当前所有任务号和状态
        const currentTaskStatuses = {};
        taskData.forEach(task => {
          currentTaskStatuses[task.taskNum] = task.taskStatus;
        });
        
        // æ£€æŸ¥ä»»åŠ¡çŠ¶æ€
        taskData.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) {
        // èŽ·å–全局对象和store
        const globalObj = this.$global || window.$global || {};
        const store = this.$store || window.$store;
        
        // èŽ·å–所有消息列表
        const globalMessageList = globalObj.messageList || [];
        const storeMessageList = store?.state?.messageList || [];
        
        // åˆå¹¶æ‰€æœ‰æ¶ˆæ¯ï¼Œæ‰¾å‡ºéœ€è¦æ¸…除的任务超时消息
        const allMessages = [...globalMessageList, ...storeMessageList];
        const taskTimeoutMessages = allMessages.filter(msg => msg.businessType === 'task_timeout');
        
        // éåŽ†æ‰€æœ‰ä»»åŠ¡è¶…时消息
        taskTimeoutMessages.forEach(msg => {
          const taskNum = msg.taskNum;
          // æ£€æŸ¥è¯¥ä»»åŠ¡æ˜¯å¦ä»ç„¶å¤„于堆垛机执行中状态
          if (currentTaskStatuses[taskNum] && currentTaskStatuses[taskNum] !== 210) {
            // ä»»åŠ¡å·²ä¸å†å¤„于堆垛机执行中状态，清除该消息
            this.handleDeleteTaskMessage(msg);
          }
        });
      },
      
      // å¤„理删除单个任务消息
      handleDeleteTaskMessage(message) {
        // èŽ·å–全局对象和store
        const globalObj = this.$global || window.$global || {};
        const store = this.$store || window.$store;
        
        // ä»Žå…¨å±€æ¶ˆæ¯åˆ—表中删除该消息
        if (globalObj.messageList) {
          const index = globalObj.messageList.findIndex(msg => msg.id === message.id);
          if (index !== -1) {
            globalObj.messageList.splice(index, 1);
          }
        }
        
        // ä»Žstore中删除该消息
        if (store) {
          store.commit('removeMessage', message.id);
        }
      },
      
      // å‘送任务警告消息
      sendTaskWarningMessage(task, duration) {
        // åˆ›å»ºè­¦å‘Šæ¶ˆæ¯
        const warningMessage = {
          id: Date.now(),
          title: '任务异常警告',
          message: `任务号 ${task.taskNum} å·²åœ¨å †åž›æœºæ‰§è¡Œä¸­çŠ¶æ€è¶…过${Math.round(duration)}分钟，请及时处理！`,
          type: 'warning',
          businessType: 'task_timeout',
          taskNum: task.taskNum,
          createTime: new Date().toLocaleString()
        };
        
        // èŽ·å–全局对象和store，检查是否存在相同的警告消息
        const globalObj = this.$global || window.$global || {};
        const store = this.$store || window.$store;
        const globalMessageList = globalObj.messageList || [];
        const storeMessageList = store?.state?.messageList || [];
        
        // æ£€æŸ¥æ˜¯å¦å·²ç»å­˜åœ¨ç›¸åŒçš„任务超时警告
        const hasExistingWarning = [...globalMessageList, ...storeMessageList].some(msg => 
          msg.businessType === 'task_timeout' && msg.taskNum === task.taskNum
        );
        
        if (hasExistingWarning) return;
        
        // å‘送消息到消息列表
        try {
          // æ·»åŠ æ¶ˆæ¯åˆ°store
          const $store = this.$store || window.$store;
          if ($store) {
            $store.commit('addMessage', warningMessage);
          }
          
          // æ·»åŠ æ¶ˆæ¯åˆ°å…¨å±€æ¶ˆæ¯åˆ—表
          if (globalObj.messageList) {
            globalObj.messageList.push(warningMessage);
          }
          
          // æ˜¾ç¤ºè­¦å‘Šå¯¹è¯æ¡†ï¼Œä¼˜å…ˆä½¿ç”¨$alert
          // const $global = this.$global || window.$global;
          // const alertOptions = {
          //   confirmButtonText: '确定',
          //   type: warningMessage.type,
          //   closeOnClickModal: false,
          //   closeOnPressEscape: false,
          //   showCancelButton: false
          // };
          
          // if (this.$alert || window.$alert) {
          //   const $alert = this.$alert || window.$alert;
          //   $alert(warningMessage.message, warningMessage.title, alertOptions);
          // } else if (this.$confirm || window.$confirm) {
          //   const $confirm = this.$confirm || window.$confirm;
          //   $confirm(warningMessage.message, warningMessage.title, alertOptions);
          // } else {
          //   // ä½¿ç”¨æµè§ˆå™¨åŽŸç”Ÿalert作为备选
          //   alert(`${warningMessage.title}: ${warningMessage.message}`);
          // }
        } catch (error) {
          // å‡ºé”™æ—¶ä½¿ç”¨æµè§ˆå™¨åŽŸç”Ÿalert作为最终备选
          try {
            alert(`任务异常警告: ä»»åŠ¡å· ${task.taskNum} å·²åœ¨å †åž›æœºæ‰§è¡Œä¸­çŠ¶æ€è¶…过${Math.round(duration)}分钟，请及时处理！`);
          } catch (e) {
            // å¿½ç•¥æ‰€æœ‰é”™è¯¯
          }
        }
      },
      onInited() {
        //框架初始化配置后
@@ -74,7 +285,7 @@
        return true;
      },
      searchAfter(result) {
        //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
        // æŸ¥è¯¢åŽï¼Œresult返回的查询数据,可以在显示到表格前处理表格的值
        return true;
      },
      addBefore(formData) {