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:
@@ -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)
|
||||
# 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", "")
|
||||
|
||||
51
app/db.py
51
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
|
||||
return passwords
|
||||
|
||||
@@ -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 "<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.
|
||||
"""
|
||||
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)
|
||||
|
||||
@@ -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
|
||||
return extraidos
|
||||
|
||||
@@ -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
|
||||
|
||||
113
app/main.py
113
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()
|
||||
main()
|
||||
|
||||
268
app/notificaciones.py
Normal file
268
app/notificaciones.py
Normal 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("&", "&").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"""<!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)
|
||||
Reference in New Issue
Block a user