mirror of
https://github.com/NapNeko/NapCatQQ.git
synced 2024-11-21 09:36:35 +00:00
849 lines
32 KiB
TypeScript
849 lines
32 KiB
TypeScript
import { UUIDConverter } from '@/common/utils/helper';
|
||
import { MessageUnique } from '@/common/utils/message-unique';
|
||
import {
|
||
AtType,
|
||
ChatType,
|
||
CustomMusicSignPostData,
|
||
ElementType,
|
||
FaceIndex,
|
||
FaceType,
|
||
IdMusicSignPostData,
|
||
MessageElement,
|
||
NapCatCore,
|
||
Peer,
|
||
RawMessage,
|
||
SendMessageElement,
|
||
SendTextElement,
|
||
} from '@/core';
|
||
import faceConfig from '@/core/external/face_config.json';
|
||
import {
|
||
NapCatOneBot11Adapter,
|
||
OB11Message,
|
||
OB11MessageData,
|
||
OB11MessageDataType,
|
||
OB11MessageFileBase,
|
||
OB11MessageForward,
|
||
} from '@/onebot';
|
||
import { OB11Entities } from '../helper';
|
||
import { EventType } from '@/onebot/event/OB11BaseEvent';
|
||
import { encodeCQCode } from '@/onebot/helper/cqcode';
|
||
import { uri2local } from '@/common/utils/file';
|
||
import { RequestUtil } from '@/common/utils/request';
|
||
import fs from 'node:fs';
|
||
import fsPromise from 'node:fs/promises';
|
||
|
||
type RawToOb11Converters = {
|
||
[Key in keyof MessageElement as Key extends `${string}Element` ? Key : never]: (
|
||
element: Exclude<MessageElement[Key], null | undefined>,
|
||
msg: RawMessage,
|
||
elementWrapper: MessageElement,
|
||
) => PromiseLike<OB11MessageData | null>
|
||
}
|
||
|
||
type Ob11ToRawConverters = {
|
||
[Key in OB11MessageDataType]: (
|
||
sendMsg: Extract<OB11MessageData, { type: Key }>,
|
||
context: MessageContext,
|
||
) => Promise<SendMessageElement | undefined>
|
||
}
|
||
|
||
export type MessageContext = {
|
||
deleteAfterSentFiles: string[],
|
||
peer: Peer
|
||
}
|
||
|
||
function keyCanBeParsed(key: string, parser: RawToOb11Converters): key is keyof RawToOb11Converters {
|
||
return key in parser;
|
||
}
|
||
|
||
export class OneBotMsgApi {
|
||
obContext: NapCatOneBot11Adapter;
|
||
core: NapCatCore;
|
||
|
||
rawToOb11Converters: RawToOb11Converters = {
|
||
textElement: async element => {
|
||
if (element.atType === AtType.notAt) {
|
||
let text = element.content;
|
||
if (!text.trim()) {
|
||
return null;
|
||
}
|
||
// 兼容 9.7.x 换行符
|
||
if (text.indexOf('\n') === -1 && text.indexOf('\r\n') === -1) {
|
||
text = text.replace(/\r/g, '\n');
|
||
}
|
||
return {
|
||
type: OB11MessageDataType.text,
|
||
data: { text },
|
||
};
|
||
} else {
|
||
let qq: string = 'all';
|
||
if (element.atType !== AtType.atAll) {
|
||
const { atNtUid /* content */ } = element;
|
||
let atQQ = element.atUid;
|
||
if (!atQQ || atQQ === '0') {
|
||
atQQ = await this.core.apis.UserApi.getUinByUidV2(atNtUid);
|
||
}
|
||
if (atQQ) {
|
||
qq = atQQ as `${number}`;
|
||
}
|
||
}
|
||
return {
|
||
type: OB11MessageDataType.at,
|
||
data: {
|
||
qq: qq,
|
||
// name: content.slice(1);
|
||
},
|
||
};
|
||
}
|
||
},
|
||
|
||
picElement: async (element, msg) => {
|
||
try {
|
||
return {
|
||
type: OB11MessageDataType.image,
|
||
data: {
|
||
file: element.fileName,
|
||
sub_type: element.picSubType,
|
||
file_id: UUIDConverter.encode(msg.peerUin, msg.msgId),
|
||
url: await this.core.apis.FileApi.getImageUrl(element),
|
||
file_size: element.fileSize,
|
||
},
|
||
};
|
||
} catch (e: any) {
|
||
this.core.context.logger.logError('获取图片url失败', e.stack);
|
||
return null;
|
||
}
|
||
},
|
||
|
||
fileElement: async (element, msg, elementWrapper) => {
|
||
await this.core.apis.FileApi.addFileCache(
|
||
{
|
||
peerUid: msg.peerUid,
|
||
chatType: msg.chatType,
|
||
guildId: '',
|
||
},
|
||
msg.msgId,
|
||
msg.msgSeq,
|
||
msg.senderUid,
|
||
elementWrapper.elementId,
|
||
elementWrapper.elementType.toString(),
|
||
element.fileSize,
|
||
element.fileName,
|
||
);
|
||
return {
|
||
type: OB11MessageDataType.file,
|
||
data: {
|
||
file: element.fileName,
|
||
path: element.filePath,
|
||
url: element.filePath,
|
||
file_id: UUIDConverter.encode(msg.peerUin, msg.msgId),
|
||
file_size: element.fileSize,
|
||
},
|
||
};
|
||
},
|
||
|
||
faceElement: async element => {
|
||
const faceIndex = element.faceIndex;
|
||
if (faceIndex === FaceIndex.dice) {
|
||
return {
|
||
type: OB11MessageDataType.dice,
|
||
data: {
|
||
result: element.resultId!,
|
||
},
|
||
};
|
||
} else if (faceIndex === FaceIndex.RPS) {
|
||
return {
|
||
type: OB11MessageDataType.RPS,
|
||
data: {
|
||
result: element.resultId!,
|
||
},
|
||
};
|
||
} else {
|
||
return {
|
||
type: OB11MessageDataType.face,
|
||
data: {
|
||
id: element.faceIndex.toString(),
|
||
},
|
||
};
|
||
}
|
||
},
|
||
|
||
marketFaceElement: async (_, msg, elementWrapper) => {
|
||
await this.core.apis.FileApi.addFileCache(
|
||
{
|
||
peerUid: msg.peerUid,
|
||
chatType: msg.chatType,
|
||
guildId: '',
|
||
},
|
||
msg.msgId,
|
||
msg.msgSeq,
|
||
msg.senderUid,
|
||
elementWrapper.elementId,
|
||
elementWrapper.elementType.toString(),
|
||
'0',
|
||
'marketface',
|
||
);
|
||
return {
|
||
type: OB11MessageDataType.image,
|
||
data: {
|
||
file: 'marketface',
|
||
file_id: UUIDConverter.encode(msg.peerUin, msg.msgId),
|
||
path: elementWrapper.elementId,
|
||
url: elementWrapper.elementId,
|
||
},
|
||
};
|
||
},
|
||
|
||
replyElement: async (element, msg) => {
|
||
const NTQQMsgApi = this.core.apis.MsgApi;
|
||
const records = msg.records.find(msgRecord => msgRecord.msgId === element?.sourceMsgIdInRecords);
|
||
const peer = {
|
||
chatType: msg.chatType,
|
||
peerUid: msg.peerUid,
|
||
guildId: '',
|
||
};
|
||
if (!records) {
|
||
this.core.context.logger.logError('获取不到引用的消息', element.replayMsgSeq);
|
||
return null;
|
||
}
|
||
let replyMsg: RawMessage | undefined;
|
||
// Attempt 1
|
||
replyMsg = (await NTQQMsgApi.getMsgsBySeqAndCount({
|
||
peerUid: msg.peerUid,
|
||
guildId: '',
|
||
chatType: msg.chatType,
|
||
}, element.replayMsgSeq, 1, true, true))
|
||
.msgList
|
||
.find(msg => msg.msgRandom === records.msgRandom);
|
||
|
||
if (!replyMsg || records.msgRandom !== replyMsg.msgRandom) {
|
||
// Attempt 2
|
||
replyMsg = (await NTQQMsgApi.getSingleMsg(peer, element.replayMsgSeq)).msgList[0];
|
||
|
||
if ((!replyMsg || records.msgRandom !== replyMsg.msgRandom) && msg.peerUin !== '284840486') {
|
||
// Attempt 3
|
||
const replyMsgList = (await NTQQMsgApi.getMsgExBySeq(peer, records.msgSeq)).msgList;
|
||
if (replyMsgList.length < 1) {
|
||
this.core.context.logger.logError('回复消息消息验证失败', element.replayMsgSeq);
|
||
return null;
|
||
}
|
||
replyMsg = replyMsgList.filter(e => e.msgSeq == records.msgSeq)
|
||
.sort((a, b) => parseInt(a.msgTime) - parseInt(b.msgTime))[0];
|
||
}
|
||
}
|
||
|
||
return {
|
||
type: OB11MessageDataType.reply,
|
||
data: {
|
||
id: MessageUnique.createMsg({
|
||
peerUid: msg.peerUid,
|
||
guildId: '',
|
||
chatType: msg.chatType,
|
||
}, replyMsg.msgId).toString(),
|
||
},
|
||
};
|
||
},
|
||
|
||
videoElement: async (element, msg, elementWrapper) => {
|
||
const NTQQFileApi = this.core.apis.FileApi;
|
||
|
||
//读取视频链接并兜底
|
||
let videoUrlWrappers: Awaited<ReturnType<typeof NTQQFileApi.getVideoUrl>> | undefined;
|
||
|
||
if (msg.peerUin === '284840486') {
|
||
//TODO: 合并消息内部 应该进行特殊处理 可能需要重写peer 待测试与研究 Mlikiowa Tagged
|
||
}
|
||
try {
|
||
videoUrlWrappers = await NTQQFileApi.getVideoUrl({
|
||
chatType: msg.chatType,
|
||
peerUid: msg.peerUid,
|
||
guildId: '0',
|
||
}, msg.msgId, elementWrapper.elementId);
|
||
} catch (error) {
|
||
this.core.context.logger.logWarn('获取视频 URL 失败');
|
||
}
|
||
|
||
//读取在线URL
|
||
let videoDownUrl: string | undefined;
|
||
|
||
if (videoUrlWrappers) {
|
||
const videoDownUrlTemp = videoUrlWrappers.find((urlWrapper) => {
|
||
return !!(urlWrapper.url);
|
||
});
|
||
if (videoDownUrlTemp) {
|
||
videoDownUrl = videoDownUrlTemp.url;
|
||
}
|
||
}
|
||
|
||
//开始兜底
|
||
if (!videoDownUrl) {
|
||
videoDownUrl = element.filePath;
|
||
}
|
||
|
||
await NTQQFileApi.addFileCache(
|
||
{
|
||
peerUid: msg.peerUid,
|
||
chatType: msg.chatType,
|
||
guildId: '',
|
||
},
|
||
msg.msgId,
|
||
msg.msgSeq,
|
||
msg.senderUid,
|
||
elementWrapper.elementId,
|
||
elementWrapper.elementType.toString(),
|
||
element.fileSize ?? '0',
|
||
element.fileName,
|
||
);
|
||
|
||
return {
|
||
type: OB11MessageDataType.video,
|
||
data: {
|
||
file: element.fileName,
|
||
path: videoDownUrl,
|
||
url: videoDownUrl,
|
||
file_id: UUIDConverter.encode(msg.peerUin, msg.msgId),
|
||
file_size: element.fileSize,
|
||
},
|
||
};
|
||
},
|
||
|
||
pttElement: async (element, msg, elementWrapper) => {
|
||
await this.core.apis.FileApi.addFileCache(
|
||
{
|
||
peerUid: msg.peerUid,
|
||
chatType: msg.chatType,
|
||
guildId: '',
|
||
},
|
||
msg.msgId,
|
||
msg.msgSeq,
|
||
msg.senderUid,
|
||
elementWrapper.elementId,
|
||
elementWrapper.elementType.toString(),
|
||
element.fileSize || '0',
|
||
element.fileUuid || '',
|
||
);
|
||
return {
|
||
type: OB11MessageDataType.voice,
|
||
data: {
|
||
file: element.fileName,
|
||
path: element.filePath,
|
||
file_id: UUIDConverter.encode(msg.peerUin, msg.msgId),
|
||
file_size: element.fileSize,
|
||
},
|
||
};
|
||
},
|
||
|
||
multiForwardMsgElement: async (_, msg) => {
|
||
const NTQQMsgApi = this.core.apis.MsgApi;
|
||
const message_data: OB11MessageForward = {
|
||
data: {} as any,
|
||
type: OB11MessageDataType.forward,
|
||
};
|
||
message_data.data.id = msg.msgId;
|
||
const parentMsgPeer = msg.parentMsgPeer ?? {
|
||
chatType: msg.chatType,
|
||
guildId: '',
|
||
peerUid: msg.peerUid,
|
||
};
|
||
//判断是否在合并消息内
|
||
msg.parentMsgIdList = msg.parentMsgIdList ?? [];
|
||
//首次列表不存在则开始创建
|
||
msg.parentMsgIdList.push(msg.msgId);
|
||
//let parentMsgId = msg.parentMsgIdList[msg.parentMsgIdList.length - 2 < 0 ? 0 : msg.parentMsgIdList.length - 2];
|
||
//加入自身MsgId
|
||
const multiMsgs = (await NTQQMsgApi.getMultiMsg(parentMsgPeer, msg.parentMsgIdList[0], msg.msgId))?.msgList;
|
||
//拉取下级消息
|
||
if (!multiMsgs) return null;
|
||
//拉取失败则跳过
|
||
|
||
return {
|
||
type: OB11MessageDataType.forward,
|
||
data: {
|
||
id: msg.msgId,
|
||
content: (await Promise.all(multiMsgs.map(
|
||
async multiMsgItem => {
|
||
multiMsgItem.parentMsgPeer = parentMsgPeer;
|
||
multiMsgItem.parentMsgIdList = msg.parentMsgIdList;
|
||
multiMsgItem.id = MessageUnique.createMsg(parentMsgPeer, multiMsgItem.msgId); //该ID仅用查看 无法调用
|
||
return await this.parseMessage(multiMsgItem);
|
||
},
|
||
))).filter(item => item !== undefined),
|
||
},
|
||
};
|
||
},
|
||
|
||
arkElement: async (element) => {
|
||
return {
|
||
type: OB11MessageDataType.json,
|
||
data: {
|
||
data: element.bytesData,
|
||
},
|
||
};
|
||
},
|
||
|
||
markdownElement: async (element) => {
|
||
return {
|
||
type: OB11MessageDataType.markdown,
|
||
data: {
|
||
content: element.content,
|
||
},
|
||
};
|
||
},
|
||
};
|
||
|
||
ob11ToRawConverters: Ob11ToRawConverters = {
|
||
[OB11MessageDataType.text]: async ({ data: { text } }) => ({
|
||
elementType: ElementType.TEXT,
|
||
elementId: '',
|
||
textElement: {
|
||
content: text,
|
||
atType: AtType.notAt,
|
||
atUid: '',
|
||
atTinyId: '',
|
||
atNtUid: '',
|
||
},
|
||
}),
|
||
|
||
[OB11MessageDataType.at]: async ({ data: { qq: atQQ } }, context) => {
|
||
function at(atUid: string, atNtUid: string, atType: AtType, atName: string): SendTextElement {
|
||
return {
|
||
elementType: ElementType.TEXT,
|
||
elementId: '',
|
||
textElement: {
|
||
content: `@${atName}`,
|
||
atType,
|
||
atUid,
|
||
atTinyId: '',
|
||
atNtUid,
|
||
},
|
||
};
|
||
}
|
||
|
||
if (!context.peer || context.peer.chatType == ChatType.KCHATTYPEC2C) return undefined;
|
||
if (atQQ === 'all') return at(atQQ, atQQ, AtType.atAll, '全体成员');
|
||
const NTQQGroupApi = this.core.apis.GroupApi;
|
||
const NTQQUserApi = this.core.apis.UserApi;
|
||
const atMember = await NTQQGroupApi.getGroupMember(context.peer.peerUid, atQQ);
|
||
if (atMember) {
|
||
return at(atQQ, atMember.uid, AtType.atUser, atMember.nick || atMember.cardName);
|
||
}
|
||
const uid = await NTQQUserApi.getUidByUinV2(`${atQQ}`);
|
||
if (!uid) throw new Error('Get Uid Error');
|
||
const info = await NTQQUserApi.getUserDetailInfo(uid);
|
||
return at(atQQ, uid, AtType.atUser, info.nick || '');
|
||
},
|
||
|
||
[OB11MessageDataType.reply]: async ({ data: { id } }) => {
|
||
const replyMsgM = MessageUnique.getMsgIdAndPeerByShortId(parseInt(id));
|
||
if (!replyMsgM) {
|
||
this.core.context.logger.logWarn('回复消息不存在', id);
|
||
return undefined;
|
||
}
|
||
const NTQQMsgApi = this.core.apis.MsgApi;
|
||
const replyMsg = (await NTQQMsgApi.getMsgsByMsgId(
|
||
replyMsgM.Peer, [replyMsgM.MsgId])).msgList[0];
|
||
return replyMsg ?
|
||
{
|
||
elementType: ElementType.REPLY,
|
||
elementId: '',
|
||
replyElement: {
|
||
replayMsgSeq: replyMsg.msgSeq, // raw.msgSeq
|
||
replayMsgId: replyMsg.msgId, // raw.msgId
|
||
senderUin: replyMsg.senderUin,
|
||
senderUinStr: replyMsg.senderUin,
|
||
},
|
||
} :
|
||
undefined;
|
||
},
|
||
|
||
[OB11MessageDataType.face]: async ({ data: { id } }) => {
|
||
let parsedFaceId = parseInt(id);
|
||
// 从face_config.json中获取表情名称
|
||
const sysFaces = faceConfig.sysface;
|
||
const face: any = sysFaces.find((systemFace) => systemFace.QSid === parsedFaceId.toString());
|
||
parsedFaceId = parseInt(parsedFaceId.toString());
|
||
let faceType = 1;
|
||
if (parsedFaceId >= 222) {
|
||
faceType = 2;
|
||
}
|
||
if (face.AniStickerType) {
|
||
faceType = 3;
|
||
}
|
||
return {
|
||
elementType: ElementType.FACE,
|
||
elementId: '',
|
||
faceElement: {
|
||
faceIndex: parsedFaceId,
|
||
faceType,
|
||
faceText: face.QDes,
|
||
stickerId: face.AniStickerId,
|
||
stickerType: face.AniStickerType,
|
||
packId: face.AniStickerPackId,
|
||
sourceType: 1,
|
||
},
|
||
};
|
||
},
|
||
|
||
[OB11MessageDataType.mface]: async ({
|
||
data: {
|
||
emoji_package_id, emoji_id, key, summary,
|
||
},
|
||
}) => ({
|
||
elementType: ElementType.MFACE,
|
||
marketFaceElement: {
|
||
emojiPackageId: emoji_package_id,
|
||
emojiId: emoji_id,
|
||
key,
|
||
faceName: summary || '[商城表情]',
|
||
},
|
||
}),
|
||
|
||
// File service
|
||
[OB11MessageDataType.image]: async (sendMsg, context) => {
|
||
const sendPicElement = await this.core.apis.FileApi.createValidSendPicElement(
|
||
(await this.handleOb11FileLikeMessage(sendMsg, context)).path,
|
||
sendMsg.data.summary,
|
||
sendMsg.data.sub_type,
|
||
);
|
||
context.deleteAfterSentFiles.push(sendPicElement.picElement.sourcePath);
|
||
return sendPicElement;
|
||
},
|
||
|
||
[OB11MessageDataType.file]: async (sendMsg, context) => {
|
||
const { path, fileName } = await this.handleOb11FileLikeMessage(sendMsg, context);
|
||
return await this.core.apis.FileApi.createValidSendFileElement(path, fileName);
|
||
},
|
||
|
||
[OB11MessageDataType.video]: async (sendMsg, context) => {
|
||
const { path, fileName } = await this.handleOb11FileLikeMessage(sendMsg, context);
|
||
|
||
let thumb = sendMsg.data.thumb;
|
||
if (thumb) {
|
||
const uri2LocalRes = await uri2local(this.core.NapCatTempPath, thumb);
|
||
if (uri2LocalRes.success) thumb = uri2LocalRes.path;
|
||
}
|
||
const videoEle = await this.core.apis.FileApi.createValidSendVideoElement(path, fileName, thumb);
|
||
|
||
context.deleteAfterSentFiles.push(videoEle.videoElement.filePath);
|
||
return videoEle;
|
||
},
|
||
|
||
[OB11MessageDataType.voice]: async (sendMsg, context) =>
|
||
this.core.apis.FileApi.createValidSendPttElement(
|
||
(await this.handleOb11FileLikeMessage(sendMsg, context)).path),
|
||
|
||
[OB11MessageDataType.json]: async ({ data: { data } }) => ({
|
||
elementType: ElementType.ARK,
|
||
elementId: '',
|
||
arkElement: {
|
||
bytesData: typeof data === 'string' ? data : JSON.stringify(data),
|
||
linkInfo: null,
|
||
subElementType: null,
|
||
},
|
||
}),
|
||
|
||
[OB11MessageDataType.dice]: async () => ({
|
||
elementType: ElementType.FACE,
|
||
elementId: '',
|
||
faceElement: {
|
||
faceIndex: FaceIndex.dice,
|
||
faceType: FaceType.dice,
|
||
'faceText': '[骰子]',
|
||
'packId': '1',
|
||
'stickerId': '33',
|
||
'sourceType': 1,
|
||
'stickerType': 2,
|
||
// resultId: resultId.toString(),
|
||
'surpriseId': '',
|
||
// "randomType": 1,
|
||
},
|
||
}),
|
||
|
||
[OB11MessageDataType.RPS]: async () => ({
|
||
elementType: ElementType.FACE,
|
||
elementId: '',
|
||
faceElement: {
|
||
'faceIndex': FaceIndex.RPS,
|
||
'faceText': '[包剪锤]',
|
||
'faceType': 3,
|
||
'packId': '1',
|
||
'stickerId': '34',
|
||
'sourceType': 1,
|
||
'stickerType': 2,
|
||
// 'resultId': resultId.toString(),
|
||
'surpriseId': '',
|
||
// "randomType": 1,
|
||
},
|
||
}),
|
||
|
||
// Need signing
|
||
[OB11MessageDataType.markdown]: async ({ data: { content } }) => ({
|
||
elementType: ElementType.MARKDOWN,
|
||
elementId: '',
|
||
markdownElement: { content },
|
||
}),
|
||
|
||
[OB11MessageDataType.music]: async ({ data }, context) => {
|
||
// 保留, 直到...找到更好的解决方案
|
||
if (data.type === 'custom') {
|
||
if (!data.url) {
|
||
this.core.context.logger.logError('自定义音卡缺少参数url');
|
||
return undefined;
|
||
}
|
||
if (!data.audio) {
|
||
this.core.context.logger.logError('自定义音卡缺少参数audio');
|
||
return undefined;
|
||
}
|
||
if (!data.title) {
|
||
this.core.context.logger.logError('自定义音卡缺少参数title');
|
||
return undefined;
|
||
}
|
||
} else {
|
||
if (!['qq', '163'].includes(data.type)) {
|
||
this.core.context.logger.logError('音乐卡片type错误, 只支持qq、163、custom，当前type:', data.type);
|
||
return undefined;
|
||
}
|
||
if (!data.id) {
|
||
this.core.context.logger.logError('音乐卡片缺少参数id');
|
||
return undefined;
|
||
}
|
||
}
|
||
|
||
let postData: IdMusicSignPostData | CustomMusicSignPostData;
|
||
if (data.type === 'custom' && data.content) {
|
||
const { content, ...others } = data;
|
||
postData = { singer: content, ...others };
|
||
} else {
|
||
postData = data;
|
||
}
|
||
const signUrl = this.obContext.configLoader.configData.musicSignUrl;
|
||
if (!signUrl) {
|
||
throw Error('音乐消息签名地址未配置');
|
||
}
|
||
try {
|
||
const musicJson = await RequestUtil.HttpGetJson<any>(signUrl, 'POST', postData);
|
||
return this.ob11ToRawConverters.json({
|
||
data: { data: musicJson },
|
||
type: OB11MessageDataType.json
|
||
}, context);
|
||
} catch (e) {
|
||
this.core.context.logger.logError('生成音乐消息失败', e);
|
||
}
|
||
},
|
||
|
||
[OB11MessageDataType.node]: async () => undefined,
|
||
|
||
[OB11MessageDataType.forward]: async () => undefined,
|
||
|
||
[OB11MessageDataType.xml]: async () => undefined,
|
||
|
||
[OB11MessageDataType.poke]: async () => undefined,
|
||
|
||
[OB11MessageDataType.Location]: async () => ({
|
||
elementType: ElementType.SHARELOCATION,
|
||
elementId: '',
|
||
shareLocationElement: {
|
||
text: '测试',
|
||
ext: '',
|
||
},
|
||
}),
|
||
|
||
[OB11MessageDataType.miniapp]: async () => undefined,
|
||
};
|
||
|
||
constructor(obContext: NapCatOneBot11Adapter, core: NapCatCore) {
|
||
this.obContext = obContext;
|
||
this.core = core;
|
||
}
|
||
|
||
async parseMessage(
|
||
msg: RawMessage,
|
||
messagePostFormat: string = this.obContext.configLoader.configData.messagePostFormat,
|
||
) {
|
||
if (msg.senderUin == '0' || msg.senderUin == '') return;
|
||
if (msg.peerUin == '0' || msg.peerUin == '') return;
|
||
//跳过空消息
|
||
const NTQQGroupApi = this.core.apis.GroupApi;
|
||
const NTQQUserApi = this.core.apis.UserApi;
|
||
const NTQQMsgApi = this.core.apis.MsgApi;
|
||
const resMsg: OB11Message = {
|
||
self_id: parseInt(this.core.selfInfo.uin),
|
||
user_id: parseInt(msg.senderUin!),
|
||
time: parseInt(msg.msgTime) || Date.now(),
|
||
message_id: msg.id!,
|
||
message_seq: msg.id!,
|
||
real_id: msg.id!,
|
||
message_type: msg.chatType == ChatType.KCHATTYPEGROUP ? 'group' : 'private',
|
||
sender: {
|
||
user_id: parseInt(msg.senderUin || '0'),
|
||
nickname: msg.sendNickName,
|
||
card: msg.sendMemberName || '',
|
||
},
|
||
raw_message: '',
|
||
font: 14,
|
||
sub_type: 'friend',
|
||
message: messagePostFormat === 'string' ? '' : [],
|
||
message_format: messagePostFormat === 'string' ? 'string' : 'array',
|
||
post_type: this.core.selfInfo.uin == msg.senderUin ? EventType.MESSAGE_SENT : EventType.MESSAGE,
|
||
};
|
||
if (msg.chatType == ChatType.KCHATTYPEGROUP) {
|
||
resMsg.sub_type = 'normal'; // 这里go-cqhttp是group，而onebot11标准是normal, 蛋疼
|
||
resMsg.group_id = parseInt(msg.peerUin);
|
||
let member = await NTQQGroupApi.getGroupMember(msg.peerUin, msg.senderUin);
|
||
if (!member) member = await NTQQGroupApi.getGroupMember(msg.peerUin, msg.senderUin);
|
||
if (member) {
|
||
resMsg.sender.role = OB11Entities.groupMemberRole(member.role);
|
||
resMsg.sender.nickname = member.nick;
|
||
}
|
||
} else if (msg.chatType == ChatType.KCHATTYPEC2C) {
|
||
resMsg.sub_type = 'friend';
|
||
resMsg.sender.nickname = (await NTQQUserApi.getUserDetailInfo(msg.senderUid)).nick;
|
||
} else if (msg.chatType == ChatType.KCHATTYPETEMPC2CFROMGROUP) {
|
||
resMsg.sub_type = 'group';
|
||
const ret = await NTQQMsgApi.getTempChatInfo(ChatType.KCHATTYPETEMPC2CFROMGROUP, msg.senderUid);
|
||
if (ret.result === 0) {
|
||
resMsg.group_id = parseInt(ret.tmpChatInfo!.groupCode);
|
||
resMsg.sender.nickname = ret.tmpChatInfo!.fromNick;
|
||
} else {
|
||
resMsg.group_id = 284840486; //兜底数据
|
||
resMsg.sender.nickname = '临时会话';
|
||
}
|
||
}
|
||
|
||
const msgSegments = (await Promise.allSettled(msg.elements.map(
|
||
async (element) => {
|
||
for (const key in element) {
|
||
if (keyCanBeParsed(key, this.rawToOb11Converters) && element[key]) {
|
||
return await this.rawToOb11Converters[key]?.(
|
||
// eslint-disable-next-line
|
||
// @ts-ignore
|
||
element[key],
|
||
msg,
|
||
element,
|
||
);
|
||
}
|
||
}
|
||
},
|
||
))).filter(entry => {
|
||
if (entry.status === 'fulfilled') {
|
||
return !!entry.value;
|
||
} else {
|
||
this.core.context.logger.logError('消息段解析失败', entry.reason);
|
||
return false;
|
||
}
|
||
}).map((entry) => (<PromiseFulfilledResult<OB11MessageData>>entry).value);
|
||
|
||
const msgAsCQCode = msgSegments.map(msg => encodeCQCode(msg)).join('').trim();
|
||
|
||
if (messagePostFormat === 'string') {
|
||
resMsg.message = msgAsCQCode;
|
||
resMsg.raw_message = msgAsCQCode;
|
||
} else {
|
||
resMsg.message = msgSegments;
|
||
resMsg.raw_message = msgAsCQCode;
|
||
}
|
||
return resMsg;
|
||
}
|
||
|
||
async createSendElements(
|
||
messageData: OB11MessageData[],
|
||
peer: Peer,
|
||
ignoreTypes: OB11MessageDataType[] = [],
|
||
) {
|
||
const deleteAfterSentFiles: string[] = [];
|
||
const callResultList: Array<Promise<SendMessageElement | undefined>> = [];
|
||
for (const sendMsg of messageData) {
|
||
if (ignoreTypes.includes(sendMsg.type)) {
|
||
continue;
|
||
}
|
||
const callResult = this.ob11ToRawConverters[sendMsg.type](
|
||
// eslint-disable-next-line
|
||
// @ts-ignore
|
||
sendMsg,
|
||
{ peer, deleteAfterSentFiles },
|
||
)?.catch(undefined);
|
||
callResultList.push(callResult);
|
||
}
|
||
const ret = await Promise.all(callResultList);
|
||
const sendElements: SendMessageElement[] = ret.filter(ele => !!ele);
|
||
return { sendElements, deleteAfterSentFiles };
|
||
}
|
||
|
||
async sendMsgWithOb11UniqueId(peer: Peer, sendElements: SendMessageElement[], deleteAfterSentFiles: string[], waitComplete = true) {
|
||
if (!sendElements.length) {
|
||
throw new Error('消息体无法解析, 请检查是否发送了不支持的消息类型');
|
||
}
|
||
let totalSize = 0;
|
||
let timeout = 10000;
|
||
try {
|
||
for (const fileElement of sendElements) {
|
||
if (fileElement.elementType === ElementType.PTT) {
|
||
totalSize += fs.statSync(fileElement.pttElement.filePath).size;
|
||
}
|
||
if (fileElement.elementType === ElementType.FILE) {
|
||
totalSize += fs.statSync(fileElement.fileElement.filePath).size;
|
||
}
|
||
if (fileElement.elementType === ElementType.VIDEO) {
|
||
totalSize += fs.statSync(fileElement.videoElement.filePath).size;
|
||
}
|
||
if (fileElement.elementType === ElementType.PIC) {
|
||
totalSize += fs.statSync(fileElement.picElement.sourcePath).size;
|
||
}
|
||
}
|
||
//且 PredictTime ((totalSize / 1024 / 512) * 1000)不等于Nan
|
||
const PredictTime = totalSize / 1024 / 256 * 1000;
|
||
if (!Number.isNaN(PredictTime)) {
|
||
timeout += PredictTime;// 10S Basic Timeout + PredictTime( For File 512kb/s )
|
||
}
|
||
} catch (e) {
|
||
this.core.context.logger.logError('发送消息计算预计时间异常', e);
|
||
}
|
||
const returnMsg = await this.core.apis.MsgApi.sendMsg(peer, sendElements, waitComplete, timeout);
|
||
try {
|
||
returnMsg!.id = MessageUnique.createMsg({
|
||
chatType: peer.chatType,
|
||
guildId: '',
|
||
peerUid: peer.peerUid,
|
||
}, returnMsg!.msgId);
|
||
} catch (e: any) {
|
||
this.core.context.logger.logDebug('发送消息id获取失败', e);
|
||
returnMsg!.id = 0;
|
||
}
|
||
deleteAfterSentFiles.forEach(file => {
|
||
fsPromise.unlink(file).then().catch(e => this.core.context.logger.logError('发送消息删除文件失败', e));
|
||
});
|
||
return returnMsg;
|
||
}
|
||
|
||
private async handleOb11FileLikeMessage(
|
||
{ data: inputdata }: OB11MessageFileBase,
|
||
{ deleteAfterSentFiles }: MessageContext,
|
||
) {
|
||
const isBlankUrl = !inputdata.url || inputdata.url === '';
|
||
const isBlankFile = !inputdata.file || inputdata.file === '';
|
||
if (isBlankUrl && isBlankFile) {
|
||
this.core.context.logger.logError('文件消息缺少参数', inputdata);
|
||
throw Error('文件消息缺少参数');
|
||
}
|
||
const fileOrUrl = (isBlankUrl ? inputdata.file : inputdata.url) ?? '';
|
||
const {
|
||
path,
|
||
isLocal,
|
||
fileName,
|
||
errMsg,
|
||
success,
|
||
} = (await uri2local(this.core.NapCatTempPath, fileOrUrl));
|
||
|
||
if (!success) {
|
||
this.core.context.logger.logError('文件下载失败', errMsg);
|
||
throw Error('文件下载失败' + errMsg);
|
||
}
|
||
|
||
if (!isLocal) { // 只删除http和base64转过来的文件
|
||
deleteAfterSentFiles.push(path);
|
||
}
|
||
|
||
return { path, fileName: inputdata.name ?? fileName };
|
||
}
|
||
}
|