feat(workbench): add runtime GIS and sample integrations
This commit is contained in:
@@ -0,0 +1,244 @@
|
||||
"""Read-only workbench runtime aggregation."""
|
||||
|
||||
import logging
|
||||
from contextlib import asynccontextmanager
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
||||
from psycopg import AsyncConnection
|
||||
from pydantic import ValidationError
|
||||
|
||||
from app.auth.project_dependencies import (
|
||||
ProjectContext,
|
||||
get_project_context,
|
||||
get_project_pg_connection,
|
||||
)
|
||||
from app.domain.schemas.workbench_runtime import (
|
||||
WorkbenchAnalysisHistoryPage,
|
||||
WorkbenchPersistedAlert,
|
||||
WorkbenchRuntimeLatestAnalysis,
|
||||
WorkbenchRuntimeSnapshot,
|
||||
WorkbenchRuntimeWorkOrder,
|
||||
)
|
||||
from app.domain.schemas.task_alert import TaskAlertCommand, TaskAlertEvent, TaskAlertState
|
||||
from app.infra.db.postgresql.analysis import AnalysisRepository
|
||||
from app.infra.db.postgresql.workbench_operations import (
|
||||
WorkbenchOperationsRepository,
|
||||
)
|
||||
from app.infra.db.postgresql.task_alerts import TaskAlertRepository
|
||||
from app.services.task_alerts import TaskAlertService
|
||||
from app.domain.domain_errors import DomainError
|
||||
from app.services.workbench_runtime import (
|
||||
build_workbench_runtime_snapshot,
|
||||
project_analysis_history_item,
|
||||
project_latest_analysis,
|
||||
project_sensor_location_map_payload,
|
||||
sensor_location_ids_for_map_projection,
|
||||
)
|
||||
|
||||
router = APIRouter()
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def _projection_transaction(conn: AsyncConnection):
|
||||
"""Isolate an optional projection so one SQL failure cannot poison others."""
|
||||
transaction = getattr(conn, "transaction", None)
|
||||
if transaction is None: # Lightweight endpoint test doubles.
|
||||
yield
|
||||
return
|
||||
async with transaction():
|
||||
yield
|
||||
|
||||
|
||||
@router.get(
|
||||
"/workbench/analysis-runs",
|
||||
response_model=WorkbenchAnalysisHistoryPage,
|
||||
)
|
||||
async def workbench_analysis_runs(
|
||||
limit: int = Query(default=20, ge=1, le=100),
|
||||
offset: int = Query(default=0, ge=0),
|
||||
conn: AsyncConnection = Depends(get_project_pg_connection),
|
||||
):
|
||||
"""Return a bounded, sanitized analysis history page for the workbench."""
|
||||
rows = await AnalysisRepository.list_run_summaries(
|
||||
conn,
|
||||
limit=limit + 1,
|
||||
offset=offset,
|
||||
)
|
||||
has_more = len(rows) > limit
|
||||
items = rows[:limit]
|
||||
return {
|
||||
"items": [project_analysis_history_item(run) for run in items],
|
||||
"limit": limit,
|
||||
"offset": offset,
|
||||
"next_offset": offset + limit if has_more else None,
|
||||
}
|
||||
|
||||
|
||||
@router.get(
|
||||
"/workbench/analysis-runs/{run_id}",
|
||||
response_model=WorkbenchRuntimeLatestAnalysis,
|
||||
)
|
||||
async def workbench_analysis_run(
|
||||
run_id: UUID,
|
||||
conn: AsyncConnection = Depends(get_project_pg_connection),
|
||||
):
|
||||
"""Return one authorized project's analysis run as a typed workbench artifact."""
|
||||
run = await AnalysisRepository.get_run(conn, run_id)
|
||||
if run is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND,
|
||||
detail="Analysis run not found",
|
||||
)
|
||||
results = await AnalysisRepository.list_recent_results(conn, run_id, limit=100)
|
||||
try:
|
||||
referenced_map_payload = await _sensor_location_map_payload(conn, results)
|
||||
except Exception:
|
||||
referenced_map_payload = None
|
||||
logger.warning(
|
||||
"Workbench analysis spatial references are unavailable",
|
||||
exc_info=True,
|
||||
)
|
||||
return project_latest_analysis(
|
||||
run,
|
||||
results,
|
||||
referenced_map_payload=referenced_map_payload,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/workbench/task-alert-events", response_model=TaskAlertState)
|
||||
async def push_task_alert_event(
|
||||
command: TaskAlertCommand,
|
||||
ctx: ProjectContext = Depends(get_project_context),
|
||||
conn: AsyncConnection = Depends(get_project_pg_connection),
|
||||
):
|
||||
try:
|
||||
event = TaskAlertEvent(
|
||||
**command.model_dump(),
|
||||
producer_id=f"principal:{ctx.user_id}",
|
||||
)
|
||||
return await TaskAlertService(
|
||||
TaskAlertRepository(conn, ctx.project_id), ctx
|
||||
).push(event)
|
||||
except DomainError as exc:
|
||||
raise HTTPException(status_code=exc.status, detail=exc.message) from exc
|
||||
|
||||
|
||||
@router.get("/workbench/runtime", response_model=WorkbenchRuntimeSnapshot)
|
||||
async def workbench_runtime(
|
||||
ctx: ProjectContext = Depends(get_project_context),
|
||||
conn: AsyncConnection = Depends(get_project_pg_connection),
|
||||
):
|
||||
analysis_runs: list[dict] | None = None
|
||||
latest_results: list[dict] | None = None
|
||||
latest_analysis_map_payload: dict | None = None
|
||||
analysis_availability = "not_configured"
|
||||
work_order_storage_configured = False
|
||||
work_orders: list[dict] | None = None
|
||||
alert_storage_configured = False
|
||||
alerts: list[dict] | None = None
|
||||
schedule_availability = "not_configured"
|
||||
work_order_availability = "not_configured"
|
||||
alert_availability = "not_configured"
|
||||
try:
|
||||
async with _projection_transaction(conn):
|
||||
analysis_runs = await AnalysisRepository.list_recent_runs(conn, limit=100)
|
||||
if analysis_runs:
|
||||
latest_results = await AnalysisRepository.list_recent_results(
|
||||
conn, analysis_runs[0]["run_id"], limit=100
|
||||
)
|
||||
analysis_availability = "ready" if analysis_runs else "not_configured"
|
||||
except Exception:
|
||||
logger.warning("Workbench analysis projection is unavailable", exc_info=True)
|
||||
analysis_runs = None
|
||||
latest_results = None
|
||||
analysis_availability = "degraded"
|
||||
if analysis_runs and latest_results:
|
||||
try:
|
||||
async with _projection_transaction(conn):
|
||||
latest_analysis_map_payload = await _sensor_location_map_payload(
|
||||
conn, latest_results
|
||||
)
|
||||
except Exception:
|
||||
logger.warning(
|
||||
"Workbench analysis spatial references are unavailable",
|
||||
exc_info=True,
|
||||
)
|
||||
try:
|
||||
async with _projection_transaction(conn):
|
||||
operations_availability = await WorkbenchOperationsRepository.availability(conn)
|
||||
work_order_storage_configured = operations_availability.work_orders
|
||||
alert_storage_configured = operations_availability.alerts
|
||||
except Exception:
|
||||
logger.warning("Workbench operations storage probe is unavailable", exc_info=True)
|
||||
schedule_availability = "degraded"
|
||||
work_order_availability = "degraded"
|
||||
alert_availability = "degraded"
|
||||
if work_order_storage_configured:
|
||||
try:
|
||||
async with _projection_transaction(conn):
|
||||
work_order_documents = await WorkbenchOperationsRepository.list_work_orders(
|
||||
conn, str(ctx.project_id)
|
||||
)
|
||||
work_orders, invalid_work_orders = _validate_documents(
|
||||
work_order_documents, WorkbenchRuntimeWorkOrder, "work order"
|
||||
)
|
||||
work_order_availability = (
|
||||
"degraded" if invalid_work_orders else "ready"
|
||||
)
|
||||
except Exception:
|
||||
work_orders = None
|
||||
work_order_availability = "degraded"
|
||||
logger.warning("Workbench work-order projection is unavailable", exc_info=True)
|
||||
if alert_storage_configured:
|
||||
try:
|
||||
async with _projection_transaction(conn):
|
||||
alert_documents = await WorkbenchOperationsRepository.list_alerts(
|
||||
conn, str(ctx.project_id)
|
||||
)
|
||||
alerts, invalid_alerts = _validate_documents(
|
||||
alert_documents, WorkbenchPersistedAlert, "alert"
|
||||
)
|
||||
alert_availability = "degraded" if invalid_alerts else "ready"
|
||||
except Exception:
|
||||
alerts = None
|
||||
alert_availability = "degraded"
|
||||
logger.warning("Workbench alert projection is unavailable", exc_info=True)
|
||||
return await build_workbench_runtime_snapshot(
|
||||
analysis_runs=analysis_runs,
|
||||
latest_analysis_results=latest_results,
|
||||
latest_analysis_map_payload=latest_analysis_map_payload,
|
||||
work_order_storage_configured=work_order_storage_configured,
|
||||
work_orders=work_orders,
|
||||
alert_storage_configured=alert_storage_configured,
|
||||
persisted_alerts=alerts,
|
||||
scenario_availability=analysis_availability,
|
||||
artifact_availability=analysis_availability,
|
||||
schedule_availability=schedule_availability,
|
||||
work_order_availability=work_order_availability,
|
||||
alert_availability=alert_availability,
|
||||
projection_degraded=False,
|
||||
)
|
||||
|
||||
|
||||
async def _sensor_location_map_payload(
|
||||
conn: AsyncConnection, results: list[dict]
|
||||
) -> dict | None:
|
||||
node_ids = sensor_location_ids_for_map_projection(results)
|
||||
if not node_ids:
|
||||
return None
|
||||
map_points = await AnalysisRepository.list_junction_map_points(conn, node_ids)
|
||||
return project_sensor_location_map_payload(node_ids, map_points)
|
||||
|
||||
|
||||
def _validate_documents(documents, model, label: str) -> tuple[list[dict], int]:
|
||||
valid: list[dict] = []
|
||||
rejected = 0
|
||||
for document in documents:
|
||||
try:
|
||||
valid.append(model.model_validate(document).model_dump())
|
||||
except ValidationError:
|
||||
rejected += 1
|
||||
logger.warning("Workbench %s document was rejected", label)
|
||||
return valid, rejected
|
||||
Reference in New Issue
Block a user