feat(chat): 优化私聊消息处理，支持批量未读消息解析

Author: KwdeTfpv

client/src/app.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use crate::commands::{CommandContext, CommandRegistry};
 use crate::ui::{CrosstermInputHandler, GLOBAL_COMMAND_CONTEXT};
-use crate::utils::AuthService;
+use crate::utils::{AuthService, strip_html_tags_chatroom};
 use fishpi_rust::services::notice_service::ListenerId;
 
 pub struct App {
@@ -39,6 +39,7 @@ impl App {
         if self.notice_listener_id.is_some() {
             return;
         }
+        let client_clone = self.client.clone();
 
         let listener_id = self.client.notice
             .add_listener(move |notice_msg| {
@@ -54,12 +55,28 @@ impl App {
                         }
                     }
                     "newIdleChatMessage" => {
-                        println!(
-                            "\r{} {}: {}",
-                            "[新私信]".blue(),
-                            notice_msg.sender_name().green(),
-                            notice_msg.preview_text()
-                        );
+                        let client = client_clone.clone();
+                        let sender_name = notice_msg.sender_name().to_string();
+                        let preview = notice_msg.preview_text().to_string();
+                        
+                        tokio::spawn(async move {
+                            let message = client.chat.get_messages(&sender_name, 1, 1, true).await;
+                            if let Some(last_msg) = message.data.and_then(|mut msgs| msgs.pop()) {
+                                println!(
+                                    "\r{} {}: {}",
+                                    "[新私信]".blue(),
+                                    sender_name.green(),
+                                    strip_html_tags_chatroom(last_msg.content_text()).bright_black()
+                                );
+                            } else {
+                                println!(
+                                    "\r{} {}: {}",
+                                    "[新私信]".blue(),
+                                    sender_name.green(),
+                                    preview
+                                );
+                            }
+                        });
                     }
                     _ => {
                         log::warn!("未知通知类型: {}", notice_msg.command);

src/api/chat_api.rs

@@ -77,38 +77,30 @@ impl ChatApi {
 
     /// 获取未读消息
     pub async fn has_unread(&self) -> Result<Value> {
-        let url = "chat/has-unread";
         let token = self.client.get_token().await;
         if token.is_none() {
             return Err(anyhow::anyhow!("未登录，无法获取未读消息"));
         }
+        let url = "chat/has-unread?apiKey=".to_string() + &token.unwrap();
 
-        let mut params = HashMap::new();
-        if let Some(token_value) = token {
-            params.insert("apiKey".to_string(), token_value);
-        }
-
-        let response = self.client.get::<Value>(url, Some(params)).await?;
+        let response = self.client.get::<Value>(&url,None).await?;
         Ok(response)
     }
 
     /// 撤回私聊消息
     ///
     /// * `msg_id` - 消息ID
     pub async fn revoke(&self, msg_id: &str) -> Result<Value> {
-        let url = "chat/revoke";
         let token = self.client.get_token().await;
         if token.is_none() {
             return Err(anyhow::anyhow!("未登录，无法撤回消息"));
         }
+        let url = "chat/revoke?apiKey=".to_string() + &token.unwrap();
 
         let mut params = HashMap::new();
-        if let Some(token_value) = token {
-            params.insert("apiKey".to_string(), token_value);
-        }
         params.insert("oId".to_string(), msg_id.to_string());
 
-        let response = self.client.get::<Value>(url, Some(params)).await?;
+        let response = self.client.get::<Value>(&url, Some(params)).await?;
         Ok(response)
     }
 

src/models/chat.rs

@@ -1,3 +1,4 @@
+use std::fmt::Display;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -128,39 +129,53 @@ pub struct ChatNotice {
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct ChatData {
     /// 接收 id
-    #[serde(rename = "toId")]
+    #[serde(rename = "toId", default)]
     pub to_id: String,
     /// 预览内容
+    #[serde(default)]
     pub preview: String,
     /// 用户会话
-    #[serde(rename = "user_session")]
+    #[serde(rename = "user_session", default)]
     pub user_session: String,
     /// 发送者头像
-    #[serde(rename = "senderAvatar")]
+    #[serde(rename = "senderAvatar", default)]
     pub sender_avatar: String,
     /// markdown内容
+    #[serde(default)]
     pub markdown: String,
     /// 接收者头像
-    #[serde(rename = "receiverAvatar")]
+    #[serde(rename = "receiverAvatar", default)]
     pub receiver_avatar: String,
     /// 消息ID
-    #[serde(rename = "oId")]
+    #[serde(rename = "oId", default)]
     pub oid: String,
     /// 时间
+    #[serde(default)]
     pub time: String,
     /// 发送 id
-    #[serde(rename = "fromId")]
+    #[serde(rename = "fromId", default)]
     pub from_id: String,
     /// 发送者用户名
-    #[serde(rename = "senderUserName")]
+    #[serde(rename = "senderUserName", default)]
     pub sender_user_name: String,
     /// 内容
+    #[serde(default)]
     pub content: String,
     /// 接收者用户名
-    #[serde(rename = "receiverUserName")]
+    #[serde(rename = "receiverUserName", default)]
     pub receiver_user_name: String,
 }
 
+impl Display for ChatData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} 给你发送了私信",
+            self.sender_name(),
+        )
+    }
+}
+
 impl ChatData {
     pub fn from_json(value: &Value) -> Option<Self> {
         serde_json::from_value(value.clone()).ok()
@@ -206,6 +221,13 @@ impl ChatData {
         }
     }
 
+    pub fn count(sender: &str, count: usize)-> String {
+        if count == 1 {
+            format!("{} 给你发送了 1 条私信", sender)
+        } else {
+            format!("{} 给你发送了 {} 条私信", sender, count)
+        }
+    }
 }
 
 /// 聊天撤回

src/services/chat_service.rs

@@ -207,13 +207,21 @@ impl ChatService {
     }
 
     /// 获取未读私聊消息
-    pub async fn unread(&self) -> Response<ChatData> {
+    pub async fn unread(&self) -> Response<Vec<ChatData>> {
         match self.chat_api.has_unread().await {
             Ok(data) => {
-                if let Some(chat_data) = data.get("data").and_then(ChatData::from_json) {
-                    Response::success(chat_data)
+                if let Some(chat_data_list) = data.get("data").and_then(|d| d.as_array()) {
+                    let parsed_data: Vec<ChatData> = chat_data_list
+                        .iter()
+                        .filter_map(ChatData::from_json)
+                        .collect();
+                    if !parsed_data.is_empty() {
+                        Response::success(parsed_data)
+                    } else {
+                        Response::error("解析未读消息失败：数据为空")
+                    }
                 } else {
-                    Response::error("解析未读消息失败")
+                    Response::error("解析未读消息失败：数据格式错误")
                 }
             }
             Err(e) => Response::error(&format!("获取未读私聊消息失败: {}", e)),
@@ -594,9 +602,6 @@ impl ChatService {
 
         // 确保有监听器
         let listener_manager = self.get_or_create_listener_manager(user).await;
-        if listener_manager.is_empty().await {
-            return Err("没有监听器，无法建立有效连接".to_string());
-        }
 
         // 获取连接对象
         let connection = self.get_connection(user).await;