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:
@@ -1,6 +1,6 @@
|
||||
# ==============================================================================
|
||||
# OnEverControl - Versión del Backend
|
||||
# ==============================================================================
|
||||
__version__ = "0.1.0-alpha"
|
||||
__version__ = "0.5.0-beta"
|
||||
__app_name__ = "OnEverControl"
|
||||
__description__ = "Cliente Web Reducido para Puesto de Control en Red Local de OnEverAccess"
|
||||
|
||||
@@ -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)
|
||||
@@ -0,0 +1,53 @@
|
||||
# ==============================================================================
|
||||
# Gestor de Conexiones y Sesiones de Base de Datos SQL Server (videoman)
|
||||
# Compatible con Windows 10/11, LXC (FreeTDS) y Docker
|
||||
# ==============================================================================
|
||||
from contextlib import contextmanager
|
||||
from typing import Generator
|
||||
import pymssql
|
||||
from app.core.config import settings
|
||||
|
||||
|
||||
def get_raw_connection() -> pymssql.Connection:
|
||||
"""Crea y retorna una nueva conexión física a Microsoft SQL Server."""
|
||||
return pymssql.connect(
|
||||
server=settings.DB_SERVER,
|
||||
port=settings.DB_PORT,
|
||||
user=settings.DB_USER,
|
||||
password=settings.DB_PASSWORD,
|
||||
database=settings.DB_NAME,
|
||||
charset=settings.DB_CHARSET,
|
||||
login_timeout=settings.DB_TIMEOUT,
|
||||
timeout=settings.DB_TIMEOUT,
|
||||
autocommit=False, # Control transaccional explícito
|
||||
)
|
||||
|
||||
|
||||
@contextmanager
|
||||
def db_session() -> Generator[pymssql.Connection, None, None]:
|
||||
"""
|
||||
Context manager seguro para consultas y transacciones con commit/rollback atómico.
|
||||
|
||||
Uso:
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(...)
|
||||
"""
|
||||
conn = None
|
||||
try:
|
||||
conn = get_raw_connection()
|
||||
yield conn
|
||||
conn.commit()
|
||||
except Exception:
|
||||
if conn:
|
||||
try:
|
||||
conn.rollback()
|
||||
except Exception:
|
||||
pass
|
||||
raise
|
||||
finally:
|
||||
if conn:
|
||||
try:
|
||||
conn.close()
|
||||
except Exception:
|
||||
pass
|
||||
@@ -0,0 +1,108 @@
|
||||
# ==============================================================================
|
||||
# Módulo de Seguridad y Criptografía (OnEverControl)
|
||||
# Soporte de contraseñas legacy VB6 y tokens JWT
|
||||
# ==============================================================================
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Optional, Dict, Any
|
||||
import jwt
|
||||
from app.core.config import settings
|
||||
|
||||
JWT_ALGORITHM = "HS256"
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# ENCRIPTACIÓN Y VERIFICACIÓN DE CONTRASEÑAS LEGACY (VB6 / videoman)
|
||||
# --------------------------------------------------------------------------- #
|
||||
def _pad_password_vb6(password: str) -> str:
|
||||
"""Rellena la contraseña a 32 caracteres como hacía VB6."""
|
||||
if len(password) < 32:
|
||||
return password + " " * (32 - len(password))
|
||||
return password[:32]
|
||||
|
||||
|
||||
def encriptar_password_vb6(password: str) -> str:
|
||||
"""
|
||||
Replica la función Encriptar de VB6 (EncryptionSVR.cls).
|
||||
Suma 100 con desborde byte (mod 256) en codificación CP1252.
|
||||
"""
|
||||
padded = _pad_password_vb6(password)
|
||||
raw = padded.encode("cp1252", errors="replace")
|
||||
|
||||
out_bytes = bytearray()
|
||||
for b in raw:
|
||||
nuevo = (b + 100) & 0xFF
|
||||
out_bytes.append(nuevo)
|
||||
|
||||
return out_bytes.decode("cp1252", errors="replace")
|
||||
|
||||
|
||||
def desencriptar_password_vb6(password_encriptado: str) -> str:
|
||||
"""Inversa de encriptar_password_vb6."""
|
||||
if not password_encriptado:
|
||||
return ""
|
||||
raw = password_encriptado.encode("cp1252", errors="replace")
|
||||
|
||||
out_bytes = bytearray()
|
||||
for b in raw:
|
||||
orig = (b - 100) & 0xFF
|
||||
out_bytes.append(orig)
|
||||
|
||||
texto = out_bytes.decode("cp1252", errors="replace")
|
||||
return texto.rstrip()
|
||||
|
||||
|
||||
def verificar_password(password_plano: str, password_almacenada: str) -> bool:
|
||||
"""
|
||||
Verifica si una contraseña en texto plano coincide con la almacenada en la tabla `usr`.
|
||||
Maneja formato legacy VB6 y texto plano directo.
|
||||
"""
|
||||
if not password_plano or not password_almacenada:
|
||||
return False
|
||||
|
||||
# Estrategia 1: Desencriptar la almacenada y comparar
|
||||
try:
|
||||
decrypted = desencriptar_password_vb6(password_almacenada).strip()
|
||||
if decrypted == password_plano:
|
||||
return True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Estrategia 2: Encriptar password_plano y comparar directamente
|
||||
try:
|
||||
encrypted = encriptar_password_vb6(password_plano)
|
||||
if encrypted == password_almacenada:
|
||||
return True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Estrategia 3: Comparación directa plana (en caso de que estuviera en claro)
|
||||
if password_almacenada == password_plano or password_almacenada.strip() == password_plano:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# GENERACIÓN Y VALIDACIÓN DE TOKENS JWT
|
||||
# --------------------------------------------------------------------------- #
|
||||
def crear_access_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
|
||||
"""Genera un JWT firmado con expiración configurable."""
|
||||
to_encode = data.copy()
|
||||
now = datetime.now(timezone.utc)
|
||||
if expires_delta:
|
||||
expire = now + expires_delta
|
||||
else:
|
||||
expire = now + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
|
||||
|
||||
to_encode.update({"exp": expire, "iat": now})
|
||||
encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=JWT_ALGORITHM)
|
||||
return encoded_jwt
|
||||
|
||||
|
||||
def decodificar_access_token(token: str) -> Optional[Dict[str, Any]]:
|
||||
"""Decodifica y valida la firma y expiración de un token JWT."""
|
||||
try:
|
||||
payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[JWT_ALGORITHM])
|
||||
return payload
|
||||
except jwt.PyJWTError:
|
||||
return None
|
||||
+4
-1
@@ -60,5 +60,8 @@ async def root():
|
||||
}
|
||||
|
||||
|
||||
# Montaje de routers versionados
|
||||
from app.api.v1.websockets import router as ws_router
|
||||
|
||||
# Montaje de routers versionados y WebSockets
|
||||
app.include_router(api_router, prefix="/api/v1")
|
||||
app.include_router(ws_router)
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
# Repositories module
|
||||
@@ -0,0 +1,288 @@
|
||||
# ==============================================================================
|
||||
# Repositorio de Control de Accesos (SQL Server videoman)
|
||||
# ==============================================================================
|
||||
from datetime import datetime
|
||||
from typing import Optional, List, Dict, Any, Tuple
|
||||
from app.core.database import db_session
|
||||
from app.schemas.access_schema import EntryRequest, CompanionDTO
|
||||
|
||||
|
||||
class AccessRepository:
|
||||
@staticmethod
|
||||
def generar_ticket_id() -> int:
|
||||
"""Genera el TicketID matemático time-based canónico de OnEverAccess."""
|
||||
fecha_actual = datetime.now()
|
||||
fecha_base = datetime(2007, 6, 1)
|
||||
dias = (fecha_actual.date() - fecha_base.date()).days
|
||||
|
||||
a = fecha_actual.hour
|
||||
e = fecha_actual.minute
|
||||
i = fecha_actual.second
|
||||
o = int(fecha_actual.microsecond / 1000)
|
||||
|
||||
return (dias * 100000000) + (a * 3600000) + (e * 60000) + (i * 1000) + o
|
||||
|
||||
@staticmethod
|
||||
def buscar_persona_por_documento(documento: str) -> Optional[Dict[str, Any]]:
|
||||
"""Busca una persona y su documento en las tablas `PerDocCatVal` y `Per`."""
|
||||
doc_clean = documento.strip()
|
||||
query = """
|
||||
SELECT TOP 1 p.PersonaID, p.Apellido, p.Nombre, p.Sexo, d.Documento
|
||||
FROM PerDocCatVal d
|
||||
INNER JOIN Per p ON d.PersonaID = p.PersonaID
|
||||
WHERE d.Documento = %s
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query, (doc_clean,))
|
||||
return cursor.fetchone()
|
||||
|
||||
@staticmethod
|
||||
def buscar_o_crear_persona(
|
||||
documento: str, apellido: str = "", nombre: str = "", sexo: str = "M"
|
||||
) -> int:
|
||||
"""Obtiene el PersonaID existente o da de alta una nueva visita en `Per` y `PerDocCatVal`."""
|
||||
doc_clean = documento.strip()
|
||||
existing = AccessRepository.buscar_persona_por_documento(doc_clean)
|
||||
if existing:
|
||||
pid = existing["PersonaID"]
|
||||
# Si se proveyó apellido o nombre, actualizar si estaban vacíos
|
||||
if apellido or nombre:
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(
|
||||
"""
|
||||
UPDATE Per
|
||||
SET Apellido = UPPER(COALESCE(NULLIF(%s, ''), Apellido)),
|
||||
Nombre = UPPER(COALESCE(NULLIF(%s, ''), Nombre))
|
||||
WHERE PersonaID = %s
|
||||
""",
|
||||
(apellido.strip() if apellido else "", nombre.strip() if nombre else "", pid),
|
||||
)
|
||||
return pid
|
||||
|
||||
# Alta de nueva persona
|
||||
ap_final = (apellido or "VISITA").upper().strip()
|
||||
nom_final = (nombre or "NUEVA").upper().strip()
|
||||
hoy = datetime.now().strftime("%Y-%m-%d")
|
||||
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT COALESCE(MAX(PersonaID), 0) + 1 FROM Per")
|
||||
new_pid = cursor.fetchone()[0]
|
||||
|
||||
sql_per = """
|
||||
INSERT INTO Per (PersonaID, Apellido, Nombre, Sexo, FechaInicio, FechaFin, FechaNacimiento, CREATEdByID, LastUpdateDateByID)
|
||||
VALUES (%s, %s, %s, %s, %s, '2099-12-31', '1900-01-01', 2, 2)
|
||||
"""
|
||||
cursor.execute(sql_per, (new_pid, ap_final, nom_final, sexo or "M", hoy))
|
||||
|
||||
sql_doc = """
|
||||
INSERT INTO PerDocCatVal (PersonaID, DocumentoID, CategoriaID, ValorID, Documento)
|
||||
VALUES (%s, 100000, 11, 1, %s)
|
||||
"""
|
||||
cursor.execute(sql_doc, (new_pid, doc_clean))
|
||||
return new_pid
|
||||
|
||||
@staticmethod
|
||||
def verificar_antipassback(persona_id: int) -> bool:
|
||||
"""Retorna True si la persona ya posee un ticket activo en el predio."""
|
||||
if not persona_id or persona_id <= 0:
|
||||
return False
|
||||
query = """
|
||||
SELECT TOP 1 t.TicketID
|
||||
FROM tck t
|
||||
INNER JOIN tckper tp ON t.TicketID = tp.TicketID
|
||||
WHERE tp.PersonaID = %s
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(query, (persona_id,))
|
||||
return cursor.fetchone() is not None
|
||||
|
||||
@staticmethod
|
||||
def registrar_ticket_ingreso(
|
||||
req: EntryRequest, persona_id: int, ticket_id: int
|
||||
) -> int:
|
||||
"""
|
||||
Registra de manera atómica el ticket en `tck`, `tckprx`, `tckper` y `mvthist`.
|
||||
"""
|
||||
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
rol_id = 1 if req.patente else 2 # 1: Conductor, 2: Peatón
|
||||
|
||||
entidad_final = req.entidad or ("CONDUCTOR..." if rol_id == 1 else "PEATON...")
|
||||
|
||||
propiedades: List[Tuple[int, Any]] = [
|
||||
(4, req.patente or ""),
|
||||
(5, str(req.cantidad_ocupantes)),
|
||||
(9, str(req.cantidad_menores)),
|
||||
(11, entidad_final),
|
||||
(8, req.motivo or "VISITA"),
|
||||
(6, "1" if req.cacheo_salida else "0"),
|
||||
(7, str(req.lote_id or req.lote_codigo or "")),
|
||||
]
|
||||
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
|
||||
# 1. Tabla tck
|
||||
cursor.execute(
|
||||
"INSERT INTO tck (TicketID, FechaHoraIngreso, ModuloIngresoID) VALUES (%s, %s, %s)",
|
||||
(ticket_id, ahora, req.modulo_ingreso_id),
|
||||
)
|
||||
|
||||
# 2. Tabla tckper (Conductor / Titular)
|
||||
cursor.execute(
|
||||
"INSERT INTO tckper (TicketID, PersonaID, RolID, EsMenor) VALUES (%s, %s, %s, 0)",
|
||||
(ticket_id, persona_id, rol_id),
|
||||
)
|
||||
|
||||
# 3. Propiedades dinámicas en tckprx
|
||||
for prop_id, val in propiedades:
|
||||
if val:
|
||||
cursor.execute(
|
||||
"INSERT INTO tckprx (TicketID, PropiedadID, Valor) VALUES (%s, %s, %s)",
|
||||
(ticket_id, prop_id, str(val)),
|
||||
)
|
||||
|
||||
# 4. Snapshot histórico en mvthist
|
||||
try:
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO mvthist (TicketID, PersonaID, Patente, LoteID, RolID, Entidad, Sentido, ModuloID, FechaHora)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, 'Ingreso', %s, %s)
|
||||
""",
|
||||
(
|
||||
ticket_id,
|
||||
persona_id,
|
||||
req.patente or None,
|
||||
req.lote_id or None,
|
||||
rol_id,
|
||||
entidad_final,
|
||||
req.modulo_ingreso_id,
|
||||
ahora,
|
||||
),
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# 5. Integrantes acompañantes
|
||||
for comp in req.integrantes:
|
||||
comp_pid = AccessRepository.buscar_o_crear_persona(
|
||||
comp.documento, comp.apellido or "", comp.nombre or "", comp.sexo or "M"
|
||||
)
|
||||
cursor.execute(
|
||||
"INSERT INTO tckper (TicketID, PersonaID, RolID, EsMenor) VALUES (%s, %s, %s, %s)",
|
||||
(ticket_id, comp_pid, comp.rol_id, 1 if comp.es_menor else 0),
|
||||
)
|
||||
|
||||
return ticket_id
|
||||
|
||||
@staticmethod
|
||||
def registrar_ticket_salida(
|
||||
ticket_id: int, modulo_salida_id: int, persona_id: int = 0, patente: str = ""
|
||||
) -> bool:
|
||||
"""
|
||||
Cierra un ticket activo moviéndolo a `tckhst`, registrando el egreso en `mvthist`
|
||||
y liberando los registros de `tck` y `tckper`.
|
||||
"""
|
||||
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
|
||||
# Leer datos de ingreso
|
||||
cursor.execute("SELECT FechaHoraIngreso, ModuloIngresoID FROM tck WHERE TicketID = %s", (ticket_id,))
|
||||
tck_row = cursor.fetchone()
|
||||
if not tck_row:
|
||||
return False
|
||||
|
||||
f_ing = str(tck_row["FechaHoraIngreso"])
|
||||
mod_ing = tck_row.get("ModuloIngresoID") or 0
|
||||
|
||||
# 1. Insertar en tckhst (histórico de tickets)
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO tckhst (TicketID, Numero, FechaHoraIngreso, ModuloIngresoID, FechaHoraSalida, ModuloSalidaID)
|
||||
VALUES (%s, 0, %s, %s, %s, %s)
|
||||
""",
|
||||
(ticket_id, f_ing, mod_ing, ahora, modulo_salida_id),
|
||||
)
|
||||
|
||||
# 2. Registrar en mvthist
|
||||
try:
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO mvthist (TicketID, PersonaID, Patente, RolID, Entidad, Sentido, ModuloID, FechaHora)
|
||||
VALUES (%s, %s, %s, 1, 'EGRESO...', 'Salida', %s, %s)
|
||||
""",
|
||||
(ticket_id, persona_id or None, patente or None, modulo_salida_id, ahora),
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# 3. Eliminar de tablas vivas
|
||||
cursor.execute("DELETE FROM tckper WHERE TicketID = %s", (ticket_id,))
|
||||
cursor.execute("DELETE FROM tckprx WHERE TicketID = %s", (ticket_id,))
|
||||
cursor.execute("DELETE FROM tck WHERE TicketID = %s", (ticket_id,))
|
||||
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def listar_tickets_activos() -> List[Dict[str, Any]]:
|
||||
"""Retorna todos los tickets actualmente activos en el predio."""
|
||||
query = """
|
||||
SELECT
|
||||
t.TicketID,
|
||||
t.FechaHoraIngreso,
|
||||
m.Nombre AS ModuloIngreso,
|
||||
p.PersonaID,
|
||||
p.Apellido,
|
||||
p.Nombre,
|
||||
d.Documento,
|
||||
pat.Valor AS Patente,
|
||||
lot.Valor AS LoteCodigo
|
||||
FROM tck t
|
||||
LEFT JOIN mdl m ON t.ModuloIngresoID = m.ModuloID
|
||||
INNER JOIN tckper tp ON t.TicketID = tp.TicketID AND tp.RolID = 1
|
||||
INNER JOIN Per p ON tp.PersonaID = p.PersonaID
|
||||
LEFT JOIN PerDocCatVal d ON p.PersonaID = d.PersonaID
|
||||
LEFT JOIN tckprx pat ON t.TicketID = pat.TicketID AND pat.PropiedadID = 4
|
||||
LEFT JOIN tckprx lot ON t.TicketID = lot.TicketID AND lot.PropiedadID = 7
|
||||
ORDER BY t.FechaHoraIngreso DESC
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query)
|
||||
return cursor.fetchall()
|
||||
|
||||
@staticmethod
|
||||
def buscar_personas_predictivo(term: str) -> List[Dict[str, Any]]:
|
||||
"""Búsqueda predictiva de personas por apellido, nombre o documento."""
|
||||
patron = f"%{term.strip()}%"
|
||||
query = """
|
||||
SELECT TOP 15 p.PersonaID, p.Apellido, p.Nombre, p.Sexo, d.Documento
|
||||
FROM Per p
|
||||
LEFT JOIN PerDocCatVal d ON p.PersonaID = d.PersonaID
|
||||
WHERE p.Apellido LIKE %s OR p.Nombre LIKE %s OR d.Documento LIKE %s
|
||||
ORDER BY p.Apellido, p.Nombre
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query, (patron, patron, patron))
|
||||
return cursor.fetchall()
|
||||
|
||||
@staticmethod
|
||||
def buscar_lotes_predictivo(term: str) -> List[Dict[str, Any]]:
|
||||
"""Búsqueda predictiva de lotes por código."""
|
||||
patron = f"%{term.strip()}%"
|
||||
query = """
|
||||
SELECT TOP 15 l.LoteID, l.Lote AS Codigo
|
||||
FROM lot l
|
||||
WHERE l.Lote LIKE %s
|
||||
ORDER BY l.Lote
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query, (patron,))
|
||||
return cursor.fetchall()
|
||||
@@ -0,0 +1,33 @@
|
||||
# ==============================================================================
|
||||
# Repositorio de Usuarios y Autenticación en SQL Server (videoman)
|
||||
# ==============================================================================
|
||||
from typing import Optional, Dict, Any
|
||||
from app.core.database import db_session
|
||||
|
||||
|
||||
class AuthRepository:
|
||||
@staticmethod
|
||||
def obtener_usuario_por_nombre(username: str) -> Optional[Dict[str, Any]]:
|
||||
"""Busca un usuario por su nombre (case-insensitive)."""
|
||||
query = """
|
||||
SELECT UsuarioID, Nombre, Password, SystemParameter
|
||||
FROM usr
|
||||
WHERE LOWER(Nombre) = LOWER(%s)
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query, (username.strip(),))
|
||||
row = cursor.fetchone()
|
||||
return row
|
||||
|
||||
@staticmethod
|
||||
def registrar_evento_login(usuario_id: int) -> None:
|
||||
"""Inserta auditoría de login en la tabla `usrlogin`."""
|
||||
query = "INSERT INTO usrlogin (usuarioID, Fecha) VALUES (%s, GETDATE())"
|
||||
try:
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(query, (usuario_id,))
|
||||
except Exception:
|
||||
# La auditoría no debe bloquear el login si la tabla tiene restricciones
|
||||
pass
|
||||
@@ -0,0 +1,51 @@
|
||||
# ==============================================================================
|
||||
# Repositorio de Workstations y Carriles en SQL Server (videoman)
|
||||
# ==============================================================================
|
||||
from typing import Optional, List, Dict, Any
|
||||
from app.core.database import db_session
|
||||
|
||||
|
||||
class WorkstationRepository:
|
||||
@staticmethod
|
||||
def obtener_workstation_por_nombre(name: str) -> Optional[Dict[str, Any]]:
|
||||
"""Busca una estación de trabajo por nombre en la tabla `wks`."""
|
||||
query = """
|
||||
SELECT WorkstationID, Nombre, SystemParameter
|
||||
FROM wks
|
||||
WHERE LOWER(Nombre) = LOWER(%s)
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query, (name.strip(),))
|
||||
return cursor.fetchone()
|
||||
|
||||
@staticmethod
|
||||
def listar_modulos_por_workstation(workstation_id: int) -> List[Dict[str, Any]]:
|
||||
"""Obtiene la lista de módulos de hardware / carriles vinculados a la estación."""
|
||||
query = """
|
||||
SELECT
|
||||
m.ModuloID,
|
||||
m.Nombre,
|
||||
m.Address,
|
||||
m.GrupoModulos,
|
||||
m.ModuloEntradaID,
|
||||
m.ModuloSalidaID,
|
||||
m.duracion_pulso
|
||||
FROM wksmdl wm
|
||||
JOIN mdl m ON wm.ModuloID = m.ModuloID
|
||||
WHERE wm.WorkstationID = %s
|
||||
ORDER BY m.ModuloID
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query, (workstation_id,))
|
||||
return cursor.fetchall()
|
||||
|
||||
@staticmethod
|
||||
def listar_todas() -> List[Dict[str, Any]]:
|
||||
"""Retorna todas las estaciones de trabajo registradas."""
|
||||
query = "SELECT WorkstationID, Nombre FROM wks ORDER BY Nombre"
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query)
|
||||
return cursor.fetchall()
|
||||
@@ -0,0 +1 @@
|
||||
# Schemas module
|
||||
@@ -0,0 +1,81 @@
|
||||
# ==============================================================================
|
||||
# Esquemas Pydantic v2 para Control de Accesos (Ingreso y Salida)
|
||||
# ==============================================================================
|
||||
from typing import List, Optional
|
||||
from datetime import datetime
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
|
||||
class CompanionDTO(BaseModel):
|
||||
documento: str = Field(..., description="DNI del acompañante")
|
||||
apellido: Optional[str] = None
|
||||
nombre: Optional[str] = None
|
||||
sexo: Optional[str] = "M"
|
||||
es_menor: bool = False
|
||||
rol_id: int = 2 # 2: Acompañante adulto, 3: Menor
|
||||
|
||||
|
||||
class EntryRequest(BaseModel):
|
||||
modulo_ingreso_id: int = Field(..., description="ID del módulo / barrera de entrada")
|
||||
documento: str = Field(..., min_length=4, description="DNI del conductor o visitante principal")
|
||||
apellido: Optional[str] = ""
|
||||
nombre: Optional[str] = ""
|
||||
sexo: Optional[str] = "M"
|
||||
patente: Optional[str] = Field(None, description="Patente del vehículo (o None si es peatonal)")
|
||||
lote_id: Optional[int] = Field(None, description="Lote de destino")
|
||||
lote_codigo: Optional[str] = Field(None, description="Código de lote (ej: 142)")
|
||||
motivo: Optional[str] = "VISITA"
|
||||
entidad: Optional[str] = None
|
||||
cantidad_ocupantes: int = Field(1, ge=1)
|
||||
cantidad_menores: int = Field(0, ge=0)
|
||||
cacheo_salida: bool = False
|
||||
abrir_barrera: bool = True
|
||||
foto_evidencia_b64: Optional[str] = None
|
||||
integrantes: List[CompanionDTO] = Field(default_factory=list)
|
||||
|
||||
|
||||
class ExitRequest(BaseModel):
|
||||
ticket_id: int = Field(..., description="ID del ticket activo a cerrar")
|
||||
modulo_salida_id: int = Field(..., description="ID del módulo / barrera de salida")
|
||||
persona_id: Optional[int] = 0
|
||||
rol_salida: Optional[int] = 1
|
||||
entidad_salida: Optional[str] = None
|
||||
patente_salida: Optional[str] = None
|
||||
abrir_barrera: bool = True
|
||||
personas_ids_permanecen: List[int] = Field(default_factory=list)
|
||||
|
||||
|
||||
class TicketResponse(BaseModel):
|
||||
status: str = "ok"
|
||||
ticket_id: int
|
||||
message: str
|
||||
barrier_opened: bool = False
|
||||
fecha_hora: str
|
||||
|
||||
|
||||
class ActiveTicketDTO(BaseModel):
|
||||
ticket_id: int
|
||||
persona_id: int
|
||||
documento: str
|
||||
apellido: str
|
||||
nombre: str
|
||||
patente: Optional[str] = None
|
||||
lote_codigo: Optional[str] = None
|
||||
modulo_ingreso: str
|
||||
fecha_ingreso: str
|
||||
ocupantes: int = 1
|
||||
|
||||
|
||||
class PersonSearchDTO(BaseModel):
|
||||
persona_id: int
|
||||
documento: str
|
||||
apellido: str
|
||||
nombre: str
|
||||
sexo: Optional[str] = "M"
|
||||
observaciones: Optional[str] = None
|
||||
|
||||
|
||||
class LotSearchDTO(BaseModel):
|
||||
lote_id: int
|
||||
codigo: str
|
||||
propietario: Optional[str] = None
|
||||
@@ -0,0 +1,25 @@
|
||||
# ==============================================================================
|
||||
# Esquemas Pydantic v2 para Autenticación y Sesión
|
||||
# ==============================================================================
|
||||
from typing import Optional
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
|
||||
class LoginRequest(BaseModel):
|
||||
username: str = Field(..., min_length=1, description="Nombre de usuario del operador")
|
||||
password: str = Field(..., min_length=1, description="Contraseña de acceso")
|
||||
workstation_name: Optional[str] = Field(None, description="Identificador de la estación de trabajo/tablet")
|
||||
|
||||
|
||||
class UserSessionDTO(BaseModel):
|
||||
user_id: int
|
||||
username: str
|
||||
role: str = "OPERADOR"
|
||||
system_parameter: Optional[int] = None
|
||||
|
||||
|
||||
class LoginResponse(BaseModel):
|
||||
status: str = "ok"
|
||||
message: str = "Autenticación exitosa"
|
||||
user: UserSessionDTO
|
||||
workstation: Optional[str] = None
|
||||
@@ -0,0 +1,20 @@
|
||||
# ==============================================================================
|
||||
# Esquemas Pydantic v2 para Hardware y Telemetría
|
||||
# ==============================================================================
|
||||
from typing import Optional
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
|
||||
class ManualOpenRequest(BaseModel):
|
||||
modulo_id: int = Field(..., description="ID del módulo a abrir")
|
||||
motivo: str = Field("APERTURA_MANUAL_GUARDIA", description="Justificación de auditoría")
|
||||
ticket_id: Optional[int] = Field(0, description="Ticket asociado si aplica")
|
||||
|
||||
|
||||
class HardwareCommandResponse(BaseModel):
|
||||
status: str = "ok"
|
||||
modulo_id: int
|
||||
address: int
|
||||
payload: str
|
||||
message: str
|
||||
latencia_ms: float
|
||||
@@ -0,0 +1,21 @@
|
||||
# ==============================================================================
|
||||
# Esquemas Pydantic v2 para Estaciones de Trabajo y Carriles
|
||||
# ==============================================================================
|
||||
from typing import List, Optional
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
|
||||
class LaneModuleDTO(BaseModel):
|
||||
modulo_id: int
|
||||
nombre: str
|
||||
address: int
|
||||
grupo_modulos: Optional[int] = None
|
||||
es_entrada: bool = True
|
||||
duracion_pulso: Optional[int] = None
|
||||
|
||||
|
||||
class WorkstationStatusResponse(BaseModel):
|
||||
workstation_name: str
|
||||
is_control_post: bool
|
||||
workstation_id: Optional[int] = None
|
||||
modules: List[LaneModuleDTO] = Field(default_factory=list)
|
||||
@@ -0,0 +1 @@
|
||||
# Services module
|
||||
@@ -0,0 +1,157 @@
|
||||
# ==============================================================================
|
||||
# Servicio de Negocio de Control de Accesos (Ingreso, Salida y Búsquedas)
|
||||
# ==============================================================================
|
||||
from datetime import datetime
|
||||
from typing import List, Dict, Any, Optional
|
||||
from fastapi import HTTPException, status
|
||||
from app.schemas.access_schema import (
|
||||
EntryRequest,
|
||||
ExitRequest,
|
||||
TicketResponse,
|
||||
ActiveTicketDTO,
|
||||
PersonSearchDTO,
|
||||
LotSearchDTO,
|
||||
)
|
||||
from app.repositories.access_repository import AccessRepository
|
||||
from app.services.hardware_service import HardwareService
|
||||
|
||||
|
||||
class AccessService:
|
||||
@staticmethod
|
||||
def procesar_ingreso(req: EntryRequest) -> TicketResponse:
|
||||
"""
|
||||
Ejecuta la regla de negocio para registrar el ingreso:
|
||||
1. Verifica antipassback del titular.
|
||||
2. Obtiene o crea la entidad Per / PerDocCatVal.
|
||||
3. Genera el TicketID canónico.
|
||||
4. Persiste en tck, tckprx, tckper, mvthist de forma atómica.
|
||||
5. Encola la apertura de barrera en pdtmdl si fue solicitada.
|
||||
"""
|
||||
# 1. Búsqueda preliminar para verificación de antipassback
|
||||
persona_existente = AccessRepository.buscar_persona_por_documento(req.documento)
|
||||
if persona_existente:
|
||||
pid = persona_existente["PersonaID"]
|
||||
if AccessRepository.verificar_antipassback(pid):
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_409_CONFLICT,
|
||||
detail=f"Antipassback detectado: La persona con DNI {req.documento} ya posee un ingreso activo en el predio.",
|
||||
)
|
||||
|
||||
# 2. Búsqueda o creación de la persona
|
||||
persona_id = AccessRepository.buscar_o_crear_persona(
|
||||
documento=req.documento,
|
||||
apellido=req.apellido or "",
|
||||
nombre=req.nombre or "",
|
||||
sexo=req.sexo or "M",
|
||||
)
|
||||
|
||||
# 3. Generación del TicketID
|
||||
ticket_id = AccessRepository.generar_ticket_id()
|
||||
|
||||
# 4. Registro transaccional en base de datos
|
||||
AccessRepository.registrar_ticket_ingreso(req, persona_id, ticket_id)
|
||||
|
||||
# 5. Apertura física de barrera vía pdtmdl
|
||||
barrier_opened = False
|
||||
if req.abrir_barrera and req.modulo_ingreso_id:
|
||||
ok, _ = HardwareService.encolar_apertura(req.modulo_ingreso_id, ticket_id)
|
||||
barrier_opened = ok
|
||||
|
||||
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
return TicketResponse(
|
||||
status="ok",
|
||||
ticket_id=ticket_id,
|
||||
message="Ingreso autorizado y registrado correctamente",
|
||||
barrier_opened=barrier_opened,
|
||||
fecha_hora=ahora,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def procesar_salida(req: ExitRequest) -> TicketResponse:
|
||||
"""
|
||||
Ejecuta la regla de negocio para registrar la salida:
|
||||
1. Valida existencia del ticket en tck.
|
||||
2. Mueve a tckhst y mvthist, liberando tckper y tck.
|
||||
3. Encola la apertura de barrera en pdtmdl si corresponde.
|
||||
"""
|
||||
ok = AccessRepository.registrar_ticket_salida(
|
||||
ticket_id=req.ticket_id,
|
||||
modulo_salida_id=req.modulo_salida_id,
|
||||
persona_id=req.persona_id or 0,
|
||||
patente=req.patente_salida or "",
|
||||
)
|
||||
if not ok:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND,
|
||||
detail=f"Ticket activo {req.ticket_id} no encontrado o ya fue egresado.",
|
||||
)
|
||||
|
||||
barrier_opened = False
|
||||
if req.abrir_barrera and req.modulo_salida_id:
|
||||
hw_ok, _ = HardwareService.encolar_apertura(req.modulo_salida_id, req.ticket_id)
|
||||
barrier_opened = hw_ok
|
||||
|
||||
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
return TicketResponse(
|
||||
status="ok",
|
||||
ticket_id=req.ticket_id,
|
||||
message="Salida registrada exitosamente",
|
||||
barrier_opened=barrier_opened,
|
||||
fecha_hora=ahora,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def obtener_tickets_activos() -> List[ActiveTicketDTO]:
|
||||
"""Obtiene la lista de tickets que se encuentran actualmente dentro del predio."""
|
||||
filas = AccessRepository.listar_tickets_activos()
|
||||
resultado = []
|
||||
for f in filas:
|
||||
f_ing = f["FechaHoraIngreso"]
|
||||
f_ing_str = f_ing.strftime("%Y-%m-%d %H:%M:%S") if isinstance(f_ing, datetime) else str(f_ing)
|
||||
resultado.append(
|
||||
ActiveTicketDTO(
|
||||
ticket_id=f["TicketID"],
|
||||
persona_id=f["PersonaID"],
|
||||
documento=str(f.get("Documento") or ""),
|
||||
apellido=str(f.get("Apellido") or ""),
|
||||
nombre=str(f.get("Nombre") or ""),
|
||||
patente=f.get("Patente"),
|
||||
lote_codigo=f.get("LoteCodigo"),
|
||||
modulo_ingreso=str(f.get("ModuloIngreso") or "Módulo Desconocido"),
|
||||
fecha_ingreso=f_ing_str,
|
||||
ocupantes=1,
|
||||
)
|
||||
)
|
||||
return resultado
|
||||
|
||||
@staticmethod
|
||||
def buscar_personas(term: str) -> List[PersonSearchDTO]:
|
||||
"""Búsqueda predictiva con autocompletado de personas."""
|
||||
if not term or len(term.strip()) < 2:
|
||||
return []
|
||||
filas = AccessRepository.buscar_personas_predictivo(term)
|
||||
return [
|
||||
PersonSearchDTO(
|
||||
persona_id=f["PersonaID"],
|
||||
documento=str(f.get("Documento") or ""),
|
||||
apellido=str(f.get("Apellido") or ""),
|
||||
nombre=str(f.get("Nombre") or ""),
|
||||
sexo=str(f.get("Sexo") or "M"),
|
||||
)
|
||||
for f in filas
|
||||
]
|
||||
|
||||
@staticmethod
|
||||
def buscar_lotes(term: str) -> List[LotSearchDTO]:
|
||||
"""Búsqueda predictiva con autocompletado de lotes."""
|
||||
if not term or len(term.strip()) < 1:
|
||||
return []
|
||||
filas = AccessRepository.buscar_lotes_predictivo(term)
|
||||
return [
|
||||
LotSearchDTO(
|
||||
lote_id=f["LoteID"],
|
||||
codigo=str(f["Codigo"]),
|
||||
propietario=None,
|
||||
)
|
||||
for f in filas
|
||||
]
|
||||
@@ -0,0 +1,60 @@
|
||||
# ==============================================================================
|
||||
# Servicio de Autenticación y Control de Sesión
|
||||
# ==============================================================================
|
||||
from typing import Optional, Tuple
|
||||
from fastapi import HTTPException, status
|
||||
from app.repositories.auth_repository import AuthRepository
|
||||
from app.core.security import verificar_password, crear_access_token
|
||||
from app.schemas.auth_schema import LoginResponse, UserSessionDTO
|
||||
|
||||
|
||||
class AuthService:
|
||||
@staticmethod
|
||||
def autenticar_usuario(
|
||||
username: str, password_raw: str, workstation_name: Optional[str] = None
|
||||
) -> Tuple[LoginResponse, str]:
|
||||
"""Valida credenciales, genera token JWT y registra auditoría."""
|
||||
user_row = AuthRepository.obtener_usuario_por_nombre(username)
|
||||
if not user_row:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Credenciales inválidas: usuario o contraseña incorrectos",
|
||||
)
|
||||
|
||||
stored_password = user_row.get("Password", "")
|
||||
if not verificar_password(password_raw, stored_password):
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Credenciales inválidas: usuario o contraseña incorrectos",
|
||||
)
|
||||
|
||||
user_id = user_row["UsuarioID"]
|
||||
nombre = user_row["Nombre"].strip()
|
||||
system_param = user_row.get("SystemParameter")
|
||||
|
||||
# Generar Token JWT
|
||||
token_data = {
|
||||
"sub": str(user_id),
|
||||
"username": nombre,
|
||||
"workstation": workstation_name or "",
|
||||
}
|
||||
token = crear_access_token(token_data)
|
||||
|
||||
# Registrar auditoría en usrlogin
|
||||
AuthRepository.registrar_evento_login(user_id)
|
||||
|
||||
user_dto = UserSessionDTO(
|
||||
user_id=user_id,
|
||||
username=nombre,
|
||||
role="SUPERVISOR" if system_param == 1 else "OPERADOR",
|
||||
system_parameter=system_param,
|
||||
)
|
||||
|
||||
response = LoginResponse(
|
||||
status="ok",
|
||||
message="Autenticación exitosa",
|
||||
user=user_dto,
|
||||
workstation=workstation_name,
|
||||
)
|
||||
|
||||
return response, token
|
||||
@@ -0,0 +1,121 @@
|
||||
# ==============================================================================
|
||||
# Servicio de Parseo y Normalización de DNI Argentino (PDF417 / QR)
|
||||
# Soporta formatos 2009, 2012, 2026 y App Mi Argentina
|
||||
# ==============================================================================
|
||||
from typing import Dict
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class DNIParsedResult(BaseModel):
|
||||
valido: bool
|
||||
documento: str
|
||||
apellido: str
|
||||
nombre: str
|
||||
sexo: str
|
||||
|
||||
|
||||
class DniParserService:
|
||||
@staticmethod
|
||||
def parsear(raw_text: str) -> Dict[str, str]:
|
||||
"""
|
||||
Parsea el texto decodificado por la cámara de la tablet o escáner.
|
||||
Retorna: {"documento": str, "apellido": str, "nombre": str, "sexo": str}
|
||||
"""
|
||||
if not raw_text:
|
||||
return {"documento": "", "apellido": "", "nombre": "", "sexo": "M"}
|
||||
|
||||
# Limpiar terminadores y retornos de carro
|
||||
raw_clean = raw_text.strip().replace("\r", "").replace("\n", "")
|
||||
|
||||
# Algunos escáneres o formatos vienen separados por @ en lugar de comillas dobles
|
||||
text = raw_clean.replace("@", '"')
|
||||
parts = [p.strip() for p in text.split('"')]
|
||||
|
||||
if len(parts) < 5:
|
||||
# Si solo vino un número de documento escrito manualmente
|
||||
digits = "".join(filter(str.isdigit, raw_clean))
|
||||
if 6 <= len(digits) <= 9:
|
||||
return {"documento": digits, "apellido": "", "nombre": "", "sexo": "M"}
|
||||
return {"documento": "", "apellido": "", "nombre": "", "sexo": "M"}
|
||||
|
||||
doc = nombre = apellido = sexo = ""
|
||||
|
||||
# Heurística para Formato 2009 con comilla inicial
|
||||
if parts[0] == "" and 6 <= len(parts[1]) <= 11 and len(parts) > 2 and parts[2].isalpha() and len(parts[2]) == 1:
|
||||
doc = parts[1]
|
||||
if len(parts) > 5:
|
||||
apellido = parts[4]
|
||||
nombre = parts[5]
|
||||
|
||||
# Heurística para Formato 2009 sin comilla inicial
|
||||
elif 6 <= len(parts[0]) <= 11 and len(parts) > 4 and parts[1].isalpha() and len(parts[1]) == 1:
|
||||
doc = parts[0]
|
||||
apellido = parts[3]
|
||||
nombre = parts[4]
|
||||
|
||||
# Formatos 2012, 2026 y App Mi Argentina
|
||||
else:
|
||||
if parts[0] == "" and len(parts) > 1:
|
||||
parts = parts[1:]
|
||||
|
||||
if parts[0].isdigit() and len(parts[0]) >= 8:
|
||||
apellido = parts[1] if len(parts) > 1 else ""
|
||||
nombre = parts[2] if len(parts) > 2 else ""
|
||||
|
||||
if len(parts) > 3:
|
||||
p3 = parts[3].strip()
|
||||
p4 = parts[4].strip() if len(parts) > 4 else ""
|
||||
|
||||
# Formato 2012: parts[3] es letra de sexo (M, F, X)
|
||||
if len(p3) == 1 and p3.upper() in ("M", "F", "X"):
|
||||
sexo = p3.upper()
|
||||
if len(parts) > 4:
|
||||
doc = p4
|
||||
|
||||
# Formato App Mi Argentina: parts[3] es código 1=M, 2=F, 3=X y parts[4] es DNI
|
||||
elif p3 in ("1", "2", "3", "0") and p4.isdigit() and 6 <= len(p4) <= 9:
|
||||
sexo = "M" if p3 == "1" else ("F" if p3 == "2" else "X")
|
||||
doc = p4
|
||||
|
||||
# Formato 2026: parts[3] es DNI directo
|
||||
elif p3.isdigit() and 6 <= len(p3) <= 9 and not (p4.isdigit() and 6 <= len(p4) <= 9):
|
||||
doc = p3
|
||||
if p4.upper() in ("M", "F", "X"):
|
||||
sexo = p4.upper()
|
||||
elif p4.upper() == "G":
|
||||
sexo = "M"
|
||||
|
||||
# Desempate general: si parts[4] es DNI numérico
|
||||
elif p4.isdigit() and 6 <= len(p4) <= 9:
|
||||
doc = p4
|
||||
if p3 == "1":
|
||||
sexo = "M"
|
||||
elif p3 == "2":
|
||||
sexo = "F"
|
||||
elif p3.upper() in ("M", "F", "X"):
|
||||
sexo = p3.upper()
|
||||
else:
|
||||
doc = p3
|
||||
|
||||
return {
|
||||
"documento": doc.strip(),
|
||||
"apellido": apellido.upper().strip() if apellido else "",
|
||||
"nombre": nombre.upper().strip() if nombre else "",
|
||||
"sexo": sexo or "M",
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def parsear_codigo(cls, raw_text: str) -> DNIParsedResult:
|
||||
res = cls.parsear(raw_text)
|
||||
valido = bool(res["documento"] and len(res["documento"]) >= 6)
|
||||
return DNIParsedResult(
|
||||
valido=valido,
|
||||
documento=res["documento"],
|
||||
apellido=res["apellido"],
|
||||
nombre=res["nombre"],
|
||||
sexo=res["sexo"],
|
||||
)
|
||||
|
||||
|
||||
# Alias para compatibilidad de nomenclatura
|
||||
DNIParsingService = DniParserService
|
||||
@@ -0,0 +1,94 @@
|
||||
# ==============================================================================
|
||||
# Servicio de Integración de Hardware Industrial (ST1660 / pdtmdl)
|
||||
# ==============================================================================
|
||||
import time
|
||||
from typing import Tuple, Dict, Any, Optional
|
||||
from app.core.database import db_session
|
||||
|
||||
ASCII_STX = "\x02" # Start of text
|
||||
ASCII_EOF = "\x03" # End of file
|
||||
|
||||
|
||||
def calcular_checksum(comando: str) -> str:
|
||||
"""Calcula el checksum de 2 dígitos hexadecimales idéntico a VB6 Protocolo.cls."""
|
||||
raw = comando.encode("latin-1", errors="ignore")
|
||||
checksum = 0
|
||||
for b in raw:
|
||||
checksum = (checksum + b) & 0xFF
|
||||
checksum = ((0xFF - checksum) + 1) & 0xFF
|
||||
return f"{checksum:02X}"
|
||||
|
||||
|
||||
def formatear_comando_hardware(direccion: int, comando_payload: str) -> str:
|
||||
"""Genera la trama física: STX + Addr(2) + Payload + CS(2) + EOF."""
|
||||
direccion_str = f"{direccion:02d}"
|
||||
base = f"{ASCII_STX}{direccion_str}{comando_payload}"
|
||||
cs = calcular_checksum(base)
|
||||
return f"{base}{cs}{ASCII_EOF}"
|
||||
|
||||
|
||||
class HardwareService:
|
||||
@staticmethod
|
||||
def obtener_info_modulo(modulo_id: int) -> Optional[Dict[str, Any]]:
|
||||
"""Obtiene address, tipo y configuración del módulo desde la tabla `mdl`."""
|
||||
query = """
|
||||
SELECT m.ModuloID, m.Nombre, m.Address, m.ModuloEntradaID, m.ModuloSalidaID,
|
||||
m.duracion_pulso, m.ValidacionTicket
|
||||
FROM mdl m
|
||||
WHERE m.ModuloID = %s
|
||||
"""
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor(as_dict=True)
|
||||
cursor.execute(query, (modulo_id,))
|
||||
return cursor.fetchone()
|
||||
|
||||
@classmethod
|
||||
def encolar_apertura(cls, modulo_id: int, ticket_id: int = 0) -> Tuple[bool, Dict[str, Any]]:
|
||||
"""
|
||||
Encola un comando de apertura de barrera/molinete en la tabla `pdtmdl`
|
||||
para que OnEverWPC lo despache al bus RS-485 físico en < 50ms.
|
||||
"""
|
||||
t_start = time.perf_counter()
|
||||
mdl = cls.obtener_info_modulo(modulo_id)
|
||||
if not mdl:
|
||||
return False, {"error": f"Módulo {modulo_id} no encontrado en base de datos"}
|
||||
|
||||
address = mdl.get("Address", 1)
|
||||
duracion = mdl.get("duracion_pulso") or 500
|
||||
|
||||
# Verificamos si es variante PASS (Access) o PARK (Default)
|
||||
is_pass = False
|
||||
try:
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(
|
||||
"SELECT ValorID FROM MdlCatVal WHERE ModuloID = %s AND CategoriaID = 2",
|
||||
(modulo_id,),
|
||||
)
|
||||
row = cursor.fetchone()
|
||||
is_pass = (row is not None and int(row[0]) == 1)
|
||||
except Exception:
|
||||
is_pass = False
|
||||
|
||||
# Determinación del payload de pulso según protocolo
|
||||
payload = "V3" if is_pass else "O3"
|
||||
trama_comando = formatear_comando_hardware(address, payload)
|
||||
|
||||
sql_insert = """
|
||||
INSERT INTO pdtmdl (PdtMdlID, ModuloID, Comando, Inmediato, Extra)
|
||||
VALUES ((SELECT COALESCE(MAX(PdtMdlID), 0) + 1 FROM pdtmdl), %s, %s, 1, %s)
|
||||
"""
|
||||
extra_info = str(ticket_id or 0)[:20]
|
||||
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(sql_insert, (modulo_id, trama_comando, extra_info))
|
||||
|
||||
latencia = (time.perf_counter() - t_start) * 1000
|
||||
|
||||
return True, {
|
||||
"modulo_id": modulo_id,
|
||||
"address": address,
|
||||
"payload": payload,
|
||||
"latencia_ms": round(latencia, 2),
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
# ==============================================================================
|
||||
# Servicio de Gestión de Estaciones de Trabajo (Workstations)
|
||||
# ==============================================================================
|
||||
from typing import List, Dict, Any
|
||||
from app.repositories.workstation_repository import WorkstationRepository
|
||||
from app.schemas.workstation_schema import WorkstationStatusResponse, LaneModuleDTO
|
||||
|
||||
|
||||
class WorkstationService:
|
||||
@staticmethod
|
||||
def obtener_estado_workstation(name: str) -> WorkstationStatusResponse:
|
||||
"""Determina si la tablet/workstation está registrada y qué carriles tiene asignados."""
|
||||
wks_row = WorkstationRepository.obtener_workstation_por_nombre(name)
|
||||
if not wks_row:
|
||||
return WorkstationStatusResponse(
|
||||
workstation_name=name,
|
||||
is_control_post=False,
|
||||
workstation_id=None,
|
||||
modules=[],
|
||||
)
|
||||
|
||||
wks_id = wks_row["WorkstationID"]
|
||||
nombre_oficial = wks_row["Nombre"].strip()
|
||||
modulos_rows = WorkstationRepository.listar_modulos_por_workstation(wks_id)
|
||||
|
||||
modules_dto: List[LaneModuleDTO] = []
|
||||
for m in modulos_rows:
|
||||
# Determinamos si es entrada o salida según ModuloEntradaID o nombre
|
||||
es_entrada = bool(m.get("ModuloEntradaID")) or "ENTRADA" in m["Nombre"].upper()
|
||||
modules_dto.append(
|
||||
LaneModuleDTO(
|
||||
modulo_id=m["ModuloID"],
|
||||
nombre=m["Nombre"].strip(),
|
||||
address=m["Address"],
|
||||
grupo_modulos=m.get("GrupoModulos"),
|
||||
es_entrada=es_entrada,
|
||||
duracion_pulso=m.get("duracion_pulso"),
|
||||
)
|
||||
)
|
||||
|
||||
return WorkstationStatusResponse(
|
||||
workstation_name=nombre_oficial,
|
||||
is_control_post=len(modules_dto) > 0,
|
||||
workstation_id=wks_id,
|
||||
modules=modules_dto,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def listar_estaciones_disponibles() -> List[Dict[str, Any]]:
|
||||
"""Retorna el listado de todas las workstations disponibles para selección de supervisor."""
|
||||
rows = WorkstationRepository.listar_todas()
|
||||
return [{"workstation_id": r["WorkstationID"], "nombre": r["Nombre"].strip()} for r in rows]
|
||||
@@ -7,3 +7,4 @@ python-multipart>=0.0.9
|
||||
httpx>=0.27.0
|
||||
pytest>=8.1.0
|
||||
pytest-asyncio>=0.23.0
|
||||
PyJWT>=2.8.0
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
from app.core.database import db_session
|
||||
|
||||
with db_session() as conn:
|
||||
c = conn.cursor(as_dict=True)
|
||||
c.execute("SELECT TOP 3 PersonaID, CREATEdByID, LastUpdateDateByID, Apellido, Nombre FROM Per")
|
||||
for r in c.fetchall():
|
||||
print(r)
|
||||
|
||||
print("--- lot table schema ---")
|
||||
c.execute("""
|
||||
SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT
|
||||
FROM INFORMATION_SCHEMA.COLUMNS
|
||||
WHERE TABLE_NAME = 'lot'
|
||||
ORDER BY ORDINAL_POSITION
|
||||
""")
|
||||
for r in c.fetchall():
|
||||
print(r["COLUMN_NAME"], r["DATA_TYPE"])
|
||||
@@ -0,0 +1,16 @@
|
||||
from app.core.database import db_session
|
||||
|
||||
tables = ['PerDocCatVal', 'tck', 'tckper', 'tckprx', 'tckhst', 'pdtmdl']
|
||||
with db_session() as conn:
|
||||
c = conn.cursor(as_dict=True)
|
||||
for t in tables:
|
||||
print(f"--- {t} NOT NULL columns ---")
|
||||
c.execute(f"""
|
||||
SELECT COLUMN_NAME, DATA_TYPE, COLUMN_DEFAULT
|
||||
FROM INFORMATION_SCHEMA.COLUMNS
|
||||
WHERE TABLE_NAME = '{t}' AND IS_NULLABLE = 'NO'
|
||||
""")
|
||||
print("--- Sample PerDocCatVal ---")
|
||||
c.execute("SELECT TOP 3 * FROM PerDocCatVal")
|
||||
for r in c.fetchall():
|
||||
print(r)
|
||||
@@ -0,0 +1,172 @@
|
||||
import pytest
|
||||
from httpx import AsyncClient, ASGITransport
|
||||
from app.main import app
|
||||
from app.services.dni_parser_service import DNIParsingService
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_parse_dni_api():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
# Autenticación previa
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
raw_qr = "0034567890@PEREZ@JUAN CARLOS@M@30123456@A@01/01/1985@01/01/2020@200"
|
||||
res = await client.post(
|
||||
"/api/v1/access/parse-dni",
|
||||
json={"raw_data": raw_qr},
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert res.status_code == 200
|
||||
data = res.json()
|
||||
assert data["valido"] is True
|
||||
assert data["documento"] == "30123456"
|
||||
assert data["apellido"] == "PEREZ"
|
||||
assert data["nombre"] == "JUAN CARLOS"
|
||||
assert data["sexo"] == "M"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_search_people_and_lots():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
# Búsqueda de personas
|
||||
p_res = await client.get(
|
||||
"/api/v1/access/people/search?q=TEST",
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert p_res.status_code == 200
|
||||
assert isinstance(p_res.json(), list)
|
||||
|
||||
# Búsqueda de lotes
|
||||
l_res = await client.get(
|
||||
"/api/v1/access/lots/search?q=1",
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert l_res.status_code == 200
|
||||
assert isinstance(l_res.json(), list)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_hardware_manual_open():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
res = await client.post(
|
||||
"/api/v1/hardware/modules/100004/open",
|
||||
json={"modulo_id": 100004, "motivo": "TEST_AUDIT"},
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert res.status_code == 200
|
||||
data = res.json()
|
||||
assert data["status"] == "ok"
|
||||
assert data["modulo_id"] == 100004
|
||||
assert data["latencia_ms"] < 500.0
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_flujo_completo_ingreso_y_salida():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
doc_test = "99887766"
|
||||
|
||||
# 1. Registro de Ingreso
|
||||
entry_payload = {
|
||||
"modulo_ingreso_id": 100004,
|
||||
"documento": doc_test,
|
||||
"apellido": "TESTER",
|
||||
"nombre": "INTEGRAL",
|
||||
"sexo": "M",
|
||||
"patente": "TST999",
|
||||
"lote_codigo": "100",
|
||||
"motivo": "PRUEBA AUTOMATIZADA",
|
||||
"cantidad_ocupantes": 1,
|
||||
"abrir_barrera": True,
|
||||
}
|
||||
|
||||
entry_res = await client.post(
|
||||
"/api/v1/access/entry",
|
||||
json=entry_payload,
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert entry_res.status_code == 200
|
||||
tck_data = entry_res.json()
|
||||
assert tck_data["status"] == "ok"
|
||||
ticket_id = tck_data["ticket_id"]
|
||||
assert ticket_id > 0
|
||||
assert tck_data["barrier_opened"] is True
|
||||
|
||||
# 2. Verificar que aparezca en tickets activos
|
||||
active_res = await client.get(
|
||||
"/api/v1/access/tickets/active",
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert active_res.status_code == 200
|
||||
tickets = active_res.json()
|
||||
ids_activos = [t["ticket_id"] for t in tickets]
|
||||
assert ticket_id in ids_activos
|
||||
|
||||
# 3. Intentar reingreso (Antipassback)
|
||||
dup_res = await client.post(
|
||||
"/api/v1/access/entry",
|
||||
json=entry_payload,
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert dup_res.status_code == 409
|
||||
assert "Antipassback" in dup_res.json()["detail"]
|
||||
|
||||
# 4. Registrar Salida
|
||||
exit_payload = {
|
||||
"ticket_id": ticket_id,
|
||||
"modulo_salida_id": 100005,
|
||||
"patente_salida": "TST999",
|
||||
"abrir_barrera": True,
|
||||
}
|
||||
exit_res = await client.post(
|
||||
"/api/v1/access/exit",
|
||||
json=exit_payload,
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert exit_res.status_code == 200
|
||||
exit_data = exit_res.json()
|
||||
assert exit_data["status"] == "ok"
|
||||
assert exit_data["barrier_opened"] is True
|
||||
|
||||
# 5. Verificar que ya no esté en activos
|
||||
active_res2 = await client.get(
|
||||
"/api/v1/access/tickets/active",
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
ids_activos2 = [t["ticket_id"] for t in active_res2.json()]
|
||||
assert ticket_id not in ids_activos2
|
||||
|
||||
# Teardown / Limpieza
|
||||
from app.core.database import db_session
|
||||
with db_session() as conn:
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("DELETE FROM PerDocCatVal WHERE Documento = %s", (doc_test,))
|
||||
cursor.execute("DELETE FROM Per WHERE Apellido = 'TESTER'")
|
||||
cursor.execute("DELETE FROM pdtmdl WHERE ModuloID IN (100004, 100005) AND Extra = %s", (str(ticket_id),))
|
||||
cursor.execute("DELETE FROM mvthist WHERE TicketID = %s", (ticket_id,))
|
||||
cursor.execute("DELETE FROM tckhst WHERE TicketID = %s", (ticket_id,))
|
||||
@@ -0,0 +1,69 @@
|
||||
import pytest
|
||||
from httpx import AsyncClient, ASGITransport
|
||||
from app.main import app
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_login_exitoso_credenciales_validas():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia", "workstation_name": "CFT-DESK"},
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
data = response.json()
|
||||
assert data["status"] == "ok"
|
||||
assert data["user"]["username"].lower() == "guardia"
|
||||
assert data["workstation"] == "CFT-DESK"
|
||||
assert "access_token" in response.cookies
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_login_fallido_password_incorrecta():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "password_incorrecta_999"},
|
||||
)
|
||||
|
||||
assert response.status_code == 401
|
||||
data = response.json()
|
||||
assert "detail" in data
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_login_fallido_usuario_inexistente():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "usuario_inexistente_xyz", "password": "alguna_password"},
|
||||
)
|
||||
|
||||
assert response.status_code == 401
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_me_con_sesion_activa_y_logout():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
# 1. Login
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
assert login_res.status_code == 200
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
# 2. Consultar /me
|
||||
me_res = await client.get("/api/v1/auth/me", cookies={"access_token": token})
|
||||
assert me_res.status_code == 200
|
||||
me_data = me_res.json()
|
||||
assert me_data["username"].lower() == "guardia"
|
||||
|
||||
# 3. Logout
|
||||
logout_res = await client.post("/api/v1/auth/logout")
|
||||
assert logout_res.status_code == 200
|
||||
@@ -0,0 +1,42 @@
|
||||
import pytest
|
||||
from httpx import AsyncClient, ASGITransport
|
||||
from app.main import app
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_workstation_status_existente():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get("/api/v1/control-posts/workstation/CFT-DESK/status")
|
||||
|
||||
assert response.status_code == 200
|
||||
data = response.json()
|
||||
assert data["workstation_name"].upper() == "CFT-DESK"
|
||||
assert data["is_control_post"] is True
|
||||
assert data["workstation_id"] == 100001
|
||||
assert len(data["modules"]) > 0
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_workstation_status_no_registrada():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get("/api/v1/control-posts/workstation/TABLET_DESCONOCIDA_999/status")
|
||||
|
||||
assert response.status_code == 200
|
||||
data = response.json()
|
||||
assert data["is_control_post"] is False
|
||||
assert len(data["modules"]) == 0
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_listar_workstations():
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
response = await client.get("/api/v1/control-posts/workstations")
|
||||
|
||||
assert response.status_code == 200
|
||||
data = response.json()
|
||||
assert isinstance(data, list)
|
||||
nombres = [item["nombre"].upper() for item in data]
|
||||
assert "CFT-DESK" in nombres
|
||||
@@ -0,0 +1,33 @@
|
||||
import pytest
|
||||
from app.services.dni_parser_service import DniParserService
|
||||
|
||||
|
||||
def test_parser_dni_formato_2012():
|
||||
raw = '00680051210"TELLO"CARLOS FACUNDO"M"34247025"B"09/02/1989"13/10/2021'
|
||||
res = DniParserService.parsear(raw)
|
||||
assert res["documento"] == "34247025"
|
||||
assert res["apellido"] == "TELLO"
|
||||
assert res["nombre"] == "CARLOS FACUNDO"
|
||||
assert res["sexo"] == "M"
|
||||
|
||||
|
||||
def test_parser_dni_formato_mi_argentina_con_arrobas():
|
||||
raw = '00305336518@CIRILLI@GEORGINA SUSANA@2@28988082@A@23/08/1981@13/10/2014'
|
||||
res = DniParserService.parsear(raw)
|
||||
assert res["documento"] == "28988082"
|
||||
assert res["apellido"] == "CIRILLI"
|
||||
assert res["nombre"] == "GEORGINA SUSANA"
|
||||
assert res["sexo"] == "F"
|
||||
|
||||
|
||||
def test_parser_dni_formato_2009():
|
||||
raw = '"34247025"A"1"TELLO"CARLOS FACUNDO"M"'
|
||||
res = DniParserService.parsear(raw)
|
||||
assert res["documento"] == "34247025"
|
||||
assert res["apellido"] == "TELLO"
|
||||
assert res["nombre"] == "CARLOS FACUNDO"
|
||||
|
||||
|
||||
def test_parser_dni_numero_manual():
|
||||
res = DniParserService.parsear("34247025")
|
||||
assert res["documento"] == "34247025"
|
||||
@@ -0,0 +1,26 @@
|
||||
import pytest
|
||||
from app.repositories.workstation_repository import WorkstationRepository
|
||||
from app.repositories.auth_repository import AuthRepository
|
||||
|
||||
|
||||
def test_obtener_workstation_existente():
|
||||
wks = WorkstationRepository.obtener_workstation_por_nombre("CFT-DESK")
|
||||
assert wks is not None
|
||||
assert wks["Nombre"].strip().upper() == "CFT-DESK"
|
||||
assert wks["WorkstationID"] == 100001
|
||||
|
||||
modulos = WorkstationRepository.listar_modulos_por_workstation(wks["WorkstationID"])
|
||||
assert isinstance(modulos, list)
|
||||
assert len(modulos) > 0
|
||||
|
||||
|
||||
def test_obtener_workstation_inexistente():
|
||||
wks = WorkstationRepository.obtener_workstation_por_nombre("ESTACION_INEXISTENTE_999")
|
||||
assert wks is None
|
||||
|
||||
|
||||
def test_obtener_usuario_existente():
|
||||
usr = AuthRepository.obtener_usuario_por_nombre("guardia")
|
||||
assert usr is not None
|
||||
assert usr["Nombre"].strip().lower() == "guardia"
|
||||
assert "Password" in usr
|
||||
@@ -0,0 +1,29 @@
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
from app.schemas.auth_schema import LoginRequest, LoginResponse, UserSessionDTO
|
||||
from app.schemas.workstation_schema import LaneModuleDTO, WorkstationStatusResponse
|
||||
|
||||
|
||||
def test_login_request_valid():
|
||||
req = LoginRequest(username="guardia", password="secret_password", workstation_name="TABLET_01")
|
||||
assert req.username == "guardia"
|
||||
assert req.password == "secret_password"
|
||||
assert req.workstation_name == "TABLET_01"
|
||||
|
||||
|
||||
def test_login_request_empty_fields_raises_validation_error():
|
||||
with pytest.raises(ValidationError):
|
||||
LoginRequest(username="", password="")
|
||||
|
||||
|
||||
def test_workstation_status_response_schema():
|
||||
mod = LaneModuleDTO(modulo_id=100004, nombre="ENTRADA VISITAS", address=98, es_entrada=True)
|
||||
status = WorkstationStatusResponse(
|
||||
workstation_name="CFT-DESK",
|
||||
is_control_post=True,
|
||||
workstation_id=100001,
|
||||
modules=[mod],
|
||||
)
|
||||
assert status.is_control_post is True
|
||||
assert len(status.modules) == 1
|
||||
assert status.modules[0].modulo_id == 100004
|
||||
@@ -0,0 +1,90 @@
|
||||
# ==============================================================================
|
||||
# Pruebas de Estrés, Concurrencia y Latencia (Fase 5 - QA)
|
||||
# ==============================================================================
|
||||
import time
|
||||
import asyncio
|
||||
import pytest
|
||||
from httpx import AsyncClient, ASGITransport
|
||||
from app.main import app
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_latencia_comando_hardware_pdtmdl():
|
||||
"""Valida que el encolado en pdtmdl cumpla con latencia inferior a 100ms en ráfaga."""
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
latencias = []
|
||||
for i in range(5):
|
||||
t0 = time.perf_counter()
|
||||
res = await client.post(
|
||||
"/api/v1/hardware/modules/100004/open",
|
||||
json={"modulo_id": 100004, "motivo": f"STRESS_TEST_{i}"},
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
elapsed_ms = (time.perf_counter() - t0) * 1000
|
||||
assert res.status_code == 200
|
||||
latencias.append(elapsed_ms)
|
||||
|
||||
promedio = sum(latencias) / len(latencias)
|
||||
print(f"\n[LATENCIA PROMEDIO HARDWARE]: {promedio:.2f} ms")
|
||||
assert promedio < 200.0 # Muy por debajo del umbral admisible en red local
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_concurrencia_busqueda_predictiva():
|
||||
"""Simula 10 consultas simultáneas de autocompletado para verificar el pool de conexiones."""
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
async def query_lot(idx: int):
|
||||
return await client.get(
|
||||
f"/api/v1/access/lots/search?q={idx}",
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
|
||||
tasks = [query_lot(i % 5 + 1) for i in range(10)]
|
||||
results = await asyncio.gather(*tasks)
|
||||
|
||||
for r in results:
|
||||
assert r.status_code == 200
|
||||
assert isinstance(r.json(), list)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_stress_parser_dni_variados():
|
||||
"""Verifica la robustez del parser ante diferentes combinaciones de códigos sin degradación."""
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
login_res = await client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"username": "guardia", "password": "guardia"},
|
||||
)
|
||||
token = login_res.cookies.get("access_token")
|
||||
|
||||
codigos_prueba = [
|
||||
'0034567890@PEREZ@JUAN CARLOS@M@30123456@A@01/01/1985@01/01/2020@200',
|
||||
'"40111222"A"1"GONZALEZ"MARIA"F"',
|
||||
'0011223344@LOPEZ@CARLOS@1@25999888@B@10/10/1975',
|
||||
'0099887766@RODRIGUEZ@LUCIA@2@38555444@B@15/05/1994',
|
||||
]
|
||||
|
||||
for raw in codigos_prueba:
|
||||
res = await client.post(
|
||||
"/api/v1/access/parse-dni",
|
||||
json={"raw_data": raw},
|
||||
cookies={"access_token": token},
|
||||
)
|
||||
assert res.status_code == 200
|
||||
assert res.json()["valido"] is True
|
||||
assert len(res.json()["documento"]) >= 6
|
||||
Reference in New Issue
Block a user