feat(ALMainWindow): 引入对新增定时器任务状态 - 执行失败的处理支持 (#18ae949)

同时，为了统一消息处理，我们将 ALMainWorkers 中的原信号
槽处理的消息逻辑更改为使用继承的 MsgBase 类的 showTrace 方法

src/gui/ALMainWindow.py

@@ -38,6 +38,7 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
 
     timerTaskIsRunning = Signal(dict)
     timerTaskIsExecuted = Signal(dict)
+    timerTaskIsError = Signal(dict)
 
     def __init__(
         self
@@ -84,6 +85,7 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
         self.__alTimerTaskWidget = ALTimerTaskWidget(self, self.__config_paths["timer_task"])
         self.timerTaskIsRunning.connect(self.__alTimerTaskWidget.onTimerTaskIsRunning)
         self.timerTaskIsExecuted.connect(self.__alTimerTaskWidget.onTimerTaskIsExecuted)
+        self.timerTaskIsError.connect(self.__alTimerTaskWidget.onTimerTaskIsError)
         self.__alTimerTaskWidget.timerTaskIsReady.connect(self.onTimerTaskIsReady)
         self.__alTimerTaskWidget.timerTaskWidgetClosed.connect(self.onTimerTaskWidgetClosed)
         self.__alTimerTaskWidget.setWindowFlags(Qt.WindowType.Window|Qt.WindowType.WindowCloseButtonHint)
@@ -245,8 +247,6 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
                     self.__config_paths
                 )
                 self.__current_timer_task_thread.finishedSignal_TimerWorker.connect(self.onTimerTaskFinished)
-                self.__current_timer_task_thread.showTraceSignal.connect(self.showTrace)
-                self.__current_timer_task_thread.showMsgSignal.connect(self.showMsg)
                 self.__current_timer_task_thread.start()
         except queue.Empty:
             self.__is_running_timer_task = False
@@ -293,7 +293,6 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
         except queue.Empty:
             pass
 
-
     @Slot()
     def onTimerTaskWidgetClosed(
         self
@@ -301,7 +300,6 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
 
         self.TimerTaskWidgetButton.setEnabled(True)
 
-
     @Slot(dict)
     def onConfigWidgetClosed(
         self,
@@ -326,13 +324,12 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
     @Slot(dict)
     def onTimerTaskFinished(
         self,
+        is_error: bool,
         timer_task: dict
     ):
 
         self.__current_timer_task_thread.wait(1000)
         self.__current_timer_task_thread.finishedSignal_TimerWorker.disconnect(self.onTimerTaskFinished)
-        self.__current_timer_task_thread.showTraceSignal.disconnect(self.showTrace)
-        self.__current_timer_task_thread.showMsgSignal.disconnect(self.showMsg)
         self.__current_timer_task_thread.deleteLater()
         self.__current_timer_task_thread = None
         self.setControlButtons(True, False, True)
@@ -341,12 +338,17 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
         timer_task["executed"] = True
         self.TrayIcon.showMessage(
             "定时任务 - AutoLibrary",
-            f"\n定时任务 '{timer_task['name']}' 执行完成",
+            f"\n定时任务 '{timer_task['name']}' 执行{'失败' if is_error else '完成'}",
             QSystemTrayIcon.MessageIcon.Information,
             1000
         )
-        self.showTrace(f"定时任务 {timer_task['name']} 执行完成, uuid: {timer_task['task_uuid']}")
-        self.timerTaskIsExecuted.emit(timer_task)
+        self.showTrace(
+            f"定时任务 {timer_task['name']} 执行{'失败' if is_error else '完成'}, uuid: {timer_task['task_uuid']}"
+        )
+        if not is_error:
+            self.timerTaskIsExecuted.emit(timer_task)
+        else:
+            self.timerTaskIsError.emit(timer_task)
 
     @Slot()
     def onTimerTaskWidgetButtonClicked(
@@ -387,8 +389,7 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
                 self.__config_paths
             )
             self.__auto_lib_thread.finishedSignal.connect(self.onStopButtonClicked)
-            self.__auto_lib_thread.showMsgSignal.connect(self.showMsg)
-            self.__auto_lib_thread.showTraceSignal.connect(self.showTrace)
+            self.__auto_lib_thread.finishedWithErrorSignal.connect(self.onStopButtonClicked)
         self.__auto_lib_thread.start()
 
     @Slot()
@@ -400,9 +401,8 @@ class ALMainWindow(QMainWindow, Ui_ALMainWindow):
             self.showTrace("正在停止操作......")
             self.__auto_lib_thread.wait(2000)
             self.showTrace("操作已停止")
-            self.__auto_lib_thread.showMsgSignal.disconnect(self.showMsg)
-            self.__auto_lib_thread.showTraceSignal.disconnect(self.showTrace)
             self.__auto_lib_thread.finishedSignal.disconnect(self.onStopButtonClicked)
+            self.__auto_lib_thread.finishedWithErrorSignal.disconnect(self.onStopButtonClicked)
             self.__auto_lib_thread.deleteLater()
             self.__auto_lib_thread = None
         self.setControlButtons(True, False, True)

src/gui/ALMainWorkers.py

@@ -12,18 +12,18 @@ import time
 import queue
 
 from PySide6.QtCore import (
-    Signal, QThread
+    Slot, Signal, QThread
 )
 
+from base.MsgBase import MsgBase
 from operators.AutoLib import AutoLib
 from utils.ConfigReader import ConfigReader
 
 
-class AutoLibWorker(QThread):
+class AutoLibWorker(QThread, MsgBase):
 
     finishedSignal = Signal()
-    showTraceSignal = Signal(str)
-    showMsgSignal = Signal(str)
+    finishedWithErrorSignal = Signal()
 
     def __init__(
         self,
@@ -32,10 +32,8 @@ class AutoLibWorker(QThread):
         config_paths: dict
     ):
 
-        super().__init__()
+        super().__init__(input_queue = input_queue, output_queue = output_queue)
 
-        self.__input_queue = input_queue
-        self.__output_queue = output_queue
         self.__config_paths = config_paths
 
 
@@ -45,6 +43,10 @@ class AutoLibWorker(QThread):
 
         current_time = time.strftime("%H:%M", time.localtime())
         if current_time >= "23:30" or current_time <= "07:30":
+            self._showTrace(
+                "当前时间不在图书馆开放时间内\n"\
+                "    请在 07:30 - 23:30 之间尝试"
+            )
             return False
         return True
 
@@ -56,9 +58,7 @@ class AutoLibWorker(QThread):
         if not all(
             os.path.exists(path) for path in self.__config_paths.values()
         ):
-            self.showTraceSignal.emit(
-                "配置文件路径不存在, 请检查配置文件路径是否正确。"
-            )
+            self._showTrace("配置文件路径不存在, 请检查配置文件路径是否正确。")
             return False
         return True
 
@@ -67,25 +67,24 @@ class AutoLibWorker(QThread):
         self
     ) -> bool:
 
-        self.showTraceSignal.emit(
+        self._showTrace(
             f"正在加载配置文件, 运行配置文件路径: {self.__config_paths["run"]}"
         )
         self.__run_config = ConfigReader(
             self.__config_paths["run"]
         ).getConfigs()
-        self.showTraceSignal.emit(
+        self._showTrace(
             f"正在加载配置文件, 用户配置文件路径: {self.__config_paths["user"]}"
         )
         self.__user_config = ConfigReader(
             self.__config_paths["user"]
         ).getConfigs()
         if self.__run_config is None or self.__user_config is None:
-            self.showTraceSignal.emit(
-                "配置文件加载失败, 请检查配置文件是否正确。"
-            )
+            self._showTrace("配置文件加载失败, 请检查配置文件是否正确")
+            self._showTrace("配置文件加载失败, 请检查配置文件是否正确")
             return False
         if not self.__user_config.get("groups"):
-            self.showTraceSignal.emit(
+            self._showTrace(
                 "用户配置文件中无有效任务组, 请检查用户配置文件是否正确"
             )
             return False
@@ -99,55 +98,39 @@ class AutoLibWorker(QThread):
         auto_lib = None
         try:
             if not self.checkTimeAvailable():
-                self.showTraceSignal.emit(
-                    "当前时间不在图书馆开放时间内\n"\
-                    "    请在 07:30 - 23:30 之间尝试"
-                )
                 return
             if not self.checkConfigPaths():
                 return
-            self.showTraceSignal.emit("AutoLibrary 开始运行")
+            self._showTrace("AutoLibrary 开始运行")
             if not self.loadConfigs():
-                return
+                raise Exception("配置文件加载失败")
             auto_lib = AutoLib(
-                self.__input_queue,
-                self.__output_queue,
+                self._input_queue,
+                self._output_queue,
                 self.__run_config
             )
-            if auto_lib is None:
-                self.showTraceSignal.emit(
-                    "AutoLibrary 初始化失败"
-                )
-                return
             groups = self.__user_config.get("groups")
             for group in groups:
-                time.sleep(0.2) # wait for the message queue to be empty
                 if not group["enabled"]:
-                    self.showTraceSignal.emit(
-                        f"任务组 {group["name"]} 已跳过"
-                    )
+                    self._showTrace(f"任务组 {group["name"]} 已跳过")
                     continue
-                self.showTraceSignal.emit(
-                    f"正在运行任务组 {group["name"]}"
-                )
+                self._showTrace(f"正在运行任务组 {group["name"]}")
                 auto_lib.run(
                     { "users": group.get("users", []) }
                 )
         except Exception as e:
-            self.showTraceSignal.emit(
-                f"AutoLibrary 运行时发生异常 : {e}"
-            )
-        finally:
-            if auto_lib:
-                auto_lib.close()
-                time.sleep(0.2) # wait for the message queue to be empty
-            self.showTraceSignal.emit("AutoLibrary 运行结束")
-            self.finishedSignal.emit()
+            self._showTrace(f"AutoLibrary 运行时发生异常 : {e}")
+            self.finishedWithErrorSignal.emit()
+            return
+        if auto_lib:
+            auto_lib.close()
+        self._showTrace("AutoLibrary 运行结束")
+        self.finishedSignal.emit()
 
 
 class TimerTaskWorker(AutoLibWorker):
 
-    finishedSignal_TimerWorker = Signal(dict)
+    finishedSignal_TimerWorker = Signal(bool, dict)
 
     def __init__(
         self,
@@ -160,16 +143,28 @@ class TimerTaskWorker(AutoLibWorker):
         super().__init__(input_queue, output_queue, config_paths)
 
         self.__timer_task = timer_task
+        self.finishedSignal.connect(self.onTimerTaskIsFinished)
+        self.finishedWithErrorSignal.connect(self.onTimerTaskIsError)
 
     def run(
         self
     ):
 
-        self.showTraceSignal.emit(
-            f"定时任务 {self.__timer_task['name']} 开始运行"
-        )
+        self._showTrace(f"定时任务 {self.__timer_task['name']} 开始运行")
         super().run()
-        self.showTraceSignal.emit(
-            f"定时任务 {self.__timer_task['name']} 运行结束"
-        )
-        self.finishedSignal_TimerWorker.emit(self.__timer_task)
+
+    @Slot(dict)
+    def onTimerTaskIsError(
+        self
+    ):
+
+        self._showTrace(f"定时任务 {self.__timer_task['name']} 运行时发生异常")
+        self.finishedSignal_TimerWorker.emit(True, self.__timer_task)
+
+    @Slot(dict)
+    def onTimerTaskIsFinished(
+        self
+    ):
+
+        self._showTrace(f"定时任务 {self.__timer_task['name']} 运行结束")
+        self.finishedSignal_TimerWorker.emit(False, self.__timer_task)