# ============================================================================== # 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)