wechaty-puppet-matrix 0.0.4

package/src/matrix/schema-mapper/message/message-parser-appmsg.ts

@@ -0,0 +1,78 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload  } from '../../../engine-schema.js'
+
+import { log } from '@juzi/wechaty-puppet'
+import { LOGPRE, MessageParser, MessageParserContext } from './message-parser.js'
+import { AppMessageType, parseAppmsgMessagePayload } from '../../messages/message-appmsg.js'
+import { getFileName } from '../../utils/index.js'
+
+export const appMsgParser: MessageParser = async (engineMessage: MessagePayload, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+  if (ret.type !== PUPPET.types.Message.Attachment) {
+    return ret
+  }
+
+  try {
+    if (engineMessage.msg.includes('[file=')) {
+      const reg = /\[file=(.+)]/
+      const res = engineMessage.msg && reg.exec(engineMessage.msg)
+      const path = res?.[1]
+      if (path) {
+        ret.type = PUPPET.types.Message.Attachment
+        ret.filename = getFileName(path)
+        return ret
+      }
+      ret.type = PUPPET.types.Message.Attachment
+      ret.filename = ''
+      return ret
+    }
+    const appPayload = await parseAppmsgMessagePayload(engineMessage.msg)
+    context.appMessagePayload = appPayload
+
+    switch (appPayload.type) {
+      case AppMessageType.Text:
+        ret.type = PUPPET.types.Message.Text
+        ret.text = appPayload.title
+        break
+      case AppMessageType.Audio:
+        ret.type = PUPPET.types.Message.Url
+        break
+      case AppMessageType.Video:
+        ret.type = PUPPET.types.Message.Url
+        break
+      case AppMessageType.Url:
+        ret.type = PUPPET.types.Message.Url
+        break
+      case AppMessageType.Attach:
+        ret.type = PUPPET.types.Message.Attachment
+        ret.filename = appPayload.title
+        break
+      case AppMessageType.ChatHistory:
+        ret.type = PUPPET.types.Message.ChatHistory
+        break
+      case AppMessageType.MiniProgram:
+      case AppMessageType.MiniProgramApp:
+        ret.type = PUPPET.types.Message.MiniProgram
+        break
+      case AppMessageType.RedEnvelopes:
+        ret.type = PUPPET.types.Message.RedEnvelope
+        break
+      case AppMessageType.Transfers:
+        ret.type = PUPPET.types.Message.Transfer
+        break
+      case AppMessageType.RealtimeShareLocation:
+        ret.type = PUPPET.types.Message.Location
+        break
+      case AppMessageType.GroupNote:
+        ret.type = PUPPET.types.Message.GroupNote
+        ret.text = appPayload.title
+        break
+      default:
+        ret.type = PUPPET.types.Message.Unknown
+        break
+    }
+  } catch (e) {
+    log.warn(LOGPRE, `Error occurred while parse message attachment: ${JSON.stringify(engineMessage)} , ${(e as Error).stack}`)
+  }
+
+  return ret
+}

package/src/matrix/schema-mapper/message/message-parser-refermsg.ts

@@ -0,0 +1,53 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload  } from '../../../engine-schema.js'
+import { AppMessageType, parseAppmsgMessagePayload, ReferMsgPayload } from '../../messages/message-appmsg.js'
+import { WechatMessageType } from '../../types.js'
+import type { MessageParser, MessageParserContext } from './message-parser.js'
+
+export const referMsgParser: MessageParser = async (_padLocalMessage:  MessagePayload, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+  if (!context.appMessagePayload || context.appMessagePayload.type !== AppMessageType.ReferMsg) {
+    return ret
+  }
+
+  const appPayload = context.appMessagePayload
+
+  let referMessageContent: string
+
+  const referMessagePayload: ReferMsgPayload = appPayload.refermsg!
+  const referMessageType = parseInt(referMessagePayload.type) as WechatMessageType
+  switch (referMessageType) {
+    case WechatMessageType.Text:
+      referMessageContent = referMessagePayload.content
+      break
+    case WechatMessageType.Image:
+      referMessageContent = '图片'
+      break
+
+    case WechatMessageType.Video:
+      referMessageContent = '视频'
+      break
+
+    case WechatMessageType.Emoticon:
+      referMessageContent = '动画表情'
+      break
+
+    case WechatMessageType.Location:
+      referMessageContent = '位置'
+      break
+
+    case WechatMessageType.App: {
+      const referMessageAppPayload = await parseAppmsgMessagePayload(referMessagePayload.content)
+      referMessageContent = referMessageAppPayload.title
+      break
+    }
+
+    default:
+      referMessageContent = '未知消息'
+      break
+  }
+
+  ret.type = PUPPET.types.Message.Text
+  ret.text = `「${referMessagePayload.displayname}：${referMessageContent}」\n- - - - - - - - - - - - - - -\n${appPayload.title}`
+
+  return ret
+}

