astrbot_plugin_imagestudio/backend/routes/node_routes.py

222 行
7.4 KiB
Python

"""Workflow node route handlers."""
from __future__ import annotations
from typing import Any
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.routes.common import handle_request
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService
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.job_repository import JobRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
def list_workflow_nodes(
ctx: RequestContext,
workflow_id: str,
service: WorkflowService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> list[dict[str, Any]]:
require_authenticated(ctx)
return [node.to_dict() for node in workflow_service.list_nodes(workflow_id)]
return handle_request(ctx, action)
def create_workflow_node(
ctx: RequestContext,
workflow_id: str,
payload: dict[str, Any],
service: WorkflowService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> dict[str, Any]:
require_write(ctx)
return workflow_service.create_node(workflow_id, payload, ctx).to_dict()
return handle_request(ctx, action)
def get_node(
ctx: RequestContext,
node_id: str,
service: WorkflowService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> dict[str, Any]:
require_authenticated(ctx)
return workflow_service.get_node(node_id).to_dict()
return handle_request(ctx, action)
def update_node(
ctx: RequestContext,
node_id: str,
payload: dict[str, Any],
service: WorkflowService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> dict[str, Any]:
require_write(ctx)
return workflow_service.update_node(node_id, payload, ctx).to_dict()
return handle_request(ctx, action)
def generate_node(
ctx: RequestContext,
node_id: str,
payload: dict[str, Any] | None = None,
service: WorkflowService | None = None,
generation_service: GenerationService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
resolved_generation_service = generation_service or (None if service else _create_generation_service())
request_payload = payload or {}
def action() -> dict[str, Any]:
require_write(ctx)
if resolved_generation_service:
return resolved_generation_service.generate_node(node_id, request_payload, ctx)
update_payload: dict[str, Any] = {
"status": "queued",
"metadata": {
"last_generate_request": request_payload,
"queue_placeholder": True,
},
}
if "model_route" in request_payload:
update_payload["model_route"] = request_payload["model_route"]
node = workflow_service.update_node(node_id, update_payload, ctx)
return {
"task_id": None,
"request_id": f"genreq_{uuid4().hex}",
"node_status": node.status,
"queue_placeholder": True,
}
return handle_request(ctx, action)
def retry_node(
ctx: RequestContext,
node_id: str,
service: WorkflowService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> dict[str, Any]:
require_write(ctx)
node = workflow_service.update_node(node_id, {"status": "queued"}, ctx)
return {"node_id": node.node_id, "node_status": node.status, "queue_placeholder": True}
return handle_request(ctx, action)
def select_node_image(
ctx: RequestContext,
node_id: str,
payload: dict[str, Any],
image_service: ImageService | None = None,
workflow_service: WorkflowService | None = None,
) -> dict:
selected_image_service, selected_workflow_service = _resolve_services(image_service, workflow_service)
def action() -> dict[str, Any]:
require_write(ctx)
selected_workflow_service.get_node(node_id)
image_id = str(payload.get("image_id") or "").strip()
if not image_id:
raise ApiError(ErrorCode.VALIDATION_FAILED, "image_id is required", {"field": "image_id"})
image = selected_image_service.get_image(image_id)
if image.node_id != node_id:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"image does not belong to this node",
{"image_id": image_id, "node_id": node_id},
)
return selected_image_service.select_image(image_id, ctx).to_dict()
return handle_request(ctx, action)
def mark_node_completed(
ctx: RequestContext,
node_id: str,
service: WorkflowService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> dict[str, Any]:
require_write(ctx)
return workflow_service.update_node(node_id, {"status": "completed"}, ctx).to_dict()
return handle_request(ctx, action)
def _resolve_services(
image_service: ImageService | None,
workflow_service: WorkflowService | None,
) -> tuple[ImageService, WorkflowService]:
if image_service and workflow_service:
return image_service, workflow_service
database = Database(load_database_settings())
audit_service = AuditService(database)
resolved_workflow_service = workflow_service or WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=audit_service,
)
resolved_image_service = image_service or ImageService(
image_repository=ImageRepository(database),
workflow_repository=WorkflowRepository(database),
audit_service=audit_service,
)
return resolved_image_service, resolved_workflow_service
def _create_workflow_service() -> WorkflowService:
database = Database(load_database_settings())
return WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
)
def _create_generation_service() -> GenerationService:
database = Database(load_database_settings())
audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database)
return GenerationService(
workflow_service=WorkflowService(
workflow_repository=workflow_repository,
profile_repository=ProfileRepository(database),
audit_service=audit_service,
),
queue_service=QueueService(
repository=JobRepository(database),
audit_service=audit_service,
),
image_service=ImageService(
image_repository=ImageRepository(database),
workflow_repository=workflow_repository,
audit_service=audit_service,
),
)