Files
bot_dnit/app/filtro.py

130 lines
4.7 KiB
Python
Raw Permalink Normal View History

import logging
import re
from config import PREFIJOS_PERSONAS_JURIDICAS, LONGITUD_RUC_JURIDICA
logger = logging.getLogger(__name__)
_RUC_BASE_RE = re.compile(r"^\d+")
def _normalizar_ruc(ruc):
"""
El campo ruc que trae el DNIT para personas físicas a veces viene con una
letra pegada al final (ej. "1023860A", duplicados/históricos). En la BD
(ver db.fetch_passwords_fisicas) esas mismas personas están cargadas con
el ruc numérico puro ("1023860"), así que hay que aplicar la misma
normalización acá para poder compararlos.
Devuelve None para valores que no arrancan con un dígito.
"""
match = _RUC_BASE_RE.match(ruc)
return match.group() if match else None
def _es_juridica(ruc):
"""
Jurídica solo si el prefijo coincide Y el RUC (sin el dv) tiene la longitud
esperada, ej. "80119080" (8 caracteres). Si el prefijo coincide pero la longitud
no, se considera persona física.
"""
return (
len(ruc) == LONGITUD_RUC_JURIDICA
and any(ruc.startswith(prefijo) for prefijo in PREFIJOS_PERSONAS_JURIDICAS)
)
def filtrar_juridicas(registros):
"""
registros: lista de tuplas (ruc, razon_social, dv, codigo, estado, archivo_origen)
Devuelve solo los que corresponden a persona jurídica según el prefijo y la
longitud del RUC.
"""
filtrados = [r for r in registros if _es_juridica(r[0])]
logger.info(
"Registros jurídicos por prefijo y longitud: %d de %d totales",
len(filtrados), len(registros),
)
return filtrados
def filtrar_no_existentes(registros, rucs_existentes):
"""
Deja solo los registros cuyo "ruc-dv" (tal cual se guarda en personas para las
jurídicas) NO está en la tabla.
"""
faltantes = [r for r in registros if f"{r[0]}-{r[2]}" not in rucs_existentes]
logger.info(
"RUC no encontrados en la BD: %d de %d jurídicos",
len(faltantes), len(registros),
)
return faltantes
def filtrar_fisicas(registros):
"""
registros: lista de tuplas (ruc, razon_social, dv, codigo, estado, archivo_origen)
Devuelve los que NO corresponden a persona jurídica (complemento de filtrar_juridicas).
"""
filtrados = [r for r in registros if not _es_juridica(r[0])]
logger.info(
"Registros físicos (complemento de jurídicos): %d de %d totales",
len(filtrados), len(registros),
)
return filtrados
def clasificar_passwords_fisicas(registros_fisicas, passwords_existentes):
"""
registros_fisicas: lista de tuplas (ruc, razon_social, dv, codigo, estado, archivo_origen).
passwords_existentes: dict {ruc: password_actual} de personas físicas ya cargadas en la BD.
Compara el dv parseado del DNIT contra el password actual en la BD (no escribe nada,
solo clasifica para exportar a CSV y que la carga se haga aparte):
- password ya coincide con el dv -> no se toca.
- persona existe pero el password está vacío -> acción INSERTAR.
- persona existe con un password distinto -> acción ACTUALIZAR.
- el RUC no existe como persona física en la BD -> no se puede insertar una fila nueva
(faltan nombres, apellidos, fecha de nacimiento, etc. que el DNIT no provee),
se descarta y se loguea.
Devuelve (a_generar, no_encontrados):
- a_generar: lista de tuplas (ruc, razon_social, dv, codigo, estado) listas para
exportar a CSV (mismo formato de 5 campos que trae el DNIT).
- no_encontrados: lista de los registros originales cuyo RUC no está en la BD.
"""
a_generar = []
no_encontrados = []
sin_cambios = 0
a_insertar = 0
a_actualizar = 0
for registro in registros_fisicas:
ruc, razon_social, dv, codigo, estado, _archivo_origen = registro
ruc_base = _normalizar_ruc(ruc)
if ruc_base is None or ruc_base not in passwords_existentes:
no_encontrados.append(registro)
continue
password_actual = (passwords_existentes[ruc_base] or "").strip()
if password_actual == dv:
sin_cambios += 1
continue
if password_actual:
a_actualizar += 1
else:
a_insertar += 1
a_generar.append((ruc, razon_social, dv, codigo, estado))
logger.info(
"Personas físicas: %d sin cambios, %d a insertar, %d a actualizar, %d no encontradas en la BD",
sin_cambios, a_insertar, a_actualizar, len(no_encontrados),
)
if no_encontrados:
logger.warning(
"Personas físicas no encontradas en la BD (se omiten, no se generan filas nuevas): %s",
", ".join(r[0] for r in no_encontrados[:20])
+ (f" ... (+{len(no_encontrados) - 20} más)" if len(no_encontrados) > 20 else ""),
)
return a_generar, no_encontrados