Update main.py

main.py

@@ -69,6 +69,29 @@ def copy_collection(source_ref, dest_ref):
         for sub_coll_ref in doc.reference.collections():
             copy_collection(sub_coll_ref, dest_ref.document(doc.id).collection(sub_coll_ref.id))
 
+# In dashboard_server.py
+
+def normalize_currency_code(raw_code, default_code='USD'):
+    """
+    Takes a messy currency string (e.g., '$', 'rand', 'R') and returns a
+    standard 3-letter ISO code (e.g., 'USD', 'ZAR').
+    """
+    if not raw_code or not isinstance(raw_code, str):
+        return default_code
+
+    # Create a mapping of common variations to the standard code
+    # The keys should be lowercase for case-insensitive matching
+    currency_map = {
+        # US Dollar
+        '$': 'USD', 'dollar': 'USD', 'dollars': 'USD', 'usd': 'USD',
+        # South African Rand
+        'r': 'ZAR', 'rand': 'ZAR', 'rands': 'ZAR', 'zar': 'ZAR',
+    }
+    
+    # Clean the input and check against the map
+    clean_code = raw_code.lower().strip()
+    return currency_map.get(clean_code, default_code)
+
 # -----------------------------------------------------------------------------
 # 3. AUTHENTICATION & USER MANAGEMENT ENDPOINTS
 # -----------------------------------------------------------------------------
@@ -177,14 +200,12 @@ def get_user_profile():
     
     return jsonify({'uid': uid, **user_doc.to_dict()})
 
-
-
 @app.route('/api/user/dashboard', methods=['GET'])
 def get_user_dashboard():
     """
-    Retrieves and aggregates data for the user's dashboard with correct profit calculation.
-    **FIXED**: Now segregates all financial totals by currency and intelligently infers
-    the currency for transactions where it is missing.
+    Retrieves and aggregates data for the user's dashboard.
+    **FIXED**: Now normalizes currency codes to prevent fragmentation (e.g., '$' and 'USD'
+    are treated as the same currency).
     """
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Invalid or expired token'}), 401
@@ -203,60 +224,42 @@ def get_user_dashboard():
         bot_data_id = phone_number.lstrip('+')
         bot_user_ref = db.collection('users').document(bot_data_id)
         
-        # --- REVISED LOGIC FOR MULTI-CURRENCY ---
-        # Use dictionaries to store totals for each currency
-        sales_revenue_by_currency = {}
-        cogs_by_currency = {}
-        expenses_by_currency = {}
+        sales_revenue_by_currency, cogs_by_currency, expenses_by_currency = {}, {}, {}
         sales_count = 0
 
+        # --- THE FIX IS HERE ---
         # Establish the user's default currency as the initial fallback
-        last_seen_currency = user_data.get('defaultCurrency', 'USD') 
+        default_currency_code = normalize_currency_code(user_data.get('defaultCurrency'), 'USD')
+        last_seen_currency_code = default_currency_code
 
         # Process Sales
-        sales_docs = bot_user_ref.collection('sales').stream()
-        for doc in sales_docs:
+        for doc in bot_user_ref.collection('sales').stream():
             details = doc.to_dict().get('details', {})
             
-            # Infer currency: use the transaction's currency, or fall back to the last seen one
-            currency = details.get('currency')
-            if currency:
-                last_seen_currency = currency
-            else:
-                currency = last_seen_currency
-
-            quantity = int(details.get('quantity', 1))
-            price = float(details.get('price', 0))
-            cost = float(details.get('cost', 0))
+            # Normalize the currency code using the helper function
+            currency_code = normalize_currency_code(details.get('currency'), last_seen_currency_code)
+            last_seen_currency_code = currency_code # Update for the next transaction
 
-            sales_revenue_by_currency[currency] = sales_revenue_by_currency.get(currency, 0) + (price * quantity)
-            cogs_by_currency[currency] = cogs_by_currency.get(currency, 0) + (cost * quantity)
+            quantity, price, cost = int(details.get('quantity', 1)), float(details.get('price', 0)), float(details.get('cost', 0))
+            sales_revenue_by_currency[currency_code] = sales_revenue_by_currency.get(currency_code, 0) + (price * quantity)
+            cogs_by_currency[currency_code] = cogs_by_currency.get(currency_code, 0) + (cost * quantity)
             sales_count += 1
         
         # Process Expenses
-        expenses_docs = bot_user_ref.collection('expenses').stream()
-        for doc in expenses_docs:
+        for doc in bot_user_ref.collection('expenses').stream():
             details = doc.to_dict().get('details', {})
-            
-            # Infer currency using the same logic
-            currency = details.get('currency')
-            if currency:
-                last_seen_currency = currency
-            else:
-                currency = last_seen_currency
+            currency_code = normalize_currency_code(details.get('currency'), last_seen_currency_code)
+            last_seen_currency_code = currency_code
             
             amount = float(details.get('amount', 0))
-            expenses_by_currency[currency] = expenses_by_currency.get(currency, 0) + amount
+            expenses_by_currency[currency_code] = expenses_by_currency.get(currency_code, 0) + amount
 
