Add new endpoint /recommendations/by-name to accept Head Category names instead of category_id for easier frontend integration

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, RecommendationRequest, RecommendationResponse
+from app.models import BudgetRecommendation, Expense, Budget, CategoryExpense, RecommendationRequest, RecommendationResponse, RecommendationByNameRequest, RecommendationByNameRequest
 from app.smart_recommendation import SmartBudgetRecommender
 
 app = FastAPI(title="Smart Budget Recommendation API", version="1.0.0")
@@ -262,6 +262,111 @@ async def check_and_get_recommendations(request: RecommendationRequest, month: O
             message=f"User does not have previous data for category_id: {request.category_id}. Please provide a budget_amount or create a budget/expenses for this category first."
         )
 
+@app.post("/recommendations/by-name", response_model=RecommendationResponse)
+async def get_recommendations_by_category_name(request: RecommendationByNameRequest, month: Optional[int] = None, year: Optional[int] = None):
+    """
+    Get budget recommendations by Head Category name (instead of category_id).
+    This is useful for frontend integration where you only have the category name.
+    
+    Request body:
+    {
+        "user_id": "6741abd38d30ab5b7176397f",
+        "category_name": "Food & Drinks",
+        "budget_amount": 350.0  // optional
+    }
+    
+    Supported Head Category names:
+    - Food & Drinks
+    - Shopping
+    - Housing
+    - Financial Expenses
+    - Communication, PC
+    - Vehicle
+    - Transportation
+    - Life & Entertainment
+    - Investments
+    - Income
+    - Loan Payment
+    - Marketing
+    
+    Response:
+    - If user has previous data: returns recommendations based on historical data
+    - If user doesn't have previous data but provided budget_amount: returns recommendations based on budget_amount
+    - If user doesn't have previous data and no budget_amount: returns message asking for budget_amount
+    """
+    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
+    
+    # Find category_id by name
+    category_id = recommender._get_category_id_by_name(request.category_name)
+    
+    if not category_id:
+        return RecommendationResponse(
+            has_previous_data=False,
+            recommendations=None,
+            message=f"Category '{request.category_name}' not found in database. Please check the category name or create the category first."
+        )
+    
+    # Now use the existing check endpoint logic
+    has_data = recommender.check_user_has_category_data(request.user_id, category_id)
+    
+    if has_data:
+        # User has previous data - use it for recommendations
+        print(f"✅ User {request.user_id} has previous data for category '{request.category_name}' (id: {category_id}) - using historical data")
+        recommendations = recommender.get_recommendation_for_category(
+            request.user_id, 
+            category_id, 
+            month, 
+            year,
+            budget_amount=None  # Don't use budget_amount if user has historical data
+        )
+        
+        if recommendations:
+            return RecommendationResponse(
+                has_previous_data=True,
+                recommendations=recommendations,
+                message=None
+            )
+        else:
+            return RecommendationResponse(
+                has_previous_data=True,
+                recommendations=[],
+                message="User has previous data but no recommendations could be generated for this category."
+            )
+    elif request.budget_amount and request.budget_amount > 0:
+        # User doesn't have previous data, but provided budget_amount
+        print(f"ℹ️ User {request.user_id} does not have previous data for category '{request.category_name}' (id: {category_id}) - using provided budget_amount")
+        recommendations = recommender.get_recommendation_for_category(
+            request.user_id, 
+            category_id, 
+            month, 
+            year,
+            request.budget_amount
+        )
+        
+        if recommendations:
+            return RecommendationResponse(
+                has_previous_data=False,
+                recommendations=recommendations,
+                message="Recommendation generated based on provided budget amount. User does not have previous spending data for this category."
+            )
+        else:
+            return RecommendationResponse(
+                has_previous_data=False,
+                recommendations=None,
+                message="Could not generate recommendations even with provided budget amount."
+            )
+    else:
+        # User doesn't have previous data and no budget_amount provided
+        return RecommendationResponse(
+            has_previous_data=False,
+            recommendations=None,
+            message=f"User does not have previous data for category '{request.category_name}'. Please provide a budget_amount to get recommendations."
+        )
+
 @app.get("/recommendations/{user_id}", response_model=List[BudgetRecommendation])
 async def get_budget_recommendations(user_id: str, month: Optional[int] = None, year: Optional[int] = None):
     """

app/models.py

@@ -63,3 +63,18 @@ class RecommendationResponse(BaseModel):
     message: Optional[str] = None
     recommendations: Optional[List[BudgetRecommendation]] = None
 
+class RecommendationByNameRequest(BaseModel):
+    user_id: str = Field(..., description="User identifier")
+    category_name: str = Field(..., description="Head Category name (e.g., 'Food & Drinks', 'Shopping', 'Housing')")
+    budget_amount: Optional[float] = Field(None, gt=0, description="Current budget amount for this category (optional)")
+    
+    @validator('budget_amount')
+    def validate_budget_amount(cls, v):
+        if v is not None:
+            if v <= 0:
+                raise ValueError('budget_amount must be greater than 0')
+            if v > 1e12:
+                print(f"⚠️ Auto-capping corrupted budget_amount: {v:,.2e} -> 1,000,000,000,000")
+                return 1e12
+        return v
+

app/smart_recommendation.py

@@ -778,6 +778,50 @@ class SmartBudgetRecommender:
         result.sort(key=lambda x: x.average_monthly_expense, reverse=True)
         return result
 
+    def _get_category_id_by_name(self, category_name: str) -> Optional[str]:
+        """
+        Find category_id by category name from headCategories and categories collections.
+        Returns the first matching category_id found.
+        """
+        if not category_name:
+            return None
+        
+        try:
+            # Search in headCategories collection by name
+            head_category = self.db.headCategories.find_one({
+                "$or": [
+                    {"name": {"$regex": category_name, "$options": "i"}},
+                    {"headCategoryName": {"$regex": category_name, "$options": "i"}},
+                    {"categoryName": {"$regex": category_name, "$options": "i"}}
+                ]
+            })
+            
+            if head_category:
+                # Return _id as string
+                category_id = str(head_category.get("_id"))
+                print(f"✅ Found category_id in headCategories: '{category_name}' -> {category_id}")
+                return category_id
+            
+            # Search in categories collection by name
+            category = self.db.categories.find_one({
+                "$or": [
+                    {"name": {"$regex": category_name, "$options": "i"}},
+                    {"categoryName": {"$regex": category_name, "$options": "i"}}
+                ]
+            })
+            
+            if category:
+                category_id = str(category.get("_id"))
+                print(f"✅ Found category_id in categories: '{category_name}' -> {category_id}")
+                return category_id
+            
+            print(f"⚠️ Category name not found: '{category_name}'")
+            return None
+            
+        except Exception as e:
+            print(f"Error looking up category_id by name '{category_name}': {e}")
+            return None
+    
     def _get_category_name(self, category_id) -> str:
         """
         Look up category name from headCategories and categories collections.