Import asset pack materials

这个提交存在于:
YokiiroBW 2026-07-05 21:25:50 +08:00
父节点 0e1ed7d8ef
当前提交 74ef6a9070
共有 4 个文件被更改,包括 167 次插入 和 12 次删除

查看文件

@ -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

查看文件

@ -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

查看文件

@ -26,5 +26,6 @@ export interface AssetImportPlan {
applied: {
materials: number
styles: number
material_ids: string[]
}
}

查看文件

@ -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,