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