Move April fools channels to guild storage

Author: Earthcomputer

src/config.rs

@@ -107,10 +107,6 @@ impl Config {
 pub struct SpecialChannels {
     pub applications: ChannelId,
     pub support: ChannelId,
-    #[serde(default)]
-    pub simple_words: Option<ChannelId>,
-    #[serde(default)]
-    pub haiku: Option<ChannelId>,
 }
 
 #[derive(Deserialize)]

src/discord_bot/april_fools_channel/mod.rs

@@ -1,14 +1,35 @@
-use crate::config;
-use serenity::all::{ChannelId, Context, CreateMessage, MessageFlags, MessageId, User};
+use crate::discord_bot::guild_storage::GuildStorage;
+use serde::{Deserialize, Serialize};
+use serenity::all::{ChannelId, Context, CreateMessage, GuildId, MessageFlags, MessageId, User};
 
 mod haiku;
 mod simple_words;
 
-pub(crate) fn get_april_fools_channel(
+#[derive(Debug)]
+pub(crate) struct AprilFoolsMessageContext<'a> {
+    pub context: Context,
+    pub has_attachments: bool,
+    pub content: &'a str,
+    pub author: &'a User,
+    pub guild_id: GuildId,
+    pub channel_id: ChannelId,
+    pub message_id: MessageId,
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+pub(crate) struct AprilFoolsChannels {
+    #[serde(default)]
+    pub simple_words: Option<ChannelId>,
+    #[serde(default)]
+    pub haiku: Option<ChannelId>,
+}
+
+pub(crate) async fn get_april_fools_channel(
+    guild_id: GuildId,
     channel_id: ChannelId,
 ) -> Option<&'static dyn AprilFoolsChannel> {
-    let config = config::get();
-    let channels = &config.special_channels;
+    let storage = GuildStorage::get(guild_id).await;
+    let channels = &storage.april_fools_channels;
     if channels.simple_words == Some(channel_id) {
         Some(&simple_words::CHANNEL)
     } else if channels.haiku == Some(channel_id) {
@@ -19,37 +40,38 @@ pub(crate) fn get_april_fools_channel(
 }
 
 pub(crate) async fn on_message(
-    ctx: Context,
     april_fools: &(impl AprilFoolsChannel + ?Sized),
-    has_attachments: bool,
-    content: &str,
-    author: &User,
-    channel_id: ChannelId,
-    message_id: MessageId,
+    context: AprilFoolsMessageContext<'_>,
 ) -> crate::Result<()> {
     // find words in message
-    let error_message = if has_attachments {
+    let error_message = if context.has_attachments {
         Some(april_fools.has_attachment_message().to_owned())
     } else {
-        april_fools.get_error(content)
+        april_fools.get_error(context.content)
     };
     if let Some(mut error_message) = error_message {
-        channel_id.delete_message(&ctx, message_id).await?;
-        if !author.bot {
-            let dm_channel = author.create_dm_channel(&ctx).await?;
+        context
+            .channel_id
+            .delete_message(&context.context, context.message_id)
+            .await?;
+        if !context.author.bot {
+            let dm_channel = context.author.create_dm_channel(&context.context).await?;
             if let Some(your_original_message_was) = april_fools.your_original_message_was() {
                 error_message.push(' ');
                 error_message.push_str(your_original_message_was);
             }
             dm_channel
-                .send_message(&ctx, CreateMessage::new().content(error_message))
+                .send_message(
+                    &context.context,
+                    CreateMessage::new().content(error_message),
+                )
                 .await?;
-            if !content.is_empty() {
+            if !context.content.is_empty() {
                 dm_channel
                     .send_message(
-                        ctx,
+                        context.context,
                         CreateMessage::new()
-                            .content(content)
+                            .content(context.content)
                             .flags(MessageFlags::SUPPRESS_NOTIFICATIONS),
                     )
                     .await?;

src/discord_bot/guild_storage.rs

@@ -1,3 +1,4 @@
+use crate::discord_bot::april_fools_channel::AprilFoolsChannels;
 use crate::discord_bot::chess::ChessState;
 use crate::discord_bot::permanent_latest::PermanentLatestInfo;
 use crate::discord_bot::role::RoleData;
@@ -50,6 +51,8 @@ pub struct GuildStorage {
     pub counters: HashMap<String, u64>,
     #[serde(default)]
     pub social_credit: HashMap<UserId, i32>,
+    #[serde(default)]
+    pub april_fools_channels: AprilFoolsChannels,
 }
 
 impl Default for GuildStorage {
@@ -69,6 +72,7 @@ impl Default for GuildStorage {
             users_sent_to_support: HashSet::new(),
             counters: HashMap::new(),
             social_credit: HashMap::new(),
+            april_fools_channels: AprilFoolsChannels::default(),
         }
     }
 }

src/discord_bot/mod.rs

@@ -16,7 +16,9 @@ mod update_copy;
 mod welcome_message;
 
 use crate::config;
-use crate::discord_bot::april_fools_channel::{get_april_fools_channel, AprilFoolsChannel};
+use crate::discord_bot::april_fools_channel::{
+    get_april_fools_channel, AprilFoolsChannel, AprilFoolsMessageContext,
+};
 use crate::discord_bot::guild_storage::GuildStorage;
 use crate::pterodactyl::{tellraw, PterodactylChatBridge, PterodactylServer};
 use async_trait::async_trait;
@@ -318,7 +320,9 @@ impl EventHandler for Handler {
             let config = config::get();
 
             let message_handling = {
-                if let Some(april_fools_channel) = get_april_fools_channel(new_message.channel_id) {
+                if let Some(april_fools_channel) =
+                    get_april_fools_channel(guild_id, new_message.channel_id).await
+                {
                     MessageHandling::AprilFools(april_fools_channel)
                 } else if new_message.author.bot {
                     return;
@@ -373,13 +377,16 @@ impl EventHandler for Handler {
                 }
                 MessageHandling::AprilFools(april_fools) => {
                     april_fools_channel::on_message(
-                        ctx,
                         april_fools,
-                        !new_message.attachments.is_empty(),
-                        &new_message.content,
-                        &new_message.author,
-                        new_message.channel_id,
-                        new_message.id,
+                        AprilFoolsMessageContext {
+                            context: ctx,
+                            has_attachments: !new_message.attachments.is_empty(),
+                            content: &new_message.content,
+                            author: &new_message.author,
+                            guild_id,
+                            channel_id: new_message.channel_id,
+                            message_id: new_message.id,
+                        },
                     )
                     .await
                 }
@@ -399,10 +406,15 @@ impl EventHandler for Handler {
         _new: Option<Message>,
         event: MessageUpdateEvent,
     ) {
+        let Some(guild_id) = event.guild_id else {
+            return;
+        };
+
         enum MessageEditHandling {
             AprilFools(&'static dyn AprilFoolsChannel),
         }
-        let handling = if let Some(april_fools_channel) = get_april_fools_channel(event.channel_id)
+        let handling = if let Some(april_fools_channel) =
+            get_april_fools_channel(guild_id, event.channel_id).await
         {
             MessageEditHandling::AprilFools(april_fools_channel)
         } else {
@@ -418,17 +430,20 @@ impl EventHandler for Handler {
             if let Err(err) = match handling {
                 MessageEditHandling::AprilFools(april_fools) => {
                     april_fools_channel::on_message(
-                        ctx,
                         april_fools,
-                        event
-                            .attachments
-                            .as_ref()
-                            .map(|attachments| attachments.is_empty())
-                            == Some(false),
-                        &content,
-                        &author,
-                        event.channel_id,
-                        event.id,
+                        AprilFoolsMessageContext {
+                            context: ctx,
+                            has_attachments: event
+                                .attachments
+                                .as_ref()
+                                .map(|attachments| attachments.is_empty())
+                                == Some(false),
+                            content: &content,
+                            author: &author,
+                            guild_id,
+                            channel_id: event.channel_id,
+                            message_id: event.id,
+                        },
                     )
                     .await
                 }