refactor: optimize backend module

domain/backup/__init__.py

@@ -0,0 +1 @@
+

domain/backup/api.py

@@ -0,0 +1,30 @@
+import datetime
+
+from fastapi import APIRouter, Depends, File, Request, UploadFile
+from fastapi.responses import JSONResponse
+
+from domain.audit import AuditAction, audit
+from domain.auth.service import get_current_active_user
+from domain.backup.service import BackupService
+
+router = APIRouter(
+    prefix="/api/backup",
+    tags=["Backup & Restore"],
+    dependencies=[Depends(get_current_active_user)],
+)
+
+
+@router.get("/export", summary="导出全站数据")
+@audit(action=AuditAction.DOWNLOAD, description="导出备份")
+async def export_backup(request: Request):
+    data = await BackupService.export_data()
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    headers = {"Content-Disposition": f"attachment; filename=foxel_backup_{timestamp}.json"}
+    return JSONResponse(content=data.model_dump(), headers=headers)
+
+
+@router.post("/import", summary="导入数据")
+@audit(action=AuditAction.UPLOAD, description="导入备份")
+async def import_backup(request: Request, file: UploadFile = File(...)):
+    await BackupService.import_from_bytes(file.filename, await file.read())
+    return {"message": "数据导入成功。"}

domain/backup/service.py

@@ -0,0 +1,91 @@
+import json
+
+from fastapi import HTTPException
+from tortoise.transactions import in_transaction
+
+from domain.backup.types import BackupData
+from domain.config.service import VERSION
+from models.database import (
+    AutomationTask,
+    Configuration,
+    ShareLink,
+    StorageAdapter,
+    UserAccount,
+)
+
+
+class BackupService:
+    @classmethod
+    async def export_data(cls) -> BackupData:
+        async with in_transaction():
+            adapters = await StorageAdapter.all().values()
+            users = await UserAccount.all().values()
+            tasks = await AutomationTask.all().values()
+            shares = await ShareLink.all().values()
+            configs = await Configuration.all().values()
+
+        for share in shares:
+            share["created_at"] = (
+                share["created_at"].isoformat() if share.get("created_at") else None
+            )
+            share["expires_at"] = (
+                share["expires_at"].isoformat() if share.get("expires_at") else None
+            )
+
+        return BackupData(
+            version=VERSION,
+            storage_adapters=list(adapters),
+            user_accounts=list(users),
+            automation_tasks=list(tasks),
+            share_links=list(shares),
+            configurations=list(configs),
+        )
+
+    @classmethod
+    async def import_from_bytes(cls, filename: str, content: bytes) -> None:
+        if not filename.endswith(".json"):
+            raise HTTPException(status_code=400, detail="无效的文件类型, 请上传 .json 文件")
+        try:
+            raw_data = json.loads(content)
+        except Exception:
+            raise HTTPException(status_code=400, detail="无法解析JSON文件")
+        await cls.import_data(BackupData(**raw_data))
+
+    @classmethod
+    async def import_data(cls, payload: BackupData) -> None:
+        async with in_transaction() as conn:
+            await ShareLink.all().using_db(conn).delete()
+            await AutomationTask.all().using_db(conn).delete()
+            await StorageAdapter.all().using_db(conn).delete()
+            await UserAccount.all().using_db(conn).delete()
+            await Configuration.all().using_db(conn).delete()
+
+            if payload.configurations:
+                await Configuration.bulk_create(
+                    [Configuration(**config) for config in payload.configurations],
+                    using_db=conn,
+                )
+
+            if payload.user_accounts:
+                await UserAccount.bulk_create(
+                    [UserAccount(**user) for user in payload.user_accounts],
+                    using_db=conn,
+                )
+
+            if payload.storage_adapters:
+                await StorageAdapter.bulk_create(
+                    [StorageAdapter(**adapter) for adapter in payload.storage_adapters],
+                    using_db=conn,
+                )
+
+            if payload.automation_tasks:
+                await AutomationTask.bulk_create(
+                    [AutomationTask(**task) for task in payload.automation_tasks],
+                    using_db=conn,
+                )
+
+            if payload.share_links:
+                await ShareLink.bulk_create(
+                    [ShareLink(**share) for share in payload.share_links],
+                    using_db=conn,
+                )

domain/backup/types.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class BackupData(BaseModel):
+    version: str | None = None
+    storage_adapters: list[dict[str, Any]] = Field(default_factory=list)
+    user_accounts: list[dict[str, Any]] = Field(default_factory=list)
+    automation_tasks: list[dict[str, Any]] = Field(default_factory=list)
+    share_links: list[dict[str, Any]] = Field(default_factory=list)
+    configurations: list[dict[str, Any]] = Field(default_factory=list)