Update modules/auth/auth.py

modules/auth/auth.py

@@ -1,13 +1,14 @@
+#/modules/auth/auth.py
 import gradio as gr
 import os
 from azure.cosmos import CosmosClient, exceptions
+from azure.cosmos.exceptions import CosmosHttpResponseError
 import bcrypt
 import base64
-import logging
-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,
@@ -15,16 +16,12 @@ from ..database.sql_db import (
     record_logout
 )
 
-logger = logging.getLogger(__name__)
+import logging
 
-# Verificar las variables de entorno
-COSMOS_ENDPOINT = os.getenv("COSMOS_ENDPOINT")
-COSMOS_KEY = os.getenv("COSMOS_KEY")
+from datetime import datetime, timezone
 
-if not COSMOS_ENDPOINT or not COSMOS_KEY:
-    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY no están configuradas.")
+logger = logging.getLogger(__name__)
 
-# Inicializar el cliente de Cosmos DB
 def clean_and_validate_key(key):
     """Limpia y valida la clave de CosmosDB"""
     key = key.strip()
@@ -33,97 +30,23 @@ def clean_and_validate_key(key):
     try:
         base64.b64decode(key)
         return key
-    except Exception:
+    except:
         raise ValueError("La clave proporcionada no es válida")
 
-COSMOS_KEY = clean_and_validate_key(COSMOS_KEY)
-cosmos_client = CosmosClient(COSMOS_ENDPOINT, COSMOS_KEY)
-
-########################################
-# Funciones de autenticación
-########################################
-
-def authenticate_user(username: str, password: str) -> tuple[bool, str | None]:
-    """
-    Autentica un usuario utilizando la base de datos.
-    Args:
-        username (str): Nombre de usuario.
-        password (str): Contraseña.
-    Returns:
-        tuple: (True, role) si la autenticación es exitosa; (False, None) en caso contrario.
-    """
-    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 register_student(username: str, password: str, additional_info=None) -> bool:
-    """
-    Registra un nuevo estudiante en la base de datos.
-    Args:
-        username (str): Nombre de usuario.
-        password (str): Contraseña.
-        additional_info (dict): Información adicional del estudiante.
-    Returns:
-        bool: True si el registro es exitoso, False en caso contrario.
-    """
-    try:
-        if get_student_user(username):
-            logger.warning(f"El estudiante {username} ya existe.")
-            return False
+# Verificar las variables de entorno
+endpoint = os.getenv("COSMOS_ENDPOINT")
+key = os.getenv("COSMOS_KEY")
 
-        hashed_password = hash_password(password)
-        additional_info = additional_info or {}
-        additional_info["role"] = "Estudiante"
+if not endpoint or not key:
+    raise ValueError("Las variables de entorno COSMOS_ENDPOINT y COSMOS_KEY deben estar configuradas")
+
+key = clean_and_validate_key(key)
 
-        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
 
-########################################
-# Funciones para manejo de contraseñas
-########################################
-
-def hash_password(password: str) -> str:
-    """
-    Hashea una contraseña utilizando bcrypt.
-    Args:
-        password (str): Contraseña en texto plano.
-    Returns:
-        str: Contraseña hasheada.
-    """
-    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.
-    Args:
-        stored_password (str): Contraseña almacenada (hash).
-        provided_password (str): Contraseña proporcionada por el usuario.
-    Returns:
-        bool: True si coinciden, False en caso contrario.
-    """
-    return bcrypt.checkpw(provided_password.encode("utf-8"), stored_password.encode("utf-8"))
-
-########################################
-# Interfaz de autenticación
-########################################
 
+##################################################################
 def create_auth_interface():
-    """
-    Crea la interfaz de autenticación utilizando Gradio.
-    Returns:
-        gr.Blocks: Interfaz Gradio para el login.
-    """
+    """Crea la interfaz de autenticación."""
     with gr.Blocks() as auth_interface:
         gr.Markdown("# Login")
         username = gr.Textbox(label="Usuario")
@@ -133,52 +56,125 @@ def create_auth_interface():
 
         def handle_login(user, pwd):
             success, role = authenticate_user(user, pwd)
-            if success:
-                return f"Bienvenido, {user} ({role})"
-            return "Credenciales incorrectas."
+            return f"Bienvenido, {user} ({role})" if success else "Credenciales incorrectas."
 
         login_btn.click(fn=handle_login, inputs=[username, password], outputs=message)
     return auth_interface
 
-########################################
-# Página de usuario
-########################################
-
-def create_user_page():
-    """
-    Crea una página de usuario para mostrar información básica tras el login.
-    Returns:
-        gr.Blocks: Interfaz Gradio para la página del usuario.
-    """
-    with gr.Blocks() as user_page:
-        gr.Markdown("# Bienvenido a la User Page")
-        gr.Markdown("Esta página está disponible solo después de un inicio de sesión exitoso.")
-
-        username = gr.Textbox(label="Usuario", interactive=False)
-        role = gr.Textbox(label="Rol", interactive=False)
+######################################################################################
+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
+
+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 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
 
-        def load_user_info():
-            # Aquí puedes utilizar un sistema de gestión de sesión (Gradio no tiene uno nativo)
-            return "UsuarioPrueba", "Estudiante"
+        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
 
-        user_page.load(fn=load_user_info, inputs=[], outputs=[username, role])
+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
 
-        gr.Button("Cerrar Sesión").click(
-            fn=lambda: "Sesión cerrada",
-            inputs=[],
-            outputs=[user_page]
-        )
-    return user_page
+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
 
-########################################
-# Exportar funciones relevantes
-########################################
+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')
+    )
 
 __all__ = [
-    "create_auth_interface",
-    "create_user_page",
-    "register_student",
-    "hash_password",
-    "verify_password",
-    "authenticate_user"
+    'create_auth_interface', # por 'authenticate_user',
+    'authenticate_admin',
+    'authenticate_student',
+    'register_student',
+    'update_student_info',
+    'delete_student',
+    'logout',
+    'hash_password',
+    'verify_password'
 ]