feat: 支持Redis作为Cache的时候使用TLS (#834)

* feat: 支持Redis作为Cache的时候使用TLS

* feat: fix lint

* fix lint

* Update redis.go

cache/redis.go

@@ -2,6 +2,8 @@ package cache
 
 import (
 	"context"
+	"crypto/tls"
+	"net"
 	"time"
 
 	"github.com/go-redis/redis/v8"
@@ -15,25 +17,38 @@ type Redis struct {
 
 // RedisOpts redis 连接属性
 type RedisOpts struct {
-	Host        string `yml:"host" json:"host"`
+	Host        string `json:"host"         yml:"host"`
-	Username    string `yaml:"username" json:"username"`
+	Username    string `json:"username"                        yaml:"username"`
-	Password    string `yml:"password" json:"password"`
+	Password    string `json:"password"     yml:"password"`
-	Database    int    `yml:"database" json:"database"`
+	Database    int    `json:"database"     yml:"database"`
-	MaxIdle     int    `yml:"max_idle" json:"max_idle"`
+	MaxIdle     int    `json:"max_idle"     yml:"max_idle"`
-	MaxActive   int    `yml:"max_active" json:"max_active"`
+	MaxActive   int    `json:"max_active"   yml:"max_active"`
-	IdleTimeout int    `yml:"idle_timeout" json:"idle_timeout"` // second
+	IdleTimeout int    `json:"idle_timeout" yml:"idle_timeout"` // second
+	UseTLS      bool   `json:"use_tls"      yml:"use_tls"`      // 是否使用TLS
 }
 
 // NewRedis 实例化
 func NewRedis(ctx context.Context, opts *RedisOpts) *Redis {
-	conn := redis.NewUniversalClient(&redis.UniversalOptions{
+	uniOpt := &redis.UniversalOptions{
 		Addrs:        []string{opts.Host},
 		DB:           opts.Database,
 		Username:     opts.Username,
 		Password:     opts.Password,
 		IdleTimeout:  time.Second * time.Duration(opts.IdleTimeout),
 		MinIdleConns: opts.MaxIdle,
-	})
+	}
+
+	if opts.UseTLS {
+		h, _, err := net.SplitHostPort(opts.Host)
+		if err != nil {
+			h = opts.Host
+		}
+		uniOpt.TLSConfig = &tls.Config{
+			ServerName: h,
+		}
+	}
+
+	conn := redis.NewUniversalClient(uniOpt)
 	return &Redis{ctx: ctx, conn: conn}
 }
 

miniprogram/urllink/query.go

@@ -6,7 +6,13 @@ import (
 	"github.com/silenceper/wechat/v2/util"
 )
 
-const queryURL = "https://api.weixin.qq.com/wxa/query_urllink"
+const queryURL = "https://api.weixin.qq.com/wxa/query_urllink?access_token=%s"
+
+// ULQueryRequest 查询加密URLLink请求
+type ULQueryRequest struct {
+	URLLink   string `json:"url_link"`
+	QueryType int    `json:"query_type"`
+}
 
 // ULQueryResult 返回的结果
 // https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-link/urllink.query.html 返回值
@@ -28,25 +34,35 @@ type ULQueryResult struct {
 			ResourceAppid string `json:"resource_appid"`
 		} `json:"cloud_base"`
 	} `json:"url_link_info"`
-	VisitOpenid string `json:"visit_openid"`
+	VisitOpenid string    `json:"visit_openid"`
+	QuotaInfo   QuotaInfo `json:"quota_info"`
+}
+
+// QuotaInfo quota 配置
+type QuotaInfo struct {
+	RemainVisitQuota int64 `json:"remain_visit_quota"`
 }
 
 // Query 查询小程序 url_link 配置。
 func (u *URLLink) Query(urlLink string) (*ULQueryResult, error) {
-	accessToken, err := u.GetAccessToken()
+	return u.QueryWithType(&ULQueryRequest{URLLink: urlLink})
-	if err != nil {
+}
-		return nil, err
+
-	}
+// QueryWithType 查询加密URLLink
-
+// see https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/qrcode-link/url-link/queryUrlLink.html
-	uri := fmt.Sprintf("%s?access_token=%s", queryURL, accessToken)
+func (u *URLLink) QueryWithType(req *ULQueryRequest) (*ULQueryResult, error) {
-	response, err := util.PostJSON(uri, map[string]string{"url_link": urlLink})
+	var (
-	if err != nil {
+		accessToken string
-		return nil, err
+		err         error
-	}
+	)
-	var resp ULQueryResult
+	if accessToken, err = u.GetAccessToken(); err != nil {
-	err = util.DecodeWithError(response, &resp, "URLLink.Query")
+		return nil, err
-	if err != nil {
+	}
-		return nil, err
+	var response []byte
-	}
+	if response, err = util.PostJSON(fmt.Sprintf(queryURL, accessToken), req); err != nil {
-	return &resp, nil
+		return nil, err
+	}
+	result := &ULQueryResult{}
+	err = util.DecodeWithError(response, result, "URLLink.Query")
+	return result, err
 }

miniprogram/urlscheme/query.go

@@ -14,7 +14,8 @@ const (
 // https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.query.html#参数
 type QueryScheme struct {
 	// 小程序 scheme 码
-	Scheme string `json:"scheme"`
+	Scheme    string `json:"scheme"`
+	QueryType int    `json:"query_type"`
 }
 
 // SchemeInfo scheme 配置
@@ -33,34 +34,47 @@ type SchemeInfo struct {
 	EnvVersion EnvVersion `json:"env_version"`
 }
 
-// resQueryScheme 返回结构体
+// QuotaInfo quota 配置
+type QuotaInfo struct {
+	RemainVisitQuota int64 `json:"remain_visit_quota"`
+}
+
+// ResQueryScheme 返回结构体
 // https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.query.html#参数
-type resQueryScheme struct {
+type ResQueryScheme struct {
 	// 通用错误
 	util.CommonError
 	// scheme 配置
 	SchemeInfo SchemeInfo `json:"scheme_info"`
 	// 访问该链接的openid，没有用户访问过则为空字符串
-	VisitOpenid string `json:"visit_openid"`
+	VisitOpenid string    `json:"visit_openid"`
+	QuotaInfo   QuotaInfo `json:"quota_info"`
 }
 
 // QueryScheme 查询小程序 scheme 码
 func (u *URLScheme) QueryScheme(querySchemeParams QueryScheme) (schemeInfo SchemeInfo, visitOpenid string, err error) {
-	var accessToken string
+	res, err := u.QuerySchemeWithRes(querySchemeParams)
-	accessToken, err = u.GetAccessToken()
 	if err != nil {
 		return
 	}
-
-	urlStr := fmt.Sprintf(querySchemeURL, accessToken)
-	var response []byte
-	response, err = util.PostJSON(urlStr, querySchemeParams)
-	if err != nil {
-		return
-	}
-
-	// 使用通用方法返回错误
-	var res resQueryScheme
-	err = util.DecodeWithError(response, &res, "QueryScheme")
 	return res.SchemeInfo, res.VisitOpenid, err
 }
+
+// QuerySchemeWithRes 查询scheme码
+// see https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/qrcode-link/url-scheme/queryScheme.html
+func (u *URLScheme) QuerySchemeWithRes(req QueryScheme) (*ResQueryScheme, error) {
+	var (
+		accessToken string
+		err         error
+	)
+	if accessToken, err = u.GetAccessToken(); err != nil {
+		return nil, err
+	}
+	var response []byte
+	if response, err = util.PostJSON(fmt.Sprintf(querySchemeURL, accessToken), req); err != nil {
+		return nil, err
+	}
+	result := &ResQueryScheme{}
+	err = util.DecodeWithError(response, result, "QueryScheme")
+	return result, err
+}

miniprogram/urlscheme/urlscheme.go

@@ -17,7 +17,12 @@ func NewURLScheme(ctx *context.Context) *URLScheme {
 	return &URLScheme{Context: ctx}
 }
 
-const generateURL = "https://api.weixin.qq.com/wxa/generatescheme"
+const (
+	// generateURL 获取加密scheme码
+	generateURL = "https://api.weixin.qq.com/wxa/generatescheme"
+	// generateNFCURL 获取 NFC 的小程序 scheme
+	generateNFCURL = "https://api.weixin.qq.com/wxa/generatenfcscheme?access_token=%s"
+)
 
 // TExpireType 失效类型 (指定时间戳/指定间隔)
 type TExpireType int
@@ -50,11 +55,13 @@ type JumpWxa struct {
 // USParams 请求参数
 // https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.generate.html#请求参数
 type USParams struct {
-	JumpWxa        *JumpWxa    `json:"jump_wxa"`
+	JumpWxa        *JumpWxa    `json:"jump_wxa,omitempty"`
-	ExpireType     TExpireType `json:"expire_type"`
+	ExpireType     TExpireType `json:"expire_type,omitempty"`
-	ExpireTime     int64       `json:"expire_time"`
+	ExpireTime     int64       `json:"expire_time,omitempty"`
-	ExpireInterval int         `json:"expire_interval"`
+	ExpireInterval int         `json:"expire_interval,omitempty"`
 	IsExpire       bool        `json:"is_expire,omitempty"`
+	ModelID        string      `json:"model_id,omitempty"`
+	Sn             string      `json:"sn,omitempty"`
 }
 
 // USResult 返回的结果
@@ -81,3 +88,22 @@ func (u *URLScheme) Generate(params *USParams) (string, error) {
 	err = util.DecodeWithError(response, &resp, "URLScheme.Generate")
 	return resp.OpenLink, err
 }
+
+// GenerateNFC 获取 NFC 的小程序 scheme
+// see https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/qrcode-link/url-scheme/generateNFCScheme.html
+func (u *URLScheme) GenerateNFC(params *USParams) (string, error) {
+	var (
+		accessToken string
+		err         error
+	)
+	if accessToken, err = u.GetAccessToken(); err != nil {
+		return "", err
+	}
+	var response []byte
+	if response, err = util.PostJSON(fmt.Sprintf(generateNFCURL, accessToken), params); err != nil {
+		return "", err
+	}
+	result := &USResult{}
+	err = util.DecodeWithError(response, result, "URLScheme.GenerateNFC")
+	return result.OpenLink, err
+}