refactor(reminder): allow staff to ping role from reminder command

Author: Akinator31

crates/rustmail/src/commands/add_reminder/common.rs

@@ -2,9 +2,9 @@ use crate::prelude::config::*;
 use crate::prelude::db::*;
 use crate::prelude::utils::*;
 use chrono::Local;
-use serenity::all::{ChannelId, CommandInteraction, Context, Message, UserId};
+use serenity::all::{ChannelId, CommandInteraction, Context, GuildId, Message, RoleId, UserId};
 use sqlx::SqlitePool;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::select;
@@ -162,12 +162,46 @@ pub fn spawn_reminder(
         params.insert("user".to_string(), reminder.user_id.to_string());
         params.insert("content".to_string(), reminder.reminder_content.to_string());
 
-        let mut mentions = Vec::<UserId>::new();
-        mentions.push(UserId::new(reminder.user_id as u64));
+        let (mentions, is_role_targeted) = if let Some(ref target_roles_str) = reminder.target_roles
+        {
+            let role_mentions: String = target_roles_str
+                .split(',')
+                .filter_map(|s| s.trim().parse::<u64>().ok())
+                .map(|id| format!("<@&{}>", id))
+                .collect::<Vec<_>>()
+                .join(", ");
+            params.insert("roles".to_string(), role_mentions);
+
+            let members =
+                get_targeted_mentions(&ctx, &pool, reminder.guild_id as u64, target_roles_str)
+                    .await;
+            (members, true)
+        } else {
+            (vec![UserId::new(reminder.user_id as u64)], false)
+        };
+
+        if mentions.is_empty() {
+            if let Err(e) = update_reminder_status(&reminder, true, &pool).await {
+                eprintln!("Failed to update reminder status: {}", e);
+            }
+            return;
+        }
+
+        let (key_with_content, key_without_content) = if is_role_targeted {
+            (
+                "reminder.show_with_content_roles",
+                "reminder.show_without_content_roles",
+            )
+        } else {
+            (
+                "reminder.show_with_content",
+                "reminder.show_without_content",
+            )
+        };
 
         if !reminder.reminder_content.is_empty() {
             let _ = MessageBuilder::system_message(&ctx, &config)
-                .translated_content("reminder.show_with_content", Some(&params), None, None)
+                .translated_content(key_with_content, Some(&params), None, None)
                 .await
                 .to_channel(ChannelId::new(reminder.channel_id as u64))
                 .color(hex_string_to_int(&config.reminders.embed_color) as u32)
@@ -176,7 +210,7 @@ pub fn spawn_reminder(
                 .await;
         } else {
             let _ = MessageBuilder::system_message(&ctx, &config)
-                .translated_content("reminder.show_without_content", Some(&params), None, None)
+                .translated_content(key_without_content, Some(&params), None, None)
                 .await
                 .to_channel(ChannelId::new(reminder.channel_id as u64))
                 .color(hex_string_to_int(&config.reminders.embed_color) as u32)
@@ -190,3 +224,60 @@ pub fn spawn_reminder(
         }
     });
 }
+
+async fn get_targeted_mentions(
+    ctx: &Context,
+    pool: &SqlitePool,
+    guild_id: u64,
+    target_roles_str: &str,
+) -> Vec<UserId> {
+    let guild_id_obj = GuildId::new(guild_id);
+
+    let role_ids: Vec<u64> = target_roles_str
+        .split(',')
+        .filter_map(|s| s.trim().parse::<u64>().ok())
+        .collect();
+
+    if role_ids.is_empty() {
+        return vec![];
+    }
+
+    let members = match guild_id_obj.members(&ctx.http, None, None).await {
+        Ok(m) => m,
+        Err(e) => {
+            eprintln!("Failed to fetch guild members: {}", e);
+            return vec![];
+        }
+    };
+
+    let mut user_ids_with_roles: HashSet<UserId> = HashSet::new();
+
+    for role_id in &role_ids {
+        let role_id_obj = RoleId::new(*role_id);
+        for member in &members {
+            if member.roles.contains(&role_id_obj) {
+                user_ids_with_roles.insert(member.user.id);
+            }
+        }
+    }
+
+    let mut opted_out_users: HashSet<u64> = HashSet::new();
+
+    for role_id in &role_ids {
+        match get_optouts_for_role(guild_id as i64, *role_id as i64, pool).await {
+            Ok(optouts) => {
+                for user_id in optouts {
+                    opted_out_users.insert(user_id as u64);
+                }
+            }
+            Err(e) => {
+                eprintln!("Failed to get optouts for role {}: {}", role_id, e);
+            }
+        }
+    }
+
+    user_ids_with_roles
+        .into_iter()
+        .filter(|user_id| !opted_out_users.contains(&user_id.get()))
+        .collect()
+}

