Use the poise framework

Author: omfj

Cargo.lock

@@ -17,3 +17,4 @@ tower = { version = "0.5.2", features = ["util"] }
 tower-http = { version = "0.6.2", features = ["fs", "trace"] }
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+poise = "0.6.1"

Cargo.toml

@@ -15,31 +15,3 @@ HOW TO TEST
 
 You can test the application with `cargo test -- --test-threads=1`. Remember to
 have docker running.
-
-COMMANDS
---------
-
-/kø
-
-Sjekker hvor i køen brukeren er.
-
-/vaffel
-
-Bestiller en vaffel og setter deg i køen. Om du allerede er i køen, vil den bare
-vise hvor i øken brukeren er.
-
-/stekt [number]
-
-Steker antall vafler, og fjerner de fra køen.
-
-/tøm
-
-Fjerner alle vafler fra køen. Brukes når det er tomt for vafler.
-
-/stopp
-
-Stopper steking av vafler, lar ingen kommer inn i køen.
-
-/start
-
-Starter steking av vafler, lar alle komme inn i køen.

README

@@ -1,125 +1,80 @@
+use serenity::Error as SerenityError;
 use std::sync::Arc;
 
-use serenity::all::UserId;
-use serenity::async_trait;
-use serenity::model::application::Interaction;
-use serenity::model::gateway::Ready;
-use serenity::model::id::GuildId;
-use serenity::prelude::*;
-use tracing::{debug, error, info};
+use poise::FrameworkOptions;
+use serenity::all::GatewayIntents;
 
-use crate::commands::bake::BakeCommand;
-use crate::commands::close::CloseCommand;
-use crate::commands::empty::EmptyCommand;
-use crate::commands::open::OpenCommand;
-use crate::commands::ping::PingCommand;
-use crate::commands::queue_size::QueueSizeCommand;
-use crate::commands::waffle::WaffleCommand;
-use crate::commands::CommandHandler;
-use crate::queue::WaffleQueue;
+use crate::{commands, queue::WaffleQueue};
 
-pub struct WaffleContext<'a> {
-    pub is_oracle: bool,
+pub type Error = Box<dyn std::error::Error + Send + Sync>;
+pub type Context<'a> = poise::Context<'a, Data, Error>;
+
+pub struct Data {
     pub queue: Arc<WaffleQueue>,
-    #[allow(dead_code)]
-    pub context: &'a Context,
 }
 
 pub struct WaffleBot {
     token: String,
-    guild_id: GuildId,
     queue: Arc<WaffleQueue>,
-    commands: Vec<Box<(dyn CommandHandler + 'static)>>,
 }
 
 impl WaffleBot {
-    pub fn new(token: String, guild_id: u64, queue: Arc<WaffleQueue>) -> Self {
-        let guild_id = GuildId::new(guild_id);
+    pub fn new(token: String, queue: Arc<WaffleQueue>) -> Self {
+        Self { token, queue }
+    }
 
-        let commands: Vec<Box<dyn CommandHandler>> = vec![
-            Box::new(PingCommand::new()),
-            Box::new(OpenCommand::new()),
-            Box::new(QueueSizeCommand::new()),
-            Box::new(WaffleCommand::new()),
-            Box::new(BakeCommand::new()),
-            Box::new(CloseCommand::new()),
-            Box::new(EmptyCommand::new()),
-        ];
+    pub async fn start(self) -> Result<(), SerenityError> {
+        let options: FrameworkOptions<Data, Error> = poise::FrameworkOptions {
+            commands: vec![
+                commands::bake::bake(),
+                commands::close::close(),
+                commands::open::open(),
+                commands::ping::ping(),
+                commands::queue_size::queue(),
+                commands::waffle::waffle(),
+            ],
+            prefix_options: poise::PrefixFrameworkOptions {
+                prefix: Some("!".into()),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        let framework = poise::Framework::builder()
+            .setup(move |ctx, _ready, framework| {
+                Box::pin(async move {
+                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+                    Ok(Data {
+                        queue: self.queue.clone(),
+                    })
+                })
+            })
+            .options(options)
+            .build();
+
+        let mut client = serenity::Client::builder(self.token.clone(), GatewayIntents::empty())
+            .framework(framework)
+            .await?;
 
-        Self {
-            token,
-            guild_id,
-            queue,
-            commands,
-        }
+        client.start().await
     }
+}
 
-    pub async fn is_user_oracle(&self, ctx: &Context, user_id: UserId) -> bool {
-        if let Ok(member) = self.guild_id.member(ctx, user_id).await {
-            if let Ok(roles) = self.guild_id.roles(ctx).await {
+#[allow(unused)]
+pub async fn check_is_oracle(ctx: Context<'_>) -> Result<bool, Error> {
+    if let Ok(member) = ctx.guild_id().unwrap().member(ctx, ctx.author().id).await {
+        if let Some(guild_id) = ctx.guild_id() {
+            if let Ok(roles) = guild_id.roles(ctx).await {
                 if let Some(orakel_role_id) = roles
                     .values()
                     .find(|r| r.name.to_lowercase() == "orakel")
                     .map(|r| r.id)
                 {
-                    return member.roles.contains(&orakel_role_id);
+                    return Ok(member.roles.contains(&orakel_role_id));
                 }
             }
         }
-
-        false
     }
 
-    pub async fn start(self) -> Result<(), serenity::Error> {
-        let mut client = Client::builder(self.token.clone(), GatewayIntents::empty())
-            .event_handler(self)
-            .await?;
-
-        client.start().await
-    }
-}
-
-#[async_trait]
-impl EventHandler for WaffleBot {
-    async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
-        if let Interaction::Command(command) = interaction {
-            let cmd = self
-                .commands
-                .iter()
-                .find(|cmd| cmd.name() == command.data.name);
-
-            if let Some(cmd) = cmd {
-                let is_oracle = self.is_user_oracle(&ctx, command.user.id).await;
-                let c = WaffleContext {
-                    is_oracle,
-                    queue: self.queue.clone(),
-                    context: &ctx,
-                };
-
-                let content = cmd.execute(&c, &command);
-
-                if let Err(why) = command.create_response(&ctx.http, content).await {
-                    debug!("Cannot respond to slash command: {why}");
-                }
-            }
-        }
-    }
-
-    async fn ready(&self, ctx: Context, ready: Ready) {
-        info!("{} is connected!", ready.user.name);
-
-        let commands = self
-            .guild_id
-            .set_commands(
-                &ctx.http,
-                self.commands.iter().map(|cmd| cmd.register()).collect(),
-            )
-            .await;
-
-        if let Err(why) = commands {
-            error!("Error registering commands: {why}");
-        } else {
-            info!("Commands registered successfully");
-        }
-    }
+    Ok(false)
 }