chore(commands): Add a FAQ command

Author: Archasion

.gitignore

@@ -1,4 +1,5 @@
 /target
 .idea
 .env
-magnolia.cfg.yml
+magnolia.cfg.yml
+magnolia.cfg.*.yml

bot/src/commands/devforum_self_role.rs

@@ -23,7 +23,7 @@ pub(crate) struct DevForumSelfRole<'a> {
 
 #[async_trait]
 impl CommandHandler for DevForumSelfRole<'_> {
-    fn model() -> anyhow::Result<Command> {
+    fn model(_ctx: Option<crate::Context>) -> anyhow::Result<Command> {
         Ok(CommandBuilder::new(
             "devforum-self-role",
             "Send an info embed with a button to self-update DevForum roles.",

bot/src/commands/faq.rs

@@ -0,0 +1,104 @@
+use anyhow::Context;
+use async_trait::async_trait;
+use builders::command_option::CommandOptionBuilder;
+use twilight_model::application::command::{Command, CommandOptionType, CommandType};
+use twilight_model::application::interaction::application_command::CommandOptionValue;
+use twilight_model::application::interaction::{
+    Interaction, InteractionContextType, InteractionData,
+};
+use twilight_model::guild::Permissions;
+use twilight_model::http::interaction::{InteractionResponse, InteractionResponseType};
+use twilight_model::oauth::ApplicationIntegrationType;
+use twilight_util::builder::command::CommandBuilder;
+use twilight_util::builder::InteractionResponseDataBuilder;
+
+use crate::commands::CommandHandler;
+
+const QUERY_OPTION_NAME: &str = "query";
+const MENTION_OPTION_NAME: &str = "mention";
+
+#[allow(dead_code)]
+pub(crate) struct Faq<'a> {
+    pub(crate) cmd: &'a Interaction,
+}
+
+#[async_trait]
+impl CommandHandler for Faq<'_> {
+    fn model(ctx: Option<crate::Context>) -> anyhow::Result<Command> {
+        let ctx = ctx.expect("ctx is required");
+        let query_option = CommandOptionBuilder::new(
+            QUERY_OPTION_NAME,
+            "The response to send.",
+            CommandOptionType::String,
+        )
+        .choices(ctx.cfg.faq_option_choices())
+        .required(true)
+        .build()?;
+
+        let mention_option = CommandOptionBuilder::new(
+            MENTION_OPTION_NAME,
+            "The user to mention in the response.",
+            CommandOptionType::User,
+        )
+        .build()?;
+
+        Ok(CommandBuilder::new(
+            "faq",
+            "Send quick responses to common questions/queries.",
+            CommandType::ChatInput,
+        )
+        .contexts([InteractionContextType::Guild])
+        .integration_types([ApplicationIntegrationType::GuildInstall])
+        .default_member_permissions(Permissions::MANAGE_CHANNELS)
+        .option(query_option)
+        .option(mention_option)
+        .validate()
+        .context("validate faq command")?
+        .build())
+    }
+
+    async fn exec(&self, ctx: crate::Context) -> anyhow::Result<()> {
+        let Some(InteractionData::ApplicationCommand(data)) = &self.cmd.data else {
+            anyhow::bail!("expected application command interaction");
+        };
+        // Get the query option from the command data
+        let query = data
+            .options
+            .iter()
+            .find(|opt| opt.name == QUERY_OPTION_NAME)
+            .context("missing query option")?;
+        let CommandOptionValue::String(query) = &query.value else {
+            anyhow::bail!("expected string query option");
+        };
+        let Some(embed) = ctx.cfg.faq_option_embed(query) else {
+            anyhow::bail!("unknown query option: {}", query);
+        };
+
+        // Create the response builder with an embed
+        let mut response_builder = InteractionResponseDataBuilder::new().embeds([embed]);
+
+        // Add mention if provided
+        let mention = data
+            .options
+            .iter()
+            .find(|opt| opt.name == MENTION_OPTION_NAME);
+
+        if let Some(mention) = mention {
+            let CommandOptionValue::User(u_id) = mention.value else {
+                anyhow::bail!("expected user option");
+            };
+            response_builder = response_builder.content(format!("<@{u_id}>"));
+        }
+
+        // Send the response
+        ctx.http
+            .interaction(self.cmd.application_id)
+            .create_response(self.cmd.id, &self.cmd.token, &InteractionResponse {
+                kind: InteractionResponseType::ChannelMessageWithSource,
+                data: Some(response_builder.build()),
+            })
+            .await?;
+
+        Ok(())
+    }
+}

bot/src/commands/mod.rs

@@ -2,17 +2,21 @@ use async_trait::async_trait;
 use twilight_model::application::command::Command;
 use twilight_model::application::interaction::Interaction;
 
-pub(crate) mod devforum_self_role;
+mod devforum_self_role;
+mod faq;
 
 /// Get all application command models.
-pub(crate) fn models() -> anyhow::Result<Vec<Command>> {
-    Ok(vec![devforum_self_role::DevForumSelfRole::model()?])
+pub(crate) fn models(ctx: crate::Context) -> anyhow::Result<Vec<Command>> {
+    Ok(vec![
+        devforum_self_role::DevForumSelfRole::model(None)?,
+        faq::Faq::model(Some(ctx))?,
+    ])
 }
 
 /// Trait for implementing application commands.
 #[async_trait]
 pub(crate) trait CommandHandler: Send {
-    fn model() -> anyhow::Result<Command>
+    fn model(ctx: Option<crate::Context>) -> anyhow::Result<Command>
     where
         Self: Sized;
     async fn exec(&self, ctx: crate::Context) -> anyhow::Result<()>;
@@ -25,6 +29,7 @@ pub(crate) async fn handle_command(
 ) -> anyhow::Result<()> {
     let handler: Box<dyn CommandHandler> = match cmd_name {
         "devforum-self-role" => Box::new(devforum_self_role::DevForumSelfRole { cmd }),
+        "faq" => Box::new(faq::Faq { cmd }),
         unknown => anyhow::bail!("unknown command name: {}", unknown),
     };
     handler.exec(ctx).await

bot/src/config.rs

@@ -1,11 +1,14 @@
 use anyhow::Context;
 use serde::Deserialize;
+use twilight_model::application::command::{CommandOptionChoice, CommandOptionChoiceValue};
+use twilight_model::channel::message::Embed;
 use twilight_model::id::marker::RoleMarker;
 use twilight_model::id::Id;
 
 #[derive(Deserialize, Debug)]
 pub(crate) struct Config {
     pub(crate) roles: ConfigRoles,
+    faq_options: Vec<FAQOption>,
 }
 
 #[derive(Deserialize, Debug)]
@@ -15,6 +18,36 @@ pub(crate) struct ConfigRoles {
     pub(crate) roblox_verified: Option<Id<RoleMarker>>,
 }
 
+#[derive(Deserialize, Debug)]
+pub(crate) struct FAQOption {
+    label: String,
+    value: String,
+    embed: Embed,
+}
+
+impl Config {
+    pub(crate) fn faq_option_choices(&self) -> Vec<CommandOptionChoice> {
+        self.faq_options
+            .iter()
+            .map(|opt| CommandOptionChoice {
+                name: opt.label.clone(),
+                value: CommandOptionChoiceValue::String(opt.value.clone()),
+                name_localizations: None,
+            })
+            .collect()
+    }
+
+    pub(crate) fn faq_option_embed<S>(&self, value: S) -> Option<Embed>
+    where
+        S: AsRef<str>,
+    {
+        self.faq_options
+            .iter()
+            .find(|opt| opt.value == value.as_ref())
+            .map(|opt| opt.embed.clone())
+    }
+}
+
 #[tracing::instrument(ret)]
 pub(crate) fn load_config<S>(path: S) -> Result<Config, anyhow::Error>
 where

bot/src/main.rs

@@ -86,8 +86,8 @@ async fn handle_event_wrapper(
     Ok(())
 }
 
-async fn handle_event(event: Event, state: Context) -> anyhow::Result<()> {
-    match event {
+async fn handle_event(event: Event, ctx: Context) -> anyhow::Result<()> {
+    let res: anyhow::Result<()> = match event {
         Event::Ready(client) => {
             tracing::info!(
                 "the client has logged in as @{} ({})",
@@ -97,30 +97,31 @@ async fn handle_event(event: Event, state: Context) -> anyhow::Result<()> {
 
             // Publish commands every time the bot starts
             // to ensure they are always up to date.
-            let global_commands = state
+            let global_commands = ctx
                 .http
                 .interaction(client.application.id)
-                .set_global_commands(commands::models()?.as_slice())
+                .set_global_commands(commands::models(ctx.clone())?.as_slice())
                 .await
                 .context("publish global commands")?
                 .models()
                 .await
                 .context("get global commands")?;
 
             tracing::info!("published {} global commands", global_commands.len());
+            Ok(())
         },
         Event::InteractionCreate(interaction) => {
             match &interaction.data {
                 Some(InteractionData::ApplicationCommand(command)) => {
-                    commands::handle_command(&interaction.0, command.name.as_str(), state.clone())
+                    commands::handle_command(&interaction.0, command.name.as_str(), ctx.clone())
                         .await
                         .with_context(|| format!("handle command: {}", command.name))?;
                 },
                 Some(InteractionData::MessageComponent(component)) => {
                     components::handle_component(
                         &interaction.0,
                         component.custom_id.as_str(),
-                        state.clone(),
+                        ctx.clone(),
                     )
                     .await
                     .with_context(|| format!("handle component: {}", component.custom_id))?;
@@ -133,8 +134,13 @@ async fn handle_event(event: Event, state: Context) -> anyhow::Result<()> {
                 // },
                 _ => anyhow::bail!("unsupported interaction type"),
             };
+            Ok(())
         },
-        _ => {},
+        _ => Ok(()),
+    };
+
+    if let Err(err) = res {
+        tracing::error!(source = ?err, "error handling event");
     }
 
     Ok(())