From 9a23d89eb73b79b5a7623413fb9ff31fa24bd439 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Mon, 6 Jul 2026 03:13:37 +0800 Subject: [PATCH] =?UTF-8?q?S96=20=E5=88=A0=E9=99=A4=E5=BD=92=E6=A1=A3?= =?UTF-8?q?=E5=AE=89=E5=85=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/route_registry.py | 1 + backend/routes/image_routes.py | 26 +++++ backend/services/deletion_safety_service.py | 75 ++++++++++++ tests/test_deletion_safety_service.py | 122 ++++++++++++++++++++ tests/test_route_registry.py | 1 + 5 files changed, 225 insertions(+) create mode 100644 backend/services/deletion_safety_service.py create mode 100644 tests/test_deletion_safety_service.py diff --git a/backend/route_registry.py b/backend/route_registry.py index d46cb04..c56afa1 100644 --- a/backend/route_registry.py +++ b/backend/route_registry.py @@ -68,6 +68,7 @@ ROUTES: tuple[RouteSpec, ...] = ( RouteSpec("POST", "images/{image_id}/select", "backend.routes.image_routes.select_image", "write"), RouteSpec("POST", "images/{image_id}/unselect", "backend.routes.image_routes.unselect_image", "write"), RouteSpec("POST", "images/{image_id}/archive", "backend.routes.image_routes.archive_image", "write"), + RouteSpec("POST", "images/{image_id}/safe-delete", "backend.routes.image_routes.safe_delete_image", "write"), RouteSpec("DELETE", "images/{image_id}", "backend.routes.image_routes.delete_image", "write"), RouteSpec("GET", "jobs", "backend.routes.job_routes.list_jobs", "read"), RouteSpec("GET", "jobs/{task_id}", "backend.routes.job_routes.get_job", "read"), diff --git a/backend/routes/image_routes.py b/backend/routes/image_routes.py index c4aa260..9071dfe 100644 --- a/backend/routes/image_routes.py +++ b/backend/routes/image_routes.py @@ -7,6 +7,7 @@ from typing import Any from backend.dto.common import ApiError from backend.dto.image_dto import GenerationImage from backend.routes.common import handle_request +from backend.services.deletion_safety_service import DeletionSafetyService from backend.services.image_service import ImageService from backend.services.media_service import MediaService from core.audit_service import AuditService @@ -116,6 +117,31 @@ def delete_image( return handle_request(ctx, action) +def safe_delete_image( + ctx: RequestContext, + image_id: str, + payload: dict[str, Any] | None = None, + service: DeletionSafetyService | None = None, + image_service: ImageService | None = None, + media_service: MediaService | None = None, +) -> dict: + params = payload or {} + resolved_image_service = image_service or _create_image_service() + resolved_media_service = media_service or MediaService() + deletion_service = service or DeletionSafetyService(resolved_image_service, resolved_media_service) + + def action() -> dict[str, Any]: + require_write(ctx) + return deletion_service.delete_image( + image_id, + ctx, + dry_run=_as_bool(params.get("dry_run", True)), + delete_files=_as_bool(params.get("delete_files")), + ) + + return handle_request(ctx, action) + + def _create_image_service() -> ImageService: database = Database(load_database_settings()) return ImageService( diff --git a/backend/services/deletion_safety_service.py b/backend/services/deletion_safety_service.py new file mode 100644 index 0000000..bbfde71 --- /dev/null +++ b/backend/services/deletion_safety_service.py @@ -0,0 +1,75 @@ +"""Safe deletion planners for media-backed records.""" + +from __future__ import annotations + +from typing import Any + +from backend.dto.common import ApiError, ErrorCode +from backend.services.image_service import ImageService +from backend.services.media_service import MediaService +from core.identity import RequestContext + + +class DeletionSafetyService: + def __init__(self, image_service: ImageService, media_service: MediaService): + self.image_service = image_service + self.media_service = media_service + + def plan_image_delete(self, image_id: str, *, delete_files: bool = False) -> dict[str, Any]: + image = self.image_service.get_image(image_id) + files = [_file_entry(uri) for uri in (image.image_uri, image.thumbnail_uri) if uri] + return { + "target_type": "generation_image", + "image_id": image.image_id, + "metadata_delete": True, + "delete_files": bool(delete_files), + "requires_explicit_file_delete": not bool(delete_files), + "files": [self._hydrate_entry(entry) for entry in files], + } + + def delete_image( + self, + image_id: str, + ctx: RequestContext, + *, + dry_run: bool = True, + delete_files: bool = False, + ) -> dict[str, Any]: + plan = self.plan_image_delete(image_id, delete_files=delete_files) + if dry_run: + return {**plan, "dry_run": True, "status": "planned", "deleted_files": []} + deleted_files = [] + deleted = self.image_service.delete_image_metadata(image_id, ctx) + if delete_files: + for file_entry in plan["files"]: + if self._delete_storage_file(str(file_entry["uri"])): + deleted_files.append(file_entry["uri"]) + return { + **plan, + "dry_run": False, + "status": "completed", + "deleted_image": deleted.to_dict(), + "deleted_files": deleted_files, + } + + def _hydrate_entry(self, entry: dict[str, Any]) -> dict[str, Any]: + try: + path = self.media_service.storage.resolve_uri(entry["uri"]) + except ApiError: + return {**entry, "exists": False, "bytes": 0} + if path.exists() and not path.is_file(): + raise ApiError(ErrorCode.FORBIDDEN, "refusing to delete non-file media path", {"uri": entry["uri"]}) + return {**entry, "exists": path.exists(), "bytes": path.stat().st_size if path.exists() else 0} + + def _delete_storage_file(self, uri: str) -> bool: + path = self.media_service.storage.resolve_uri(uri) + if not path.exists(): + return False + if not path.is_file(): + raise ApiError(ErrorCode.FORBIDDEN, "refusing to delete non-file media path", {"uri": uri}) + path.unlink() + return True + + +def _file_entry(uri: str) -> dict[str, Any]: + return {"uri": uri, "exists": False, "bytes": 0} diff --git a/tests/test_deletion_safety_service.py b/tests/test_deletion_safety_service.py new file mode 100644 index 0000000..eab7d1d --- /dev/null +++ b/tests/test_deletion_safety_service.py @@ -0,0 +1,122 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from backend.routes.image_routes import safe_delete_image +from backend.services.deletion_safety_service import DeletionSafetyService +from backend.services.image_service import ImageService +from backend.services.media_service import MediaService +from backend.services.profile_service import ProfileService +from backend.services.workflow_service import WorkflowService +from core.audit_service import AuditService +from core.config_service import ConfigService +from core.identity import RequestContext +from database.db_helper import Database, DatabaseSettings, SqliteSettings +from database.repositories.image_repository import ImageRepository +from database.repositories.profile_repository import ProfileRepository +from database.repositories.workflow_repository import WorkflowRepository + + +class DeletionSafetyServiceTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.root = Path(self.tmp.name) + self.config_path = self.root / "config.yaml" + self.config_path.write_text( + f""" +storage: + images_path: "{(self.root / "images").as_posix()}" + thumbnails_path: "{(self.root / "thumbnails").as_posix()}" + materials_path: "{(self.root / "materials").as_posix()}" + styles_path: "{(self.root / "styles").as_posix()}" + archives_path: "{(self.root / "archives").as_posix()}" + temp_path: "{(self.root / "temp").as_posix()}" +""", + encoding="utf-8", + ) + for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"): + (self.root / folder).mkdir(parents=True, exist_ok=True) + self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db")))) + self.database.initialize() + self.audit_service = AuditService(self.database) + self.profile_repository = ProfileRepository(self.database) + self.workflow_repository = WorkflowRepository(self.database) + self.image_repository = ImageRepository(self.database) + self.profile_service = ProfileService(self.profile_repository, self.audit_service) + self.workflow_service = WorkflowService(self.workflow_repository, self.profile_repository, self.audit_service) + self.image_service = ImageService(self.image_repository, self.workflow_repository, self.audit_service) + self.media_service = MediaService(ConfigService(self.config_path)) + self.deletion_service = DeletionSafetyService(self.image_service, self.media_service) + self.ctx = RequestContext.from_astrbot( + username="admin", + user_id="user_001", + permissions={"can_write"}, + ) + profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) + workflow = self.workflow_service.create_workflow( + profile.profile_id, + {"workflow_type": "single_image", "display_name": "Single"}, + self.ctx, + ) + self.node = workflow.nodes[0] + + def tearDown(self): + self.tmp.cleanup() + + def test_safe_delete_dry_run_exposes_plan_without_local_paths(self): + image = self._create_image_with_files() + + plan = self.deletion_service.delete_image(image.image_id, self.ctx, dry_run=True) + + self.assertEqual(plan["status"], "planned") + self.assertTrue(plan["requires_explicit_file_delete"]) + self.assertEqual({item["uri"] for item in plan["files"]}, {image.image_uri, image.thumbnail_uri}) + self.assertNotIn(str(self.root), str(plan)) + self.assertIsNotNone(self.image_service.get_image(image.image_id)) + + def test_safe_delete_can_remove_metadata_and_files_when_explicit(self): + image = self._create_image_with_files(is_selected=True) + + result = self.deletion_service.delete_image( + image.image_id, + self.ctx, + dry_run=False, + delete_files=True, + ) + + self.assertEqual(result["status"], "completed") + self.assertEqual(set(result["deleted_files"]), {image.image_uri, image.thumbnail_uri}) + self.assertFalse((self.root / "images" / "delete.png").exists()) + self.assertFalse((self.root / "thumbnails" / "delete.webp").exists()) + self.assertIsNone(self.workflow_repository.get_node(self.node.node_id).selected_image_id) + + def test_safe_delete_route_requires_write_permission(self): + image = self._create_image_with_files() + read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001") + + denied = safe_delete_image(read_only, image.image_id, {}, self.deletion_service) + planned = safe_delete_image(self.ctx, image.image_id, {}, self.deletion_service) + + self.assertFalse(denied["ok"]) + self.assertEqual(denied["error_code"], "FORBIDDEN") + self.assertTrue(planned["ok"]) + self.assertEqual(planned["data"]["status"], "planned") + + def _create_image_with_files(self, *, is_selected: bool = False): + (self.root / "images" / "delete.png").write_bytes(b"image") + (self.root / "thumbnails" / "delete.webp").write_bytes(b"thumb") + return self.image_service.create_image( + { + "node_id": self.node.node_id, + "image_uri": "storage://images/delete.png", + "thumbnail_uri": "storage://thumbnails/delete.webp", + "is_selected": is_selected, + }, + self.ctx, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_route_registry.py b/tests/test_route_registry.py index 5b4ae04..884714b 100644 --- a/tests/test_route_registry.py +++ b/tests/test_route_registry.py @@ -45,6 +45,7 @@ class RouteRegistryTests(unittest.TestCase): self.assertIn(("POST", "review/policy/validate"), keys) self.assertIn(("POST", "review/policy/save"), keys) self.assertIn(("POST", "prompts/expand"), keys) + self.assertIn(("POST", "images/{image_id}/safe-delete"), keys) self.assertIn(("POST", "nodes/{node_id}/retry"), keys) self.assertIn(("POST", "nodes/{node_id}/complete"), keys) self.assertIn(("POST", "nodes/{node_id}/mark-completed"), keys)