feat(parity): implement Bloques 1, 2 y 3 complete feature parity v0.7.0-beta

This commit is contained in:
Carlos Tello
2026-10-29 20:52:58 -03:00
parent 918b87c645
commit ad92bb5fc1
28 changed files with 3704 additions and 118 deletions
@@ -1,6 +1,7 @@
# ==============================================================================
# Repositorio de Control de Accesos (SQL Server videoman)
# ==============================================================================
import re
from datetime import datetime
from typing import Optional, List, Dict, Any, Tuple
from app.core.database import db_session
@@ -191,6 +192,13 @@ class AccessRepository:
except Exception as e:
print(f"Nota: error al guardar polizas/vehiculo: {e}")
# 7. Consumir preautorización atómicamente si fue provista
if getattr(req, "preautorizado_id", None):
try:
AccessRepository.consumir_preautorizacion(req.preautorizado_id)
except Exception as e:
print(f"Nota: error al consumir preautorizacion {req.preautorizado_id}: {e}")
return ticket_id
@staticmethod
@@ -947,3 +955,318 @@ class AccessRepository:
return True
@staticmethod
def obtener_preautorizados_activos(busqueda: str = "", solo_vigentes: bool = True) -> List[Dict[str, Any]]:
"""Consulta visitas preautorizadas activas en la tabla 'pre'."""
where_clauses = []
params = []
if solo_vigentes:
where_clauses.append("pr.FechaInicio <= DATEADD(day, 1, GETDATE()) AND pr.FechaFin >= DATEADD(day, -1, GETDATE())")
if busqueda:
palabras = [w.strip() for w in busqueda.split() if w.strip()]
for w in palabras:
p_like = f"%{w}%"
where_clauses.append("(pr.Apellido LIKE %s OR pr.Nombre LIKE %s OR pr.Entidad LIKE %s OR pr.Motivo LIKE %s OR l.Lote LIKE %s)")
params.extend([p_like, p_like, p_like, p_like, p_like])
where_sql = ("WHERE " + " AND ".join(where_clauses)) if where_clauses else ""
sql = f"""
SELECT
pr.PreautorizadoID AS id,
pr.LoteID AS lote_id,
ISNULL(l.Lote, 'Sin Lote') AS lote_nombre,
ISNULL(pr.Apellido, '') AS apellido,
ISNULL(pr.Nombre, '') AS nombre,
ISNULL(pr.Entidad, '') AS entidad,
ISNULL(pr.Motivo, '') AS motivo,
CONVERT(varchar, pr.FechaInicio, 120) AS fecha_inicio,
CONVERT(varchar, pr.FechaFin, 120) AS fecha_fin
FROM pre pr
LEFT JOIN Lot l ON pr.LoteID = l.LoteID
{where_sql}
ORDER BY pr.FechaInicio DESC
"""
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
cursor.execute(sql, tuple(params) if params else None)
rows = cursor.fetchall()
for r in rows:
motivo_val = str(r.get('motivo') or '').strip()
doc_val = motivo_val if (motivo_val.isdigit() or (len(motivo_val) <= 12 and not ' ' in motivo_val)) else ""
r["documento"] = doc_val
return rows
@staticmethod
def consumir_preautorizacion(preautorizado_id: int) -> bool:
"""Elimina o da por consumida la preautorización tras generar el ticket."""
if not preautorizado_id:
return False
with db_session() as conn:
cursor = conn.cursor()
cursor.execute("DELETE FROM pre WHERE PreautorizadoID = %s", (preautorizado_id,))
return True
@staticmethod
def buscar_personas_avanzado(texto: str, limite: int = 50) -> List[Dict[str, Any]]:
"""
Búsqueda avanzada multi-palabra de personas por Apellido, Nombre, Documento, NroSocio o Lote.
Idéntico a DialogoBuscarPersona (pct_dialogs.py).
"""
palabras = [w.strip() for w in texto.split() if w.strip()] if texto else []
where_clauses = []
params = []
for p in palabras:
like_str = f"%{p}%"
where_clauses.append("""
(p.Apellido LIKE %s OR p.Nombre LIKE %s OR EXISTS (
SELECT 1 FROM PerDocCatVal d WHERE d.PersonaID = p.PersonaID AND d.Documento LIKE %s
) OR CAST(p.NroSocio AS VARCHAR) LIKE %s OR EXISTS (
SELECT 1 FROM lotper lp
INNER JOIN lot l ON lp.LoteID = l.LoteID
WHERE lp.PersonaID = p.PersonaID AND (l.Lote LIKE %s OR CAST(lp.LoteID AS VARCHAR) LIKE %s)
))
""")
params.extend([like_str, like_str, like_str, like_str, like_str, like_str])
where_sql = ("WHERE " + " AND ".join(where_clauses)) if where_clauses else ""
sql = f"""
SELECT TOP {int(limite)}
p.PersonaID,
p.Apellido,
p.Nombre,
p.NroSocio,
COALESCE(p.Blacklist, 0) AS Blacklist,
(SELECT TOP 1 d.Documento FROM PerDocCatVal d WHERE d.PersonaID = p.PersonaID ORDER BY d.DocumentoID) AS Documento
FROM Per p
{where_sql}
ORDER BY p.Apellido, p.Nombre
"""
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
cursor.execute(sql, tuple(params) if params else None)
return cursor.fetchall()
@staticmethod
def buscar_vehiculos_coincidencias(termino: str, es_salida: bool = False, limite: int = 50) -> List[Dict[str, Any]]:
"""
Búsqueda predictiva y parcial de vehículos (LIKE %...%) por patente, marca, modelo, o titular.
En Salida: busca vehículos con tickets activos dentro del predio.
En Entrada: busca en el maestro de vehículos (Aut) con sus conductores/titulares vinculados.
Paridad exacta con pct_repository.py:buscar_vehiculos_coincidencias.
"""
t_clean = re.sub(r'[\s\-]', '', str(termino or "")).upper()
patron_like = f"%{t_clean}%" if t_clean else "%"
patron_text = f"%{str(termino or '').strip().upper()}%" if termino else "%"
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
if es_salida:
sql = f"""
SELECT TOP ({limite})
t.TicketID AS ticket_id,
px.Valor AS patente,
ISNULL(a.Marca, '') AS marca,
ISNULL(a.Modelo, '') AS modelo,
p.PersonaID AS persona_id,
ISNULL(p.Apellido, '') AS apellido,
ISNULL(p.Nombre, '') AS nombre,
ISNULL(d.Documento, '') AS documento,
COALESCE(
(SELECT TOP 1 l.Lote FROM Lot l INNER JOIN tckprx pxl ON CAST(l.LoteID AS VARCHAR) = pxl.Valor WHERE pxl.TicketID = t.TicketID AND pxl.PropiedadID = 7),
(SELECT TOP 1 l.Lote FROM Lot l INNER JOIN tckprx pxl ON l.Lote = px.Valor WHERE pxl.TicketID = t.TicketID AND pxl.PropiedadID = 7),
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = t.TicketID AND PropiedadID = 7),
''
) AS lote,
CONVERT(varchar, t.FechaHoraIngreso, 120) AS fecha_ingreso,
'' AS vigencia_seguro
FROM tck t
INNER JOIN tckprx px ON t.TicketID = px.TicketID AND px.PropiedadID = 4
LEFT JOIN aut a ON REPLACE(REPLACE(UPPER(LTRIM(RTRIM(a.Patente))), ' ', ''), '-', '') = REPLACE(REPLACE(UPPER(LTRIM(RTRIM(px.Valor))), ' ', ''), '-', '')
INNER JOIN tckper tp ON t.TicketID = tp.TicketID AND (tp.RolID = 1 OR tp.RolID IS NULL)
INNER JOIN Per p ON tp.PersonaID = p.PersonaID
LEFT JOIN PerDocCatVal d ON p.PersonaID = d.PersonaID
WHERE (
REPLACE(REPLACE(UPPER(LTRIM(RTRIM(px.Valor))), ' ', ''), '-', '') LIKE %s
OR UPPER(p.Apellido) LIKE %s
OR UPPER(p.Nombre) LIKE %s
OR d.Documento LIKE %s
OR UPPER(a.Marca) LIKE %s
)
ORDER BY t.FechaHoraIngreso DESC
"""
cursor.execute(sql, (patron_like, patron_text, patron_text, patron_like, patron_text))
else:
sql = f"""
SELECT TOP ({limite})
0 AS ticket_id,
UPPER(LTRIM(RTRIM(a.Patente))) AS patente,
ISNULL(a.Marca, '') AS marca,
ISNULL(a.Modelo, '') AS modelo,
p.PersonaID AS persona_id,
ISNULL(p.Apellido, '') AS apellido,
ISNULL(p.Nombre, '') AS nombre,
ISNULL(d.Documento, '') AS documento,
'' AS lote,
'' AS fecha_ingreso,
CONVERT(varchar, a.PolizaVigenciaHasta, 120) AS vigencia_seguro
FROM aut a
LEFT JOIN peraut pa ON a.AutoID = pa.AutoID
LEFT JOIN Per p ON pa.PersonaID = p.PersonaID
LEFT JOIN PerDocCatVal d ON p.PersonaID = d.PersonaID
WHERE (
REPLACE(REPLACE(UPPER(LTRIM(RTRIM(a.Patente))), ' ', ''), '-', '') LIKE %s
OR UPPER(a.Marca) LIKE %s
OR UPPER(a.Modelo) LIKE %s
OR UPPER(p.Apellido) LIKE %s
OR UPPER(p.Nombre) LIKE %s
OR d.Documento LIKE %s
)
ORDER BY a.Patente ASC
"""
cursor.execute(sql, (patron_like, patron_text, patron_text, patron_text, patron_text, patron_like))
return cursor.fetchall()
@staticmethod
def ejecutar_salida_masiva(
ticket_ids: List[int],
usuario_id: int,
operador: str,
modulo_salida_id: int,
motivo: str = "Toque de queda / Cierre de jornada",
observaciones: str = "",
) -> Tuple[bool, str, int]:
"""
Ejecuta la salida masiva de múltiples personas/visitas en una única transacción atómica:
1. Crea el registro maestro en salida_masiva.
2. Registra el desglose en salida_masiva_detalle.
3. Cierra y migra cada ticket activo a tckhst.
4. Registra los snapshots correspondientes en mvthist con flag 'Salida Masiva'.
5. Genera la traza inmutable en auditoria_cambios.
Paridad exacta con pct_repository.py:ejecutar_salida_masiva.
"""
if not ticket_ids:
return False, "No se seleccionaron personas para registrar salida masiva.", 0
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# 1. Registro Maestro en salida_masiva
sql_master = """
INSERT INTO dbo.salida_masiva (
FechaHora, UsuarioID, Operador, CantidadPersonas, ModuloSalidaID, Motivo, Observaciones
) VALUES (%s, %s, %s, %s, %s, %s, %s)
"""
cursor.execute(sql_master, (
ahora, usuario_id or 0, operador or "Operador",
len(ticket_ids), modulo_salida_id or 0,
motivo or "Toque de queda / Cierre de jornada",
observaciones or "Salida masiva procesada desde Puesto de Control"
))
cursor.execute("SELECT SCOPE_IDENTITY() AS ID")
row_id = cursor.fetchone()
salida_masiva_id = int(row_id['ID'] if row_id and row_id.get('ID') else 0)
# 2. Desglose y cierre de cada ticket seleccionado
tickets_cerrados = set()
for tck_id in ticket_ids:
# Obtener datos de la persona vinculada al ticket
sql_p = """
SELECT TOP 1
t.Numero, t.FechaHoraIngreso, t.ModuloIngresoID,
tp.PersonaID, p.Apellido, p.Nombre, tp.RolID,
(SELECT TOP 1 d.Documento FROM PerDocCatVal d WHERE d.PersonaID = tp.PersonaID ORDER BY d.DocumentoID) AS Documento,
(SELECT TOP 1 px.Valor FROM tckprx px WHERE px.TicketID = t.TicketID AND px.PropiedadID = 4) AS Patente,
(SELECT TOP 1 px.Valor FROM tckprx px WHERE px.TicketID = t.TicketID AND px.PropiedadID = 7) AS LoteID,
(SELECT TOP 1 px.Valor FROM tckprx px WHERE px.TicketID = t.TicketID AND px.PropiedadID = 11) AS Entidad
FROM tck t
LEFT JOIN tckper tp ON t.TicketID = tp.TicketID AND (tp.RolID = 1 OR tp.RolID IS NULL)
LEFT JOIN Per p ON tp.PersonaID = p.PersonaID
WHERE t.TicketID = %s
"""
cursor.execute(sql_p, (tck_id,))
p_info = cursor.fetchone() or {}
p_id = int(p_info.get("PersonaID") or 0)
doc = str(p_info.get("Documento") or "")
ape = str(p_info.get("Apellido") or "")
nom = str(p_info.get("Nombre") or "")
lot_id = p_info.get("LoteID")
pat = str(p_info.get("Patente") or "")
ent = str(p_info.get("Entidad") or "SALIDA MASIVA")
rol_id = int(p_info.get("RolID") or 1)
sql_det = """
INSERT INTO dbo.salida_masiva_detalle (
SalidaMasivaID, TicketID, PersonaID, Documento, Apellido, Nombre,
LoteID, NombreLote, Patente, Entidad, RolID
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
"""
cursor.execute(sql_det, (
salida_masiva_id, tck_id, p_id, doc, ape, nom,
int(lot_id) if lot_id and str(lot_id).isdigit() else None,
str(lot_id or ""), pat, ent, rol_id
))
if tck_id and tck_id not in tickets_cerrados:
num_tck = p_info.get("Numero") or 0
f_ing = p_info.get("FechaHoraIngreso")
if isinstance(f_ing, str) == False and f_ing is not None:
f_ing = f_ing.strftime('%Y-%m-%d %H:%M:%S')
mod_ing = p_info.get("ModuloIngresoID") or 0
cursor.execute("SELECT TicketID FROM tckhst WHERE TicketID = %s", (tck_id,))
if cursor.fetchone():
nuevo_tck_id = AccessRepository.generar_ticket_id()
cursor.execute("UPDATE tckper SET TicketID = %s WHERE TicketID = %s", (nuevo_tck_id, tck_id))
cursor.execute("UPDATE tckprx SET TicketID = %s WHERE TicketID = %s", (nuevo_tck_id, tck_id))
cursor.execute("UPDATE tck SET TicketID = %s WHERE TicketID = %s", (nuevo_tck_id, tck_id))
cursor.execute("UPDATE dbo.salida_masiva_detalle SET TicketID = %s WHERE TicketID = %s AND SalidaMasivaID = %s",
(nuevo_tck_id, tck_id, salida_masiva_id))
tck_id = nuevo_tck_id
sql_tckhst = """
INSERT INTO tckhst (TicketID, Numero, FechaHoraIngreso, ModuloIngresoID, FechaHoraSalida, ModuloSalidaID)
VALUES (%s, %s, %s, %s, %s, %s)
"""
cursor.execute(sql_tckhst, (tck_id, num_tck, str(f_ing or ahora), mod_ing, ahora, modulo_salida_id or 0))
cursor.execute("DELETE FROM tck WHERE TicketID = %s", (tck_id,))
tickets_cerrados.add(tck_id)
sql_mvt = """
INSERT INTO mvthist (TicketID, PersonaID, Patente, LoteID, RolID, Entidad, Sentido, ModuloID, FechaHora)
VALUES (%s, %s, %s, %s, %s, %s, 'Salida', %s, %s)
"""
cursor.execute(sql_mvt, (
tck_id, p_id,
(pat.strip() if pat else None),
int(lot_id) if lot_id and str(lot_id).isdigit() else None,
rol_id,
f"SALIDA MASIVA ({ent})" if ent and ent != '-' else "SALIDA MASIVA",
modulo_salida_id or 0,
ahora
))
# 3. Trazabilidad en auditoria_cambios
sql_audit = """
INSERT INTO dbo.auditoria_cambios (
Modulo, Entidad, EntidadID, Operacion, CampoModificado, ValorNuevo, UsuarioID, FechaHora
) VALUES ('PuestoControl', 'SalidaMasiva', %s, 'SALIDA_MASIVA', 'CantidadPersonas', %s, %s, %s)
"""
cursor.execute(sql_audit, (
str(salida_masiva_id),
f"{len(ticket_ids)} personas egresadas ({motivo})",
usuario_id or 0,
ahora
))
return True, f"Se registró la salida masiva de {len(ticket_ids)} persona(s) exitosamente.", salida_masiva_id