fix(commands): fixed mention that doesn't ping mentionned user

Akinator31 · Akinator31 · commit 02eed0e84b50 · 2025-10-08T08:53:38.000+02:00
diff --git a/src/commands/add_reminder/common.rs b/src/commands/add_reminder/common.rs
@@ -1,10 +1,16 @@
 use crate::config::Config;
+use crate::db::reminders::{update_reminder_status, Reminder};
 use crate::utils::conversion::hex_string_to_int::hex_string_to_int;
 use crate::utils::message::message_builder::MessageBuilder;
-use serenity::all::{Context, Message};
+use chrono::Local;
+use serenity::all::{ChannelId, Context, Message, UserId};
+use sqlx::SqlitePool;
 use std::collections::HashMap;
+use std::time::Duration;
+use tokio::time::sleep;
 
 pub async fn send_register_confirmation(
+    reminder_id: i64,
     reminder_content: &str,
     ctx: &Context,
     msg: &Message,
@@ -32,6 +38,7 @@ pub async fn send_register_confirmation(
             )
             .await
             .to_channel(msg.channel_id)
+            .footer(format!("{}: {}", "ID", reminder_id))
             .send()
             .await;
     } else {
@@ -44,44 +51,65 @@ pub async fn send_register_confirmation(
             )
             .await
             .to_channel(msg.channel_id)
+            .footer(format!("{}: {}", "ID", reminder_id))
             .send()
             .await;
     }
 }
 
-pub async fn send_reminder_content(
-    reminder_content: &str,
-    ctx: &Context,
-    msg: &Message,
-    config: &Config,
-    trigger_timestamp: i64,
-) {
-    let mut params = HashMap::new();
-    params.insert("time".to_string(), format!("<t:{}:F>", trigger_timestamp));
-    params.insert(
-        "remaining_time".to_string(),
-        format!("<t:{}:R>", trigger_timestamp),
-    );
+pub fn spawn_reminder(reminder: &Reminder, ctx: &Context, config: &Config, pool: &SqlitePool) {
+    let pool = pool.clone();
+    let config = config.clone();
+    let ctx = ctx.clone();
+    let reminder = reminder.clone();
 
-    if !reminder_content.is_empty() {
-        params.insert("content".to_string(), reminder_content.to_string());
-    }
+    tokio::spawn(async move {
+        let now = Local::now().timestamp();
+        let delay_duration = if reminder.trigger_time > now {
+            reminder.trigger_time - now
+        } else {
+            0
+        };
+        sleep(Duration::from_secs(delay_duration as u64)).await;
 
-    if !reminder_content.is_empty() {
-        let _ = MessageBuilder::system_message(&ctx, &config)
-            .translated_content("reminder.show_with_content", Some(&params), None, None)
-            .await
-            .to_channel(msg.channel_id)
-            .color(hex_string_to_int(&config.reminders.embed_color) as u32)
-            .send()
-            .await;
-    } else {
-        let _ = MessageBuilder::system_message(&ctx, &config)
-            .translated_content("reminder.show_without_content", None, None, None)
-            .await
-            .to_channel(msg.channel_id)
-            .color(hex_string_to_int(&config.reminders.embed_color) as u32)
-            .send()
-            .await;
-    }
+        let mut params = HashMap::new();
+        params.insert(
+            "time".to_string(),
+            format!("<t:{}:F>", reminder.trigger_time),
+        );
+        params.insert(
+            "remaining_time".to_string(),
+            format!("<t:{}:R>", reminder.trigger_time),
+        );
+
+        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));
+
+        if !reminder.reminder_content.is_empty() {
+            let _ = MessageBuilder::system_message(&ctx, &config)
+                .translated_content("reminder.show_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)
+                .mention(mentions)
+                .send()
+                .await;
+        } else {
+            let _ = MessageBuilder::system_message(&ctx, &config)
+                .translated_content("reminder.show_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)
+                .mention(mentions)
+                .send()
+                .await;
+        }
+
+        if let Err(e) = update_reminder_status(&reminder, true, &pool).await {
+            eprintln!("Failed to update reminder status: {}", e);
+        }
+    });
 }
diff --git a/src/commands/add_reminder/text_command/add_reminder.rs b/src/commands/add_reminder/text_command/add_reminder.rs
@@ -1,14 +1,14 @@
-use crate::commands::add_reminder::common::{send_register_confirmation, send_reminder_content};
+use crate::commands::add_reminder::common::{send_register_confirmation, spawn_reminder};
 use crate::config::Config;
-use crate::db::reminders::{insert_reminder, update_reminder_status, Reminder};
+use crate::db::reminders::{insert_reminder, Reminder};
 use crate::db::threads::get_thread_by_user_id;
-use crate::errors::{common, CommandError, ModmailError, ModmailResult, ThreadError};
+use crate::errors::{
+    common, CommandError, DatabaseError, ModmailError, ModmailResult, ThreadError,
+};
 use crate::utils::command::extract_reply_content::extract_reply_content;
 use chrono::{Local, NaiveTime};
 use regex::Regex;
 use serenity::all::{Context, Message};
-use std::time::Duration;
-use tokio::time::sleep;
 
 pub async fn add_reminder(ctx: &Context, msg: &Message, config: &Config) -> ModmailResult<()> {
     let pool = config
@@ -76,36 +76,29 @@ pub async fn add_reminder(ctx: &Context, msg: &Message, config: &Config) -> Modm
         completed: false,
     };
 
-    if let Err(e) = insert_reminder(&reminder, pool).await {
-        eprintln!("Failed to insert reminder: {}", e);
-    }
+    let reminder_id = match insert_reminder(&reminder, pool).await {
+        Ok(id) => id,
+        Err(e) => {
+            eprintln!("Failed to insert reminder: {}", e);
+            return Err(ModmailError::Database(DatabaseError::InsertFailed(
+                e.to_string(),
+            )));
+        }
+    };
 
-    send_register_confirmation(reminder_content, ctx, msg, config, trigger_timestamp).await;
+    send_register_confirmation(
+        reminder_id,
+        reminder_content,
+        ctx,
+        msg,
+        config,
+        trigger_timestamp,
+    )
+    .await;
 
     let _ = msg.delete(&ctx.http).await;
 
-    let ctx = ctx.clone();
-    let config = config.clone();
-    let msg = msg.clone();
-    let reminder_content = reminder_content.to_string();
-    let pool = pool.clone();
-    let reminder = reminder.clone();
-
-    tokio::spawn(async move {
-        let now = Local::now().timestamp();
-        let delay_duration = if trigger_timestamp > now {
-            trigger_timestamp - now
-        } else {
-            0
-        };
-        sleep(Duration::from_secs(delay_duration as u64)).await;
-
-        send_reminder_content(&reminder_content, &ctx, &msg, &config, trigger_timestamp).await;
-
-        if let Err(e) = update_reminder_status(&reminder, true, &pool).await {
-            eprintln!("Failed to update reminder status: {}", e);
-        }
-    });
+    spawn_reminder(&reminder, &ctx, &config, &pool);
 
     Ok(())
 }
