Minimal working TODO example

Author: seqre

Cargo.lock

@@ -4,5 +4,10 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-serenity = { version = "0.10", default-features = false, features = ["builder", "cache", "client", "gateway", "model", "http", "utils", "rustls_backend", "unstable_discord_api"] }
+async-trait = { version = "0.1.52" }
+serenity = { version = "0.11.1", default-features = false, features = ["client", "gateway", "model", "rustls_backend", "unstable_discord_api"] }
 tokio = { version = "1.15.0",	features = ["full"] }
+dotenv = { version = "0.15.0" }
+diesel = { version = "1.4.8", features = ["sqlite", "chrono"] }
+chrono = { version = "0.4", features = ["serde"] }
+serde = { version = "1.0.136" }

Cargo.toml

@@ -0,0 +1,5 @@
+# For documentation on how to configure this file,
+# see diesel.rs/guides/configuring-diesel-cli
+
+[print_schema]
+file = "src/schema.rs"

diesel.toml

@@ -0,0 +1,3 @@
+-- This file should undo anything in `up.sql`
+
+DROP TABLE "todos"

migrations/2022-04-21-181429_create_todos/down.sql

@@ -0,0 +1,9 @@
+-- Create TODO table
+
+CREATE TABLE IF NOT EXISTS "todos" (
+  "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+	"channel_id" BIGINT NOT NULL,
+	"todo"	TEXT NOT NULL,
+	"creation_date"	TEXT NOT NULL,
+	"completion_date"	TEXT
+);

migrations/2022-04-21-181429_create_todos/up.sql

@@ -1,20 +1,98 @@
-use serenity::model::interactions::application_command::ApplicationCommandInteraction;
+use async_trait::async_trait;
+use serenity::{
+    builder::{CreateApplicationCommand, CreateApplicationCommands},
+    client::Context,
+    model::interactions::{
+        application_command::ApplicationCommandInteraction,
+        Interaction,
+        InteractionResponseType,
+    },
+};
+use std::error::Error;
 
-use crate::Handler;
+use crate::{
+    commands::todo::TodoCommand,
+    Secubot,
+};
 
-pub trait Command {
-    fn execute(handler: &Handler, interaction: &ApplicationCommandInteraction) -> String;
+mod todo;
+
+pub type CommandResult = Result<(), Box<dyn Error>>;
+
+#[async_trait]
+pub trait Command: Send + Sync {
+    fn get_name(&self) -> &'static str;
+    fn add_application_command(&self, command: &mut CreateApplicationCommand);
+    async fn handle(
+        &self,
+        ctx: &Context,
+        command: &ApplicationCommandInteraction,
+        secubot: &Secubot,
+    ) -> CommandResult;
 }
 
-//use std::collections::HashMap;
+pub struct Commands {
+    commands: Vec<Box<dyn Command>>,
+}
 
-//static COMMANDS: HashMap<String, Box<dyn Command>> = HashMap::from([
-//    ("ping".to_string(), Box::new(ping::Ping))
-//]);
+impl Commands {
+    pub fn new() -> Self {
+        Self {
+            commands: Self::get_commands(),
+        }
+    }
 
+    fn get_commands() -> Vec<Box<dyn Command>> {
+        vec![
+            Box::new(TodoCommand::new()),
+        ]
+    }
 
-mod ping;
-pub use ping::Ping;
+    pub fn register_commands(&self, commands: &mut CreateApplicationCommands) {
+        for command in &self.commands {
+            commands.create_application_command(|com| {
+                command.add_application_command(com);
+                com.name(command.get_name())
+            });
+        }
+    }
 
-mod todo;
-pub use todo::{Todo, TodoActions};
+    pub async fn handle(&self, ctx: Context, interaction: Interaction, secubot: &Secubot) {
+        if let Interaction::ApplicationCommand(command) = interaction {
+            let requested_command_name = command.data.name.as_str();
+            let bot_command_option = self
+                .commands
+                .iter()
+                .find(|command| command.get_name() == requested_command_name);
+
+            if let Some(bot_command) = bot_command_option {
+                //let channel_id = command.channel_id;
+                //let http = ctx.http.clone();
+
+                let error_message =
+                    if let Err(e) = bot_command.handle(&ctx, &command, secubot).await {
+                        println!("Could not respond: {:?}", e);
+                        format!("Could not generate response:\n```\n{}\n```", e)
+                    } else {
+                        "".to_owned()
+                    };
+                if !error_message.is_empty() {
+                    // Try to create message (if not exists) and then edit it (if existed already)
+                    command
+                        .create_interaction_response(&ctx.http, |response| {
+                            response.kind(InteractionResponseType::ChannelMessageWithSource)
+                        })
+                        .await;
+
+                    command
+                        .edit_original_interaction_response(&ctx.http, |response| {
+                            response.content(error_message)
+                        })
+                        .await;
+                }
+            } else {
+                println!("Invalid command received");
+            }
+        }
+    }
+}