pc responsive issues

app/main.py

@@ -13,7 +13,6 @@ from flask import Flask, render_template, request, jsonify, redirect, url_for, f
 from flask_socketio import SocketIO, emit
 from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user
 from werkzeug.security import generate_password_hash, check_password_hash
-import mysql.connector
 import gitlab
 import telebot
 from telebot import types
@@ -41,61 +40,66 @@ class User(UserMixin):
         self.id = id
         self.username = username
 
-# --- BASE DE DATOS MYSQL ---
-def get_db_connection():
-    """Establece y retorna una conexión a la base de datos MySQL."""
-    try:
-        conn = mysql.connector.connect(
-            host=os.getenv("MYSQL_HOST", "localhost"),
-            user=os.getenv("MYSQL_USER", "root"),
-            password=os.getenv("MYSQL_PASSWORD", ""),
-            database=os.getenv("MYSQL_DB", "makerpage")
-        )
-        return conn
-    except mysql.connector.Error as err:
-        print(f"ERROR CRÍTICO MYSQL: {err}")
+# --- GESTOR DE USUARIOS (Persistencia JSON) ---
+class UserManager:
+    """Clase para manejar los usuarios en un archivo JSON."""
+    def __init__(self, filename="users.json"):
+        self.filename = filename
+        self.users = self._load()
+
+    def _load(self):
+        """Carga los usuarios desde el archivo JSON."""
+        if os.path.exists(self.filename):
+            try:
+                with open(self.filename, "r") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+
+    def save(self):
+        """Guarda la lista de usuarios en el archivo JSON."""
+        with open(self.filename, "w") as f:
+            json.dump(self.users, f, indent=4)
+
+    def add_user(self, username, password):
+        """Registra un nuevo usuario con contraseña hasheada."""
+        if self.get_by_username(username):
+            return False
+        
+        user_id = str(len(self.users) + 1)
+        hashed_pw = generate_password_hash(password)
+        self.users.append({
+            "id": user_id,
+            "username": username,
+            "password": hashed_pw
+        })
+        self.save()
+        return True
+
+    def get_by_username(self, username):
+        """Busca un usuario por su nombre."""
+        for user in self.users:
+            if user["username"] == username:
+                return user
         return None
 
-def init_db():
-    """Inicializa la base de datos y crea las tablas necesarias si no existen."""
-    conn = get_db_connection()
-    if conn:
-        try:
-            cursor = conn.cursor()
-            # Crear tabla de usuarios con soporte para hashing de contraseñas
-            cursor.execute("""
-                CREATE TABLE IF NOT EXISTS users (
-                    id INT AUTO_INCREMENT PRIMARY KEY,
-                    username VARCHAR(50) UNIQUE NOT NULL,
-                    password VARCHAR(255) NOT NULL
-                )
-            """)
-            conn.commit()
-            print("INFO: Base de datos verificada/inicializada correctamente.")
-        except mysql.connector.Error as err:
-            print(f"ERROR al inicializar tablas: {err}")
-        finally:
-            conn.close()
-    else:
-        print("ADVERTENCIA: No se pudo conectar a MySQL para inicializar. Verifica las credenciales.")
-
-# Llamar a la inicialización al arrancar
-init_db()
+    def get_by_id(self, user_id):
+        """Busca un usuario por su ID."""
+        for user in self.users:
+            if user["id"] == user_id:
+                return user
+        return None
+
+user_mgr = UserManager()
 
 @login_manager.user_loader
 def load_user(user_id):
-    """Recupera un usuario de la base de datos por su ID para Flask-Login."""
-    conn = get_db_connection()
-    if not conn: return None
-    try:
-        cursor = conn.cursor(dictionary=True)
-        cursor.execute("SELECT id, username FROM users WHERE id = %s", (user_id,))
-        user_data = cursor.fetchone()
-        return User(str(user_data['id']), user_data['username']) if user_data else None
-    except:
-        return None
-    finally:
-        conn.close()
+    """Cargador de usuario para Flask-Login desde el JSON."""
+    user_data = user_mgr.get_by_id(user_id)
+    if user_data:
+        return User(user_data['id'], user_data['username'])
+    return None
 
 # --- GESTOR DE PRÉSTAMOS (Persistencia JSON) ---
 class LoanManager:
@@ -147,11 +151,10 @@ try:
 except:
     pass
 
-# URL del proxy de Google Script para evadir restricciones de red si es necesario
+# URL del proxy de Google Script
 GOOGLE_PROXY_URL = os.getenv("GOOGLE_PROXY_URL") or "https://script.google.com/macros/s/AKfycbz7z1Jb0vsur42GmmqrL3PVXeRkN2WxSojFDIleEDoLOg6MnrmJjb_uuPcQ15CTwyzD/exec"
 
 if TG_TOKEN and GOOGLE_PROXY_URL:
