mirror of
https://github.com/NapNeko/NapCatQQ.git
synced 2025-12-18 20:30:08 +08:00
684 lines
26 KiB
TypeScript
684 lines
26 KiB
TypeScript
import {
|
||
BuddyReqType,
|
||
ChatType,
|
||
GroupNotifyMsgStatus,
|
||
GroupNotifyMsgType,
|
||
InstanceContext,
|
||
NapCatCore,
|
||
NodeIKernelBuddyListener,
|
||
NodeIKernelGroupListener,
|
||
NodeIKernelMsgListener,
|
||
Peer,
|
||
RawMessage,
|
||
SendStatusType,
|
||
NTMsgType,
|
||
MessageElement,
|
||
ElementType,
|
||
NTMsgAtType,
|
||
} from 'napcat-core';
|
||
import { OB11ConfigLoader } from '@/napcat-onebot/config';
|
||
import { pendingTokenToSend } from 'napcat-webui-backend/index';
|
||
import {
|
||
OB11HttpClientAdapter,
|
||
OB11WebSocketClientAdapter,
|
||
OB11NetworkManager,
|
||
OB11NetworkReloadType,
|
||
OB11HttpServerAdapter,
|
||
OB11WebSocketServerAdapter,
|
||
} from '@/napcat-onebot/network';
|
||
import { NapCatPathWrapper } from 'napcat-common/src/path';
|
||
import {
|
||
OneBotFriendApi,
|
||
OneBotGroupApi,
|
||
OneBotMsgApi,
|
||
OneBotQuickActionApi,
|
||
OneBotUserApi,
|
||
} from '@/napcat-onebot/api';
|
||
import { ActionMap, createActionMap } from '@/napcat-onebot/action';
|
||
import { WebUiDataRuntime } from 'napcat-webui-backend/src/helper/Data';
|
||
import { OB11InputStatusEvent } from '@/napcat-onebot/event/notice/OB11InputStatusEvent';
|
||
import { MessageUnique } from 'napcat-common/src/message-unique';
|
||
import { proxiedListenerOf } from 'napcat-common/src/proxy-handler';
|
||
import { OB11FriendRequestEvent } from '@/napcat-onebot/event/request/OB11FriendRequest';
|
||
import { OB11GroupRequestEvent } from '@/napcat-onebot/event/request/OB11GroupRequest';
|
||
import { OB11FriendRecallNoticeEvent } from '@/napcat-onebot/event/notice/OB11FriendRecallNoticeEvent';
|
||
import { OB11GroupRecallNoticeEvent } from '@/napcat-onebot/event/notice/OB11GroupRecallNoticeEvent';
|
||
import { BotOfflineEvent } from './event/notice/BotOfflineEvent';
|
||
import {
|
||
NetworkAdapterConfig,
|
||
OneBotConfig,
|
||
OneBotConfigSchema,
|
||
} from './config/config';
|
||
import { OB11Message } from './types';
|
||
import { IOB11NetworkAdapter } from '@/napcat-onebot/network/adapter';
|
||
import { OB11HttpSSEServerAdapter } from './network/http-server-sse';
|
||
import { OB11PluginMangerAdapter } from './network/plugin-manger';
|
||
import { existsSync } from 'node:fs';
|
||
import { OneBotFileApi } from './api/file';
|
||
|
||
interface ApiListType {
|
||
GroupApi: OneBotGroupApi;
|
||
UserApi: OneBotUserApi;
|
||
FriendApi: OneBotFriendApi;
|
||
MsgApi: OneBotMsgApi;
|
||
QuickActionApi: OneBotQuickActionApi;
|
||
FileApi: OneBotFileApi;
|
||
}
|
||
// OneBot实现类
|
||
export class NapCatOneBot11Adapter {
|
||
readonly core: NapCatCore;
|
||
readonly context: InstanceContext;
|
||
|
||
configLoader: OB11ConfigLoader;
|
||
public apis: ApiListType;
|
||
networkManager: OB11NetworkManager;
|
||
actions: ActionMap;
|
||
private readonly bootTime = Date.now() / 1000;
|
||
recallEventCache = new Map<string, NodeJS.Timeout>();
|
||
constructor(core: NapCatCore, context: InstanceContext, pathWrapper: NapCatPathWrapper) {
|
||
this.core = core;
|
||
this.context = context;
|
||
this.configLoader = new OB11ConfigLoader(core, pathWrapper.configPath, OneBotConfigSchema);
|
||
this.apis = {
|
||
GroupApi: new OneBotGroupApi(this, core),
|
||
UserApi: new OneBotUserApi(this, core),
|
||
FriendApi: new OneBotFriendApi(this, core),
|
||
MsgApi: new OneBotMsgApi(this, core),
|
||
QuickActionApi: new OneBotQuickActionApi(this, core),
|
||
FileApi: new OneBotFileApi(this, core),
|
||
} as const;
|
||
this.actions = createActionMap(this, core);
|
||
this.networkManager = new OB11NetworkManager();
|
||
}
|
||
|
||
async creatOneBotLog(ob11Config: OneBotConfig) {
|
||
let log = '[network] 配置加载\n';
|
||
for (const key of ob11Config.network.httpServers) {
|
||
log += `HTTP服务: ${key.host}:${key.port}, : ${key.enable ? '已启动' : '未启动'}\n`;
|
||
}
|
||
for (const key of ob11Config.network.httpSseServers) {
|
||
log += `HTTP-SSE服务: ${key.host}:${key.port}, : ${key.enable ? '已启动' : '未启动'}\n`;
|
||
}
|
||
for (const key of ob11Config.network.httpClients) {
|
||
log += `HTTP上报服务: ${key.url}, : ${key.enable ? '已启动' : '未启动'}\n`;
|
||
}
|
||
for (const key of ob11Config.network.websocketServers) {
|
||
log += `WebSocket服务: ${key.host}:${key.port}, : ${key.enable ? '已启动' : '未启动'}\n`;
|
||
}
|
||
for (const key of ob11Config.network.websocketClients) {
|
||
log += `WebSocket反向服务: ${key.url}, : ${key.enable ? '已启动' : '未启动'}\n`;
|
||
}
|
||
return log;
|
||
}
|
||
|
||
async InitOneBot() {
|
||
const selfInfo = this.core.selfInfo;
|
||
const ob11Config = this.configLoader.configData;
|
||
this.core.apis.UserApi.getUserDetailInfo(selfInfo.uid, false)
|
||
.then(async (user) => {
|
||
selfInfo.nick = user.nick;
|
||
this.context.logger.setLogSelfInfo(selfInfo);
|
||
|
||
// 检查是否有待发送的token
|
||
if (pendingTokenToSend) {
|
||
this.context.logger.log('[NapCat] [OneBot] 🔐 检测到待发送的WebUI Token，开始发送');
|
||
try {
|
||
await this.core.apis.MsgApi.sendMsg(
|
||
{ chatType: ChatType.KCHATTYPEC2C, peerUid: selfInfo.uid, guildId: '' },
|
||
[{
|
||
elementType: ElementType.TEXT,
|
||
elementId: '',
|
||
textElement: {
|
||
content:
|
||
'[NapCat] 温馨提示:\n' +
|
||
'WebUI密码为默认密码，已进行强制修改\n' +
|
||
'新密码: ' + pendingTokenToSend,
|
||
atType: NTMsgAtType.ATTYPEUNKNOWN,
|
||
atUid: '',
|
||
atTinyId: '',
|
||
atNtUid: '',
|
||
},
|
||
}],
|
||
5000
|
||
);
|
||
this.context.logger.log('[NapCat] [OneBot] ✅ WebUI Token 消息发送成功');
|
||
} catch (error) {
|
||
this.context.logger.logError('[NapCat] [OneBot] ❌ WebUI Token 消息发送失败:', error);
|
||
}
|
||
}
|
||
|
||
WebUiDataRuntime.getQQLoginCallback()(true);
|
||
})
|
||
.catch(e => this.context.logger.logError(e));
|
||
|
||
const serviceInfo = await this.creatOneBotLog(ob11Config);
|
||
this.context.logger.log(`[Notice] [OneBot11] ${serviceInfo}`);
|
||
|
||
// 创建NetWork服务
|
||
|
||
// 注册Plugin 如果需要基于NapCat进行快速开发
|
||
// this.networkManager.registerAdapter(
|
||
// new OB11PluginAdapter('myPlugin', this.core, this,this.actions)
|
||
// );
|
||
if (existsSync(this.context.pathWrapper.pluginPath)) {
|
||
this.context.logger.log('[Plugins] 插件目录存在，开始加载插件');
|
||
this.networkManager.registerAdapter(
|
||
new OB11PluginMangerAdapter('plugin_manager', this.core, this, this.actions)
|
||
);
|
||
}
|
||
for (const key of ob11Config.network.httpServers) {
|
||
if (key.enable) {
|
||
this.networkManager.registerAdapter(
|
||
new OB11HttpServerAdapter(key.name, key, this.core, this, this.actions)
|
||
);
|
||
}
|
||
}
|
||
for (const key of ob11Config.network.httpSseServers) {
|
||
if (key.enable) {
|
||
this.networkManager.registerAdapter(
|
||
new OB11HttpSSEServerAdapter(key.name, key, this.core, this, this.actions)
|
||
);
|
||
}
|
||
}
|
||
for (const key of ob11Config.network.httpClients) {
|
||
if (key.enable) {
|
||
this.networkManager.registerAdapter(
|
||
new OB11HttpClientAdapter(key.name, key, this.core, this, this.actions)
|
||
);
|
||
}
|
||
}
|
||
for (const key of ob11Config.network.websocketServers) {
|
||
if (key.enable) {
|
||
this.networkManager.registerAdapter(
|
||
new OB11WebSocketServerAdapter(
|
||
key.name,
|
||
key,
|
||
this.core,
|
||
this,
|
||
this.actions
|
||
)
|
||
);
|
||
}
|
||
}
|
||
for (const key of ob11Config.network.websocketClients) {
|
||
if (key.enable) {
|
||
this.networkManager.registerAdapter(
|
||
new OB11WebSocketClientAdapter(
|
||
key.name,
|
||
key,
|
||
this.core,
|
||
this,
|
||
this.actions
|
||
)
|
||
);
|
||
}
|
||
}
|
||
await this.networkManager.openAllAdapters();
|
||
|
||
this.initMsgListener();
|
||
this.initBuddyListener();
|
||
this.initGroupListener();
|
||
|
||
WebUiDataRuntime.setQQVersion(this.core.context.basicInfoWrapper.getFullQQVersion());
|
||
WebUiDataRuntime.setQQLoginInfo(selfInfo);
|
||
WebUiDataRuntime.setQQLoginStatus(true);
|
||
WebUiDataRuntime.setOnOB11ConfigChanged(async (newConfig) => {
|
||
const prev = this.configLoader.configData;
|
||
this.configLoader.save(newConfig);
|
||
// this.context.logger.log(`OneBot11 配置更改：${JSON.stringify(prev)} -> ${JSON.stringify(newConfig)}`);
|
||
await this.reloadNetwork(prev, newConfig);
|
||
});
|
||
this.apis.GroupApi.registerParseGroupReactEventByCore().catch(e =>
|
||
this.context.logger.logError('注册群消息反应表情失败', e)
|
||
);
|
||
}
|
||
|
||
private async reloadNetwork(prev: OneBotConfig, now: OneBotConfig): Promise<void> {
|
||
const prevLog = await this.creatOneBotLog(prev);
|
||
const newLog = await this.creatOneBotLog(now);
|
||
this.context.logger.log(`[Notice] [OneBot11] 配置变更前:\n${prevLog}`);
|
||
this.context.logger.log(`[Notice] [OneBot11] 配置变更后:\n${newLog}`);
|
||
|
||
await this.handleConfigChange(prev.network.httpServers, now.network.httpServers, OB11HttpServerAdapter);
|
||
await this.handleConfigChange(prev.network.httpClients, now.network.httpClients, OB11HttpClientAdapter);
|
||
await this.handleConfigChange(prev.network.httpSseServers, now.network.httpSseServers, OB11HttpSSEServerAdapter);
|
||
await this.handleConfigChange(prev.network.websocketServers, now.network.websocketServers, OB11WebSocketServerAdapter);
|
||
await this.handleConfigChange(prev.network.websocketClients, now.network.websocketClients, OB11WebSocketClientAdapter);
|
||
}
|
||
|
||
private async handleConfigChange<CT extends NetworkAdapterConfig>(
|
||
prevConfig: NetworkAdapterConfig[],
|
||
nowConfig: NetworkAdapterConfig[],
|
||
adapterClass: new (
|
||
...args: ConstructorParameters<typeof IOB11NetworkAdapter<CT>>
|
||
) => IOB11NetworkAdapter<CT>
|
||
): Promise<void> {
|
||
// 比较旧的在新的找不到的回收
|
||
for (const adapterConfig of prevConfig) {
|
||
const existingAdapter = nowConfig.find((e) => e.name === adapterConfig.name);
|
||
if (!existingAdapter) {
|
||
const existingAdapter = this.networkManager.findSomeAdapter(adapterConfig.name);
|
||
if (existingAdapter) {
|
||
await this.networkManager.closeSomeAdaterWhenOpen([existingAdapter]);
|
||
}
|
||
}
|
||
}
|
||
// 通知新配置重载 删除关闭的 加入新开的
|
||
for (const adapterConfig of nowConfig) {
|
||
const existingAdapter = this.networkManager.findSomeAdapter(adapterConfig.name);
|
||
if (existingAdapter) {
|
||
const networkChange = await existingAdapter.reload(adapterConfig);
|
||
if (networkChange === OB11NetworkReloadType.NetWorkClose) {
|
||
await this.networkManager.closeSomeAdaterWhenOpen([existingAdapter]);
|
||
}
|
||
} else if (adapterConfig.enable) {
|
||
// eslint-disable-next-line new-cap
|
||
const newAdapter = new adapterClass(adapterConfig.name, adapterConfig as CT, this.core, this, this.actions);
|
||
await this.networkManager.registerAdapterAndOpen(newAdapter);
|
||
}
|
||
}
|
||
}
|
||
|
||
private initMsgListener() {
|
||
const msgListener = new NodeIKernelMsgListener();
|
||
msgListener.onRecvSysMsg = (msg) => {
|
||
this.apis.MsgApi.parseSysMessage(msg)
|
||
.then((event) => {
|
||
if (event) this.networkManager.emitEvent(event);
|
||
})
|
||
.catch((e) =>
|
||
this.context.logger.logError(
|
||
'constructSysMessage error: ',
|
||
e,
|
||
'\n Parse Hex:',
|
||
Buffer.from(msg).toString('hex')
|
||
)
|
||
);
|
||
};
|
||
|
||
msgListener.onInputStatusPush = async (data) => {
|
||
const uin = await this.core.apis.UserApi.getUinByUidV2(data.fromUin);
|
||
this.context.logger.log(`[Notice] [输入状态] ${uin} ${data.statusText}`);
|
||
await this.networkManager.emitEvent(
|
||
new OB11InputStatusEvent(this.core, parseInt(uin), data.eventType, data.statusText)
|
||
);
|
||
};
|
||
|
||
msgListener.onRecvMsg = async (msg) => {
|
||
for (const m of msg) {
|
||
if (this.bootTime > parseInt(m.msgTime)) {
|
||
this.context.logger.logDebug(`消息时间${m.msgTime}早于启动时间${this.bootTime}，忽略上报`);
|
||
continue;
|
||
}
|
||
m.id = MessageUnique.createUniqueMsgId(
|
||
{
|
||
chatType: m.chatType,
|
||
peerUid: m.peerUid,
|
||
guildId: '',
|
||
},
|
||
m.msgId
|
||
);
|
||
await this.emitMsg(m).catch((e) =>
|
||
this.context.logger.logError('处理消息失败', e)
|
||
);
|
||
}
|
||
};
|
||
msgListener.onAddSendMsg = async (msg) => {
|
||
try {
|
||
if (msg.sendStatus === SendStatusType.KSEND_STATUS_SENDING) {
|
||
const [updatemsgs] = await this.core.eventWrapper.registerListen('NodeIKernelMsgListener/onMsgInfoListUpdate', (msgList: RawMessage[]) => {
|
||
const report = msgList.find((e) =>
|
||
e.senderUin === this.core.selfInfo.uin && e.sendStatus !== SendStatusType.KSEND_STATUS_SENDING && e.msgId === msg.msgId
|
||
);
|
||
return !!report;
|
||
}, 1, 10 * 60 * 1000);
|
||
// 10分钟 超时
|
||
const updatemsg = updatemsgs.find((e) => e.msgId === msg.msgId);
|
||
// updatemsg?.sendStatus == SendStatusType.KSEND_STATUS_SUCCESS_NOSEQ NOSEQ一般是服务器未下发SEQ 这意味着这条消息不应该推送network
|
||
if (updatemsg?.sendStatus === SendStatusType.KSEND_STATUS_SUCCESS) {
|
||
updatemsg.id = MessageUnique.createUniqueMsgId(
|
||
{
|
||
chatType: updatemsg.chatType,
|
||
peerUid: updatemsg.peerUid,
|
||
guildId: '',
|
||
},
|
||
updatemsg.msgId
|
||
);
|
||
this.emitMsg(updatemsg);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
this.context.logger.logError('处理发送消息失败', error);
|
||
}
|
||
};
|
||
msgListener.onMsgRecall = async (chatType: ChatType, uid: string, msgSeq: string) => {
|
||
const peer: Peer = {
|
||
chatType,
|
||
peerUid: uid,
|
||
guildId: '',
|
||
};
|
||
let msg = (await this.core.apis.MsgApi.queryMsgsWithFilterExWithSeq(peer, msgSeq)).msgList.find(e => e.msgType === NTMsgType.KMSGTYPEGRAYTIPS);
|
||
const element = msg?.elements.find(e => !!e.grayTipElement?.revokeElement);
|
||
if (msg && element?.grayTipElement?.revokeElement.isSelfOperate) {
|
||
const isSelfDevice = this.recallEventCache.has(msg.msgId);
|
||
if (isSelfDevice) {
|
||
await this.core.eventWrapper.registerListen('NodeIKernelMsgListener/onMsgRecall',
|
||
(chatType: ChatType, uid: string, msgSeq: string) => {
|
||
return chatType === msg?.chatType && uid === msg?.peerUid && msgSeq === msg?.msgSeq;
|
||
}
|
||
).catch(() => {
|
||
msg = undefined;
|
||
this.context.logger.logDebug('自操作消息撤回事件');
|
||
});
|
||
}
|
||
}
|
||
if (msg && element) {
|
||
const recallEvent = await this.emitRecallMsg(msg, element);
|
||
try {
|
||
if (recallEvent) {
|
||
await this.networkManager.emitEvent(recallEvent);
|
||
}
|
||
} catch (e) {
|
||
this.context.logger.logError('处理消息撤回失败', e);
|
||
}
|
||
}
|
||
};
|
||
msgListener.onKickedOffLine = async (kick) => {
|
||
const event = new BotOfflineEvent(this.core, kick.tipsTitle, kick.tipsDesc);
|
||
this.networkManager
|
||
.emitEvent(event)
|
||
.catch((e) => this.context.logger.logError('处理Bot掉线失败', e));
|
||
};
|
||
this.context.session.getMsgService().addKernelMsgListener(proxiedListenerOf(msgListener, this.context.logger));
|
||
}
|
||
|
||
private initBuddyListener() {
|
||
const buddyListener = new NodeIKernelBuddyListener();
|
||
|
||
buddyListener.onBuddyReqChange = async (reqs) => {
|
||
this.core.apis.FriendApi.clearBuddyReqUnreadCnt();
|
||
for (let i = 0; i < reqs.unreadNums; i++) {
|
||
const req = reqs.buddyReqs[i];
|
||
if (!req) continue;
|
||
if (!!req.isInitiator || (req.isDecide && req.reqType !== BuddyReqType.KMEINITIATORWAITPEERCONFIRM) || !req.isUnread) {
|
||
continue;
|
||
}
|
||
try {
|
||
const requesterUin = await this.core.apis.UserApi.getUinByUidV2(req.friendUid);
|
||
await this.networkManager.emitEvent(
|
||
new OB11FriendRequestEvent(
|
||
this.core,
|
||
+requesterUin,
|
||
req.extWords,
|
||
req.reqTime
|
||
)
|
||
);
|
||
} catch (e) {
|
||
this.context.logger.logDebug('获取加好友者QQ号失败', e);
|
||
}
|
||
}
|
||
};
|
||
this.context.session
|
||
.getBuddyService()
|
||
.addKernelBuddyListener(proxiedListenerOf(buddyListener, this.context.logger));
|
||
}
|
||
|
||
private initGroupListener() {
|
||
const groupListener = new NodeIKernelGroupListener();
|
||
|
||
groupListener.onGroupNotifiesUpdated = async (_, notifies) => {
|
||
await this.core.apis.GroupApi.clearGroupNotifiesUnreadCount(false);
|
||
if (!notifies[0]?.type) return;
|
||
if (
|
||
![
|
||
GroupNotifyMsgType.SET_ADMIN,
|
||
GroupNotifyMsgType.CANCEL_ADMIN_NOTIFY_CANCELED,
|
||
GroupNotifyMsgType.CANCEL_ADMIN_NOTIFY_ADMIN,
|
||
].includes(notifies[0]?.type)
|
||
) {
|
||
for (const notify of notifies) {
|
||
const notifyTime = parseInt(notify.seq) / 1000 / 1000;
|
||
// log(`群通知时间${notifyTime}`, `启动时间${this.bootTime}`);
|
||
if (notifyTime < this.bootTime) {
|
||
continue;
|
||
}
|
||
const flag = notify.seq;
|
||
this.context.logger.logDebug('收到群通知', notify);
|
||
if (
|
||
[GroupNotifyMsgType.REQUEST_JOIN_NEED_ADMINI_STRATOR_PASS].includes(notify.type) &&
|
||
notify.status === GroupNotifyMsgStatus.KUNHANDLE
|
||
) {
|
||
this.context.logger.logDebug('有加群请求');
|
||
try {
|
||
const requestUin = await this.core.apis.UserApi.getUinByUidV2(notify.user1.uid);
|
||
const groupRequestEvent = new OB11GroupRequestEvent(
|
||
this.core,
|
||
parseInt(notify.group.groupCode),
|
||
parseInt(requestUin),
|
||
'add',
|
||
notify.postscript,
|
||
flag
|
||
);
|
||
this.networkManager
|
||
.emitEvent(groupRequestEvent)
|
||
.catch((e) =>
|
||
this.context.logger.logError('处理加群请求失败', e)
|
||
);
|
||
} catch (e) {
|
||
this.context.logger.logError(
|
||
'获取加群人QQ号失败 Uid:',
|
||
notify.user1.uid,
|
||
e
|
||
);
|
||
}
|
||
} else if (
|
||
notify.type === GroupNotifyMsgType.INVITED_BY_MEMBER &&
|
||
notify.status === GroupNotifyMsgStatus.KUNHANDLE
|
||
) {
|
||
this.context.logger.logDebug(`收到邀请我加群通知:${notify}`);
|
||
const groupInviteEvent = new OB11GroupRequestEvent(
|
||
this.core,
|
||
+notify.group.groupCode,
|
||
+await this.core.apis.UserApi.getUinByUidV2(notify.user2.uid),
|
||
'invite',
|
||
notify.postscript,
|
||
flag
|
||
);
|
||
this.networkManager
|
||
.emitEvent(groupInviteEvent)
|
||
.catch((e) =>
|
||
this.context.logger.logError('处理邀请本人加群失败', e)
|
||
);
|
||
} else if (
|
||
notify.type === GroupNotifyMsgType.INVITED_NEED_ADMINI_STRATOR_PASS &&
|
||
notify.status === GroupNotifyMsgStatus.KUNHANDLE
|
||
) {
|
||
this.context.logger.logDebug(`收到群员邀请加群通知:${notify}`);
|
||
const groupInviteEvent = new OB11GroupRequestEvent(
|
||
this.core,
|
||
+notify.group.groupCode,
|
||
+await this.core.apis.UserApi.getUinByUidV2(notify.user1.uid),
|
||
'add',
|
||
notify.postscript,
|
||
flag
|
||
);
|
||
this.networkManager
|
||
.emitEvent(groupInviteEvent)
|
||
.catch((e) =>
|
||
this.context.logger.logError('处理邀请本人加群失败', e)
|
||
);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
this.context.session
|
||
.getGroupService()
|
||
.addKernelGroupListener(proxiedListenerOf(groupListener, this.context.logger));
|
||
}
|
||
|
||
private async emitMsg(message: RawMessage) {
|
||
const network = await this.networkManager.getAllConfig();
|
||
this.context.logger.logDebug('收到新消息 RawMessage', message);
|
||
await Promise.allSettled([
|
||
this.handleMsg(message, network),
|
||
message.chatType === ChatType.KCHATTYPEGROUP ? this.handleGroupEvent(message) : this.handlePrivateMsgEvent(message),
|
||
]);
|
||
}
|
||
|
||
private async handleMsg(message: RawMessage, network: Array<NetworkAdapterConfig>) {
|
||
// 过滤无效消息
|
||
if (message.msgType === NTMsgType.KMSGTYPENULL) {
|
||
return;
|
||
}
|
||
try {
|
||
const ob11Msg = await this.apis.MsgApi.parseMessageV2(message, this.configLoader.configData.parseMultMsg);
|
||
if (ob11Msg) {
|
||
const isSelfMsg = this.isSelfMessage(ob11Msg);
|
||
this.context.logger.logDebug('转化为 OB11Message', ob11Msg);
|
||
const msgMap = this.createMsgMap(network, ob11Msg, isSelfMsg, message);
|
||
this.handleDebugNetwork(network, msgMap, message);
|
||
this.handleNotReportSelfNetwork(network, msgMap, isSelfMsg);
|
||
this.networkManager.emitEventByNames(msgMap);
|
||
}
|
||
} catch (e) {
|
||
this.context.logger.logError('constructMessage error: ', e);
|
||
}
|
||
}
|
||
|
||
private isSelfMessage(ob11Msg: {
|
||
stringMsg: OB11Message;
|
||
arrayMsg: OB11Message;
|
||
}): boolean {
|
||
return ob11Msg.stringMsg.user_id.toString() === this.core.selfInfo.uin ||
|
||
ob11Msg.arrayMsg.user_id.toString() === this.core.selfInfo.uin;
|
||
}
|
||
|
||
private createMsgMap(network: Array<NetworkAdapterConfig>, ob11Msg: {
|
||
stringMsg: OB11Message;
|
||
arrayMsg: OB11Message;
|
||
}, isSelfMsg: boolean, message: RawMessage): Map<string, OB11Message> {
|
||
const msgMap: Map<string, OB11Message> = new Map();
|
||
network.filter(e => e.enable).forEach(e => {
|
||
if (isSelfMsg || message.chatType !== ChatType.KCHATTYPEGROUP) {
|
||
ob11Msg.stringMsg.target_id = parseInt(message.peerUin);
|
||
ob11Msg.arrayMsg.target_id = parseInt(message.peerUin);
|
||
}
|
||
if ('messagePostFormat' in e && e.messagePostFormat === 'string') {
|
||
msgMap.set(e.name, structuredClone(ob11Msg.stringMsg));
|
||
} else {
|
||
msgMap.set(e.name, structuredClone(ob11Msg.arrayMsg));
|
||
}
|
||
});
|
||
return msgMap;
|
||
}
|
||
|
||
private handleDebugNetwork(network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, message: RawMessage) {
|
||
const debugNetwork = network.filter(e => e.enable && e.debug);
|
||
if (debugNetwork.length > 0) {
|
||
debugNetwork.forEach(adapter => {
|
||
const msg = msgMap.get(adapter.name);
|
||
if (msg) {
|
||
msg.raw = message;
|
||
}
|
||
});
|
||
} else if (msgMap.size === 0) {
|
||
this.context.logger.logDebug('没有可用的网络适配器发送消息，消息内容:', message);
|
||
}
|
||
}
|
||
|
||
private handleNotReportSelfNetwork(network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, isSelfMsg: boolean) {
|
||
if (isSelfMsg) {
|
||
const notReportSelfNetwork = network.filter(e => e.enable && (('reportSelfMessage' in e && !e.reportSelfMessage) || !('reportSelfMessage' in e)));
|
||
notReportSelfNetwork.forEach(adapter => {
|
||
msgMap.delete(adapter.name);
|
||
});
|
||
}
|
||
}
|
||
|
||
private async handleGroupEvent(message: RawMessage) {
|
||
try {
|
||
// 群名片修改事件解析 任何都该判断
|
||
if (message.senderUin && message.senderUin !== '0') {
|
||
const cardChangedEvent = await this.apis.GroupApi.parseCardChangedEvent(message);
|
||
if (cardChangedEvent) {
|
||
await this.networkManager.emitEvent(cardChangedEvent);
|
||
}
|
||
}
|
||
if (message.msgType === NTMsgType.KMSGTYPEFILE) {
|
||
// 文件为单元素消息
|
||
const elementWrapper = message.elements.find(e => !!e.fileElement);
|
||
if (elementWrapper?.fileElement) {
|
||
const uploadGroupFileEvent = await this.apis.GroupApi.parseGroupUploadFileEvene(message, elementWrapper.fileElement, elementWrapper);
|
||
if (uploadGroupFileEvent) {
|
||
await this.networkManager.emitEvent(uploadGroupFileEvent);
|
||
}
|
||
}
|
||
} else if (message.msgType === NTMsgType.KMSGTYPEGRAYTIPS) {
|
||
// 灰条为单元素消息
|
||
const grayTipElement = message.elements[0]?.grayTipElement;
|
||
if (grayTipElement) {
|
||
const event = await this.apis.GroupApi.parseGrayTipElement(message, grayTipElement);
|
||
if (event) {
|
||
await this.networkManager.emitEvent(event);
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
this.context.logger.logError('constructGroupEvent error: ', e);
|
||
}
|
||
}
|
||
|
||
private async handlePrivateMsgEvent(message: RawMessage) {
|
||
try {
|
||
if (message.msgType === NTMsgType.KMSGTYPEGRAYTIPS) {
|
||
// 灰条为单元素消息
|
||
const grayTipElement = message.elements[0]?.grayTipElement;
|
||
if (grayTipElement) {
|
||
const event = await this.apis.MsgApi.parsePrivateMsgEvent(message, grayTipElement);
|
||
if (event) {
|
||
await this.networkManager.emitEvent(event);
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
this.context.logger.logError('constructPrivateEvent error: ', e);
|
||
}
|
||
}
|
||
|
||
private async emitRecallMsg(message: RawMessage, element: MessageElement) {
|
||
const peer: Peer = { chatType: message.chatType, peerUid: message.peerUid, guildId: '' };
|
||
const oriMessageId = MessageUnique.getShortIdByMsgId(message.msgId) ?? MessageUnique.createUniqueMsgId(peer, message.msgId);
|
||
if (message.chatType === ChatType.KCHATTYPEC2C) {
|
||
return await this.emitFriendRecallMsg(message, oriMessageId, element);
|
||
} else if (message.chatType === ChatType.KCHATTYPEGROUP) {
|
||
return await this.emitGroupRecallMsg(message, oriMessageId, element);
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
private async emitFriendRecallMsg(message: RawMessage, oriMessageId: number, element: MessageElement) {
|
||
const operatorUid = element.grayTipElement?.revokeElement.operatorUid;
|
||
if (!operatorUid) return undefined;
|
||
return new OB11FriendRecallNoticeEvent(
|
||
this.core,
|
||
+message.senderUin,
|
||
oriMessageId
|
||
);
|
||
}
|
||
|
||
private async emitGroupRecallMsg(message: RawMessage, oriMessageId: number, element: MessageElement) {
|
||
const operatorUid = element.grayTipElement?.revokeElement.operatorUid;
|
||
if (!operatorUid) return undefined;
|
||
const operatorId = await this.core.apis.UserApi.getUinByUidV2(operatorUid);
|
||
return new OB11GroupRecallNoticeEvent(
|
||
this.core,
|
||
+message.peerUin,
|
||
+message.senderUin,
|
||
+operatorId,
|
||
oriMessageId
|
||
);
|
||
}
|
||
}
|
||
|
||
export * from './types';
|