diff --git a/backend/routes/review_routes.py b/backend/routes/review_routes.py new file mode 100644 index 0000000..0e0726e --- /dev/null +++ b/backend/routes/review_routes.py @@ -0,0 +1,57 @@ +"""Review route handlers.""" + +from __future__ import annotations + +from typing import Any + +from backend.routes.common import handle_request +from backend.services.review_service import ReviewService +from backend.services.workflow_service import WorkflowService +from core.audit_service import AuditService +from core.identity import RequestContext +from core.security import require_authenticated +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 review_node( + ctx: RequestContext, + node_id: str, + service: ReviewService | None = None, +) -> dict: + review_service = service or _create_review_service() + + def action() -> dict[str, Any]: + require_authenticated(ctx) + return review_service.review_node(node_id) + + return handle_request(ctx, action) + + +def review_workflow( + ctx: RequestContext, + workflow_id: str, + service: ReviewService | None = None, +) -> dict: + review_service = service or _create_review_service() + + def action() -> dict[str, Any]: + require_authenticated(ctx) + return review_service.review_workflow(workflow_id) + + return handle_request(ctx, action) + + +def _create_review_service() -> ReviewService: + database = Database(load_database_settings()) + workflow_service = WorkflowService( + workflow_repository=WorkflowRepository(database), + profile_repository=ProfileRepository(database), + audit_service=AuditService(database), + ) + return ReviewService( + workflow_service=workflow_service, + image_repository=ImageRepository(database), + ) diff --git a/backend/services/review_service.py b/backend/services/review_service.py new file mode 100644 index 0000000..3fed7bc --- /dev/null +++ b/backend/services/review_service.py @@ -0,0 +1,31 @@ +"""Review service for workflow and node readiness checks.""" + +from __future__ import annotations + +from typing import Any + +from backend.services.workflow_service import WorkflowService +from database.repositories.image_repository import ImageRepository +from engines.review_flow import ReviewFlowEngine + + +class ReviewService: + def __init__( + self, + workflow_service: WorkflowService, + image_repository: ImageRepository, + review_engine: ReviewFlowEngine | None = None, + ): + self.workflow_service = workflow_service + self.image_repository = image_repository + self.review_engine = review_engine or ReviewFlowEngine() + + def review_node(self, node_id: str) -> dict[str, Any]: + node = self.workflow_service.get_node(node_id) + images = self.image_repository.list_by_node(node_id, include_archived=True) + return self.review_engine.review_node(node, images) + + def review_workflow(self, workflow_id: str) -> dict[str, Any]: + detail = self.workflow_service.get_workflow(workflow_id) + node_results = [self.review_node(node.node_id) for node in detail.nodes] + return self.review_engine.review_workflow(detail.workflow, detail.nodes, node_results) diff --git a/engines/review_flow.py b/engines/review_flow.py index 319db3a..2ea8d76 100644 --- a/engines/review_flow.py +++ b/engines/review_flow.py @@ -1 +1,65 @@ -"""Review and stability-check workflow placeholder.""" +"""Lightweight workflow review checks.""" + +from __future__ import annotations + +from typing import Any + +from backend.dto.image_dto import GenerationImage +from backend.dto.workflow_dto import ProfileWorkflow, WorkflowNode + + +class ReviewFlowEngine: + def review_node(self, node: WorkflowNode, images: list[GenerationImage]) -> dict[str, Any]: + warnings: list[dict[str, Any]] = [] + errors: list[dict[str, Any]] = [] + if not images: + warnings.append({"code": "NO_IMAGES", "message": "node has no generated images"}) + if node.status in {"completed", "selected"} and not node.selected_image_id: + errors.append({"code": "MISSING_SELECTED_IMAGE", "message": "completed node has no selected image"}) + if node.selected_image_id and node.selected_image_id not in {image.image_id for image in images}: + errors.append({"code": "SELECTED_IMAGE_NOT_FOUND", "message": "selected image is not in node images"}) + if any(image.image_id == node.selected_image_id and image.is_archived for image in images): + errors.append({"code": "SELECTED_IMAGE_ARCHIVED", "message": "selected image is archived"}) + return { + "target_type": "node", + "target_id": node.node_id, + "passed": not errors, + "warnings": warnings, + "errors": errors, + "summary": { + "image_count": len(images), + "selected_image_id": node.selected_image_id, + "node_status": node.status, + }, + } + + def review_workflow( + self, + workflow: ProfileWorkflow, + nodes: list[WorkflowNode], + node_results: list[dict[str, Any]], + ) -> dict[str, Any]: + errors = [error for result in node_results for error in result["errors"]] + warnings = [warning for result in node_results for warning in result["warnings"]] + incomplete = [node.node_id for node in nodes if node.status not in {"completed", "selected", "skipped"}] + if incomplete: + warnings.append( + { + "code": "INCOMPLETE_NODES", + "message": "workflow has nodes that are not finished", + "node_ids": incomplete, + } + ) + return { + "target_type": "workflow", + "target_id": workflow.workflow_id, + "passed": not errors, + "warnings": warnings, + "errors": errors, + "summary": { + "workflow_type": workflow.workflow_type, + "node_count": len(nodes), + "incomplete_count": len(incomplete), + }, + "nodes": node_results, + } diff --git a/tests/test_review_service.py b/tests/test_review_service.py new file mode 100644 index 0000000..53c4593 --- /dev/null +++ b/tests/test_review_service.py @@ -0,0 +1,110 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from backend.routes.review_routes import review_node, review_workflow +from backend.services.history_service import HistoryService +from backend.services.image_service import ImageService +from backend.services.profile_service import ProfileService +from backend.services.review_service import ReviewService +from backend.services.workflow_service import WorkflowService +from core.audit_service import AuditService +from core.identity import RequestContext +from database.db_helper import Database, DatabaseSettings, SqliteSettings +from database.repositories.image_repository import ImageRepository +from database.repositories.profile_repository import ProfileRepository +from database.repositories.workflow_repository import WorkflowRepository + + +class ReviewServiceTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.database = Database( + DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db"))) + ) + self.database.initialize() + self.audit_service = AuditService(self.database) + self.profile_repository = ProfileRepository(self.database) + self.workflow_repository = WorkflowRepository(self.database) + self.image_repository = ImageRepository(self.database) + self.profile_service = ProfileService(self.profile_repository, self.audit_service) + self.workflow_service = WorkflowService( + self.workflow_repository, + self.profile_repository, + self.audit_service, + ) + self.image_service = ImageService( + self.image_repository, + self.workflow_repository, + self.audit_service, + ) + self.history_service = HistoryService( + self.workflow_repository, + self.workflow_service, + self.image_service, + self.audit_service, + ) + self.review_service = ReviewService(self.workflow_service, self.image_repository) + self.ctx = RequestContext.from_astrbot( + username="admin", + user_id="user_001", + permissions={"can_write"}, + ) + self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) + self.workflow = self.workflow_service.create_workflow( + self.profile.profile_id, + {"workflow_type": "character_fast", "display_name": "Fast"}, + self.ctx, + ) + + def tearDown(self): + self.tmp.cleanup() + + def test_review_node_warns_without_images_and_errors_without_selected_image(self): + node = self.workflow.nodes[0] + + empty = self.review_service.review_node(node.node_id) + self.assertTrue(empty["passed"]) + self.assertEqual(empty["warnings"][0]["code"], "NO_IMAGES") + + self.workflow_service.update_node(node.node_id, {"status": "completed"}, self.ctx) + missing_selection = self.review_service.review_node(node.node_id) + self.assertFalse(missing_selection["passed"]) + self.assertEqual(missing_selection["errors"][0]["code"], "MISSING_SELECTED_IMAGE") + + def test_review_passes_after_image_adoption(self): + node = self.workflow.nodes[1] + image = self.image_service.create_image( + { + "node_id": node.node_id, + "image_uri": "storage://images/fast.png", + "positive_prompt": "fast character", + }, + self.ctx, + ) + self.history_service.adopt_node_image(node.node_id, {"image_id": image.image_id}, self.ctx) + + result = self.review_service.review_node(node.node_id) + + self.assertTrue(result["passed"]) + self.assertEqual(result["summary"]["selected_image_id"], image.image_id) + + def test_review_routes_require_authentication(self): + node = self.workflow.nodes[0] + response = review_node(self.ctx, node.node_id, self.review_service) + self.assertTrue(response["ok"]) + + workflow_response = review_workflow(self.ctx, self.workflow.workflow.workflow_id, self.review_service) + self.assertTrue(workflow_response["ok"]) + self.assertEqual(workflow_response["data"]["summary"]["node_count"], 3) + + anonymous = RequestContext() + denied = review_node(anonymous, node.node_id, self.review_service) + self.assertFalse(denied["ok"]) + self.assertEqual(denied["error_code"], "UNAUTHORIZED") + + +if __name__ == "__main__": + unittest.main()