Add welcome message option

Author: Earthcomputer

src/discord_bot/commands.rs

@@ -1,7 +1,7 @@
 use crate::discord_bot::guild_storage::GuildStorage;
 use crate::discord_bot::{
     brainfuck, chess, counter, mood, permanent_latest, reaction_role_toggle, role, roletoggle,
-    social_credit, storage, support,
+    social_credit, storage, support, welcome_message,
 };
 use chrono::Datelike;
 use log::info;
@@ -76,6 +76,7 @@ declare_commands! {
     "storage" => (storage::run, "Admin commands to directly manipulate guild storage"),
     "support" => (support::run, "Use on people who are asking for support without using the support channel"),
     "trick" => (trick, "Adds a trick"),
+    "welcome_message" => (welcome_message::run, "Sets the welcome message for new users in this discord"),
 }
 
 pub(crate) async fn run(

src/discord_bot/guild_storage.rs

@@ -2,6 +2,7 @@ use crate::discord_bot::chess::ChessState;
 use crate::discord_bot::permanent_latest::PermanentLatestInfo;
 use crate::discord_bot::role::RoleData;
 use crate::discord_bot::roletoggle::RoleToggleInfo;
+use crate::discord_bot::welcome_message::WelcomeMessageData;
 use dashmap::mapref::entry::Entry;
 use dashmap::mapref::one::{Ref, RefMut};
 use dashmap::DashMap;
@@ -32,6 +33,8 @@ pub struct GuildStorage {
     #[serde(default)]
     pub join_log_channel: Option<ChannelId>,
     #[serde(default)]
+    pub welcome_message: Option<WelcomeMessageData>,
+    #[serde(default)]
     pub role_toggles: HashMap<String, RoleToggleInfo>,
     #[serde(default)]
     pub tricks: HashMap<String, String>,
@@ -57,6 +60,7 @@ impl Default for GuildStorage {
             role_data: RoleData::default(),
             log_channel: None,
             join_log_channel: None,
+            welcome_message: None,
             role_toggles: HashMap::new(),
             tricks: HashMap::new(),
             permanent_latest: PermanentLatestInfo::default(),

src/discord_bot/mod.rs

@@ -13,6 +13,7 @@ mod social_credit;
 mod storage;
 mod support;
 mod update_copy;
+mod welcome_message;
 
 use crate::config;
 use crate::discord_bot::april_fools_channel::{get_april_fools_channel, AprilFoolsChannel};
@@ -237,13 +238,12 @@ async fn send_chatbridge_message_to_discord(
 #[async_trait]
 impl EventHandler for Handler {
     async fn guild_member_addition(&self, ctx: Context, new_member: Member) {
-        if let Some(join_log_channel) = GuildStorage::get(new_member.guild_id)
-            .await
-            .join_log_channel
-        {
+        let storage = GuildStorage::get(new_member.guild_id).await;
+
+        if let Some(join_log_channel) = storage.join_log_channel {
             if let Err(err) = join_log_channel
                 .send_message(
-                    ctx,
+                    &ctx,
                     CreateMessage::new().content(format!(
                         "{} has risen from the dead.",
                         new_member.display_name()
@@ -254,6 +254,23 @@ impl EventHandler for Handler {
                 error!("Failed to send message in join log channel: {}", err);
             }
         }
+
+        if let Some(welcome_message_data) = &storage.welcome_message {
+            if let Err(err) = welcome_message_data
+                .channel
+                .send_message(
+                    &ctx,
+                    CreateMessage::new().content(
+                        welcome_message_data
+                            .message
+                            .replace("[user]", &format!("<@{}>", new_member.user.id)),
+                    ),
+                )
+                .await
+            {
+                error!("Failed to send welcome message: {}", err);
+            }
+        }
     }
 
     async fn guild_member_removal(

src/discord_bot/welcome_message.rs

@@ -0,0 +1,76 @@
+use crate::discord_bot::commands::check_admin;
+use crate::discord_bot::guild_storage::GuildStorage;
+use serde::{Deserialize, Serialize};
+use serenity::client::Context;
+use serenity::model::channel::Message;
+use serenity::model::id::{ChannelId, GuildId};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+pub struct WelcomeMessageData {
+    pub channel: ChannelId,
+    pub message: String,
+}
+
+async fn print_usage(guild_id: GuildId, ctx: Context, message: &Message) -> crate::Result<()> {
+    let prefix = GuildStorage::get(guild_id).await.command_prefix.clone();
+    message
+        .reply(
+            ctx,
+            format!(
+                "{prefix}welcome_message <channel_id> [message]\nUse [user] as a placeholder for a ping to the user."
+            ),
+        )
+        .await?;
+    Ok(())
+}
+
+pub(crate) async fn run(
+    args: &str,
+    guild_id: GuildId,
+    ctx: Context,
+    message: &Message,
+) -> crate::Result<()> {
+    if !check_admin(&ctx, message).await? {
+        return Ok(());
+    }
+
+    let first_arg_end = args.find(char::is_whitespace).unwrap_or(args.len());
+    let second_arg_begin = first_arg_end
+        + args[first_arg_end..]
+            .find(|c: char| !c.is_whitespace())
+            .unwrap_or_default();
+    let Ok(channel_id) = args[..first_arg_end].parse::<ChannelId>() else {
+        return print_usage(guild_id, ctx, message).await;
+    };
+
+    if !guild_id.channels(&ctx).await?.contains_key(&channel_id) {
+        message
+            .reply(ctx, "That channel is not in this discord")
+            .await?;
+        return Ok(());
+    }
+
+    let welcome_message = args[second_arg_begin..].trim();
+    let mut storage = GuildStorage::get_mut(guild_id).await;
+    if welcome_message.is_empty() {
+        storage.welcome_message = None;
+        storage.save().await;
+        message
+            .reply(&ctx, "Successfully removed the welcome message")
+            .await?;
+    } else {
+        storage.welcome_message = Some(WelcomeMessageData {
+            channel: channel_id,
+            message: welcome_message.to_owned(),
+        });
+        storage.save().await;
+        message
+            .reply(
+                &ctx,
+                format!("Set the welcome message to {welcome_message}"),
+            )
+            .await?;
+    }
+
+    Ok(())
+}