chore: Änderungen commited

backend/utils/hardware_integration.py

@@ -185,6 +185,23 @@ class TapoController:
                     
         return False
     
+    def clear_cache(self) -> bool:
+        """
+        Leert alle Caches des TapoControllers
+        
+        Returns:
+            bool: True wenn erfolgreich
+        """
+        try:
+            # Hier können Cache-Daten geleert werden falls vorhanden
+            # Aktuell verwendet TapoController keinen expliziten Cache,
+            # aber diese Methode wird für Konsistenz bereitgestellt
+            tapo_logger.debug("TapoController Cache geleert (keine Cache-Daten vorhanden)")
+            return True
+        except Exception as e:
+            tapo_logger.error(f"Fehler beim Leeren des TapoController Cache: {str(e)}")
+            return False
+    
     def turn_off(self, ip: str, username: str = None, password: str = None, printer_id: int = None) -> bool:
         """
         Schaltet eine TP-Link Tapo P110-Steckdose aus

backend/utils/tapo_status_manager.py

@@ -54,30 +54,37 @@ class TapoStatusManager:
         
         logger.info("TapoStatusManager mit Session-Caching initialisiert")
     
-    def get_printer_status(self, printer_id: int) -> Dict[str, any]:
+    def get_printer_status(self, printer_id: int, force_refresh: bool = False) -> Dict[str, any]:
         """
         Gibt den aktuellen Status eines Druckers zurück
         
         Args:
             printer_id: ID des Druckers
+            force_refresh: True = Cache umgehen und echten Netzwerk-Test durchführen
             
         Returns:
             Dict mit Status-Informationen
         """
-        with self._cache_lock:
-            # Aus Cache holen wenn vorhanden und aktuell
-            if printer_id in self._status_cache:
-                cache_data = self._status_cache[printer_id]
-                if self._is_cache_valid(printer_id):
-                    return cache_data
+        if not force_refresh:
+            with self._cache_lock:
+                # Aus Cache holen wenn vorhanden und aktuell
+                if printer_id in self._status_cache:
+                    cache_data = self._status_cache[printer_id]
+                    if self._is_cache_valid(printer_id):
+                        return cache_data
         
-        # Neuen Status abrufen
+        # Neuen Status abrufen (mit Cache-Invalidierung bei force_refresh)
+        if force_refresh:
+            self.invalidate_cache(printer_id)
         return self._fetch_printer_status(printer_id)
     
-    def get_all_printer_status(self) -> List[Dict[str, any]]:
+    def get_all_printer_status(self, force_refresh: bool = False) -> List[Dict[str, any]]:
         """
         Gibt den Status aller Drucker zurück
         
+        Args:
+            force_refresh: True = Cache für alle Drucker umgehen
+        
         Returns:
             Liste mit Status-Informationen aller Drucker
         """
@@ -89,7 +96,7 @@ class TapoStatusManager:
             
             # Status für jeden Drucker abrufen
             for printer in printers:
-                status = self.get_printer_status(printer.id)
+                status = self.get_printer_status(printer.id, force_refresh=force_refresh)
                 status_list.append(status)
             
             db_session.close()
@@ -660,6 +667,104 @@ class TapoStatusManager:
             logger.error(f"Fehler beim Bereinigen des Session-Cache: {str(e)}")
             return 0
     
+    def invalidate_cache(self, printer_id: int = None) -> bool:
+        """
+        Invalidiert Cache für spezifischen Drucker oder alle
+        
+        Args:
+            printer_id: Optional - spezifischer Drucker, None = alle Drucker
+            
+        Returns:
+            bool: True wenn erfolgreich
+        """
+        try:
+            with self._cache_lock:
+                if printer_id is not None:
+                    # Spezifischen Drucker-Cache löschen
+                    self._status_cache.pop(printer_id, None)
+                    self._last_check.pop(printer_id, None)
+                    logger.debug(f"Cache für Drucker {printer_id} invalidiert")
+                else:
+                    # Alle Caches löschen
+                    self._status_cache.clear()
+                    self._last_check.clear()
+                    logger.info("Kompletter Status-Cache invalidiert")
+                
+                return True
+                
+        except Exception as e:
+            logger.error(f"Fehler beim Invalidieren des Cache: {str(e)}")
+            return False
+    
+    def invalidate_all_caches(self) -> bool:
+        """
+        Invalidiert alle Cache-Systeme (Status + Session)
+        Verwendet bei Netzwerkwechseln oder Force-Refresh
+        
+        Returns:
+            bool: True wenn erfolgreich
+        """
+        try:
+            # Status-Cache invalidieren
+            self.invalidate_cache()
+            
+            # Session-Cache invalidieren
+            self.clear_session_cache()
+            
+            logger.info("Alle Caches invalidiert (Status + Session)")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Fehler beim Invalidieren aller Caches: {str(e)}")
+            return False
+    
+    def force_network_refresh(self) -> Dict[str, any]:
+        """
+        Forciert komplette Netzwerk-Neuprüfung aller Drucker
+        Invalidiert alle Caches und führt echte Netzwerk-Tests durch
+        
+        Returns:
+            Dict mit Refresh-Ergebnissen
+        """
+        try:
+            logger.info("Starte Force-Network-Refresh für alle Drucker")
+            
+            # Alle Caches invalidieren
+            self.invalidate_all_caches()
+            
+            # Tapo-Controller Cache leeren falls vorhanden
+            try:
+                from utils.hardware_integration import tapo_controller
+                if tapo_controller and hasattr(tapo_controller, 'clear_cache'):
+                    tapo_controller.clear_cache()
+                    logger.debug("Tapo-Controller Cache geleert")
+            except Exception as e:
+                logger.warning(f"Tapo-Controller Cache konnte nicht geleert werden: {str(e)}")
+            
+            # Frischen Status für alle Drucker abrufen
+            fresh_status = self.get_all_printer_status(force_refresh=True)
+            
+            # Ergebnisse zusammenfassen
+            results = {
+                "success": True,
+                "timestamp": datetime.now().isoformat(),
+                "printers_refreshed": len(fresh_status),
+                "printers": fresh_status,
+                "message": f"Netzwerk-Status für {len(fresh_status)} Drucker erfolgreich aktualisiert"
+            }
+            
+            logger.info(f"Force-Network-Refresh abgeschlossen: {len(fresh_status)} Drucker aktualisiert")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Fehler beim Force-Network-Refresh: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e),
+                "timestamp": datetime.now().isoformat(),
+                "message": "Fehler beim Aktualisieren der Netzwerk-Status"
+            }
+    
     def _get_status_color(self, status: str) -> str:
         """Gibt die Farbe für einen Status zurück"""
         colors = {