Update modules/auth/auth.py

modules/auth/auth.py

@@ -1,52 +1,163 @@
-#/modules/auth/auth.py
+# modules/auth/auth.py
+
 import gradio as gr
 import os
-from azure.cosmos import CosmosClient, exceptions
-from azure.cosmos.exceptions import CosmosHttpResponseError
+import logging
 import bcrypt
 import base64
+from azure.cosmos import CosmosClient
+from azure.cosmos.exceptions import CosmosHttpResponseError
+from datetime import datetime, timezone
+
 from ..database.sql_db import (
     get_user,
     get_student_user,
-    get_admin_user,
     create_student_user,
     update_student_user,
     delete_student_user,
     record_login,
-    record_logout
+    record_logout,
 )
 
-import logging
+logger = logging.getLogger(__name__)
 
-from datetime import datetime, timezone
+# Verificar las variables de entorno necesarias
+COSMOS_ENDPOINT = os.getenv("COSMOS_ENDPOINT")
+COSMOS_KEY = os.getenv("COSMOS_KEY")
 
-logger = logging.getLogger(__name__)
+if not COSMOS_ENDPOINT or not COSMOS_KEY:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY no están configuradas.")
 
+# Validar y limpiar la clave de Cosmos DB
 def clean_and_validate_key(key):
-    """Limpia y valida la clave de CosmosDB"""
     key = key.strip()
     while len(key) % 4 != 0:
-        key += '='
+        key += "="
     try:
         base64.b64decode(key)
         return key
-    except:
-        raise ValueError("La clave proporcionada no es válida")
+    except Exception:
+        raise ValueError("La clave proporcionada no es válida.")
+
+COSMOS_KEY = clean_and_validate_key(COSMOS_KEY)
+cosmos_client = CosmosClient(COSMOS_ENDPOINT, COSMOS_KEY)
+
+########################################
+# ÍNDICE DE FUNCIONES (Referencia consolidada)
+########################################
+# Autenticación
+# - authenticate_user
+# - authenticate_student
+# - authenticate_admin
+
+# Manejo de contraseñas
+# - hash_password
+# - verify_password
+
+# Manejo de usuarios
+# - register_student
+# - update_student_info
+# - delete_student
+
+# Interfaz de Gradio
+# - create_auth_interface
+# - create_user_page
+
+########################################
+# Funciones de Autenticación
+########################################
+
+def authenticate_user(username: str, password: str) -> tuple[bool, str | None]:
+    """
+    Autentica un usuario utilizando la base de datos.
+    """
+    try:
+        user = get_user(username)
+        if user and verify_password(user["password"], password):
+            logger.info(f"Usuario autenticado: {username}, Rol: {user['role']}")
+            return True, user["role"]
+        logger.warning(f"Credenciales incorrectas para el usuario: {username}")
+        return False, None
+    except Exception as e:
+        logger.error(f"Error autenticando al usuario {username}: {str(e)}")
+        return False, None
+
+def authenticate_student(username, password):
+    """Autentica a un estudiante."""
+    success, role = authenticate_user(username, password)
+    return (success, role) if role == "Estudiante" else (False, None)
+
+def authenticate_admin(username, password):
+    """Autentica a un administrador."""
+    success, role = authenticate_user(username, password)
+    return (success, role) if role == "Administrador" else (False, None)
+
+########################################
+# Registro y Manejo de Usuarios
+########################################
+
+def register_student(username: str, password: str, additional_info=None) -> bool:
+    """
+    Registra un nuevo estudiante.
+    """
+    try:
+        if get_student_user(username):
+            logger.warning(f"El estudiante {username} ya existe.")
+            return False
+
+        hashed_password = hash_password(password)
+        additional_info = additional_info or {}
+        additional_info["role"] = "Estudiante"
+
+        create_student_user(username, hashed_password, additional_info)
+        logger.info(f"Estudiante registrado: {username}")
+        return True
+    except Exception as e:
+        logger.error(f"Error registrando al estudiante {username}: {str(e)}")
+        return False
 
-# Verificar las variables de entorno
-endpoint = os.getenv("COSMOS_ENDPOINT")
-key = os.getenv("COSMOS_KEY")
+def update_student_info(username: str, new_info: dict) -> bool:
+    """
+    Actualiza la información de un estudiante.
+    """
+    try:
+        if "password" in new_info:
+            new_info["password"] = hash_password(new_info["password"])
+        return update_student_user(username, new_info)
+    except Exception as e:
+        logger.error(f"Error actualizando información del estudiante {username}: {str(e)}")
+        return False
+
+def delete_student(username: str) -> bool:
+    """
+    Elimina un estudiante de la base de datos.
+    """
+    try:
+        return delete_student_user(username)
+    except Exception as e:
+        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
+        return False
 
-if not endpoint or not key:
-    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+########################################
+# Manejo de Contraseñas
+########################################
 
-key = clean_and_validate_key(key)
+def hash_password(password: str) -> str:
+    """Hashea una contraseña utilizando bcrypt."""
+    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
 
+def verify_password(stored_password: str, provided_password: str) -> bool:
+    """Verifica que una contraseña coincida con su hash."""
+    return bcrypt.checkpw(provided_password.encode("utf-8"), stored_password.encode("utf-8"))
 
+########################################
+# Interfaz Gradio para Login
+########################################
 
-##################################################################
 def create_auth_interface():
-    """Crea la interfaz de autenticación."""
+    """
+    Crea la interfaz de autenticación.
+    """
     with gr.Blocks() as auth_interface:
         gr.Markdown("# Login")
         username = gr.Textbox(label="Usuario")
@@ -61,120 +172,46 @@ def create_auth_interface():
         login_btn.click(fn=handle_login, inputs=[username, password], outputs=message)
     return auth_interface
 
-######################################################################################
-def authenticate_student(username, password):
-    """Autentica un estudiante"""
-    success, role = authenticate_user(username, password)
-    if success and role == 'Estudiante':
-        return True, role
-    return False, None
+########################################
+# Página de Usuario
+########################################
 
-def authenticate_admin(username, password):
-    """Autentica un administrador"""
-    success, role = authenticate_user(username, password)
-    if success and role == 'Administrador':
-        return True, role
-    return False, None
+def create_user_page():
+    """
+    Crea una página de usuario simple tras el inicio de sesión.
+    """
+    with gr.Blocks() as user_page:
+        gr.Markdown("# Bienvenido a la Página de Usuario")
+        gr.Markdown("Esta página está disponible después de un inicio de sesión exitoso.")
 
-def register_student(username, password, additional_info=None):
-    """Registra un nuevo estudiante"""
-    try:
-        if get_student_user(username):
-            logger.warning(f"Estudiante ya existe: {username}")
-            return False
+        username = gr.Textbox(label="Usuario", interactive=False)
+        role = gr.Textbox(label="Rol", interactive=False)
 
-        hashed_password = hash_password(password)
-        
-        # Asegurarse que additional_info tenga el rol correcto
-        if not additional_info:
-            additional_info = {}
-        additional_info['role'] = 'Estudiante'
-        
-        success = create_student_user(username, hashed_password, additional_info)
-        if success:
-            logger.info(f"Nuevo estudiante registrado: {username}")
-            return True
-            
-        logger.error(f"Error al crear estudiante: {username}")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error al registrar estudiante: {str(e)}")
-        return False
+        def load_user_info():
+            return "UsuarioPrueba", "Estudiante"  # Simula datos de sesión
 
-def update_student_info(username, new_info):
-    """Actualiza la información de un estudiante"""
-    try:
-        if 'password' in new_info:
-            new_info['password'] = hash_password(new_info['password'])
-            
-        success = update_student_user(username, new_info)
-        if success:
-            logger.info(f"Información actualizada: {username}")
-            return True
-            
-        logger.error(f"Error al actualizar: {username}")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error en actualización: {str(e)}")
-        return False
+        user_page.load(fn=load_user_info, inputs=[], outputs=[username, role])
 
-def delete_student(username):
-    """Elimina un estudiante"""
-    try:
-        success = delete_student_user(username)
-        if success:
-            logger.info(f"Estudiante eliminado: {username}")
-            return True
-            
-        logger.error(f"Error al eliminar: {username}")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error en eliminación: {str(e)}")
-        return False
+        gr.Button("Cerrar Sesión").click(
+            fn=lambda: "Sesión cerrada",
+            inputs=[],
+            outputs=[user_page]
+        )
+    return user_page
 
-def logout():
-    """Cierra la sesión del usuario"""
-    try:
-        if 'session_id' in st.session_state and 'username' in st.session_state:
-            success = record_logout(
-                st.session_state.username, 
-                st.session_state.session_id
-            )
-            if success:
-                logger.info(f"Sesión cerrada: {st.session_state.username}")
-            else:
-                logger.warning(f"Error al registrar cierre de sesión: {st.session_state.username}")
-        
-    except Exception as e:
-        logger.error(f"Error en logout: {str(e)}")
-    finally:
-        st.session_state.clear()
-
-def hash_password(password):
-    """Hashea una contraseña"""
-    return bcrypt.hashpw(
-        password.encode('utf-8'), 
-        bcrypt.gensalt()
-    ).decode('utf-8')
-
-def verify_password(stored_password, provided_password):
-    """Verifica una contraseña"""
-    return bcrypt.checkpw(
-        provided_password.encode('utf-8'), 
-        stored_password.encode('utf-8')
-    )
+########################################
+# Exportar Funciones
+########################################
 
 __all__ = [
-    'create_auth_interface', # por 'authenticate_user',
-    'authenticate_admin',
-    'authenticate_student',
-    'register_student',
-    'update_student_info',
-    'delete_student',
-    'logout',
-    'hash_password',
-    'verify_password'
+    "create_auth_interface",
+    "create_user_page",
+    "register_student",
+    "authenticate_user",
+    "authenticate_student",
+    "authenticate_admin",
+    "update_student_info",
+    "delete_student",
+    "hash_password",
+    "verify_password",
 ]