Upload 16 files

modules/database/chat_mongo_db.py

@@ -1,116 +1,116 @@
-# /modules/database/chat_mongo_db.py
-from .mongo_db import insert_document, find_documents, get_collection
-from datetime import datetime, timezone
-import logging
-
-logger = logging.getLogger(__name__)
-COLLECTION_NAME = 'chat_history-v3'
-
-def get_chat_history(username: str, analysis_type: str = 'sidebar', limit: int = None) -> list:
-    """
-    Recupera el historial del chat.
-    
-    Args:
-        username: Nombre del usuario
-        analysis_type: Tipo de análisis ('sidebar' por defecto)
-        limit: Límite de conversaciones a recuperar
-        
-    Returns:
-        list: Lista de conversaciones con formato
-    """
-    try:
-        query = {
-            "username": username,
-            "analysis_type": analysis_type
-        }
-        
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección de chat")
-            return []
-            
-        # Obtener y formatear conversaciones
-        cursor = collection.find(query).sort("timestamp", -1)
-        if limit:
-            cursor = cursor.limit(limit)
-            
-        conversations = []
-        for chat in cursor:
-            try:
-                formatted_chat = {
-                    'timestamp': chat['timestamp'],
-                    'messages': [
-                        {
-                            'role': msg.get('role', 'unknown'),
-                            'content': msg.get('content', '')
-                        }
-                        for msg in chat.get('messages', [])
-                    ]
-                }
-                conversations.append(formatted_chat)
-            except Exception as e:
-                logger.error(f"Error formateando chat: {str(e)}")
-                continue
-                
-        return conversations
-        
-    except Exception as e:
-        logger.error(f"Error al recuperar historial de chat: {str(e)}")
-        return []
-
-def store_chat_history(username: str, messages: list, analysis_type: str = 'sidebar') -> bool:
-    """
-    Guarda el historial del chat.
-    
-    Args:
-        username: Nombre del usuario
-        messages: Lista de mensajes a guardar
-        analysis_type: Tipo de análisis
-    
-    Returns:
-        bool: True si se guardó correctamente
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección de chat")
-            return False
-            
-        # Formatear mensajes antes de guardar
-        formatted_messages = [
-            {
-                'role': msg.get('role', 'unknown'),
-                'content': msg.get('content', ''),
-                'timestamp': datetime.now(timezone.utc).isoformat()
-            }
-            for msg in messages
-        ]
-        
-        chat_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'messages': formatted_messages,
-            'analysis_type': analysis_type
-        }
-        
-        result = collection.insert_one(chat_document)
-        if result.inserted_id:
-            logger.info(f"Historial de chat guardado con ID: {result.inserted_id} para el usuario: {username}")
-            return True
-            
-        logger.error("No se pudo insertar el documento")
-        return False
-        
-    except Exception as e:
-        logger.error(f"Error al guardar historial de chat: {str(e)}")
-        return False
-        
-        
-        #def get_chat_history(username, analysis_type=None, limit=10):
-#    query = {"username": username}
-#    if analysis_type:
-#        query["analysis_type"] = analysis_type
-
-#    return find_documents(COLLECTION_NAME, query, sort=[("timestamp", -1)], limit=limit)
-
+# /modules/database/chat_mongo_db.py
+from .mongo_db import insert_document, find_documents, get_collection
+from datetime import datetime, timezone
+import logging
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'chat_history-v3'
+
+def get_chat_history(username: str, analysis_type: str = 'sidebar', limit: int = None) -> list:
+    """
+    Recupera el historial del chat.
+    
+    Args:
+        username: Nombre del usuario
+        analysis_type: Tipo de análisis ('sidebar' por defecto)
+        limit: Límite de conversaciones a recuperar
+        
+    Returns:
+        list: Lista de conversaciones con formato
+    """
+    try:
+        query = {
+            "username": username,
+            "analysis_type": analysis_type
+        }
+        
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de chat")
+            return []
+            
+        # Obtener y formatear conversaciones
+        cursor = collection.find(query).sort("timestamp", -1)
+        if limit:
+            cursor = cursor.limit(limit)
+            
+        conversations = []
+        for chat in cursor:
+            try:
+                formatted_chat = {
+                    'timestamp': chat['timestamp'],
+                    'messages': [
+                        {
+                            'role': msg.get('role', 'unknown'),
+                            'content': msg.get('content', '')
+                        }
+                        for msg in chat.get('messages', [])
+                    ]
+                }
+                conversations.append(formatted_chat)
+            except Exception as e:
+                logger.error(f"Error formateando chat: {str(e)}")
+                continue
+                
+        return conversations
+        
+    except Exception as e:
+        logger.error(f"Error al recuperar historial de chat: {str(e)}")
+        return []
+
+def store_chat_history(username: str, messages: list, analysis_type: str = 'sidebar') -> bool:
+    """
+    Guarda el historial del chat.
+    
+    Args:
+        username: Nombre del usuario
+        messages: Lista de mensajes a guardar
+        analysis_type: Tipo de análisis
+    
+    Returns:
+        bool: True si se guardó correctamente
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de chat")
+            return False
+            
+        # Formatear mensajes antes de guardar
+        formatted_messages = [
+            {
+                'role': msg.get('role', 'unknown'),
+                'content': msg.get('content', ''),
+                'timestamp': datetime.now(timezone.utc).isoformat()
+            }
+            for msg in messages
+        ]
+        
+        chat_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'messages': formatted_messages,
+            'analysis_type': analysis_type
+        }
+        
+        result = collection.insert_one(chat_document)
+        if result.inserted_id:
+            logger.info(f"Historial de chat guardado con ID: {result.inserted_id} para el usuario: {username}")
+            return True
+            
+        logger.error("No se pudo insertar el documento")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error al guardar historial de chat: {str(e)}")
+        return False
+        
+        
+        #def get_chat_history(username, analysis_type=None, limit=10):
+#    query = {"username": username}
+#    if analysis_type:
+#        query["analysis_type"] = analysis_type
+
+#    return find_documents(COLLECTION_NAME, query, sort=[("timestamp", -1)], limit=limit)
+
 # Agregar funciones para actualizar y eliminar chat si es necesario

modules/database/claude_recommendations_mongo_db.py

@@ -0,0 +1,137 @@
+# modules/database/claude_recommendations_mongo_db.py
+from datetime import datetime, timezone, timedelta
+import logging
+from .mongo_db import get_collection
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'student_claude_recommendations'
+
+def store_claude_recommendation(username, text, metrics, text_type, recommendations):
+    """
+    Guarda las recomendaciones generadas por Claude AI.
+    
+    Args:
+        username: Nombre del usuario
+        text: Texto analizado
+        metrics: Métricas del análisis
+        text_type: Tipo de texto (academic_article, university_work, general_communication)
+        recommendations: Recomendaciones generadas por Claude
+        
+    Returns:
+        bool: True si se guardó correctamente, False en caso contrario
+    """
+    try:
+        # Verificar parámetros
+        if not all([username, text, recommendations]):
+            logger.error("Faltan parámetros requeridos para guardar recomendaciones de Claude")
+            return False
+            
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de recomendaciones de Claude")
+            return False
+            
+        # Crear documento
+        document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'metrics': metrics or {},
+            'text_type': text_type,
+            'recommendations': recommendations,
+            'analysis_type': 'claude_recommendation'
+        }
+        
+        # Insertar documento
+        result = collection.insert_one(document)
+        if result.inserted_id:
+            logger.info(f"""
+                Recomendaciones de Claude guardadas:
+                - Usuario: {username}
+                - ID: {result.inserted_id}
+                - Tipo de texto: {text_type}
+                - Longitud del texto: {len(text)}
+            """)
+            
+            # Verificar almacenamiento
+            storage_verified = verify_recommendation_storage(username)
+            if not storage_verified:
+                logger.warning("Verificación de almacenamiento de recomendaciones falló")
+            
+            return True
+            
+        logger.error("No se pudo insertar el documento de recomendaciones")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error guardando recomendaciones de Claude: {str(e)}")
+        return False
+
+def verify_recommendation_storage(username):
+    """
+    Verifica que las recomendaciones se están guardando correctamente.
+    
+    Args:
+        username: Nombre del usuario
+        
+    Returns:
+        bool: True si la verificación es exitosa, False en caso contrario
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección para verificación de recomendaciones")
+            return False
+            
+        # Buscar documentos recientes del usuario
+        timestamp_threshold = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
+        recent_docs = collection.find({
+            'username': username,
+            'timestamp': {'$gte': timestamp_threshold}
+        }).sort('timestamp', -1).limit(1)
+        
+        docs = list(recent_docs)
+        if docs:
+            logger.info(f"""
+                Último documento de recomendaciones guardado:
+                - ID: {docs[0]['_id']}
+                - Timestamp: {docs[0]['timestamp']}
+                - Tipo de texto: {docs[0].get('text_type', 'N/A')}
+            """)
+            return True
+            
+        logger.warning(f"No se encontraron documentos recientes de recomendaciones para {username}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error verificando almacenamiento de recomendaciones: {str(e)}")
+        return False
+
+def get_claude_recommendations(username, limit=10):
+    """
+    Obtiene las recomendaciones más recientes de Claude para un usuario.
+    
+    Args:
+        username: Nombre del usuario
+        limit: Número máximo de recomendaciones a recuperar
+        
+    Returns:
+        list: Lista de recomendaciones
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección de recomendaciones")
+            return []
+            
+        results = collection.find(
+            {'username': username}
+        ).sort('timestamp', -1).limit(limit)
+        
+        recommendations = list(results)
+        logger.info(f"Recuperadas {len(recommendations)} recomendaciones de Claude para {username}")
+        return recommendations
+        
+    except Exception as e:
+        logger.error(f"Error obteniendo recomendaciones de Claude: {str(e)}")
+        return []

modules/database/current_situation_mongo_db.py

