@juzi/wechaty-puppet-service 1.0.13 → 1.0.17

package/src/client/puppet-service.ts

@@ -1920,82 +1920,263 @@ class PuppetService extends PUPPET.Puppet {
    * Tag
    *
    */
-  // add a tag for a Contact. Create it first if it not exist.
-  override async tagContactAdd (
-    id: string,
+
+  override async tagContactTagAdd (
+    tagGroupId: string | undefined,
+    tagId: string,
     contactId: string,
   ): Promise<void> {
-    log.verbose('PuppetService', 'tagContactAdd(%s, %s)', id, contactId)
+    log.verbose('PuppetService', 'tagContactTagAdd(%s, %s, %s)', tagGroupId, tagId, contactId)
 
-    const request = new grpcPuppet.TagContactAddRequest()
-    request.setId(id)
+    const request = new grpcPuppet.TagContactTagAddRequest()
+
+    if (typeof tagGroupId !== 'undefined') {
+      request.setTagGroupId(tagGroupId)
+    }
+    request.setTagId(tagId)
     request.setContactId(contactId)
 
     await util.promisify(
-      this.grpcManager.client.tagContactAdd
+      this.grpcManager.client.tagContactTagAdd
         .bind(this.grpcManager.client),
     )(request)
   }
 
-  // remove a tag from the Contact
-  override async tagContactRemove (
-    id: string,
+  override async tagContactTagRemove (
+    tagGroupId: string | undefined,
+    tagId: string,
     contactId: string,
-  ) : Promise<void> {
-    log.verbose('PuppetService', 'tagContactRemove(%s, %s)', id, contactId)
+  ): Promise<void> {
+    log.verbose('PuppetService', 'tagContactTagRemove(%s, %s, %s)', tagGroupId, tagId, contactId)
 
-    const request = new grpcPuppet.TagContactRemoveRequest()
-    request.setId(id)
+    const request = new grpcPuppet.TagContactTagRemoveRequest()
+
+    if (typeof tagGroupId !== 'undefined') {
+      request.setTagGroupId(tagGroupId)
+    }
+    request.setTagId(tagId)
     request.setContactId(contactId)
 
     await util.promisify(
-      this.grpcManager.client.tagContactRemove
+      this.grpcManager.client.tagContactTagRemove
         .bind(this.grpcManager.client),
     )(request)
   }
 
-  // delete a tag from Wechat
-  override async tagContactDelete (
-    id: string,
-  ) : Promise<void> {
-    log.verbose('PuppetService', 'tagContactDelete(%s)', id)
+  override async tagGroupAdd (
+    tagGroupName: string,
+  ): Promise<PUPPET.payloads.TagGroup | void> {
+    log.verbose('PuppetService', 'tagGroupAdd(%s)', tagGroupName)
 
-    const request = new grpcPuppet.TagContactDeleteRequest()
-    request.setId(id)
+    const request = new grpcPuppet.TagGroupAddRequest()
+
+    request.setTagGroupName(tagGroupName)
+
+    const result = await util.promisify(
+      this.grpcManager.client.tagGroupAdd
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const grpcPayload = result.getPayload()
+    const id = grpcPayload?.getId()
+    const name = grpcPayload?.getName()
+
+    if (id && name) {
+      const payload: PUPPET.payloads.TagGroup = {
+        id,
+        name,
+      }
+      return payload
+    }
+
+  }
+
+  override async tagGroupDelete (
+    tagGroupId: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'tagGroupDelete(%s)', tagGroupId)
+
+    const request = new grpcPuppet.TagGroupDeleteRequest()
+
+    request.setTagGroupId(tagGroupId)
 
     await util.promisify(
-      this.grpcManager.client.tagContactDelete
+      this.grpcManager.client.tagGroupDelete
         .bind(this.grpcManager.client),
     )(request)
+
   }
 
-  // get tags from a specific Contact
-  override async tagContactList (
-    contactId?: string,
-  ) : Promise<string[]> {
-    log.verbose('PuppetService', 'tagContactList(%s)', contactId)
+  override async tagTagAdd (
+    tagGroupId: string | undefined,
+    tagName: string,
+  ): Promise<PUPPET.payloads.Tag | void> {
+    log.verbose('PuppetService', 'tagTagAdd(%s, %s)', tagGroupId, tagName)
 
-    const request = new grpcPuppet.TagContactListRequest()
+    const request = new grpcPuppet.TagTagAddRequest()
 
-    if (typeof contactId !== 'undefined') {
-      request.setContactId(contactId)
-      {
+    if (typeof tagGroupId !== 'undefined') {
+      request.setTagGroupId(tagGroupId)
+    }
+    request.setTagName(tagName)
 
-        /**
-         * Huan(202110): Deprecated: will be removed after Dec 31, 2022
-         */
-        const contactIdWrapper = new StringValue()
-        contactIdWrapper.setValue(contactId)
-        request.setContactIdStringValueDeprecated(contactIdWrapper)
+    const result = await util.promisify(
+      this.grpcManager.client.tagTagAdd
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const grpcPayload = result.getPayload()
+    const id = grpcPayload?.getId()
+    const name = grpcPayload?.getName()
+    const groupId = grpcPayload?.getGroupId()
+    const type = grpcPayload?.getType()
+
+    if (id && name && (typeof type !== 'undefined')) {
+      const payload: PUPPET.payloads.Tag = {
+        id,
+        name,
+        groupId,
+        type,
       }
+      return payload
     }
 
-    const response = await util.promisify(
-      this.grpcManager.client.tagContactList
+  }
+
+  override async tagTagDelete (
+    tagGroupId: string | undefined,
+    tagId: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'tagTagDelete(%s, %s)', tagGroupId, tagId)
+
+    const request = new grpcPuppet.TagTagDeleteRequest()
+
+    if (typeof tagGroupId !== 'undefined') {
+      request.setTagGroupId(tagGroupId)
+    }
+    request.setTagId(tagId)
+
+    await util.promisify(
+      this.grpcManager.client.tagTagDelete
         .bind(this.grpcManager.client),
     )(request)
 
-    return response.getIdsList()
+  }
+
+  override async tagGroupList (): Promise<PUPPET.payloads.TagGroup[]> {
+    log.verbose('PuppetService', 'tagGroupList()')
+
+    const request = new grpcPuppet.TagGroupListRequest()
+
+    const result = await util.promisify(
+      this.grpcManager.client.tagGroupList
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const grpcPayloads = result.getPayloadsList()
+    const payloads: PUPPET.payloads.TagGroup[] = grpcPayloads.map(payload => {
+      return {
+        id: payload.getId(),
+        name: payload.getName(),
+      } as PUPPET.payloads.TagGroup
+    })
+    return payloads
+  }
+
+  override async tagGroupTagList (
+    tagGroupId: string | undefined,
+  ): Promise<PUPPET.payloads.Tag[]> {
+    log.verbose('PuppetService', 'tagGroupTagList(%s)', tagGroupId)
+
+    const request = new grpcPuppet.TagGroupTagListRequest()
+    if (typeof tagGroupId !== 'undefined') {
+      request.setTagGroupId(tagGroupId)
+    }
+
+    const result = await util.promisify(
+      this.grpcManager.client.tagGroupTagList
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const grpcPayloads = result.getPayloadsList()
+    const payloads: PUPPET.payloads.Tag[] = grpcPayloads.map(payload => {
+      return {
+        id: payload.getId(),
+        name: payload.getName(),
+        groupId: payload.getGroupId(),
+        type: payload.getType(),
+      } as PUPPET.payloads.Tag
+    })
+    return payloads
+  }
+
+  override async tagTagList (
+  ): Promise<PUPPET.payloads.Tag[]> {
+    log.verbose('PuppetService', 'tagTagList()')
+
+    const request = new grpcPuppet.TagTagListRequest()
+
+    const result = await util.promisify(
+      this.grpcManager.client.tagTagList
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const grpcPayloads = result.getPayloadsList()
+    const payloads: PUPPET.payloads.Tag[] = grpcPayloads.map(payload => {
+      return {
+        id: payload.getId(),
+        name: payload.getName(),
+        groupId: payload.getGroupId(),
+        type: payload.getType(),
+      } as PUPPET.payloads.Tag
+    })
+    return payloads
+  }
+
+  override async tagContactTagList (
+    contactId: string,
+  ): Promise<PUPPET.payloads.Tag[]> {
+    log.verbose('PuppetService', 'tagContactTagList(%s)', contactId)
+
+    const request = new grpcPuppet.TagContactTagListRequest()
+    request.setContactId(contactId)
+
+    const result = await util.promisify(
+      this.grpcManager.client.tagContactTagList
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const grpcPayloads = result.getPayloadsList()
+    const payloads: PUPPET.payloads.Tag[] = grpcPayloads.map(payload => {
+      return {
+        id: payload.getId(),
+        name: payload.getName(),
+        groupId: payload.getGroupId(),
+        type: payload.getType(),
+      } as PUPPET.payloads.Tag
+    })
+    return payloads
+  }
+
+  override async tagTagContactList (
+    tagGroupId: string | undefined,
+    tagId: string,
+  ): Promise<string[]> {
+    log.verbose('PuppetService', 'tagTagContactList(%s, %s)', tagGroupId, tagId)
+
+    const request = new grpcPuppet.TagTagContactListRequest()
+    if (typeof tagGroupId !== 'undefined') {
+      request.setTagGroupId(tagGroupId)
+    }
+    request.setTagId(tagId)
+
+    const result = await util.promisify(
+      this.grpcManager.client.tagTagContactList
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const payloads = result.getPayloadsList()
+    return payloads
   }
 
   /**

package/src/package-json.ts

@@ -4,7 +4,7 @@
 import type { PackageJson } from 'type-fest'
 export const packageJson: PackageJson = {
   "name": "@juzi/wechaty-puppet-service",
-  "version": "1.0.13",
+  "version": "1.0.17",
   "description": "Puppet Service for Wechaty",
   "type": "module",
   "exports": {
@@ -69,10 +69,10 @@ export const packageJson: PackageJson = {
     "why-is-node-running": "^2.2.1"
   },
   "peerDependencies": {
-    "@juzi/wechaty-puppet": "1.0.7"
+    "@juzi/wechaty-puppet": "^1.0.12"
   },
   "dependencies": {
-    "@juzi/wechaty-grpc": "1.0.7",
+    "@juzi/wechaty-grpc": "^1.0.11",
     "clone-class": "^1.1.1",
     "ducks": "^1.0.2",
     "file-box": "^1.5.5",

package/src/server/puppet-implementation.ts

@@ -1492,101 +1492,235 @@ function puppetImplementation (
       }
     },
 
-    tagContactAdd: async (call, callback) => {
-      log.verbose('PuppetServiceImpl', 'tagContactAdd()')
+    /**
+     *
+     * tag section
+     *
+     */
+
+    tagContactTagAdd: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagContactTagAdd()')
 
       try {
-        const tagId = call.request.getId()
+        const tagGroupId = call.request.getTagGroupId()
+        const tagId = call.request.getTagId()
         const contactId = call.request.getContactId()
 
-        await puppet.tagContactAdd(tagId, contactId)
+        await puppet.tagContactTagAdd(tagGroupId, tagId, contactId)
+
+        return callback(null, new grpcPuppet.TagContactTagAddResponse())
+      } catch (e) {
+        return grpcError('tagContactTagAdd', e, callback)
+      }
+    },
+
+    tagContactTagRemove: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagContactTagRemove()')
 
-        return callback(null, new grpcPuppet.TagContactAddResponse())
+      try {
+        const tagGroupId = call.request.getTagGroupId()
+        const tagId = call.request.getTagId()
+        const contactId = call.request.getContactId()
 
+        await puppet.tagContactTagRemove(tagGroupId, tagId, contactId)
+
+        return callback(null, new grpcPuppet.TagContactTagRemoveResponse())
       } catch (e) {
-        return grpcError('tagContactAdd', e, callback)
+        return grpcError('tagContactTagRemove', e, callback)
       }
     },
 
-    tagContactDelete: async (call, callback) => {
-      log.verbose('PuppetServiceImpl', 'tagContactDelete()')
+    tagGroupAdd: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagGroupAdd()')
 
       try {
-        const tagId = call.request.getId()
+        const tagGroupName = call.request.getTagGroupName()
 
-        await puppet.tagContactDelete(tagId)
+        const result = await puppet.tagGroupAdd(tagGroupName)
+        const payload = new grpcPuppet.TagGroupPayload()
+        const response = new grpcPuppet.TagGroupAddResponse()
 
-        return callback(null, new grpcPuppet.TagContactDeleteResponse())
+        if (result) {
+          payload.setId(result.id)
+          payload.setName(result.name)
+          response.setPayload(payload)
+        }
 
+        return callback(null, response)
       } catch (e) {
-        return grpcError('tagContactDelete', e, callback)
+        return grpcError('tagGroupAdd', e, callback)
       }
     },
 
-    tagContactList: async (call, callback) => {
-      log.verbose('PuppetServiceImpl', 'tagContactList()')
+    tagGroupDelete: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagGroupDelete()')
 
       try {
-        const contactId = call.request.getContactId()
+        const tagGroupId = call.request.getTagGroupId()
 
-        /**
-         * for a specific contact
-         */
-        if (contactId) {
-          const tagIdList = await puppet.tagContactList(contactId)
+        await puppet.tagGroupDelete(tagGroupId)
+
+        return callback(null, new grpcPuppet.TagGroupDeleteResponse())
+      } catch (e) {
+        return grpcError('tagGroupDelete', e, callback)
+      }
+    },
 
-          const response = new grpcPuppet.TagContactListResponse()
-          response.setIdsList(tagIdList)
+    tagTagAdd: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagTagAdd()')
 
-          return callback(null, new grpcPuppet.TagContactListResponse())
+      try {
+        const tagGroupId = call.request.getTagGroupId()
+        const tagName = call.request.getTagName()
+
+        const result = await puppet.tagTagAdd(tagGroupId, tagName)
+        const payload = new grpcPuppet.TagPayload()
+        const response = new grpcPuppet.TagTagAddResponse()
+
+        if (result) {
+          payload.setId(result.id)
+          payload.setName(result.name)
+          payload.setType(result.type)
+          if (result.groupId) {
+            payload.setGroupId(result.groupId)
+          }
+          response.setPayload(payload)
         }
 
-        {
-          /**
-            * Huan(202110): Deprecated: will be removed after Dec 31, 2022
-            */
-          const contactIdWrapper = call.request.getContactIdStringValueDeprecated()
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('tagTagAdd', e, callback)
+      }
+    },
 
-          if (contactIdWrapper) {
-            const contactId = contactIdWrapper.getValue()
+    tagTagDelete: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagTagDelete()')
 
-            const tagIdList = await puppet.tagContactList(contactId)
+      try {
+        const tagGroupId = call.request.getTagGroupId()
+        const tagId = call.request.getTagId()
 
-            const response = new grpcPuppet.TagContactListResponse()
-            response.setIdsList(tagIdList)
+        await puppet.tagTagDelete(tagGroupId, tagId)
 
-            return callback(null, new grpcPuppet.TagContactListResponse())
-          }
-        }
+        return callback(null, new grpcPuppet.TagTagDeleteResponse())
+      } catch (e) {
+        return grpcError('tagTagDelete', e, callback)
+      }
+    },
 
-        /**
-         * get all tags for all contact
-         */
-        const tagIdList = await puppet.tagContactList()
+    tagGroupList: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagGroupList()')
+      void call
 
-        const response = new grpcPuppet.TagContactListResponse()
-        response.setIdsList(tagIdList)
+      try {
+        const result = await puppet.tagGroupList()
+        const payloads = result.map(tagGroup => {
+          const payload = new grpcPuppet.TagGroupPayload()
+          payload.setId(tagGroup.id)
+          payload.setName(tagGroup.name)
+          return payload
+        })
+        const response = new grpcPuppet.TagGroupListResponse()
+        response.setPayloadsList(payloads)
 
         return callback(null, response)
+      } catch (e) {
+        return grpcError('tagGroupList', e, callback)
+      }
+    },
+
+    tagGroupTagList: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagGroupTagList()')
+
+      try {
+        const tagGroupId = call.request.getTagGroupId()
+
+        const result = await puppet.tagGroupTagList(tagGroupId)
+        const payloads = result.map(tag => {
+          const payload = new grpcPuppet.TagPayload()
+          payload.setId(tag.id)
+          payload.setName(tag.name)
+          payload.setType(tag.type)
+          if (tag.groupId) {
+            payload.setGroupId(tag.groupId)
+          }
+          return payload
+        })
+        const response = new grpcPuppet.TagGroupTagListResponse()
+        response.setPayloadsList(payloads)
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('tagTagList', e, callback)
+      }
+    },
 
+    tagTagList: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagTagList()')
+      void call
+
+      try {
+        const result = await puppet.tagTagList()
+        const payloads = result.map(tag => {
+          const payload = new grpcPuppet.TagPayload()
+          payload.setId(tag.id)
+          payload.setName(tag.name)
+          payload.setType(tag.type)
+          if (tag.groupId) {
+            payload.setGroupId(tag.groupId)
+          }
+          return payload
+        })
+        const response = new grpcPuppet.TagTagListResponse()
+        response.setPayloadsList(payloads)
+
+        return callback(null, response)
       } catch (e) {
-        return grpcError('tagContactList', e, callback)
+        return grpcError('tagTagList', e, callback)
       }
     },
 
-    tagContactRemove: async (call, callback) => {
-      log.verbose('PuppetServiceImpl', 'tagContactRemove()')
+    tagContactTagList: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagContactTagList()')
 
       try {
-        const tagId = call.request.getId()
         const contactId = call.request.getContactId()
 
-        await puppet.tagContactRemove(tagId, contactId)
+        const result = await puppet.tagContactTagList(contactId)
+        const payloads = result.map(tag => {
+          const payload = new grpcPuppet.TagPayload()
+          payload.setId(tag.id)
+          payload.setName(tag.name)
+          payload.setType(tag.type)
+          if (tag.groupId) {
+            payload.setGroupId(tag.groupId)
+          }
+          return payload
+        })
+        const response = new grpcPuppet.TagContactTagListResponse()
+        response.setPayloadsList(payloads)
 
-        return callback(null, new grpcPuppet.TagContactRemoveResponse())
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('tagContactTagList', e, callback)
+      }
+    },
+
+    tagTagContactList: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'tagTagContactList()')
+
+      try {
+        const tagGroupId = call.request.getTagGroupId()
+        const tagId = call.request.getTagId()
+
+        const result = await puppet.tagTagContactList(tagGroupId, tagId)
 
+        const response = new grpcPuppet.TagTagContactListResponse()
+        response.setPayloadsList(result)
+
+        return callback(null, response)
       } catch (e) {
-        return grpcError('tagContactRemove', e, callback)
+        return grpcError('tagTagContactList', e, callback)
       }
     },