@lambo-design/workflow-approve 1.0.0-beta.77 → 1.0.0-beta.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambo-design/workflow-approve",
-  "version": "1.0.0-beta.77",
+  "version": "1.0.0-beta.79",
   "description": "",
   "main": "index.js",
   "author": "lambo",
@@ -13,7 +13,7 @@
     "axios": "^0.24.0",
     "axios-cache-plugin": "^0.1.0",
     "@lambo-design/core": "^4.7.1-beta.167",
-    "@lambo-design/shared": "^1.0.0-beta.279"
+    "@lambo-design/shared": "^1.0.0-beta.280"
   },
   "dependencies": {
     "bpmn-js": "^7.3.1",

package/src/components/history.vue

@@ -404,54 +404,110 @@ export default {
       if (this.sortBy === 'time') {
         // 按时间排序：将所有审批记录平铺，按时间排序，然后重新分组
         let allRecords = [];
-        let pendingGroups = []; // 待审批的分组
 
         // 平铺所有审批记录
         this.itemList.forEach(nodeGroup => {
           // 确保 nodeGroup 是数组
           if (Array.isArray(nodeGroup)) {
-            // 检查这个节点组是否包含待审批的记录
-            let hasPendingRecords = nodeGroup.some(record => this.isPendingAudit(record));
-
-            if (hasPendingRecords) {
-              // 如果包含待审批记录，整个节点组作为一个待审批组
-              if (nodeGroup.length > 0) {
-                // 使用第一个记录的时间作为排序时间，或使用当前时间
-                let sortTime = this.getRecordTime(nodeGroup[0]) || new Date().toISOString();
-                pendingGroups.push({
-                  records: nodeGroup,
+            nodeGroup.forEach(record => {
+              if (record && typeof record === 'object') {
+                // 获取准确的时间用于排序
+                let sortTime = this.getRecordTime(record);
+                let timestamp = new Date(sortTime).getTime();
+
+                // 验证时间戳是否有效
+                if (isNaN(timestamp)) {
+                  console.warn('时间戳解析失败:', {
+                    record: record,
+                    sortTime: sortTime,
+                    auditDate: record.auditDate,
+                    createTime: record.createTime
+                  });
+                  // 使用当前时间作为后备
+                  timestamp = new Date().getTime();
+                  sortTime = new Date().toISOString();
+                }
+
+                allRecords.push({
+                  record: record,
                   sortTime: sortTime,
-                  isPending: true
+                  timestamp: timestamp
                 });
               }
-            } else {
-              // 如果是已审批记录，按个人分组
-              nodeGroup.forEach(record => {
-                if (record && typeof record === 'object') {
-                  record.sortTime = this.getRecordTime(record);
-                  allRecords.push({
-                    records: [record],
-                    sortTime: record.sortTime,
-                    isPending: false
-                  });
-                }
-              });
-            }
+            });
           }
         });
 
-        // 合并所有记录（已审批+待审批）
-        let allGroups = [...allRecords, ...pendingGroups];
+        // 调试信息：打印排序前的数据
+        console.log('排序前的记录:', allRecords.map(item => ({
+          auditResult: item.record.auditResult,
+          auditDate: item.record.auditDate,
+          createTime: item.record.createTime,
+          sortTime: item.sortTime,
+          timestamp: item.timestamp,
+          date: new Date(item.timestamp)
+        })));
+
+        // 按时间戳排序（倒序，最新在前）
+        allRecords.sort((a, b) => {
+          // 使用时间戳进行排序，避免字符串比较问题
+          return b.timestamp - a.timestamp;
+        });
 
-        // 按时间排序（倒序，最新在前）
-        allGroups.sort((a, b) => {
-          const timeA = new Date(a.sortTime).getTime();
-          const timeB = new Date(b.sortTime).getTime();
-          return timeB - timeA; // 倒序排列
+        // 调试信息：打印排序后的数据
+        console.log('排序后的记录:', allRecords.map(item => ({
+          auditResult: item.record.auditResult,
+          auditDate: item.record.auditDate,
+          createTime: item.record.createTime,
+          sortTime: item.sortTime,
+          timestamp: item.timestamp,
+          date: new Date(item.timestamp)
+        })));
+
+        // 重新分组：相同状态且时间相近的记录分为一组
+        let groupedRecords = [];
+        let currentGroup = [];
+
+        allRecords.forEach((item, index) => {
+          if (currentGroup.length === 0) {
+            // 第一个记录，直接加入
+            currentGroup.push(item.record);
+          } else {
+            // 检查是否应该与当前组合并
+            let shouldGroup = false;
+
+            // 如果都是待审批状态且是同一个节点，则分为一组
+            if (this.isPendingAudit(item.record) &&
+                currentGroup.some(r => this.isPendingAudit(r) && r.taskName === item.record.taskName)) {
+              shouldGroup = true;
+            }
+            // 如果都是已审批状态且时间非常接近（同一天或几分钟内），可以考虑分组，但通常按个人分组
+            else if (!this.isPendingAudit(item.record) &&
+                currentGroup.length === 1 &&
+                !this.isPendingAudit(currentGroup[0]) &&
+                currentGroup[0].taskName === item.record.taskName) {
+              // 暂时不分组已审批记录，每个人一组
+              shouldGroup = false;
+            }
+
+            if (shouldGroup) {
+              currentGroup.push(item.record);
+            } else {
+              // 开始新的分组
+              if (currentGroup.length > 0) {
+                groupedRecords.push([...currentGroup]);
+              }
+              currentGroup = [item.record];
+            }
+          }
         });
 
-        // 返回记录数组
-        return allGroups.map(group => group.records);
+        // 添加最后一组
+        if (currentGroup.length > 0) {
+          groupedRecords.push(currentGroup);
+        }
+
+        return groupedRecords;
       } else {
         // 按节点分组：保持原有的节点分组结构
         return this.itemList;
@@ -615,10 +671,55 @@ export default {
     },
     getRecordTime(item) {
       // 获取记录的时间用于排序
-      if (item.auditResult) {
-        return item.auditDate || item.createTime;
+      let timeStr = '';
+
+      if (item.auditResult && item.auditResult !== '') {
+        // 已审批记录：优先使用审批时间
+        timeStr = item.auditDate || item.createTime;
+      } else {
+        // 待审批记录：使用创建时间
+        timeStr = item.createTime || item.auditDate;
+      }
+
+      // 如果没有时间，使用当前时间
+      if (!timeStr) {
+        return new Date().toISOString();
+      }
+
+      // 标准化时间格式
+      try {
+        // 处理中国标准时间格式 "YYYY-MM-DD HH:mm:ss"
+        if (typeof timeStr === 'string') {
+          // 移除可能的多余空格
+          timeStr = timeStr.trim();
+
+          // 检查是否是标准格式 "YYYY-MM-DD HH:mm:ss"
+          if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(timeStr)) {
+            // 直接使用 new Date() 解析，这样会按本地时区处理
+            let date = new Date(timeStr);
+            if (!isNaN(date.getTime())) {
+              return date.toISOString();
+            }
+          }
+
+          // 如果包含 T 但没有时区信息，添加本地时区
+          if (timeStr.includes('T') && !timeStr.includes('Z') && !timeStr.includes('+')) {
+            timeStr += 'Z';
+          }
+        }
+
+        // 验证时间是否有效
+        let date = new Date(timeStr);
+        if (isNaN(date.getTime())) {
+          console.warn('Invalid date format:', timeStr);
+          return new Date().toISOString();
+        }
+
+        return date.toISOString();
+      } catch (error) {
+        console.warn('Error parsing date:', timeStr, error);
+        return new Date().toISOString();
       }
-      return item.createTime || item.auditDate;
     },
     getTimelineDotColor(auditResult) {
       if (this.auditPassStatus.includes(auditResult)) {

package/src/portrait.vue

@@ -309,7 +309,7 @@
                 </FormItem>
               </Col>
             </Row>
-            <FormItem label="处理方式：">
+            <FormItem v-if="item.remainDay != 0 || item.remainTime != 0 || item.inAdvanceDay != 0 || item.inAdvanceTime != 0" label="处理方式：">
               <Select v-model="item.processing" style="width:200px" placeholder="自动同意">
                 <Option v-for="item in handleTypeList" :value="item.value" :key="item.value">
                   {{ item.label }}