feat: complete Phases 2 to 5 inclusive - Access Core, Web Cockpit, Hardware enqueuing, Optical Scanner and QA (v0.5.0-beta)
This commit is contained in:
@@ -0,0 +1,98 @@
|
||||
# ==============================================================================
|
||||
# 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,
|
||||
)
|
||||
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("/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
|
||||
@@ -0,0 +1,78 @@
|
||||
# ==============================================================================
|
||||
# Endpoints de Autenticación (/api/v1/auth)
|
||||
# ==============================================================================
|
||||
from typing import Optional
|
||||
from fastapi import APIRouter, Response, Request, HTTPException, status, Depends
|
||||
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
||||
from app.schemas.auth_schema import LoginRequest, LoginResponse, UserSessionDTO
|
||||
from app.services.auth_service import AuthService
|
||||
from app.core.security import decodificar_access_token
|
||||
|
||||
router = APIRouter()
|
||||
security_bearer = HTTPBearer(auto_error=False)
|
||||
|
||||
|
||||
def get_current_user_payload(
|
||||
request: Request,
|
||||
bearer: Optional[HTTPAuthorizationCredentials] = Depends(security_bearer),
|
||||
) -> dict:
|
||||
"""Extrae el token JWT desde la cookie HttpOnly o el header Bearer."""
|
||||
token = request.cookies.get("access_token")
|
||||
if not token and bearer:
|
||||
token = bearer.credentials
|
||||
|
||||
if not token:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="No se encontró una sesión activa o token válido",
|
||||
)
|
||||
|
||||
payload = decodificar_access_token(token)
|
||||
if not payload:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Token inválido o expirado",
|
||||
)
|
||||
return payload
|
||||
|
||||
|
||||
obtener_usuario_actual = get_current_user_payload
|
||||
|
||||
|
||||
@router.post("/login", response_model=LoginResponse, summary="Iniciar sesión de operador")
|
||||
async def login(login_req: LoginRequest, response: Response):
|
||||
"""Autentica al guardia o supervisor y emite una cookie HttpOnly con JWT."""
|
||||
res_dto, token = AuthService.autenticar_usuario(
|
||||
username=login_req.username,
|
||||
password_raw=login_req.password,
|
||||
workstation_name=login_req.workstation_name,
|
||||
)
|
||||
|
||||
# Cookie HttpOnly segura
|
||||
response.set_cookie(
|
||||
key="access_token",
|
||||
value=token,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
secure=False, # En LAN sin HTTPS directo se permite False; en Nginx SSL pasará a True
|
||||
max_age=1800, # 30 minutos
|
||||
)
|
||||
|
||||
return res_dto
|
||||
|
||||
|
||||
@router.post("/logout", summary="Cerrar sesión")
|
||||
async def logout(response: Response):
|
||||
"""Elimina la cookie de sesión activa."""
|
||||
response.delete_cookie(key="access_token")
|
||||
return {"status": "ok", "message": "Sesión cerrada exitosamente"}
|
||||
|
||||
|
||||
@router.get("/me", response_model=UserSessionDTO, summary="Obtener usuario actual en sesión")
|
||||
async def get_current_user(payload: dict = Depends(get_current_user_payload)):
|
||||
"""Retorna la información del usuario autenticado."""
|
||||
return UserSessionDTO(
|
||||
user_id=int(payload["sub"]),
|
||||
username=payload["username"],
|
||||
role="OPERADOR",
|
||||
)
|
||||
@@ -0,0 +1,29 @@
|
||||
# ==============================================================================
|
||||
# Endpoints de Puestos de Control y Workstations (/api/v1/control-posts)
|
||||
# ==============================================================================
|
||||
from typing import List, Dict, Any
|
||||
from fastapi import APIRouter
|
||||
from app.schemas.workstation_schema import WorkstationStatusResponse
|
||||
from app.services.workstation_service import WorkstationService
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get(
|
||||
"/workstation/{name}/status",
|
||||
response_model=WorkstationStatusResponse,
|
||||
summary="Consultar estado y carriles asignados a una Workstation",
|
||||
)
|
||||
async def get_workstation_status(name: str):
|
||||
"""Verifica si la tablet/estación está autorizada como Puesto de Control y retorna sus carriles."""
|
||||
return WorkstationService.obtener_estado_workstation(name)
|
||||
|
||||
|
||||
@router.get(
|
||||
"/workstations",
|
||||
response_model=List[Dict[str, Any]],
|
||||
summary="Listar todas las Workstations registradas",
|
||||
)
|
||||
async def list_workstations():
|
||||
"""Listado de estaciones para selector de tablets o supervisores."""
|
||||
return WorkstationService.listar_estaciones_disponibles()
|
||||
@@ -0,0 +1,48 @@
|
||||
# ==============================================================================
|
||||
# Rutas de Hardware y Telemetría Industrial
|
||||
# ==============================================================================
|
||||
from fastapi import APIRouter, Depends, HTTPException, status
|
||||
from app.schemas.hardware_schema import ManualOpenRequest, HardwareCommandResponse
|
||||
from app.services.hardware_service import HardwareService
|
||||
from app.api.v1.auth import obtener_usuario_actual
|
||||
from app.api.v1.websockets import ws_manager
|
||||
|
||||
router = APIRouter(prefix="/hardware", tags=["Hardware"])
|
||||
|
||||
|
||||
@router.post(
|
||||
"/modules/{modulo_id}/open",
|
||||
response_model=HardwareCommandResponse,
|
||||
summary="Apertura manual o forzada de barrera",
|
||||
)
|
||||
async def abrir_barrera_manual(
|
||||
modulo_id: int,
|
||||
req: ManualOpenRequest,
|
||||
current_user: dict = Depends(obtener_usuario_actual),
|
||||
):
|
||||
"""
|
||||
Encola un pulso de apertura inmediata en la tabla pdtmdl para el módulo especificado.
|
||||
Cumple con el requerimiento de auditoría y latencia menor a 50ms.
|
||||
"""
|
||||
ok, res = HardwareService.encolar_apertura(modulo_id=modulo_id, ticket_id=req.ticket_id or 0)
|
||||
if not ok:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail=res.get("error", "Error al encolar comando de hardware"),
|
||||
)
|
||||
|
||||
await ws_manager.broadcast_all({
|
||||
"type": "barrier_opened",
|
||||
"modulo_id": modulo_id,
|
||||
"motivo": req.motivo,
|
||||
"operador": current_user.get("username", "guardia"),
|
||||
})
|
||||
|
||||
return HardwareCommandResponse(
|
||||
status="ok",
|
||||
modulo_id=modulo_id,
|
||||
address=res["address"],
|
||||
payload=res["payload"],
|
||||
message=f"Comando de apertura encolado para módulo {modulo_id} ({req.motivo})",
|
||||
latencia_ms=res["latencia_ms"],
|
||||
)
|
||||
@@ -1,11 +1,9 @@
|
||||
# ==============================================================================
|
||||
# Router Principal API v1
|
||||
# ==============================================================================
|
||||
from fastapi import APIRouter
|
||||
from app.api.v1 import auth, control_posts, access, hardware
|
||||
|
||||
api_router = APIRouter()
|
||||
|
||||
# En fases posteriores aquí se incluirán los sub-routers:
|
||||
# api_router.include_router(auth.router, prefix="/auth", tags=["Autenticación"])
|
||||
# api_router.include_router(control_posts.router, prefix="/control-posts", tags=["Puestos de Control"])
|
||||
# api_router.include_router(access.router, prefix="/access", tags=["Accesos"])
|
||||
api_router.include_router(auth.router, prefix="/auth", tags=["Autenticación"])
|
||||
api_router.include_router(control_posts.router, prefix="/control-posts", tags=["Puestos de Control"])
|
||||
api_router.include_router(access.router, tags=["Control de Accesos"])
|
||||
api_router.include_router(hardware.router, tags=["Hardware"])
|
||||
|
||||
@@ -0,0 +1,68 @@
|
||||
# ==============================================================================
|
||||
# WebSockets para Telemetría y Eventos en Tiempo Real de Garita
|
||||
# ==============================================================================
|
||||
import asyncio
|
||||
from typing import Dict, Set
|
||||
from fastapi import APIRouter, WebSocket, WebSocketDisconnect
|
||||
|
||||
router = APIRouter(tags=["WebSockets"])
|
||||
|
||||
|
||||
class ConnectionManager:
|
||||
def __init__(self):
|
||||
# Mapeo de workstation_name -> Set de conexiones activas
|
||||
self.active_connections: Dict[str, Set[WebSocket]] = {}
|
||||
|
||||
async def connect(self, websocket: WebSocket, station_name: str):
|
||||
await websocket.accept()
|
||||
key = station_name.upper()
|
||||
if key not in self.active_connections:
|
||||
self.active_connections[key] = set()
|
||||
self.active_connections[key].add(websocket)
|
||||
|
||||
def disconnect(self, websocket: WebSocket, station_name: str):
|
||||
key = station_name.upper()
|
||||
if key in self.active_connections:
|
||||
self.active_connections[key].discard(websocket)
|
||||
if not self.active_connections[key]:
|
||||
del self.active_connections[key]
|
||||
|
||||
async def broadcast_to_station(self, station_name: str, message: dict):
|
||||
key = station_name.upper()
|
||||
if key in self.active_connections:
|
||||
dead_sockets = set()
|
||||
for ws in self.active_connections[key]:
|
||||
try:
|
||||
await ws.send_json(message)
|
||||
except Exception:
|
||||
dead_sockets.add(ws)
|
||||
for dead in dead_sockets:
|
||||
self.active_connections[key].discard(dead)
|
||||
|
||||
async def broadcast_all(self, message: dict):
|
||||
for station_name in list(self.active_connections.keys()):
|
||||
await self.broadcast_to_station(station_name, message)
|
||||
|
||||
|
||||
ws_manager = ConnectionManager()
|
||||
|
||||
|
||||
@router.websocket("/ws/station/{station_name}")
|
||||
async def station_websocket(websocket: WebSocket, station_name: str):
|
||||
await ws_manager.connect(websocket, station_name)
|
||||
try:
|
||||
# Enviar mensaje de bienvenida
|
||||
await websocket.send_json({
|
||||
"type": "connected",
|
||||
"station": station_name,
|
||||
"message": f"Conexión en tiempo real activa para estación {station_name}",
|
||||
})
|
||||
while True:
|
||||
# Recibir pings o mensajes del cliente
|
||||
data = await websocket.receive_text()
|
||||
if data == "ping":
|
||||
await websocket.send_text("pong")
|
||||
except WebSocketDisconnect:
|
||||
ws_manager.disconnect(websocket, station_name)
|
||||
except Exception:
|
||||
ws_manager.disconnect(websocket, station_name)
|
||||
Reference in New Issue
Block a user