Merge pull request #175 from Rustmail/173-add-remove_reminder-command

feat(commands): add remove_reminder command

Author: Akinator31

.sqlx/query-0f04c6745dd5b1b1a1f1cc69952147d37c06cfa802ce579377d87462192fca87.json

@@ -1,5 +1,5 @@
 use crate::config::Config;
-use crate::db::reminders::{Reminder, update_reminder_status};
+use crate::db::reminders::{Reminder, is_reminder_active, 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;
@@ -109,7 +109,13 @@ pub async fn send_register_confirmation_from_command(
     }
 }
 
-pub fn spawn_reminder(reminder: &Reminder, ctx: &Context, config: &Config, pool: &SqlitePool) {
+pub fn spawn_reminder(
+    reminder: &Reminder,
+    reminder_id: Option<i64>,
+    ctx: &Context,
+    config: &Config,
+    pool: &SqlitePool,
+) {
     let pool = pool.clone();
     let config = config.clone();
     let ctx = ctx.clone();
@@ -124,6 +130,20 @@ pub fn spawn_reminder(reminder: &Reminder, ctx: &Context, config: &Config, pool:
         };
         sleep(Duration::from_secs(delay_duration as u64)).await;
 
+        if let Some(reminder_id) = reminder_id {
+            match is_reminder_active(reminder_id, &pool).await {
+                Ok(active) => {
+                    if !active {
+                        return;
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Failed to check reminder status: {}", e);
+                    return;
+                }
+            }
+        }
+
         let mut params = HashMap::new();
         params.insert(
             "time".to_string(),

.sqlx/query-8c1812a53a9a92d31b6b692a0c9983b12d0c46835fe8deb108c846324557be09.json

@@ -199,7 +199,7 @@ impl RegistrableCommand for AddReminderCommand {
             )
             .await;
 
-            spawn_reminder(&reminder, &ctx, &config, &pool);
+            spawn_reminder(&reminder, Some(reminder_id), &ctx, &config, &pool);
 
             Ok(())
         })

src/commands/add_reminder/common.rs

@@ -100,7 +100,7 @@ pub async fn add_reminder(ctx: &Context, msg: &Message, config: &Config) -> Modm
 
     let _ = msg.delete(&ctx.http).await;
 
-    spawn_reminder(&reminder, &ctx, &config, &pool);
+    spawn_reminder(&reminder, Some(reminder_id), &ctx, &config, &pool);
 
     Ok(())
 }

src/commands/add_reminder/slash_command/add_reminder.rs

@@ -18,6 +18,7 @@ pub mod id;
 pub mod move_thread;
 pub mod new_thread;
 pub mod recover;
+pub mod remove_reminder;
 pub mod remove_staff;
 pub mod reply;
 

src/commands/add_reminder/text_command/add_reminder.rs

@@ -0,0 +1,2 @@
+pub mod slash_command;
+pub mod text_command;

src/commands/mod.rs

@@ -0,0 +1 @@
+pub mod remove_reminder;

src/commands/remove_reminder/mod.rs

@@ -0,0 +1,135 @@
+use crate::commands::{BoxFuture, RegistrableCommand};
+use crate::config::Config;
+use crate::db::reminders::{get_reminder_by_id, update_reminder_status};
+use crate::errors::{CommandError, DatabaseError, ModmailError, ModmailResult, common};
+use crate::i18n::get_translated_message;
+use crate::utils::command::defer_response::defer_response;
+use crate::utils::message::message_builder::MessageBuilder;
+use serenity::all::{
+    CommandDataOptionValue, CommandInteraction, CommandOptionType, Context, CreateCommand,
+    CreateCommandOption, ResolvedOption,
+};
+use std::collections::HashMap;
+
+pub struct RemoveReminderCommand;
+
+impl RegistrableCommand for RemoveReminderCommand {
+    fn name(&self) -> &'static str {
+        "remove_reminder"
+    }
+
+    fn register(&self, config: &Config) -> BoxFuture<Vec<CreateCommand>> {
+        let config = config.clone();
+        let name = self.name();
+
+        Box::pin(async move {
+            let cmd_desc = get_translated_message(
+                &config,
+                "slash_command.remove_reminder_command_description",
+                None,
+                None,
+                None,
+                None,
+            )
+            .await;
+            let id_desc = get_translated_message(
+                &config,
+                "slash_command.remove_reminder_id_argument",
+                None,
+                None,
+                None,
+                None,
+            )
+            .await;
+
+            vec![CreateCommand::new(name).description(cmd_desc).add_option(
+                CreateCommandOption::new(CommandOptionType::Number, "id", id_desc).required(true),
+            )]
+        })
+    }
+
+    fn run(
+        &self,
+        ctx: &Context,
+        command: &CommandInteraction,
+        options: &[ResolvedOption<'_>],
+        config: &Config,
+    ) -> BoxFuture<ModmailResult<()>> {
+        let ctx = ctx.clone();
+        let command = command.clone();
+        let config = config.clone();
+
+        Box::pin(async move {
+            let pool = config
+                .db_pool
+                .as_ref()
+                .ok_or_else(common::database_connection_failed)?;
+
+            let _ = defer_response(&ctx, &command).await;
+
+            let mut reminder_id: Option<i64> = None;
+
+            for option in &command.data.options {
+                match option.name.as_str() {
+                    "id" => {
+                        if let CommandDataOptionValue::Number(val) = &option.value {
+                            reminder_id.replace(*val as i64);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            let reminder_id = match reminder_id {
+                Some(id) => id,
+                None => {
+                    return Err(ModmailError::Command(CommandError::InvalidArguments(
+                        "reminder ID".to_string(),
+                    )));
+                }
+            };
+
+            let reminder = match get_reminder_by_id(reminder_id, pool).await {
+                Ok(Some(r)) => r,
+                Ok(None) => {
+                    return Err(ModmailError::Database(DatabaseError::NotFound(
+                        "".to_string(),
+                    )));
+                }
+                Err(e) => {
+                    return Err(ModmailError::Database(DatabaseError::QueryFailed(
+                        e.to_string(),
+                    )));
+                }
+            };
+
+            match update_reminder_status(&reminder, true, pool).await {
+                Ok(_) => {
+                    let mut params = HashMap::new();
+                    params.insert("id".to_string(), reminder_id.to_string());
+
+                    let response = MessageBuilder::system_message(&ctx, &config)
+                        .translated_content(
+                            "remove_reminder.confirmation",
+                            Some(&params),
+                            None,
+                            None,
+                        )
+                        .await
+                        .to_channel(command.channel_id)
+                        .build_interaction_message_followup()
+                        .await;
+
+                    let _ = command.create_followup(&ctx.http, response).await;
+                }
+                Err(e) => {
+                    return Err(ModmailError::Database(DatabaseError::QueryFailed(
+                        e.to_string(),
+                    )));
+                }
+            }
+
+            Ok(())
+        })
+    }
+}

src/commands/remove_reminder/slash_command/mod.rs

@@ -0,0 +1 @@
+pub mod remove_reminder;