-    # Configurar telebot para usar el proxy
     base_url = GOOGLE_PROXY_URL.split('?')[0]
     telebot.apihelper.API_URL = base_url + "?path={1}&token={0}"
     telebot.apihelper.CONNECT_TIMEOUT = 60
@@ -160,17 +163,15 @@ if TG_TOKEN and GOOGLE_PROXY_URL:
 bot = telebot.TeleBot(TG_TOKEN) if TG_TOKEN else None
 
 def escape_md(text):
-    """Escapa caracteres especiales para el modo Markdown de Telegram."""
+    """Escapa caracteres para Markdown de Telegram."""
     if not text: return ""
     for char in ['_', '*', '[', '`']:
         text = text.replace(char, f"\\{char}")
     return text
 
-# --- MANEJADORES DEL BOT DE TELEGRAM ---
 if bot:
     @bot.callback_query_handler(func=lambda call: True)
     def handle_query(call):
-        """Maneja las pulsaciones de botones Inline (Aceptar/Declinar)."""
         try:
             if call.data.startswith("accept_"):
                 loan_id = call.data.replace("accept_", "")
@@ -178,7 +179,6 @@ if bot:
                     bot.answer_callback_query(call.id, "Préstamo Aceptado")
                     nuevo_texto = f"✅ *ACEPTADO*\n{escape_md(call.message.text)}"
                     bot.edit_message_text(nuevo_texto, call.message.chat.id, call.message.message_id, parse_mode="Markdown")
-                    # Emitir evento Socket.IO para actualizar la UI en tiempo real
                     socketio.emit('notification', {"text": f"Préstamo {loan_id[:8]} ACEPTADO", "color": "green"})
             elif call.data.startswith("decline_"):
                 loan_id = call.data.replace("decline_", "")
@@ -192,7 +192,6 @@ if bot:
 
     @bot.message_handler(commands=['aceptar', 'declinar', 'status'])
     def handle_text_commands(message):
-        """Maneja comandos directos por texto."""
         try:
             text = message.text.split()
             if len(text) < 2:
@@ -204,47 +203,31 @@ if bot:
                 emoji = "✅" if status == "ACCEPTED" else "❌"
                 bot.reply_to(message, f"{emoji} Préstamo {loan_id} actualizado a {status}")
                 socketio.emit('notification', {"text": f"Préstamo {loan_id[:8]} {status}", "color": "green" if status == "ACCEPTED" else "red"})
-            else:
-                bot.reply_to(message, "ID de préstamo no encontrado.")
         except Exception as e:
             print(f"Command Error: {e}")
 
-    @bot.message_handler(commands=['getid'])
-    def handle_getid(message):
-        """Comando de ayuda para obtener el Chat ID actual."""
-        try:
-            bot.reply_to(message, f"Chat ID: `{message.chat.id}`", parse_mode="Markdown")
-        except Exception as e:
-            print(f"GetID Error: {e}")
-
 def start_bot_thread():
-    """Hilo de ejecución para el polling infinito del bot de Telegram."""
     if bot:
-        print("INFO: Esperando 5s para estabilizar conexión con Telegram...")
         time.sleep(5)
         try: bot.delete_webhook()
         except: pass
         while True:
             try:
-                print("DEBUG: Iniciando polling de Telegram...")
                 bot.infinity_polling(timeout=20, long_polling_timeout=10)
             except Exception as e:
-                print(f"Error Polling: {e}. Reintento en 30s...")
                 time.sleep(30)
 
 if bot:
     threading.Thread(target=start_bot_thread, daemon=True).start()
 
-# --- RUTAS WEB (Flask) ---
+# --- RUTAS WEB ---
 
 @app.route('/')
 def index():
-    """Página principal del panel."""
     return render_template('index.html', title="MAKER SPACE")
 
 @app.route('/login', methods=['GET', 'POST'])
 def login():
-    """Ruta para el inicio de sesión de usuarios."""
     if current_user.is_authenticated:
         return redirect(url_for('repos'))
         
@@ -252,19 +235,10 @@ def login():
         username = request.form.get('username')
         password = request.form.get('password')
         
-        conn = get_db_connection()
-        if not conn:
-            flash("Error de conexión a la base de datos", "red")
-            return render_template('login.html')
-            
-        cursor = conn.cursor(dictionary=True)
-        cursor.execute("SELECT id, username, password FROM users WHERE username = %s", (username,))
-        user_data = cursor.fetchone()
-        conn.close()
+        user_data = user_mgr.get_by_username(username)
         
