astrbot_plugin_imagestudio/backend/routes/image_routes.py

237 行
8.6 KiB
Python

"""Generation image route handlers."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.dto.image_dto import GenerationImage, ImageListResult
from backend.routes.common import handle_request
from backend.routes.params import as_bool, int_or_default, optional_str
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
from core.identity import RequestContext
from core.security import require_authenticated, require_write
from database.db_helper import Database, load_database_settings
from database.repositories.image_repository import ImageRepository
from database.repositories.workflow_repository import WorkflowRepository
def list_images(
ctx: RequestContext,
query: dict[str, Any] | None = None,
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
params = query or {}
def action() -> dict[str, Any]:
require_authenticated(ctx)
result = image_service.list_images(
profile_id=optional_str(params.get("profile_id")),
workflow_id=optional_str(params.get("workflow_id")),
include_archived=as_bool(params.get("include_archived"), default=True, non_string_truthiness=True),
page=int_or_default(params.get("page"), 1),
page_size=int_or_default(params.get("page_size"), 60),
)
include_restricted = as_bool(params.get("include_restricted"), default=False, non_string_truthiness=True)
if include_restricted and not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
include_restricted = False
payload = _serialize_image_list(result, signer)
if not include_restricted:
visible = [item for item in payload["items"] if not _is_restricted_image(item)]
payload["restricted_hidden"] = len(payload["items"]) - len(visible)
payload["items"] = visible
payload["total"] = max(len(visible), int(payload.get("total") or 0) - payload["restricted_hidden"])
return payload
return handle_request(ctx, action)
def list_node_images(
ctx: RequestContext,
node_id: str,
query: dict[str, Any] | None = None,
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
params = query or {}
def action() -> list[dict[str, Any]]:
require_authenticated(ctx)
include_archived = as_bool(params.get("include_archived"), non_string_truthiness=True)
include_restricted = as_bool(params.get("include_restricted"), default=False, non_string_truthiness=True)
if include_restricted and not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
include_restricted = False
images = [_serialize_image(image, signer) for image in image_service.list_by_node(node_id, include_archived)]
return images if include_restricted else [item for item in images if not _is_restricted_image(item)]
return handle_request(ctx, action)
def get_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
require_authenticated(ctx)
image = _serialize_image(image_service.get_image(image_id), signer)
if _is_restricted_image(image) and not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
raise ApiError(ErrorCode.FORBIDDEN, "受限图片仅管理员可查看", {"image_id": image_id})
return image
return handle_request(ctx, action)
def select_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
require_write(ctx)
return _serialize_image(image_service.select_image(image_id, ctx), signer)
return handle_request(ctx, action)
def unselect_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
require_write(ctx)
return _serialize_image(image_service.unselect_image(image_id, ctx), signer)
return handle_request(ctx, action)
def archive_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
require_write(ctx)
return _serialize_image(image_service.archive_image(image_id, ctx), signer)
return handle_request(ctx, action)
def review_moderated_image(
ctx: RequestContext,
image_id: str,
payload: dict[str, Any],
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
if not (ctx.has_permission("can_manage_materials") or ctx.has_permission("*")):
raise ApiError(ErrorCode.FORBIDDEN, "仅管理员可复核受限图片", {"image_id": image_id})
return _serialize_image(image_service.review_moderated_image(image_id, payload, ctx), signer)
return handle_request(ctx, action)
def delete_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
image_service = service or _create_image_service()
signer = media_service or MediaService()
def action() -> dict[str, Any]:
require_write(ctx)
return _serialize_image(image_service.delete_image_metadata(image_id, ctx), signer)
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), non_string_truthiness=True),
delete_files=as_bool(params.get("delete_files"), non_string_truthiness=True),
)
return handle_request(ctx, action)
def _create_image_service() -> ImageService:
database = Database(load_database_settings())
return ImageService(
image_repository=ImageRepository(database),
workflow_repository=WorkflowRepository(database),
audit_service=AuditService(database),
)
def _serialize_image(image: GenerationImage, media_service: MediaService) -> dict[str, Any]:
payload = image.to_dict()
payload["image_url"] = _signed_url(media_service, image.image_uri)
payload["thumbnail_url"] = _signed_url(media_service, image.thumbnail_uri)
return payload
def _serialize_image_list(result: ImageListResult, media_service: MediaService) -> dict[str, Any]:
payload = result.to_dict()
payload["items"] = [_serialize_image(image, media_service) for image in result.items]
return payload
def _signed_url(media_service: MediaService, uri: str | None) -> str | None:
if not uri:
return None
try:
return media_service.sign_media(uri)["url"]
except ApiError:
return None
def _is_restricted_image(image: dict[str, Any]) -> bool:
metadata = image.get("metadata") if isinstance(image.get("metadata"), dict) else {}
return bool(metadata.get("quarantined") or metadata.get("gallery_visibility") == "restricted")