feat: complete Phases 2 to 5 inclusive - Access Core, Web Cockpit, Hardware enqueuing, Optical Scanner and QA (v0.5.0-beta)
This commit is contained in:
@@ -0,0 +1 @@
|
||||
# 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()
|
||||
Reference in New Issue
Block a user