From e98f32ebfbefdcb31bf6697cb28a3d586d2ac30f Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Sun, 5 Jul 2026 09:00:36 +0800 Subject: [PATCH] feat: add workflow node image route handlers --- backend/routes/image_routes.py | 118 ++++++++++++++++++ backend/routes/node_routes.py | 193 ++++++++++++++++++++++++++++++ backend/routes/workflow_routes.py | 120 +++++++++++++++++++ tests/test_s2_routes.py | 172 ++++++++++++++++++++++++++ 4 files changed, 603 insertions(+) create mode 100644 backend/routes/image_routes.py create mode 100644 backend/routes/node_routes.py create mode 100644 backend/routes/workflow_routes.py diff --git a/backend/routes/image_routes.py b/backend/routes/image_routes.py new file mode 100644 index 0000000..fac5e02 --- /dev/null +++ b/backend/routes/image_routes.py @@ -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) diff --git a/backend/routes/node_routes.py b/backend/routes/node_routes.py new file mode 100644 index 0000000..ffdfd71 --- /dev/null +++ b/backend/routes/node_routes.py @@ -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), + ) diff --git a/backend/routes/workflow_routes.py b/backend/routes/workflow_routes.py new file mode 100644 index 0000000..ffc2570 --- /dev/null +++ b/backend/routes/workflow_routes.py @@ -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), + ) diff --git a/tests/test_s2_routes.py b/tests/test_s2_routes.py index e38e726..502921c 100644 --- a/tests/test_s2_routes.py +++ b/tests/test_s2_routes.py @@ -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()