Work connnectivity update page

BlocksScreen/lib/moonrakerComm.py

@@ -734,13 +734,16 @@ def update_status(self, refresh: bool = False) -> bool:
 
     @QtCore.pyqtSlot(name="update-refresh")
     @QtCore.pyqtSlot(str, name="update-refresh")
-    def refresh_update_status(self, name: str = "") -> bool:
+    def refresh_update_status(self, name: str = None) -> bool:
         """Refresh packages state"""
-        if not isinstance(name, str) or not name:
-            return False
-        return self._ws.send_request(
-            method="machine.update.refresh", params={"name": name}
-        )
+        if isinstance(name, str):
+            return self._ws.send_request(
+                method="machine.update.refresh", params={"name": name}
+            )
+        else:
+            return self._ws.send_request(
+                method="machine.update.refresh",
+            )
 
     @QtCore.pyqtSlot(name="update-full")
     def full_update(self) -> bool:

BlocksScreen/lib/panels/mainWindow.py

@@ -153,6 +153,7 @@ def __init__(self):
         )
         self.controlPanel.disable_popups.connect(self.popup_toggle)
         self.on_update_message.connect(self.utilitiesPanel.on_update_message)
+        self.on_update_message.connect(self.conn_window.on_update_message)
         self.ui.extruder_temp_display.display_format = "upper_downer"
         self.ui.bed_temp_display.display_format = "upper_downer"
         if self.config.has_section("server"):

BlocksScreen/lib/panels/widgets/connectionPage.py

@@ -1,8 +1,10 @@
 import logging
+import typing
 
 from events import KlippyDisconnected, KlippyReady, KlippyShutdown
 from lib.moonrakerComm import MoonWebSocket
 from lib.ui.connectionWindow_ui import Ui_ConnectivityForm
+from lib.panels.widgets.updatePage import UpdatePage
 from PyQt6 import QtCore, QtWidgets
 
 
@@ -13,11 +15,33 @@ class ConnectionPage(QtWidgets.QFrame):
     reboot_clicked = QtCore.pyqtSignal(name="reboot_clicked")
     restart_klipper_clicked = QtCore.pyqtSignal(name="restart_klipper_clicked")
     firmware_restart_clicked = QtCore.pyqtSignal(name="firmware_restart_clicked")
+    on_update_message: typing.ClassVar[QtCore.pyqtSignal] = QtCore.pyqtSignal(
+        dict, name="handle-update-message"
+    )
 
     def __init__(self, parent: QtWidgets.QWidget, ws: MoonWebSocket, /):
         super().__init__(parent)
+        self.setMinimumSize(QtCore.QSize(800, 480))
+        self.stack = QtWidgets.QStackedLayout(self)
+        self.connection_widget = QtWidgets.QFrame(self)
         self.panel = Ui_ConnectivityForm()
-        self.panel.setupUi(self)
+        self.panel.setupUi(self.connection_widget)
+        self.up = UpdatePage(self)
+        self.stack.addWidget(self.connection_widget)
+        self.stack.addWidget(self.up)
+
+        self.stack.currentChanged.connect(self.up.build_model_list)
+
+        self.stack.setCurrentWidget(self.connection_widget)
+
+        self.up.update_back_btn.clicked.connect(
+            lambda: {self.stack.setCurrentWidget(self.connection_widget)}
+        )
+        self.panel.updatepageButton.clicked.connect(
+            lambda: 
+                self.stack.setCurrentWidget(self.up)
+        )
+
         self.ws = ws
         self._moonraker_status: str = "disconnected"
         self._klippy_state: str = "closed"
@@ -46,6 +70,22 @@ def __init__(self, parent: QtWidgets.QWidget, ws: MoonWebSocket, /):
         self.ws.klippy_connected_signal.connect(self.on_klippy_connected)
         self.ws.klippy_state_signal.connect(self.on_klippy_state)
 
+        self.on_update_message.connect(self.up.handle_update_message)
+        self.up.request_full_update.connect(self.ws.api.full_update)
+        self.up.request_recover_repo[str].connect(self.ws.api.recover_corrupt_repo)
+        self.up.request_recover_repo[str, bool].connect(
+            self.ws.api.recover_corrupt_repo
+        )
+        self.up.request_refresh_update.connect(self.ws.api.refresh_update_status)
+        self.up.request_refresh_update[str].connect(self.ws.api.refresh_update_status)
+
+        self.up.request_rollback_update.connect(self.ws.api.rollback_update)
+        self.up.request_update_client.connect(self.ws.api.update_client)
+        self.up.request_update_klipper.connect(self.ws.api.update_klipper)
+        self.up.request_update_moonraker.connect(self.ws.api.update_moonraker)
+        self.up.request_update_status.connect(self.ws.api.update_status)
+        self.up.request_update_system.connect(self.ws.api.update_system)
+
     def show_panel(self, reason: str | None = None):
         """Show widget"""
         self.show()
@@ -55,9 +95,16 @@ def show_panel(self, reason: str | None = None):
         self.text_update()
         return False
 
