Soulter
268 lines
12 KiB
Python
268 lines
12 KiB
Python
import time
|
|
import asyncio
|
|
import traceback
|
|
import logging
|
|
from aiocqhttp import CQHttp, Event
|
|
from aiocqhttp.exceptions import ActionFailed
|
|
from . import Platform, T2IException
|
|
from type.astrbot_message import *
|
|
from type.message_event import *
|
|
from type.command import *
|
|
from typing import Union, List, Dict
|
|
from nakuru.entities.components import *
|
|
from util.log import LogManager
|
|
from logging import Logger
|
|
from astrbot.message.handler import MessageHandler
|
|
from util.cmd_config import PlatformConfig, AiocqhttpPlatformConfig
|
|
|
|
logger: Logger = LogManager.GetLogger(log_name='astrbot')
|
|
|
|
class AIOCQHTTP(Platform):
|
|
def __init__(self, context: Context,
|
|
message_handler: MessageHandler,
|
|
platform_config: PlatformConfig) -> None:
|
|
super().__init__("aiocqhttp", context)
|
|
assert isinstance(platform_config, AiocqhttpPlatformConfig), "aiocqhttp: 无法识别的配置类型。"
|
|
|
|
self.message_handler = message_handler
|
|
self.context = context
|
|
self.config = platform_config
|
|
self.unique_session = context.config_helper.platform_settings.unique_session
|
|
self.host = platform_config.ws_reverse_host
|
|
self.port = platform_config.ws_reverse_port
|
|
|
|
def convert_message(self, event: Event) -> AstrBotMessage:
|
|
|
|
abm = AstrBotMessage()
|
|
abm.self_id = str(event.self_id)
|
|
abm.tag = "aiocqhttp"
|
|
|
|
abm.sender = MessageMember(str(event.sender['user_id']), event.sender['nickname'])
|
|
|
|
if event['message_type'] == 'group':
|
|
abm.type = MessageType.GROUP_MESSAGE
|
|
elif event['message_type'] == 'private':
|
|
abm.type = MessageType.FRIEND_MESSAGE
|
|
|
|
if self.unique_session:
|
|
abm.session_id = abm.sender.user_id
|
|
else:
|
|
abm.session_id = str(event.group_id) if abm.type == MessageType.GROUP_MESSAGE else abm.sender.user_id
|
|
|
|
abm.message_id = str(event.message_id)
|
|
abm.message = []
|
|
|
|
message_str = ""
|
|
if not isinstance(event.message, list):
|
|
err = f"aiocqhttp: 无法识别的消息类型: {str(event.message)}，此条消息将被忽略。如果您在使用 go-cqhttp，请将其配置文件中的 message.post-format 更改为 array。"
|
|
logger.critical(err)
|
|
try:
|
|
self.bot.send(event, err)
|
|
except BaseException as e:
|
|
logger.error(f"回复消息失败: {e}")
|
|
return
|
|
for m in event.message:
|
|
t = m['type']
|
|
a = None
|
|
if t == 'at':
|
|
a = At(**m['data'])
|
|
abm.message.append(a)
|
|
if t == 'text':
|
|
a = Plain(text=m['data']['text'])
|
|
message_str += m['data']['text'].strip()
|
|
abm.message.append(a)
|
|
if t == 'image':
|
|
file = m['data']['file'] if 'file' in m['data'] else None
|
|
url = m['data']['url'] if 'url' in m['data'] else None
|
|
a = Image(file=file, url=url)
|
|
abm.message.append(a)
|
|
abm.timestamp = int(time.time())
|
|
abm.message_str = message_str
|
|
abm.raw_message = event
|
|
return abm
|
|
|
|
def run_aiocqhttp(self):
|
|
if not self.host or not self.port:
|
|
return
|
|
self.bot = CQHttp(use_ws_reverse=True, import_name='aiocqhttp', api_timeout_sec=180)
|
|
@self.bot.on_message('group')
|
|
async def group(event: Event):
|
|
abm = self.convert_message(event)
|
|
if abm:
|
|
await self.handle_msg(abm)
|
|
|
|
@self.bot.on_message('private')
|
|
async def private(event: Event):
|
|
abm = self.convert_message(event)
|
|
if abm:
|
|
await self.handle_msg(abm)
|
|
|
|
bot = self.bot.run_task(host=self.host, port=int(self.port), shutdown_trigger=self.shutdown_trigger_placeholder)
|
|
|
|
for handler in logging.root.handlers[:]:
|
|
logging.root.removeHandler(handler)
|
|
logging.getLogger('aiocqhttp').setLevel(logging.ERROR)
|
|
|
|
return bot
|
|
|
|
async def shutdown_trigger_placeholder(self):
|
|
while self.context.running:
|
|
await asyncio.sleep(1)
|
|
|
|
async def pre_check(self, message: AstrBotMessage) -> bool:
|
|
# if message chain contains Plain components or
|
|
# At components which points to self_id, return True
|
|
if message.type == MessageType.FRIEND_MESSAGE:
|
|
return True, "friend"
|
|
for comp in message.message:
|
|
if isinstance(comp, At) and str(comp.qq) == message.self_id:
|
|
return True, "at"
|
|
# check commands which ignore prefix
|
|
if await self.context.command_manager.check_command_ignore_prefix(message.message_str):
|
|
return True, "command"
|
|
# check nicks
|
|
if self.check_nick(message.message_str):
|
|
return True, "nick"
|
|
return False, "none"
|
|
|
|
async def handle_msg(self, message: AstrBotMessage):
|
|
logger.info(
|
|
f"{message.sender.nickname}/{message.sender.user_id} -> {self.parse_message_outline(message)}")
|
|
|
|
ok, reason = await self.pre_check(message)
|
|
if not ok:
|
|
return
|
|
|
|
# parse unified message origin
|
|
unified_msg_origin = None
|
|
assert isinstance(message.raw_message, Event)
|
|
if message.type == MessageType.GROUP_MESSAGE:
|
|
unified_msg_origin = f"aiocqhttp:{message.type.value}:{message.raw_message.group_id}"
|
|
elif message.type == MessageType.FRIEND_MESSAGE:
|
|
unified_msg_origin = f"aiocqhttp:{message.type.value}:{message.sender.user_id}"
|
|
|
|
logger.debug(f"unified_msg_origin: {unified_msg_origin}")
|
|
|
|
# construct astrbot message event
|
|
ame = AstrMessageEvent.from_astrbot_message(message,
|
|
self.context,
|
|
"aiocqhttp",
|
|
message.session_id,
|
|
unified_msg_origin,
|
|
reason == "command") # only_command
|
|
|
|
# transfer control to message handler
|
|
message_result = await self.message_handler.handle(ame)
|
|
if not message_result: return
|
|
|
|
await self.reply_msg(message, message_result.result_message, message_result.use_t2i)
|
|
if message_result.callback:
|
|
message_result.callback()
|
|
|
|
return message_result
|
|
|
|
async def reply_msg(self,
|
|
message: AstrBotMessage,
|
|
result_message: list,
|
|
use_t2i: bool = None):
|
|
"""
|
|
回复用户唤醒机器人的消息。（被动回复）
|
|
"""
|
|
try:
|
|
await self._reply(message, result_message, use_t2i)
|
|
except T2IException as e:
|
|
logger.error(traceback.format_exc())
|
|
logger.warning(f"文本转图片时发生错误，将使用纯文本发送。")
|
|
await self._reply(message, result_message, False)
|
|
return result_message
|
|
|
|
async def _reply(self, message: Union[AstrBotMessage, Dict], message_chain: List[BaseMessageComponent], use_t2i: bool = None):
|
|
await self.record_metrics()
|
|
if isinstance(message_chain, str):
|
|
message_chain = [Plain(text=message_chain), ]
|
|
|
|
# 文转图处理
|
|
if (use_t2i or (use_t2i == None and self.context.config_helper.t2i)) and isinstance(message_chain, list):
|
|
try:
|
|
message_chain = await self.convert_to_t2i_chain(message_chain)
|
|
if not message_chain: raise T2IException()
|
|
except BaseException as e:
|
|
raise T2IException()
|
|
|
|
# log
|
|
if isinstance(message, AstrBotMessage):
|
|
logger.info(
|
|
f"{message.sender.nickname}/{message.sender.user_id} <- {self.parse_message_outline(message_chain)}")
|
|
else:
|
|
logger.info(f"回复消息: {message_chain}")
|
|
|
|
# 解析成 OneBot json 格式并发送
|
|
ret = []
|
|
image_idx = []
|
|
for idx, segment in enumerate(message_chain):
|
|
d = segment.toDict()
|
|
if isinstance(segment, Plain):
|
|
d['type'] = 'text'
|
|
if isinstance(segment, Image):
|
|
image_idx.append(idx)
|
|
ret.append(d)
|
|
if os.environ.get('TEST_MODE', 'off') == 'on':
|
|
logger.info(f"回复消息: {ret}")
|
|
return
|
|
try:
|
|
await self._reply_wrapper(message, ret)
|
|
except ActionFailed as e:
|
|
if e.retcode == 1200:
|
|
# ENOENT
|
|
if not image_idx:
|
|
raise e
|
|
logger.warning("回复失败。检测到失败原因为文件未找到，猜测用户的协议端与 AstrBot 位于不同的文件系统上。尝试采用上传图片的方式发图。")
|
|
for idx in image_idx:
|
|
if ret[idx]['data']['file'].startswith('file://'):
|
|
logger.info(f"正在上传图片: {ret[idx]['data']['path']}")
|
|
# 除了上传到图床，想不到更好的办法。
|
|
image_url = await self.context.image_uploader.upload_image(ret[idx]['data']['path'])
|
|
logger.info(f"上传成功。")
|
|
ret[idx]['data']['file'] = image_url
|
|
ret[idx]['data']['path'] = image_url
|
|
await self._reply_wrapper(message, ret)
|
|
else:
|
|
logger.error(traceback.format_exc())
|
|
logger.error(f"回复消息失败: {e}")
|
|
raise e
|
|
|
|
async def _reply_wrapper(self, message: Union[AstrBotMessage, Dict], ret: List):
|
|
if isinstance(message, AstrBotMessage):
|
|
await self.bot.send(message.raw_message, ret)
|
|
if isinstance(message, dict):
|
|
if 'group_id' in message:
|
|
await self.bot.send_group_msg(group_id=message['group_id'], message=ret)
|
|
elif 'user_id' in message:
|
|
await self.bot.send_private_msg(user_id=message['user_id'], message=ret)
|
|
else:
|
|
raise Exception("aiocqhttp: 无法识别的消息来源。仅支持 group_id 和 user_id。")
|
|
|
|
async def send_msg(self, target: Dict[str, int], result_message: CommandResult):
|
|
'''
|
|
以主动的方式给QQ用户、QQ群发送一条消息。
|
|
|
|
`target` 接收一个 dict 类型的值引用。
|
|
|
|
- 要发给 QQ 下的某个用户，请添加 key `user_id`，值为 int 类型的 qq 号；
|
|
- 要发给某个群聊，请添加 key `group_id`，值为 int 类型的 qq 群号；
|
|
|
|
'''
|
|
try:
|
|
await self._reply(target, result_message.message_chain, result_message.is_use_t2i)
|
|
except T2IException as e:
|
|
logger.error(traceback.format_exc())
|
|
logger.warning(f"文本转图片时发生错误，将使用纯文本发送。")
|
|
await self._reply(target, result_message.message_chain, False)
|
|
|
|
async def send_msg_new(self, message_type: MessageType, target: str, result_message: CommandResult):
|
|
if message_type == MessageType.GROUP_MESSAGE:
|
|
await self.send_msg({'group_id': int(target)}, result_message)
|
|
elif message_type == MessageType.FRIEND_MESSAGE:
|
|
await self.send_msg({'user_id': int(target)}, result_message)
|
|
else:
|
|
raise Exception("aiocqhttp: 无法识别的消息类型。") |