diff --git a/app/config.py b/app/config.py index 9c39433..2014a41 100644 --- a/app/config.py +++ b/app/config.py @@ -20,6 +20,11 @@ MARKER_SUFFIX = ".procesado" # TODO: completar con la lista real (por ahora solo los dos ejemplos dados). PREFIJOS_PERSONAS_JURIDICAS = ["8000", "801"] +# Longitud exacta que debe tener el RUC (sin el dv) para considerarse persona jurídica, +# ej. "80119080". Si no cumple, el registro se trata como persona física aunque el +# prefijo coincida. +LONGITUD_RUC_JURIDICA = 8 + # Tabla y columna donde ya están cargadas las personas existentes TABLA_PERSONAS = os.getenv("TABLA_PERSONAS", "personas") COLUMNA_RUC = os.getenv("COLUMNA_RUC", "ruc") @@ -28,4 +33,7 @@ COLUMNA_RUC = os.getenv("COLUMNA_RUC", "ruc") CSV_CHUNK_SIZE = 80000 # Carpeta donde se escriben los CSV con los RUC faltantes -OUTPUT_DIR = os.getenv("OUTPUT_DIR", "/data/salida") \ No newline at end of file +OUTPUT_DIR = os.getenv("OUTPUT_DIR", "/data/salida") + +# Carpeta donde se escribe el .log de cada corrida (por defecto, la misma que OUTPUT_DIR) +LOG_DIR = os.getenv("LOG_DIR", OUTPUT_DIR) \ No newline at end of file diff --git a/app/db.py b/app/db.py index 2a575c4..6d14355 100644 --- a/app/db.py +++ b/app/db.py @@ -1,4 +1,5 @@ import logging +import re import pymysql @@ -6,6 +7,19 @@ from config import DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME, TABLA_PERSON logger = logging.getLogger(__name__) +_RUC_BASE_RE = re.compile(r"^\d+") + + +def _normalizar_ruc(ruc): + """ + Para las personas físicas, el ruc en la BD viene casi siempre como número puro + (sin el dv pegado). Para poder comparar contra el ruc plano que trae el DNIT, + nos quedamos solo con el prefijo numérico inicial. + Devuelve None para filas basura que no arrancan con un dígito. + """ + match = _RUC_BASE_RE.match(str(ruc).strip()) + return match.group() if match else None + def get_connection(): return pymysql.connect( @@ -21,8 +35,9 @@ def get_connection(): def fetch_rucs_existentes(conn): """ - Trae todos los RUC ya cargados en la tabla personas y los devuelve - como set (lookup O(1) para comparar contra los parseados del DNIT). + Trae todos los RUC ya cargados en la tabla personas, tal cual están guardados + (para jurídicas eso es casi siempre "ruc-dv" literal), como set para comparar + contra la clave "ruc-dv" armada con los datos del DNIT. """ query = f"SELECT {COLUMNA_RUC} FROM {TABLA_PERSONAS}" existentes = set() @@ -31,4 +46,21 @@ def fetch_rucs_existentes(conn): for (ruc,) in cur.fetchall(): existentes.add(str(ruc).strip()) logger.info("RUC existentes en %s: %d", TABLA_PERSONAS, len(existentes)) - return existentes \ No newline at end of file + return existentes + + +def fetch_passwords_fisicas(conn): + """ + Trae ruc y password de las personas físicas (tipo_persona = 'F') ya cargadas, + como dict {ruc: password_actual} para comparar contra el dv del DNIT. + """ + query = f"SELECT {COLUMNA_RUC}, password FROM {TABLA_PERSONAS} WHERE tipo_persona = 'F'" + passwords = {} + with conn.cursor() as cur: + cur.execute(query) + for ruc, password in cur.fetchall(): + ruc_base = _normalizar_ruc(ruc) + if ruc_base: + passwords[ruc_base] = password + logger.info("Personas físicas cargadas en %s: %d", TABLA_PERSONAS, len(passwords)) + return passwords \ No newline at end of file diff --git a/app/exportador.py b/app/exportador.py index b4cb077..1b04813 100644 --- a/app/exportador.py +++ b/app/exportador.py @@ -6,10 +6,10 @@ from config import OUTPUT_DIR, CSV_CHUNK_SIZE logger = logging.getLogger(__name__) -ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado", "archivo_origen"] +ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado"] -def exportar_csv(registros, prefijo_nombre="rucs_faltantes"): +def exportar_csv(registros, prefijo_nombre="rucs_faltantes", encabezado=ENCABEZADO): """ Escribe los registros en archivos CSV de hasta CSV_CHUNK_SIZE filas cada uno. Devuelve la lista de rutas generadas. @@ -28,7 +28,7 @@ def exportar_csv(registros, prefijo_nombre="rucs_faltantes"): ruta = os.path.join(OUTPUT_DIR, f"{prefijo_nombre}_part{i + 1}.csv") with open(ruta, "w", newline="", encoding="utf-8") as f: writer = csv.writer(f) - writer.writerow(ENCABEZADO) + writer.writerow(encabezado) writer.writerows(bloque) rutas.append(ruta) diff --git a/app/filtro.py b/app/filtro.py index d83a32d..583ab38 100644 --- a/app/filtro.py +++ b/app/filtro.py @@ -1,31 +1,113 @@ import logging -from config import PREFIJOS_PERSONAS_JURIDICAS +from config import PREFIJOS_PERSONAS_JURIDICAS, LONGITUD_RUC_JURIDICA logger = logging.getLogger(__name__) +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 del RUC. + 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 any(r[0].startswith(prefijo) for prefijo in PREFIJOS_PERSONAS_JURIDICAS) - ] + filtrados = [r for r in registros if _es_juridica(r[0])] logger.info( - "Registros jurídicos por prefijo: %d de %d totales", + "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 NO está en la tabla personas.""" - faltantes = [r for r in registros if r[0] not in 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 \ No newline at end of file + 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 + if ruc not in passwords_existentes: + no_encontrados.append(registro) + continue + + password_actual = (passwords_existentes[ruc] 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 \ No newline at end of file diff --git a/app/main.py b/app/main.py index f18bcab..db8ad58 100644 --- a/app/main.py +++ b/app/main.py @@ -1,14 +1,29 @@ import logging +import os +from datetime import datetime +from config import LOG_DIR from extractor import descomprimir_todo from parser import recorrer_y_parsear -from filtro import filtrar_juridicas, filtrar_no_existentes +from filtro import ( + filtrar_juridicas, + filtrar_no_existentes, + filtrar_fisicas, + clasificar_passwords_fisicas, +) from exportador import exportar_csv -from db import get_connection, fetch_rucs_existentes +from db import get_connection, fetch_rucs_existentes, fetch_passwords_fisicas + +os.makedirs(LOG_DIR, exist_ok=True) +LOG_FILE = os.path.join(LOG_DIR, f"bot_{datetime.now():%Y%m%d_%H%M%S}.log") logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", + handlers=[ + logging.FileHandler(LOG_FILE, encoding="utf-8"), + logging.StreamHandler(), + ], ) logger = logging.getLogger(__name__) @@ -36,9 +51,22 @@ def main(): faltantes = filtrar_no_existentes(juridicas, rucs_existentes) logger.info("Paso 5: exportando CSV de RUC faltantes") - rutas = exportar_csv(faltantes) + rutas = exportar_csv([r[:5] for r in faltantes]) - logger.info("Bot finalizado. Archivos generados: %s", rutas) + logger.info("Paso 6: comparando password de personas físicas contra el dv del DNIT") + fisicas = filtrar_fisicas(registros) + conn = get_connection() + try: + passwords_existentes = fetch_passwords_fisicas(conn) + finally: + conn.close() + + a_generar, _no_encontrados = clasificar_passwords_fisicas(fisicas, passwords_existentes) + + logger.info("Paso 7: exportando CSV de personas físicas a insertar/actualizar password") + rutas_passwords = exportar_csv(a_generar, prefijo_nombre="fisicas_password") + + logger.info("Bot finalizado. Archivos generados: %s", rutas + rutas_passwords) if __name__ == "__main__": diff --git a/app/parser.py b/app/parser.py index 303dd81..0c430f4 100644 --- a/app/parser.py +++ b/app/parser.py @@ -36,19 +36,19 @@ def recorrer_y_parsear(directorio_raiz=BASE_DIR): """ registros = [] - for carpeta_actual, _subcarpetas, archivos in os.walk(directorio_raiz): - for nombre in archivos: + for carpeta_actual, _subcarpetas, archivos in sorted(os.walk(directorio_raiz)): + for nombre in sorted(archivos): if not nombre.lower().endswith(".txt"): continue ruta_txt = os.path.join(carpeta_actual, nombre) try: - with open(ruta_txt, "r", encoding="latin-1") as f: + with open(ruta_txt, "r", encoding="utf-8") as f: for linea in f: registro = _parsear_linea(linea, nombre) if registro: registros.append(registro) - except OSError as e: + except (OSError, UnicodeDecodeError) as e: logger.error("No se pudo leer %s: %s", ruta_txt, e) logger.info("Total de registros parseados: %d", len(registros))