diff --git a/.env.example b/.env.example index 7eb895d..5df0378 100644 --- a/.env.example +++ b/.env.example @@ -6,6 +6,9 @@ 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 +# Ruta donde queda el log de cada corrida del bot (NO debe ser HOST_SALIDA_PATH) +HOST_LOGS_PATH=/home/var/www/proyecto_desarrollo/botDNIT/logs + # Datos de conexión a la BD EXISTENTE que ya tiene la tabla personas DB_HOST=111.111.111 DB_PORT=3306 diff --git a/README.md b/README.md index e69de29..1ab7a96 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,110 @@ +# Bot DNIT (Bot 2) + +Segundo bot del pipeline DNIT. Bot 1 (n8n, fuera de este repo) descarga los +`.zip` del DNIT al host y registra cada descarga en la tabla de control +`control_descargas_dnit`. Este bot (Bot 2) toma esas filas pendientes, +descomprime y parsea los `.txt`, filtra RUC de personas jurídicas y físicas, +los compara contra la tabla `personas` de la base existente, y exporta CSV +con lo que falta cargar. Un script separado (`sync_dnit.sh`) sincroniza esos +CSV a una carpeta compartida de red para que otro equipo los cargue. + +``` +Bot 1 (n8n) --> control_descargas_dnit --> Bot 2 (este repo, Docker) + | + v + CSV en /mnt/bot_dnit/procesados + | + v + sync_dnit.sh (rsync) + | + v + Carpeta compartida (CIFS, //192.168.0.51/...) +``` + +## Qué genera + +Por cada fila pendiente procesada, `main.py` exporta dos tipos de CSV en +`OUTPUT_DIR`: + +- `rucs_faltantes__*.csv`: personas **jurídicas** (RUC con prefijo de + `PREFIJOS_PERSONAS_JURIDICAS` y longitud `LONGITUD_RUC_JURIDICA`) cuyo + `ruc-dv` no está en la tabla `personas`. +- `fisicas_password__*.csv`: personas **físicas** a insertar (sin + password cargado) o actualizar (password distinto al dv que trae el + DNIT). Las que no existen como persona física en la BD se descartan y + quedan solo logueadas (falta el resto de sus datos para poder insertarlas). + +Si el procesamiento de una fila falla, la corrida se corta ahí (no se +procesan las filas siguientes) y se envía un correo de error; si sale bien +se envía un correo con el resumen y se marca la fila como procesada +(`procesados_filtro = 1`, `estado = 'D'`). + +## Configuración (`.env`) + +Copiar `.env.example` a `.env` y completar: + +| Variable | Uso | +|---|---| +| `HOST_DOCUMENTOS_PATH` | Ruta en el **host** donde Bot 1 deja los `.zip` (la misma que escribe en `directorio_zips`). Se usa para traducir esa ruta a `BASE_DIR` dentro del contenedor. | +| `HOST_SALIDA_PATH` | Ruta en el host donde el bot escribe los CSV generados. **Debe apuntar a lo mismo que `ORIGEN_DNIT`** (ver más abajo) para que `sync_dnit.sh` encuentre lo que generó el bot. | +| `DB_HOST` / `DB_PORT` / `DB_NAME` / `DB_USER` / `DB_PASSWORD` | BD existente con la tabla `personas`. La base de control (`bot_dnit_monitor` / `control_descargas_dnit`) vive en el mismo servidor, con las mismas credenciales. | +| `TABLA_PERSONAS` / `COLUMNA_RUC` | Nombre de tabla/columna de RUC en la BD de personas. | +| `SMTP_*` / `SMTP_FROM` / `SMTP_FROM_NAME` | Envío de correos de error/resumen. | +| `DESTINATARIOS` | Destinatarios del correo, separados por coma sin espacios. | +| `ORIGEN_DNIT` | Carpeta local con los CSV a sincronizar (debe coincidir con `HOST_SALIDA_PATH`). | +| `DESTINO_DNIT` | Punto de montaje local del recurso CIFS remoto. | +| `MIGRADOS_DNIT` | Carpeta local donde se archiva lo ya sincronizado (con timestamp). | +| `CARPETA_COMPARTIDA` | Ruta UNC del recurso compartido (`//servidor/share/carpeta`). | +| `USER_COMPARTIDA` / `PASS_COMPARTIDA` | Credenciales del recurso compartido. | +| `LOG_DNIT` | Archivo de log de `sync_dnit.sh`. | + +Cualquier valor con espacios (rutas, usuario) debe ir entre comillas: el +`.env` lo cargan tanto Docker/`python-dotenv` como scripts bash con +`source`, y bash rompe en variables sin comillas si tienen espacios. + +## Correr manualmente + +```bash +docker compose up --build +``` + +Es una corrida única: el contenedor procesa todas las filas pendientes y +termina. `docker-compose.yml` monta `HOST_DOCUMENTOS_PATH` en `/data` y +`HOST_SALIDA_PATH` en `/data/salida`. + +## Sincronización a la carpeta compartida (`sync_dnit.sh`) + +1. Verifica si `DESTINO_DNIT` ya está montado (`mountpoint -q`); si no, + monta el recurso CIFS con `sudo mount -t cifs`. +2. Si `ORIGEN_DNIT` tiene contenido, lo sincroniza con `rsync -av` al + recurso remoto montado. +3. Mueve lo sincronizado de `ORIGEN_DNIT` a `MIGRADOS_DNIT//` + (archivo local de lo ya enviado). + +Se puede correr suelto (`bash sync_dnit.sh`) o encadenado desde `run.sh`. + +**Pendiente / limitación conocida:** el `sudo mount` pide contraseña +interactiva. Si el recurso ya está montado (no sobrevivió un reinicio del +servidor), `sync_dnit.sh` no puede montarlo solo desde cron. Hasta que se +resuelva (fstab + archivo de credenciales, o una regla `sudoers` acotada), +hay que montarlo a mano después de cada reinicio del servidor. + +## Corrida automática diaria (`run.sh` + cron) + +`run.sh` levanta el contenedor, espera a que termine y, si salió bien, +dispara `sync_dnit.sh`. Loguea todo en `/mnt/bot_dnit/logs/run_dnit.log` +(configurable con `RUN_LOG`). + +Para correrlo todos los días a las 7:30 AM, agregar al crontab del usuario +(`crontab -e`): + +``` +30 7 * * * /home/var/www/proyecto_desarrollo/botDNIT/run.sh >> /mnt/bot_dnit/logs/run_dnit_cron.log 2>&1 +``` + +## Logs + +- `LOG_DIR` (por defecto, el mismo que `OUTPUT_DIR`): un log por corrida del + bot Python (`bot_.log`). +- `LOG_DNIT`: log de `sync_dnit.sh`. +- `/mnt/bot_dnit/logs/run_dnit.log`: log de `run.sh` (orquesta bot + sync). diff --git a/app/config.py b/app/config.py index 2014a41..258a515 100644 --- a/app/config.py +++ b/app/config.py @@ -1,18 +1,38 @@ import os -# Directorio base donde llegan los .zip descargados por el otro bot +# Directorio base donde llegan los .zip descargados por el otro bot. +# El directorio real a procesar en cada corrida ahora viene de la columna +# `directorio_zips` de la tabla de control (ver CONTROL_DB_NAME / CONTROL_TABLA +# más abajo). Este valor queda solo como fallback para correr algún script +# de forma manual/suelta. BASE_DIR = os.getenv("BASE_DIR", "/data/Documentos Descargados") -# Carpeta donde se descomprimen los .zip (por defecto, dentro del mismo BASE_DIR) +# Ya no se usa para elegir dónde descomprimir (cada zip se descomprime dentro +# de su propio directorio_zips); se mantiene solo por compatibilidad. EXTRACT_DIR = os.getenv("EXTRACT_DIR", BASE_DIR) -# Conexión a la base de datos (MySQL). Ajustar si Criterion usa otro motor. +# Bot 1 (n8n) corre directo en el host y escribe en `directorio_zips` la ruta +# del host (ej. "/home/var/www/proyecto_desarrollo/botDNIT/Documentos Descargados"). +# Este bot corre dentro de Docker, donde esa misma carpeta está montada en +# BASE_DIR (ver docker-compose.yml). Si HOST_DOCUMENTOS_PATH está seteada, +# main.py usa este valor para traducir la ruta del host a la ruta dentro del +# contenedor antes de usarla. Si se corre fuera de Docker, se deja vacía y no +# se traduce nada. +HOST_DOCUMENTOS_PATH = os.getenv("HOST_DOCUMENTOS_PATH", "") + +# Conexión a la base de datos de "personas" (MySQL) 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") +# Base y tabla de control donde Bot 1 (n8n) registra cada descarga. +# Usa las mismas credenciales de arriba (DB_HOST/DB_USER/DB_PASSWORD), +# solo cambia la base. +CONTROL_DB_NAME = os.getenv("CONTROL_DB_NAME", "bot_dnit_monitor") +CONTROL_TABLA = os.getenv("CONTROL_TABLA", "control_descargas_dnit") + # Marca los .zip ya procesados para no descomprimir de nuevo en cada corrida MARKER_SUFFIX = ".procesado" @@ -35,5 +55,18 @@ CSV_CHUNK_SIZE = 80000 # Carpeta donde se escriben los CSV con los RUC faltantes 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 +# Carpeta donde se escribe el .log de cada corrida. Debe ser distinta de +# OUTPUT_DIR: OUTPUT_DIR se sincroniza tal cual a la carpeta compartida (ver +# sync_dnit.sh) y ahí no deben terminar logs. +LOG_DIR = os.getenv("LOG_DIR", OUTPUT_DIR) + +# --- Notificación por correo cuando el bot corta la corrida por un error --- +SMTP_HOST = os.getenv("SMTP_HOST", "") +SMTP_PORT = int(os.getenv("SMTP_PORT", "587")) +SMTP_USER = os.getenv("SMTP_USER", "") +SMTP_PASSWORD = os.getenv("SMTP_PASSWORD", "") +SMTP_USE_TLS = os.getenv("SMTP_USE_TLS", "true").lower() == "true" +EMAIL_FROM = os.getenv("EMAIL_FROM", SMTP_USER) +SMTP_FROM_NAME = os.getenv("SMTP_FROM_NAME", "CRITERION S.A.") +# Lista de destinatarios separados por coma, ej: "jazmin@criterion.com.py,otro@x.com" +EMAIL_TO = os.getenv("EMAIL_TO", "") diff --git a/app/db.py b/app/db.py index 6d14355..8b78908 100644 --- a/app/db.py +++ b/app/db.py @@ -3,7 +3,10 @@ import re import pymysql -from config import DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME, TABLA_PERSONAS, COLUMNA_RUC +from config import ( + DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME, TABLA_PERSONAS, COLUMNA_RUC, + CONTROL_DB_NAME, CONTROL_TABLA, +) logger = logging.getLogger(__name__) @@ -33,6 +36,50 @@ def get_connection(): ) +def get_connection_control(): + """ + Conexión a la base de control (bot_dnit_monitor) donde Bot 1 (n8n) registra + cada descarga en CONTROL_TABLA. Usa las mismas credenciales que + get_connection(), solo cambia la base. + """ + return pymysql.connect( + host=DB_HOST, + port=DB_PORT, + user=DB_USER, + password=DB_PASSWORD, + database=CONTROL_DB_NAME, + charset="utf8mb4", + autocommit=True, + ) + + +def fetch_pendientes(conn): + """ + Trae las filas de CONTROL_TABLA que todavía no procesó este bot: + procesados_filtro = 0 y estado = 'P'. + Devuelve una lista de tuplas (id, directorio_zips). + """ + query = f"SELECT id, directorio_zips FROM {CONTROL_TABLA} WHERE procesados_filtro = 0 AND estado = 'P'" + pendientes = [] + with conn.cursor() as cur: + cur.execute(query) + for row_id, directorio_zips in cur.fetchall(): + pendientes.append((row_id, directorio_zips)) + logger.info("Filas pendientes en %s: %d", CONTROL_TABLA, len(pendientes)) + return pendientes + + +def marcar_procesado(conn, row_id): + """ + Marca una fila de CONTROL_TABLA como ya procesada por este bot: + procesados_filtro = 1, estado = 'D'. + """ + query = f"UPDATE {CONTROL_TABLA} SET procesados_filtro = 1, estado = 'D' WHERE id = %s" + with conn.cursor() as cur: + cur.execute(query, (row_id,)) + logger.info("Fila id=%s marcada como procesada (procesados_filtro=1, estado='D')", row_id) + + def fetch_rucs_existentes(conn): """ Trae todos los RUC ya cargados en la tabla personas, tal cual están guardados @@ -63,4 +110,4 @@ def fetch_passwords_fisicas(conn): 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 + return passwords diff --git a/app/exportador.py b/app/exportador.py index 1b04813..9314439 100644 --- a/app/exportador.py +++ b/app/exportador.py @@ -1,6 +1,7 @@ import csv import logging import os +from datetime import datetime from config import OUTPUT_DIR, CSV_CHUNK_SIZE @@ -8,10 +9,24 @@ logger = logging.getLogger(__name__) ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado"] +MESES_ES = [ + "ENERO", "FEBRERO", "MARZO", "ABRIL", "MAYO", "JUNIO", + "JULIO", "AGOSTO", "SEPTIEMBRE", "OCTUBRE", "NOVIEMBRE", "DICIEMBRE", +] + + +def _mes_anio_generacion(): + ahora = datetime.now() + return f"{MESES_ES[ahora.month - 1]}_{ahora.year}" + def exportar_csv(registros, prefijo_nombre="rucs_faltantes", encabezado=ENCABEZADO): """ - Escribe los registros en archivos CSV de hasta CSV_CHUNK_SIZE filas cada uno. + Escribe los registros en archivos CSV de hasta CSV_CHUNK_SIZE filas cada uno, + nombrados "__.csv" según el mes/año en que se + genera (o "...___partN.csv" si hacen falta varios archivos por + volumen). Si ya existe un CSV de este mes con el mismo nombre, se + sobrescribe: no acumula filas de corridas anteriores del mismo mes. Devuelve la lista de rutas generadas. """ os.makedirs(OUTPUT_DIR, exist_ok=True) @@ -19,13 +34,15 @@ def exportar_csv(registros, prefijo_nombre="rucs_faltantes", encabezado=ENCABEZA rutas = [] total = len(registros) partes = max(1, (total + CSV_CHUNK_SIZE - 1) // CSV_CHUNK_SIZE) + mes_anio = _mes_anio_generacion() 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") + sufijo_parte = f"_part{i + 1}" if partes > 1 else "" + ruta = os.path.join(OUTPUT_DIR, f"{prefijo_nombre}_{mes_anio}{sufijo_parte}.csv") with open(ruta, "w", newline="", encoding="utf-8") as f: writer = csv.writer(f) writer.writerow(encabezado) diff --git a/app/extractor.py b/app/extractor.py index 24f12eb..b3b039a 100644 --- a/app/extractor.py +++ b/app/extractor.py @@ -2,34 +2,39 @@ import logging import os import zipfile -from config import BASE_DIR, EXTRACT_DIR, MARKER_SUFFIX +from config import BASE_DIR, MARKER_SUFFIX logger = logging.getLogger(__name__) -def descomprimir_todo(): +def descomprimir_todo(base_dir=BASE_DIR): """ - 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. + Recorre base_dir buscando archivos .zip y los descomprime en una carpeta + con el mismo nombre (sin extensión), dentro del mismo base_dir. Usa un + archivo .procesado como marca para no volver a descomprimir en corridas + posteriores. + + base_dir: ahora normalmente es el valor de `directorio_zips` de la fila + de control_descargas_dnit que se está procesando (ver main.py). Si no se + pasa nada, usa BASE_DIR de config.py como fallback. """ - if not os.path.isdir(BASE_DIR): - raise FileNotFoundError(f"No existe el directorio base: {BASE_DIR}") + 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)): + for nombre in sorted(os.listdir(base_dir)): if not nombre.lower().endswith(".zip"): continue - ruta_zip = os.path.join(BASE_DIR, nombre) + 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]) + destino = os.path.join(base_dir, os.path.splitext(nombre)[0]) os.makedirs(destino, exist_ok=True) try: @@ -42,4 +47,4 @@ def descomprimir_todo(): except zipfile.BadZipFile: logger.error("Zip corrupto, se omite: %s", nombre) - return extraidos \ No newline at end of file + return extraidos diff --git a/app/filtro.py b/app/filtro.py index 583ab38..312a97d 100644 --- a/app/filtro.py +++ b/app/filtro.py @@ -1,9 +1,25 @@ 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): """ @@ -84,11 +100,12 @@ def clasificar_passwords_fisicas(registros_fisicas, passwords_existentes): for registro in registros_fisicas: ruc, razon_social, dv, codigo, estado, _archivo_origen = registro - if ruc not in passwords_existentes: + 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] or "").strip() + password_actual = (passwords_existentes[ruc_base] or "").strip() if password_actual == dv: sin_cambios += 1 continue diff --git a/app/main.py b/app/main.py index db8ad58..273275e 100644 --- a/app/main.py +++ b/app/main.py @@ -1,8 +1,9 @@ import logging import os +import traceback from datetime import datetime -from config import LOG_DIR +from config import LOG_DIR, BASE_DIR, HOST_DOCUMENTOS_PATH from extractor import descomprimir_todo from parser import recorrer_y_parsear from filtro import ( @@ -12,7 +13,15 @@ from filtro import ( clasificar_passwords_fisicas, ) from exportador import exportar_csv -from db import get_connection, fetch_rucs_existentes, fetch_passwords_fisicas +from db import ( + get_connection, + get_connection_control, + fetch_rucs_existentes, + fetch_passwords_fisicas, + fetch_pendientes, + marcar_procesado, +) +from notificaciones import enviar_correo_error, enviar_correo_resultado 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") @@ -28,15 +37,41 @@ logging.basicConfig( logger = logging.getLogger(__name__) -def main(): - logger.info("Iniciando bot RUC DNIT") +def _mapear_a_ruta_local(directorio_zips): + """ + directorio_zips viene de control_descargas_dnit tal cual lo escribe Bot 1, + que corre en el host (ej. HOST_DOCUMENTOS_PATH="/home/.../Documentos + Descargados"). Este bot corre en Docker, donde esa misma carpeta está + montada en BASE_DIR (ver docker-compose.yml, target: /data), así que la + ruta del host no existe dentro del contenedor tal cual. + Si HOST_DOCUMENTOS_PATH coincide con el prefijo de directorio_zips, lo + reemplazamos por BASE_DIR. Si no hay match (o no está seteada, ej. corridas + fuera de Docker), se devuelve directorio_zips sin cambios. + """ + if not HOST_DOCUMENTOS_PATH or not directorio_zips.startswith(HOST_DOCUMENTOS_PATH): + return directorio_zips + + resto = directorio_zips[len(HOST_DOCUMENTOS_PATH):].lstrip("/\\") + ruta_local = os.path.join(BASE_DIR, resto) if resto else BASE_DIR + logger.info("directorio_zips traducido de host a contenedor: %s -> %s", directorio_zips, ruta_local) + return ruta_local + + +def procesar_fila(row_id, directorio_zips): + """ + Corre el pipeline completo (descomprimir -> parsear -> filtrar -> + comparar contra la BD -> exportar CSV) para el directorio_zips de una + fila pendiente de control_descargas_dnit. + """ + directorio_zips = _mapear_a_ruta_local(directorio_zips) + logger.info("=== Procesando fila id=%s, directorio_zips=%s ===", row_id, directorio_zips) logger.info("Paso 1: descomprimiendo zips nuevos") - carpetas_nuevas = descomprimir_todo() + carpetas_nuevas = descomprimir_todo(directorio_zips) logger.info("Carpetas descomprimidas en esta corrida: %d", len(carpetas_nuevas)) logger.info("Paso 2: recorriendo carpetas y parseando .txt") - registros = recorrer_y_parsear() + registros = recorrer_y_parsear(directorio_zips) logger.info("Paso 3: filtrando personas jurídicas por prefijo de RUC") juridicas = filtrar_juridicas(registros) @@ -51,7 +86,7 @@ def main(): faltantes = filtrar_no_existentes(juridicas, rucs_existentes) logger.info("Paso 5: exportando CSV de RUC faltantes") - rutas = exportar_csv([r[:5] for r in faltantes]) + rutas = exportar_csv([r[:5] for r in faltantes], prefijo_nombre="SET_PERSONAS_JURIDICAS") logger.info("Paso 6: comparando password de personas físicas contra el dv del DNIT") fisicas = filtrar_fisicas(registros) @@ -64,10 +99,68 @@ def main(): 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") + rutas_passwords = exportar_csv(a_generar, prefijo_nombre="SET_UNIPERSONALES") - logger.info("Bot finalizado. Archivos generados: %s", rutas + rutas_passwords) + logger.info("Fila id=%s finalizada. Archivos generados: %s", row_id, rutas + rutas_passwords) + + return { + "carpetas_descomprimidas": len(carpetas_nuevas), + "total_registros": len(registros), + "juridicas_total": len(juridicas), + "rucs_faltantes": len(faltantes), + "rutas_rucs_faltantes": rutas, + "fisicas_total": len(fisicas), + "fisicas_a_generar": len(a_generar), + "fisicas_no_encontradas": len(_no_encontrados), + "rutas_fisicas_password": rutas_passwords, + } + + +def main(): + logger.info("Iniciando bot RUC DNIT") + + logger.info("Buscando filas pendientes en control_descargas_dnit (procesados_filtro=0, estado='P')") + conn_control = get_connection_control() + try: + pendientes = fetch_pendientes(conn_control) + finally: + conn_control.close() + + if not pendientes: + logger.info("No hay filas pendientes. Nada para hacer.") + return + + for row_id, directorio_zips in pendientes: + try: + resumen = procesar_fila(row_id, directorio_zips) + + conn_control = get_connection_control() + try: + marcar_procesado(conn_control, row_id) + finally: + conn_control.close() + + enviar_correo_resultado( + row_id=row_id, + directorio_zips=directorio_zips, + resumen=resumen, + ) + + except Exception as e: + logger.exception( + "Error procesando fila id=%s (directorio_zips=%s). Se corta la corrida.", + row_id, directorio_zips, + ) + enviar_correo_error( + row_id=row_id, + directorio_zips=directorio_zips, + error=e, + traceback_texto=traceback.format_exc(), + ) + return + + logger.info("Bot finalizado. Se procesaron %d fila(s) pendiente(s).", len(pendientes)) if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/app/notificaciones.py b/app/notificaciones.py new file mode 100644 index 0000000..73d180a --- /dev/null +++ b/app/notificaciones.py @@ -0,0 +1,268 @@ +import logging +import os +import smtplib +from datetime import datetime +from email import encoders +from email.mime.base import MIMEBase +from email.mime.multipart import MIMEMultipart +from email.mime.text import MIMEText +from email.utils import formatdate + +from config import ( + SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASSWORD, SMTP_USE_TLS, + EMAIL_FROM, EMAIL_TO, SMTP_FROM_NAME, +) + +logger = logging.getLogger(__name__) + +LOGO_URL = "https://www.criterion.com.py/tema/images/Logo_Criterion_V1_enc_az.png" + + +def _escapar_html(texto): + return str(texto).replace("&", "&").replace("<", "<").replace(">", ">") + + +def _construir_html_error(row_id, directorio_zips, error, traceback_texto): + """ + Arma el cuerpo HTML del correo de error con el mismo formato que usan los + avisos de Bot 1 (n8n): logo, título en rojo, tabla de detalle y pie con + la acción requerida. + """ + fecha_hora = datetime.now().strftime("%d/%m/%Y %H:%M:%S") + + return f""" + + + + BOT DNIT | ERROR DE PROCESAMIENTO + + + + + +

+ Bot DNIT: Error en el Procesamiento +

+ +

+El bot RUC DNIT (Bot 2) se detuvo por un error al procesar una fila pendiente de control_descargas_dnit. La corrida quedó cortada y la fila no se marcó como procesada. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
DetalleValor
Fila (id){_escapar_html(row_id)}
directorio_zips{_escapar_html(directorio_zips)}
Error{_escapar_html(error)}
Fecha/Hora{fecha_hora}
Detalle técnico
{_escapar_html(traceback_texto)}
+ Acción requerida: Revisar el log del bot y la fila id={_escapar_html(row_id)} en control_descargas_dnit antes de reintentar. +
+ + +""" + + +MESES_ES = [ + "enero", "febrero", "marzo", "abril", "mayo", "junio", + "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre", +] + + +def _mes_procesado(): + """ + Mes/año de la corrida (no el de los datos del DNIT, que no viene indicado + en directorio_zips ni en la fila de control_descargas_dnit). Nombres de + mes en español a mano para no depender del locale del contenedor. + """ + ahora = datetime.now() + return f"{MESES_ES[ahora.month - 1].capitalize()} {ahora.year}" + + +def _construir_html_resultado(directorio_zips, resumen): + """ + Arma el cuerpo HTML del correo que avisa que una fila terminó de + procesarse sin errores, con el mismo formato que _construir_html_error + pero en verde (éxito) y con el resumen de lo generado. + """ + return f""" + + + + BOT DNIT | PROCESAMIENTO FINALIZADO + + + + + +

+ Bot DNIT: Procesamiento Finalizado +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
DetalleValor
Mes Procesado{_mes_procesado()}
Directorio ZIPS{_escapar_html(directorio_zips)}
Carpetas Descomprimidas{resumen['carpetas_descomprimidas']}
Personas Jurídicas Nuevas{resumen['rucs_faltantes']}
CSV de Personas Jurídicas Nuevas{_escapar_html(", ".join(os.path.basename(r) for r in resumen['rutas_rucs_faltantes']) or "(sin filas)")}
Personas Físicas - Actualizar{resumen['fisicas_a_generar']}
Personas Físicas - No encontradas en la BD{resumen['fisicas_no_encontradas']}
CSV - Personas Físicas{_escapar_html(", ".join(os.path.basename(r) for r in resumen['rutas_fisicas_password']) or "(sin filas)")}
+ + +""" + + +def enviar_mail(destinatarios, texto, asunto, adjunto=None): + """ + Envía un correo HTML por SMTP. Estructura tomada como referencia del + enviar_mail() del bot de Empleos IPS, adaptada a la config de este + proyecto (config.py / .env) y con soporte para puerto 465 (SSL implícito, + caso TurboSMTP) además de 587/25 (STARTTLS). + + destinatarios: lista de direcciones de correo (strings). + texto: cuerpo HTML del correo. + asunto: asunto del correo. + adjunto: ruta local opcional a un archivo para adjuntar. + + Nunca deja que un fallo de correo corte la corrida del bot: devuelve + {"estado": "1"/"0", "msg": "..."} en vez de propagar la excepción. + """ + def _retornar(estado, msg, nivel_log=logging.INFO): + logger.log(nivel_log, msg) + return {"estado": estado, "msg": msg} + + if not SMTP_USER or not SMTP_PASSWORD: + return _retornar("0", "Faltan credenciales SMTP en variables de entorno.", logging.WARNING) + + if not texto: + return _retornar("0", "Se esperaba el cuerpo del correo.", logging.ERROR) + + if not destinatarios: + return _retornar("0", "No se encontraron correos válidos para enviar.", logging.ERROR) + + try: + msg = MIMEMultipart() + msg["From"] = f"{SMTP_FROM_NAME} <{EMAIL_FROM}>" + msg["To"] = ", ".join(destinatarios) + msg["Subject"] = asunto + msg["Date"] = formatdate(localtime=True) + + msg.attach(MIMEText(texto, "html", "utf-8")) + + if adjunto: + if not os.path.exists(adjunto): + return _retornar("0", f"El archivo adjunto no existe: {adjunto}", logging.WARNING) + + with open(adjunto, "rb") as f: + part = MIMEBase("application", "octet-stream") + part.set_payload(f.read()) + encoders.encode_base64(part) + part.add_header( + "Content-Disposition", + f'attachment; filename="{os.path.basename(adjunto)}"', + ) + msg.attach(part) + + # El puerto 465 es SSL implícito (hay que conectar ya cifrado con + # SMTP_SSL); STARTTLS (SMTP_USE_TLS) es para 587/25, donde se conecta + # en plano y se sube a TLS después. Usar SMTP + starttls() contra 465 + # (como TurboSMTP) falla la conexión. + server_cls = smtplib.SMTP_SSL if SMTP_PORT == 465 else smtplib.SMTP + with server_cls(SMTP_HOST, SMTP_PORT, timeout=30) as server: + if SMTP_PORT != 465 and SMTP_USE_TLS: + server.starttls() + server.login(SMTP_USER, SMTP_PASSWORD) + server.sendmail(from_addr=EMAIL_FROM, to_addrs=destinatarios, msg=msg.as_string()) + + s = "s" if len(destinatarios) != 1 else "" + return _retornar( + "1", f"Correo{s} enviado{s} exitosamente a: {', '.join(destinatarios)} | Asunto: {asunto}", + ) + + except Exception as e: + return _retornar("0", f"Error SMTP, no se pudo enviar el correo. Asunto: {asunto} | {e!r}", logging.ERROR) + + +def _destinatarios_configurados(): + return [d.strip() for d in EMAIL_TO.split(",") if d.strip()] + + +def enviar_correo_error(row_id, directorio_zips, error, traceback_texto): + """ + Envía un correo HTML de notificación cuando el bot corta la corrida por + un error. + """ + asunto = f"BOT DNIT - Error procesando" + cuerpo_html = _construir_html_error(row_id, directorio_zips, error, traceback_texto) + enviar_mail(_destinatarios_configurados(), cuerpo_html, asunto) + + +def enviar_correo_resultado(row_id, directorio_zips, resumen): + """ + Envía un correo HTML de notificación cuando una fila terminó de + procesarse sin errores, con el resumen de lo generado. + """ + asunto = f"BOT DNIT - Procesamiento finalizado" + cuerpo_html = _construir_html_resultado(directorio_zips, resumen) + enviar_mail(_destinatarios_configurados(), cuerpo_html, asunto) diff --git a/docker-compose.yml b/docker-compose.yml index 8d46b27..d38989b 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -4,6 +4,13 @@ services: environment: BASE_DIR: /data OUTPUT_DIR: /data/salida + # Carpeta propia para los logs del bot: NO debe ser la misma que + # OUTPUT_DIR, porque OUTPUT_DIR se sincroniza tal cual a la carpeta + # compartida (ver sync_dnit.sh) y ahí no deben terminar logs. + LOG_DIR: /data/logs + # Ruta del host tal cual la escribe Bot 1 (n8n) en directorio_zips; se usa + # para traducirla a BASE_DIR dentro del contenedor (ver main._mapear_a_ruta_local). + HOST_DOCUMENTOS_PATH: ${HOST_DOCUMENTOS_PATH} DB_HOST: ${DB_HOST} DB_PORT: ${DB_PORT:-3306} DB_USER: ${DB_USER} @@ -11,11 +18,20 @@ services: DB_NAME: ${DB_NAME} TABLA_PERSONAS: ${TABLA_PERSONAS:-personas} COLUMNA_RUC: ${COLUMNA_RUC:-ruc} + SMTP_HOST: ${SMTP_HOST} + SMTP_PORT: ${SMTP_PORT:-587} + SMTP_USER: ${SMTP_USER} + SMTP_PASSWORD: ${SMTP_PASSWORD} + SMTP_FROM_NAME: ${SMTP_FROM_NAME} + EMAIL_FROM: ${SMTP_FROM} + EMAIL_TO: ${DESTINATARIOS} 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 + # Carpeta donde quedan los CSV de RUC faltantes (esta es la que sincroniza sync_dnit.sh) - ${HOST_SALIDA_PATH}:/data/salida + # Logs del bot, separados de OUTPUT_DIR para que no se sincronicen a la carpeta compartida + - ${HOST_LOGS_PATH:-/mnt/bot_dnit/logs}:/data/logs # 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/run_dnit.sh b/run_dnit.sh new file mode 100755 index 0000000..25b97cd --- /dev/null +++ b/run_dnit.sh @@ -0,0 +1,52 @@ +#!/bin/bash + +# ========================= +# CONFIGURACIÓN +# ========================= +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +ENV_FILE="$SCRIPT_DIR/.env" +if [ ! -f "$ENV_FILE" ]; then + echo "❌ No se encontró el archivo .env en: $ENV_FILE" + exit 1 +fi + +set -a +source "$ENV_FILE" +set +a + +LOG="${RUN_LOG:-/mnt/bot_dnit/logs/run_dnit.log}" +mkdir -p "$(dirname "$LOG")" + +log() { + echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG" +} + +# ========================= +# INICIO +# ========================= +log "==== INICIO CORRIDA DIARIA BOT DNIT ====" + +# 1. Levantar el contenedor y esperar a que termine (corrida única) +log "Levantando contenedor del bot..." +docker compose up --exit-code-from bot >> "$LOG" 2>&1 +BOT_EXIT=$? +docker compose down >> "$LOG" 2>&1 + +if [ $BOT_EXIT -ne 0 ]; then + log "❌ El bot terminó con error (exit=$BOT_EXIT), no se sincroniza" + exit 1 +fi +log "✔ Bot ejecutado correctamente" + +# 2. Sincronizar lo generado con la carpeta compartida +log "Iniciando sincronización con carpeta compartida..." +if bash "$SCRIPT_DIR/sync_dnit.sh"; then + log "✔ Sincronización completada" +else + log "❌ Error en sync_dnit.sh" + exit 1 +fi + +log "==== FIN CORRIDA DIARIA BOT DNIT ====" diff --git a/sync_dnit.sh b/sync_dnit.sh new file mode 100644 index 0000000..eb37ef6 --- /dev/null +++ b/sync_dnit.sh @@ -0,0 +1,117 @@ +#!/bin/bash + +# ========================= +# CONFIGURACIÓN +# ========================= +# Cargar variables desde .env (mismo directorio que este script) +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +ENV_FILE="$SCRIPT_DIR/.env" + +if [ ! -f "$ENV_FILE" ]; then + echo "❌ No se encontró el archivo .env en: $ENV_FILE" + exit 1 +fi + +# Cargar variables del .env respetando espacios y caracteres especiales +set -a +source "$ENV_FILE" +set +a + +# Mapear a los nombres internos del script +ORIGEN="$ORIGEN_DNIT" +DESTINO="$DESTINO_DNIT" +MIGRADOS="$MIGRADOS_DNIT" +REMOTE="$CARPETA_COMPARTIDA" +USER="$USER_COMPARTIDA" +PASS="$PASS_COMPARTIDA" +LOG="$LOG_DNIT" + +# Validar variables críticas +for var in ORIGEN DESTINO MIGRADOS REMOTE USER PASS LOG; do + if [ -z "${!var}" ]; then + echo "❌ Variable $var no está definida en el .env" + exit 1 + fi +done + +# existe el directorio de logs? +mkdir -p "$(dirname "$LOG")" + +# ========================= +# FUNCIONES +# ========================= +MESES_ES=(ENERO FEBRERO MARZO ABRIL MAYO JUNIO JULIO AGOSTO SEPTIEMBRE OCTUBRE NOVIEMBRE DICIEMBRE) + +carpeta_mes_actual() { + local mes_idx=$(( 10#$(date +%m) - 1 )) + echo "${MESES_ES[$mes_idx]} - $(date +%Y)" +} + +log() { + echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG" +} + +montar() { + log "Intentando montar recurso remoto..." + sudo mount -t cifs "$REMOTE" "$DESTINO" \ + -o username="$USER",password="$PASS",uid=1000,gid=1000,file_mode=0777,dir_mode=0777,_netdev + if mountpoint -q "$DESTINO"; then + log "✔ Montaje exitoso" + else + log "❌ Error al montar" + exit 1 + fi +} + +# ========================= +# INICIO +# ========================= +log "==== INICIO DE SINCRONIZACIÓN ====" + +# 1. Verificar montaje +if mountpoint -q "$DESTINO"; then + log "✔ Unidad ya montada" +else + log "⚠️ Unidad no montada" + montar +fi + +# 2. Verificar que exista contenido en procesados +if [ -z "$(ls -A "$ORIGEN" 2>/dev/null)" ]; then + log "⚠️ Carpeta procesados vacía, nada que sincronizar" + exit 0 +fi + +# 3. Sincronizar dentro de la subcarpeta del mes en curso (ej. "SEPTIEMBRE - 2026") +CARPETA_MES="$(carpeta_mes_actual)" +DESTINO_MES="$DESTINO/$CARPETA_MES" +mkdir -p "$DESTINO_MES" + +log "Iniciando rsync de procesados hacia '$CARPETA_MES'..." +rsync -av --exclude='*.log' "$ORIGEN" "$DESTINO_MES" >> "$LOG" 2>&1 + +if [ $? -eq 0 ]; then + log "✔ Sincronización completada" +else + log "❌ Error en rsync" + exit 1 +fi + +# 4. Archivar contenido de procesados localmente +TIMESTAMP=$(date +%d_%m_%Y_%H_%M_%S) +DESTINO_MIGRACION="$MIGRADOS/$TIMESTAMP" + +log "Moviendo contenido de procesados a $DESTINO_MIGRACION" +mkdir -p "$DESTINO_MIGRACION" + +# Mover todo lo de procesados/ +find "$ORIGEN" -mindepth 1 -maxdepth 1 -exec mv -t "$DESTINO_MIGRACION" {} + + +if [ $? -eq 0 ]; then + log "✔ Contenido archivado en $DESTINO_MIGRACION" +else + log "❌ Error al mover contenido a migrados_compartida" + exit 1 +fi + +log "==== FIN DE SINCRONIZACIÓN ====" \ No newline at end of file