-        # Calculate final totals by currency
+        # Calculate final totals using the clean, normalized currency codes
         all_currencies = set(sales_revenue_by_currency.keys()) | set(cogs_by_currency.keys()) | set(expenses_by_currency.keys())
-        gross_profit_by_currency = {}
-        net_profit_by_currency = {}
+        gross_profit_by_currency, net_profit_by_currency = {}, {}
 
         for curr in all_currencies:
-            revenue = sales_revenue_by_currency.get(curr, 0)
-            cogs = cogs_by_currency.get(curr, 0)
-            expenses = expenses_by_currency.get(curr, 0)
+            revenue, cogs, expenses = sales_revenue_by_currency.get(curr, 0), cogs_by_currency.get(curr, 0), expenses_by_currency.get(curr, 0)
             gross_profit_by_currency[curr] = round(revenue - cogs, 2)
             net_profit_by_currency[curr] = round(revenue - cogs - expenses, 2)
 
@@ -268,7 +271,6 @@ def get_user_dashboard():
             'netProfitByCurrency': net_profit_by_currency,
             'salesCount': sales_count,
         }
-        # --- END OF REVISED LOGIC ---
         return jsonify(dashboard_data), 200
         
     except Exception as e:
@@ -760,8 +762,8 @@ def admin_remove_member_from_org(org_id, member_uid):
 @app.route('/api/admin/dashboard/stats', methods=['GET'])
 def get_admin_dashboard_stats():
     """
-    Retrieves global statistics for the admin dashboard, including multi-currency totals
-    and leaderboards.
+    Retrieves complete global statistics, including multi-currency totals and
+    leaderboards based on agreed-upon ranking logic.
     """
     try:
         verify_admin_and_get_uid(request.headers.get('Authorization'))
@@ -769,18 +771,9 @@ def get_admin_dashboard_stats():
         all_users_docs = list(db.collection('users').stream())
         all_orgs_docs = list(db.collection('organizations').stream())
         
-        # --- Initialize data structures ---
-        user_sales_data = {} 
-        global_item_revenue = {} 
-        global_expense_totals = {} 
-        phone_to_user_map = {}
-        
-        # Global financial accumulators are now dictionaries
-        global_sales_rev_by_curr = {}
-        global_cogs_by_curr = {}
-        global_expenses_by_curr = {}
+        user_sales_data, global_item_revenue, global_expense_totals, phone_to_user_map = {}, {}, {}, {}
+        global_sales_rev_by_curr, global_cogs_by_curr, global_expenses_by_curr = {}, {}, {}
 
-        # --- First Pass: Get user info and list of approved phones ---
         pending_approvals, approved_users, admin_count = 0, 0, 0
         approved_phone_numbers = []
 
@@ -793,9 +786,8 @@ def get_admin_dashboard_stats():
                 approved_users += 1
                 approved_phone_numbers.append(phone)
                 phone_to_user_map[phone] = {
-                    'displayName': user_data.get('displayName', 'N/A'),
-                    'uid': user_data.get('uid'),
-                    'defaultCurrency': user_data.get('defaultCurrency', 'USD') # Store default currency
+                    'displayName': user_data.get('displayName', 'N/A'), 'uid': user_data.get('uid'),
+                    'defaultCurrency': user_data.get('defaultCurrency', 'USD')
                 }
             if user_data.get('isAdmin', False):
                 admin_count += 1
@@ -803,7 +795,6 @@ def get_admin_dashboard_stats():
         user_stats = {'total': len(all_users_docs), 'admins': admin_count, 'approvedForBot': approved_users, 'pendingApproval': pending_approvals}
         org_stats = {'total': len(all_orgs_docs)}
 
-        # --- Second Pass: Aggregate financial data ---
         sales_count = 0
         
         for phone in approved_phone_numbers:
@@ -813,59 +804,58 @@ def get_admin_dashboard_stats():
                 
                 user_sales_data[phone] = {'total_revenue_by_currency': {}, 'item_sales': {}}
                 user_info = phone_to_user_map.get(phone, {})
-                last_seen_currency = user_info.get('defaultCurrency', 'USD')
+                default_currency_code = normalize_currency_code(user_info.get('defaultCurrency'), 'USD')
+                last_seen_currency_code = default_currency_code
 
                 # Process Sales
                 for sale_doc in bot_user_ref.collection('sales').stream():
                     details = sale_doc.to_dict().get('details', {})
-                    currency = details.get('currency')
-                    if currency: last_seen_currency = currency
-                    else: currency = last_seen_currency
+                    currency_code = normalize_currency_code(details.get('currency'), last_seen_currency_code)
+                    last_seen_currency_code = currency_code
 
-                    quantity, price = int(details.get('quantity', 1)), float(details.get('price', 0))
+                    quantity, price, cost = int(details.get('quantity', 1)), float(details.get('price', 0)), float(details.get('cost', 0))
                     sale_revenue = price * quantity
                     
