Update app/smart_recommendation.py

app/smart_recommendation.py

@@ -69,17 +69,22 @@ class SmartBudgetRecommender:
             avg_expense = data["average_monthly"]
             confidence = self._calculate_confidence(data)
 
-            # 1) Try OpenAI first (primary source of recommendation)
+            # Always try OpenAI first (primary source of recommendation)
             ai_result = self._get_ai_recommendation(category, data, avg_expense)
-            if ai_result:
+            if ai_result and ai_result.get("recommended_budget"):
                 recommended_budget = ai_result.get("recommended_budget")
-                reason = ai_result.get("reason")
+                reason = ai_result.get("reason", f"AI recommendation for {category}")
                 action = ai_result.get("action")
+                print(f"OpenAI recommendation for {category}: {recommended_budget}")
             else:
-                # 2) Fallback to rule-based recommendation
+                # Fallback to rule-based recommendation if OpenAI fails
                 recommended_budget = self._calculate_recommended_budget(avg_expense, data)
                 reason = self._generate_reason(category, avg_expense, recommended_budget)
                 action = None
+                if not ai_result:
+                    print(f"OpenAI unavailable, using rule-based for {category}: {recommended_budget}")
+                else:
+                    print(f"OpenAI returned invalid data, using rule-based for {category}: {recommended_budget}")
 
             recommendations.append(BudgetRecommendation(
                 category=category,
@@ -266,32 +271,85 @@ class SmartBudgetRecommender:
         We treat each budget document (e.g. \"Office Maintenance\", \"LOGICGO\")
         as a spending category and derive an \"average\" from its amounts.
         """
-        # createdBy is stored as ObjectId in WalletSync, while user_id is a string.
-        # Try to cast to ObjectId; if it fails, fall back to matching the raw string.
-        query: Dict = {"status": "OPEN"}
+        budgets = []
+        
+        # Try multiple query patterns to find budgets
+        # Pattern 1: Try with ObjectId (most common in WalletSync)
         try:
-            query["createdBy"] = ObjectId(user_id)
+            query_objid = {"status": "OPEN", "createdBy": ObjectId(user_id)}
+            budgets_objid = list(self.db.budgets.find(query_objid))
+            if budgets_objid:
+                budgets.extend(budgets_objid)
         except Exception:
-            query["createdBy"] = user_id
-
-        budgets = list(self.db.budgets.find(query))
+            pass
+        
+        # Pattern 2: Try with string user_id
+        try:
+            query_str = {"status": "OPEN", "createdBy": user_id}
+            budgets_str = list(self.db.budgets.find(query_str))
+            if budgets_str:
+                budgets.extend(budgets_str)
+        except Exception:
+            pass
+        
+        # Pattern 3: Try with user_id field (alternative field name)
+        try:
+            query_userid = {"status": "OPEN", "user_id": user_id}
+            budgets_userid = list(self.db.budgets.find(query_userid))
+            if budgets_userid:
+                budgets.extend(budgets_userid)
+        except Exception:
+            pass
+        
+        # Pattern 4: Try ObjectId with user_id field
+        try:
+            query_objid_userid = {"status": "OPEN", "user_id": ObjectId(user_id)}
+            budgets_objid_userid = list(self.db.budgets.find(query_objid_userid))
+            if budgets_objid_userid:
+                budgets.extend(budgets_objid_userid)
+        except Exception:
+            pass
+        
+        # Remove duplicates based on _id
+        seen_ids = set()
+        unique_budgets = []
+        for b in budgets:
+            budget_id = str(b.get("_id", ""))
+            if budget_id not in seen_ids:
+                seen_ids.add(budget_id)
+                unique_budgets.append(b)
+        
+        budgets = unique_budgets
 
         if not budgets:
+            print(f"No budgets found for user_id: {user_id}")
             return {}
 
+        print(f"Found {len(budgets)} budgets for user_id: {user_id}")
+
         result: Dict[str, Dict] = {}
         for b in budgets:
-            # Use budget \"name\" as category label
+            # Use budget "name" as category label
             category = b.get("name", "Uncategorized")
+            if not category or category == "Uncategorized":
+                # Try alternative field names
+                category = b.get("category") or b.get("title") or "Uncategorized"
 
             # Derive a base amount from WalletSync fields
-            max_amount = float(b.get("maxAmount", 0) or 0)
-            spend_amount = float(b.get("spendAmount", 0) or 0)
-
-            # If there is recorded spend, use that as \"average\"; otherwise maxAmount
-            base_amount = spend_amount if spend_amount > 0 else max_amount
-            if base_amount <= 0:
-                continue
+            # Try multiple field name variations
+            max_amount = float(b.get("maxAmount", 0) or b.get("max_amount", 0) or b.get("amount", 0) or 0)
+            spend_amount = float(b.get("spendAmount", 0) or b.get("spend_amount", 0) or b.get("spent", 0) or 0)
+            budget_amount = float(b.get("budget", 0) or b.get("budgetAmount", 0) or 0)
+
+            # Priority: spendAmount > maxAmount > budgetAmount > budget
+            if spend_amount > 0:
+                base_amount = spend_amount
+            elif max_amount > 0:
+                base_amount = max_amount
+            elif budget_amount > 0:
+                base_amount = budget_amount
+            else:
+                continue  # Skip if no valid amount found
 
             if category not in result:
                 result[category] = {
@@ -312,6 +370,7 @@ class SmartBudgetRecommender:
                 )
                 result[category]["monthly_values"].append(base_amount)
 
+        print(f"Processed {len(result)} budget categories for recommendations")
         return result
 
     def _get_ai_recommendation(self, category: str, data: Dict, avg_expense: float):