Update modules/database/discourse_mongo_db.py

modules/database/discourse_mongo_db.py

@@ -21,68 +21,50 @@ 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 en MongoDB.
-    Los gráficos ya deben venir en formato bytes.
     """
     try:
-        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:
-                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 codificar gráfico 1: {str(e)}")
-
-        # Codificar graph2 si existe
-        if 'graph2' in analysis_result and analysis_result['graph2'] is not None:
-            try:
-                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 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:
-                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 codificar gráfico combinado: {str(e)}")
-
-        # Crear documento para MongoDB
-        analysis_document = {
+        # Verificar que el resultado contenga bytes de gráficos
+        if not analysis_result.get('success', False):
+            logger.error("No se puede guardar un análisis fallido")
+            return False
+            
+        # Preparar el documento para MongoDB
+        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
+            'key_concepts2': analysis_result.get('key_concepts2', [])
         }
-
-        # Insertar en MongoDB
-        result = insert_document(COLLECTION_NAME, analysis_document)
-        if result:
-            logger.info(f"Análisis del discurso guardado con ID: {result}")
-            return True
-
-        logger.error("No se pudo insertar el documento en MongoDB")
-        return False
-
+        
+        # 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')
+        if not collection:
+            logger.error("No se pudo obtener la colección")
+            return False
+            
+        result = collection.insert_one(document)
+        logger.info(f"Análisis de discurso guardado con ID: {result.inserted_id}")
+        return True
+        
     except Exception as e:
-        logger.error(f"Error al guardar el análisis del discurso: {str(e)}")
+        logger.error(f"Error guardando análisis de discurso: {str(e)}")
         return False
 
 #################################################################################
@@ -94,59 +76,30 @@ 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:
-            logger.error("No se pudo obtener la colección discourse")
+        collection = get_collection('student_discourse_analysis')
+        if not collection:
+            logger.error("No se pudo obtener la colección")
             return []
-
-        # Consulta
-        query = {
-            "username": username,
-            "analysis_type": "discourse"
-        }
-        
-        # NO usar projection - recuperar todos los campos
-        
-        # Ejecutar consulta
-        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
-            
-            # 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
             
-            # 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
+        query = {"username": username}
+        documents = list(collection.find(query).sort("timestamp", -1).limit(limit))
+        
+        # Decodificar gráficos de base64 a bytes
+        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)}")
+                
+        return documents
         
-        return results
-            
     except Exception as e:
-        logger.error(f"Error recuperando análisis del discurso: {str(e)}")
+        logger.error(f"Error recuperando análisis de discurso: {str(e)}")
         return []
         
 #####################################################################################