wechaty-puppet-matrix 0.0.4

package/src/matrix/messages/message-emotion.ts

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import type { MessagePayload } from '../../engine-schema.js'
+import { xmlToJson } from '../utils/xml-to-json.js'
+
+interface EmotionXmlSchema {
+  msg: {
+    emoji: {
+      $: {
+        type: string;
+        len: string;
+        cdnurl: string;
+        width: string;
+        height: string;
+        md5: string;
+      };
+    };
+    gameext: {
+      $: {
+        content: string;
+        type: string;
+      };
+    };
+  };
+}
+
+export interface EmojiMessagePayload {
+  type: number;
+  len: number;
+  md5: string;
+  cdnurl: string;
+  width: number;
+  height: number;
+  gameext?: string;
+}
+
+export async function parseEmotionMessagePayload (message: MessagePayload): Promise<EmojiMessagePayload> {
+  const jsonPayload: EmotionXmlSchema = await xmlToJson(message.msg)
+
+  const len = parseInt(jsonPayload.msg.emoji.$.len, 10) || 0
+  const width = parseInt(jsonPayload.msg.emoji.$.width, 10) || 0
+  const height = parseInt(jsonPayload.msg.emoji.$.height, 10) || 0
+  const cdnurl = jsonPayload.msg.emoji.$.cdnurl
+  const type = parseInt(jsonPayload.msg.emoji.$.type, 10) || 0
+  const md5 = jsonPayload.msg.emoji.$.md5
+
+  let gameext
+  if (jsonPayload.msg.gameext) {
+    const gameextType = parseInt(jsonPayload.msg.gameext.$.type, 10) || 0
+    const gameextContent = parseInt(jsonPayload.msg.gameext.$.content, 10) || 0
+    gameext = `<gameext type="${gameextType}" content="${gameextContent}" ></gameext>`
+  }
+
+  return {
+    cdnurl,
+    gameext,
+    height,
+    len,
+    md5,
+    type,
+    width,
+  }
+}
+
+export function generateEmotionPayload (emojiMessagePayload: EmojiMessagePayload): string {
+  return `<msg><emoji cdnurl="${emojiMessagePayload.cdnurl}" len="${emojiMessagePayload.len}" md5="${
+    emojiMessagePayload.md5
+  }" type="${emojiMessagePayload.type}"/>${emojiMessagePayload.gameext || ''}</msg>`
+}

package/src/matrix/messages/message-image.ts

@@ -0,0 +1,46 @@
+import { MessagePayload } from '../../engine-schema.js'
+import { xmlToJson } from '../utils/xml-to-json.js'
+
+export interface ImageXmlSchema {
+    msg: {
+        img: {
+            $: {
+                aeskey: string
+                encryver: string
+                cdnthumbaeskey: string
+                cdnthumburl: string
+                cdnthumblength: string
+                cdnthumbheight: string
+                cdnthumbwidth: string
+                cdnmidheight: string
+                cdnmidwidth: string
+                cdnhdheight: string
+                cdnhdwidth: string
+                cdnmidimgurl: string
+                length: string
+                cdnbigimgurl: string
+                hdlength: string
+                md5: string
+            }
+        }
+    }
+}
+
+export interface ImageMessagePayload {
+  aes_key: string,
+  file_id: string,
+  file_size: string,
+  file_name: string,
+}
+
+export async function parseImageMessagePayload (rawPayload: MessagePayload): Promise<ImageMessagePayload> {
+  const imageXml: ImageXmlSchema = await xmlToJson(rawPayload.msg)
+  const schema = imageXml.msg.img.$
+
+  return {
+    aes_key: schema.aeskey,
+    file_id: schema.cdnmidimgurl,
+    file_size: schema.length,
+    file_name: '',
+  }
+}

package/src/matrix/messages/message-miniprogram.ts

@@ -0,0 +1,45 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload } from '../../engine-schema.js'
+import { xmlToJson } from '../utils/xml-to-json.js'
+
+interface MiniProgramXmlSchema {
+  msg: {
+    appmsg: {
+      title: string;
+      sourcedisplayname: string;
+      appattach: {
+        cdnthumbaeskey: string;
+        cdnthumburl: string;
+      };
+      weappinfo: {
+        username: string;
+        appid: string;
+        pagepath: string;
+        weappiconurl: string;
+        shareId: string;
+      };
+      thumburl: string;
+      md5: any;
+    };
+    fromusername: string;
+  };
+}
+
+export async function parseMiniProgramMessagePayload (rawPayload: MessagePayload): Promise<PUPPET.payloads.MiniProgram> {
+  const miniProgramXml: MiniProgramXmlSchema = await xmlToJson(rawPayload.msg)
+  const appmsg = miniProgramXml.msg.appmsg
+  const weappinfo = appmsg.weappinfo
+  const appattach = appmsg.appattach
+
+  return {
+    appid: weappinfo.appid,
+    description: appmsg.sourcedisplayname,
+    iconUrl: weappinfo.weappiconurl,
+    pagePath: weappinfo.pagepath,
+    shareId: weappinfo.shareId,
+    thumbKey: appattach.cdnthumbaeskey,
+    thumbUrl: appattach.cdnthumburl,
+    title: appmsg.title,
+    username: weappinfo.username,
+  }
+}

