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

@@ -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", "")

View File

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

View File

@@ -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)

View File

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

View File

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

View File

@@ -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
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)