diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..7eb895d --- /dev/null +++ b/.env.example @@ -0,0 +1,18 @@ +# Ejemplo de .env con valores concretos (ilustrativo — reemplazar por los reales) + +# Ruta real en el servidor donde llegan los .zip del DNIT +HOST_DOCUMENTOS_PATH=/var/www/proyecto_desarrollo/botDNIT/Documentos Descargados + +# Ruta donde quedan los CSV de RUC faltantes generados por el bot +HOST_SALIDA_PATH=/home/var/www/proyecto_desarrollo/botDNIT/salida + +# Datos de conexión a la BD EXISTENTE que ya tiene la tabla personas +DB_HOST=111.111.111 +DB_PORT=3306 +DB_NAME=database +DB_USER=user +DB_PASSWORD=password + +# Nombre de tabla/columna donde están las personas ya cargadas +TABLA_PERSONAS=table +COLUMNA_RUC=cedula diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c14122e --- /dev/null +++ b/.gitignore @@ -0,0 +1,30 @@ +# Entorno y credenciales +.env +*.env +!.env.example + +# Entornos virtuales de Python +env/ +venv/ +.venv/ +__pycache__/ +*.pyc + +# Datos descargados y salida generada (no van al repo) +Documentos Descargados/ +salida/ +*.zip +*.txt +!requirements.txt + +# Marcadores del extractor +*.procesado + +# Docker +*.log + +# Editor / SO +.vscode/ +.idea/ +*.swp +.DS_Store \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..a61d233 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,14 @@ +FROM python:3.12-slim + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY app/ . + +# Usuario no root, buena práctica de seguridad +RUN useradd -m botuser +USER botuser + +CMD ["python", "main.py"] \ No newline at end of file diff --git a/app/config.py b/app/config.py new file mode 100644 index 0000000..9c39433 --- /dev/null +++ b/app/config.py @@ -0,0 +1,31 @@ +import os + +# Directorio base donde llegan los .zip descargados por el otro bot +BASE_DIR = os.getenv("BASE_DIR", "/data/Documentos Descargados") + +# Carpeta donde se descomprimen los .zip (por defecto, dentro del mismo BASE_DIR) +EXTRACT_DIR = os.getenv("EXTRACT_DIR", BASE_DIR) + +# Conexión a la base de datos (MySQL). Ajustar si Criterion usa otro motor. +DB_HOST = os.getenv("DB_HOST", "db") +DB_PORT = int(os.getenv("DB_PORT", "3306")) +DB_USER = os.getenv("DB_USER", "botdnit") +DB_PASSWORD = os.getenv("DB_PASSWORD", "botdnit") +DB_NAME = os.getenv("DB_NAME", "botdnit") + +# Marca los .zip ya procesados para no descomprimir de nuevo en cada corrida +MARKER_SUFFIX = ".procesado" + +# Prefijos de RUC que identifican persona jurídica. +# TODO: completar con la lista real (por ahora solo los dos ejemplos dados). +PREFIJOS_PERSONAS_JURIDICAS = ["8000", "801"] + +# 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") + +# Tamaño de cada CSV de salida +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 diff --git a/app/db.py b/app/db.py new file mode 100644 index 0000000..2a575c4 --- /dev/null +++ b/app/db.py @@ -0,0 +1,34 @@ +import logging + +import pymysql + +from config import DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME, TABLA_PERSONAS, COLUMNA_RUC + +logger = logging.getLogger(__name__) + + +def get_connection(): + return pymysql.connect( + host=DB_HOST, + port=DB_PORT, + user=DB_USER, + password=DB_PASSWORD, + database=DB_NAME, + charset="utf8mb4", + autocommit=True, + ) + + +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). + """ + query = f"SELECT {COLUMNA_RUC} FROM {TABLA_PERSONAS}" + existentes = set() + with conn.cursor() as cur: + cur.execute(query) + 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 diff --git a/app/exportador.py b/app/exportador.py new file mode 100644 index 0000000..b4cb077 --- /dev/null +++ b/app/exportador.py @@ -0,0 +1,37 @@ +import csv +import logging +import os + +from config import OUTPUT_DIR, CSV_CHUNK_SIZE + +logger = logging.getLogger(__name__) + +ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado", "archivo_origen"] + + +def exportar_csv(registros, prefijo_nombre="rucs_faltantes"): + """ + Escribe los registros en archivos CSV de hasta CSV_CHUNK_SIZE filas cada uno. + Devuelve la lista de rutas generadas. + """ + os.makedirs(OUTPUT_DIR, exist_ok=True) + + rutas = [] + total = len(registros) + partes = max(1, (total + CSV_CHUNK_SIZE - 1) // CSV_CHUNK_SIZE) + + for i in range(partes): + inicio = i * CSV_CHUNK_SIZE + fin = inicio + CSV_CHUNK_SIZE + bloque = registros[inicio:fin] + + 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.writerows(bloque) + + rutas.append(ruta) + logger.info("CSV generado: %s (%d filas)", ruta, len(bloque)) + + return rutas \ No newline at end of file diff --git a/app/extractor.py b/app/extractor.py new file mode 100644 index 0000000..24f12eb --- /dev/null +++ b/app/extractor.py @@ -0,0 +1,45 @@ +import logging +import os +import zipfile + +from config import BASE_DIR, EXTRACT_DIR, MARKER_SUFFIX + +logger = logging.getLogger(__name__) + + +def descomprimir_todo(): + """ + Recorre BASE_DIR buscando archivos .zip y los descomprime en una carpeta + con el mismo nombre (sin extensión). Usa un archivo .procesado como marca + para no volver a descomprimir en corridas posteriores. + """ + if not os.path.isdir(BASE_DIR): + raise FileNotFoundError(f"No existe el directorio base: {BASE_DIR}") + + extraidos = [] + + for nombre in sorted(os.listdir(BASE_DIR)): + if not nombre.lower().endswith(".zip"): + continue + + ruta_zip = os.path.join(BASE_DIR, nombre) + marker = ruta_zip + MARKER_SUFFIX + + if os.path.exists(marker): + logger.info("Ya procesado, se omite: %s", nombre) + continue + + destino = os.path.join(EXTRACT_DIR, os.path.splitext(nombre)[0]) + os.makedirs(destino, exist_ok=True) + + try: + with zipfile.ZipFile(ruta_zip, "r") as zf: + zf.extractall(destino) + with open(marker, "w") as f: + f.write("ok") + extraidos.append(destino) + logger.info("Descomprimido: %s -> %s", nombre, destino) + except zipfile.BadZipFile: + logger.error("Zip corrupto, se omite: %s", nombre) + + return extraidos \ No newline at end of file diff --git a/app/filtro.py b/app/filtro.py new file mode 100644 index 0000000..d83a32d --- /dev/null +++ b/app/filtro.py @@ -0,0 +1,31 @@ +import logging + +from config import PREFIJOS_PERSONAS_JURIDICAS + +logger = logging.getLogger(__name__) + + +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. + """ + filtrados = [ + r for r in registros + if any(r[0].startswith(prefijo) for prefijo in PREFIJOS_PERSONAS_JURIDICAS) + ] + logger.info( + "Registros jurídicos por prefijo: %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] + 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 diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..f18bcab --- /dev/null +++ b/app/main.py @@ -0,0 +1,45 @@ +import logging + +from extractor import descomprimir_todo +from parser import recorrer_y_parsear +from filtro import filtrar_juridicas, filtrar_no_existentes +from exportador import exportar_csv +from db import get_connection, fetch_rucs_existentes + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] %(message)s", +) +logger = logging.getLogger(__name__) + + +def main(): + logger.info("Iniciando bot RUC DNIT") + + logger.info("Paso 1: descomprimiendo zips nuevos") + carpetas_nuevas = descomprimir_todo() + logger.info("Carpetas descomprimidas en esta corrida: %d", len(carpetas_nuevas)) + + logger.info("Paso 2: recorriendo carpetas y parseando .txt") + registros = recorrer_y_parsear() + + logger.info("Paso 3: filtrando personas jurídicas por prefijo de RUC") + juridicas = filtrar_juridicas(registros) + + logger.info("Paso 4: comparando contra la tabla personas") + conn = get_connection() + try: + rucs_existentes = fetch_rucs_existentes(conn) + finally: + conn.close() + + faltantes = filtrar_no_existentes(juridicas, rucs_existentes) + + logger.info("Paso 5: exportando CSV de RUC faltantes") + rutas = exportar_csv(faltantes) + + logger.info("Bot finalizado. Archivos generados: %s", rutas) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/app/parser.py b/app/parser.py new file mode 100644 index 0000000..303dd81 --- /dev/null +++ b/app/parser.py @@ -0,0 +1,55 @@ +import logging +import os + +from config import BASE_DIR + +logger = logging.getLogger(__name__) + +CAMPOS_ESPERADOS = 5 # ruc, razon_social, dv, codigo, estado + + +def _parsear_linea(linea, archivo_origen): + linea = linea.rstrip("\n").rstrip("\r") + if not linea.strip(): + return None + + partes = linea.split("|") + + # El formato trae un pipe final -> el último elemento queda vacío, se descarta. + # Ojo: el campo "codigo" puede venir vacío legítimamente (doble pipe "||"), + # así que NO se filtran strings vacíos en el medio, solo se saca el último. + if partes and partes[-1] == "": + partes = partes[:-1] + + if len(partes) != CAMPOS_ESPERADOS: + logger.warning("Línea con formato inesperado en %s: %r", archivo_origen, linea) + return None + + ruc, razon_social, dv, codigo, estado = (p.strip() for p in partes) + return (ruc, razon_social, dv, codigo, estado, archivo_origen) + + +def recorrer_y_parsear(directorio_raiz=BASE_DIR): + """ + Recorre recursivamente directorio_raiz, encuentra todos los .txt + y devuelve una lista de tuplas listas para insertar en la base. + """ + registros = [] + + for carpeta_actual, _subcarpetas, archivos in os.walk(directorio_raiz): + for nombre in 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: + for linea in f: + registro = _parsear_linea(linea, nombre) + if registro: + registros.append(registro) + except OSError as e: + logger.error("No se pudo leer %s: %s", ruta_txt, e) + + logger.info("Total de registros parseados: %d", len(registros)) + return registros \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..8d46b27 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,21 @@ +services: + bot: + build: . + environment: + BASE_DIR: /data + OUTPUT_DIR: /data/salida + DB_HOST: ${DB_HOST} + DB_PORT: ${DB_PORT:-3306} + DB_USER: ${DB_USER} + DB_PASSWORD: ${DB_PASSWORD} + DB_NAME: ${DB_NAME} + TABLA_PERSONAS: ${TABLA_PERSONAS:-personas} + COLUMNA_RUC: ${COLUMNA_RUC:-ruc} + volumes: + # Mapea la carpeta real del servidor con los zip/txt del DNIT + - ${HOST_DOCUMENTOS_PATH}:/data + # Carpeta donde quedan los CSV de RUC faltantes + - ${HOST_SALIDA_PATH}:/data/salida + # Corrida única (para disparar por cron del host, ver README). + # network_mode: host si la BD existente corre en el mismo servidor + # y preferís no exponer nada por IP de contenedor. \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..0ccdf79 --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +PyMySQL==1.1.1 \ No newline at end of file