@juzi/wechaty 1.0.23 → 1.0.26

package/src/wechaty-mixins/puppet-mixin.ts

@@ -11,12 +11,14 @@ import type {
   StateSwitchInterface,
 }                       from 'state-switch'
 
-import { config, FOUR_PER_EM_SPACE }               from '../config.js'
+import { config, PUPPET_PAYLOAD_SYNC_GAP, PUPPET_PAYLOAD_SYNC_MAX_RETRY }               from '../config.js'
 import { timestampToDate }      from '../pure-functions/timestamp-to-date.js'
 import type {
   ContactImpl,
   ContactInterface,
   RoomImpl,
+  TagGroupInterface,
+  TagInterface,
 }                               from '../user-modules/mod.js'
 
 import type {
@@ -26,7 +28,7 @@ import type {
 import type { GErrorMixin } from './gerror-mixin.js'
 import type { IoMixin }     from './io-mixin.js'
 import { ContactImportantFields, ContactUpdatableValuePair, InfoUpdateInterface, RoomImportantFields, RoomUpdatableValuePair } from '../schemas/update.js'
-import { diffPayload } from '../pure-functions/update.js'
+import { checkUntilChanged, diffPayload } from '../pure-functions/update.js'
 
 const PUPPET_MEMORY_NAME = 'puppet'
 
@@ -427,6 +429,92 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
             })
             break
 
+          case 'tag':
+            puppet.on('tag', async payload => {
+              switch (payload.type) {
+                case PUPPET.types.TagEvent.TagCreate: {
+                  const newTagPromises = payload.idList.map(id => this.Tag.find({ id }))
+                  const newTags = await Promise.all(newTagPromises)
+                  this.emit('tag', payload.type, newTags)
+                  break
+                }
+                case PUPPET.types.TagEvent.TagDelete: {
+                  const deletedTagPromises = payload.idList.map(id => this.Tag.find({ id }))
+                  const deletedTags = await Promise.all(deletedTagPromises)
+                  this.emit('tag', payload.type, deletedTags)
+                  // TODO: bind tag-delete to tag instance
+                  break
+                }
+                case PUPPET.types.TagEvent.TagRename: {
+                  const renamedTagPromises = payload.idList.map(id => this.Tag.find({ id }))
+                  const renamedTags = (await Promise.all(renamedTagPromises)) as TagInterface[]
+                  await Promise.all(renamedTags.map(async tag => {
+                    const oldName = tag.name()
+                    const result = await checkUntilChanged(PUPPET_PAYLOAD_SYNC_GAP, PUPPET_PAYLOAD_SYNC_MAX_RETRY, async () => {
+                      await tag.sync()
+                      return tag.name() === oldName
+                    })
+                    if (!result) {
+                      log.warn('WechatyPuppetMixin', 'tagRenameEvent still get old name after %s retries for tag %s', PUPPET_PAYLOAD_SYNC_MAX_RETRY, tag.id)
+                    }
+                  }))
+                  this.emit('tag', payload.type, renamedTags)
+                  // TODO: bind tag-rename to tag instance
+                  break
+                }
+                default:
+                  throw new Error('tagEventType ' + payload.type + ' unsupported!')
+              }
+            })
+            break
+
+          case 'tag-group':
+            puppet.on('tag-group', async payload => {
+              switch (payload.type) {
+
+                case PUPPET.types.TagGroupEvent.TagGroupCreate: {
+                  const newTagGroupPromises = payload.idList.map(id =>
+                    this.TagGroup.find({ id }),
+                  )
+                  const newTagGroups = await Promise.all(newTagGroupPromises)
+                  this.emit('tag-group', payload.type, newTagGroups)
+                  break
+                }
+                case PUPPET.types.TagGroupEvent.TagGroupDelete: {
+                  const deletedTagGroupPromises = payload.idList.map(id =>
+                    this.TagGroup.find({ id }),
+                  )
+                  const deletedTagGroups = await Promise.all(deletedTagGroupPromises)
+                  this.emit('tag-group', payload.type, deletedTagGroups)
+                  break
+                  // TODO: bind tagGroup-delete to tagGroup instance
+                }
+                case PUPPET.types.TagGroupEvent.TagGroupRename: {
+                  const renamedTagGroupPromises = payload.idList.map(id =>
+                    this.TagGroup.find({ id }),
+                  )
+                  const renamedTagGroups = (await Promise.all(renamedTagGroupPromises)) as TagGroupInterface[]
+                  await Promise.all(renamedTagGroups.map(async tagGroup => {
+                    const oldName = tagGroup.name()
+                    const result = await checkUntilChanged(PUPPET_PAYLOAD_SYNC_GAP, PUPPET_PAYLOAD_SYNC_MAX_RETRY, async () => {
+                      await tagGroup.sync()
+                      return tagGroup.name() === oldName
+                    })
+                    if (!result) {
+                      log.warn('WechatyPuppetMixin', 'tagGroupRenameEvent still get old name after %s retries for tagGroup %s', PUPPET_PAYLOAD_SYNC_MAX_RETRY, tagGroup.id)
+                    }
+                  }))
+                  this.emit('tag-group', payload.type, renamedTagGroups)
+                  // TODO: bind tagGroup-rename to tagGroup instance
+                  break
+                }
+                default:
+                  throw new Error('tagGroupEventType ' + payload.type + ' unsupported!')
+              }
+
+            })
+            break
+
           case 'reset':
             // Do not propagation `reset` event from puppet
             break