package/src/matrix/messages/message-sysmsg.ts

@@ -0,0 +1,106 @@
+import type { MessagePayload } from '../../engine-schema.js'
+import { WechatMessageType } from '../types.js'
+import { xmlToJson } from '../utils/xml-to-json.js'
+import type { PatMessagePayload, PatXmlSchema } from './sysmsg/message-pat.js'
+import type { SysmsgTemplateMessagePayload, SysmsgTemplateXmlSchema } from './sysmsg/message-sysmsgtemplate.js'
+import { parsePatMessagePayload } from './sysmsg/message-pat.js'
+import { parseSysmsgTemplateMessagePayload } from './sysmsg/message-sysmsgtemplate.js'
+import type { TodoMessagePayload, TodoXmlSchema } from './sysmsg/message-todo.js'
+import { parseTodoMessagePayload } from './sysmsg/message-todo.js'
+import type { RevokeMsgMessagePayload, RevokeMsgXmlSchema } from './sysmsg/message-revokemsg.js'
+import { parseRevokeMsgMessagePayload } from './sysmsg/message-revokemsg.js'
+
+interface SysmsgXmlSchema {
+  sysmsg: {
+    $: {
+      type: string;
+    },
+    pat?: PatXmlSchema,
+    sysmsgtemplate?: SysmsgTemplateXmlSchema,
+    todo?: TodoXmlSchema,
+    revokemsg?: RevokeMsgXmlSchema,
+  };
+}
+
+type SysMsgType = 'pat' | 'sysmsgtemplate' | 'roomtoolstips' | 'revokemsg';
+type SysMsgPayload = PatMessagePayload | SysmsgTemplateMessagePayload | TodoMessagePayload | RevokeMsgMessagePayload;
+
+export interface SysmsgMessagePayload {
+  type: SysMsgType;
+  payload: SysMsgPayload
+}
+
+export async function parseSysmsgMessagePayload (message: MessagePayload): Promise<SysmsgMessagePayload | null> {
+  if (message.msgType !== WechatMessageType.Sys) {
+    return null
+  }
+
+  const content = message.msg.trim()
+  const sysmsgIndex = content.indexOf('<sysmsg')
+  if (sysmsgIndex === -1) {
+    return null
+  }
+
+  const sysmsgXml: SysmsgXmlSchema = await xmlToJson(content.substring(sysmsgIndex))
+
+  let payload : SysMsgPayload | undefined
+  switch (sysmsgXml.sysmsg.$.type) {
+    case 'pat':
+      payload = await parsePatMessagePayload(sysmsgXml.sysmsg.pat!)
+      break
+    case 'sysmsgtemplate':
+      payload = await parseSysmsgTemplateMessagePayload(sysmsgXml.sysmsg.sysmsgtemplate!)
+      break
+    case 'roomtoolstips':
+      payload = await parseTodoMessagePayload(sysmsgXml.sysmsg.todo!)
+      break
+    case 'revokemsg':
+      payload = await parseRevokeMsgMessagePayload(sysmsgXml.sysmsg.revokemsg!)
+      break
+  }
+
+  if (payload) {
+    return {
+      payload,
+      type: sysmsgXml.sysmsg.$.type as SysMsgType,
+    }
+  } else {
+    return null
+  }
+}
+
+export async function parseSysmsgPatMessagePayload (message: MessagePayload) : Promise<PatMessagePayload | null> {
+  const sysmsgPayload = await parseSysmsgMessagePayload(message)
+  if (!sysmsgPayload || sysmsgPayload.type !== 'pat') {
+    return null
+  }
+
+  return sysmsgPayload.payload as PatMessagePayload
+}
+
+export async function parseSysmsgSysmsgTemplateMessagePayload (message: MessagePayload) : Promise<SysmsgTemplateMessagePayload | null> {
+  const sysmsgPayload = await parseSysmsgMessagePayload(message)
+  if (!sysmsgPayload || sysmsgPayload.type !== 'sysmsgtemplate') {
+    return null
+  }
+
+  return sysmsgPayload.payload as SysmsgTemplateMessagePayload
+}
+
+export async function parseSysmsgTodoMessagePayload (message: MessagePayload) : Promise<TodoMessagePayload | null> {
+  const sysmsgPayload = await parseSysmsgMessagePayload(message)
+  if (!sysmsgPayload || sysmsgPayload.type !== 'roomtoolstips') {
+    return null
+  }
+
+  return sysmsgPayload.payload as TodoMessagePayload
+}
+
+export async function parseSysmsgRevokeMsgMessagePayload (message: MessagePayload) : Promise<RevokeMsgMessagePayload | null> {
+  const sysmsgPayload = await parseSysmsgMessagePayload(message)
+  if (!sysmsgPayload || sysmsgPayload.type !== 'revokemsg') {
+    return null
+  }
+
+  return sysmsgPayload.payload as RevokeMsgMessagePayload
+}

package/src/matrix/messages/message-video.ts

@@ -0,0 +1,62 @@
+import { MessagePayload } from '../../engine-schema.js'
+import { xmlToJson } from '../utils/xml-to-json.js'
+
+export interface VideoXmlSchema {
+  msg: {
+      videomsg: {
+          $: {
+              aeskey: string
+              cdnvideourl: string
+              cdnthumbaeskey: string
+              cdnthumburl: string
+              length: string
+              playlength: string
+              cdnthumblength: string
+              cdnthumbwidth: string
+              cdnthumbheight: string
+              fromusername: string
+              md5: string
+              newmd5: string
+              isplaceholder: string
+              rawmd5: string
+              rawlength: string
+              cdnrawvideourl: string
+              cdnrawvideoaeskey: string
+              overwritenewmsgid: string
+              originsourcemd5: string
+              isad: string
+          }
+      }
+  }
+}
+
+export interface VideoMessagePayload {
+  aes_key: string,
+  file_id: string,
+  file_size: string,
+  play_length: string,
+  thumb_aes_key: string,
+  thumb_url: string,
+  thumb_size: string,
+  thumb_width: string,
+  thumb_height: string,
+  file_name: ''
+}
+
+export async function parseVideoMessagePayload (rawPayload: MessagePayload): Promise<VideoMessagePayload> {
+  const videoXml: VideoXmlSchema = await xmlToJson(rawPayload.msg)
+  const videoSchema = videoXml.msg.videomsg.$
+
+  return {
+    aes_key: videoSchema.aeskey,
+    file_id: videoSchema.cdnvideourl,
+    file_size: videoSchema.length,
+    play_length: videoSchema.playlength,
+    thumb_aes_key: videoSchema.cdnthumbaeskey,
+    thumb_url: videoSchema.cdnthumburl,
+    thumb_size: videoSchema.cdnthumblength,
+    thumb_width: videoSchema.cdnthumbwidth,
+    thumb_height: videoSchema.cdnthumbheight,
+    file_name: '',
+  }
+}

package/src/matrix/messages/sysmsg/message-pat.ts

@@ -0,0 +1,22 @@
+export interface PatXmlSchema {
+  fromusername: string;
+  chatusername: string;
+  pattedusername: string;
+  template: string;
+}
+
+export interface PatMessagePayload {
+  fromUserName: string;
+  chatUserName: string;
+  pattedUserName: string;
+  template: string;
+}
+
+export async function parsePatMessagePayload (patXml: PatXmlSchema): Promise<PatMessagePayload> {
+  return {
+    chatUserName: patXml.chatusername,
+    fromUserName: patXml.fromusername,
+    pattedUserName: patXml.pattedusername,
+    template: patXml.template,
+  }
+}

package/src/matrix/messages/sysmsg/message-revokemsg.ts