@@ -1,112 +1,137 @@
-# modules/database/current_situation_mongo_db.py
-from datetime import datetime, timezone, timedelta
-import logging
-from .mongo_db import get_collection
-
-logger = logging.getLogger(__name__)
-COLLECTION_NAME = 'student_current_situation'
-
-# En modules/database/current_situation_mongo_db.py
-
-def store_current_situation_result(username, text, metrics, feedback):
-    """
-    Guarda los resultados del análisis de situación actual.
-    """
-    try:
-        # Verificar parámetros
-        if not all([username, text, metrics]):
-            logger.error("Faltan parámetros requeridos")
-            return False
-
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección")
-            return False
-
-        # Crear documento
-        document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text': text,
-            'metrics': metrics,
-            'feedback': feedback or {},
-            'analysis_type': 'current_situation'
-        }
-
-        # Insertar documento y verificar
-        result = collection.insert_one(document)
-        if result.inserted_id:
-            logger.info(f"""
-                Análisis de situación actual guardado:
-                - Usuario: {username}
-                - ID: {result.inserted_id}
-                - Longitud texto: {len(text)}
-            """)
-            
-            # Verificar almacenamiento
-            storage_verified = verify_storage(username)
-            if not storage_verified:
-                logger.warning("Verificación de almacenamiento falló")
-            
-            return True
-
-        logger.error("No se pudo insertar el documento")
-        return False
-
-    except Exception as e:
-        logger.error(f"Error guardando análisis de situación actual: {str(e)}")
-        return False
-
-def verify_storage(username):
-    """
-    Verifica que los datos se están guardando correctamente.
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            logger.error("No se pudo obtener la colección para verificación")
-            return False
-            
-        # Buscar documentos recientes del usuario
-        timestamp_threshold = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
-        
-        recent_docs = collection.find({
-            'username': username,
-            'timestamp': {'$gte': timestamp_threshold}
-        }).sort('timestamp', -1).limit(1)
-
-        docs = list(recent_docs)
-        if docs:
-            logger.info(f"""
-                Último documento guardado:
-                - ID: {docs[0]['_id']}
-                - Timestamp: {docs[0]['timestamp']}
-                - Métricas guardadas: {bool(docs[0].get('metrics'))}
-            """)
-            return True
-        
-        logger.warning(f"No se encontraron documentos recientes para {username}")
-        return False
-
-    except Exception as e:
-        logger.error(f"Error verificando almacenamiento: {str(e)}")
-        return False
-
-def get_recent_situation_analysis(username, limit=5):
-    """
-    Obtiene los análisis más recientes de un usuario.
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:
-            return []
-            
-        results = collection.find(
-            {'username': username}
-        ).sort('timestamp', -1).limit(limit)
-        
-        return list(results)
-        
-    except Exception as e:
-        logger.error(f"Error obteniendo análisis recientes: {str(e)}")
+# modules/database/current_situation_mongo_db.py
+from datetime import datetime, timezone, timedelta
+import logging
+from .mongo_db import get_collection
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'student_current_situation'
+
+# En modules/database/current_situation_mongo_db.py
+
+def store_current_situation_result(username, text, metrics, feedback):
+    """
+    Guarda los resultados del análisis de situación actual.
+    """
+    try:
+        # Verificar parámetros
+        if not all([username, text, metrics]):
+            logger.error("Faltan parámetros requeridos")
+            return False
+
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección")
+            return False
+
+        # Crear documento
+        document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'metrics': metrics,
+            'feedback': feedback or {},
+            'analysis_type': 'current_situation'
+        }
+
+        # Insertar documento y verificar
+        result = collection.insert_one(document)
+        if result.inserted_id:
+            logger.info(f"""
+                Análisis de situación actual guardado:
+                - Usuario: {username}
+                - ID: {result.inserted_id}
+                - Longitud texto: {len(text)}
+            """)
+            
+            # Verificar almacenamiento
+            storage_verified = verify_storage(username)
+            if not storage_verified:
+                logger.warning("Verificación de almacenamiento falló")
+            
+            return True
+
+        logger.error("No se pudo insertar el documento")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error guardando análisis de situación actual: {str(e)}")
+        return False
+
+def verify_storage(username):
+    """
+    Verifica que los datos se están guardando correctamente.
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección para verificación")
+            return False
+            
+        # Buscar documentos recientes del usuario
+        timestamp_threshold = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
+        
+        recent_docs = collection.find({
+            'username': username,
+            'timestamp': {'$gte': timestamp_threshold}
+        }).sort('timestamp', -1).limit(1)
+
+        docs = list(recent_docs)
+        if docs:
+            logger.info(f"""
+                Último documento guardado:
+                - ID: {docs[0]['_id']}
+                - Timestamp: {docs[0]['timestamp']}
+                - Métricas guardadas: {bool(docs[0].get('metrics'))}
+            """)
+            return True
+        
+        logger.warning(f"No se encontraron documentos recientes para {username}")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error verificando almacenamiento: {str(e)}")
+        return False
+
+def get_current_situation_analysis(username, limit=5):
+    """
+    Obtiene los análisis de situación actual de un usuario.
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            logger.error("No se pudo obtener la colección")
+            return []
+            
+        # Buscar documentos
+        query = {'username': username, 'analysis_type': 'current_situation'}
+        cursor = collection.find(query).sort('timestamp', -1)
+        
+        # Aplicar límite si se especifica
+        if limit:
+            cursor = cursor.limit(limit)
+            
+        # Convertir cursor a lista
+        return list(cursor)
+        
+    except Exception as e:
+        logger.error(f"Error obteniendo análisis de situación actual: {str(e)}")
+        return []
+
+def get_recent_situation_analysis(username, limit=5):
+    """
+    Obtiene los análisis más recientes de un usuario.
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:
+            return []
+            
+        results = collection.find(
+            {'username': username}
+        ).sort('timestamp', -1).limit(limit)
+        
+        return list(results)
+        
+    except Exception as e:
+        logger.error(f"Error obteniendo análisis recientes: {str(e)}")
         return []

modules/database/database_init.py

@@ -1,188 +1,188 @@
-# 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"""
-    logger.info(f"Solicitando contenedor: {container_name}")
-    
-    if not initialize_cosmos_sql_connection():
-        logger.error("No se pudo inicializar la conexión")
-        return None
-    
-    # Verificar estado de los contenedores
-    containers_status = {
-        "users": user_container is not None,
-        "users_sessions": user_sessions_container is not None,
-        "application_requests": application_requests_container is not None,
-        "user_feedback": user_feedback_container is not None  # Añadido
-    }
-    
-    logger.info(f"Estado actual de los contenedores: {containers_status}")
-    
-    # Mapear nombres a contenedores
-    containers = {
-        "users": user_container,
-        "users_sessions": user_sessions_container,
-        "application_requests": application_requests_container,
-        "user_feedback": user_feedback_container  # Añadido
-    }
-    
-    container = containers.get(container_name)
-    
-    if container is None:
-        logger.error(f"Contenedor '{container_name}' no encontrado o no inicializado")
-        logger.error(f"Contenedores disponibles: {[k for k, v in containers_status.items() if v]}")
-        return None
-        
-    logger.info(f"Contenedor '{container_name}' obtenido exitosamente")
-    return container
-###################################################################
-
-def initialize_cosmos_sql_connection():
-    """Inicializa la conexión a Cosmos DB SQL API"""
-    global cosmos_client, user_database, user_container, user_sessions_container, application_requests_container, user_feedback_container  # Añadida aquí user_feedback_container
-
-    try:
-        # Verificar conexión existente
-        if all([
-            cosmos_client,
-            user_database, 
-            user_container,
-            user_sessions_container,
-            application_requests_container,
-            user_feedback_container
-        ]):
-            logger.debug("Todas las conexiones ya están inicializadas")
-            return True
-
-        # Obtener credenciales
-        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")
-
-        # Inicializar cliente y base de datos
-        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
-        user_database = cosmos_client.get_database_client("user_database")
-        
-        # Inicializar contenedores
-        try:
-            user_container = user_database.get_container_client("users")
-            logger.info("Contenedor 'users' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'users': {str(e)}")
-            user_container = None
-
-        try:
-            user_sessions_container = user_database.get_container_client("users_sessions")
-            logger.info("Contenedor 'users_sessions' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'users_sessions': {str(e)}")
-            user_sessions_container = None
-
-        try:
-            application_requests_container = user_database.get_container_client("application_requests")
-            logger.info("Contenedor 'application_requests' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'application_requests': {str(e)}")
-            application_requests_container = None
-
-        try:
-            user_feedback_container = user_database.get_container_client("user_feedback")
-            logger.info("Contenedor 'user_feedback' inicializado correctamente")
-        except Exception as e:
-            logger.error(f"Error inicializando contenedor 'user_feedback': {str(e)}")
-            user_feedback_container = None
-
-        # Verificar el estado de los contenedores
-        containers_status = {
-            'users': user_container is not None,
-            'users_sessions': user_sessions_container is not None,
-            'application_requests': application_requests_container is not None,
-            'user_feedback': user_feedback_container is not None
-        }
-        
-        logger.info(f"Estado de los contenedores: {containers_status}")
-        
-        if all(containers_status.values()):
-            logger.info("Todos los contenedores inicializados correctamente")
-            return True
-        else:
-            logger.error("No se pudieron inicializar todos los contenedores")
-            return False
-
-    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()
+# 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"""
+    logger.info(f"Solicitando contenedor: {container_name}")
+    
+    if not initialize_cosmos_sql_connection():
+        logger.error("No se pudo inicializar la conexión")
+        return None
+    
+    # Verificar estado de los contenedores
+    containers_status = {
+        "users": user_container is not None,
+        "users_sessions": user_sessions_container is not None,
+        "application_requests": application_requests_container is not None,
+        "user_feedback": user_feedback_container is not None  # Añadido
+    }
+    
+    logger.info(f"Estado actual de los contenedores: {containers_status}")
+    
+    # Mapear nombres a contenedores
+    containers = {
+        "users": user_container,
+        "users_sessions": user_sessions_container,
+        "application_requests": application_requests_container,
+        "user_feedback": user_feedback_container  # Añadido
+    }
+    
+    container = containers.get(container_name)
+    
+    if container is None:
+        logger.error(f"Contenedor '{container_name}' no encontrado o no inicializado")
+        logger.error(f"Contenedores disponibles: {[k for k, v in containers_status.items() if v]}")
+        return None
+        
+    logger.info(f"Contenedor '{container_name}' obtenido exitosamente")
+    return container
+###################################################################
+
+def initialize_cosmos_sql_connection():
+    """Inicializa la conexión a Cosmos DB SQL API"""
+    global cosmos_client, user_database, user_container, user_sessions_container, application_requests_container, user_feedback_container  # Añadida aquí user_feedback_container
+
+    try:
+        # Verificar conexión existente
+        if all([
+            cosmos_client,
+            user_database, 
+            user_container,
+            user_sessions_container,
+            application_requests_container,
+            user_feedback_container
+        ]):
+            logger.debug("Todas las conexiones ya están inicializadas")
+            return True
+
+        # Obtener credenciales
+        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")
+
+        # Inicializar cliente y base de datos
+        cosmos_client = CosmosClient(cosmos_endpoint, cosmos_key)
+        user_database = cosmos_client.get_database_client("user_database")
+        
+        # Inicializar contenedores
+        try:
+            user_container = user_database.get_container_client("users")
+            logger.info("Contenedor 'users' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'users': {str(e)}")
+            user_container = None
+
+        try:
+            user_sessions_container = user_database.get_container_client("users_sessions")
+            logger.info("Contenedor 'users_sessions' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'users_sessions': {str(e)}")
+            user_sessions_container = None
+
+        try:
+            application_requests_container = user_database.get_container_client("application_requests")
+            logger.info("Contenedor 'application_requests' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'application_requests': {str(e)}")
+            application_requests_container = None
+
+        try:
+            user_feedback_container = user_database.get_container_client("user_feedback")
+            logger.info("Contenedor 'user_feedback' inicializado correctamente")
+        except Exception as e:
+            logger.error(f"Error inicializando contenedor 'user_feedback': {str(e)}")
+            user_feedback_container = None
+
+        # Verificar el estado de los contenedores
+        containers_status = {
+            'users': user_container is not None,
+            'users_sessions': user_sessions_container is not None,
+            'application_requests': application_requests_container is not None,
+            'user_feedback': user_feedback_container is not None
+        }
+        
+        logger.info(f"Estado de los contenedores: {containers_status}")
+        
+        if all(containers_status.values()):
+            logger.info("Todos los contenedores inicializados correctamente")
+            return True
+        else:
+            logger.error("No se pudieron inicializar todos los contenedores")
+            return False
+
+    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/discourse_mongo_db.py

