# ============================================================================== # Repositorio de Control de Accesos (SQL Server videoman) # ============================================================================== from datetime import datetime from typing import Optional, List, Dict, Any, Tuple from app.core.database import db_session from app.schemas.access_schema import EntryRequest, CompanionDTO class AccessRepository: @staticmethod def generar_ticket_id() -> int: """Genera el TicketID matemático time-based canónico de OnEverAccess.""" fecha_actual = datetime.now() fecha_base = datetime(2007, 6, 1) dias = (fecha_actual.date() - fecha_base.date()).days a = fecha_actual.hour e = fecha_actual.minute i = fecha_actual.second o = int(fecha_actual.microsecond / 1000) return (dias * 100000000) + (a * 3600000) + (e * 60000) + (i * 1000) + o @staticmethod def buscar_persona_por_documento(documento: str) -> Optional[Dict[str, Any]]: """Busca una persona y su documento en las tablas `PerDocCatVal` y `Per`.""" doc_clean = documento.strip() query = """ SELECT TOP 1 p.PersonaID, p.Apellido, p.Nombre, p.Sexo, d.Documento FROM PerDocCatVal d INNER JOIN Per p ON d.PersonaID = p.PersonaID WHERE d.Documento = %s """ with db_session() as conn: cursor = conn.cursor(as_dict=True) cursor.execute(query, (doc_clean,)) return cursor.fetchone() @staticmethod def buscar_o_crear_persona( documento: str, apellido: str = "", nombre: str = "", sexo: str = "M" ) -> int: """Obtiene el PersonaID existente o da de alta una nueva visita en `Per` y `PerDocCatVal`.""" doc_clean = documento.strip() existing = AccessRepository.buscar_persona_por_documento(doc_clean) if existing: pid = existing["PersonaID"] # Si se proveyó apellido o nombre, actualizar si estaban vacíos if apellido or nombre: with db_session() as conn: cursor = conn.cursor() cursor.execute( """ UPDATE Per SET Apellido = UPPER(COALESCE(NULLIF(%s, ''), Apellido)), Nombre = UPPER(COALESCE(NULLIF(%s, ''), Nombre)) WHERE PersonaID = %s """, (apellido.strip() if apellido else "", nombre.strip() if nombre else "", pid), ) return pid # Alta de nueva persona ap_final = (apellido or "VISITA").upper().strip() nom_final = (nombre or "NUEVA").upper().strip() hoy = datetime.now().strftime("%Y-%m-%d") with db_session() as conn: cursor = conn.cursor() cursor.execute("SELECT COALESCE(MAX(PersonaID), 0) + 1 FROM Per") new_pid = cursor.fetchone()[0] sql_per = """ INSERT INTO Per (PersonaID, Apellido, Nombre, Sexo, FechaInicio, FechaFin, FechaNacimiento, CREATEdByID, LastUpdateDateByID) VALUES (%s, %s, %s, %s, %s, '2099-12-31', '1900-01-01', 2, 2) """ cursor.execute(sql_per, (new_pid, ap_final, nom_final, sexo or "M", hoy)) sql_doc = """ INSERT INTO PerDocCatVal (PersonaID, DocumentoID, CategoriaID, ValorID, Documento) VALUES (%s, 100000, 11, 1, %s) """ cursor.execute(sql_doc, (new_pid, doc_clean)) return new_pid @staticmethod def verificar_antipassback(persona_id: int) -> bool: """Retorna True si la persona ya posee un ticket activo en el predio.""" if not persona_id or persona_id <= 0: return False query = """ SELECT TOP 1 t.TicketID FROM tck t INNER JOIN tckper tp ON t.TicketID = tp.TicketID WHERE tp.PersonaID = %s """ with db_session() as conn: cursor = conn.cursor() cursor.execute(query, (persona_id,)) return cursor.fetchone() is not None @staticmethod def registrar_ticket_ingreso( req: EntryRequest, persona_id: int, ticket_id: int ) -> int: """ Registra de manera atómica el ticket en `tck`, `tckprx`, `tckper` y `mvthist`. """ ahora = datetime.now().strftime("%Y-%m-%d %H:%M:%S") rol_id = 1 if req.patente else 2 # 1: Conductor, 2: Peatón entidad_final = req.entidad or ("CONDUCTOR..." if rol_id == 1 else "PEATON...") propiedades: List[Tuple[int, Any]] = [ (4, req.patente or ""), (5, str(req.cantidad_ocupantes)), (9, str(req.cantidad_menores)), (11, entidad_final), (8, req.motivo or "VISITA"), (6, "1" if req.cacheo_salida else "0"), (7, str(req.lote_id or req.lote_codigo or "")), ] with db_session() as conn: cursor = conn.cursor() # 1. Tabla tck cursor.execute( "INSERT INTO tck (TicketID, FechaHoraIngreso, ModuloIngresoID) VALUES (%s, %s, %s)", (ticket_id, ahora, req.modulo_ingreso_id), ) # 2. Tabla tckper (Conductor / Titular) cursor.execute( "INSERT INTO tckper (TicketID, PersonaID, RolID, EsMenor) VALUES (%s, %s, %s, 0)", (ticket_id, persona_id, rol_id), ) # 3. Propiedades dinámicas en tckprx for prop_id, val in propiedades: if val: cursor.execute( "INSERT INTO tckprx (TicketID, PropiedadID, Valor) VALUES (%s, %s, %s)", (ticket_id, prop_id, str(val)), ) # 4. Snapshot histórico en mvthist try: cursor.execute( """ INSERT INTO mvthist (TicketID, PersonaID, Patente, LoteID, RolID, Entidad, Sentido, ModuloID, FechaHora) VALUES (%s, %s, %s, %s, %s, %s, 'Ingreso', %s, %s) """, ( ticket_id, persona_id, req.patente or None, req.lote_id or None, rol_id, entidad_final, req.modulo_ingreso_id, ahora, ), ) except Exception: pass # 5. Integrantes acompañantes for comp in req.integrantes: comp_pid = AccessRepository.buscar_o_crear_persona( comp.documento, comp.apellido or "", comp.nombre or "", comp.sexo or "M" ) cursor.execute( "INSERT INTO tckper (TicketID, PersonaID, RolID, EsMenor) VALUES (%s, %s, %s, %s)", (ticket_id, comp_pid, comp.rol_id, 1 if comp.es_menor else 0), ) return ticket_id @staticmethod def 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 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 ORDER BY t.FechaHoraIngreso DESC """ 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_lotes_predictivo(term: str) -> List[Dict[str, Any]]: """Búsqueda predictiva de lotes por código.""" patron = f"%{term.strip()}%" query = """ SELECT TOP 15 l.LoteID, l.Lote AS Codigo FROM lot l WHERE l.Lote LIKE %s ORDER BY l.Lote """ with db_session() as conn: cursor = conn.cursor(as_dict=True) cursor.execute(query, (patron,)) return cursor.fetchall()