@@ -0,0 +1,70 @@
+import { parseTextWithRegexList } from '../../utils/regex.js'
+import { executeRunners } from '../../utils/runner.js'
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import { isIMRoomId, isRoomId } from '../../utils/is-type.js'
+
+export interface RevokeMsgXmlSchema {
+  session: string;
+  msgid: string;
+  newmsgid: string;
+  replacemsg: string;
+}
+
+export type RevokeMsgType = 'You' | 'Other';
+
+export interface RevokeMsgMessagePayload {
+  content: string;
+  operatorNickName?: string,
+  originalMessageId: string;
+  session: string;
+  type: RevokeMsgType;
+}
+
+const YOU_REVOKE_REGEX_LIST = [
+  /你撤回了一条消息/,
+  /You recalled a message/,
+]
+const OTHER_REVOKE_REGEX_LIST = [
+  /"(.+)" 撤回了一条消息/,
+  /"(.+)" has recalled a message./,
+]
+
+export async function parseRevokeMsgMessagePayload (revokeMsgXmlSchema: RevokeMsgXmlSchema): Promise<RevokeMsgMessagePayload> {
+  let nickName: string | undefined
+
+  const youRevoke = async () => parseTextWithRegexList<RevokeMsgType>(revokeMsgXmlSchema.replacemsg, YOU_REVOKE_REGEX_LIST, async () => 'You')
+  const otherRevoke = async () => parseTextWithRegexList<RevokeMsgType>(revokeMsgXmlSchema.replacemsg, OTHER_REVOKE_REGEX_LIST, async (_, match) => {
+    nickName = match[1]
+    return 'Other'
+  })
+
+  const type = (await executeRunners<RevokeMsgType>([ youRevoke, otherRevoke ]))!
+
+  return {
+    content: revokeMsgXmlSchema.replacemsg,
+    operatorNickName: nickName,
+    originalMessageId: revokeMsgXmlSchema.newmsgid,
+    session: revokeMsgXmlSchema.session,
+    type,
+  }
+}
+
+export async function getRevokeOriginalMessage (puppet: PUPPET.Puppet, revokemsgPayload:RevokeMsgMessagePayload): Promise<PUPPET.payloads.Message | null> {
+  const messageIdList = await puppet.messageSearch({ id: revokemsgPayload.originalMessageId })
+  if (messageIdList.length) {
+    return puppet.messagePayload(messageIdList[0]!)
+  }
+
+  return null
+}
+
+export async function getRevokeOperatorIdForRoomMessage (puppet: PUPPET.Puppet, revokemsgPayload:RevokeMsgMessagePayload) : Promise<string | null> {
+  if (isRoomId(revokemsgPayload.session) || isIMRoomId(revokemsgPayload.session)) {
+    const contactIdList = await puppet.roomMemberSearch(revokemsgPayload.session, revokemsgPayload.operatorNickName!)
+    if (contactIdList.length) {
+      return contactIdList[0]!
+    }
+  }
+
+  return null
+}

package/src/matrix/messages/sysmsg/message-sysmsgtemplate.ts

@@ -0,0 +1,133 @@
+/* eslint-disable camelcase */
+import { parseTextWithRegexList } from '../../utils/regex.js'
+import type { Runner } from '../../utils/runner.js'
+
+export interface SysmsgTemplateXmlSchema {
+  content_template: {
+    $: {
+      type: string;
+    };
+    plain: string;
+    template: string;
+    link_list: {
+      link: [
+        {
+          $: {
+            name: string;
+            type: string;
+            hidden?: string;
+          };
+          memberlist?: {
+            member: [
+              {
+                username?: string;
+                nickname: string;
+              }
+            ];
+          };
+          separator?: string;
+          title?: string;
+          usernamelist?: {
+            username: string[];
+          };
+        }
+      ];
+    };
+  };
+}
+
+export interface SysmsgTemplateLinkMember {
+  userName?: string,
+  nickName: string,
+}
+
+export type SysmsgTemplateLinkProfile = Array<SysmsgTemplateLinkMember>;
+
+export interface SysmsgTemplateLinkRevoke {
+  title: string,
+  userNameList: string[],
+}
+
+export type SysmsgTemplateLinkType = 'link_profile' | 'link_revoke';
+
+export type SysmsgTemplateLinkPayload = SysmsgTemplateLinkProfile | SysmsgTemplateLinkRevoke;
+
+export interface SysmsgTemplateLink {
+  name: string,
+  payload: SysmsgTemplateLinkPayload,
+  type: SysmsgTemplateLinkType,
+}
+
+export interface SysmsgTemplateMessagePayload {
+  template: string;
+  templateLinkList: Array<SysmsgTemplateLink>; // link list is sorted by template variable name order
+}
+
+/**
+ * xmlToJson will return element instead of array if xml node only contains one child.
+ * @param list
+ */
+function toList (list: any): any[] {
+  if (!Array.isArray(list)) {
+    return [ list ]
+  } else {
+    return list
+  }
+}
+
+export async function parseSysmsgTemplateMessagePayload (sysmsgTemplateXml: SysmsgTemplateXmlSchema): Promise<SysmsgTemplateMessagePayload> {
+  const linkList = toList(sysmsgTemplateXml.content_template.link_list.link)
+
+  const allLinkList = linkList.map((link): SysmsgTemplateLink  => {
+    const type = link.$.type as SysmsgTemplateLinkType
+    let payload: SysmsgTemplateLinkPayload | undefined
+
+    if (type === 'link_profile') {
+      const memberList = toList(link.memberlist!.member)
+      payload = memberList.map((member: { nickname: string; username?: string; }): SysmsgTemplateLinkMember => {
+        return {
+          nickName: member.nickname,
+          userName: member.username,
+        }
+      })
+    } else if (link.$.type === 'link_revoke') {
+      payload = {
+        title: link.title!,
+        userNameList: toList(link.usernamelist!.username),
+      }
+    } else {
+      // handle more link type here
+    }
+
+    return {
+      name: link.$.name,
+      payload: payload!,
+      type,
+    }
+  })
+
+  const template = sysmsgTemplateXml.content_template.template
+  const matches = [ ...template.matchAll(/\$(.+?)\$/g) ]
+
+  const templateLinkList = matches.map(match => {
+    const linkName = match[1]
+    return allLinkList.filter((link) => link.name === linkName)[0]!
+  })
+
+  return {
+    template,
+    templateLinkList,
+  }
+}
+
+export type SysmsgTemplateHandler<T> = (templateLinkList: SysmsgTemplateLink[], matchedRegexIndex: number) => Promise<T>;
+
+export async function parseSysmsgTemplate<T> (sysmsgTemplatePayload: SysmsgTemplateMessagePayload, regexList: RegExp[], handler: SysmsgTemplateHandler<T>) : Promise<T | null> {
+  return parseTextWithRegexList(sysmsgTemplatePayload.template, regexList, async (matchedRegexIndex) => {
+    return handler(sysmsgTemplatePayload.templateLinkList, matchedRegexIndex)
+  })
+}
+
+export function createSysmsgTemplateRunner<T> (sysmsgTemplatePayload: SysmsgTemplateMessagePayload, regexList: RegExp[], handler: SysmsgTemplateHandler<T>): Runner<T> {
+  return async () => parseSysmsgTemplate<T>(sysmsgTemplatePayload, regexList, handler)
+}

