Files

1273 lines
59 KiB
Python

# ==============================================================================
# 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
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(max_id), 0) + 1 FROM (
SELECT MAX(PersonaID) AS max_id FROM Per
UNION
SELECT MAX(PersonaID) AS max_id FROM PerDocCatVal
) AS t
""")
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")
es_conductor = req.tipo_ingreso.upper() == "CONDUCTOR" or bool(req.patente and req.tipo_ingreso.upper() != "PEATON")
rol_id = 1 if es_conductor 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 "")),
]
if req.observaciones and req.observaciones.strip():
propiedades.append((10, req.observaciones.strip()))
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),
)
# 6. Persistencia de pólizas, patentes y observaciones en tablas relacionales
try:
AccessRepository.guardar_polizas_y_vehiculo(persona_id, req)
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
def obtener_permiso_lote(lote_id: int, persona_id: int = 0) -> Dict[str, Any]:
"""
Verifica restricciones del lote en LotCatVal (Categoría 26) y relación de la persona en LotPer.
Idéntico a pct_repository.py en OnEverAccess de escritorio.
"""
resultado = {
"estado": "Habilitado",
"color": "#155724",
"bg_color": "#d4edda",
"detalle": "Lote Habilitado",
"es_residente": False,
}
try:
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# 1. Chequear estado del lote en LotCatVal (Categoría 26)
sql_lot = """
SELECT c.Nombre AS Categoria
FROM LotCatVal lc
JOIN CatVal c ON lc.CategoriaID = c.CategoriaID AND lc.ValorID = c.ValorID
WHERE lc.LoteID = %s AND lc.CategoriaID = 26
"""
cursor.execute(sql_lot, (lote_id,))
row_cat = cursor.fetchone()
if row_cat and row_cat.get("Categoria"):
cat_nombre = str(row_cat["Categoria"]).strip()
cat_lower = cat_nombre.lower()
if any(k in cat_lower for k in ["moroso", "restringido", "bloqueado", "deuda", "inhabilitado"]):
resultado["estado"] = "Restringido"
resultado["color"] = "#721c24"
resultado["bg_color"] = "#f8d7da"
resultado["detalle"] = f"Lote con Restricción ({cat_nombre})"
elif any(k in cat_lower for k in ["obra", "construc"]):
resultado["estado"] = "En Obra"
resultado["color"] = "#856404"
resultado["bg_color"] = "#fff3cd"
resultado["detalle"] = f"Lote en Obra ({cat_nombre})"
else:
resultado["detalle"] = f"Lote {cat_nombre}"
# 2. Si se especificó persona, verificar si es residente o autorizado
if persona_id > 0:
sql_per = """
SELECT lp.FechaInicio, lp.FechaFin, pr.Nombre AS Perfil, c.Nombre AS EstadoRel
FROM LotPer lp
LEFT JOIN Prf pr ON lp.PerfilID = pr.PerfilID
LEFT JOIN CatVal c ON lp.ValorID = c.ValorID AND c.CategoriaID = 18
WHERE lp.LoteID = %s AND lp.PersonaID = %s
"""
cursor.execute(sql_per, (lote_id, persona_id))
row_lp = cursor.fetchone()
if row_lp:
resultado["es_residente"] = True
f_fin = row_lp.get("FechaFin")
ahora = datetime.now()
if f_fin and f_fin < ahora:
resultado["detalle"] += f" · Permiso Vencido ({f_fin.strftime('%d/%m/%Y')})"
resultado["color"] = "#856404"
resultado["bg_color"] = "#fff3cd"
else:
perfil = row_lp.get("Perfil") or "Residente"
resultado["detalle"] += f" · {perfil}"
except Exception as e:
print(f"Error al verificar permiso del lote {lote_id}: {e}")
return resultado
@staticmethod
def obtener_ocupantes_ticket(ticket_id: int) -> List[Dict[str, Any]]:
"""
Retorna la lista de ocupantes (titular + acompañantes) vinculados a un ticket en tckper.
"""
ocupantes = []
try:
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
sql = """
SELECT tp.PersonaID,
COALESCE(p.Apellido, '') AS Apellido,
COALESCE(p.Nombre, '') AS Nombre,
COALESCE(pd.Documento, '') AS Documento,
COALESCE(tp.RolID, 2) AS RolID,
COALESCE(tp.EsMenor, 0) AS EsMenor
FROM tckper tp
LEFT JOIN Per p ON tp.PersonaID = p.PersonaID
LEFT JOIN PerDocCatVal pd ON p.PersonaID = pd.PersonaID AND pd.DocumentoID = 100000
WHERE tp.TicketID = %s
ORDER BY tp.RolID ASC, tp.PersonaID ASC
"""
cursor.execute(sql, (ticket_id,))
rows = cursor.fetchall()
for r in rows:
es_menor = bool(r.get("EsMenor") or r.get("RolID") == 3)
rol_id = int(r.get("RolID") or 2)
rol_nom = "Conductor" if rol_id == 1 else ("Menor de Edad" if es_menor else "Acompañante")
ocupantes.append({
"persona_id": int(r.get("PersonaID") or 0),
"documento": str(r.get("Documento") or ""),
"apellido": str(r.get("Apellido") or "").strip(),
"nombre": str(r.get("Nombre") or "").strip(),
"rol_id": rol_id,
"es_menor": es_menor,
"rol_nombre": rol_nom,
})
except Exception as e:
print(f"Error al obtener ocupantes de ticket {ticket_id}: {e}")
return ocupantes
@staticmethod
def desacoplar_acompanantes_a_peaton(ticket_id: int, personas_ids: List[int], modulo_id: int) -> bool:
"""
Desacopla acompañantes que permanecen en el predio a tickets peatonales individuales.
"""
if not personas_ids:
return True
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
try:
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# Obtener lote y entidad del ticket padre
cursor.execute("SELECT PropiedadID, Valor FROM tckprx WHERE TicketID = %s", (ticket_id,))
prx_rows = cursor.fetchall()
lote_val = None
entidad_val = None
for prx in prx_rows:
if prx.get("PropiedadID") == 7:
lote_val = prx.get("Valor")
elif prx.get("PropiedadID") == 11:
entidad_val = prx.get("Valor")
for pid in personas_ids:
# Desasociar del ticket del vehículo
cursor.execute("DELETE FROM tckper WHERE TicketID = %s AND PersonaID = %s", (ticket_id, pid))
# Generar ticket peatonal individual
cursor.execute("SELECT COALESCE(MAX(TicketID), 0) + 1 AS NextTid FROM tck")
nuevo_tid = cursor.fetchone()["NextTid"]
cursor.execute("SELECT COALESCE(MAX(Numero), 0) + 1 AS NextNro FROM tck")
nuevo_nro = cursor.fetchone()["NextNro"]
cursor.execute(
"INSERT INTO tck (TicketID, Numero, FechaHoraIngreso, ModuloIngresoID) VALUES (%s, %s, %s, %s)",
(nuevo_tid, nuevo_nro, ahora, modulo_id or 0),
)
cursor.execute(
"INSERT INTO tckper (TicketID, PersonaID, RolID, EsMenor) VALUES (%s, %s, 2, 0)",
(nuevo_tid, pid),
)
if lote_val:
cursor.execute("INSERT INTO tckprx (TicketID, PropiedadID, Valor) VALUES (%s, 7, %s)", (nuevo_tid, str(lote_val)))
if entidad_val:
cursor.execute("INSERT INTO tckprx (TicketID, PropiedadID, Valor) VALUES (%s, 11, %s)", (nuevo_tid, str(entidad_val)))
return True
except Exception as e:
print(f"Error al desacoplar acompañantes a peatón: {e}")
return False
@staticmethod
def registrar_ticket_salida(
ticket_id: int,
modulo_salida_id: int,
persona_id: int = 0,
patente: str = "",
personas_ids_permanecen: Optional[List[int]] = None,
integrantes_verificados: Optional[List[Any]] = None,
) -> bool:
"""
Cierra un ticket activo moviéndolo a `tckhst`, registrando el egreso en `mvthist`
para todos los que salen, desacoplando acompañantes que permanecen, y liberando el ticket de `tck`.
"""
ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# 1. Desacoplar acompañantes que permanecen
if personas_ids_permanecen:
AccessRepository.desacoplar_acompanantes_a_peaton(ticket_id, personas_ids_permanecen, modulo_salida_id)
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# Leer datos de ingreso
cursor.execute("SELECT Numero, 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"])
nro_tck = tck_row.get("Numero") or 0
mod_ing = tck_row.get("ModuloIngresoID") or 0
# 2. Insertar en tckhst (histórico de tickets)
cursor.execute(
"""
INSERT INTO tckhst (TicketID, Numero, FechaHoraIngreso, ModuloIngresoID, FechaHoraSalida, ModuloSalidaID)
VALUES (%s, %s, %s, %s, %s, %s)
""",
(ticket_id, nro_tck, f_ing, mod_ing, ahora, modulo_salida_id),
)
# 3. Registrar en mvthist para todos los que egresan con este ticket
try:
# Ocupantes en tckper para este ticket
cursor.execute("""
SELECT tp.PersonaID, tp.RolID, tp.EsMenor,
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = tp.TicketID AND PropiedadID = 4) AS Patente,
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = tp.TicketID AND PropiedadID = 7) AS LoteID,
(SELECT TOP 1 Valor FROM tckprx WHERE TicketID = tp.TicketID AND PropiedadID = 11) AS Entidad
FROM tckper tp
WHERE tp.TicketID = %s
""", (ticket_id,))
ocupantes_salida = cursor.fetchall()
for oc in ocupantes_salida:
oc_pid = oc.get("PersonaID")
oc_pat = patente or oc.get("Patente") or None
oc_lote = oc.get("LoteID") or None
oc_rol = oc.get("RolID") or 1
oc_ent = oc.get("Entidad") or "EGRESO..."
cursor.execute(
"""
INSERT INTO mvthist (TicketID, PersonaID, Patente, LoteID, RolID, Entidad, Sentido, ModuloID, FechaHora)
VALUES (%s, %s, %s, %s, %s, %s, 'Salida', %s, %s)
""",
(ticket_id, oc_pid, oc_pat, oc_lote, oc_rol, oc_ent, modulo_salida_id, ahora),
)
except Exception as e:
print(f"Aviso registrando mvthist salida: {e}")
# 4. Eliminar de tck (manteniendo tckper y tckprx para coherencia histórica con tckhst)
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,
COALESCE(m.Nombre, 'MODULO_ING') AS ModuloIngreso,
COALESCE(p.PersonaID, 0) AS PersonaID,
COALESCE(p.Apellido, 'VISITANTE') AS Apellido,
COALESCE(p.Nombre, '') AS Nombre,
COALESCE(d.Documento, '') AS Documento,
pat.Valor AS Patente,
lot.Valor AS LoteCodigo,
COALESCE(cch.Valor, '0') AS CacheoSalida,
(SELECT COUNT(*) FROM tckper WHERE TicketID = t.TicketID) AS CantidadOcupantes
FROM tck t
LEFT JOIN mdl m ON t.ModuloIngresoID = m.ModuloID
LEFT JOIN tckper tp ON t.TicketID = tp.TicketID
LEFT 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
LEFT JOIN tckprx cch ON t.TicketID = cch.TicketID AND cch.PropiedadID = 6
ORDER BY t.FechaHoraIngreso DESC, tp.RolID ASC
"""
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
cursor.execute(query)
# Desduplicar por TicketID si hay múltiples ocupantes en el mismo ticket
rows = cursor.fetchall()
seen = set()
unique_tickets = []
for r in rows:
tid = r["TicketID"]
if tid not in seen:
seen.add(tid)
unique_tickets.append(r)
return unique_tickets
@staticmethod
def listar_ultimos_movimientos(limite: int = 50) -> List[Dict[str, Any]]:
"""Retorna los últimos movimientos registrados en mvthist desde SQL Server."""
query = """
SELECT TOP (%s)
m.MvtHistID,
m.TicketID,
m.PersonaID,
p.Apellido,
p.Nombre,
d.Documento,
m.Patente,
m.Sentido,
m.Entidad,
m.FechaHora,
md.Nombre AS ModuloNombre
FROM mvthist m
LEFT JOIN Per p ON m.PersonaID = p.PersonaID
LEFT JOIN PerDocCatVal d ON p.PersonaID = d.PersonaID
LEFT JOIN mdl md ON m.ModuloID = md.ModuloID
ORDER BY m.FechaHora DESC, m.MvtHistID DESC
"""
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
cursor.execute(query, (limite,))
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_lote_por_codigo(codigo: str) -> Optional[Dict[str, Any]]:
"""Busca un lote por coincidencia exacta o normalizada de código/número o LoteID."""
query = """
SELECT TOP 1 l.LoteID, l.Lote AS Codigo
FROM lot l
WHERE UPPER(LTRIM(RTRIM(l.Lote))) = UPPER(%s)
OR (ISNUMERIC(%s) = 1 AND l.LoteID = CAST(%s AS INT))
"""
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
cod_clean = codigo.strip()
cursor.execute(query, (cod_clean, cod_clean, cod_clean))
return cursor.fetchone()
@staticmethod
def buscar_lotes_predictivo(term: str) -> List[Dict[str, Any]]:
"""
Búsqueda completa de lotes por número, UF, calle o residentes asociados.
Padrón enriquecido y ponderado idéntico a DialogoBuscarLote (pct_dialogs.py).
"""
f_clean = term.strip() if term else ""
if not f_clean:
query = """
SELECT TOP 50
l.LoteID,
l.Lote AS Codigo,
l.UF,
l.Calle,
l.Numero,
COALESCE(
(SELECT TOP 1 cv.Nombre FROM LotCatVal lcv JOIN CatVal cv ON lcv.ValorID = cv.ValorID AND cv.CategoriaID = 26 WHERE lcv.LoteID = l.LoteID),
'Habilitado'
) AS Estado,
(
SELECT TOP 1 CONCAT(p.Apellido, ', ', p.Nombre)
FROM LotPer lp
JOIN Per p ON lp.PersonaID = p.PersonaID
WHERE lp.LoteID = l.LoteID
ORDER BY lp.PerfilID
) AS Propietario
FROM lot l
ORDER BY
CASE WHEN ISNUMERIC(l.Lote) = 1 THEN 1 ELSE 2 END,
CASE WHEN ISNUMERIC(l.Lote) = 1 THEN CAST(l.Lote AS INT) ELSE 0 END,
l.Lote
"""
params = ()
else:
f_exact = f_clean
f_start = f"{f_clean}%"
f_contains = f"%{f_clean}%"
query = """
SELECT TOP 50
l.LoteID,
l.Lote AS Codigo,
l.UF,
l.Calle,
l.Numero,
COALESCE(
(SELECT TOP 1 cv.Nombre FROM LotCatVal lcv JOIN CatVal cv ON lcv.ValorID = cv.ValorID AND cv.CategoriaID = 26 WHERE lcv.LoteID = l.LoteID),
'Habilitado'
) AS Estado,
(
SELECT TOP 1 CONCAT(p.Apellido, ', ', p.Nombre)
FROM LotPer lp
JOIN Per p ON lp.PersonaID = p.PersonaID
WHERE lp.LoteID = l.LoteID
ORDER BY lp.PerfilID
) AS Propietario
FROM lot l
WHERE l.Lote LIKE %s OR l.Calle LIKE %s OR l.UF LIKE %s
OR EXISTS (
SELECT 1 FROM LotPer lp
JOIN Per p ON lp.PersonaID = p.PersonaID
WHERE lp.LoteID = l.LoteID
AND (p.Nombre LIKE %s OR p.Apellido LIKE %s)
)
ORDER BY
CASE
WHEN UPPER(LTRIM(RTRIM(l.Lote))) = UPPER(%s) THEN 1
WHEN UPPER(LTRIM(RTRIM(l.UF))) = UPPER(%s) THEN 2
WHEN UPPER(l.Lote) LIKE UPPER(%s) THEN 3
WHEN UPPER(l.UF) LIKE UPPER(%s) THEN 4
WHEN UPPER(l.Lote) LIKE UPPER(%s) THEN 5
WHEN UPPER(l.Calle) LIKE UPPER(%s) THEN 6
ELSE 7
END,
CASE WHEN ISNUMERIC(l.Lote) = 1 THEN 1 ELSE 2 END,
CASE WHEN ISNUMERIC(l.Lote) = 1 THEN CAST(l.Lote AS INT) ELSE 0 END,
l.Lote
"""
params = (
f_contains, f_contains, f_contains, f_contains, f_contains,
f_exact, f_exact, f_start, f_start, f_contains, f_contains
)
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
cursor.execute(query, params)
return cursor.fetchall()
@staticmethod
def obtener_residentes_lote(lote_id: int) -> List[Dict[str, Any]]:
"""
Obtiene el padrón de residentes y teléfonos vinculados a un lote (LotPer JOIN Per).
Paridad exacta con pct_repository.py:1752.
"""
query = """
SELECT TOP 100
p.PersonaID,
p.Apellido,
p.Nombre,
(SELECT TOP 1 pd.Documento FROM PerDocCatVal pd WHERE pd.PersonaID = p.PersonaID) AS Documento,
COALESCE(pr.Nombre, 'Residente') AS Perfil,
COALESCE(c.Nombre, 'Activo') AS Estado,
(
SELECT STRING_AGG(pt.Telefono, ' / ')
FROM PerTelCatVal pt
WHERE pt.PersonaID = p.PersonaID
) AS Telefonos
FROM LotPer lp
JOIN Per p ON lp.PersonaID = p.PersonaID
LEFT JOIN Prf pr ON lp.PerfilID = pr.PerfilID
LEFT JOIN CatVal c ON lp.ValorID = c.ValorID AND c.CategoriaID = 18
WHERE lp.LoteID = %s
ORDER BY p.Apellido, p.Nombre
"""
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
cursor.execute(query, (lote_id,))
return cursor.fetchall()
@staticmethod
def buscar_polizas_y_vehiculos_persona(documento: str) -> Optional[Dict[str, Any]]:
"""
Retorna la ficha de la persona con sus patentes asociadas, seguros y pólizas de perpolreg y Aut.
"""
doc_clean = documento.strip()
per = AccessRepository.buscar_persona_por_documento(doc_clean)
if not per:
return None
pid = per["PersonaID"]
resultado: Dict[str, Any] = {
"persona_id": pid,
"documento": doc_clean,
"apellido": per.get("Apellido", "") or "",
"nombre": per.get("Nombre", "") or "",
"sexo": per.get("Sexo", "M") or "M",
"patente_sugerida": None,
"patentes_asociadas": [],
"seguro_empresa": None,
"seguro_poliza": None,
"seguro_desde": None,
"seguro_hasta": None,
"art_empresa": None,
"art_poliza": None,
"art_desde": None,
"art_hasta": None,
"licencia_nro": None,
"licencia_entidad": None,
"licencia_hasta": None,
"observaciones": None,
}
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
# 1. Patentes asociadas en PerAut + Aut
sql_pats = """
SELECT DISTINCT UPPER(a.Patente) AS Patente, a.Aseguradora, a.PolizaNro,
CONVERT(varchar(10), a.PolizaVigenciaDesde, 120) AS FecDesde,
CONVERT(varchar(10), a.PolizaVigenciaHasta, 120) AS FecHasta
FROM Aut a
INNER JOIN PerAut pa ON a.AutoID = pa.AutoID
WHERE pa.PersonaID = %s AND a.Patente IS NOT NULL AND a.Patente <> ''
ORDER BY UPPER(a.Patente)
"""
cursor.execute(sql_pats, (pid,))
pats_rows = cursor.fetchall()
pats = [r["Patente"] for r in pats_rows if r.get("Patente")]
resultado["patentes_asociadas"] = pats
if pats:
resultado["patente_sugerida"] = pats[0]
first_row = pats_rows[0]
if first_row.get("Aseguradora") or first_row.get("PolizaNro"):
resultado["seguro_empresa"] = first_row.get("Aseguradora")
resultado["seguro_poliza"] = first_row.get("PolizaNro")
resultado["seguro_desde"] = first_row.get("FecDesde")
resultado["seguro_hasta"] = first_row.get("FecHasta")
# 2. Pólizas en perpolreg
sql_pol = """
SELECT NroRC, ExpedidoRC,
CONVERT(varchar(10), FechaFinRC, 120) AS FecFinRC,
EmpresaPS, NroPS,
CONVERT(varchar(10), FechaInicioPS, 120) AS FecIniPS,
CONVERT(varchar(10), FechaFinPS, 120) AS FecFinPS,
EmpresaPA, NroPA,
CONVERT(varchar(10), FechaInicioPA, 120) AS FecIniPA,
CONVERT(varchar(10), FechaFinPA, 120) AS FecFinPA
FROM perpolreg
WHERE PersonaID = %s
"""
cursor.execute(sql_pol, (pid,))
row_pol = cursor.fetchone()
if row_pol:
def _clean_str(v):
if not v or str(v).strip().upper() in ('-', 'SPACE', 'NULL', 'NONE'):
return None
return str(v).strip()
def _clean_date(v):
if not v or str(v).strip() in ('1900-01-01', '01-01-1900', '-'):
return None
return str(v).strip().split()[0]
resultado["licencia_nro"] = _clean_str(row_pol.get("NroRC"))
resultado["licencia_entidad"] = _clean_str(row_pol.get("ExpedidoRC"))
resultado["licencia_hasta"] = _clean_date(row_pol.get("FecFinRC"))
if not resultado["seguro_empresa"]:
resultado["seguro_empresa"] = _clean_str(row_pol.get("EmpresaPS"))
resultado["seguro_poliza"] = _clean_str(row_pol.get("NroPS"))
resultado["seguro_desde"] = _clean_date(row_pol.get("FecIniPS"))
resultado["seguro_hasta"] = _clean_date(row_pol.get("FecFinPS"))
resultado["art_empresa"] = _clean_str(row_pol.get("EmpresaPA"))
resultado["art_poliza"] = _clean_str(row_pol.get("NroPA"))
resultado["art_desde"] = _clean_date(row_pol.get("FecIniPA"))
resultado["art_hasta"] = _clean_date(row_pol.get("FecFinPA"))
# 3. Observaciones en PerPrx (PropiedadID = 1)
sql_obs = "SELECT Valor FROM PerPrx WHERE PersonaID = %s AND PropiedadID = 1"
cursor.execute(sql_obs, (pid,))
row_obs = cursor.fetchone()
if row_obs and row_obs.get("Valor"):
resultado["observaciones"] = row_obs["Valor"]
return resultado
@staticmethod
def buscar_datos_vehiculo(patente: str) -> Optional[Dict[str, Any]]:
"""
Busca datos de seguro y titular asociado a una patente.
"""
import re
pat_clean = re.sub(r'[\s\-]', '', str(patente)).upper()
if not pat_clean:
return None
with db_session() as conn:
cursor = conn.cursor(as_dict=True)
sql = """
SELECT TOP 1
a.AutoID, a.Patente, a.Aseguradora, a.PolizaNro,
CONVERT(varchar(10), a.PolizaVigenciaDesde, 120) AS VigenciaDesde,
CONVERT(varchar(10), a.PolizaVigenciaHasta, 120) AS VigenciaHasta,
p.PersonaID, p.Apellido, p.Nombre,
(SELECT TOP 1 d.Documento FROM PerDocCatVal d WHERE d.PersonaID = p.PersonaID ORDER BY d.DocumentoID) AS Documento
FROM Aut a
LEFT JOIN PerAut pa ON a.AutoID = pa.AutoID
LEFT JOIN Per p ON pa.PersonaID = p.PersonaID
WHERE REPLACE(REPLACE(UPPER(LTRIM(RTRIM(a.Patente))), ' ', ''), '-', '') = %s
ORDER BY p.PersonaID DESC
"""
cursor.execute(sql, (pat_clean,))
row = cursor.fetchone()
if not row:
return None
def _clean_str(v):
if not v or str(v).strip().upper() in ('-', 'SPACE', 'NULL', 'NONE'):
return None
return str(v).strip()
def _clean_date(v):
if not v or str(v).strip() in ('1900-01-01', '01-01-1900', '-'):
return None
return str(v).strip().split()[0]
return {
"patente": row.get("Patente") or pat_clean,
"aseguradora": _clean_str(row.get("Aseguradora")),
"poliza_nro": _clean_str(row.get("PolizaNro")),
"vigencia_desde": _clean_date(row.get("VigenciaDesde")),
"vigencia_hasta": _clean_date(row.get("VigenciaHasta")),
"persona_id": row.get("PersonaID"),
"apellido": row.get("Apellido"),
"nombre": row.get("Nombre"),
"documento": row.get("Documento"),
}
@staticmethod
def guardar_polizas_y_vehiculo(persona_id: int, req: EntryRequest) -> bool:
"""
Persiste coberturas en perpolreg, seguro en Aut (si Conductor) y observaciones en PerPrx.
"""
if persona_id <= 0:
return False
def _iso_date(val: Optional[str]) -> str:
if not val:
return "1900-01-01"
v = str(val).strip().split()[0].replace('/', '-')
if v in ("1900-01-01", "01-01-1900", "-", ""):
return "1900-01-01"
parts = v.split('-')
if len(parts) == 3:
if len(parts[0]) == 4:
return f"{int(parts[0]):04d}-{int(parts[1]):02d}-{int(parts[2]):02d}"
elif len(parts[2]) == 4:
return f"{int(parts[2]):04d}-{int(parts[1]):02d}-{int(parts[0]):02d}"
return "1900-01-01"
def _str_clean(val: Optional[str]) -> str:
if not val:
return "-"
v = str(val).strip()
return v if v else "-"
es_conductor = req.tipo_ingreso.upper() == "CONDUCTOR" or bool(req.patente and req.tipo_ingreso.upper() != "PEATON")
with db_session() as conn:
cursor = conn.cursor()
# 1. Si es Conductor y hay patente, gestionar Aut y PerAut
if es_conductor and req.patente:
pat_upper = req.patente.strip().upper()
cursor.execute("SELECT AutoID FROM Aut WHERE UPPER(Patente) = %s", (pat_upper,))
row_aut = cursor.fetchone()
if row_aut:
auto_id = row_aut[0]
if req.seguro_empresa or req.seguro_poliza or req.seguro_hasta:
cursor.execute("""
UPDATE Aut
SET Aseguradora = COALESCE(NULLIF(%s, '-'), Aseguradora),
PolizaNro = COALESCE(NULLIF(%s, '-'), PolizaNro),
PolizaVigenciaDesde = CASE WHEN %s != '1900-01-01' THEN %s ELSE PolizaVigenciaDesde END,
PolizaVigenciaHasta = CASE WHEN %s != '1900-01-01' THEN %s ELSE PolizaVigenciaHasta END
WHERE AutoID = %s
""", (
_str_clean(req.seguro_empresa),
_str_clean(req.seguro_poliza),
_iso_date(req.seguro_desde), _iso_date(req.seguro_desde),
_iso_date(req.seguro_hasta), _iso_date(req.seguro_hasta),
auto_id
))
else:
cursor.execute("SELECT COALESCE(MAX(AutoID), 0) + 1 FROM Aut")
auto_id = cursor.fetchone()[0]
cursor.execute("""
INSERT INTO Aut (AutoID, Patente, Aseguradora, PolizaNro, PolizaVigenciaDesde, PolizaVigenciaHasta)
VALUES (%s, %s, %s, %s, %s, %s)
""", (
auto_id, pat_upper,
_str_clean(req.seguro_empresa),
_str_clean(req.seguro_poliza),
_iso_date(req.seguro_desde),
_iso_date(req.seguro_hasta),
))
# Vincular en PerAut si no existe
cursor.execute("SELECT 1 FROM PerAut WHERE PersonaID = %s AND AutoID = %s", (persona_id, auto_id))
if not cursor.fetchone():
cursor.execute("INSERT INTO PerAut (PersonaID, AutoID) VALUES (%s, %s)", (persona_id, auto_id))
# 2. Gestionar perpolreg
cursor.execute("SELECT 1 FROM perpolreg WHERE PersonaID = %s", (persona_id,))
existe_pol = cursor.fetchone() is not None
if es_conductor:
rc_ini = _iso_date(req.seguro_desde)
rc_fin = _iso_date(req.licencia_hasta)
rc_nro = _str_clean(req.licencia_nro)
rc_ent = _str_clean(req.licencia_entidad)
ps_ini = _iso_date(req.seguro_desde)
ps_fin = _iso_date(req.seguro_hasta)
ps_nro = _str_clean(req.seguro_poliza)
ps_emp = _str_clean(req.seguro_empresa)
pa_ini = _iso_date(req.art_desde)
pa_fin = _iso_date(req.art_hasta)
pa_nro = _str_clean(req.art_poliza)
pa_emp = _str_clean(req.art_empresa)
if existe_pol:
cursor.execute("""
UPDATE perpolreg SET
FechaInicioRC = %s, FechaFinRC = %s, NroRC = %s, ExpedidoRC = %s,
FechaInicioPS = %s, FechaFinPS = %s, NroPS = %s, EmpresaPS = %s,
FechaInicioPA = %s, FechaFinPA = %s, NroPA = %s, EmpresaPA = %s
WHERE PersonaID = %s
""", (rc_ini, rc_fin, rc_nro, rc_ent, ps_ini, ps_fin, ps_nro, ps_emp, pa_ini, pa_fin, pa_nro, pa_emp, persona_id))
else:
cursor.execute("""
INSERT INTO perpolreg (
PersonaID, FechaInicioRC, FechaFinRC, NroRC, ExpedidoRC,
FechaInicioPS, FechaFinPS, NroPS, EmpresaPS,
FechaInicioPA, FechaFinPA, NroPA, EmpresaPA
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
""", (persona_id, rc_ini, rc_fin, rc_nro, rc_ent, ps_ini, ps_fin, ps_nro, ps_emp, pa_ini, pa_fin, pa_nro, pa_emp))
else:
# Peatón: No sobrescribe ni borra pólizas de auto o licencia existentes
pa_ini = _iso_date(req.art_desde)
pa_fin = _iso_date(req.art_hasta)
pa_nro = _str_clean(req.art_poliza)
pa_emp = _str_clean(req.art_empresa)
if existe_pol:
cursor.execute("""
UPDATE perpolreg SET
FechaInicioPA = %s, FechaFinPA = %s, NroPA = %s, EmpresaPA = %s
WHERE PersonaID = %s
""", (pa_ini, pa_fin, pa_nro, pa_emp, persona_id))
else:
cursor.execute("""
INSERT INTO perpolreg (
PersonaID, FechaInicioRC, FechaFinRC, NroRC, ExpedidoRC,
FechaInicioPS, FechaFinPS, NroPS, EmpresaPS,
FechaInicioPA, FechaFinPA, NroPA, EmpresaPA
) VALUES (%s, '1900-01-01', '1900-01-01', '-', '-', '1900-01-01', '1900-01-01', '-', '-', %s, %s, %s, %s)
""", (persona_id, pa_ini, pa_fin, pa_nro, pa_emp))
# 3. Observaciones en PerPrx (PropiedadID = 1)
if req.observaciones is not None:
obs_val = req.observaciones.strip()
cursor.execute("SELECT 1 FROM PerPrx WHERE PersonaID = %s AND PropiedadID = 1", (persona_id,))
if cursor.fetchone():
cursor.execute("UPDATE PerPrx SET Valor = %s WHERE PersonaID = %s AND PropiedadID = 1", (obs_val, persona_id))
else:
cursor.execute("INSERT INTO PerPrx (PersonaID, PropiedadID, Valor) VALUES (%s, 1, %s)", (persona_id, obs_val))
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