update recommendation

src/api/recommendation_routes.py

@@ -1,40 +1,28 @@
-# from fastapi import APIRouter
-# from typing import Dict, Any
-
-# router = APIRouter(prefix="/recommendations", tags=["Recommendations"])
-
-# @router.get("")
-# async def get_general_recommendations() -> Dict[str, Any]:
-#     """
-#     Placeholder endpoint for future ML recommendation logic.
-#     """
-#     return {
-#         "status": "success",
-#         "recommendations": []
-#     }
-
-
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
 from typing import Dict, Any
+from src.auth.dependencies import get_current_user
+from src.db.firebase import get_firebase_db
+from src.recommendation.recommender import RecommendationService
+from src.utils.logger import setup_logger
 
+logger = setup_logger(__name__)
 router = APIRouter(prefix="/recommendations", tags=["Recommendations"])
+recommendation_service = RecommendationService()
 
 @router.get("")
-async def get_general_recommendations() -> Dict[str, Any]:
-    """
-    Placeholder endpoint for future ML recommendation logic.
-      """
+async def get_general_recommendations(
+    current_user=Depends(get_current_user),
+    db=Depends(get_firebase_db)
+) -> Dict[str, Any]:
+    logger.info(f"🎯 Getting recommendations for user: {current_user['uid']}")
+    
+    recommendations = await recommendation_service.get_recommendations_for_user(
+        db=db,
+        user_id=current_user['uid'],
+        limit=5
+    )
+    
     return {
         "status": "success",
-        "recommendations": [
-            {
-                "id": "vS07S_yIn_U",
-                "title": "Introduction to Neural Networks",
-                "description": "Learn the basics of Neural Networks in this educational video.",
-                "thumbnail": "https://i.ytimg.com/vi/vS07S_yIn_U/mqdefault.jpg",
-                "channelTitle": "AI Academy",
-                "url": "https://www.youtube.com/watch?v=vS07S_yIn_U",
-                "type": "youtube_video"
-            }
-        ]
+        "recommendations": recommendations
     }

src/recommendation/recommender.py

@@ -1,86 +1,80 @@
 import asyncio
 from typing import List, Dict, Optional
-from google import genai
 from googleapiclient.discovery import build
-from sqlmodel import select
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from src.db.models import Note
 from src.utils.logger import setup_logger
-from src.utils.config import settings
 
 import os
 from dotenv import load_dotenv
 load_dotenv()
 
-
 logger = setup_logger(__name__)
 
 
 class RecommendationService:
     """
-    Service for suggesting videos and categories based on user's saved notes.
-    Uses keyword overlap and YouTube Search API for new recommendations.
+    Service for suggesting videos based on user's saved notes.
+    Uses YouTube Search API for recommendations.
     """
 
     def __init__(self, api_key: Optional[str] = None):
-
         self.api_key = "AIzaSyA3erB-Lxd5SOoBOXaumOCVaEr3TcgYG60"
-        # Use the newer google-genai client
-        # self.client = genai.Client(api_key=self.api_key)
         self.youtube = build("youtube", "v3", developerKey=self.api_key)
 
     async def get_recommendations_for_user(
-        self, session: AsyncSession, user_id: int, limit: int = 5
+        self, db, user_id: str, limit: int = 5
     ) -> List[Dict]:
         """
-        Get general recommendations (Categories & YouTube Videos) for a user based on their history.
+        Get recommendations based on user's note history in Firebase.
         """
-        # 1. Fetch user's saved notes
-        statement = (
-            select(Note).where(Note.user_id == user_id).order_by(Note.created_at.desc())
-        )
-        result = await session.exec(statement)
-        notes = result.all()
+        logger.info(f"📚 Fetching notes for user: {user_id}")
 
-        if not notes:
-            return await self.get_youtube_recommendations(
-                "educational tutorials", limit
+        try:
+            notes_ref = (
+                db.collection("notes")
+                .where("user_id", "==", user_id)
+                .order_by("created_at", direction="DESCENDING")
+                .limit(5)
             )
+            notes_docs = notes_ref.stream()
+            notes = [doc.to_dict() for doc in notes_docs]
+            logger.info(f"📝 Found {len(notes)} notes for user")
+        except Exception as e:
+            logger.error(f"❌ Failed to fetch notes from Firebase: {e}")
+            notes = []
+
+        if not notes:
+            logger.info("⚠️ No notes found, returning general recommendations")
+            return await self.get_youtube_recommendations("educational tutorials", limit)
 
-        # 2. Extract topics from categories of recent notes
+        # Extract topics from note categories
         topics = [
-            n.category
+            n.get("category")
             for n in notes[:5]
-            if n.category and n.category != "Uncategorized"
+            if n.get("category") and n.get("category") != "Uncategorized"
         ]
 
-        # If no categories, use titles
+        # If no categories found, fall back to video titles
         if not topics:
-            topics = [n.video_title for n in notes[:3]]
+            topics = [n.get("video_title", "") for n in notes[:3]]
 
         search_query = " ".join(topics[:3])
+        logger.info(f"🔍 Search query built: {search_query}")
 
-        # 3. Get YouTube recommendations
-        youtube_recs = await self.get_youtube_recommendations(search_query, limit)
-
-        return youtube_recs
+        return await self.get_youtube_recommendations(search_query, limit)
 
     async def get_youtube_recommendations(
         self, query: str, limit: int = 5
     ) -> List[Dict]:
         """
-        Search YouTube for new videos based on a query.
-        Prioritizes educational content.
+        Search YouTube for videos based on a query.
         """
         if not query:
             return []
 
-        # Enhance query for better educational results
         enhanced_query = f"{query} educational lecture tutorial"
+        logger.info(f"🎬 Searching YouTube for: {enhanced_query}")
 
         try:
-            # Run in thread pool since google-api-python-client is synchronous
             loop = asyncio.get_event_loop()
             search_response = await loop.run_in_executor(
                 None,
@@ -110,37 +104,11 @@ class RecommendationService:
                         "type": "youtube_video",
                     }
                 )
-                # ✨ السطر ده اللي هيظهرلك الفيديو في الـ Logs
-                logger.info(f"✅ Found Video: {snippet['title']}")
+                logger.info(f"✅ Found video: {snippet['title']}")
 
-            # ✨ السطر ده عشان تعرفي إجمالي اللي رجع كام فيديو
             logger.info(f"🚀 Total videos fetched: {len(videos)}")
             return videos
-        except Exception as e:
-            logger.error(f"YouTube search failed: {e}")
-            return []
 
-    async def get_similar_notes(
-        self, session: AsyncSession, note_id: int, limit: int = 3
-    ) -> List[Note]:
-        """
-        Find notes similar to a specific note based on category.
-        """
-        # Fetch the target note
-        target_note = await session.get(Note, note_id)
-        if not target_note:
-            return []
-
-        # Fetch other notes in the same category
-        statement = (
-            select(Note)
-            .where(
-                Note.id != note_id,
-                Note.category == target_note.category,
-                Note.user_id == target_note.user_id,
-            )
-            .limit(limit)
-        )
-
-        result = await session.exec(statement)
-        return result.all()
+        except Exception as e:
+            logger.error(f"❌ YouTube search failed: {e}")
+            return []