Files
OnEverControl/backend/app/api/v1/access.py
T

237 lines
9.5 KiB
Python

# ==============================================================================
# Rutas de Control de Accesos (Ingreso, Egreso, Tickets y Búsquedas)
# ==============================================================================
from typing import List, Dict, Any, Optional
from fastapi import APIRouter, Depends, Query, HTTPException, status
from pydantic import BaseModel, Field
from app.schemas.access_schema import (
EntryRequest,
ExitRequest,
TicketResponse,
ActiveTicketDTO,
PersonSearchDTO,
LotSearchDTO,
LotResidentDTO,
LotPermissionDTO,
TicketOccupantDTO,
PersonPoliciesDTO,
VehicleDetailsDTO,
PreauthorizationDTO,
VehicleSearchResultDTO,
MassExitRequestDTO,
MassExitResultDTO,
)
from app.services.access_service import AccessService
from app.services.dni_parser_service import DNIParsingService, DNIParsedResult
from app.api.v1.auth import obtener_usuario_actual
from app.api.v1.websockets import ws_manager
router = APIRouter(prefix="/access", tags=["Control de Accesos"])
class DNIParseRequest(BaseModel):
raw_data: str = Field(..., description="Cadena de texto escaneada del PDF417 o QR")
@router.post("/entry", response_model=TicketResponse, summary="Registrar ingreso de visita/vehículo")
async def registrar_ingreso(
req: EntryRequest,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Registra atómicamente el ingreso, valida antipassback y dispara apertura de barrera."""
res = AccessService.procesar_ingreso(req)
await ws_manager.broadcast_all({
"type": "ticket_created",
"ticket_id": res.ticket_id,
"modulo_id": req.modulo_ingreso_id,
"documento": req.documento,
"patente": req.patente,
})
return res
@router.post("/exit", response_model=TicketResponse, summary="Registrar egreso de visita/vehículo")
async def registrar_salida(
req: ExitRequest,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Cierra el ticket activo, archiva en histórico y acciona la barrera de salida."""
res = AccessService.procesar_salida(req)
await ws_manager.broadcast_all({
"type": "ticket_closed",
"ticket_id": req.ticket_id,
"modulo_id": req.modulo_salida_id,
})
return res
@router.get("/tickets/active", response_model=List[ActiveTicketDTO], summary="Listar tickets activos en predio")
def listar_tickets_activos(
current_user: dict = Depends(obtener_usuario_actual),
):
"""Obtiene todos los ingresos que permanecen dentro del predio."""
return AccessService.obtener_tickets_activos()
@router.get("/movements/recent", summary="Listar últimos movimientos registrados en SQL Server")
def listar_ultimos_movimientos(
limit: int = Query(30, ge=1, le=100),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Obtiene los últimos movimientos de ingreso y salida registrados en la tabla mvthist."""
return AccessService.obtener_ultimos_movimientos(limite=limit)
@router.get("/people/search", response_model=List[PersonSearchDTO], summary="Búsqueda predictiva de personas")
def buscar_personas(
q: str = Query(..., min_length=2, description="Texto de búsqueda por apellido o documento"),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Búsqueda autocompletada rápida para agilizar el ingreso."""
return AccessService.buscar_personas(q)
@router.get("/lots/search", response_model=List[LotSearchDTO], summary="Búsqueda predictiva de lotes")
def buscar_lotes(
q: str = Query(..., min_length=1, description="Texto de búsqueda por código de lote"),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Búsqueda autocompletada de unidades funcionales / lotes de destino."""
return AccessService.buscar_lotes(q)
@router.post("/parse-dni", response_model=DNIParsedResult, summary="Parsear código de barras DNI")
def parsear_codigo_dni(
req: DNIParseRequest,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Decodifica texto crudo de PDF417 o QR Mi Argentina y extrae DNI, apellidos, nombres y sexo."""
res = DNIParsingService.parsear_codigo(req.raw_data)
if not res.valido:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="No se pudo interpretar el formato del código escaneado.",
)
return res
@router.get("/lots/{lote_id}/permission", response_model=LotPermissionDTO, summary="Validar estado y permisos de lote")
def validar_permiso_lote(
lote_id: int,
persona_id: int = Query(0, description="ID opcional de la persona a validar con el lote"),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Consulta estado del lote (Cat 26) y relación de persona (LotPer)."""
return AccessService.obtener_permiso_lote(lote_id, persona_id)
@router.get("/lots/{lote_id}/residents", response_model=List[LotResidentDTO], summary="Listar padrón de residentes de un lote")
def listar_residentes_lote(
lote_id: int,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna el padrón de residentes y teléfonos asignados al lote (LotPer JOIN Per)."""
return AccessService.obtener_residentes_lote(lote_id)
@router.get("/tickets/{ticket_id}/occupants", response_model=List[TicketOccupantDTO], summary="Listar ocupantes de un ticket")
def listar_ocupantes_ticket(
ticket_id: int,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna todos los integrantes que ingresaron en el vehículo correspondiente a este ticket."""
return AccessService.obtener_ocupantes_ticket(ticket_id)
@router.get("/people/{documento}/details", response_model=PersonPoliciesDTO, summary="Consultar datos completos, patentes y pólizas de persona")
def consultar_datos_persona(
documento: str,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna ficha de persona con patentes asociadas, seguros, ART y licencia."""
res = AccessService.obtener_polizas_y_vehiculos_persona(documento)
if not res:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Persona con DNI {documento} no encontrada.",
)
return res
@router.get("/vehicles/{patente}/details", response_model=VehicleDetailsDTO, summary="Consultar datos de seguro y titular de vehículo")
def consultar_datos_vehiculo(
patente: str,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna póliza de seguro y datos del titular asociado a la patente."""
res = AccessService.obtener_datos_vehiculo(patente)
if not res:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Vehículo con patente {patente} no encontrado en base de datos.",
)
return res
@router.get("/preauthorizations", response_model=List[PreauthorizationDTO], summary="Listar visitas preautorizadas")
def listar_preautorizaciones(
q: str = Query("", description="Filtro de búsqueda por visitante, lote o entidad"),
solo_vigentes: bool = Query(True, description="Filtrar únicamente preautorizaciones vigentes"),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Retorna listado de visitas preautorizadas activas desde la tabla 'pre'."""
return AccessService.listar_preautorizados(busqueda=q, solo_vigentes=solo_vigentes)
@router.post("/preauthorizations/{id}/consume", summary="Consumir visita preautorizada")
def consumir_preautorizacion(
id: int,
current_user: dict = Depends(obtener_usuario_actual),
):
"""Marca como consumida (o elimina) una preautorización tras generar el ingreso."""
ok = AccessService.consumir_preautorizado(id)
if not ok:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"No se pudo consumir la preautorización #{id}.",
)
return {"status": "ok", "message": f"Preautorización #{id} consumida exitosamente."}
@router.get("/people/advanced-search", response_model=List[Dict[str, Any]], summary="Búsqueda avanzada multi-criterio de personas")
def buscar_personas_avanzado(
q: str = Query("", description="Búsqueda por apellido, nombre, DNI, nro socio o lote"),
limite: int = Query(50, ge=1, le=200),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Búsqueda avanzada idéntica a DialogoBuscarPersona de escritorio."""
return AccessService.buscar_personas_avanzado(texto=q, limite=limite)
@router.get("/vehicles/search", response_model=List[VehicleSearchResultDTO], summary="Búsqueda predictiva y parcial de vehículos")
def buscar_vehiculos(
q: str = Query("", description="Búsqueda por patente, marca, modelo o titular"),
es_salida: bool = Query(False, description="True si busca vehículos ingresados en el predio"),
limite: int = Query(50, ge=1, le=200),
current_user: dict = Depends(obtener_usuario_actual),
):
"""Búsqueda predictiva idéntica a DialogoBuscarPatente de escritorio."""
return AccessService.buscar_vehiculos(termino=q, es_salida=es_salida, limite=limite)
@router.post("/mass-exit", response_model=MassExitResultDTO, summary="Ejecutar salida masiva transaccional")
def ejecutar_salida_masiva(
req: MassExitRequestDTO,
current_user: dict = Depends(obtener_usuario_actual),
):
"""
Ejecuta el egreso atómico de múltiples personas/vehículos dentro del predio.
Paridad 1:1 con DlgSalidaMasiva de escritorio.
"""
u_id = current_user.get("user_id", 0)
u_nom = current_user.get("username", "Operador")
return AccessService.procesar_salida_masiva(req=req, usuario_id=u_id, operador=u_nom)