# ============================================================================== # 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