200 lines
7.3 KiB
Python
200 lines
7.3 KiB
Python
from datetime import datetime, timezone, timedelta
|
|
from typing import Optional, List, Tuple
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
|
|
from app import db
|
|
from app.models.user import User
|
|
from app.models.building import Building
|
|
from app.models.access_log_qr import AccessLogQR
|
|
from app.models.setting import SystemSetting
|
|
from app.services.audit_service import AuditService
|
|
from app.services.qr_security_service import QRSecurityService
|
|
from dependencies import get_current_user, require_roles
|
|
from schemas.reception_dto import (
|
|
QRVerificationRequestDTO,
|
|
QRVerificationResponseDTO,
|
|
AccessLogResponseDTO,
|
|
AccessLogListResponseDTO
|
|
)
|
|
|
|
router = APIRouter(prefix="/api/v1/reception", tags=["Reception & Access Control"])
|
|
|
|
|
|
def to_argentina_time(dt_val: Optional[datetime]) -> Tuple[str, str]:
|
|
"""Convierte un datetime (UTC) a la hora local institucional de Buenos Aires (UTC-3)."""
|
|
if not dt_val:
|
|
return "", "--"
|
|
try:
|
|
from zoneinfo import ZoneInfo
|
|
tz_ar = ZoneInfo("America/Argentina/Buenos_Aires")
|
|
if dt_val.tzinfo is None:
|
|
dt_utc = dt_val.replace(tzinfo=timezone.utc)
|
|
else:
|
|
dt_utc = dt_val.astimezone(timezone.utc)
|
|
local_dt = dt_utc.astimezone(tz_ar)
|
|
except Exception:
|
|
offset = timedelta(hours=-3)
|
|
local_dt = (dt_val if dt_val.tzinfo is None else dt_val.replace(tzinfo=None)) + offset
|
|
|
|
return local_dt.isoformat(), local_dt.strftime("%H:%M hs")
|
|
|
|
|
|
@router.post("/verify-qr", response_model=QRVerificationResponseDTO)
|
|
def verify_qr_and_register_access(
|
|
payload: QRVerificationRequestDTO,
|
|
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA", "RECEPCION"]))
|
|
):
|
|
"""
|
|
Verifica un código QR institucional en la mesa de entrada o torniquete de acceso.
|
|
Registra el ingreso en AccessLogQR y retorna la identidad del alumno/docente
|
|
junto con sus clases y aulas asignadas para el día de hoy.
|
|
"""
|
|
now_utc = datetime.now(timezone.utc).replace(tzinfo=None)
|
|
user, auth_status, reason = QRSecurityService.decode_and_resolve_user(payload.qr_token)
|
|
|
|
# Si se identificó un usuario
|
|
if user:
|
|
classes = QRSecurityService.get_todays_classes_for_user(user)
|
|
|
|
# Registro en la base de accesos
|
|
access_log = AccessLogQR(
|
|
user_id=user.id,
|
|
building_id=payload.building_id,
|
|
scanned_by_user_id=current_user.id,
|
|
scanned_at=now_utc,
|
|
status=auth_status,
|
|
reason=payload.notes or reason
|
|
)
|
|
db.session.add(access_log)
|
|
db.session.commit()
|
|
|
|
AuditService.log(
|
|
user_id=current_user.id,
|
|
action="QR_ACCESS_SCAN",
|
|
module="reception",
|
|
entity_id=access_log.id,
|
|
details={
|
|
"target_user_id": user.id,
|
|
"status": auth_status,
|
|
"building_id": payload.building_id,
|
|
"classes_today_count": len(classes)
|
|
}
|
|
)
|
|
|
|
message = (
|
|
f"Acceso autorizado para {user.name}."
|
|
if auth_status == "AUTORIZADO"
|
|
else f"Acceso observado: {reason}"
|
|
)
|
|
|
|
scanned_at_iso, scanned_time_str = to_argentina_time(now_utc)
|
|
|
|
return QRVerificationResponseDTO(
|
|
status=auth_status,
|
|
message=message,
|
|
user_id=user.id,
|
|
user_name=user.name,
|
|
user_dni=user.document_number,
|
|
user_role=(user.role or "ALUMNO").upper(),
|
|
matricula_status="REGULAR / ACTIVO" if user.is_active else "SUSPENDIDO / INACTIVO",
|
|
photo_url=None,
|
|
todays_classes=classes,
|
|
scanned_at=scanned_at_iso,
|
|
scanned_time=scanned_time_str
|
|
)
|
|
|
|
# Si el código QR es inválido o el usuario no existe
|
|
AuditService.log(
|
|
user_id=current_user.id,
|
|
action="QR_ACCESS_FAILED",
|
|
module="reception",
|
|
entity_id=None,
|
|
details={"reason": reason, "raw_snippet": payload.qr_token[:15]}
|
|
)
|
|
|
|
scanned_at_iso, scanned_time_str = to_argentina_time(now_utc)
|
|
|
|
return QRVerificationResponseDTO(
|
|
status="DENEGADO",
|
|
message=reason,
|
|
user_id=None,
|
|
user_name=None,
|
|
user_dni=None,
|
|
user_role=None,
|
|
matricula_status="NO REGISTRADO",
|
|
photo_url=None,
|
|
todays_classes=[],
|
|
scanned_at=scanned_at_iso,
|
|
scanned_time=scanned_time_str
|
|
)
|
|
|
|
|
|
@router.get("/recent-logs", response_model=AccessLogListResponseDTO)
|
|
def get_recent_access_logs(
|
|
building_id: Optional[int] = Query(None, description="Filtrar por sede específica"),
|
|
limit: int = Query(50, ge=1, le=200, description="Cantidad máxima de registros a recuperar"),
|
|
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA", "RECEPCION"]))
|
|
):
|
|
"""
|
|
Retorna los últimos ingresos registrados en el punto de acceso.
|
|
Permite monitoreo en tiempo real para el personal de Recepción y Seguridad con hora local de Buenos Aires.
|
|
"""
|
|
query = AccessLogQR.query
|
|
if building_id:
|
|
query = query.filter_by(building_id=building_id)
|
|
|
|
logs: List[AccessLogQR] = query.order_by(AccessLogQR.scanned_at.desc()).limit(limit).all()
|
|
|
|
items = []
|
|
for l in logs:
|
|
scanned_at_iso, scanned_time_str = to_argentina_time(l.scanned_at)
|
|
items.append(AccessLogResponseDTO(
|
|
id=l.id,
|
|
user_name=l.user.name if l.user else "Usuario no disponible",
|
|
user_dni=l.user.document_number if l.user else None,
|
|
user_role=l.user.role if l.user else None,
|
|
building_name=l.building.name if l.building else "Sede no especificada",
|
|
scanned_by_name=l.scanned_by.name if l.scanned_by else "Recepción",
|
|
scanned_at=scanned_at_iso,
|
|
scanned_time=scanned_time_str,
|
|
status=l.status,
|
|
reason=l.reason
|
|
))
|
|
|
|
return AccessLogListResponseDTO(
|
|
total=len(items),
|
|
items=items
|
|
)
|
|
|
|
|
|
@router.get("/my-qr-token")
|
|
def get_my_credential_qr_token(
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""
|
|
Genera y entrega el token criptográfico del código QR para la credencial digital
|
|
del usuario autenticado (estudiante o docente).
|
|
Soporta rotación dinámica periódica (default 3s) y ventana de validez anti-captura estricta (default 6s).
|
|
"""
|
|
renewal_seconds = int(SystemSetting.get_value('qr_renewal_interval_seconds', 3) or 3)
|
|
# Ventana estricta anti-captura: el token expira pasados pocos segundos (default 6s)
|
|
# de modo que una captura de pantalla de 10 segundos queda garantizadamente rechazada.
|
|
configured_grace = SystemSetting.get_value('qr_token_grace_period_seconds', None)
|
|
if configured_grace is not None:
|
|
grace_seconds = int(configured_grace)
|
|
else:
|
|
grace_seconds = max(renewal_seconds + 3, 6)
|
|
|
|
token = QRSecurityService.generate_qr_token(current_user, valid_seconds=grace_seconds)
|
|
return {
|
|
"status": "success",
|
|
"qr_token": token,
|
|
"user_id": current_user.id,
|
|
"user_name": current_user.name,
|
|
"user_dni": current_user.document_number,
|
|
"user_role": (current_user.role or "ALUMNO").upper(),
|
|
"expires_in_hours": QRSecurityService.DEFAULT_VALID_HOURS,
|
|
"renewal_interval_seconds": renewal_seconds,
|
|
"grace_period_seconds": grace_seconds
|
|
}
|