@@ -1,173 +1,173 @@
-# modules/database/discourse_mongo_db.py
-# Importaciones estándar
-import io
-import base64
-from datetime import datetime, timezone
-import logging
-
-# Importaciones de terceros
-import matplotlib.pyplot as plt
-
-from .mongo_db import (
-    get_collection,
-    insert_document, 
-    find_documents, 
-    update_document, 
-    delete_document
-)
-
-# Configuración del logger
-logger = logging.getLogger(__name__)
-COLLECTION_NAME = 'student_discourse_analysis'
-
-########################################################################
-def store_student_discourse_result(username, text1, text2, analysis_result):
-    """
-    Guarda el resultado del análisis de discurso comparativo en MongoDB.
-    """
-    try:
-        # Los gráficos ya vienen en bytes, solo necesitamos codificar a base64
-        graph1_data = None
-        graph2_data = None
-        combined_graph_data = None
-
-        if 'graph1' in analysis_result and analysis_result['graph1'] is not None:
-            try:
-                graph1_data = base64.b64encode(analysis_result['graph1']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico 1: {str(e)}")
-
-        if 'graph2' in analysis_result and analysis_result['graph2'] is not None:
-            try:
-                graph2_data = base64.b64encode(analysis_result['graph2']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico 2: {str(e)}")
-
-        if 'combined_graph' in analysis_result and analysis_result['combined_graph'] is not None:
-            try:
-                combined_graph_data = base64.b64encode(analysis_result['combined_graph']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico combinado: {str(e)}")
-
-        # Crear documento para MongoDB
-        analysis_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text1': text1,
-            'text2': text2,
-            'analysis_type': 'discourse',
-            'key_concepts1': analysis_result.get('key_concepts1', []),
-            'key_concepts2': analysis_result.get('key_concepts2', []),
-            'graph1': graph1_data,
-            'graph2': graph2_data,
-            'combined_graph': combined_graph_data
-        }
-
-        # Insertar en MongoDB
-        result = insert_document(COLLECTION_NAME, analysis_document)
-        if result:
-            logger.info(f"Análisis del discurso guardado con ID: {result} para el usuario: {username}")
-            return True
-
-        logger.error("No se pudo insertar el documento en MongoDB")
-        return False
-
-    except Exception as e:
-        logger.error(f"Error al guardar el análisis del discurso: {str(e)}")
-        return False
-
-
-
-#################################################################################
-def get_student_discourse_analysis(username, limit=10):
-    """
-    Recupera los análisis del discurso de un estudiante.
-    """
-    try:
-        # Obtener la colección
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:  # Cambiado de if not collection a if collection is None
-            logger.error("No se pudo obtener la colección discourse")
-            return []
-
-        # Consulta
-        query = {
-            "username": username,
-            "analysis_type": "discourse"
-        }
-        
-        # Campos a recuperar
-        projection = {
-            "timestamp": 1,
-            "combined_graph": 1,
-            "_id": 1
-        }
-        
-        # Ejecutar consulta
-        try:
-            cursor = collection.find(query, projection).sort("timestamp", -1)
-            if limit:
-                cursor = cursor.limit(limit)
-            
-            # Convertir cursor a lista
-            results = list(cursor)
-            logger.info(f"Recuperados {len(results)} análisis del discurso para {username}")
-            return results
-            
-        except Exception as db_error:
-            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
-            return []
-        
-    except Exception as e:
-        logger.error(f"Error recuperando análisis del discurso: {str(e)}")
-        return []
-#####################################################################################
-        
-def get_student_discourse_data(username):
-    """
-    Obtiene un resumen de los análisis del discurso de un estudiante.
-    """
-    try:
-        analyses = get_student_discourse_analysis(username, limit=None)
-        formatted_analyses = []
-        
-        for analysis in analyses:
-            formatted_analysis = {
-                'timestamp': analysis['timestamp'],
-                'text1': analysis.get('text1', ''),
-                'text2': analysis.get('text2', ''),
-                'key_concepts1': analysis.get('key_concepts1', []),
-                'key_concepts2': analysis.get('key_concepts2', [])
-            }
-            formatted_analyses.append(formatted_analysis)
-            
-        return {'entries': formatted_analyses}
-        
-    except Exception as e:
-        logger.error(f"Error al obtener datos del discurso: {str(e)}")
-        return {'entries': []}
-
-###########################################################################
-def update_student_discourse_analysis(analysis_id, update_data):
-    """
-    Actualiza un análisis del discurso existente.
-    """
-    try:
-        query = {"_id": analysis_id}
-        update = {"$set": update_data}
-        return update_document(COLLECTION_NAME, query, update)
-    except Exception as e:
-        logger.error(f"Error al actualizar análisis del discurso: {str(e)}")
-        return False
-
-###########################################################################
-def delete_student_discourse_analysis(analysis_id):
-    """
-    Elimina un análisis del discurso.
-    """
-    try:
-        query = {"_id": analysis_id}
-        return delete_document(COLLECTION_NAME, query)
-    except Exception as e:
-        logger.error(f"Error al eliminar análisis del discurso: {str(e)}")
+# modules/database/discourse_mongo_db.py
+# Importaciones estándar
+import io
+import base64
+from datetime import datetime, timezone
+import logging
+
+# Importaciones de terceros
+import matplotlib.pyplot as plt
+
+from .mongo_db import (
+    get_collection,
+    insert_document, 
+    find_documents, 
+    update_document, 
+    delete_document
+)
+
+# Configuración del logger
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'student_discourse_analysis'
+
+########################################################################
+def store_student_discourse_result(username, text1, text2, analysis_result):
+    """
+    Guarda el resultado del análisis de discurso comparativo en MongoDB.
+    """
+    try:
+        # Los gráficos ya vienen en bytes, solo necesitamos codificar a base64
+        graph1_data = None
+        graph2_data = None
+        combined_graph_data = None
+
+        if 'graph1' in analysis_result and analysis_result['graph1'] is not None:
+            try:
+                graph1_data = base64.b64encode(analysis_result['graph1']).decode('utf-8')
+            except Exception as e:
+                logger.error(f"Error al codificar gráfico 1: {str(e)}")
+
+        if 'graph2' in analysis_result and analysis_result['graph2'] is not None:
+            try:
+                graph2_data = base64.b64encode(analysis_result['graph2']).decode('utf-8')
+            except Exception as e:
+                logger.error(f"Error al codificar gráfico 2: {str(e)}")
+
+        if 'combined_graph' in analysis_result and analysis_result['combined_graph'] is not None:
+            try:
+                combined_graph_data = base64.b64encode(analysis_result['combined_graph']).decode('utf-8')
+            except Exception as e:
+                logger.error(f"Error al codificar gráfico combinado: {str(e)}")
+
+        # Crear documento para MongoDB
+        analysis_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text1': text1,
+            'text2': text2,
+            'analysis_type': 'discourse',
+            'key_concepts1': analysis_result.get('key_concepts1', []),
+            'key_concepts2': analysis_result.get('key_concepts2', []),
+            'graph1': graph1_data,
+            'graph2': graph2_data,
+            'combined_graph': combined_graph_data
+        }
+
+        # Insertar en MongoDB
+        result = insert_document(COLLECTION_NAME, analysis_document)
+        if result:
+            logger.info(f"Análisis del discurso guardado con ID: {result} para el usuario: {username}")
+            return True
+
+        logger.error("No se pudo insertar el documento en MongoDB")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error al guardar el análisis del discurso: {str(e)}")
+        return False
+
+
+
+#################################################################################
+def get_student_discourse_analysis(username, limit=10):
+    """
+    Recupera los análisis del discurso de un estudiante.
+    """
+    try:
+        # Obtener la colección
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:  # Cambiado de if not collection a if collection is None
+            logger.error("No se pudo obtener la colección discourse")
+            return []
+
+        # Consulta
+        query = {
+            "username": username,
+            "analysis_type": "discourse"
+        }
+        
+        # Campos a recuperar
+        projection = {
+            "timestamp": 1,
+            "combined_graph": 1,
+            "_id": 1
+        }
+        
+        # Ejecutar consulta
+        try:
+            cursor = collection.find(query, projection).sort("timestamp", -1)
+            if limit:
+                cursor = cursor.limit(limit)
+            
+            # Convertir cursor a lista
+            results = list(cursor)
+            logger.info(f"Recuperados {len(results)} análisis del discurso para {username}")
+            return results
+            
+        except Exception as db_error:
+            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
+            return []
+        
+    except Exception as e:
+        logger.error(f"Error recuperando análisis del discurso: {str(e)}")
+        return []
+#####################################################################################
+        
+def get_student_discourse_data(username):
+    """
+    Obtiene un resumen de los análisis del discurso de un estudiante.
+    """
+    try:
+        analyses = get_student_discourse_analysis(username, limit=None)
+        formatted_analyses = []
+        
+        for analysis in analyses:
+            formatted_analysis = {
+                'timestamp': analysis['timestamp'],
+                'text1': analysis.get('text1', ''),
+                'text2': analysis.get('text2', ''),
+                'key_concepts1': analysis.get('key_concepts1', []),
+                'key_concepts2': analysis.get('key_concepts2', [])
+            }
+            formatted_analyses.append(formatted_analysis)
+            
+        return {'entries': formatted_analyses}
+        
+    except Exception as e:
+        logger.error(f"Error al obtener datos del discurso: {str(e)}")
+        return {'entries': []}
+
+###########################################################################
+def update_student_discourse_analysis(analysis_id, update_data):
+    """
+    Actualiza un análisis del discurso existente.
+    """
+    try:
+        query = {"_id": analysis_id}
+        update = {"$set": update_data}
+        return update_document(COLLECTION_NAME, query, update)
+    except Exception as e:
+        logger.error(f"Error al actualizar análisis del discurso: {str(e)}")
+        return False
+
+###########################################################################
+def delete_student_discourse_analysis(analysis_id):
+    """
+    Elimina un análisis del discurso.
+    """
+    try:
+        query = {"_id": analysis_id}
+        return delete_document(COLLECTION_NAME, query)
+    except Exception as e:
+        logger.error(f"Error al eliminar análisis del discurso: {str(e)}")
         return False

modules/database/mongo_db.py

@@ -1,63 +1,62 @@
-#modules/database/mongo_db.py
-from .database_init import get_mongodb
-import logging
-
-logger = logging.getLogger(__name__)
-
-def get_collection(collection_name):
-    try:
-        db = get_mongodb()
-        if db is None:
-            logger.error(f"No se pudo obtener la base de datos para {collection_name}")
-            return None
-            
-        collection = db[collection_name]
-        logger.info(f"Colección {collection_name} obtenida exitosamente")
-        return collection
-        
-    except Exception as e:
-        logger.error(f"Error al obtener colección {collection_name}: {str(e)}")
-        return None
-
-def insert_document(collection_name, document):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.insert_one(document)
-        logger.info(f"Documento insertado en {collection_name} con ID: {result.inserted_id}")
-        return result.inserted_id
-    except Exception as e:
-        logger.error(f"Error al insertar documento en {collection_name}: {str(e)}")
-        return None
-
-def find_documents(collection_name, query, sort=None, limit=None):
-    collection = get_collection(collection_name)
-    try:
-        cursor = collection.find(query)
-        if sort:
-            cursor = cursor.sort(sort)
-        if limit:
-            cursor = cursor.limit(limit)
-        return list(cursor)
-    except Exception as e:
-        logger.error(f"Error al buscar documentos en {collection_name}: {str(e)}")
-        return []
-
-def update_document(collection_name, query, update):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.update_one(query, update)
-        logger.info(f"Documento actualizado en {collection_name}: {result.modified_count} modificado(s)")
-        return result.modified_count
-    except Exception as e:
-        logger.error(f"Error al actualizar documento en {collection_name}: {str(e)}")
-        return 0
-
-def delete_document(collection_name, query):
-    collection = get_collection(collection_name)
-    try:
-        result = collection.delete_one(query)
-        logger.info(f"Documento eliminado de {collection_name}: {result.deleted_count} eliminado(s)")
-        return result.deleted_count
-    except Exception as e:
-        logger.error(f"Error al eliminar documento de {collection_name}: {str(e)}")
+from .database_init import get_mongodb
+import logging
+
+logger = logging.getLogger(__name__)
+
+def get_collection(collection_name):
+    try:
+        db = get_mongodb()
+        if db is None:
+            logger.error(f"No se pudo obtener la base de datos para {collection_name}")
+            return None
+            
+        collection = db[collection_name]
+        logger.info(f"Colección {collection_name} obtenida exitosamente")
+        return collection
+        
+    except Exception as e:
+        logger.error(f"Error al obtener colección {collection_name}: {str(e)}")
+        return None
+
+def insert_document(collection_name, document):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.insert_one(document)
+        logger.info(f"Documento insertado en {collection_name} con ID: {result.inserted_id}")
+        return result.inserted_id
+    except Exception as e:
+        logger.error(f"Error al insertar documento en {collection_name}: {str(e)}")
+        return None
+
+def find_documents(collection_name, query, sort=None, limit=None):
+    collection = get_collection(collection_name)
+    try:
+        cursor = collection.find(query)
+        if sort:
+            cursor = cursor.sort(sort)
+        if limit:
+            cursor = cursor.limit(limit)
+        return list(cursor)
+    except Exception as e:
+        logger.error(f"Error al buscar documentos en {collection_name}: {str(e)}")
+        return []
+
+def update_document(collection_name, query, update):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.update_one(query, update)
+        logger.info(f"Documento actualizado en {collection_name}: {result.modified_count} modificado(s)")
+        return result.modified_count
+    except Exception as e:
+        logger.error(f"Error al actualizar documento en {collection_name}: {str(e)}")
+        return 0
+
+def delete_document(collection_name, query):
+    collection = get_collection(collection_name)
+    try:
+        result = collection.delete_one(query)
+        logger.info(f"Documento eliminado de {collection_name}: {result.deleted_count} eliminado(s)")
+        return result.deleted_count
+    except Exception as e:
+        logger.error(f"Error al eliminar documento de {collection_name}: {str(e)}")
         return 0

modules/database/morphosyntax_iterative_mongo_db.py

@@ -1,171 +1,171 @@
-# modules/database/morphosyntax_iterative_mongo_db.py
-
-
-from datetime import datetime, timezone
-import logging
-from bson import ObjectId  # <--- Importar ObjectId
-from .mongo_db import get_collection, insert_document, find_documents, update_document, delete_document
-
-logger = logging.getLogger(__name__)
-
-BASE_COLLECTION = 'student_morphosyntax_analysis_base'
-ITERATION_COLLECTION = 'student_morphosyntax_iterations'
-
-def store_student_morphosyntax_base(username, text, arc_diagrams):
-    """Almacena el análisis morfosintáctico base y retorna su ObjectId."""
-    try:
-        base_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text': text,
-            'arc_diagrams': arc_diagrams,
-            'analysis_type': 'morphosyntax_base',
-            'has_iterations': False
-        }
-        collection = get_collection(BASE_COLLECTION)
-        result = collection.insert_one(base_document)
-
-        logger.info(f"Análisis base guardado para {username}")
-        # Retornamos el ObjectId directamente (NO str)
-        return result.inserted_id
-
-    except Exception as e:
-        logger.error(f"Error almacenando análisis base: {str(e)}")
-        return None
-
-def store_student_morphosyntax_iteration(username, base_id, original_text, iteration_text, arc_diagrams):
-    """
-    Almacena una iteración de análisis morfosintáctico.
-    base_id: ObjectId de la base (o string convertible a ObjectId).
-    """
-    try:
-        # Convertir a ObjectId si viene como string
-        if isinstance(base_id, str):
-            base_id = ObjectId(base_id)
-
-        iteration_document = {
-            'username': username,
-            'base_id': base_id,  # Guardar el ObjectId en la iteración
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'original_text': original_text,
-            'iteration_text': iteration_text,
-            'arc_diagrams': arc_diagrams,
-            'analysis_type': 'morphosyntax_iteration'
-        }
-        collection = get_collection(ITERATION_COLLECTION)
-        result = collection.insert_one(iteration_document)
-
-        # Actualizar documento base (usando ObjectId)
-        base_collection = get_collection(BASE_COLLECTION)
-        base_collection.update_one(
-            {'_id': base_id, 'username': username},
-            {'$set': {'has_iterations': True}}
-        )
-
-        logger.info(f"Iteración guardada para {username}, base_id: {base_id}")
-        return result.inserted_id  # Retornar el ObjectId de la iteración
-
-    except Exception as e:
-        logger.error(f"Error almacenando iteración: {str(e)}")
-        return None
-
-def get_student_morphosyntax_analysis(username, limit=10):
-    """
-    Obtiene los análisis base y sus iteraciones.
-    Returns: Lista de análisis con sus iteraciones.
-    """
-    try:
-        base_collection = get_collection(BASE_COLLECTION)
-        base_query = {
-            "username": username,
-            "analysis_type": "morphosyntax_base"
-        }
-        base_analyses = list(
-            base_collection.find(base_query).sort("timestamp", -1).limit(limit)
-        )
-
-        # Para cada análisis base, obtener sus iteraciones
-        iteration_collection = get_collection(ITERATION_COLLECTION)
-        for analysis in base_analyses:
-            base_id = analysis['_id']
-            # Buscar iteraciones con base_id = ObjectId
-            iterations = list(
-                iteration_collection.find({"base_id": base_id}).sort("timestamp", -1)
-            )
-            analysis['iterations'] = iterations
-
-        return base_analyses
-
-    except Exception as e:
-        logger.error(f"Error obteniendo análisis: {str(e)}")
-        return []
-
-def update_student_morphosyntax_analysis(analysis_id, is_base, update_data):
-    """
-    Actualiza un análisis base o iteración.
-    analysis_id puede ser un ObjectId o string.
-    """
-    from bson import ObjectId
-
-    try:
-        collection_name = BASE_COLLECTION if is_base else ITERATION_COLLECTION
-        collection = get_collection(collection_name)
-
-        if isinstance(analysis_id, str):
-            analysis_id = ObjectId(analysis_id)
-
-        query = {"_id": analysis_id}
-        update = {"$set": update_data}
-
-        result = update_document(collection_name, query, update)
-        return result
-
-    except Exception as e:
-        logger.error(f"Error actualizando análisis: {str(e)}")
-        return False
-
-def delete_student_morphosyntax_analysis(analysis_id, is_base):
-    """
-    Elimina un análisis base o iteración.
-    Si es base, también elimina todas sus iteraciones.
-    """
-    from bson import ObjectId
-
-    try:
-        if isinstance(analysis_id, str):
-            analysis_id = ObjectId(analysis_id)
-
-        if is_base:
-            # Eliminar iteraciones vinculadas
-            iteration_collection = get_collection(ITERATION_COLLECTION)
-            iteration_collection.delete_many({"base_id": analysis_id})
-
-            # Luego eliminar el análisis base
-            collection = get_collection(BASE_COLLECTION)
-        else:
-            collection = get_collection(ITERATION_COLLECTION)
-
-        query = {"_id": analysis_id}
-        result = delete_document(collection.name, query)
-        return result
-
-    except Exception as e:
-        logger.error(f"Error eliminando análisis: {str(e)}")
-        return False
-
-def get_student_morphosyntax_data(username):
-    """
-    Obtiene todos los datos de análisis morfosintáctico de un estudiante.
-    Returns: Diccionario con todos los análisis y sus iteraciones.
-    """
-    try:
-        analyses = get_student_morphosyntax_analysis(username, limit=None)
-        return {
-            'entries': analyses,
-            'total_analyses': len(analyses),
-            'has_iterations': any(a.get('has_iterations', False) for a in analyses)
-        }
-
-    except Exception as e:
-        logger.error(f"Error obteniendo datos del estudiante: {str(e)}")
-        return {'entries': [], 'total_analyses': 0, 'has_iterations': False}
+# modules/database/morphosyntax_iterative_mongo_db.py
+
+
+from datetime import datetime, timezone
+import logging
+from bson import ObjectId  # <--- Importar ObjectId
+from .mongo_db import get_collection, insert_document, find_documents, update_document, delete_document
+
+logger = logging.getLogger(__name__)
+
+BASE_COLLECTION = 'student_morphosyntax_analysis_base'
+ITERATION_COLLECTION = 'student_morphosyntax_iterations'
+
+def store_student_morphosyntax_base(username, text, arc_diagrams):
+    """Almacena el análisis morfosintáctico base y retorna su ObjectId."""
+    try:
+        base_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'arc_diagrams': arc_diagrams,
+            'analysis_type': 'morphosyntax_base',
+            'has_iterations': False
+        }
+        collection = get_collection(BASE_COLLECTION)
+        result = collection.insert_one(base_document)
+
+        logger.info(f"Análisis base guardado para {username}")
+        # Retornamos el ObjectId directamente (NO str)
+        return result.inserted_id
+
+    except Exception as e:
+        logger.error(f"Error almacenando análisis base: {str(e)}")
+        return None
+
+def store_student_morphosyntax_iteration(username, base_id, original_text, iteration_text, arc_diagrams):
+    """
+    Almacena una iteración de análisis morfosintáctico.
+    base_id: ObjectId de la base (o string convertible a ObjectId).
+    """
+    try:
+        # Convertir a ObjectId si viene como string
+        if isinstance(base_id, str):
+            base_id = ObjectId(base_id)
+
+        iteration_document = {
+            'username': username,
+            'base_id': base_id,  # Guardar el ObjectId en la iteración
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'original_text': original_text,
+            'iteration_text': iteration_text,
+            'arc_diagrams': arc_diagrams,
+            'analysis_type': 'morphosyntax_iteration'
+        }
+        collection = get_collection(ITERATION_COLLECTION)
+        result = collection.insert_one(iteration_document)
+
+        # Actualizar documento base (usando ObjectId)
+        base_collection = get_collection(BASE_COLLECTION)
+        base_collection.update_one(
+            {'_id': base_id, 'username': username},
+            {'$set': {'has_iterations': True}}
+        )
+
+        logger.info(f"Iteración guardada para {username}, base_id: {base_id}")
+        return result.inserted_id  # Retornar el ObjectId de la iteración
+
+    except Exception as e:
+        logger.error(f"Error almacenando iteración: {str(e)}")
+        return None
+
+def get_student_morphosyntax_analysis(username, limit=10):
+    """
+    Obtiene los análisis base y sus iteraciones.
+    Returns: Lista de análisis con sus iteraciones.
+    """
+    try:
+        base_collection = get_collection(BASE_COLLECTION)
+        base_query = {
+            "username": username,
+            "analysis_type": "morphosyntax_base"
+        }
+        base_analyses = list(
+            base_collection.find(base_query).sort("timestamp", -1).limit(limit)
+        )
+
+        # Para cada análisis base, obtener sus iteraciones
+        iteration_collection = get_collection(ITERATION_COLLECTION)
+        for analysis in base_analyses:
+            base_id = analysis['_id']
+            # Buscar iteraciones con base_id = ObjectId
+            iterations = list(
+                iteration_collection.find({"base_id": base_id}).sort("timestamp", -1)
+            )
+            analysis['iterations'] = iterations
+
+        return base_analyses
+
+    except Exception as e:
+        logger.error(f"Error obteniendo análisis: {str(e)}")
+        return []
+
+def update_student_morphosyntax_analysis(analysis_id, is_base, update_data):
+    """
+    Actualiza un análisis base o iteración.
+    analysis_id puede ser un ObjectId o string.
+    """
+    from bson import ObjectId
+
+    try:
+        collection_name = BASE_COLLECTION if is_base else ITERATION_COLLECTION
+        collection = get_collection(collection_name)
+
+        if isinstance(analysis_id, str):
+            analysis_id = ObjectId(analysis_id)
+
+        query = {"_id": analysis_id}
+        update = {"$set": update_data}
+
+        result = update_document(collection_name, query, update)
+        return result
+
+    except Exception as e:
+        logger.error(f"Error actualizando análisis: {str(e)}")
+        return False
+
+def delete_student_morphosyntax_analysis(analysis_id, is_base):
+    """
+    Elimina un análisis base o iteración.
+    Si es base, también elimina todas sus iteraciones.
+    """
+    from bson import ObjectId
+
+    try:
+        if isinstance(analysis_id, str):
+            analysis_id = ObjectId(analysis_id)
+
+        if is_base:
+            # Eliminar iteraciones vinculadas
+            iteration_collection = get_collection(ITERATION_COLLECTION)
+            iteration_collection.delete_many({"base_id": analysis_id})
+
+            # Luego eliminar el análisis base
+            collection = get_collection(BASE_COLLECTION)
+        else:
+            collection = get_collection(ITERATION_COLLECTION)
+
+        query = {"_id": analysis_id}
+        result = delete_document(collection.name, query)
+        return result
+
+    except Exception as e:
+        logger.error(f"Error eliminando análisis: {str(e)}")
+        return False
+
+def get_student_morphosyntax_data(username):
+    """
+    Obtiene todos los datos de análisis morfosintáctico de un estudiante.
+    Returns: Diccionario con todos los análisis y sus iteraciones.
+    """
+    try:
+        analyses = get_student_morphosyntax_analysis(username, limit=None)
+        return {
+            'entries': analyses,
+            'total_analyses': len(analyses),
+            'has_iterations': any(a.get('has_iterations', False) for a in analyses)
+        }
+
+    except Exception as e:
+        logger.error(f"Error obteniendo datos del estudiante: {str(e)}")
+        return {'entries': [], 'total_analyses': 0, 'has_iterations': False}

