Update modules/database/discourse_mongo_db.py

modules/database/discourse_mongo_db.py

@@ -23,96 +23,40 @@ 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.
+    Guarda el resultado del análisis de discurso en MongoDB.
+    Los gráficos ya deben venir en formato bytes.
     """
     try:
-        # Verificar qué tipo de objetos son los gráficos para depuración
-        if 'graph1' in analysis_result:
-            logger.info(f"Tipo de graph1 recibido: {type(analysis_result['graph1'])}")
-        if 'graph2' in analysis_result:
-            logger.info(f"Tipo de graph2 recibido: {type(analysis_result['graph2'])}")
-        if 'combined_graph' in analysis_result:
-            logger.info(f"Tipo de combined_graph recibido: {type(analysis_result['combined_graph'])}")
-            
-        # Convertir gráficos a bytes o base64 según corresponda
+        logger.info(f"Almacenando análisis de discurso para {username}")
+        
+        # Los gráficos ya vienen en bytes, solo codificar a base64 para almacenamiento
         graph1_data = None
         graph2_data = None
         combined_graph_data = None
 
+        # Codificar graph1 si existe
         if 'graph1' in analysis_result and analysis_result['graph1'] is not None:
             try:
-                # Si es un objeto matplotlib Figure, convertirlo a bytes primero
-                if hasattr(analysis_result['graph1'], 'savefig'):
-                    logger.info("Convirtiendo graph1 de matplotlib a bytes")
-                    buf = io.BytesIO()
-                    analysis_result['graph1'].savefig(buf, format='png', dpi=100)
-                    buf.seek(0)
-                    graph1_bytes = buf.getvalue()
-                    graph1_data = base64.b64encode(graph1_bytes).decode('utf-8')
-                # Si ya es bytes, codificarlo directamente
-                elif isinstance(analysis_result['graph1'], bytes):
-                    logger.info("Codificando graph1 (ya en bytes) a base64")
-                    graph1_data = base64.b64encode(analysis_result['graph1']).decode('utf-8')
-                # Si ya es una cadena base64, usarla directamente
-                elif isinstance(analysis_result['graph1'], str):
-                    logger.info("Usando graph1 (ya en string) directamente")
-                    graph1_data = analysis_result['graph1']
-                # Otro tipo - convertir a string
-                else:
-                    logger.warning(f"Tipo inesperado para graph1: {type(analysis_result['graph1'])}")
-                    graph1_data = str(analysis_result['graph1'])
+                graph1_data = base64.b64encode(analysis_result['graph1']).decode('utf-8')
+                logger.info(f"Graph1 codificado en base64 ({len(graph1_data)} caracteres)")
             except Exception as e:
-                logger.error(f"Error al procesar gráfico 1: {str(e)}")
+                logger.error(f"Error al codificar gráfico 1: {str(e)}")
 
+        # Codificar graph2 si existe
         if 'graph2' in analysis_result and analysis_result['graph2'] is not None:
             try:
-                # Si es un objeto matplotlib Figure, convertirlo a bytes primero
-                if hasattr(analysis_result['graph2'], 'savefig'):
-                    logger.info("Convirtiendo graph2 de matplotlib a bytes")
-                    buf = io.BytesIO()
-                    analysis_result['graph2'].savefig(buf, format='png', dpi=100)
-                    buf.seek(0)
-                    graph2_bytes = buf.getvalue()
-                    graph2_data = base64.b64encode(graph2_bytes).decode('utf-8')
-                # Si ya es bytes, codificarlo directamente
-                elif isinstance(analysis_result['graph2'], bytes):
-                    logger.info("Codificando graph2 (ya en bytes) a base64")
-                    graph2_data = base64.b64encode(analysis_result['graph2']).decode('utf-8')
-                # Si ya es una cadena base64, usarla directamente
-                elif isinstance(analysis_result['graph2'], str):
-                    logger.info("Usando graph2 (ya en string) directamente")
-                    graph2_data = analysis_result['graph2']
-                # Otro tipo - convertir a string
-                else:
-                    logger.warning(f"Tipo inesperado para graph2: {type(analysis_result['graph2'])}")
-                    graph2_data = str(analysis_result['graph2'])
+                graph2_data = base64.b64encode(analysis_result['graph2']).decode('utf-8')
+                logger.info(f"Graph2 codificado en base64 ({len(graph2_data)} caracteres)")
             except Exception as e:
-                logger.error(f"Error al procesar gráfico 2: {str(e)}")
+                logger.error(f"Error al codificar gráfico 2: {str(e)}")
 
+        # Codificar combined_graph si existe
         if 'combined_graph' in analysis_result and analysis_result['combined_graph'] is not None:
             try:
-                # Si es un objeto matplotlib Figure, convertirlo a bytes primero
-                if hasattr(analysis_result['combined_graph'], 'savefig'):
-                    logger.info("Convirtiendo combined_graph de matplotlib a bytes")
-                    buf = io.BytesIO()
-                    analysis_result['combined_graph'].savefig(buf, format='png', dpi=100)
-                    buf.seek(0)
-                    combined_graph_bytes = buf.getvalue()
-                    combined_graph_data = base64.b64encode(combined_graph_bytes).decode('utf-8')
-                # Si ya es bytes, codificarlo directamente
-                elif isinstance(analysis_result['combined_graph'], bytes):
-                    logger.info("Codificando combined_graph (ya en bytes) a base64")
-                    combined_graph_data = base64.b64encode(analysis_result['combined_graph']).decode('utf-8')
-                # Si ya es una cadena base64, usarla directamente
-                elif isinstance(analysis_result['combined_graph'], str):
-                    logger.info("Usando combined_graph (ya en string) directamente")
-                    combined_graph_data = analysis_result['combined_graph']
-                # Otro tipo - convertir a string
-                else:
-                    logger.warning(f"Tipo inesperado para combined_graph: {type(analysis_result['combined_graph'])}")
-                    combined_graph_data = str(analysis_result['combined_graph'])
+                combined_graph_data = base64.b64encode(analysis_result['combined_graph']).decode('utf-8')
+                logger.info(f"Combined_graph codificado en base64 ({len(combined_graph_data)} caracteres)")
             except Exception as e:
-                logger.error(f"Error al procesar gráfico combinado: {str(e)}")
+                logger.error(f"Error al codificar gráfico combinado: {str(e)}")
 
         # Crear documento para MongoDB
         analysis_document = {
@@ -131,7 +75,7 @@ def store_student_discourse_result(username, text1, text2, analysis_result):
         # 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}")
+            logger.info(f"Análisis del discurso guardado con ID: {result}")
             return True
 
         logger.error("No se pudo insertar el documento en MongoDB")
@@ -147,7 +91,7 @@ def store_student_discourse_result(username, text1, text2, analysis_result):
 
 def get_student_discourse_analysis(username, limit=10):
     """
-    Recupera los análisis del discurso de un estudiante, incluyendo todos los gráficos y conceptos.
+    Recupera los análisis del discurso de un estudiante.
     """
     try:
         # Obtener la colección
@@ -162,36 +106,45 @@ def get_student_discourse_analysis(username, limit=10):
             "analysis_type": "discourse"
         }
         
-        # Eliminar la proyección para recuperar todos los campos
-        # No usar projection para obtener TODOS los campos
+        # NO usar projection - recuperar todos los campos
         
         # Ejecutar consulta
-        try:
-            cursor = collection.find(query).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}")
-            
-            # Verificar qué campos contienen los resultados para depuración
-            if results:
-                for result in results:
-                    logger.info(f"Campos disponibles: {list(result.keys())}")
-                    if 'graph1' in result:
-                        logger.info(f"Tipo de graph1: {type(result['graph1'])}")
-                    if 'graph2' in result:
-                        logger.info(f"Tipo de graph2: {type(result['graph2'])}")
-                    if 'combined_graph' in result:
-                        logger.info(f"Tipo de combined_graph: {type(result['combined_graph'])}")
+        cursor = collection.find(query).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}")
+        
+        # Decodificar gráficos de base64 a bytes para su uso en la aplicación
+        for result in results:
+            # Decodificar graph1
+            if 'graph1' in result and result['graph1']:
+                try:
+                    result['graph1'] = base64.b64decode(result['graph1'])
+                except Exception as e:
+                    logger.error(f"Error decodificando graph1: {str(e)}")
+                    result['graph1'] = None
             
-            return results
+            # Decodificar graph2
+            if 'graph2' in result and result['graph2']:
+                try:
+                    result['graph2'] = base64.b64decode(result['graph2'])
+                except Exception as e:
+                    logger.error(f"Error decodificando graph2: {str(e)}")
+                    result['graph2'] = None
             
-        except Exception as db_error:
-            logger.error(f"Error en la consulta a MongoDB: {str(db_error)}")
-            return []
+            # Decodificar combined_graph
+            if 'combined_graph' in result and result['combined_graph']:
+                try:
+                    result['combined_graph'] = base64.b64decode(result['combined_graph'])
+                except Exception as e:
+                    logger.error(f"Error decodificando combined_graph: {str(e)}")
+                    result['combined_graph'] = None
         
+        return results
+            
     except Exception as e:
         logger.error(f"Error recuperando análisis del discurso: {str(e)}")
         return []