diff --git a/src/db/operations/reminders.rs b/src/db/operations/reminders.rs
@@ -13,12 +13,12 @@ pub struct Reminder {
 pub async fn insert_reminder(
     reminder: &Reminder,
     pool: &sqlx::SqlitePool,
-) -> Result<(), sqlx::Error> {
+) -> Result<i64, sqlx::Error> {
     let user_id = reminder.user_id;
     let channel_id = &reminder.channel_id;
     let guild_id = &reminder.guild_id;
 
-    sqlx::query!(
+    let result = sqlx::query!(
         r#"
         INSERT INTO reminders (thread_id, user_id, channel_id, guild_id, reminder_content, trigger_time, created_at, completed)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
@@ -34,7 +34,8 @@ pub async fn insert_reminder(
     )
     .execute(pool)
     .await?;
-    Ok(())
+
+    Ok(result.last_insert_rowid())
 }
 
 pub async fn update_reminder_status(
diff --git a/src/i18n/language/en.rs b/src/i18n/language/en.rs
@@ -725,10 +725,10 @@ pub fn load_english_messages(dict: &mut ErrorDictionary) {
     );
     dict.messages.insert(
         "reminder.show_with_content".to_string(),
-        DictionaryMessage::new("⏰ Reminder: \n\n{content} !"),
+        DictionaryMessage::new("⏰ Reminder <@{user}>: \n\n{content} !"),
     );
     dict.messages.insert(
         "reminder.show_without_content".to_string(),
-        DictionaryMessage::new("⏰ Reminder!"),
+        DictionaryMessage::new("⏰ Reminder <@{user}>!"),
     );
 }
diff --git a/src/i18n/language/fr.rs b/src/i18n/language/fr.rs
@@ -742,10 +742,10 @@ pub fn load_french_messages(dict: &mut ErrorDictionary) {
     );
     dict.messages.insert(
         "reminder.show_with_content".to_string(),
-        DictionaryMessage::new("⏰ Rappel : \n\n{content} !"),
+        DictionaryMessage::new("⏰ Rappel <@{user}> : \n\n{content} !"),
     );
     dict.messages.insert(
         "reminder.show_without_content".to_string(),
-        DictionaryMessage::new("⏰ Rappel !"),
+        DictionaryMessage::new("⏰ Rappel <@{user}> !"),
     );
 }
diff --git a/src/modules/reminders.rs b/src/modules/reminders.rs
@@ -1,12 +1,7 @@
+use crate::commands::add_reminder::common::spawn_reminder;
 use crate::config::Config;
-use crate::db::reminders::{get_all_pending_reminders, update_reminder_status};
-use crate::utils::conversion::hex_string_to_int::hex_string_to_int;
-use crate::utils::message::message_builder::MessageBuilder;
-use chrono::Local;
-use serenity::all::{ChannelId, Context};
-use std::collections::HashMap;
-use std::time::Duration;
-use tokio::time::sleep;
+use crate::db::reminders::get_all_pending_reminders;
+use serenity::all::Context;
 
 pub async fn load_reminders(ctx: &Context, config: &Config, pool: &sqlx::SqlitePool) {
     let reminders = get_all_pending_reminders(pool).await.unwrap_or_else(|e| {
@@ -15,47 +10,7 @@ pub async fn load_reminders(ctx: &Context, config: &Config, pool: &sqlx::SqliteP
     });
 
     for reminder in reminders {
-        let pool = pool.clone();
-        let config = config.clone();
-        let ctx = ctx.clone();
-
-        tokio::spawn(async move {
-            let now = Local::now().timestamp();
-            let delay_duration = if reminder.trigger_time > now {
-                reminder.trigger_time - now
-            } else {
-                0
-            };
-
-            sleep(Duration::from_secs(delay_duration as u64)).await;
-
-            let channel_id = ChannelId::new(reminder.channel_id as u64);
-
-            let mut params = HashMap::new();
-            params.insert("content".to_string(), reminder.reminder_content.clone());
-
-            if !reminder.reminder_content.is_empty() {
-                let _ = MessageBuilder::system_message(&ctx, &config)
-                    .translated_content("reminder.show_with_content", Some(&params), None, None)
-                    .await
-                    .to_channel(channel_id)
-                    .color(hex_string_to_int(&config.reminders.embed_color) as u32)
-                    .send()
-                    .await;
-            } else {
-                let _ = MessageBuilder::system_message(&ctx, &config)
-                    .translated_content("reminder.show_without_content", None, None, None)
-                    .await
-                    .to_channel(channel_id)
-                    .color(hex_string_to_int(&config.reminders.embed_color) as u32)
-                    .send()
-                    .await;
-            }
-
-            if let Err(e) = update_reminder_status(&reminder, true, &pool).await {
-                eprintln!("Failed to update reminder status: {}", e);
-            }
-        });
+        spawn_reminder(&reminder, &ctx, &config, &pool);
     }
     println!("All pending reminders have been scheduled.");
 }
diff --git a/src/utils/message/message_builder.rs b/src/utils/message/message_builder.rs
@@ -51,6 +51,7 @@ pub struct MessageBuilder<'a> {
     bot_user_id: UserId,
     components: Option<Vec<CreateActionRow>>,
     ephemeral: bool,
+    mention: Vec<UserId>,
 }
 
 impl<'a> MessageBuilder<'a> {
@@ -69,6 +70,7 @@ impl<'a> MessageBuilder<'a> {
             bot_user_id,
             components: None,
             ephemeral: false,
+            mention: Vec::<UserId>::new(),
         }
     }
 
@@ -124,6 +126,11 @@ impl<'a> MessageBuilder<'a> {
         self
     }
 
+    pub fn mention(mut self, mention: Vec<UserId>) -> Self {
+        self.mention.extend(mention);
+        self
+    }
+
     pub fn ephemeral(mut self, ephemeral: bool) -> Self {
         if ephemeral {
             self.ephemeral = ephemeral;
@@ -434,6 +441,13 @@ impl<'a> MessageBuilder<'a> {
 
         if self.should_use_embed().await {
             message = message.embed(self.build_embed().await);
+
+            if !self.mention.is_empty() {
+                let mentions: Vec<String> =
+                    self.mention.iter().map(|id| format!("<@{}>", id)).collect();
+                let mention_str = mentions.join(" ");
+                message = message.content(mention_str);
+            }
         } else {
             let content = self.build_plain_message();
             if !content.is_empty() {
diff --git a/src/utils/thread/send_to_thread.rs b/src/utils/thread/send_to_thread.rs
@@ -4,7 +4,7 @@ use crate::db::operations::{
 };
 use crate::i18n::get_translated_message;
 use crate::utils::message::message_builder::MessageBuilder;
-use serenity::all::{ChannelId, Context, CreateAttachment, GuildId, Message};
+use serenity::all::{ChannelId, Context, CreateAttachment, GuildId, Message, UserId};
 use std::collections::HashMap;
 
 fn extract_message_content_with_media(msg: &Message) -> (String, Vec<String>) {
@@ -146,8 +146,10 @@ pub async fn send_to_thread(
         && !alerts.is_empty()
     {
         let mut ping_mentions = String::new();
+        let mut mentions = Vec::<UserId>::new();
         for staff_id in &alerts {
             ping_mentions.push_str(&format!("<@{}> ", staff_id));
+            mentions.push(UserId::new(*staff_id as u64));
         }
 
         let mut params = HashMap::new();
@@ -166,6 +168,7 @@ pub async fn send_to_thread(
 
         let _ = MessageBuilder::system_message(ctx, config)
             .content(full_content)
+            .mention(mentions)
             .to_channel(channel_id)
             .send()
             .await;
