114 lines
3.6 KiB
Python
114 lines
3.6 KiB
Python
import logging
|
|
import re
|
|
|
|
import pymysql
|
|
|
|
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__)
|
|
|
|
_RUC_BASE_RE = re.compile(r"^\d+")
|
|
|
|
|
|
def _normalizar_ruc(ruc):
|
|
"""
|
|
Para las personas físicas, el ruc en la BD viene casi siempre como número puro
|
|
(sin el dv pegado). Para poder comparar contra el ruc plano que trae el DNIT,
|
|
nos quedamos solo con el prefijo numérico inicial.
|
|
Devuelve None para filas basura que no arrancan con un dígito.
|
|
"""
|
|
match = _RUC_BASE_RE.match(str(ruc).strip())
|
|
return match.group() if match else None
|
|
|
|
|
|
def get_connection():
|
|
return pymysql.connect(
|
|
host=DB_HOST,
|
|
port=DB_PORT,
|
|
user=DB_USER,
|
|
password=DB_PASSWORD,
|
|
database=DB_NAME,
|
|
charset="utf8mb4",
|
|
autocommit=True,
|
|
)
|
|
|
|
|
|
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
|
|
(para jurídicas eso es casi siempre "ruc-dv" literal), como set para comparar
|
|
contra la clave "ruc-dv" armada con los datos del DNIT.
|
|
"""
|
|
query = f"SELECT {COLUMNA_RUC} FROM {TABLA_PERSONAS}"
|
|
existentes = set()
|
|
with conn.cursor() as cur:
|
|
cur.execute(query)
|
|
for (ruc,) in cur.fetchall():
|
|
existentes.add(str(ruc).strip())
|
|
logger.info("RUC existentes en %s: %d", TABLA_PERSONAS, len(existentes))
|
|
return existentes
|
|
|
|
|
|
def fetch_passwords_fisicas(conn):
|
|
"""
|
|
Trae ruc y password de las personas físicas (tipo_persona = 'F') ya cargadas,
|
|
como dict {ruc: password_actual} para comparar contra el dv del DNIT.
|
|
"""
|
|
query = f"SELECT {COLUMNA_RUC}, password FROM {TABLA_PERSONAS} WHERE tipo_persona = 'F'"
|
|
passwords = {}
|
|
with conn.cursor() as cur:
|
|
cur.execute(query)
|
|
for ruc, password in cur.fetchall():
|
|
ruc_base = _normalizar_ruc(ruc)
|
|
if ruc_base:
|
|
passwords[ruc_base] = password
|
|
logger.info("Personas físicas cargadas en %s: %d", TABLA_PERSONAS, len(passwords))
|
|
return passwords
|