projectmycelium/docs/dev/design/archive/USER_DASHBOARD.md

User Dashboard - Focused Implementation Plan

Complete User Experience Lifecycle

🎯 User Dashboard Workflow

The user dashboard must follow this specific user journey:

1. Registration & Onboarding → User creates account and sets preferences
2. Marketplace Discovery → Browse, search, and discover services/apps
3. Purchase & Deployment → Buy services, deploy apps, track orders
4. Active Management → Monitor deployments, manage services
5. Profile & Preferences → Customize experience, manage settings
6. Analytics & Insights → Track spending, usage patterns, optimization

---

🏗️ Implementation Strategy - User Lifecycle

Phase 1: User Activity Tracking 🔄 Foundation

Target: Track all user actions for comprehensive activity timeline

1.1 Enhanced UserActivity Model

// src/models/user.rs - Comprehensive activity tracking
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserActivity {
    pub id: String,
    pub user_email: String,
    pub activity_type: ActivityType,
    pub description: String,
    pub timestamp: DateTime<Utc>,
    pub metadata: HashMap<String, serde_json::Value>,
    pub related_entity_id: Option<String>,  // Product ID, Service ID, etc.
    pub related_entity_type: Option<String>, // "product", "service", "app"
    pub impact_level: ActivityImpact,
    pub session_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ActivityType {
    Login,
    Logout,
    MarketplaceBrowse,
    ProductView,
    CartAdd,
    CartRemove,
    Purchase,
    ServiceDeploy,
    AppDeploy,
    ProfileUpdate,
    PreferencesUpdate,
    WalletTransaction,
    PoolInvestment,
    ServiceRating,
    SupportRequest,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ActivityImpact {
    Low,    // Browsing, viewing
    Medium, // Profile updates, cart actions
    High,   // Purchases, deployments, transactions
}

1.2 Activity Tracking Service

// src/services/user_service.rs - Activity management
impl UserService {
    pub fn track_activity(&self, user_email: &str, activity: UserActivity) -> Result<(), String> {
        let mut persistent_data = UserPersistence::load_user_data(user_email)
            .unwrap_or_else(|| UserPersistence::create_default_user_data(user_email));
        
        persistent_data.user_activities.push(activity);
        
        // Keep only last 1000 activities to prevent data bloat
        if persistent_data.user_activities.len() > 1000 {
            persistent_data.user_activities.drain(0..persistent_data.user_activities.len() - 1000);
        }
        
        UserPersistence::save_user_data(user_email, &persistent_data)
    }
    
    pub fn get_user_activities(&self, user_email: &str, limit: Option<usize>, filter: Option<ActivityType>) -> Vec<UserActivity> {
        if let Some(data) = UserPersistence::load_user_data(user_email) {
            let mut activities = data.user_activities;
            
            // Filter by activity type if specified
            if let Some(filter_type) = filter {
                activities.retain(|a| std::mem::discriminant(&a.activity_type) == std::mem::discriminant(&filter_type));
            }
            
            // Sort by timestamp (most recent first)
            activities.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
            
            // Apply limit
            if let Some(limit) = limit {
                activities.truncate(limit);
            }
            
            activities
        } else {
            Vec::new()
        }
    }
    
    pub fn get_activity_summary(&self, user_email: &str, days: i32) -> HashMap<String, i32> {
        let activities = self.get_user_activities(user_email, None, None);
        let cutoff_date = Utc::now() - chrono::Duration::days(days as i64);
        
        let recent_activities: Vec<&UserActivity> = activities.iter()
            .filter(|a| a.timestamp > cutoff_date)
            .collect();
        
        let mut summary = HashMap::new();
        for activity in recent_activities {
            let activity_name = format!("{:?}", activity.activity_type);
            *summary.entry(activity_name).or_insert(0) += 1;
        }
        
        summary
    }
}

Phase 2: Purchase & Deployment Management 🔄 Core Feature

Target: Comprehensive purchase tracking and deployment monitoring

2.1 Enhanced Purchase Models

// src/models/user.rs - Purchase and deployment tracking
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PurchaseRecord {
    pub id: String,
    pub transaction_id: String,
    pub product_id: String,
    pub product_name: String,
    pub product_type: ProductType,
    pub provider_id: String,
    pub provider_name: String,
    pub amount: Decimal,
    pub currency: String,
    pub purchase_date: DateTime<Utc>,
    pub status: PurchaseStatus,
    pub deployment_info: Option<DeploymentInfo>,
    pub service_period: Option<ServicePeriod>,
    pub rating: Option<f32>,
    pub review: Option<String>,
    pub support_tickets: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ProductType {
    Service,
    Application,
    ComputeSlice,
    Storage,
    Network,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PurchaseStatus {
    Pending,
    Active,
    Completed,
    Cancelled,
    Refunded,
    Expired,
    Suspended,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeploymentInfo {
    pub deployment_id: String,
    pub status: DeploymentStatus,
    pub region: String,
    pub node_id: Option<String>,
    pub resources_allocated: ResourceAllocation,
    pub uptime_percentage: f32,
    pub last_health_check: DateTime<Utc>,
    pub deployment_url: Option<String>,
    pub access_credentials: Option<AccessCredentials>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum DeploymentStatus {
    Deploying,
    Running,
    Stopped,
    Error,
    Maintenance,
    Scaling,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceAllocation {
    pub cpu_cores: f32,
    pub memory_gb: f32,
    pub storage_gb: f32,
    pub bandwidth_mbps: f32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServicePeriod {
    pub start_date: DateTime<Utc>,
    pub end_date: Option<DateTime<Utc>>,
    pub auto_renewal: bool,
    pub hours_used: f32,
    pub sessions_completed: i32,
    pub next_billing_date: Option<DateTime<Utc>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccessCredentials {
    pub username: Option<String>,
    pub password: Option<String>,
    pub api_key: Option<String>,
    pub ssh_key: Option<String>,
}

2.2 Purchase Management Service

// src/services/user_service.rs - Purchase management
impl UserService {
    pub fn get_purchase_history(&self, user_email: &str, limit: Option<usize>) -> Vec<PurchaseRecord> {
        if let Some(data) = UserPersistence::load_user_data(user_email) {
            // Convert transactions to purchase records
            let mut purchases: Vec<PurchaseRecord> = data.transactions.iter()
                .filter(|t| matches!(t.transaction_type, crate::models::user::TransactionType::Purchase { .. }))
                .map(|t| self.transaction_to_purchase_record(t))
                .collect();
            
            purchases.sort_by(|a, b| b.purchase_date.cmp(&a.purchase_date));
            
            if let Some(limit) = limit {
                purchases.truncate(limit);
            }
            
            purchases
        } else {
            Vec::new()
        }
    }
    
    pub fn get_active_deployments(&self, user_email: &str) -> Vec<PurchaseRecord> {
        self.get_purchase_history(user_email, None).into_iter()
            .filter(|p| matches!(p.status, PurchaseStatus::Active) && p.deployment_info.is_some())
            .collect()
    }
    
    pub fn get_purchase_by_id(&self, user_email: &str, purchase_id: &str) -> Option<PurchaseRecord> {
        self.get_purchase_history(user_email, None).into_iter()
            .find(|p| p.id == purchase_id)
    }
    
    pub fn update_purchase_rating(&self, user_email: &str, purchase_id: &str, rating: f32, review: Option<String>) -> Result<(), String> {
        // Update purchase record with rating and review
        // Track rating activity
        let activity = UserActivity::builder()
            .activity_type(ActivityType::ServiceRating)
            .description(format!("Rated purchase: {} stars", rating))
            .related_entity_id(purchase_id.to_string())
            .impact_level(ActivityImpact::Medium)
            .build()?;
        
        self.track_activity(user_email, activity)?;
        
        // Save updated purchase record
        Ok(())
    }
    
    pub fn get_deployment_status(&self, user_email: &str, deployment_id: &str) -> Option<DeploymentInfo> {
        self.get_active_deployments(user_email).into_iter()
            .find_map(|p| p.deployment_info)
            .filter(|d| d.deployment_id == deployment_id)
    }
}

Phase 3: Profile & Preferences Management 🔄 Personalization

Target: Complete user profile and preference management

3.1 Enhanced User Profile Models

// src/models/user.rs - Profile and preferences
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserProfile {
    pub user_email: String,
    pub display_name: String,
    pub first_name: Option<String>,
    pub last_name: Option<String>,
    pub avatar_url: Option<String>,
    pub bio: Option<String>,
    pub company: Option<String>,
    pub job_title: Option<String>,
    pub country: Option<String>,
    pub timezone: String,
    pub phone: Option<String>,
    pub website: Option<String>,
    pub social_links: HashMap<String, String>,
    pub profile_visibility: ProfileVisibility,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ProfileVisibility {
    Public,
    Limited,
    Private,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserPreferences {
    // Display preferences
    pub preferred_currency: String,
    pub language: String,
    pub theme: Theme,
    pub dashboard_layout: DashboardLayout,
    pub items_per_page: i32,
    
    // Notification preferences
    pub email_notifications: bool,
    pub push_notifications: bool,
    pub marketing_emails: bool,
    pub security_alerts: bool,
    pub deployment_alerts: bool,
    pub billing_alerts: bool,
    
    // Marketplace preferences
    pub default_category_filter: Option<String>,
    pub price_range_filter: Option<(Decimal, Decimal)>,
    pub preferred_providers: Vec<String>,
    pub blocked_providers: Vec<String>,
    pub auto_renewal_default: bool,
    
    // Privacy preferences
    pub activity_tracking: bool,
    pub analytics_participation: bool,
    pub data_sharing: bool,
    pub cookie_preferences: CookiePreferences,
    
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Theme {
    Light,
    Dark,
    Auto,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum DashboardLayout {
    Compact,
    Detailed,
    Cards,
    List,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CookiePreferences {
    pub essential: bool,        // Always true
    pub analytics: bool,
    pub marketing: bool,
    pub personalization: bool,
}

3.2 Profile Management Service

// src/services/user_service.rs - Profile management
impl UserService {
    pub fn get_user_profile(&self, user_email: &str) -> Option<UserProfile> {
        if let Some(data) = UserPersistence::load_user_data(user_email) {
            // Convert persistent data to profile
            Some(UserProfile {
                user_email: data.user_email.clone(),
                display_name: data.name.clone().unwrap_or_else(|| user_email.split('@').next().unwrap_or("User").to_string()),
                country: data.country.clone(),
                timezone: data.timezone.clone().unwrap_or_else(|| "UTC".to_string()),
                // ... map other fields
                created_at: Utc::now(), // Would be stored in real implementation
                updated_at: Utc::now(),
            })
        } else {
            None
        }
    }
    
    pub fn update_user_profile(&self, user_email: &str, profile: UserProfile) -> Result<(), String> {
        let mut persistent_data = UserPersistence::load_user_data(user_email)
            .unwrap_or_else(|| UserPersistence::create_default_user_data(user_email));
        
        // Update persistent data fields
        persistent_data.name = Some(profile.display_name.clone());
        persistent_data.country = profile.country.clone();
        persistent_data.timezone = profile.timezone.clone().into();
        
        // Track profile update activity
        let activity = UserActivity::builder()
            .activity_type(ActivityType::ProfileUpdate)
            .description("Updated profile information".to_string())
            .impact_level(ActivityImpact::Medium)
            .build()?;
        
        persistent_data.user_activities.push(activity);
        
        UserPersistence::save_user_data(user_email, &persistent_data)
    }
    
    pub fn get_user_preferences(&self, user_email: &str) -> Option<UserPreferences> {
        if let Some(data) = UserPersistence::load_user_data(user_email) {
            data.user_preferences
        } else {
            None
        }
    }
    
    pub fn update_user_preferences(&self, user_email: &str, preferences: UserPreferences) -> Result<(), String> {
        let mut persistent_data = UserPersistence::load_user_data(user_email)
            .unwrap_or_else(|| UserPersistence::create_default_user_data(user_email));
        
        persistent_data.user_preferences = Some(preferences);
        
        // Track preferences update activity
        let activity = UserActivity::builder()
            .activity_type(ActivityType::PreferencesUpdate)
            .description("Updated preferences".to_string())
            .impact_level(ActivityImpact::Medium)
            .build()?;
        
        persistent_data.user_activities.push(activity);
        
        UserPersistence::save_user_data(user_email, &persistent_data)
    }
}

Phase 4: Analytics & Insights 🔄 Intelligence

Target: Provide meaningful insights about user behavior and spending

4.1 Usage Analytics Models

// src/models/user.rs - Analytics and insights
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UsageStatistics {
    pub user_email: String,
    pub total_purchases: i32,
    pub total_spent: Decimal,
    pub average_monthly_spending: Decimal,
    pub favorite_categories: Vec<CategoryUsage>,
    pub preferred_providers: Vec<ProviderUsage>,
    pub spending_trends: Vec<MonthlySpending>,
    pub deployment_stats: DeploymentStatistics,
    pub activity_patterns: ActivityPatterns,
    pub last_calculated: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CategoryUsage {
    pub category: String,
    pub purchase_count: i32,
    pub total_spent: Decimal,
    pub percentage_of_total: f32,
    pub last_purchase: DateTime<Utc>,
    pub average_rating: f32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProviderUsage {
    pub provider_id: String,
    pub provider_name: String,
    pub purchase_count: i32,
    pub total_spent: Decimal,
    pub average_rating: f32,
    pub last_purchase: DateTime<Utc>,
    pub satisfaction_score: f32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MonthlySpending {
    pub month: String,              // "2025-06"
    pub total_spent: Decimal,
    pub purchase_count: i32,
    pub categories: HashMap<String, Decimal>,
    pub providers: HashMap<String, Decimal>,
    pub average_per_purchase: Decimal,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeploymentStatistics {
    pub total_deployments: i32,
    pub active_deployments: i32,
    pub average_uptime: f32,
    pub total_resource_hours: f32,
    pub monthly_costs: Decimal,
    pub cost_efficiency_score: f32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActivityPatterns {
    pub most_active_hours: Vec<i32>,    // Hours of day (0-23)
    pub most_active_days: Vec<String>,  // Days of week
    pub session_frequency: f32,         // Sessions per week
    pub average_session_duration: i32,  // Minutes
    pub peak_usage_times: Vec<String>,
}

4.2 Analytics Service

// src/services/user_service.rs - Analytics and insights
impl UserService {
    pub fn calculate_usage_statistics(&self, user_email: &str) -> UsageStatistics {
        let purchases = self.get_purchase_history(user_email, None);
        let activities = self.get_user_activities(user_email, None, None);
        
        let total_spent = purchases.iter().map(|p| p.amount).sum();
        let total_purchases = purchases.len() as i32;
        
        // Calculate favorite categories
        let mut category_stats: HashMap<String, (i32, Decimal)> = HashMap::new();
        for purchase in &purchases {
            let category = format!("{:?}", purchase.product_type);
            let entry = category_stats.entry(category).or_insert((0, Decimal::from(0)));
            entry.0 += 1;
            entry.1 += purchase.amount;
        }
        
        let favorite_categories: Vec<CategoryUsage> = category_stats.into_iter()
            .map(|(category, (count, spent))| CategoryUsage {
                category,
                purchase_count: count,
                total_spent: spent,
                percentage_of_total: if total_spent > Decimal::from(0) {
                    (spent / total_spent * Decimal::from(100)).to_f32().unwrap_or(0.0)
                } else {
                    0.0
                },
                last_purchase: purchases.iter()
                    .filter(|p| format!("{:?}", p.product_type) == category)
                    .map(|p| p.purchase_date)
                    .max()
                    .unwrap_or(Utc::now()),
                average_rating: 4.5, // Calculate from actual ratings
            })
            .collect();
        
        // Calculate monthly spending trends
        let spending_trends = self.calculate_monthly_spending_trends(&purchases);
        
        // Calculate activity patterns
        let activity_patterns = self.calculate_activity_patterns(&activities);
        
        UsageStatistics {
            user_email: user_email.to_string(),
            total_purchases,
            total_spent,
            average_monthly_spending: if spending_trends.len() > 0 {
                spending_trends.iter().map(|m| m.total_spent).sum::<Decimal>() / Decimal::from(spending_trends.len())
            } else {
                Decimal::from(0)
            },
            favorite_categories,
            preferred_providers: Vec::new(), // Calculate similar to categories
            spending_trends,
            deployment_stats: self.calculate_deployment_stats(user_email),
            activity_patterns,
            last_calculated: Utc::now(),
        }
    }
    
    pub fn get_spending_recommendations(&self, user_email: &str) -> Vec<SpendingRecommendation> {
        let stats = self.calculate_usage_statistics(user_email);
        let mut recommendations = Vec::new();
        
        // Analyze spending patterns and generate recommendations
        if stats.average_monthly_spending > Decimal::from(100) {
            recommendations.push(SpendingRecommendation {
                type_: "cost_optimization".to_string(),
                title: "Consider annual subscriptions".to_string(),
                description: "You could save 15% by switching to annual billing".to_string(),
                potential_savings: stats.average_monthly_spending * Decimal::from(12) * Decimal::from(0.15),
                confidence: 0.8,
            });
        }
        
        recommendations
    }
    
    pub fn get_product_recommendations(&self, user_email: &str) -> Vec<Product> {
        let stats = self.calculate_usage_statistics(user_email);
        
        // Get products from favorite categories that user hasn't purchased
        // This would integrate with the existing ProductService
        Vec::new() // Placeholder
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpendingRecommendation {
    pub type_: String,
    pub title: String,
    pub description: String,
    pub potential_savings: Decimal,
    pub confidence: f32,
}

---

🎨 UI Implementation - Complete User Experience

Dashboard Navigation

/dashboard/user/
├── overview              # Main dashboard with personalized insights
├── activity             # Complete activity timeline and analytics
├── purchases            # Purchase history and active deployments
├── deployments          # Active service and app management
├── profile              # Personal information and account settings
├── preferences          # Customization and notification settings
├── analytics            # Spending insights and usage patterns
├── wallet               # TFP balance, transactions, pool positions
└── recommendations      # Personalized product and optimization suggestions

Main User Dashboard (/dashboard/user)

<!-- Personalized Welcome Section -->
<div class="welcome-section">
    <div class="user-greeting">
        <h2>Welcome back, {{ user_profile.display_name }}!</h2>
        <p class="last-login">Last login: {{ user_stats.last_login | date }}</p>
    </div>
    <div class="quick-stats">
        <div class="stat-card">
            <h3>Active Services</h3>
            <div class="stat-value">{{ active_deployments|length }}</div>
            <div class="stat-change">{{ deployment_change }}</div>
        </div>
        <div class="stat-card">
            <h3>This Month</h3>
            <div class="stat-value">{{ monthly_spending }} TFP</div>
            <div class="stat-change">{{ spending_change }}</div>
        </div>
        <div class="stat-card">
            <h3>Wallet Balance</h3>
            <div class="stat-value">{{ wallet_balance }} TFP</div>
            <div class="stat-change">{{ balance_change }}</div>
        </div>
    </div>
</div>

<!-- Recent Activity Timeline -->
<section class="activity-timeline">
    <h3>Recent Activity</h3>
    <div class="timeline">
        {% for activity in recent_activities %}
        <div class="timeline-item" data-impact="{{ activity.impact_level|lower }}">
            <div class="timeline-icon">
                <i class="icon-{{ activity.activity_type|lower }}"></i>
            </div>
            <div class="timeline-content">
                <div class="activity-description">{{ activity.description }}</div>
                <div class="activity-time">{{ activity.timestamp | timeago }}</div>
                {% if activity.metadata %}
                <div class="activity-metadata">
                    {% for key, value in activity.metadata %}
                    <span class="metadata-item">{{ key }}: {{ value }}</span>
                    {% endfor %}
                </div>
                {% endif %}
            </div>
        </div>
        {% endfor %}
    </div>
    <a href="/dashboard/user/activity" class="view-all-link">View All Activity</a>
</section>

<!-- Active Deployments -->
<section class="active-deployments">
    <h3>Active Deployments</h3>
    <div class="deployment-grid">
        {% for deployment in active_deployments %}
        <div class="deployment-card" data-status="{{ deployment.deployment_info.status|lower }}">
            <div class="deployment-header">
                <h4>{{ deployment.product_name }}</h4>
                <span class="status-badge {{ deployment.deployment_info.status|lower }}">
                    {{ deployment.deployment_info.status }}
                </span>
            </div>
            <div class="deployment-details">
                <div class="detail-row">
                    <span class="label">Provider:</span>
                    <span class="value">{{ deployment.provider_name }}</span>
                </div>
                <div class="detail-row">
                    <span class="label">Region:</span>
                    <span class="value">{{ deployment.deployment_info.region }}</span>
                </div>
                <div class="detail-row">
                    <span class="label">Uptime:</span>
                    <span class="value">{{ deployment.deployment_info.uptime_percentage }}%</span>
                </div>
                <div class="detail-row">
                    <span class="label">Monthly Cost:</span>
                    <span class="value">{{ deployment.monthly_cost }} TFP</span>
                </div>
            </div>
            <div class="deployment-actions">
                <button onclick="manageDeployment('{{ deployment.deployment_info.deployment_id }}')">
                    Manage
                </button>
                {% if deployment.deployment_info.deployment_url %}
                <a href="{{ deployment.deployment_info.deployment_url }}" target="_blank" class="btn btn-secondary">
                    Access
                </a>
                {% endif %}
            </div>
        </div>
        {% endfor %}
    </div>
</section>

<!-- Insights and Recommendations -->
<section class="insights-section">
    <h3>Insights & Recommendations</h3>
    <div class="insights-grid">
        <div class="insight-card">
            <h4>Spending Pattern</h4>
            <p>You spend most on {{ top_category }} services</p>
            <div class="insight-chart">
                <!-- Spending breakdown chart -->
            </div>
        </div>
        <div class="insight-card">
            <h4>Cost Optimization</h4>
            <p>Switch to annual billing to save {{ potential_savings }} TFP/year</p>
            <button class="btn btn-primary">Learn More</button>
        </div>
        <div class="insight-card">
            <h4>Recommended for You</h4>
            <div class="recommendation-list">
                {% for product in recommended_products %}
                <div class="recommendation-item">
                    <span class="product-name">{{ product.name }}</span>
                    <span class="product-price">{{ product.price }} TFP</span>
                </div>
                {% endfor %}
            </div>
        </div>
    </div>
</section>

Purchase Management (/dashboard/user/purchases)

<!-- Purchase History with Advanced Filtering -->
<div class="purchase-management">
    <div class="purchase-filters">
        <select id="status-filter">
            <option value="">All Statuses</option>
            <option value="active">Active</option>
            <option value="completed">Completed</option>
            <option value="cancelled">Cancelled</option>
        </select>
        <select id="type-filter">
            <option value="">All Types</option>
            <option value="service">Services</option>
            <option value="application">Applications</option>
            <option value="compute">Compute</option>
        </select>
        <input type="date" id="date-from" placeholder="From Date">
        <input type="date" id="date-to" placeholder="To Date">
        <button onclick="applyFilters()">Filter</button>
    </div>
    
    <div class="purchase-grid">
        {% for purchase in purchases %}
        <div class="purchase-card" data-status="{{ purchase.status|lower }}">
            <div class="purchase-header">
                <h4>{{ purchase.product_name }}</h4>
                <span class="status-badge {{ purchase.status|lower }}">{{ purchase.status }}</span>
            </div>
            <div class="purchase-details">
                <div class="detail-row">
                    <span class="label">Provider:</span>
                    <span class="value">{{ purchase.provider_name }}</span>
                </div>
                <div class="detail-row">
                    <span class="label">Purchase Date:</span>
                    <span class="value">{{ purchase.purchase_date | date }}</span>
                </div>
                <div class="detail-row">
                    <span class="label">Amount:</span>
                    <span class="value">{{ purchase.amount }} {{ purchase.currency }}</span>
                </div>
                {% if purchase.deployment_info %}
                <div class="detail-row">
                    <span class="label">Deployment:</span>
                    <span class="value">{{ purchase.deployment_info.status }}</span>
                </div>
                {% endif %}
            </div>
            <div class="purchase-actions">
                <button onclick="viewPurchaseDetails('{{ purchase.id }}')">Details</button>
                {% if purchase.status == "Active" %}
                <button onclick="managePurchase('{{ purchase.id }}')">Manage</button>
                {% endif %}
                {% if not purchase.rating %}
                <button onclick="ratePurchase('{{ purchase.id }}')">Rate</button>
                {% endif %}
            </div>
        </div>
        {% endfor %}
    </div>
</div>

---

📋 **Implementation Checklist

---

📋 Implementation Checklist - User Lifecycle

Phase 1: Activity Tracking Foundation

• Create enhanced UserActivity model with activity types and impact levels
• Implement ActivityType enum with all user action types
• Add activity tracking methods to UserService
• Create activity timeline UI with filtering and search
• Add automatic activity tracking hooks throughout the application

Phase 2: Purchase & Deployment Management

• Create comprehensive PurchaseRecord model with deployment info
• Implement DeploymentInfo model with status and resource tracking
• Add purchase management methods to UserService
• Create purchase history UI with advanced filtering
• Implement deployment monitoring and management interface
• Add purchase rating and review system

Phase 3: Profile & Preferences Management

• Create detailed UserProfile model with all personal information
• Implement comprehensive UserPreferences model
• Add profile management methods to UserService
• Create profile editing UI with validation
• Implement preferences management with real-time updates
• Add privacy controls and visibility settings

Phase 4: Analytics & Insights

• Create UsageStatistics model with spending and usage analytics
• Implement analytics calculation methods in UserService
• Add spending trend analysis and forecasting
• Create analytics dashboard with charts and insights
• Implement recommendation engine for products and optimizations
• Add comparative analytics and benchmarking

Phase 5: Controller Implementation

• Add user dashboard controller methods to DashboardController
• Implement activity tracking API endpoints
• Add purchase management API endpoints
• Create profile and preferences API endpoints
• Implement analytics and insights API endpoints
• Add proper authentication and authorization

Phase 6: UI Templates

• Create main user dashboard template with personalized overview
• Implement activity timeline template with filtering
• Create purchase history template with deployment tracking
• Build profile management template with comprehensive forms
• Implement preferences template with all user controls
• Create analytics dashboard template with charts and insights

Phase 7: Routes & Integration

• Add all user dashboard routes to routing configuration
• Implement RESTful API endpoints for user data management
• Add proper middleware for authentication and validation
• Integrate with existing wallet and transaction systems
• Connect with marketplace for purchase tracking
• Add real-time updates and notifications

Phase 8: Data Migration & Enhancement

• Extend UserPersistentData with new user models
• Create migration helpers for existing user data
• Add builder patterns for all new models
• Implement data validation and sanitization
• Add data export and import functionality

---

🎯 Success Criteria - Complete User Experience

Functional Requirements

• User can view comprehensive dashboard with personalized insights
• User can track complete activity history with detailed timeline
• User can manage all purchases with deployment monitoring
• User can update profile and preferences with full control
• User can view detailed analytics and spending insights
• User can receive personalized recommendations and optimizations

User Experience Requirements

• Dashboard loads quickly with real-time data
• Activity tracking works automatically across all user actions
• Purchase history accurately reflects all marketplace transactions
• Profile management provides intuitive and comprehensive controls
• Analytics provide meaningful insights and actionable recommendations
• Navigation between sections is smooth and consistent

Technical Requirements

• All new code follows established builder patterns
• All services use proper error handling with Result types
• All templates use ContextBuilder for consistency
• All data loading uses UserPersistence for real data
• Performance optimized for large datasets and frequent updates
• Security controls protect user privacy and data

Data Integration Requirements

• Activity tracking integrates with all existing user actions
• Purchase history connects with existing transaction system
• Profile data syncs with existing user authentication
• Analytics calculations use real transaction and activity data
• Recommendations based on actual user behavior patterns
• Wallet integration shows real TFP balances and transactions

Testing Requirements

• Complete user workflow testing from registration to analytics
• Activity tracking verification across all user actions
• Purchase and deployment management testing
• Profile and preferences functionality testing
• Analytics accuracy and recommendation quality testing
• Performance testing with large datasets

---

🚀 Implementation Priority

High Priority (Essential)

1. Activity Tracking - Foundation for all user insights
2. Purchase Management - Core user functionality
3. Profile Management - Essential user control

Medium Priority (Important)

1. Analytics & Insights - Value-added intelligence
2. Deployment Monitoring - Advanced management features
3. Recommendations - Personalization features

Low Priority (Enhancement)

1. Advanced Analytics - Detailed reporting and forecasting
2. Social Features - Profile sharing and community
3. Export/Import - Data portability features

---

💡 Implementation Tips

Start Simple, Build Complex

• Begin with basic activity tracking and purchase history
• Add analytics and insights once foundation is solid
• Implement advanced features after core functionality works

Leverage Existing Patterns

• Copy controller patterns from existing dashboard sections
• Use established service builder patterns throughout
• Follow existing template structures and CSS classes

Focus on Real Data

• Always use UserPersistence::load_user_data() for data access
• Convert existing transactions to purchase records
• Build analytics from real user activity and transaction data

Maintain Performance

• Limit activity history to prevent data bloat
• Use pagination for large datasets
• Cache analytics calculations when possible

This comprehensive plan provides everything needed to create a complete user dashboard that matches the quality and functionality of modern SaaS platforms while maintaining the excellent architectural patterns established in the Project Mycelium.