improve comment ,参考：https://github.com/huacnlee/autocorrect

.golangci.yml

@@ -53,3 +53,68 @@ linters-settings:
     lines: 66
     statements: 50
 
+  errcheck:
+    # Report about not checking of errors in type assertions: `a := b.(MyStruct)`.
+    # Such cases aren't reported by default.
+    # Default: false
+    check-type-assertions: true
+    # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`.
+    # Such cases aren't reported by default.
+    # Default: false
+    check-blank: true
+    # To disable the errcheck built-in exclude list.
+    # See `-excludeonly` option in https://github.com/kisielk/errcheck#excluding-functions for details.
+    # Default: false
+    disable-default-exclusions: true
+    # List of functions to exclude from checking, where each entry is a single function to exclude.
+    # See https://github.com/kisielk/errcheck#excluding-functions for details.
+    exclude-functions:
+      - io/ioutil.ReadFile
+      - io.Copy(*bytes.Buffer)
+      - io.Copy(os.Stdout)
+      - (*bytes.Buffer).WriteString
+      - (*bytes.Buffer).Write
+      - url.Parse
+      - (*strings.Builder).WriteString
+      - io.WriteString
+      - (*bytes.Buffer).WriteByte
+      - (*hmac.New).Write
+      - (*int)
+      - (*string)
+      - (hash.Hash).Write
+
+  depguard:
+    # Rules to apply.
+    #
+    # Variables:
+    # - File Variables
+    #   you can still use and exclamation mark ! in front of a variable to say not to use it.
+    #   Example !$test will match any file that is not a go test file.
+    #
+    #   `$all` - matches all go files
+    #   `$test` - matches all go test files
+    #
+    # - Package Variables
+    #
+    #  `$gostd` - matches all of go's standard library (Pulled from `GOROOT`)
+    #
+    # Default: Only allow $gostd in all files.
+    rules:
+      # Name of a rule.
+      main:
+        # Used to determine the package matching priority.
+        # There are three different modes: `original`, `strict`, and `lax`.
+        # Default: "original"
+        list-mode: lax
+        # List of file globs that will match this list of settings to compare against.
+        # Default: $all
+        files:
+          - "!**/*_a _file.go"
+        # List of allowed packages.
+        allow:
+          - $gostd
+          - github.com/OpenPeeDeeP
+        # Packages that are not allowed where the value is a suggestion.
+        deny:
+          - pkg: "github.com/pkg/errors"
+            desc: Should be replaced by standard lib errors package

README.md

