Add remaining commands

src/commands/timer/delete.rs

@@ -0,0 +1,65 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    utils::{Extract, Recordable},
+    Context, Error,
+};
+
+#[derive(Serialize, Deserialize, Extract)]
+pub struct Options {
+    name: String,
+}
+
+impl Recordable for Options {
+    async fn run(self, ctx: Context<'_>) -> Result<(), Error> {
+        let owner = ctx.guild_id().map(|g| g.get()).unwrap_or_else(|| ctx.author().id.get());
+
+        let exists = sqlx::query!(
+            "
+            SELECT 1 as _r
+            FROM timers
+            WHERE owner = ?
+                AND name = ?
+            ",
+            owner,
+            self.name
+        )
+        .fetch_one(&ctx.data().database)
+        .await;
+
+        if exists.is_ok() {
+            sqlx::query!(
+                "
+                DELETE FROM timers
+                WHERE owner = ?
+                    AND name = ?
+                ",
+                owner,
+                self.name
+            )
+            .execute(&ctx.data().database)
+            .await
+            .unwrap();
+
+            ctx.say("Deleted a timer").await?;
+        } else {
+            ctx.say("Could not find a timer by that name").await?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Delete a timer
+#[poise::command(
+    slash_command,
+    rename = "delete",
+    identifying_name = "delete_timer",
+    default_member_permissions = "MANAGE_GUILD"
+)]
+pub async fn delete(
+    ctx: Context<'_>,
+    #[description = "Name of timer to delete"] name: String,
+) -> Result<(), Error> {
+    (Options { name }).run(ctx).await
+}

src/commands/timer/delete_timer.rs

@@ -1,33 +0,0 @@
-use crate::{Context, Error};
-
-/// Delete a timer
-#[poise::command(
-    slash_command,
-    rename = "delete",
-    identifying_name = "delete_timer",
-    default_member_permissions = "MANAGE_GUILD"
-)]
-pub async fn delete_timer(
-    ctx: Context<'_>,
-    #[description = "Name of timer to delete"] name: String,
-) -> Result<(), Error> {
-    let owner = ctx.guild_id().map(|g| g.get()).unwrap_or_else(|| ctx.author().id.get());
-
-    let exists =
-        sqlx::query!("SELECT 1 as _r FROM timers WHERE owner = ? AND name = ?", owner, name)
-            .fetch_one(&ctx.data().database)
-            .await;
-
-    if exists.is_ok() {
-        sqlx::query!("DELETE FROM timers WHERE owner = ? AND name = ?", owner, name)
-            .execute(&ctx.data().database)
-            .await
-            .unwrap();
-
-        ctx.say("Deleted a timer").await?;
-    } else {
-        ctx.say("Could not find a timer by that name").await?;
-    }
-
-    Ok(())
-}

src/commands/timer/list.rs

@@ -0,0 +1,64 @@
+use chrono::{DateTime, Utc};
+use num_integer::Integer;
+use poise::{serenity_prelude::CreateEmbed, CreateReply};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    consts::THEME_COLOR,
+    models::timer::Timer,
+    utils::{Extract, Recordable},
+    Context, Error,
+};
+
+fn time_difference(start_time: DateTime<Utc>) -> String {
+    let delta = (Utc::now() - start_time).num_seconds();
+
+    let (minutes, seconds) = delta.div_rem(&60);
+    let (hours, minutes) = minutes.div_rem(&60);
+    let (days, hours) = hours.div_rem(&24);
+
+    format!("{} days, {:02}:{:02}:{:02}", days, hours, minutes, seconds)
+}
+
+#[derive(Serialize, Deserialize, Extract)]
+pub struct Options;
+
+impl Recordable for Options {
+    async fn run(self, ctx: Context<'_>) -> Result<(), Error> {
+        let owner = ctx.guild_id().map(|g| g.get()).unwrap_or_else(|| ctx.author().id.get());
+
+        let timers = Timer::from_owner(owner, &ctx.data().database).await;
+
+        if !timers.is_empty() {
+            ctx.send(
+                CreateReply::default().embed(
+                    CreateEmbed::new()
+                        .fields(timers.iter().map(|timer| {
+                            (
+                                &timer.name,
+                                format!("⌚ `{}`", time_difference(timer.start_time)),
+                                false,
+                            )
+                        }))
+                        .color(*THEME_COLOR),
+                ),
+            )
+            .await?;
+        } else {
+            ctx.say("No timers currently. Use `/timer start` to create a new timer").await?;
+        }
+
+        Ok(())
+    }
+}
+
+/// List the timers in this server or DM channel
+#[poise::command(
+    slash_command,
+    rename = "list",
+    identifying_name = "list_timer",
+    default_member_permissions = "MANAGE_GUILD"
+)]
+pub async fn list(ctx: Context<'_>) -> Result<(), Error> {
+    (Options {}).run(ctx).await
+}