-                    global_sales_rev_by_curr[currency] = global_sales_rev_by_curr.get(currency, 0) + sale_revenue
-                    global_cogs_by_curr[currency] = global_cogs_by_curr.get(currency, 0) + (float(details.get('cost', 0)) * quantity)
+                    global_sales_rev_by_curr[currency_code] = global_sales_rev_by_curr.get(currency_code, 0) + sale_revenue
+                    global_cogs_by_curr[currency_code] = global_cogs_by_curr.get(currency_code, 0) + (cost * quantity)
                     sales_count += 1
                     
                     item_name = details.get('item', 'Unknown Item')
-                    user_sales_data[phone]['total_revenue_by_currency'][currency] = user_sales_data[phone]['total_revenue_by_currency'].get(currency, 0) + sale_revenue
+                    user_sales_data[phone]['total_revenue_by_currency'][currency_code] = user_sales_data[phone]['total_revenue_by_currency'].get(currency_code, 0) + sale_revenue
                     user_sales_data[phone]['item_sales'][item_name] = user_sales_data[phone]['item_sales'].get(item_name, 0) + sale_revenue
                     global_item_revenue[item_name] = global_item_revenue.get(item_name, 0) + sale_revenue
                 
                 # Process Expenses
                 for expense_doc in bot_user_ref.collection('expenses').stream():
                     details = expense_doc.to_dict().get('details', {})
-                    currency = details.get('currency')
-                    if currency: last_seen_currency = currency
-                    else: currency = last_seen_currency
+                    currency_code = normalize_currency_code(details.get('currency'), last_seen_currency_code)
+                    last_seen_currency_code = currency_code
                     
                     amount = float(details.get('amount', 0))
                     category = details.get('description', 'Uncategorized')
-                    global_expenses_by_curr[currency] = global_expenses_by_curr.get(currency, 0) + amount
+                    global_expenses_by_curr[currency_code] = global_expenses_by_curr.get(currency_code, 0) + amount
                     global_expense_totals[category] = global_expense_totals.get(category, 0) + amount
             except Exception as e:
                 logging.error(f"Admin stats: Could not process data for phone {phone}. Error: {e}")
                 continue
         
-        # --- Post-Processing: Leaderboards & Final Totals ---
-        # Note: Ranking users with multiple currencies is complex. This example ranks them by the revenue
-        # in their default currency. A more advanced version might convert to a single currency.
+        # --- Post-Processing and Final Assembly ---
+        # Rank users based on revenue in their primary/default currency.
         sorted_users = sorted(user_sales_data.items(), key=lambda item: item[1]['total_revenue_by_currency'].get(phone_to_user_map.get(item[0], {}).get('defaultCurrency', 'USD'), 0), reverse=True)
         top_users_by_revenue = []
         for phone, data in sorted_users[:5]:
             user_info = phone_to_user_map.get(phone, {})
             top_item = max(data['item_sales'], key=data['item_sales'].get) if data['item_sales'] else 'N/A'
             top_users_by_revenue.append({
-                'displayName': user_info.get('displayName'),
-                'uid': user_info.get('uid'),
+                'displayName': user_info.get('displayName'), 'uid': user_info.get('uid'),
                 'revenueByCurrency': {k: round(v, 2) for k, v in data['total_revenue_by_currency'].items()},
                 'topSellingItem': top_item
             })
 
+        # Rank items and expenses based on their total nominal value (summing across currencies for ranking only).
         sorted_items = sorted(global_item_revenue.items(), key=lambda item: item[1], reverse=True)
         top_selling_items = [{'item': name, 'totalRevenue': round(revenue, 2)} for name, revenue in sorted_items[:5]]
+        
         sorted_expenses = sorted(global_expense_totals.items(), key=lambda item: item[1], reverse=True)
         top_expenses = [{'category': name, 'totalAmount': round(amount, 2)} for name, amount in sorted_expenses[:5]]
 
@@ -881,14 +871,19 @@ def get_admin_dashboard_stats():
             'totalSalesRevenueByCurrency': {k: round(v, 2) for k, v in global_sales_rev_by_curr.items()},
             'totalCostOfGoodsSoldByCurrency': {k: round(v, 2) for k, v in global_cogs_by_curr.items()},
             'totalExpensesByCurrency': {k: round(v, 2) for k, v in global_expenses_by_curr.items()},
-            'totalNetProfitByCurrency': global_net_profit_by_curr,
+            'totalNetProfitByCurrency': global_net_profit_by_curr, 
             'totalSalesCount': sales_count,
         }
 
         return jsonify({
-            'userStats': user_stats, 'organizationStats': org_stats,
+            'userStats': user_stats, 
+            'organizationStats': org_stats, 
             'systemStats': system_stats,
-            'leaderboards': {'topUsersByRevenue': top_users_by_revenue, 'topSellingItems': top_selling_items, 'topExpenses': top_expenses}
+            'leaderboards': {
+                'topUsersByRevenue': top_users_by_revenue, 
+                'topSellingItems': top_selling_items, 
+                'topExpenses': top_expenses
+            }
         }), 200
 
     except PermissionError as e: