950 lines
43 KiB
Python
950 lines
43 KiB
Python
# ==============================================================================
|
|
# 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
|
|
|