add antimention system

Author: 0x7d8

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bot-rs"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -8,6 +8,9 @@ pub struct Env {
     pub database_url: String,
     pub database_migrate: bool,
 
+    pub antimention_user_ids: Vec<u64>,
+    pub antimention_whitelisted_role_ids: Vec<u64>,
+
     pub github_channel_id: u64,
     pub github_sponsors_channel_id: Option<u64>,
     pub github_sponsors_login: Option<String>,
@@ -44,6 +47,17 @@ impl Env {
                 .parse()
                 .unwrap(),
 
+            antimention_user_ids: std::env::var("ANTIMENTION_USER_IDS")
+                .unwrap_or("".to_string())
+                .split(',')
+                .filter_map(|s| s.trim().parse().ok())
+                .collect(),
+            antimention_whitelisted_role_ids: std::env::var("ANTIMENTION_WHITELISTED_ROLE_IDS")
+                .unwrap_or("".to_string())
+                .split(',')
+                .filter_map(|s| s.trim().parse().ok())
+                .collect(),
+
             github_channel_id: std::env::var("GITHUB_CHANNEL_ID")
                 .expect("GITHUB_CHANNEL_ID is required")
                 .trim_matches('"')

src/env.rs

@@ -1,4 +1,10 @@
-use serenity::all::{ActivityData, Event, Interaction, ReactionType};
+use std::{
+    collections::HashMap,
+    sync::{Arc, LazyLock},
+};
+
+use serenity::all::{ActivityData, Event, Interaction, ReactionType, Timestamp, UserId};
+use tokio::{sync::Mutex, time};
 
 pub struct EventHandler {
     pub components: crate::components::ComponentList,
@@ -44,6 +50,79 @@ impl serenity::all::RawEventHandler for EventHandler {
                             .react(&ctx.http, ReactionType::Unicode('👋'.into()))
                             .await?;
                     }
+
+                    let Some(guild_id) = event.message.guild_id else {
+                        return Ok(());
+                    };
+
+                    for mention in &event.message.mentions {
+                        if state.env.antimention_user_ids.contains(&mention.id.get())
+                            && !state
+                                .env
+                                .antimention_user_ids
+                                .contains(&event.message.author.id.get())
+                            && let Ok(mut member) =
+                                guild_id.member(&ctx.http, event.message.author.id).await
+                        {
+                            for role_id in &state.env.antimention_whitelisted_role_ids {
+                                if member.roles.contains(&(*role_id).into()) {
+                                    return Ok(());
+                                }
+                            }
+
+                            static TIMEOUT_MAP: LazyLock<Arc<Mutex<HashMap<UserId, u32>>>> =
+                                LazyLock::new(|| {
+                                    let map = Arc::new(Mutex::new(HashMap::new()));
+
+                                    tokio::spawn({
+                                        let map = Arc::clone(&map);
+                                        async move {
+                                            loop {
+                                                time::sleep(time::Duration::from_hours(6)).await;
+                                                let mut map = map.lock().await;
+                                                map.retain(|_, count| *count > 0);
+                                                for count in map.values_mut() {
+                                                    if *count > 0 {
+                                                        *count -= 1;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    });
+
+                                    map
+                                });
+
+                            let mut timeout_map = TIMEOUT_MAP.lock().await;
+                            let timeout_count = timeout_map.entry(mention.id).or_insert(0);
+                            *timeout_count += 1;
+                            let timeout_duration = match *timeout_count {
+                                1 | 2 => 30,
+                                3 | 4 => 60,
+                                5 => 300,
+                                6 => 600,
+                                _ => 3600,
+                            };
+                            drop(timeout_map);
+
+                            let timestamp = match Timestamp::from_unix_timestamp(
+                                chrono::Utc::now().timestamp() + timeout_duration,
+                            ) {
+                                Ok(t) => t,
+                                Err(_) => return Ok(()),
+                            };
+
+                            member
+                                .disable_communication_until(&ctx.http, timestamp)
+                                .await?;
+                            event
+                                .message
+                                .reply_ping(&ctx.http, "👋 Hey, please do not mention this person. You have been temporarily timed out, repeated offenses will result in longer timeouts.")
+                                .await?;
+
+                            break;
+                        }
+                    }
                 }
                 Event::InteractionCreate(event) => {
                     if let Interaction::Component(component) = &event.interaction

src/events.rs

@@ -553,13 +553,13 @@ async fn handle_organization_event(
     let mut container_components = Vec::new();
     let mut channel_id = state.env.github_channel_id;
 
-    if state.env.github_token.is_some() {
-        return Ok(());
-    }
-
     if let WebhookEventPayload::Sponsorship(sponsorship) = event.specific
         && sponsorship.action == SponsorshipWebhookEventAction::Created
     {
+        if state.env.github_token.is_some() {
+            return Ok(());
+        }
+
         #[derive(Deserialize)]
         struct SponsorshipMaintainer {
             avatar_url: String,