refactor(queue): 重构队列数据获取逻辑

- 使用专门的定时项和队列项 API 获取数据，提高数据获取效率和准确性
- 优化数据处理逻辑，移除不必要的中间步骤
- 提高代码可读性和可维护性

frontend/src/components/queue/QueueItemManager.vue

@@ -182,7 +182,7 @@ const loadOptions = async () => {
 const addQueueItem = async () => {
   editingQueueItem.value = null
   Object.assign(form, {
-    script: '',
+    script: null,
   })
 
   // 确保在打开弹窗时加载脚本选项

frontend/src/views/Queue.vue

@@ -252,65 +252,54 @@ const refreshTimeSets = async () => {
   }
 
   try {
-    // 重新从API获取最新的队列数据
+    // 使用专门的定时项API获取数据
-    const response = await Service.getQueuesApiQueueGetPost({})
+    const response = await Service.getTimeSetApiQueueTimeGetPost({
+      queueId: activeQueueId.value,
+    })
+
     if (response.code !== 200) {
-      console.error('获取队列数据失败:', response)
+      console.error('获取定时项数据失败:', response)
       currentTimeSets.value = []
       return
     }
 
-    // 更新缓存的队列数据
+    const timeSets: any[] = []
-    currentQueueData.value = response.data
 
-    // 从最新的队列数据中获取定时项信息
+    // 处理定时项数据
-    if (response.data && response.data[activeQueueId.value]) {
+    if (response.index && Array.isArray(response.index)) {
-      const queueData = response.data[activeQueueId.value]
+      response.index.forEach((item: any) => {
-      const timeSets: any[] = []
+        try {
+          const timeSetId = item.uid
+          if (!timeSetId || !response.data || !response.data[timeSetId]) return
 
-      // 检查是否有TimeSet配置
+          const timeSetData = response.data[timeSetId]
-      if (queueData?.SubConfigsInfo?.TimeSet) {
+          if (timeSetData?.Info) {
-        const timeSetConfig = queueData.SubConfigsInfo.TimeSet
+            // 解析时间字符串 "HH:mm"
+            const originalTimeString = timeSetData.Info.Set || timeSetData.Info.Time || '00:00'
+            const [hours = 0, minutes = 0] = originalTimeString.split(':').map(Number)
 
-        // 遍历instances数组获取所有定时项ID
+            // 创建标准化的时间字符串
-        if (Array.isArray(timeSetConfig.instances)) {
+            const validHours = Math.max(0, Math.min(23, hours))
-          timeSetConfig.instances.forEach((instance: any) => {
+            const validMinutes = Math.max(0, Math.min(59, minutes))
-            try {
+            const timeString = `${validHours.toString().padStart(2, '0')}:${validMinutes.toString().padStart(2, '0')}`
-              const timeSetId = instance?.uid
-              if (!timeSetId) return
 
-              const timeSetData = timeSetConfig[timeSetId]
+            timeSets.push({
-              if (timeSetData?.Info) {
+              id: timeSetId,
-                // 解析时间字符串 "HH:mm" - 修复字段名
+              time: timeString,
-                const originalTimeString = timeSetData.Info.Set || timeSetData.Info.Time || '00:00'
+              enabled: Boolean(timeSetData.Info.Enabled),
-                const [hours = 0, minutes = 0] = originalTimeString.split(':').map(Number)
+              description: timeSetData.Info.Description || '',
-
+            })
-                // 创建标准化的时间字符串
+          }
-                const validHours = Math.max(0, Math.min(23, hours))
+        } catch (itemError) {
-                const validMinutes = Math.max(0, Math.min(59, minutes))
+          console.warn('解析单个定时项失败:', itemError, item)
-                const timeString = `${validHours.toString().padStart(2, '0')}:${validMinutes.toString().padStart(2, '0')}`
-
-                timeSets.push({
-                  id: timeSetId,
-                  time: timeString,
-                  enabled: Boolean(timeSetData.Info.Enabled),
-                  description: timeSetData.Info.Description || '',
-                })
-              }
-            } catch (itemError) {
-              console.warn('解析单个定时项失败:', itemError, instance)
-            }
-          })
         }
-      }
+      })
-
-      // 使用nextTick确保数据更新不会导致渲染问题
-      await nextTick()
-      currentTimeSets.value = [...timeSets]
-      console.log('刷新后的定时项数据:', timeSets) // 调试日志
-    } else {
-      currentTimeSets.value = []
     }
+
+    // 使用nextTick确保数据更新不会导致渲染问题
+    await nextTick()
+    currentTimeSets.value = [...timeSets]
+    console.log('刷新后的定时项数据:', timeSets) // 调试日志
   } catch (error) {
     console.error('刷新定时项列表失败:', error)
     currentTimeSets.value = []
@@ -326,54 +315,43 @@ const refreshQueueItems = async () => {
   }
 
   try {
-    // 重新从API获取最新的队列数据
+    // 使用专门的队列项API获取数据
-    const response = await Service.getQueuesApiQueueGetPost({})
+    const response = await Service.getItemApiQueueItemGetPost({
+      queueId: activeQueueId.value,
+    })
+
     if (response.code !== 200) {
-      console.error('获取队列数据失败:', response)
+      console.error('获取队列项数据失败:', response)
       currentQueueItems.value = []
       return
     }
 
-    // 更新缓存的队列数据
+    const queueItems: any[] = []
-    currentQueueData.value = response.data
 
-    // 从最新的队列数据中获取队列项信息
+    // 处理队列项数据
-    if (response.data && response.data[activeQueueId.value]) {
+    if (response.index && Array.isArray(response.index)) {
-      const queueData = response.data[activeQueueId.value]
+      response.index.forEach((item: any) => {
-      const queueItems: any[] = []
+        try {
+          const queueItemId = item.uid
+          if (!queueItemId || !response.data || !response.data[queueItemId]) return
 
-      // 检查是否有QueueItem配置
+          const queueItemData = response.data[queueItemId]
-      if (queueData?.SubConfigsInfo?.QueueItem) {
+          if (queueItemData?.Info) {
-        const queueItemConfig = queueData.SubConfigsInfo.QueueItem
+            queueItems.push({
-
+              id: queueItemId,
-        // 遍历instances数组获取所有队列项ID
+              script: queueItemData.Info.ScriptId || '',
-        if (Array.isArray(queueItemConfig.instances)) {
+            })
-          queueItemConfig.instances.forEach((instance: any) => {
+          }
-            try {
+        } catch (itemError) {
-              const queueItemId = instance?.uid
+          console.warn('解析单个队列项失败:', itemError, item)
-              if (!queueItemId) return
-
-              const queueItemData = queueItemConfig[queueItemId]
-              if (queueItemData?.Info) {
-                queueItems.push({
-                  id: queueItemId,
-                  script: queueItemData.Info.ScriptId || '',
-                })
-              }
-            } catch (itemError) {
-              console.warn('解析单个队列项失败:', itemError, instance)
-            }
-          })
         }
-      }
+      })
-
-      // 使用nextTick确保数据更新不会导致渲染问题
-      await nextTick()
-      currentQueueItems.value = [...queueItems]
-      console.log('刷新后的队列项数据:', queueItems) // 调试日志
-    } else {
-      currentQueueItems.value = []
     }
+
+    // 使用nextTick确保数据更新不会导致渲染问题
+    await nextTick()
+    currentQueueItems.value = [...queueItems]
+    console.log('刷新后的队列项数据:', queueItems) // 调试日志
   } catch (error) {
     console.error('刷新队列项列表失败:', error)
     currentQueueItems.value = []