Update modules/auth/auth.py

modules/auth/auth.py

@@ -1,5 +1,4 @@
 import os
-import streamlit as st
 from azure.cosmos import CosmosClient, exceptions
 from azure.cosmos.exceptions import CosmosHttpResponseError
 import bcrypt
@@ -8,19 +7,18 @@ from ..database.sql_db import (
     get_user,
     get_student_user,
     get_admin_user,
+    get_teacher_user,
     create_student_user,
     update_student_user,
-    delete_student_user,
-    record_login,
-    record_logout
+    delete_student_user
 )
+
 import logging
-from datetime import datetime, timezone
 
 logger = logging.getLogger(__name__)
 
+# ... (código de inicialización)
 def clean_and_validate_key(key):
-    """Limpia y valida la clave de CosmosDB"""
     key = key.strip()
     while len(key) % 4 != 0:
         key += '='
@@ -38,152 +36,84 @@ 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 un usuario y registra el inicio de sesión
-    """
     try:
-        # Primero intentar obtener usuario general
         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):
+        if user_item and 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"Contraseña incorrecta para usuario: {username}")
+        logger.warning(f"Autenticación fallida para el 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):
+    return authenticate_user(username, password)
+
 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
+    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 authenticate_teacher(username, password):
+    return authenticate_user(username, password)
 
+############################
 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
+            logger.warning(f"Intento de registro de estudiante existente: {username}")
+            return False  # El estudiante ya existe
 
-        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)
+        success = create_student_user(username, password, additional_info)
         if success:
             logger.info(f"Nuevo estudiante registrado: {username}")
             return True
-            
-        logger.error(f"Error al crear estudiante: {username}")
-        return False
-        
+        else:
+            logger.error(f"Error al registrar nuevo 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}")
+            logger.info(f"Información del estudiante actualizada: {username}")
             return True
-            
-        logger.error(f"Error al actualizar: {username}")
-        return False
-        
+        else:
+            logger.error(f"Error al actualizar información del estudiante: {username}")
+            return False
     except Exception as e:
-        logger.error(f"Error en actualización: {str(e)}")
+        logger.error(f"Error al actualizar información del estudiante: {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
-        
+        else:
+            logger.error(f"Error al eliminar estudiante: {username}")
+            return False
     except Exception as e:
-        logger.error(f"Error en eliminación: {str(e)}")
+        logger.error(f"Error al eliminar estudiante: {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:
-            record_logout(
-                st.session_state.username, 
-                st.session_state.session_id
-            )
-            logger.info(f"Sesión cerrada: {st.session_state.username}")
-            
-        st.session_state.clear()
-        
-    except Exception as e:
-        logger.error(f"Error en logout: {str(e)}")
-        st.session_state.clear()
+
+# ... (funciones de hash y verificación de contraseña)
 
 def hash_password(password):
-    """Hashea una contraseña"""
-    return bcrypt.hashpw(
-        password.encode('utf-8'), 
-        bcrypt.gensalt()
-    ).decode('utf-8')
+    """Hash a password for storing."""
+    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+##################################################################################33
 
 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'
-]
+    """Verify a stored password against one provided by user"""
+    return bcrypt.checkpw(provided_password.encode('utf-8'), stored_password.encode('utf-8'))
+#############################################################################