modules/database/semantic_export.py

@@ -1,78 +1,78 @@
-from io import BytesIO
-from reportlab.lib import colors
-from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, PageBreak
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.units import cm
-from svglib.svglib import svg2rlg
-from reportlab.graphics import renderPM
-import base64
-import cairosvg
-from reportlab.graphics import renderPDF
-from reportlab.lib.utils import ImageReader
-
-#importaciones locales
-from .semantic_mongo_db import get_student_semantic_data
-from .chat_db import get_chat_history
-
-# Placeholder para el logo
-LOGO_PATH = "assets\img\logo_92x92.png" # Reemplaza esto con la ruta real de tu logo
-
-# Definir el tamaño de página carta manualmente (612 x 792 puntos)
-LETTER_SIZE = (612, 792)
-
-def add_logo(canvas, doc):
-    logo = Image(LOGO_PATH, width=2*cm, height=2*cm)
-    logo.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin - 0.5*cm)
-
-def export_user_interactions(username, analysis_type):
-    # Obtener historial de chat (que ahora incluye los análisis morfosintácticos)
-    chat_history = get_chat_history(username, analysis_type)
-
-    # Crear un PDF
-    buffer = BytesIO()
-    doc = SimpleDocTemplate(
-        buffer,
-        pagesize=letter,
-        rightMargin=2*cm,
-        leftMargin=2*cm,
-        topMargin=2*cm,
-        bottomMargin=2*cm
-    )
-
-    story = []
-    styles = getSampleStyleSheet()
-
-    # Título
-    story.append(Paragraph(f"Interacciones de {username} - Análisis {analysis_type}", styles['Title']))
-    story.append(Spacer(1, 0.5*cm))
-
-    # Historial del chat y análisis
-    for entry in chat_history:
-        for message in entry['messages']:
-            role = message['role']
-            content = message['content']
-            story.append(Paragraph(f"<b>{role.capitalize()}:</b> {content}", styles['BodyText']))
-            story.append(Spacer(1, 0.25*cm))
-
-            # Si hay visualizaciones (diagramas SVG), convertirlas a imagen y añadirlas
-            if 'visualizations' in message and message['visualizations']:
-                for svg in message['visualizations']:
-                    drawing = svg2rlg(BytesIO(svg.encode('utf-8')))
-                    img_data = BytesIO()
-                    renderPM.drawToFile(drawing, img_data, fmt="PNG")
-                    img_data.seek(0)
-                    img = Image(img_data, width=15*cm, height=7.5*cm)
-                    story.append(img)
-                    story.append(Spacer(1, 0.5*cm))
-
-        story.append(PageBreak())
-
-    # Construir el PDF
-    doc.build(story)
-    buffer.seek(0)
-    return buffer
-
-# Uso en Streamlit:
-# pdf_buffer = export_user_interactions(username, 'morphosyntax')
+from io import BytesIO
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import cm
+from svglib.svglib import svg2rlg
+from reportlab.graphics import renderPM
+import base64
+import cairosvg
+from reportlab.graphics import renderPDF
+from reportlab.lib.utils import ImageReader
+
+#importaciones locales
+from .semantic_mongo_db import get_student_semantic_data
+from .chat_db import get_chat_history
+
+# Placeholder para el logo
+LOGO_PATH = "assets\img\logo_92x92.png" # Reemplaza esto con la ruta real de tu logo
+
+# Definir el tamaño de página carta manualmente (612 x 792 puntos)
+LETTER_SIZE = (612, 792)
+
+def add_logo(canvas, doc):
+    logo = Image(LOGO_PATH, width=2*cm, height=2*cm)
+    logo.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin - 0.5*cm)
+
+def export_user_interactions(username, analysis_type):
+    # Obtener historial de chat (que ahora incluye los análisis morfosintácticos)
+    chat_history = get_chat_history(username, analysis_type)
+
+    # Crear un PDF
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=2*cm,
+        leftMargin=2*cm,
+        topMargin=2*cm,
+        bottomMargin=2*cm
+    )
+
+    story = []
+    styles = getSampleStyleSheet()
+
+    # Título
+    story.append(Paragraph(f"Interacciones de {username} - Análisis {analysis_type}", styles['Title']))
+    story.append(Spacer(1, 0.5*cm))
+
+    # Historial del chat y análisis
+    for entry in chat_history:
+        for message in entry['messages']:
+            role = message['role']
+            content = message['content']
+            story.append(Paragraph(f"<b>{role.capitalize()}:</b> {content}", styles['BodyText']))
+            story.append(Spacer(1, 0.25*cm))
+
+            # Si hay visualizaciones (diagramas SVG), convertirlas a imagen y añadirlas
+            if 'visualizations' in message and message['visualizations']:
+                for svg in message['visualizations']:
+                    drawing = svg2rlg(BytesIO(svg.encode('utf-8')))
+                    img_data = BytesIO()
+                    renderPM.drawToFile(drawing, img_data, fmt="PNG")
+                    img_data.seek(0)
+                    img = Image(img_data, width=15*cm, height=7.5*cm)
+                    story.append(img)
+                    story.append(Spacer(1, 0.5*cm))
+
+        story.append(PageBreak())
+
+    # Construir el PDF
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+# Uso en Streamlit:
+# pdf_buffer = export_user_interactions(username, 'morphosyntax')
 # st.download_button(label="Descargar PDF", data=pdf_buffer, file_name="interacciones.pdf", mime="application/pdf")

