astrbot_plugin_imagestudio/backend/services/image_service.py

243 行
11 KiB
Python

2026-07-04 23:42:11 +08:00
"""Generation image card service."""
from __future__ import annotations
from typing import Any
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.dto.image_dto import GenerationImage, ImageListResult
from backend.services.workflow_service import LOCKED_NODE_STATUSES, locked_node_edit_error
2026-07-04 23:42:11 +08:00
from core.audit_service import AuditService
from core.identity import RequestContext
from database.repositories.image_repository import ImageRepository
from database.repositories.workflow_repository import WorkflowRepository
class ImageService:
def __init__(
self,
image_repository: ImageRepository,
workflow_repository: WorkflowRepository,
audit_service: AuditService,
):
self.image_repository = image_repository
self.workflow_repository = workflow_repository
self.audit_service = audit_service
def create_image(self, payload: dict[str, Any], ctx: RequestContext) -> GenerationImage:
node_id = payload.get("node_id")
node = self.workflow_repository.get_node(node_id) if node_id else None
if node_id and node is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "节点不存在", {"node_id": node_id})
workflow = self.workflow_repository.get_workflow(node.workflow_id) if node else None
image_uri = str(payload.get("image_uri") or "").strip()
if not image_uri:
raise ApiError(ErrorCode.VALIDATION_FAILED, "图片 URI 不能为空", {"field": "image_uri"})
if not image_uri.startswith("storage://"):
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"图片 URI 必须使用 storage:// VFS 路径",
{"field": "image_uri"},
)
image = self.image_repository.create(
{
"image_id": payload.get("image_id") or new_image_id(),
"profile_id": payload.get("profile_id") or (workflow.profile_id if workflow else None),
"workflow_id": payload.get("workflow_id") or (workflow.workflow_id if workflow else None),
"node_id": node_id,
"task_id": payload.get("task_id"),
"batch_id": payload.get("batch_id"),
"version_tag": payload.get("version_tag"),
"image_uri": image_uri,
"thumbnail_uri": payload.get("thumbnail_uri"),
"positive_prompt": payload.get("positive_prompt"),
"negative_prompt": payload.get("negative_prompt"),
"model_used": payload.get("model_used"),
"model_route": payload.get("model_route"),
"seed": payload.get("seed"),
"width": payload.get("width"),
"height": payload.get("height"),
"is_selected": payload.get("is_selected", False),
"metadata": payload.get("metadata") or {},
}
)
if image.is_selected:
image = self.image_repository.select_exclusive(image) or image
if node:
self.workflow_repository.update_node(node.node_id, {"selected_image_id": image.image_id})
self.audit_service.record(
ctx=ctx,
action="create_image",
target_type="generation_image",
target_id=image.image_id,
after_snapshot=image.to_dict(),
)
return image
def list_by_node(self, node_id: str, include_archived: bool = False) -> list[GenerationImage]:
if self.workflow_repository.get_node(node_id) is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "节点不存在", {"node_id": node_id})
return self.image_repository.list_by_node(node_id, include_archived=include_archived)
def list_images(
self,
*,
profile_id: str | None = None,
workflow_id: str | None = None,
include_archived: bool = True,
page: int = 1,
page_size: int = 60,
) -> ImageListResult:
normalized_page = max(page, 1)
normalized_page_size = min(max(page_size, 1), 100)
items, total = self.image_repository.list_images(
profile_id=profile_id,
workflow_id=workflow_id,
include_archived=include_archived,
page=normalized_page,
page_size=normalized_page_size,
)
return ImageListResult(
items=items,
total=total,
page=normalized_page,
page_size=normalized_page_size,
)
2026-07-04 23:42:11 +08:00
def get_image(self, image_id: str) -> GenerationImage:
image = self.image_repository.get(image_id)
if image is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
return image
2026-07-12 02:54:45 +08:00
def review_moderated_image(self, image_id: str, payload: dict[str, Any], ctx: RequestContext) -> GenerationImage:
before = self.get_image(image_id)
action = str(payload.get("action") or "").strip().lower()
if action not in {"approve", "reject"}:
raise ApiError(ErrorCode.VALIDATION_FAILED, "moderation review action must be approve or reject", {"field": "action"})
metadata = before.metadata if isinstance(before.metadata, dict) else {}
if not (metadata.get("quarantined") or metadata.get("gallery_visibility") == "restricted"):
raise ApiError(ErrorCode.VALIDATION_FAILED, "image is not awaiting moderation review", {"image_id": image_id})
review = {
"action": action,
"reviewer_id": ctx.actor_id,
"reason": str(payload.get("reason") or "").strip(),
}
update = {
"metadata": {
**metadata,
"quarantined": False if action == "approve" else True,
"gallery_visibility": "normal" if action == "approve" else "restricted",
"moderation_admin_review": review,
},
**({"is_archived": True} if action == "reject" else {}),
}
after = self.image_repository.update(image_id, update)
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
self.audit_service.record(ctx=ctx, action="review_moderated_image", target_type="generation_image", target_id=image_id, before_snapshot=before.to_dict(), after_snapshot=after.to_dict(), metadata=review)
return after
2026-07-04 23:42:11 +08:00
def select_image(self, image_id: str, ctx: RequestContext) -> GenerationImage:
before = self.get_image(image_id)
self._ensure_image_node_is_editable(before)
2026-07-04 23:42:11 +08:00
if before.is_archived:
raise ApiError(ErrorCode.VALIDATION_FAILED, "不能选择已归档图片", {"image_id": image_id})
after = self.image_repository.select_exclusive(before)
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
if after.node_id:
self.workflow_repository.update_node(after.node_id, {"selected_image_id": after.image_id})
self.audit_service.record(
ctx=ctx,
action="select_image",
target_type="generation_image",
target_id=image_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
def unselect_image(self, image_id: str, ctx: RequestContext) -> GenerationImage:
before = self.get_image(image_id)
self._ensure_image_node_is_editable(before)
2026-07-04 23:42:11 +08:00
after = self.image_repository.update(image_id, {"is_selected": False})
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
if after.node_id:
node = self.workflow_repository.get_node(after.node_id)
if node and node.selected_image_id == image_id:
self.workflow_repository.update_node(after.node_id, {"selected_image_id": None})
self.audit_service.record(
ctx=ctx,
action="unselect_image",
target_type="generation_image",
target_id=image_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
def archive_image(self, image_id: str, ctx: RequestContext) -> GenerationImage:
before = self.get_image(image_id)
self._ensure_image_node_is_editable(before)
2026-07-04 23:42:11 +08:00
after = self.image_repository.update(
image_id,
{
"is_archived": True,
"is_selected": False,
},
)
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
if after.node_id:
node = self.workflow_repository.get_node(after.node_id)
if node and node.selected_image_id == image_id:
self.workflow_repository.update_node(after.node_id, {"selected_image_id": None})
self.audit_service.record(
ctx=ctx,
action="archive_image",
target_type="generation_image",
target_id=image_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
def delete_image_metadata(self, image_id: str, ctx: RequestContext) -> GenerationImage:
existing = self.get_image(image_id)
self._ensure_image_node_is_editable(existing)
2026-07-04 23:42:11 +08:00
before = self.image_repository.delete_metadata(image_id)
if before is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "图片不存在", {"image_id": image_id})
if before.node_id:
node = self.workflow_repository.get_node(before.node_id)
if node and node.selected_image_id == image_id:
self.workflow_repository.update_node(before.node_id, {"selected_image_id": None})
self.audit_service.record(
ctx=ctx,
action="delete_image",
target_type="generation_image",
target_id=image_id,
before_snapshot=before.to_dict(),
metadata={"metadata_only": True},
)
return before
def _ensure_image_node_is_editable(self, image: GenerationImage) -> None:
if not image.node_id:
return
node = self.workflow_repository.get_node(image.node_id)
# ``completed`` means generation finished and its candidates are ready
# for curation. Prompt/node edits stay locked in WorkflowService, but
# users must still be able to change the tentative selection or
# archive rejected candidates until an image is formally adopted and
# the node enters ``selected``.
if node and node.status in LOCKED_NODE_STATUSES and node.status != "completed":
raise locked_node_edit_error(node)
2026-07-04 23:42:11 +08:00
def new_image_id() -> str:
return f"img_{uuid4().hex}"