feat(status): add bases for ticket status updates

Author: Akinator31

Cargo.lock

@@ -1,3 +1,3 @@
 [workspace]
 members = ["rustmail", "rustmail_panel"]
-resolver = "3"
+resolver = "3"

Cargo.toml

@@ -0,0 +1,11 @@
+-- Add migration script here
+CREATE TABLE IF NOT EXISTS "thread_status" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+    "thread_id" TEXT NOT NULL UNIQUE,
+    "channel_id" INTEGER NOT NULL UNIQUE,
+    "owner_id" TEXT NOT NULL,
+    "taken_by" TEXT DEFAULT NULL,
+    "last_message_by" TEXT NOT NULL,
+    "last_message_at" INTEGER NOT NULL,
+    CONSTRAINT "thread_status_thread_id_fkey" FOREIGN KEY ("thread_id") REFERENCES "threads" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);

migrations/20251030075606_thread_status.sql

@@ -25,6 +25,7 @@ rand = "0.8.5"
 base64 = "0.22.1"
 subtle = "2.6.1"
 chrono-tz = "0.10.4"
+console-subscriber = "0.4.1"
 
 [dependencies.uuid]
 version = "1.18.1"

rustmail/Cargo.toml

@@ -3,6 +3,8 @@ use crate::prelude::db::*;
 use crate::prelude::errors::*;
 use crate::prelude::handlers::*;
 use crate::prelude::utils::*;
