🎉 Refactored backend structure: Removed unused files including app_cleaned.py, admin_api.py, admin.py, user.py, and others. Updated settings.local.json to include additional Bash commands. Enhanced admin templates for better navigation and functionality. Improved logging and error handling across various modules.

backend/utils/backup_manager.py

@@ -1,25 +1,177 @@
 """
-Backup Manager - Datensicherungsverwaltung
-Minimal implementation to resolve import dependencies.
+Backup Manager - Wrapper für DatabaseBackupManager
+Kompatibilitäts-Wrapper für die vollständige Backup-Implementierung in database_utils.py
 """
 
 from utils.logging_config import get_logger
+from utils.database_utils import DatabaseBackupManager
 
 backup_logger = get_logger("backup")
 
 class BackupManager:
-    """Minimale BackupManager-Implementierung"""
+    """
+    Kompatibilitäts-Wrapper für DatabaseBackupManager.
+    Stellt die ursprüngliche API bereit, nutzt aber die vollständige Implementierung.
+    """
     
     def __init__(self):
-        self.enabled = False
-        backup_logger.info("BackupManager initialisiert (minimal implementation)")
+        """Initialisiert den BackupManager mit vollständiger Funktionalität."""
+        try:
+            self._db_backup_manager = DatabaseBackupManager()
+            self.enabled = True
+            backup_logger.info("BackupManager erfolgreich initialisiert mit vollständiger Funktionalität")
+        except Exception as e:
+            backup_logger.error(f"Fehler bei BackupManager-Initialisierung: {e}")
+            self._db_backup_manager = None
+            self.enabled = False
     
     def create_backup(self, backup_type="manual"):
-        """Erstellt ein Backup (Placeholder)"""
-        backup_logger.info(f"Backup-Erstellung angefordert: {backup_type}")
-        return {"success": False, "message": "Backup-Funktionalität nicht implementiert"}
+        """
+        Erstellt ein Backup der Datenbank.
+        
+        Args:
+            backup_type (str): Typ des Backups (manual, automatic, emergency)
+            
+        Returns:
+            dict: Ergebnis der Backup-Operation mit success/error Status
+        """
+        if not self.enabled or not self._db_backup_manager:
+            backup_logger.warning("BackupManager nicht verfügbar - Backup-Erstellung fehlgeschlagen")
+            return {
+                "success": False, 
+                "message": "Backup-System nicht verfügbar",
+                "error": "BackupManager nicht initialisiert"
+            }
+        
+        try:
+            backup_logger.info(f"Starte Backup-Erstellung: {backup_type}")
+            
+            # Nutze die vollständige DatabaseBackupManager-Implementation
+            backup_path = self._db_backup_manager.create_backup(compress=True)
+            
+            backup_logger.info(f"Backup erfolgreich erstellt: {backup_path}")
+            return {
+                "success": True,
+                "message": f"Backup erfolgreich erstellt: {backup_type}",
+                "backup_path": backup_path,
+                "backup_type": backup_type
+            }
+            
+        except Exception as e:
+            backup_logger.error(f"Fehler bei Backup-Erstellung ({backup_type}): {str(e)}")
+            return {
+                "success": False,
+                "message": f"Backup-Erstellung fehlgeschlagen: {str(e)}",
+                "error": str(e),
+                "backup_type": backup_type
+            }
     
     def restore_backup(self, backup_path):
-        """Stellt ein Backup wieder her (Placeholder)"""
-        backup_logger.info(f"Backup-Wiederherstellung angefordert: {backup_path}")
-        return {"success": False, "message": "Restore-Funktionalität nicht implementiert"} 
+        """
+        Stellt ein Backup wieder her.
+        
+        Args:
+            backup_path (str): Pfad zur Backup-Datei
+            
+        Returns:
+            dict: Ergebnis der Restore-Operation
+        """
+        if not self.enabled or not self._db_backup_manager:
+            backup_logger.warning("BackupManager nicht verfügbar - Restore fehlgeschlagen")
+            return {
+                "success": False,
+                "message": "Backup-System nicht verfügbar",
+                "error": "BackupManager nicht initialisiert"
+            }
+        
+        try:
+            backup_logger.info(f"Starte Backup-Wiederherstellung: {backup_path}")
+            
+            # Nutze die vollständige DatabaseBackupManager-Implementation
+            success = self._db_backup_manager.restore_backup(backup_path)
+            
+            if success:
+                backup_logger.info(f"Backup erfolgreich wiederhergestellt: {backup_path}")
+                return {
+                    "success": True,
+                    "message": f"Backup erfolgreich wiederhergestellt",
+                    "backup_path": backup_path
+                }
+            else:
+                backup_logger.error(f"Backup-Wiederherstellung fehlgeschlagen: {backup_path}")
+                return {
+                    "success": False,
+                    "message": "Backup-Wiederherstellung fehlgeschlagen",
+                    "backup_path": backup_path
+                }
+                
+        except Exception as e:
+            backup_logger.error(f"Fehler bei Backup-Wiederherstellung ({backup_path}): {str(e)}")
+            return {
+                "success": False,
+                "message": f"Restore fehlgeschlagen: {str(e)}",
+                "error": str(e),
+                "backup_path": backup_path
+            }
+    
+    def get_backup_list(self):
+        """
+        Holt eine Liste aller verfügbaren Backups.
+        
+        Returns:
+            dict: Liste der verfügbaren Backups
+        """
+        if not self.enabled or not self._db_backup_manager:
+            return {
+                "success": False,
+                "message": "Backup-System nicht verfügbar",
+                "backups": []
+            }
+        
+        try:
+            backups = self._db_backup_manager.list_backups()
+            return {
+                "success": True,
+                "message": f"{len(backups)} Backups gefunden",
+                "backups": backups
+            }
+        except Exception as e:
+            backup_logger.error(f"Fehler beim Abrufen der Backup-Liste: {str(e)}")
+            return {
+                "success": False,
+                "message": f"Fehler beim Abrufen der Backups: {str(e)}",
+                "backups": []
+            }
+    
+    def cleanup_old_backups(self, keep_count=10):
+        """
+        Räumt alte Backups auf und behält nur die neuesten.
+        
+        Args:
+            keep_count (int): Anzahl der zu behaltenden Backups
+            
+        Returns:
+            dict: Ergebnis der Cleanup-Operation
+        """
+        if not self.enabled or not self._db_backup_manager:
+            return {
+                "success": False,
+                "message": "Backup-System nicht verfügbar"
+            }
+        
+        try:
+            removed_count = self._db_backup_manager.cleanup_old_backups(keep_count)
+            backup_logger.info(f"Backup-Cleanup abgeschlossen: {removed_count} alte Backups entfernt")
+            return {
+                "success": True,
+                "message": f"{removed_count} alte Backups entfernt",
+                "removed_count": removed_count,
+                "kept_count": keep_count
+            }
+        except Exception as e:
+            backup_logger.error(f"Fehler beim Backup-Cleanup: {str(e)}")
+            return {
+                "success": False,
+                "message": f"Cleanup fehlgeschlagen: {str(e)}",
+                "error": str(e)
+            }