Update modules/auth/auth.py

modules/auth/auth.py

@@ -1,33 +1,197 @@
 #/modules/auth/auth.py
 
+##########modules/auth/auth.py
+
+import os
+import streamlit as st
+from azure.cosmos import CosmosClient, exceptions
+from azure.cosmos.exceptions import CosmosHttpResponseError
 import bcrypt
-from modules.database.sql_db import get_user, create_user
-import gradio as gr
+import base64
+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
+)
+
+import logging
+
+from datetime import datetime, timezone
+
+logger = logging.getLogger(__name__)
+
+def clean_and_validate_key(key):
+    """Limpia y valida la clave de CosmosDB"""
+    key = key.strip()
+    while len(key) % 4 != 0:
+        key += '='
+    try:
+        base64.b64decode(key)
+        return key
+    except:
+        raise ValueError("La clave proporcionada no es válida")
+
+# Verificar las variables de entorno
+endpoint = os.getenv("COSMOS_ENDPOINT")
+key = os.getenv("COSMOS_KEY")
+
+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)
+
 
 def authenticate_user(username, password):
-    """Autentica a un usuario."""
-    user = get_user(username)
-    if user and bcrypt.checkpw(password.encode('utf-8'), user['password'].encode('utf-8')):
-        return True, user['role']
+    """Autentica un usuario y registra el inicio de sesión"""
+    try:
+        user_item = get_user(username)
+        
+        if not user_item:
+            logger.warning(f"Usuario no encontrado: {username}")
+            return False, None
+            
+        if verify_password(user_item['password'], password):
+            logger.info(f"Usuario autenticado: {username}, Rol: {user_item['role']}")
+            
+            try:
+                session_id = record_login(username)
+                if session_id:
+                    st.session_state.session_id = session_id
+                    st.session_state.username = username
+                    st.session_state.login_time = datetime.now(timezone.utc).isoformat()
+                    logger.info(f"Sesión iniciada: {session_id}")
+                else:
+                    logger.warning("No se pudo registrar la sesión")
+            except Exception as e:
+                logger.error(f"Error al registrar inicio de sesión: {str(e)}")
+            
+            return True, user_item['role']
+            
+        logger.warning(f"Contraseña incorrecta para usuario: {username}")
+        return False, None
+        
+    except Exception as e:
+        logger.error(f"Error durante la autenticación del usuario: {str(e)}")
+        return False, None
+
+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 register_user(username, password, role):
-    """Registra un nuevo usuario."""
-    hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
-    return create_user(username, hashed_password, role)
-
-def create_auth_interface():
-    """Crea la interfaz de autenticación."""
-    with gr.Blocks() as auth_interface:
-        gr.Markdown("# Login")
-        username = gr.Textbox(label="Usuario")
-        password = gr.Textbox(label="Contraseña", type="password")
-        login_btn = gr.Button("Iniciar Sesión")
-        message = gr.Markdown()
-
-        def handle_login(user, pwd):
-            success, role = authenticate_user(user, pwd)
-            return f"Bienvenido, {user} ({role})" if success else "Credenciales incorrectas."
-
-        login_btn.click(fn=handle_login, inputs=[username, password], outputs=message)
-    return auth_interface
+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
+
+        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 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
+
+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
+
+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__ = [
+    'authenticate_user',
+    'authenticate_admin',
+    'authenticate_student',
+    'register_student',
+    'update_student_info',
+    'delete_student',
+    'logout',
+    'hash_password',
+    'verify_password'
+]