+use crate::types::TicketAuthor;
+use chrono::Utc;
 use serenity::all::{Context, GuildId, Message, UserId};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -66,6 +68,17 @@ pub async fn anonreply(
         .await
         .map_err(|_| validation_failed("Failed to allocate message number"))?;
 
+    let mut ticket_status = match get_thread_status(&thread.id, db_pool).await {
+        Some(status) => status,
+        None => {
+            return Err(validation_failed("Failed to get thread status"));
+        }
+    };
+
+    ticket_status.last_message_by = TicketAuthor::Staff;
+    ticket_status.last_message_at = Utc::now().timestamp();
+    update_thread_status(&thread.id, &ticket_status, db_pool).await?;
+
     let _ = msg.delete(&ctx.http).await;
 
     let mut sr = MessageBuilder::begin_staff_reply(

rustmail/src/commands/anonreply/text_command/anonreply.rs

@@ -4,7 +4,9 @@ use crate::prelude::db::*;
 use crate::prelude::errors::*;
 use crate::prelude::handlers::*;
 use crate::prelude::i18n::*;
+use crate::prelude::types::*;
 use crate::prelude::utils::*;
+use chrono::Utc;
 use serenity::FutureExt;
 use serenity::all::{
     Attachment, CommandDataOptionValue, CommandInteraction, CommandOptionType, Context,
@@ -155,6 +157,17 @@ impl RegistrableCommand for ReplyCommand {
                 .await
                 .map_err(|_| validation_failed("Failed to allocate message number"))?;
 
+            let mut ticket_status = match get_thread_status(&thread.id, db_pool).await {
+                Some(status) => status,
+                None => {
+                    return Err(validation_failed("Failed to get thread status"));
+                }
+            };
+
+            ticket_status.last_message_by = TicketAuthor::Staff;
+            ticket_status.last_message_at = Utc::now().timestamp();
+            update_thread_status(&thread.id, &ticket_status, db_pool).await?;
+
             let mut sr = MessageBuilder::begin_staff_reply(
                 &ctx,
                 &config,

rustmail/src/commands/reply/slash_command/reply.rs

@@ -2,7 +2,9 @@ use crate::prelude::config::*;
 use crate::prelude::db::*;
 use crate::prelude::errors::*;
 use crate::prelude::handlers::*;
+use crate::prelude::types::*;
 use crate::prelude::utils::*;
+use chrono::Utc;
 use serenity::all::{Context, GuildId, Message, UserId};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -38,6 +40,17 @@ pub async fn reply(
         .await
         .map_err(|_| validation_failed("Failed to allocate message number"))?;
 
+    let mut ticket_status = match get_thread_status(&thread.id, db_pool).await {
+        Some(status) => status,
+        None => {
+            return Err(validation_failed("Failed to get thread status"));
+        }
+    };
+
+    ticket_status.last_message_by = TicketAuthor::Staff;
+    ticket_status.last_message_at = Utc::now().timestamp();
+    update_thread_status(&thread.id, &ticket_status, db_pool).await?;
+
     let _ = msg.delete(&ctx.http).await;
 
     let mut sr = MessageBuilder::begin_staff_reply(

rustmail/src/commands/reply/text_command/reply.rs

@@ -1,5 +1,6 @@
 use crate::prelude::db::*;
 use crate::prelude::errors::*;
+use crate::prelude::types::*;
 use chrono::Utc;
 use serenity::all::{ChannelId, GuildChannel, UserId};
 use sqlx::{Error, SqlitePool};
@@ -116,17 +117,17 @@ pub async fn create_thread_for_user(
     let channel_id = channel.id.to_string();
     let thread_id = Uuid::new_v4().to_string();
 
-    match sqlx::query!(
+    let res = match sqlx::query!(
         "INSERT INTO threads (id, user_id, user_name, channel_id) VALUES (?, ?, ?, ?)",
         thread_id,
         user_id,
         user_name,
         channel_id
     )
-    .execute(pool)
+    .execute(&pool.clone())
     .await
     {
-        Ok(_) => Ok(thread_id),
+        Ok(_) => Ok(thread_id.clone()),
         Err(Error::Database(db_err))
             if db_err.code() == Some(std::borrow::Cow::Borrowed("2067")) =>
         {
@@ -142,7 +143,43 @@ pub async fn create_thread_for_user(
             }
         }
         Err(e) => Err(e),
-    }
+    };
+
+    let channel_id = channel.id.get() as i64;
+    let user_id_str = user_id.to_string();
+    let timestamp = Utc::now().timestamp();
+
+    let _ = match sqlx::query!(
+        "INSERT INTO thread_status (thread_id, channel_id, owner_id, taken_by, last_message_by, last_message_at) VALUES (?, ?, ?, ?, ?, ?)",
+        thread_id,
+        channel_id,
+        user_id_str,
+        None::<String>,
+        "user",
+        timestamp
+    )
+        .execute(&pool.clone())
+        .await
+    {
+        Ok(_) => Ok(thread_id),
+        Err(Error::Database(db_err))
+        if db_err.code() == Some(std::borrow::Cow::Borrowed("2067")) =>
+            {
+                if let Some(existing_thread_id) =
+                    sqlx::query_scalar("SELECT id FROM threads WHERE user_id = ? AND status = 1")
+                        .bind(user_id)
+                        .fetch_optional(pool)
+                        .await?
+                {
+                    Ok(existing_thread_id)
+                } else {
+                    Err(Error::Database(db_err))
+                }
+            }
+        Err(e) => Err(e),
+    };
+
+    res
 }
 
 pub async fn close_thread(
@@ -379,3 +416,97 @@ pub async fn is_orphaned_thread_channel(
 
     Ok(exists)
 }
+
+pub async fn get_all_thread_status(pool: &SqlitePool) -> Vec<TicketState> {
+    match sqlx::query!(
+        r#"
+        SELECT channel_id, owner_id, taken_by, last_message_by, last_message_at
+        FROM thread_status
+        "#
+    )
+    .fetch_all(pool)
+    .await
+    {
+        Ok(rows) => rows
+            .into_iter()
+            .map(|r| TicketState {
+                channel_id: r.channel_id,
+                owner_id: r.owner_id,
+                taken_by: r.taken_by,
+                last_message_by: TicketAuthor::from_str(&r.last_message_by),
+                last_message_at: r.last_message_at,
+            })
+            .collect(),
+        Err(e) => {
+            eprintln!("Database error getting thread statuses: {:?}", e);
+            vec![]
+        }
+    }
+}
+
+pub async fn get_thread_status(thread_id: &str, pool: &SqlitePool) -> Option<TicketState> {
+    match sqlx::query!(
+        r#"
+        SELECT
+            channel_id,
+            owner_id,
+            taken_by,
+            last_message_by,
+            last_message_at
+        FROM thread_status
+        WHERE thread_id = ?
+        "#,
+        thread_id
+    )
+    .fetch_optional(pool)
+    .await
+    {
+        Ok(Some(row)) => Some(TicketState {
+            channel_id: row.channel_id,
+            owner_id: row.owner_id,
+            taken_by: row.taken_by,
+            last_message_by: TicketAuthor::from_str(&row.last_message_by),
+            last_message_at: row.last_message_at,
+        }),
+        Ok(None) => None,
+        Err(e) => {
+            eprintln!(
+                "⚠️ Database error getting thread status for id {}: {:?}",
+                thread_id, e
+            );
+            None
+        }
+    }
+}
+
+pub async fn update_thread_status(
+    thread_id: &str,
+    ticket: &TicketState,
+    pool: &SqlitePool,
+) -> ModmailResult<()> {
+    let last_message_by = format!("{:?}", ticket.last_message_by).to_lowercase();
+
+    println!(
+        "Updating thread status for thread_id {}: taken_by={:?}, last_message_by={}, last_message_at={}",
+        thread_id, ticket.taken_by, last_message_by, ticket.last_message_at
+    );
+
+    sqlx::query!(
+        r#"
+        UPDATE thread_status
+        SET
+            taken_by = ?,
+            last_message_by = ?,
+            last_message_at = ?
+        WHERE thread_id = ?
+        "#,
+        ticket.taken_by,
+        last_message_by,
+        ticket.last_message_at,
+        thread_id
+    )
+    .execute(pool)
+    .await?;
+
+    Ok(())
+}

rustmail/src/db/operations/threads.rs

@@ -1,14 +1,19 @@
+use crate::db::get_all_thread_status;
 use crate::prelude::commands::*;
 use crate::prelude::config::*;
 use crate::prelude::features::*;
 use crate::prelude::modules::*;
 use serenity::all::{ActivityData, CreateCommand, GuildId};
+use serenity::futures::future::join_all;
 use serenity::{
     all::{Context, EventHandler, Ready},
     async_trait,
 };
+use sqlx::SqlitePool;
 use std::sync::Arc;
+use std::time::Duration;
 use tokio::sync::watch::Receiver;
+use tokio::time::interval;
 
 #[derive(Clone)]
 pub struct ReadyHandler {
@@ -39,11 +44,14 @@ impl EventHandler for ReadyHandler {
             }
         };
 
+        let config = self.config.clone();
+
         ctx.set_activity(Option::from(ActivityData::playing(&self.config.bot.status)));
 
         tokio::spawn({
             let ctx = ctx.clone();
-            let config = self.config.clone();
+            let config = config.clone();
+
             async move {
                 let recovery_results = recover_missing_messages(&ctx, &config).await;
                 send_recovery_summary(&ctx, &config, &recovery_results).await;
@@ -52,7 +60,9 @@ impl EventHandler for ReadyHandler {
             }
         });
 
-        load_reminders(&ctx, &self.config, pool, self.shutdown.clone()).await;
+        load_reminders(&ctx, &self.config, &pool.clone(), self.shutdown.clone()).await;
+
+        update_threads_status(&ctx, &pool.clone());
 
         let guild_id = GuildId::new(self.config.bot.get_staff_guild_id());
         let guild_id2 = GuildId::new(self.config.bot.get_community_guild_id());
@@ -82,3 +92,40 @@ impl EventHandler for ReadyHandler {
         }
     }
 }
+
+fn update_threads_status(ctx: &Context, pool: &SqlitePool) {
+    tokio::spawn({
+        let ctx = ctx.clone();
+        let pool = pool.clone();
+
+        async move {
+            let mut interval = interval(Duration::from_secs(60 * 10));
+
+            loop {
+                let tickets_status = get_all_thread_status(&pool).await;
+
+                let mut handles = Vec::new();
+                for ticket in tickets_status.iter() {
+                    let ctx = ctx.clone();
+                    let ticket = ticket.clone();
+                    let handle = tokio::spawn(async move {
+                        println!("Update");
+                        if let Err(e) = update_thread_status(&ctx, &ticket).await {
+                            eprintln!(
+                                "Failed to update thread status for channel {}: {:?}",
+                                ticket.channel_id, e
+                            );
+                        }
+                    });
+                    handles.push(handle);
+                }
+
+                join_all(handles).await;
+
+                println!("Updated {} ticket statuses", tickets_status.len());
+
+                interval.tick().await;
+            }
+        }
+    });
+}

rustmail/src/handlers/ready_handler.rs

@@ -3,9 +3,11 @@ pub mod message_recovery;
 pub mod reminders;
 pub mod scheduled_closures;
 pub mod threads;
+pub mod threads_status;
 
 pub use commands::*;
 pub use message_recovery::*;
 pub use reminders::*;
 pub use scheduled_closures::*;
 pub use threads::*;
+pub use threads_status::*;