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:
Carlos Tello
2026-10-13 15:47:43 -03:00
parent 78c1a306de
commit 1ba74f7929
53 changed files with 4000 additions and 279 deletions
+1 -1
View File
@@ -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"
+98
View File
@@ -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
+78
View File
@@ -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",
)
+29
View File
@@ -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()
+48
View File
@@ -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"],
)
+5 -7
View File
@@ -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"])
+68
View File
@@ -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)
+53
View File
@@ -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
+108
View File
@@ -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
View File
@@ -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)
+1
View File
@@ -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()
+1
View File
@@ -0,0 +1 @@
# Schemas module
+81
View File
@@ -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
+25
View File
@@ -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
+20
View File
@@ -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
+21
View File
@@ -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)
+1
View File
@@ -0,0 +1 @@
# Services module
+157
View File
@@ -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
]
+60
View File
@@ -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
+121
View File
@@ -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
+94
View File
@@ -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]
+1
View File
@@ -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
+17
View File
@@ -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"])
+16
View File
@@ -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)
+172
View File
@@ -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,))
+69
View File
@@ -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
+42
View File
@@ -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
+33
View File
@@ -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"
+26
View File
@@ -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
+29
View File
@@ -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
+90
View File
@@ -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