backup

src/server/api/backup.py

@@ -0,0 +1,304 @@
+"""Backup management API endpoints."""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from src.server.services.backup_service import BackupService, get_backup_service
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/backup", tags=["backup"])
+
+
+class BackupCreateRequest(BaseModel):
+    """Request to create a backup."""
+
+    backup_type: str  # 'config', 'database', 'full'
+    description: Optional[str] = None
+
+
+class BackupResponse(BaseModel):
+    """Response for backup creation."""
+
+    success: bool
+    message: str
+    backup_name: Optional[str] = None
+    size_bytes: Optional[int] = None
+
+
+class BackupListResponse(BaseModel):
+    """Response for listing backups."""
+
+    backups: List[Dict[str, Any]]
+    total_count: int
+
+
+class RestoreRequest(BaseModel):
+    """Request to restore from backup."""
+
+    backup_name: str
+
+
+class RestoreResponse(BaseModel):
+    """Response for restore operation."""
+
+    success: bool
+    message: str
+
+
+def get_backup_service_dep() -> BackupService:
+    """Dependency to get backup service."""
+    return get_backup_service()
+
+
+@router.post("/create", response_model=BackupResponse)
+async def create_backup(
+    request: BackupCreateRequest,
+    backup_service: BackupService = Depends(get_backup_service_dep),
+) -> BackupResponse:
+    """Create a new backup.
+
+    Args:
+        request: Backup creation request.
+        backup_service: Backup service dependency.
+
+    Returns:
+        BackupResponse: Result of backup creation.
+    """
+    try:
+        backup_info = None
+
+        if request.backup_type == "config":
+            backup_info = backup_service.backup_configuration(
+                request.description or ""
+            )
+        elif request.backup_type == "database":
+            backup_info = backup_service.backup_database(
+                request.description or ""
+            )
+        elif request.backup_type == "full":
+            backup_info = backup_service.backup_full(
+                request.description or ""
+            )
+        else:
+            raise ValueError(f"Invalid backup type: {request.backup_type}")
+
+        if backup_info is None:
+            return BackupResponse(
+                success=False,
+                message=f"Failed to create {request.backup_type} backup",
+            )
+
+        return BackupResponse(
+            success=True,
+            message=(
+                f"{request.backup_type.capitalize()} backup created "
+                "successfully"
+            ),
+            backup_name=backup_info.name,
+            size_bytes=backup_info.size_bytes,
+        )
+    except Exception as e:
+        logger.error(f"Failed to create backup: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/list", response_model=BackupListResponse)
+async def list_backups(
+    backup_type: Optional[str] = None,
+    backup_service: BackupService = Depends(get_backup_service_dep),
+) -> BackupListResponse:
+    """List available backups.
+
+    Args:
+        backup_type: Optional filter by backup type.
+        backup_service: Backup service dependency.
+
+    Returns:
+        BackupListResponse: List of available backups.
+    """
+    try:
+        backups = backup_service.list_backups(backup_type)
+        return BackupListResponse(backups=backups, total_count=len(backups))
+    except Exception as e:
+        logger.error(f"Failed to list backups: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/restore", response_model=RestoreResponse)
+async def restore_backup(
+    request: RestoreRequest,
+    backup_type: Optional[str] = None,
+    backup_service: BackupService = Depends(get_backup_service_dep),
+) -> RestoreResponse:
+    """Restore from a backup.
+
+    Args:
+        request: Restore request.
+        backup_type: Type of backup to restore.
+        backup_service: Backup service dependency.
+
+    Returns:
+        RestoreResponse: Result of restore operation.
+    """
+    try:
+        # Determine backup type from filename if not provided
+        if backup_type is None:
+            if "config" in request.backup_name:
+                backup_type = "config"
+            elif "database" in request.backup_name:
+                backup_type = "database"
+            else:
+                backup_type = "full"
+
+        success = False
+
+        if backup_type == "config":
+            success = backup_service.restore_configuration(
+                request.backup_name
+            )
+        elif backup_type == "database":
+            success = backup_service.restore_database(request.backup_name)
+        else:
+            raise ValueError(f"Cannot restore backup type: {backup_type}")
+
+        if not success:
+            return RestoreResponse(
+                success=False,
+                message=f"Failed to restore {backup_type} backup",
+            )
+
+        return RestoreResponse(
+            success=True,
+            message=f"{backup_type.capitalize()} backup restored successfully",
+        )
+    except Exception as e:
+        logger.error(f"Failed to restore backup: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/{backup_name}", response_model=Dict[str, Any])
+async def delete_backup(
+    backup_name: str,
+    backup_service: BackupService = Depends(get_backup_service_dep),
+) -> Dict[str, Any]:
+    """Delete a backup.
+
+    Args:
+        backup_name: Name of the backup to delete.
+        backup_service: Backup service dependency.
+
+    Returns:
+        dict: Result of delete operation.
+    """
+    try:
+        success = backup_service.delete_backup(backup_name)
+
+        if not success:
+            raise HTTPException(status_code=404, detail="Backup not found")
+
+        return {"success": True, "message": "Backup deleted successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to delete backup: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/cleanup", response_model=Dict[str, Any])
+async def cleanup_backups(
+    max_backups: int = 10,
+    backup_type: Optional[str] = None,
+    backup_service: BackupService = Depends(get_backup_service_dep),
+) -> Dict[str, Any]:
+    """Clean up old backups.
+
+    Args:
+        max_backups: Maximum number of backups to keep.
+        backup_type: Optional filter by backup type.
+        backup_service: Backup service dependency.
+
+    Returns:
+        dict: Number of backups deleted.
+    """
+    try:
+        deleted_count = backup_service.cleanup_old_backups(
+            max_backups, backup_type
+        )
+        return {
+            "success": True,
+            "message": "Cleanup completed",
+            "deleted_count": deleted_count,
+        }
+    except Exception as e:
+        logger.error(f"Failed to cleanup backups: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/export/anime", response_model=Dict[str, Any])
+async def export_anime_data(
+    backup_service: BackupService = Depends(get_backup_service_dep),
+) -> Dict[str, Any]:
+    """Export anime library data.
+
+    Args:
+        backup_service: Backup service dependency.
+
+    Returns:
+        dict: Result of export operation.
+    """
+    try:
+        output_file = "data/backups/anime_export.json"
+        success = backup_service.export_anime_data(output_file)
+
+        if not success:
+            raise HTTPException(
+                status_code=500, detail="Failed to export anime data"
+            )
+
+        return {
+            "success": True,
+            "message": "Anime data exported successfully",
+            "export_file": output_file,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to export anime data: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/import/anime", response_model=Dict[str, Any])
+async def import_anime_data(
+    import_file: str,
+    backup_service: BackupService = Depends(get_backup_service_dep),
+) -> Dict[str, Any]:
+    """Import anime library data.
+
+    Args:
+        import_file: Path to import file.
+        backup_service: Backup service dependency.
+
+    Returns:
+        dict: Result of import operation.
+    """
+    try:
+        success = backup_service.import_anime_data(import_file)
+
+        if not success:
+            raise HTTPException(
+                status_code=400, detail="Failed to import anime data"
+            )
+
+        return {
+            "success": True,
+            "message": "Anime data imported successfully",
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to import anime data: {e}")
+        raise HTTPException(status_code=500, detail=str(e))