feat: add workflow node image route handlers

这个提交存在于:
YokiiroBW 2026-07-05 09:00:36 +08:00
父节点 b69f631711
当前提交 e98f32ebfb
共有 4 个文件被更改,包括 603 次插入 和 0 次删除

查看文件

@ -0,0 +1,118 @@
"""Generation image route handlers."""
from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.image_service import ImageService
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_node_images(
ctx: RequestContext,
node_id: str,
query: dict[str, Any] | None = None,
service: ImageService | None = None,
) -> dict:
image_service = service or _create_image_service()
params = query or {}
def action() -> list[dict[str, Any]]:
require_authenticated(ctx)
include_archived = _as_bool(params.get("include_archived"))
return [image.to_dict() for image in image_service.list_by_node(node_id, include_archived)]
return handle_request(ctx, action)
def get_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
) -> dict:
image_service = service or _create_image_service()
def action() -> dict[str, Any]:
require_authenticated(ctx)
return image_service.get_image(image_id).to_dict()
return handle_request(ctx, action)
def select_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
) -> dict:
image_service = service or _create_image_service()
def action() -> dict[str, Any]:
require_write(ctx)
return image_service.select_image(image_id, ctx).to_dict()
return handle_request(ctx, action)
def unselect_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
) -> dict:
image_service = service or _create_image_service()
def action() -> dict[str, Any]:
require_write(ctx)
return image_service.unselect_image(image_id, ctx).to_dict()
return handle_request(ctx, action)
def archive_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
) -> dict:
image_service = service or _create_image_service()
def action() -> dict[str, Any]:
require_write(ctx)
return image_service.archive_image(image_id, ctx).to_dict()
return handle_request(ctx, action)
def delete_image(
ctx: RequestContext,
image_id: str,
service: ImageService | None = None,
) -> dict:
image_service = service or _create_image_service()
def action() -> dict[str, Any]:
require_write(ctx)
return image_service.delete_image_metadata(image_id, ctx).to_dict()
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 _as_bool(value: Any) -> bool:
if isinstance(value, bool):
return value
if isinstance(value, str):
return value.strip().lower() in {"1", "true", "yes", "on"}
return bool(value)

查看文件

