fix: address category review feedback across API, commands, flow, and panel

Agent-Logs-Url: https://github.com/Rustmail/rustmail/sessions/7f12ccf8-887b-4e84-8b8f-9f4629b1f1a4

Co-authored-by: Akinator31 <99099121+Akinator31@users.noreply.github.com>

Author: Copilot

crates/rustmail/src/api/handler/categories/categories.rs

@@ -78,7 +78,8 @@ pub async fn create_category_handler(
     State(bot_state): State<Arc<Mutex<BotState>>>,
     Json(req): Json<CreateCategoryRequest>,
 ) -> Result<Json<CategoryDto>, (StatusCode, String)> {
-    if req.name.trim().is_empty() {
+    let name = req.name.trim();
+    if name.is_empty() {
         return Err((StatusCode::BAD_REQUEST, "Name required".to_string()));
     }
     if req.discord_category_id.parse::<u64>().is_err() {
@@ -97,15 +98,19 @@ pub async fn create_category_handler(
         ));
     }
 
-    if let Ok(Some(_)) = get_category_by_name(&req.name, &p).await {
+    if get_category_by_name(name, &p)
+        .await
+        .map_err(internal)?
+        .is_some()
+    {
         return Err((
             StatusCode::CONFLICT,
             "Category with this name already exists".to_string(),
         ));
     }
 
     let created = create_category(
-        &req.name,
+        name,
         req.description.as_deref(),
         req.emoji.as_deref(),
         &req.discord_category_id,
@@ -138,6 +143,22 @@ pub async fn update_category_handler(
         .map_err(internal)?
         .ok_or((StatusCode::NOT_FOUND, "Category not found".to_string()))?;
 
+    let trimmed_name = req.name.as_deref().map(str::trim);
+    if let Some(name) = trimmed_name {
+        if name.is_empty() {
+            return Err((StatusCode::BAD_REQUEST, "Name required".to_string()));
+        }
+
+        if let Some(conflict) = get_category_by_name(name, &p).await.map_err(internal)? {
+            if conflict.id != existing.id {
+                return Err((
+                    StatusCode::CONFLICT,
+                    "Category with this name already exists".to_string(),
+                ));
+            }
+        }
+    }
+
     if let Some(true) = req.enabled {
         if !existing.enabled {
             let enabled_count = count_enabled_categories(&p).await.map_err(internal)?;
@@ -161,7 +182,7 @@ pub async fn update_category_handler(
 
     update_category(
         &id,
-        req.name.as_deref(),
+        trimmed_name,
         req.description.as_ref().map(|o| o.as_deref()),
         req.emoji.as_ref().map(|o| o.as_deref()),
         req.discord_category_id.as_deref(),

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

@@ -441,10 +441,19 @@ async fn sub_rename(
         Some(v) => v,
         None => return reply(ctx, command, config, "category.text_usage", None).await,
     };
+    let new = new.trim().to_string();
+    if new.is_empty() {
+        return reply(ctx, command, config, "category.text_usage", None).await;
+    }
     let cat = match get_category_by_name(&old, pool).await? {
         Some(c) => c,
         None => return reply(ctx, command, config, "category.not_found", None).await,
     };
+    if let Some(existing) = get_category_by_name(&new, pool).await? {
+        if existing.id != cat.id {
+            return reply(ctx, command, config, "category.already_exists", None).await;
+        }
+    }
     update_category(&cat.id, Some(&new), None, None, None, None, None, pool).await?;
     let mut params = HashMap::new();
     params.insert("name".to_string(), new);

crates/rustmail/src/commands/category/text_command/category.rs

@@ -211,6 +211,11 @@ async fn handle_rename(
         Some(c) => c,
         None => return send_translated(ctx, config, msg, "category.not_found", None).await,
     };
+    if let Some(existing) = get_category_by_name(new, pool).await? {
+        if existing.id != cat.id {
+            return send_translated(ctx, config, msg, "category.already_exists", None).await;
+        }
+    }
     update_category(&cat.id, Some(new), None, None, None, None, None, pool).await?;
     let mut params = HashMap::new();
     params.insert("name".to_string(), new.to_string());

crates/rustmail/src/db/operations/ticket_categories.rs

@@ -151,7 +151,7 @@ pub async fn get_category_by_name(
         SELECT id, name, description, emoji, discord_category_id,
                position, enabled, created_at, updated_at
         FROM ticket_categories
-        WHERE name = ?
+        WHERE name = ? COLLATE NOCASE
         LIMIT 1
         "#,
     )

crates/rustmail/src/modules/categories.rs

@@ -72,8 +72,18 @@ pub async fn maybe_start_category_selection(ctx: &Context, config: &Config, msg:
     }
 
     if let Ok(Some(_)) = get_pending_selection(msg.author.id.get() as i64, pool).await {
-        let _ = append_queued_message(msg.author.id.get() as i64, &msg.id.to_string(), pool).await;
-        return true;
+        match append_queued_message(msg.author.id.get() as i64, &msg.id.to_string(), pool).await {
+            Ok(_) => return true,
+            Err(err) => {
+                eprintln!(
+                    "failed to append queued message for user {} and message {}: {}",
+                    msg.author.id.get(),
+                    msg.id,
+                    err
+                );
+                return false;
+            }
+        }
     }
 
     let categories = match list_enabled_categories(pool).await {
@@ -196,22 +206,15 @@ pub async fn finalize_with_category(
         None => return Ok(()),
     };
 
-    if !delete_pending_selection(user_id, pool)
-        .await
-        .unwrap_or(false)
-    {
-        return Ok(());
-    }
-
     let user = UserId::new(user_id as u64);
 
     let (discord_override, ticket_cat_id) = if let Some(id) = category_id {
         match get_category_by_id(id, pool).await? {
-            Some(cat) => {
+            Some(cat) if cat.enabled => {
                 let parent = cat.discord_category_id.parse::<u64>().ok();
                 (parent, Some(cat.id.clone()))
             }
-            None => (None, None),
+            Some(_) | None => (None, None),
         }
     } else {
         (None, None)
@@ -237,6 +240,10 @@ pub async fn finalize_with_category(
         }
     }
 
+    if !delete_pending_selection(user_id, pool).await? {
+        return Err("Failed to clear pending selection".into());
+    }
+
     Ok(())
 }
 

crates/rustmail/src/modules/threads.rs

@@ -43,16 +43,16 @@ pub async fn create_or_get_thread_for_user(
         .create_channel(&ctx.http, channel_builder)
         .await?;
 
-    let _ = create_thread_for_user(&channel, user_id.get() as i64, &username, pool)
+    let thread_id = create_thread_for_user(&channel, user_id.get() as i64, &username, pool)
         .await
         .map_err(|e| {
             eprintln!("Error creating thread: {}", e);
             e
         })?;
 
     if let Some(cat_id) = ticket_category_id {
-        if let Some(thread) = get_thread_by_channel_id(&channel.id.to_string(), pool).await {
-            let _ = set_thread_category(&thread.id, Some(cat_id), pool).await;
+        if let Err(e) = set_thread_category(&thread_id, Some(cat_id), pool).await {
+            eprintln!("Failed to set thread category for thread {thread_id}: {e}");
         }
     }
 

crates/rustmail_panel/src/components/categories.rs

@@ -42,20 +42,34 @@ struct UpdateCategoryRequest {
     enabled: Option<bool>,
 }
 
-async fn fetch_categories() -> Option<Vec<CategoryDto>> {
-    let resp = Request::get("/api/categories").send().await.ok()?;
+async fn fetch_categories() -> Result<Vec<CategoryDto>, String> {
+    let resp = Request::get("/api/categories")
+        .send()
+        .await
+        .map_err(|e| e.to_string())?;
     if resp.status() != 200 {
-        return None;
+        let status = resp.status();
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("HTTP {}: {}", status, body));
     }
-    resp.json::<Vec<CategoryDto>>().await.ok()
+    resp.json::<Vec<CategoryDto>>()
+        .await
+        .map_err(|e| e.to_string())
 }
 
-async fn fetch_settings() -> Option<CategorySettingsDto> {
-    let resp = Request::get("/api/categories/settings").send().await.ok()?;
+async fn fetch_settings() -> Result<CategorySettingsDto, String> {
+    let resp = Request::get("/api/categories/settings")
+        .send()
+        .await
+        .map_err(|e| e.to_string())?;
     if resp.status() != 200 {
-        return None;
+        let status = resp.status();
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("HTTP {}: {}", status, body));
     }
-    resp.json::<CategorySettingsDto>().await.ok()
+    resp.json::<CategorySettingsDto>()
+        .await
+        .map_err(|e| e.to_string())
 }
 
 #[function_component(CategoriesPage)]
@@ -102,22 +116,28 @@ pub fn categories_page() -> Html {
         let settings = settings.clone();
         let loading = loading.clone();
         let error = error.clone();
+        let i18n = i18n.clone();
         Callback::from(move |_| {
             let categories = categories.clone();
             let settings = settings.clone();
             let loading = loading.clone();
             let error = error.clone();
+            let i18n = i18n.clone();
             spawn_local(async move {
                 loading.set(true);
                 let cats = fetch_categories().await;
                 let s = fetch_settings().await;
                 match (cats, s) {
-                    (Some(c), Some(s)) => {
+                    (Ok(c), Ok(s)) => {
                         categories.set(c);
                         settings.set(Some(s));
                         error.set(None);
                     }
-                    _ => error.set(Some("Failed to load".to_string())),
+                    (Err(e), _) | (_, Err(e)) => error.set(Some(format!(
+                        "{}: {}",
+                        i18n.t("panel.categories.error_load"),
+                        e
+                    ))),
                 }
                 loading.set(false);
             });

crates/rustmail_panel/src/i18n/en/en.json

@@ -288,6 +288,7 @@
       "discord_category_id": "Discord Category ID",
       "error_name_required": "Name is required",
       "error_discord_id_required": "Discord category ID is required",
+      "error_load": "Failed to load categories",
       "error_create": "Failed to create category",
       "modal": {
         "title": "Create Category",

migrations/20260413120000_ticket_categories.sql

@@ -12,6 +12,9 @@ CREATE TABLE IF NOT EXISTS ticket_categories (
     updated_at          INTEGER NOT NULL
 );
 
+CREATE UNIQUE INDEX IF NOT EXISTS idx_ticket_categories_name_unique
+    ON ticket_categories(name COLLATE NOCASE);
+
 CREATE INDEX IF NOT EXISTS idx_ticket_categories_enabled
     ON ticket_categories(enabled, position);