Merge branch #AIdeaText/v3' into 'AIdeaText/v4'

README.md

@@ -4,7 +4,7 @@ emoji: 👀
 colorFrom: blue
 colorTo: purple
 sdk: streamlit
-sdk_version: 1.40.0
+sdk_version: 1.40.1
 app_file: app.py
 pinned: true
 license: mit

modules/__init__.py

@@ -12,19 +12,22 @@ def load_auth_functions():
 def load_database_functions():
 
     from .database.database_init import (
-    initialize_database_connections
+    initialize_database_connections, 
+    get_container, 
+    get_mongodb
     )
 
+    # Importar funciones SQL
     from .database.sql_db import (
         create_student_user,
         get_student_user,
         update_student_user,
         delete_student_user,
         store_application_request,
-        store_student_feedback, 
-        record_login, 
-        record_logout, 
-        get_recent_sessions, 
+        store_student_feedback,
+        record_login,
+        record_logout,
+        get_recent_sessions,
         get_user_total_time
     )
     
@@ -64,6 +67,8 @@ def load_database_functions():
 
     return {
         'initialize_database_connections': initialize_database_connections,
+        'get_container': get_container,
+        'get_mongodb': get_mongodb,
         'create_student_user': create_student_user,
         'get_student_user': get_student_user,
         'update_student_user': update_student_user,

modules/admin/admin_ui.py

@@ -1,3 +1,5 @@
+#modules/admin/admin_ui.py
+
 import streamlit as st
 from datetime import datetime
 from ..database.sql_db import (

modules/auth/auth.py

@@ -1,3 +1,5 @@
+##########modules/auth/auth.py
+
 import os
 import streamlit as st
 from azure.cosmos import CosmosClient, exceptions
@@ -14,7 +16,9 @@ from ..database.sql_db import (
     record_login,
     record_logout
 )
+
 import logging
+
 from datetime import datetime, timezone
 
 logger = logging.getLogger(__name__)
@@ -39,12 +43,10 @@ if not endpoint or not key:
 
 key = clean_and_validate_key(key)
 
+
 def authenticate_user(username, password):
-    """
-    Autentica un usuario y registra el inicio de sesión
-    """
+    """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:
@@ -54,16 +56,18 @@ def authenticate_user(username, password):
         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.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)}")
-                # Continuar aunque falle el registro de sesión
-                
+            
             return True, user_item['role']
             
         logger.warning(f"Contraseña incorrecta para usuario: {username}")
@@ -150,16 +154,18 @@ def logout():
     """Cierra la sesión del usuario"""
     try:
         if 'session_id' in st.session_state and 'username' in st.session_state:
-            record_logout(
+            success = 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()
+            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):

modules/database/database_init.py

@@ -1,80 +1,116 @@
-import os
-import logging
-from azure.cosmos import CosmosClient
-from pymongo import MongoClient
-import certifi
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# Variables globales para Cosmos DB SQL API
-cosmos_client = None
-user_database = None
-user_container = None
-application_requests_container = None
-user_feedback_container = None
-
-# Variables globales para Cosmos DB MongoDB API
-mongo_client = None
-mongo_db = None
-
-def initialize_cosmos_sql_connection():
-    global cosmos_client, user_database, user_container, application_requests_container, user_feedback_container
-    try:
-        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
-        cosmos_key = os.environ.get("COSMOS_KEY")
-
-        if not cosmos_endpoint or not cosmos_key:
-            raise ValueError("COSMOS_ENDPOINT and COSMOS_KEY environment variables must be set")
-
-        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
-        user_database = cosmos_client.get_database_client("user_database")
-        user_container = user_database.get_container_client("users")
-        application_requests_container = user_database.get_container_client("application_requests")
-        user_feedback_container = user_database.get_container_client("user_feedback")
-
-        logger.info("Conexión a Cosmos DB SQL API exitosa")
-        return True
-    except Exception as e:
-        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}", exc_info=True)
-        return False
-
-def initialize_mongodb_connection():
-    global mongo_client, mongo_db
-    try:
-        cosmos_mongodb_connection_string = os.getenv("MONGODB_CONNECTION_STRING")
-        if not cosmos_mongodb_connection_string:
-            raise ValueError("MONGODB_CONNECTION_STRING environment variable is not set")
-
-        mongo_client = MongoClient(cosmos_mongodb_connection_string,
-                                   tls=True,
-                                   tlsCAFile=certifi.where(),
-                                   retryWrites=False,
-                                   serverSelectionTimeoutMS=5000,
-                                   connectTimeoutMS=10000,
-                                   socketTimeoutMS=10000)
-
-        mongo_client.admin.command('ping')
-
-        mongo_db = mongo_client['aideatext_db']
-
-        logger.info("Conexión a Cosmos DB MongoDB API exitosa")
-        return True
-    except Exception as e:
-        logger.error(f"Error al conectar con Cosmos DB MongoDB API: {str(e)}", exc_info=True)
-        return False
-
-def initialize_database_connections():
-    sql_success = initialize_cosmos_sql_connection()
-    mongodb_success = initialize_mongodb_connection()
-    return sql_success and mongodb_success
-
-def get_sql_containers():
-    if user_container is None or application_requests_container is None or user_feedback_container is None:
-        initialize_cosmos_sql_connection()
-    return user_container, application_requests_container, user_feedback_container
-
-def get_mongodb():
-    if mongo_db is None:
-        initialize_mongodb_connection()
+# 1. modules/database/database_init.py
+
+import os
+import logging
+from azure.cosmos import CosmosClient
+from pymongo import MongoClient
+import certifi
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Variables globales para Cosmos DB SQL API
+cosmos_client = None
+user_database = None
+user_container = None
+application_requests_container = None
+user_feedback_container = None
+user_sessions_container = None
+
+# Variables globales para Cosmos DB MongoDB API
+mongo_client = None
+mongo_db = None
+
+###################################################################
+def verify_container_partition_key(container, expected_path):
+    """Verifica la configuración de partition key de un contenedor"""
+    try:
+        container_props = container.read()
+        partition_key_paths = container_props['partitionKey']['paths']
+        logger.info(f"Container: {container.id}, Partition Key Paths: {partition_key_paths}")
+        return expected_path in partition_key_paths
+    except Exception as e:
+        logger.error(f"Error verificando partition key en {container.id}: {str(e)}")
+        return False
+
+###################################################################
+def get_container(container_name):
+    """Obtiene un contenedor específico"""
+    global user_container, user_sessions_container
+    
+    if not initialize_cosmos_sql_connection():
+        logger.error("No se pudo inicializar la conexión")
+        return None
+    
+    containers = {
+        "users": user_container,
+        "users_sessions": user_sessions_container
+    }
+    
+    return containers.get(container_name)
+
+###################################################################
+def initialize_cosmos_sql_connection():
+    """Inicializa la conexión a Cosmos DB SQL API"""
+    global cosmos_client, user_database, user_container, user_sessions_container
+
+    try:
+        if cosmos_client and user_database and user_container and user_sessions_container:
+            return True
+
+        cosmos_endpoint = os.environ.get("COSMOS_ENDPOINT")
+        cosmos_key = os.environ.get("COSMOS_KEY")
+        
+        if not cosmos_endpoint or not cosmos_key:
+            raise ValueError("COSMOS_ENDPOINT y COSMOS_KEY deben estar configurados")
+
+        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
+        user_database = cosmos_client.get_database_client("user_database")
+        
+        # Inicializar contenedores manteniendo la estructura existente
+        user_container = user_database.get_container_client("users")
+        user_sessions_container = user_database.get_container_client("users_sessions")
+        
+        logger.info("Conexión a Cosmos DB SQL API exitosa")
+        return True
+
+    except Exception as e:
+        logger.error(f"Error al conectar con Cosmos DB SQL API: {str(e)}")
+        return False
+        
+###################################################################
+def initialize_mongodb_connection():
+    """Inicializa la conexión a MongoDB"""
+    global mongo_client, mongo_db
+    try:
+        connection_string = os.getenv("MONGODB_CONNECTION_STRING")
+        if not connection_string:
+            raise ValueError("MONGODB_CONNECTION_STRING debe estar configurado")
+
+        mongo_client = MongoClient(
+            connection_string,
+            tls=True,
+            tlsCAFile=certifi.where(),
+            retryWrites=False,
+            serverSelectionTimeoutMS=5000,
+            connectTimeoutMS=10000,
+            socketTimeoutMS=10000
+        )
+        
+        mongo_db = mongo_client['aideatext_db']
+        return True
+    except Exception as e:
+        logger.error(f"Error conectando a MongoDB: {str(e)}")
+        return False
+
+###################################################################
+def initialize_database_connections():
+    """Inicializa todas las conexiones"""
+    return initialize_cosmos_sql_connection() and initialize_mongodb_connection()
+
+###################################################################
+def get_mongodb():
+    """Obtiene la conexión MongoDB"""
+    if mongo_db is None:
+        initialize_mongodb_connection()
     return mongo_db

modules/database/sql_db.py

@@ -1,6 +1,6 @@
 #modules/database/sql_db.py
 
-from .database_init import get_sql_containers
+from .database_init import get_container
 from datetime import datetime, timezone
 import logging
 import bcrypt
@@ -9,12 +9,15 @@ import uuid
 logger = logging.getLogger(__name__)
 
 def get_user(username, role=None):
-    user_container, _, _ = get_sql_containers()
+    container = get_container("users")
     try:
         query = f"SELECT * FROM c WHERE c.id = '{username}'"
         if role:
             query += f" AND c.role = '{role}'"
-        items = list(user_container.query_items(query=query, enable_cross_partition_query=True))
+        items = list(container.query_items(
+            query=query,
+            enable_cross_partition_query=True
+        ))
         return items[0] if items else None
     except Exception as e:
         logger.error(f"Error al obtener usuario {username}: {str(e)}")
@@ -30,19 +33,28 @@ def get_teacher_user(username):
     return get_user(username, role='Profesor')
 
 def create_user(username, password, role, additional_info=None):
-    user_container, _, _ = get_sql_containers()
+    """Crea un nuevo usuario"""
+    container = get_container("users")
+    if not container:
+        logger.error("No se pudo obtener el contenedor de usuarios")
+        return False
+        
     try:
-        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
         user_data = {
             'id': username,
-            'password': hashed_password,
+            'password': password,
             'role': role,
             'timestamp': datetime.now(timezone.utc).isoformat(),
             'additional_info': additional_info or {}
         }
-        user_container.create_item(body=user_data)
+        
+        container.create_item(
+            body=user_data,
+            partition_key=username
+        )
         logger.info(f"Usuario {role} creado: {username}")
         return True
+        
     except Exception as e:
         logger.error(f"Error al crear usuario {role}: {str(e)}")
         return False
@@ -58,32 +70,47 @@ def create_admin_user(username, password, additional_info=None):
 
 ############-- Funciones de control del tiempo de sesión ##################
 
+###########################################################
+
 def record_login(username):
     """Registra el inicio de sesión de un usuario"""
     try:
-        container = get_container("user_sessions")
+        container = get_container("users_sessions")
         if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
             return None
 
+        session_id = str(uuid.uuid4())
         session_doc = {
-            "id": str(uuid.uuid4()),
+            "id": session_id,
             "type": "session",
             "username": username,
             "loginTime": datetime.now(timezone.utc).isoformat(),
+            "additional_info": {},
+            # El campo para partition key debe estar en el documento
             "partitionKey": username
         }
 
-        result = container.create_item(body=session_doc)
-        return result['id']
+        # Crear el documento usando options
+        result = container.create_item(
+            body=session_doc,
+            enable_cross_partition_query=True
+        )
+        logger.info(f"Sesión {session_id} registrada para {username}")
+        return session_id
     except Exception as e:
         logger.error(f"Error registrando login: {str(e)}")
         return None
 
+
+###########################################################
+
 def record_logout(username, session_id):
     """Registra el cierre de sesión y calcula la duración"""
     try:
-        container = get_container("user_sessions")
+        container = get_container("users_sessions")
         if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
             return False
 
         # Obtener la sesión actual
@@ -93,65 +120,88 @@ def record_logout(username, session_id):
             {"name": "@username", "value": username}
         ]
         
-        sessions = list(container.query_items(
+        items = list(container.query_items(
             query=query,
             parameters=params,
             enable_cross_partition_query=True
         ))
 
-        if not sessions:
+        if not items:
+            logger.warning(f"Sesión no encontrada: {session_id}")
             return False
 
-        session = sessions[0]
+        session = items[0]
         login_time = datetime.fromisoformat(session['loginTime'].rstrip('Z'))
         logout_time = datetime.now(timezone.utc)
         duration = int((logout_time - login_time).total_seconds())
 
-        # Actualizar el documento
         session.update({
             "logoutTime": logout_time.isoformat(),
             "sessionDuration": duration
         })
 
-        container.upsert_item(body=session)
+        # Actualizar el documento
+        container.upsert_item(
+            body=session
+        )
+        logger.info(f"Sesión {session_id} cerrada para {username}, duración: {duration}s")
         return True
     except Exception as e:
         logger.error(f"Error registrando logout: {str(e)}")
         return False
 
+
+###########################################################
+
 def get_recent_sessions(limit=10):
     """Obtiene las sesiones más recientes"""
     try:
-        container = get_container("user_sessions")
+        container = get_container("users_sessions")
         if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
             return []
 
         query = """
         SELECT c.username, c.loginTime, c.logoutTime, c.sessionDuration
         FROM c
         WHERE c.type = 'session'
-        AND c.logoutTime != null
         ORDER BY c.loginTime DESC
         OFFSET 0 LIMIT @limit
         """
         
-        params = [{"name": "@limit", "value": limit}]
-        
-        sessions = container.query_items(
+        sessions = list(container.query_items(
             query=query,
-            parameters=params,
+            parameters=[{"name": "@limit", "value": limit}],
             enable_cross_partition_query=True
-        )
+        ))
+
+        # Validar y limpiar los datos
+        clean_sessions = []
+        for session in sessions:
+            try:
+                clean_sessions.append({
+                    "username": session["username"],
+                    "loginTime": session["loginTime"],
+                    "logoutTime": session.get("logoutTime", "Activo"),
+                    "sessionDuration": session.get("sessionDuration", 0)
+                })
+            except KeyError as e:
+                logger.warning(f"Sesión con datos incompletos: {e}")
+                continue
 
-        return list(sessions)
+        return clean_sessions
     except Exception as e:
         logger.error(f"Error obteniendo sesiones recientes: {str(e)}")
         return []
 
+
+
+###########################################################
+
 def get_user_total_time(username):
     """Obtiene el tiempo total que un usuario ha pasado en la plataforma"""
     try:
-        container = get_container("user_sessions")
+        container = get_container("users_sessions")
         if not container:
             return None
 
@@ -160,21 +210,19 @@ def get_user_total_time(username):
         FROM c
         WHERE c.type = 'session'
         AND c.username = @username
-        AND c.logoutTime != null
+        AND IS_DEFINED(c.sessionDuration)
         """
         
-        params = [{"name": "@username", "value": username}]
-        
         result = list(container.query_items(
             query=query,
-            parameters=params,
+            parameters=[{"name": "@username", "value": username}],
             enable_cross_partition_query=True
         ))
 
-        return result[0] if result else 0
+        return result[0] if result and result[0] is not None else 0
     except Exception as e:
         logger.error(f"Error obteniendo tiempo total: {str(e)}")
-        return None
+        return 0
 
 ###########################################################
 def update_student_user(username, new_info):