Refactor bot_logic.py into handlers package

Author: rozen03

bot_logic.py

@@ -0,0 +1,114 @@
+import logging
+import datetime
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode
+from tg_ids import CODEPERS_CHATID, ROZEN_CHATID, DGARRO_CHATID
+from models import Noticia
+from handlers.db import get_session
+
+logger = logging.getLogger("DCUBABOT")
+admin_ids = [ROZEN_CHATID, DGARRO_CHATID]
+
+async def checodepers(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    if not context.args:
+        ejemplo = """ Ejemplo de uso:
+  /checodepers Hola, tengo un mensaje mucho muy importante que me gustaria que respondan
+"""
+        await update.message.reply_text(ejemplo)
+        return
+    user = update.message.from_user
+    try:
+        if not user.username:
+            raise Exception("not userneim")
+        message = " ".join(context.args)
+        await context.bot.send_message(
+            chat_id=CODEPERS_CHATID, text=f"{user.first_name}(@{user.username}) : {message}")
+    except Exception:
+        try:
+            await context.bot.forward_message(
+                CODEPERS_CHATID, update.message.chat_id, update.message.message_id)
+            logger.info(f"Malio sal {str(user)}")
+        except Exception as e:
+            await update.message.reply_text(
+                "La verdad me re rompí, avisale a roz asi ve que onda")
+            logger.error(e)
+            return
+    await update.message.reply_text("OK, se lo mando a les codepers.")
+
+async def checodeppers(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    await checodepers(update, context)
+
+async def sugerirNoticia(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user = update.message.from_user
+    name = user.first_name
+    texto = " ".join(context.args)
+    if not texto:
+        await update.message.reply_text(
+            text="Loc@, pusisiste algo mal, la idea es q pongas:\n "
+                 "/sugerirNoticia <texto>")
+        return
+    with get_session() as session:
+        noticia = Noticia(text=texto)
+        session.add(noticia)
+        session.flush()
+        noticia_id = noticia.id
+    keyboard = [
+        [
+            InlineKeyboardButton("Aceptar", callback_data=f"Noticia|{noticia_id}|1"),
+            InlineKeyboardButton("Rechazar", callback_data=f"Noticia|{noticia_id}|0")
+        ]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    await context.bot.send_message(chat_id=ROZEN_CHATID, text=f"Noticia-{name}: {texto}",
+                            reply_markup=reply_markup, parse_mode=ParseMode.MARKDOWN)
+    await update.message.reply_text(text="Ok, se lo pregunto a Rozen")
+
+async def get_logs(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user_id = update.effective_user.id
+    if user_id not in admin_ids:
+        return
+    
+    try:
+        from google.cloud import logging as gcp_logging
+        import json
+        import io
+        
+        await update.message.reply_text("Buscando errores en Google Cloud Logging...")
+        client = gcp_logging.Client()
+        
+        filter_str = 'resource.type="cloud_run_revision" AND severity>=ERROR AND resource.labels.service_name="dcubabot"'
+        entries = client.list_entries(filter_=filter_str, order_by=gcp_logging.DESCENDING, max_results=50)
+        
+        log_msgs = []
+        for entry in entries:
+            log_data = {
+                "timestamp": entry.timestamp.isoformat(),
+                "severity": entry.severity,
+            }
+            
+            payload = entry.payload
+            if isinstance(payload, dict):
+                log_data["json_payload"] = payload
+            elif payload is not None:
+                log_data["text_payload"] = str(payload)
+            else:
+                log_data["resource"] = str(entry.resource)
+                
+            log_msgs.append(log_data)
+            
+        if not log_msgs:
+            await update.message.reply_text("✅ No se encontraron errores recientes en GCP.")
+            return
+            
+        logs_json_str = json.dumps(log_msgs, indent=2, ensure_ascii=False)
+        file_obj = io.BytesIO(logs_json_str.encode('utf-8'))
+        file_obj.name = f"gcp_error_logs_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        await context.bot.send_document(
+            chat_id=update.effective_chat.id,
+            document=file_obj,
+            caption="Acá tenés el archivo con los últimos errores registrados en GCP 🕵️‍♂️"
+        )
+    except Exception as e:
+        await update.message.reply_text(f"Error al leer logs (¿falta permiso roles/logging.viewer en la Service Account?): {e}")

dcubabot.py

@@ -0,0 +1,27 @@
+import sys
+from telegram import Update
+from telegram.ext import ContextTypes
+from models import Command
+from handlers.db import get_session
+
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    await update.message.reply_text(
+        "Hola, ¿qué tal? ¡Mandame /help si no sabés qué puedo hacer!")
+
+async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    message_text = "Comandos disponibles:\n"
+    with get_session() as session:
+        commands = session.query(Command).filter_by(enabled=True).order_by(Command.name).all()
+        for command in commands:
+            if command.description:
+                message_text += f"/{command.name} - {command.description}\n"
+            else:
+                message_text += f"/{command.name}\n"
+    await update.message.reply_text(message_text)
+
+async def estasvivo(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    await update.message.reply_text(f"Sí, estoy vivo y corriendo en Python {sys.version.split()[0]}")
+
+async def colaborar(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    await update.message.reply_text(
+        "Se puede colaborar con el DCUBA bot en https://github.com/comcomUBA/dcubabot")

handlers/__init__.py

@@ -0,0 +1,37 @@
+from telegram import Update
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode
+from models import Listable, Noticia
+from handlers.db import get_session
+from tg_ids import NOTICIAS_CHATID
+
+async def button(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    await query.answer()
+    message = query.message
+    buttonType, id_val, action = query.data.split("|")
+    
+    with get_session() as session:
+        if buttonType == "Listable":
+            group = session.query(Listable).filter_by(id=int(id_val)).first()
+            if group:
+                if action == "1":
+                    group.validated = True
+                    action_text = "\n¡Aceptado!"
+                else:
+                    session.delete(group)
+                    action_text = "\n¡Rechazado!"
+                await query.edit_message_text(text=message.text + action_text)
+        
+        elif buttonType == "Noticia":
+            noticia = session.query(Noticia).filter_by(id=int(id_val)).first()
+            if noticia:
+                if action == "1":
+                    noticia.validated = True
+                    action_text = "\n¡Aceptado!"
+                    await context.bot.send_message(chat_id=NOTICIAS_CHATID,
+                                                   text=noticia.text, parse_mode=ParseMode.MARKDOWN)
+                else:
+                    session.delete(noticia)
+                    action_text = "\n¡Rechazado!"
+                await query.edit_message_text(text=message.text + action_text)

handlers/admin.py

@@ -0,0 +1,59 @@
+import pytz
+import datetime
+import random
+import logging
+from telegram.ext import ContextTypes
+import river
+import conciertos
+from tg_ids import DC_GROUP_CHATID, NOTICIAS_CHATID
+
+logger = logging.getLogger("DCUBABOT")
+bsasTz = pytz.timezone("America/Argentina/Buenos_Aires")
+
+def felizdia_text(today):
+    meses = ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio",
+             "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"]
+    dia = str(today.day)
+    mes = int(today.month)
+
+    if mes == 3 and today.day == 8:
+        return "Hoy es 8 de Marzo"
+    else:
+        mes = meses[mes - 1]
+        return "Feliz " + dia + " de " + mes
+
+async def felizdia(context: ContextTypes.DEFAULT_TYPE):
+    if random.uniform(0, 7) > 1:
+        return
+    today = datetime.date.today()
+    chat_id = DC_GROUP_CHATID
+    await context.bot.send_message(chat_id=chat_id, text=felizdia_text(today))
+
+async def actualizarPartidos(context: ContextTypes.DEFAULT_TYPE):
+    hoy = datetime.datetime.now(bsasTz)
+    mañana = hoy + datetime.timedelta(days=1)
+    try:
+        local, partido = river.es_local(mañana)
+        if not local:
+            return
+        horario = "hora a confirmar" if partido.hora is None else partido.hora.strftime("a las %H:%M")
+        msg = f"Mañana juega River, {horario}\n(contra {partido.equipo_visitante}, {partido.copa})"
+        await context.bot.send_message(chat_id=NOTICIAS_CHATID, text=msg)
+    except Exception as e:
+        logger.error(f"Error checking River matches: {e}")
+
+async def actualizarConciertos(context: ContextTypes.DEFAULT_TYPE):
+    hoy = datetime.datetime.now(bsasTz)
+    mañana = hoy + datetime.timedelta(days=1)
+    try:
+        hay, concierto = conciertos.hay_concierto(mañana)
+        if not hay:
+            return
+        msg = f"Mañana hay un concierto en River\n{concierto.titulo}"
+        await context.bot.send_message(chat_id=NOTICIAS_CHATID, text=msg)
+    except Exception as e:
+        logger.error(f"Error checking concerts: {e}")
+
+async def actualizarRiver(context: ContextTypes.DEFAULT_TYPE):
+    await actualizarPartidos(context)
+    await actualizarConciertos(context)

handlers/basic.py

@@ -0,0 +1,17 @@
+import models
+from contextlib import contextmanager
+
+@contextmanager
+def get_session():
+    """Provide a transactional scope around a series of operations."""
+    if models.Session is None:
+        models.init_db()
+    session = models.Session()
+    try:
+        yield session
+        session.commit()
+    except:
+        session.rollback()
+        raise
+    finally:
+        session.close()