Update main.py

main.py

@@ -303,68 +303,87 @@ def get_spending_overview():
         transactions_ref = db.reference('transactions')
         transactions = transactions_ref.order_by_child('uid').equal_to(uid).get() or {}
         
-        # Process transactions directly (similar to the admin overview approach)
-        transactions_list = [{'id': tid, **data} for tid, data in transactions.items()]
-        
-        if not transactions_list:
-            return jsonify({
-                'daily_spending': [],
-                'recent_transactions': []
-            })
+        # Convert to list for easier processing
+        transactions_list = []
+        for tx_id, tx_data in transactions.items():
+            # Add ID to the transaction data
+            tx_item = tx_data.copy()
+            tx_item['id'] = tx_id
+            transactions_list.append(tx_item)
         
         # Create a DataFrame
-        df = pd.DataFrame(transactions_list)
-        
-        # Handle date formatting (only if the date column exists)
-        if 'date' in df.columns:
-            # Convert to datetime, but keep non-convertible values
-            df['date'] = pd.to_datetime(df['date'], errors='coerce')
-            # Filter out rows with invalid dates
-            df = df.dropna(subset=['date'])
-            
-            if not df.empty:
-                # Convert datetime to ISO format
-                df['date'] = df['date'].apply(lambda d: d.isoformat())
-                # Extract date part for grouping
-                df['date_only'] = df['date'].apply(lambda d: d.split("T")[0])
+        df = pd.DataFrame(transactions_list) if transactions_list else pd.DataFrame()
         
-        # Return empty response if we don't have valid data after processing
         if df.empty:
             return jsonify({
                 'daily_spending': [],
                 'recent_transactions': []
             })
         
-        # For daily spending, group by date
-        if 'date_only' in df.columns and 'total' in df.columns:
-            daily_spending = df.groupby('date_only')['total'].sum().reset_index()
-            daily_spending.rename(columns={'date_only': 'date'}, inplace=True)
+        # Handle date parsing without dropping invalid dates
+        if 'date' in df.columns:
+            # Create a temporary column for parsed dates
+            df['parsed_date'] = pd.to_datetime(df['date'], errors='coerce')
+            
+            # For rows with invalid dates, set a default date
+            default_date = pd.Timestamp('2000-01-01')
+            mask = df['parsed_date'].isna()
+            
+            if mask.any():
+                print(f"Found {mask.sum()} transactions with invalid dates")
+                # Keep the original string in 'date' column, but use default for calculations
+                df.loc[mask, 'parsed_date'] = default_date
+            
+            # Create ISO format dates for valid dates
+            df['date_iso'] = df['parsed_date'].apply(lambda d: d.isoformat() if pd.notnull(d) else '2000-01-01T00:00:00')
+            
+            # Extract date part for daily spending calculations
+            df['date_only'] = df['date_iso'].apply(lambda d: d.split('T')[0])
         else:
-            daily_spending = pd.DataFrame(columns=['date', 'total'])
+            # If no date column exists, create default values
+            df['date_only'] = '2000-01-01'
+            df['date_iso'] = '2000-01-01T00:00:00'
+        
+        # For daily spending, group by date
+        daily_spending = df.groupby('date_only')['total'].sum().reset_index()
+        daily_spending.rename(columns={'date_only': 'date'}, inplace=True)
         
-        # Sort the transactions by timestamp if available
+        # Sort transactions by timestamp if available
         if 'timestamp' in df.columns:
-            recent_transactions = df.sort_values(by='timestamp', ascending=False).head(10)
-        else:
-            recent_transactions = df.head(10)
+            df = df.sort_values(by='timestamp', ascending=False)
+        
+        # Select the most recent transactions
+        recent_transactions = df.head(10)
         
-        # Replace NaN values with None for JSON serialization
+        # Replace NaN with None for JSON serialization
         daily_spending = daily_spending.replace({np.nan: None})
         recent_transactions = recent_transactions.replace({np.nan: None})
         
-        # Prepare response
-        response_data = {
-            'daily_spending': daily_spending.to_dict(orient='records'),
-            'recent_transactions': recent_transactions.drop(columns=['date_only'], errors='ignore').to_dict(orient='records')
-        }
+        # Ensure proper column selections for the response
+        recent_tx_dict = recent_transactions.to_dict(orient='records')
         
-        return jsonify(response_data)
+        # Make sure each transaction has the original date string
+        for tx in recent_tx_dict:
+            # Remove temporary columns
+            if 'parsed_date' in tx:
+                del tx['parsed_date']
+            if 'date_only' in tx:
+                del tx['date_only']
+            if 'date_iso' in tx and 'date' not in tx:
+                tx['date'] = tx['date_iso']
+                del tx['date_iso']
+            elif 'date_iso' in tx:
+                del tx['date_iso']
         
+        return jsonify({
+            'daily_spending': daily_spending.to_dict(orient='records'),
+            'recent_transactions': recent_tx_dict
+        })
     except Exception as e:
+        print(f"Error in spending overview: {e}")
         return jsonify({'error': str(e)}), 500
 
 
-
 # ========================================
 # Modified verify_admin function (now checks database is_admin flag)
 # ========================================