refactor(chatroom): 重构用户名补全功能，优化相关结构和逻辑

Author: KwdeTfpv

client/src/app.rs

@@ -4,7 +4,7 @@ use fishpi_rust::FishPi;
 use std::sync::Arc;
 
 use crate::commands::{CommandContext, CommandRegistry};
-use crate::ui::CrosstermInputHandler;
+use crate::ui::{CrosstermInputHandler, GLOBAL_COMMAND_CONTEXT};
 use crate::utils::AuthService;
 
 pub struct App {
@@ -161,6 +161,7 @@ impl App {
 
     async fn main_loop(&mut self) -> Result<()> {
         let context = CommandContext::new((*self.client).clone());
+        GLOBAL_COMMAND_CONTEXT.set(context.clone()).ok();
 
         loop {
             match self

client/src/commands/handlers/chatroom.rs

@@ -18,15 +18,14 @@ use crossterm::{
     cursor, execute,
     terminal::{Clear, ClearType},
 };
-use fishpi_rust::{ChatRoomDataContent, ChatRoomMessage, ChatRoomUser, GestureType, RedPacketType};
+use fishpi_rust::{ChatRoomDataContent, ChatRoomMessage, GestureType, RedPacketType};
 use lru::LruCache;
 use std::borrow::Cow;
 use std::io::{self, Write};
 use std::sync::{Arc, Mutex};
 
 pub struct ChatroomCommand {
     context: CommandContext,
-    online_users: Arc<Mutex<Vec<ChatRoomUser>>>,
     redpacket_handler: RedpacketCommand,
     filter_handler: FilterCommand,
     message_cache: Arc<Mutex<LruCache<String, ChatRoomMessage>>>,
@@ -36,7 +35,6 @@ impl ChatroomCommand {
     pub fn new(context: CommandContext) -> Self {
         Self {
             context: context.clone(),
-            online_users: Arc::new(Mutex::new(vec![])),
             redpacket_handler: RedpacketCommand::new(context),
             filter_handler: FilterCommand::new(),
             message_cache: Arc::new(Mutex::new(LruCache::new(
@@ -89,10 +87,7 @@ impl Command for ChatroomCommand {
 
 impl ChatroomCommand {
     async fn chatroom_loop(&self) -> Result<()> {
-        let completer = CommandCompleter {
-            commands: vec![],
-            users: Arc::clone(&self.online_users),
-        };
+        let completer = CommandCompleter { commands: vec![] };
         let mut input_handler = CrosstermInputHandler::with_completer(completer);
         input_handler.set_commands(vec![
             CommandItem {
@@ -197,7 +192,10 @@ impl ChatroomCommand {
                             let stats = crate::utils::GESTURE_STATS.lock().unwrap();
                             let total: u64 = stats.iter().sum();
                             if total == 0 {
-                                println!("石头: {}, 剪刀: {}, 布: {}，总数: 0", stats[0], stats[1], stats[2]);
+                                println!(
+                                    "石头: {}, 剪刀: {}, 布: {}，总数: 0",
+                                    stats[0], stats[1], stats[2]
+                                );
                             } else {
                                 let rock_pct = stats[0] as f64 / total as f64 * 100.0;
                                 let scissors_pct = stats[1] as f64 / total as f64 * 100.0;
@@ -335,7 +333,6 @@ impl ChatroomCommand {
     }
 
     async fn register_message_handler(&self) -> Result<()> {
-        let online_users = Arc::clone(&self.online_users);
         let auth = Arc::clone(&self.context.auth);
         let client = Arc::clone(&self.context.client);
         let redpacket_cache = Arc::clone(&self.redpacket_handler.redpacket_cache);
@@ -348,7 +345,6 @@ impl ChatroomCommand {
             .client
             .chatroom
             .add_listener(move |data| {
-                let online_users = Arc::clone(&online_users);
                 let auth = Arc::clone(&auth);
                 let client = Arc::clone(&client);
                 let redpacket_cache = Arc::clone(&redpacket_cache);
@@ -491,11 +487,7 @@ impl ChatroomCommand {
                         ChatRoomDataContent::Custom(custom) => {
                             println!("\r[{}]", custom.cyan());
                         }
-                        ChatRoomDataContent::OnlineUsers(online_user, ..) => {
-                            if let Ok(mut users) = online_users.lock() {
-                                *users = online_user;
-                            }
-                        }
+                        ChatRoomDataContent::OnlineUsers(..) => {}
                         ChatRoomDataContent::Discuss(topic) => {
                             println!("\r{}: {}", "💬 话题变更".yellow().bold(), topic.yellow());
                         }

client/src/commands/handlers/redpacket.rs

@@ -1,11 +1,11 @@
 use crate::commands::{Command, CommandContext, CommandResult};
+use crate::utils::random_gesture;
 use anyhow::Result;
 use async_trait::async_trait;
 use colored::*;
 use fishpi_rust::{GestureType, RedPacketMessage, RedPacketType};
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
-use crate::utils::random_gesture;
 
 pub struct RedpacketCommand {
     context: CommandContext,

client/src/ui/mod.rs

@@ -1,5 +1,7 @@
+use crate::commands::CommandContext;
 use colored::*;
-use fishpi_rust::ChatRoomUser;
+use fishpi_rust::api::ChatroomApi;
+use once_cell::sync::OnceCell;
 use rustyline::completion::{Completer, Pair};
 use rustyline::error::ReadlineError;
 use rustyline::highlight::Highlighter;
@@ -9,7 +11,8 @@ use rustyline::validate::Validator;
 use rustyline::{CompletionType, Config, Editor};
 use rustyline::{Context, Helper};
 use std::io;
-use std::sync::{Arc, Mutex};
+
+pub static GLOBAL_COMMAND_CONTEXT: OnceCell<CommandContext> = OnceCell::new();
 
 pub struct CommandItem {
     pub name: &'static str,
@@ -19,15 +22,11 @@ pub struct CommandItem {
 /// 命令补全器
 pub struct CommandCompleter {
     pub commands: Vec<CommandItem>,
-    pub users: Arc<Mutex<Vec<ChatRoomUser>>>,
 }
 
 impl CommandCompleter {
     fn new() -> Self {
-        Self {
-            commands: vec![],
-            users: Arc::new(Mutex::new(vec![])),
-        }
+        Self { commands: vec![] }
     }
 
     fn set_commands(&mut self, commands: Vec<CommandItem>) {
@@ -77,21 +76,33 @@ impl Completer for CommandCompleter {
         // @用户名补全
         if let Some(at_pos) = line[..pos].rfind('@') {
             let prefix = &line[at_pos + 1..pos];
-            let users = self.users.lock().unwrap();
-            let candidates: Vec<Pair> = users
-                .iter()
-                .filter(|user| {
-                    user.user_name
-                        .to_lowercase()
-                        .starts_with(&prefix.to_lowercase())
-                })
-                .map(|user| Pair {
-                    display: format!("@{}", user.user_name.cyan()),
-                    replacement: user.user_name.clone(),
-                })
-                .collect();
-
-            return Ok((at_pos + 1, candidates));
+            if !prefix.is_empty() {
+                if let Some(ctx) = GLOBAL_COMMAND_CONTEXT.get() {
+                    let prefix_owned = prefix.to_string();
+                    let ctx_clone = ctx.clone();
+                    let candidates = std::thread::scope(|s| {
+                        let handle = s.spawn(move || {
+                            let rt = tokio::runtime::Runtime::new().unwrap();
+                            rt.block_on(async move {
+                                let api = ChatroomApi::new(ctx_clone.client.api_client.clone());
+                                match api.autocomplete_username(&prefix_owned).await {
+                                    Ok(api_users) => api_users
+                                        .into_iter()
+                                        .map(|u| Pair {
+                                            display: format!("@{}", u.user_name.cyan()),
+                                            replacement: u.user_name,
+                                        })
+                                        .collect(),
+                                    Err(_) => vec![],
+                                }
+                            })
+                        });
+                        handle.join().unwrap_or_else(|_| vec![])
+                    });
+
+                    return Ok((at_pos + 1, candidates));
+                }
+            }
         }
 
         if line.trim().is_empty() {

client/src/utils/mod.rs

@@ -4,12 +4,12 @@ pub use auth::AuthService;
 
 use chrono::{Local, TimeZone};
 use colored::*;
-use regex::Regex;
-use std::sync::{Arc, Mutex};
 use once_cell::sync::Lazy;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::Path;
-use serde::{Serialize, Deserialize};
+use std::sync::{Arc, Mutex};
 
 const GESTURE_STATS_FILE: &str = "gesture_stats.json";
 
@@ -34,9 +34,8 @@ pub fn load_gesture_stats() -> [u64; 3] {
     [0; 3]
 }
 
-pub static GESTURE_STATS: Lazy<Arc<Mutex<[u64; 3]>>> = Lazy::new(|| {
-    Arc::new(Mutex::new(load_gesture_stats()))
-});
+pub static GESTURE_STATS: Lazy<Arc<Mutex<[u64; 3]>>> =
+    Lazy::new(|| Arc::new(Mutex::new(load_gesture_stats())));
 
 //随机猜拳
 pub fn random_gesture() -> u8 {

src/api/chatroom_api.rs

@@ -1,7 +1,7 @@
 use crate::api::client::ApiClient;
 use crate::models::chatroom::{
-    BarrageCost, ChatRoomMessage, ChatRoomNode, ChatRoomNodeInfo, ChatRoomQueryMode, ChatSource,
-    MuteItem,
+    AutoCompleteUsername, BarrageCost, ChatRoomMessage, ChatRoomNode, ChatRoomNodeInfo,
+    ChatRoomQueryMode, ChatSource, MuteItem,
 };
 use crate::models::user::ApiResponse;
 use anyhow::{Result, anyhow};
@@ -380,4 +380,22 @@ impl ChatroomApi {
             avaliable,
         })
     }
+
+    /// 用户名补全接口
+    ///
+    /// 返回用户名 Vec<AutoCompleteUsername>
+    pub async fn autocomplete_username(&self, prefix: &str) -> Result<Vec<AutoCompleteUsername>> {
+        let token = self.check_token("用户名补全").await?;
+        let params = self.build_params(HashMap::new(), token);
+        let data = json!({ "name": prefix });
+        let response = self
+            .client
+            .post::<ApiResponse<Vec<AutoCompleteUsername>>>("/users/names", Some(params), data)
+            .await?;
+        // 失败返回空列表
+        if response.code != 0 || response.data.is_none() {
+            return Err(anyhow!("获取用户名失败"));
+        }
+        Ok(response.data.unwrap_or_default())
+    }
 }

src/lib.rs

@@ -65,10 +65,10 @@ pub mod services;
 
 // 导出常用类型到顶层命名空间
 pub use models::chatroom::{
-    BarrageCost, BarragerMsg, ChatContentType, ChatRoomData, ChatRoomDataContent, ChatRoomMessage,
-    ChatRoomMessageType, ChatRoomNode, ChatRoomNodeInfo, ChatRoomQueryMode, ChatRoomUser,
-    ChatSource, MusicMsg, MuteItem, SpecialMessageContent, WeatherMsg, WeatherMsgData,
-    WebSocketMessage,
+    AutoCompleteUsername, BarrageCost, BarragerMsg, ChatContentType, ChatRoomData,
+    ChatRoomDataContent, ChatRoomMessage, ChatRoomMessageType, ChatRoomNode, ChatRoomNodeInfo,
+    ChatRoomQueryMode, ChatRoomUser, ChatSource, MusicMsg, MuteItem, SpecialMessageContent,
+    WeatherMsg, WeatherMsgData, WebSocketMessage,
 };
 
 pub use models::chat::{
@@ -110,7 +110,7 @@ use api::{
 /// FishPi API 客户端主类
 #[derive(Debug, Clone)]
 pub struct FishPi {
-    api_client: ApiClient,
+    pub api_client: ApiClient,
     pub user: UserService,
     pub chatroom: ChatroomService,
     pub redpacket: RedpacketService,

src/models/chatroom.rs

@@ -1001,6 +1001,22 @@ pub struct ChatRoomNodeInfo {
     pub avaliable: Vec<ChatRoomNode>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct AutoCompleteUsername {
+    #[serde(rename = "userNameLowerCase")]
+    pub username_lowercase: String,
+    #[serde(rename = "userAvatarURL")]
+    pub useravatar_url: String,
+    #[serde(rename = "userAvatarURL20")]
+    pub uservatar_url20: String,
+    #[serde(rename = "userName")]
+    pub user_name: String,
+    #[serde(rename = "userAvatarURL210")]
+    pub uservatar_url210: String,
+    #[serde(rename = "userAvatarURL48")]
+    pub uservatar_url48: String,
+}
+
 // 聊天室数据类型
 #[derive(Debug, Clone)]
 pub struct ChatRoomData {

src/services/chatroom_service.rs

@@ -1,3 +1,4 @@
+use crate::AutoCompleteUsername;
 use crate::api::ChatroomApi;
 use crate::api::client::ApiClient;
 use crate::models::chatroom::{
@@ -126,6 +127,14 @@ impl ChatroomService {
         }
     }
 
+    /// 用户名补全
+    pub async fn autocomplete(&self, prefix: &str) -> Response<Vec<AutoCompleteUsername>> {
+        self.call_api("用户名补全", || {
+            self.chatroom_api.autocomplete_username(prefix)
+        })
+        .await
+    }
+
     /// 发送消息
     pub async fn send<'a>(
         &self,