237 行
8.6 KiB
Python
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")
|