@ -0,0 +1,193 @@
"""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.image_service import ImageService
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.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,
) -> dict:
workflow_service = service or _create_workflow_service()
request_payload = payload or {}
def action() -> dict[str, Any]:
require_write(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),
)

查看文件

@ -0,0 +1,120 @@
"""Workflow route handlers."""
from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
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.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
def list_profile_workflows(
ctx: RequestContext,
profile_id: str,
service: WorkflowService | None = None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> list[dict[str, Any]]:
require_authenticated(ctx)
return [workflow.to_dict() for workflow in workflow_service.list_workflows(profile_id)]
return handle_request(ctx, action)
def create_profile_workflow(
ctx: RequestContext,
profile_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_workflow(profile_id, payload, ctx).to_dict()
return handle_request(ctx, action)
def get_workflow(
ctx: RequestContext,
workflow_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_workflow(workflow_id).to_dict()
return handle_request(ctx, action)
def update_workflow(
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.update_workflow(workflow_id, payload, ctx).to_dict()
return handle_request(ctx, action)
def start_workflow(
ctx: RequestContext,
workflow_id: str,
service: WorkflowService | None = None,
) -> dict:
return _set_workflow_status(ctx, workflow_id, "running", service)
def cancel_workflow(
ctx: RequestContext,
workflow_id: str,
service: WorkflowService | None = None,
) -> dict:
return _set_workflow_status(ctx, workflow_id, "cancelled", service)
def archive_workflow(
ctx: RequestContext,
workflow_id: str,
service: WorkflowService | None = None,
) -> dict:
return _set_workflow_status(ctx, workflow_id, "archived", service)
def _set_workflow_status(
ctx: RequestContext,
workflow_id: str,
status: str,
service: WorkflowService | None,
) -> dict:
workflow_service = service or _create_workflow_service()
def action() -> dict[str, Any]:
require_write(ctx)
return workflow_service.update_workflow(workflow_id, {"status": status}, ctx).to_dict()
return handle_request(ctx, action)
def _create_workflow_service() -> WorkflowService:
database = Database(load_database_settings())
return WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
)

查看文件

@ -5,6 +5,20 @@ import unittest
from pathlib import Path
from backend.routes.dashboard_routes import get_dashboard_summary
from backend.routes.image_routes import (
archive_image,
delete_image,
get_image,
list_node_images,
select_image,
)
from backend.routes.node_routes import (
generate_node,
get_node,
list_workflow_nodes,
select_node_image,
update_node,
)
from backend.routes.profile_routes import (
create_profile,
create_quick_profile_draft,
@ -14,6 +28,13 @@ from backend.routes.profile_routes import (
update_profile,
)
from backend.routes.ui_routes import get_ui_bootstrap
from backend.routes.workflow_routes import (
archive_workflow,
create_profile_workflow,
get_workflow,
list_profile_workflows,
start_workflow,
)
from backend.services.dashboard_service import DashboardService
from backend.services.image_service import ImageService
from backend.services.profile_service import ProfileService
@ -235,6 +256,157 @@ storage:
self.assertIn("魔法学院学生", preview["base_prompt"])
self.assertIn("银白色 hair", preview["appearance_prompt"])
def test_workflow_node_image_routes_return_wrapped_responses(self):
profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
created_workflow = create_profile_workflow(
self.ctx,
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Single image"},
self.workflow_service,
)
self.assertTrue(created_workflow["ok"])
workflow = created_workflow["data"]["workflow"]
node = created_workflow["data"]["nodes"][0]
workflow_id = workflow["workflow_id"]
node_id = node["node_id"]
self.assertEqual(workflow["workflow_type"], "single_image")
self.assertEqual(node["node_key"], "virtual_single_image")
listed_workflows = list_profile_workflows(self.ctx, profile.profile_id, self.workflow_service)
self.assertTrue(listed_workflows["ok"])
self.assertEqual([item["workflow_id"] for item in listed_workflows["data"]], [workflow_id])
started = start_workflow(self.ctx, workflow_id, self.workflow_service)
self.assertTrue(started["ok"])
self.assertEqual(started["data"]["status"], "running")
detail = get_workflow(self.ctx, workflow_id, self.workflow_service)
self.assertTrue(detail["ok"])
self.assertEqual(detail["data"]["workflow"]["status"], "running")
self.assertEqual(detail["data"]["nodes"][0]["node_id"], node_id)
listed_nodes = list_workflow_nodes(self.ctx, workflow_id, self.workflow_service)
self.assertTrue(listed_nodes["ok"])
self.assertEqual(listed_nodes["data"][0]["node_id"], node_id)
updated_node = update_node(
self.ctx,
node_id,
{"prompt": "portrait, clean line art", "model_route": "image_low"},
self.workflow_service,
)
self.assertTrue(updated_node["ok"])
self.assertEqual(updated_node["data"]["prompt"], "portrait, clean line art")
generated = generate_node(
self.ctx,
node_id,
{"prompt_patch": "white shirt", "model_route": "image_low", "count": 2},
self.workflow_service,
)
self.assertTrue(generated["ok"])
self.assertIsNone(generated["data"]["task_id"])
self.assertEqual(generated["data"]["node_status"], "queued")
queued_node = get_node(self.ctx, node_id, self.workflow_service)
self.assertTrue(queued_node["ok"])
self.assertEqual(queued_node["data"]["status"], "queued")
self.assertTrue(queued_node["data"]["metadata"]["queue_placeholder"])
first_image = self.image_service.create_image(
{"node_id": node_id, "image_uri": "storage://images/first.png"},
self.ctx,
)
second_image = self.image_service.create_image(
{"node_id": node_id, "image_uri": "storage://images/second.png"},
self.ctx,
)
selected_by_node = select_node_image(
self.ctx,
node_id,
{"image_id": first_image.image_id},
self.image_service,
self.workflow_service,
)
self.assertTrue(selected_by_node["ok"])
self.assertTrue(selected_by_node["data"]["is_selected"])
selected_by_image = select_image(self.ctx, second_image.image_id, self.image_service)
self.assertTrue(selected_by_image["ok"])
self.assertTrue(selected_by_image["data"]["is_selected"])
self.assertFalse(get_image(self.ctx, first_image.image_id, self.image_service)["data"]["is_selected"])
self.assertEqual(
get_node(self.ctx, node_id, self.workflow_service)["data"]["selected_image_id"],
second_image.image_id,
)
visible_images = list_node_images(self.ctx, node_id, {}, self.image_service)
self.assertTrue(visible_images["ok"])
self.assertEqual(
{image["image_id"] for image in visible_images["data"]},
{first_image.image_id, second_image.image_id},
)
archived = archive_image(self.ctx, second_image.image_id, self.image_service)
self.assertTrue(archived["ok"])
self.assertTrue(archived["data"]["is_archived"])
visible_after_archive = list_node_images(self.ctx, node_id, {}, self.image_service)
self.assertEqual([image["image_id"] for image in visible_after_archive["data"]], [first_image.image_id])
all_images = list_node_images(
self.ctx,
node_id,
{"include_archived": "true"},
self.image_service,
)
self.assertEqual(
{image["image_id"] for image in all_images["data"]},
{first_image.image_id, second_image.image_id},
)
deleted = delete_image(self.ctx, first_image.image_id, self.image_service)
self.assertTrue(deleted["ok"])
missing = get_image(self.ctx, first_image.image_id, self.image_service)
self.assertFalse(missing["ok"])
self.assertEqual(missing["error_code"], "RESOURCE_NOT_FOUND")
archived_workflow = archive_workflow(self.ctx, workflow_id, self.workflow_service)
self.assertTrue(archived_workflow["ok"])
self.assertEqual(archived_workflow["data"]["status"], "archived")
def test_workflow_and_node_write_routes_require_write_permission(self):
profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied_workflow = create_profile_workflow(
read_only,
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Denied"},
self.workflow_service,
)
self.assertFalse(denied_workflow["ok"])
self.assertEqual(denied_workflow["error_code"], "FORBIDDEN")
workflow = self.workflow_service.create_workflow(
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Allowed"},
self.ctx,
)
denied_generate = generate_node(
read_only,
workflow.nodes[0].node_id,
{"model_route": "image_low"},
self.workflow_service,
)
self.assertFalse(denied_generate["ok"])
self.assertEqual(denied_generate["error_code"], "FORBIDDEN")
if __name__ == "__main__":
unittest.main()