""" WechatHookClient - 微信 Hook API 客户端 封装所有微信操作的高级 API """ import asyncio import json import uuid from typing import List, Dict, Optional from loguru import logger from .loader import NoveLoader from .message_types import MessageType from .callbacks import RECV_CALLBACK, add_callback_handler class WechatHookClient: """ 微信 Hook API 客户端 提供统一的异步 API 接口 """ def __init__(self, loader: NoveLoader, client_id: int): """ 初始化客户端 Args: loader: NoveLoader 实例 client_id: 客户端 ID（进程 ID） """ self.loader = loader self.client_id = client_id # 存储待处理的API请求 self.pending_requests = {} # 注册回调处理器 add_callback_handler(self) logger.info(f"WechatHookClient 初始化: client_id={client_id}") async def _log_bot_message(self, to_wxid: str, content: str, msg_type: str = "text", media_url: str = ""): """记录机器人发送的消息到 MessageLogger""" try: logger.info(f"尝试记录机器人消息: {to_wxid} - {content[:50]}...") from utils.message_hook import log_bot_message await log_bot_message(to_wxid, content, msg_type, media_url) logger.info(f"机器人消息记录成功") except Exception as e: logger.error(f"记录机器人消息失败: {e}") import traceback logger.error(f"详细错误: {traceback.format_exc()}") def _send_data(self, msg_type: int, data: dict) -> bool: """ 发送数据到微信（同步） Args: msg_type: 消息类型 data: 消息数据 Returns: 是否发送成功 """ payload = { "type": msg_type, "data": data } message = json.dumps(payload, ensure_ascii=False) return self.loader.SendWeChatData(self.client_id, message) async def _send_data_async(self, msg_type: int, data: dict) -> bool: """ 发送数据到微信（异步） Args: msg_type: 消息类型 data: 消息数据 Returns: 是否发送成功 """ return await asyncio.to_thread(self._send_data, msg_type, data) # ==================== 消息发送 ==================== async def send_text(self, to_wxid: str, content: str) -> bool: """ 发送文本消息 Args: to_wxid: 接收者 wxid content: 文本内容 Returns: 是否发送成功 """ data = { "to_wxid": to_wxid, "content": content } result = await self._send_data_async(MessageType.MT_SEND_TEXT, data) if result: logger.info(f"发送文本成功: {to_wxid}") # 记录机器人发送的消息到 MessageLogger await self._log_bot_message(to_wxid, content, "text") else: logger.error(f"发送文本失败: {to_wxid}") return result async def send_image(self, to_wxid: str, image_path: str) -> bool: """ 发送图片消息 Args: to_wxid: 接收者 wxid image_path: 图片文件路径 Returns: 是否发送成功 """ data = { "to_wxid": to_wxid, "file": image_path } # 使用正确的图片发送API类型 result = await self._send_data_async(11040, data) if result: logger.info(f"发送图片成功: {to_wxid}") # 记录机器人发送的图片消息 import os filename = os.path.basename(image_path) await self._log_bot_message(to_wxid, f"[图片] {filename}", "image", image_path) else: logger.error(f"发送图片失败: {to_wxid}") return result async def send_file(self, to_wxid: str, file_path: str) -> bool: """ 发送文件消息（普通发送） Args: to_wxid: 接收者 wxid file_path: 文件路径 Returns: 是否发送成功 """ data = { "to_wxid": to_wxid, "file": file_path # 注意：参数名是 "file" 而不是 "file_path" } result = await self._send_data_async(11041, data) # 使用正确的 type=11041 if result: logger.info(f"发送文件成功: {to_wxid}") # 记录机器人发送的文件消息 import os filename = os.path.basename(file_path) await self._log_bot_message(to_wxid, f"[文件] {filename}", "file", file_path) else: logger.error(f"发送文件失败: {to_wxid}") return result async def send_video(self, to_wxid: str, video_path: str) -> bool: """ 发送视频消息 Args: to_wxid: 接收者 wxid video_path: 视频文件路径 Returns: 是否发送成功 """ data = { "to_wxid": to_wxid, "video_path": video_path } result = await self._send_data_async(11039, data) if result: logger.info(f"发送视频成功: {to_wxid}") # 记录机器人发送的视频消息 import os filename = os.path.basename(video_path) await self._log_bot_message(to_wxid, f"[视频] {filename}", "video", video_path) else: logger.error(f"发送视频失败: {to_wxid}") return result async def send_at_message( self, chatroom_id: str, content: str, at_list: List[str] ) -> bool: """ 发送群聊 @ 消息 Args: chatroom_id: 群聊 ID content: 消息内容 at_list: 要 @ 的 wxid 列表，["notify@all"] 表示 @所有人 Returns: 是否发送成功 """ data = { "chatroom_id": chatroom_id, "content": content, "at_list": at_list } result = await self._send_data_async(11040, data) if result: logger.info(f"发送 @ 消息成功: {chatroom_id}") else: logger.error(f"发送 @ 消息失败: {chatroom_id}") return result async def send_card( self, to_wxid: str, card_wxid: str, card_nickname: str ) -> bool: """ 发送名片消息 Args: to_wxid: 接收者 wxid card_wxid: 名片的 wxid card_nickname: 名片昵称 Returns: 是否发送成功 """ data = { "to_wxid": to_wxid, "card_wxid": card_wxid, "card_nickname": card_nickname } result = await self._send_data_async(11041, data) if result: logger.info(f"发送名片成功: {to_wxid}") else: logger.error(f"发送名片失败: {to_wxid}") return result async def send_link( self, to_wxid: str, title: str, desc: str, url: str, thumb_url: str = "" ) -> bool: """ 发送链接消息 Args: to_wxid: 接收者 wxid title: 链接标题 desc: 链接描述 url: 链接地址 thumb_url: 缩略图 URL Returns: 是否发送成功 """ data = { "to_wxid": to_wxid, "title": title, "desc": desc, "url": url, "thumb_url": thumb_url } result = await self._send_data_async(11042, data) if result: logger.info(f"发送链接成功: {to_wxid}") else: logger.error(f"发送链接失败: {to_wxid}") return result async def cdn_init(self) -> bool: """ 初始化 CDN 环境 用于初始化 CDN 环境，收到登录消息后执行一次即可。 初始化后才能使用协议 API（如获取群成员信息等）。 Returns: 是否初始化成功 """ result = await self._send_data_async(11228, {}) if result: logger.success("CDN 初始化成功") else: logger.error("CDN 初始化失败") return result async def cdn_download(self, file_id: str, aes_key: str, save_path: str, file_type: int = 2) -> bool: """ CDN 下载文件（图片/视频等） Args: file_id: 文件 ID（从消息中获取的 cdnbigimgurl 等） aes_key: AES 密钥 save_path: 保存路径 file_type: 文件类型 (1=原图, 2=中图, 3=缩略图, 4=视频, 5=文件&GIF) Returns: 是否下载成功 """ data = { "file_id": file_id, "file_type": file_type, "aes_key": aes_key, "save_path": save_path } result = await self._send_data_async(11230, data) if result: logger.info(f"CDN 下载成功: {save_path}") else: logger.error(f"CDN 下载失败: {file_id}") return result async def cdn_upload(self, file_path: str, file_type: int = 1) -> Optional[Dict]: """ CDN 上传文件 Args: file_path: 文件路径 file_type: 文件类型 (1=原图, 2=中图, 3=缩略图, 4=视频, 5=文件&GIF) Returns: 上传结果字典，包含 aes_key, file_md5 等信息 失败返回 None """ # 生成唯一请求ID request_id = str(uuid.uuid4()) # 创建等待事件 event = asyncio.Event() result_data = {"cdn_info": None} # 存储待处理请求 request_key = f"cdn_upload_{request_id}" self.pending_requests[request_key] = { "request_id": request_id, "event": event, "result": result_data, "type": "cdn_upload", "file_path": file_path } data = { "file_path": file_path, "file_type": file_type } await self._send_data_async(11229, data) logger.info(f"CDN 上传请求已发送: {file_path}") # 等待回调结果 try: await asyncio.wait_for(event.wait(), timeout=30) cdn_info = result_data["cdn_info"] if cdn_info and cdn_info.get("error_code") == 0: logger.success(f"CDN 上传成功: {file_path}") return cdn_info else: error_code = cdn_info.get("error_code") if cdn_info else "unknown" logger.error(f"CDN 上传失败: {file_path}, error_code={error_code}") return None except asyncio.TimeoutError: logger.error(f"CDN 上传超时: {file_path}") return None finally: if request_key in self.pending_requests: del self.pending_requests[request_key] async def send_link_card( self, to_wxid: str, title: str, desc: str, url: str, image_url: str = "" ) -> bool: """ 发送链接卡片（CDN发送） Args: to_wxid: 接收者 wxid title: 卡片标题 desc: 卡片描述 url: 链接地址 image_url: 卡片图片 URL Returns: 是否发送成功 """ data = { "to_wxid": to_wxid, "title": title, "desc": desc, "url": url, "image_url": image_url } result = await self._send_data_async(11236, data) if result: logger.info(f"发送链接卡片成功: {to_wxid}") else: logger.error(f"发送链接卡片失败: {to_wxid}") return result async def send_link_card_and_get_response( self, to_wxid: str, title: str, desc: str, url: str, image_url: str = "", timeout_sec: int = 15 ) -> Optional[dict]: data = { "to_wxid": to_wxid, "title": title, "desc": desc, "url": url, "image_url": image_url } request_key = f"send_link_card_{to_wxid}" event = asyncio.Event() self.pending_requests[request_key] = {"event": event, "result": None} await self._send_data_async(11236, data) try: await asyncio.wait_for(event.wait(), timeout=timeout_sec) result = self.pending_requests[request_key]["result"] del self.pending_requests[request_key] return result except asyncio.TimeoutError: del self.pending_requests[request_key] return None async def revoke_message(self, msg_id: str) -> bool: """ 撤回消息 Args: msg_id: 消息 ID Returns: 是否撤回成功 """ data = {"msg_id": msg_id} result = await self._send_data_async(11043, data) if result: logger.info(f"撤回消息成功: {msg_id}") else: logger.error(f"撤回消息失败: {msg_id}") return result # ==================== 好友管理 ==================== async def get_friend_list(self) -> List[Dict]: """ 获取好友列表 Returns: 好友列表 """ # 需要实际测试确认返回格式 data = {} await self._send_data_async(11050, data) logger.info("请求好友列表") return [] async def get_friend_info(self, wxid: str) -> Optional[Dict]: """ 获取好友信息 Args: wxid: 好友 wxid Returns: 好友信息字典 """ data = {"wxid": wxid} await self._send_data_async(11051, data) logger.info(f"请求好友信息: {wxid}") return None async def add_friend( self, wxid: str, verify_msg: str = "", scene: int = 3 ) -> bool: """ 添加好友 Args: wxid: 要添加的 wxid verify_msg: 验证消息 scene: 添加场景（3=搜索，15=名片） Returns: 是否发送成功 """ data = { "wxid": wxid, "verify_msg": verify_msg, "scene": scene } result = await self._send_data_async(11052, data) if result: logger.info(f"发送好友请求成功: {wxid}") else: logger.error(f"发送好友请求失败: {wxid}") return result async def accept_friend(self, v3: str, v4: str, scene: int) -> bool: """ 同意好友请求 Args: v3: 好友请求的 v3 参数 v4: 好友请求的 v4 参数 scene: 场景值 Returns: 是否成功 """ data = { "v3": v3, "v4": v4, "scene": scene } result = await self._send_data_async(11053, data) if result: logger.info("同意好友请求成功") else: logger.error("同意好友请求失败") return result async def delete_friend(self, wxid: str) -> bool: """ 删除好友 Args: wxid: 要删除的好友 wxid Returns: 是否成功 """ data = {"wxid": wxid} result = await self._send_data_async(11054, data) if result: logger.info(f"删除好友成功: {wxid}") else: logger.error(f"删除好友失败: {wxid}") return result async def set_friend_remark(self, wxid: str, remark: str) -> bool: """ 修改好友备注 Args: wxid: 好友 wxid remark: 新备注 Returns: 是否成功 """ data = { "wxid": wxid, "remark": remark } result = await self._send_data_async(11055, data) if result: logger.info(f"修改备注成功: {wxid} -> {remark}") else: logger.error(f"修改备注失败: {wxid}") return result # ==================== 群聊管理 ==================== async def get_chatroom_list(self) -> List[Dict]: """ 获取群聊列表 Returns: 群聊列表 """ data = {} await self._send_data_async(11060, data) logger.info("请求群聊列表") return [] async def get_chatroom_members(self, chatroom_id: str) -> List[Dict]: """ 获取群成员列表（使用协议 API） Args: chatroom_id: 群聊 ID Returns: 群成员列表，每个成员包含: wxid, nickname, display_name, avatar """ # 生成唯一请求ID request_id = str(uuid.uuid4()) # 创建等待事件 event = asyncio.Event() result_data = {"members": [], "success": False} # 存储待处理请求 self.pending_requests[f"chatroom_info_{chatroom_id}"] = { "request_id": request_id, "event": event, "result": result_data, "type": "chatroom_info" } # 使用 type=11174 获取群信息（协议），包含成员列表和头像 data = {"wxid": chatroom_id} await self._send_data_async(11174, data) logger.info(f"请求群信息（协议）: {chatroom_id}, request_id: {request_id}") # 等待回调结果 members = await self._wait_for_chatroom_info(chatroom_id, timeout=15) return members async def _wait_for_chatroom_info(self, chatroom_id: str, timeout: int = 15) -> List[Dict]: """等待群信息回调（type=11174）""" request_key = f"chatroom_info_{chatroom_id}" if request_key not in self.pending_requests: logger.error(f"未找到待处理的群信息请求: {chatroom_id}") return [] request_info = self.pending_requests[request_key] event = request_info["event"] try: # 等待回调事件，设置超时 await asyncio.wait_for(event.wait(), timeout=timeout) # 获取结果 result = request_info["result"]["members"] logger.success(f"获取群成员成功（协议）: {chatroom_id}, 成员数: {len(result)}") return result except asyncio.TimeoutError: logger.error(f"获取群信息超时: {chatroom_id}") return [] finally: # 清理请求 if request_key in self.pending_requests: del self.pending_requests[request_key] async def _wait_for_chatroom_members(self, chatroom_id: str, timeout: int = 15) -> List[Dict]: """等待群成员信息回调（已废弃，保留用于兼容）""" if chatroom_id not in self.pending_requests: logger.error(f"未找到待处理的群成员请求: {chatroom_id}") return [] request_info = self.pending_requests[chatroom_id] event = request_info["event"] try: # 等待回调事件，设置超时 await asyncio.wait_for(event.wait(), timeout=timeout) # 获取结果 result = request_info["result"]["members"] logger.success(f"获取群成员成功: {chatroom_id}, 成员数: {len(result)}") return result except asyncio.TimeoutError: logger.error(f"获取群成员超时: {chatroom_id}") return [] finally: # 清理请求 if chatroom_id in self.pending_requests: del self.pending_requests[chatroom_id] async def _get_chatroom_members_fallback(self, chatroom_id: str) -> List[Dict]: """ 备用方案：使用11031获取群成员基本信息 Args: chatroom_id: 群聊ID Returns: 群成员列表（仅包含wxid） """ try: # 生成唯一请求ID request_id = str(uuid.uuid4()) # 创建等待事件 event = asyncio.Event() result_data = {"chatrooms": []} # 存储待处理请求 self.pending_requests[f"chatroom_list_{request_id}"] = { "request_id": request_id, "event": event, "result": result_data, "type": "chatroom_list", "target_chatroom": chatroom_id } # 发送获取群聊列表请求（包含成员列表） data = {"detail": 1} await self._send_data_async(11031, data) logger.info(f"请求群聊列表（备用方案）: {chatroom_id}, request_id: {request_id}") # 等待回调结果 try: await asyncio.wait_for(event.wait(), timeout=15) # 查找目标群聊的成员列表 chatrooms = result_data["chatrooms"] for chatroom in chatrooms: if chatroom.get("wxid") == chatroom_id: member_list = chatroom.get("member_list", []) # 转换为标准格式 members = [] for wxid in member_list: members.append({ "wxid": wxid, "nickname": wxid, # 使用wxid作为备用昵称 "display_name": "" # 群内昵称为空 }) logger.success(f"备用方案获取群成员成功: {chatroom_id}, 成员数: {len(members)}") return members logger.warning(f"在群聊列表中未找到目标群聊: {chatroom_id}") return [] except asyncio.TimeoutError: logger.error(f"备用方案获取群成员超时: {chatroom_id}") return [] finally: # 清理请求 key = f"chatroom_list_{request_id}" if key in self.pending_requests: del self.pending_requests[key] except Exception as e: logger.error(f"备用方案获取群成员失败: {e}") return [] async def get_chatroom_info(self, chatroom_id: str) -> Optional[Dict]: """ 获取群信息 Args: chatroom_id: 群聊 ID Returns: 群信息字典 """ data = {"chatroom_id": chatroom_id} await self._send_data_async(11062, data) logger.info(f"请求群信息: {chatroom_id}") return None async def create_chatroom(self, member_list: List[str]) -> Optional[str]: """ 创建群聊 Args: member_list: 成员 wxid 列表（至少2人） Returns: 新群聊的 chatroom_id """ data = {"member_list": member_list} result = await self._send_data_async(11063, data) if result: logger.info("创建群聊成功") else: logger.error("创建群聊失败") return None async def invite_to_chatroom( self, chatroom_id: str, wxid_list: List[str] ) -> bool: """ 邀请进群 Args: chatroom_id: 群聊 ID wxid_list: 要邀请的 wxid 列表 Returns: 是否成功 """ data = { "chatroom_id": chatroom_id, "wxid_list": wxid_list } result = await self._send_data_async(11064, data) if result: logger.info(f"邀请进群成功: {chatroom_id}") else: logger.error(f"邀请进群失败: {chatroom_id}") return result async def remove_chatroom_member( self, chatroom_id: str, wxid_list: List[str] ) -> bool: """ 踢出群成员 Args: chatroom_id: 群聊 ID wxid_list: 要踢出的 wxid 列表 Returns: 是否成功 """ data = { "chatroom_id": chatroom_id, "wxid_list": wxid_list } result = await self._send_data_async(11065, data) if result: logger.info(f"踢出群成员成功: {chatroom_id}") else: logger.error(f"踢出群成员失败: {chatroom_id}") return result async def quit_chatroom(self, chatroom_id: str) -> bool: """ 退出群聊 Args: chatroom_id: 群聊 ID Returns: 是否成功 """ data = {"chatroom_id": chatroom_id} result = await self._send_data_async(11066, data) if result: logger.info(f"退出群聊成功: {chatroom_id}") else: logger.error(f"退出群聊失败: {chatroom_id}") return result async def set_chatroom_name(self, chatroom_id: str, name: str) -> bool: """ 修改群名称 Args: chatroom_id: 群聊 ID name: 新群名称 Returns: 是否成功 """ data = { "chatroom_id": chatroom_id, "name": name } result = await self._send_data_async(11067, data) if result: logger.info(f"修改群名称成功: {chatroom_id}") else: logger.error(f"修改群名称失败: {chatroom_id}") return result async def set_chatroom_announcement( self, chatroom_id: str, announcement: str ) -> bool: """ 修改群公告 Args: chatroom_id: 群聊 ID announcement: 群公告内容 Returns: 是否成功 """ data = { "chatroom_id": chatroom_id, "announcement": announcement } result = await self._send_data_async(11068, data) if result: logger.info(f"修改群公告成功: {chatroom_id}") else: logger.error(f"修改群公告失败: {chatroom_id}") return result async def set_my_chatroom_nickname( self, chatroom_id: str, nickname: str ) -> bool: """ 修改我的群昵称 Args: chatroom_id: 群聊 ID nickname: 新昵称 Returns: 是否成功 """ data = { "chatroom_id": chatroom_id, "nickname": nickname } result = await self._send_data_async(11069, data) if result: logger.info(f"修改群昵称成功: {chatroom_id}") else: logger.error(f"修改群昵称失败: {chatroom_id}") return result # ==================== 登录信息 ==================== async def get_login_info(self) -> Optional[Dict]: """ 获取当前登录信息 Returns: 登录信息字典 """ data = {} await self._send_data_async(MessageType.MT_GET_LOGIN_INFO, data) logger.info("请求登录信息") return None async def get_user_info_in_chatroom(self, chatroom_id: str, user_wxid: str, max_retries: int = 2) -> Optional[Dict]: """ 获取群内用户详细信息（使用协议API） Args: chatroom_id: 群聊 ID user_wxid: 用户 wxid max_retries: 最大重试次数 Returns: 用户详细信息字典 """ for attempt in range(max_retries + 1): # 生成唯一请求ID request_id = str(uuid.uuid4()) # 创建等待事件 event = asyncio.Event() result_data = {"user_info": None} # 存储待处理请求 request_key = f"user_info_{chatroom_id}_{user_wxid}" self.pending_requests[request_key] = { "request_id": request_id, "event": event, "result": result_data, "type": "user_info_in_chatroom", "chatroom_id": chatroom_id, "user_wxid": user_wxid } # 发送请求 data = { "room_wxid": chatroom_id, "wxid": user_wxid } await self._send_data_async(11174, data) if attempt == 0: logger.info(f"请求群内用户信息: chatroom={chatroom_id}, user={user_wxid}") else: logger.info(f"重试请求群内用户信息 (第{attempt}次): user={user_wxid}") # 等待回调结果 try: await asyncio.wait_for(event.wait(), timeout=15) # 获取结果 user_info = result_data["user_info"] if user_info: logger.success(f"获取群内用户信息成功: {user_wxid}") return user_info else: logger.warning(f"获取群内用户信息为空: {user_wxid}") if attempt < max_retries: await asyncio.sleep(1) continue return None except asyncio.TimeoutError: logger.warning(f"获取群内用户信息超时 (第{attempt + 1}次): {user_wxid}") if attempt < max_retries: await asyncio.sleep(1) continue logger.error(f"获取群内用户信息最终失败: {user_wxid}") return None finally: # 清理请求 if request_key in self.pending_requests: del self.pending_requests[request_key] return None @RECV_CALLBACK(in_class=True) def on_api_response(self, client_id: int, msg_type: int, data: dict): """ 处理API响应回调 Args: client_id: 客户端ID msg_type: 消息类型 data: 响应数据 """ # 只处理本客户端的消息 if client_id != self.client_id: return # 处理群成员信息响应 if msg_type == 11032: self._handle_chatroom_members_response(data) # 处理群聊列表响应（备用方案） elif msg_type == 11031: self._handle_chatroom_list_response(data) # 处理单个用户信息响应（协议API） elif msg_type == 11174: self._handle_user_info_in_chatroom_response(data) # 处理CDN上传响应 elif msg_type == 11229: self._handle_cdn_upload_response(data) elif msg_type == 11236: try: to_user = data.get("toUserName", "") request_key = f"send_link_card_{to_user}" if request_key in self.pending_requests: self.pending_requests[request_key]["result"] = data self.pending_requests[request_key]["event"].set() except Exception as e: logger.error(f"处理链接卡片响应失败: {e}") def _handle_chatroom_members_response(self, data: dict): """ 处理群成员信息响应 Args: data: 响应数据 """ try: # 检查是否有错误 errcode = data.get("errcode") errmsg = data.get("errmsg", "") if errcode is not None and errcode != 0: logger.error(f"群成员信息API返回错误: errcode={errcode}, errmsg={errmsg}") # 对于所有待处理的群成员请求，都触发事件（返回空结果） for chatroom_id, request_info in list(self.pending_requests.items()): if request_info.get("type") == "chatroom_members": request_info["result"]["members"] = [] request_info["result"]["success"] = False request_info["event"].set() logger.warning(f"群成员请求因API错误而失败: {chatroom_id}") return group_wxid = data.get("group_wxid", "") member_list = data.get("member_list", []) logger.info(f"收到群成员信息响应: group_wxid={group_wxid}, 成员数={len(member_list)}") # 查找对应的待处理请求 if group_wxid in self.pending_requests: request_info = self.pending_requests[group_wxid] # 存储结果数据 request_info["result"]["members"] = member_list request_info["result"]["success"] = True # 触发等待事件 request_info["event"].set() logger.success(f"群成员信息处理完成: {group_wxid}") else: logger.warning(f"未找到对应的群成员请求: {group_wxid}") except Exception as e: logger.error(f"处理群成员信息响应失败: {e}") # 触发所有待处理的群成员请求（返回空结果） for chatroom_id, request_info in list(self.pending_requests.items()): if request_info.get("type") == "chatroom_members": request_info["result"]["members"] = [] request_info["result"]["success"] = False request_info["event"].set() def _handle_chatroom_list_response(self, data: dict): """ 处理群聊列表响应（备用方案） Args: data: 响应数据 """ try: # data应该是一个包含群聊信息的列表 chatrooms = data if isinstance(data, list) else [] logger.info(f"收到群聊列表响应: 群聊数={len(chatrooms)}") # 查找所有等待群聊列表的请求 for key, request_info in list(self.pending_requests.items()): if key.startswith("chatroom_list_") and request_info.get("type") == "chatroom_list": # 存储结果数据 request_info["result"]["chatrooms"] = chatrooms # 触发等待事件 request_info["event"].set() logger.success(f"群聊列表处理完成: {key}") break except Exception as e: logger.error(f"处理群聊列表响应失败: {e}") def _handle_user_info_in_chatroom_response(self, data: dict): """ 处理群内用户信息响应（11174 API） 支持两种请求类型： 1. chatroom_info - 获取群信息（包含成员列表） 2. user_info_in_chatroom - 获取单个用户信息 Args: data: 响应数据 """ try: # 检查基础响应 base_response = data.get("baseResponse", {}) ret_code = base_response.get("ret", -1) if ret_code != 0: logger.error(f"11174 API返回错误: ret={ret_code}") # 触发所有相关的待处理请求 self._trigger_user_info_requests(None) self._trigger_chatroom_info_requests([]) return # 获取联系人列表 contact_list = data.get("contactList", []) if not contact_list: logger.warning("11174 响应中无联系人数据") self._trigger_user_info_requests(None) self._trigger_chatroom_info_requests([]) return # 第一个联系人信息 contact_info = contact_list[0] contact_wxid = contact_info.get("userName", {}).get("string", "") # 判断是群聊还是个人 is_chatroom = contact_wxid.endswith("@chatroom") if is_chatroom: # 处理群信息请求 logger.info(f"收到群信息响应: chatroom_id={contact_wxid}") # 提取群成员列表 new_chatroom_data = contact_info.get("newChatroomData", {}) member_list = new_chatroom_data.get("chatRoomMemberList", []) # 转换成员数据格式 members = [] for member in member_list: members.append({ "wxid": member.get("userName", ""), "nickname": member.get("nickName", ""), "display_name": member.get("displayName", ""), "avatar": member.get("bigHeadImgUrl", ""), "invite_by": member.get("inviteBy", "") }) logger.info(f"解析到 {len(members)} 个群成员") # 查找对应的待处理请求 request_key = f"chatroom_info_{contact_wxid}" if request_key in self.pending_requests: request_info = self.pending_requests[request_key] request_info["result"]["members"] = members request_info["result"]["success"] = True request_info["event"].set() logger.success(f"群信息处理完成: {contact_wxid}") else: logger.warning(f"未找到对应的群信息请求: {contact_wxid}") else: # 处理单个用户信息请求 logger.info(f"收到群内用户信息响应: user_wxid={contact_wxid}") # 查找对应的待处理请求 for request_key, request_info in list(self.pending_requests.items()): if (request_info.get("type") == "user_info_in_chatroom" and request_info.get("user_wxid") == contact_wxid): # 存储结果数据 request_info["result"]["user_info"] = contact_info # 触发等待事件 request_info["event"].set() logger.success(f"群内用户信息处理完成: {contact_wxid}") return logger.warning(f"未找到对应的群内用户信息请求: {contact_wxid}") except Exception as e: logger.error(f"处理 11174 响应失败: {e}") import traceback logger.error(f"详细错误: {traceback.format_exc()}") self._trigger_user_info_requests(None) self._trigger_chatroom_info_requests([]) def _trigger_user_info_requests(self, user_info): """ 触发所有待处理的用户信息请求 Args: user_info: 用户信息，None表示失败 """ for request_key, request_info in list(self.pending_requests.items()): if request_info.get("type") == "user_info_in_chatroom": request_info["result"]["user_info"] = user_info request_info["event"].set() def _trigger_chatroom_info_requests(self, members): """ 触发所有待处理的群信息请求 Args: members: 群成员列表，空列表表示失败 """ for request_key, request_info in list(self.pending_requests.items()): if request_info.get("type") == "chatroom_info": request_info["result"]["members"] = members request_info["result"]["success"] = len(members) > 0 request_info["event"].set() def _handle_cdn_upload_response(self, data: dict): """ 处理CDN上传响应 Args: data: 响应数据，包含 aes_key, file_md5, error_code 等 """ try: file_path = data.get("file_path", "") error_code = data.get("error_code", -1) logger.info(f"收到CDN上传响应: file_path={file_path}, error_code={error_code}") # 查找对应的待处理请求 for request_key, request_info in list(self.pending_requests.items()): if request_info.get("type") == "cdn_upload": # 存储结果数据 request_info["result"]["cdn_info"] = data # 触发等待事件 request_info["event"].set() logger.success(f"CDN上传响应处理完成: {file_path}") break except Exception as e: logger.error(f"处理CDN上传响应失败: {e}") async def send_cdn_image(self, to_wxid: str, file_path: str) -> bool: """ 通过CDN上传并发送图片 Args: to_wxid: 接收者 wxid file_path: 图片文件路径 Returns: 是否发送成功 """ try: # 1. 上传到CDN cdn_info = await self.cdn_upload(file_path, file_type=1) if not cdn_info: logger.error(f"CDN上传失败，无法发送图片: {file_path}") return False # 2. 使用CDN信息发送图片 data = { "to_wxid": to_wxid, "aes_key": cdn_info.get("aes_key", ""), "file_md5": cdn_info.get("file_md5", ""), "file_size": cdn_info.get("file_size", 0), "mid_file_md5": cdn_info.get("mid_file_md5", ""), "mid_file_size": cdn_info.get("mid_file_size", 0), "thumb_file_md5": cdn_info.get("thumb_file_md5", ""), "thumb_file_size": cdn_info.get("thumb_file_size", 0) } result = await self._send_data_async(11233, data) if result: logger.success(f"CDN图片发送成功: {to_wxid}") import os filename = os.path.basename(file_path) await self._log_bot_message(to_wxid, f"[图片] {filename}", "image", file_path) else: logger.error(f"CDN图片发送失败: {to_wxid}") return result except Exception as e: logger.error(f"发送CDN图片异常: {e}") return False