Files
bot_dnit/app/db.py

114 lines
3.6 KiB
Python
Raw Normal View History

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