src/commands/timer/list_timer.rs

@@ -1,45 +0,0 @@
-use chrono::{DateTime, Utc};
-use num_integer::Integer;
-use poise::{serenity_prelude::CreateEmbed, CreateReply};
-
-use crate::{consts::THEME_COLOR, models::timer::Timer, Context, Error};
-
-fn time_difference(start_time: DateTime<Utc>) -> String {
-    let delta = (Utc::now() - start_time).num_seconds();
-
-    let (minutes, seconds) = delta.div_rem(&60);
-    let (hours, minutes) = minutes.div_rem(&60);
-    let (days, hours) = hours.div_rem(&24);
-
-    format!("{} days, {:02}:{:02}:{:02}", days, hours, minutes, seconds)
-}
-
-/// List the timers in this server or DM channel
-#[poise::command(
-    slash_command,
-    rename = "list",
-    identifying_name = "list_timer",
-    default_member_permissions = "MANAGE_GUILD"
-)]
-pub async fn list_timer(ctx: Context<'_>) -> Result<(), Error> {
-    let owner = ctx.guild_id().map(|g| g.get()).unwrap_or_else(|| ctx.author().id.get());
-
-    let timers = Timer::from_owner(owner, &ctx.data().database).await;
-
-    if !timers.is_empty() {
-        ctx.send(
-            CreateReply::default().embed(
-                CreateEmbed::new()
-                    .fields(timers.iter().map(|timer| {
-                        (&timer.name, format!("⌚ `{}`", time_difference(timer.start_time)), false)
-                    }))
-                    .color(*THEME_COLOR),
-            ),
-        )
-        .await?;
-    } else {
-        ctx.say("No timers currently. Use `/timer start` to create a new timer").await?;
-    }
-
-    Ok(())
-}

src/commands/timer/mod.rs

@@ -1,6 +1,6 @@
-pub mod delete_timer;
-pub mod list_timer;
-pub mod start_timer;
+pub mod delete;
+pub mod list;
+pub mod start;
 
 use crate::{Context, Error};
 

src/commands/timer/start.rs

@@ -0,0 +1,53 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    models::timer::Timer,
+    utils::{Extract, Recordable},
+    Context, Error,
+};
+
+#[derive(Serialize, Deserialize, Extract)]
+pub struct Options {
+    name: String,
+}
+
+impl Recordable for Options {
+    async fn run(self, ctx: Context<'_>) -> Result<(), Error> {
+        let owner = ctx.guild_id().map(|g| g.get()).unwrap_or_else(|| ctx.author().id.get());
+
+        let count = Timer::count_from_owner(owner, &ctx.data().database).await;
+
+        if count >= 25 {
+            ctx.say(
+                "You already have 25 timers. Please delete some timers before creating a new one",
+            )
+            .await?;
+        } else if self.name.len() <= 32 {
+            Timer::create(&self.name, owner, &ctx.data().database).await;
+
+            ctx.say("Created a new timer").await?;
+        } else {
+            ctx.say(format!(
+                "Please name your timer something shorted (max. 32 characters, you used {})",
+                self.name.len()
+            ))
+            .await?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Start a new timer from now
+#[poise::command(
+    slash_command,
+    rename = "start",
+    identifying_name = "start_timer",
+    default_member_permissions = "MANAGE_GUILD"
+)]
+pub async fn start(
+    ctx: Context<'_>,
+    #[description = "Name for the new timer"] name: String,
+) -> Result<(), Error> {
+    (Options { name }).run(ctx).await
+}

src/commands/timer/start_timer.rs

@@ -1,34 +0,0 @@
-use crate::{models::timer::Timer, Context, Error};
-
-/// Start a new timer from now
-#[poise::command(
-    slash_command,
-    rename = "start",
-    identifying_name = "start_timer",
-    default_member_permissions = "MANAGE_GUILD"
-)]
-pub async fn start_timer(
-    ctx: Context<'_>,
-    #[description = "Name for the new timer"] name: String,
-) -> Result<(), Error> {
-    let owner = ctx.guild_id().map(|g| g.get()).unwrap_or_else(|| ctx.author().id.get());
-
-    let count = Timer::count_from_owner(owner, &ctx.data().database).await;
-
-    if count >= 25 {
-        ctx.say("You already have 25 timers. Please delete some timers before creating a new one")
-            .await?;
-    } else if name.len() <= 32 {
-        Timer::create(&name, owner, &ctx.data().database).await;
-
-        ctx.say("Created a new timer").await?;
-    } else {
-        ctx.say(format!(
-            "Please name your timer something shorted (max. 32 characters, you used {})",
-            name.len()
-        ))
-        .await?;
-    }
-
-    Ok(())
-}