-        # Verificación segura de la contraseña usando hashes
         if user_data and check_password_hash(user_data['password'], password):
-            user = User(str(user_data['id']), user_data['username'])
+            user = User(user_data['id'], user_data['username'])
             login_user(user)
             flash(f"¡Bienvenido de nuevo, {username}!", "green")
             return redirect(url_for('repos'))
@@ -275,7 +249,6 @@ def login():
 
 @app.route('/register', methods=['GET', 'POST'])
 def register():
-    """Ruta para el registro de nuevos usuarios."""
     if current_user.is_authenticated:
         return redirect(url_for('repos'))
 
@@ -288,47 +261,28 @@ def register():
             flash("Las contraseñas no coinciden", "red")
             return render_template('register.html')
 
-        # Generar hash seguro de la contraseña
-        hashed_password = generate_password_hash(password)
-        
-        conn = get_db_connection()
-        if not conn:
-            flash("Error de conexión a la base de datos", "red")
-            return render_template('register.html')
-
-        try:
-            cursor = conn.cursor()
-            cursor.execute("INSERT INTO users (username, password) VALUES (%s, %s)", (username, hashed_password))
-            conn.commit()
+        if user_mgr.add_user(username, password):
             flash("Cuenta creada exitosamente. Ahora puedes iniciar sesión.", "green")
             return redirect(url_for('login'))
-        except mysql.connector.Error as err:
-            if err.errno == 1062:
-                flash("El nombre de usuario ya existe.", "red")
-            else:
-                flash("Error al crear la cuenta. Inténtalo de nuevo.", "red")
-        finally:
-            conn.close()
+        else:
+            flash("El nombre de usuario ya existe.", "red")
 
     return render_template('register.html', title="Registro")
 
 @app.route('/logout')
 @login_required
 def logout():
-    """Cierra la sesión del usuario actual."""
     logout_user()
     flash("Has cerrado sesión", "blue")
     return redirect(url_for('index'))
 
 @app.route('/prestamos')
 def prestamos():
-    """Vista del historial y formulario de préstamos."""
     loans = loan_mgr.get_all()
     return render_template('prestamos.html', title="Préstamos", loans=loans)
 
 @app.route('/api/prestamo', methods=['POST'])
 def api_prestamo():
-    """API para registrar una nueva solicitud de préstamo."""
     data = request.json
     solicitante = data.get('solicitante')
     h_salida = data.get('hora_salida')
@@ -341,7 +295,7 @@ def api_prestamo():
     loan_id = str(uuid.uuid4())
     lista_items_str = "\n".join([f"• [{i['categoria']}] {i['descripcion']} (x{i['cantidad']})" for i in items])
 
