feat(puesto-control): paridad total de validaciones, seguro automotor, ART y UX tablet 9-11 pulgadas

This commit is contained in:
Carlos Tello
2026-10-14 08:20:37 -03:00
parent b2568ed873
commit d80a4dba74
9 changed files with 1387 additions and 52 deletions
+314 -1
View File
@@ -108,7 +108,8 @@ class AccessRepository:
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
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...")
@@ -121,6 +122,8 @@ class AccessRepository:
(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()
@@ -176,6 +179,12 @@ class AccessRepository:
(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
@@ -507,3 +516,307 @@ class AccessRepository:
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