978 lines
36 KiB
Markdown
978 lines
36 KiB
Markdown
# 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**
|
|
```rust
|
|
// 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**
|
|
```rust
|
|
// 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**
|
|
```rust
|
|
// 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**
|
|
```rust
|
|
// 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**
|
|
```rust
|
|
// 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**
|
|
```rust
|
|
// 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**
|
|
```rust
|
|
// 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**
|
|
```rust
|
|
// 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`)
|
|
```html
|
|
<!-- 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`)
|
|
```html
|
|
<!-- 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. |