crates/rustmail/src/commands/add_reminder/slash_command/add_reminder.rs

@@ -10,7 +10,7 @@ use regex::Regex;
 use serenity::FutureExt;
 use serenity::all::{
     CommandDataOptionValue, CommandInteraction, CommandOptionType, Context, CreateCommand,
-    CreateCommandOption, ResolvedOption,
+    CreateCommandOption, GuildId, ResolvedOption, RoleId,
 };
 use std::sync::Arc;
 
@@ -60,6 +60,15 @@ impl RegistrableCommand for AddReminderCommand {
                 None,
             )
             .await;
+            let roles_desc = get_translated_message(
+                &config,
+                "slash_command.add_reminder_roles_argument_description",
+                None,
+                None,
+                None,
+                None,
+            )
+            .await;
 
             vec![
                 CreateCommand::new(name)
@@ -75,6 +84,10 @@ impl RegistrableCommand for AddReminderCommand {
                             content_desc,
                         )
                         .required(true),
+                    )
+                    .add_option(
+                        CreateCommandOption::new(CommandOptionType::String, "roles", roles_desc)
+                            .required(false),
                     ),
             ]
         })
@@ -102,6 +115,7 @@ impl RegistrableCommand for AddReminderCommand {
 
             let mut time: Option<String> = None;
             let mut content: Option<String> = None;
+            let mut roles: Option<String> = None;
 
             for option in &command.data.options {
                 match option.name.as_str() {
@@ -115,6 +129,11 @@ impl RegistrableCommand for AddReminderCommand {
                             content.replace(val.clone());
                         }
                     }
+                    "roles" => {
+                        if let CommandDataOptionValue::String(val) = &option.value {
+                            roles.replace(val.clone());
+                        }
+                    }
                     _ => {}
                 }
             }
@@ -171,6 +190,12 @@ impl RegistrableCommand for AddReminderCommand {
                 }
             };
 
+            let target_roles = if let Some(roles_str) = roles {
+                resolve_role_names_to_ids(&ctx, config.bot.get_staff_guild_id(), &roles_str).await
+            } else {
+                None
+            };
+
             let reminder: Reminder = Reminder {
                 thread_id: thread.id,
                 user_id: command.user.id.get() as i64,
@@ -180,6 +205,7 @@ impl RegistrableCommand for AddReminderCommand {
                 trigger_time: trigger_timestamp,
                 created_at: now.timestamp(),
                 completed: false,
+                target_roles,
             };
 
             let reminder_id = match insert_reminder(&reminder, pool).await {
@@ -213,3 +239,61 @@ impl RegistrableCommand for AddReminderCommand {
         })
     }
 }
+
+async fn resolve_role_names_to_ids(
+    ctx: &Context,
+    guild_id: u64,
+    roles_str: &str,
+) -> Option<String> {
+    if roles_str.is_empty() {
+        return None;
+    }
+
+    let guild_id_obj = GuildId::new(guild_id);
+    let guild = match guild_id_obj.to_partial_guild(&ctx.http).await {
+        Ok(g) => g,
+        Err(_) => return None,
+    };
+
+    let mention_regex = Regex::new(r"<@&(\d+)>").unwrap();
+
+    let role_parts: Vec<&str> = roles_str.split(',').map(|s| s.trim()).collect();
+    let mut role_ids: Vec<u64> = Vec::new();
+
+    for role_part in role_parts {
+        if role_part.is_empty() {
+            continue;
+        }
+
+        if let Some(caps) = mention_regex.captures(role_part) {
+            if let Some(id_match) = caps.get(1) {
+                if let Ok(id) = id_match.as_str().parse::<u64>() {
+                    if guild.roles.contains_key(&RoleId::new(id)) {
+                        role_ids.push(id);
+                    }
+                }
+            }
+        } else {
+            let role_name_lower = role_part.to_lowercase();
+            if let Some(role) = guild
+                .roles
+                .values()
+                .find(|r| r.name.to_lowercase() == role_name_lower)
+            {
+                role_ids.push(role.id.get());
+            }
+        }
+    }
+
+    if role_ids.is_empty() {
+        None
+    } else {
+        Some(
+            role_ids
+                .iter()
+                .map(|id| id.to_string())
+                .collect::<Vec<_>>()
+                .join(","),
+        )
+    }
+}