-    # Preparar mensaje para Telegram
+    # Notificar a Telegram
     mensaje_tg = (
         "🛠 *NUEVA SOLICITUD DE PRÉSTAMO*\n"
         f"👤 *Solicitante:* {escape_md(solicitante)}\n"
@@ -352,7 +306,6 @@ def api_prestamo():
     res_tg = "OK"
     if bot and TG_CHAT_ID:
         try:
-            # Crear botones de acción rápida en el mensaje de Telegram
             markup = types.InlineKeyboardMarkup()
             markup.add(
                 types.InlineKeyboardButton("✅ Aceptar", callback_data=f"accept_{loan_id}"),
@@ -362,8 +315,8 @@ def api_prestamo():
         except Exception as e:
             res_tg = str(e)
 
-    # Registrar en el historial JSON
-    nuevo = {
+    # Guardar en JSON
+    loan_mgr.add_loan({
         "id": loan_id,
         "Solicitante": solicitante,
         "item": lista_items_str,
@@ -372,34 +325,28 @@ def api_prestamo():
         "devolucion": h_retorno,
         "status_loan": "PENDING",
         "status_tg": res_tg
-    }
+    })
     
-    loan_mgr.add_loan(nuevo)
     return jsonify({"status": "success", "id": loan_id})
 
 @app.route('/api/entregar/<loan_id>', methods=['POST'])
 def api_entregar(loan_id):
-    """API para notificar la entrega física de los materiales."""
     loan = None
     for l in loan_mgr.get_all():
         if l['id'] == loan_id:
             loan = l
             break
             
-    if not loan:
-        return jsonify({"status": "error", "message": "Préstamo no encontrado"}), 404
-        
-    if loan['status_loan'] != "ACCEPTED":
-        return jsonify({"status": "error", "message": "Solo se pueden entregar préstamos aceptados"}), 400
+    if not loan or loan['status_loan'] != "ACCEPTED":
+        return jsonify({"status": "error", "message": "No se puede entregar"}), 400
 
-    # Ajuste de zona horaria a República Dominicana (UTC-4)
+    # Hora AST (Rep. Dom.)
     utc_now = datetime.datetime.now(datetime.timezone.utc)
     rd_now = utc_now - datetime.timedelta(hours=4)
     ahora = rd_now.strftime("%H:%M")
     
     loan_mgr.update_status(loan_id, "DELIVERED")
     
-    # Notificar a Telegram sobre la entrega
     mensaje_tg = (
         "📦 *ENTREGA DE MATERIALES*\n"
         f"👤 *Solicitante:* {escape_md(loan['Solicitante'])}\n"
@@ -408,10 +355,8 @@ def api_entregar(loan_id):
     )
     
     if bot and TG_CHAT_ID:
-        try:
-            bot.send_message(TG_CHAT_ID, mensaje_tg, parse_mode="Markdown")
-        except Exception as e:
-            print(f"Error Telegram Entregar: {e}")
+        try: bot.send_message(TG_CHAT_ID, mensaje_tg, parse_mode="Markdown")
+        except: pass
 
     socketio.emit('notification', {"text": f"Entrega confirmada para {loan['Solicitante']}", "color": "blue"})
     return jsonify({"status": "success"})
@@ -419,60 +364,41 @@ def api_entregar(loan_id):
 @app.route('/repos')
 @login_required
 def repos():
-    """Lista de proyectos desde GitLab (requiere autenticación)."""
-    GITLAB_URL = "https://gitlab.com"
     GIT_TOKEN = os.getenv("GITLAB_TOKEN")
     GIT_GROUP = os.getenv("GITLAB_GROUP_ID")
-    
     projects = []
     if GIT_TOKEN and GIT_GROUP:
         try:
-            gl = gitlab.Gitlab(GITLAB_URL, private_token=GIT_TOKEN)
+            gl = gitlab.Gitlab("https://gitlab.com", private_token=GIT_TOKEN)
             projects = gl.groups.get(GIT_GROUP).projects.list(all=True)
-        except Exception as e:
-            print(f"GitLab Error: {e}")
+        except: pass
     return render_template('repos.html', title="Proyectos", projects=projects)
 
 @app.route('/ver/<pid>/<pname>')
 @login_required
 def ver_repo(pid, pname):
-    """Vista detallada de un proyecto, muestra el README renderizado."""
     GIT_TOKEN = os.getenv("GITLAB_TOKEN")
-    GITLAB_URL = "https://gitlab.com"
-    
-    readme_html = "<p>README.md no encontrado.</p>"
-    web_url = "#"
-    download_url = "#"
+    readme_html = "<p>README no disponible</p>"
+    web_url = "#"; download_url = "#"
 
     if GIT_TOKEN:
         try:
-            gl = gitlab.Gitlab(GITLAB_URL, private_token=GIT_TOKEN)
+            gl = gitlab.Gitlab("https://gitlab.com", private_token=GIT_TOKEN)
             project = gl.projects.get(pid)
             web_url = project.web_url
-            download_url = f"{GITLAB_URL}/api/v4/projects/{pid}/repository/archive.zip?private_token={GIT_TOKEN}"
+            download_url = f"https://gitlab.com/api/v4/projects/{pid}/repository/archive.zip?private_token={GIT_TOKEN}"
             
-            # Buscar el archivo README.md en las ramas principales
-            readme_text = ""
             for branch in ["main", "master"]:
                 try:
                     f = project.files.get(file_path='README.md', ref=branch)
                     readme_text = base64.b64decode(f.content).decode("utf-8")
+                    readme_html = markdown.markdown(readme_text, extensions=['fenced_code', 'tables'])
                     break
                 except: continue
-            
-            if readme_text:
-                # Renderizar Markdown a HTML
-                readme_html = markdown.markdown(readme_text, extensions=['fenced_code', 'tables'])
         except: pass
         
-    return render_template('ver_repo.html', 
-                          title=pname, 
-                          project_name=pname, 
-                          readme_html=readme_html,
-                          web_url=web_url,
-                          download_url=download_url)
+    return render_template('ver_repo.html', title=pname, project_name=pname, readme_html=readme_html, web_url=web_url, download_url=download_url)
 
 if __name__ == '__main__':
-    # Ejecución del servidor con Socket.IO y soporte para Eventlet
     port = int(os.getenv("PORT", 7860))
     socketio.run(app, host="0.0.0.0", port=port, debug=True)

app/requirements.txt

@@ -8,4 +8,3 @@ gunicorn
 eventlet
 markdown
 flask-login
-mysql-connector-python