Update pages/dashboard.py

pages/dashboard.py

@@ -1,317 +1,326 @@
+"""
+Dashboard page for the application
+"""
 import streamlit as st
 import pandas as pd
-import numpy as np
 import plotly.express as px
 import plotly.graph_objects as go
 from datetime import datetime, timedelta
-
 from utils.storage import load_data, save_data, load_dataframe, save_dataframe
-from utils.config import load_config, get_config_value
-from utils.error_handling import handle_ui_exceptions
-from utils.logging import get_logger
+from utils.error_handling import handle_data_exceptions, log_error, display_error
 
-logger = get_logger(__name__)
 
-@handle_ui_exceptions
+@handle_data_exceptions
 def create_dashboard_page():
-    """Create the main dashboard page"""
-    st.title("📊 MONA Dashboard")
-    
-    config = load_config()
-    
-    # Create tabs for different dashboard sections
-    tab1, tab2, tab3, tab4 = st.tabs(["Overview", "Analytics", "Data Upload", "Real-time"])
-    
-    with tab1:
-        create_overview_section()
-    
-    with tab2:
-        create_analytics_section()
-    
-    with tab3:
-        create_data_upload_section()
-    
-    with tab4:
-        create_realtime_section()
-
-@handle_ui_exceptions
-def create_overview_section():
-    """Create the overview section of the dashboard"""
-    st.header("📈 Overview")
-    
-    # Create sample metrics
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        st.metric("Total Records", "1,234", "12%")
-    
-    with col2:
-        st.metric("Active Users", "567", "8%")
-    
-    with col3:
-        st.metric("Processing Time", "2.3s", "-0.5s")
-    
-    with col4:
-        st.metric("Success Rate", "98.5%", "1.2%")
-    
-    # Create sample charts
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        st.subheader("📊 Trend Analysis")
-        # Generate sample data
-        dates = pd.date_range(start='2024-01-01', end='2024-12-31', freq='D')
-        values = np.random.randn(len(dates)).cumsum() + 100
+    """
+    Create the main dashboard page
+    """
+    st.title("📊 Dashboard")
+    st.markdown("---")
+    
+    # Initialize session state
+    if 'dashboard_data' not in st.session_state:
+        st.session_state.dashboard_data = generate_sample_data()
+    
+    # Sidebar controls
+    with st.sidebar:
+        st.header("Dashboard Controls")
         
-        df = pd.DataFrame({
-            'Date': dates,
-            'Value': values
-        })
+        # Data refresh button
+        if st.button("🔄 Refresh Data"):
+            st.session_state.dashboard_data = generate_sample_data()
+            st.success("Data refreshed!")
         
-        fig = px.line(df, x='Date', y='Value', title='Daily Trend')
-        st.plotly_chart(fig, use_container_width=True)
-    
-    with col2:
-        st.subheader("📦 Category Distribution")
-        categories = ['A', 'B', 'C', 'D', 'E']
-        values = np.random.randint(10, 100, size=len(categories))
+        # Date range selector
+        st.subheader("Date Range")
+        start_date = st.date_input("Start Date", value=datetime.now() - timedelta(days=30))
+        end_date = st.date_input("End Date", value=datetime.now())
         
-        fig = px.pie(values=values, names=categories, title='Category Distribution')
-        st.plotly_chart(fig, use_container_width=True)
+        # Chart type selector
+        chart_type = st.selectbox(
+            "Chart Type",
+            ["Line Chart", "Bar Chart", "Area Chart", "Scatter Plot"]
+        )
+    
+    # Main dashboard content
+    create_metrics_section()
+    create_charts_section(chart_type)
+    create_data_table_section()
 
-@handle_ui_exceptions
-def create_analytics_section():
-    """Create the analytics section"""
-    st.header("🔍 Analytics")
+
+def generate_sample_data():
+    """
+    Generate sample data for the dashboard
+    """
+    import random
+    import numpy as np
+    
+    # Generate date range
+    dates = pd.date_range(start='2024-01-01', end='2024-12-31', freq='D')
+    
+    # Generate sample metrics
+    data = {
+        'date': dates,
+        'sales': [random.randint(1000, 5000) + random.randint(-500, 500) for _ in dates],
+        'users': [random.randint(100, 1000) + random.randint(-100, 100) for _ in dates],
+        'revenue': [random.randint(5000, 25000) + random.randint(-2000, 2000) for _ in dates],
+        'conversion_rate': [round(random.uniform(0.02, 0.08), 4) for _ in dates]
+    }
     