package/src/matrix/messages/sysmsg/message-todo.ts

@@ -0,0 +1,45 @@
+/* eslint-disable camelcase */
+export interface TodoXmlSchema {
+  op: string;
+  todoid: string;
+  username: string;
+  path: string;
+  time: number;
+  custominfo: string;
+  title: string;
+  creator: string;
+  related_msgid: string;
+  manager: string;
+  nreply: number;
+  scene: string;
+  oper: string;
+  sharekey: string;
+  sharename: string;
+  template?: string;
+}
+
+export interface TodoMessagePayload {
+  id: string;
+  creatorUserName: string;
+  operatorUserName: string;
+  numberOfReply: number;
+  appId: string;
+  path: string;
+  relatedMessageId: string;
+  title: string;
+  template?: string;
+}
+
+export async function parseTodoMessagePayload (todoXml: TodoXmlSchema): Promise<TodoMessagePayload> {
+  return {
+    appId: todoXml.username,
+    creatorUserName: todoXml.creator,
+    id: todoXml.todoid,
+    numberOfReply: todoXml.nreply,
+    operatorUserName: todoXml.oper,
+    path: todoXml.path,
+    relatedMessageId: todoXml.related_msgid,
+    template: todoXml.template,
+    title: todoXml.title,
+  }
+}

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

@@ -0,0 +1,37 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import { isContactOfficialId } from '../utils/is-type.js'
+import type { ContactPayload } from '../../engine-schema.js'
+
+export function engineContactToWechaty (contact?: ContactPayload): PUPPET.payloads.Contact {
+  if (contact) {
+    return {
+      alias: contact.remark, // 备注
+      avatar: contact.avatar, // 头像
+      city: contact.city, // 城市
+      gender: contact.sex, // 性别
+      id: contact.wxid, // wxid
+      name: contact.name, // 昵称
+      friend: !!contact.isFriend, // 是否是好友
+      phone: [],
+      province: contact.province,
+      signature: contact.sign, // 签名
+      type: isContactOfficialId(contact.wxid) ? PUPPET.types.Contact.Official : PUPPET.types.Contact.Individual,
+      weixin: contact.wxNum,
+    }
+  } else {
+    return {
+      alias: '', // 备注
+      avatar: '', // 头像
+      city: '', // 城市
+      gender: 0, // 性别
+      id: '', // wxid
+      name: '', // 昵称
+      friend: false, // 是否是好友
+      phone: [],
+      province: '',
+      signature: '', // 签名
+      type: PUPPET.types.Contact.Individual,
+      weixin: '',
+    }
+  }
+}