Envío de las notificaciones, consultas optimizadas en la BD, filtros correctos, conexión modificada, se agrego el sincronizador y el shell para el crontab

This commit is contained in:
2026-09-22 08:17:36 -03:00
parent 5c422fe3ef
commit f806b63bc8
12 changed files with 811 additions and 33 deletions

View File

@@ -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 # Ruta donde quedan los CSV de RUC faltantes generados por el bot
HOST_SALIDA_PATH=/home/var/www/proyecto_desarrollo/botDNIT/salida 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 # Datos de conexión a la BD EXISTENTE que ya tiene la tabla personas
DB_HOST=111.111.111 DB_HOST=111.111.111
DB_PORT=3306 DB_PORT=3306

110
README.md
View File

@@ -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_<id>_*.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_<id>_*.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/<timestamp>/`
(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_<timestamp>.log`).
- `LOG_DNIT`: log de `sync_dnit.sh`.
- `/mnt/bot_dnit/logs/run_dnit.log`: log de `run.sh` (orquesta bot + sync).

View File

@@ -1,18 +1,38 @@
import os 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") 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) 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_HOST = os.getenv("DB_HOST", "db")
DB_PORT = int(os.getenv("DB_PORT", "3306")) DB_PORT = int(os.getenv("DB_PORT", "3306"))
DB_USER = os.getenv("DB_USER", "botdnit") DB_USER = os.getenv("DB_USER", "botdnit")
DB_PASSWORD = os.getenv("DB_PASSWORD", "botdnit") DB_PASSWORD = os.getenv("DB_PASSWORD", "botdnit")
DB_NAME = os.getenv("DB_NAME", "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 # Marca los .zip ya procesados para no descomprimir de nuevo en cada corrida
MARKER_SUFFIX = ".procesado" MARKER_SUFFIX = ".procesado"
@@ -35,5 +55,18 @@ CSV_CHUNK_SIZE = 80000
# Carpeta donde se escriben los CSV con los RUC faltantes # Carpeta donde se escriben los CSV con los RUC faltantes
OUTPUT_DIR = os.getenv("OUTPUT_DIR", "/data/salida") OUTPUT_DIR = os.getenv("OUTPUT_DIR", "/data/salida")
# Carpeta donde se escribe el .log de cada corrida (por defecto, la misma que OUTPUT_DIR) # 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) 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", "")

View File

@@ -3,7 +3,10 @@ import re
import pymysql 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__) 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): def fetch_rucs_existentes(conn):
""" """
Trae todos los RUC ya cargados en la tabla personas, tal cual están guardados Trae todos los RUC ya cargados en la tabla personas, tal cual están guardados

View File

@@ -1,6 +1,7 @@
import csv import csv
import logging import logging
import os import os
from datetime import datetime
from config import OUTPUT_DIR, CSV_CHUNK_SIZE from config import OUTPUT_DIR, CSV_CHUNK_SIZE
@@ -8,10 +9,24 @@ logger = logging.getLogger(__name__)
ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado"] 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): 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 "<prefijo_nombre>_<MES>_<AÑO>.csv" según el mes/año en que se
genera (o "..._<MES>_<AÑ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. Devuelve la lista de rutas generadas.
""" """
os.makedirs(OUTPUT_DIR, exist_ok=True) os.makedirs(OUTPUT_DIR, exist_ok=True)
@@ -19,13 +34,15 @@ def exportar_csv(registros, prefijo_nombre="rucs_faltantes", encabezado=ENCABEZA
rutas = [] rutas = []
total = len(registros) total = len(registros)
partes = max(1, (total + CSV_CHUNK_SIZE - 1) // CSV_CHUNK_SIZE) partes = max(1, (total + CSV_CHUNK_SIZE - 1) // CSV_CHUNK_SIZE)
mes_anio = _mes_anio_generacion()
for i in range(partes): for i in range(partes):
inicio = i * CSV_CHUNK_SIZE inicio = i * CSV_CHUNK_SIZE
fin = inicio + CSV_CHUNK_SIZE fin = inicio + CSV_CHUNK_SIZE
bloque = registros[inicio:fin] 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: with open(ruta, "w", newline="", encoding="utf-8") as f:
writer = csv.writer(f) writer = csv.writer(f)
writer.writerow(encabezado) writer.writerow(encabezado)

View File

@@ -2,34 +2,39 @@ import logging
import os import os
import zipfile import zipfile
from config import BASE_DIR, EXTRACT_DIR, MARKER_SUFFIX from config import BASE_DIR, MARKER_SUFFIX
logger = logging.getLogger(__name__) 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 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 con el mismo nombre (sin extensión), dentro del mismo base_dir. Usa un
para no volver a descomprimir en corridas posteriores. 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): if not os.path.isdir(base_dir):
raise FileNotFoundError(f"No existe el directorio base: {BASE_DIR}") raise FileNotFoundError(f"No existe el directorio base: {base_dir}")
extraidos = [] extraidos = []
for nombre in sorted(os.listdir(BASE_DIR)): for nombre in sorted(os.listdir(base_dir)):
if not nombre.lower().endswith(".zip"): if not nombre.lower().endswith(".zip"):
continue continue
ruta_zip = os.path.join(BASE_DIR, nombre) ruta_zip = os.path.join(base_dir, nombre)
marker = ruta_zip + MARKER_SUFFIX marker = ruta_zip + MARKER_SUFFIX
if os.path.exists(marker): if os.path.exists(marker):
logger.info("Ya procesado, se omite: %s", nombre) logger.info("Ya procesado, se omite: %s", nombre)
continue 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) os.makedirs(destino, exist_ok=True)
try: try:

View File

@@ -1,9 +1,25 @@
import logging import logging
import re
from config import PREFIJOS_PERSONAS_JURIDICAS, LONGITUD_RUC_JURIDICA from config import PREFIJOS_PERSONAS_JURIDICAS, LONGITUD_RUC_JURIDICA
logger = logging.getLogger(__name__) 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): def _es_juridica(ruc):
""" """
@@ -84,11 +100,12 @@ def clasificar_passwords_fisicas(registros_fisicas, passwords_existentes):
for registro in registros_fisicas: for registro in registros_fisicas:
ruc, razon_social, dv, codigo, estado, _archivo_origen = registro 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) no_encontrados.append(registro)
continue continue
password_actual = (passwords_existentes[ruc] or "").strip() password_actual = (passwords_existentes[ruc_base] or "").strip()
if password_actual == dv: if password_actual == dv:
sin_cambios += 1 sin_cambios += 1
continue continue

View File

@@ -1,8 +1,9 @@
import logging import logging
import os import os
import traceback
from datetime import datetime 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 extractor import descomprimir_todo
from parser import recorrer_y_parsear from parser import recorrer_y_parsear
from filtro import ( from filtro import (
@@ -12,7 +13,15 @@ from filtro import (
clasificar_passwords_fisicas, clasificar_passwords_fisicas,
) )
from exportador import exportar_csv 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) 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") 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__) logger = logging.getLogger(__name__)
def main(): def _mapear_a_ruta_local(directorio_zips):
logger.info("Iniciando bot RUC DNIT") """
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") 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("Carpetas descomprimidas en esta corrida: %d", len(carpetas_nuevas))
logger.info("Paso 2: recorriendo carpetas y parseando .txt") 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") logger.info("Paso 3: filtrando personas jurídicas por prefijo de RUC")
juridicas = filtrar_juridicas(registros) juridicas = filtrar_juridicas(registros)
@@ -51,7 +86,7 @@ def main():
faltantes = filtrar_no_existentes(juridicas, rucs_existentes) faltantes = filtrar_no_existentes(juridicas, rucs_existentes)
logger.info("Paso 5: exportando CSV de RUC faltantes") 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") logger.info("Paso 6: comparando password de personas físicas contra el dv del DNIT")
fisicas = filtrar_fisicas(registros) fisicas = filtrar_fisicas(registros)
@@ -64,9 +99,67 @@ def main():
a_generar, _no_encontrados = clasificar_passwords_fisicas(fisicas, passwords_existentes) a_generar, _no_encontrados = clasificar_passwords_fisicas(fisicas, passwords_existentes)
logger.info("Paso 7: exportando CSV de personas físicas a insertar/actualizar password") 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__": if __name__ == "__main__":

268
app/notificaciones.py Normal file
View File

@@ -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("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
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"""<!DOCTYPE html>
<html>
<head>
<meta http-equiv='Content-Type' content='text/html; charset=UTF-8' />
<title>BOT DNIT | ERROR DE PROCESAMIENTO</title>
</head>
<body>
<img src='{LOGO_URL}' width='255'>
<h2 style='text-align:center; margin:10px 0; color:#c0392b;'>
Bot DNIT: Error en el Procesamiento
</h2>
<p>
El bot RUC DNIT (Bot 2) se detuvo por un error al procesar una fila pendiente de <code>control_descargas_dnit</code>. La corrida quedó cortada y la fila no se marcó como procesada.
</p>
<table border='1' cellpadding='6' cellspacing='0' style='border-collapse:collapse; width:100%;'>
<thead>
<tr>
<th width='30%'>Detalle</th>
<th width='70%'>Valor</th>
</tr>
</thead>
<tbody>
<tr>
<td>Fila (id)</td>
<td>{_escapar_html(row_id)}</td>
</tr>
<tr>
<td>directorio_zips</td>
<td>{_escapar_html(directorio_zips)}</td>
</tr>
<tr>
<td>Error</td>
<td>{_escapar_html(error)}</td>
</tr>
<tr>
<td>Fecha/Hora</td>
<td>{fecha_hora}</td>
</tr>
<tr>
<td>Detalle técnico</td>
<td><pre style='white-space:pre-wrap; margin:0; font-size:12px;'>{_escapar_html(traceback_texto)}</pre></td>
</tr>
</tbody>
<tfoot>
<tr>
<td colspan='2' style='text-align:left;'>
<strong>Acción requerida:</strong> Revisar el log del bot y la fila id={_escapar_html(row_id)} en control_descargas_dnit antes de reintentar.
</td>
</tr>
</tfoot>
</table>
</body>
</html>"""
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"""<!DOCTYPE html>
<html>
<head>
<meta http-equiv='Content-Type' content='text/html; charset=UTF-8' />
<title>BOT DNIT | PROCESAMIENTO FINALIZADO</title>
</head>
<body>
<img src='{LOGO_URL}' width='255'>
<h2 style='text-align:center; margin:10px 0; color:#1e8449;'>
Bot DNIT: Procesamiento Finalizado
</h2>
<table border='1' cellpadding='6' cellspacing='0' style='border-collapse:collapse; width:100%;'>
<thead>
<tr>
<th width='30%'>Detalle</th>
<th width='70%'>Valor</th>
</tr>
</thead>
<tbody>
<tr>
<td>Mes Procesado</td>
<td>{_mes_procesado()}</td>
</tr>
<tr>
<td>Directorio ZIPS</td>
<td>{_escapar_html(directorio_zips)}</td>
</tr>
<tr>
<td>Carpetas Descomprimidas</td>
<td>{resumen['carpetas_descomprimidas']}</td>
</tr>
<tr>
<td>Personas Jurídicas Nuevas</td>
<td>{resumen['rucs_faltantes']}</td>
</tr>
<tr>
<td>CSV de Personas Jurídicas Nuevas</td>
<td>{_escapar_html(", ".join(os.path.basename(r) for r in resumen['rutas_rucs_faltantes']) or "(sin filas)")}</td>
</tr>
<tr>
<td>Personas Físicas - Actualizar</td>
<td>{resumen['fisicas_a_generar']}</td>
</tr>
<tr>
<td>Personas Físicas - No encontradas en la BD</td>
<td>{resumen['fisicas_no_encontradas']}</td>
</tr>
<tr>
<td>CSV - Personas Físicas</td>
<td>{_escapar_html(", ".join(os.path.basename(r) for r in resumen['rutas_fisicas_password']) or "(sin filas)")}</td>
</tr>
</tbody>
</table>
</body>
</html>"""
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)

View File

@@ -4,6 +4,13 @@ services:
environment: environment:
BASE_DIR: /data BASE_DIR: /data
OUTPUT_DIR: /data/salida 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_HOST: ${DB_HOST}
DB_PORT: ${DB_PORT:-3306} DB_PORT: ${DB_PORT:-3306}
DB_USER: ${DB_USER} DB_USER: ${DB_USER}
@@ -11,11 +18,20 @@ services:
DB_NAME: ${DB_NAME} DB_NAME: ${DB_NAME}
TABLA_PERSONAS: ${TABLA_PERSONAS:-personas} TABLA_PERSONAS: ${TABLA_PERSONAS:-personas}
COLUMNA_RUC: ${COLUMNA_RUC:-ruc} 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: volumes:
# Mapea la carpeta real del servidor con los zip/txt del DNIT # Mapea la carpeta real del servidor con los zip/txt del DNIT
- ${HOST_DOCUMENTOS_PATH}:/data - ${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 - ${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). # Corrida única (para disparar por cron del host, ver README).
# network_mode: host si la BD existente corre en el mismo servidor # network_mode: host si la BD existente corre en el mismo servidor
# y preferís no exponer nada por IP de contenedor. # y preferís no exponer nada por IP de contenedor.

52
run_dnit.sh Executable file
View File

@@ -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 ===="

117
sync_dnit.sh Normal file
View File

@@ -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 ===="