Update modules/database/discourse_mongo_db.py

modules/database/discourse_mongo_db.py

@@ -1,23 +1,11 @@
 # modules/database/discourse_mongo_db.py
-# Importaciones estándar
-import io
 import base64
-from datetime import datetime, timezone
 import logging
+from datetime import datetime, timezone
+from ..database.mongo_db import get_collection, insert_document, find_documents
 
-# 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'
 
 ########################################################################
@@ -27,11 +15,13 @@ def store_student_discourse_result(username, text1, text2, analysis_result):
     Guarda el resultado del análisis de discurso en MongoDB.
     """
     try:
-        # Verificar que el resultado contenga bytes de gráficos
+        # Verificar que el resultado sea válido
         if not analysis_result.get('success', False):
             logger.error("No se puede guardar un análisis fallido")
             return False
             
+        logger.info(f"Almacenando análisis de discurso para {username}")
+        
         # Preparar el documento para MongoDB
         document = {
             'username': username,
@@ -42,19 +32,20 @@ def store_student_discourse_result(username, text1, text2, analysis_result):
             'key_concepts2': analysis_result.get('key_concepts2', [])
         }
         
-        # Codificar gráficos a base64
-        if 'graph1' in analysis_result and isinstance(analysis_result['graph1'], bytes):
-            document['graph1'] = base64.b64encode(analysis_result['graph1']).decode('utf-8')
-            
-        if 'graph2' in analysis_result and isinstance(analysis_result['graph2'], bytes):
-            document['graph2'] = base64.b64encode(analysis_result['graph2']).decode('utf-8')
-            
-        # Crear un gráfico combinado si se desea (opcional)
-        if 'graph1' in document and 'graph2' in document:
-            document['combined_graph'] = document['graph1']  # O alguna combinación
-            
-        # Guardar en MongoDB
-        collection = get_collection('student_discourse_analysis')
+        # Codificar gráficos a base64 para almacenamiento
+        for graph_key in ['graph1', 'graph2', 'combined_graph']:
+            if graph_key in analysis_result and analysis_result[graph_key] is not None:
+                if isinstance(analysis_result[graph_key], bytes):
+                    logger.info(f"Codificando {graph_key} como base64")
+                    document[graph_key] = base64.b64encode(analysis_result[graph_key]).decode('utf-8')
+                    logger.info(f"{graph_key} codificado correctamente, longitud: {len(document[graph_key])}")
+                else:
+                    logger.warning(f"{graph_key} no es de tipo bytes, es: {type(analysis_result[graph_key])}")
+            else:
+                logger.info(f"{graph_key} no presente en el resultado del análisis")
+        
+        # Almacenar el documento en MongoDB
+        collection = get_collection(COLLECTION_NAME)
         if not collection:
             logger.error("No se pudo obtener la colección")
             return False
@@ -76,26 +67,29 @@ def get_student_discourse_analysis(username, limit=10):
     Recupera los análisis del discurso de un estudiante.
     """
     try:
-        collection = get_collection('student_discourse_analysis')
+        logger.info(f"Recuperando análisis de discurso para {username}")
+        
+        collection = get_collection(COLLECTION_NAME)
         if not collection:
             logger.error("No se pudo obtener la colección")
             return []
             
         query = {"username": username}
         documents = list(collection.find(query).sort("timestamp", -1).limit(limit))
+        logger.info(f"Recuperados {len(documents)} documentos")
         
-        # Decodificar gráficos de base64 a bytes
+        # Decodificar gráficos para uso en la aplicación
         for doc in documents:
-            try:
-                if 'graph1' in doc and doc['graph1']:
-                    doc['graph1'] = base64.b64decode(doc['graph1'])
-                if 'graph2' in doc and doc['graph2']:
-                    doc['graph2'] = base64.b64decode(doc['graph2'])
-                if 'combined_graph' in doc and doc['combined_graph']:
-                    doc['combined_graph'] = base64.b64decode(doc['combined_graph'])
-            except Exception as decode_error:
-                logger.error(f"Error decodificando gráficos: {str(decode_error)}")
-                
+            for graph_key in ['graph1', 'graph2', 'combined_graph']:
+                if graph_key in doc and doc[graph_key]:
+                    try:
+                        logger.info(f"Decodificando {graph_key} de base64 a bytes")
+                        doc[graph_key] = base64.b64decode(doc[graph_key])
+                        logger.info(f"{graph_key} decodificado correctamente")
+                    except Exception as decode_error:
+                        logger.error(f"Error decodificando {graph_key}: {str(decode_error)}")
+                        doc[graph_key] = None
+        
         return documents
         
     except Exception as e: