Files
OnEverControl/backend/app/repositories/access_repository.py
T

823 lines
37 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(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")
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
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()
@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