214 lines
7.5 KiB
Python
214 lines
7.5 KiB
Python
"""
|
|
Site alert rules and events API endpoints.
|
|
|
|
Routes:
|
|
/api/tenants/{tenant_id}/sites/{site_id}/alert-rules (CRUD)
|
|
/api/tenants/{tenant_id}/sites/{site_id}/alert-events (list)
|
|
/api/tenants/{tenant_id}/alert-events/{event_id}/resolve (resolve)
|
|
/api/tenants/{tenant_id}/alert-events/count (active count for bell badge)
|
|
|
|
RBAC:
|
|
- viewer: GET endpoints (read-only)
|
|
- operator: POST, PUT, DELETE, resolve (write)
|
|
"""
|
|
|
|
import uuid
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.database import get_db
|
|
from app.middleware.rbac import require_operator_or_above
|
|
from app.middleware.tenant_context import CurrentUser, get_current_user
|
|
from app.routers.devices import _check_tenant_access
|
|
from app.schemas.site_alert import (
|
|
SiteAlertEventListResponse,
|
|
SiteAlertEventResponse,
|
|
SiteAlertRuleCreate,
|
|
SiteAlertRuleListResponse,
|
|
SiteAlertRuleResponse,
|
|
SiteAlertRuleUpdate,
|
|
)
|
|
from app.services import site_alert_service
|
|
|
|
router = APIRouter(tags=["site-alerts"])
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Alert Rules CRUD
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@router.post(
|
|
"/tenants/{tenant_id}/sites/{site_id}/alert-rules",
|
|
response_model=SiteAlertRuleResponse,
|
|
status_code=status.HTTP_201_CREATED,
|
|
summary="Create a site alert rule",
|
|
dependencies=[Depends(require_operator_or_above)],
|
|
)
|
|
async def create_alert_rule(
|
|
tenant_id: uuid.UUID,
|
|
site_id: uuid.UUID,
|
|
data: SiteAlertRuleCreate,
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> SiteAlertRuleResponse:
|
|
"""Create a new site/sector alert rule. Requires operator role or above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
return await site_alert_service.create_alert_rule(
|
|
db=db, tenant_id=tenant_id, site_id=site_id, data=data
|
|
)
|
|
|
|
|
|
@router.get(
|
|
"/tenants/{tenant_id}/sites/{site_id}/alert-rules",
|
|
response_model=SiteAlertRuleListResponse,
|
|
summary="List site alert rules",
|
|
)
|
|
async def list_alert_rules(
|
|
tenant_id: uuid.UUID,
|
|
site_id: uuid.UUID,
|
|
sector_id: Optional[uuid.UUID] = Query(None, description="Filter by sector"),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> SiteAlertRuleListResponse:
|
|
"""List alert rules for a site, optionally filtered by sector. Viewer role and above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
return await site_alert_service.list_alert_rules(
|
|
db=db, tenant_id=tenant_id, site_id=site_id, sector_id=sector_id
|
|
)
|
|
|
|
|
|
@router.get(
|
|
"/tenants/{tenant_id}/sites/{site_id}/alert-rules/{rule_id}",
|
|
response_model=SiteAlertRuleResponse,
|
|
summary="Get a site alert rule",
|
|
)
|
|
async def get_alert_rule(
|
|
tenant_id: uuid.UUID,
|
|
site_id: uuid.UUID,
|
|
rule_id: uuid.UUID,
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> SiteAlertRuleResponse:
|
|
"""Get a single site alert rule by ID. Viewer role and above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
result = await site_alert_service.get_alert_rule(
|
|
db=db, tenant_id=tenant_id, site_id=site_id, rule_id=rule_id
|
|
)
|
|
if not result:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Alert rule not found")
|
|
return result
|
|
|
|
|
|
@router.put(
|
|
"/tenants/{tenant_id}/sites/{site_id}/alert-rules/{rule_id}",
|
|
response_model=SiteAlertRuleResponse,
|
|
summary="Update a site alert rule",
|
|
dependencies=[Depends(require_operator_or_above)],
|
|
)
|
|
async def update_alert_rule(
|
|
tenant_id: uuid.UUID,
|
|
site_id: uuid.UUID,
|
|
rule_id: uuid.UUID,
|
|
data: SiteAlertRuleUpdate,
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> SiteAlertRuleResponse:
|
|
"""Update a site alert rule. Requires operator role or above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
result = await site_alert_service.update_alert_rule(
|
|
db=db, tenant_id=tenant_id, site_id=site_id, rule_id=rule_id, data=data
|
|
)
|
|
if not result:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Alert rule not found")
|
|
return result
|
|
|
|
|
|
@router.delete(
|
|
"/tenants/{tenant_id}/sites/{site_id}/alert-rules/{rule_id}",
|
|
status_code=status.HTTP_204_NO_CONTENT,
|
|
summary="Delete a site alert rule",
|
|
dependencies=[Depends(require_operator_or_above)],
|
|
)
|
|
async def delete_alert_rule(
|
|
tenant_id: uuid.UUID,
|
|
site_id: uuid.UUID,
|
|
rule_id: uuid.UUID,
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> None:
|
|
"""Delete a site alert rule. Requires operator role or above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
deleted = await site_alert_service.delete_alert_rule(
|
|
db=db, tenant_id=tenant_id, site_id=site_id, rule_id=rule_id
|
|
)
|
|
if not deleted:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Alert rule not found")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Alert Events
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@router.get(
|
|
"/tenants/{tenant_id}/sites/{site_id}/alert-events",
|
|
response_model=SiteAlertEventListResponse,
|
|
summary="List site alert events",
|
|
)
|
|
async def list_alert_events(
|
|
tenant_id: uuid.UUID,
|
|
site_id: uuid.UUID,
|
|
state: Optional[str] = Query(None, description="Filter by state (active, resolved)"),
|
|
limit: int = Query(50, ge=1, le=200, description="Max events to return"),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> SiteAlertEventListResponse:
|
|
"""List alert events for a site. Viewer role and above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
return await site_alert_service.list_alert_events(
|
|
db=db, tenant_id=tenant_id, site_id=site_id, state=state, limit=limit
|
|
)
|
|
|
|
|
|
@router.post(
|
|
"/tenants/{tenant_id}/alert-events/{event_id}/resolve",
|
|
response_model=SiteAlertEventResponse,
|
|
summary="Resolve a site alert event",
|
|
dependencies=[Depends(require_operator_or_above)],
|
|
)
|
|
async def resolve_alert_event(
|
|
tenant_id: uuid.UUID,
|
|
event_id: uuid.UUID,
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> SiteAlertEventResponse:
|
|
"""Resolve an active alert event. Requires operator role or above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
result = await site_alert_service.resolve_alert_event(
|
|
db=db, tenant_id=tenant_id, event_id=event_id, user_id=current_user.user_id
|
|
)
|
|
if not result:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail="Alert event not found or already resolved",
|
|
)
|
|
return result
|
|
|
|
|
|
@router.get(
|
|
"/tenants/{tenant_id}/alert-events/count",
|
|
summary="Get active alert event count",
|
|
)
|
|
async def get_active_event_count(
|
|
tenant_id: uuid.UUID,
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> dict:
|
|
"""Get count of active site alert events for notification bell badge. Viewer role and above."""
|
|
await _check_tenant_access(current_user, tenant_id, db)
|
|
count = await site_alert_service.get_active_event_count(db=db, tenant_id=tenant_id)
|
|
return {"count": count}
|