-    # Data filtering options
-    col1, col2, col3 = st.columns(3)
+    return pd.DataFrame(data)
+
+
+def create_metrics_section():
+    """
+    Create metrics cards section
+    """
+    st.subheader("📈 Key Metrics")
+    
+    data = st.session_state.dashboard_data
+    
+    # Calculate metrics
+    total_sales = data['sales'].sum()
+    total_users = data['users'].sum()
+    total_revenue = data['revenue'].sum()
+    avg_conversion = data['conversion_rate'].mean()
+    
+    # Previous period comparison (last 30 days vs previous 30 days)
+    recent_data = data.tail(30)
+    previous_data = data.iloc[-60:-30] if len(data) >= 60 else data.head(30)
+    
+    sales_change = ((recent_data['sales'].sum() - previous_data['sales'].sum()) / previous_data['sales'].sum()) * 100
+    users_change = ((recent_data['users'].sum() - previous_data['users'].sum()) / previous_data['users'].sum()) * 100
+    revenue_change = ((recent_data['revenue'].sum() - previous_data['revenue'].sum()) / previous_data['revenue'].sum()) * 100
+    conversion_change = ((recent_data['conversion_rate'].mean() - previous_data['conversion_rate'].mean()) / previous_data['conversion_rate'].mean()) * 100
+    
+    # Display metrics in columns
+    col1, col2, col3, col4 = st.columns(4)
     
     with col1:
-        date_range = st.date_input(
-            "Select Date Range",
-            value=(datetime.now() - timedelta(days=30), datetime.now()),
-            max_value=datetime.now()
+        st.metric(
+            label="Total Sales",
+            value=f"{total_sales:,}",
+            delta=f"{sales_change:.1f}%"
         )
     
     with col2:
-        chart_type = st.selectbox(
-            "Chart Type",
-            ["Line", "Bar", "Scatter", "Area", "Histogram"]
+        st.metric(
+            label="Total Users", 
+            value=f"{total_users:,}",
+            delta=f"{users_change:.1f}%"
         )
     
     with col3:
-        metric = st.selectbox(
-            "Metric",
-            ["Revenue", "Users", "Sessions", "Conversions"]
+        st.metric(
+            label="Total Revenue",
+            value=f"${total_revenue:,}",
+            delta=f"{revenue_change:.1f}%"
         )
     
-    # Generate analytics data based on selections
-    if len(date_range) == 2:
-        start_date, end_date = date_range
-        days = (end_date - start_date).days + 1
-        
-        # Generate sample data
-        dates = pd.date_range(start=start_date, end=end_date, freq='D')
-        values = np.random.randn(len(dates)).cumsum() + np.random.randint(50, 200)
-        
-        df = pd.DataFrame({
-            'Date': dates,
-            metric: values
-        })
-        
-        # Create chart based on selection
-        if chart_type == "Line":
-            fig = px.line(df, x='Date', y=metric, title=f'{metric} Over Time')
-        elif chart_type == "Bar":
-            fig = px.bar(df, x='Date', y=metric, title=f'{metric} by Day')
-        elif chart_type == "Scatter":
-            df['Random'] = np.random.randn(len(df))
-            fig = px.scatter(df, x='Random', y=metric, title=f'{metric} Scatter Plot')
-        elif chart_type == "Area":
-            fig = px.area(df, x='Date', y=metric, title=f'{metric} Area Chart')
-        elif chart_type == "Histogram":
-            fig = px.histogram(df, x=metric, title=f'{metric} Distribution')
-        
-        st.plotly_chart(fig, use_container_width=True)
-        
-        # Show data table
-        with st.expander("View Raw Data"):
-            st.dataframe(df)
+    with col4:
+        st.metric(
+            label="Avg Conversion Rate",
+            value=f"{avg_conversion:.2%}",
+            delta=f"{conversion_change:.1f}%"
+        )
 
-@handle_ui_exceptions
-def create_data_upload_section():
-    """Create the data upload section"""
-    st.header("📤 Data Upload")
-    
-    # File upload
-    uploaded_file = st.file_uploader(
-        "Upload your data file",
-        type=['csv', 'xlsx', 'json'],
-        help="Supported formats: CSV, Excel, JSON"
-    )
-    
-    if uploaded_file is not None:
-        try:
-            # Read the uploaded file
-            if uploaded_file.name.endswith('.csv'):
-                df = pd.read_csv(uploaded_file)
-            elif uploaded_file.name.endswith('.xlsx'):
-                df = pd.read_excel(uploaded_file)
-            elif uploaded_file.name.endswith('.json'):
-                df = pd.read_json(uploaded_file)
-            
-            st.success(f"File uploaded successfully! Shape: {df.shape}")
-            
-            # Display data preview
-            st.subheader("Data Preview")
-            st.dataframe(df.head())
-            
-            # Data summary
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                st.subheader("Data Info")
-                st.write(f"**Rows:** {len(df)}")
-                st.write(f"**Columns:** {len(df.columns)}")
-                st.write(f"**File Size:** {uploaded_file.size} bytes")
-            
-            with col2:
-                st.subheader("Column Types")
-                for col, dtype in df.dtypes.items():
-                    st.write(f"**{col}:** {dtype}")
-            
-            # Save data option
-            if st.button("Save Data"):
-                save_dataframe(df, f"uploaded_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
-                st.success("Data saved successfully!")
-            
-            # Basic analytics on uploaded data
-            if len(df.select_dtypes(include=[np.number]).columns) > 0:
-                st.subheader("Quick Analytics")
-                numeric_cols = df.select_dtypes(include=[np.number]).columns
-                
-                selected_col = st.selectbox("Select column for analysis", numeric_cols)
-                
-                if selected_col:
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        fig = px.histogram(df, x=selected_col, title=f'Distribution of {selected_col}')
-                        st.plotly_chart(fig, use_container_width=True)
-                    
-                    with col2:
-                        fig = px.box(df, y=selected_col, title=f'Box Plot of {selected_col}')
-                        st.plotly_chart(fig, use_container_width=True)
-        
-        except Exception as e:
-            st.error(f"Error processing file: {str(e)}")
-            logger.error(f"File processing error: {str(e)}")
 
-@handle_ui_exceptions
-def create_realtime_section():
-    """Create the real-time monitoring section"""
-    st.header("⚡ Real-time Monitoring")
-    
-    # Auto-refresh toggle
-    auto_refresh = st.checkbox("Enable Auto-refresh", value=False)
+def create_charts_section(chart_type):
+    """
+    Create charts section
+    """
+    st.subheader("📊 Analytics Charts")
     
-    if auto_refresh:
-        refresh_interval = st.slider("Refresh Interval (seconds)", 1, 60, 5)
-        st.info(f"Data will refresh every {refresh_interval} seconds")
+    data = st.session_state.dashboard_data
     
-    # Real-time metrics
-    col1, col2, col3 = st.columns(3)
-    
-    # Generate real-time data
-    current_time = datetime.now()
+    # Create two columns for charts
+    col1, col2 = st.columns(2)
     
     with col1:
-        cpu_usage = np.random.uniform(20, 80)
-        st.metric("CPU Usage", f"{cpu_usage:.1f}%", f"{np.random.uniform(-5, 5):.1f}%")
+        st.write("**Sales Over Time**")
+        if chart_type == "Line Chart":
+            fig = px.line(data, x='date', y='sales', title='Daily Sales')
+        elif chart_type == "Bar Chart":
+            # Group by month for bar chart
+            monthly_data = data.groupby(data['date'].dt.to_period('M'))['sales'].sum().reset_index()
+            monthly_data['date'] = monthly_data['date'].astype(str)
+            fig = px.bar(monthly_data, x='date', y='sales', title='Monthly Sales')
+        elif chart_type == "Area Chart":
+            fig = px.area(data, x='date', y='sales', title='Sales Area Chart')
+        else:  # Scatter Plot
+            fig = px.scatter(data, x='date', y='sales', title='Sales Scatter Plot')
+        
+        fig.update_layout(height=400)
+        st.plotly_chart(fig, use_container_width=True)
     
     with col2:
-        memory_usage = np.random.uniform(30, 90)
-        st.metric("Memory Usage", f"{memory_usage:.1f}%", f"{np.random.uniform(-3, 3):.1f}%")
-    
-    with col3:
-        active_connections = np.random.randint(100, 500)
-        st.metric("Active Connections", active_connections, np.random.randint(-10, 20))
-    
-    # Real-time chart
-    st.subheader("📊 Real-time Performance")
-    
-    # Generate time series data
-    time_points = pd.date_range(end=current_time, periods=50, freq='1T')
-    performance_data = {
-        'Time': time_points,
-        'CPU': np.random.uniform(20, 80, 50),
-        'Memory': np.random.uniform(30, 90, 50),
-        'Network': np.random.uniform(10, 60, 50)
-    }
-    
-    df_realtime = pd.DataFrame(performance_data)
-    
-    # Create multi-line chart
-    fig = go.Figure()
-    
-    for metric in ['CPU', 'Memory', 'Network']:
-        fig.add_trace(go.Scatter(
-            x=df_realtime['Time'],
-            y=df_realtime[metric],
-            mode='lines+markers',
-            name=f'{metric} %',
-            line=dict(width=2)
-        ))
-    
-    fig.update_layout(
-        title='System Performance Over Time',
-        xaxis_title='Time',
-        yaxis_title='Usage (%)',
-        hovermode='x unified'
+        st.write("**Revenue vs Users**")
+        fig2 = px.scatter(
+            data, 
+            x='users', 
+            y='revenue',
+            size='sales',
+            color='conversion_rate',
+            title='Revenue vs Users (sized by Sales)',
+            color_continuous_scale='Viridis'
+        )
+        fig2.update_layout(height=400)
+        st.plotly_chart(fig2, use_container_width=True)
+    
+    # Full width chart
+    st.write("**Multi-Metric Trend Analysis**")
+    
+    # Normalize data for comparison
+    normalized_data = data.copy()
+    for col in ['sales', 'users', 'revenue']:
+        normalized_data[f'{col}_normalized'] = (normalized_data[col] - normalized_data[col].min()) / (normalized_data[col].max() - normalized_data[col].min())
+    
+    fig3 = go.Figure()
+    fig3.add_trace(go.Scatter(x=normalized_data['date'], y=normalized_data['sales_normalized'], name='Sales (Normalized)'))
+    fig3.add_trace(go.Scatter(x=normalized_data['date'], y=normalized_data['users_normalized'], name='Users (Normalized)'))
+    fig3.add_trace(go.Scatter(x=normalized_data['date'], y=normalized_data['revenue_normalized'], name='Revenue (Normalized)'))
+    
+    fig3.update_layout(
+        title='Normalized Trends Comparison',
+        xaxis_title='Date',
+        yaxis_title='Normalized Value (0-1)',
+        height=400
     )
     
-    st.plotly_chart(fig, use_container_width=True)
+    st.plotly_chart(fig3, use_container_width=True)
+
+
+def create_data_table_section():
+    """
+    Create data table section
+    """
+    st.subheader("📋 Data Table")
     
-    # Status indicators
-    st.subheader("🚨 System Status")
+    data = st.session_state.dashboard_data
     
-    col1, col2, col3, col4 = st.columns(4)
+    # Add filters
+    col1, col2, col3 = st.columns(3)
     
     with col1:
-        status = "🟢 Online" if np.random.random() > 0.1 else "🔴 Offline"
-        st.write(f"**Database:** {status}")
+        min_sales = st.number_input("Min Sales", value=0, max_value=int(data['sales'].max()))
     
     with col2:
-        status = "🟢 Healthy" if np.random.random() > 0.05 else "🟡 Warning"
-        st.write(f"**API:** {status}")
+        min_users = st.number_input("Min Users", value=0, max_value=int(data['users'].max()))
     
     with col3:
-        status = "🟢 Running" if np.random.random() > 0.02 else "🔴 Down"
-        st.write(f"**Services:** {status}")
+        min_revenue = st.number_input("Min Revenue", value=0, max_value=int(data['revenue'].max()))
     
-    with col4:
-        status = "🟢 Good" if np.random.random() > 0.15 else "🟡 Slow"
-        st.write(f"**Network:** {status}")
-    
-    # Recent events log
-    st.subheader("📝 Recent Events")
-    
-    events = [
-        {"time": current_time - timedelta(minutes=2), "event": "System backup completed", "type": "info"},
-        {"time": current_time - timedelta(minutes=5), "event": "High CPU usage detected", "type": "warning"},
-        {"time": current_time - timedelta(minutes=8), "event": "New user registration", "type": "info"},
-        {"time": current_time - timedelta(minutes=12), "event": "Database connection restored", "type": "success"},
-        {"time": current_time - timedelta(minutes=15), "event": "Scheduled maintenance started", "type": "info"},
+    # Filter data
+    filtered_data = data[
+        (data['sales'] >= min_sales) & 
+        (data['users'] >= min_users) & 
+        (data['revenue'] >= min_revenue)
     ]
     
-    for event in events:
-        icon = {"info": "ℹ️", "warning": "⚠️", "success": "✅", "error": "❌"}.get(event["type"], "📝")
-        st.write(f"{icon} **{event['time'].strftime('%H:%M:%S')}** - {event['event']}")
+    # Display filtered data
+    st.write(f"Showing {len(filtered_data)} of {len(data)} records")
+    
+    # Format data for display
+    display_data = filtered_data.copy()
+    display_data['date'] = display_data['date'].dt.strftime('%Y-%m-%d')
+    display_data['revenue'] = display_data['revenue'].apply(lambda x: f"${x:,}")
+    display_data['conversion_rate'] = display_data['conversion_rate'].apply(lambda x: f"{x:.2%}")
+    
+    st.dataframe(
+        display_data,
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "date": "Date",
+            "sales": st.column_config.NumberColumn("Sales", format="%d"),
+            "users": st.column_config.NumberColumn("Users", format="%d"),
+            "revenue": "Revenue",
+            "conversion_rate": "Conversion Rate"
+        }
+    )
     
-    # Auto-refresh functionality
-    if auto_refresh:
-        # Use Streamlit's rerun to refresh the page
-        import time
-        time.sleep(refresh_interval)
-        st.rerun()
+    # Download button
+    csv = data.to_csv(index=False)
+    st.download_button(
+        label="📥 Download Data as CSV",
+        data=csv,
+        file_name=f"dashboard_data_{datetime.now().strftime('%Y%m%d')}.csv",
+        mime="text/csv"
+    )
+
+
+def create_summary_statistics():
+    """
+    Create summary statistics section
+    """
+    data = st.session_state.dashboard_data
+    
+    st.subheader("📊 Summary Statistics")
+    
+    # Calculate statistics
+    stats = data[['sales', 'users', 'revenue', 'conversion_rate']].describe()
+    
+    # Display statistics table
+    st.dataframe(
+        stats,
+        use_container_width=True,
+        column_config={
+            "sales": st.column_config.NumberColumn("Sales", format="%.0f"),
+            "users": st.column_config.NumberColumn("Users", format="%.0f"),
+            "revenue": st.column_config.NumberColumn("Revenue", format="%.0f"),
+            "conversion_rate": st.column_config.NumberColumn("Conversion Rate", format="%.4f")
+        }
+    )
+
+
+# Additional utility functions
+@handle_data_exceptions 
+def export_dashboard_data(format_type='csv'):
+    """
+    Export dashboard data in specified format
+    """
+    data = st.session_state.dashboard_data
+    
+    if format_type == 'csv':
+        return data.to_csv(index=False)
+    elif format_type == 'json':
+        return data.to_json(orient='records', date_format='iso')
+    elif format_type == 'excel':
+        # This would require openpyxl
+        return data.to_excel(index=False)
+    else:
+        raise ValueError(f"Unsupported format: {format_type}")
+
+
+@handle_data_exceptions
+def load_dashboard_config():
+    """
+    Load dashboard configuration
+    """
+    try:
+        config = load_data('dashboard_config.json')
+        return config if config else get_default_config()
+    except:
+        return get_default_config()
+
+
+def get_default_config():
+    """
+    Get default dashboard configuration
+    """
+    return {
+        'theme': 'light',
+        'default_chart_type': 'Line Chart',
+        'refresh_interval': 300,  # 5 minutes
+        'show_metrics': True,
+        'show_charts': True,
+        'show_table': True
+    }
+
+
+@handle_data_exceptions
+def save_dashboard_config(config):
+    """
+    Save dashboard configuration
+    """
+    return save_data(config, 'dashboard_config.json')