Update modules/auth/auth.py

modules/auth/auth.py

@@ -4,6 +4,16 @@ from azure.cosmos import CosmosClient, exceptions
 from azure.cosmos.exceptions import CosmosHttpResponseError
 import bcrypt
 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
 
@@ -34,140 +44,142 @@ def authenticate_user(username, password):
     Autentica un usuario y registra el inicio de sesión
     """
     try:
+        # Primero intentar obtener usuario general
         user_item = get_user(username)
-        if user_item and verify_password(user_item['password'], password):
-            logger.info(f"Usuario autenticado: {username}, Rol: {user_item['role']}")
+        
+        if not user_item:
+            logger.warning(f"Usuario no encontrado: {username}")
+            return False, None
             
-            # Registrar inicio de sesión
-            session_id = record_login(username)
-            if session_id:
-                st.session_state.session_id = session_id
-                st.session_state.login_time = datetime.now(timezone.utc).isoformat()
+        if verify_password(user_item['password'], password):
+            logger.info(f"Usuario autenticado: {username}, Rol: {user_item['role']}")
             
+            # Registrar la sesión
+            try:
+                session_id = record_login(username)
+                if session_id:
+                    st.session_state.session_id = session_id
+                    st.session_state.login_time = datetime.now(timezone.utc).isoformat()
+            except Exception as e:
+                logger.error(f"Error al registrar inicio de sesión: {str(e)}")
+                # Continuar aunque falle el registro de sesión
+                
             return True, user_item['role']
             
-        logger.warning(f"Autenticación fallida para el usuario: {username}")
+        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_admin(username, password):
-    """Autentica un administrador"""
-    return authenticate_user(username, password)
-
 def authenticate_student(username, password):
     """Autentica un estudiante"""
-    return authenticate_user(username, password)
+    success, role = authenticate_user(username, password)
+    if success and role == 'Estudiante':
+        return True, role
+    return False, None
 
-def authenticate_teacher(username, password):
-    """Autentica un profesor"""
-    return authenticate_user(username, password)
+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
-    """
+    """Registra un nuevo estudiante"""
     try:
         if get_student_user(username):
-            logger.warning(f"Intento de registro de estudiante existente: {username}")
+            logger.warning(f"Estudiante ya existe: {username}")
             return False
 
-        # Hash de la contraseña antes de almacenar
         hashed_password = hash_password(password)
-        success = create_student_user(username, hashed_password, additional_info)
         
+        # 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
-        else:
-            logger.error(f"Error al registrar nuevo estudiante: {username}")
-            return False
+            
+        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
-    """
+    """Actualiza la información de un estudiante"""
     try:
-        # Si hay contraseña en new_info, hashearla
         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 del estudiante actualizada: {username}")
+            logger.info(f"Información actualizada: {username}")
             return True
-        else:
-            logger.error(f"Error al actualizar información del estudiante: {username}")
-            return False
+            
+        logger.error(f"Error al actualizar: {username}")
+        return False
+        
     except Exception as e:
-        logger.error(f"Error al actualizar información del estudiante: {str(e)}")
+        logger.error(f"Error en actualización: {str(e)}")
         return False
 
 def delete_student(username):
-    """
-    Elimina un estudiante
-    """
+    """Elimina un estudiante"""
     try:
         success = delete_student_user(username)
         if success:
             logger.info(f"Estudiante eliminado: {username}")
             return True
-        else:
-            logger.error(f"Error al eliminar estudiante: {username}")
-            return False
+            
+        logger.error(f"Error al eliminar: {username}")
+        return False
+        
     except Exception as e:
-        logger.error(f"Error al eliminar estudiante: {str(e)}")
+        logger.error(f"Error en eliminación: {str(e)}")
         return False
 
 def logout():
-    """
-    Cierra la sesión del usuario y registra el tiempo
-    """
+    """Cierra la sesión del usuario"""
     try:
         if 'session_id' in st.session_state and 'username' in st.session_state:
-            # Registrar el cierre de sesión
             record_logout(
                 st.session_state.username, 
                 st.session_state.session_id
             )
-            logger.info(f"Sesión cerrada para el usuario: {st.session_state.username}")
-        
-        # Limpiar el estado de la sesión
+            logger.info(f"Sesión cerrada: {st.session_state.username}")
+            
         st.session_state.clear()
         
     except Exception as e:
-        logger.error(f"Error durante el logout: {str(e)}")
-        # Asegurar que la sesión se limpie incluso si hay error
+        logger.error(f"Error en logout: {str(e)}")
         st.session_state.clear()
 
 def hash_password(password):
-    """
-    Hashea una contraseña para almacenamiento
-    """
+    """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 almacenada contra una proporcionada
-    """
+    """Verifica una contraseña"""
     return bcrypt.checkpw(
         provided_password.encode('utf-8'), 
         stored_password.encode('utf-8')
     )
 
-# Asegurarse de exportar todas las funciones necesarias
 __all__ = [
     'authenticate_user',
     'authenticate_admin',
     'authenticate_student',
-    'authenticate_teacher',
     'register_student',
     'update_student_info',
     'delete_student',