65 行
3 KiB
Python
65 行
3 KiB
Python
"""Review service for workflow and node readiness checks."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from backend.dto.common import ApiError, ErrorCode
|
|
from backend.services.workflow_service import WorkflowService
|
|
from core.config_service import ConfigService
|
|
from core.config_writer import config_file_lock, dump_yaml, write_text_atomic
|
|
from database.db_helper import _load_yaml_subset
|
|
from database.repositories.image_repository import ImageRepository
|
|
from engines.review_flow import ReviewFlowEngine, ReviewPolicy
|
|
|
|
|
|
class ReviewService:
|
|
def __init__(
|
|
self,
|
|
workflow_service: WorkflowService,
|
|
image_repository: ImageRepository,
|
|
review_engine: ReviewFlowEngine | None = None,
|
|
config_service: ConfigService | None = None,
|
|
):
|
|
self.workflow_service = workflow_service
|
|
self.image_repository = image_repository
|
|
self.config_service = config_service or ConfigService()
|
|
self.review_engine = review_engine or ReviewFlowEngine(self._load_policy())
|
|
|
|
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 save_policy(self, payload: dict[str, Any]) -> dict[str, Any]:
|
|
validation = self.validate_policy(payload)
|
|
if not validation["valid"]:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "review policy validation failed", validation)
|
|
with config_file_lock(self.config_service.config_path):
|
|
config = self._load_config_mapping()
|
|
config["review_policy"] = validation["policy"]
|
|
write_text_atomic(self.config_service.config_path, dump_yaml(config))
|
|
self.review_engine = ReviewFlowEngine(ReviewPolicy.from_mapping(validation["policy"])[0])
|
|
return {"saved": True, "policy": self.get_policy()}
|
|
|
|
def review_node(self, node_id: str) -> dict[str, Any]:
|
|
node = self.workflow_service.get_node(node_id)
|
|
workflow = self.workflow_service.get_workflow(node.workflow_id).workflow
|
|
images = self.image_repository.list_by_node(node_id, include_archived=True)
|
|
return self.review_engine.review_node(node, images, workflow.metadata)
|
|
|
|
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)
|
|
|
|
def _load_policy(self) -> ReviewPolicy:
|
|
policy, errors = ReviewPolicy.from_mapping(self._load_config_mapping().get("review_policy", {}))
|
|
return ReviewPolicy() if errors else policy
|
|
|
|
def _load_config_mapping(self) -> dict[str, Any]:
|
|
path = self.config_service.config_path
|
|
if not path.exists():
|
|
return {}
|
|
return _load_yaml_subset(path.read_text(encoding="utf-8"))
|