Upload 15 files

modules/database/chat_mongo_db.py

@@ -0,0 +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)
+
+# 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

@@ -0,0 +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_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

@@ -0,0 +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()
+    return mongo_db

modules/database/discourse_mongo_db.py

@@ -0,0 +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)}")
+        return False

modules/database/mongo_db.py

@@ -0,0 +1,62 @@
+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/morphosintax_mongo_db.py

@@ -0,0 +1,49 @@
+#/modules/database/morphosintax_mongo_db.py
+from .mongo_db import insert_document, find_documents, update_document, delete_document
+from ..utils.svg_to_png_converter import process_and_save_svg_diagrams
+from datetime import datetime, timezone
+import logging
+
+logger = logging.getLogger(__name__)
+
+COLLECTION_NAME = 'student_morphosyntax_analysis'
+
+def store_student_morphosyntax_result(username, text, arc_diagrams):
+    analysis_document = {
+        'username': username,
+        'timestamp': datetime.now(timezone.utc).isoformat(),
+        'text': text,
+        'arc_diagrams': arc_diagrams,
+        'analysis_type': 'morphosyntax'
+    }
+
+    result = insert_document(COLLECTION_NAME, analysis_document)
+    if result:
+        # Procesar y guardar los diagramas SVG como PNG
+        png_ids = process_and_save_svg_diagrams(username, str(result), arc_diagrams)
+
+        # Actualizar el documento con los IDs de los PNGs
+        update_document(COLLECTION_NAME, {'_id': result}, {'$set': {'png_diagram_ids': png_ids}})
+
+        logger.info(f"Análisis morfosintáctico del estudiante guardado con ID: {result} para el usuario: {username}")
+        return True
+    return False
+
+def get_student_morphosyntax_analysis(username, limit=10):
+    query = {"username": username, "analysis_type": "morphosyntax"}
+    return find_documents(COLLECTION_NAME, query, sort=[("timestamp", -1)], limit=limit)
+
+def update_student_morphosyntax_analysis(analysis_id, update_data):
+    query = {"_id": analysis_id}
+    update = {"$set": update_data}
+    return update_document(COLLECTION_NAME, query, update)
+
+def delete_student_morphosyntax_analysis(analysis_id):
+    query = {"_id": analysis_id}
+    return delete_document(COLLECTION_NAME, query)
+
+def get_student_morphosyntax_data(username):
+    analyses = get_student_morphosyntax_analysis(username, limit=None)  # Obtener todos los análisis
+    return {
+        'entries': analyses
+    }

modules/database/morphosintaxis_export.py

@@ -0,0 +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 .morphosintax_mongo_db import get_student_morphosyntax_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/morphosintaxis_export_v1.py

@@ -0,0 +1,97 @@
+# database_export.py
+
+import pandas as pd
+import matplotlib.pyplot as plt
+from io import BytesIO
+#importaciones locales
+from .morphosintax_mongo_db import get_student_morphosyntax_analysis
+from .chat_db import get_chat_history
+
+
+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
+
+#def export_user_interactions(username, analysis_type):
+    # Obtener análisis morfosintáctico
+    #morphosyntax_data = get_student_morphosyntax_analysis(username)
+
+    # Obtener historial de chat
+    #chat_history = get_chat_history(username, analysis_type)
+
+    # Crear un DataFrame con los datos
+    #df = pd.DataFrame({
+    #    'Timestamp': [entry['timestamp'] for entry in chat_history],
+    #    'Role': [msg['role'] for entry in chat_history for msg in entry['messages']],
+    #    'Content': [msg['content'] for entry in chat_history for msg in entry['messages']]
+    #})
+
+    # Crear un PDF
+    #buffer = BytesIO()
+    #plt.figure(figsize=(12, 6))
+    #plt.axis('off')
+    #plt.text(0.5, 0.98, f"Interacciones de {username} - Análisis {analysis_type}", ha='center', va='top', fontsize=16)
+    #plt.text(0.5, 0.95, f"Total de interacciones: {len(df)}", ha='center', va='top', fontsize=12)
+
+    # Añadir tabla con las interacciones
+    #plt.table(cellText=df.values, colLabels=df.columns, cellLoc='center', loc='center')
+
+    # Añadir diagramas de arco si es análisis morfosintáctico
+    #if analysis_type == 'morphosyntax' and morphosyntax_data:
+    #    for i, analysis in enumerate(morphosyntax_data):
+    #        plt.figure(figsize=(12, 6))
+    #        plt.axis('off')
+    #        plt.text(0.5, 0.98, f"Diagrama de Arco {i+1}", ha='center', va='top', fontsize=16)
+    #        plt.imshow(analysis['arc_diagrams'][0])  # Asumiendo que arc_diagrams es una lista de imágenes
+
+    #plt.savefig(buffer, format='pdf', bbox_inches='tight')
+    #buffer.seek(0)
+    #return buffer
+
+# Uso:
+# 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/morphosyntax_iterative_mongo_db.py

@@ -0,0 +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/semantic_export.py

@@ -0,0 +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')
+# st.download_button(label="Descargar PDF", data=pdf_buffer, file_name="interacciones.pdf", mime="application/pdf")

modules/database/semantic_mongo_db.py

@@ -0,0 +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/sql_db.py

@@ -0,0 +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)}")
+        return False

modules/database/writing_progress_mongo_db.py

@@ -0,0 +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)}")
+        return None