package/src/matrix/schema-mapper/message/message-parser-room.ts

@@ -0,0 +1,62 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload  } from '../../../engine-schema.js'
+import { isIMRoomId, isRoomId } from '../../utils/is-type.js'
+import type { MessageParser, MessageParserContext } from './message-parser.js'
+
+async function roomMessageSentByOthers (engineMessage: MessagePayload, ret: PUPPET.payloads.Message) {
+  if (isRoomId(engineMessage.talkerId) || isIMRoomId(engineMessage.talkerId)) {
+    ret.roomId = engineMessage.talkerId
+    ret.talkerId = engineMessage.talkerId
+    ret.text = engineMessage.msg
+    /**
+     * separator of talkerId and content:
+     *
+     * text:    "wxid_xxxx:\nnihao"
+     * appmsg:  "wxid_xxxx:\n<?xml version="1.0"?><msg><appmsg appid="" sdkver="0">..."
+     * pat:     "19850419xxx@chatroom:\n<sysmsg type="pat"><pat><fromusername>xxx</fromusername><chatusername>19850419xxx@chatroom</chatusername><pattedusername>wxid_xxx</pattedusername>...<template><![CDATA["${vagase}" 拍了拍我]]></template></pat></sysmsg>"
+     */
+  }
+}
+
+async function roomMessageSentBySelf (engineMessage: MessagePayload, ret: PUPPET.payloads.Message) {
+  if (isRoomId(engineMessage.fromWxid) || isIMRoomId(engineMessage.fromWxid)) {
+    // room message sent by self
+    ret.roomId = engineMessage.fromWxid
+    ret.talkerId = engineMessage.talkerId
+    ret.text = engineMessage.msg
+  }
+}
+
+/**
+ * try to parse talkerId and content for generic room messages
+ * @param engineMessage
+ * @param ret
+ * @param context
+ */
+export const roomParser: MessageParser = async (engineMessage: MessagePayload, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+  await roomMessageSentByOthers(engineMessage, ret)
+  await roomMessageSentBySelf(engineMessage, ret)
+
+  if (ret.roomId) {
+    context.isRoomMessage = true
+
+    let mentionIdList: string[]
+    /**
+     *
+     */
+    if (!Array.isArray(engineMessage.atWxidList)) {
+      engineMessage.atWxidList = []
+    }
+    if ((engineMessage.atWxidList.length === 1 && engineMessage.atWxidList[0] === 'announcement@all') || engineMessage.msg.includes('@所有人 ')) {
+      const roomPayload = await context.puppet.roomPayload(ret.roomId)
+      mentionIdList = roomPayload.memberIdList
+    } else {
+      mentionIdList = engineMessage.atWxidList
+    }
+
+    const room = ret as PUPPET.payloads.MessageRoom
+    room.mentionIdList = mentionIdList
+  }
+
+  return ret
+}

package/src/matrix/schema-mapper/message/message-parser-single-chat.ts

@@ -0,0 +1,12 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload  } from '../../../engine-schema.js'
+import type { MessageParser, MessageParserContext } from './message-parser.js'
+
+export const singleChatParser: MessageParser = async (engineMessage: MessagePayload, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+  if (!context.isRoomMessage) {
+    ret.talkerId = engineMessage.talkerId
+    ret.listenerId = engineMessage.listenerId
+  }
+
+  return ret
+}

package/src/matrix/schema-mapper/message/message-parser-sysmsg.ts

