199 行
8.6 KiB
Python
199 行
8.6 KiB
Python
"""Material library service."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from uuid import uuid4
|
|
|
|
from backend.dto.common import ApiError, ErrorCode
|
|
from backend.dto.material_dto import Material, MaterialCategory, MaterialListResult
|
|
from core.audit_service import AuditService
|
|
from core.identity import RequestContext
|
|
from database.repositories.material_repository import MaterialRepository
|
|
|
|
|
|
MATERIAL_STATUSES = {"pending_upload", "pending_recognition", "pending_confirm", "confirmed", "archived"}
|
|
|
|
|
|
class MaterialService:
|
|
def __init__(self, repository: MaterialRepository, audit_service: AuditService):
|
|
self.repository = repository
|
|
self.audit_service = audit_service
|
|
|
|
def create_category(self, payload: dict[str, Any], ctx: RequestContext) -> MaterialCategory:
|
|
name = str(payload.get("name") or "").strip()
|
|
if not name:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "category name is required", {"field": "name"})
|
|
parent_id = payload.get("parent_id")
|
|
if parent_id and self.repository.get_category(parent_id) is None:
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "parent category not found", {"parent_id": parent_id})
|
|
category = self.repository.create_category(
|
|
{
|
|
"category_id": payload.get("category_id") or new_category_id(),
|
|
"name": name,
|
|
"parent_id": parent_id,
|
|
"category_type": payload.get("category_type", "material"),
|
|
"sort_order": payload.get("sort_order", 0),
|
|
"metadata": payload.get("metadata") or {},
|
|
}
|
|
)
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="create_material_category",
|
|
target_type="material_category",
|
|
target_id=category.category_id,
|
|
after_snapshot=category.to_dict(),
|
|
)
|
|
return category
|
|
|
|
def list_categories(self) -> list[MaterialCategory]:
|
|
return self.repository.list_categories()
|
|
|
|
def update_category(self, category_id: str, payload: dict[str, Any], ctx: RequestContext) -> MaterialCategory:
|
|
before = self.get_category(category_id)
|
|
if "name" in payload and not str(payload["name"]).strip():
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "category name is required", {"field": "name"})
|
|
after = self.repository.update_category(category_id, payload)
|
|
if after is None:
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "category not found", {"category_id": category_id})
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="update_material_category",
|
|
target_type="material_category",
|
|
target_id=category_id,
|
|
before_snapshot=before.to_dict(),
|
|
after_snapshot=after.to_dict(),
|
|
)
|
|
return after
|
|
|
|
def delete_category(self, category_id: str, ctx: RequestContext) -> MaterialCategory:
|
|
before = self.repository.delete_category(category_id)
|
|
if before is None:
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "category not found", {"category_id": category_id})
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="delete_material_category",
|
|
target_type="material_category",
|
|
target_id=category_id,
|
|
before_snapshot=before.to_dict(),
|
|
)
|
|
return before
|
|
|
|
def get_category(self, category_id: str) -> MaterialCategory:
|
|
category = self.repository.get_category(category_id)
|
|
if category is None:
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "category not found", {"category_id": category_id})
|
|
return category
|
|
|
|
def create_material(self, payload: dict[str, Any], ctx: RequestContext) -> Material:
|
|
display_name = str(payload.get("display_name") or "").strip()
|
|
if not display_name:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "display_name is required", {"field": "display_name"})
|
|
self._validate_category(payload.get("category_id"))
|
|
self._validate_storage_uri(payload.get("image_uri"), "image_uri")
|
|
self._validate_storage_uri(payload.get("thumbnail_uri"), "thumbnail_uri")
|
|
status = payload.get("recognition_status", "pending_upload")
|
|
self._validate_status(status)
|
|
material = self.repository.create_material(
|
|
{
|
|
"material_id": payload.get("material_id") or new_material_id(),
|
|
"category_id": payload.get("category_id"),
|
|
"display_name": display_name,
|
|
"image_uri": payload.get("image_uri"),
|
|
"thumbnail_uri": payload.get("thumbnail_uri"),
|
|
"prompt": payload.get("prompt"),
|
|
"negative_prompt": payload.get("negative_prompt"),
|
|
"tags": payload.get("tags") or [],
|
|
"recognition_status": status,
|
|
"metadata": payload.get("metadata") or {},
|
|
}
|
|
)
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="create_material",
|
|
target_type="material",
|
|
target_id=material.material_id,
|
|
after_snapshot=material.to_dict(),
|
|
)
|
|
return material
|
|
|
|
def list_materials(
|
|
self,
|
|
*,
|
|
category_id: str | None = None,
|
|
keyword: str | None = None,
|
|
page: int = 1,
|
|
page_size: int = 30,
|
|
) -> MaterialListResult:
|
|
normalized_page = max(page, 1)
|
|
normalized_page_size = min(max(page_size, 1), 100)
|
|
items, total = self.repository.list_materials(
|
|
category_id=category_id,
|
|
keyword=keyword,
|
|
page=normalized_page,
|
|
page_size=normalized_page_size,
|
|
)
|
|
return MaterialListResult(items=items, total=total, page=normalized_page, page_size=normalized_page_size)
|
|
|
|
def get_material(self, material_id: str) -> Material:
|
|
material = self.repository.get_material(material_id)
|
|
if material is None or material.recognition_status == "archived":
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "material not found", {"material_id": material_id})
|
|
return material
|
|
|
|
def update_material(self, material_id: str, payload: dict[str, Any], ctx: RequestContext) -> Material:
|
|
before = self.get_material(material_id)
|
|
if "category_id" in payload:
|
|
self._validate_category(payload.get("category_id"))
|
|
if "image_uri" in payload:
|
|
self._validate_storage_uri(payload.get("image_uri"), "image_uri")
|
|
if "thumbnail_uri" in payload:
|
|
self._validate_storage_uri(payload.get("thumbnail_uri"), "thumbnail_uri")
|
|
if "recognition_status" in payload:
|
|
self._validate_status(payload["recognition_status"])
|
|
update_payload = dict(payload)
|
|
if "display_name" in update_payload:
|
|
update_payload["display_name"] = str(update_payload["display_name"]).strip()
|
|
if not update_payload["display_name"]:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "display_name is required", {"field": "display_name"})
|
|
after = self.repository.update_material(material_id, update_payload)
|
|
if after is None:
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "material not found", {"material_id": material_id})
|
|
self.audit_service.record(
|
|
ctx=ctx,
|
|
action="update_material",
|
|
target_type="material",
|
|
target_id=material_id,
|
|
before_snapshot=before.to_dict(),
|
|
after_snapshot=after.to_dict(),
|
|
)
|
|
return after
|
|
|
|
def delete_material(self, material_id: str, ctx: RequestContext) -> Material:
|
|
return self.update_material(material_id, {"recognition_status": "archived"}, ctx)
|
|
|
|
def _validate_category(self, category_id: Any) -> None:
|
|
if category_id and self.repository.get_category(str(category_id)) is None:
|
|
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "category not found", {"category_id": category_id})
|
|
|
|
def _validate_status(self, status: Any) -> None:
|
|
if status not in MATERIAL_STATUSES:
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"unsupported material status",
|
|
{"field": "recognition_status", "allowed": sorted(MATERIAL_STATUSES)},
|
|
)
|
|
|
|
def _validate_storage_uri(self, uri: Any, field: str) -> None:
|
|
if uri is None:
|
|
return
|
|
if not str(uri).startswith("storage://"):
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, f"{field} must use storage://", {"field": field})
|
|
|
|
|
|
def new_category_id() -> str:
|
|
return f"cat_{uuid4().hex}"
|
|
|
|
|
|
def new_material_id() -> str:
|
|
return f"mat_{uuid4().hex}"
|