company-ai-platform/app/modules/risk/routes.py

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session

from app.core.background.task_queue import enqueue_risk_event_generation
from app.core.database import get_db
from app.core.security import ApiPrincipal, require_api_key, require_operations_enabled
from app.modules.risk.constants import RiskEventActionKey, RiskGenerationResultKey
from app.modules.risk.schemas import (
    RiskAssignRequest,
    RiskCloseRequest,
    RiskCommentRequest,
    RiskReopenRequest,
    RiskResolveRequest,
)
from app.modules.risk.services import RiskService

router = APIRouter(dependencies=[Depends(require_api_key)])


@router.get("/summary")
def risk_summary(
    db: Session = Depends(get_db),
) -> dict:
    return RiskService(db).summary()


@router.get("/overdue-tasks")
def overdue_tasks(
    db: Session = Depends(get_db),
) -> dict:
    return {RiskGenerationResultKey.ITEMS: RiskService(db).overdue_tasks()}


@router.get("/delayed-projects")
def delayed_projects(
    db: Session = Depends(get_db),
) -> dict:
    return {RiskGenerationResultKey.ITEMS: RiskService(db).delayed_projects()}


@router.get("/over-budget-projects")
def over_budget_projects(
    db: Session = Depends(get_db),
) -> dict:
    return {RiskGenerationResultKey.ITEMS: RiskService(db).over_budget_projects()}


@router.get("/funds")
def fund_risks(
    db: Session = Depends(get_db),
) -> dict:
    return {RiskGenerationResultKey.ITEMS: RiskService(db).fund_risks()}


@router.get("/suppliers")
def supplier_risks(
    db: Session = Depends(get_db),
) -> dict:
    return {RiskGenerationResultKey.ITEMS: RiskService(db).supplier_risks()}


@router.get("/events")
def risk_events(
    limit: int = Query(default=100, ge=1, le=500),
    status: str | None = None,
    db: Session = Depends(get_db),
) -> dict:
    return {
        RiskGenerationResultKey.ITEMS: RiskService(db).list_events(
            limit=limit,
            status_filter=status,
        )
    }


@router.get("/events/{event_id}/actions")
def risk_event_actions(
    event_id: int,
    limit: int = Query(default=100, ge=1, le=500),
    db: Session = Depends(get_db),
) -> dict:
    return {
        RiskEventActionKey.ITEMS: RiskService(db).list_actions(
            risk_event_id=event_id,
            limit=limit,
        )
    }


@router.post("/events/{event_id}/assign")
def assign_risk_event(
    event_id: int,
    payload: RiskAssignRequest,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    require_operations_enabled()
    return RiskService(db).assign_event(
        event_id,
        assigned_to=payload.assigned_to,
        comment=payload.comment,
        actor=principal.actor,
    )


@router.post("/events/{event_id}/comment")
def comment_risk_event(
    event_id: int,
    payload: RiskCommentRequest,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    require_operations_enabled()
    return RiskService(db).comment_event(
        event_id,
        comment=payload.comment,
        payload=payload.payload,
        actor=principal.actor,
    )


@router.post("/events/{event_id}/resolve")
def resolve_risk_event(
    event_id: int,
    payload: RiskResolveRequest,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    require_operations_enabled()
    return RiskService(db).resolve_event(
        event_id,
        comment=payload.comment,
        payload=payload.payload,
        actor=principal.actor,
    )


@router.post("/events/{event_id}/close")
def close_risk_event(
    event_id: int,
    payload: RiskCloseRequest,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    require_operations_enabled()
    return RiskService(db).close_event(
        event_id,
        closed_reason=payload.closed_reason,
        review_summary=payload.review_summary,
        actor=principal.actor,
    )


@router.post("/events/{event_id}/reopen")
def reopen_risk_event(
    event_id: int,
    payload: RiskReopenRequest,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    require_operations_enabled()
    return RiskService(db).reopen_event(
        event_id,
        comment=payload.comment,
        actor=principal.actor,
    )


@router.post("/events/generate")
def generate_risk_events(
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    require_operations_enabled()
    return RiskService(db).generate_events(actor=principal.actor)


@router.post("/events/enqueue")
def enqueue_risk_events(
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    require_operations_enabled()
    return enqueue_risk_event_generation(actor=principal.actor)