"""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")