@@ -0,0 +1,62 @@
+import type { MessageParser, MessageParserContext } from './message-parser.js'
+import type { MessagePayload  } from '../../../engine-schema.js'
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import { parseSysmsgMessagePayload } from '../../messages/message-sysmsg.js'
+import type { PatMessagePayload } from '../../messages/sysmsg/message-pat.js'
+import type { TodoMessagePayload } from '../../messages/sysmsg/message-todo.js'
+import type { RevokeMsgMessagePayload } from '../../messages/sysmsg/message-revokemsg.js'
+
+/**
+ * try to parse talker and listenerId from sysmsg for room messages
+ * @param engineMessage
+ * @param ret
+ * @param context
+ */
+export const sysmsgParser: MessageParser = async (engineMessage: MessagePayload, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+  const sysmsgPayload = await parseSysmsgMessagePayload(engineMessage)
+  if (!sysmsgPayload) {
+    return ret
+  }
+
+  switch (sysmsgPayload.type) {
+    case 'pat': {
+      const patMessagePayload: PatMessagePayload = sysmsgPayload.payload as PatMessagePayload
+
+      if (context.isRoomMessage) {
+        ret.talkerId = patMessagePayload.pattedUserName
+        ret.listenerId = patMessagePayload.fromUserName
+      }
+
+      break
+    }
+
+    case 'roomtoolstips': {
+      const todoMessagePayload: TodoMessagePayload = sysmsgPayload.payload as TodoMessagePayload
+
+      if (context.isRoomMessage) {
+        ret.talkerId = todoMessagePayload.operatorUserName
+      }
+
+      break
+    }
+
+    case 'revokemsg': {
+      const revokeMsgPayload: RevokeMsgMessagePayload = sysmsgPayload.payload as RevokeMsgMessagePayload
+
+      if (context.isRoomMessage) {
+        // Generic room message logic can get the right talkerId for revoke message
+      } else {
+        // Fix talkerId for single chat revoke message that sent by you
+        // talkerId and listenerId for revoke message sent by others is right already
+        if (revokeMsgPayload.type === 'You') {
+          ret.listenerId = ret.talkerId
+          ret.talkerId = context.puppet.currentUserId
+        }
+      }
+
+      break
+    }
+  }
+
+  return ret
+}

package/src/matrix/schema-mapper/message/message-parser-type.ts

@@ -0,0 +1,48 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload  } from '../../../engine-schema.js'
+import { WechatMessageType } from '../../types.js'
+import { log } from '@juzi/wechaty-puppet'
+import type { MessageParser, MessageParserContext } from './message-parser.js'
+import { LOGPRE } from './message-parser.js'
+
+const TypeMappings: { [key: number]: PUPPET.types.Message; } = {
+  [WechatMessageType.Text]: PUPPET.types.Message.Text,
+  [WechatMessageType.Image]: PUPPET.types.Message.Image,
+  [WechatMessageType.Voice]: PUPPET.types.Message.Audio,
+  [WechatMessageType.Emoticon]: PUPPET.types.Message.Emoticon,
+  [WechatMessageType.App]: PUPPET.types.Message.Attachment,
+  [WechatMessageType.File]: PUPPET.types.Message.Attachment,
+  [WechatMessageType.Location]: PUPPET.types.Message.Location,
+  [WechatMessageType.Video]: PUPPET.types.Message.Video,
+  [WechatMessageType.Sys]: PUPPET.types.Message.Unknown,
+  [WechatMessageType.ShareCard]: PUPPET.types.Message.Contact,
+  [WechatMessageType.VoipMsg]: PUPPET.types.Message.Recalled,
+  [WechatMessageType.SysTemplate]: PUPPET.types.Message.Recalled,
+  [WechatMessageType.StatusNotify]: PUPPET.types.Message.Unknown,
+  [WechatMessageType.SysNotice]: PUPPET.types.Message.Unknown,
+  [WechatMessageType.RedEnvelope]: PUPPET.types.Message.RedEnvelope,
+  [WechatMessageType.Transfer]: PUPPET.types.Message.Transfer,
+}
+
+export const typeParser: MessageParser = async (engineMessage: MessagePayload, ret: PUPPET.payloads.Message, _context: MessageParserContext) => {
+  let type: PUPPET.types.Message | undefined
+  const wechatMessageType = engineMessage.msgType
+
+  if (!wechatMessageType) {
+    type = PUPPET.types.Message.Unknown
+    ret.type = type
+    return ret
+  }
+
+  type = TypeMappings[wechatMessageType]
+
+  if (!type) {
+    log.verbose(LOGPRE, `unsupported type: ${JSON.stringify(engineMessage)}`)
+
+    type = PUPPET.types.Message.Unknown
+  }
+
+  ret.type = type
+
+  return ret
+}

package/src/matrix/schema-mapper/message/message-parser.ts

@@ -0,0 +1,35 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload } from '../../../engine-schema.js'
+import type { AppMessagePayload } from '../../messages/message-appmsg.js'
+
+/**
+ * Add customized message parser context info here
+ */
+export type MessageParserContext = {
+  puppet: PUPPET.Puppet,
+  isRoomMessage: boolean,
+  appMessagePayload?: AppMessagePayload,
+};
+
+export type MessageParser = (padLocalMessage: MessagePayload, ret: PUPPET.payloads.Message, context: MessageParserContext) => Promise<PUPPET.payloads.Message>;
+
+const messageParserList: Array<MessageParser> = []
+
+export function addMessageParser (parser: MessageParser) {
+  messageParserList.push(parser)
+}
+
+export async function executeMessageParsers (puppet: PUPPET.Puppet, engineMessage: MessagePayload, ret: PUPPET.payloads.Message): Promise<PUPPET.payloads.Message> {
+  const context: MessageParserContext = {
+    isRoomMessage: false,
+    puppet,
+  }
+
+  for (const parser of messageParserList) {
+    ret = await parser(engineMessage, ret, context)
+  }
+
+  return ret
+}
+
+export const LOGPRE = 'message-parser'

package/src/matrix/schema-mapper/message/mod.ts

@@ -0,0 +1,17 @@
+import { addMessageParser, executeMessageParsers } from './message-parser.js'
+import { typeParser } from './message-parser-type.js'
+import { roomParser } from './message-parser-room.js'
+import { singleChatParser } from './message-parser-single-chat.js'
+import { appMsgParser } from './message-parser-appmsg.js'
+import { referMsgParser } from './message-parser-refermsg.js'
+import { sysmsgParser } from './message-parser-sysmsg.js'
+
+// The order of message parser is important
+addMessageParser(typeParser)
+addMessageParser(roomParser)
+addMessageParser(singleChatParser)
+addMessageParser(appMsgParser)
+addMessageParser(referMsgParser)
+addMessageParser(sysmsgParser)
+
+export { executeMessageParsers }

package/src/matrix/schema-mapper/message.ts

@@ -0,0 +1,30 @@
+import type { MessagePayload } from '../../engine-schema.js'
+import * as PUPPET from '@juzi/wechaty-puppet'
+import { executeMessageParsers } from './message/mod.js'
+
+type WechatyMessagePayload = PUPPET.payloads.Message
+
+export async function engineMessageToWechaty (puppet: PUPPET.Puppet, engineMessage: MessagePayload): Promise<WechatyMessagePayload> {
+  try {
+    // set default value for MessagePayloadBase, other fields will be fulfilled or updated var MessageParers
+    let ret: PUPPET.payloads.Message = {
+      id: engineMessage.id,
+      talkerId: engineMessage.talkerId,
+      text: engineMessage.msg,
+      timestamp: engineMessage.timeStamp,
+      type: PUPPET.types.Message.Unknown,
+    } as WechatyMessagePayload
+
+    ret = await executeMessageParsers(puppet, engineMessage, ret)
+
+    // validate the return value
+    if (!(ret.roomId || ret.listenerId)) {
+      throw new Error('neither roomId nor listenerId')
+    }
+
+    return ret
+  } catch (e) {
+    return {} as PUPPET.payloads.Message
+  }
+
+}

package/src/matrix/schema-mapper/room.ts

@@ -0,0 +1,28 @@
+import type { ContactPayload } from '../../engine-schema.js'
+
+import type * as PUPPET from '@juzi/wechaty-puppet'
+
+export function engineRoomToWechaty (contact: ContactPayload): PUPPET.payloads.Room {
+  return {
+    adminIdList: contact.adminIdList || [],
+    avatar: contact.avatar,
+    id: contact.wxid,
+    memberIdList: contact.chatroommemberList || [],
+    ownerId: contact.ownerId,
+    topic: contact.name,
+  }
+}
+
+export function engineRoomMemberToWechaty (chatRoomMember: ContactPayload): PUPPET.payloads.RoomMember {
+  return {
+    avatar: chatRoomMember.avatar,
+    id: chatRoomMember.wxid,
+    inviterId: '',
+    name: chatRoomMember.name,
+    roomAlias: chatRoomMember.remark,
+  }
+}
+
+export function chatRoomMemberToContact (chatRoomMember: ContactPayload): ContactPayload {
+  return chatRoomMember
+}