diff --git a/backend/routes/asset_routes.py b/backend/routes/asset_routes.py index 9a98bb0..28976cb 100644 --- a/backend/routes/asset_routes.py +++ b/backend/routes/asset_routes.py @@ -7,8 +7,12 @@ from typing import Any from backend.dto.common import ApiError, ErrorCode from backend.routes.common import handle_request from backend.services.asset_import_service import AssetImportService +from backend.services.material_service import MaterialService +from core.audit_service import AuditService from core.identity import RequestContext from core.security import require_permission +from database.db_helper import Database, load_database_settings +from database.repositories.material_repository import MaterialRepository def import_asset_pack( @@ -16,18 +20,32 @@ def import_asset_pack( payload: dict[str, Any], service: AssetImportService | None = None, ) -> dict: - asset_service = service or AssetImportService() + asset_service = service or _create_asset_import_service() def action() -> dict[str, Any]: require_permission(ctx, "can_manage_materials") package_uri = str(payload.get("package_uri") or "").strip() if not package_uri: raise ApiError(ErrorCode.VALIDATION_FAILED, "package_uri is required", {"field": "package_uri"}) - return asset_service.plan_import_pack(package_uri, dry_run=_as_bool(payload.get("dry_run"), default=True)) + return asset_service.plan_import_pack( + package_uri, + dry_run=_as_bool(payload.get("dry_run"), default=True), + ctx=ctx, + ) return handle_request(ctx, action) +def _create_asset_import_service() -> AssetImportService: + database = Database(load_database_settings()) + return AssetImportService( + material_service=MaterialService( + repository=MaterialRepository(database), + audit_service=AuditService(database), + ) + ) + + def _as_bool(value: Any, *, default: bool = False) -> bool: if value is None: return default diff --git a/backend/services/asset_import_service.py b/backend/services/asset_import_service.py index cedaef3..299746e 100644 --- a/backend/services/asset_import_service.py +++ b/backend/services/asset_import_service.py @@ -7,7 +7,9 @@ from pathlib import Path from typing import Any from backend.dto.common import ApiError, ErrorCode +from backend.services.material_service import MaterialService from core.config_service import ConfigService +from core.identity import RequestContext from core.storage import VfsStorage @@ -20,10 +22,21 @@ _MANIFEST_FILENAME_PRIORITY = { class AssetImportService: - def __init__(self, config_service: ConfigService | None = None): + def __init__( + self, + config_service: ConfigService | None = None, + material_service: MaterialService | None = None, + ): self.storage = VfsStorage(config_service) + self.material_service = material_service - def plan_import_pack(self, package_uri: str, *, dry_run: bool = True) -> dict[str, Any]: + def plan_import_pack( + self, + package_uri: str, + *, + dry_run: bool = True, + ctx: RequestContext | None = None, + ) -> dict[str, Any]: root, relative = self.storage.split_uri(package_uri) package_path = self.storage.resolve_uri(package_uri) if not package_path.exists(): @@ -32,12 +45,21 @@ class AssetImportService: files, total_bytes = _path_file_stats(package_path) manifest_candidates = _manifest_candidates(root, relative, package_path) manifest_summary = _manifest_summary(package_path, manifest_candidates) + applied = {"materials": 0, "styles": 0, "material_ids": []} if not dry_run and not manifest_summary["valid"]: raise ApiError( ErrorCode.VALIDATION_FAILED, "asset pack manifest is invalid", {"field": "manifest", "errors": manifest_summary["errors"]}, ) + if not dry_run: + if self.material_service is None or ctx is None: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "asset pack import execution is unavailable", + {"field": "material_service"}, + ) + applied = self._apply_manifest(package_uri, root, relative, package_path, manifest_candidates[0], ctx) return { "dry_run": dry_run, "status": "planned" if dry_run else "applied", @@ -48,10 +70,45 @@ class AssetImportService: "manifest": manifest_summary, "import_enabled": manifest_summary["valid"], "execution_enabled": True, - "applied": { - "materials": 0 if dry_run else manifest_summary["materials"], - "styles": 0 if dry_run else manifest_summary["styles"], - }, + "applied": applied, + } + + def _apply_manifest( + self, + package_uri: str, + root: str, + relative: Path, + package_path: Path, + manifest: dict[str, Any], + ctx: RequestContext, + ) -> dict[str, Any]: + payload = _load_manifest_payload(manifest["path"]) + material_ids: list[str] = [] + base_relative = relative if package_path.is_dir() else relative.parent + for index, item in enumerate(payload.get("materials") or []): + if not isinstance(item, dict): + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "asset pack material entries must be objects", + {"field": f"materials[{index}]"}, + ) + material_payload = _material_payload_from_manifest_item( + item, + root=root, + base_relative=base_relative, + package_uri=package_uri, + manifest_uri=manifest["uri"], + index=index, + ) + self.storage.ensure_file(material_payload["image_uri"]) + if material_payload.get("thumbnail_uri"): + self.storage.ensure_file(material_payload["thumbnail_uri"]) + created = self.material_service.create_material(material_payload, ctx) + material_ids.append(created.material_id) + return { + "materials": len(material_ids), + "styles": _list_count(payload.get("styles")), + "material_ids": material_ids, } @@ -134,6 +191,57 @@ def _manifest_summary(package_path: Path, candidates: list[dict[str, Any]]) -> d } +def _load_manifest_payload(path: Path) -> dict[str, Any]: + payload = json.loads(path.read_text(encoding="utf-8")) + if not isinstance(payload, dict): + raise ApiError(ErrorCode.VALIDATION_FAILED, "asset pack manifest must be a JSON object", {"field": "manifest"}) + return payload + + +def _material_payload_from_manifest_item( + item: dict[str, Any], + *, + root: str, + base_relative: Path, + package_uri: str, + manifest_uri: str, + index: int, +) -> dict[str, Any]: + image_uri = _asset_uri(item.get("image_uri") or item.get("uri") or item.get("image") or item.get("file"), root, base_relative) + if not image_uri: + raise ApiError(ErrorCode.VALIDATION_FAILED, "material image uri is required", {"field": f"materials[{index}].image_uri"}) + thumbnail_uri = _asset_uri(item.get("thumbnail_uri") or item.get("thumbnail"), root, base_relative) + display_name = _optional_text(item.get("display_name") or item.get("name") or item.get("title")) or Path(image_uri).stem + metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {} + return { + "category_id": _optional_text(item.get("category_id")), + "display_name": display_name, + "image_uri": image_uri, + "thumbnail_uri": thumbnail_uri, + "prompt": _optional_text(item.get("prompt")), + "negative_prompt": _optional_text(item.get("negative_prompt")), + "tags": _normalize_tags(item.get("tags")), + "recognition_status": _optional_text(item.get("recognition_status")) or "pending_recognition", + "metadata": { + **metadata, + "asset_pack": { + "package_uri": package_uri, + "manifest_uri": manifest_uri, + "index": index, + }, + }, + } + + +def _asset_uri(value: Any, root: str, base_relative: Path) -> str | None: + text = _optional_text(value) + if text is None: + return None + if text.startswith("storage://"): + return text + return _storage_uri(root, base_relative / text) + + def _storage_uri(root: str, relative: Path) -> str: return f"storage://{root}/{relative.as_posix()}" @@ -147,6 +255,21 @@ def _list_count(value: Any) -> int: return len(value) if isinstance(value, list) else 0 +def _normalize_tags(value: Any) -> list[str]: + if isinstance(value, str): + candidates = value.split(",") + elif isinstance(value, list): + candidates = value + else: + candidates = [] + tags: list[str] = [] + for item in candidates: + tag = str(item or "").strip() + if tag and tag not in tags: + tags.append(tag) + return tags + + def _path_file_stats(path: Path) -> tuple[int, int]: if path.is_file(): return 1, path.stat().st_size diff --git a/frontend/shared/types/assets.ts b/frontend/shared/types/assets.ts index 0389dfe..83a87c6 100644 --- a/frontend/shared/types/assets.ts +++ b/frontend/shared/types/assets.ts @@ -26,5 +26,6 @@ export interface AssetImportPlan { applied: { materials: number styles: number + material_ids: string[] } } diff --git a/tests/test_s2_routes.py b/tests/test_s2_routes.py index 9b3e687..c2fb509 100644 --- a/tests/test_s2_routes.py +++ b/tests/test_s2_routes.py @@ -66,6 +66,7 @@ from backend.routes.workflow_routes import ( from backend.services.asset_import_service import AssetImportService from backend.services.dashboard_service import DashboardService from backend.services.image_service import ImageService +from backend.services.material_service import MaterialService from backend.services.media_service import MediaService from backend.services.profile_service import ProfileService from backend.services.queue_service import QueueService @@ -79,6 +80,7 @@ from core.identity import RequestContext from database.db_helper import Database, DatabaseSettings, SqliteSettings from database.repositories.image_repository import ImageRepository from database.repositories.job_repository import JobRepository +from database.repositories.material_repository import MaterialRepository from database.repositories.profile_repository import ProfileRepository from database.repositories.workflow_repository import WorkflowRepository @@ -130,6 +132,7 @@ storage: self.workflow_repository = WorkflowRepository(self.database) self.image_repository = ImageRepository(self.database) self.job_repository = JobRepository(self.database) + self.material_repository = MaterialRepository(self.database) self.profile_service = ProfileService( repository=self.profile_repository, audit_service=self.audit_service, @@ -150,7 +153,8 @@ storage: ) self.settings_service = SettingsService(self.config_service, audit_service=self.audit_service) self.media_service = MediaService(self.config_service) - self.asset_import_service = AssetImportService(self.config_service) + self.material_service = MaterialService(self.material_repository, self.audit_service) + self.asset_import_service = AssetImportService(self.config_service, self.material_service) self.web_hosting_service = WebHostingService() self.ctx = RequestContext.from_astrbot( username="admin", @@ -697,7 +701,7 @@ database: pack = self.root / "materials" / "pack" pack.mkdir(parents=True, exist_ok=True) (pack / "manifest.json").write_text( - '{"name":"demo","materials":[{"name":"hat"}],"styles":[{"name":"daily"}]}', + '{"name":"demo","materials":[{"name":"hat","image":"image.bin","tags":"daily,hat"}],"styles":[{"name":"daily"}]}', encoding="utf-8", ) (pack / "image.bin").write_bytes(b"123") @@ -720,7 +724,9 @@ database: self.assertEqual(planned["data"]["manifest"]["name"], "demo") self.assertTrue(planned["data"]["import_enabled"]) self.assertTrue(planned["data"]["execution_enabled"]) - self.assertEqual(planned["data"]["applied"], {"materials": 0, "styles": 0}) + self.assertEqual(planned["data"]["applied"]["materials"], 0) + self.assertEqual(planned["data"]["applied"]["styles"], 0) + self.assertEqual(planned["data"]["applied"]["material_ids"], []) self.assertNotIn(str(self.root), str(planned["data"])) execution = import_asset_pack( @@ -731,8 +737,15 @@ database: self.assertTrue(execution["ok"]) self.assertFalse(execution["data"]["dry_run"]) self.assertEqual(execution["data"]["status"], "applied") - self.assertEqual(execution["data"]["applied"], {"materials": 1, "styles": 1}) + self.assertEqual(execution["data"]["applied"]["materials"], 1) + self.assertEqual(execution["data"]["applied"]["styles"], 1) + self.assertEqual(len(execution["data"]["applied"]["material_ids"]), 1) self.assertNotIn(str(self.root), str(execution["data"])) + imported = self.material_service.get_material(execution["data"]["applied"]["material_ids"][0]) + self.assertEqual(imported.display_name, "hat") + self.assertEqual(imported.image_uri, "storage://materials/pack/image.bin") + self.assertEqual(imported.recognition_status, "pending_recognition") + self.assertIn("daily", imported.tags) unsafe = import_asset_pack( self.ctx,