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:
@@ -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
|
||||
|
||||
110
README.md
110
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_<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).
|
||||
|
||||
@@ -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)
|
||||
@@ -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.
|
||||
52
run_dnit.sh
Executable file
52
run_dnit.sh
Executable 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
117
sync_dnit.sh
Normal 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 ===="
|
||||
Reference in New Issue
Block a user