+    def showEvent(self, a0: QtCore.QEvent|None):
+        """Handle show event"""
+        self.ws.api.refresh_update_status()
+        return super().showEvent(a0)
+
     @QtCore.pyqtSlot(bool, name="on_klippy_connected")
     def on_klippy_connection(self, connected: bool):
         """Handle klippy connection state"""
+        self.dot_timer.stop()
+
         self._klippy_connection = connected
         if not connected:
             self.panel.connectionTextBox.setText("Klipper Disconnected")
@@ -69,6 +116,7 @@ def on_klippy_connection(self, connected: bool):
     @QtCore.pyqtSlot(str, name="on_klippy_state")
     def on_klippy_state(self, state: str):
         """Handle klippy state changes"""
+        self.dot_timer.stop()
         if state == "error":
             self.panel.connectionTextBox.setText("Klipper Connection Error")
             if not self.isVisible():
@@ -87,7 +135,6 @@ def on_klippy_state(self, state: str):
             self.panel.connectionTextBox.setText("Klipper Startup")
         elif state == "ready":
             self.panel.connectionTextBox.setText("Klipper Ready")
-            self.hide()
 
     @QtCore.pyqtSlot(int, name="on_websocket_connecting")
     @QtCore.pyqtSlot(str, name="on_websocket_connecting")
@@ -98,21 +145,22 @@ def on_websocket_connecting(self, attempt: int):
     @QtCore.pyqtSlot(name="on_websocket_connection_achieved")
     def on_websocket_connection_achieved(self):
         """Handle websocket connected state"""
+        self.dot_timer.stop()
         self.panel.connectionTextBox.setText("Moonraker Connected\n Klippy not ready")
-        self.hide()
 
-    @QtCore.pyqtSlot(name="on_websocket_connection_lost")
+    @QtCore.pyqtSlot(name="on_websocket_connection_lzost")
     def on_websocket_connection_lost(self):
         """Handle websocket connection lost state"""
         if not self.isVisible():
             self.show()
+        self.dot_timer.stop()
         self.text_update(text="Websocket lost")
 
     def text_update(self, text: int | str | None = None):
         """Update widget text"""
         if self.state == "shutdown" and self.message is not None:
             return False
-
+        self.dot_timer.stop()
         logging.debug(f"[ConnectionWindowPanel] text_update: {text}")
         if text == "wb lost":
             self.panel.connectionTextBox.setText("Moonraker connection lost")
@@ -125,41 +173,34 @@ def text_update(self, text: int | str | None = None):
             return True
         if isinstance(text, str):
             self.panel.connectionTextBox.setText(
-                f"""
-                Connection to Moonraker unavailable\nTry again by reconnecting or \nrestarting klipper\n{text}
-                """
+                f"""Connection to Moonraker unavailable\nTry again by reconnecting or \nrestarting klipper\n{text}"""
             )
             return True
         if isinstance(text, int):
             # * Websocket connection messages
+
+            self.base_text = f"Attempting to reconnect to Moonraker.\n\nConnection try number: {text}"
+
             if text == 0:
-                self.dot_timer.stop()
                 self.panel.connectionTextBox.setText(
-                    "Unable to Connect to Moonraker.\n\nTry again"
+                    "Connection to Moonraker timeout \n \n please retry"
                 )
-                return False
+                return
+            self.dot_count = 0
 
-            if text == 1:
-                if self.dot_timer.isActive():
-                    self.dot_timer.stop()
-                    return
-                self.dot_timer.start()
-
-            self.text2 = f"Attempting to reconnect to Moonraker.\n\nConnection try number: {text}"
+            self.dot_timer.start()
+            self._add_dot()
 
         return False
 
     def _add_dot(self):
-        if self.state == "shutdown" and self.message is not None:
+        """Add one dot per second (max 3)."""
+        self.dot_count += 1
+        if self.dot_count > 3:
             self.dot_timer.stop()
-            return False
-
-        if self.dot_count > 2:
-            self.dot_count = 1
-        else:
-            self.dot_count += 1
+            return
         dots = "." * self.dot_count + " " * (3 - self.dot_count)
-        self.panel.connectionTextBox.setText(f"{self.text2}{dots}")
+        self.panel.connectionTextBox.setText(f"{self.base_text}{dots}")
 
     @QtCore.pyqtSlot(str, str, name="webhooks_update")
     def webhook_update(self, state: str, message: str):
@@ -171,16 +212,19 @@ def webhook_update(self, state: str, message: str):
     def eventFilter(self, object: QtCore.QObject, event: QtCore.QEvent) -> bool:
         """Re-implemented method, filter events"""
         if event.type() == KlippyDisconnected.type():
+            self.dot_timer.stop()
             if not self.isVisible():
                 self.panel.connectionTextBox.setText("Klippy Disconnected")
                 self.show()
 
         elif event.type() == KlippyReady.type():
+            self.dot_timer.stop()
             self.panel.connectionTextBox.setText("Klippy Ready")
             self.hide()
             return False
 
         elif event.type() == KlippyShutdown.type():
+            self.dot_timer.stop()
             if not self.isVisible():
                 self.panel.connectionTextBox.setText(f"{self.message}")
                 self.show()