@@ -445,7 +533,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     const newPayload = JSON.parse(JSON.stringify(contact?.payload || {}))
 
                     const differences = diffPayload<PUPPET.payloads.Contact>(oldPayload, newPayload)
-                    const importangDifferences = differences.filter(ele => ele && ContactImportantFields.some(key => key === ele.key))
+                    const importantDifferences = differences.filter(ele => ele && ContactImportantFields.some(key => key === ele.key))
                     const regularDifferences = differences.filter(ele => ele && !ContactImportantFields.some(key => key === ele.key)) as ContactUpdatableValuePair[]
                     if (regularDifferences.length > 0) {
                       const updateEvent: InfoUpdateInterface = {
@@ -456,17 +544,19 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                       this.emit('update', updateEvent)
                       contact?.emit('update', updateEvent)
                     }
-                    for (const difference of importangDifferences) {
+                    for (const difference of importantDifferences) {
                       switch (difference?.key) {
                         case 'tags': {
-                          const oldTagsSet = new Set(difference.oldValue?.map(ele => ele.groupId + FOUR_PER_EM_SPACE + ele.id))
-                          const newTagsSet = new Set(difference.newValue?.map(ele => ele.groupId + FOUR_PER_EM_SPACE + ele.id))
-                          const addedTags = difference.newValue?.filter(ele => !oldTagsSet.has(ele.groupId + FOUR_PER_EM_SPACE + ele.id)).map(ele => this.Tag.load(ele)) || []
-                          const removedTags = difference.oldValue?.filter(ele => !newTagsSet.has(ele.groupId + FOUR_PER_EM_SPACE + ele.id)).map(ele => this.Tag.load(ele)) || []
-                          if (addedTags.length > 0) {
+                          const oldTagsSet = new Set(difference.oldValue)
+                          const newTagsSet = new Set(difference.newValue)
+                          const addedTagPromises = difference.newValue?.filter(ele => !oldTagsSet.has(ele)).map(ele => this.Tag.find({ id: ele })) || []
+                          const removedTagPromises = difference.oldValue?.filter(ele => !newTagsSet.has(ele)).map(ele => this.Tag.find({ id: ele })) || []
+                          if (addedTagPromises.length > 0) {
+                            const addedTags = await Promise.all(addedTagPromises)
                             this.emit('contact-tag-add', contact, addedTags)
                           }
-                          if (removedTags.length > 0) {
+                          if (removedTagPromises.length > 0) {
+                            const removedTags = await Promise.all(removedTagPromises)
                             this.emit('contact-tag-remove', contact, removedTags)
                           }
                           break
@@ -504,7 +594,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     const newPayload = JSON.parse(JSON.stringify(room?.payload || {}))
 
                     const differences = diffPayload<PUPPET.payloads.Room>(oldPayload, newPayload)
-                    const importangDifferences = differences.filter(ele => ele && RoomImportantFields.some(key => key === ele.key))
+                    const importantDifferences = differences.filter(ele => ele && RoomImportantFields.some(key => key === ele.key))
                     const regularDifferences = differences.filter(ele => ele && !RoomImportantFields.some(key => key === ele.key)) as RoomUpdatableValuePair[]
                     if (regularDifferences.length > 0) {
                       const updateEvent: InfoUpdateInterface = {
@@ -515,7 +605,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                       this.emit('update', updateEvent)
                       room?.emit('update', updateEvent)
                     }
-                    for (const difference of importangDifferences) {
+                    for (const difference of importantDifferences) {
                       switch (difference?.key) {
                         case 'ownerId': {
                           const oldOwner = (await this.Contact.find({ id: difference.oldValue }))!
@@ -545,6 +635,10 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                   case PUPPET.types.Payload.Message:
                     // Message does not need to dirty (?)
                     break
+                  case PUPPET.types.Payload.Tag:
+                    break
+                  case PUPPET.types.Payload.TagGroup:
+                    break
 
                   case PUPPET.types.Payload.Unspecified:
                   default: