Create claude_recommendations_mongo_db.py

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 []