modules/database/semantic_mongo_db.py

@@ -1,160 +1,160 @@
-#/modules/database/semantic_mongo_db.py
-
-# Importaciones estándar
-import io
-import base64
-from datetime import datetime, timezone
-import logging
-
-# Importaciones de terceros
-import matplotlib.pyplot as plt
-
-# Importaciones locales
-from .mongo_db import (
-    get_collection,
-    insert_document, 
-    find_documents, 
-    update_document, 
-    delete_document
-)
-
-# Configuración del logger
-logger = logging.getLogger(__name__)  # Cambiado de name a __name__
-COLLECTION_NAME = 'student_semantic_analysis'
-
-def store_student_semantic_result(username, text, analysis_result):
-    """
-    Guarda el resultado del análisis semántico en MongoDB.
-    """
-    try:
-        # El gráfico ya viene en bytes, solo necesitamos codificarlo a base64
-        concept_graph_data = None
-        if 'concept_graph' in analysis_result and analysis_result['concept_graph'] is not None:
-            try:
-                # Ya está en bytes, solo codificar a base64
-                concept_graph_data = base64.b64encode(analysis_result['concept_graph']).decode('utf-8')
-            except Exception as e:
-                logger.error(f"Error al codificar gráfico conceptual: {str(e)}")
-
-        # Crear documento para MongoDB
-        analysis_document = {
-            'username': username,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'text': text,
-            'analysis_type': 'semantic',
-            'key_concepts': analysis_result.get('key_concepts', []),
-            'concept_graph': concept_graph_data
-        }
-
-        # Insertar en MongoDB
-        result = insert_document(COLLECTION_NAME, analysis_document)
-        if result:
-            logger.info(f"Análisis semántico guardado con ID: {result} para el usuario: {username}")
-            return True
-        
-        logger.error("No se pudo insertar el documento en MongoDB")
-        return False
-
-    except Exception as e:
-        logger.error(f"Error al guardar el análisis semántico: {str(e)}")
-        return False
-
-####################################################################################
-def get_student_semantic_analysis(username, limit=10):
-    """
-    Recupera los análisis semánticos de un estudiante.
-    """
-    try:
-        # Obtener la colección
-        collection = get_collection(COLLECTION_NAME)
-        if collection is None:  # Cambiado de if not collection a if collection is None
-            logger.error("No se pudo obtener la colección semantic")
-            return []
-
-        # Consulta
-        query = {
-            "username": username,
-            "analysis_type": "semantic"
-        }
-        
-        # Campos a recuperar
-        projection = {
-            "timestamp": 1,
-            "concept_graph": 1,
-            "_id": 1
-        }
-        
-        # Ejecutar consulta
-        try:
-            cursor = collection.find(query, projection).sort("timestamp", -1)
-            if limit:
-                cursor = cursor.limit(limit)
-            
-            # Convertir cursor a lista
-            results = list(cursor)
-            logger.info(f"Recuperados {len(results)} análisis semánticos para {username}")
-            return results
-            
-        except Exception as db_error:
-            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
-            return []
-        
-    except Exception as e:
-        logger.error(f"Error recuperando análisis semántico: {str(e)}")
-        return []
-####################################################################################################
-
-
-def update_student_semantic_analysis(analysis_id, update_data):
-    """
-    Actualiza un análisis semántico existente.
-    Args:
-        analysis_id: ID del análisis a actualizar
-        update_data: Datos a actualizar
-    """
-    query = {"_id": analysis_id}
-    update = {"$set": update_data}
-    return update_document(COLLECTION_NAME, query, update)
-
-def delete_student_semantic_analysis(analysis_id):
-    """
-    Elimina un análisis semántico.
-    Args:
-        analysis_id: ID del análisis a eliminar
-    """
-    query = {"_id": analysis_id}
-    return delete_document(COLLECTION_NAME, query)
-
-def get_student_semantic_data(username):
-    """
-    Obtiene todos los análisis semánticos de un estudiante.
-    Args:
-        username: Nombre del usuario
-    Returns:
-        dict: Diccionario con todos los análisis del estudiante
-    """
-    analyses = get_student_semantic_analysis(username, limit=None)
-    
-    formatted_analyses = []
-    for analysis in analyses:
-        formatted_analysis = {
-            'timestamp': analysis['timestamp'],
-            'text': analysis['text'],
-            'key_concepts': analysis['key_concepts'],
-            'entities': analysis['entities']
-            # No incluimos los gráficos en el resumen general
-        }
-        formatted_analyses.append(formatted_analysis)
-    
-    return {
-        'entries': formatted_analyses
-    }
-
-# Exportar las funciones necesarias
-__all__ = [
-    'store_student_semantic_result',
-    'get_student_semantic_analysis',
-    'update_student_semantic_analysis',
-    'delete_student_semantic_analysis',
-    'get_student_semantic_data'
+#/modules/database/semantic_mongo_db.py
+
+# Importaciones estándar
+import io
+import base64
+from datetime import datetime, timezone
+import logging
+
+# Importaciones de terceros
+import matplotlib.pyplot as plt
+
+# Importaciones locales
+from .mongo_db import (
+    get_collection,
+    insert_document, 
+    find_documents, 
+    update_document, 
+    delete_document
+)
+
+# Configuración del logger
+logger = logging.getLogger(__name__)  # Cambiado de name a __name__
+COLLECTION_NAME = 'student_semantic_analysis'
+
+def store_student_semantic_result(username, text, analysis_result):
+    """
+    Guarda el resultado del análisis semántico en MongoDB.
+    """
+    try:
+        # El gráfico ya viene en bytes, solo necesitamos codificarlo a base64
+        concept_graph_data = None
+        if 'concept_graph' in analysis_result and analysis_result['concept_graph'] is not None:
+            try:
+                # Ya está en bytes, solo codificar a base64
+                concept_graph_data = base64.b64encode(analysis_result['concept_graph']).decode('utf-8')
+            except Exception as e:
+                logger.error(f"Error al codificar gráfico conceptual: {str(e)}")
+
+        # Crear documento para MongoDB
+        analysis_document = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'analysis_type': 'semantic',
+            'key_concepts': analysis_result.get('key_concepts', []),
+            'concept_graph': concept_graph_data
+        }
+
+        # Insertar en MongoDB
+        result = insert_document(COLLECTION_NAME, analysis_document)
+        if result:
+            logger.info(f"Análisis semántico guardado con ID: {result} para el usuario: {username}")
+            return True
+        
+        logger.error("No se pudo insertar el documento en MongoDB")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error al guardar el análisis semántico: {str(e)}")
+        return False
+
+####################################################################################
+def get_student_semantic_analysis(username, limit=10):
+    """
+    Recupera los análisis semánticos de un estudiante.
+    """
+    try:
+        # Obtener la colección
+        collection = get_collection(COLLECTION_NAME)
+        if collection is None:  # Cambiado de if not collection a if collection is None
+            logger.error("No se pudo obtener la colección semantic")
+            return []
+
+        # Consulta
+        query = {
+            "username": username,
+            "analysis_type": "semantic"
+        }
+        
+        # Campos a recuperar
+        projection = {
+            "timestamp": 1,
+            "concept_graph": 1,
+            "_id": 1
+        }
+        
+        # Ejecutar consulta
+        try:
+            cursor = collection.find(query, projection).sort("timestamp", -1)
+            if limit:
+                cursor = cursor.limit(limit)
+            
+            # Convertir cursor a lista
+            results = list(cursor)
+            logger.info(f"Recuperados {len(results)} análisis semánticos para {username}")
+            return results
+            
+        except Exception as db_error:
+            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
+            return []
+        
+    except Exception as e:
+        logger.error(f"Error recuperando análisis semántico: {str(e)}")
+        return []
+####################################################################################################
+
+
+def update_student_semantic_analysis(analysis_id, update_data):
+    """
+    Actualiza un análisis semántico existente.
+    Args:
+        analysis_id: ID del análisis a actualizar
+        update_data: Datos a actualizar
+    """
+    query = {"_id": analysis_id}
+    update = {"$set": update_data}
+    return update_document(COLLECTION_NAME, query, update)
+
+def delete_student_semantic_analysis(analysis_id):
+    """
+    Elimina un análisis semántico.
+    Args:
+        analysis_id: ID del análisis a eliminar
+    """
+    query = {"_id": analysis_id}
+    return delete_document(COLLECTION_NAME, query)
+
+def get_student_semantic_data(username):
+    """
+    Obtiene todos los análisis semánticos de un estudiante.
+    Args:
+        username: Nombre del usuario
+    Returns:
+        dict: Diccionario con todos los análisis del estudiante
+    """
+    analyses = get_student_semantic_analysis(username, limit=None)
+    
+    formatted_analyses = []
+    for analysis in analyses:
+        formatted_analysis = {
+            'timestamp': analysis['timestamp'],
+            'text': analysis['text'],
+            'key_concepts': analysis['key_concepts'],
+            'entities': analysis['entities']
+            # No incluimos los gráficos en el resumen general
+        }
+        formatted_analyses.append(formatted_analysis)
+    
+    return {
+        'entries': formatted_analyses
+    }
+
+# Exportar las funciones necesarias
+__all__ = [
+    'store_student_semantic_result',
+    'get_student_semantic_analysis',
+    'update_student_semantic_analysis',
+    'delete_student_semantic_analysis',
+    'get_student_semantic_data'
 ]

