"""SCADA replay controls. Manual steps are processed by the command request.""" from uuid import UUID from datetime import datetime from fastapi import APIRouter, Depends, Query, HTTPException from app.auth.metadata_dependencies import get_metadata_repository from app.auth.permissions import SCADA_VIEW, SCADA_CLEAN, require_permission, permissions_for_context from app.auth.project_dependencies import ProjectContext, get_project_pg_connection, get_project_timescale_connection from app.domain.schemas.scada_replay import ( ScadaReplayCapabilities, ScadaReplayCreate, ScadaReplayCommand, ScadaReplaySnapshot, ScadaReplayEventsPage, ScadaReplayReadings, ) from app.infra.db.postgresql.scada_replays import ScadaReplayRepository from app.domain.schemas.project_settings import ProjectSettings from app.services.scada_replay import ScadaReplayService, snapshot from app.domain.schemas.periodic_task import PeriodicTaskPage, PeriodicTaskExecution, PeriodicTaskRetry from app.services.periodic_tasks import ( ensure_periodic_tasks, initialize_periodic_tasks, project_periodic_state, project_periodic_tasks, retry_periodic_task, require_execution_permissions, ) router = APIRouter(prefix="/scada-replays", tags=["SCADA Replay"]) async def repository( ctx: ProjectContext = Depends(require_permission(SCADA_VIEW)), connection=Depends(get_project_pg_connection), ): return ScadaReplayRepository(connection, ctx.project_id) async def project_settings( ctx: ProjectContext = Depends(require_permission(SCADA_VIEW)), metadata_repo=Depends(get_metadata_repository), ) -> ProjectSettings: project = await metadata_repo.get_project_by_id(ctx.project_id) if project is None: raise HTTPException(404, "当前项目不存在") return ProjectSettings.model_validate(project.settings or {}) @router.get("/capabilities", response_model=ScadaReplayCapabilities) async def replay_capabilities(repo=Depends(repository), ctx=Depends(require_permission(SCADA_VIEW)), settings=Depends(project_settings)): available = await repo.available() current = await repo.current() if available else None if current and current.get("config", {}).get("scheduled_tasks_enabled"): current = await project_periodic_state(repo, current) monitoring = settings.scada_monitoring monitoring_ready = bool( monitoring and len(monitoring.pressure_device_ids) >= 5 and (monitoring.decision_policy == "weighted" or monitoring.outlet_flow_device_ids) ) if monitoring_ready: monitoring_reason = None elif monitoring is None: monitoring_reason = "项目尚未配置压力监测角色及组合判定规则" elif len(monitoring.pressure_device_ids) < 5: monitoring_reason = "爆管侦测至少需要 5 个压力监测设备" else: monitoring_reason = "项目尚未配置出厂边界流量设备" return ScadaReplayCapabilities( available=available, can_write=SCADA_CLEAN in permissions_for_context(ctx), reason=None if available else "需先部署 SCADA 回放存储结构", monitoring_interval_seconds=settings.scada_monitoring_interval_seconds, burst_monitoring_ready=monitoring_ready, burst_monitoring_reason=monitoring_reason, monitoring_config=monitoring, current=snapshot(current) if current else None, ) @router.post("", response_model=ScadaReplaySnapshot, status_code=201) async def create_replay(command: ScadaReplayCreate, repo=Depends(repository), ctx=Depends(require_permission(SCADA_CLEAN)), settings=Depends(project_settings)): if command.scheduled_tasks_enabled: require_execution_permissions(ctx) result = await ScadaReplayService(repo, ctx).create( command, monitoring_interval_seconds=settings.scada_monitoring_interval_seconds, monitoring_config=settings.scada_monitoring, ) if command.scheduled_tasks_enabled: await initialize_periodic_tasks(repo, ctx, result.replay_id) return result @router.get("/{replay_id}", response_model=ScadaReplaySnapshot) async def get_replay(replay_id: UUID, repo=Depends(repository)): await ScadaReplayService(repo, None).ensure_storage() return snapshot(await project_periodic_state(repo, await repo.get(replay_id))) @router.post("/{replay_id}/commands", response_model=ScadaReplaySnapshot) async def replay_command(replay_id: UUID, command: ScadaReplayCommand, repo=Depends(repository), ctx=Depends(require_permission(SCADA_CLEAN)), timescale=Depends(get_project_timescale_connection)): service = ScadaReplayService(repo, ctx, timescale) document = await repo.get(replay_id) if command.action != "stop" and document.get("config", {}).get("scheduled_tasks_enabled"): await ensure_periodic_tasks(repo, ctx, replay_id) result = await service.command(replay_id, command) if command.action in {"step", "monitor", "retry"} and result.step_pending: result = await service.process_pending_step(replay_id) if command.action != "stop" and getattr(result, "scheduled_tasks_enabled", False): await ensure_periodic_tasks(repo, ctx, replay_id) return snapshot(await project_periodic_state(repo, await repo.get(replay_id))) return result @router.get("/{replay_id}/scheduled-tasks", response_model=PeriodicTaskPage) async def scheduled_tasks(replay_id: UUID, offset: int = Query(0, ge=0), limit: int = Query(100, ge=1, le=200), repo=Depends(repository)): await ScadaReplayService(repo, None).ensure_storage() await repo.get(replay_id) items = await project_periodic_tasks(repo, replay_id, offset, limit + 1) return PeriodicTaskPage(items=items[:limit], next_offset=offset + limit if len(items) > limit else None) @router.post("/{replay_id}/scheduled-tasks/{execution_id}/retry", response_model=PeriodicTaskExecution) async def retry_scheduled_task(replay_id: UUID, execution_id: UUID, command: PeriodicTaskRetry, repo=Depends(repository), ctx=Depends(require_permission(SCADA_CLEAN))): return await retry_periodic_task(repo, ctx, replay_id, execution_id, command.request_id) @router.get("/{replay_id}/events", response_model=ScadaReplayEventsPage) async def replay_events(replay_id: UUID, offset: int = Query(0, ge=0), limit: int = Query(100, ge=1, le=200), repo=Depends(repository)): await ScadaReplayService(repo, None).ensure_storage() await repo.get(replay_id) items = await repo.events(replay_id, offset, limit + 1) return ScadaReplayEventsPage(items=items[:limit], next_offset=offset + limit if len(items) > limit else None) @router.get("/{replay_id}/observations", response_model=ScadaReplayReadings) async def replay_observations(replay_id: UUID, through: datetime, repo=Depends(repository)): await ScadaReplayService(repo, None).ensure_storage() document = await repo.get(replay_id) if (through.tzinfo is None or not document.get("delivered_until") or through > datetime.fromisoformat(document["delivered_until"]) or through < datetime.fromisoformat(document["start_time"])): raise HTTPException(422, "回看仅允许本轮已读取的时间区间") return ScadaReplayReadings( items=await repo.latest_outputs(replay_id, through), through=through, )