Add review policy backend endpoints

这个提交存在于:
YokiiroBW 2026-07-05 19:20:54 +08:00
父节点 0cac283b08
当前提交 9de0996eb6
共有 5 个文件被更改,包括 210 次插入 和 8 次删除

查看文件

@ -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"),

查看文件

@ -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(

查看文件

@ -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)

查看文件

@ -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)

查看文件

@ -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()