@juzi/wechaty 1.0.15 → 1.0.18

package/src/user-modules/tag-group.ts

@@ -0,0 +1,115 @@
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agGroupreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific languagGroupe governing permissions and
+ *   limitations under the License.
+ *
+ */
+import type * as PUPPET from '@juzi/wechaty-puppet'
+
+import type { Constructor } from 'clone-class'
+import { log } from '../config.js'
+
+import { validationMixin } from '../user-mixins/validation.js'
+import {
+  wechatifyMixinBase,
+} from '../user-mixins/wechatify.js'
+
+class TagGroupMixin extends wechatifyMixinBase() {
+
+  /**
+   *
+   * Create
+   *
+   */
+  static create (payload: PUPPET.payloads.TagGroup): TagGroupInterface {
+    log.verbose('TagGroup', 'create()')
+
+    return new this(payload)
+  }
+
+  /**
+   * @hideconstructor
+   */
+  constructor (
+    public readonly payload: PUPPET.payloads.TagGroup,
+  ) {
+    super()
+    log.silly('TagGroup', 'constructor()')
+  }
+
+  id (): string {
+    return this.payload.id
+  }
+
+  name (): string {
+    return this.payload.name
+  }
+
+  static async createTagGroup (name: string): Promise<TagGroupInterface | void> {
+    log.verbose('TagGroup', 'createTagGroup(%s, %s)', name)
+
+    try {
+      const payload = await this.wechaty.puppet.tagGroupAdd(name)
+      if (payload) {
+        return new this(payload)
+      }
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('Contact', 'createTag() exception: %s', (e as Error).message)
+    }
+  }
+
+  static async deleteTagGroup (tagGroup: TagGroupInterface): Promise<TagGroupInterface | void> {
+    log.verbose('TagGroup', 'deleteTagGroup(%s)', tagGroup)
+
+    try {
+      await this.wechaty.puppet.tagGroupDelete(tagGroup.id())
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('Contact', 'createTag() exception: %s', (e as Error).message)
+    }
+  }
+
+  static async list (): Promise<TagGroupInterface[]> {
+    log.verbose('TagGroup', 'list()')
+
+    try {
+      const payloads = await this.wechaty.puppet.tagGroupList()
+      return payloads.map(payload => new this(payload))
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('TagGroup', 'list() exception: %s', (e as Error).message)
+      return []
+    }
+  }
+
+}
+
+class TagGroupImpl extends validationMixin(TagGroupMixin)<TagGroupInterface>() { }
+interface TagGroupInterface extends TagGroupImpl { }
+
+type TagGroupConstructor = Constructor<
+  TagGroupInterface,
+  typeof TagGroupImpl
+>
+
+export type {
+  TagGroupConstructor,
+  TagGroupInterface,
+}
+export {
+  TagGroupImpl,
+}

package/src/user-modules/tag.ts

@@ -17,169 +17,106 @@
  *   limitations under the License.
  *
  */
-import {
-  log,
-}                     from '@juzi/wechaty-puppet'
-
-import type { Constructor }  from 'clone-class'
+import type * as PUPPET from '@juzi/wechaty-puppet'
 
-import { ContactInterface, ContactImpl }  from './contact.js'
-import { FavoriteInterface, FavoriteImpl } from './favorite.js'
+import type { Constructor } from 'clone-class'
+import { log } from '../config.js'
 
-import {
-  poolifyMixin,
-}                     from '../user-mixins/poolify.js'
 import { validationMixin } from '../user-mixins/validation.js'
 import {
   wechatifyMixinBase,
 }                     from '../user-mixins/wechatify.js'
+import type { ContactInterface } from './contact.js'
 
