Add POST endpoint to check user category data and return recommendations

app/main.py

@@ -6,7 +6,7 @@ import os
 import time
 from typing import List, Optional
 from datetime import datetime, timedelta, timezone
-from app.models import BudgetRecommendation, Expense, Budget, CategoryExpense
+from app.models import BudgetRecommendation, Expense, Budget, CategoryExpense, RecommendationRequest, RecommendationResponse
 from app.smart_recommendation import SmartBudgetRecommender
 
 app = FastAPI(title="Smart Budget Recommendation API", version="1.0.0")
@@ -213,6 +213,60 @@ async def get_category_expenses(user_id: str, months: int = 3):
     category_expenses = recommender.get_category_averages(user_id, months)
     return category_expenses
 
+@app.post("/recommendations/check", response_model=RecommendationResponse)
+async def check_and_get_recommendations(request: RecommendationRequest, month: Optional[int] = None, year: Optional[int] = None):
+    """
+    Check if user has previous data for a category and return recommendations if available.
+    
+    Request body:
+    {
+        "user_id": "68a834c3f4694b11efedacd2",
+        "category_id": "688c80ca990b63f0e945ecf1"
+    }
+    
+    Response:
+    - If user has previous data: returns recommendations
+    - If user doesn't have previous data: returns message indicating no previous data
+    """
+    if not month or not year:
+        # Default to next month
+        next_month = datetime.now().replace(day=1) + timedelta(days=32)
+        month = next_month.month
+        year = next_month.year
+    
+    # Check if user has previous data for this category
+    has_data = recommender.check_user_has_category_data(request.user_id, request.category_id)
+    
+    if has_data:
+        # Get recommendations for this specific category
+        recommendations = recommender.get_recommendation_for_category(
+            request.user_id, 
+            request.category_id, 
+            month, 
+            year
+        )
+        
+        if recommendations:
+            return RecommendationResponse(
+                has_previous_data=True,
+                recommendations=recommendations,
+                message=None
+            )
+        else:
+            # User has data but no recommendations generated (edge case)
+            return RecommendationResponse(
+                has_previous_data=True,
+                recommendations=[],
+                message="User has previous data but no recommendations could be generated for this category."
+            )
+    else:
+        # User doesn't have previous data
+        return RecommendationResponse(
+            has_previous_data=False,
+            recommendations=None,
+            message=f"User does not have previous data for category_id: {request.category_id}. Please create a budget or add expenses for this category first."
+        )
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)

app/models.py

@@ -41,3 +41,12 @@ class CategoryExpense(BaseModel):
     total_expenses: int
     months_analyzed: int
 
+class RecommendationRequest(BaseModel):
+    user_id: str = Field(..., description="User identifier")
+    category_id: str = Field(..., description="Category ID to check for previous data")
+
+class RecommendationResponse(BaseModel):
+    has_previous_data: bool
+    message: Optional[str] = None
+    recommendations: Optional[List[BudgetRecommendation]] = None
+

app/smart_recommendation.py

@@ -50,7 +50,15 @@ class SmartBudgetRecommender:
 
         for category_key, data in category_data.items():
             # Extract category_name and category_id from data
-            category_name = data.get("category_name", category_key.split("|")[0] if "|" in category_key else category_key)
+            # category_key format: "user_id|category_name|category_id"
+            key_parts = category_key.split("|")
+            if len(key_parts) >= 3:
+                # Skip user_id (first part), get category_name (second part)
+                category_name = data.get("category_name", key_parts[1])
+            elif len(key_parts) >= 2:
+                category_name = data.get("category_name", key_parts[1])
+            else:
+                category_name = data.get("category_name", category_key)
             category_id = data.get("category_id")
             avg_expense = data["average_monthly"]
             confidence = self._calculate_confidence(data)
@@ -87,6 +95,115 @@ class SmartBudgetRecommender:
         
         return recommendations
     
+    def check_user_has_category_data(self, user_id: str, category_id: str) -> bool:
+        """
+        Check if user has previous budget or expense data for a specific category.
+        
+        Args:
+            user_id: User identifier
+            category_id: Category ID to check
+            
+        Returns:
+            True if user has previous data for this category, False otherwise
+        """
+        # Check if user has budgets with this category_id
+        try:
+            # Try ObjectId format
+            try:
+                category_objid = ObjectId(category_id)
+                budget_query = {
+                    "$or": [
+                        {"createdBy": ObjectId(user_id), "category": category_objid},
+                        {"createdBy": ObjectId(user_id), "categoryId": category_objid},
+                        {"createdBy": ObjectId(user_id), "headCategory": category_objid},
+                        {"createdBy": user_id, "category": category_objid},
+                        {"createdBy": user_id, "categoryId": category_objid},
+                        {"createdBy": user_id, "headCategory": category_objid},
+                        {"user_id": ObjectId(user_id), "category": category_objid},
+                        {"user_id": user_id, "category": category_objid},
+                    ]
+                }
+            except (ValueError, TypeError):
+                # category_id is not a valid ObjectId, try as string
+                budget_query = {
+                    "$or": [
+                        {"createdBy": ObjectId(user_id), "category": category_id},
+                        {"createdBy": ObjectId(user_id), "categoryId": category_id},
+                        {"createdBy": ObjectId(user_id), "headCategory": category_id},
+                        {"createdBy": user_id, "category": category_id},
+                        {"createdBy": user_id, "categoryId": category_id},
+                        {"createdBy": user_id, "headCategory": category_id},
+                        {"user_id": ObjectId(user_id), "category": category_id},
+                        {"user_id": user_id, "category": category_id},
+                    ]
+                }
+            
+            # Check budgets collection
+            budget_count = self.db.budgets.count_documents(budget_query)
+            if budget_count > 0:
+                print(f"✅ Found {budget_count} budget(s) for user {user_id} with category_id {category_id}")
+                return True
+            
+            # Also check if category_id is in headCategories array
+            head_cat_query = {
+                "$or": [
+                    {"createdBy": ObjectId(user_id), "headCategories.category": category_id},
+                    {"createdBy": user_id, "headCategories.category": category_id},
+                    {"user_id": ObjectId(user_id), "headCategories.category": category_id},
+                    {"user_id": user_id, "headCategories.category": category_id},
+                ]
+            }
+            head_cat_count = self.db.budgets.count_documents(head_cat_query)
+            if head_cat_count > 0:
+                print(f"✅ Found {head_cat_count} budget(s) with category_id {category_id} in headCategories for user {user_id}")
+                return True
+            
+            # Check expenses collection
+            try:
+                expense_query = {
+                    "$or": [
+                        {"user_id": ObjectId(user_id), "category": category_id},
+                        {"user_id": user_id, "category": category_id},
+                    ]
+                }
+                expense_count = self.db.expenses.count_documents(expense_query)
+                if expense_count > 0:
+                    print(f"✅ Found {expense_count} expense(s) for user {user_id} with category_id {category_id}")
+                    return True
+            except Exception as e:
+                print(f"Error checking expenses: {e}")
+            
+            print(f"❌ No previous data found for user {user_id} with category_id {category_id}")
+            return False
+            
+        except Exception as e:
+            print(f"Error checking user category data: {e}")
+            return False
+    
+    def get_recommendation_for_category(self, user_id: str, category_id: str, month: int, year: int) -> List[BudgetRecommendation]:
+        """
+        Get budget recommendations for a specific category for a user.
+        
+        Args:
+            user_id: User identifier
+            category_id: Category ID to get recommendations for
+            month: Target month (1-12)
+            year: Target year
+            
+        Returns:
+            List of budget recommendations for the specific category
+        """
+        # Get all recommendations for the user
+        all_recommendations = self.get_recommendations(user_id, month, year)
+        
+        # Filter to only include recommendations for the specified category_id
+        filtered_recommendations = [
+            rec for rec in all_recommendations 
+            if rec.category_id == category_id or str(rec.category_id) == str(category_id)
+        ]
+        
+        return filtered_recommendations
+    
     def _calculate_category_statistics(self, expenses: List[Dict], start_date: datetime, end_date: datetime) -> Dict:
         """Calculate statistics for each category"""
         category_data = defaultdict(lambda: {
@@ -547,8 +664,10 @@ class SmartBudgetRecommender:
             # Only add budget if it has an amount - use category name as key
             # Store both category_name and category_id in the result
             if base_amount > 0:
-                # Use a unique key that includes category_id to handle multiple budgets with same category name
-                result_key = f"{category_name}|{category_id}" if category_id else category_name
+                # Use a unique key that includes user_id and category_id to ensure user-specific grouping
+                # This prevents budgets from different users with same category name from being mixed
+                category_id_str = str(category_id) if category_id else "none"
+                result_key = f"{user_id}|{category_name}|{category_id_str}"
                 
                 if result_key not in result:
                     result[result_key] = {
@@ -570,9 +689,15 @@ class SmartBudgetRecommender:
                     )
                     result[result_key]["monthly_values"].append(base_amount)
 
-        # Extract category names for logging
-        category_names = [data.get("category_name", key.split("|")[0] if "|" in key else key) for key, data in result.items()]
-        print(f"✅ Processed {len(result)} budget categories for recommendations: {category_names}")
+        # Extract category names for logging (skip user_id part in key)
+        category_names = []
+        for key, data in result.items():
+            key_parts = key.split("|")
+            if len(key_parts) >= 2:
+                category_names.append(key_parts[1])  # Get category_name (second part after user_id)
+            else:
+                category_names.append(data.get("category_name", key))
+        print(f"✅ Processed {len(result)} budget categories for user {user_id}: {category_names}")
         return result
 
     def _get_ai_recommendation(self, category: str, data: Dict, avg_expense: float):