chore(faq): Support the entire message data rather than just an embed

Author: Archasion

bot/src/commands/faq.rs

@@ -10,7 +10,6 @@ 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;
 
@@ -70,13 +69,10 @@ impl CommandHandler for Faq<'_> {
         let CommandOptionValue::String(query) = &query.value else {
             anyhow::bail!("expected string query option");
         };
-        let Some(embed) = ctx.cfg.faq_option_embed(query) else {
+        let Some(mut response) = ctx.cfg.faq_option_response(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
@@ -87,15 +83,20 @@ impl CommandHandler for Faq<'_> {
             let CommandOptionValue::User(u_id) = mention.value else {
                 anyhow::bail!("expected user option");
             };
-            response_builder = response_builder.content(format!("<@{u_id}>"));
+            // Either set the content to the response or prepend it to the response
+            response.content = response
+                .content
+                .map_or(Some(format!("<@{u_id}>")), |content| {
+                    Some(format!("<@{u_id}> {content}"))
+                });
         }
 
         // 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()),
+                data: Some(response),
             })
             .await?;
 

bot/src/config.rs

@@ -1,7 +1,7 @@
 use anyhow::Context;
 use serde::Deserialize;
 use twilight_model::application::command::{CommandOptionChoice, CommandOptionChoiceValue};
-use twilight_model::channel::message::Embed;
+use twilight_model::http::interaction::InteractionResponseData;
 use twilight_model::id::marker::RoleMarker;
 use twilight_model::id::Id;
 
@@ -24,13 +24,16 @@ pub(crate) struct RoleConfig {
 
 /// Configuration for an option of the FAQ command.
 #[derive(Deserialize, Debug)]
-struct FaqOption {
+pub(crate) struct FaqOption {
     /// The label of the option (displayed to the user).
     label: String,
     /// The value of the option (used as the identifier).
     value: String,
     /// The embed to be sent when this option is selected.
-    embed: Embed,
+    // pub(crate) embed: Embed,
+    /// The components to be included with the embed.
+    // pub(crate) components: Option<Vec<Component>>,
+    pub(crate) response: InteractionResponseData,
 }
 
 impl Config {
@@ -46,22 +49,21 @@ impl Config {
             .collect()
     }
 
-    /// Returns the embed associated with a given FAQ option value.
-    pub(crate) fn faq_option_embed<S>(&self, value: S) -> Option<Embed>
+    /// Returns the FAQ option corresponding to the given value.
+    pub(crate) fn faq_option_response<S>(&self, value: S) -> Option<InteractionResponseData>
     where
         S: AsRef<str>,
     {
         self.faq_options
             .iter()
             .find(|opt| opt.value == value.as_ref())
-            .map(|opt| opt.embed.clone())
+            .map(|opt| opt.response.clone())
     }
 }
 
 /// Loads the configuration from a YAML file.
-#[tracing::instrument(ret)]
-pub(crate) fn load_config() -> Result<Config, anyhow::Error> {
-    let cfg_yaml = std::fs::read(config_path()).context("read config file")?;
+pub(crate) fn load_config(path: String) -> Result<Config, anyhow::Error> {
+    let cfg_yaml = std::fs::read(path).context("read config file")?;
     serde_yaml::from_slice(&cfg_yaml).context("parse config file")
 }
 

bot/src/main.rs

@@ -3,7 +3,6 @@ mod components;
 mod config;
 mod modals;
 
-use std::env;
 use std::sync::Arc;
 
 use anyhow::Context as _;
@@ -21,12 +20,28 @@ pub(crate) struct Context {
     request: Arc<reqwest::Client>,
 }
 
+fn validate_config() -> anyhow::Result<()> {
+    let path = std::env::args()
+        .nth(2)
+        .unwrap_or_else(|| "magnolia.cfg.yml".to_string());
+    config::load_config(path)?;
+    Ok(())
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     // Initialize the tracing subscriber.
     tracing_subscriber::fmt::init();
 
-    let token = env::var("DISCORD_TOKEN").context("get DISCORD_TOKEN env")?;
+    // Validate the config file.
+    if let Some(arg) = std::env::args().nth(1) {
+        if arg == "validate-config" {
+            validate_config()?;
+            return Ok(());
+        }
+    }
+
+    let token = std::env::var("DISCORD_TOKEN").context("get DISCORD_TOKEN env")?;
 
     // Use intents to only receive guild message events.
     let shard = Shard::new(ShardId::ONE, token.clone(), Intents::empty());
@@ -41,7 +56,7 @@ async fn main() -> anyhow::Result<()> {
         .build();
 
     // Parse the config file.
-    let cfg = Arc::new(config::load_config()?);
+    let cfg = Arc::new(config::load_config(config::config_path())?);
     let req_client = Arc::new(reqwest::Client::new());
 
     // Initialize the state.