modules/database/sql_db.py

@@ -1,323 +1,323 @@
-# modules/database/sql_db.py
-
-from .database_init import get_container
-from datetime import datetime, timezone
-import logging
-import bcrypt
-import uuid
-
-logger = logging.getLogger(__name__)
-
-#########################################
-def get_user(username, role=None):
-    container = get_container("users")
-    try:
-        query = f"SELECT * FROM c WHERE c.id = '{username}'"
-        if role:
-            query += f" AND c.role = '{role}'"
-        items = list(container.query_items(query=query))
-        return items[0] if items else None
-    except Exception as e:
-        logger.error(f"Error al obtener usuario {username}: {str(e)}")
-        return None
-
-
-#########################################
-def get_admin_user(username):
-    return get_user(username, role='Administrador')
-
-
-#########################################
-def get_student_user(username):
-    return get_user(username, role='Estudiante')
-
-
-#########################################
-def get_teacher_user(username):
-    return get_user(username, role='Profesor')
-
-
-#########################################
-def create_user(username, password, role, additional_info=None):
-    """Crea un nuevo usuario"""
-    container = get_container("users")
-    if not container:
-        logger.error("No se pudo obtener el contenedor de usuarios")
-        return False
-        
-    try:
-        user_data = {
-            'id': username,
-            'password': password,
-            'role': role,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'additional_info': additional_info or {},
-            'partitionKey': username  # Agregar partition key
-        }
-        
-        # Crear item sin especificar partition_key en el método
-        container.create_item(body=user_data)
-        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
-
-#########################################
-def create_student_user(username, password, additional_info=None):
-    return create_user(username, password, 'Estudiante', additional_info)
-
-#########################################
-def create_teacher_user(username, password, additional_info=None):
-    return create_user(username, password, 'Profesor', additional_info)
-
-#########################################
-def create_admin_user(username, password, additional_info=None):
-    return create_user(username, password, 'Administrador', additional_info)
-
-#########################################
-def record_login(username):
-    """Registra el inicio de sesión de un usuario"""
-    try:
-        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": session_id,
-            "type": "session",
-            "username": username,
-            "loginTime": datetime.now(timezone.utc).isoformat(),
-            "additional_info": {},
-            "partitionKey": username
-        }
-
-        result = container.create_item(body=session_doc)
-        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("users_sessions")
-        if not container:
-            logger.error("No se pudo obtener el contenedor users_sessions")
-            return False
-
-        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
-        params = [
-            {"name": "@id", "value": session_id},
-            {"name": "@username", "value": username}
-        ]
-        
-        items = list(container.query_items(
-            query=query,
-            parameters=params
-        ))
-
-        if not items:
-            logger.warning(f"Sesión no encontrada: {session_id}")
-            return False
-
-        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())
-
-        session.update({
-            "logoutTime": logout_time.isoformat(),
-            "sessionDuration": duration,
-            "partitionKey": username
-        })
-
-        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("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'
-        ORDER BY c.loginTime DESC
-        OFFSET 0 LIMIT @limit
-        """
-        
-        sessions = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@limit", "value": limit}],
-            enable_cross_partition_query=True  # Agregar este parámetro
-        ))
-
-        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 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("users_sessions")
-        if not container:
-            return None
-
-        query = """
-        SELECT VALUE SUM(c.sessionDuration)
-        FROM c
-        WHERE c.type = 'session'
-        AND c.username = @username
-        AND IS_DEFINED(c.sessionDuration)
-        """
-        
-        result = list(container.query_items(
-            query=query,
-            parameters=[{"name": "@username", "value": username}]
-        ))
-
-        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 0
-
-#########################################
-def update_student_user(username, new_info):
-    container = get_container("users") 
-    try:
-        user = get_student_user(username)
-        if user:
-            user['additional_info'].update(new_info)
-            user['partitionKey'] = username
-            container.upsert_item(body=user)
-            logger.info(f"Información del estudiante actualizada: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
-        return False
-
-#########################################
-def delete_student_user(username):
-    container = get_container("users")
-    try:
-        user = get_student_user(username)
-        if user:
-            # El ID es suficiente para eliminación ya que partitionKey está en el documento
-            container.delete_item(item=user['id'])
-            logger.info(f"Estudiante eliminado: {username}")
-            return True
-        else:
-            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
-            return False
-    except Exception as e:
-        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
-        return False
-
-#########################################
-def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
-    """Almacena una solicitud de aplicación"""
-    try:
-        # Obtener el contenedor usando get_container() que sí funciona
-        container = get_container("application_requests")
-        if not container:
-            logger.error("No se pudo obtener el contenedor de solicitudes")
-            return False
-
-        # Crear documento con la solicitud
-        # Nótese que incluimos email como partition key en el cuerpo del documento
-        application_request = {
-            "id": str(uuid.uuid4()),
-            "name": name,
-            "lastname": lastname,
-            "email": email,
-            "institution": institution,
-            "current_role": current_role,
-            "desired_role": desired_role,
-            "reason": reason,
-            "requestDate": datetime.utcnow().isoformat(),
-            # El campo para partition key debe estar en el documento
-            "partitionKey": email
-        }
-        
-        # Crear el item en el contenedor - sin el parámetro enable_cross_partition_query
-        container.create_item(
-            body=application_request  # Solo pasamos el body
-        )
-        logger.info(f"Solicitud de aplicación almacenada para: {email}")
-        return True
-        
-    except Exception as e:
-        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
-        logger.error(f"Detalles del error: {str(e)}")
-        return False
-
-
-################################################################
-def store_student_feedback(username, name, email, feedback):
-    """Almacena el feedback de un estudiante"""
-    try:
-        # Obtener el contenedor - verificar disponibilidad
-        logger.info(f"Intentando obtener contenedor user_feedback para usuario: {username}")
-        container = get_container("user_feedback")
-        if not container:
-            logger.error("No se pudo obtener el contenedor user_feedback")
-            return False
-
-        # Crear documento de feedback - asegurar que el username esté como partition key
-        feedback_item = {
-            "id": str(uuid.uuid4()),
-            "username": username,  # Campo regular
-            "name": name,
-            "email": email,
-            "feedback": feedback,
-            "role": "Estudiante",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "partitionKey": username  # Campo de partición
-        }
-
-        # Crear el item - sin el parámetro enable_cross_partition_query
-        logger.info(f"Intentando almacenar feedback para usuario: {username}")
-        result = container.create_item(
-            body=feedback_item  # Solo el body, no parámetros adicionales
-        )
-        
-        logger.info(f"Feedback almacenado exitosamente para el usuario: {username}")
-        return True
-
-    except Exception as e:
-        logger.error(f"Error al almacenar el feedback del estudiante {username}")
-        logger.error(f"Detalles del error: {str(e)}")
+# modules/database/sql_db.py
+
+from .database_init import get_container
+from datetime import datetime, timezone
+import logging
+import bcrypt
+import uuid
+
+logger = logging.getLogger(__name__)
+
+#########################################
+def get_user(username, role=None):
+    container = get_container("users")
+    try:
+        query = f"SELECT * FROM c WHERE c.id = '{username}'"
+        if role:
+            query += f" AND c.role = '{role}'"
+        items = list(container.query_items(query=query))
+        return items[0] if items else None
+    except Exception as e:
+        logger.error(f"Error al obtener usuario {username}: {str(e)}")
+        return None
+
+
+#########################################
+def get_admin_user(username):
+    return get_user(username, role='Administrador')
+
+
+#########################################
+def get_student_user(username):
+    return get_user(username, role='Estudiante')
+
+
+#########################################
+def get_teacher_user(username):
+    return get_user(username, role='Profesor')
+
+
+#########################################
+def create_user(username, password, role, additional_info=None):
+    """Crea un nuevo usuario"""
+    container = get_container("users")
+    if not container:
+        logger.error("No se pudo obtener el contenedor de usuarios")
+        return False
+        
+    try:
+        user_data = {
+            'id': username,
+            'password': password,
+            'role': role,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'additional_info': additional_info or {},
+            'partitionKey': username  # Agregar partition key
+        }
+        
+        # Crear item sin especificar partition_key en el método
+        container.create_item(body=user_data)
+        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
+
+#########################################
+def create_student_user(username, password, additional_info=None):
+    return create_user(username, password, 'Estudiante', additional_info)
+
+#########################################
+def create_teacher_user(username, password, additional_info=None):
+    return create_user(username, password, 'Profesor', additional_info)
+
+#########################################
+def create_admin_user(username, password, additional_info=None):
+    return create_user(username, password, 'Administrador', additional_info)
+
+#########################################
+def record_login(username):
+    """Registra el inicio de sesión de un usuario"""
+    try:
+        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": session_id,
+            "type": "session",
+            "username": username,
+            "loginTime": datetime.now(timezone.utc).isoformat(),
+            "additional_info": {},
+            "partitionKey": username
+        }
+
+        result = container.create_item(body=session_doc)
+        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("users_sessions")
+        if not container:
+            logger.error("No se pudo obtener el contenedor users_sessions")
+            return False
+
+        query = "SELECT * FROM c WHERE c.id = @id AND c.username = @username"
+        params = [
+            {"name": "@id", "value": session_id},
+            {"name": "@username", "value": username}
+        ]
+        
+        items = list(container.query_items(
+            query=query,
+            parameters=params
+        ))
+
+        if not items:
+            logger.warning(f"Sesión no encontrada: {session_id}")
+            return False
+
+        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())
+
+        session.update({
+            "logoutTime": logout_time.isoformat(),
+            "sessionDuration": duration,
+            "partitionKey": username
+        })
+
+        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("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'
+        ORDER BY c.loginTime DESC
+        OFFSET 0 LIMIT @limit
+        """
+        
+        sessions = list(container.query_items(
+            query=query,
+            parameters=[{"name": "@limit", "value": limit}],
+            enable_cross_partition_query=True  # Agregar este parámetro
+        ))
+
+        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 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("users_sessions")
+        if not container:
+            return None
+
+        query = """
+        SELECT VALUE SUM(c.sessionDuration)
+        FROM c
+        WHERE c.type = 'session'
+        AND c.username = @username
+        AND IS_DEFINED(c.sessionDuration)
+        """
+        
+        result = list(container.query_items(
+            query=query,
+            parameters=[{"name": "@username", "value": username}]
+        ))
+
+        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 0
+
+#########################################
+def update_student_user(username, new_info):
+    container = get_container("users") 
+    try:
+        user = get_student_user(username)
+        if user:
+            user['additional_info'].update(new_info)
+            user['partitionKey'] = username
+            container.upsert_item(body=user)
+            logger.info(f"Información del estudiante actualizada: {username}")
+            return True
+        else:
+            logger.warning(f"Intento de actualizar estudiante no existente: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al actualizar información del estudiante {username}: {str(e)}")
+        return False
+
+#########################################
+def delete_student_user(username):
+    container = get_container("users")
+    try:
+        user = get_student_user(username)
+        if user:
+            # El ID es suficiente para eliminación ya que partitionKey está en el documento
+            container.delete_item(item=user['id'])
+            logger.info(f"Estudiante eliminado: {username}")
+            return True
+        else:
+            logger.warning(f"Intento de eliminar estudiante no existente: {username}")
+            return False
+    except Exception as e:
+        logger.error(f"Error al eliminar estudiante {username}: {str(e)}")
+        return False
+
+#########################################
+def store_application_request(name, lastname, email, institution, current_role, desired_role, reason):
+    """Almacena una solicitud de aplicación"""
+    try:
+        # Obtener el contenedor usando get_container() que sí funciona
+        container = get_container("application_requests")
+        if not container:
+            logger.error("No se pudo obtener el contenedor de solicitudes")
+            return False
+
+        # Crear documento con la solicitud
+        # Nótese que incluimos email como partition key en el cuerpo del documento
+        application_request = {
+            "id": str(uuid.uuid4()),
+            "name": name,
+            "lastname": lastname,
+            "email": email,
+            "institution": institution,
+            "current_role": current_role,
+            "desired_role": desired_role,
+            "reason": reason,
+            "requestDate": datetime.utcnow().isoformat(),
+            # El campo para partition key debe estar en el documento
+            "partitionKey": email
+        }
+        
+        # Crear el item en el contenedor - sin el parámetro enable_cross_partition_query
+        container.create_item(
+            body=application_request  # Solo pasamos el body
+        )
+        logger.info(f"Solicitud de aplicación almacenada para: {email}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error al almacenar la solicitud de aplicación: {str(e)}")
+        logger.error(f"Detalles del error: {str(e)}")
+        return False
+
+
+################################################################
+def store_student_feedback(username, name, email, feedback):
+    """Almacena el feedback de un estudiante"""
+    try:
+        # Obtener el contenedor - verificar disponibilidad
+        logger.info(f"Intentando obtener contenedor user_feedback para usuario: {username}")
+        container = get_container("user_feedback")
+        if not container:
+            logger.error("No se pudo obtener el contenedor user_feedback")
+            return False
+
+        # Crear documento de feedback - asegurar que el username esté como partition key
+        feedback_item = {
+            "id": str(uuid.uuid4()),
+            "username": username,  # Campo regular
+            "name": name,
+            "email": email,
+            "feedback": feedback,
+            "role": "Estudiante",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "partitionKey": username  # Campo de partición
+        }
+
+        # Crear el item - sin el parámetro enable_cross_partition_query
+        logger.info(f"Intentando almacenar feedback para usuario: {username}")
+        result = container.create_item(
+            body=feedback_item  # Solo el body, no parámetros adicionales
+        )
+        
+        logger.info(f"Feedback almacenado exitosamente para el usuario: {username}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Error al almacenar el feedback del estudiante {username}")
+        logger.error(f"Detalles del error: {str(e)}")
         return False

modules/database/writing_progress_mongo_db.py

@@ -1,141 +1,141 @@
-# modules/database/writing_progress_mongo_db.py
-
-from .mongo_db import get_collection, insert_document
-from datetime import datetime, timezone
-import logging
-
-logger = logging.getLogger(__name__)
-COLLECTION_NAME = 'writing_progress'
-
-def store_writing_baseline(username, metrics, text):
-    """
-    Guarda la línea base de escritura de un usuario.
-    Args:
-        username: ID del usuario
-        metrics: Diccionario con métricas iniciales
-        text: Texto analizado
-    """
-    try:
-        document = {
-            'username': username,
-            'type': 'baseline',
-            'metrics': metrics,
-            'text': text,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'iteration': 0  # Línea base siempre es iteración 0
-        }
-        
-        # Verificar si ya existe una línea base
-        collection = get_collection(COLLECTION_NAME)
-        existing = collection.find_one({
-            'username': username,
-            'type': 'baseline'
-        })
-        
-        if existing:
-            # Actualizar línea base existente
-            result = collection.update_one(
-                {'_id': existing['_id']},
-                {'$set': document}
-            )
-            success = result.modified_count > 0
-        else:
-            # Insertar nueva línea base
-            result = collection.insert_one(document)
-            success = result.inserted_id is not None
-            
-        logger.info(f"Línea base {'actualizada' if existing else 'creada'} para usuario: {username}")
-        return success
-        
-    except Exception as e:
-        logger.error(f"Error al guardar línea base: {str(e)}")
-        return False
-
-def store_writing_progress(username, metrics, text):
-    """
-    Guarda una nueva iteración de progreso.
-    """
-    try:
-        # Obtener último número de iteración
-        collection = get_collection(COLLECTION_NAME)
-        last_progress = collection.find_one(
-            {'username': username},
-            sort=[('iteration', -1)]
-        )
-        
-        next_iteration = (last_progress['iteration'] + 1) if last_progress else 1
-        
-        document = {
-            'username': username,
-            'type': 'progress',
-            'metrics': metrics,
-            'text': text,
-            'timestamp': datetime.now(timezone.utc).isoformat(),
-            'iteration': next_iteration
-        }
-        
-        result = collection.insert_one(document)
-        success = result.inserted_id is not None
-        
-        if success:
-            logger.info(f"Progreso guardado para {username}, iteración {next_iteration}")
-        
-        return success
-        
-    except Exception as e:
-        logger.error(f"Error al guardar progreso: {str(e)}")
-        return False
-
-def get_writing_baseline(username):
-    """
-    Obtiene la línea base de un usuario.
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        return collection.find_one({
-            'username': username,
-            'type': 'baseline'
-        })
-    except Exception as e:
-        logger.error(f"Error al obtener línea base: {str(e)}")
-        return None
-
-def get_writing_progress(username, limit=None):
-    """
-    Obtiene el historial de progreso de un usuario.
-    Args:
-        username: ID del usuario
-        limit: Número máximo de registros a retornar
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        cursor = collection.find(
-            {
-                'username': username,
-                'type': 'progress'
-            },
-            sort=[('iteration', -1)]
-        )
-        
-        if limit:
-            cursor = cursor.limit(limit)
-            
-        return list(cursor)
-        
-    except Exception as e:
-        logger.error(f"Error al obtener progreso: {str(e)}")
-        return []
-
-def get_latest_writing_metrics(username):
-    """
-    Obtiene las métricas más recientes (línea base o progreso).
-    """
-    try:
-        collection = get_collection(COLLECTION_NAME)
-        return collection.find_one(
-            {'username': username},
-            sort=[('timestamp', -1)]
-        )
-    except Exception as e:
-        logger.error(f"Error al obtener métricas recientes: {str(e)}")
+# modules/database/writing_progress_mongo_db.py
+
+from .mongo_db import get_collection, insert_document
+from datetime import datetime, timezone
+import logging
+
+logger = logging.getLogger(__name__)
+COLLECTION_NAME = 'writing_progress'
+
+def store_writing_baseline(username, metrics, text):
+    """
+    Guarda la línea base de escritura de un usuario.
+    Args:
+        username: ID del usuario
+        metrics: Diccionario con métricas iniciales
+        text: Texto analizado
+    """
+    try:
+        document = {
+            'username': username,
+            'type': 'baseline',
+            'metrics': metrics,
+            'text': text,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'iteration': 0  # Línea base siempre es iteración 0
+        }
+        
+        # Verificar si ya existe una línea base
+        collection = get_collection(COLLECTION_NAME)
+        existing = collection.find_one({
+            'username': username,
+            'type': 'baseline'
+        })
+        
+        if existing:
+            # Actualizar línea base existente
+            result = collection.update_one(
+                {'_id': existing['_id']},
+                {'$set': document}
+            )
+            success = result.modified_count > 0
+        else:
+            # Insertar nueva línea base
+            result = collection.insert_one(document)
+            success = result.inserted_id is not None
+            
+        logger.info(f"Línea base {'actualizada' if existing else 'creada'} para usuario: {username}")
+        return success
+        
+    except Exception as e:
+        logger.error(f"Error al guardar línea base: {str(e)}")
+        return False
+
+def store_writing_progress(username, metrics, text):
+    """
+    Guarda una nueva iteración de progreso.
+    """
+    try:
+        # Obtener último número de iteración
+        collection = get_collection(COLLECTION_NAME)
+        last_progress = collection.find_one(
+            {'username': username},
+            sort=[('iteration', -1)]
+        )
+        
+        next_iteration = (last_progress['iteration'] + 1) if last_progress else 1
+        
+        document = {
+            'username': username,
+            'type': 'progress',
+            'metrics': metrics,
+            'text': text,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'iteration': next_iteration
+        }
+        
+        result = collection.insert_one(document)
+        success = result.inserted_id is not None
+        
+        if success:
+            logger.info(f"Progreso guardado para {username}, iteración {next_iteration}")
+        
+        return success
+        
+    except Exception as e:
+        logger.error(f"Error al guardar progreso: {str(e)}")
+        return False
+
+def get_writing_baseline(username):
+    """
+    Obtiene la línea base de un usuario.
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        return collection.find_one({
+            'username': username,
+            'type': 'baseline'
+        })
+    except Exception as e:
+        logger.error(f"Error al obtener línea base: {str(e)}")
+        return None
+
+def get_writing_progress(username, limit=None):
+    """
+    Obtiene el historial de progreso de un usuario.
+    Args:
+        username: ID del usuario
+        limit: Número máximo de registros a retornar
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        cursor = collection.find(
+            {
+                'username': username,
+                'type': 'progress'
+            },
+            sort=[('iteration', -1)]
+        )
+        
+        if limit:
+            cursor = cursor.limit(limit)
+            
+        return list(cursor)
+        
+    except Exception as e:
+        logger.error(f"Error al obtener progreso: {str(e)}")
+        return []
+
+def get_latest_writing_metrics(username):
+    """
+    Obtiene las métricas más recientes (línea base o progreso).
+    """
+    try:
+        collection = get_collection(COLLECTION_NAME)
+        return collection.find_one(
+            {'username': username},
+            sort=[('timestamp', -1)]
+        )
+    except Exception as e:
+        logger.error(f"Error al obtener métricas recientes: {str(e)}")
         return None