Fix recommendation generation when user has data but no recommendations found - Fixed MongoDB query structure for budget lookup - Added fallback logic to generate recommendations from budget data - Added debug logging

app/smart_recommendation.py

@@ -196,65 +196,180 @@ class SmartBudgetRecommender:
         """
         # Get all recommendations for the user
         all_recommendations = self.get_recommendations(user_id, month, year)
+        print(f"🔍 get_recommendation_for_category: Found {len(all_recommendations)} total recommendations for user {user_id}")
         
         # 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)
         ]
-        
-        # If budget_amount is provided and we have a recommendation, use it to generate a new recommendation
-        if budget_amount and budget_amount > 0 and filtered_recommendations:
-            # Get the first recommendation (should be the one for this category)
-            original_rec = filtered_recommendations[0]
-            
-            # Get category name
-            category_name = original_rec.category
-            
-            # Use the provided budget_amount as average_expense for comparison
+        print(f"🔍 get_recommendation_for_category: Filtered to {len(filtered_recommendations)} recommendations for category_id {category_id}")
+        
+        # If we found a recommendation, use it (or regenerate with budget_amount if provided)
+        if filtered_recommendations:
+            # If budget_amount is provided, regenerate recommendation with it
+            if budget_amount and budget_amount > 0:
+                # Get the first recommendation (should be the one for this category)
+                original_rec = filtered_recommendations[0]
+                
+                # Get category name
+                category_name = original_rec.category
+                
+                # Use the provided budget_amount as average_expense for comparison
+                avg_expense = budget_amount
+                
+                # Create data structure for recommendation calculation
+                data = {
+                    "average_monthly": avg_expense,
+                    "total": avg_expense,
+                    "count": 1,
+                    "months_analyzed": 1,
+                    "std_dev": 0.0,
+                    "monthly_values": [avg_expense],
+                }
+                
+                confidence = self._calculate_confidence(data)
+                
+                # Always try OpenAI first (primary source of recommendation)
+                ai_result = self._get_ai_recommendation(category_name, data, avg_expense)
+                if ai_result and ai_result.get("recommended_budget"):
+                    recommended_budget = ai_result.get("recommended_budget")
+                    reason = ai_result.get("reason", f"AI recommendation for {category_name} based on your budget of Rs.{budget_amount:,.2f}")
+                    action = ai_result.get("action")
+                    print(f"✅ OpenAI recommendation for {category_name} (budget: {budget_amount}): {recommended_budget} (action: {action})")
+                else:
+                    # Fallback to rule-based recommendation if OpenAI fails
+                    recommended_budget = self._calculate_recommended_budget(avg_expense, data)
+                    reason = self._generate_reason(category_name, avg_expense, recommended_budget)
+                    action = None
+                    if not ai_result:
+                        print(f"❌ OpenAI unavailable (no API key or error), using rule-based for {category_name} (budget: {budget_amount}): {recommended_budget}")
+                    else:
+                        print(f"⚠️ OpenAI returned invalid data, using rule-based for {category_name} (budget: {budget_amount}): {recommended_budget}")
+                
+                # Create new recommendation based on provided budget_amount
+                filtered_recommendations = [BudgetRecommendation(
+                    category=category_name,
+                    category_id=category_id,
+                    average_expense=round(avg_expense, 2),
+                    recommended_budget=round(recommended_budget or 0, 2),
+                    reason=reason,
+                    confidence=confidence,
+                    action=action
+                )]
+            return filtered_recommendations
+        
+        # If no recommendations found, try to generate one
+        # First, get category name
+        category_name = self._get_category_name(category_id)
+        
+        # If budget_amount is provided, use it
+        if budget_amount and budget_amount > 0:
             avg_expense = budget_amount
-            
-            # Create data structure for recommendation calculation
-            data = {
-                "average_monthly": avg_expense,
-                "total": avg_expense,
-                "count": 1,
-                "months_analyzed": 1,
-                "std_dev": 0.0,
-                "monthly_values": [avg_expense],
-            }
-            
-            confidence = self._calculate_confidence(data)
-            
-            # Always try OpenAI first (primary source of recommendation)
-            ai_result = self._get_ai_recommendation(category_name, data, avg_expense)
-            if ai_result and ai_result.get("recommended_budget"):
-                recommended_budget = ai_result.get("recommended_budget")
-                reason = ai_result.get("reason", f"AI recommendation for {category_name} based on your budget of Rs.{budget_amount:,.2f}")
-                action = ai_result.get("action")
-                print(f"✅ OpenAI recommendation for {category_name} (budget: {budget_amount}): {recommended_budget} (action: {action})")
-            else:
-                # Fallback to rule-based recommendation if OpenAI fails
-                recommended_budget = self._calculate_recommended_budget(avg_expense, data)
-                reason = self._generate_reason(category_name, avg_expense, recommended_budget)
-                action = None
-                if not ai_result:
-                    print(f"❌ OpenAI unavailable (no API key or error), using rule-based for {category_name} (budget: {budget_amount}): {recommended_budget}")
+        else:
+            # Try to get budget data for this category
+            try:
+                # Try to find budgets with this category_id
+                try:
+                    category_objid = ObjectId(category_id)
+                except (ValueError, TypeError):
+                    category_objid = category_id
+                
+                # Build user query
+                user_query = {
+                    "$or": [
+                        {"createdBy": ObjectId(user_id) if len(user_id) == 24 and all(c in '0123456789abcdefABCDEF' for c in user_id) else user_id},
+                        {"createdBy": user_id},
+                        {"user_id": ObjectId(user_id) if len(user_id) == 24 and all(c in '0123456789abcdefABCDEF' for c in user_id) else user_id},
+                        {"user_id": user_id}
+                    ]
+                }
+                
+                # Build category query
+                category_query = {
+                    "$or": [
+                        {"category": category_objid},
+                        {"categoryId": category_objid},
+                        {"headCategory": category_objid},
+                        {"headCategories.headCategory": category_objid},
+                        {"headCategories.categories.category": category_objid}
+                    ]
+                }
+                
+                # Combine queries
+                budget_query = {"$and": [user_query, category_query]}
+                
+                budgets = list(self.db.budgets.find(budget_query).limit(10))
+                print(f"🔍 get_recommendation_for_category: Found {len(budgets)} budgets for user {user_id} and category {category_id}")
+                
+                if budgets:
+                    # Calculate average from budgets
+                    total_amount = 0
+                    count = 0
+                    for budget in budgets:
+                        try:
+                            max_amount = float(budget.get("maxAmount", 0) or budget.get("max_amount", 0) or budget.get("amount", 0) or 0)
+                            spend_amount = float(budget.get("spendAmount", 0) or budget.get("spend_amount", 0) or budget.get("spent", 0) or 0)
+                            budget_amount_val = float(budget.get("budget", 0) or budget.get("budgetAmount", 0) or 0)
+                            
+                            base_amount = spend_amount if spend_amount > 0 else (max_amount if max_amount > 0 else budget_amount_val)
+                            if base_amount > 0:
+                                total_amount += base_amount
+                                count += 1
+                        except (ValueError, TypeError):
+                            continue
+                    
+                    if count > 0:
+                        avg_expense = total_amount / count
+                    else:
+                        # No valid amounts found, can't generate recommendation
+                        return []
                 else:
-                    print(f"⚠️ OpenAI returned invalid data, using rule-based for {category_name} (budget: {budget_amount}): {recommended_budget}")
-            
-            # Create new recommendation based on provided budget_amount
-            filtered_recommendations = [BudgetRecommendation(
-                category=category_name,
-                category_id=category_id,
-                average_expense=round(avg_expense, 2),
-                recommended_budget=round(recommended_budget or 0, 2),
-                reason=reason,
-                confidence=confidence,
-                action=action
-            )]
-        
-        return filtered_recommendations
+                    # No budgets found for this category
+                    return []
+            except Exception as e:
+                print(f"Error getting budget data for category: {e}")
+                return []
+        
+        # Generate recommendation
+        data = {
+            "average_monthly": avg_expense,
+            "total": avg_expense,
+            "count": 1,
+            "months_analyzed": 1,
+            "std_dev": 0.0,
+            "monthly_values": [avg_expense],
+        }
+        
+        confidence = self._calculate_confidence(data)
+        
+        # Always try OpenAI first
+        ai_result = self._get_ai_recommendation(category_name, data, avg_expense)
+        if ai_result and ai_result.get("recommended_budget"):
+            recommended_budget = ai_result.get("recommended_budget")
+            reason = ai_result.get("reason", f"AI recommendation for {category_name}")
+            action = ai_result.get("action")
+            print(f"✅ OpenAI recommendation for {category_name}: {recommended_budget} (action: {action})")
+        else:
+            # Fallback to rule-based recommendation if OpenAI fails
+            recommended_budget = self._calculate_recommended_budget(avg_expense, data)
+            reason = self._generate_reason(category_name, avg_expense, recommended_budget)
+            action = None
+            if not ai_result:
+                print(f"❌ OpenAI unavailable (no API key or error), using rule-based for {category_name}: {recommended_budget}")
+            else:
+                print(f"⚠️ OpenAI returned invalid data, using rule-based for {category_name}: {recommended_budget}")
+        
+        # Create recommendation
+        return [BudgetRecommendation(
+            category=category_name,
+            category_id=category_id,
+            average_expense=round(avg_expense, 2),
+            recommended_budget=round(recommended_budget or 0, 2),
+            reason=reason,
+            confidence=confidence,
+            action=action
+        )]
     
     def _calculate_category_statistics(self, expenses: List[Dict], start_date: datetime, end_date: datetime) -> Dict:
         """Calculate statistics for each category"""

find_user_with_data.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+from pymongo import MongoClient
+from bson import ObjectId
+import sys
+import io
+import json
+
+# Fix encoding for Windows console
+if sys.platform == 'win32':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+# MongoDB connection string
+MONGODB_URI = "mongodb://expenseuser:Kem_6o%3F%3F@165.227.69.221:27017/expense?authSource=admin"
+
+try:
+    # Connect to MongoDB
+    client = MongoClient(MONGODB_URI)
+    db = client.expense
+    
+    # Test connection
+    client.admin.command('ping')
+    print("[OK] Successfully connected to MongoDB")
+    print(f"Database: expense\n")
+    
+    # Find users with budgets that have category_id
+    print("Searching for users with budgets that have category_id...")
+    
+    # Get user with most budgets
+    user_with_most_budgets = "6741abd38d30ab5b7176397f"
+    print(f"\nChecking user: {user_with_most_budgets} (has 243 budgets)")
+    
+    # Get budgets for this user
+    user_budgets = list(db.budgets.find({
+        "$or": [
+            {"createdBy": ObjectId(user_with_most_budgets)},
+            {"createdBy": user_with_most_budgets},
+            {"user_id": ObjectId(user_with_most_budgets)},
+            {"user_id": user_with_most_budgets}
+        ]
+    }).limit(20))
+    
+    print(f"Found {len(user_budgets)} budgets for this user\n")
+    
+    valid_combinations = []
+    
+    for budget in user_budgets:
+        created_by = str(budget.get("createdBy") or budget.get("user_id", ""))
+        category_id = None
+        
+        # Try direct category fields
+        category_id = budget.get("category") or budget.get("categoryId") or budget.get("headCategory")
+        
+        # Check headCategories array
+        if not category_id:
+            head_categories = budget.get("headCategories", [])
+            if head_categories and isinstance(head_categories, list):
+                for head_cat in head_categories:
+                    if isinstance(head_cat, dict):
+                        # Get headCategory ID
+                        head_cat_id = head_cat.get("headCategory")
+                        if head_cat_id:
+                            category_id = head_cat_id
+                            break
+                        
+                        # Get nested category IDs
+                        nested_cats = head_cat.get("categories", [])
+                        if nested_cats and isinstance(nested_cats, list):
+                            for nested_cat in nested_cats:
+                                if isinstance(nested_cat, dict):
+                                    nested_cat_id = nested_cat.get("category")
+                                    if nested_cat_id:
+                                        category_id = nested_cat_id
+                                        break
+                            if category_id:
+                                break
+        
+        if category_id:
+            valid_combinations.append({
+                "user_id": created_by,
+                "category_id": str(category_id),
+                "budget_name": budget.get("name", "N/A"),
+                "budget_id": str(budget.get("_id"))
+            })
+    
+    print(f"{'='*60}")
+    print(f"Found {len(valid_combinations)} budgets with category_id")
+    print(f"{'='*60}\n")
+    
+    if valid_combinations:
+        print("[OK] User ID and Category ID combinations for testing:")
+        print("-" * 60)
+        seen = set()
+        for i, combo in enumerate(valid_combinations[:10], 1):
+            key = (combo["user_id"], combo["category_id"])
+            if key not in seen:
+                seen.add(key)
+                print(f"{i}. user_id: {combo['user_id']}")
+                print(f"   category_id: {combo['category_id']}")
+                print(f"   budget_name: {combo['budget_name']}")
+                print()
+        
+        print(f"\n{'='*60}")
+        print("[RECOMMENDED] Use this for testing:")
+        print(f"{'='*60}")
+        first = valid_combinations[0]
+        print(f"user_id: {first['user_id']}")
+        print(f"category_id: {first['category_id']}")
+        print(f"{'='*60}\n")
+    else:
+        print("[WARNING] No budgets found with category_id")
+        print("Checking sample budget structure...\n")
+        
+        # Show structure of first budget
+        if user_budgets:
+            sample = user_budgets[0]
+            print("Sample budget structure:")
+            print(f"  _id: {sample.get('_id')}")
+            print(f"  createdBy: {sample.get('createdBy')}")
+            print(f"  user_id: {sample.get('user_id')}")
+            print(f"  name: {sample.get('name')}")
+            print(f"  category: {sample.get('category')}")
+            print(f"  categoryId: {sample.get('categoryId')}")
+            print(f"  headCategory: {sample.get('headCategory')}")
+            print(f"  has headCategories array: {bool(sample.get('headCategories'))}")
+            if sample.get('headCategories'):
+                print(f"  headCategories length: {len(sample.get('headCategories', []))}")
+                if len(sample.get('headCategories', [])) > 0:
+                    print(f"  First headCategory structure:")
+                    print(json.dumps(sample.get('headCategories')[0], indent=2, default=str))
+    
+except Exception as e:
+    print(f"[ERROR] Error: {e}")
+    import traceback
+    traceback.print_exc()