fix: trigger mode and status enums

src/controllers.rs

@@ -1,4 +1,4 @@
-use crate::models::{LogLine, TaskRun, TaskRunSummary};
+use crate::models::{LogLine, TaskRun, TaskRunSummary, TriggerMode};
 use axum::extract::{Path as ExtractPath, State};
 use axum::http::StatusCode;
 use axum::Json;
@@ -46,6 +46,7 @@ pub async fn trigger_task(
         .executor_tx
         .send(ExecutorOrder {
             id: Uuid::new_v4(),
+            trigger_mode: TriggerMode::Manual,
             task_id
         })
         .await
@@ -92,7 +93,7 @@ pub async fn list_task_runs(
     State(app_state): State<AppState>,
     ExtractPath(task_id): ExtractPath<String>,
 ) -> Html<String> {
-    let runs = sqlx::query_as::<_, TaskRunSummary>("SELECT id,status,trigger_mode,submitted_at,started_at,ended_at FROM task_runs WHERE task_id = $1")
+    let runs = sqlx::query_as::<_, TaskRunSummary>("SELECT id,status,trigger_mode,submitted_at,started_at,ended_at FROM task_runs WHERE task_id = $1 ORDER BY submitted_at ASC")
         .bind(&task_id)
         .fetch_all(&app_state.db)
         .await

src/debouncer.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::mpsc::{Receiver, Sender};
 
-use crate::models::{ExecutorOrder, Webhook};
+use crate::models::{ExecutorOrder, TriggerMode, Webhook};
 use crate::AppState;
 
 async fn run_debouncer(webhook: Webhook, duration: Duration, executor_tx: Arc<Sender<ExecutorOrder>>, cancellation_token: CancellationToken) {
@@ -22,6 +22,7 @@ async fn run_debouncer(webhook: Webhook, duration: Duration, executor_tx: Arc<Se
                 trace!("Debouncer is now triggering {}", &task_id);
                 let _ = executor_tx.send(ExecutorOrder {
                     id: Uuid::new_v4(),
+                    trigger_mode: TriggerMode::Webhook,
                     task_id: task_id.to_string()
                 }).await;
             }

src/executor.rs

@@ -9,7 +9,7 @@ use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader};
 use tokio::process::Command;
 use tokio::sync::mpsc::Receiver;
 
-use crate::models::{ExecutorOrder, LogKind, LogLine};
+use crate::models::{ExecutorOrder, LogKind, LogLine, TaskStatus};
 use crate::AppState;
 
 async fn insert_logs(db: &Pool<Sqlite>, collected_logs: &mut Vec<LogLine>) -> Result<()> {
@@ -59,8 +59,8 @@ async fn run_task(state: AppState, order: ExecutorOrder) -> Result<()> {
     let _result = sqlx::query("INSERT INTO task_runs (id, task_id, trigger_mode, status, submitted_at, started_at) VALUES ($1, $2, $3, $4, $5, $5)")
         .bind(order.id.to_string())
         .bind(order.task_id.clone())
-        .bind("manual")
-        .bind("running")
+        .bind(order.trigger_mode.to_string())
+        .bind(TaskStatus::Running.to_string())
         .bind(Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true))
         .execute(&state.db)
         .await.unwrap();
@@ -115,8 +115,8 @@ async fn run_task(state: AppState, order: ExecutorOrder) -> Result<()> {
     let _result = sqlx::query("UPDATE task_runs SET status = $2, ended_at = $3, exit_code = $4 WHERE id = $1")
         .bind(order.id.to_string())
         .bind(match status.success() {
-            true => "success",
-            false => "failed"
+            true => TaskStatus::Success,
+            false => TaskStatus::Failed,
         })
         .bind(Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true))
         .bind(status.code())

src/models.rs

@@ -5,9 +5,9 @@ use fully_pub::fully_pub;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-#[derive(sqlx::Type, Debug, Serialize, Deserialize)]
+#[derive(sqlx::Type, Clone, Debug, Serialize, Deserialize)]
+#[derive(strum_macros::Display)]
 #[fully_pub]
-#[sqlx(rename_all = "lowercase")]
 enum TriggerMode {
     Manual,
     Webhook,
@@ -15,7 +15,7 @@ enum TriggerMode {
 }
 
 #[derive(sqlx::Type, Debug, Serialize, Deserialize)]
-#[sqlx(rename_all = "lowercase")]
+#[derive(strum_macros::Display)]
 #[fully_pub]
 enum TaskStatus {
     Pending,
@@ -94,6 +94,7 @@ struct Task {
 struct ExecutorOrder {
     id: Uuid,
     task_id: String,
+    trigger_mode: TriggerMode
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]

src/scheduler.rs

@@ -4,16 +4,17 @@ use tokio_cron_scheduler::{Job, JobScheduler, JobSchedulerError};
 use tokio::sync::mpsc::Sender;
 use uuid::Uuid;
 
-use crate::{models::{ExecutorOrder, ScheduleConfig}, AppState};
+use crate::{models::{ExecutorOrder, ScheduleConfig, TriggerMode}, AppState};
 
 fn get_repeated_job(task_id: String, executor_tx: Arc<Sender<ExecutorOrder>>, seconds: u64) -> Result<Job, JobSchedulerError> {
     Job::new_repeated_async(
         Duration::from_secs(seconds),
         move |_uuid, _l| {
+            let executor_tx = executor_tx.clone();
             Box::pin({
-                let executor_tx = executor_tx.clone();
                 let order = ExecutorOrder {
                     id: Uuid::new_v4(),
+                    trigger_mode: TriggerMode::Schedule,
                     task_id: task_id.clone()
                 };
                 async move {
@@ -52,6 +53,7 @@ pub async fn run_scheduler(app_state: AppState) -> Result<(), JobSchedulerError>
                                 executor_tx
                                     .send(ExecutorOrder {
                                         id: Uuid::new_v4(),
+                                        trigger_mode: TriggerMode::Schedule,
                                         task_id
                                     })
                                     .await.unwrap();