@@ -5,12 +5,12 @@
 [![pkg](https://img.shields.io/badge/dev-reference-007d9c?logo=go&logoColor=white&style=flat)](https://pkg.go.dev/github.com/silenceper/wechat/v2?tab=doc)
 ![version](https://img.shields.io/badge/version-v2-green)
 
-使用Golang开发的微信SDK，简单、易用。
-> 注意：当前版本为v2版本，v1版本已废弃
+使用 Golang 开发的微信 SDK，简单、易用。
+> 注意：当前版本为 v2 版本，v1 版本已废弃
 
 ## 文档 && 例子
 
-[API列表](https://github.com/silenceper/wechat/tree/v2/doc/api)
+[API 列表](https://github.com/silenceper/wechat/tree/v2/doc/api)
 
 [Wechat SDK 2.0 文档](https://silenceper.com/wechat)
 
@@ -25,7 +25,7 @@ import "github.com/silenceper/wechat/v2"
 以下是一个微信公众号处理消息接收以及回复的例子：
 
 ```go
-// 使用memcache保存access_token，也可选择redis或自定义cache
+// 使用 memcache 保存 access_token，也可选择 redis 或自定义 cache
 wc := wechat.NewWechat()
 memory := cache.NewMemory()
 cfg := &offConfig.Config{
@@ -37,7 +37,7 @@ cfg := &offConfig.Config{
 }
 officialAccount := wc.GetOfficialAccount(cfg)
 
-// 传入request和responseWriter
+// 传入 request 和 responseWriter
 server := officialAccount.GetServer(req, rw)
 // 设置接收消息的处理方法
 server.SetMessageHandler(func(msg *message.MixMessage) *message.Reply {
@@ -60,20 +60,20 @@ server.Send()
 
 ## 目录说明
 
-- officialaccount: 微信公众号API
-- miniprogram: 小程序API
-- minigame:小游戏API
-- pay:微信支付API
-- openplatform:开放平台API
+- officialaccount: 微信公众号 API
+- miniprogram: 小程序 API
+- minigame:小游戏 API
+- pay:微信支付 API
+- openplatform:开放平台 API
 - work:企业微信
 - aispeech:智能对话
-- doc: api文档
+- doc: api 文档
 
 ## 贡献
 
-- 在[API列表](https://github.com/silenceper/wechat/tree/v2/doc/api)中查看哪些API未实现
-- 提交issue，描述需要贡献的内容
-- 完成更改后，提交PR
+- 在[API 列表](https://github.com/silenceper/wechat/tree/v2/doc/api)中查看哪些 API 未实现
+- 提交 issue，描述需要贡献的内容
+- 完成更改后，提交 PR
 
 ## 公众号
 

cache/memcache_test.go

@@ -22,12 +22,16 @@ func TestMemcache(t *testing.T) {
 	exists := mem.IsExist("unknown-key")
 	assert.Equal(t, false, exists)
 
-	name := mem.Get("username").(string)
+	name, ok := mem.Get("username").(string)
+	if !ok {
+		t.Error("get Error")
+	}
 	if name != "" {
 		if name != "silenceper" {
 			t.Error("get Error")
 		}
 	}
+
 	data := mem.Get("unknown-key")
 	assert.Nil(t, data)
 

cache/redis.go

@@ -35,12 +35,12 @@ func NewRedis(ctx context.Context, opts *RedisOpts) *Redis {
 	return &Redis{ctx: ctx, conn: conn}
 }
 
-// SetConn 设置conn
+// SetConn 设置 conn
 func (r *Redis) SetConn(conn redis.UniversalClient) {
 	r.conn = conn
 }
 
-// SetRedisCtx 设置redis ctx 参数
+// SetRedisCtx 设置 redis ctx 参数
 func (r *Redis) SetRedisCtx(ctx context.Context) {
 	r.ctx = ctx
 }
@@ -69,15 +69,17 @@ func (r *Redis) SetContext(ctx context.Context, key string, val interface{}, tim
 	return r.conn.SetEX(ctx, key, val, timeout).Err()
 }
 
-// IsExist 判断key是否存在
+// IsExist 判断 key 是否存在
 func (r *Redis) IsExist(key string) bool {
 	return r.IsExistContext(r.ctx, key)
 }
 
-// IsExistContext 判断key是否存在
+// IsExistContext 判断 key 是否存在
 func (r *Redis) IsExistContext(ctx context.Context, key string) bool {
-	result, _ := r.conn.Exists(ctx, key).Result()
-
+	result, err := r.conn.Exists(ctx, key).Result()
+	if err != nil {
+		return false
+	}
 	return result > 0
 }
 

cache/redis_test.go

@@ -35,7 +35,10 @@ func TestRedis(t *testing.T) {
 		t.Error("IsExist Error")
 	}
 
-	name := redis.Get(key).(string)
+	name, ok := redis.Get(key).(string)
+	if !ok {
+		t.Error("get Error")
+	}
 	if name != val {
 		t.Error("get Error")
 	}

credential/default_access_token.go

@@ -12,21 +12,21 @@ import (
 )
 
 const (
-	// accessTokenURL 获取access_token的接口
+	// accessTokenURL 获取 access_token 的接口
 	accessTokenURL = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s"
-	// stableAccessTokenURL 获取稳定版access_token的接口
+	// stableAccessTokenURL 获取稳定版 access_token 的接口
 	stableAccessTokenURL = "https://api.weixin.qq.com/cgi-bin/stable_token"
-	// workAccessTokenURL 企业微信获取access_token的接口
+	// workAccessTokenURL 企业微信获取 access_token 的接口
 	workAccessTokenURL = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s"
-	// CacheKeyOfficialAccountPrefix 微信公众号cache key前缀
+	// CacheKeyOfficialAccountPrefix 微信公众号 cache key 前缀
 	CacheKeyOfficialAccountPrefix = "gowechat_officialaccount_"
-	// CacheKeyMiniProgramPrefix 小程序cache key前缀
+	// CacheKeyMiniProgramPrefix 小程序 cache key 前缀
 	CacheKeyMiniProgramPrefix = "gowechat_miniprogram_"
-	// CacheKeyWorkPrefix 企业微信cache key前缀
+	// CacheKeyWorkPrefix 企业微信 cache key 前缀
 	CacheKeyWorkPrefix = "gowechat_work_"
 )
 
-// DefaultAccessToken 默认AccessToken 获取
+// DefaultAccessToken 默认 AccessToken 获取
 type DefaultAccessToken struct {
 	appID           string
 	appSecret       string
@@ -57,34 +57,36 @@ type ResAccessToken struct {
 	ExpiresIn   int64  `json:"expires_in"`
 }
 
-// GetAccessToken 获取access_token,先从cache中获取，没有则从服务端获取
+// GetAccessToken 获取 access_token，先从 cache 中获取，没有则从服务端获取
 func (ak *DefaultAccessToken) GetAccessToken() (accessToken string, err error) {
 	return ak.GetAccessTokenContext(context.Background())
 }
 
-// GetAccessTokenContext 获取access_token,先从cache中获取，没有则从服务端获取
+// GetAccessTokenContext 获取 access_token，先从 cache 中获取，没有则从服务端获取
 func (ak *DefaultAccessToken) GetAccessTokenContext(ctx context.Context) (accessToken string, err error) {
-	// 先从cache中取
+	// 先从 cache 中取
 	accessTokenCacheKey := fmt.Sprintf("%s_access_token_%s", ak.cacheKeyPrefix, ak.appID)
 
 	if val := ak.cache.Get(accessTokenCacheKey); val != nil {
-		if accessToken = val.(string); accessToken != "" {
+		var ok bool
+		if accessToken, ok = val.(string); ok && accessToken != "" {
 			return
 		}
 	}
 
-	// 加上lock，是为了防止在并发获取token时，cache刚好失效，导致从微信服务器上获取到不同token
+	// 加上 lock，是为了防止在并发获取 token 时，cache 刚好失效，导致从微信服务器上获取到不同 token
 	ak.accessTokenLock.Lock()
 	defer ak.accessTokenLock.Unlock()
 
 	// 双检，防止重复从微信服务器获取
 	if val := ak.cache.Get(accessTokenCacheKey); val != nil {
-		if accessToken = val.(string); accessToken != "" {
+		var ok bool
+		if accessToken, ok = val.(string); ok && accessToken != "" {
 			return
 		}
 	}
 
-	// cache失效，从微信服务器获取
+	// cache 失效，从微信服务器获取
 	var resAccessToken ResAccessToken
 	if resAccessToken, err = GetTokenFromServerContext(ctx, fmt.Sprintf(accessTokenURL, ak.appID, ak.appSecret)); err != nil {
 		return
@@ -97,8 +99,8 @@ func (ak *DefaultAccessToken) GetAccessTokenContext(ctx context.Context) (access
 	return
 }
 
-// StableAccessToken 获取稳定版接口调用凭据(与getAccessToken获取的调用凭证完全隔离，互不影响)
-// 不强制更新access_token,可用于不同环境不同服务而不需要分布式锁以及公用缓存，避免access_token争抢
+// StableAccessToken 获取稳定版接口调用凭据 (与 getAccessToken 获取的调用凭证完全隔离，互不影响)
+// 不强制更新 access_token，可用于不同环境不同服务而不需要分布式锁以及公用缓存，避免 access_token 争抢
 // https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/mp-access-token/getStableAccessToken.html
 type StableAccessToken struct {
 	appID          string
@@ -120,20 +122,20 @@ func NewStableAccessToken(appID, appSecret, cacheKeyPrefix string, cache cache.C
 	}
 }
 
-// GetAccessToken 获取access_token,先从cache中获取，没有则从服务端获取
+// GetAccessToken 获取 access_token，先从 cache 中获取，没有则从服务端获取
 func (ak *StableAccessToken) GetAccessToken() (accessToken string, err error) {
 	return ak.GetAccessTokenContext(context.Background())
 }
 
-// GetAccessTokenContext 获取access_token,先从cache中获取，没有则从服务端获取
+// GetAccessTokenContext 获取 access_token，先从 cache 中获取，没有则从服务端获取
 func (ak *StableAccessToken) GetAccessTokenContext(ctx context.Context) (accessToken string, err error) {
-	// 先从cache中取
+	// 先从 cache 中取
 	accessTokenCacheKey := fmt.Sprintf("%s_stable_access_token_%s", ak.cacheKeyPrefix, ak.appID)
 	if val := ak.cache.Get(accessTokenCacheKey); val != nil {
 		return val.(string), nil
 	}
 
-	// cache失效，从微信服务器获取
+	// cache 失效，从微信服务器获取
 	var resAccessToken ResAccessToken
 	resAccessToken, err = ak.GetAccessTokenDirectly(ctx, false)
 	if err != nil {
@@ -147,7 +149,7 @@ func (ak *StableAccessToken) GetAccessTokenContext(ctx context.Context) (accessT
 	return
 }
 
-// GetAccessTokenDirectly 从微信获取access_token
+// GetAccessTokenDirectly 从微信获取 access_token
 func (ak *StableAccessToken) GetAccessTokenDirectly(ctx context.Context, forceRefresh bool) (resAccessToken ResAccessToken, err error) {
 	b, err := util.PostJSONContext(ctx, stableAccessTokenURL, map[string]interface{}{
 		"grant_type":    "client_credential",
@@ -170,7 +172,7 @@ func (ak *StableAccessToken) GetAccessTokenDirectly(ctx context.Context, forceRe
 	return
 }
 
-// WorkAccessToken 企业微信AccessToken 获取
+// WorkAccessToken 企业微信 AccessToken 获取
 type WorkAccessToken struct {
 	CorpID          string
 	CorpSecret      string
@@ -193,24 +195,27 @@ func NewWorkAccessToken(corpID, corpSecret, cacheKeyPrefix string, cache cache.C
 	}
 }
 
-// GetAccessToken 企业微信获取access_token,先从cache中获取，没有则从服务端获取
+// GetAccessToken 企业微信获取 access_token，先从 cache 中获取，没有则从服务端获取
 func (ak *WorkAccessToken) GetAccessToken() (accessToken string, err error) {
 	return ak.GetAccessTokenContext(context.Background())
 }
 
-// GetAccessTokenContext 企业微信获取access_token,先从cache中获取，没有则从服务端获取
+// GetAccessTokenContext 企业微信获取 access_token，先从 cache 中获取，没有则从服务端获取
 func (ak *WorkAccessToken) GetAccessTokenContext(ctx context.Context) (accessToken string, err error) {
-	// 加上lock，是为了防止在并发获取token时，cache刚好失效，导致从微信服务器上获取到不同token
+	// 加上 lock，是为了防止在并发获取 token 时，cache 刚好失效，导致从微信服务器上获取到不同 token
 	ak.accessTokenLock.Lock()
 	defer ak.accessTokenLock.Unlock()
 	accessTokenCacheKey := fmt.Sprintf("%s_access_token_%s", ak.cacheKeyPrefix, ak.CorpID)
 	val := ak.cache.Get(accessTokenCacheKey)
 	if val != nil {
-		accessToken = val.(string)
+		var ok bool
+		if accessToken, ok = val.(string); !ok {
+			accessToken = ""
+		}
 		return
 	}
 
-	// cache失效，从微信服务器获取
+	// cache 失效，从微信服务器获取
 	var resAccessToken ResAccessToken
 	resAccessToken, err = GetTokenFromServerContext(ctx, fmt.Sprintf(workAccessTokenURL, ak.CorpID, ak.CorpSecret))
 	if err != nil {
@@ -224,12 +229,12 @@ func (ak *WorkAccessToken) GetAccessTokenContext(ctx context.Context) (accessTok
 	return
 }
 
-// GetTokenFromServer 强制从微信服务器获取token
+// GetTokenFromServer 强制从微信服务器获取 token
 func GetTokenFromServer(url string) (resAccessToken ResAccessToken, err error) {
 	return GetTokenFromServerContext(context.Background(), url)
 }
 
-// GetTokenFromServerContext 强制从微信服务器获取token
+// GetTokenFromServerContext 强制从微信服务器获取 token
 func GetTokenFromServerContext(ctx context.Context, url string) (resAccessToken ResAccessToken, err error) {
 	var body []byte
 	body, err = util.HTTPGetContext(ctx, url)

credential/default_js_ticket.go

@@ -10,15 +10,15 @@ import (
 	"github.com/silenceper/wechat/v2/util"
 )
 
-// getTicketURL 获取ticket的url
+// getTicketURL 获取 ticket 的 url
 const getTicketURL = "https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=%s&type=jsapi"
 
-// DefaultJsTicket 默认获取js ticket方法
+// DefaultJsTicket 默认获取 js ticket 方法
 type DefaultJsTicket struct {
 	appID          string
 	cacheKeyPrefix string
 	cache          cache.Cache
-	// jsAPITicket 读写锁 同一个AppID一个
+	// jsAPITicket 读写锁 同一个 AppID 一个
 	jsAPITicketLock *sync.Mutex
 }
 
@@ -32,7 +32,7 @@ func NewDefaultJsTicket(appID string, cacheKeyPrefix string, cache cache.Cache)
 	}
 }
 
-// ResTicket 请求jsapi_tikcet返回结果
+// ResTicket 请求 jsapi_tikcet 返回结果
 type ResTicket struct {
 	util.CommonError
 
@@ -40,9 +40,9 @@ type ResTicket struct {
 	ExpiresIn int64  `json:"expires_in"`
 }
 
-// GetTicket 获取jsapi_ticket
+// GetTicket 获取 jsapi_ticket
 func (js *DefaultJsTicket) GetTicket(accessToken string) (ticketStr string, err error) {
-	// 先从cache中取
+	// 先从 cache 中取
 	jsAPITicketCacheKey := fmt.Sprintf("%s_jsapi_ticket_%s", js.cacheKeyPrefix, js.appID)
 	if val := js.cache.Get(jsAPITicketCacheKey); val != nil {
 		return val.(string), nil
@@ -67,7 +67,7 @@ func (js *DefaultJsTicket) GetTicket(accessToken string) (ticketStr string, err
 	return
 }
 
-// GetTicketFromServer 从服务器中获取ticket
+// GetTicketFromServer 从服务器中获取 ticket
 func GetTicketFromServer(accessToken string) (ticket ResTicket, err error) {
 	var response []byte
 	url := fmt.Sprintf(getTicketURL, accessToken)

credential/js_ticket.go

@@ -1,7 +1,7 @@
 package credential
 
-// JsTicketHandle js ticket获取
+// JsTicketHandle js ticket 获取
 type JsTicketHandle interface {
-	// GetTicket 获取ticket
+	// GetTicket 获取 ticket
 	GetTicket(accessToken string) (ticket string, err error)
 }

doc/api/README.md

@@ -1,10 +1,10 @@
 # API 文档
 
-已完成以及未完成API列表汇总
+已完成以及未完成 API 列表汇总
 
-如果有兴趣参与贡献，可以在具体的API表格后面标识自己为贡献者以及完成时间，例如：
+如果有兴趣参与贡献，可以在具体的 API 表格后面标识自己为贡献者以及完成时间，例如：
 
-|          名称           | 请求方式 | URL                        | 是否已实现 | 使用方法 |贡献者|完成时间|
+|          名称           | 请求方式 | URL                        | 是否已实现 | 使用方法 |贡献者 | 完成时间|
 | :---------------------: | -------- | :------------------------- | ---------- | -------- |-------- |-------- |
 | 获取公众号类目       | GET      | /wxaapi/newtmpl/getcategory            | NO         |   |silenceper| 2021-12-20|
 

doc/api/miniprogram.md

@@ -37,7 +37,7 @@ TODO
 
 |        名称        | 请求方式 | URL                              | 是否已实现 | 使用方法                            |
 | :----------------: | -------- | :------------------------------- | ---------- | ----------------------------------- |
-| code换取用户手机号 | POST     | /wxa/business/getuserphonenumber | YES        | (business *Business) GetPhoneNumber |
+| code 换取用户手机号 | POST     | /wxa/business/getuserphonenumber | YES        | (business *Business) GetPhoneNumber |
 
 
 ## 安全风控

doc/api/officialaccount.md

@@ -155,7 +155,7 @@
 | 通过网页授权的 code 换取 access_token(区别于 context 中的 access_token) | GET      | /sns/oauth2/access_token                            | YES        | (oauth \*Oauth) GetUserAccessToken   |
 | 刷新 access_token                                                       | GET      | /sns/oauth2/refresh_token?                          | YES        | (oauth \*Oauth) RefreshAccessToken   |
 | 检验 access_token 是否有效                                              | GET      | /sns/auth                                           | YES        | (oauth \*Oauth) CheckAccessToken(    |
-| 拉取用户信息(需 scope 为 snsapi_userinfo)                               | GET      | /sns/userinfo                                       | YES        | (oauth \*Oauth) GetUserInfo          |
+| 拉取用户信息 (需 scope 为 snsapi_userinfo)                               | GET      | /sns/userinfo                                       | YES        | (oauth \*Oauth) GetUserInfo          |
 | 获取 jssdk 需要的配置参数                                               | GET      | /cgi-bin/ticket/getticket                           | YES        | (js \*Js) GetConfig                  |
 
 ## 素材管理

doc/api/work.md

@@ -89,10 +89,10 @@ host: https://qyapi.weixin.qq.com/
 
 |    名称     | 请求方式 | URL                                     | 是否已实现   | 使用方法                            | 贡献者      |
 |:---------:|------|:----------------------------------------| ---------- | -------------------------------   |----------|
-| 获取子部门ID列表 | GET  | /cgi-bin/department/simplelist          | YES        | (r *Client) DepartmentSimpleList| MARKWANG |
+| 获取子部门 ID 列表 | GET  | /cgi-bin/department/simplelist          | YES        | (r *Client) DepartmentSimpleList| MARKWANG |
 | 获取部门列表 | GET  | /cgi-bin/department/list                 | YES        | (r *Client) DepartmentList| just5325, ourines |
 |  获取部门成员   | GET | /cgi-bin/user/simplelist                | YES        | (r *Client) UserSimpleList  | MARKWANG  |
-|  获取成员ID列表   | Post | /cgi-bin/user/list_id                | YES        | (r *Client) UserListId  | MARKWANG  |
+|  获取成员 ID 列表   | Post | /cgi-bin/user/list_id                | YES        | (r *Client) UserListId  | MARKWANG  |
 
 
 

internal/openapi/mgnt.go

@@ -11,13 +11,13 @@ import (
 )
 
 const (
-	clearQuotaURL            = "https://api.weixin.qq.com/cgi-bin/clear_quota"       // 重置API调用次数
-	getAPIQuotaURL           = "https://api.weixin.qq.com/cgi-bin/openapi/quota/get" // 查询API调用额度
-	getRidInfoURL            = "https://api.weixin.qq.com/cgi-bin/openapi/rid/get"   // 查询rid信息
-	clearQuotaByAppSecretURL = "https://api.weixin.qq.com/cgi-bin/clear_quota/v2"    // 使用AppSecret重置 API 调用次数
+	clearQuotaURL            = "https://api.weixin.qq.com/cgi-bin/clear_quota"       // 重置 API 调用次数
+	getAPIQuotaURL           = "https://api.weixin.qq.com/cgi-bin/openapi/quota/get" // 查询 API 调用额度
+	getRidInfoURL            = "https://api.weixin.qq.com/cgi-bin/openapi/rid/get"   // 查询 rid 信息
+	clearQuotaByAppSecretURL = "https://api.weixin.qq.com/cgi-bin/clear_quota/v2"    // 使用 AppSecret 重置 API 调用次数
 )
 
-// OpenAPI openApi管理
+// OpenAPI openApi 管理
 type OpenAPI struct {
 	ctx interface{}
 }
@@ -27,7 +27,7 @@ func NewOpenAPI(ctx interface{}) *OpenAPI {
 	return &OpenAPI{ctx: ctx}
 }
 
-// ClearQuota 重置API调用次数
+// ClearQuota 重置 API 调用次数
 // https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/openApi-mgnt/clearQuota.html
 func (o *OpenAPI) ClearQuota() error {
 	appID, _, err := o.getAppIDAndSecret()
@@ -48,7 +48,7 @@ func (o *OpenAPI) ClearQuota() error {
 	return util.DecodeWithCommonError(res, "ClearQuota")
 }
 
-// GetAPIQuota 查询API调用额度
+// GetAPIQuota 查询 API 调用额度
 // https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/openApi-mgnt/getApiQuota.html
 func (o *OpenAPI) GetAPIQuota(params openapi.GetAPIQuotaParams) (quota openapi.APIQuota, err error) {
 	res, err := o.doPostRequest(getAPIQuotaURL, params)
@@ -60,7 +60,7 @@ func (o *OpenAPI) GetAPIQuota(params openapi.GetAPIQuotaParams) (quota openapi.A
 	return
 }
 
-// GetRidInfo 查询rid信息
+// GetRidInfo 查询 rid 信息
 // https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/openApi-mgnt/getRidInfo.html
 func (o *OpenAPI) GetRidInfo(params openapi.GetRidInfoParams) (r openapi.RidInfo, err error) {
 	res, err := o.doPostRequest(getRidInfoURL, params)
@@ -72,7 +72,7 @@ func (o *OpenAPI) GetRidInfo(params openapi.GetRidInfoParams) (r openapi.RidInfo
 	return
 }
 
-// ClearQuotaByAppSecret 使用AppSecret重置 API 调用次数
+// ClearQuotaByAppSecret 使用 AppSecret 重置 API 调用次数
 // https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/openApi-mgnt/clearQuotaByAppSecret.html
 func (o *OpenAPI) ClearQuotaByAppSecret() error {
 	id, secret, err := o.getAppIDAndSecret()
@@ -93,10 +93,16 @@ func (o *OpenAPI) ClearQuotaByAppSecret() error {
 func (o *OpenAPI) getAppIDAndSecret() (string, string, error) {
 	switch o.ctx.(type) {
 	case *mpContext.Context:
-		c := o.ctx.(*mpContext.Context)
+		c, ok := o.ctx.(*mpContext.Context)
+		if !ok {
+			return "", "", errors.New("invalid context type")
+		}
 		return c.AppID, c.AppSecret, nil
 	case *ocContext.Context:
-		c := o.ctx.(*ocContext.Context)
+		c, ok := o.ctx.(*ocContext.Context)
+		if !ok {
+			return "", "", errors.New("invalid context type")
+		}
 		return c.AppID, c.AppSecret, nil
 	default:
 		return "", "", errors.New("invalid context type")

miniprogram/analysis/analysis.go

@@ -56,8 +56,8 @@ func (analysis *Analysis) fetchData(urlStr string, body interface{}) (response [
 
 // RetainItem 留存项结构
 type RetainItem struct {
-	Key   int `json:"key"`   // 标识，0开始表示当天，1表示1甜后，以此类推
-	Value int `json:"value"` // key对应日期的新增用户数/活跃用户数（key=0时）或留存用户数（k>0时）
+	Key   int `json:"key"`   // 标识，0 开始表示当天，1 表示 1 甜后，以此类推
+	Value int `json:"value"` // key 对应日期的新增用户数/活跃用户数（key=0 时）或留存用户数（k>0 时）
 }
 
 // ResAnalysisRetain 小程序留存数据返回
@@ -68,7 +68,7 @@ type ResAnalysisRetain struct {
 	VisitUV    []RetainItem `json:"visit_uv"`     // 活跃用户留存
 }
 
-// getAnalysisRetain 获取用户访问小程序留存数据(日、月、周)
+// getAnalysisRetain 获取用户访问小程序留存数据 (日、月、周)
 func (analysis *Analysis) getAnalysisRetain(urlStr string, beginDate, endDate string) (result ResAnalysisRetain, err error) {
 	body := map[string]string{
 		"begin_date": beginDate,
@@ -137,7 +137,7 @@ func (analysis *Analysis) GetAnalysisDailySummary(beginDate, endDate string) (re
 	return
 }
 
-// ResAnalysisVisitTrend 小程序访问数据趋势(日、月、周)
+// ResAnalysisVisitTrend 小程序访问数据趋势 (日、月、周)
 type ResAnalysisVisitTrend struct {
 	util.CommonError
 	List []struct {
@@ -152,7 +152,7 @@ type ResAnalysisVisitTrend struct {
 	} `json:"list"`
 }
 
-// getAnalysisRetain 获取小程序访问数据趋势(日、月、周)
+// getAnalysisRetain 获取小程序访问数据趋势 (日、月、周)
 func (analysis *Analysis) getAnalysisVisitTrend(urlStr string, beginDate, endDate string) (result ResAnalysisVisitTrend, err error) {
 	body := map[string]string{
 		"begin_date": beginDate,
@@ -190,9 +190,9 @@ func (analysis *Analysis) GetAnalysisWeeklyVisitTrend(beginDate, endDate string)
 
 // UserPortraitItem 用户画像项目
 type UserPortraitItem struct {
-	ID    int    `json:"id"`    // 属性值id
+	ID    int    `json:"id"`    // 属性值 id
 	Name  string `json:"name"`  // 属性值名称
-	Value int    `json:"value"` // 该场景访问uv
+	Value int    `json:"value"` // 该场景访问 uv
 }
 
 // UserPortrait 用户画像
@@ -201,9 +201,9 @@ type UserPortrait struct {
 	Province  []UserPortraitItem `json:"province"`  // 省份，如北京、广东等
 	City      []UserPortraitItem `json:"city"`      // 城市，如北京、广州等
 	Genders   []UserPortraitItem `json:"genders"`   // 性别，包括男、女、未知
-	Platforms []UserPortraitItem `json:"platforms"` // 终端类型，包括iPhone, android, 其他
-	Devices   []UserPortraitItem `json:"devices"`   // 机型，如苹果iPhone 6, OPPO R9等
-	Ages      []UserPortraitItem `json:"ages"`      // 年龄，包括17岁以下、18-24对等区间
+	Platforms []UserPortraitItem `json:"platforms"` // 终端类型，包括 iPhone, android, 其他
+	Devices   []UserPortraitItem `json:"devices"`   // 机型，如苹果 iPhone 6, OPPO R9 等
+	Ages      []UserPortraitItem `json:"ages"`      // 年龄，包括 17 岁以下、18-24 对等区间
 }
 
 // ResAnalysisUserPortrait 小程序新增或活跃用户的画像分布数据返回
@@ -237,9 +237,9 @@ func (analysis *Analysis) GetAnalysisUserPortrait(beginDate, endDate string) (re
 
 // VisitDistributionIndexItem 访问分数数据结构
 type VisitDistributionIndexItem struct {
-	Key                 int `json:"key"`                    // 场景id
-	Value               int `json:"value"`                  // 该场景id访问pv
-	AccessSourceVisitUV int `json:"access_source_visit_uv"` // 该场景id访问uv
+	Key                 int `json:"key"`                    // 场景 id
+	Value               int `json:"value"`                  // 该场景 id 访问 pv
+	AccessSourceVisitUV int `json:"access_source_visit_uv"` // 该场景 id 访问 uv
 }
 
 // VisitDistributionIndex 访问分布单分布类型数据

miniprogram/auth/auth.go

@@ -33,7 +33,7 @@ type ResCode2Session struct {
 
 	OpenID     string `json:"openid"`      // 用户唯一标识
 	SessionKey string `json:"session_key"` // 会话密钥
-	UnionID    string `json:"unionid"`     // 用户在开放平台的唯一标识符，在满足UnionID下发条件的情况下会返回
+	UnionID    string `json:"unionid"`     // 用户在开放平台的唯一标识符，在满足 UnionID 下发条件的情况下会返回
 }
 
 // RspCheckEncryptedData .
@@ -70,12 +70,12 @@ func (auth *Auth) GetPaidUnionID() {
 	// TODO
 }
 
-// CheckEncryptedData .检查加密信息是否由微信生成（当前只支持手机号加密数据），只能检测最近3天生成的加密数据
+// CheckEncryptedData .检查加密信息是否由微信生成（当前只支持手机号加密数据），只能检测最近 3 天生成的加密数据
 func (auth *Auth) CheckEncryptedData(encryptedMsgHash string) (result RspCheckEncryptedData, err error) {
 	return auth.CheckEncryptedDataContext(context2.Background(), encryptedMsgHash)
 }
 
-// CheckEncryptedDataContext .检查加密信息是否由微信生成（当前只支持手机号加密数据），只能检测最近3天生成的加密数据
+// CheckEncryptedDataContext .检查加密信息是否由微信生成（当前只支持手机号加密数据），只能检测最近 3 天生成的加密数据
 func (auth *Auth) CheckEncryptedDataContext(ctx context2.Context, encryptedMsgHash string) (result RspCheckEncryptedData, err error) {
 	var response []byte
 	var (
@@ -85,7 +85,7 @@ func (auth *Auth) CheckEncryptedDataContext(ctx context2.Context, encryptedMsgHa
 		return
 	}
 
-	// 由于GetPhoneNumberContext需要传入JSON，所以HTTPPostContext入参改为[]byte
+	// 由于 GetPhoneNumberContext 需要传入 JSON，所以 HTTPPostContext 入参改为 []byte
 	if response, err = util.HTTPPostContext(ctx, fmt.Sprintf(checkEncryptedDataURL, at), []byte("encrypted_msg_hash="+encryptedMsgHash), nil); err != nil {
 		return
 	}
@@ -113,7 +113,7 @@ type PhoneInfo struct {
 	} `json:"watermark"` // 数据水印
 }
 
-// GetPhoneNumberContext 小程序通过code获取用户手机号
+// GetPhoneNumberContext 小程序通过 code 获取用户手机号
 func (auth *Auth) GetPhoneNumberContext(ctx context2.Context, code string) (*GetPhoneNumberResponse, error) {
 	var response []byte
 	var (
@@ -142,7 +142,7 @@ func (auth *Auth) GetPhoneNumberContext(ctx context2.Context, code string) (*Get
 	return &result, err
 }
 
-// GetPhoneNumber 小程序通过code获取用户手机号
+// GetPhoneNumber 小程序通过 code 获取用户手机号
 func (auth *Auth) GetPhoneNumber(code string) (*GetPhoneNumberResponse, error) {
 	return auth.GetPhoneNumberContext(context2.Background(), code)
 }

miniprogram/business/phone_number.go

@@ -21,12 +21,12 @@ type PhoneInfo struct {
 	PurePhoneNumber string `json:"purePhoneNumber"` // 没有区号的手机号
 	CountryCode     string `json:"countryCode"`     // 区号
 	Watermark       struct {
-		AppID     string `json:"appid"`     // 小程序appid
+		AppID     string `json:"appid"`     // 小程序 appid
 		Timestamp int64  `json:"timestamp"` // 用户获取手机号操作的时间戳
 	} `json:"watermark"`
 }
 
-// GetPhoneNumber code换取用户手机号。 每个code只能使用一次，code的有效期为5min
+// GetPhoneNumber code 换取用户手机号。每个 code 只能使用一次，code 的有效期为 5min
 func (business *Business) GetPhoneNumber(in *GetPhoneNumberRequest) (info PhoneInfo, err error) {
 	accessToken, err := business.GetAccessToken()
 	if err != nil {

miniprogram/content/content.go

@@ -44,7 +44,7 @@ func (content *Content) CheckText(text string) error {
 }
 
 // CheckImage 检测图片
-// 所传参数为要检测的图片文件的绝对路径，图片格式支持PNG、JPEG、JPG、GIF, 像素不超过 750 x 1334，同时文件大小以不超过 300K 为宜，否则可能报错
+// 所传参数为要检测的图片文件的绝对路径，图片格式支持 PNG、JPEG、JPG、GIF, 像素不超过 750 x 1334，同时文件大小以不超过 300K 为宜，否则可能报错
 // @media 图片文件的绝对路径
 // Deprecated
 // 采用 security.ImageCheckV1 替代，返回值更加丰富

miniprogram/encryptor/encryptor.go

@@ -24,13 +24,13 @@ func NewEncryptor(context *context.Context) *Encryptor {
 }
 
 var (
-	// ErrAppIDNotMatch appid不匹配
+	// ErrAppIDNotMatch appid 不匹配
 	ErrAppIDNotMatch = errors.New("app id not match")
-	// ErrInvalidBlockSize block size不合法
+	// ErrInvalidBlockSize block size 不合法
 	ErrInvalidBlockSize = errors.New("invalid block size")
-	// ErrInvalidPKCS7Data PKCS7数据不合法
+	// ErrInvalidPKCS7Data PKCS7 数据不合法
 	ErrInvalidPKCS7Data = errors.New("invalid PKCS7 data")
-	// ErrInvalidPKCS7Padding 输入padding失败
+	// ErrInvalidPKCS7Padding 输入 padding 失败
 	ErrInvalidPKCS7Padding = errors.New("invalid padding on input")
 )
 

miniprogram/message/updatable_msg.go

@@ -8,7 +8,7 @@ import (
 )
 
 const (
-	// createActivityURL 创建activity_id
+	// createActivityURL 创建 activity_id
 	createActivityURL = "https://api.weixin.qq.com/cgi-bin/message/wxopen/activityid/create?access_token=%s"
 	// SendUpdatableMsgURL 修改动态消息
 	setUpdatableMsgURL = "https://api.weixin.qq.com/cgi-bin/message/wxopen/updatablemsg/send?access_token=%s"
@@ -38,7 +38,7 @@ func NewUpdatableMessage(ctx *context.Context) *UpdatableMessage {
 	}
 }
 
-// CreateActivityID 创建activity_id
+// CreateActivityID 创建 activity_id
 func (updatableMessage *UpdatableMessage) CreateActivityID() (res CreateActivityIDResponse, err error) {
 	accessToken, err := updatableMessage.GetAccessToken()
 	if err != nil {
@@ -75,7 +75,7 @@ func (updatableMessage *UpdatableMessage) SetUpdatableMsg(activityID string, tar
 	return util.DecodeWithCommonError(response, "SendUpdatableMsg")
 }
 
-// CreateActivityIDResponse 创建activity_id 返回
+// CreateActivityIDResponse 创建 activity_id 返回
 type CreateActivityIDResponse struct {
 	util.CommonError
 

miniprogram/order/shipping.go

@@ -114,29 +114,29 @@ type UploadShippingInfoRequest struct {
 
 // ShippingOrderKey 订单
 type ShippingOrderKey struct {
-	OrderNumberType NumberType `json:"order_number_type"` // 订单单号类型，用于确认需要上传详情的订单。枚举值1，使用下单商户号和商户侧单号；枚举值2，使用微信支付单号。
+	OrderNumberType NumberType `json:"order_number_type"` // 订单单号类型，用于确认需要上传详情的订单。枚举值 1，使用下单商户号和商户侧单号；枚举值 2，使用微信支付单号。
 	TransactionID   string     `json:"transaction_id"`    // 原支付交易对应的微信订单号
 	Mchid           string     `json:"mchid"`             // 支付下单商户的商户号，由微信支付生成并下发
-	OutTradeNo      string     `json:"out_trade_no"`      // 商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一
+	OutTradeNo      string     `json:"out_trade_no"`      // 商户系统内部订单号，只能是数字、大小写字母 `_-*` 且在同一个商户号下唯一
 }
 
 // ShippingPayer 支付者信息
 type ShippingPayer struct {
-	Openid string `json:"openid"` // 用户标识，用户在小程序appid下的唯一标识
+	Openid string `json:"openid"` // 用户标识，用户在小程序 appid 下的唯一标识
 }
 
 // ShippingInfo 物流信息
 type ShippingInfo struct {
 	TrackingNo     string          `json:"tracking_no"`     // 物流单号，物流快递发货时必填
-	ExpressCompany string          `json:"express_company"` // 物流公司编码，快递公司ID，物流快递发货时必填；参见「查询物流公司编码列表」
-	ItemDesc       string          `json:"item_desc"`       // 商品信息，例如：微信红包抱枕*1个，限120个字以内
+	ExpressCompany string          `json:"express_company"` // 物流公司编码，快递公司 ID，物流快递发货时必填；参见「查询物流公司编码列表」
+	ItemDesc       string          `json:"item_desc"`       // 商品信息，例如：微信红包抱枕*1 个，限 120 个字以内
 	Contact        ShippingContact `json:"contact"`         // 联系方式，当发货的物流公司为顺丰时，联系方式为必填，收件人或寄件人联系方式二选一
 }
 
 // ShippingContact 联系方式
 type ShippingContact struct {
-	ConsignorContact string `json:"consignor_contact"` // 寄件人联系方式，寄件人联系方式，采用掩码传输，最后4位数字不能打掩码
-	ReceiverContact  string `json:"receiver_contact"`  // 收件人联系方式，收件人联系方式，采用掩码传输，最后4位数字不能打掩码
+	ConsignorContact string `json:"consignor_contact"` // 寄件人联系方式，寄件人联系方式，采用掩码传输，最后 4 位数字不能打掩码
+	ReceiverContact  string `json:"receiver_contact"`  // 收件人联系方式，收件人联系方式，采用掩码传输，最后 4 位数字不能打掩码
 }
 
 // DeliveryMode 发货模式
@@ -178,13 +178,13 @@ type GetShippingOrderRequest struct {
 	TransactionID   string `json:"transaction_id"`    // 原支付交易对应的微信订单号
 	MerchantID      string `json:"merchant_id"`       // 支付下单商户的商户号，由微信支付生成并下发
 	SubMerchantID   string `json:"sub_merchant_id"`   //二级商户号
-	MerchantTradeNo string `json:"merchant_trade_no"` //商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一。
+	MerchantTradeNo string `json:"merchant_trade_no"` //商户系统内部订单号，只能是数字、大小写字母 `_-*` 且在同一个商户号下唯一。
 }
 
 // ShippingItem 物流信息
 type ShippingItem struct {
-	TrackingNo     string `json:"tracking_no"`     // 物流单号，示例值: "323244567777
-	ExpressCompany string `json:"express_company"` // 物流公司编码，快递公司ID，物流快递发货时必填；参见「查询物流公司编码列表」
+	TrackingNo     string `json:"tracking_no"`     // 物流单号，示例值："323244567777
+	ExpressCompany string `json:"express_company"` // 物流公司编码，快递公司 ID，物流快递发货时必填；参见「查询物流公司编码列表」
 	UploadTime     int64  `json:"upload_time"`     // 上传物流信息时间，时间戳形式
 }
 
@@ -201,12 +201,12 @@ type ShippingDetail struct {
 // ShippingOrder 订单发货状态
 type ShippingOrder struct {
 	TransactionID   string          `json:"transaction_id"`    // 原支付交易对应的微信订单号
-	MerchantTradeNo string          `json:"merchant_trade_no"` // 商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一
+	MerchantTradeNo string          `json:"merchant_trade_no"` // 商户系统内部订单号，只能是数字、大小写字母 `_-*` 且在同一个商户号下唯一
 	MerchantID      string          `json:"merchant_id"`       // 支付下单商户的商户号，由微信支付生成并下发
 	SubMerchantID   string          `json:"sub_merchant_id"`   // 二级商户号
-	Description     string          `json:"description"`       // 以分号连接的该支付单的所有商品描述，当超过120字时自动截断并以 “...” 结尾
+	Description     string          `json:"description"`       // 以分号连接的该支付单的所有商品描述，当超过 120 字时自动截断并以“...”结尾
 	PaidAmount      int64           `json:"paid_amount"`       // 支付单实际支付金额，整型，单位：分钱
-	Openid          string          `json:"openid"`            // 支付者openid
+	Openid          string          `json:"openid"`            // 支付者 openid
 	TradeCreateTime int64           `json:"trade_create_time"` // 交易创建时间，时间戳形式
 	PayTime         int64           `json:"pay_time"`          // 支付时间，时间戳形式
 	InComplaint     bool            `json:"in_complaint"`      // 是否处在交易纠纷中
@@ -240,9 +240,9 @@ const (
 type GetShippingOrderListRequest struct {
 	PayTimeRange *TimeRange `json:"pay_time_range"`        // 支付时间范围
 	OrderState   State      `json:"order_state,omitempty"` // 订单状态
-	Openid       string     `json:"openid,omitempty"`      // 支付者openid
+	Openid       string     `json:"openid,omitempty"`      // 支付者 openid
 	LastIndex    string     `json:"last_index,omitempty"`  // 	翻页时使用，获取第一页时不用传入，如果查询结果中 has_more 字段为 true，则传入该次查询结果中返回的 last_index 字段可获取下一页
-	PageSize     int64      `json:"page_size"`             // 每页数量，最多50条
+	PageSize     int64      `json:"page_size"`             // 每页数量，最多 50 条
 }
 
 // TimeRange 时间范围
@@ -264,6 +264,6 @@ type NotifyConfirmReceiveRequest struct {
 	TransactionID   string `json:"transaction_id"`    // 原支付交易对应的微信订单号
 	MerchantID      string `json:"merchant_id"`       // 支付下单商户的商户号，由微信支付生成并下发
 	SubMerchantID   string `json:"sub_merchant_id"`   // 二级商户号
-	MerchantTradeNo string `json:"merchant_trade_no"` // 商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一
+	MerchantTradeNo string `json:"merchant_trade_no"` // 商户系统内部订单号，只能是数字、大小写字母 `_-*` 且在同一个商户号下唯一
 	ReceivedTime    int64  `json:"received_time"`     // 收货时间，时间戳形式
 }

miniprogram/privacy/privacy.go

@@ -53,9 +53,9 @@ const (
 	getPrivacySettingURL    = "https://api.weixin.qq.com/cgi-bin/component/getprivacysetting"
 	uploadPrivacyExtFileURL = "https://api.weixin.qq.com/cgi-bin/component/uploadprivacyextfile"
 
-	// PrivacyV1 用户隐私保护指引的版本，1表示现网版本。
+	// PrivacyV1 用户隐私保护指引的版本，1 表示现网版本。
 	PrivacyV1 = 1
-	// PrivacyV2 2表示开发版。默认是2开发版。
+	// PrivacyV2 2 表示开发版。默认是 2 开发版。
 	PrivacyV2 = 2
 )
 
@@ -77,12 +77,12 @@ type SettingResponseItem struct {
 	PrivacyLabel string `json:"privacy_label"`
 }
 
-// DescList 权限列表(保持与官方一致)
+// DescList 权限列表 (保持与官方一致)
 type DescList struct {
 	PrivacyDescList []Desc `json:"privacy_desc_list"`
 }
 
-// Desc 权限列表明细(保持与官方一致)
+// Desc 权限列表明细 (保持与官方一致)
 type Desc struct {
 	PrivacyDesc string `json:"privacy_desc"`
 	PrivacyKey  string `json:"privacy_key"`
@@ -110,7 +110,7 @@ func (s *Privacy) GetPrivacySetting(privacyVer int) (GetPrivacySettingResponse,
 // SetPrivacySetting 更新小程序权限配置
 func (s *Privacy) SetPrivacySetting(privacyVer int, ownerSetting OwnerSetting, settingList []SettingItem) error {
 	if privacyVer == PrivacyV1 && len(settingList) > 0 {
-		return errors.New("当privacy_ver传2或者不传时，setting_list是必填；当privacy_ver传1时，该参数不可传")
+		return errors.New("当 privacy_ver 传 2 或者不传时，setting_list 是必填；当 privacy_ver 传 1 时，该参数不可传")
 	}
 	accessToken, err := s.GetAccessToken()
 	if err != nil {

miniprogram/qrcode/qrcode.go

@@ -36,21 +36,21 @@ type Color struct {
 
 // QRCoder 小程序码参数
 type QRCoder struct {
-	// page 必须是已经发布的小程序存在的页面,根路径前不要填加 /,不能携带参数（参数请放在scene字段里），如果不填写这个字段，默认跳主页面
+	// page 必须是已经发布的小程序存在的页面，根路径前不要填加 /,不能携带参数（参数请放在 scene 字段里），如果不填写这个字段，默认跳主页面
 	Page string `json:"page,omitempty"`
 	// path 扫码进入的小程序页面路径
 	Path string `json:"path,omitempty"`
-	// checkPath 检查page 是否存在，为 true 时 page 必须是已经发布的小程序存在的页面（否则报错）；为 false 时允许小程序未发布或者 page 不存在， 但page 有数量上限（60000个）请勿滥用，默认true
+	// checkPath 检查 page 是否存在，为 true 时 page 必须是已经发布的小程序存在的页面（否则报错）；为 false 时允许小程序未发布或者 page 不存在，但 page 有数量上限（60000 个）请勿滥用，默认 true
 	CheckPath *bool `json:"check_path,omitempty"`
 	// width 图片宽度
 	Width int `json:"width,omitempty"`
-	// scene 最大32个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()*+,/:;=?@-._~，其它字符请自行编码为合法字符（因不支持%，中文无法使用 urlencode 处理，请使用其他编码方式）
+	// scene 最大 32 个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()*+,/:;=?@-._~，其它字符请自行编码为合法字符（因不支持%，中文无法使用 urlencode 处理，请使用其他编码方式）
 	Scene string `json:"scene,omitempty"`
-	// autoColor 自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调，默认false
+	// autoColor 自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调，默认 false
 	AutoColor bool `json:"auto_color,omitempty"`
 	// lineColor AutoColor 为 false 时生效，使用 rgb 设置颜色 例如 {"r":"xxx","g":"xxx","b":"xxx"},十进制表示
 	LineColor *Color `json:"line_color,omitempty"`
-	// isHyaline 是否需要透明底色，默认false
+	// isHyaline 是否需要透明底色，默认 false
 	IsHyaline bool `json:"is_hyaline,omitempty"`
 	// envVersion 要打开的小程序版本。正式版为 "release"，体验版为 "trial"，开发版为 "develop"
 	EnvVersion string `json:"env_version,omitempty"`
@@ -88,19 +88,19 @@ func (qrCode *QRCode) fetchCode(urlStr string, body interface{}) (response []byt
 }
 
 // CreateWXAQRCode 获取小程序二维码，适用于需要的码数量较少的业务场景
-// 文档地址： https://developers.weixin.qq.com/miniprogram/dev/api/createWXAQRCode.html
+// 文档地址：https://developers.weixin.qq.com/miniprogram/dev/api/createWXAQRCode.html
 func (qrCode *QRCode) CreateWXAQRCode(coderParams QRCoder) (response []byte, err error) {
 	return qrCode.fetchCode(createWXAQRCodeURL, coderParams)
 }
 
 // GetWXACode 获取小程序码，适用于需要的码数量较少的业务场景
-// 文档地址： https://developers.weixin.qq.com/miniprogram/dev/api/getWXACode.html
+// 文档地址：https://developers.weixin.qq.com/miniprogram/dev/api/getWXACode.html
 func (qrCode *QRCode) GetWXACode(coderParams QRCoder) (response []byte, err error) {
 	return qrCode.fetchCode(getWXACodeURL, coderParams)
 }
 
 // GetWXACodeUnlimit 获取小程序码，适用于需要的码数量极多的业务场景
-// 文档地址： https://developers.weixin.qq.com/miniprogram/dev/api/getWXACodeUnlimit.html
+// 文档地址：https://developers.weixin.qq.com/miniprogram/dev/api/getWXACodeUnlimit.html
 func (qrCode *QRCode) GetWXACodeUnlimit(coderParams QRCoder) (response []byte, err error) {
 	return qrCode.fetchCode(getWXACodeUnlimitURL, coderParams)
 }

miniprogram/redpacketcover/redpacketcover.go

@@ -25,9 +25,9 @@ func NewRedPacketCover(context *context.Context) *RedPacketCover {
 
 // GetRedPacketCoverRequest 获取微信红包封面参数
 type GetRedPacketCoverRequest struct {
-	// openid 可领取用户的openid
+	// openid 可领取用户的 openid
 	OpenID string `json:"openid"`
-	// ctoken 在红包封面平台获取发放ctoken（需要指定可以发放的appid）
+	// ctoken 在红包封面平台获取发放 ctoken（需要指定可以发放的 appid）
 	CToken string `json:"ctoken"`
 }
 
@@ -39,8 +39,8 @@ type GetRedPacketCoverResp struct {
 	} `json:"data"` // 唯一请求标识
 }
 
-// GetRedPacketCoverURL 获得指定用户可以领取的红包封面链接。获取参数ctoken参考微信红包封面开放平台
-// 文档地址： https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/red-packet-cover/getRedPacketCoverUrl.html
+// GetRedPacketCoverURL 获得指定用户可以领取的红包封面链接。获取参数 ctoken 参考微信红包封面开放平台
+// 文档地址：https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/red-packet-cover/getRedPacketCoverUrl.html
 func (cover *RedPacketCover) GetRedPacketCoverURL(coderParams GetRedPacketCoverRequest) (res GetRedPacketCoverResp, err error) {
 	accessToken, err := cover.GetAccessToken()
 	if err != nil {

miniprogram/riskcontrol/riskcontrol.go

@@ -26,7 +26,7 @@ type UserRiskRankRequest struct {
 	AppID    string `json:"appid"`     // 小程序 app id
 	OpenID   string `json:"openid"`    // 用户的 openid
 	Scene    uint8  `json:"scene"`     // 场景值，0:注册，1:营销作弊
-	ClientIP string `json:"client_ip"` // 用户访问源ip
+	ClientIP string `json:"client_ip"` // 用户访问源 ip
 
 	Mobile       string `json:"mobile_no"`     // 用户手机号
 	Email        string `json:"email_address"` // 用户邮箱地址

miniprogram/security/security.go

@@ -26,13 +26,13 @@ func NewSecurity(ctx *context.Context) *Security {
 
 // MediaCheckAsyncV1Request 图片/音频异步校验请求参数
 type MediaCheckAsyncV1Request struct {
-	MediaURL  string `json:"media_url"`  // 要检测的图片或音频的url，支持图片格式包括jpg, jepg, png, bmp, gif（取首帧），支持的音频格式包括mp3, aac, ac3, wma, flac, vorbis, opus, wav
+	MediaURL  string `json:"media_url"`  // 要检测的图片或音频的 url，支持图片格式包括 jpg, jepg, png, bmp, gif（取首帧），支持的音频格式包括 mp3, aac, ac3, wma, flac, vorbis, opus, wav
 	MediaType uint8  `json:"media_type"` // 1:音频;2:图片
 }
 
 // MediaCheckAsyncV1 异步校验图片/音频是否含有违法违规内容
 // Deprecated
-// 在2021年9月1日停止更新，请尽快更新至 2.0 接口。建议使用 MediaCheckAsync
+// 在 2021 年 9 月 1 日停止更新，请尽快更新至 2.0 接口。建议使用 MediaCheckAsync
 func (security *Security) MediaCheckAsyncV1(in *MediaCheckAsyncV1Request) (traceID string, err error) {
 	accessToken, err := security.GetAccessToken()
 	if err != nil {
@@ -56,9 +56,9 @@ func (security *Security) MediaCheckAsyncV1(in *MediaCheckAsyncV1Request) (trace
 
 // MediaCheckAsyncRequest 图片/音频异步校验请求参数
 type MediaCheckAsyncRequest struct {
-	MediaURL  string `json:"media_url"`  // 要检测的图片或音频的url，支持图片格式包括jpg, jepg, png, bmp, gif（取首帧），支持的音频格式包括mp3, aac, ac3, wma, flac, vorbis, opus, wav
+	MediaURL  string `json:"media_url"`  // 要检测的图片或音频的 url，支持图片格式包括 jpg, jepg, png, bmp, gif（取首帧），支持的音频格式包括 mp3, aac, ac3, wma, flac, vorbis, opus, wav
 	MediaType uint8  `json:"media_type"` // 1:音频;2:图片
-	OpenID    string `json:"openid"`     // 用户的openid（用户需在近两小时访问过小程序）
+	OpenID    string `json:"openid"`     // 用户的 openid（用户需在近两小时访问过小程序）
 	Scene     uint8  `json:"scene"`      // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
 }
 
@@ -71,7 +71,7 @@ func (security *Security) MediaCheckAsync(in *MediaCheckAsyncRequest) (traceID s
 
 	var req struct {
 		MediaCheckAsyncRequest
-		Version uint `json:"version"` // 接口版本号，2.0版本为固定值2
+		Version uint `json:"version"` // 接口版本号，2.0 版本为固定值 2
 	}
 	req.MediaCheckAsyncRequest = *in
 	req.Version = 2
@@ -94,7 +94,7 @@ func (security *Security) MediaCheckAsync(in *MediaCheckAsyncRequest) (traceID s
 // ImageCheckV1 校验一张图片是否含有违法违规内容（同步）
 // https://developers.weixin.qq.com/miniprogram/dev/framework/security.imgSecCheck.html
 // Deprecated
-// 在2021年9月1日停止更新。建议使用 MediaCheckAsync
+// 在 2021 年 9 月 1 日停止更新。建议使用 MediaCheckAsync
 func (security *Security) ImageCheckV1(filename string) (err error) {
 	accessToken, err := security.GetAccessToken()
 	if err != nil {
@@ -169,12 +169,12 @@ func (cl CheckLabel) String() string {
 
 // MsgCheckRequest 文本检查请求
 type MsgCheckRequest struct {
-	OpenID    string   `json:"openid"`    // 用户的openid（用户需在近两小时访问过小程序）
+	OpenID    string   `json:"openid"`    // 用户的 openid（用户需在近两小时访问过小程序）
 	Scene     MsgScene `json:"scene"`     // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
 	Content   string   `json:"content"`   // 需检测的文本内容，文本字数的上限为 2500 字，需使用 UTF-8 编码
-	Nickname  string   `json:"nickname"`  // （非必填）用户昵称，需使用UTF-8编码
-	Title     string   `json:"title"`     // （非必填）文本标题，需使用UTF-8编码
-	Signature string   `json:"signature"` // （非必填）个性签名，该参数仅在资料类场景有效(scene=1)，需使用UTF-8编码
+	Nickname  string   `json:"nickname"`  // （非必填）用户昵称，需使用 UTF-8 编码
+	Title     string   `json:"title"`     // （非必填）文本标题，需使用 UTF-8 编码
+	Signature string   `json:"signature"` // （非必填）个性签名，该参数仅在资料类场景有效 (scene=1)，需使用 UTF-8 编码
 }
 
 // MsgCheckResponse 文本检查响应
@@ -186,7 +186,7 @@ type MsgCheckResponse struct {
 		Label   CheckLabel   `json:"label"`   // 命中标签
 	} `json:"result"` // 综合结果
 	Detail []struct {
-		ErrCode  int64      `json:"errcode"`  // 错误码，仅当该值为0时，该项结果有效
+		ErrCode  int64      `json:"errcode"`  // 错误码，仅当该值为 0 时，该项结果有效
 		Strategy string     `json:"strategy"` // 策略类型
 		Suggest  string     `json:"suggest"`  // 建议
 		Label    CheckLabel `json:"label"`    // 命中标签
@@ -197,7 +197,7 @@ type MsgCheckResponse struct {
 
 // MsgCheckV1 检查一段文本是否含有违法违规内容
 // Deprecated
-// 在2021年9月1日停止更新，请尽快更新至 2.0 接口。建议使用 MsgCheck
+// 在 2021 年 9 月 1 日停止更新，请尽快更新至 2.0 接口。建议使用 MsgCheck
 func (security *Security) MsgCheckV1(content string) (res MsgCheckResponse, err error) {
 	accessToken, err := security.GetAccessToken()
 	if err != nil {

miniprogram/subscribe/subscribe.go

@@ -42,11 +42,11 @@ func NewSubscribe(ctx *context.Context) *Subscribe {
 // Message 订阅消息请求参数
 type Message struct {
 	ToUser           string               `json:"touser"`            // 必选，接收者（用户）的 openid
-	TemplateID       string               `json:"template_id"`       // 必选，所需下发的订阅模板id
-	Page             string               `json:"page"`              // 可选，点击模板卡片后的跳转页面，仅限本小程序内的页面。支持带参数,（示例index?foo=bar）。该字段不填则模板无跳转。
-	Data             map[string]*DataItem `json:"data"`              // 必选, 模板内容
-	MiniprogramState string               `json:"miniprogram_state"` // 可选，跳转小程序类型：developer为开发版；trial为体验版；formal为正式版；默认为正式版
-	Lang             string               `json:"lang"`              // 入小程序查看”的语言类型，支持zh_CN(简体中文)、en_US(英文)、zh_HK(繁体中文)、zh_TW(繁体中文)，默认为zh_CN
+	TemplateID       string               `json:"template_id"`       // 必选，所需下发的订阅模板 id
+	Page             string               `json:"page"`              // 可选，点击模板卡片后的跳转页面，仅限本小程序内的页面。支持带参数，（示例 index?foo=bar）。该字段不填则模板无跳转。
+	Data             map[string]*DataItem `json:"data"`              // 必选，模板内容
+	MiniprogramState string               `json:"miniprogram_state"` // 可选，跳转小程序类型：developer 为开发版；trial 为体验版；formal 为正式版；默认为正式版
+	Lang             string               `json:"lang"`              // 入小程序查看”的语言类型，支持 zh_CN(简体中文)、en_US(英文)、zh_HK(繁体中文)、zh_TW(繁体中文)，默认为 zh_CN
 }
 
 // DataItem 模版内某个 .DATA 的值

miniprogram/tcb/README.md

@@ -1,4 +1,4 @@
-# 小程序-云开发 SDK
+# 小程序 - 云开发 SDK
 
 Tencent Cloud Base [文档](https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/)
 

miniprogram/tcb/cloudfunction.go

@@ -14,7 +14,7 @@ const (
 // InvokeCloudFunctionRes 云函数调用返回结果
 type InvokeCloudFunctionRes struct {
 	util.CommonError
-	RespData string `json:"resp_data"` // 云函数返回的buffer
+	RespData string `json:"resp_data"` // 云函数返回的 buffer
 }
 
 // InvokeCloudFunction 云函数调用

miniprogram/tcb/database.go

@@ -49,13 +49,13 @@ type ConflictMode int
 // FileType 文件上传和导出的允许文件类型
 type FileType int
 
-// ValidDirections 合法的direction值
+// ValidDirections 合法的 direction 值
 var ValidDirections = []string{"1", "-1", "2dsphere"}
 
 // DatabaseMigrateExportReq 数据库出 请求参数
 type DatabaseMigrateExportReq struct {
-	Env      string   `json:"env,omitempty"`       // 云环境ID
-	FilePath string   `json:"file_path,omitempty"` // 导出文件路径(导入文件需先上传到同环境的存储中，可使用开发者工具或 HTTP API的上传文件 API上传）
+	Env      string   `json:"env,omitempty"`       // 云环境 ID
+	FilePath string   `json:"file_path,omitempty"` // 导出文件路径 (导入文件需先上传到同环境的存储中，可使用开发者工具或 HTTP API 的上传文件 API 上传）
 	FileType FileType `json:"file_type,omitempty"` // 导出文件类型，文件格式参考数据库导入指引中的文件格式部分  1:json 2:csv
 	Query    string   `json:"query,omitempty"`     // 导出条件
 }
@@ -63,12 +63,12 @@ type DatabaseMigrateExportReq struct {
 // DatabaseMigrateExportRes 数据库导出 返回结果
 type DatabaseMigrateExportRes struct {
 	util.CommonError
-	JobID int64 `json:"job_id"` // 导出任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
+	JobID int64 `json:"job_id"` // 导出任务 ID，可使用数据库迁移进度查询 API 查询导入进度及结果
 }
 
 // DatabaseMigrateImportReq 数据库导入 请求参数
 type DatabaseMigrateImportReq struct {
-	Env            string       `json:"env,omitempty"`             // 云环境ID
+	Env            string       `json:"env,omitempty"`             // 云环境 ID
 	CollectionName string       `json:"collection_name,omitempty"` // 集合名称
 	FilePath       string       `json:"file_path,omitempty"`       // 导出文件路径（文件会导出到同环境的云存储中，可使用获取下载链接 API 获取下载链接）
 	FileType       FileType     `json:"file_type,omitempty"`       // 导入文件类型，文件格式参考数据库导入指引中的文件格式部分  1:json 2:csv
@@ -79,7 +79,7 @@ type DatabaseMigrateImportReq struct {
 // DatabaseMigrateImportRes 数据库导入 返回结果
 type DatabaseMigrateImportRes struct {
 	util.CommonError
-	JobID int64 `json:"job_id"` // 导入任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
+	JobID int64 `json:"job_id"` // 导入任务 ID，可使用数据库迁移进度查询 API 查询导入进度及结果
 }
 
 // DatabaseMigrateQueryInfoRes 数据库迁移状态查询
@@ -94,7 +94,7 @@ type DatabaseMigrateQueryInfoRes struct {
 
 // UpdateIndexReq 变更数据库索引 请求参数
 type UpdateIndexReq struct {
-	Env            string        `json:"env,omitempty"`             // 云环境ID
+	Env            string        `json:"env,omitempty"`             // 云环境 ID
 	CollectionName string        `json:"collection_name,omitempty"` // 集合名称
 	CreateIndexes  []CreateIndex `json:"create_indexes,omitempty"`  // 新增索引
 	DropIndexes    []DropIndex   `json:"drop_indexes,omitempty"`    // 删除索引
@@ -120,13 +120,13 @@ type DropIndex struct {
 
 // DatabaseCollectionReq 新增/删除集合请求参数
 type DatabaseCollectionReq struct {
-	Env            string `json:"env,omitempty"`             // 云环境ID
+	Env            string `json:"env,omitempty"`             // 云环境 ID
 	CollectionName string `json:"collection_name,omitempty"` // 集合名称
 }
 
 // DatabaseCollectionGetReq 获取特定云环境下集合信息请求
 type DatabaseCollectionGetReq struct {
-	Env    string `json:"env,omitempty"`    // 云环境ID
+	Env    string `json:"env,omitempty"`    // 云环境 ID
 	Limit  int64  `json:"limit,omitempty"`  // 获取数量限制
 	Offset int64  `json:"offset,omitempty"` // 偏移量
 }
@@ -150,7 +150,7 @@ type DatabaseCollectionGetRes struct {
 
 // DatabaseReq 数据库插入/删除/更新/查询/统计记录请求参数
 type DatabaseReq struct {
-	Env   string `json:"env,omitempty"`   // 云环境ID
+	Env   string `json:"env,omitempty"`   // 云环境 ID
 	Query string `json:"query,omitempty"` // 数据库操作语句
 }
 
@@ -170,7 +170,7 @@ type DatabaseDeleteRes struct {
 type DatabaseUpdateRes struct {
 	util.CommonError
 	Matched  int64  `json:"matched"`  // 更新条件匹配到的结果数
-	Modified int64  `json:"modified"` // 修改的记录数，注意：使用set操作新插入的数据不计入修改数目
+	Modified int64  `json:"modified"` // 修改的记录数，注意：使用 set 操作新插入的数据不计入修改数目
 	ID       string `json:"id"`
 }
 

miniprogram/tcb/file.go

@@ -24,11 +24,11 @@ type UploadFileReq struct {
 // UploadFileRes 上传文件返回结果
 type UploadFileRes struct {
 	util.CommonError
-	URL           string `json:"url"`           // 上传url
+	URL           string `json:"url"`           // 上传 url
 	Token         string `json:"token"`         // token
 	Authorization string `json:"authorization"` // authorization
-	FileID        string `json:"file_id"`       // 文件ID
-	CosFileID     string `json:"cos_file_id"`   // cos文件ID
+	FileID        string `json:"file_id"`       // 文件 ID
+	CosFileID     string `json:"cos_file_id"`   // cos 文件 ID
 }
 
 // BatchDownloadFileReq 上传文件请求值
@@ -39,7 +39,7 @@ type BatchDownloadFileReq struct {
 
 // DownloadFile 文件信息
 type DownloadFile struct {
-	FileID string `json:"fileid"`  // 文件ID
+	FileID string `json:"fileid"`  // 文件 ID
 	MaxAge int64  `json:"max_age"` // 下载链接有效期
 }
 
@@ -47,7 +47,7 @@ type DownloadFile struct {
 type BatchDownloadFileRes struct {
 	util.CommonError
 	FileList []struct {
-		FileID      string `json:"file_id"`      // 文件ID
+		FileID      string `json:"file_id"`      // 文件 ID
 		DownloadURL string `json:"download_url"` // 下载链接
 		Status      int64  `json:"status"`       // 状态码
 		ErrMsg      string `json:"errmsg"`       // 该文件错误信息

miniprogram/urllink/urllink.go

@@ -51,7 +51,7 @@ type ULResult struct {
 	URLLink string `json:"url_link"`
 }
 
-// Generate 生成url link
+// Generate 生成 url link
 func (u *URLLink) Generate(params *ULParams) (string, error) {
 	accessToken, err := u.GetAccessToken()
 	if err != nil {

miniprogram/urlscheme/query.go

@@ -10,7 +10,7 @@ const (
 	querySchemeURL = "https://api.weixin.qq.com/wxa/queryscheme?access_token=%s"
 )
 
-// QueryScheme 获取小程序访问scheme
+// QueryScheme 获取小程序访问 scheme
 // https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.query.html#参数
 type QueryScheme struct {
 	// 小程序 scheme 码
@@ -23,7 +23,7 @@ type SchemeInfo struct {
 	AppID string `json:"appid"`
 	// 小程序页面路径。
 	Path string `json:"path"`
-	// 小程序页面query。
+	// 小程序页面 query。
 	Query string `json:"query"`
 	// 创建时间，为 Unix 时间戳。
 	CreateTime int64 `json:"create_time"`
@@ -40,7 +40,7 @@ type resQueryScheme struct {
 	util.CommonError
 	// scheme 配置
 	SchemeInfo SchemeInfo `json:"scheme_info"`
-	// 访问该链接的openid，没有用户访问过则为空字符串
+	// 访问该链接的 openid，没有用户访问过则为空字符串
 	VisitOpenid string `json:"visit_openid"`
 }
 

miniprogram/urlscheme/urlscheme.go

@@ -64,7 +64,7 @@ type USResult struct {
 	OpenLink string `json:"openlink"`
 }
 
-// Generate 生成url link
+// Generate 生成 url link
 func (u *URLScheme) Generate(params *USParams) (string, error) {
 	accessToken, err := u.GetAccessToken()
 	if err != nil {

miniprogram/virtualpayment/domain.go

@@ -136,7 +136,7 @@ type OrderItem struct {
 	PaidFee        int         `json:"paid_fee"`         // 用户支付金额，单位：分
 	OrderType      int         `json:"order_type"`       // 订单类型 0-支付单 1-退款单
 	RefundFee      int         `json:"refund_fee"`       // 当类型为退款单时表示退款金额，单位分
-	PaidTime       int64       `json:"paid_time"`        // 支付/退款时间，unix秒级时间戳
+	PaidTime       int64       `json:"paid_time"`        // 支付/退款时间，unix 秒级时间戳
 	ProvideTime    int64       `json:"provide_time"`     // 发货时间，unix 秒级时间戳
 	BizMeta        string      `json:"biz_meta"`         // 业务自定义数据 订单创建时传的信息
 	EnvType        int         `json:"env_type"`         // 环境类型 1-现网 2-沙箱

officialaccount/basic/basic.go

@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	// 获取微信服务器IP地址
+	// 获取微信服务器 IP 地址
 	// 文档：https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_the_WeChat_server_IP_address.html
 	getCallbackIPURL  = "https://api.weixin.qq.com/cgi-bin/getcallbackip"
 	getAPIDomainIPURL = "https://api.weixin.qq.com/cgi-bin/get_api_domain_ip"
@@ -29,13 +29,13 @@ func NewBasic(context *context.Context) *Basic {
 	return basic
 }
 
-// IPListRes 获取微信服务器IP地址 返回结果
+// IPListRes 获取微信服务器 IP 地址 返回结果
 type IPListRes struct {
 	util.CommonError
 	IPList []string `json:"ip_list"`
 }
 
-// GetCallbackIP 获取微信callback IP地址
+// GetCallbackIP 获取微信 callback IP 地址
 func (basic *Basic) GetCallbackIP() ([]string, error) {
 	ak, err := basic.GetAccessToken()
 	if err != nil {
@@ -51,7 +51,7 @@ func (basic *Basic) GetCallbackIP() ([]string, error) {
 	return ipListRes.IPList, err
 }
 
-// GetAPIDomainIP 获取微信API接口 IP地址
+// GetAPIDomainIP 获取微信 API 接口 IP 地址
 func (basic *Basic) GetAPIDomainIP() ([]string, error) {
 	ak, err := basic.GetAccessToken()
 	if err != nil {

officialaccount/basic/qr.go

@@ -34,7 +34,7 @@ type Request struct {
 	} `json:"action_info"`
 }
 
-// Ticket 二维码ticket
+// Ticket 二维码 ticket
 type Ticket struct {
 	util.CommonError `json:",inline"`
 	Ticket           string `json:"ticket"`
@@ -70,26 +70,34 @@ func (basic *Basic) GetQRTicket(tq *Request) (t *Ticket, err error) {
 	return
 }
 
-// ShowQRCode 通过ticket换取二维码
+// ShowQRCode 通过 ticket 换取二维码
 func ShowQRCode(tk *Ticket) string {
 	return fmt.Sprintf(getQRImgURL, tk.Ticket)
 }
 
 // NewTmpQrRequest 新建临时二维码请求实例
 func NewTmpQrRequest(exp time.Duration, scene interface{}) *Request {
-	tq := &Request{
-		ExpireSeconds: int64(exp.Seconds()),
-	}
+	var (
+		tq = &Request{
+			ExpireSeconds: int64(exp.Seconds()),
+		}
+		ok bool
+	)
 	switch reflect.ValueOf(scene).Kind() {
 	case reflect.String:
 		tq.ActionName = actionStr
-		tq.ActionInfo.Scene.SceneStr = scene.(string)
+		if tq.ActionInfo.Scene.SceneStr, ok = scene.(string); !ok {
+			panic("scene must be string")
+		}
 	case reflect.Int, reflect.Int8, reflect.Int16,
 		reflect.Int32, reflect.Int64,
 		reflect.Uint, reflect.Uint8, reflect.Uint16,
 		reflect.Uint32, reflect.Uint64:
 		tq.ActionName = actionID
-		tq.ActionInfo.Scene.SceneID = scene.(int)
+		if tq.ActionInfo.Scene.SceneID, ok = scene.(int); !ok {
+			panic("scene must be int")
+		}
+	default:
 	}
 
 	return tq
@@ -97,17 +105,25 @@ func NewTmpQrRequest(exp time.Duration, scene interface{}) *Request {
 
 // NewLimitQrRequest 新建永久二维码请求实例
 func NewLimitQrRequest(scene interface{}) *Request {
-	tq := &Request{}
+	var (
+		tq = &Request{}
+		ok bool
+	)
 	switch reflect.ValueOf(scene).Kind() {
 	case reflect.String:
 		tq.ActionName = actionLimitStr
-		tq.ActionInfo.Scene.SceneStr = scene.(string)
+		if tq.ActionInfo.Scene.SceneStr, ok = scene.(string); !ok {
+			panic("scene must be string")
+		}
 	case reflect.Int, reflect.Int8, reflect.Int16,
 		reflect.Int32, reflect.Int64,
 		reflect.Uint, reflect.Uint8, reflect.Uint16,
 		reflect.Uint32, reflect.Uint64:
 		tq.ActionName = actionLimitID
-		tq.ActionInfo.Scene.SceneID = scene.(int)
+		if tq.ActionInfo.Scene.SceneID, ok = scene.(int); !ok {
+			panic("scene must be int")
+		}
+	default:
 	}
 
 	return tq

officialaccount/broadcast/broadcast.go

@@ -69,9 +69,9 @@ type SpeedResult struct {
 
 // sendRequest 发送请求的数据
 type sendRequest struct {
-	// 根据tag获全部发送
+	// 根据 tag 获全部发送
 	Filter map[string]interface{} `json:"filter,omitempty"`
-	// 根据OpenID发送
+	// 根据 OpenID 发送
 	ToUser interface{} `json:"touser,omitempty"`
 	// 发送文本
 	Text map[string]interface{} `json:"text,omitempty"`
@@ -81,7 +81,7 @@ type sendRequest struct {
 	Voice map[string]interface{} `json:"voice,omitempty"`
 	// 发送视频
 	Mpvideo map[string]interface{} `json:"mpvideo,omitempty"`
-	// 发送图片-预览使用
+	// 发送图片 - 预览使用
 	Image map[string]interface{} `json:"image,omitempty"`
 	// 发送图片
 	Images *Image `json:"images,omitempty"`
@@ -100,9 +100,9 @@ type Image struct {
 }
 
 // SendText 群发文本
-// user 为nil，表示全员发送
-// &User{TagID:2} 根据tag发送
-// &User{OpenID:[]string("xxx","xxx")} 根据openid发送
+// user 为 nil，表示全员发送
+// &User{TagID:2} 根据 tag 发送
+// &User{OpenID:[]string("xxx","xxx")} 根据 openid 发送
 func (broadcast *Broadcast) SendText(user *User, content string) (*Result, error) {
 	ak, err := broadcast.GetAccessToken()
 	if err != nil {

officialaccount/customerservice/manager.go

@@ -46,10 +46,10 @@ type KeFuInfo struct {
 	KfNick        string `json:"kf_nick"`            // 客服昵称
 	KfID          int    `json:"kf_id"`              // 客服编号
 	KfHeadImgURL  string `json:"kf_headimgurl"`      // 客服头像
-	KfWX          string `json:"kf_wx"`              // 如果客服帐号已绑定了客服人员微信号， 则此处显示微信号
-	InviteWX      string `json:"invite_wx"`          // 如果客服帐号尚未绑定微信号，但是已经发起了一个绑定邀请， 则此处显示绑定邀请的微信号
-	InviteExpTime int    `json:"invite_expire_time"` // 如果客服帐号尚未绑定微信号，但是已经发起过一个绑定邀请， 邀请的过期时间，为unix 时间戳
-	InviteStatus  string `json:"invite_status"`      // 邀请的状态，有等待确认“waiting”，被拒绝“rejected”， 过期“expired”
+	KfWX          string `json:"kf_wx"`              // 如果客服帐号已绑定了客服人员微信号，则此处显示微信号
+	InviteWX      string `json:"invite_wx"`          // 如果客服帐号尚未绑定微信号，但是已经发起了一个绑定邀请，则此处显示绑定邀请的微信号
+	InviteExpTime int    `json:"invite_expire_time"` // 如果客服帐号尚未绑定微信号，但是已经发起过一个绑定邀请，邀请的过期时间，为 unix 时间戳
+	InviteStatus  string `json:"invite_status"`      // 邀请的状态，有等待确认“waiting”，被拒绝“rejected”，过期“expired”
 }
 
 type resKeFuList struct {
@@ -108,8 +108,8 @@ func (csm *Manager) OnlineList() (customerServiceOnlineList []*KeFuOnlineInfo, e
 
 // Add 添加客服账号
 func (csm *Manager) Add(kfAccount, nickName string) (err error) {
-	// kfAccount：完整客服帐号，格式为：帐号前缀@公众号微信号，帐号前缀最多10个字符，必须是英文、数字字符或者下划线，后缀为公众号微信号，长度不超过30个字符
-	// nickName：客服昵称，最长16个字
+	// kfAccount：完整客服帐号，格式为：帐号前缀@公众号微信号，帐号前缀最多 10 个字符，必须是英文、数字字符或者下划线，后缀为公众号微信号，长度不超过 30 个字符
+	// nickName：客服昵称，最长 16 个字
 	// 参数此处均不做校验
 	var accessToken string
 	accessToken, err = csm.GetAccessToken()

officialaccount/datacube/publisher.go

@@ -22,7 +22,7 @@ const (
 	SlotIDBizSponsor AdSlot = "SLOT_ID_BIZ_SPONSOR"
 	// SlotIDBizCps 公众号返佣商品
 	SlotIDBizCps AdSlot = "SLOT_ID_BIZ_CPS"
-	// SlotIDWeappBanner 小程序banner
+	// SlotIDWeappBanner 小程序 banner
 	SlotIDWeappBanner AdSlot = "SLOT_ID_WEAPP_BANNER"
 	// SlotIDWeappRewardVideo 小程序激励视频
 	SlotIDWeappRewardVideo AdSlot = "SLOT_ID_WEAPP_REWARD_VIDEO"

officialaccount/device/authorize.go

@@ -16,11 +16,11 @@ const (
 )
 
 type reqDeviceAuthorize struct {
-	// 设备id的个数
+	// 设备 id 的个数
 	DeviceNum string `json:"device_num"`
-	// 设备id的列表，json的array格式，其size必须等于device_num
+	// 设备 id 的列表，json 的 array 格式，其 size 必须等于 device_num
 	DeviceList []ReqDevice `json:"device_list"`
-	// 请求操作的类型，限定取值为：0：设备授权（缺省值为0） 1：设备更新（更新已授权设备的各属性值）
+	// 请求操作的类型，限定取值为：0：设备授权（缺省值为 0）1：设备更新（更新已授权设备的各属性值）
 	OpType string `json:"op_type,omitempty"`
 	// 设备的产品编号（由微信硬件平台分配）。可在公众号设备功能管理页面查询。
 	// 当 op_type 为‘0’，product_id 为‘1’时，不要填写 product_id 字段（会引起不必要错误）；
@@ -33,39 +33,39 @@ type reqDeviceAuthorize struct {
 type ReqDevice struct {
 	// 设备的 device id
 	ID string `json:"id"`
-	// 设备的mac地址 格式采用16进制串的方式（长度为12字节），
-	// 不需要0X前缀，如： 1234567890AB
+	// 设备的 mac 地址 格式采用 16 进制串的方式（长度为 12 字节），
+	// 不需要 0X 前缀，如：1234567890AB
 	Mac string `json:"mac"`
 	//  支持以下四种连接协议：
 	//	android classic bluetooth – 1
 	//	ios classic bluetooth – 2
 	//	ble – 3
 	//	wifi -- 4
-	//	一个设备可以支持多种连接类型，用符号"|"做分割，客户端优先选择靠前的连接方式（优先级按|关系的排序依次降低），举例：
-	//	1：表示设备仅支持andiod classic bluetooth 1|2：表示设备支持android 和ios 两种classic bluetooth，但是客户端优先选择android classic bluetooth 协议，如果android classic bluetooth协议连接失败，再选择ios classic bluetooth协议进行连接
-	//	（注：安卓平台不同时支持BLE和classic类型）
+	//	一个设备可以支持多种连接类型，用符号"|"做分割，客户端优先选择靠前的连接方式（优先级按 | 关系的排序依次降低），举例：
+	//	1：表示设备仅支持 andiod classic bluetooth 1|2：表示设备支持 android 和 ios 两种 classic bluetooth，但是客户端优先选择 android classic bluetooth 协议，如果 android classic bluetooth 协议连接失败，再选择 ios classic bluetooth 协议进行连接
+	//	（注：安卓平台不同时支持 BLE 和 classic 类型）
 	ConnectProtocol string `json:"connect_protocol"`
-	// auth及通信的加密key，第三方需要将key烧制在设备上（128bit），格式采用16进制串的方式（长度为32字节），不需要0X前缀，如： 1234567890ABCDEF1234567890ABCDEF
+	// auth 及通信的加密 key，第三方需要将 key 烧制在设备上（128bit），格式采用 16 进制串的方式（长度为 32 字节），不需要 0X 前缀，如：1234567890ABCDEF1234567890ABCDEF
 	AuthKey string `json:"auth_key"`
-	// 断开策略，目前支持： 1：退出公众号页面时即断开连接 2：退出公众号之后保持连接不断开
+	// 断开策略，目前支持：1：退出公众号页面时即断开连接 2：退出公众号之后保持连接不断开
 	CloseStrategy string `json:"close_strategy"`
-	// 连接策略，32位整型，按bit位置位，目前仅第1bit和第3bit位有效（bit置0为无效，1为有效；第2bit已被废弃），且bit位可以按或置位（如1|4=5），各bit置位含义说明如下：
-	// 1：（第1bit置位）在公众号对话页面，不停的尝试连接设备
-	// 4：（第3bit置位）处于非公众号页面（如主界面等），微信自动连接。当用户切换微信到前台时，可能尝试去连接设备，连上后一定时间会断开
+	// 连接策略，32 位整型，按 bit 位置位，目前仅第 1bit 和第 3bit 位有效（bit 置 0 为无效，1 为有效；第 2bit 已被废弃），且 bit 位可以按或置位（如 1|4=5），各 bit 置位含义说明如下：
+	// 1：（第 1bit 置位）在公众号对话页面，不停的尝试连接设备
+	// 4：（第 3bit 置位）处于非公众号页面（如主界面等），微信自动连接。当用户切换微信到前台时，可能尝试去连接设备，连上后一定时间会断开
 	ConnStrategy string `json:"conn_strategy"`
-	// auth version，设备和微信进行auth时，会根据该版本号来确认auth buf和auth key的格式（各version对应的auth buf及key的具体格式可以参看“客户端蓝牙外设协议”），该字段目前支持取值：
-	// 0：不加密的version
+	// auth version，设备和微信进行 auth 时，会根据该版本号来确认 auth buf 和 auth key 的格式（各 version 对应的 auth buf 及 key 的具体格式可以参看“客户端蓝牙外设协议”），该字段目前支持取值：
+	// 0：不加密的 version
 	// 1：version 1
 	AuthVer string `json:"auth_ver"`
-	// 表示mac地址在厂商广播manufacture data里含有mac地址的偏移，取值如下：
+	// 表示 mac 地址在厂商广播 manufacture data 里含有 mac 地址的偏移，取值如下：
 	// -1：在尾部、
-	// -2：表示不包含mac地址 其他：非法偏移
+	// -2：表示不包含 mac 地址 其他：非法偏移
 	ManuMacPos string `json:"manu_mac_pos"`
-	// 表示mac地址在厂商serial number里含有mac地址的偏移，取值如下：
+	// 表示 mac 地址在厂商 serial number 里含有 mac 地址的偏移，取值如下：
 	// -1：表示在尾部
-	// -2：表示不包含mac地址 其他：非法偏移
+	// -2：表示不包含 mac 地址 其他：非法偏移
 	SerMacPost string `json:"ser_mac_post"`
-	// 精简协议类型，取值如下：计步设备精简协议：1 （若该字段填1，connect_protocol 必须包括3。非精简协议设备切勿填写该字段）
+	// 精简协议类型，取值如下：计步设备精简协议：1（若该字段填 1，connect_protocol 必须包括 3。非精简协议设备切勿填写该字段）
 	BleSimpleProtocol string `json:"ble_simple_protocol,omitempty"`
 }
 

officialaccount/draft/draft.go

@@ -33,12 +33,12 @@ type Article struct {
 	Title              string `json:"title"`                 // 标题
 	Author             string `json:"author"`                // 作者
 	Digest             string `json:"digest"`                // 图文消息的摘要，仅有单图文消息才有摘要，多图文此处为空。
-	Content            string `json:"content"`               // 图文消息的具体内容，支持HTML标签，必须少于2万字符，小于1M，且去除JS
-	ContentSourceURL   string `json:"content_source_url"`    // 图文消息的原文地址，即点击“阅读原文”后的URL
-	ThumbMediaID       string `json:"thumb_media_id"`        // 图文消息的封面图片素材id（必须是永久MediaID）
-	ShowCoverPic       uint   `json:"show_cover_pic"`        // 是否显示封面，0为false，即不显示，1为true，即显示(默认)
-	NeedOpenComment    uint   `json:"need_open_comment"`     // 是否打开评论，0不打开(默认)，1打开
-	OnlyFansCanComment uint   `json:"only_fans_can_comment"` // 是否粉丝才可评论，0所有人可评论(默认)，1粉丝才可评论
+	Content            string `json:"content"`               // 图文消息的具体内容，支持 HTML 标签，必须少于 2 万字符，小于 1M，且去除 JS
+	ContentSourceURL   string `json:"content_source_url"`    // 图文消息的原文地址，即点击“阅读原文”后的 URL
+	ThumbMediaID       string `json:"thumb_media_id"`        // 图文消息的封面图片素材 id（必须是永久 MediaID）
+	ShowCoverPic       uint   `json:"show_cover_pic"`        // 是否显示封面，0 为 false，即不显示，1 为 true，即显示 (默认)
+	NeedOpenComment    uint   `json:"need_open_comment"`     // 是否打开评论，0 不打开 (默认)，1 打开
+	OnlyFansCanComment uint   `json:"only_fans_can_comment"` // 是否粉丝才可评论，0 所有人可评论 (默认)，1 粉丝才可评论
 }
 
 // AddDraft 新建草稿
@@ -117,7 +117,7 @@ func (draft *Draft) DeleteDraft(mediaID string) (err error) {
 }
 
 // UpdateDraft 修改草稿
-// index 要更新的文章在图文消息中的位置（多图文消息时，此字段才有意义），第一篇为0
+// index 要更新的文章在图文消息中的位置（多图文消息时，此字段才有意义），第一篇为 0
 func (draft *Draft) UpdateDraft(article *Article, mediaID string, index uint) (err error) {
 	accessToken, err := draft.GetAccessToken()
 	if err != nil {
@@ -176,7 +176,7 @@ type ArticleList struct {
 
 // ArticleListItem 用于 ArticleList 的 item 节点
 type ArticleListItem struct {
-	MediaID    string             `json:"media_id"`    // 图文消息的id
+	MediaID    string             `json:"media_id"`    // 图文消息的 id
 	Content    ArticleListContent `json:"content"`     // 内容
 	UpdateTime int64              `json:"update_time"` // 这篇图文消息素材的最后更新时间
 }

officialaccount/freepublish/freepublish.go

@@ -79,23 +79,23 @@ func (freePublish *FreePublish) Publish(mediaID string) (publishID int64, err er
 // PublishStatusList 发布任务状态列表
 type PublishStatusList struct {
 	util.CommonError
-	PublishID     int64                `json:"publish_id"`     // 发布任务id
+	PublishID     int64                `json:"publish_id"`     // 发布任务 id
 	PublishStatus PublishStatus        `json:"publish_status"` // 发布状态
-	ArticleID     string               `json:"article_id"`     // 当发布状态为0时（即成功）时，返回图文的 article_id，可用于“客服消息”场景
+	ArticleID     string               `json:"article_id"`     // 当发布状态为 0 时（即成功）时，返回图文的 article_id，可用于“客服消息”场景
 	ArticleDetail PublishArticleDetail `json:"article_detail"` // 发布任务文章成功状态详情
-	FailIndex     []uint               `json:"fail_idx"`       // 当发布状态为2或4时，返回不通过的文章编号，第一篇为 1；其他发布状态则为空
+	FailIndex     []uint               `json:"fail_idx"`       // 当发布状态为 2 或 4 时，返回不通过的文章编号，第一篇为 1；其他发布状态则为空
 }
 
 // PublishArticleDetail 发布任务成功详情
 type PublishArticleDetail struct {
-	Count uint                 `json:"count"` // 当发布状态为0时（即成功）时，返回文章数量
+	Count uint                 `json:"count"` // 当发布状态为 0 时（即成功）时，返回文章数量
 	Items []PublishArticleItem `json:"item"`
 }
 
 // PublishArticleItem 发布任务成功的文章内容
 type PublishArticleItem struct {
-	Index      uint   `json:"idx"`         // 当发布状态为0时（即成功）时，返回文章对应的编号
-	ArticleURL string `json:"article_url"` // 当发布状态为0时（即成功）时，返回图文的永久链接
+	Index      uint   `json:"idx"`         // 当发布状态为 0 时（即成功）时，返回文章对应的编号
+	ArticleURL string `json:"article_url"` // 当发布状态为 0 时（即成功）时，返回图文的永久链接
 }
 
 // SelectStatus 发布状态轮询接口
@@ -122,8 +122,8 @@ func (freePublish *FreePublish) SelectStatus(publishID int64) (list PublishStatu
 }
 
 // Delete 删除发布。
-// index 要删除的文章在图文消息中的位置，第一篇编号为1，该字段不填或填0会删除全部文章
-// !!!此操作不可逆，请谨慎操作!!!删除后微信公众号后台仍然会有记录!!!
+// index 要删除的文章在图文消息中的位置，第一篇编号为 1，该字段不填或填 0 会删除全部文章
+// !!! 此操作不可逆，请谨慎操作!!! 删除后微信公众号后台仍然会有记录!!!
 func (freePublish *FreePublish) Delete(articleID string, index uint) (err error) {
 	accessToken, err := freePublish.GetAccessToken()
 	if err != nil {
@@ -152,13 +152,13 @@ type Article struct {
 	Title              string `json:"title"`                 // 标题
 	Author             string `json:"author"`                // 作者
 	Digest             string `json:"digest"`                // 图文消息的摘要，仅有单图文消息才有摘要，多图文此处为空
-	Content            string `json:"content"`               // 图文消息的具体内容，支持HTML标签，必须少于2万字符，小于1M，且此处会去除JS
-	ContentSourceURL   string `json:"content_source_url"`    // 图文消息的原文地址，即点击“阅读原文”后的URL
-	ThumbMediaID       string `json:"thumb_media_id"`        // 图文消息的封面图片素材id（一定是永久MediaID）
-	ShowCoverPic       uint   `json:"show_cover_pic"`        // 是否显示封面，0为false，即不显示，1为true，即显示(默认)
-	NeedOpenComment    uint   `json:"need_open_comment"`     // 是否打开评论，0不打开(默认)，1打开
-	OnlyFansCanComment uint   `json:"only_fans_can_comment"` // 是否粉丝才可评论，0所有人可评论(默认)，1粉丝才可评论
-	URL                string `json:"url"`                   // 图文消息的URL
+	Content            string `json:"content"`               // 图文消息的具体内容，支持 HTML 标签，必须少于 2 万字符，小于 1M，且此处会去除 JS
+	ContentSourceURL   string `json:"content_source_url"`    // 图文消息的原文地址，即点击“阅读原文”后的 URL
+	ThumbMediaID       string `json:"thumb_media_id"`        // 图文消息的封面图片素材 id（一定是永久 MediaID）
+	ShowCoverPic       uint   `json:"show_cover_pic"`        // 是否显示封面，0 为 false，即不显示，1 为 true，即显示 (默认)
+	NeedOpenComment    uint   `json:"need_open_comment"`     // 是否打开评论，0 不打开 (默认)，1 打开
+	OnlyFansCanComment uint   `json:"only_fans_can_comment"` // 是否粉丝才可评论，0 所有人可评论 (默认)，1 粉丝才可评论
+	URL                string `json:"url"`                   // 图文消息的 URL
 	IsDeleted          bool   `json:"is_deleted"`            // 该图文是否被删除
 }
 
@@ -199,7 +199,7 @@ type ArticleList struct {
 
 // ArticleListItem 用于 ArticleList 的 item 节点
 type ArticleListItem struct {
-	ArticleID  string             `json:"article_id"`  // 成功发布的图文消息id
+	ArticleID  string             `json:"article_id"`  // 成功发布的图文消息 id
 	Content    ArticleListContent `json:"content"`     // 内容
 	UpdateTime int64              `json:"update_time"` // 这篇图文消息素材的最后更新时间
 }

officialaccount/js/js.go

@@ -14,7 +14,7 @@ type Js struct {
 	credential.JsTicketHandle
 }
 
-// Config 返回给用户jssdk配置信息
+// Config 返回给用户 jssdk 配置信息
 type Config struct {
 	AppID     string `json:"app_id"`
 	Timestamp int64  `json:"timestamp"`
@@ -31,12 +31,12 @@ func NewJs(context *context.Context) *Js {
 	return js
 }
 
-// SetJsTicketHandle 自定义js ticket取值方式
+// SetJsTicketHandle 自定义 js ticket 取值方式
 func (js *Js) SetJsTicketHandle(ticketHandle credential.JsTicketHandle) {
 	js.JsTicketHandle = ticketHandle
 }
 
-// GetConfig 获取jssdk需要的配置参数
+// GetConfig 获取 jssdk 需要的配置参数
 // uri 为当前网页地址
 func (js *Js) GetConfig(uri string) (config *Config, err error) {
 	config = new(Config)

officialaccount/material/media.go

@@ -11,13 +11,13 @@ import (
 type MediaType string
 
 const (
-	// MediaTypeImage 媒体文件:图片
+	// MediaTypeImage 媒体文件：图片
 	MediaTypeImage MediaType = "image"
-	// MediaTypeVoice 媒体文件:声音
+	// MediaTypeVoice 媒体文件：声音
 	MediaTypeVoice MediaType = "voice"
-	// MediaTypeVideo 媒体文件:视频
+	// MediaTypeVideo 媒体文件：视频
 	MediaTypeVideo MediaType = "video"
-	// MediaTypeThumb 媒体文件:缩略图
+	// MediaTypeThumb 媒体文件：缩略图
 	MediaTypeThumb MediaType = "thumb"
 )
 
@@ -63,7 +63,7 @@ func (material *Material) MediaUpload(mediaType MediaType, filename string) (med
 }
 
 // GetMediaURL 返回临时素材的下载地址供用户自己处理
-// NOTICE: URL 不可公开，因为含access_token 需要立即另存文件
+// NOTICE: URL 不可公开，因为含 access_token 需要立即另存文件
 func (material *Material) GetMediaURL(mediaID string) (mediaURL string, err error) {
 	var accessToken string
 	accessToken, err = material.GetAccessToken()

officialaccount/menu/button.go

@@ -23,7 +23,7 @@ func (btn *Button) SetSubButton(name string, subButtons []*Button) *Button {
 	return btn
 }
 
-// SetClickButton btn 为click类型
+// SetClickButton btn 为 click 类型
 func (btn *Button) SetClickButton(name, key string) *Button {
 	btn.Type = "click"
 	btn.Name = name
@@ -34,7 +34,7 @@ func (btn *Button) SetClickButton(name, key string) *Button {
 	return btn
 }
 
-// SetViewButton view类型
+// SetViewButton view 类型
 func (btn *Button) SetViewButton(name, url string) *Button {
 	btn.Type = "view"
 	btn.Name = name
@@ -116,7 +116,7 @@ func (btn *Button) SetLocationSelectButton(name, key string) *Button {
 	return btn
 }
 
-// SetMediaIDButton  设置 下发消息(除文本消息) 类型按钮
+// SetMediaIDButton  设置 下发消息 (除文本消息) 类型按钮
 func (btn *Button) SetMediaIDButton(name, mediaID string) *Button {
 	btn.Type = "media_id"
 	btn.Name = name
@@ -128,7 +128,7 @@ func (btn *Button) SetMediaIDButton(name, mediaID string) *Button {
 	return btn
 }
 
-// SetViewLimitedButton  设置 跳转图文消息URL 类型按钮
+// SetViewLimitedButton  设置 跳转图文消息 URL 类型按钮
 func (btn *Button) SetViewLimitedButton(name, mediaID string) *Button {
 	btn.Type = "view_limited"
 	btn.Name = name
@@ -159,12 +159,12 @@ func NewSubButton(name string, subButtons []*Button) *Button {
 	return (&Button{}).SetSubButton(name, subButtons)
 }
 
-// NewClickButton btn 为click类型
+// NewClickButton btn 为 click 类型
 func NewClickButton(name, key string) *Button {
 	return (&Button{}).SetClickButton(name, key)
 }
 
-// NewViewButton view类型
+// NewViewButton view 类型
 func NewViewButton(name, url string) *Button {
 	return (&Button{}).SetViewButton(name, url)
 }
@@ -199,12 +199,12 @@ func NewLocationSelectButton(name, key string) *Button {
 	return (&Button{}).SetLocationSelectButton(name, key)
 }
 
-// NewMediaIDButton  下发消息(除文本消息) 类型按钮
+// NewMediaIDButton  下发消息 (除文本消息) 类型按钮
 func NewMediaIDButton(name, mediaID string) *Button {
 	return (&Button{}).SetMediaIDButton(name, mediaID)
 }
 
-// NewViewLimitedButton  跳转图文消息URL 类型按钮
+// NewViewLimitedButton  跳转图文消息 URL 类型按钮
 func NewViewLimitedButton(name, mediaID string) *Button {
 	return (&Button{}).SetViewLimitedButton(name, mediaID)
 }

officialaccount/message/customer_message.go

@@ -26,7 +26,7 @@ func NewMessageManager(context *context.Context) *Manager {
 
 // CustomerMessage  客服消息
 type CustomerMessage struct {
-	ToUser          string                `json:"touser"`                    // 接受者OpenID
+	ToUser          string                `json:"touser"`                    // 接受者 OpenID
 	Msgtype         MsgType               `json:"msgtype"`                   // 客服消息类型
 	Text            *MediaText            `json:"text,omitempty"`            // 可选
 	Image           *MediaResource        `json:"image,omitempty"`           // 可选
@@ -93,12 +93,12 @@ type MediaText struct {
 	Content string `json:"content"`
 }
 
-// MediaResource  消息使用的永久素材id
+// MediaResource  消息使用的永久素材 id
 type MediaResource struct {
 	MediaID string `json:"media_id"`
 }
 
-// MediaArticle  消息使用的已发布文章id
+// MediaArticle  消息使用的已发布文章 id
 type MediaArticle struct {
 	ArticleID string `json:"article_id"`
 }
@@ -146,7 +146,7 @@ type MsgmenuItem struct {
 	Content string `json:"content"`
 }
 
-// MediaWxcard 卡券的id
+// MediaWxcard 卡券的 id
 type MediaWxcard struct {
 	CardID string `json:"card_id"`
 }

officialaccount/message/subscribe.go

@@ -31,14 +31,14 @@ func NewSubscribe(context *context.Context) *Subscribe {
 
 // SubscribeMessage 发送的订阅消息内容
 type SubscribeMessage struct {
-	ToUser      string                        `json:"touser"`         // 必须, 接受者OpenID
-	TemplateID  string                        `json:"template_id"`    // 必须, 模版ID
-	Page        string                        `json:"page,omitempty"` // 可选, 跳转网页时填写
-	Data        map[string]*SubscribeDataItem `json:"data"`           // 必须, 模板数据
+	ToUser      string                        `json:"touser"`         // 必须，接受者 OpenID
+	TemplateID  string                        `json:"template_id"`    // 必须，模版 ID
+	Page        string                        `json:"page,omitempty"` // 可选，跳转网页时填写
+	Data        map[string]*SubscribeDataItem `json:"data"`           // 必须，模板数据
 	MiniProgram struct {
-		AppID    string `json:"appid"`    // 所需跳转到的小程序appid（该小程序appid必须与发模板消息的公众号是绑定关联关系）
-		PagePath string `json:"pagepath"` // 所需跳转到小程序的具体页面路径，支持带参数,（示例index?foo=bar）
-	} `json:"miniprogram"` // 可选,跳转至小程序地址
+		AppID    string `json:"appid"`    // 所需跳转到的小程序 appid（该小程序 appid 必须与发模板消息的公众号是绑定关联关系）
+		PagePath string `json:"pagepath"` // 所需跳转到小程序的具体页面路径，支持带参数，（示例 index?foo=bar）
+	} `json:"miniprogram"` // 可选，跳转至小程序地址
 }
 
 // SubscribeDataItem 模版内某个 .DATA 的值
@@ -143,7 +143,7 @@ func (tpl *Subscribe) Delete(templateID string) (err error) {
 
 // PublicTemplateCategory 公众号类目
 type PublicTemplateCategory struct {
-	ID   int    `json:"id"`   // 类目ID
+	ID   int    `json:"id"`   // 类目 ID
 	Name string `json:"name"` // 类目的中文名
 }
 

officialaccount/message/template.go

@@ -29,17 +29,17 @@ func NewTemplate(context *context.Context) *Template {
 
 // TemplateMessage 发送的模板消息内容
 type TemplateMessage struct {
-	ToUser      string                       `json:"touser"`                  // 必须, 接受者OpenID
-	TemplateID  string                       `json:"template_id"`             // 必须, 模版ID
-	URL         string                       `json:"url,omitempty"`           // 可选, 用户点击后跳转的URL, 该URL必须处于开发者在公众平台网站中设置的域中
-	Color       string                       `json:"color,omitempty"`         // 可选, 整个消息的颜色, 可以不设置
-	Data        map[string]*TemplateDataItem `json:"data"`                    // 必须, 模板数据
-	ClientMsgID string                       `json:"client_msg_id,omitempty"` // 可选, 防重入ID
+	ToUser      string                       `json:"touser"`                  // 必须，接受者 OpenID
+	TemplateID  string                       `json:"template_id"`             // 必须，模版 ID
+	URL         string                       `json:"url,omitempty"`           // 可选，用户点击后跳转的 URL, 该 URL 必须处于开发者在公众平台网站中设置的域中
+	Color       string                       `json:"color,omitempty"`         // 可选，整个消息的颜色，可以不设置
+	Data        map[string]*TemplateDataItem `json:"data"`                    // 必须，模板数据
+	ClientMsgID string                       `json:"client_msg_id,omitempty"` // 可选，防重入 ID
 
 	MiniProgram struct {
-		AppID    string `json:"appid"`    // 所需跳转到的小程序appid（该小程序appid必须与发模板消息的公众号是绑定关联关系）
-		PagePath string `json:"pagepath"` // 所需跳转到小程序的具体页面路径，支持带参数,（示例index?foo=bar）
-	} `json:"miniprogram"` // 可选,跳转至小程序地址
+		AppID    string `json:"appid"`    // 所需跳转到的小程序 appid（该小程序 appid 必须与发模板消息的公众号是绑定关联关系）
+		PagePath string `json:"pagepath"` // 所需跳转到小程序的具体页面路径，支持带参数，（示例 index?foo=bar）
+	} `json:"miniprogram"` // 可选，跳转至小程序地址
 }
 
 // TemplateDataItem 模版内某个 .DATA 的值
@@ -80,7 +80,7 @@ func (tpl *Template) Send(msg *TemplateMessage) (msgID int64, err error) {
 	return
 }
 
-// TemplateItem 模板消息.
+// TemplateItem 模板消息。
 type TemplateItem struct {
 	TemplateID      string `json:"template_id"`
 	Title           string `json:"title"`
@@ -121,7 +121,7 @@ type resTemplateAdd struct {
 	TemplateID string `json:"template_id"`
 }
 
-// Add 添加模板.
+// Add 添加模板。
 func (tpl *Template) Add(shortID string, keyNameList []string) (templateID string, err error) {
 	var accessToken string
 	accessToken, err = tpl.GetAccessToken()
@@ -144,7 +144,7 @@ func (tpl *Template) Add(shortID string, keyNameList []string) (templateID strin
 	return result.TemplateID, err
 }
 
-// Delete 删除私有模板.
+// Delete 删除私有模板。
 func (tpl *Template) Delete(templateID string) (err error) {
 	var accessToken string
 	accessToken, err = tpl.GetAccessToken()

officialaccount/oauth/oauth.go

@@ -32,14 +32,14 @@ func NewOauth(context *context.Context) *Oauth {
 	return auth
 }
 
-// GetRedirectURL 获取跳转的url地址
+// GetRedirectURL 获取跳转的 url 地址
 func (oauth *Oauth) GetRedirectURL(redirectURI, scope, state string) (string, error) {
 	// url encode
 	urlStr := url.QueryEscape(redirectURI)
 	return fmt.Sprintf(redirectOauthURL, oauth.AppID, urlStr, scope, state), nil
 }
 
-// GetWebAppRedirectURL 获取网页应用跳转的url地址
+// GetWebAppRedirectURL 获取网页应用跳转的 url 地址
 func (oauth *Oauth) GetWebAppRedirectURL(redirectURI, scope, state string) (string, error) {
 	urlStr := url.QueryEscape(redirectURI)
 	return fmt.Sprintf(webAppRedirectOauthURL, oauth.AppID, urlStr, scope, state), nil
@@ -55,7 +55,7 @@ func (oauth *Oauth) Redirect(writer http.ResponseWriter, req *http.Request, redi
 	return nil
 }
 
-// ResAccessToken 获取用户授权access_token的返回结果
+// ResAccessToken 获取用户授权 access_token 的返回结果
 type ResAccessToken struct {
 	util.CommonError
 
@@ -65,7 +65,7 @@ type ResAccessToken struct {
 	OpenID       string `json:"openid"`
 	Scope        string `json:"scope"`
 
-	// IsSnapShotUser 是否为快照页模式虚拟账号，只有当用户是快照页模式虚拟账号时返回，值为1
+	// IsSnapShotUser 是否为快照页模式虚拟账号，只有当用户是快照页模式虚拟账号时返回，值为 1
 	// 公众号文档 https://developers.weixin.qq.com/community/minihome/doc/000c2c34068880629ced91a2f56001
 	IsSnapShotUser int `json:"is_snapshotuser"`
 
@@ -74,7 +74,7 @@ type ResAccessToken struct {
 	UnionID string `json:"unionid"`
 }
 
-// GetUserInfoByCodeContext 通过网页授权的code 换取用户的信息
+// GetUserInfoByCodeContext 通过网页授权的 code 换取用户的信息
 func (oauth *Oauth) GetUserInfoByCodeContext(ctx ctx2.Context, code string) (result UserInfo, err error) {
 	var (
 		token ResAccessToken
@@ -86,12 +86,12 @@ func (oauth *Oauth) GetUserInfoByCodeContext(ctx ctx2.Context, code string) (res
 	return oauth.GetUserInfoContext(ctx, token.AccessToken, token.OpenID, "")
 }
 
-// GetUserAccessToken 通过网页授权的code 换取access_token(区别于context中的access_token)
+// GetUserAccessToken 通过网页授权的 code 换取 access_token(区别于 context 中的 access_token)
 func (oauth *Oauth) GetUserAccessToken(code string) (result ResAccessToken, err error) {
 	return oauth.GetUserAccessTokenContext(ctx2.Background(), code)
 }
 
-// GetUserAccessTokenContext 通过网页授权的code 换取access_token(区别于context中的access_token) with context
+// GetUserAccessTokenContext 通过网页授权的 code 换取 access_token(区别于 context 中的 access_token) with context
 func (oauth *Oauth) GetUserAccessTokenContext(ctx ctx2.Context, code string) (result ResAccessToken, err error) {
 	urlStr := fmt.Sprintf(accessTokenURL, oauth.AppID, oauth.AppSecret, code)
 	var response []byte
@@ -110,12 +110,12 @@ func (oauth *Oauth) GetUserAccessTokenContext(ctx ctx2.Context, code string) (re
 	return
 }
 
-// RefreshAccessToken 刷新access_token
+// RefreshAccessToken 刷新 access_token
 func (oauth *Oauth) RefreshAccessToken(refreshToken string) (result ResAccessToken, err error) {
 	return oauth.RefreshAccessTokenContext(ctx2.Background(), refreshToken)
 }
 
-// RefreshAccessTokenContext 刷新access_token with context
+// RefreshAccessTokenContext 刷新 access_token with context
 func (oauth *Oauth) RefreshAccessTokenContext(ctx ctx2.Context, refreshToken string) (result ResAccessToken, err error) {
 	urlStr := fmt.Sprintf(refreshAccessTokenURL, oauth.AppID, refreshToken)
 	var response []byte
@@ -134,12 +134,12 @@ func (oauth *Oauth) RefreshAccessTokenContext(ctx ctx2.Context, refreshToken str
 	return
 }
 
-// CheckAccessToken 检验access_token是否有效
+// CheckAccessToken 检验 access_token 是否有效
 func (oauth *Oauth) CheckAccessToken(accessToken, openID string) (b bool, err error) {
 	return oauth.CheckAccessTokenContext(ctx2.Background(), accessToken, openID)
 }
 
-// CheckAccessTokenContext 检验access_token是否有效 with context
+// CheckAccessTokenContext 检验 access_token 是否有效 with context
 func (oauth *Oauth) CheckAccessTokenContext(ctx ctx2.Context, accessToken, openID string) (b bool, err error) {
 	urlStr := fmt.Sprintf(checkAccessTokenURL, accessToken, openID)
 	var response []byte
@@ -175,12 +175,12 @@ type UserInfo struct {
 	Unionid    string   `json:"unionid"`
 }
 
-// GetUserInfo 如果scope为 snsapi_userinfo 则可以通过此方法获取到用户基本信息
+// GetUserInfo 如果 scope 为 snsapi_userinfo 则可以通过此方法获取到用户基本信息
 func (oauth *Oauth) GetUserInfo(accessToken, openID, lang string) (result UserInfo, err error) {
 	return oauth.GetUserInfoContext(ctx2.Background(), accessToken, openID, lang)
 }
 
-// GetUserInfoContext 如果scope为 snsapi_userinfo 则可以通过此方法获取到用户基本信息 with context
+// GetUserInfoContext 如果 scope 为 snsapi_userinfo 则可以通过此方法获取到用户基本信息 with context
 func (oauth *Oauth) GetUserInfoContext(ctx ctx2.Context, accessToken, openID, lang string) (result UserInfo, err error) {
 	if lang == "" {
 		lang = "zh_CN"

officialaccount/ocr/ocr.go

@@ -153,7 +153,7 @@ func NewOCR(c *context.Context) *OCR {
 	return ocr
 }
 
-// IDCard 身份证OCR识别接口
+// IDCard 身份证 OCR 识别接口
 func (ocr *OCR) IDCard(path string) (resIDCard ResIDCard, err error) {
 	accessToken, err := ocr.GetAccessToken()
 	if err != nil {
@@ -170,7 +170,7 @@ func (ocr *OCR) IDCard(path string) (resIDCard ResIDCard, err error) {
 	return
 }
 
-// BankCard 银行卡OCR识别接口
+// BankCard 银行卡 OCR 识别接口
 func (ocr *OCR) BankCard(path string) (resBankCard ResBankCard, err error) {
 	accessToken, err := ocr.GetAccessToken()
 	if err != nil {
@@ -187,7 +187,7 @@ func (ocr *OCR) BankCard(path string) (resBankCard ResBankCard, err error) {
 	return
 }
 
-// Driving 行驶证OCR识别接口
+// Driving 行驶证 OCR 识别接口
 func (ocr *OCR) Driving(path string) (resDriving ResDriving, err error) {
 	accessToken, err := ocr.GetAccessToken()
 	if err != nil {
@@ -204,7 +204,7 @@ func (ocr *OCR) Driving(path string) (resDriving ResDriving, err error) {
 	return
 }
 
-// DrivingLicense 驾驶证OCR识别接口
+// DrivingLicense 驾驶证 OCR 识别接口
 func (ocr *OCR) DrivingLicense(path string) (resDrivingLicense ResDrivingLicense, err error) {
 	accessToken, err := ocr.GetAccessToken()
 	if err != nil {
@@ -221,7 +221,7 @@ func (ocr *OCR) DrivingLicense(path string) (resDrivingLicense ResDrivingLicense
 	return
 }
 
-// BizLicense 营业执照OCR识别接口
+// BizLicense 营业执照 OCR 识别接口
 func (ocr *OCR) BizLicense(path string) (resBizLicense ResBizLicense, err error) {
 	accessToken, err := ocr.GetAccessToken()
 	if err != nil {
@@ -238,7 +238,7 @@ func (ocr *OCR) BizLicense(path string) (resBizLicense ResBizLicense, err error)
 	return
 }
 
-// Common 通用印刷体OCR识别接口
+// Common 通用印刷体 OCR 识别接口
 func (ocr *OCR) Common(path string) (resCommon ResCommon, err error) {
 	accessToken, err := ocr.GetAccessToken()
 	if err != nil {
@@ -255,7 +255,7 @@ func (ocr *OCR) Common(path string) (resCommon ResCommon, err error) {
 	return
 }
 
-// PlateNumber 车牌OCR识别接口
+// PlateNumber 车牌 OCR 识别接口
 func (ocr *OCR) PlateNumber(path string) (resPlateNumber ResPlateNumber, err error) {
 	accessToken, err := ocr.GetAccessToken()
 	if err != nil {

officialaccount/user/blacklist.go

@@ -19,11 +19,11 @@ const (
 )
 
 // GetBlackList 获取公众号的黑名单列表
-// 该接口每次调用最多可拉取 1000 个OpenID，当列表数较多时，可以通过多次拉取的方式来满足需求。
+// 该接口每次调用最多可拉取 1000 个 OpenID，当列表数较多时，可以通过多次拉取的方式来满足需求。
 // 参数 beginOpenid：当 begin_openid 为空时，默认从开头拉取。
 func (user *User) GetBlackList(beginOpenid ...string) (userlist *OpenidList, err error) {
 	if len(beginOpenid) > 1 {
-		return nil, errors.New("参数 beginOpenid 错误：请传递 1 个openID，若需要从头开始拉取列表请留空。")
+		return nil, errors.New("参数 beginOpenid 错误：请传递 1 个 openID，若需要从头开始拉取列表请留空。")
 	}
 	// 获取 AccessToken
 	var accessToken string
@@ -62,13 +62,13 @@ func (user *User) GetAllBlackList() (openIDList []string, err error) {
 	)
 
 	for {
-		// 获取列表（每次1k条）
+		// 获取列表（每次 1k 条）
 		if userlist, err = user.GetBlackList(beginOpenid); err != nil {
 			return nil, err
 		}
-		openIDList = append(openIDList, userlist.Data.OpenIDs...) // 存储本次获得的OpenIDs
+		openIDList = append(openIDList, userlist.Data.OpenIDs...) // 存储本次获得的 OpenIDs
 		count += userlist.Count                                   // 记录获得的总数量
-		beginOpenid = userlist.NextOpenID                         // 记录下次循环的起始openID
+		beginOpenid = userlist.NextOpenID                         // 记录下次循环的起始 openID
 		if count >= userlist.Total {
 			break // 获得的数量=total，结束循环
 		}
@@ -78,13 +78,13 @@ func (user *User) GetAllBlackList() (openIDList []string, err error) {
 }
 
 // BatchBlackList 拉黑用户
-// 参数 openidList：需要拉入黑名单的用户的openid，每次拉黑最多允许20个
+// 参数 openidList：需要拉入黑名单的用户的 openid，每次拉黑最多允许 20 个
 func (user *User) BatchBlackList(openidList ...string) (err error) {
 	return user.batch(batchblacklistURL, "BatchBlackList", openidList...)
 }
 
 // BatchUnBlackList 取消拉黑用户
-// 参数 openidList：需要取消拉入黑名单的用户的openid，每次拉黑最多允许20个
+// 参数 openidList：需要取消拉入黑名单的用户的 openid，每次拉黑最多允许 20 个
 func (user *User) BatchUnBlackList(openidList ...string) (err error) {
 	return user.batch(batchunblacklistURL, "BatchUnBlackList", openidList...)
 }
@@ -93,7 +93,7 @@ func (user *User) BatchUnBlackList(openidList ...string) (err error) {
 func (user *User) batch(url, apiName string, openidList ...string) (err error) {
 	// 检查参数
 	if len(openidList) == 0 || len(openidList) > 20 {
-		return errors.New("参数 openidList 错误：每次操作黑名单用户数量为1-20个。")
+		return errors.New("参数 openidList 错误：每次操作黑名单用户数量为 1-20 个。")
 	}
 
 	// 获取 AccessToken

officialaccount/user/migrate.go

@@ -1,4 +1,4 @@
-// Package user migrate 用于微信公众号账号迁移，获取openID变化
+// Package user migrate 用于微信公众号账号迁移，获取 openID 变化
 // 参考文档：https://kf.qq.com/faq/1901177NrqMr190117nqYJze.html
 package user
 
@@ -13,23 +13,23 @@ const (
 	changeOpenIDURL = "https://api.weixin.qq.com/cgi-bin/changeopenid"
 )
 
-// ChangeOpenIDResult OpenID迁移变化
+// ChangeOpenIDResult OpenID 迁移变化
 type ChangeOpenIDResult struct {
 	OriOpenID string `json:"ori_openid"`
 	NewOpenID string `json:"new_openid"`
 	ErrMsg    string `json:"err_msg,omitempty"`
 }
 
-// ChangeOpenIDResultList OpenID迁移变化列表
+// ChangeOpenIDResultList OpenID 迁移变化列表
 type ChangeOpenIDResultList struct {
 	util.CommonError
 	List []ChangeOpenIDResult `json:"result_list"`
 }
 
-// ListChangeOpenIDs 返回指定OpenID变化列表
-// fromAppID 为老账号AppID
-// openIDs 为老账号的openID，openIDs限100个以内
-// AccessToken 为新账号的AccessToken
+// ListChangeOpenIDs 返回指定 OpenID 变化列表
+// fromAppID 为老账号 AppID
+// openIDs 为老账号的 openID，openIDs 限 100 个以内
+// AccessToken 为新账号的 AccessToken
 func (user *User) ListChangeOpenIDs(fromAppID string, openIDs ...string) (list *ChangeOpenIDResultList, err error) {
 	list = &ChangeOpenIDResultList{}
 	// list.List = make([]ChangeOpenIDResult, 0)
@@ -65,10 +65,10 @@ func (user *User) ListChangeOpenIDs(fromAppID string, openIDs ...string) (list *
 	return
 }
 
-// ListAllChangeOpenIDs  返回所有用户OpenID列表
-// fromAppID 为老账号AppID
-// openIDs 为老账号的openID
-// AccessToken 为新账号的AccessToken
+// ListAllChangeOpenIDs  返回所有用户 OpenID 列表
+// fromAppID 为老账号 AppID
+// openIDs 为老账号的 openID
+// AccessToken 为新账号的 AccessToken
 func (user *User) ListAllChangeOpenIDs(fromAppID string, openIDs ...string) (list []ChangeOpenIDResult, err error) {
 	list = make([]ChangeOpenIDResult, 0)
 	chunks := util.SliceChunk(openIDs, 100)

officialaccount/user/user.go

@@ -102,7 +102,7 @@ type BatchGetUserInfoParams struct {
 // BatchGetUserListItem 需要获取基本信息的用户
 type BatchGetUserListItem struct {
 	OpenID string `json:"openid"` // 用户的标识，对当前公众号唯一
-	Lang   string `json:"lang"`   // 国家地区语言版本，zh_CN 简体，zh_TW 繁体，en 英语，默认为zh-CN
+	Lang   string `json:"lang"`   // 国家地区语言版本，zh_CN 简体，zh_TW 繁体，en 英语，默认为 zh-CN
 }
 
 // InfoList 用户基本信息列表
@@ -161,7 +161,10 @@ func (user *User) ListUserOpenIDs(nextOpenid ...string) (*OpenidList, error) {
 		return nil, err
 	}
 
-	uri, _ := url.Parse(userListURL)
+	uri, err := url.Parse(userListURL)
+	if err != nil {
+		return nil, err
+	}
 	q := uri.Query()
 	q.Set("access_token", accessToken)
 	if len(nextOpenid) > 0 && nextOpenid[0] != "" {
@@ -184,7 +187,7 @@ func (user *User) ListUserOpenIDs(nextOpenid ...string) (*OpenidList, error) {
 	return &userlist, nil
 }
 
-// ListAllUserOpenIDs 返回所有用户OpenID列表
+// ListAllUserOpenIDs 返回所有用户 OpenID 列表
 func (user *User) ListAllUserOpenIDs() ([]string, error) {
 	nextOpenid := ""
 	openids := make([]string, 0)

openplatform/README.md

@@ -19,7 +19,7 @@ cfg := &openplatform.Config{
 
 
 openPlatform := wc.GetOpenPlatform(cfg)
-// 传入request和responseWriter
+// 传入 request 和 responseWriter
 server := openPlatform.GetServer(req, rw)
 //设置接收消息的处理方法
 server.SetMessageHandler(func(msg *message.MixMessage) *message.Reply {
@@ -57,7 +57,7 @@ server.Send()
 
 ```go
 
-//授权的第三方公众号的appID
+//授权的第三方公众号的 appID
 appID := "xxx"
 openPlatform := wc.GetOpenPlatform(cfg)
 openPlatform.GetOfficialAccount(appID)

openplatform/miniprogram/basic/basic.go

@@ -53,7 +53,7 @@ func (basic *Basic) GetAccountBasicInfo() (*AccountBasicInfo, error) {
 	return result, nil
 }
 
-// modify_domain设置服务器域名
+// modify_domain 设置服务器域名
 // TODO
 // func (encryptor *Basic) modifyDomain() {
 // }
@@ -87,7 +87,7 @@ func (basic *Basic) CheckNickName(nickname string) (*CheckNickNameResp, error) {
 // SetNickNameResp 设置小程序名称结果
 type SetNickNameResp struct {
 	util.CommonError
-	AuditID int64  `json:"audit_id"` // 审核单Id，通过用于查询改名审核状态
+	AuditID int64  `json:"audit_id"` // 审核单 Id，通过用于查询改名审核状态
 	Wording string `json:"wording"`  // 材料说明
 }
 
@@ -221,7 +221,7 @@ func (basic *Basic) SetHeadImage(imgMediaID string) error {
 }
 
 // SetHeadImageFull 修改小程序头像
-// 新增临时素材: https://developers.weixin.qq.com/doc/offiaccount/Asset_Management/New_temporary_materials.html
+// 新增临时素材：https://developers.weixin.qq.com/doc/offiaccount/Asset_Management/New_temporary_materials.html
 // ref: https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/miniprogram-management/basic-info-management/setHeadImage.html
 func (basic *Basic) SetHeadImageFull(param *SetHeadImageParam) error {
 	ak, err := basic.GetAuthrAccessToken(basic.AppID)

openplatform/miniprogram/component/component.go

@@ -25,7 +25,7 @@ func NewComponent(opContext *openContext.Context) *Component {
 type RegisterMiniProgramParam struct {
 	Name               string `json:"name"`                 // 企业名
 	Code               string `json:"code"`                 // 企业代码
-	CodeType           string `json:"code_type"`            // 企业代码类型 1：统一社会信用代码（18 位） 2：组织机构代码（9 位 xxxxxxxx-x） 3：营业执照注册号(15 位)
+	CodeType           string `json:"code_type"`            // 企业代码类型 1：统一社会信用代码（18 位）2：组织机构代码（9 位 xxxxxxxx-x）3：营业执照注册号 (15 位)
 	LegalPersonaWechat string `json:"legal_persona_wechat"` // 法人微信号
 	LegalPersonaName   string `json:"legal_persona_name"`   // 法人姓名（绑定银行卡）
 	ComponentPhone     string `json:"component_phone"`      // 第三方联系电话（方便法人与第三方联系）
@@ -54,7 +54,7 @@ type GetRegistrationStatusParam struct {
 
 }
 
-// GetRegistrationStatus 查询创建任务状态.
+// GetRegistrationStatus 查询创建任务状态。
 func (component *Component) GetRegistrationStatus(param *GetRegistrationStatusParam) error {
 	componentAK, err := component.GetComponentAccessToken()
 	if err != nil {

openplatform/miniprogram/miniprogram.go

@@ -21,7 +21,7 @@ type MiniProgram struct {
 	authorizerRefreshToken string
 }
 
-// GetAccessToken 获取ak
+// GetAccessToken 获取 ak
 func (miniProgram *MiniProgram) GetAccessToken() (string, error) {
 	ak, akErr := miniProgram.openContext.GetAuthrAccessToken(miniProgram.AppID)
 	if akErr == nil {
@@ -37,7 +37,7 @@ func (miniProgram *MiniProgram) GetAccessToken() (string, error) {
 	return akRes.AccessToken, nil
 }
 
-// SetAuthorizerRefreshToken 设置代执操作业务授权账号authorizer_refresh_token
+// SetAuthorizerRefreshToken 设置代执操作业务授权账号 authorizer_refresh_token
 func (miniProgram *MiniProgram) SetAuthorizerRefreshToken(authorizerRefreshToken string) *MiniProgram {
 	miniProgram.authorizerRefreshToken = authorizerRefreshToken
 	return miniProgram
@@ -49,7 +49,7 @@ func NewMiniProgram(opCtx *openContext.Context, appID string) *MiniProgram {
 		AppID: opCtx.AppID,
 		Cache: opCtx.Cache,
 	})
-	// 设置获取access_token的函数
+	// 设置获取 access_token 的函数
 	miniProgram.SetAccessTokenHandle(NewDefaultAuthrAccessToken(opCtx, appID))
 	return &MiniProgram{AppID: appID, MiniProgram: miniProgram, openContext: opCtx}
 }
@@ -65,20 +65,20 @@ func (miniProgram *MiniProgram) GetBasic() *basic.Basic {
 	return basic.NewBasic(miniProgram.openContext, miniProgram.AppID)
 }
 
-// GetURLLink 小程序URL Link接口 调用前需确认已调用 SetAuthorizerRefreshToken 避免由于缓存中 authorizer_access_token 过期执行中断
+// GetURLLink 小程序 URL Link 接口 调用前需确认已调用 SetAuthorizerRefreshToken 避免由于缓存中 authorizer_access_token 过期执行中断
 func (miniProgram *MiniProgram) GetURLLink() *urllink.URLLink {
 	return urllink.NewURLLink(&miniContext.Context{
 		AccessTokenHandle: miniProgram,
 	})
 }
 
-// DefaultAuthrAccessToken 默认获取授权ak的方法
+// DefaultAuthrAccessToken 默认获取授权 ak 的方法
 type DefaultAuthrAccessToken struct {
 	opCtx *openContext.Context
 	appID string
 }
 
-// NewDefaultAuthrAccessToken 设置access_token
+// NewDefaultAuthrAccessToken 设置 access_token
 func NewDefaultAuthrAccessToken(opCtx *openContext.Context, appID string) credential.AccessTokenHandle {
 	return &DefaultAuthrAccessToken{
 		opCtx: opCtx,
@@ -86,7 +86,7 @@ func NewDefaultAuthrAccessToken(opCtx *openContext.Context, appID string) creden
 	}
 }
 
-// GetAccessToken 获取ak
+// GetAccessToken 获取 ak
 func (ak *DefaultAuthrAccessToken) GetAccessToken() (string, error) {
 	return ak.opCtx.GetAuthrAccessToken(ak.appID)
 }

openplatform/officialaccount/js/js.go

@@ -24,12 +24,12 @@ func NewJs(context *context.Context, appID string) *Js {
 	return js
 }
 
-// SetJsTicketHandle 自定义js ticket取值方式
+// SetJsTicketHandle 自定义 js ticket 取值方式
 func (js *Js) SetJsTicketHandle(ticketHandle credential.JsTicketHandle) {
 	js.JsTicketHandle = ticketHandle
 }
 
-// GetConfig 第三方平台 - 获取jssdk需要的配置参数
+// GetConfig 第三方平台 - 获取 jssdk 需要的配置参数
 // uri 为当前网页地址
 func (js *Js) GetConfig(uri, appid string) (config *officialJs.Config, err error) {
 	config = new(officialJs.Config)

openplatform/officialaccount/oauth/oauth.go

@@ -16,19 +16,19 @@ const (
 	platformAccessTokenURL   = "https://api.weixin.qq.com/sns/oauth2/component/access_token?appid=%s&code=%s&grant_type=authorization_code&component_appid=%s&component_access_token=%s"
 )
 
-// Oauth 平台代发起oauth2网页授权
+// Oauth 平台代发起 oauth2 网页授权
 type Oauth struct {
 	*context.Context
 }
 
-// NewOauth 实例化平台代发起oauth2网页授权
+// NewOauth 实例化平台代发起 oauth2 网页授权
 func NewOauth(context *context.Context) *Oauth {
 	auth := new(Oauth)
 	auth.Context = context
 	return auth
 }
 
-// GetRedirectURL 第三方平台 - 获取跳转的url地址
+// GetRedirectURL 第三方平台 - 获取跳转的 url 地址
 func (oauth *Oauth) GetRedirectURL(redirectURI, scope, state, appID string) (string, error) {
 	// url encode
 	urlStr := url.QueryEscape(redirectURI)
@@ -45,7 +45,7 @@ func (oauth *Oauth) Redirect(writer http.ResponseWriter, req *http.Request, redi
 	return nil
 }
 
-// GetUserAccessToken 第三方平台 - 通过网页授权的code 换取access_token(区别于context中的access_token)
+// GetUserAccessToken 第三方平台 - 通过网页授权的 code 换取 access_token(区别于 context 中的 access_token)
 func (oauth *Oauth) GetUserAccessToken(code, appID, componentAccessToken string) (result officialOauth.ResAccessToken, err error) {
 	urlStr := fmt.Sprintf(platformAccessTokenURL, appID, code, oauth.AppID, componentAccessToken)
 	var response []byte

openplatform/openplatform.go

@@ -11,7 +11,7 @@ import (
 	"github.com/silenceper/wechat/v2/openplatform/officialaccount"
 )
 
-// OpenPlatform 微信开放平台相关api
+// OpenPlatform 微信开放平台相关 api
 type OpenPlatform struct {
 	*context.Context
 }

pay/notify/paid.go

@@ -75,7 +75,7 @@ func (notify *Notify) PaidVerifySign(notifyRes PaidResult) bool {
 	}
 	sort.Strings(sortedKeys)
 
-	// STEP2, 对key=value的键值对用&连接起来，略过空值 & sign
+	// STEP2, 对 key=value 的键值对用&连接起来，略过空值 & sign
 	var signStrings string
 	for _, k := range sortedKeys {
 		value := fmt.Sprintf("%v", cast.ToString(resMap[k]))
@@ -84,10 +84,10 @@ func (notify *Notify) PaidVerifySign(notifyRes PaidResult) bool {
 		}
 	}
 
-	// STEP3, 在键值对的最后加上key=API_KEY
+	// STEP3, 在键值对的最后加上 key=API_KEY
 	signStrings = signStrings + "key=" + notify.Key
 
-	// STEP4, 根据SignType计算出签名
+	// STEP4, 根据 SignType 计算出签名
 	var signType string
 	if notifyRes.SignType != nil {
 		signType = *notifyRes.SignType

pay/order/close.go

@@ -18,7 +18,7 @@ type CloseParams struct {
 
 // closeRequest 接口请求参数
 type closeRequest struct {
-	AppID      string `xml:"appid"`               // 公众账号ID
+	AppID      string `xml:"appid"`               // 公众账号 ID
 	MchID      string `xml:"mch_id"`              // 商户号
 	NonceStr   string `xml:"nonce_str"`           // 随机字符串
 	Sign       string `xml:"sign"`                // 签名

pay/order/pay.go

@@ -35,7 +35,7 @@ type Params struct {
 	CreateIP   string
 	Body       string
 	OutTradeNo string
-	TimeExpire string // 订单失效时间，格式为yyyyMMddHHmmss，如2009年12月27日9点10分10秒表示为20091227091010。
+	TimeExpire string // 订单失效时间，格式为 yyyyMMddHHmmss，如 2009 年 12 月 27 日 9 点 10 分 10 秒表示为 20091227091010。
 	OpenID     string
 	TradeType  string
 	SignType   string
@@ -85,7 +85,7 @@ type PreOrder struct {
 
 // payRequest 接口请求参数
 type payRequest struct {
-	AppID          string `xml:"appid"`                 // 公众账号ID
+	AppID          string `xml:"appid"`                 // 公众账号 ID
 	MchID          string `xml:"mch_id"`                // 商户号
 	DeviceInfo     string `xml:"device_info,omitempty"` // 设备号
 	NonceStr       string `xml:"nonce_str"`             // 随机字符串
@@ -97,13 +97,13 @@ type payRequest struct {
 	OutTradeNo     string `xml:"out_trade_no"`          // 商户订单号
 	FeeType        string `xml:"fee_type,omitempty"`    // 标价币种
 	TotalFee       string `xml:"total_fee"`             // 标价金额
-	SpbillCreateIP string `xml:"spbill_create_ip"`      // 终端IP
+	SpbillCreateIP string `xml:"spbill_create_ip"`      // 终端 IP
 	TimeStart      string `xml:"time_start,omitempty"`  // 交易起始时间
 	TimeExpire     string `xml:"time_expire,omitempty"` // 交易结束时间
 	GoodsTag       string `xml:"goods_tag,omitempty"`   // 订单优惠标记
 	NotifyURL      string `xml:"notify_url"`            // 通知地址
 	TradeType      string `xml:"trade_type"`            // 交易类型
-	ProductID      string `xml:"product_id,omitempty"`  // 商品ID
+	ProductID      string `xml:"product_id,omitempty"`  // 商品 ID
 	LimitPay       string `xml:"limit_pay,omitempty"`   // 指定支付方式
 	OpenID         string `xml:"openid,omitempty"`      // 用户标识
 	SceneInfo      string `xml:"scene_info,omitempty"`  // 场景信息
@@ -213,7 +213,7 @@ func (o *Order) PrePayOrder(p *Params) (payOrder PreOrder, err error) {
 
 	// 通知地址
 	if len(p.NotifyURL) == 0 {
-		p.NotifyURL = o.NotifyURL // 默认使用order.NotifyURL
+		p.NotifyURL = o.NotifyURL // 默认使用 order.NotifyURL
 	}
 
 	// 签名类型

pay/order/query.go

@@ -19,7 +19,7 @@ type QueryParams struct {
 
 // queryRequest 接口请求参数
 type queryRequest struct {
-	AppID         string `xml:"appid"`               // 公众账号ID
+	AppID         string `xml:"appid"`               // 公众账号 ID
 	MchID         string `xml:"mch_id"`              // 商户号
 	NonceStr      string `xml:"nonce_str"`           // 随机字符串
 	Sign          string `xml:"sign"`                // 签名

pay/pay.go

@@ -9,12 +9,12 @@ import (
 	"github.com/silenceper/wechat/v2/pay/transfer"
 )
 
-// Pay 微信支付相关API
+// Pay 微信支付相关 API
 type Pay struct {
 	cfg *config.Config
 }
 
-// NewPay 实例化微信支付相关API
+// NewPay 实例化微信支付相关 API
 func NewPay(cfg *config.Config) *Pay {
 	return &Pay{cfg}
 }

pay/redpacket/redpacket.go

@@ -35,7 +35,7 @@ type Params struct {
 	ActName     string
 	Remark      string
 
-	RootCa string // ca证书
+	RootCa string // ca 证书
 }
 
 // request 接口请求参数

pay/refund/refund.go

@@ -29,7 +29,7 @@ type Params struct {
 	TotalFee      string
 	RefundFee     string
 	RefundDesc    string
-	RootCa        string // ca证书
+	RootCa        string // ca 证书
 	NotifyURL     string
 	SignType      string
 }

pay/transfer/transfer_wallet.go

@@ -33,7 +33,7 @@ type Params struct {
 	Amount         int
 	Desc           string
 	SpbillCreateIP string
-	RootCa         string // ca证书
+	RootCa         string // ca 证书
 }
 
 // request 接口请求参数

util/crypto.go

@@ -44,7 +44,7 @@ func EncryptMsg(random, rawXMLMsg []byte, appID, aesKey string) (encrtptMsg []by
 func AESEncryptMsg(random, rawXMLMsg []byte, appID string, aesKey []byte) (ciphertext []byte) {
 	const (
 		BlockSize = 32            // PKCS#7
-		BlockMask = BlockSize - 1 // BLOCK_SIZE 为 2^n 时, 可以用 mask 获取针对 BLOCK_SIZE 的余数
+		BlockMask = BlockSize - 1 // BLOCK_SIZE 为 2^n 时，可以用 mask 获取针对 BLOCK_SIZE 的余数
 	)
 
 	appIDOffset := 20 + len(rawXMLMsg)
@@ -100,7 +100,7 @@ func DecryptMsg(appID, encryptedMsg, aesKey string) (random, rawMsgXMLBytes []by
 		return
 	}
 	if appID != string(getAppIDBytes) {
-		err = fmt.Errorf("消息解密校验APPID失败")
+		err = fmt.Errorf("消息解密校验 APPID 失败")
 		return
 	}
 	return
@@ -127,7 +127,7 @@ func aesKeyDecode(encodedAESKey string) (key []byte, err error) {
 func AESDecryptMsg(ciphertext []byte, aesKey []byte) (random, rawXMLMsg, appID []byte, err error) {
 	const (
 		BlockSize = 32            // PKCS#7
-		BlockMask = BlockSize - 1 // BLOCK_SIZE 为 2^n 时, 可以用 mask 获取针对 BLOCK_SIZE 的余数
+		BlockMask = BlockSize - 1 // BLOCK_SIZE 为 2^n 时，可以用 mask 获取针对 BLOCK_SIZE 的余数
 	)
 
 	if len(ciphertext) < BlockSize {

util/http.go

@@ -17,15 +17,15 @@ import (
 	"golang.org/x/crypto/pkcs12"
 )
 
-// URIModifier URI修改器
+// URIModifier URI 修改器
 type URIModifier func(uri string) string
 
 var uriModifier URIModifier
 
-// DefaultHTTPClient 默认httpClient
+// DefaultHTTPClient 默认 httpClient
 var DefaultHTTPClient = http.DefaultClient
 
-// SetURIModifier 设置URI修改器
+// SetURIModifier 设置 URI 修改器
 func SetURIModifier(fn URIModifier) {
 	uriModifier = fn
 }

util/query.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 )
 
-// Query 将Map序列化为Query参数
+// Query 将 Map 序列化为 Query 参数
 func Query(params map[string]interface{}) string {
 	finalString := make([]string, 0)
 	for key, value := range params {

util/rsa.go

@@ -25,7 +25,10 @@ func RSADecrypt(privateKey string, ciphertext []byte) ([]byte, error) {
 		}
 		switch t := key.(type) {
 		case *rsa.PrivateKey:
-			priv = key.(*rsa.PrivateKey)
+			var ok bool
+			if priv, ok = key.(*rsa.PrivateKey); !ok {
+				return nil, fmt.Errorf(" ParsePKCS8PrivateKey error: Not supported privatekey format, should be *rsa.PrivateKey, got %T", t)
+			}
 		default:
 			return nil, fmt.Errorf("ParsePKCS1PrivateKey error: %s, ParsePKCS8PrivateKey error: Not supported privatekey format, should be *rsa.PrivateKey, got %T", oldErr.Error(), t)
 		}
@@ -33,7 +36,7 @@ func RSADecrypt(privateKey string, ciphertext []byte) ([]byte, error) {
 	return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
 }
 
-// RSADecryptBase64 Base64解码后再次进行RSA解密
+// RSADecryptBase64 Base64 解码后再次进行 RSA 解密
 func RSADecryptBase64(privateKey string, cryptoText string) ([]byte, error) {
 	encryptedData, err := base64.StdEncoding.DecodeString(cryptoText)
 	if err != nil {

util/signature.go

@@ -7,7 +7,7 @@ import (
 	"sort"
 )
 
-// Signature sha1签名
+// Signature sha1 签名
 func Signature(params ...string) string {
 	sort.Strings(params)
 	h := sha1.New()

util/template.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 )
 
-// Template 对字符串中的和map的key相同的字符串进行模板替换 仅支持 形如: {name}
+// Template 对字符串中的和 map 的 key 相同的字符串进行模板替换 仅支持 形如：{name}
 func Template(source string, data map[string]interface{}) string {
 	sourceCopy := &source
 	for k, val := range data {

wechat.go

@@ -84,7 +84,7 @@ func (wc *Wechat) GetWork(cfg *workConfig.Config) *work.Work {
 	return work.NewWork(cfg)
 }
 
-// SetHTTPClient  设置HTTPClient
+// SetHTTPClient  设置 HTTPClient
 func (wc *Wechat) SetHTTPClient(client *http.Client) {
 	util.DefaultHTTPClient = client
 }

work/addresslist/department.go

@@ -9,7 +9,7 @@ import (
 const (
 	// departmentCreateURL 创建部门
 	departmentCreateURL = "https://qyapi.weixin.qq.com/cgi-bin/department/create?access_token=%s"
-	// departmentSimpleListURL 获取子部门ID列表
+	// departmentSimpleListURL 获取子部门 ID 列表
 	departmentSimpleListURL = "https://qyapi.weixin.qq.com/cgi-bin/department/simplelist?access_token=%s&id=%d"
 	// departmentListURL 获取部门列表
 	departmentListURL     = "https://qyapi.weixin.qq.com/cgi-bin/department/list?access_token=%s"
@@ -33,12 +33,12 @@ type (
 		ID int `json:"id"`
 	}
 
-	// DepartmentSimpleListResponse 获取子部门ID列表响应
+	// DepartmentSimpleListResponse 获取子部门 ID 列表响应
 	DepartmentSimpleListResponse struct {
 		util.CommonError
 		DepartmentID []*DepartmentID `json:"department_id"`
 	}
-	// DepartmentID 子部门ID
+	// DepartmentID 子部门 ID
 	DepartmentID struct {
 		ID       int `json:"id"`
 		ParentID int `json:"parentid"`
@@ -52,12 +52,12 @@ type (
 	}
 	// Department 部门列表数据
 	Department struct {
-		ID               int      `json:"id"`                // 创建的部门id
+		ID               int      `json:"id"`                // 创建的部门 id
 		Name             string   `json:"name"`              // 部门名称
 		NameEn           string   `json:"name_en"`           // 英文名称
-		DepartmentLeader []string `json:"department_leader"` // 部门负责人的UserID
-		ParentID         int      `json:"parentid"`          // 父部门id。根部门为1
-		Order            int      `json:"order"`             // 在父部门中的次序值。order值大的排序靠前
+		DepartmentLeader []string `json:"department_leader"` // 部门负责人的 UserID
+		ParentID         int      `json:"parentid"`          // 父部门 id。根部门为 1
+		Order            int      `json:"order"`             // 在父部门中的次序值。order 值大的排序靠前
 	}
 	// DepartmentGetResponse 获取单个部门详情
 	DepartmentGetResponse struct {
@@ -85,7 +85,7 @@ func (r *Client) DepartmentCreate(req *DepartmentCreateRequest) (*DepartmentCrea
 	return result, err
 }
 
-// DepartmentSimpleList 获取子部门ID列表
+// DepartmentSimpleList 获取子部门 ID 列表
 // see https://developer.work.weixin.qq.com/document/path/95350
 func (r *Client) DepartmentSimpleList(departmentID int) ([]*DepartmentID, error) {
 	var (
@@ -112,13 +112,13 @@ func (r *Client) DepartmentList() ([]*Department, error) {
 
 // DepartmentListByID 获取部门列表
 //
-// departmentID 部门id。获取指定部门及其下的子部门（以及子部门的子部门等等，递归）
+// departmentID 部门 id。获取指定部门及其下的子部门（以及子部门的子部门等等，递归）
 //
 // @desc https://developer.work.weixin.qq.com/document/path/90208
 func (r *Client) DepartmentListByID(departmentID int) ([]*Department, error) {
 	var formatURL string
 
-	// 获取accessToken
+	// 获取 accessToken
 	accessToken, err := r.GetAccessToken()
 	if err != nil {
 		return nil, err
@@ -130,7 +130,7 @@ func (r *Client) DepartmentListByID(departmentID int) ([]*Department, error) {
 		formatURL = fmt.Sprintf(departmentListURL, accessToken)
 	}
 
-	// 发起http请求
+	// 发起 http 请求
 	response, err := util.HTTPGet(formatURL)
 	if err != nil {
 		return nil, err

work/addresslist/linkedcorp.go

@@ -83,12 +83,12 @@ type ExtattrItem struct {
 	Web   ExtattrItemWeb  `json:"web,omitempty"`
 }
 
-// ExtattrItemText 互联企业成员详细信息自定义属性(文本)
+// ExtattrItemText 互联企业成员详细信息自定义属性 (文本)
 type ExtattrItemText struct {
 	Value string `json:"value"`
 }
 
-// ExtattrItemWeb 互联企业成员详细信息自定义属性(网页)
+// ExtattrItemWeb 互联企业成员详细信息自定义属性 (网页)
 type ExtattrItemWeb struct {
 	URL   string `json:"url"`
 	Title string `json:"title"`

work/appchat/appchat.go

@@ -15,11 +15,11 @@ const (
 type (
 	// SendRequestCommon 发送应用推送消息请求公共参数
 	SendRequestCommon struct {
-		// 群聊id
+		// 群聊 id
 		ChatID string `json:"chatid"`
 		// 消息类型
 		MsgType string `json:"msgtype"`
-		// 表示是否是保密消息，0表示否，1表示是，默认0
+		// 表示是否是保密消息，0 表示否，1 表示是，默认 0
 		Safe int `json:"safe"`
 	}
 
@@ -35,7 +35,7 @@ type (
 	}
 	// TextField 文本消息参数
 	TextField struct {
-		// 消息内容，最长不超过2048个字节
+		// 消息内容，最长不超过 2048 个字节
 		Content string `json:"content"`
 	}
 
@@ -46,7 +46,7 @@ type (
 	}
 	// ImageField 图片消息参数
 	ImageField struct {
-		// 图片媒体文件id，可以调用上传临时素材接口获取
+		// 图片媒体文件 id，可以调用上传临时素材接口获取
 		MediaID string `json:"media_id"`
 	}
 
@@ -57,7 +57,7 @@ type (
 	}
 	// VoiceField 语音消息参数
 	VoiceField struct {
-		// 语音文件id，可以调用上传临时素材接口获取
+		// 语音文件 id，可以调用上传临时素材接口获取
 		MediaID string `json:"media_id"`
 	}
 )
@@ -65,7 +65,7 @@ type (
 // Send 发送应用消息
 // @desc 实现企业微信发送应用消息接口：https://developer.work.weixin.qq.com/document/path/90248
 func (r *Client) Send(apiName string, request interface{}) (*SendResponse, error) {
-	// 获取accessToken
+	// 获取 accessToken
 	accessToken, err := r.GetAccessToken()
 	if err != nil {
 		return nil, err
@@ -75,7 +75,7 @@ func (r *Client) Send(apiName string, request interface{}) (*SendResponse, error
 	if err != nil {
 		return nil, err
 	}
-	// 发起http请求
+	// 发起 http 请求
 	response, err := util.HTTPPost(fmt.Sprintf(sendURL, accessToken), string(jsonData))
 	if err != nil {
 		return nil, err
@@ -89,25 +89,25 @@ func (r *Client) Send(apiName string, request interface{}) (*SendResponse, error
 
 // SendText 发送文本消息
 func (r *Client) SendText(request SendTextRequest) (*SendResponse, error) {
-	// 发送文本消息MsgType参数固定为：text
+	// 发送文本消息 MsgType 参数固定为：text
 	request.MsgType = "text"
 	return r.Send("MessageSendText", request)
 }
 
 // SendImage 发送图片消息
 func (r *Client) SendImage(request SendImageRequest) (*SendResponse, error) {
-	// 发送图片消息MsgType参数固定为：image
+	// 发送图片消息 MsgType 参数固定为：image
 	request.MsgType = "image"
 	return r.Send("MessageSendImage", request)
 }
 
 // SendVoice 发送语音消息
 func (r *Client) SendVoice(request SendVoiceRequest) (*SendResponse, error) {
-	// 发送语音消息MsgType参数固定为：voice
+	// 发送语音消息 MsgType 参数固定为：voice
 	request.MsgType = "voice"
 	return r.Send("MessageSendVoice", request)
 }
 
 // 以上实现了部分常用消息推送：SendText 发送文本消息、SendImage 发送图片消息、SendVoice 发送语音消息，
 // 如需扩展其他消息类型，建议按照以上格式，扩展对应消息类型的参数即可
-// 也可以直接使用Send方法，按照企业微信消息推送的接口文档传对应消息类型的参数来使用
+// 也可以直接使用 Send 方法，按照企业微信消息推送的接口文档传对应消息类型的参数来使用

work/appchat/client.go

@@ -1,4 +1,4 @@
-// Package appchat 应用发送消息到群聊会话,企业微信接口：https://developer.work.weixin.qq.com/document/path/90248
+// Package appchat 应用发送消息到群聊会话，企业微信接口：https://developer.work.weixin.qq.com/document/path/90248
 package appchat
 
 import (

work/checkin/checkin.go

@@ -217,7 +217,7 @@ type OptionGroupSpeOffDays struct {
 	EndTime   int64  `json:"endtime"`
 }
 
-// OptionGroupWifiMacInfos WIFI信息
+// OptionGroupWifiMacInfos WIFI 信息
 type OptionGroupWifiMacInfos struct {
 	WifiName string `json:"wifiname"`
 	WifiMac  string `json:"wifimac"`

work/checkin/record.go

@@ -19,7 +19,7 @@ const (
 	getOptionURL = "https://qyapi.weixin.qq.com/cgi-bin/checkin/getcheckinoption?access_token=%s"
 	// getScheduleListURL 获取打卡人员排班信息
 	getScheduleListURL = "https://qyapi.weixin.qq.com/cgi-bin/checkin/getcheckinschedulist?access_token=%s"
-	// getHardwareDataURL获取设备打卡数据
+	// getHardwareDataURL 获取设备打卡数据
 	getHardwareDataURL = "https://qyapi.weixin.qq.com/cgi-bin/hardware/get_hardware_checkin_data?access_token=%s"
 )
 
@@ -138,17 +138,17 @@ type (
 		SpDescription SpDescription `json:"sp_description"`
 	}
 
-	// SpTitle 假勤信息摘要-标题信息
+	// SpTitle 假勤信息摘要 - 标题信息
 	SpTitle struct {
 		Data []SpData `json:"data"`
 	}
 
-	// SpDescription 假勤信息摘要-描述信息
+	// SpDescription 假勤信息摘要 - 描述信息
 	SpDescription struct {
 		Data []SpData `json:"data"`
 	}
 
-	// SpData 假勤信息(多种语言描述，目前只有中文一种)
+	// SpData 假勤信息 (多种语言描述，目前只有中文一种)
 	SpData struct {
 		Lang string `json:"lang"`
 		Text string `json:"text"`
@@ -324,26 +324,26 @@ type GroupCheckinTime struct {
 	RemindOffWorkSec int64 `json:"remind_off_work_sec"`
 }
 
-// SpeWorkdays 特殊日期-必须打卡日期信息
+// SpeWorkdays 特殊日期 - 必须打卡日期信息
 type SpeWorkdays struct {
 	Timestamp   int64              `json:"timestamp"`
 	Notes       string             `json:"notes"`
 	CheckinTime []GroupCheckinTime `json:"checkintime"`
 }
 
-// SpeOffDays 特殊日期-不用打卡日期信息
+// SpeOffDays 特殊日期 - 不用打卡日期信息
 type SpeOffDays struct {
 	Timestamp int64  `json:"timestamp"`
 	Notes     string `json:"notes"`
 }
 
-// WifiMacInfos 打卡地点-WiFi打卡信息
+// WifiMacInfos 打卡地点-WiFi 打卡信息
 type WifiMacInfos struct {
 	WifiName string `json:"wifiname"`
 	WifiMac  string `json:"wifimac"`
 }
 
-// LocInfos 打卡地点-位置打卡信息
+// LocInfos 打卡地点 - 位置打卡信息
 type LocInfos struct {
 	Lat       int64  `json:"lat"`
 	Lng       int64  `json:"lng"`
@@ -365,7 +365,7 @@ type ReporterInfo struct {
 	UpdateTime int64       `json:"updatetime"`
 }
 
-// Reporters 汇报对象，每个汇报人用userid表示
+// Reporters 汇报对象，每个汇报人用 userid 表示
 type Reporters struct {
 	UserID string `json:"userid"`
 }
@@ -378,7 +378,7 @@ type GroupOtInfo struct {
 	OtCheckInfo          OtCheckInfo `json:"otcheckinfo"`
 }
 
-// OtCheckInfo 以打卡时间为准-加班时长计算规则信息
+// OtCheckInfo 以打卡时间为准 - 加班时长计算规则信息
 type OtCheckInfo struct {
 	OtWorkingDayTimeStart      int64      `json:"ot_workingday_time_start"`
 	OtWorkingDayTimeMin        int64      `json:"ot_workingday_time_min"`
@@ -390,25 +390,25 @@ type OtCheckInfo struct {
 	OtNonWorkingDayRestInfo    OtRestInfo `json:"ot_nonworkingday_restinfo"`
 }
 
-// OtRestInfo 加班-休息扣除配置信息
+// OtRestInfo 加班 - 休息扣除配置信息
 type OtRestInfo struct {
 	Type          int64         `json:"type"`
 	FixTimeRule   FixTimeRule   `json:"fix_time_rule"`
 	CalOtTimeRule CalOtTimeRule `json:"cal_ottime_rule"`
 }
 
-// FixTimeRule 工作日加班-指定休息时间配置信息
+// FixTimeRule 工作日加班 - 指定休息时间配置信息
 type FixTimeRule struct {
 	FixTimeBeginSec int64 `json:"fix_time_begin_sec"`
 	FixTimeEndSec   int64 `json:"fix_time_end_sec"`
 }
 
-// CalOtTimeRule 工作日加班-按加班时长扣除配置信息
+// CalOtTimeRule 工作日加班 - 按加班时长扣除配置信息
 type CalOtTimeRule struct {
 	Items []CalOtTimeRuleItem `json:"items"`
 }
 
-// CalOtTimeRuleItem 工作日加班-按加班时长扣除条件信息
+// CalOtTimeRuleItem 工作日加班 - 按加班时长扣除条件信息
 type CalOtTimeRuleItem struct {
 	OtTime   int64 `json:"ot_time"`
 	RestTime int64 `json:"rest_time"`

work/config/config.go

@@ -1,4 +1,4 @@
-// Package config 企业微信config配置
+// Package config 企业微信 config 配置
 package config
 
 import (
@@ -8,11 +8,11 @@ import (
 // Config for 企业微信
 type Config struct {
 	CorpID        string `json:"corp_id"`     // corp_id
-	CorpSecret    string `json:"corp_secret"` // corp_secret,如果需要获取会话存档实例，当前参数请填写聊天内容存档的Secret，可以在企业微信管理端--管理工具--聊天内容存档查看
+	CorpSecret    string `json:"corp_secret"` // corp_secret，如果需要获取会话存档实例，当前参数请填写聊天内容存档的 Secret，可以在企业微信管理端--管理工具--聊天内容存档查看
 	AgentID       string `json:"agent_id"`    // agent_id
 	Cache         cache.Cache
 	RasPrivateKey string // 消息加密私钥，可以在企业微信管理端--管理工具--消息加密公钥查看对用公钥，私钥一般由自己保存
 
 	Token          string `json:"token"`            // 微信客服回调配置，用于生成签名校验回调请求的合法性
-	EncodingAESKey string `json:"encoding_aes_key"` // 微信客服回调p配置，用于解密回调消息内容对应的密文
+	EncodingAESKey string `json:"encoding_aes_key"` // 微信客服回调 p 配置，用于解密回调消息内容对应的密文
 }

work/externalcontact/callback.go

@@ -8,8 +8,8 @@ import (
 
 // 原始回调消息内容
 type callbackOriginMessage struct {
-	ToUserName string // 企业微信的CorpID，当为第三方套件回调事件时，CorpID的内容为suiteid
-	AgentID    string // 接收的应用id，可在应用的设置页面获取
+	ToUserName string // 企业微信的 CorpID，当为第三方套件回调事件时，CorpID 的内容为 suiteid
+	AgentID    string // 接收的应用 id，可在应用的设置页面获取
 	Encrypt    string // 消息结构体加密后的字符串
 }
 

work/externalcontact/contact_way.go

@@ -116,7 +116,7 @@ type (
 		util.CommonError
 		ContactWay ContactWay `json:"contact_way"`
 	}
-	// ContactWay 「联系我」配置
+	// ContactWay「联系我」配置
 	ContactWay struct {
 		ConfigID      string              `json:"config_id"`
 		Type          int                 `json:"type"`
@@ -209,7 +209,7 @@ type (
 		ContactWay []*ContactWayForList `json:"contact_way"`
 		NextCursor string               `json:"next_cursor"`
 	}
-	// ContactWayForList 「联系我」配置
+	// ContactWayForList「联系我」配置
 	ContactWayForList struct {
 		ConfigID string `json:"config_id"`
 	}

work/externalcontact/external_user.go

@@ -104,7 +104,7 @@ type WechatChannel struct {
 	Source   int    `json:"source"`
 }
 
-// ExternalProfile 外部联系人的自定义展示信息,可以有多个字段和多种类型，包括文本，网页和小程序
+// ExternalProfile 外部联系人的自定义展示信息，可以有多个字段和多种类型，包括文本，网页和小程序
 type ExternalProfile struct {
 	ExternalCorpName string         `json:"external_corp_name"`
 	WechatChannels   WechatChannels `json:"wechat_channels"`
@@ -276,7 +276,7 @@ type ListCustomerStrategyResponse struct {
 	NextCursor string       `json:"next_cursor"`
 }
 
-// StrategyID 规则组ID
+// StrategyID 规则组 ID
 type StrategyID struct {
 	StrategyID int `json:"strategy_id"`
 }

work/externalcontact/groupchat.go

@@ -6,14 +6,14 @@ import (
 	"github.com/silenceper/wechat/v2/util"
 )
 
-// opengIDToChatIDURL 客户群opengid转换URL
+// opengIDToChatIDURL 客户群 opengid 转换 URL
 const opengIDToChatIDURL = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/opengid_to_chatid"
 
 type (
 	//GroupChatListRequest 获取客户群列表的请求参数
 	GroupChatListRequest struct {
-		StatusFilter int         `json:"status_filter"` // 非必填	客户群跟进状态过滤。0 - 所有列表(即不过滤) 1 - 离职待继承 2 - 离职继承中 3 - 离职继承完成
-		OwnerFilter  OwnerFilter `json:"owner_filter"`  //非必填	群主过滤。如果不填，表示获取应用可见范围内全部群主的数据（但是不建议这么用，如果可见范围人数超过1000人，为了防止数据包过大，会报错 81017）
+		StatusFilter int         `json:"status_filter"` // 非必填	客户群跟进状态过滤。0 - 所有列表 (即不过滤) 1 - 离职待继承 2 - 离职继承中 3 - 离职继承完成
+		OwnerFilter  OwnerFilter `json:"owner_filter"`  //非必填	群主过滤。如果不填，表示获取应用可见范围内全部群主的数据（但是不建议这么用，如果可见范围人数超过 1000 人，为了防止数据包过大，会报错 81017）
 		Cursor       string      `json:"cursor"`        //非必填	用于分页查询的游标，字符串类型，由上一次调用返回，首次调用不填
 		Limit        int         `json:"limit"`         //必填	分页，预期请求的数据量，取值范围 1 ~ 1000
 	}
@@ -56,29 +56,29 @@ type (
 	}
 	//Invitor 邀请者
 	Invitor struct {
-		UserID string `json:"userid"` //邀请者的userid
+		UserID string `json:"userid"` //邀请者的 userid
 	}
 	//GroupChatMember 群成员
 	GroupChatMember struct {
-		UserID        string  `json:"userid"`            //群成员id
-		Type          int     `json:"type"`              //成员类型。 1 - 企业成员  2 - 外部联系人
+		UserID        string  `json:"userid"`            //群成员 id
+		Type          int     `json:"type"`              //成员类型。1 - 企业成员  2 - 外部联系人
 		JoinTime      int     `json:"join_time"`         //入群时间
-		JoinScene     int     `json:"join_scene"`        //入群方式 1 - 由群成员邀请入群（直接邀请入群） 2 - 由群成员邀请入群（通过邀请链接入群） 3 - 通过扫描群二维码入群
+		JoinScene     int     `json:"join_scene"`        //入群方式 1 - 由群成员邀请入群（直接邀请入群）2 - 由群成员邀请入群（通过邀请链接入群）3 - 通过扫描群二维码入群
 		Invitor       Invitor `json:"invitor,omitempty"` //邀请者。目前仅当是由本企业内部成员邀请入群时会返回该值
 		GroupNickname string  `json:"group_nickname"`    //在群里的昵称
 		Name          string  `json:"name"`              //名字。仅当 need_name = 1 时返回 如果是微信用户，则返回其在微信中设置的名字 如果是企业微信联系人，则返回其设置对外展示的别名或实名
-		UnionID       string  `json:"unionid,omitempty"` //外部联系人在微信开放平台的唯一身份标识（微信unionid），通过此字段企业可将外部联系人与公众号/小程序用户关联起来。仅当群成员类型是微信用户（包括企业成员未添加好友），且企业绑定了微信开发者ID有此字段（查看绑定方法）。第三方不可获取，上游企业不可获取下游企业客户的unionid字段
-		State         string  `json:"state,omitempty"`   //如果在配置入群方式时，配置了state参数，那么在获取客户群详情时，通过该方式入群的成员，会额外获取到相应的state参数
+		UnionID       string  `json:"unionid,omitempty"` //外部联系人在微信开放平台的唯一身份标识（微信 unionid），通过此字段企业可将外部联系人与公众号/小程序用户关联起来。仅当群成员类型是微信用户（包括企业成员未添加好友），且企业绑定了微信开发者 ID 有此字段（查看绑定方法）。第三方不可获取，上游企业不可获取下游企业客户的 unionid 字段
+		State         string  `json:"state,omitempty"`   //如果在配置入群方式时，配置了 state 参数，那么在获取客户群详情时，通过该方式入群的成员，会额外获取到相应的 state 参数
 	}
 	//GroupChatAdmin 群管理员
 	GroupChatAdmin struct {
-		UserID string `json:"userid"` //群管理员userid
+		UserID string `json:"userid"` //群管理员 userid
 	}
 	//GroupChat 客户群详情
 	GroupChat struct {
-		ChatID        string            `json:"chat_id"`        //客户群ID
+		ChatID        string            `json:"chat_id"`        //客户群 ID
 		Name          string            `json:"name"`           //群名
-		Owner         string            `json:"owner"`          //群主ID
+		Owner         string            `json:"owner"`          //群主 ID
 		CreateTime    int64             `json:"create_time"`    //群的创建时间
 		Notice        string            `json:"notice"`         //群公告
 		MemberList    []GroupChatMember `json:"member_list"`    //群成员列表
@@ -110,18 +110,18 @@ func (r *Client) GetGroupChatDetail(req *GroupChatDetailRequest) (*GroupChatDeta
 }
 
 type (
-	//OpengIDToChatIDRequest 客户群opengid转换 请求参数
+	//OpengIDToChatIDRequest 客户群 opengid 转换 请求参数
 	OpengIDToChatIDRequest struct {
 		OpengID string `json:"opengid"`
 	}
-	//OpengIDToChatIDResponse 客户群opengid转换 返回值
+	//OpengIDToChatIDResponse 客户群 opengid 转换 返回值
 	OpengIDToChatIDResponse struct {
 		util.CommonError
-		ChatID string `json:"chat_id"` //客户群ID
+		ChatID string `json:"chat_id"` //客户群 ID
 	}
 )
 
-// OpengIDToChatID 客户群opengid转换
+// OpengIDToChatID 客户群 opengid 转换
 // @see https://developer.work.weixin.qq.com/document/path/94828
 func (r *Client) OpengIDToChatID(req *OpengIDToChatIDRequest) (*OpengIDToChatIDResponse, error) {
 	accessToken, err := r.GetAccessToken()

work/externalcontact/join_way.go

@@ -12,13 +12,13 @@ const groupChatURL = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/groupc
 type (
 	// AddJoinWayRequest 添加群配置请求参数
 	AddJoinWayRequest struct {
-		Scene          int      `json:"scene"`            // 必填 1 - 群的小程序插件,2 - 群的二维码插件
-		Remark         string   `json:"remark"`           //非必填	联系方式的备注信息，用于助记，超过30个字符将被截断
-		AutoCreateRoom int      `json:"auto_create_room"` //非必填	当群满了后，是否自动新建群。0-否；1-是。 默认为1
-		RoomBaseName   string   `json:"room_base_name"`   //非必填	自动建群的群名前缀，当auto_create_room为1时有效。最长40个utf8字符
-		RoomBaseID     int      `json:"room_base_id"`     //非必填	自动建群的群起始序号，当auto_create_room为1时有效
-		ChatIDList     []string `json:"chat_id_list"`     //必填	使用该配置的客户群ID列表，支持5个。见客户群ID获取方法
-		State          string   `json:"state"`            //非必填	企业自定义的state参数，用于区分不同的入群渠道。不超过30个UTF-8字符
+		Scene          int      `json:"scene"`            // 必填 1 - 群的小程序插件，2 - 群的二维码插件
+		Remark         string   `json:"remark"`           //非必填	联系方式的备注信息，用于助记，超过 30 个字符将被截断
+		AutoCreateRoom int      `json:"auto_create_room"` //非必填	当群满了后，是否自动新建群。0-否；1-是。默认为 1
+		RoomBaseName   string   `json:"room_base_name"`   //非必填	自动建群的群名前缀，当 auto_create_room 为 1 时有效。最长 40 个 utf8 字符
+		RoomBaseID     int      `json:"room_base_id"`     //非必填	自动建群的群起始序号，当 auto_create_room 为 1 时有效
+		ChatIDList     []string `json:"chat_id_list"`     //必填	使用该配置的客户群 ID 列表，支持 5 个。见客户群 ID 获取方法
+		State          string   `json:"state"`            //非必填	企业自定义的 state 参数，用于区分不同的入群渠道。不超过 30 个 UTF-8 字符
 	}
 
 	// AddJoinWayResponse 添加群配置返回值
@@ -96,13 +96,13 @@ func (r *Client) GetJoinWay(req *JoinWayConfigRequest) (*GetJoinWayResponse, err
 // UpdateJoinWayRequest 更新群配置的请求参数
 type UpdateJoinWayRequest struct {
 	ConfigID       string   `json:"config_id"`
-	Scene          int      `json:"scene"`            // 必填 1 - 群的小程序插件,2 - 群的二维码插件
-	Remark         string   `json:"remark"`           //非必填	联系方式的备注信息，用于助记，超过30个字符将被截断
-	AutoCreateRoom int      `json:"auto_create_room"` //非必填	当群满了后，是否自动新建群。0-否；1-是。 默认为1
-	RoomBaseName   string   `json:"room_base_name"`   //非必填	自动建群的群名前缀，当auto_create_room为1时有效。最长40个utf8字符
-	RoomBaseID     int      `json:"room_base_id"`     //非必填	自动建群的群起始序号，当auto_create_room为1时有效
-	ChatIDList     []string `json:"chat_id_list"`     //必填	使用该配置的客户群ID列表，支持5个。见客户群ID获取方法
-	State          string   `json:"state"`            //非必填	企业自定义的state参数，用于区分不同的入群渠道。不超过30个UTF-8字符
+	Scene          int      `json:"scene"`            // 必填 1 - 群的小程序插件，2 - 群的二维码插件
+	Remark         string   `json:"remark"`           //非必填	联系方式的备注信息，用于助记，超过 30 个字符将被截断
+	AutoCreateRoom int      `json:"auto_create_room"` //非必填	当群满了后，是否自动新建群。0-否；1-是。默认为 1
+	RoomBaseName   string   `json:"room_base_name"`   //非必填	自动建群的群名前缀，当 auto_create_room 为 1 时有效。最长 40 个 utf8 字符
+	RoomBaseID     int      `json:"room_base_id"`     //非必填	自动建群的群起始序号，当 auto_create_room 为 1 时有效
+	ChatIDList     []string `json:"chat_id_list"`     //必填	使用该配置的客户群 ID 列表，支持 5 个。见客户群 ID 获取方法
+	State          string   `json:"state"`            //非必填	企业自定义的 state 参数，用于区分不同的入群渠道。不超过 30 个 UTF-8 字符
 }
 
 // UpdateJoinWay 更新客户群进群方式配置

work/externalcontact/moment.go

@@ -441,7 +441,7 @@ type ListMomentStrategyResponse struct {
 	NextCursor string             `json:"next_cursor"`
 }
 
-// MomentStrategyID 规则组ID
+// MomentStrategyID 规则组 ID
 type MomentStrategyID struct {
 	StrategyID int `json:"strategy_id"`
 }

work/externalcontact/statistic.go

@@ -81,7 +81,7 @@ type (
 		NextOffset int                 `json:"next_offset"`
 		Items      []GroupChatStatItem `json:"items"`
 	}
-	// GroupChatStatItem 群聊数据统计(按群主聚合)条目
+	// GroupChatStatItem 群聊数据统计 (按群主聚合) 条目
 	GroupChatStatItem struct {
 		Owner string                `json:"owner"`
 		Data  GroupChatStatItemData `json:"data"`
@@ -138,7 +138,7 @@ type (
 		util.CommonError
 		Items []GetGroupChatStatByDayItem `json:"items"`
 	}
-	// GetGroupChatStatByDayItem 群聊数据统计(按自然日聚合)条目
+	// GetGroupChatStatByDayItem 群聊数据统计 (按自然日聚合) 条目
 	GetGroupChatStatByDayItem struct {
 		StatTime int                   `json:"stat_time"`
 		Data     GroupChatStatItemData `json:"data"`

work/kf/README.md

@@ -1,3 +1,3 @@
-### 微信客服SDK
+### 微信客服 SDK
 
 相关文档正在梳理中...

work/kf/account.go

@@ -22,14 +22,14 @@ const (
 
 // AccountAddOptions 添加客服账号请求参数
 type AccountAddOptions struct {
-	Name    string `json:"name"`     // 客服帐号名称, 不多于16个字符
-	MediaID string `json:"media_id"` // 客服头像临时素材。可以调用上传临时素材接口获取, 不多于128个字节
+	Name    string `json:"name"`     // 客服帐号名称，不多于 16 个字符
+	MediaID string `json:"media_id"` // 客服头像临时素材。可以调用上传临时素材接口获取，不多于 128 个字节
 }
 
 // AccountAddSchema 添加客服账号响应内容
 type AccountAddSchema struct {
 	util.CommonError
-	OpenKFID string `json:"open_kfid"` // 新创建的客服张号ID
+	OpenKFID string `json:"open_kfid"` // 新创建的客服张号 ID
 }
 
 // AccountAdd 添加客服账号
@@ -55,7 +55,7 @@ func (r *Client) AccountAdd(options AccountAddOptions) (info AccountAddSchema, e
 
 // AccountDelOptions 删除客服账号请求参数
 type AccountDelOptions struct {
-	OpenKFID string `json:"open_kfid"` // 客服帐号ID, 不多于64字节
+	OpenKFID string `json:"open_kfid"` // 客服帐号 ID, 不多于 64 字节
 }
 
 // AccountDel 删除客服账号
@@ -81,9 +81,9 @@ func (r *Client) AccountDel(options AccountDelOptions) (info util.CommonError, e
 
 // AccountUpdateOptions 修改客服账号请求参数
 type AccountUpdateOptions struct {
-	OpenKFID string `json:"open_kfid"` // 客服帐号ID, 不多于64字节
-	Name     string `json:"name"`      // 客服帐号名称, 不多于16个字符
-	MediaID  string `json:"media_id"`  // 客服头像临时素材。可以调用上传临时素材接口获取, 不多于128个字节
+	OpenKFID string `json:"open_kfid"` // 客服帐号 ID, 不多于 64 字节
+	Name     string `json:"name"`      // 客服帐号名称，不多于 16 个字符
+	MediaID  string `json:"media_id"`  // 客服头像临时素材。可以调用上传临时素材接口获取，不多于 128 个字节
 }
 
 // AccountUpdate 修复客服账号
@@ -109,9 +109,9 @@ func (r *Client) AccountUpdate(options AccountUpdateOptions) (info util.CommonEr
 
 // AccountInfoSchema 客服详情
 type AccountInfoSchema struct {
-	OpenKFID string `json:"open_kfid"` // 客服帐号ID
+	OpenKFID string `json:"open_kfid"` // 客服帐号 ID
 	Name     string `json:"name"`      // 客服帐号名称
-	Avatar   string `json:"avatar"`    // 客服头像URL
+	Avatar   string `json:"avatar"`    // 客服头像 URL
 }
 
 // AccountListSchema 获取客服账号列表响应内容
@@ -142,19 +142,19 @@ func (r *Client) AccountList() (info AccountListSchema, err error) {
 }
 
 // AddContactWayOptions 获取客服账号链接
-// 1.若scene非空，返回的客服链接开发者可拼接scene_param=SCENE_PARAM参数使用，用户进入会话事件会将SCENE_PARAM原样返回。其中SCENE_PARAM需要urlencode，且长度不能超过128字节。
+// 1.若 scene 非空，返回的客服链接开发者可拼接 scene_param=SCENE_PARAM 参数使用，用户进入会话事件会将 SCENE_PARAM 原样返回。其中 SCENE_PARAM 需要 urlencode，且长度不能超过 128 字节。
 // 如 https://work.weixin.qq.com/kf/kfcbf8f8d07ac7215f?enc_scene=ENCGFSDF567DF&scene_param=a%3D1%26b%3D2
-// 2.历史调用接口返回的客服链接（包含encScene=XXX参数），不支持scene_param参数。
+// 2.历史调用接口返回的客服链接（包含 encScene=XXX 参数），不支持 scene_param 参数。
 // 3.返回的客服链接，不能修改或复制参数到其他链接使用。否则进入会话事件参数校验不通过，导致无法回调。
 type AddContactWayOptions struct {
-	OpenKFID string `json:"open_kfid"` // 客服帐号ID, 不多于64字节
-	Scene    string `json:"scene"`     // 场景值，字符串类型，由开发者自定义, 不多于32字节, 字符串取值范围(正则表达式)：[0-9a-zA-Z_-]*
+	OpenKFID string `json:"open_kfid"` // 客服帐号 ID, 不多于 64 字节
+	Scene    string `json:"scene"`     // 场景值，字符串类型，由开发者自定义，不多于 32 字节，字符串取值范围 (正则表达式)：[0-9a-zA-Z_-]*
 }
 
 // AddContactWaySchema 获取客服账号链接响应内容
 type AddContactWaySchema struct {
 	util.CommonError
-	URL string `json:"url"` // 客服链接，开发者可将该链接嵌入到H5页面中，用户点击链接即可向对应的微信客服帐号发起咨询。开发者也可根据该url自行生成需要的二维码图片
+	URL string `json:"url"` // 客服链接，开发者可将该链接嵌入到 H5 页面中，用户点击链接即可向对应的微信客服帐号发起咨询。开发者也可根据该 url 自行生成需要的二维码图片
 }
 
 // AddContactWay 获取客服账号链接

work/kf/callback.go

@@ -16,14 +16,14 @@ type SignatureOptions struct {
 
 // VerifyURL 验证请求参数是否合法并返回解密后的消息内容
 //
-//	 //Gin框架的使用示例
+//	 //Gin 框架的使用示例
 //		r.GET("/v1/event/callback", func(c *gin.Context) {
 //			options := kf.SignatureOptions{}
 //			//获取回调的的校验参数
 //			if = c.ShouldBindQuery(&options); err != nil {
 //				c.String(http.StatusUnauthorized, "参数解析失败")
 //			}
-//			// 调用VerifyURL方法校验当前请求，如果合法则把解密后的内容作为响应返回给微信服务器
+//			// 调用 VerifyURL 方法校验当前请求，如果合法则把解密后的内容作为响应返回给微信服务器
 //			echo, err := kfClient.VerifyURL(options)
 //			if err == nil {
 //				c.String(http.StatusOK, echo)
@@ -45,24 +45,24 @@ func (r *Client) VerifyURL(options SignatureOptions) (string, error) {
 
 // 原始回调消息内容
 type callbackOriginMessage struct {
-	ToUserName string // 企业微信的CorpID，当为第三方套件回调事件时，CorpID的内容为suiteid
-	AgentID    string // 接收的应用id，可在应用的设置页面获取
+	ToUserName string // 企业微信的 CorpID，当为第三方套件回调事件时，CorpID 的内容为 suiteid
+	AgentID    string // 接收的应用 id，可在应用的设置页面获取
 	Encrypt    string // 消息结构体加密后的字符串
 }
 
 // CallbackMessage 微信客服回调消息
 type CallbackMessage struct {
-	ToUserName string `json:"to_user_name" xml:"ToUserName"` // 微信客服组件ID
-	CreateTime int64  `json:"create_time" xml:"CreateTime"`  // 消息创建时间，unix时间戳
+	ToUserName string `json:"to_user_name" xml:"ToUserName"` // 微信客服组件 ID
+	CreateTime int64  `json:"create_time" xml:"CreateTime"`  // 消息创建时间，unix 时间戳
 	MsgType    string `json:"msgtype" xml:"MsgType"`         // 消息的类型，此时固定为 event
 	Event      string `json:"event" xml:"Event"`             // 事件的类型，此时固定为 kf_msg_or_event
-	Token      string `json:"token" xml:"Token"`             // 调用拉取消息接口时，需要传此token，用于校验请求的合法性
-	OpenKfID   string `json:"open_kfid" xml:"OpenKfId"`      // 有新消息的客服帐号。可通过sync_msg接口指定open_kfid获取此客服帐号的消息
+	Token      string `json:"token" xml:"Token"`             // 调用拉取消息接口时，需要传此 token，用于校验请求的合法性
+	OpenKfID   string `json:"open_kfid" xml:"OpenKfId"`      // 有新消息的客服帐号。可通过 sync_msg 接口指定 open_kfid 获取此客服帐号的消息
 }
 
 // GetCallbackMessage 获取回调事件中的消息内容
 //
-//	 //Gin框架的使用示例
+//	 //Gin 框架的使用示例
 //		r.POST("/v1/event/callback", func(c *gin.Context) {
 //			var (
 //				message kf.CallbackMessage

work/kf/client.go

@@ -9,10 +9,10 @@ import (
 
 // Client 微信客服实例
 type Client struct {
-	corpID         string // 企业ID：企业开通的每个微信客服，都对应唯一的企业ID，企业可在微信客服管理后台的企业信息处查看
-	secret         string // Secret是微信客服用于校验开发者身份的访问密钥，企业成功注册微信客服后，可在「微信客服管理后台-开发配置」处获取
+	corpID         string // 企业 ID：企业开通的每个微信客服，都对应唯一的企业 ID，企业可在微信客服管理后台的企业信息处查看
+	secret         string // Secret 是微信客服用于校验开发者身份的访问密钥，企业成功注册微信客服后，可在「微信客服管理后台 - 开发配置」处获取
 	token          string // 用于生成签名校验回调请求的合法性
-	encodingAESKey string // 回调消息加解密参数是AES密钥的Base64编码，用于解密回调消息内容对应的密文
+	encodingAESKey string // 回调消息加解密参数是 AES 密钥的 Base64 编码，用于解密回调消息内容对应的密文
 	cache          cache.Cache
 	ctx            *context.Context
 }

work/kf/customer.go

@@ -13,23 +13,23 @@ const (
 
 // CustomerBatchGetOptions 客户基本信息获取请求参数
 type CustomerBatchGetOptions struct {
-	ExternalUserIDList []string `json:"external_userid_list"` // external_userid列表
+	ExternalUserIDList []string `json:"external_userid_list"` // external_userid 列表
 }
 
 // CustomerSchema 微信客户基本资料
 type CustomerSchema struct {
-	ExternalUserID string `json:"external_userid"` // 微信客户的external_userid
+	ExternalUserID string `json:"external_userid"` // 微信客户的 external_userid
 	NickName       string `json:"nickname"`        // 微信昵称
 	Avatar         string `json:"avatar"`          // 微信头像。第三方不可获取
 	Gender         int    `json:"gender"`          // 性别
-	UnionID        string `json:"unionid"`         // unionid，需要绑定微信开发者帐号才能获取到，查看绑定方法: https://open.work.weixin.qq.com/kf/doc/92512/93143/94769#%E5%A6%82%E4%BD%95%E8%8E%B7%E5%8F%96%E5%BE%AE%E4%BF%A1%E5%AE%A2%E6%88%B7%E7%9A%84unionid
+	UnionID        string `json:"unionid"`         // unionid，需要绑定微信开发者帐号才能获取到，查看绑定方法：https://open.work.weixin.qq.com/kf/doc/92512/93143/94769#%E5%A6%82%E4%BD%95%E8%8E%B7%E5%8F%96%E5%BE%AE%E4%BF%A1%E5%AE%A2%E6%88%B7%E7%9A%84unionid
 }
 
 // CustomerBatchGetSchema 获取客户基本信息响应内容
 type CustomerBatchGetSchema struct {
 	util.CommonError
 	CustomerList          []CustomerSchema `json:"customer_list"`           // 微信客户信息列表
-	InvalidExternalUserID []string         `json:"invalid_external_userid"` // 无效的微信客户ID
+	InvalidExternalUserID []string         `json:"invalid_external_userid"` // 无效的微信客户 ID
 }
 
 // CustomerBatchGet 客户基本信息获取

work/kf/error.go

@@ -10,13 +10,13 @@ type Error string
 
 const (
 	// SDKInitFailed 错误码：50001
-	SDKInitFailed Error = "SDK初始化失败"
+	SDKInitFailed Error = "SDK 初始化失败"
 	// SDKCacheUnavailable 错误码：50002
 	SDKCacheUnavailable Error = "缓存无效"
 	// SDKUnknownError 错误码：50003
 	SDKUnknownError Error = "未知错误"
 	// SDKInvalidCredential 错误码：40001
-	SDKInvalidCredential Error = "不合法的secret参数"
+	SDKInvalidCredential Error = "不合法的 secret 参数"
 	// SDKInvalidImageSize 错误码：40009
 	SDKInvalidImageSize Error = "无效的图片大小"
 	// SDKInvalidCorpID 错误码：40013
@@ -28,11 +28,11 @@ const (
 	// SDKDecryptMSGFailed 错误码：40016
 	SDKDecryptMSGFailed Error = "消息解密失败"
 	// SDKMediaIDExceedMinLength 错误码：40058
-	SDKMediaIDExceedMinLength Error = "不合法的参数, 请参照具体 API 接口说明进行传参"
+	SDKMediaIDExceedMinLength Error = "不合法的参数，请参照具体 API 接口说明进行传参"
 	// SDKContentContainsSensitiveInformation 错误码：40201
 	SDKContentContainsSensitiveInformation Error = "当前客服账号由于涉及敏感信息，已被封禁，请联系企业微信客服处理"
 	// SDKAccessTokenMissing 错误码：41001
-	SDKAccessTokenMissing Error = "缺少AccessToken参数"
+	SDKAccessTokenMissing Error = "缺少 AccessToken 参数"
 	// SDKAccessTokenExpired 错误码：42001
 	SDKAccessTokenExpired Error = "AccessToken 已过期"
 	// SDKApiFreqOutOfLimit 错误码：45009
@@ -79,7 +79,7 @@ var codeDic = map[int64]error{
 	95017: SDKApiNotOpen,
 }
 
-// NewSDKErr 初始化SDK实例错误信息
+// NewSDKErr 初始化 SDK 实例错误信息
 func NewSDKErr(code int64, msgList ...string) error {
 	if err := codeDic[code]; err != nil {
 		return err

work/kf/other.go

@@ -15,14 +15,14 @@ const (
 // CorpQualificationSchema 获取视频号绑定状态响应内容
 type CorpQualificationSchema struct {
 	util.CommonError
-	WechatChannelsBinding bool `json:"wechat_channels_binding"` // 	当企业具有绑定成功的视频号时，返回true，否则返回false。 1. 企业申请绑定视频号且由视频号管理员确认后，才为绑定成功状态 2. 至少有一个绑定成功的视频号就会返回true
+	WechatChannelsBinding bool `json:"wechat_channels_binding"` // 	当企业具有绑定成功的视频号时，返回 true，否则返回 false。1. 企业申请绑定视频号且由视频号管理员确认后，才为绑定成功状态 2. 至少有一个绑定成功的视频号就会返回 true
 }
 
 // GetCorpQualification 获取视频号绑定状态
 // 微信客服可接待的客户数，和企业是否已完成主体验证、是否绑定视频号相关。
 //
-// 企业未完成主体验证时，微信客服仅可累计接待100位客户
-// 企业已验证但未绑定视频号时，微信客服仅可累计接待10000位客户
+// 企业未完成主体验证时，微信客服仅可累计接待 100 位客户
+// 企业已验证但未绑定视频号时，微信客服仅可累计接待 10000 位客户
 // 企业已验证且已绑定视频号时，微信客服可接待的客户数不受限制
 //
 // 开发者可获取状态后，在应用等地方提示企业去完成主体验证或绑定视频号。

work/kf/sendmsg.go

@@ -15,17 +15,17 @@ const (
 // SendMsgSchema 发送消息响应内容
 type SendMsgSchema struct {
 	util.CommonError
-	MsgID string `json:"msgid"` // 消息ID。如果请求参数指定了msgid，则原样返回，否则系统自动生成并返回。不多于32字节, 字符串取值范围(正则表达式)：[0-9a-zA-Z_-]*
+	MsgID string `json:"msgid"` // 消息 ID。如果请求参数指定了 msgid，则原样返回，否则系统自动生成并返回。不多于 32 字节，字符串取值范围 (正则表达式)：[0-9a-zA-Z_-]*
 }
 
 // SendMsg 发送消息
 // 当微信客户处于“新接入待处理”或“由智能助手接待”状态下，可调用该接口给用户发送消息。
-// 注意仅当微信客户在主动发送消息给客服后的48小时内，企业可发送消息给客户，最多可发送5条消息；若用户继续发送消息，企业可再次下发消息。
+// 注意仅当微信客户在主动发送消息给客服后的 48 小时内，企业可发送消息给客户，最多可发送 5 条消息；若用户继续发送消息，企业可再次下发消息。
 // 支持发送消息类型：文本、图片、语音、视频、文件、图文、小程序、菜单消息、地理位置。
 // 目前该接口允许下发消息条数和下发时限如下：
 //
 // 用户动作	允许下发条数限制	下发时限
-// 用户发送消息	5条	48 小时
+// 用户发送消息	5 条	48 小时
 func (r *Client) SendMsg(options interface{}) (info SendMsgSchema, err error) {
 	var (
 		accessToken string

work/kf/sendmsg/message.go

@@ -2,9 +2,9 @@ package sendmsg
 
 // Message 发送消息
 type Message struct {
-	ToUser   string `json:"touser"`          // 指定接收消息的客户UserID
-	OpenKFID string `json:"open_kfid"`       // 指定发送消息的客服帐号ID
-	MsgID    string `json:"msgid,omitempty"` // 指定消息ID
+	ToUser   string `json:"touser"`          // 指定接收消息的客户 UserID
+	OpenKFID string `json:"open_kfid"`       // 指定发送消息的客服帐号 ID
+	MsgID    string `json:"msgid,omitempty"` // 指定消息 ID
 }
 
 // Text 发送文本消息
@@ -12,7 +12,7 @@ type Text struct {
 	Message
 	MsgType string `json:"msgtype"` // 消息类型，此时固定为：text
 	Text    struct {
-		Content string `json:"content"` // 消息内容，最长不超过2048个字节
+		Content string `json:"content"` // 消息内容，最长不超过 2048 个字节
 	} `json:"text"` // 文本消息
 }
 
@@ -21,7 +21,7 @@ type Image struct {
 	Message
 	MsgType string `json:"msgtype"` // 消息类型，此时固定为：image
 	Image   struct {
-		MediaID string `json:"media_id"` // 图片文件id，可以调用上传临时素材接口获取
+		MediaID string `json:"media_id"` // 图片文件 id，可以调用上传临时素材接口获取
 	} `json:"image"` // 图片消息
 }
 
@@ -30,7 +30,7 @@ type Voice struct {
 	Message
 	MsgType string `json:"msgtype"` // 消息类型，此时固定为：voice
 	Voice   struct {
-		MediaID string `json:"media_id"` // 语音文件id，可以调用上传临时素材接口获取
+		MediaID string `json:"media_id"` // 语音文件 id，可以调用上传临时素材接口获取
 	} `json:"voice"` // 语音消息
 }
 
@@ -39,7 +39,7 @@ type Video struct {
 	Message
 	MsgType string `json:"msgtype"` // 消息类型，此时固定为：video
 	Video   struct {
-		MediaID string `json:"media_id"` // 视频文件id，可以调用上传临时素材接口获取
+		MediaID string `json:"media_id"` // 视频文件 id，可以调用上传临时素材接口获取
 	} `json:"video"` // 视频消息
 }
 
@@ -48,7 +48,7 @@ type File struct {
 	Message
 	MsgType string `json:"msgtype"` // 消息类型，此时固定为：file
 	File    struct {
-		MediaID string `json:"media_id"` // 文件id，可以调用上传临时素材接口获取
+		MediaID string `json:"media_id"` // 文件 id，可以调用上传临时素材接口获取
 	} `json:"file"` // 文件消息
 }
 
@@ -57,10 +57,10 @@ type Link struct {
 	Message
 	MsgType string `json:"msgtype"` // 消息类型，此时固定为：link
 	Link    struct {
-		Title        string `json:"title"`          // 标题，不超过128个字节，超过会自动截断
-		Desc         string `json:"desc"`           // 描述，不超过512个字节，超过会自动截断
-		URL          string `json:"url"`            // 点击后跳转的链接。 最长2048字节，请确保包含了协议头(http/https)
-		ThumbMediaID string `json:"thumb_media_id"` // 缩略图的media_id, 可以通过素材管理接口获得。此处thumb_media_id即上传接口返回的media_id
+		Title        string `json:"title"`          // 标题，不超过 128 个字节，超过会自动截断
+		Desc         string `json:"desc"`           // 描述，不超过 512 个字节，超过会自动截断
+		URL          string `json:"url"`            // 点击后跳转的链接。最长 2048 字节，请确保包含了协议头 (http/https)
+		ThumbMediaID string `json:"thumb_media_id"` // 缩略图的 media_id, 可以通过素材管理接口获得。此处 thumb_media_id 即上传接口返回的 media_id
 	} `json:"link"` // 链接消息
 }
 
@@ -69,9 +69,9 @@ type MiniProgram struct {
 	Message
 	MsgType     string `json:"msgtype"` // 消息类型，此时固定为：miniprogram
 	MiniProgram struct {
-		AppID        string `json:"appid"`          // 小程序appid，必须是关联到企业的小程序应用
-		Title        string `json:"title"`          // 小程序消息标题，最多64个字节，超过会自动截断
-		ThumbMediaID string `json:"thumb_media_id"` // 小程序消息封面的mediaid，封面图建议尺寸为520*416
+		AppID        string `json:"appid"`          // 小程序 appid，必须是关联到企业的小程序应用
+		Title        string `json:"title"`          // 小程序消息标题，最多 64 个字节，超过会自动截断
+		ThumbMediaID string `json:"thumb_media_id"` // 小程序消息封面的 mediaid，封面图建议尺寸为 520*416
 		PagePath     string `json:"pagepath"`       // 点击消息卡片后进入的小程序页面路径
 	} `json:"miniprogram"` // 小程序消息
 }
@@ -81,37 +81,37 @@ type Menu struct {
 	Message
 	MsgType string `json:"msgtype"` // 消息类型，此时固定为：msgmenu
 	MsgMenu struct {
-		HeadContent string        `json:"head_content"` // 消息内容，不多于1024字节
-		List        []interface{} `json:"list"`         // 菜单项配置，不能多余10个
-		TailContent string        `json:"tail_content"` // 结束文本, 不多于1024字
+		HeadContent string        `json:"head_content"` // 消息内容，不多于 1024 字节
+		List        []interface{} `json:"list"`         // 菜单项配置，不能多余 10 个
+		TailContent string        `json:"tail_content"` // 结束文本，不多于 1024 字
 	} `json:"msgmenu"`
 }
 
 // MenuClick 回复菜单
 type MenuClick struct {
-	Type  string `json:"type"` // 菜单类型: click 回复菜单
+	Type  string `json:"type"` // 菜单类型：click 回复菜单
 	Click struct {
-		ID      string `json:"id"`      // 菜单ID, 不少于1字节, 不多于64字节
-		Content string `json:"content"` // 菜单显示内容, 不少于1字节, 不多于128字节
+		ID      string `json:"id"`      // 菜单 ID, 不少于 1 字节，不多于 64 字节
+		Content string `json:"content"` // 菜单显示内容，不少于 1 字节，不多于 128 字节
 	} `json:"click"`
 }
 
 // MenuView 超链接菜单
 type MenuView struct {
-	Type string `json:"type"` // 菜单类型: view 超链接菜单
+	Type string `json:"type"` // 菜单类型：view 超链接菜单
 	View struct {
-		URL     string `json:"url"`     // 点击后跳转的链接, 不少于1字节, 不多于2048字节
-		Content string `json:"content"` // 菜单显示内容, 不少于1字节, 不多于1024字节
+		URL     string `json:"url"`     // 点击后跳转的链接，不少于 1 字节，不多于 2048 字节
+		Content string `json:"content"` // 菜单显示内容，不少于 1 字节，不多于 1024 字节
 	} `json:"view"`
 }
 
 // MenuMiniProgram 小程序菜单
 type MenuMiniProgram struct {
-	Type        string `json:"type"` // 菜单类型: miniprogram 小程序菜单
+	Type        string `json:"type"` // 菜单类型：miniprogram 小程序菜单
 	MiniProgram struct {
-		AppID    string `json:"appid"`    // 小程序appid, 不少于1字节, 不多于32字节
-		PagePath string `json:"pagepath"` // 点击后进入的小程序页面, 不少于1字节, 不多于1024字节
-		Content  string `json:"content"`  // 菜单显示内容, 不少于1字节, 不多于1024字节
+		AppID    string `json:"appid"`    // 小程序 appid, 不少于 1 字节，不多于 32 字节
+		PagePath string `json:"pagepath"` // 点击后进入的小程序页面，不少于 1 字节，不多于 1024 字节
+		Content  string `json:"content"`  // 菜单显示内容，不少于 1 字节，不多于 1024 字节
 	} `json:"miniprogram"`
 }
 
@@ -120,8 +120,8 @@ type Location struct {
 	Message
 	MsgType  string `json:"msgtype"` // 消息类型，此时固定为：location
 	Location struct {
-		Latitude  float32 `json:"latitude"`  // 纬度, 浮点数，范围为90 ~ -90
-		Longitude float32 `json:"longitude"` // 经度, 浮点数，范围为180 ~ -180
+		Latitude  float32 `json:"latitude"`  // 纬度，浮点数，范围为 90 ~ -90
+		Longitude float32 `json:"longitude"` // 经度，浮点数，范围为 180 ~ -180
 		Name      string  `json:"name"`      // 位置名
 		Address   string  `json:"address"`   // 地址详情说明
 	} `json:"location"`