Rodrigo Rodriguez (Pragmatismo)
479950945b
- Add generate_secure_password() for OTP generation during admin bootstrap - Display admin credentials (username/password) in console on first run - Save credentials to ~/.gb-setup-credentials file - Fix Zitadel client to support PAT token authentication - Replace OAuth2 password grant with Zitadel Session API for login - Fix get_current_user to fetch user data from Zitadel session - Return session_id as access_token for proper authentication - Set email as verified on user creation to skip verification - Add password grant type to OAuth application config - Update directory_setup to include proper redirect URIs
1106 lines
35 KiB
Rust
1106 lines
35 KiB
Rust
use axum::{
|
|
extract::{Query, State},
|
|
http::StatusCode,
|
|
response::{Html, Json},
|
|
routing::get,
|
|
Router,
|
|
};
|
|
use chrono::{DateTime, Utc};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::sync::Arc;
|
|
use uuid::Uuid;
|
|
|
|
use crate::core::urls::ApiUrls;
|
|
use crate::shared::state::AppState;
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct ConfigUpdateRequest {
|
|
pub config_key: String,
|
|
pub config_value: serde_json::Value,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct MaintenanceScheduleRequest {
|
|
pub scheduled_at: DateTime<Utc>,
|
|
pub duration_minutes: u32,
|
|
pub reason: String,
|
|
pub notify_users: bool,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct BackupRequest {
|
|
pub backup_type: String,
|
|
pub include_files: bool,
|
|
pub include_database: bool,
|
|
pub compression: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct RestoreRequest {
|
|
pub backup_id: String,
|
|
pub restore_point: DateTime<Utc>,
|
|
pub verify_before_restore: bool,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct UserManagementRequest {
|
|
pub user_id: Uuid,
|
|
pub action: String,
|
|
pub reason: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct RoleManagementRequest {
|
|
pub role_name: String,
|
|
pub permissions: Vec<String>,
|
|
pub description: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct QuotaManagementRequest {
|
|
pub user_id: Option<Uuid>,
|
|
pub group_id: Option<Uuid>,
|
|
pub quota_type: String,
|
|
pub limit_value: u64,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct LicenseManagementRequest {
|
|
pub license_key: String,
|
|
pub license_type: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct LogQuery {
|
|
pub start_date: Option<String>,
|
|
pub end_date: Option<String>,
|
|
pub level: Option<String>,
|
|
pub service: Option<String>,
|
|
pub limit: Option<u32>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct SystemStatusResponse {
|
|
pub status: String,
|
|
pub uptime_seconds: u64,
|
|
pub version: String,
|
|
pub services: Vec<ServiceStatus>,
|
|
pub health_checks: Vec<HealthCheck>,
|
|
pub last_restart: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct ServiceStatus {
|
|
pub name: String,
|
|
pub status: String,
|
|
pub uptime_seconds: u64,
|
|
pub memory_mb: f64,
|
|
pub cpu_percent: f64,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct HealthCheck {
|
|
pub name: String,
|
|
pub status: String,
|
|
pub message: Option<String>,
|
|
pub last_check: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct SystemMetricsResponse {
|
|
pub cpu_usage: f64,
|
|
pub memory_total_mb: u64,
|
|
pub memory_used_mb: u64,
|
|
pub memory_percent: f64,
|
|
pub disk_total_gb: u64,
|
|
pub disk_used_gb: u64,
|
|
pub disk_percent: f64,
|
|
pub network_in_mbps: f64,
|
|
pub network_out_mbps: f64,
|
|
pub active_connections: u32,
|
|
pub request_rate_per_minute: u32,
|
|
pub error_rate_percent: f64,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct LogEntry {
|
|
pub id: Uuid,
|
|
pub timestamp: DateTime<Utc>,
|
|
pub level: String,
|
|
pub service: String,
|
|
pub message: String,
|
|
pub metadata: Option<serde_json::Value>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct ConfigResponse {
|
|
pub configs: Vec<ConfigItem>,
|
|
pub last_updated: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct ConfigItem {
|
|
pub key: String,
|
|
pub value: serde_json::Value,
|
|
pub description: Option<String>,
|
|
pub editable: bool,
|
|
pub requires_restart: bool,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct MaintenanceResponse {
|
|
pub id: Uuid,
|
|
pub scheduled_at: DateTime<Utc>,
|
|
pub duration_minutes: u32,
|
|
pub reason: String,
|
|
pub status: String,
|
|
pub created_by: String,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct BackupResponse {
|
|
pub id: Uuid,
|
|
pub backup_type: String,
|
|
pub size_bytes: u64,
|
|
pub created_at: DateTime<Utc>,
|
|
pub status: String,
|
|
pub download_url: Option<String>,
|
|
pub expires_at: Option<DateTime<Utc>>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct QuotaResponse {
|
|
pub id: Uuid,
|
|
pub entity_type: String,
|
|
pub entity_id: Uuid,
|
|
pub quota_type: String,
|
|
pub limit_value: u64,
|
|
pub current_value: u64,
|
|
pub percent_used: f64,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct LicenseResponse {
|
|
pub id: Uuid,
|
|
pub license_type: String,
|
|
pub status: String,
|
|
pub max_users: u32,
|
|
pub current_users: u32,
|
|
pub features: Vec<String>,
|
|
pub issued_at: DateTime<Utc>,
|
|
pub expires_at: Option<DateTime<Utc>>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct SuccessResponse {
|
|
pub success: bool,
|
|
pub message: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct AdminDashboardData {
|
|
pub total_users: i64,
|
|
pub active_groups: i64,
|
|
pub running_bots: i64,
|
|
pub storage_used_gb: f64,
|
|
pub storage_total_gb: f64,
|
|
pub recent_activity: Vec<ActivityItem>,
|
|
pub system_health: SystemHealth,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct ActivityItem {
|
|
pub id: String,
|
|
pub action: String,
|
|
pub user: String,
|
|
pub timestamp: DateTime<Utc>,
|
|
pub details: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct SystemHealth {
|
|
pub status: String,
|
|
pub cpu_percent: f64,
|
|
pub memory_percent: f64,
|
|
pub services_healthy: i32,
|
|
pub services_total: i32,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct StatValue {
|
|
pub value: String,
|
|
pub label: String,
|
|
pub trend: Option<String>,
|
|
}
|
|
|
|
pub fn configure() -> Router<Arc<AppState>> {
|
|
Router::new()
|
|
.route(ApiUrls::ADMIN_DASHBOARD, get(get_admin_dashboard))
|
|
.route(ApiUrls::ADMIN_STATS_USERS, get(get_stats_users))
|
|
.route(ApiUrls::ADMIN_STATS_GROUPS, get(get_stats_groups))
|
|
.route(ApiUrls::ADMIN_STATS_BOTS, get(get_stats_bots))
|
|
.route(ApiUrls::ADMIN_STATS_STORAGE, get(get_stats_storage))
|
|
.route(ApiUrls::ADMIN_USERS, get(get_admin_users))
|
|
.route(ApiUrls::ADMIN_GROUPS, get(get_admin_groups))
|
|
.route(ApiUrls::ADMIN_BOTS, get(get_admin_bots))
|
|
.route(ApiUrls::ADMIN_DNS, get(get_admin_dns))
|
|
.route(ApiUrls::ADMIN_BILLING, get(get_admin_billing))
|
|
.route(ApiUrls::ADMIN_AUDIT, get(get_admin_audit))
|
|
.route(ApiUrls::ADMIN_SYSTEM, get(get_system_status))
|
|
}
|
|
|
|
pub async fn get_admin_dashboard(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="dashboard-view">
|
|
<div class="page-header">
|
|
<h1 data-i18n="admin-dashboard-title">Dashboard</h1>
|
|
<p class="subtitle" data-i18n="admin-dashboard-subtitle">System overview and quick statistics</p>
|
|
</div>
|
|
|
|
<div class="stats-grid">
|
|
<div class="stat-card"
|
|
hx-get="/api/admin/stats/users"
|
|
hx-trigger="load, every 30s"
|
|
hx-swap="innerHTML">
|
|
<div class="loading-state"><div class="spinner"></div></div>
|
|
</div>
|
|
<div class="stat-card"
|
|
hx-get="/api/admin/stats/groups"
|
|
hx-trigger="load, every 30s"
|
|
hx-swap="innerHTML">
|
|
<div class="loading-state"><div class="spinner"></div></div>
|
|
</div>
|
|
<div class="stat-card"
|
|
hx-get="/api/admin/stats/bots"
|
|
hx-trigger="load, every 30s"
|
|
hx-swap="innerHTML">
|
|
<div class="loading-state"><div class="spinner"></div></div>
|
|
</div>
|
|
<div class="stat-card"
|
|
hx-get="/api/admin/stats/storage"
|
|
hx-trigger="load, every 30s"
|
|
hx-swap="innerHTML">
|
|
<div class="loading-state"><div class="spinner"></div></div>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2 data-i18n="admin-quick-actions">Quick Actions</h2>
|
|
<div class="quick-actions-grid">
|
|
<button class="action-card" onclick="document.getElementById('create-user-modal').showModal()">
|
|
<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<path d="M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path>
|
|
<circle cx="8.5" cy="7" r="4"></circle>
|
|
<line x1="20" y1="8" x2="20" y2="14"></line>
|
|
<line x1="23" y1="11" x2="17" y2="11"></line>
|
|
</svg>
|
|
<span data-i18n="admin-add-user">Add User</span>
|
|
</button>
|
|
<button class="action-card" onclick="document.getElementById('create-group-modal').showModal()">
|
|
<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path>
|
|
<circle cx="9" cy="7" r="4"></circle>
|
|
<line x1="23" y1="11" x2="17" y2="11"></line>
|
|
<line x1="20" y1="8" x2="20" y2="14"></line>
|
|
</svg>
|
|
<span data-i18n="admin-add-group">Add Group</span>
|
|
</button>
|
|
<button class="action-card" hx-get="/api/admin/audit" hx-target="#admin-content" hx-swap="innerHTML">
|
|
<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<circle cx="12" cy="12" r="10"></circle>
|
|
<line x1="12" y1="8" x2="12" y2="12"></line>
|
|
<line x1="12" y1="16" x2="12.01" y2="16"></line>
|
|
</svg>
|
|
<span data-i18n="admin-view-audit">View Audit Log</span>
|
|
</button>
|
|
<button class="action-card" hx-get="/api/admin/billing" hx-target="#admin-content" hx-swap="innerHTML">
|
|
<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<rect x="1" y="4" width="22" height="16" rx="2" ry="2"></rect>
|
|
<line x1="1" y1="10" x2="23" y2="10"></line>
|
|
</svg>
|
|
<span data-i18n="admin-billing">Billing</span>
|
|
</button>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2 data-i18n="admin-system-health">System Health</h2>
|
|
<div class="health-grid">
|
|
<div class="health-card">
|
|
<div class="health-card-header">
|
|
<span class="health-card-title">API Server</span>
|
|
<span class="health-status healthy">Healthy</span>
|
|
</div>
|
|
<div class="health-value">99.9%</div>
|
|
<div class="health-label">Uptime</div>
|
|
</div>
|
|
<div class="health-card">
|
|
<div class="health-card-header">
|
|
<span class="health-card-title">Database</span>
|
|
<span class="health-status healthy">Healthy</span>
|
|
</div>
|
|
<div class="health-value">12ms</div>
|
|
<div class="health-label">Avg Response</div>
|
|
</div>
|
|
<div class="health-card">
|
|
<div class="health-card-header">
|
|
<span class="health-card-title">Storage</span>
|
|
<span class="health-status healthy">Healthy</span>
|
|
</div>
|
|
<div class="health-value">45%</div>
|
|
<div class="health-label">Capacity Used</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_stats_users(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="stat-icon users">
|
|
<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path>
|
|
<circle cx="9" cy="7" r="4"></circle>
|
|
<path d="M23 21v-2a4 4 0 0 0-3-3.87"></path>
|
|
<path d="M16 3.13a4 4 0 0 1 0 7.75"></path>
|
|
</svg>
|
|
</div>
|
|
<div class="stat-content">
|
|
<span class="stat-value">127</span>
|
|
<span class="stat-label" data-i18n="admin-total-users">Total Users</span>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_stats_groups(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="stat-icon groups">
|
|
<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path>
|
|
<circle cx="9" cy="7" r="4"></circle>
|
|
<circle cx="19" cy="11" r="2"></circle>
|
|
</svg>
|
|
</div>
|
|
<div class="stat-content">
|
|
<span class="stat-value">12</span>
|
|
<span class="stat-label" data-i18n="admin-active-groups">Active Groups</span>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_stats_bots(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="stat-icon bots">
|
|
<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<rect x="3" y="11" width="18" height="10" rx="2"></rect>
|
|
<circle cx="12" cy="5" r="2"></circle>
|
|
<path d="M12 7v4"></path>
|
|
</svg>
|
|
</div>
|
|
<div class="stat-content">
|
|
<span class="stat-value">8</span>
|
|
<span class="stat-label" data-i18n="admin-running-bots">Running Bots</span>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_stats_storage(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="stat-icon storage">
|
|
<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
|
|
<path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path>
|
|
<path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path>
|
|
</svg>
|
|
</div>
|
|
<div class="stat-content">
|
|
<span class="stat-value">45.2 GB</span>
|
|
<span class="stat-label" data-i18n="admin-storage-used">Storage Used</span>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_admin_users(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="admin-page">
|
|
<div class="page-header">
|
|
<h1 data-i18n="admin-users">Users</h1>
|
|
<p class="subtitle" data-i18n="admin-users-subtitle">Manage user accounts and permissions</p>
|
|
</div>
|
|
<div class="toolbar">
|
|
<button class="btn-primary" onclick="document.getElementById('create-user-modal').showModal()">
|
|
<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<line x1="12" y1="5" x2="12" y2="19"></line>
|
|
<line x1="5" y1="12" x2="19" y2="12"></line>
|
|
</svg>
|
|
Add User
|
|
</button>
|
|
</div>
|
|
<div class="data-table">
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>Name</th>
|
|
<th>Email</th>
|
|
<th>Role</th>
|
|
<th>Status</th>
|
|
<th>Actions</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>John Doe</td>
|
|
<td>john@example.com</td>
|
|
<td><span class="badge badge-admin">Admin</span></td>
|
|
<td><span class="status status-active">Active</span></td>
|
|
<td><button class="btn-icon">Edit</button></td>
|
|
</tr>
|
|
<tr>
|
|
<td>Jane Smith</td>
|
|
<td>jane@example.com</td>
|
|
<td><span class="badge badge-user">User</span></td>
|
|
<td><span class="status status-active">Active</span></td>
|
|
<td><button class="btn-icon">Edit</button></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_admin_groups(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="admin-page">
|
|
<div class="page-header">
|
|
<h1 data-i18n="admin-groups">Groups</h1>
|
|
<p class="subtitle" data-i18n="admin-groups-subtitle">Manage groups and team permissions</p>
|
|
</div>
|
|
<div class="toolbar">
|
|
<button class="btn-primary" onclick="document.getElementById('create-group-modal').showModal()">
|
|
<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<line x1="12" y1="5" x2="12" y2="19"></line>
|
|
<line x1="5" y1="12" x2="19" y2="12"></line>
|
|
</svg>
|
|
Add Group
|
|
</button>
|
|
</div>
|
|
<div class="data-table">
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>Name</th>
|
|
<th>Members</th>
|
|
<th>Created</th>
|
|
<th>Actions</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>Engineering</td>
|
|
<td>15</td>
|
|
<td>2024-01-15</td>
|
|
<td><button class="btn-icon">Manage</button></td>
|
|
</tr>
|
|
<tr>
|
|
<td>Marketing</td>
|
|
<td>8</td>
|
|
<td>2024-02-20</td>
|
|
<td><button class="btn-icon">Manage</button></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_admin_bots(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="admin-page">
|
|
<div class="page-header">
|
|
<h1 data-i18n="admin-bots">Bots</h1>
|
|
<p class="subtitle" data-i18n="admin-bots-subtitle">Manage bot instances and deployments</p>
|
|
</div>
|
|
<div class="data-table">
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>Name</th>
|
|
<th>Status</th>
|
|
<th>Messages</th>
|
|
<th>Last Active</th>
|
|
<th>Actions</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>Support Bot</td>
|
|
<td><span class="status status-active">Running</span></td>
|
|
<td>1,234</td>
|
|
<td>Just now</td>
|
|
<td><button class="btn-icon">Configure</button></td>
|
|
</tr>
|
|
<tr>
|
|
<td>Sales Assistant</td>
|
|
<td><span class="status status-active">Running</span></td>
|
|
<td>567</td>
|
|
<td>5 min ago</td>
|
|
<td><button class="btn-icon">Configure</button></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_admin_dns(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="admin-page">
|
|
<div class="page-header">
|
|
<h1 data-i18n="admin-dns">DNS Management</h1>
|
|
<p class="subtitle" data-i18n="admin-dns-subtitle">Configure custom domains and DNS settings</p>
|
|
</div>
|
|
<div class="toolbar">
|
|
<button class="btn-primary" onclick="document.getElementById('add-dns-modal').showModal()">
|
|
<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
|
|
<line x1="12" y1="5" x2="12" y2="19"></line>
|
|
<line x1="5" y1="12" x2="19" y2="12"></line>
|
|
</svg>
|
|
Add Domain
|
|
</button>
|
|
</div>
|
|
<div class="data-table">
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>Domain</th>
|
|
<th>Type</th>
|
|
<th>Status</th>
|
|
<th>SSL</th>
|
|
<th>Actions</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>bot.example.com</td>
|
|
<td>CNAME</td>
|
|
<td><span class="status status-active">Active</span></td>
|
|
<td><span class="status status-active">Valid</span></td>
|
|
<td><button class="btn-icon">Edit</button></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_admin_billing(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let html = r##"
|
|
<div class="admin-page">
|
|
<div class="page-header">
|
|
<h1 data-i18n="admin-billing">Billing</h1>
|
|
<p class="subtitle" data-i18n="admin-billing-subtitle">Manage subscription and payment settings</p>
|
|
</div>
|
|
<div class="billing-overview">
|
|
<div class="billing-card">
|
|
<h3>Current Plan</h3>
|
|
<div class="plan-name">Enterprise</div>
|
|
<div class="plan-price">$499/month</div>
|
|
</div>
|
|
<div class="billing-card">
|
|
<h3>Next Billing Date</h3>
|
|
<div class="billing-date">January 15, 2025</div>
|
|
</div>
|
|
<div class="billing-card">
|
|
<h3>Payment Method</h3>
|
|
<div class="payment-method">**** **** **** 4242</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
"##;
|
|
Html(html.to_string())
|
|
}
|
|
|
|
pub async fn get_admin_audit(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Html<String> {
|
|
let now = Utc::now();
|
|
let html = format!(r##"
|
|
<div class="admin-page">
|
|
<div class="page-header">
|
|
<h1 data-i18n="admin-audit">Audit Log</h1>
|
|
<p class="subtitle" data-i18n="admin-audit-subtitle">Track system events and user actions</p>
|
|
</div>
|
|
<div class="data-table">
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>Time</th>
|
|
<th>User</th>
|
|
<th>Action</th>
|
|
<th>Details</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>{}</td>
|
|
<td>admin@example.com</td>
|
|
<td>User Login</td>
|
|
<td>Successful login from 192.168.1.1</td>
|
|
</tr>
|
|
<tr>
|
|
<td>{}</td>
|
|
<td>admin@example.com</td>
|
|
<td>Settings Changed</td>
|
|
<td>Updated system configuration</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
</div>
|
|
"##, now.format("%Y-%m-%d %H:%M"), now.format("%Y-%m-%d %H:%M"));
|
|
Html(html)
|
|
}
|
|
|
|
pub async fn get_system_status(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Result<Json<SystemStatusResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
let now = Utc::now();
|
|
|
|
let status = SystemStatusResponse {
|
|
status: "healthy".to_string(),
|
|
uptime_seconds: 3600 * 24 * 7,
|
|
version: "1.0.0".to_string(),
|
|
services: vec![
|
|
ServiceStatus {
|
|
name: "ui_server".to_string(),
|
|
status: "running".to_string(),
|
|
uptime_seconds: 3600 * 24 * 7,
|
|
memory_mb: 256.5,
|
|
cpu_percent: 12.3,
|
|
},
|
|
ServiceStatus {
|
|
name: "database".to_string(),
|
|
status: "running".to_string(),
|
|
uptime_seconds: 3600 * 24 * 7,
|
|
memory_mb: 512.8,
|
|
cpu_percent: 8.5,
|
|
},
|
|
ServiceStatus {
|
|
name: "cache".to_string(),
|
|
status: "running".to_string(),
|
|
uptime_seconds: 3600 * 24 * 7,
|
|
memory_mb: 128.2,
|
|
cpu_percent: 3.2,
|
|
},
|
|
ServiceStatus {
|
|
name: "storage".to_string(),
|
|
status: "running".to_string(),
|
|
uptime_seconds: 3600 * 24 * 7,
|
|
memory_mb: 64.1,
|
|
cpu_percent: 5.8,
|
|
},
|
|
],
|
|
health_checks: vec![
|
|
HealthCheck {
|
|
name: "database_connection".to_string(),
|
|
status: "passed".to_string(),
|
|
message: Some("Connected successfully".to_string()),
|
|
last_check: now,
|
|
},
|
|
HealthCheck {
|
|
name: "storage_access".to_string(),
|
|
status: "passed".to_string(),
|
|
message: Some("Storage accessible".to_string()),
|
|
last_check: now,
|
|
},
|
|
HealthCheck {
|
|
name: "api_endpoints".to_string(),
|
|
status: "passed".to_string(),
|
|
message: Some("All endpoints responding".to_string()),
|
|
last_check: now,
|
|
},
|
|
],
|
|
last_restart: now.checked_sub_signed(chrono::Duration::days(7)).unwrap_or(now),
|
|
};
|
|
|
|
Ok(Json(status))
|
|
}
|
|
|
|
pub async fn get_system_metrics(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Result<Json<SystemMetricsResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
let metrics = SystemMetricsResponse {
|
|
cpu_usage: 23.5,
|
|
memory_total_mb: 8192,
|
|
memory_used_mb: 4096,
|
|
memory_percent: 50.0,
|
|
disk_total_gb: 500,
|
|
disk_used_gb: 350,
|
|
disk_percent: 70.0,
|
|
network_in_mbps: 12.5,
|
|
network_out_mbps: 8.3,
|
|
active_connections: 256,
|
|
request_rate_per_minute: 1250,
|
|
error_rate_percent: 0.5,
|
|
};
|
|
|
|
Ok(Json(metrics))
|
|
}
|
|
|
|
pub fn view_logs(
|
|
State(_state): State<Arc<AppState>>,
|
|
Query(_params): Query<LogQuery>,
|
|
) -> Result<Json<Vec<LogEntry>>, (StatusCode, Json<serde_json::Value>)> {
|
|
let now = Utc::now();
|
|
|
|
let logs = vec![
|
|
LogEntry {
|
|
id: Uuid::new_v4(),
|
|
timestamp: now,
|
|
level: "info".to_string(),
|
|
service: "ui_server".to_string(),
|
|
message: "Request processed successfully".to_string(),
|
|
metadata: Some(serde_json::json!({
|
|
"endpoint": "/api/files/list",
|
|
"duration_ms": 45,
|
|
"status_code": 200
|
|
})),
|
|
},
|
|
LogEntry {
|
|
id: Uuid::new_v4(),
|
|
timestamp: now
|
|
.checked_sub_signed(chrono::Duration::minutes(5))
|
|
.unwrap_or(now),
|
|
level: "warning".to_string(),
|
|
service: "database".to_string(),
|
|
message: "Slow query detected".to_string(),
|
|
metadata: Some(serde_json::json!({
|
|
"query": "SELECT * FROM users WHERE...",
|
|
"duration_ms": 1250
|
|
})),
|
|
},
|
|
LogEntry {
|
|
id: Uuid::new_v4(),
|
|
timestamp: now
|
|
.checked_sub_signed(chrono::Duration::minutes(10))
|
|
.unwrap_or(now),
|
|
level: "error".to_string(),
|
|
service: "storage".to_string(),
|
|
message: "Failed to upload file".to_string(),
|
|
metadata: Some(serde_json::json!({
|
|
"file": "document.pdf",
|
|
"error": "Connection timeout"
|
|
})),
|
|
},
|
|
];
|
|
|
|
Ok(Json(logs))
|
|
}
|
|
|
|
pub fn export_logs(
|
|
State(_state): State<Arc<AppState>>,
|
|
Query(_params): Query<LogQuery>,
|
|
) -> Result<Json<SuccessResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
Ok(Json(SuccessResponse {
|
|
success: true,
|
|
message: Some("Logs exported successfully".to_string()),
|
|
}))
|
|
}
|
|
|
|
pub fn get_config(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Result<Json<ConfigResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
let now = Utc::now();
|
|
|
|
let config = ConfigResponse {
|
|
configs: vec![
|
|
ConfigItem {
|
|
key: "max_upload_size_mb".to_string(),
|
|
value: serde_json::json!(100),
|
|
description: Some("Maximum file upload size in MB".to_string()),
|
|
editable: true,
|
|
requires_restart: false,
|
|
},
|
|
ConfigItem {
|
|
key: "session_timeout_minutes".to_string(),
|
|
value: serde_json::json!(30),
|
|
description: Some("User session timeout in minutes".to_string()),
|
|
editable: true,
|
|
requires_restart: false,
|
|
},
|
|
ConfigItem {
|
|
key: "enable_2fa".to_string(),
|
|
value: serde_json::json!(true),
|
|
description: Some("Enable two-factor authentication".to_string()),
|
|
editable: true,
|
|
requires_restart: false,
|
|
},
|
|
ConfigItem {
|
|
key: "database_pool_size".to_string(),
|
|
value: serde_json::json!(20),
|
|
description: Some("Database connection pool size".to_string()),
|
|
editable: true,
|
|
requires_restart: true,
|
|
},
|
|
],
|
|
last_updated: now,
|
|
};
|
|
|
|
Ok(Json(config))
|
|
}
|
|
|
|
pub fn update_config(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<ConfigUpdateRequest>,
|
|
) -> Result<Json<SuccessResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
Ok(Json(SuccessResponse {
|
|
success: true,
|
|
message: Some(format!(
|
|
"Configuration '{}' updated successfully",
|
|
req.config_key
|
|
)),
|
|
}))
|
|
}
|
|
|
|
pub fn schedule_maintenance(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<MaintenanceScheduleRequest>,
|
|
) -> Result<Json<MaintenanceResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
let maintenance_id = Uuid::new_v4();
|
|
|
|
let maintenance = MaintenanceResponse {
|
|
id: maintenance_id,
|
|
scheduled_at: req.scheduled_at,
|
|
duration_minutes: req.duration_minutes,
|
|
reason: req.reason,
|
|
status: "scheduled".to_string(),
|
|
created_by: "admin".to_string(),
|
|
};
|
|
|
|
Ok(Json(maintenance))
|
|
}
|
|
|
|
pub fn create_backup(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<BackupRequest>,
|
|
) -> Result<Json<BackupResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
let backup_id = Uuid::new_v4();
|
|
let now = Utc::now();
|
|
|
|
let backup = BackupResponse {
|
|
id: backup_id,
|
|
backup_type: req.backup_type,
|
|
size_bytes: 1024 * 1024 * 500,
|
|
created_at: now,
|
|
status: "completed".to_string(),
|
|
download_url: Some(format!("/admin/backups/{}/download", backup_id)),
|
|
expires_at: Some(now.checked_add_signed(chrono::Duration::days(30)).unwrap_or(now)),
|
|
};
|
|
|
|
Ok(Json(backup))
|
|
}
|
|
|
|
pub fn restore_backup(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<RestoreRequest>,
|
|
) -> Result<Json<SuccessResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
Ok(Json(SuccessResponse {
|
|
success: true,
|
|
message: Some(format!("Restore from backup {} initiated", req.backup_id)),
|
|
}))
|
|
}
|
|
|
|
pub fn list_backups(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Result<Json<Vec<BackupResponse>>, (StatusCode, Json<serde_json::Value>)> {
|
|
let now = Utc::now();
|
|
|
|
let backups = vec![
|
|
BackupResponse {
|
|
id: Uuid::new_v4(),
|
|
backup_type: "full".to_string(),
|
|
size_bytes: 1024 * 1024 * 500,
|
|
created_at: now.checked_sub_signed(chrono::Duration::days(1)).unwrap_or(now),
|
|
status: "completed".to_string(),
|
|
download_url: Some("/admin/backups/1/download".to_string()),
|
|
expires_at: Some(now.checked_add_signed(chrono::Duration::days(29)).unwrap_or(now)),
|
|
},
|
|
BackupResponse {
|
|
id: Uuid::new_v4(),
|
|
backup_type: "incremental".to_string(),
|
|
size_bytes: 1024 * 1024 * 50,
|
|
created_at: now.checked_sub_signed(chrono::Duration::hours(12)).unwrap_or(now),
|
|
status: "completed".to_string(),
|
|
download_url: Some("/admin/backups/2/download".to_string()),
|
|
expires_at: Some(now.checked_add_signed(chrono::Duration::days(29)).unwrap_or(now)),
|
|
},
|
|
];
|
|
|
|
Ok(Json(backups))
|
|
}
|
|
|
|
pub fn manage_users(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<UserManagementRequest>,
|
|
) -> Result<Json<SuccessResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
let message = match req.action.as_str() {
|
|
"suspend" => format!("User {} suspended", req.user_id),
|
|
"activate" => format!("User {} activated", req.user_id),
|
|
"delete" => format!("User {} deleted", req.user_id),
|
|
"reset_password" => format!("Password reset for user {}", req.user_id),
|
|
_ => format!("Action {} performed on user {}", req.action, req.user_id),
|
|
};
|
|
|
|
Ok(Json(SuccessResponse {
|
|
success: true,
|
|
message: Some(message),
|
|
}))
|
|
}
|
|
|
|
pub fn get_roles(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Result<Json<Vec<serde_json::Value>>, (StatusCode, Json<serde_json::Value>)> {
|
|
let roles = vec![
|
|
serde_json::json!({
|
|
"id": Uuid::new_v4(),
|
|
"name": "admin",
|
|
"description": "Full system access",
|
|
"permissions": ["*"],
|
|
"user_count": 5
|
|
}),
|
|
serde_json::json!({
|
|
"id": Uuid::new_v4(),
|
|
"name": "user",
|
|
"description": "Standard user access",
|
|
"permissions": ["read:own", "write:own"],
|
|
"user_count": 1245
|
|
}),
|
|
serde_json::json!({
|
|
"id": Uuid::new_v4(),
|
|
"name": "guest",
|
|
"description": "Limited read-only access",
|
|
"permissions": ["read:public"],
|
|
"user_count": 328
|
|
}),
|
|
];
|
|
|
|
Ok(Json(roles))
|
|
}
|
|
|
|
pub fn manage_roles(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<RoleManagementRequest>,
|
|
) -> Result<Json<SuccessResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
Ok(Json(SuccessResponse {
|
|
success: true,
|
|
message: Some(format!("Role '{}' managed successfully", req.role_name)),
|
|
}))
|
|
}
|
|
|
|
pub fn get_quotas(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Result<Json<Vec<QuotaResponse>>, (StatusCode, Json<serde_json::Value>)> {
|
|
let quotas = vec![
|
|
QuotaResponse {
|
|
id: Uuid::new_v4(),
|
|
entity_type: "user".to_string(),
|
|
entity_id: Uuid::new_v4(),
|
|
quota_type: "storage".to_string(),
|
|
limit_value: 10 * 1024 * 1024 * 1024,
|
|
current_value: 7 * 1024 * 1024 * 1024,
|
|
percent_used: 70.0,
|
|
},
|
|
QuotaResponse {
|
|
id: Uuid::new_v4(),
|
|
entity_type: "user".to_string(),
|
|
entity_id: Uuid::new_v4(),
|
|
quota_type: "api_calls".to_string(),
|
|
limit_value: 10000,
|
|
current_value: 3500,
|
|
percent_used: 35.0,
|
|
},
|
|
];
|
|
|
|
Ok(Json(quotas))
|
|
}
|
|
|
|
pub fn manage_quotas(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<QuotaManagementRequest>,
|
|
) -> Result<Json<SuccessResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
Ok(Json(SuccessResponse {
|
|
success: true,
|
|
message: Some(format!("Quota '{}' set successfully", req.quota_type)),
|
|
}))
|
|
}
|
|
|
|
pub fn get_licenses(
|
|
State(_state): State<Arc<AppState>>,
|
|
) -> Result<Json<Vec<LicenseResponse>>, (StatusCode, Json<serde_json::Value>)> {
|
|
let now = Utc::now();
|
|
|
|
let licenses = vec![LicenseResponse {
|
|
id: Uuid::new_v4(),
|
|
license_type: "enterprise".to_string(),
|
|
status: "active".to_string(),
|
|
max_users: 1000,
|
|
current_users: 850,
|
|
features: vec![
|
|
"unlimited_storage".to_string(),
|
|
"advanced_analytics".to_string(),
|
|
"priority_support".to_string(),
|
|
"custom_integrations".to_string(),
|
|
],
|
|
issued_at: now.checked_sub_signed(chrono::Duration::days(180)).unwrap_or(now),
|
|
expires_at: Some(now.checked_add_signed(chrono::Duration::days(185)).unwrap_or(now)),
|
|
}];
|
|
|
|
Ok(Json(licenses))
|
|
}
|
|
|
|
pub fn manage_licenses(
|
|
State(_state): State<Arc<AppState>>,
|
|
Json(req): Json<LicenseManagementRequest>,
|
|
) -> Result<Json<SuccessResponse>, (StatusCode, Json<serde_json::Value>)> {
|
|
Ok(Json(SuccessResponse {
|
|
success: true,
|
|
message: Some(format!(
|
|
"License '{}' activated successfully",
|
|
req.license_type
|
|
)),
|
|
}))
|
|
}
|