163 lines
6.2 KiB
Python
163 lines
6.2 KiB
Python
# ==============================================================================
|
|
# Rutas de Control de Accesos (Ingreso, Egreso, Tickets y Búsquedas)
|
|
# ==============================================================================
|
|
from typing import List
|
|
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,
|
|
LotPermissionDTO,
|
|
TicketOccupantDTO,
|
|
PersonPoliciesDTO,
|
|
VehicleDetailsDTO,
|
|
)
|
|
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("/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
|
|
|