diff --git a/backend/route_registry.py b/backend/route_registry.py index 6d3df5f..99090b8 100644 --- a/backend/route_registry.py +++ b/backend/route_registry.py @@ -54,6 +54,8 @@ ROUTES: tuple[RouteSpec, ...] = ( RouteSpec("POST", "nodes/{node_id}/mark-completed", "backend.routes.node_routes.mark_node_completed", "write"), RouteSpec("POST", "nodes/{node_id}/select-image", "backend.routes.node_routes.select_node_image", "write"), RouteSpec("POST", "nodes/{node_id}/adopt-image", "backend.routes.history_routes.adopt_node_image", "write"), + RouteSpec("GET", "review/policy", "backend.routes.review_routes.get_review_policy", "read"), + RouteSpec("POST", "review/policy/validate", "backend.routes.review_routes.validate_review_policy", "config"), RouteSpec("GET", "nodes/{node_id}/review", "backend.routes.review_routes.review_node", "read"), RouteSpec("GET", "nodes/{node_id}/images", "backend.routes.image_routes.list_node_images", "read"), RouteSpec("GET", "workflows/{workflow_id}/review", "backend.routes.review_routes.review_workflow", "read"), diff --git a/backend/routes/review_routes.py b/backend/routes/review_routes.py index 0e0726e..0d7b664 100644 --- a/backend/routes/review_routes.py +++ b/backend/routes/review_routes.py @@ -9,7 +9,7 @@ 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 core.security import require_authenticated, require_config_manager from database.db_helper import Database, load_database_settings from database.repositories.image_repository import ImageRepository from database.repositories.profile_repository import ProfileRepository @@ -44,6 +44,33 @@ def review_workflow( return handle_request(ctx, action) +def get_review_policy( + ctx: RequestContext, + service: ReviewService | None = None, +) -> dict: + review_service = service or _create_review_service() + + def action() -> dict[str, Any]: + require_authenticated(ctx) + return review_service.get_policy() + + return handle_request(ctx, action) + + +def validate_review_policy( + ctx: RequestContext, + payload: dict[str, Any], + service: ReviewService | None = None, +) -> dict: + review_service = service or _create_review_service() + + def action() -> dict[str, Any]: + require_config_manager(ctx) + return review_service.validate_policy(payload) + + return handle_request(ctx, action) + + def _create_review_service() -> ReviewService: database = Database(load_database_settings()) workflow_service = WorkflowService( diff --git a/backend/services/review_service.py b/backend/services/review_service.py index 3fed7bc..78c579c 100644 --- a/backend/services/review_service.py +++ b/backend/services/review_service.py @@ -20,6 +20,12 @@ class ReviewService: self.image_repository = image_repository self.review_engine = review_engine or ReviewFlowEngine() + def get_policy(self) -> dict[str, Any]: + return self.review_engine.policy_snapshot() + + def validate_policy(self, payload: dict[str, Any]) -> dict[str, Any]: + return self.review_engine.validate_policy(payload) + 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) diff --git a/engines/review_flow.py b/engines/review_flow.py index 2ea8d76..80a1d3f 100644 --- a/engines/review_flow.py +++ b/engines/review_flow.py @@ -2,23 +2,127 @@ from __future__ import annotations +from dataclasses import dataclass from typing import Any from backend.dto.image_dto import GenerationImage from backend.dto.workflow_dto import ProfileWorkflow, WorkflowNode +_KNOWN_NODE_STATUSES = { + "draft", + "pending", + "queued", + "running", + "completed", + "selected", + "failed", + "cancelled", + "skipped", + "discarded", +} + + +@dataclass(frozen=True) +class ReviewPolicy: + version: str = "default-v1" + warn_without_images: bool = True + require_selected_image_for_statuses: tuple[str, ...] = ("completed", "selected") + fail_on_selected_image_not_found: bool = True + fail_on_archived_selected_image: bool = True + workflow_terminal_statuses: tuple[str, ...] = ("completed", "selected", "skipped") + + def to_dict(self) -> dict[str, Any]: + return { + "version": self.version, + "warn_without_images": self.warn_without_images, + "require_selected_image_for_statuses": list(self.require_selected_image_for_statuses), + "fail_on_selected_image_not_found": self.fail_on_selected_image_not_found, + "fail_on_archived_selected_image": self.fail_on_archived_selected_image, + "workflow_terminal_statuses": list(self.workflow_terminal_statuses), + } + + @classmethod + def from_mapping(cls, payload: dict[str, Any]) -> tuple["ReviewPolicy", list[dict[str, Any]]]: + errors: list[dict[str, Any]] = [] + defaults = cls() + values: dict[str, Any] = {} + + for field_name in ( + "warn_without_images", + "fail_on_selected_image_not_found", + "fail_on_archived_selected_image", + ): + value = payload.get(field_name, getattr(defaults, field_name)) + if not isinstance(value, bool): + errors.append( + { + "field": field_name, + "code": "INVALID_BOOLEAN", + "message": f"{field_name} must be a boolean", + } + ) + value = getattr(defaults, field_name) + values[field_name] = value + + for field_name in ("require_selected_image_for_statuses", "workflow_terminal_statuses"): + value = payload.get(field_name, getattr(defaults, field_name)) + normalized = _normalize_status_list(value) + if not normalized: + errors.append( + { + "field": field_name, + "code": "INVALID_STATUS_LIST", + "message": f"{field_name} must contain at least one known node status", + } + ) + normalized = getattr(defaults, field_name) + unknown = [status for status in normalized if status not in _KNOWN_NODE_STATUSES] + if unknown: + errors.append( + { + "field": field_name, + "code": "UNKNOWN_STATUS", + "message": f"{field_name} contains unknown statuses", + "statuses": unknown, + } + ) + normalized = tuple(status for status in normalized if status in _KNOWN_NODE_STATUSES) + if not normalized: + normalized = getattr(defaults, field_name) + values[field_name] = normalized + + version = str(payload.get("version") or defaults.version).strip() or defaults.version + return cls(version=version, **values), errors + + class ReviewFlowEngine: + def __init__(self, policy: ReviewPolicy | None = None): + self.policy = policy or ReviewPolicy() + + def policy_snapshot(self) -> dict[str, Any]: + return self.policy.to_dict() + + def validate_policy(self, payload: dict[str, Any]) -> dict[str, Any]: + policy, errors = ReviewPolicy.from_mapping(payload) + return {"valid": not errors, "policy": policy.to_dict(), "errors": errors} + 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: + if self.policy.warn_without_images and 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: + if node.status in self.policy.require_selected_image_for_statuses 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}: + if ( + self.policy.fail_on_selected_image_not_found + and 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): + if self.policy.fail_on_archived_selected_image and 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", @@ -30,6 +134,7 @@ class ReviewFlowEngine: "image_count": len(images), "selected_image_id": node.selected_image_id, "node_status": node.status, + "policy_version": self.policy.version, }, } @@ -41,7 +146,7 @@ class ReviewFlowEngine: ) -> 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"}] + incomplete = [node.node_id for node in nodes if node.status not in self.policy.workflow_terminal_statuses] if incomplete: warnings.append( { @@ -60,6 +165,23 @@ class ReviewFlowEngine: "workflow_type": workflow.workflow_type, "node_count": len(nodes), "incomplete_count": len(incomplete), + "policy_version": self.policy.version, }, "nodes": node_results, } + + +def _normalize_status_list(value: Any) -> tuple[str, ...]: + if isinstance(value, str): + candidates = [value] + elif isinstance(value, (list, tuple)): + candidates = value + else: + return () + + statuses: list[str] = [] + for item in candidates: + status = str(item or "").strip() + if status and status not in statuses: + statuses.append(status) + return tuple(statuses) diff --git a/tests/test_review_service.py b/tests/test_review_service.py index 53c4593..c2840f4 100644 --- a/tests/test_review_service.py +++ b/tests/test_review_service.py @@ -4,7 +4,7 @@ import tempfile import unittest from pathlib import Path -from backend.routes.review_routes import review_node, review_workflow +from backend.routes.review_routes import get_review_policy, review_node, review_workflow, validate_review_policy from backend.services.history_service import HistoryService from backend.services.image_service import ImageService from backend.services.profile_service import ProfileService @@ -50,7 +50,7 @@ class ReviewServiceTests(unittest.TestCase): self.ctx = RequestContext.from_astrbot( username="admin", user_id="user_001", - permissions={"can_write"}, + permissions={"can_write", "can_manage_config"}, ) self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) self.workflow = self.workflow_service.create_workflow( @@ -105,6 +105,51 @@ class ReviewServiceTests(unittest.TestCase): self.assertFalse(denied["ok"]) self.assertEqual(denied["error_code"], "UNAUTHORIZED") + def test_review_policy_is_exposed_and_validated(self): + policy_response = get_review_policy(self.ctx, self.review_service) + + self.assertTrue(policy_response["ok"]) + self.assertEqual(policy_response["data"]["version"], "default-v1") + self.assertIn("completed", policy_response["data"]["require_selected_image_for_statuses"]) + + valid_response = validate_review_policy( + self.ctx, + { + "version": "custom-v1", + "warn_without_images": False, + "require_selected_image_for_statuses": ["selected"], + "workflow_terminal_statuses": ["selected", "skipped"], + }, + self.review_service, + ) + self.assertTrue(valid_response["ok"]) + self.assertTrue(valid_response["data"]["valid"]) + self.assertFalse(valid_response["data"]["policy"]["warn_without_images"]) + self.assertEqual(valid_response["data"]["policy"]["version"], "custom-v1") + + invalid_response = validate_review_policy( + self.ctx, + { + "warn_without_images": "yes", + "workflow_terminal_statuses": ["selected", "unknown"], + }, + self.review_service, + ) + self.assertTrue(invalid_response["ok"]) + self.assertFalse(invalid_response["data"]["valid"]) + self.assertEqual( + [error["code"] for error in invalid_response["data"]["errors"]], + ["INVALID_BOOLEAN", "UNKNOWN_STATUS"], + ) + + def test_review_policy_validation_requires_config_permission(self): + read_only = RequestContext.from_astrbot(username="reader", user_id="user_002", permissions=set()) + + response = validate_review_policy(read_only, {}, self.review_service) + + self.assertFalse(response["ok"]) + self.assertEqual(response["error_code"], "FORBIDDEN") + if __name__ == "__main__": unittest.main()