template engine, activity log

Author: forefy

backend/Cargo.lock

@@ -33,7 +33,7 @@ cookie = "0.18"
 time = { version = "0.3", features = ["macros"] }
 siwe = "0.6"
 hex = "0.4"
-ethers = { version = "2.0", default-features = false }
+ethers = { version = "2.0", features = ["rustls"] }
 hex-literal = "0.4"
 utoipa = { version = "4", features = ["axum_extras"] }
 utoipa-swagger-ui = { version = "6", features = ["axum"] }
@@ -45,6 +45,8 @@ rand = "0.8"
 bs58 = "0.5"
 sha2 = "0.10"
 regex = "1.10"
+serde_yaml = "0.9"
+async-trait = "0.1.89"
 
 [profile.release]
 opt-level = 3

backend/Cargo.toml

@@ -0,0 +1,17 @@
+CREATE TABLE IF NOT EXISTS worker_activity (
+    id TEXT PRIMARY KEY NOT NULL,
+    user_id TEXT NOT NULL,
+    monitor_id TEXT,
+    event_type TEXT NOT NULL,
+    safe_address TEXT,
+    network TEXT,
+    message TEXT NOT NULL,
+    metadata TEXT,
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    FOREIGN KEY (monitor_id) REFERENCES monitors(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_worker_activity_user_id ON worker_activity(user_id);
+CREATE INDEX IF NOT EXISTS idx_worker_activity_created_at ON worker_activity(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_worker_activity_event_type ON worker_activity(event_type);

backend/migrations/013_add_worker_activity.sql

@@ -0,0 +1,121 @@
+use axum::{
+    extract::{Query, State},
+    http::StatusCode,
+    Extension, Json,
+};
+use serde::{Deserialize, Serialize};
+use crate::api::AppState;
+use crate::models::worker_activity::WorkerActivity;
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActivityQuery {
+    pub limit: Option<i32>,
+    pub event_type: Option<String>,
+    pub monitor_id: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ActivityResponse {
+    pub activities: Vec<WorkerActivity>,
+    pub total: i64,
+}
+
+pub async fn list_activity(
+    State(state): State<AppState>,
+    Extension(user_id): Extension<String>,
+    Query(query): Query<ActivityQuery>,
+) -> Result<Json<ActivityResponse>, StatusCode> {
+    let limit = query.limit.unwrap_or(50).min(100);
+
+    let mut sql = String::from(
+        "SELECT id, user_id, monitor_id, event_type, safe_address, network, message, metadata, created_at 
+         FROM worker_activity 
+         WHERE user_id = ?"
+    );
+    
+    let mut params: Vec<String> = vec![user_id.clone()];
+
+    if let Some(ref event_type) = query.event_type {
+        sql.push_str(" AND event_type = ?");
+        params.push(event_type.clone());
+    }
+
+    if let Some(ref monitor_id) = query.monitor_id {
+        sql.push_str(" AND monitor_id = ?");
+        params.push(monitor_id.clone());
+    }
+
+    sql.push_str(" ORDER BY created_at DESC LIMIT ?");
+
+    let activities = match (query.event_type.as_ref(), query.monitor_id.as_ref()) {
+        (Some(event_type), Some(monitor_id)) => {
+            sqlx::query_as::<_, WorkerActivity>(&sql)
+                .bind(&user_id)
+                .bind(event_type)
+                .bind(monitor_id)
+                .bind(limit)
+                .fetch_all(&state.pool)
+                .await
+        }
+        (Some(event_type), None) => {
+            sqlx::query_as::<_, WorkerActivity>(&sql)
+                .bind(&user_id)
+                .bind(event_type)
+                .bind(limit)
+                .fetch_all(&state.pool)
+                .await
+        }
+        (None, Some(monitor_id)) => {
+            sqlx::query_as::<_, WorkerActivity>(&sql)
+                .bind(&user_id)
+                .bind(monitor_id)
+                .bind(limit)
+                .fetch_all(&state.pool)
+                .await
+        }
+        (None, None) => {
+            sqlx::query_as::<_, WorkerActivity>(&sql)
+                .bind(&user_id)
+                .bind(limit)
+                .fetch_all(&state.pool)
+                .await
+        }
+    }.map_err(|e| {
+        tracing::error!("Failed to fetch activity: {}", e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    let total: (i64,) = sqlx::query_as(
+        "SELECT COUNT(*) FROM worker_activity WHERE user_id = ?"
+    )
+    .bind(&user_id)
+    .fetch_one(&state.pool)
+    .await
+    .map_err(|e| {
+        tracing::error!("Failed to count activity: {}", e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    Ok(Json(ActivityResponse {
+        activities,
+        total: total.0,
+    }))
+}
+
+pub async fn clear_activity(
+    State(state): State<AppState>,
+    Extension(user_id): Extension<String>,
+) -> Result<StatusCode, StatusCode> {
+    sqlx::query("DELETE FROM worker_activity WHERE user_id = ?")
+        .bind(&user_id)
+        .execute(&state.pool)
+        .await
+        .map_err(|e| {
+            tracing::error!("Failed to clear activity: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    Ok(StatusCode::NO_CONTENT)
+}