-const MixinBase = poolifyMixin(
-  wechatifyMixinBase(),
-)<TagInterface>()
+class TagMixin extends wechatifyMixinBase() {
 
-class TagMixin extends MixinBase {
+  /**
+   *
+   * Create
+   *
+   */
+  static create (payload: PUPPET.payloads.Tag): TagInterface {
+    log.verbose('Tag', 'create()')
+
+    return new this(payload)
+  }
 
   /**
    * @hideconstructor
    */
   constructor (
-    public readonly id: string,
+    public readonly payload: PUPPET.payloads.Tag,
   ) {
     super()
-    log.silly('Tag', `constructor(${id})`)
+    log.silly('Tag', 'constructor()')
   }
 
-  /**
-   * Get a Tag instance for "tag"
-   *
-   * > Tips:
-   * This function is depending on the Puppet Implementation, see [puppet-compatible-table](https://github.com/Chatie/wechaty/wiki/Puppet#3-puppet-compatible-table)
-   *
-   * @static
-   * @param {string} [tag] the tag name which want to create
-   * @returns {Promise<TagImpl>}
-   * @example
-   * const bot = new Wechaty()
-   * await bot.Tag.get('TagName')
-   */
-  static async get (
-    tag: string,
-  ): Promise<TagInterface> {
-    log.verbose('Tag', 'get(%s)', tag)
-    return this.load(tag)
+  id (): string {
+    return this.payload.id
   }
 
-  /**
-   * Delete a tag from Wechat
-   *
-   * If you want to delete a tag, please make sure there's no more Contact/Favorite(s) are using this tag.
-   * If this tag is be used by any Contact/Favorite, then it can not be deleted.
-   * (This is for protecting the tag being deleted by mistake)
-   *
-   * @static
-   * @returns {Promise<TagInterface[]>}
-   * @example
-   * const tag = wechaty.Tag.get('tag')
-   * await wechaty.Tag.delete(tag)
-   */
+  type (): PUPPET.types.Tag {
+    return this.payload.type
+  }
 
-  /**
-   * TODO: refactoring the target: do not use ContactIml or FavoriteImpl
-   */
-  static async delete (
-    tag: TagInterface,
-    target?: typeof ContactImpl | typeof FavoriteImpl,
-  ): Promise<void> {
-    log.verbose('Tag', 'static delete(%s)', tag)
-
-    /**
-     * Huan(202110) TODO: refactory this design:
-     *  1. we should not pass `typeof ContactImpl` as argument
-     *  2. find a better way to manage tag.
-     */
+  groupId (): string {
+    return this.payload.groupId || ''
+  }
 
-    try {
+  name (): string {
+    return this.payload.name
+  }
 
-      /**
-       * TODO(huan): add tag check code here for checking if this tag is still being used.
-       */
+  static async list (): Promise<TagInterface[]> {
+    log.verbose('Tag', 'list()')
 
-      if (!target || target === ContactImpl || target === this.wechaty.Contact) {
-        await this.wechaty.puppet.tagContactDelete(tag.id)
-      // TODO:
-      // } else if (!target || target === Favorite || target === this.wechaty.Favorite) {
-      //   await this.wechaty.puppet.tagFavoriteDelete(tag.id)
-      }
+    try {
+      const payloads = await this.wechaty.puppet.tagTagList()
+      return payloads.map(payload => new this(payload))
     } catch (e) {
       this.wechaty.emitError(e)
-      log.error('Tag', 'static delete() exception: %s', (e as Error).message)
+      log.error('Tag', 'list() exception: %s', (e as Error).message)
+      return []
     }
   }
 
-  /**
-   * Add tag for contact
-   *
-   * > Tips:
-   * This function is depending on the Puppet Implementation, see [puppet-compatible-table](https://github.com/Chatie/wechaty/wiki/Puppet#3-puppet-compatible-table)
-   *
-   * @param {ContactInterface} [to] the contact which need to add tag
-   * @returns {Promise<void>}
-   * @example
-   * await tag.add(contact)
-   */
-  async add (
-    to: ContactInterface | FavoriteInterface,
-  ): Promise<void> {
-    log.verbose('Tag', 'add(%s) for %s', to, this.id)
-
-    /**
-     * Huan(202110): TODO: refactory this design:
-     *  1. we should not pass `typeof ContactImpl` as argument
-     *  2. use instanceof to check the type of `to`
-     */
+  async contactList (): Promise<ContactInterface[]> {
+    log.verbose('Tag', 'contactList() for tag id: %s', this.id())
+
+    const contactIds = await this.wechaty.puppet.tagTagContactList(this.groupId(), this.id())
+    const contactPromises = contactIds.map(id => this.wechaty.Contact.find({ id })) as Promise<ContactInterface>[]
+    return Promise.all(contactPromises)
+  }
+
+  async tag (contact: ContactInterface): Promise<void> {
+    log.verbose('Tag', 'tag(%s) for tag id: %s', contact, this.id())
+
+    const contactId = contact.id
+    await this.wechaty.puppet.tagContactTagAdd(this.groupId(), this.id(), contactId)
+  }
+
+  static async createTag (tagGroupId: string | undefined, name: string): Promise<TagInterface | void> {
+    log.verbose('Tag', 'createTag(%s, %s)', tagGroupId, name)
+
     try {
-      if (ContactImpl.valid(to)) {
-        await this.wechaty.puppet.tagContactAdd(this.id, to.id)
-      } else if (FavoriteImpl.valid(to)) {
-        // TODO: await this.wechaty.puppet.tagAddFavorite(this.tag, to.id)
+      const payload = await this.wechaty.puppet.tagTagAdd(tagGroupId, name)
+      if (payload) {
+        return new this(payload)
       }
     } catch (e) {
       this.wechaty.emitError(e)
-      log.error('Tag', 'add() exception: %s', (e as Error).message)
-      throw new Error(`add error : ${(e as Error)}`)
+      log.error('Contact', 'createTag() exception: %s', (e as Error).message)
     }
   }
 
-  /**
-   * Remove this tag from Contact/Favorite
-   *
-   * > Tips:
-   * This function is depending on the Puppet Implementation, see [puppet-compatible-table](https://github.com/Chatie/wechaty/wiki/Puppet#3-puppet-compatible-table)
-   *
-   * @returns {Promise<void>}
-   * @example
-   * await tag.remove(contact)
-   */
-  async remove (from: ContactInterface | FavoriteInterface): Promise<void> {
-    log.verbose('Tag', 'remove(%s) for %s', from, this.id)
-
-    /**
-     * Huan(202110): TODO: refactory this design:
-     *  1. we should not pass `typeof ContactImpl` as argument
-     *  2. use instanceof to check the type of `to`
-     */
+  static async deleteTag (tag: TagInterface): Promise<void> {
+    log.verbose('Tag', 'deleteTag(%s, %s)', tag)
 
     try {
-      if (from instanceof ContactImpl) {
-        await this.wechaty.puppet.tagContactRemove(this.id, from.id)
-      } else if (from instanceof FavoriteImpl) {
-        // TODO await this.wechaty.puppet.tagRemoveFavorite(this.tag, from.id)
-      }
+      await this.wechaty.puppet.tagTagDelete(tag.groupId(), tag.id())
     } catch (e) {
       this.wechaty.emitError(e)
-      log.error('Tag', 'remove() exception: %s', (e as Error).message)
-      throw new Error(`remove error : ${e}`)
+      log.error('Contact', 'deleteTag() exception: %s', (e as Error).message)
     }
   }
 

package/src/wechaty/wechaty-impl.spec.ts

@@ -17,6 +17,7 @@ import type {
   RoomConstructor,
   DelayConstructor,
   TagConstructor,
+  TagGroupConstructor,
   UrlLinkConstructor,
   MessageInterface,
   ChannelConstructor,
@@ -45,6 +46,7 @@ test('Wechaty interface', async t => {
     Room           : RoomConstructor
     RoomInvitation : RoomInvitationConstructor
     Tag            : TagConstructor
+    TagGroup       : TagGroupConstructor
     UrlLink        : UrlLinkConstructor
     Channel        : ChannelConstructor
 
@@ -63,6 +65,7 @@ test('Wechaty interface', async t => {
         = this.Room
         = this.RoomInvitation
         = this.Tag
+        = this.TagGroup
         = this.UrlLink
         = this.Channel
         = {} as any

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

@@ -387,7 +387,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                 // issue #254
                 if (payload.removeeIdList.includes(puppet.currentUserId)) {
                   await puppet.roomPayloadDirty(payload.roomId)
-                  // await puppet.roomMemberPayloadDirty(payload.roomId)
+                  await puppet.roomMemberPayloadDirty(payload.roomId)
                 }
               } catch (e) {
                 this.emit('error', GError.from(e))
@@ -436,7 +436,6 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
             puppet.on('dirty', async ({ payloadType, payloadId }) => {
               try {
                 switch (payloadType) {
-                  case PUPPET.types.Payload.RoomMember:
                   case PUPPET.types.Payload.Contact: {
                     const contact = await this.Contact.find({ id: payloadId }) as unknown as undefined | ContactImpl
                     await contact?.ready(true)
@@ -447,6 +446,11 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     await room?.ready(true)
                     break
                   }
+                  case PUPPET.types.Payload.RoomMember: {
+                    const room = await this.Room.find({ id: payloadId }) as unknown as undefined | RoomImpl
+                    await room?.ready()
+                    break
+                  }
 
                   /**
                    * Huan(202008): noop for the following

package/src/wechaty-mixins/wechatify-user-module-mixin.ts

@@ -13,6 +13,7 @@ import {
   RoomImpl,
   RoomInvitationImpl,
   TagImpl,
+  TagGroupImpl,
   UrlLinkImpl,
   ChannelImpl,
 
@@ -28,6 +29,7 @@ import {
   RoomConstructor,
   RoomInvitationConstructor,
   TagConstructor,
+  TagGroupConstructor,
   UrlLinkConstructor,
   ChannelConstructor,
 
@@ -60,6 +62,7 @@ const wechatifyUserModuleMixin = <MixinBase extends typeof WechatySkeleton> (mix
     __wechatifiedRoom?           : RoomConstructor
     __wechatifiedRoomInvitation? : RoomInvitationConstructor
     __wechatifiedTag?            : TagConstructor
+    __wechatifiedTagGroup?       : TagGroupConstructor
     __wechatifiedUrlLink?        : UrlLinkConstructor
     __wechatifiedChannel?        : ChannelConstructor
 
@@ -75,6 +78,7 @@ const wechatifyUserModuleMixin = <MixinBase extends typeof WechatySkeleton> (mix
     get Room ()           : RoomConstructor           { return guardWechatify(this.__wechatifiedRoom)           }
     get RoomInvitation () : RoomInvitationConstructor { return guardWechatify(this.__wechatifiedRoomInvitation) }
     get Tag ()            : TagConstructor            { return guardWechatify(this.__wechatifiedTag)            }
+    get TagGroup ()       : TagGroupConstructor       { return guardWechatify(this.__wechatifiedTagGroup)       }
     get UrlLink ()        : UrlLinkConstructor        { return guardWechatify(this.__wechatifiedUrlLink)        }
     get Channel ()        : ChannelConstructor        { return guardWechatify(this.__wechatifiedChannel)        }
 
@@ -110,6 +114,7 @@ const wechatifyUserModuleMixin = <MixinBase extends typeof WechatySkeleton> (mix
       this.__wechatifiedRoom           = wechatifyUserModule(RoomImpl)(this as any)
       this.__wechatifiedRoomInvitation = wechatifyUserModule(RoomInvitationImpl)(this as any)
       this.__wechatifiedTag            = wechatifyUserModule(TagImpl)(this as any)
+      this.__wechatifiedTagGroup       = wechatifyUserModule(TagGroupImpl)(this as any)
       this.__wechatifiedUrlLink        = wechatifyUserModule(UrlLinkImpl)(this as any)
       this.__wechatifiedChannel        = wechatifyUserModule(ChannelImpl)(this as any)
 
@@ -145,6 +150,7 @@ type ProtectedPropertyWechatifyUserModuleMixin =
   | '__wechatifiedRoom'
   | '__wechatifiedRoomInvitation'
   | '__wechatifiedTag'
+  | '__wechatifiedTagGroup'
   | '__wechatifiedUrlLink'
   | '__wechatifiedChannel'