Add poll-backed scheduling backend

src/govoplan_scheduling/backend/router.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
+from govoplan_core.auth import ApiPrincipal, get_api_principal, has_scope
+from govoplan_core.db.session import get_session
+from govoplan_poll.backend.schemas import PollResultSummaryResponse
+from govoplan_scheduling.backend.manifest import READ_SCOPE, WRITE_SCOPE
+from govoplan_scheduling.backend.schemas import (
+    SchedulingDecisionRequest,
+    SchedulingRequestCreateRequest,
+    SchedulingRequestListResponse,
+    SchedulingRequestResponse,
+    SchedulingRequestUpdateRequest,
+    SchedulingStatusResponse,
+    SchedulingSummaryResponse,
+)
+from govoplan_scheduling.backend.service import (
+    SchedulingError,
+    cancel_scheduling_request,
+    close_scheduling_request,
+    create_scheduling_request,
+    decide_scheduling_request,
+    get_scheduling_request,
+    list_scheduling_requests,
+    open_scheduling_request,
+    scheduling_request_response,
+    scheduling_request_summary,
+    update_scheduling_request,
+)
+
+
+router = APIRouter(prefix="/scheduling", tags=["scheduling"])
+
+
+def _require_scope(principal: ApiPrincipal, scope: str) -> None:
+    if not has_scope(principal, scope):
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=f"Missing scope: {scope}")
+
+
+def _scheduling_http_error(exc: SchedulingError) -> HTTPException:
+    if str(exc) == "Scheduling request not found":
+        return HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc))
+    return HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc))
+
+
+def _request_response(request, *, invitation_tokens: dict[str, str] | None = None) -> SchedulingRequestResponse:
+    return SchedulingRequestResponse.model_validate(
+        scheduling_request_response(request, invitation_tokens=invitation_tokens)
+    )
+
+
+@router.get("/requests", response_model=SchedulingRequestListResponse)
+def api_list_scheduling_requests(
+    status_filter: str | None = Query(default=None, alias="status"),
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingRequestListResponse:
+    _require_scope(principal, READ_SCOPE)
+    requests = list_scheduling_requests(session, tenant_id=principal.tenant_id, status=status_filter)
+    return SchedulingRequestListResponse(requests=[_request_response(request) for request in requests])
+
+
+@router.post("/requests", response_model=SchedulingRequestResponse, status_code=status.HTTP_201_CREATED)
+def api_create_scheduling_request(
+    payload: SchedulingRequestCreateRequest,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingRequestResponse:
+    _require_scope(principal, WRITE_SCOPE)
+    try:
+        request, invitation_tokens = create_scheduling_request(
+            session,
+            tenant_id=principal.tenant_id,
+            user_id=principal.account_id,
+            payload=payload,
+        )
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+    return _request_response(request, invitation_tokens=invitation_tokens)
+
+
+@router.get("/requests/{request_id}", response_model=SchedulingRequestResponse)
+def api_get_scheduling_request(
+    request_id: str,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingRequestResponse:
+    _require_scope(principal, READ_SCOPE)
+    try:
+        return _request_response(get_scheduling_request(session, tenant_id=principal.tenant_id, request_id=request_id))
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+
+
+@router.patch("/requests/{request_id}", response_model=SchedulingRequestResponse)
+def api_update_scheduling_request(
+    request_id: str,
+    payload: SchedulingRequestUpdateRequest,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingRequestResponse:
+    _require_scope(principal, WRITE_SCOPE)
+    try:
+        return _request_response(
+            update_scheduling_request(session, tenant_id=principal.tenant_id, request_id=request_id, payload=payload)
+        )
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+
+
+@router.post("/requests/{request_id}/open", response_model=SchedulingStatusResponse)
+def api_open_scheduling_request(
+    request_id: str,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingStatusResponse:
+    _require_scope(principal, WRITE_SCOPE)
+    try:
+        request = open_scheduling_request(session, tenant_id=principal.tenant_id, request_id=request_id)
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+    return SchedulingStatusResponse(request=_request_response(request))
+
+
+@router.post("/requests/{request_id}/close", response_model=SchedulingStatusResponse)
+def api_close_scheduling_request(
+    request_id: str,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingStatusResponse:
+    _require_scope(principal, WRITE_SCOPE)
+    try:
+        request = close_scheduling_request(session, tenant_id=principal.tenant_id, request_id=request_id)
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+    return SchedulingStatusResponse(request=_request_response(request))
+
+
+@router.post("/requests/{request_id}/decide", response_model=SchedulingStatusResponse)
+def api_decide_scheduling_request(
+    request_id: str,
+    payload: SchedulingDecisionRequest,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingStatusResponse:
+    _require_scope(principal, WRITE_SCOPE)
+    try:
+        request = decide_scheduling_request(session, tenant_id=principal.tenant_id, request_id=request_id, payload=payload)
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+    return SchedulingStatusResponse(request=_request_response(request))
+
+
+@router.post("/requests/{request_id}/cancel", response_model=SchedulingStatusResponse)
+def api_cancel_scheduling_request(
+    request_id: str,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingStatusResponse:
+    _require_scope(principal, WRITE_SCOPE)
+    try:
+        request = cancel_scheduling_request(session, tenant_id=principal.tenant_id, request_id=request_id)
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+    return SchedulingStatusResponse(request=_request_response(request))
+
+
+@router.get("/requests/{request_id}/summary", response_model=SchedulingSummaryResponse)
+def api_scheduling_summary(
+    request_id: str,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(get_api_principal),
+) -> SchedulingSummaryResponse:
+    _require_scope(principal, READ_SCOPE)
+    try:
+        request = get_scheduling_request(session, tenant_id=principal.tenant_id, request_id=request_id)
+        summary = scheduling_request_summary(session, tenant_id=principal.tenant_id, request_id=request_id)
+    except SchedulingError as exc:
+        raise _scheduling_http_error(exc) from exc
+    return SchedulingSummaryResponse(
+        request=_request_response(request),
+        poll_summary=PollResultSummaryResponse.model_validate(summary),
+    )