# ============================================================================== # 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(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}") 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