golang/hotime
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 85 Wiki Activity

增加vendor

Browse Source
This commit is contained in:
hoteas
2022-05-24 13:49:25 +08:00
parent c3a24eeb3c
commit 65ece0418e
742 changed files with 509206 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vendor/github.com/silenceper/wechat/v2/.gitignore
Generated
+30
View File
@@ -0,0 +1,30 @@
# Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
*.test
*.prof
.DS_Store
.vscode/
vendor
.idea/
example/*
/test
vendor/github.com/silenceper/wechat/v2/.golangci.yml
Generated Vendored
+61
View File
@@ -0,0 +1,61 @@
linters:
# please, do not use `enable-all`: it's deprecated and will be removed soon.
# inverted configuration with `enable-all` and `disable` is not scalable during updates of golangci-lint
disable-all: true
enable:
- bodyclose
- deadcode
- depguard
- dogsled
- dupl
- errcheck
- funlen
- goconst
# - gocritic
- gocyclo
- gofmt
- goimports
- golint
- goprintffuncname
- gosimple
- govet
- ineffassign
- interfacer
- misspell
- nolintlint
- rowserrcheck
- scopelint
- staticcheck
- structcheck
- stylecheck
- typecheck
- unconvert
- unparam
- unused
- varcheck
- whitespace
issues:
# Excluding configuration per-path, per-linter, per-text and per-source
exclude-rules:
- path: _test\.go
linters:
- gomnd
# https://github.com/go-critic/go-critic/issues/926
- linters:
- gocritic
text: "unnecessaryDefer:"
linters-settings:
funlen:
lines: 66
statements: 40
issues:
include:
- EXC0002 # disable excluding of issues about comments from golint
exclude-rules:
- linters:
- stylecheck
text: "ST1000:"
vendor/github.com/silenceper/wechat/v2/.goreleaser.yml
Generated Vendored
+29
View File
@@ -0,0 +1,29 @@
# This is an example goreleaser.yaml file with some sane defaults.
# Make sure to check the documentation at http://goreleaser.com
before:
hooks:
# You may remove this if you don't use go modules.
- go mod download
# you may remove this if you don't need go generate
- go generate ./...
builds:
- skip: true
archives:
- replacements:
darwin: Darwin
linux: Linux
windows: Windows
386: i386
amd64: x86_64
checksum:
name_template: 'checksums.txt'
snapshot:
name_template: "{{ .Tag }}-next"
changelog:
sort: asc
filters:
exclude:
- '^docs:'
- '^test:'
vendor/github.com/silenceper/wechat/v2/LICENSE
Generated Vendored
+201
View File
@@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
vendor/github.com/silenceper/wechat/v2/README.md
Generated Vendored
+80
View File
@@ -0,0 +1,80 @@
# WeChat SDK for Go
![Go](https://github.com/silenceper/wechat/workflows/Go/badge.svg?branch=release-2.0)
[![Go Report Card](https://goreportcard.com/badge/github.com/silenceper/wechat)](https://goreportcard.com/report/github.com/silenceper/wechat)
[![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版本已废弃
## 文档 && 例子
[API列表](https://github.com/silenceper/wechat/tree/v2/doc/api)
[Wechat SDK 2.0 文档](https://silenceper.com/wechat)
[Wechat SDK 2.0 例子](https://github.com/gowechat/example)
## 快速开始
```
import "github.com/silenceper/wechat/v2"
```
以下是一个微信公众号处理消息接收以及回复的例子：
```go
//使用memcache保存access_token，也可选择redis或自定义cache
wc := wechat.NewWechat()
memory := cache.NewMemory()
cfg := &offConfig.Config{
AppID: "xxx",
AppSecret: "xxx",
Token: "xxx",
//EncodingAESKey: "xxxx",
Cache: memory,
}
officialAccount := wc.GetOfficialAccount(cfg)
// 传入request和responseWriter
server := officialAccount.GetServer(req, rw)
//设置接收消息的处理方法
server.SetMessageHandler(func(msg *message.MixMessage) *message.Reply {
//回复消息：演示回复用户发送的消息
text := message.NewText(msg.Content)
return &message.Reply{MsgType: message.MsgTypeText, MsgData: text}
})
//处理消息接收以及回复
err := server.Serve()
if err != nil {
fmt.Println(err)
return
}
//发送回复的消息
server.Send()
```
## 目录说明
- officialaccount: 微信公众号API
- miniprogram: 小程序API
- minigame:小游戏API
- pay:微信支付API
- openplatform:开放平台API
- work:企业微信
- aispeech:智能对话
- doc: api文档
## 贡献
- 在[API列表](https://github.com/silenceper/wechat/tree/v2/doc/api)中查看哪些API未实现
- 提交issue，描述需要贡献的内容
- 完成更改后，提交PR
## 公众号
![img](https://silenceper.oss-cn-beijing.aliyuncs.com/qrcode/search_study_program.png)
## License
Apache License, Version 2.0
vendor/github.com/silenceper/wechat/v2/cache/cache.go
Generated Vendored
+11
View File
@@ -0,0 +1,11 @@
package cache
import "time"
// Cache interface
type Cache interface {
Get(key string) interface{}
Set(key string, val interface{}, timeout time.Duration) error
IsExist(key string) bool
Delete(key string) error
}
vendor/github.com/silenceper/wechat/v2/cache/memcache.go
Generated Vendored
+57
View File
@@ -0,0 +1,57 @@
package cache
import (
"encoding/json"
"time"
"github.com/bradfitz/gomemcache/memcache"
)
// Memcache struct contains *memcache.Client
type Memcache struct {
conn *memcache.Client
}
// NewMemcache create new memcache
func NewMemcache(server ...string) *Memcache {
mc := memcache.New(server...)
return &Memcache{mc}
}
// Get return cached value
func (mem *Memcache) Get(key string) interface{} {
var err error
var item *memcache.Item
if item, err = mem.conn.Get(key); err != nil {
return nil
}
var result interface{}
if err = json.Unmarshal(item.Value, &result); err != nil {
return nil
}
return result
}
// IsExist check value exists in memcache.
func (mem *Memcache) IsExist(key string) bool {
if _, err := mem.conn.Get(key); err != nil {
return false
}
return true
}
// Set cached value with key and expire time.
func (mem *Memcache) Set(key string, val interface{}, timeout time.Duration) (err error) {
var data []byte
if data, err = json.Marshal(val); err != nil {
return err
}
item := &memcache.Item{Key: key, Value: data, Expiration: int32(timeout / time.Second)}
return mem.conn.Set(item)
}
// Delete delete value in memcache.
func (mem *Memcache) Delete(key string) error {
return mem.conn.Delete(key)
}
vendor/github.com/silenceper/wechat/v2/cache/memory.go
Generated Vendored
+74
View File
@@ -0,0 +1,74 @@
package cache
import (
"sync"
"time"
)
// Memory struct contains *memcache.Client
type Memory struct {
sync.Mutex
data map[string]*data
}
type data struct {
Data interface{}
Expired time.Time
}
// NewMemory create new memcache
func NewMemory() *Memory {
return &Memory{
data: map[string]*data{},
}
}
// Get return cached value
func (mem *Memory) Get(key string) interface{} {
if ret, ok := mem.data[key]; ok {
if ret.Expired.Before(time.Now()) {
mem.deleteKey(key)
return nil
}
return ret.Data
}
return nil
}
// IsExist check value exists in memcache.
func (mem *Memory) IsExist(key string) bool {
if ret, ok := mem.data[key]; ok {
if ret.Expired.Before(time.Now()) {
mem.deleteKey(key)
return false
}
return true
}
return false
}
// Set cached value with key and expire time.
func (mem *Memory) Set(key string, val interface{}, timeout time.Duration) (err error) {
mem.Lock()
defer mem.Unlock()
mem.data[key] = &data{
Data: val,
Expired: time.Now().Add(timeout),
}
return nil
}
// Delete delete value in memcache.
func (mem *Memory) Delete(key string) error {
mem.deleteKey(key)
return nil
}
// deleteKey
func (mem *Memory) deleteKey(key string) {
mem.Lock()
defer mem.Unlock()
delete(mem.data, key)
}
vendor/github.com/silenceper/wechat/v2/cache/redis.go
Generated Vendored
+112
View File
@@ -0,0 +1,112 @@
package cache
import (
"encoding/json"
"time"
"github.com/gomodule/redigo/redis"
)
// Redis .redis cache
type Redis struct {
conn *redis.Pool
}
// RedisOpts redis 连接属性
type RedisOpts struct {
Host string `yml:"host" json:"host"`
Password string `yml:"password" json:"password"`
Database int `yml:"database" json:"database"`
MaxIdle int `yml:"max_idle" json:"max_idle"`
MaxActive int `yml:"max_active" json:"max_active"`
IdleTimeout int `yml:"idle_timeout" json:"idle_timeout"` // second
}
// NewRedis 实例化
func NewRedis(opts *RedisOpts, dialOpts ...redis.DialOption) *Redis {
pool := &redis.Pool{
MaxActive: opts.MaxActive,
MaxIdle: opts.MaxIdle,
IdleTimeout: time.Second * time.Duration(opts.IdleTimeout),
Dial: func() (redis.Conn, error) {
dialOpts = append(dialOpts, []redis.DialOption{
redis.DialDatabase(opts.Database),
redis.DialPassword(opts.Password),
}...)
return redis.Dial("tcp", opts.Host, dialOpts...)
},
TestOnBorrow: func(conn redis.Conn, t time.Time) error {
if time.Since(t) < time.Minute {
return nil
}
_, err := conn.Do("PING")
return err
},
}
return &Redis{pool}
}
// SetRedisPool 设置redis连接池
func (r *Redis) SetRedisPool(pool *redis.Pool) {
r.conn = pool
}
// SetConn 设置conn
func (r *Redis) SetConn(conn *redis.Pool) {
r.conn = conn
}
// Get 获取一个值
func (r *Redis) Get(key string) interface{} {
conn := r.conn.Get()
defer conn.Close()
var data []byte
var err error
if data, err = redis.Bytes(conn.Do("GET", key)); err != nil {
return nil
}
var reply interface{}
if err = json.Unmarshal(data, &reply); err != nil {
return nil
}
return reply
}
// Set 设置一个值
func (r *Redis) Set(key string, val interface{}, timeout time.Duration) (err error) {
conn := r.conn.Get()
defer conn.Close()
var data []byte
if data, err = json.Marshal(val); err != nil {
return
}
_, err = conn.Do("SETEX", key, int64(timeout/time.Second), data)
return
}
// IsExist 判断key是否存在
func (r *Redis) IsExist(key string) bool {
conn := r.conn.Get()
defer conn.Close()
a, _ := conn.Do("EXISTS", key)
i := a.(int64)
return i > 0
}
// Delete 删除
func (r *Redis) Delete(key string) error {
conn := r.conn.Get()
defer conn.Close()
if _, err := conn.Do("DEL", key); err != nil {
return err
}
return nil
}
vendor/github.com/silenceper/wechat/v2/credential/access_token.go
Generated Vendored
+6
View File
@@ -0,0 +1,6 @@
package credential
// AccessTokenHandle AccessToken 接口
type AccessTokenHandle interface {
GetAccessToken() (accessToken string, err error)
}
vendor/github.com/silenceper/wechat/v2/credential/default_access_token.go
Generated Vendored
+157
View File
@@ -0,0 +1,157 @@
package credential
import (
"encoding/json"
"fmt"
"sync"
"time"
"github.com/silenceper/wechat/v2/cache"
"github.com/silenceper/wechat/v2/util"
)
const (
// AccessTokenURL 获取access_token的接口
accessTokenURL = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s"
// AccessTokenURL 企业微信获取access_token的接口
workAccessTokenURL = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s"
// CacheKeyOfficialAccountPrefix 微信公众号cache key前缀
CacheKeyOfficialAccountPrefix = "gowechat_officialaccount_"
// CacheKeyMiniProgramPrefix 小程序cache key前缀
CacheKeyMiniProgramPrefix = "gowechat_miniprogram_"
// CacheKeyWorkPrefix 企业微信cache key前缀
CacheKeyWorkPrefix = "gowechat_work_"
)
// DefaultAccessToken 默认AccessToken 获取
type DefaultAccessToken struct {
appID string
appSecret string
cacheKeyPrefix string
cache cache.Cache
accessTokenLock *sync.Mutex
}
// NewDefaultAccessToken new DefaultAccessToken
func NewDefaultAccessToken(appID, appSecret, cacheKeyPrefix string, cache cache.Cache) AccessTokenHandle {
if cache == nil {
panic("cache is ineed")
}
return &DefaultAccessToken{
appID: appID,
appSecret: appSecret,
cache: cache,
cacheKeyPrefix: cacheKeyPrefix,
accessTokenLock: new(sync.Mutex),
}
}
// ResAccessToken struct
type ResAccessToken struct {
util.CommonError
AccessToken string `json:"access_token"`
ExpiresIn int64 `json:"expires_in"`
}
// GetAccessToken 获取access_token,先从cache中获取，没有则从服务端获取
func (ak *DefaultAccessToken) GetAccessToken() (accessToken string, err error) {
// 先从cache中取
accessTokenCacheKey := fmt.Sprintf("%s_access_token_%s", ak.cacheKeyPrefix, ak.appID)
if val := ak.cache.Get(accessTokenCacheKey); val != nil {
return val.(string), nil
}
// 加上lock，是为了防止在并发获取token时，cache刚好失效，导致从微信服务器上获取到不同token
ak.accessTokenLock.Lock()
defer ak.accessTokenLock.Unlock()
// 双检，防止重复从微信服务器获取
if val := ak.cache.Get(accessTokenCacheKey); val != nil {
return val.(string), nil
}
// cache失效，从微信服务器获取
var resAccessToken ResAccessToken
resAccessToken, err = GetTokenFromServer(fmt.Sprintf(accessTokenURL, ak.appID, ak.appSecret))
if err != nil {
return
}
expires := resAccessToken.ExpiresIn - 1500
err = ak.cache.Set(accessTokenCacheKey, resAccessToken.AccessToken, time.Duration(expires)*time.Second)
if err != nil {
return
}
accessToken = resAccessToken.AccessToken
return
}
// WorkAccessToken 企业微信AccessToken 获取
type WorkAccessToken struct {
CorpID string
CorpSecret string
cacheKeyPrefix string
cache cache.Cache
accessTokenLock *sync.Mutex
}
// NewWorkAccessToken new WorkAccessToken
func NewWorkAccessToken(corpID, corpSecret, cacheKeyPrefix string, cache cache.Cache) AccessTokenHandle {
if cache == nil {
panic("cache the not exist")
}
return &WorkAccessToken{
CorpID: corpID,
CorpSecret: corpSecret,
cache: cache,
cacheKeyPrefix: cacheKeyPrefix,
accessTokenLock: new(sync.Mutex),
}
}
// GetAccessToken 企业微信获取access_token,先从cache中获取，没有则从服务端获取
func (ak *WorkAccessToken) GetAccessToken() (accessToken string, err error) {
// 加上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)
return
}
// cache失效，从微信服务器获取
var resAccessToken ResAccessToken
resAccessToken, err = GetTokenFromServer(fmt.Sprintf(workAccessTokenURL, ak.CorpID, ak.CorpSecret))
if err != nil {
return
}
expires := resAccessToken.ExpiresIn - 1500
err = ak.cache.Set(accessTokenCacheKey, resAccessToken.AccessToken, time.Duration(expires)*time.Second)
if err != nil {
return
}
accessToken = resAccessToken.AccessToken
return
}
// GetTokenFromServer 强制从微信服务器获取token
func GetTokenFromServer(url string) (resAccessToken ResAccessToken, err error) {
var body []byte
body, err = util.HTTPGet(url)
if err != nil {
return
}
err = json.Unmarshal(body, &resAccessToken)
if err != nil {
return
}
if resAccessToken.ErrCode != 0 {
err = fmt.Errorf("get access_token error : errcode=%v , errormsg=%v", resAccessToken.ErrCode, resAccessToken.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/credential/default_js_ticket.go
Generated Vendored
+87
View File
@@ -0,0 +1,87 @@
package credential
import (
"encoding/json"
"fmt"
"sync"
"time"
"github.com/silenceper/wechat/v2/cache"
"github.com/silenceper/wechat/v2/util"
)
// getTicketURL 获取ticket的url
const getTicketURL = "https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=%s&type=jsapi"
// DefaultJsTicket 默认获取js ticket方法
type DefaultJsTicket struct {
appID string
cacheKeyPrefix string
cache cache.Cache
// jsAPITicket 读写锁 同一个AppID一个
jsAPITicketLock *sync.Mutex
}
// NewDefaultJsTicket new
func NewDefaultJsTicket(appID string, cacheKeyPrefix string, cache cache.Cache) JsTicketHandle {
return &DefaultJsTicket{
appID: appID,
cache: cache,
cacheKeyPrefix: cacheKeyPrefix,
jsAPITicketLock: new(sync.Mutex),
}
}
// ResTicket 请求jsapi_tikcet返回结果
type ResTicket struct {
util.CommonError
Ticket string `json:"ticket"`
ExpiresIn int64 `json:"expires_in"`
}
// GetTicket 获取jsapi_ticket
func (js *DefaultJsTicket) GetTicket(accessToken string) (ticketStr string, err error) {
// 先从cache中取
jsAPITicketCacheKey := fmt.Sprintf("%s_jsapi_ticket_%s", js.cacheKeyPrefix, js.appID)
if val := js.cache.Get(jsAPITicketCacheKey); val != nil {
return val.(string), nil
}
js.jsAPITicketLock.Lock()
defer js.jsAPITicketLock.Unlock()
// 双检，防止重复从微信服务器获取
if val := js.cache.Get(jsAPITicketCacheKey); val != nil {
return val.(string), nil
}
var ticket ResTicket
ticket, err = GetTicketFromServer(accessToken)
if err != nil {
return
}
expires := ticket.ExpiresIn - 1500
err = js.cache.Set(jsAPITicketCacheKey, ticket.Ticket, time.Duration(expires)*time.Second)
ticketStr = ticket.Ticket
return
}
// GetTicketFromServer 从服务器中获取ticket
func GetTicketFromServer(accessToken string) (ticket ResTicket, err error) {
var response []byte
url := fmt.Sprintf(getTicketURL, accessToken)
response, err = util.HTTPGet(url)
if err != nil {
return
}
err = json.Unmarshal(response, &ticket)
if err != nil {
return
}
if ticket.ErrCode != 0 {
err = fmt.Errorf("getTicket Error : errcode=%d , errmsg=%s", ticket.ErrCode, ticket.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/credential/js_ticket.go
Generated Vendored
+7
View File
@@ -0,0 +1,7 @@
package credential
// JsTicketHandle js ticket获取
type JsTicketHandle interface {
// GetTicket 获取ticket
GetTicket(accessToken string) (ticket string, err error)
}
vendor/github.com/silenceper/wechat/v2/doc.go
Generated Vendored
+10
View File
@@ -0,0 +1,10 @@
/*
Package wechat provide wechat sdk for go
使用Golang开发的微信SDK，简单、易用。
更多信息：https://github.com/silenceper/wechat
*/
package wechat
vendor/github.com/silenceper/wechat/v2/go.mod
Generated Vendored
+18
View File
@@ -0,0 +1,18 @@
module github.com/silenceper/wechat/v2
go 1.14
require (
github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b
github.com/fatih/structs v1.1.0
github.com/gomodule/redigo v1.8.5
github.com/kr/text v0.2.0 // indirect
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
github.com/sirupsen/logrus v1.8.1
github.com/spf13/cast v1.3.1
github.com/stretchr/testify v1.7.0
golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
gopkg.in/h2non/gock.v1 v1.0.15
)
vendor/github.com/silenceper/wechat/v2/go.sum
Generated Vendored
+49
View File
@@ -0,0 +1,49 @@
github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b h1:L/QXpzIa3pOvUGt1D1lA5KjYhPBAN/3iWdP7xeFS9F0=
github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b/go.mod h1:H0wQNHz2YrLsuXOZozoeDmnHXkNCRmMW0gwFWDfEZDA=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
github.com/gomodule/redigo v1.8.5 h1:nRAxCa+SVsyjSBrtZmG/cqb6VbTmuRzpg/PoTFlpumc=
github.com/gomodule/redigo v1.8.5/go.mod h1:P9dn9mFrCBvWhGE1wpxx6fgq7BAeLBk+UUUzlpkBYO0=
github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 h1:2VTzZjLZBgl62/EtslCrtky5vbi9dd7HrQPQIx6wqiw=
github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 h1:W6apQkHrMkS0Muv8G/TipAy/FJl/rCYT0+EuS8+Z0z4=
github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng=
github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/h2non/gock.v1 v1.0.15 h1:SzLqcIlb/fDfg7UvukMpNcWsu7sI5tWwL+KCATZqks0=
gopkg.in/h2non/gock.v1 v1.0.15/go.mod h1:sX4zAkdYX1TRGJ2JY156cFspQn4yRWn6p9EMdODlynE=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
vendor/github.com/silenceper/wechat/v2/miniprogram/README.md
Generated Vendored
+20
View File
@@ -0,0 +1,20 @@
# 微信小程序
[官方文档](https://developers.weixin.qq.com/miniprogram/dev/framework/)
## 包说明
- analysis 数据分析相关API
## 快速入门
```go
wc := wechat.NewWechat()
memory := cache.NewMemory()
cfg := &miniConfig.Config{
AppID: "xxx",
AppSecret: "xxx",
Cache: memory,
}
miniprogram := wc.GetMiniProgram(cfg)
miniprogram.GetAnalysis().GetAnalysisDailyRetain()
```
vendor/github.com/silenceper/wechat/v2/miniprogram/analysis/analysis.go
Generated Vendored
+317
View File
@@ -0,0 +1,317 @@
package analysis
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
// 获取用户访问小程序日留存
getAnalysisDailyRetainURL = "https://api.weixin.qq.com/datacube/getweanalysisappiddailyretaininfo?access_token=%s"
// 获取用户访问小程序月留存
getAnalysisMonthlyRetainURL = "https://api.weixin.qq.com/datacube/getweanalysisappidmonthlyretaininfo?access_token=%s"
// 获取用户访问小程序周留存
getAnalysisWeeklyRetainURL = "https://api.weixin.qq.com/datacube/getweanalysisappidweeklyretaininfo?access_token=%s"
// 获取用户访问小程序数据概况
getAnalysisDailySummaryURL = "https://api.weixin.qq.com/datacube/getweanalysisappiddailysummarytrend?access_token=%s"
// 获取用户访问小程序数据日趋势
getAnalysisDailyVisitTrendURL = "https://api.weixin.qq.com/datacube/getweanalysisappiddailyvisittrend?access_token=%s"
// 获取用户访问小程序数据月趋势
getAnalysisMonthlyVisitTrendURL = "https://api.weixin.qq.com/datacube/getweanalysisappidmonthlyvisittrend?access_token=%s"
// 获取用户访问小程序数据周趋势
getAnalysisWeeklyVisitTrendURL = "https://api.weixin.qq.com/datacube/getweanalysisappidweeklyvisittrend?access_token=%s"
// 获取小程序新增或活跃用户的画像分布数据
getAnalysisUserPortraitURL = "https://api.weixin.qq.com/datacube/getweanalysisappiduserportrait?access_token=%s"
// 获取用户小程序访问分布数据
getAnalysisVisitDistributionURL = "https://api.weixin.qq.com/datacube/getweanalysisappidvisitdistribution?access_token=%s"
// 访问页面
getAnalysisVisitPageURL = "https://api.weixin.qq.com/datacube/getweanalysisappidvisitpage?access_token=%s"
)
// Analysis analyis 数据分析
type Analysis struct {
*context.Context
}
// NewAnalysis new
func NewAnalysis(ctx *context.Context) *Analysis {
return &Analysis{ctx}
}
// fetchData 拉取统计数据
func (analysis *Analysis) fetchData(urlStr string, body interface{}) (response []byte, err error) {
var accessToken string
accessToken, err = analysis.GetAccessToken()
if err != nil {
return
}
urlStr = fmt.Sprintf(urlStr, accessToken)
response, err = util.PostJSON(urlStr, body)
return
}
// RetainItem 留存项结构
type RetainItem struct {
Key int `json:"key"` // 标识，0开始表示当天，1表示1甜后，以此类推
Value int `json:"value"` // key对应日期的新增用户数/活跃用户数（key=0时）或留存用户数（k>0时）
}
// ResAnalysisRetain 小程序留存数据返回
type ResAnalysisRetain struct {
util.CommonError
RefDate string `json:"ref_date"` // 日期
VisitUVNew []RetainItem `json:"visit_uv_new"` // 新增用户留存
VisitUV []RetainItem `json:"visit_uv"` // 活跃用户留存
}
// getAnalysisRetain 获取用户访问小程序留存数据(日、月、周)
func (analysis *Analysis) getAnalysisRetain(urlStr string, beginDate, endDate string) (result ResAnalysisRetain, err error) {
body := map[string]string{
"begin_date": beginDate,
"end_date": endDate,
}
response, err := analysis.fetchData(urlStr, body)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("getAnalysisRetain error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// GetAnalysisDailyRetain 获取用户访问小程序日留存
func (analysis *Analysis) GetAnalysisDailyRetain(beginDate, endDate string) (result ResAnalysisRetain, err error) {
return analysis.getAnalysisRetain(getAnalysisDailyRetainURL, beginDate, endDate)
}
// GetAnalysisMonthlyRetain 获取用户访问小程序月留存
func (analysis *Analysis) GetAnalysisMonthlyRetain(beginDate, endDate string) (result ResAnalysisRetain, err error) {
return analysis.getAnalysisRetain(getAnalysisMonthlyRetainURL, beginDate, endDate)
}
// GetAnalysisWeeklyRetain 获取用户访问小程序周留存
func (analysis *Analysis) GetAnalysisWeeklyRetain(beginDate, endDate string) (result ResAnalysisRetain, err error) {
return analysis.getAnalysisRetain(getAnalysisWeeklyRetainURL, beginDate, endDate)
}
// ResAnalysisDailySummary 小程序访问数据概况
type ResAnalysisDailySummary struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"` // 日期
VisitTotal int `json:"visit_total"` // 累计用户数
SharePV int `json:"share_pv"` // 转发次数
ShareUV int `json:"share_uv"` // 转发人数
} `json:"list"`
}
// GetAnalysisDailySummary 获取用户访问小程序数据概况
func (analysis *Analysis) GetAnalysisDailySummary(beginDate, endDate string) (result ResAnalysisDailySummary, err error) {
body := map[string]string{
"begin_date": beginDate,
"end_date": endDate,
}
response, err := analysis.fetchData(getAnalysisDailySummaryURL, body)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetAnalysisDailySummary error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// ResAnalysisVisitTrend 小程序访问数据趋势(日、月、周)
type ResAnalysisVisitTrend struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"` // 日期
SessionCnt int `json:"session_cnt"` // 打开次数
VisitPV int `json:"visit_pv"` // 访问次数
VisitUV int `json:"visit_uv"` // 访问人数
VisitUVNew int `json:"visit_uv_new"` // 新用户数
StayTimeUV float64 `json:"stay_time_uv"` // 人均停留时长
StayTimeSession float64 `json:"stay_time_session"` // 次均停留时常
VisitDepth float64 `json:"visit_depth"` // 平均访问深度
} `json:"list"`
}
// getAnalysisRetain 获取小程序访问数据趋势(日、月、周)
func (analysis *Analysis) getAnalysisVisitTrend(urlStr string, beginDate, endDate string) (result ResAnalysisVisitTrend, err error) {
body := map[string]string{
"begin_date": beginDate,
"end_date": endDate,
}
response, err := analysis.fetchData(urlStr, body)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("getAnalysisVisitTrend error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// GetAnalysisDailyVisitTrend 获取用户访问小程序数据日趋势
func (analysis *Analysis) GetAnalysisDailyVisitTrend(beginDate, endDate string) (result ResAnalysisVisitTrend, err error) {
return analysis.getAnalysisVisitTrend(getAnalysisDailyVisitTrendURL, beginDate, endDate)
}
// GetAnalysisMonthlyVisitTrend 获取用户访问小程序数据月趋势
func (analysis *Analysis) GetAnalysisMonthlyVisitTrend(beginDate, endDate string) (result ResAnalysisVisitTrend, err error) {
return analysis.getAnalysisVisitTrend(getAnalysisMonthlyVisitTrendURL, beginDate, endDate)
}
// GetAnalysisWeeklyVisitTrend 获取用户访问小程序数据周趋势
func (analysis *Analysis) GetAnalysisWeeklyVisitTrend(beginDate, endDate string) (result ResAnalysisVisitTrend, err error) {
return analysis.getAnalysisVisitTrend(getAnalysisWeeklyVisitTrendURL, beginDate, endDate)
}
// UserPortraitItem 用户画像项目
type UserPortraitItem struct {
ID int `json:"id"` // 属性值id
Name string `json:"name"` // 属性值名称
AccessSourceVisitUV int `json:"access_source_visit_uv"` // 该场景访问uv
}
// UserPortrait 用户画像
type UserPortrait struct {
Index int `json:"index"` // 分布类型
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对等区间
}
// ResAnalysisUserPortrait 小程序新增或活跃用户的画像分布数据返回
type ResAnalysisUserPortrait struct {
util.CommonError
RefDate string `json:"ref_date"` // 日期
VisitUVNew UserPortrait `json:"visit_uv_new"` // 新用户画像
VisitUV UserPortrait `json:"visit_uv"` // 活跃用户画像
}
// GetAnalysisUserPortrait 获取小程序新增或活跃用户的画像分布数据
func (analysis *Analysis) GetAnalysisUserPortrait(beginDate, endDate string) (result ResAnalysisUserPortrait, err error) {
body := map[string]string{
"begin_date": beginDate,
"end_date": endDate,
}
response, err := analysis.fetchData(getAnalysisUserPortraitURL, body)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetAnalysisUserPortrait error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// VisitDistributionIndexItem 访问分数数据结构
type VisitDistributionIndexItem struct {
Key int `json:"key"` // 场景id
Value int `json:"value"` // 该场景id访问pv
AccessSourceVisitUV int `json:"access_source_visit_uv"` // 该场景id访问uv
}
// VisitDistributionIndex 访问分布单分布类型数据
type VisitDistributionIndex struct {
Index string `json:"index"` // 分布类型
ItemList []VisitDistributionIndexItem `json:"item_list"` // 分布数据列表
}
// ResAnalysisVisitDistribution 小程序访问分布数据返回
type ResAnalysisVisitDistribution struct {
util.CommonError
RefDate string `json:"ref_date"` // 日期
List []VisitDistributionIndex `json:"list"` // 数据列表
}
// GetAnalysisVisitDistribution 获取用户小程序访问分布数据
func (analysis *Analysis) GetAnalysisVisitDistribution(beginDate, endDate string) (result ResAnalysisVisitDistribution, err error) {
body := map[string]string{
"begin_date": beginDate,
"end_date": endDate,
}
response, err := analysis.fetchData(getAnalysisVisitDistributionURL, body)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetAnalysisVisitDistribution error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// VisitPageItem 访问单个页面的数据结构
type VisitPageItem struct {
PagePath string `json:"page_path"` // 页面路径
PageVisitPV int `json:"page_visit_pv"` // 访问次数
PageVisitUV int `json:"page_visit_uv"` // 访问人数
PageStaytimePV float64 `json:"page_staytime_pv"` // 次均停留时常
EntrypagePV int `json:"entrypage_pv"` // 进入页次数
ExitpagePV int `json:"exitpage_pv"` // 退出页次数
PageSharePV int `json:"page_share_pv"` // 转发次数
PageShareUV int `json:"page_share_uv"` // 转发人数
}
// ResAnalysisVisitPage 访问小程序页面访问数据返回
type ResAnalysisVisitPage struct {
util.CommonError
RefDate string `json:"ref_date"` // 日期
List []VisitPageItem `json:"list"` // 数据列表
}
// GetAnalysisVisitPage 获取小程序页面访问数据
func (analysis *Analysis) GetAnalysisVisitPage(beginDate, endDate string) (result ResAnalysisVisitPage, err error) {
body := map[string]string{
"begin_date": beginDate,
"end_date": endDate,
}
response, err := analysis.fetchData(getAnalysisVisitPageURL, body)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetAnalysisVisitPage error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/miniprogram/auth/auth.go
Generated Vendored
+133
View File
@@ -0,0 +1,133 @@
package auth
import (
context2 "context"
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
code2SessionURL = "https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code"
checkEncryptedDataURL = "https://api.weixin.qq.com/wxa/business/checkencryptedmsg?access_token=%s"
getPhoneNumber = "https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=%s"
)
// Auth 登录/用户信息
type Auth struct {
*context.Context
}
// NewAuth new auth
func NewAuth(ctx *context.Context) *Auth {
return &Auth{ctx}
}
// ResCode2Session 登录凭证校验的返回结果
type ResCode2Session struct {
util.CommonError
OpenID string `json:"openid"` // 用户唯一标识
SessionKey string `json:"session_key"` // 会话密钥
UnionID string `json:"unionid"` // 用户在开放平台的唯一标识符，在满足UnionID下发条件的情况下会返回
}
// RspCheckEncryptedData .
type RspCheckEncryptedData struct {
util.CommonError
Vaild bool `json:"vaild"` // 是否是合法的数据
CreateTime uint `json:"create_time"` // 加密数据生成的时间戳
}
// Code2Session 登录凭证校验。
func (auth *Auth) Code2Session(jsCode string) (result ResCode2Session, err error) {
return auth.Code2SessionContext(context2.Background(), jsCode)
}
// Code2SessionContext 登录凭证校验。
func (auth *Auth) Code2SessionContext(ctx context2.Context, jsCode string) (result ResCode2Session, err error) {
var response []byte
if response, err = util.HTTPGetContext(ctx, fmt.Sprintf(code2SessionURL, auth.AppID, auth.AppSecret, jsCode)); err != nil {
return
}
if err = json.Unmarshal(response, &result); err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("Code2Session error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// GetPaidUnionID 用户支付完成后，获取该用户的 UnionId，无需用户授权
func (auth *Auth) GetPaidUnionID() {
// TODO
}
// CheckEncryptedData .检查加密信息是否由微信生成（当前只支持手机号加密数据），只能检测最近3天生成的加密数据
func (auth *Auth) CheckEncryptedData(encryptedMsgHash string) (result RspCheckEncryptedData, err error) {
return auth.CheckEncryptedDataContext(context2.Background(), encryptedMsgHash)
}
// CheckEncryptedDataContext .检查加密信息是否由微信生成（当前只支持手机号加密数据），只能检测最近3天生成的加密数据
func (auth *Auth) CheckEncryptedDataContext(ctx context2.Context, encryptedMsgHash string) (result RspCheckEncryptedData, err error) {
var response []byte
var (
at string
)
if at, err = auth.GetAccessToken(); err != nil {
return
}
if response, err = util.HTTPPostContext(ctx, fmt.Sprintf(checkEncryptedDataURL, at), "encrypted_msg_hash="+encryptedMsgHash); err != nil {
return
}
if err = util.DecodeWithError(response, &result, "CheckEncryptedDataAuth"); err != nil {
return
}
return
}
// GetPhoneNumberResponse 新版获取用户手机号响应结构体
type GetPhoneNumberResponse struct {
util.CommonError
PhoneInfo PhoneInfo `json:"phone_info"`
}
// PhoneInfo 获取用户手机号内容
type PhoneInfo struct {
PhoneNumber string `json:"phoneNumber"` // 用户绑定的手机号
PurePhoneNumber string `json:"purePhoneNumber"` // 没有区号的手机号
CountryCode string `json:"countryCode"` // 区号
WaterMark struct {
Timestamp int64 `json:"timestamp"`
AppID string `json:"appid"`
} `json:"watermark"` // 数据水印
}
// GetPhoneNumber 小程序通过code获取用户手机号
func (auth *Auth) GetPhoneNumber(code string) (result GetPhoneNumberResponse, err error) {
var response []byte
var (
at string
)
if at, err = auth.GetAccessToken(); err != nil {
return
}
body := map[string]interface{}{
"code": code,
}
if response, err = util.PostJSON(fmt.Sprintf(getPhoneNumber, at), body); err != nil {
return
}
if err = util.DecodeWithError(response, &result, "phonenumber.getPhoneNumber"); err != nil {
return
}
return
}
vendor/github.com/silenceper/wechat/v2/miniprogram/config/config.go
Generated Vendored
+13
View File
@@ -0,0 +1,13 @@
// Package config 小程序config配置
package config
import (
"github.com/silenceper/wechat/v2/cache"
)
// Config .config for 小程序
type Config struct {
AppID string `json:"app_id"` // appid
AppSecret string `json:"app_secret"` // appsecret
Cache cache.Cache
}
vendor/github.com/silenceper/wechat/v2/miniprogram/content/content.go
Generated Vendored
+61
View File
@@ -0,0 +1,61 @@
package content
import (
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
checkTextURL = "https://api.weixin.qq.com/wxa/msg_sec_check?access_token=%s"
checkImageURL = "https://api.weixin.qq.com/wxa/img_sec_check?access_token=%s"
)
// Content 内容安全
type Content struct {
*context.Context
}
// NewContent 内容安全接口
func NewContent(ctx *context.Context) *Content {
return &Content{ctx}
}
// CheckText 检测文字
// @text 需要检测的文字
func (content *Content) CheckText(text string) error {
accessToken, err := content.GetAccessToken()
if err != nil {
return err
}
response, err := util.PostJSON(
fmt.Sprintf(checkTextURL, accessToken),
map[string]string{
"content": text,
},
)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "ContentCheckText")
}
// CheckImage 检测图片
// 所传参数为要检测的图片文件的绝对路径，图片格式支持PNG、JPEG、JPG、GIF, 像素不超过 750 x 1334，同时文件大小以不超过 300K 为宜，否则可能报错
// @media 图片文件的绝对路径
func (content *Content) CheckImage(media string) error {
accessToken, err := content.GetAccessToken()
if err != nil {
return err
}
response, err := util.PostFile(
"media",
media,
fmt.Sprintf(checkImageURL, accessToken),
)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "ContentCheckImage")
}
vendor/github.com/silenceper/wechat/v2/miniprogram/context/context.go
Generated Vendored
+12
View File
@@ -0,0 +1,12 @@
package context
import (
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/miniprogram/config"
)
// Context struct
type Context struct {
*config.Config
credential.AccessTokenHandle
}
vendor/github.com/silenceper/wechat/v2/miniprogram/encryptor/encryptor.go
Generated Vendored
+125
View File
@@ -0,0 +1,125 @@
package encryptor
import (
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
)
// Encryptor struct
type Encryptor struct {
*context.Context
}
// NewEncryptor 实例
func NewEncryptor(context *context.Context) *Encryptor {
basic := new(Encryptor)
basic.Context = context
return basic
}
var (
// ErrAppIDNotMatch appid不匹配
ErrAppIDNotMatch = errors.New("app id not match")
// ErrInvalidBlockSize block size不合法
ErrInvalidBlockSize = errors.New("invalid block size")
// ErrInvalidPKCS7Data PKCS7数据不合法
ErrInvalidPKCS7Data = errors.New("invalid PKCS7 data")
// ErrInvalidPKCS7Padding 输入padding失败
ErrInvalidPKCS7Padding = errors.New("invalid padding on input")
)
// PlainData 用户信息/手机号信息
type PlainData struct {
OpenID string `json:"openId"`
UnionID string `json:"unionId"`
NickName string `json:"nickName"`
Gender int `json:"gender"`
City string `json:"city"`
Province string `json:"province"`
Country string `json:"country"`
AvatarURL string `json:"avatarUrl"`
Language string `json:"language"`
PhoneNumber string `json:"phoneNumber"`
OpenGID string `json:"openGId"`
MsgTicket string `json:"msgTicket"`
PurePhoneNumber string `json:"purePhoneNumber"`
CountryCode string `json:"countryCode"`
Watermark struct {
Timestamp int64 `json:"timestamp"`
AppID string `json:"appid"`
} `json:"watermark"`
}
// pkcs7Unpad returns slice of the original data without padding
func pkcs7Unpad(data []byte, blockSize int) ([]byte, error) {
if blockSize <= 0 {
return nil, ErrInvalidBlockSize
}
if len(data)%blockSize != 0 || len(data) == 0 {
return nil, ErrInvalidPKCS7Data
}
c := data[len(data)-1]
n := int(c)
if n == 0 || n > len(data) {
return nil, ErrInvalidPKCS7Padding
}
for i := 0; i < n; i++ {
if data[len(data)-n+i] != c {
return nil, ErrInvalidPKCS7Padding
}
}
return data[:len(data)-n], nil
}
// GetCipherText returns slice of the cipher text
func GetCipherText(sessionKey, encryptedData, iv string) ([]byte, error) {
aesKey, err := base64.StdEncoding.DecodeString(sessionKey)
if err != nil {
return nil, err
}
cipherText, err := base64.StdEncoding.DecodeString(encryptedData)
if err != nil {
return nil, err
}
ivBytes, err := base64.StdEncoding.DecodeString(iv)
if err != nil {
return nil, err
}
if len(ivBytes) != aes.BlockSize {
return nil, fmt.Errorf("bad iv length %d", len(ivBytes))
}
block, err := aes.NewCipher(aesKey)
if err != nil {
return nil, err
}
mode := cipher.NewCBCDecrypter(block, ivBytes)
mode.CryptBlocks(cipherText, cipherText)
cipherText, err = pkcs7Unpad(cipherText, block.BlockSize())
if err != nil {
return nil, err
}
return cipherText, nil
}
// Decrypt 解密数据
func (encryptor *Encryptor) Decrypt(sessionKey, encryptedData, iv string) (*PlainData, error) {
cipherText, err := GetCipherText(sessionKey, encryptedData, iv)
if err != nil {
return nil, err
}
var plainData PlainData
err = json.Unmarshal(cipherText, &plainData)
if err != nil {
return nil, err
}
if plainData.Watermark.AppID != encryptor.AppID {
return nil, ErrAppIDNotMatch
}
return &plainData, nil
}
vendor/github.com/silenceper/wechat/v2/miniprogram/message/consts.go
Generated Vendored
+57
View File
@@ -0,0 +1,57 @@
package message
import "encoding/xml"
// MsgType 基本消息类型
type MsgType string
// EventType 事件类型
type EventType string
// InfoType 第三方平台授权事件类型
type InfoType string
const (
// MsgTypeText 文本消息
MsgTypeText MsgType = "text"
// MsgTypeImage 图片消息
MsgTypeImage = "image"
// MsgTypeLink 图文链接
MsgTypeLink = "link"
// MsgTypeMiniProgramPage 小程序卡片
MsgTypeMiniProgramPage = "miniprogrampage"
)
// CommonToken 消息中通用的结构
type CommonToken struct {
XMLName xml.Name `xml:"xml"`
ToUserName string `xml:"ToUserName"`
FromUserName string `xml:"FromUserName"`
CreateTime int64 `xml:"CreateTime"`
MsgType MsgType `xml:"MsgType"`
}
// MiniProgramMixMessage 小程序回调的消息结构
type MiniProgramMixMessage struct {
CommonToken
MsgID int64 `xml:"MsgId"`
// 文本消息
Content string `xml:"Content"`
// 图片消息
PicURL string `xml:"PicUrl"`
MediaID string `xml:"MediaId"`
// 小程序卡片消息
Title string `xml:"Title"`
AppID string `xml:"AppId"`
PagePath string `xml:"PagePath"`
ThumbURL string `xml:"ThumbUrl"`
ThumbMediaID string `xml:"ThumbMediaId"`
// 进入会话事件
Event string `xml:"Event"`
SessionFrom string `xml:"SessionFrom"`
}
vendor/github.com/silenceper/wechat/v2/miniprogram/message/customer_message.go
Generated Vendored
+124
View File
@@ -0,0 +1,124 @@
package message
import (
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
customerSendMessage = "https://api.weixin.qq.com/cgi-bin/message/custom/send"
)
// Manager 消息管理者，可以发送消息
type Manager struct {
*context.Context
}
// NewCustomerMessageManager 实例化消息管理者
func NewCustomerMessageManager(context *context.Context) *Manager {
return &Manager{
context,
}
}
// MediaText 文本消息的文字
type MediaText struct {
Content string `json:"content"`
}
// MediaResource 消息使用的临时素材id
type MediaResource struct {
MediaID string `json:"media_id"`
}
// MediaMiniprogrampage 小程序卡片
type MediaMiniprogrampage struct {
Title string `json:"title"`
Appid string `json:"appid"`
Pagepath string `json:"pagepath"`
ThumbMediaID string `json:"thumb_media_id"`
}
// MediaLink 发送图文链接
type MediaLink struct {
Title string `json:"title"`
Description string `json:"description"`
URL string `json:"url"`
ThumbURL string `json:"thumb_url"`
}
// CustomerMessage 客服消息
type CustomerMessage struct {
ToUser string `json:"touser"` // 接受者OpenID
Msgtype MsgType `json:"msgtype"` // 客服消息类型
Text *MediaText `json:"text,omitempty"` // 可选
Image *MediaResource `json:"image,omitempty"` // 可选
Link *MediaLink `json:"link,omitempty"` // 可选
Miniprogrampage *MediaMiniprogrampage `json:"miniprogrampage,omitempty"` // 可选
}
// NewCustomerTextMessage 文本消息结构体构造方法
func NewCustomerTextMessage(toUser, text string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeText,
Text: &MediaText{
Content: text,
},
}
}
// NewCustomerImgMessage 图片消息的构造方法
func NewCustomerImgMessage(toUser, mediaID string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeImage,
Image: &MediaResource{
MediaID: mediaID,
},
}
}
// NewCustomerLinkMessage 图文链接消息的构造方法
func NewCustomerLinkMessage(toUser, title, description, url, thumbURL string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeLink,
Link: &MediaLink{
Title: title,
Description: description,
URL: url,
ThumbURL: thumbURL,
},
}
}
// NewCustomerMiniprogrampageMessage 小程序卡片消息的构造方法
func NewCustomerMiniprogrampageMessage(toUser, title, pagepath, thumbMediaID string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeMiniProgramPage,
Miniprogrampage: &MediaMiniprogrampage{
Title: title,
Pagepath: pagepath,
ThumbMediaID: thumbMediaID,
},
}
}
// Send 发送客服消息
func (manager *Manager) Send(msg *CustomerMessage) error {
accessToken, err := manager.Context.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", customerSendMessage, accessToken)
response, err := util.PostJSON(uri, msg)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "SendCustomerMessage")
}
vendor/github.com/silenceper/wechat/v2/miniprogram/miniprogram.go
Generated Vendored
+104
View File
@@ -0,0 +1,104 @@
package miniprogram
import (
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/miniprogram/analysis"
"github.com/silenceper/wechat/v2/miniprogram/auth"
"github.com/silenceper/wechat/v2/miniprogram/config"
"github.com/silenceper/wechat/v2/miniprogram/content"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/miniprogram/encryptor"
"github.com/silenceper/wechat/v2/miniprogram/message"
"github.com/silenceper/wechat/v2/miniprogram/privacy"
"github.com/silenceper/wechat/v2/miniprogram/qrcode"
"github.com/silenceper/wechat/v2/miniprogram/shortlink"
"github.com/silenceper/wechat/v2/miniprogram/subscribe"
"github.com/silenceper/wechat/v2/miniprogram/tcb"
"github.com/silenceper/wechat/v2/miniprogram/urllink"
"github.com/silenceper/wechat/v2/miniprogram/werun"
)
// MiniProgram 微信小程序相关API
type MiniProgram struct {
ctx *context.Context
}
// NewMiniProgram 实例化小程序API
func NewMiniProgram(cfg *config.Config) *MiniProgram {
defaultAkHandle := credential.NewDefaultAccessToken(cfg.AppID, cfg.AppSecret, credential.CacheKeyMiniProgramPrefix, cfg.Cache)
ctx := &context.Context{
Config: cfg,
AccessTokenHandle: defaultAkHandle,
}
return &MiniProgram{ctx}
}
// SetAccessTokenHandle 自定义access_token获取方式
func (miniProgram *MiniProgram) SetAccessTokenHandle(accessTokenHandle credential.AccessTokenHandle) {
miniProgram.ctx.AccessTokenHandle = accessTokenHandle
}
// GetContext get Context
func (miniProgram *MiniProgram) GetContext() *context.Context {
return miniProgram.ctx
}
// GetEncryptor 小程序加解密
func (miniProgram *MiniProgram) GetEncryptor() *encryptor.Encryptor {
return encryptor.NewEncryptor(miniProgram.ctx)
}
// GetAuth 登录/用户信息相关接口
func (miniProgram *MiniProgram) GetAuth() *auth.Auth {
return auth.NewAuth(miniProgram.ctx)
}
// GetAnalysis 数据分析
func (miniProgram *MiniProgram) GetAnalysis() *analysis.Analysis {
return analysis.NewAnalysis(miniProgram.ctx)
}
// GetPrivacy 小程序隐私协议相关API
func (miniProgram *MiniProgram) GetPrivacy() *privacy.Privacy {
return privacy.NewPrivacy(miniProgram.ctx)
}
// GetQRCode 小程序码相关API
func (miniProgram *MiniProgram) GetQRCode() *qrcode.QRCode {
return qrcode.NewQRCode(miniProgram.ctx)
}
// GetTcb 小程序云开发API
func (miniProgram *MiniProgram) GetTcb() *tcb.Tcb {
return tcb.NewTcb(miniProgram.ctx)
}
// GetSubscribe 小程序订阅消息
func (miniProgram *MiniProgram) GetSubscribe() *subscribe.Subscribe {
return subscribe.NewSubscribe(miniProgram.ctx)
}
// GetCustomerMessage 客服消息接口
func (miniProgram *MiniProgram) GetCustomerMessage() *message.Manager {
return message.NewCustomerMessageManager(miniProgram.ctx)
}
// GetWeRun 微信运动接口
func (miniProgram *MiniProgram) GetWeRun() *werun.WeRun {
return werun.NewWeRun(miniProgram.ctx)
}
// GetContentSecurity 内容安全接口
func (miniProgram *MiniProgram) GetContentSecurity() *content.Content {
return content.NewContent(miniProgram.ctx)
}
// GetURLLink 小程序URL Link接口
func (miniProgram *MiniProgram) GetURLLink() *urllink.URLLink {
return urllink.NewURLLink(miniProgram.ctx)
}
// GetShortLink 小程序短链接口
func (miniProgram *MiniProgram) GetShortLink() *shortlink.ShortLink {
return shortlink.NewShortLink(miniProgram.ctx)
}
vendor/github.com/silenceper/wechat/v2/miniprogram/privacy/privacy.go
Generated Vendored
+167
View File
@@ -0,0 +1,167 @@
package privacy
import (
"errors"
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
// Privacy 小程序授权隐私设置
type Privacy struct {
*context.Context
}
// NewPrivacy 实例化小程序隐私接口
// 文档地址 https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/privacy_config/set_privacy_setting.html
func NewPrivacy(context *context.Context) *Privacy {
if context == nil {
panic("NewPrivacy got a nil context")
}
return &Privacy{
context,
}
}
// OwnerSetting 收集方（开发者）信息配置
type OwnerSetting struct {
ContactEmail string `json:"contact_email"`
ContactPhone string `json:"contact_phone"`
ContactQQ string `json:"contact_qq"`
ContactWeixin string `json:"contact_weixin"`
ExtFileMediaID string `json:"ext_file_media_id"`
NoticeMethod string `json:"notice_method"`
StoreExpireTimestamp string `json:"store_expire_timestamp"`
}
// SettingItem 收集权限的配置
type SettingItem struct {
PrivacyKey string `json:"privacy_key"`
PrivacyText string `json:"privacy_text"`
}
// SetPrivacySettingRequest 设置权限的请求参数
type SetPrivacySettingRequest struct {
PrivacyVer int `json:"privacy_ver"`
OwnerSetting OwnerSetting `json:"owner_setting"`
SettingList []SettingItem `json:"setting_list"`
}
const (
setPrivacySettingURL = "https://api.weixin.qq.com/cgi-bin/component/setprivacysetting"
getPrivacySettingURL = "https://api.weixin.qq.com/cgi-bin/component/getprivacysetting"
uploadPrivacyExtFileURL = "https://api.weixin.qq.com/cgi-bin/component/uploadprivacyextfile"
// PrivacyV1 用户隐私保护指引的版本，1表示现网版本。
PrivacyV1 = 1
// PrivacyV2 2表示开发版。默认是2开发版。
PrivacyV2 = 2
)
// GetPrivacySettingResponse 获取权限配置的响应结果
type GetPrivacySettingResponse struct {
util.CommonError
CodeExist int `json:"code_exist"`
PrivacyList []string `json:"privacy_list"`
SettingList []SettingResponseItem `json:"setting_list"`
UpdateTime int64 `json:"update_time"`
OwnerSetting OwnerSetting `json:"owner_setting"`
PrivacyDesc DescList `json:"privacy_desc"`
}
// SettingResponseItem 获取权限设置的响应明细
type SettingResponseItem struct {
PrivacyKey string `json:"privacy_key"`
PrivacyText string `json:"privacy_text"`
PrivacyLabel string `json:"privacy_label"`
}
// DescList 权限列表(保持与官方一致)
type DescList struct {
PrivacyDescList []Desc `json:"privacy_desc_list"`
}
// Desc 权限列表明细(保持与官方一致)
type Desc struct {
PrivacyDesc string `json:"privacy_desc"`
PrivacyKey string `json:"privacy_key"`
}
// GetPrivacySetting 获取小程序权限配置
func (s *Privacy) GetPrivacySetting(privacyVer int) (GetPrivacySettingResponse, error) {
accessToken, err := s.GetAccessToken()
if err != nil {
return GetPrivacySettingResponse{}, err
}
response, err := util.PostJSON(fmt.Sprintf("%s?access_token=%s", getPrivacySettingURL, accessToken), map[string]int{
"privacy_ver": privacyVer,
})
if err != nil {
return GetPrivacySettingResponse{}, err
}
// 返回错误信息
var result GetPrivacySettingResponse
if err = util.DecodeWithError(response, &result, "getprivacysetting"); err != nil {
return GetPrivacySettingResponse{}, err
}
return result, nil
}
// 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时，该参数不可传")
}
accessToken, err := s.GetAccessToken()
if err != nil {
return err
}
response, err := util.PostJSON(fmt.Sprintf("%s?access_token=%s", setPrivacySettingURL, accessToken), SetPrivacySettingRequest{
PrivacyVer: privacyVer,
OwnerSetting: ownerSetting,
SettingList: settingList,
})
if err != nil {
return err
}
// 返回错误信息
if err = util.DecodeWithCommonError(response, "setprivacysetting"); err != nil {
return err
}
return err
}
// UploadPrivacyExtFileResponse 上传权限定义模板响应参数
type UploadPrivacyExtFileResponse struct {
util.CommonError
ExtFileMediaID string `json:"ext_file_media_id"`
}
// UploadPrivacyExtFile 上传权限定义模板
func (s *Privacy) UploadPrivacyExtFile(fileData []byte) (UploadPrivacyExtFileResponse, error) {
accessToken, err := s.GetAccessToken()
if err != nil {
return UploadPrivacyExtFileResponse{}, err
}
response, err := util.PostJSON(fmt.Sprintf("%s?access_token=%s", uploadPrivacyExtFileURL, accessToken), map[string][]byte{
"file": fileData,
})
if err != nil {
return UploadPrivacyExtFileResponse{}, err
}
// 返回错误信息
var result UploadPrivacyExtFileResponse
if err = util.DecodeWithError(response, &result, "setprivacysetting"); err != nil {
return UploadPrivacyExtFileResponse{}, err
}
return result, err
}
vendor/github.com/silenceper/wechat/v2/miniprogram/qrcode/qrcode.go
Generated Vendored
+106
View File
@@ -0,0 +1,106 @@
package qrcode
import (
"encoding/json"
"fmt"
"strings"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
createWXAQRCodeURL = "https://api.weixin.qq.com/cgi-bin/wxaapp/createwxaqrcode?access_token=%s"
getWXACodeURL = "https://api.weixin.qq.com/wxa/getwxacode?access_token=%s"
getWXACodeUnlimitURL = "https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=%s"
)
// QRCode struct
type QRCode struct {
*context.Context
}
// NewQRCode 实例
func NewQRCode(context *context.Context) *QRCode {
qrCode := new(QRCode)
qrCode.Context = context
return qrCode
}
// Color QRCode color
type Color struct {
R string `json:"r"`
G string `json:"g"`
B string `json:"b"`
}
// QRCoder 小程序码参数
type QRCoder struct {
// page 必须是已经发布的小程序存在的页面,根路径前不要填加 /,不能携带参数（参数请放在scene字段里），如果不填写这个字段，默认跳主页面
Page string `json:"page,omitempty"`
// path 扫码进入的小程序页面路径
Path string `json:"path,omitempty"`
// checkPath 检查page 是否存在，为 true 时 page 必须是已经发布的小程序存在的页面（否则报错）；为 false 时允许小程序未发布或者 page 不存在， 但page 有数量上限（60000个）请勿滥用
CheckPath bool `json:"check_path,omitempty"`
// width 图片宽度
Width int `json:"width,omitempty"`
// scene 最大32个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()*+,/:;=?@-._~，其它字符请自行编码为合法字符（因不支持%，中文无法使用 urlencode 处理，请使用其他编码方式）
Scene string `json:"scene,omitempty"`
// autoColor 自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调
AutoColor bool `json:"auto_color,omitempty"`
// lineColor AutoColor 为 false 时生效，使用 rgb 设置颜色 例如 {"r":"xxx","g":"xxx","b":"xxx"},十进制表示
LineColor Color `json:"line_color,omitempty"`
// isHyaline 是否需要透明底色
IsHyaline bool `json:"is_hyaline,omitempty"`
// envVersion 要打开的小程序版本。正式版为 "release"，体验版为 "trial"，开发版为 "develop"
EnvVersion string `json:"env_version,omitempty"`
}
// fetchCode 请求并返回二维码二进制数据
func (qrCode *QRCode) fetchCode(urlStr string, body interface{}) (response []byte, err error) {
var accessToken string
accessToken, err = qrCode.GetAccessToken()
if err != nil {
return
}
urlStr = fmt.Sprintf(urlStr, accessToken)
var contentType string
response, contentType, err = util.PostJSONWithRespContentType(urlStr, body)
if err != nil {
return
}
if strings.HasPrefix(contentType, "application/json") {
// 返回错误信息
var result util.CommonError
err = json.Unmarshal(response, &result)
if err == nil && result.ErrCode != 0 {
err = fmt.Errorf("fetchCode error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return nil, err
}
}
if contentType == "image/jpeg" {
// 返回文件
return response, nil
}
err = fmt.Errorf("fetchCode error : unknown response content type - %v", contentType)
return nil, err
}
// CreateWXAQRCode 获取小程序二维码，适用于需要的码数量较少的业务场景
// 文档地址： 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
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
func (qrCode *QRCode) GetWXACodeUnlimit(coderParams QRCoder) (response []byte, err error) {
return qrCode.fetchCode(getWXACodeUnlimitURL, coderParams)
}
vendor/github.com/silenceper/wechat/v2/miniprogram/shortlink/shortlink.go
Generated Vendored
+86
View File
@@ -0,0 +1,86 @@
package shortlink
import (
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
generateShortLinkURL = "https://api.weixin.qq.com/wxa/genwxashortlink?access_token=%s"
)
// ShortLink 短链接
type ShortLink struct {
*context.Context
}
// NewShortLink 实例
func NewShortLink(ctx *context.Context) *ShortLink {
return &ShortLink{ctx}
}
// ShortLinker 请求结构体
type ShortLinker struct {
// pageUrl 通过 Short Link 进入的小程序页面路径，必须是已经发布的小程序存在的页面，可携带 query，最大1024个字符
PageURL string `json:"page_url"`
// pageTitle 页面标题，不能包含违法信息，超过20字符会用... 截断代替
PageTitle string `json:"page_title"`
// isPermanent 生成的 Short Link 类型，短期有效：false，永久有效：true
IsPermanent bool `json:"is_permanent,omitempty"`
}
// resShortLinker 返回结构体
type resShortLinker struct {
// 通用错误
*util.CommonError
// 返回的 shortLink
Link string `json:"link"`
}
// Generate 生成 shortLink
func (shortLink *ShortLink) generate(shortLinkParams ShortLinker) (string, error) {
var accessToken string
accessToken, err := shortLink.GetAccessToken()
if err != nil {
return "", err
}
urlStr := fmt.Sprintf(generateShortLinkURL, accessToken)
response, err := util.PostJSON(urlStr, shortLinkParams)
if err != nil {
return "", err
}
// 使用通用方法返回错误
var res resShortLinker
err = util.DecodeWithError(response, &res, "GenerateShortLink")
if err != nil {
return "", err
}
return res.Link, nil
}
// GenerateShortLinkPermanent 生成永久shortLink
func (shortLink *ShortLink) GenerateShortLinkPermanent(PageURL, pageTitle string) (string, error) {
return shortLink.generate(ShortLinker{
PageURL: PageURL,
PageTitle: pageTitle,
IsPermanent: true,
})
}
// GenerateShortLinkTemp 生成临时shortLink
func (shortLink *ShortLink) GenerateShortLinkTemp(PageURL, pageTitle string) (string, error) {
return shortLink.generate(ShortLinker{
PageURL: PageURL,
PageTitle: pageTitle,
IsPermanent: false,
})
}
vendor/github.com/silenceper/wechat/v2/miniprogram/subscribe/subscribe.go
Generated Vendored
+195
View File
@@ -0,0 +1,195 @@
package subscribe
import (
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
// 发送订阅消息
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.send.html
subscribeSendURL = "https://api.weixin.qq.com/cgi-bin/message/subscribe/send"
// 获取当前帐号下的个人模板列表
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.getTemplateList.html
getTemplateURL = "https://api.weixin.qq.com/wxaapi/newtmpl/gettemplate"
// 添加订阅模板
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.addTemplate.html
addTemplateURL = "https://api.weixin.qq.com/wxaapi/newtmpl/addtemplate"
// 删除私有模板
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.deleteTemplate.html
delTemplateURL = "https://api.weixin.qq.com/wxaapi/newtmpl/deltemplate"
// 统一服务消息
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/uniform-message/uniformMessage.send.html
uniformMessageSend = "https://api.weixin.qq.com/cgi-bin/message/wxopen/template/uniform_send"
)
// Subscribe 订阅消息
type Subscribe struct {
*context.Context
}
// NewSubscribe 实例化
func NewSubscribe(ctx *context.Context) *Subscribe {
return &Subscribe{Context: ctx}
}
// 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
}
// DataItem 模版内某个 .DATA 的值
type DataItem struct {
Value interface{} `json:"value"`
Color string `json:"color"`
}
// TemplateItem template item
type TemplateItem struct {
PriTmplID string `json:"priTmplId"`
Title string `json:"title"`
Content string `json:"content"`
Example string `json:"example"`
Type int64 `json:"type"`
}
// TemplateList template list
type TemplateList struct {
util.CommonError
Data []TemplateItem `json:"data"`
}
// Send 发送订阅消息
func (s *Subscribe) Send(msg *Message) (err error) {
var accessToken string
accessToken, err = s.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", subscribeSendURL, accessToken)
response, err := util.PostJSON(uri, msg)
if err != nil {
return
}
return util.DecodeWithCommonError(response, "Send")
}
// ListTemplates 获取当前帐号下的个人模板列表
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.getTemplateList.html
func (s *Subscribe) ListTemplates() (*TemplateList, error) {
accessToken, err := s.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", getTemplateURL, accessToken)
response, err := util.HTTPGet(uri)
if err != nil {
return nil, err
}
templateList := TemplateList{}
err = util.DecodeWithError(response, &templateList, "ListTemplates")
if err != nil {
return nil, err
}
return &templateList, nil
}
// UniformMessage 统一服务消息
type UniformMessage struct {
ToUser string `json:"touser"`
WeappTemplateMsg struct {
TemplateID string `json:"template_id"`
Page string `json:"page"`
FormID string `json:"form_id"`
Data map[string]*DataItem `json:"data"`
EmphasisKeyword string `json:"emphasis_keyword"`
} `json:"weapp_template_msg"`
MpTemplateMsg struct {
Appid string `json:"appid"`
TemplateID string `json:"template_id"`
URL string `json:"url"`
Miniprogram struct {
Appid string `json:"appid"`
Pagepath string `json:"pagepath"`
} `json:"miniprogram"`
Data map[string]*DataItem `json:"data"`
} `json:"mp_template_msg"`
}
// UniformSend 发送统一服务消息
func (s *Subscribe) UniformSend(msg *UniformMessage) (err error) {
var accessToken string
accessToken, err = s.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uniformMessageSend, accessToken)
response, err := util.PostJSON(uri, msg)
if err != nil {
return
}
return util.DecodeWithCommonError(response, "UniformSend")
}
type resSubscribeAdd struct {
util.CommonError
TemplateID string `json:"priTmplId"`
}
// Add 添加订阅消息模板
func (s *Subscribe) Add(ShortID string, kidList []int, sceneDesc string) (templateID string, err error) {
var accessToken string
accessToken, err = s.GetAccessToken()
if err != nil {
return
}
var msg = struct {
TemplateIDShort string `json:"tid"`
SceneDesc string `json:"sceneDesc"`
KidList []int `json:"kidList"`
}{TemplateIDShort: ShortID, SceneDesc: sceneDesc, KidList: kidList}
uri := fmt.Sprintf("%s?access_token=%s", addTemplateURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, msg)
if err != nil {
return
}
var result resSubscribeAdd
err = util.DecodeWithError(response, &result, "AddSubscribe")
if err != nil {
return
}
templateID = result.TemplateID
return
}
// Delete 删除私有模板
func (s *Subscribe) Delete(templateID string) (err error) {
var accessToken string
accessToken, err = s.GetAccessToken()
if err != nil {
return
}
var msg = struct {
TemplateID string `json:"priTmplId"`
}{TemplateID: templateID}
uri := fmt.Sprintf("%s?access_token=%s", delTemplateURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, msg)
if err != nil {
return
}
return util.DecodeWithCommonError(response, "DeleteSubscribe")
}
vendor/github.com/silenceper/wechat/v2/miniprogram/tcb/README.md
Generated Vendored
+32
View File
@@ -0,0 +1,32 @@
# 小程序-云开发 SDK
Tencent Cloud Base [文档](https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/)
## 使用说明
**初始化配置**
```golang
//使用memcache保存access_token，也可选择redis或自定义cache
memCache=cache.NewMemcache("127.0.0.1:11211")
//配置小程序参数
config := &wechat.Config{
AppID: "your app id",
AppSecret: "your app secret",
Cache: memCache,
}
wc := wechat.NewWechat(config)
wcTcb := wc.GetTcb()
```
### 举例
#### 触发云函数
```golang
res, err := wcTcb.InvokeCloudFunction("test-xxxx", "add", `{"a":1,"b":2}`)
if err != nil {
panic(err)
}
```
更多使用方法参考[PKG.DEV](https://pkg.go.dev/github.com/silenceper/wechat/v2/miniprogram/tcb)
vendor/github.com/silenceper/wechat/v2/miniprogram/tcb/cloudfunction.go
Generated Vendored
+35
View File
@@ -0,0 +1,35 @@
package tcb
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
// 触发云函数
invokeCloudFunctionURL = "https://api.weixin.qq.com/tcb/invokecloudfunction"
)
// InvokeCloudFunctionRes 云函数调用返回结果
type InvokeCloudFunctionRes struct {
util.CommonError
RespData string `json:"resp_data"` // 云函数返回的buffer
}
// InvokeCloudFunction 云函数调用
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/functions/invokeCloudFunction.html
func (tcb *Tcb) InvokeCloudFunction(env, name, args string) (*InvokeCloudFunctionRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s&env=%s&name=%s", invokeCloudFunctionURL, accessToken, env, name)
response, err := util.HTTPPost(uri, args)
if err != nil {
return nil, err
}
invokeCloudFunctionRes := &InvokeCloudFunctionRes{}
err = util.DecodeWithError(response, invokeCloudFunctionRes, "InvokeCloudFunction")
return invokeCloudFunctionRes, err
}
vendor/github.com/silenceper/wechat/v2/miniprogram/tcb/database.go
Generated Vendored
+418
View File
@@ -0,0 +1,418 @@
package tcb
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
// 数据库导入
databaseMigrateImportURL = "https://api.weixin.qq.com/tcb/databasemigrateimport"
// 数据库导出
databaseMigrateExportURL = "https://api.weixin.qq.com/tcb/databasemigrateexport"
// 数据库迁移状态查询
databaseMigrateQueryInfoURL = "https://api.weixin.qq.com/tcb/databasemigratequeryinfo"
// 变更数据库索引
updateIndexURL = "https://api.weixin.qq.com/tcb/updateindex"
// 新增集合
databaseCollectionAddURL = "https://api.weixin.qq.com/tcb/databasecollectionadd"
// 删除集合
databaseCollectionDeleteURL = "https://api.weixin.qq.com/tcb/databasecollectiondelete"
// 获取特定云环境下集合信息
databaseCollectionGetURL = "https://api.weixin.qq.com/tcb/databasecollectionget"
// 数据库插入记录
databaseAddURL = "https://api.weixin.qq.com/tcb/databaseadd"
// 数据库删除记录
databaseDeleteURL = "https://api.weixin.qq.com/tcb/databasedelete"
// 数据库更新记录
databaseUpdateURL = "https://api.weixin.qq.com/tcb/databaseupdate"
// 数据库查询记录
databaseQueryURL = "https://api.weixin.qq.com/tcb/databasequery"
// 统计集合记录数或统计查询语句对应的结果记录数
databaseCountURL = "https://api.weixin.qq.com/tcb/databasecount"
// ConflictModeInster 冲突处理模式 插入
ConflictModeInster ConflictMode = 1
// ConflictModeUpsert 冲突处理模式 更新
ConflictModeUpsert ConflictMode = 2
// FileTypeJSON 的合法值 json
FileTypeJSON FileType = 1
// FileTypeCsv 的合法值 csv
FileTypeCsv FileType = 2
)
// ConflictMode 冲突处理模式
type ConflictMode int
// FileType 文件上传和导出的允许文件类型
type FileType int
// 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上传）
FileType FileType `json:"file_type,omitempty"` // 导出文件类型，文件格式参考数据库导入指引中的文件格式部分 1:json 2:csv
Query string `json:"query,omitempty"` // 导出条件
}
// DatabaseMigrateExportRes 数据库导出 返回结果
type DatabaseMigrateExportRes struct {
util.CommonError
JobID int64 `json:"job_id"` // 导出任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
}
// DatabaseMigrateImportReq 数据库导入 请求参数
type DatabaseMigrateImportReq struct {
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
StopOnError bool `json:"stop_on_error,omitempty"` // 是否在遇到错误时停止导入
ConflictMode ConflictMode `json:"conflict_mode,omitempty"` // 冲突处理模式 1:inster 2:UPSERT
}
// DatabaseMigrateImportRes 数据库导入 返回结果
type DatabaseMigrateImportRes struct {
util.CommonError
JobID int64 `json:"job_id"` // 导入任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
}
// DatabaseMigrateQueryInfoRes 数据库迁移状态查询
type DatabaseMigrateQueryInfoRes struct {
util.CommonError
Status string `json:"status"` // 导出状态
RecordSuccess int64 `json:"record_success"` // 导出成功记录数
RecordFail int64 `json:"record_fail"` // 导出失败记录数
ErrMsg string `json:"err_msg"` // 导出错误信息
FileURL string `json:"file_url"` // 导出文件下载地址
}
// UpdateIndexReq 变更数据库索引 请求参数
type UpdateIndexReq struct {
Env string `json:"env,omitempty"` // 云环境ID
CollectionName string `json:"collection_name,omitempty"` // 集合名称
CreateIndexes []CreateIndex `json:"create_indexes,omitempty"` // 新增索引
DropIndexes []DropIndex `json:"drop_indexes,omitempty"` // 删除索引
}
// CreateIndex 新增索引
type CreateIndex struct {
Name string `json:"name,omitempty"` // 索引名
Unique bool `json:"unique,omitempty"` // 是否唯一
Keys []CreateIndexKey `json:"keys,omitempty"` // 索引字段
}
// CreateIndexKey create index key
type CreateIndexKey struct {
Name string `json:"name,omitempty"` // 字段名
Direction string `json:"direction,omitempty"` // 字段排序
}
// DropIndex 删除索引
type DropIndex struct {
Name string `json:"name,omitempty"`
}
// DatabaseCollectionReq 新增/删除集合请求参数
type DatabaseCollectionReq struct {
Env string `json:"env,omitempty"` // 云环境ID
CollectionName string `json:"collection_name,omitempty"` // 集合名称
}
// DatabaseCollectionGetReq 获取特定云环境下集合信息请求
type DatabaseCollectionGetReq struct {
Env string `json:"env,omitempty"` // 云环境ID
Limit int64 `json:"limit,omitempty"` // 获取数量限制
Offset int64 `json:"offset,omitempty"` // 偏移量
}
// DatabaseCollectionGetRes 获取特定云环境下集合信息结果
type DatabaseCollectionGetRes struct {
util.CommonError
Pager struct {
Limit int64 `json:"limit"` // 单次查询限制
Offset int64 `json:"offset"` // 偏移量
Total int64 `json:"total"` // 符合查询条件的记录总数
} `json:"pager"`
Collections []struct {
Name string `json:"name"` // 集合名
Count int64 `json:"count"` // 表中文档数量
Size int64 `json:"size"` // 表的大小（即表中文档总大小），单位：字节
IndexCount int64 `json:"index_count"` // 索引数量
IndexSize int64 `json:"index_size"` // 索引占用大小，单位：字节
} `json:"collections"`
}
// DatabaseReq 数据库插入/删除/更新/查询/统计记录请求参数
type DatabaseReq struct {
Env string `json:"env,omitempty"` // 云环境ID
Query string `json:"query,omitempty"` // 数据库操作语句
}
// DatabaseAddRes 数据库插入记录返回结果
type DatabaseAddRes struct {
util.CommonError
IDList []string `json:"id_list"` // 插入成功的数据集合主键_id。
}
// DatabaseDeleteRes 数据库删除记录返回结果
type DatabaseDeleteRes struct {
util.CommonError
Deleted int64 `json:"deleted"` // 删除记录数量
}
// DatabaseUpdateRes 数据库更新记录返回结果
type DatabaseUpdateRes struct {
util.CommonError
Matched int64 `json:"matched"` // 更新条件匹配到的结果数
Modified int64 `json:"modified"` // 修改的记录数，注意：使用set操作新插入的数据不计入修改数目
ID string `json:"id"`
}
// DatabaseQueryRes 数据库查询记录 返回结果
type DatabaseQueryRes struct {
util.CommonError
Pager struct {
Limit int64 `json:"limit"` // 单次查询限制
Offset int64 `json:"offset"` // 偏移量
Total int64 `json:"total"` // 符合查询条件的记录总数
} `json:"pager"`
Data []string `json:"data"`
}
// DatabaseCountRes 统计集合记录数或统计查询语句对应的结果记录数 返回结果
type DatabaseCountRes struct {
util.CommonError
Count int64 `json:"count"` // 记录数量
}
// DatabaseMigrateImport 数据库导入
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseMigrateImport.html
func (tcb *Tcb) DatabaseMigrateImport(req *DatabaseMigrateImportReq) (*DatabaseMigrateImportRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseMigrateImportURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
databaseMigrateImportRes := &DatabaseMigrateImportRes{}
err = util.DecodeWithError(response, databaseMigrateImportRes, "DatabaseMigrateImport")
return databaseMigrateImportRes, err
}
// DatabaseMigrateExport 数据库导出
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseMigrateExport.html
func (tcb *Tcb) DatabaseMigrateExport(req *DatabaseMigrateExportReq) (*DatabaseMigrateExportRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseMigrateExportURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
databaseMigrateExportRes := &DatabaseMigrateExportRes{}
err = util.DecodeWithError(response, databaseMigrateExportRes, "DatabaseMigrateExport")
return databaseMigrateExportRes, err
}
// DatabaseMigrateQueryInfo 数据库迁移状态查询
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseMigrateQueryInfo.html
func (tcb *Tcb) DatabaseMigrateQueryInfo(env string, jobID int64) (*DatabaseMigrateQueryInfoRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseMigrateQueryInfoURL, accessToken)
response, err := util.PostJSON(uri, map[string]interface{}{
"env": env,
"job_id": jobID,
})
if err != nil {
return nil, err
}
databaseMigrateQueryInfoRes := &DatabaseMigrateQueryInfoRes{}
err = util.DecodeWithError(response, databaseMigrateQueryInfoRes, "DatabaseMigrateQueryInfo")
return databaseMigrateQueryInfoRes, err
}
// UpdateIndex 变更数据库索引
// https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/updateIndex.html
func (tcb *Tcb) UpdateIndex(req *UpdateIndexReq) error {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", updateIndexURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "UpdateIndex")
}
// DatabaseCollectionAdd 新增集合
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseCollectionAdd.html
func (tcb *Tcb) DatabaseCollectionAdd(env, collectionName string) error {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseCollectionAddURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseCollectionReq{
Env: env,
CollectionName: collectionName,
})
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "DatabaseCollectionAdd")
}
// DatabaseCollectionDelete 删除集合
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseCollectionDelete.html
func (tcb *Tcb) DatabaseCollectionDelete(env, collectionName string) error {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseCollectionDeleteURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseCollectionReq{
Env: env,
CollectionName: collectionName,
})
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "DatabaseCollectionDelete")
}
// DatabaseCollectionGet 获取特定云环境下集合信息
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseCollectionGet.html
func (tcb *Tcb) DatabaseCollectionGet(env string, limit, offset int64) (*DatabaseCollectionGetRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseCollectionGetURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseCollectionGetReq{
Env: env,
Limit: limit,
Offset: offset,
})
if err != nil {
return nil, err
}
databaseCollectionGetRes := &DatabaseCollectionGetRes{}
err = util.DecodeWithError(response, databaseCollectionGetRes, "DatabaseCollectionGet")
return databaseCollectionGetRes, err
}
// DatabaseAdd 数据库插入记录
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseAdd.html
func (tcb *Tcb) DatabaseAdd(env, query string) (*DatabaseAddRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseAddURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseReq{
Env: env,
Query: query,
})
if err != nil {
return nil, err
}
databaseAddRes := &DatabaseAddRes{}
err = util.DecodeWithError(response, databaseAddRes, "DatabaseAdd")
return databaseAddRes, err
}
// DatabaseDelete 数据库插入记录
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseDelete.html
func (tcb *Tcb) DatabaseDelete(env, query string) (*DatabaseDeleteRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseDeleteURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseReq{
Env: env,
Query: query,
})
if err != nil {
return nil, err
}
databaseDeleteRes := &DatabaseDeleteRes{}
err = util.DecodeWithError(response, databaseDeleteRes, "DatabaseDelete")
return databaseDeleteRes, err
}
// DatabaseUpdate 数据库插入记录
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseUpdate.html
func (tcb *Tcb) DatabaseUpdate(env, query string) (*DatabaseUpdateRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseUpdateURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseReq{
Env: env,
Query: query,
})
if err != nil {
return nil, err
}
databaseUpdateRes := &DatabaseUpdateRes{}
err = util.DecodeWithError(response, databaseUpdateRes, "DatabaseUpdate")
return databaseUpdateRes, err
}
// DatabaseQuery 数据库查询记录
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseQuery.html
func (tcb *Tcb) DatabaseQuery(env, query string) (*DatabaseQueryRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseQueryURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseReq{
Env: env,
Query: query,
})
if err != nil {
return nil, err
}
databaseQueryRes := &DatabaseQueryRes{}
err = util.DecodeWithError(response, databaseQueryRes, "DatabaseQuery")
return databaseQueryRes, err
}
// DatabaseCount 统计集合记录数或统计查询语句对应的结果记录数
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/databaseCount.html
func (tcb *Tcb) DatabaseCount(env, query string) (*DatabaseCountRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", databaseCountURL, accessToken)
response, err := util.PostJSON(uri, &DatabaseReq{
Env: env,
Query: query,
})
if err != nil {
return nil, err
}
databaseCountRes := &DatabaseCountRes{}
err = util.DecodeWithError(response, databaseCountRes, "DatabaseCount")
return databaseCountRes, err
}
vendor/github.com/silenceper/wechat/v2/miniprogram/tcb/file.go
Generated Vendored
+134
View File
@@ -0,0 +1,134 @@
package tcb
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
// 获取文件上传链接
uploadFilePathURL = "https://api.weixin.qq.com/tcb/uploadfile"
// 获取文件下载链接
batchDownloadFileURL = "https://api.weixin.qq.com/tcb/batchdownloadfile"
// 删除文件链接
batchDeleteFileURL = "https://api.weixin.qq.com/tcb/batchdeletefile"
)
// UploadFileReq 上传文件请求值
type UploadFileReq struct {
Env string `json:"env,omitempty"`
Path string `json:"path,omitempty"`
}
// UploadFileRes 上传文件返回结果
type UploadFileRes struct {
util.CommonError
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
}
// BatchDownloadFileReq 上传文件请求值
type BatchDownloadFileReq struct {
Env string `json:"env,omitempty"`
FileList []*DownloadFile `json:"file_list,omitempty"`
}
// DownloadFile 文件信息
type DownloadFile struct {
FileID string `json:"fileid"` // 文件ID
MaxAge int64 `json:"max_age"` // 下载链接有效期
}
// BatchDownloadFileRes 上传文件返回结果
type BatchDownloadFileRes struct {
util.CommonError
FileList []struct {
FileID string `json:"file_id"` // 文件ID
DownloadURL string `json:"download_url"` // 下载链接
Status int64 `json:"status"` // 状态码
ErrMsg string `json:"errmsg"` // 该文件错误信息
} `json:"file_list"`
}
// BatchDeleteFileReq 批量删除文件请求参数
type BatchDeleteFileReq struct {
Env string `json:"env,omitempty"`
FileIDList []string `json:"fileid_list,omitempty"`
}
// BatchDeleteFileRes 批量删除文件返回结果
type BatchDeleteFileRes struct {
util.CommonError
DeleteList []struct {
FileID string `json:"fileid"`
Status int64 `json:"status"`
ErrMsg string `json:"errmsg"`
} `json:"delete_list"`
}
// UploadFile 上传文件
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/storage/uploadFile.html
func (tcb *Tcb) UploadFile(env, path string) (*UploadFileRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", uploadFilePathURL, accessToken)
req := &UploadFileReq{
Env: env,
Path: path,
}
response, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
uploadFileRes := &UploadFileRes{}
err = util.DecodeWithError(response, uploadFileRes, "UploadFile")
return uploadFileRes, err
}
// BatchDownloadFile 获取文件下载链接
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/storage/batchDownloadFile.html
func (tcb *Tcb) BatchDownloadFile(env string, fileList []*DownloadFile) (*BatchDownloadFileRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", batchDownloadFileURL, accessToken)
req := &BatchDownloadFileReq{
Env: env,
FileList: fileList,
}
response, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
batchDownloadFileRes := &BatchDownloadFileRes{}
err = util.DecodeWithError(response, batchDownloadFileRes, "BatchDownloadFile")
return batchDownloadFileRes, err
}
// BatchDeleteFile 批量删除文件
//reference:https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/storage/batchDeleteFile.html
func (tcb *Tcb) BatchDeleteFile(env string, fileIDList []string) (*BatchDeleteFileRes, error) {
accessToken, err := tcb.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", batchDeleteFileURL, accessToken)
req := &BatchDeleteFileReq{
Env: env,
FileIDList: fileIDList,
}
response, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
batchDeleteFileRes := &BatchDeleteFileRes{}
err = util.DecodeWithError(response, batchDeleteFileRes, "BatchDeleteFile")
return batchDeleteFileRes, err
}
vendor/github.com/silenceper/wechat/v2/miniprogram/tcb/tcb.go
Generated Vendored
+15
View File
@@ -0,0 +1,15 @@
package tcb
import "github.com/silenceper/wechat/v2/miniprogram/context"
// Tcb Tencent Cloud Base
type Tcb struct {
*context.Context
}
// NewTcb new Tencent Cloud Base
func NewTcb(context *context.Context) *Tcb {
return &Tcb{
context,
}
}
vendor/github.com/silenceper/wechat/v2/miniprogram/urllink/urllink.go
Generated Vendored
+72
View File
@@ -0,0 +1,72 @@
package urllink
import (
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
// URLLink 小程序 URL Link
type URLLink struct {
*context.Context
}
// NewURLLink 实例化
func NewURLLink(ctx *context.Context) *URLLink {
return &URLLink{Context: ctx}
}
const generateURL = "https://api.weixin.qq.com/wxa/generate_urllink"
// TExpireType 失效类型 (指定时间戳/指定间隔)
type TExpireType int
const (
// ExpireTypeTime 指定时间戳后失效
ExpireTypeTime TExpireType = 0
// ExpireTypeInterval 间隔指定天数后失效
ExpireTypeInterval TExpireType = 1
)
// ULParams 请求参数
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-link/urllink.generate.html#请求参数
type ULParams struct {
Path string `json:"path"`
Query string `json:"query"`
// envVersion 要打开的小程序版本。正式版为 "release"，体验版为 "trial"，开发版为 "develop"
EnvVersion string `json:"env_version,omitempty"`
IsExpire bool `json:"is_expire"`
ExpireType TExpireType `json:"expire_type"`
ExpireTime int64 `json:"expire_time"`
ExpireInterval int `json:"expire_interval"`
}
// ULResult 返回的结果
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-link/urllink.generate.html#返回值
type ULResult struct {
util.CommonError
URLLink string `json:"url_link"`
}
// Generate 生成url link
func (u *URLLink) Generate(params *ULParams) (string, error) {
accessToken, err := u.GetAccessToken()
if err != nil {
return "", err
}
uri := fmt.Sprintf("%s?access_token=%s", generateURL, accessToken)
response, err := util.PostJSON(uri, params)
if err != nil {
return "", err
}
var resp ULResult
err = util.DecodeWithError(response, &resp, "URLLink.Generate")
if err != nil {
return "", err
}
return resp.URLLink, nil
}
vendor/github.com/silenceper/wechat/v2/miniprogram/werun/werun.go
Generated Vendored
+40
View File
@@ -0,0 +1,40 @@
package werun
import (
"encoding/json"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/miniprogram/encryptor"
)
// WeRun 微信运动
type WeRun struct {
*context.Context
}
// Data 微信运动数据
type Data struct {
StepInfoList []struct {
Timestamp int `json:"timestamp"`
Step int `json:"step"`
} `json:"stepInfoList"`
}
// NewWeRun 实例化
func NewWeRun(ctx *context.Context) *WeRun {
return &WeRun{Context: ctx}
}
// GetWeRunData 解密数据
func (werun *WeRun) GetWeRunData(sessionKey, encryptedData, iv string) (*Data, error) {
cipherText, err := encryptor.GetCipherText(sessionKey, encryptedData, iv)
if err != nil {
return nil, err
}
var weRunData Data
err = json.Unmarshal(cipherText, &weRunData)
if err != nil {
return nil, err
}
return &weRunData, nil
}
vendor/github.com/silenceper/wechat/v2/officialaccount/README.md
Generated Vendored
+5
View File
@@ -0,0 +1,5 @@
# 微信公众号
[官方文档](https://developers.weixin.qq.com/doc/offiaccount/Getting_Started/Overview.html)
## 快速入门
vendor/github.com/silenceper/wechat/v2/officialaccount/basic/basic.go
Generated Vendored
+84
View File
@@ -0,0 +1,84 @@
package basic
import (
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
var (
// 获取微信服务器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"
// 清理接口调用次数
clearQuotaURL = "https://api.weixin.qq.com/cgi-bin/clear_quota"
)
// Basic struct
type Basic struct {
*context.Context
}
// NewBasic 实例
func NewBasic(context *context.Context) *Basic {
basic := new(Basic)
basic.Context = context
return basic
}
// IPListRes 获取微信服务器IP地址 返回结果
type IPListRes struct {
util.CommonError
IPList []string `json:"ip_list"`
}
// GetCallbackIP 获取微信callback IP地址
func (basic *Basic) GetCallbackIP() ([]string, error) {
ak, err := basic.GetAccessToken()
if err != nil {
return nil, err
}
url := fmt.Sprintf("%s?access_token=%s", getCallbackIPURL, ak)
data, err := util.HTTPGet(url)
if err != nil {
return nil, err
}
ipListRes := &IPListRes{}
err = util.DecodeWithError(data, ipListRes, "GetCallbackIP")
return ipListRes.IPList, err
}
// GetAPIDomainIP 获取微信API接口 IP地址
func (basic *Basic) GetAPIDomainIP() ([]string, error) {
ak, err := basic.GetAccessToken()
if err != nil {
return nil, err
}
url := fmt.Sprintf("%s?access_token=%s", getAPIDomainIPURL, ak)
data, err := util.HTTPGet(url)
if err != nil {
return nil, err
}
ipListRes := &IPListRes{}
err = util.DecodeWithError(data, ipListRes, "GetAPIDomainIP")
return ipListRes.IPList, err
}
// ClearQuota 清理接口调用次数
func (basic *Basic) ClearQuota() error {
ak, err := basic.GetAccessToken()
if err != nil {
return err
}
url := fmt.Sprintf("%s?access_token=%s", clearQuotaURL, ak)
data, err := util.PostJSON(url, map[string]string{
"appid": basic.AppID,
})
if err != nil {
return err
}
return util.DecodeWithCommonError(data, "ClearQuota")
}
vendor/github.com/silenceper/wechat/v2/officialaccount/basic/qr.go
Generated Vendored
+114
View File
@@ -0,0 +1,114 @@
package basic
import (
"encoding/json"
"fmt"
"reflect"
"time"
"github.com/silenceper/wechat/v2/util"
)
const (
qrCreateURL = "https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=%s"
getQRImgURL = "https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=%s"
)
const (
actionID = "QR_SCENE"
actionStr = "QR_STR_SCENE"
actionLimitID = "QR_LIMIT_SCENE"
actionLimitStr = "QR_LIMIT_STR_SCENE"
)
// Request 临时二维码
type Request struct {
ExpireSeconds int64 `json:"expire_seconds,omitempty"`
ActionName string `json:"action_name"`
ActionInfo struct {
Scene struct {
SceneStr string `json:"scene_str,omitempty"`
SceneID int `json:"scene_id,omitempty"`
} `json:"scene"`
} `json:"action_info"`
}
// Ticket 二维码ticket
type Ticket struct {
util.CommonError `json:",inline"`
Ticket string `json:"ticket"`
ExpireSeconds int64 `json:"expire_seconds"`
URL string `json:"url"`
}
// GetQRTicket 获取二维码 Ticket
func (basic *Basic) GetQRTicket(tq *Request) (t *Ticket, err error) {
accessToken, err := basic.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(qrCreateURL, accessToken)
response, err := util.PostJSON(uri, tq)
if err != nil {
err = fmt.Errorf("get qr ticket failed, %s", err)
return
}
t = new(Ticket)
err = json.Unmarshal(response, &t)
if err != nil {
return
}
if t.ErrMsg != "" {
err = fmt.Errorf("get qr_ticket error : errcode=%v , errormsg=%v", t.ErrCode, t.ErrMsg)
return
}
return
}
// 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()),
}
switch reflect.ValueOf(scene).Kind() {
case reflect.String:
tq.ActionName = actionStr
tq.ActionInfo.Scene.SceneStr = scene.(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)
}
return tq
}
// NewLimitQrRequest 新建永久二维码请求实例
func NewLimitQrRequest(scene interface{}) *Request {
tq := &Request{}
switch reflect.ValueOf(scene).Kind() {
case reflect.String:
tq.ActionName = actionLimitStr
tq.ActionInfo.Scene.SceneStr = scene.(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)
}
return tq
}
vendor/github.com/silenceper/wechat/v2/officialaccount/basic/short_url.go
Generated Vendored
+52
View File
@@ -0,0 +1,52 @@
package basic
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
// 将一条长链接转成短链接
// https://developers.weixin.qq.com/doc/offiaccount/Account_Management/URL_Shortener.html
long2shortURL = "https://api.weixin.qq.com/cgi-bin/shorturl?access_token=%s"
long2shortAction = "long2short"
)
type (
reqLong2ShortURL struct {
Action string `json:"action"`
LongURL string `json:"long_url"`
}
resplong2ShortURL struct {
ShortURL string `json:"short_url"`
util.CommonError
}
)
// Long2ShortURL 将一条长链接转成短链接
func (basic *Basic) Long2ShortURL(longURL string) (shortURL string, err error) {
var (
req = &reqLong2ShortURL{
Action: long2shortAction,
LongURL: longURL,
}
resp = new(resplong2ShortURL)
ac, uri string
responseBytes []byte
)
ac, err = basic.GetAccessToken()
if err != nil {
return
}
uri = fmt.Sprintf(long2shortURL, ac)
responseBytes, err = util.PostJSON(uri, req)
if err != nil {
return
}
if err = util.DecodeWithError(responseBytes, resp, long2shortAction); err != nil {
return
}
shortURL = resp.ShortURL
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/broadcast/broadcast.go
Generated Vendored
+356
View File
@@ -0,0 +1,356 @@
package broadcast
import (
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
sendURLByTag = "https://api.weixin.qq.com/cgi-bin/message/mass/sendall"
sendURLByOpenID = "https://api.weixin.qq.com/cgi-bin/message/mass/send"
deleteSendURL = "https://api.weixin.qq.com/cgi-bin/message/mass/delete"
previewSendURL = "https://api.weixin.qq.com/cgi-bin/message/mass/preview"
massStatusSendURL = "https://api.weixin.qq.com/cgi-bin/message/mass/get"
getSpeedSendURL = "https://api.weixin.qq.com/cgi-bin/message/mass/speed/get"
setSpeedSendURL = "https://api.weixin.qq.com/cgi-bin/message/mass/speed/set"
)
// MsgType 发送消息类型
type MsgType string
const (
// MsgTypeNews 图文消息
MsgTypeNews MsgType = "mpnews"
// MsgTypeText 文本
MsgTypeText MsgType = "text"
// MsgTypeVoice 语音/音频
MsgTypeVoice MsgType = "voice"
// MsgTypeImage 图片
MsgTypeImage MsgType = "image"
// MsgTypeVideo 视频
MsgTypeVideo MsgType = "mpvideo"
// MsgTypeWxCard 卡券
MsgTypeWxCard MsgType = "wxcard"
)
// Broadcast 群发消息
type Broadcast struct {
*context.Context
preview bool
}
// NewBroadcast new
func NewBroadcast(ctx *context.Context) *Broadcast {
return &Broadcast{ctx, false}
}
// User 发送的用户
type User struct {
TagID int64
OpenID []string
}
// Result 群发返回结果
type Result struct {
util.CommonError
MsgID int64 `json:"msg_id"`
MsgDataID int64 `json:"msg_data_id"`
MsgStatus string `json:"msg_status"`
}
// SpeedResult 群发速度返回结果
type SpeedResult struct {
util.CommonError
Speed int64 `json:"speed"`
RealSpeed int64 `json:"realspeed"`
}
// sendRequest 发送请求的数据
type sendRequest struct {
// 根据tag获全部发送
Filter map[string]interface{} `json:"filter,omitempty"`
// 根据OpenID发送
ToUser interface{} `json:"touser,omitempty"`
// 发送文本
Text map[string]interface{} `json:"text,omitempty"`
// 发送图文消息
Mpnews map[string]interface{} `json:"mpnews,omitempty"`
// 发送语音
Voice map[string]interface{} `json:"voice,omitempty"`
// 发送图片
Images *Image `json:"images,omitempty"`
// 发送卡券
WxCard map[string]interface{} `json:"wxcard,omitempty"`
MsgType MsgType `json:"msgtype"`
SendIgnoreReprint int32 `json:"send_ignore_reprint,omitempty"`
}
// Image 发送图片
type Image struct {
MediaIDs []string `json:"media_ids"`
Recommend string `json:"recommend"`
NeedOpenComment int32 `json:"need_open_comment"`
OnlyFansCanComment int32 `json:"only_fans_can_comment"`
}
// SendText 群发文本
// 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 {
return nil, err
}
req := &sendRequest{
ToUser: nil,
MsgType: MsgTypeText,
}
req.Text = map[string]interface{}{
"content": content,
}
req, sendURL := broadcast.chooseTagOrOpenID(user, req)
url := fmt.Sprintf("%s?access_token=%s", sendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &Result{}
err = util.DecodeWithError(data, res, "SendText")
return res, err
}
// SendNews 发送图文
func (broadcast *Broadcast) SendNews(user *User, mediaID string, ignoreReprint bool) (*Result, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := &sendRequest{
ToUser: nil,
MsgType: MsgTypeNews,
}
if ignoreReprint {
req.SendIgnoreReprint = 1
}
req.Mpnews = map[string]interface{}{
"media_id": mediaID,
}
req, sendURL := broadcast.chooseTagOrOpenID(user, req)
url := fmt.Sprintf("%s?access_token=%s", sendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &Result{}
err = util.DecodeWithError(data, res, "SendNews")
return res, err
}
// SendVoice 发送语音
func (broadcast *Broadcast) SendVoice(user *User, mediaID string) (*Result, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := &sendRequest{
ToUser: nil,
MsgType: MsgTypeVoice,
}
req.Voice = map[string]interface{}{
"media_id": mediaID,
}
req, sendURL := broadcast.chooseTagOrOpenID(user, req)
url := fmt.Sprintf("%s?access_token=%s", sendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &Result{}
err = util.DecodeWithError(data, res, "SendVoice")
return res, err
}
// SendImage 发送图片
func (broadcast *Broadcast) SendImage(user *User, images *Image) (*Result, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := &sendRequest{
ToUser: nil,
MsgType: MsgTypeImage,
}
req.Images = images
req, sendURL := broadcast.chooseTagOrOpenID(user, req)
url := fmt.Sprintf("%s?access_token=%s", sendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &Result{}
err = util.DecodeWithError(data, res, "SendImage")
return res, err
}
// SendVideo 发送视频
func (broadcast *Broadcast) SendVideo(user *User, mediaID string, title, description string) (*Result, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := &sendRequest{
ToUser: nil,
MsgType: MsgTypeVideo,
}
req.Voice = map[string]interface{}{
"media_id": mediaID,
"title": title,
"description": description,
}
req, sendURL := broadcast.chooseTagOrOpenID(user, req)
url := fmt.Sprintf("%s?access_token=%s", sendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &Result{}
err = util.DecodeWithError(data, res, "SendVideo")
return res, err
}
// SendWxCard 发送卡券
func (broadcast *Broadcast) SendWxCard(user *User, cardID string) (*Result, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := &sendRequest{
ToUser: nil,
MsgType: MsgTypeWxCard,
}
req.WxCard = map[string]interface{}{
"card_id": cardID,
}
req, sendURL := broadcast.chooseTagOrOpenID(user, req)
url := fmt.Sprintf("%s?access_token=%s", sendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &Result{}
err = util.DecodeWithError(data, res, "SendWxCard")
return res, err
}
// Delete 删除群发消息
func (broadcast *Broadcast) Delete(msgID int64, articleIDx int64) error {
ak, err := broadcast.GetAccessToken()
if err != nil {
return err
}
req := map[string]interface{}{
"msg_id": msgID,
"article_idx": articleIDx,
}
url := fmt.Sprintf("%s?access_token=%s", deleteSendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return err
}
return util.DecodeWithCommonError(data, "Delete")
}
// Preview 预览
func (broadcast *Broadcast) Preview() *Broadcast {
broadcast.preview = true
return broadcast
}
// GetMassStatus 获取群发状态
func (broadcast *Broadcast) GetMassStatus(msgID string) (*Result, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := map[string]interface{}{
"msg_id": msgID,
}
url := fmt.Sprintf("%s?access_token=%s", massStatusSendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &Result{}
err = util.DecodeWithError(data, res, "GetMassStatus")
return res, err
}
// GetSpeed 获取群发速度
func (broadcast *Broadcast) GetSpeed() (*SpeedResult, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := map[string]interface{}{}
url := fmt.Sprintf("%s?access_token=%s", getSpeedSendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &SpeedResult{}
err = util.DecodeWithError(data, res, "GetSpeed")
return res, err
}
// SetSpeed 设置群发速度
func (broadcast *Broadcast) SetSpeed(speed int) (*SpeedResult, error) {
ak, err := broadcast.GetAccessToken()
if err != nil {
return nil, err
}
req := map[string]interface{}{
"speed": speed,
}
url := fmt.Sprintf("%s?access_token=%s", setSpeedSendURL, ak)
data, err := util.PostJSON(url, req)
if err != nil {
return nil, err
}
res := &SpeedResult{}
err = util.DecodeWithError(data, res, "SetSpeed")
return res, err
}
func (broadcast *Broadcast) chooseTagOrOpenID(user *User, req *sendRequest) (ret *sendRequest, url string) {
sendURL := ""
if user == nil {
req.Filter = map[string]interface{}{
"is_to_all": true,
}
sendURL = sendURLByTag
} else {
if broadcast.preview {
// 预览 默认发给第一个用户
if len(user.OpenID) != 0 {
req.ToUser = user.OpenID[0]
sendURL = previewSendURL
}
} else {
if user.TagID != 0 {
req.Filter = map[string]interface{}{
"is_to_all": false,
"tag_id": user.TagID,
}
sendURL = sendURLByTag
}
if len(user.OpenID) != 0 {
req.ToUser = user.OpenID
sendURL = sendURLByOpenID
}
}
}
return req, sendURL
}
vendor/github.com/silenceper/wechat/v2/officialaccount/config/config.go
Generated Vendored
+14
View File
@@ -0,0 +1,14 @@
package config
import (
"github.com/silenceper/wechat/v2/cache"
)
// Config .config for 微信公众号
type Config struct {
AppID string `json:"app_id"` // appid
AppSecret string `json:"app_secret"` // appsecret
Token string `json:"token"` // token
EncodingAESKey string `json:"encoding_aes_key"` // EncodingAESKey
Cache cache.Cache
}
vendor/github.com/silenceper/wechat/v2/officialaccount/context/context.go
Generated Vendored
+12
View File
@@ -0,0 +1,12 @@
package context
import (
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/officialaccount/config"
)
// Context struct
type Context struct {
*config.Config
credential.AccessTokenHandle
}
vendor/github.com/silenceper/wechat/v2/officialaccount/datacube/broadcast.go
Generated Vendored
+271
View File
@@ -0,0 +1,271 @@
package datacube
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
getArticleSummary = "https://api.weixin.qq.com/datacube/getarticlesummary"
getArticleTotal = "https://api.weixin.qq.com/datacube/getarticletotal"
getUserRead = "https://api.weixin.qq.com/datacube/getuserread"
getUserReadHour = "https://api.weixin.qq.com/datacube/getuserreadhour"
getUserShare = "https://api.weixin.qq.com/datacube/getusershare"
getUserShareHour = "https://api.weixin.qq.com/datacube/getusersharehour"
)
// ResArticleSummary 获取图文群发每日数据响应
type ResArticleSummary struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
MsgID string `json:"msgid"`
Title string `json:"title"`
IntPageReadUser int `json:"int_page_read_user"`
IntPageReadCount int `json:"int_page_read_count"`
OriPageReadUser int `json:"ori_page_read_user"`
OriPageReadCount int `json:"ori_page_read_count"`
ShareUser int `json:"share_user"`
ShareCount int `json:"share_count"`
AddToFavUser int `json:"add_to_fav_user"`
AddToFavCount int `json:"add_to_fav_count"`
} `json:"list"`
}
// ResArticleTotal 获取图文群发总数据响应
type ResArticleTotal struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
MsgID string `json:"msgid"`
Title string `json:"title"`
Details []ArticleTotalDetails `json:"details"`
} `json:"list"`
}
// ArticleTotalDetails 获取图文群发总数据响应文字详情
type ArticleTotalDetails struct {
StatDate string `json:"stat_date"`
TargetUser int `json:"target_user"`
IntPageReadUser int `json:"int_page_read_user"`
IntPageReadCount int `json:"int_page_read_count"`
OriPageReadUser int `json:"ori_page_read_user"`
OriPageReadCount int `json:"ori_page_read_count"`
ShareUser int `json:"share_user"`
ShareCount int `json:"share_count"`
AddToFavUser int `json:"add_to_fav_user"`
AddToFavCount int `json:"add_to_fav_count"`
IntPageFromSessionReadUser int `json:"int_page_from_session_read_user"`
IntPageFromSessionReadCount int `json:"int_page_from_session_read_count"`
IntPageFromHistMsgReadUser int `json:"int_page_from_hist_msg_read_user"`
IntPageFromHistMsgReadCount int `json:"int_page_from_hist_msg_read_count"`
IntPageFromFeedReadUser int `json:"int_page_from_feed_read_user"`
IntPageFromFeedReadCount int `json:"int_page_from_feed_read_count"`
IntPageFromFriendsReadUser int `json:"int_page_from_friends_read_user"`
IntPageFromFriendsReadCount int `json:"int_page_from_friends_read_count"`
IntPageFromOtherReadUser int `json:"int_page_from_other_read_user"`
IntPageFromOtherReadCount int `json:"int_page_from_other_read_count"`
FeedShareFromSessionUser int `json:"feed_share_from_session_user"`
FeedShareFromSessionCnt int `json:"feed_share_from_session_cnt"`
FeedShareFromFeedUser int `json:"feed_share_from_feed_user"`
FeedShareFromFeedCnt int `json:"feed_share_from_feed_cnt"`
FeedShareFromOtherUser int `json:"feed_share_from_other_user"`
FeedShareFromOtherCnt int `json:"feed_share_from_other_cnt"`
}
// ResUserRead 获取图文统计数据响应
type ResUserRead struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
UserSource int `json:"user_source"`
IntPageReadUser int `json:"int_page_read_user"`
IntPageReadCount int `json:"int_page_read_count"`
OriPageReadUser int `json:"ori_page_read_user"`
OriPageReadCount int `json:"ori_page_read_count"`
ShareUser int `json:"share_user"`
ShareCount int `json:"share_count"`
AddToFavUser int `json:"add_to_fav_user"`
AddToFavCount int `json:"add_to_fav_count"`
} `json:"list"`
}
// ResUserReadHour 获取图文统计分时数据
type ResUserReadHour struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
RefHour int `json:"ref_hour"`
UserSource int `json:"user_source"`
IntPageReadUser int `json:"int_page_read_user"`
IntPageReadCount int `json:"int_page_read_count"`
OriPageReadUser int `json:"ori_page_read_user"`
OriPageReadCount int `json:"ori_page_read_count"`
ShareUser int `json:"share_user"`
ShareCount int `json:"share_count"`
AddToFavUser int `json:"add_to_fav_user"`
AddToFavCount int `json:"add_to_fav_count"`
} `json:"list"`
}
// ResUserShare 获取图文分享转发数据
type ResUserShare struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
ShareScene int `json:"share_scene"`
ShareCount int `json:"share_count"`
ShareUser int `json:"share_user"`
} `json:"list"`
}
// ResUserShareHour 获取图文分享转发分时数据
type ResUserShareHour struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
RefHour int `json:"ref_hour"`
ShareScene int `json:"share_scene"`
ShareCount int `json:"share_count"`
ShareUser int `json:"share_user"`
} `json:"list"`
}
// GetArticleSummary 获取图文群发每日数据
func (cube *DataCube) GetArticleSummary(s string, e string) (resArticleSummary ResArticleSummary, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getArticleSummary, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resArticleSummary, "GetArticleSummary")
return
}
// GetArticleTotal 获取图文群发总数据
func (cube *DataCube) GetArticleTotal(s string, e string) (resArticleTotal ResArticleTotal, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getArticleTotal, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resArticleTotal, "GetArticleTotal")
return
}
// GetUserRead 获取图文统计数据
func (cube *DataCube) GetUserRead(s string, e string) (resUserRead ResUserRead, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUserRead, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUserRead, "GetUserRead")
return
}
// GetUserReadHour 获取图文统计分时数据
func (cube *DataCube) GetUserReadHour(s string, e string) (resUserReadHour ResUserReadHour, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUserReadHour, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUserReadHour, "GetUserReadHour")
return
}
// GetUserShare 获取图文分享转发数据
func (cube *DataCube) GetUserShare(s string, e string) (resUserShare ResUserShare, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUserShare, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUserShare, "GetUserShare")
return
}
// GetUserShareHour 获取图文分享转发分时数据
func (cube *DataCube) GetUserShareHour(s string, e string) (resUserShareHour ResUserShareHour, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUserShareHour, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUserShareHour, "GetUserShareHour")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/datacube/datacube.go
Generated Vendored
+22
View File
@@ -0,0 +1,22 @@
package datacube
import (
"github.com/silenceper/wechat/v2/officialaccount/context"
)
type reqDate struct {
BeginDate string `json:"begin_date"`
EndDate string `json:"end_date"`
}
// DataCube 数据统计
type DataCube struct {
*context.Context
}
// NewCube 数据统计
func NewCube(context *context.Context) *DataCube {
dataCube := new(DataCube)
dataCube.Context = context
return dataCube
}
vendor/github.com/silenceper/wechat/v2/officialaccount/datacube/interface.go
Generated Vendored
+83
View File
@@ -0,0 +1,83 @@
package datacube
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
getInterfaceSummary = "https://api.weixin.qq.com/datacube/getinterfacesummary"
getInterfaceSummaryHour = "https://api.weixin.qq.com/datacube/getinterfacesummaryhour"
)
// ResInterfaceSummary 接口分析数据响应
type ResInterfaceSummary struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
CallbackCount int `json:"callback_count"`
FailCount int `json:"fail_count"`
TotalTimeCost int `json:"total_time_cost"`
MaxTimeCost int `json:"max_time_cost"`
} `json:"list"`
}
// ResInterfaceSummaryHour 接口分析分时数据响应
type ResInterfaceSummaryHour struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
RefHour int `json:"ref_hour"`
CallbackCount int `json:"callback_count"`
FailCount int `json:"fail_count"`
TotalTimeCost int `json:"total_time_cost"`
MaxTimeCost int `json:"max_time_cost"`
} `json:"list"`
}
// GetInterfaceSummary 获取接口分析数据
func (cube *DataCube) GetInterfaceSummary(s string, e string) (resInterfaceSummary ResInterfaceSummary, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getInterfaceSummary, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resInterfaceSummary, "GetInterfaceSummary")
return
}
// GetInterfaceSummaryHour 获取接口分析分时数据
func (cube *DataCube) GetInterfaceSummaryHour(s string, e string) (resInterfaceSummaryHour ResInterfaceSummaryHour, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getInterfaceSummaryHour, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resInterfaceSummaryHour, "GetInterfaceSummaryHour")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/datacube/message.go
Generated Vendored
+253
View File
@@ -0,0 +1,253 @@
package datacube
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
getUpstreamMsg = "https://api.weixin.qq.com/datacube/getupstreammsg"
getUpstreamMsgHour = "https://api.weixin.qq.com/datacube/getupstreammsghour"
getUpstreamMsgWeek = "https://api.weixin.qq.com/datacube/getupstreammsgweek"
getUpstreamMsgMonth = "https://api.weixin.qq.com/datacube/getupstreammsgmonth"
getUpstreamMsgDist = "https://api.weixin.qq.com/datacube/getupstreammsgdist"
getUpstreamMsgDistWeek = "https://api.weixin.qq.com/datacube/getupstreammsgdistweek"
getUpstreamMsgDistMonth = "https://api.weixin.qq.com/datacube/getupstreammsgdistmonth"
)
// ResUpstreamMsg 获取消息发送概况数据响应
type ResUpstreamMsg struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
MsgType int `json:"msg_type"`
MsgUser int `json:"msg_user"`
MsgCount int `json:"msg_count"`
} `json:"list"`
}
// ResUpstreamMsgHour 获取消息分送分时数据响应
type ResUpstreamMsgHour struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
RefHour int `json:"ref_hour"`
MsgType int `json:"msg_type"`
MsgUser int `json:"msg_user"`
MsgCount int `json:"msg_count"`
} `json:"list"`
}
// ResUpstreamMsgWeek 获取消息发送周数据响应
type ResUpstreamMsgWeek struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
MsgType int `json:"msg_type"`
MsgUser int `json:"msg_user"`
MsgCount int `json:"msg_count"`
} `json:"list"`
}
// ResUpstreamMsgMonth 获取消息发送月数据响应
type ResUpstreamMsgMonth struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
MsgType int `json:"msg_type"`
MsgUser int `json:"msg_user"`
MsgCount int `json:"msg_count"`
} `json:"list"`
}
// ResUpstreamMsgDist 获取消息发送分布数据响应
type ResUpstreamMsgDist struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
CountInterval int `json:"count_interval"`
MsgUser int `json:"msg_user"`
} `json:"list"`
}
// ResUpstreamMsgDistWeek 获取消息发送分布周数据响应
type ResUpstreamMsgDistWeek struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
CountInterval int `json:"count_interval"`
MsgUser int `json:"msg_user"`
} `json:"list"`
}
// ResUpstreamMsgDistMonth 获取消息发送分布月数据响应
type ResUpstreamMsgDistMonth struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
CountInterval int `json:"count_interval"`
MsgUser int `json:"msg_user"`
} `json:"list"`
}
// GetUpstreamMsg 获取消息发送概况数据
func (cube *DataCube) GetUpstreamMsg(s string, e string) (resUpstreamMsg ResUpstreamMsg, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUpstreamMsg, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUpstreamMsg, "GetUpstreamMsg")
return
}
// GetUpstreamMsgHour 获取消息分送分时数据
func (cube *DataCube) GetUpstreamMsgHour(s string, e string) (resUpstreamMsgHour ResUpstreamMsgHour, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUpstreamMsgHour, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUpstreamMsgHour, "GetUpstreamMsgHour")
return
}
// GetUpstreamMsgWeek 获取消息发送周数据
func (cube *DataCube) GetUpstreamMsgWeek(s string, e string) (resUpstreamMsgWeek ResUpstreamMsgWeek, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUpstreamMsgWeek, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUpstreamMsgWeek, "GetUpstreamMsgWeek")
return
}
// GetUpstreamMsgMonth 获取消息发送月数据
func (cube *DataCube) GetUpstreamMsgMonth(s string, e string) (resUpstreamMsgMonth ResUpstreamMsgMonth, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUpstreamMsgMonth, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUpstreamMsgMonth, "GetUpstreamMsgMonth")
return
}
// GetUpstreamMsgDist 获取消息发送分布数据
func (cube *DataCube) GetUpstreamMsgDist(s string, e string) (resUpstreamMsgDist ResUpstreamMsgDist, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUpstreamMsgDist, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUpstreamMsgDist, "GetUpstreamMsgDist")
return
}
// GetUpstreamMsgDistWeek 获取消息发送分布周数据
func (cube *DataCube) GetUpstreamMsgDistWeek(s string, e string) (resUpstreamMsgDistWeek ResUpstreamMsgDistWeek, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUpstreamMsgDistWeek, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUpstreamMsgDistWeek, "GetUpstreamMsgDistWeek")
return
}
// GetUpstreamMsgDistMonth 获取消息发送分布月数据
func (cube *DataCube) GetUpstreamMsgDistMonth(s string, e string) (resUpstreamMsgDistMonth ResUpstreamMsgDistMonth, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUpstreamMsgDistMonth, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUpstreamMsgDistMonth, "GetUpstreamMsgDistMonth")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/datacube/publisher.go
Generated Vendored
+272
View File
@@ -0,0 +1,272 @@
package datacube
import (
"fmt"
"net/url"
"strconv"
"github.com/silenceper/wechat/v2/util"
)
// AdSlot 广告位类型
type AdSlot string
const (
// SlotIDBizBottom 公众号底部广告
SlotIDBizBottom AdSlot = "SLOT_ID_BIZ_BOTTOM"
// SlotIDBizMidContext 公众号文中广告
SlotIDBizMidContext AdSlot = "SLOT_ID_BIZ_MID_CONTEXT"
// SlotIDBizVideoEnd 公众号视频后贴
SlotIDBizVideoEnd AdSlot = "SLOT_ID_BIZ_VIDEO_END"
// SlotIDBizSponsor 公众号互选广告
SlotIDBizSponsor AdSlot = "SLOT_ID_BIZ_SPONSOR"
// SlotIDBizCps 公众号返佣商品
SlotIDBizCps AdSlot = "SLOT_ID_BIZ_CPS"
// SlotIDWeappBanner 小程序banner
SlotIDWeappBanner AdSlot = "SLOT_ID_WEAPP_BANNER"
// SlotIDWeappRewardVideo 小程序激励视频
SlotIDWeappRewardVideo AdSlot = "SLOT_ID_WEAPP_REWARD_VIDEO"
// SlotIDWeappInterstitial 小程序插屏广告
SlotIDWeappInterstitial AdSlot = "SLOT_ID_WEAPP_INTERSTITIAL"
// SlotIDWeappVideoFeeds 小程序视频广告
SlotIDWeappVideoFeeds AdSlot = "SLOT_ID_WEAPP_VIDEO_FEEDS"
// SlotIDWeappVideoBegin 小程序视频前贴
SlotIDWeappVideoBegin AdSlot = "SLOT_ID_WEAPP_VIDEO_BEGIN"
// SlotIDWeappBox 小程序格子广告
SlotIDWeappBox AdSlot = "SLOT_ID_WEAPP_BOX"
)
const (
publisherURL = "https://api.weixin.qq.com/publisher/stat"
)
const (
actionPublisherAdPosGeneral = "publisher_adpos_general"
actionPublisherCpsGeneral = "publisher_cps_general"
actionPublisherSettlement = "publisher_settlement"
)
// BaseResp 错误信息
type BaseResp struct {
ErrMsg string `json:"err_msg"`
Ret int `json:"ret"`
}
// ResPublisherAdPos 公众号分广告位数据响应
type ResPublisherAdPos struct {
util.CommonError
BaseResp BaseResp `json:"base_resp"`
List []ResAdPosList `json:"list"`
Summary ResAdPosSummary `json:"summary"`
TotalNum int `json:"total_num"`
}
// ResAdPosList 公众号分广告位列表
type ResAdPosList struct {
SlotID int64 `json:"slot_id"`
AdSlot string `json:"ad_slot"`
Date string `json:"date"`
ReqSuccCount int `json:"req_succ_count"`
ExposureCount int `json:"exposure_count"`
ExposureRate float64 `json:"exposure_rate"`
ClickCount int `json:"click_count"`
ClickRate float64 `json:"click_rate"`
Income int `json:"income"`
Ecpm float64 `json:"ecpm"`
}
// ResAdPosSummary 公众号分广告位概览
type ResAdPosSummary struct {
ReqSuccCount int `json:"req_succ_count"`
ExposureCount int `json:"exposure_count"`
ExposureRate float64 `json:"exposure_rate"`
ClickCount int `json:"click_count"`
ClickRate float64 `json:"click_rate"`
Income int `json:"income"`
Ecpm float64 `json:"ecpm"`
}
// ResPublisherCps 公众号返佣商品数据响应
type ResPublisherCps struct {
util.CommonError
BaseResp BaseResp `json:"base_resp"`
List []ResCpsList `json:"list"`
Summary ResCpsSummary `json:"summary"`
TotalNum int `json:"total_num"`
}
// ResCpsList 公众号返佣商品列表
type ResCpsList struct {
Date string `json:"date"`
ExposureCount int `json:"exposure_count"`
ClickCount int `json:"click_count"`
ClickRate float64 `json:"click_rate"`
OrderCount int `json:"order_count"`
OrderRate float64 `json:"order_rate"`
TotalFee int `json:"total_fee"`
TotalCommission int `json:"total_commission"`
}
// ResCpsSummary 公众号返佣概览
type ResCpsSummary struct {
ExposureCount int `json:"exposure_count"`
ClickCount int `json:"click_count"`
ClickRate float64 `json:"click_rate"`
OrderCount int `json:"order_count"`
OrderRate float64 `json:"order_rate"`
TotalFee int `json:"total_fee"`
TotalCommission int `json:"total_commission"`
}
// ResPublisherSettlement 公众号结算收入数据及结算主体信息响应
type ResPublisherSettlement struct {
util.CommonError
BaseResp BaseResp `json:"base_resp"`
Body string `json:"body"`
PenaltyAll int `json:"penalty_all"`
RevenueAll int64 `json:"revenue_all"`
SettledRevenueAll int64 `json:"settled_revenue_all"`
SettlementList []SettlementList `json:"settlement_list"`
TotalNum int `json:"total_num"`
}
// SettlementList 结算单列表
type SettlementList struct {
Date string `json:"date"`
Zone string `json:"zone"`
Month string `json:"month"`
Order int `json:"order"`
SettStatus int `json:"sett_status"`
SettledRevenue int `json:"settled_revenue"`
SettNo string `json:"sett_no"`
MailSendCnt string `json:"mail_send_cnt"`
SlotRevenue []SlotRevenue `json:"slot_revenue"`
}
// SlotRevenue 产生收入的广告
type SlotRevenue struct {
SlotID string `json:"slot_id"`
SlotSettledRevenue int `json:"slot_settled_revenue"`
}
// ParamsPublisher 拉取数据参数
type ParamsPublisher struct {
Action string `json:"action"`
StartDate string `json:"start_date"`
EndDate string `json:"end_date"`
Page int `json:"page"`
PageSize int `json:"page_size"`
AdSlot AdSlot `json:"ad_slot"`
}
// fetchData 拉取统计数据
func (cube *DataCube) fetchData(params ParamsPublisher) (response []byte, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
v := url.Values{}
v.Add("action", params.Action)
v.Add("access_token", accessToken)
v.Add("page", strconv.Itoa(params.Page))
v.Add("page_size", strconv.Itoa(params.PageSize))
v.Add("start_date", params.StartDate)
v.Add("end_date", params.EndDate)
if params.AdSlot != "" {
v.Add("ad_slot", string(params.AdSlot))
}
uri := fmt.Sprintf("%s?%s", publisherURL, v.Encode())
response, err = util.HTTPGet(uri)
if err != nil {
return
}
return
}
// GetPublisherAdPosGeneral 获取公众号分广告位数据
func (cube *DataCube) GetPublisherAdPosGeneral(startDate, endDate string, page, pageSize int, adSlot AdSlot) (resPublisherAdPos ResPublisherAdPos, err error) {
params := ParamsPublisher{
Action: actionPublisherAdPosGeneral,
StartDate: startDate,
EndDate: endDate,
Page: page,
PageSize: pageSize,
AdSlot: adSlot,
}
response, err := cube.fetchData(params)
if err != nil {
return
}
err = util.DecodeWithError(response, &resPublisherAdPos, "GetPublisherAdPosGeneral")
if err != nil {
return
}
if resPublisherAdPos.BaseResp.Ret != 0 {
err = fmt.Errorf("GetPublisherAdPosGeneral Error , errcode=%d , errmsg=%s", resPublisherAdPos.BaseResp.Ret, resPublisherAdPos.BaseResp.ErrMsg)
return
}
return
}
// GetPublisherCpsGeneral 获取公众号返佣商品数据
func (cube *DataCube) GetPublisherCpsGeneral(startDate, endDate string, page, pageSize int) (resPublisherCps ResPublisherCps, err error) {
params := ParamsPublisher{
Action: actionPublisherCpsGeneral,
StartDate: startDate,
EndDate: endDate,
Page: page,
PageSize: pageSize,
}
response, err := cube.fetchData(params)
if err != nil {
return
}
err = util.DecodeWithError(response, &resPublisherCps, "GetPublisherCpsGeneral")
if err != nil {
return
}
if resPublisherCps.BaseResp.Ret != 0 {
err = fmt.Errorf("GetPublisherCpsGeneral Error , errcode=%d , errmsg=%s", resPublisherCps.BaseResp.Ret, resPublisherCps.BaseResp.ErrMsg)
return
}
return
}
// GetPublisherSettlement 获取公众号结算收入数据及结算主体信息
func (cube *DataCube) GetPublisherSettlement(startDate, endDate string, page, pageSize int) (resPublisherSettlement ResPublisherSettlement, err error) {
params := ParamsPublisher{
Action: actionPublisherSettlement,
StartDate: startDate,
EndDate: endDate,
Page: page,
PageSize: pageSize,
}
response, err := cube.fetchData(params)
if err != nil {
return
}
err = util.DecodeWithError(response, &resPublisherSettlement, "GetPublisherSettlement")
if err != nil {
return
}
if resPublisherSettlement.BaseResp.Ret != 0 {
err = fmt.Errorf("GetPublisherSettlement Error , errcode=%d , errmsg=%s", resPublisherSettlement.BaseResp.Ret, resPublisherSettlement.BaseResp.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/datacube/user.go
Generated Vendored
+78
View File
@@ -0,0 +1,78 @@
package datacube
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
getUserSummary = "https://api.weixin.qq.com/datacube/getusersummary"
getUserAccumulate = "https://api.weixin.qq.com/datacube/getusercumulate"
)
// ResUserSummary 获取用户增减数据响应
type ResUserSummary struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
UserSource int `json:"user_source"`
NewUser int `json:"new_user"`
CancelUser int `json:"cancel_user"`
} `json:"list"`
}
// ResUserAccumulate 获取累计用户数据响应
type ResUserAccumulate struct {
util.CommonError
List []struct {
RefDate string `json:"ref_date"`
CumulateUser int `json:"cumulate_user"`
} `json:"list"`
}
// GetUserSummary 获取用户增减数据
func (cube *DataCube) GetUserSummary(s string, e string) (resUserSummary ResUserSummary, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUserSummary, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUserSummary, "GetUserSummary")
return
}
// GetUserAccumulate 获取累计用户数据
func (cube *DataCube) GetUserAccumulate(s string, e string) (resUserAccumulate ResUserAccumulate, err error) {
accessToken, err := cube.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getUserAccumulate, accessToken)
reqDate := &reqDate{
BeginDate: s,
EndDate: e,
}
response, err := util.PostJSON(uri, reqDate)
if err != nil {
return
}
err = util.DecodeWithError(response, &resUserAccumulate, "GetUserAccumulate")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/device/authorize.go
Generated Vendored
+117
View File
@@ -0,0 +1,117 @@
// Package device 设备相关接口
package device
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
// DeviceAdd 添加设备标识
DeviceAdd = iota
// DeviceUpgrade 更新设备标识
DeviceUpgrade
)
type reqDeviceAuthorize struct {
// 设备id的个数
DeviceNum string `json:"device_num"`
// 设备id的列表，json的array格式，其size必须等于device_num
DeviceList []ReqDevice `json:"device_list"`
// 请求操作的类型，限定取值为：0：设备授权（缺省值为0） 1：设备更新（更新已授权设备的各属性值）
OpType string `json:"op_type,omitempty"`
// 设备的产品编号（由微信硬件平台分配）。可在公众号设备功能管理页面查询。
// 当 op_type 为‘0’，product_id 为‘1’时，不要填写 product_id 字段（会引起不必要错误）；
// 当 op_typy 为‘0’，product_id 不为‘1’时，必须填写 product_id 字段；
// 当 op_type 为 1 时，不要填写 product_id 字段。
ProductID string `json:"product_id,omitempty"`
}
// ReqDevice 设备授权实体
type ReqDevice struct {
// 设备的 device id
ID string `json:"id"`
// 设备的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类型）
ConnectProtocol string `json:"connect_protocol"`
// auth及通信的加密key，第三方需要将key烧制在设备上（128bit），格式采用16进制串的方式（长度为32字节），不需要0X前缀，如： 1234567890ABCDEF1234567890ABCDEF
AuthKey string `json:"auth_key"`
// 断开策略，目前支持： 1：退出公众号页面时即断开连接 2：退出公众号之后保持连接不断开
CloseStrategy string `json:"close_strategy"`
// 连接策略，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
// 1：version 1
AuthVer string `json:"auth_ver"`
// 表示mac地址在厂商广播manufacture data里含有mac地址的偏移，取值如下：
// -1：在尾部、
// -2：表示不包含mac地址 其他：非法偏移
ManuMacPos string `json:"manu_mac_pos"`
// 表示mac地址在厂商serial number里含有mac地址的偏移，取值如下：
// -1：表示在尾部
// -2：表示不包含mac地址 其他：非法偏移
SerMacPost string `json:"ser_mac_post"`
// 精简协议类型，取值如下：计步设备精简协议：1 （若该字段填1，connect_protocol 必须包括3。非精简协议设备切勿填写该字段）
BleSimpleProtocol string `json:"ble_simple_protocol,omitempty"`
}
// ResBaseInfo 授权回调实体
type ResBaseInfo struct {
BaseInfo struct {
DeviceType string `json:"device_type"`
DeviceID string `json:"device_id"`
} `json:"base_info"`
}
// 授权回调根信息
type resDeviceAuthorize struct {
util.CommonError
Resp []ResBaseInfo `json:"resp"`
}
// DeviceAuthorize 设备授权
func (d *Device) DeviceAuthorize(devices []ReqDevice, opType int, product string) (res []ResBaseInfo, err error) {
var accessToken string
accessToken, err = d.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uriAuthorize, accessToken)
req := reqDeviceAuthorize{
DeviceNum: fmt.Sprintf("%d", len(devices)),
DeviceList: devices,
OpType: fmt.Sprintf("%d", opType),
ProductID: product,
}
var response []byte
response, err = util.PostJSON(uri, req)
if err != nil {
return nil, err
}
var result resDeviceAuthorize
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("DeviceAuthorize Error , errcode=%d , errmsg=%s", result.ErrCode, result.ErrMsg)
return
}
res = result.Resp
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/device/bind.go
Generated Vendored
+106
View File
@@ -0,0 +1,106 @@
package device
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/util"
)
// ReqBind 设备绑定解绑共通实体
type ReqBind struct {
Ticket string `json:"ticket,omitempty"`
DeviceID string `json:"device_id"`
OpenID string `json:"openid"`
}
type resBind struct {
BaseResp util.CommonError `json:"base_resp"`
}
// Bind 设备绑定
func (d *Device) Bind(req ReqBind) (err error) {
var accessToken string
if accessToken, err = d.GetAccessToken(); err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uriBind, accessToken)
var response []byte
if response, err = util.PostJSON(uri, req); err != nil {
return
}
var result resBind
if err = json.Unmarshal(response, &result); err != nil {
return
}
if result.BaseResp.ErrCode != 0 {
err = fmt.Errorf("DeviceBind Error , errcode=%d , errmsg=%s", result.BaseResp.ErrCode, result.BaseResp.ErrMsg)
return
}
return
}
// Unbind 设备解绑
func (d *Device) Unbind(req ReqBind) (err error) {
var accessToken string
if accessToken, err = d.GetAccessToken(); err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uriUnbind, accessToken)
var response []byte
if response, err = util.PostJSON(uri, req); err != nil {
return
}
var result resBind
if err = json.Unmarshal(response, &result); err != nil {
return
}
if result.BaseResp.ErrCode != 0 {
err = fmt.Errorf("DeviceBind Error , errcode=%d , errmsg=%s", result.BaseResp.ErrCode, result.BaseResp.ErrMsg)
return
}
return
}
// CompelBind 强制绑定用户和设备
func (d *Device) CompelBind(req ReqBind) (err error) {
var accessToken string
if accessToken, err = d.GetAccessToken(); err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uriCompelBind, accessToken)
var response []byte
if response, err = util.PostJSON(uri, req); err != nil {
return
}
var result resBind
if err = json.Unmarshal(response, &result); err != nil {
return
}
if result.BaseResp.ErrCode != 0 {
err = fmt.Errorf("DeviceBind Error , errcode=%d , errmsg=%s", result.BaseResp.ErrCode, result.BaseResp.ErrMsg)
return
}
return
}
// CompelUnbind 强制解绑用户和设备
func (d *Device) CompelUnbind(req ReqBind) (err error) {
var accessToken string
if accessToken, err = d.GetAccessToken(); err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uriCompelUnbind, accessToken)
var response []byte
if response, err = util.PostJSON(uri, req); err != nil {
return
}
var result resBind
if err = json.Unmarshal(response, &result); err != nil {
return
}
if result.BaseResp.ErrCode != 0 {
err = fmt.Errorf("DeviceBind Error , errcode=%d , errmsg=%s", result.BaseResp.ErrCode, result.BaseResp.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/device/device.go
Generated Vendored
+60
View File
@@ -0,0 +1,60 @@
package device
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
uriAuthorize = "https://api.weixin.qq.com/device/authorize_device"
uriQRCode = "https://api.weixin.qq.com/device/create_qrcode"
uriVerifyQRCode = "https://api.weixin.qq.com/device/verify_qrcode"
uriBind = "https://api.weixin.qq.com/device/bind"
uriUnbind = "https://api.weixin.qq.com/device/unbind"
uriCompelBind = "https://api.weixin.qq.com/device/compel_bind"
uriCompelUnbind = "https://api.weixin.qq.com/device/compel_unbind"
uriState = "https://api.weixin.qq.com/device/get_stat"
)
// Device struct
type Device struct {
*context.Context
}
// NewDevice 实例
func NewDevice(context *context.Context) *Device {
device := new(Device)
device.Context = context
return device
}
// ResDeviceState 设备状态响应实体
type ResDeviceState struct {
util.CommonError
Status int `json:"status"`
StatusInfo string `json:"status_info"`
}
// State 设备状态查询
func (d *Device) State(device string) (res ResDeviceState, err error) {
var accessToken string
if accessToken, err = d.GetAccessToken(); err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s&device_id=%s", uriState, accessToken, device)
var response []byte
if response, err = util.HTTPGet(uri); err != nil {
return
}
if err = json.Unmarshal(response, &res); err != nil {
return
}
if res.ErrCode != 0 {
err = fmt.Errorf("DeviceState Error , errcode=%d , errmsg=%s", res.ErrCode, res.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/device/message.go
Generated Vendored
+9
View File
@@ -0,0 +1,9 @@
package device
// MsgDevice 设备消息响应
type MsgDevice struct {
DeviceType string
DeviceID string
SessionID string
OpenID string
}
vendor/github.com/silenceper/wechat/v2/officialaccount/device/qrcode.go
Generated Vendored
+76
View File
@@ -0,0 +1,76 @@
package device
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/util"
)
// ResCreateQRCode 获取二维码的返回实体
type ResCreateQRCode struct {
util.CommonError
DeviceNum int `json:"device_num"`
CodeList []struct {
DeviceID string `json:"device_id"`
Ticket string `json:"ticket"`
} `json:"code_list"`
}
// CreateQRCode 获取设备二维码
func (d *Device) CreateQRCode(devices []string) (res ResCreateQRCode, err error) {
var accessToken string
if accessToken, err = d.GetAccessToken(); err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uriQRCode, accessToken)
req := map[string]interface{}{
"device_num": len(devices),
"device_id_list": devices,
}
var response []byte
if response, err = util.PostJSON(uri, req); err != nil {
return
}
if err = json.Unmarshal(response, &res); err != nil {
return
}
if res.ErrCode != 0 {
err = fmt.Errorf("DeviceCreateQRCode Error , errcode=%d , errmsg=%s", res.ErrCode, res.ErrMsg)
return
}
return
}
// ResVerifyQRCode 验证授权结果实体
type ResVerifyQRCode struct {
util.CommonError
DeviceType string `json:"device_type"`
DeviceID string `json:"device_id"`
Mac string `json:"mac"`
}
// VerifyQRCode 验证设备二维码
func (d *Device) VerifyQRCode(ticket string) (res ResVerifyQRCode, err error) {
var accessToken string
if accessToken, err = d.GetAccessToken(); err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", uriVerifyQRCode, accessToken)
req := map[string]interface{}{
"ticket": ticket,
}
var response []byte
if response, err = util.PostJSON(uri, req); err != nil {
return
}
if err = json.Unmarshal(response, &res); err != nil {
return
}
if res.ErrCode != 0 {
err = fmt.Errorf("DeviceCreateQRCode Error , errcode=%d , errmsg=%s", res.ErrCode, res.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/draft/draft.go
Generated Vendored
+228
View File
@@ -0,0 +1,228 @@
package draft
import (
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
addURL = "https://api.weixin.qq.com/cgi-bin/draft/add" // 新建草稿
getURL = "https://api.weixin.qq.com/cgi-bin/draft/get" // 获取草稿
deleteURL = "https://api.weixin.qq.com/cgi-bin/draft/delete" // 删除草稿
updateURL = "https://api.weixin.qq.com/cgi-bin/draft/update" // 修改草稿
countURL = "https://api.weixin.qq.com/cgi-bin/draft/count" // 获取草稿总数
paginateURL = "https://api.weixin.qq.com/cgi-bin/draft/batchget" // 获取草稿列表
)
// Draft 草稿箱
type Draft struct {
*context.Context
}
// NewDraft init
func NewDraft(ctx *context.Context) *Draft {
return &Draft{
Context: ctx,
}
}
// Article 草稿
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粉丝才可评论
}
// AddDraft 新建草稿
func (draft *Draft) AddDraft(articles []*Article) (mediaID string, err error) {
accessToken, err := draft.GetAccessToken()
if err != nil {
return
}
var req struct {
Articles []*Article `json:"articles"`
}
req.Articles = articles
uri := fmt.Sprintf("%s?access_token=%s", addURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return
}
var res struct {
util.CommonError
MediaID string `json:"media_id"`
}
err = util.DecodeWithError(response, &res, "AddDraft")
if err != nil {
return
}
mediaID = res.MediaID
return
}
// GetDraft 获取草稿
func (draft *Draft) GetDraft(mediaID string) (articles []*Article, err error) {
accessToken, err := draft.GetAccessToken()
if err != nil {
return
}
var req struct {
MediaID string `json:"media_id"`
}
req.MediaID = mediaID
uri := fmt.Sprintf("%s?access_token=%s", getURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return
}
var res struct {
util.CommonError
NewsItem []*Article `json:"news_item"`
}
err = util.DecodeWithError(response, &res, "GetDraft")
if err != nil {
return
}
articles = res.NewsItem
return
}
// DeleteDraft 删除草稿
func (draft *Draft) DeleteDraft(mediaID string) (err error) {
accessToken, err := draft.GetAccessToken()
if err != nil {
return
}
var req struct {
MediaID string `json:"media_id"`
}
req.MediaID = mediaID
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", deleteURL, accessToken)
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
err = util.DecodeWithCommonError(response, "DeleteDraft")
return
}
// UpdateDraft 修改草稿
// index 要更新的文章在图文消息中的位置（多图文消息时，此字段才有意义），第一篇为0
func (draft *Draft) UpdateDraft(article *Article, mediaID string, index uint) (err error) {
accessToken, err := draft.GetAccessToken()
if err != nil {
return
}
var req struct {
MediaID string `json:"media_id"`
Index uint `json:"index"`
Article *Article `json:"articles"`
}
req.MediaID = mediaID
req.Index = index
req.Article = article
uri := fmt.Sprintf("%s?access_token=%s", updateURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
err = util.DecodeWithCommonError(response, "UpdateDraft")
return
}
// CountDraft 获取草稿总数
func (draft *Draft) CountDraft() (total uint, err error) {
accessToken, err := draft.GetAccessToken()
if err != nil {
return
}
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", countURL, accessToken)
response, err = util.HTTPGet(uri)
if err != nil {
return
}
var res struct {
util.CommonError
Total uint `json:"total_count"`
}
err = util.DecodeWithError(response, &res, "CountDraft")
if nil != err {
return
}
total = res.Total
return
}
// ArticleList 草稿列表
type ArticleList struct {
util.CommonError
TotalCount int64 `json:"total_count"` // 草稿素材的总数
ItemCount int64 `json:"item_count"` // 本次调用获取的素材的数量
Item []ArticleListItem `json:"item"`
}
// ArticleListItem 用于 ArticleList 的 item 节点
type ArticleListItem struct {
MediaID string `json:"media_id"` // 图文消息的id
Content ArticleListContent `json:"content"` // 内容
UpdateTime int64 `json:"update_time"` // 这篇图文消息素材的最后更新时间
}
// ArticleListContent 用于 ArticleListItem 的 content 节点
type ArticleListContent struct {
NewsItem []Article `json:"news_item"` // 这篇图文消息素材的内容
}
// PaginateDraft 获取草稿列表
func (draft *Draft) PaginateDraft(offset, count int64, noReturnContent bool) (list ArticleList, err error) {
accessToken, err := draft.GetAccessToken()
if err != nil {
return
}
var req struct {
Count int64 `json:"count"`
Offset int64 `json:"offset"`
NoReturnContent bool `json:"no_content"`
}
req.Count = count
req.Offset = offset
req.NoReturnContent = noReturnContent
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", paginateURL, accessToken)
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
err = util.DecodeWithError(response, &list, "PaginateDraft")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/freepublish/freepublish.go
Generated Vendored
+248
View File
@@ -0,0 +1,248 @@
package freepublish
import (
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
publishURL = "https://api.weixin.qq.com/cgi-bin/freepublish/submit" // 发布接口
selectStateURL = "https://api.weixin.qq.com/cgi-bin/freepublish/get" // 发布状态轮询接口
deleteURL = "https://api.weixin.qq.com/cgi-bin/freepublish/delete" // 删除发布
firstArticleURL = "https://api.weixin.qq.com/cgi-bin/freepublish/getarticle" // 通过 article_id 获取已发布文章
paginateURL = "https://api.weixin.qq.com/cgi-bin/freepublish/batchget" // 获取成功发布列表
)
// PublishStatus 发布状态
type PublishStatus uint
const (
// PublishStatusSuccess 0:成功
PublishStatusSuccess PublishStatus = iota
// PublishStatusPublishing 1:发布中
PublishStatusPublishing
// PublishStatusOriginalFail 2:原创失败
PublishStatusOriginalFail
// PublishStatusFail 3:常规失败
PublishStatusFail
// PublishStatusAuditRefused 4:平台审核不通过
PublishStatusAuditRefused
// PublishStatusUserDeleted 5:成功后用户删除所有文章
PublishStatusUserDeleted
// PublishStatusSystemBanned 6:成功后系统封禁所有文章
PublishStatusSystemBanned
)
// FreePublish 发布能力
type FreePublish struct {
*context.Context
}
// NewFreePublish init
func NewFreePublish(ctx *context.Context) *FreePublish {
return &FreePublish{
Context: ctx,
}
}
// Publish 发布接口。需要先将图文素材以草稿的形式保存（见“草稿箱/新建草稿”，
// 如需从已保存的草稿中选择，见“草稿箱/获取草稿列表”），选择要发布的草稿 media_id 进行发布
func (freePublish *FreePublish) Publish(mediaID string) (publishID int64, err error) {
var accessToken string
accessToken, err = freePublish.GetAccessToken()
if err != nil {
return
}
var req struct {
MediaID string `json:"media_id"`
}
req.MediaID = mediaID
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", publishURL, accessToken)
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
var res struct {
util.CommonError
PublishID int64 `json:"publish_id"`
}
err = util.DecodeWithError(response, &res, "SubmitFreePublish")
if err != nil {
return
}
publishID = res.PublishID
return
}
// PublishStatusList 发布任务状态列表
type PublishStatusList struct {
util.CommonError
PublishID int64 `json:"publish_id"` // 发布任务id
PublishStatus PublishStatus `json:"publish_status"` // 发布状态
ArticleID string `json:"article_id"` // 当发布状态为0时（即成功）时，返回图文的 article_id，可用于“客服消息”场景
ArticleDetail PublishArticleDetail `json:"article_detail"` // 发布任务文章成功状态详情
FailIndex []uint `json:"fail_idx"` // 当发布状态为2或4时，返回不通过的文章编号，第一篇为 1；其他发布状态则为空
}
// PublishArticleDetail 发布任务成功详情
type PublishArticleDetail struct {
Count uint `json:"count"` // 当发布状态为0时（即成功）时，返回文章数量
Items []PublishArticleItem `json:"item"`
}
// PublishArticleItem 发布任务成功的文章内容
type PublishArticleItem struct {
Index uint `json:"idx"` // 当发布状态为0时（即成功）时，返回文章对应的编号
ArticleURL string `json:"article_url"` // 当发布状态为0时（即成功）时，返回图文的永久链接
}
// SelectStatus 发布状态轮询接口
func (freePublish *FreePublish) SelectStatus(publishID int64) (list PublishStatusList, err error) {
accessToken, err := freePublish.GetAccessToken()
if err != nil {
return
}
var req struct {
PublishID int64 `json:"publish_id"`
}
req.PublishID = publishID
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", selectStateURL, accessToken)
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
err = util.DecodeWithError(response, &list, "SelectStatusFreePublish")
return
}
// Delete 删除发布。
// index 要删除的文章在图文消息中的位置，第一篇编号为1，该字段不填或填0会删除全部文章
// !!!此操作不可逆，请谨慎操作!!!删除后微信公众号后台仍然会有记录!!!
func (freePublish *FreePublish) Delete(articleID string, index uint) (err error) {
accessToken, err := freePublish.GetAccessToken()
if err != nil {
return err
}
var req struct {
ArticleID string `json:"article_id"`
Index uint `json:"index"`
}
req.ArticleID = articleID
req.Index = index
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", deleteURL, accessToken)
response, err = util.PostJSON(uri, req)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "DeleteFreePublish")
}
// Article 图文信息内容
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
IsDeleted bool `json:"is_deleted"` // 该图文是否被删除
}
// First 通过 article_id 获取已发布文章
func (freePublish *FreePublish) First(articleID string) (list []Article, err error) {
accessToken, err := freePublish.GetAccessToken()
if err != nil {
return
}
var req struct {
ArticleID string `json:"article_id"`
}
req.ArticleID = articleID
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", firstArticleURL, accessToken)
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
var res struct {
util.CommonError
NewsItem []Article `json:"news_item"`
}
err = util.DecodeWithError(response, &res, "FirstFreePublish")
if err != nil {
return
}
list = res.NewsItem
return
}
// ArticleList 发布列表
type ArticleList struct {
util.CommonError
TotalCount int64 `json:"total_count"` // 成功发布素材的总数
ItemCount int64 `json:"item_count"` // 本次调用获取的素材的数量
Item []ArticleListItem `json:"item"`
}
// ArticleListItem 用于 ArticleList 的 item 节点
type ArticleListItem struct {
ArticleID string `json:"article_id"` // 成功发布的图文消息id
Content ArticleListContent `json:"content"` // 内容
UpdateTime int64 `json:"update_time"` // 这篇图文消息素材的最后更新时间
}
// ArticleListContent 用于 ArticleListItem 的 content 节点
type ArticleListContent struct {
NewsItem []Article `json:"news_item"` // 这篇图文消息素材的内容
}
// Paginate 获取成功发布列表
func (freePublish *FreePublish) Paginate(offset, count int64, noReturnContent bool) (list ArticleList, err error) {
var accessToken string
accessToken, err = freePublish.GetAccessToken()
if err != nil {
return
}
var req struct {
Count int64 `json:"count"`
Offset int64 `json:"offset"`
NoReturnContent bool `json:"no_content"`
}
req.Count = count
req.Offset = offset
req.NoReturnContent = noReturnContent
var response []byte
uri := fmt.Sprintf("%s?access_token=%s", paginateURL, accessToken)
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
err = util.DecodeWithError(response, &list, "PaginateFreePublish")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/js/js.go
Generated Vendored
+64
View File
@@ -0,0 +1,64 @@
package js
import (
"fmt"
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
// Js struct
type Js struct {
*context.Context
credential.JsTicketHandle
}
// Config 返回给用户jssdk配置信息
type Config struct {
AppID string `json:"app_id"`
Timestamp int64 `json:"timestamp"`
NonceStr string `json:"nonce_str"`
Signature string `json:"signature"`
}
// NewJs init
func NewJs(context *context.Context) *Js {
js := new(Js)
js.Context = context
jsTicketHandle := credential.NewDefaultJsTicket(context.AppID, credential.CacheKeyOfficialAccountPrefix, context.Cache)
js.SetJsTicketHandle(jsTicketHandle)
return js
}
// SetJsTicketHandle 自定义js ticket取值方式
func (js *Js) SetJsTicketHandle(ticketHandle credential.JsTicketHandle) {
js.JsTicketHandle = ticketHandle
}
// GetConfig 获取jssdk需要的配置参数
// uri 为当前网页地址
func (js *Js) GetConfig(uri string) (config *Config, err error) {
config = new(Config)
var accessToken string
accessToken, err = js.GetAccessToken()
if err != nil {
return
}
var ticketStr string
ticketStr, err = js.GetTicket(accessToken)
if err != nil {
return
}
nonceStr := util.RandomStr(16)
timestamp := util.GetCurrTS()
str := fmt.Sprintf("jsapi_ticket=%s&noncestr=%s&timestamp=%d&url=%s", ticketStr, nonceStr, timestamp, uri)
sigStr := util.Signature(str)
config.AppID = js.AppID
config.NonceStr = nonceStr
config.Timestamp = timestamp
config.Signature = sigStr
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/material/material.go
Generated Vendored
+354
View File
@@ -0,0 +1,354 @@
package material
import (
"encoding/json"
"errors"
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
addNewsURL = "https://api.weixin.qq.com/cgi-bin/material/add_news"
updateNewsURL = "https://api.weixin.qq.com/cgi-bin/material/update_news"
addMaterialURL = "https://api.weixin.qq.com/cgi-bin/material/add_material"
delMaterialURL = "https://api.weixin.qq.com/cgi-bin/material/del_material"
getMaterialURL = "https://api.weixin.qq.com/cgi-bin/material/get_material"
getMaterialCountURL = "https://api.weixin.qq.com/cgi-bin/material/get_materialcount"
batchGetMaterialURL = "https://api.weixin.qq.com/cgi-bin/material/batchget_material"
)
// PermanentMaterialType 永久素材类型
type PermanentMaterialType string
const (
// PermanentMaterialTypeImage 永久素材图片类型（image）
PermanentMaterialTypeImage PermanentMaterialType = "image"
// PermanentMaterialTypeVideo 永久素材视频类型（video）
PermanentMaterialTypeVideo PermanentMaterialType = "video"
// PermanentMaterialTypeVoice 永久素材语音类型 （voice）
PermanentMaterialTypeVoice PermanentMaterialType = "voice"
// PermanentMaterialTypeNews 永久素材图文类型（news）
PermanentMaterialTypeNews PermanentMaterialType = "news"
)
// Material 素材管理
type Material struct {
*context.Context
}
// NewMaterial init
func NewMaterial(context *context.Context) *Material {
material := new(Material)
material.Context = context
return material
}
// Article 永久图文素材
type Article struct {
Title string `json:"title"`
ThumbMediaID string `json:"thumb_media_id"`
ThumbURL string `json:"thumb_url"`
Author string `json:"author"`
Digest string `json:"digest"`
ShowCoverPic int `json:"show_cover_pic"`
Content string `json:"content"`
ContentSourceURL string `json:"content_source_url"`
URL string `json:"url"`
DownURL string `json:"down_url"`
}
// GetNews 获取/下载永久素材
func (material *Material) GetNews(id string) ([]*Article, error) {
accessToken, err := material.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", getMaterialURL, accessToken)
var req struct {
MediaID string `json:"media_id"`
}
req.MediaID = id
responseBytes, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
var res struct {
NewsItem []*Article `json:"news_item"`
}
err = json.Unmarshal(responseBytes, &res)
if err != nil {
return nil, err
}
return res.NewsItem, nil
}
// reqArticles 永久性图文素材请求信息
type reqArticles struct {
Articles []*Article `json:"articles"`
}
// resArticles 永久性图文素材返回结果
type resArticles struct {
util.CommonError
MediaID string `json:"media_id"`
}
// AddNews 新增永久图文素材
func (material *Material) AddNews(articles []*Article) (mediaID string, err error) {
req := &reqArticles{articles}
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", addNewsURL, accessToken)
responseBytes, err := util.PostJSON(uri, req)
if err != nil {
return
}
var res resArticles
err = json.Unmarshal(responseBytes, &res)
if err != nil {
return
}
if res.ErrCode != 0 {
return "", fmt.Errorf("errcode=%d,errmsg=%s", res.ErrCode, res.ErrMsg)
}
mediaID = res.MediaID
return
}
// reqUpdateArticle 更新永久性图文素材请求信息
type reqUpdateArticle struct {
MediaID string `json:"media_id"`
Index int64 `json:"index"`
Articles *Article `json:"articles"`
}
// UpdateNews 更新永久图文素材
func (material *Material) UpdateNews(article *Article, mediaID string, index int64) (err error) {
req := &reqUpdateArticle{mediaID, index, article}
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", updateNewsURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
return util.DecodeWithCommonError(response, "UpdateNews")
}
// resAddMaterial 永久性素材上传返回的结果
type resAddMaterial struct {
util.CommonError
MediaID string `json:"media_id"`
URL string `json:"url"`
}
// AddMaterial 上传永久性素材（处理视频需要单独上传）
func (material *Material) AddMaterial(mediaType MediaType, filename string) (mediaID string, url string, err error) {
if mediaType == MediaTypeVideo {
err = errors.New("永久视频素材上传使用 AddVideo 方法")
return
}
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s&type=%s", addMaterialURL, accessToken, mediaType)
var response []byte
response, err = util.PostFile("media", filename, uri)
if err != nil {
return
}
var resMaterial resAddMaterial
err = json.Unmarshal(response, &resMaterial)
if err != nil {
return
}
if resMaterial.ErrCode != 0 {
err = fmt.Errorf("AddMaterial error : errcode=%v , errmsg=%v", resMaterial.ErrCode, resMaterial.ErrMsg)
return
}
mediaID = resMaterial.MediaID
url = resMaterial.URL
return
}
type reqVideo struct {
Title string `json:"title"`
Introduction string `json:"introduction"`
}
// AddVideo 永久视频素材文件上传
func (material *Material) AddVideo(filename, title, introduction string) (mediaID string, url string, err error) {
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s&type=video", addMaterialURL, accessToken)
videoDesc := &reqVideo{
Title: title,
Introduction: introduction,
}
var fieldValue []byte
fieldValue, err = json.Marshal(videoDesc)
if err != nil {
return
}
fields := []util.MultipartFormField{
{
IsFile: true,
Fieldname: "media",
Filename: filename,
},
{
IsFile: false,
Fieldname: "description",
Value: fieldValue,
},
}
var response []byte
response, err = util.PostMultipartForm(fields, uri)
if err != nil {
return
}
var resMaterial resAddMaterial
err = json.Unmarshal(response, &resMaterial)
if err != nil {
return
}
if resMaterial.ErrCode != 0 {
err = fmt.Errorf("AddMaterial error : errcode=%v , errmsg=%v", resMaterial.ErrCode, resMaterial.ErrMsg)
return
}
mediaID = resMaterial.MediaID
url = resMaterial.URL
return
}
type reqDeleteMaterial struct {
MediaID string `json:"media_id"`
}
// DeleteMaterial 删除永久素材
func (material *Material) DeleteMaterial(mediaID string) error {
accessToken, err := material.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", delMaterialURL, accessToken)
response, err := util.PostJSON(uri, reqDeleteMaterial{mediaID})
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "DeleteMaterial")
}
// ArticleList 永久素材列表
type ArticleList struct {
util.CommonError
TotalCount int64 `json:"total_count"`
ItemCount int64 `json:"item_count"`
Item []ArticleListItem `json:"item"`
}
// ArticleListItem 用于ArticleList的item节点
type ArticleListItem struct {
MediaID string `json:"media_id"`
Content ArticleListContent `json:"content"`
Name string `json:"name"`
URL string `json:"url"`
UpdateTime int64 `json:"update_time"`
}
// ArticleListContent 用于ArticleListItem的content节点
type ArticleListContent struct {
NewsItem []Article `json:"news_item"`
UpdateTime int64 `json:"update_time"`
CreateTime int64 `json:"create_time"`
}
// reqBatchGetMaterial BatchGetMaterial请求参数
type reqBatchGetMaterial struct {
Type PermanentMaterialType `json:"type"`
Count int64 `json:"count"`
Offset int64 `json:"offset"`
}
// BatchGetMaterial 批量获取永久素材
//reference:https://developers.weixin.qq.com/doc/offiaccount/Asset_Management/Get_materials_list.html
func (material *Material) BatchGetMaterial(permanentMaterialType PermanentMaterialType, offset, count int64) (list ArticleList, err error) {
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", batchGetMaterialURL, accessToken)
req := reqBatchGetMaterial{
Type: permanentMaterialType,
Offset: offset,
Count: count,
}
var response []byte
response, err = util.PostJSON(uri, req)
if err != nil {
return
}
err = util.DecodeWithError(response, &list, "BatchGetMaterial")
return
}
// ResMaterialCount 素材总数
type ResMaterialCount struct {
util.CommonError
VoiceCount int64 `json:"voice_count"` // 语音总数量
VideoCount int64 `json:"video_count"` // 视频总数量
ImageCount int64 `json:"image_count"` // 图片总数量
NewsCount int64 `json:"news_count"` // 图文总数量
}
// GetMaterialCount 获取素材总数.
func (material *Material) GetMaterialCount() (res ResMaterialCount, err error) {
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", getMaterialCountURL, accessToken)
var response []byte
response, err = util.HTTPGet(uri)
if err != nil {
return
}
err = util.DecodeWithError(response, &res, "GetMaterialCount")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/material/media.go
Generated Vendored
+109
View File
@@ -0,0 +1,109 @@
package material
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/util"
)
// MediaType 媒体文件类型
type MediaType string
const (
// MediaTypeImage 媒体文件:图片
MediaTypeImage MediaType = "image"
// MediaTypeVoice 媒体文件:声音
MediaTypeVoice MediaType = "voice"
// MediaTypeVideo 媒体文件:视频
MediaTypeVideo MediaType = "video"
// MediaTypeThumb 媒体文件:缩略图
MediaTypeThumb MediaType = "thumb"
)
const (
mediaUploadURL = "https://api.weixin.qq.com/cgi-bin/media/upload"
mediaUploadImageURL = "https://api.weixin.qq.com/cgi-bin/media/uploadimg"
mediaGetURL = "https://api.weixin.qq.com/cgi-bin/media/get"
)
// Media 临时素材上传返回信息
type Media struct {
util.CommonError
Type MediaType `json:"type"`
MediaID string `json:"media_id"`
ThumbMediaID string `json:"thumb_media_id"`
CreatedAt int64 `json:"created_at"`
}
// MediaUpload 临时素材上传
func (material *Material) MediaUpload(mediaType MediaType, filename string) (media Media, err error) {
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s&type=%s", mediaUploadURL, accessToken, mediaType)
var response []byte
response, err = util.PostFile("media", filename, uri)
if err != nil {
return
}
err = json.Unmarshal(response, &media)
if err != nil {
return
}
if media.ErrCode != 0 {
err = fmt.Errorf("MediaUpload error : errcode=%v , errmsg=%v", media.ErrCode, media.ErrMsg)
return
}
return
}
// GetMediaURL 返回临时素材的下载地址供用户自己处理
// NOTICE: URL 不可公开，因为含access_token 需要立即另存文件
func (material *Material) GetMediaURL(mediaID string) (mediaURL string, err error) {
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
mediaURL = fmt.Sprintf("%s?access_token=%s&media_id=%s", mediaGetURL, accessToken, mediaID)
return
}
// resMediaImage 图片上传返回结果
type resMediaImage struct {
util.CommonError
URL string `json:"url"`
}
// ImageUpload 图片上传
func (material *Material) ImageUpload(filename string) (url string, err error) {
var accessToken string
accessToken, err = material.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", mediaUploadImageURL, accessToken)
var response []byte
response, err = util.PostFile("media", filename, uri)
if err != nil {
return
}
var image resMediaImage
err = json.Unmarshal(response, &image)
if err != nil {
return
}
if image.ErrCode != 0 {
err = fmt.Errorf("UploadImage error : errcode=%v , errmsg=%v", image.ErrCode, image.ErrMsg)
return
}
url = image.URL
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/menu/button.go
Generated Vendored
+215
View File
@@ -0,0 +1,215 @@
package menu
// Button 菜单按钮
type Button struct {
Type string `json:"type,omitempty"`
Name string `json:"name,omitempty"`
Key string `json:"key,omitempty"`
URL string `json:"url,omitempty"`
MediaID string `json:"media_id,omitempty"`
AppID string `json:"appid,omitempty"`
PagePath string `json:"pagepath,omitempty"`
SubButtons []*Button `json:"sub_button,omitempty"`
}
// SetSubButton 设置二级菜单
func (btn *Button) SetSubButton(name string, subButtons []*Button) *Button {
btn.Name = name
btn.SubButtons = subButtons
btn.Type = ""
btn.Key = ""
btn.URL = ""
btn.MediaID = ""
return btn
}
// SetClickButton btn 为click类型
func (btn *Button) SetClickButton(name, key string) *Button {
btn.Type = "click"
btn.Name = name
btn.Key = key
btn.URL = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetViewButton view类型
func (btn *Button) SetViewButton(name, url string) *Button {
btn.Type = "view"
btn.Name = name
btn.URL = url
btn.Key = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetScanCodePushButton 扫码推事件
func (btn *Button) SetScanCodePushButton(name, key string) *Button {
btn.Type = "scancode_push"
btn.Name = name
btn.Key = key
btn.URL = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetScanCodeWaitMsgButton 设置 扫码推事件且弹出"消息接收中"提示框
func (btn *Button) SetScanCodeWaitMsgButton(name, key string) *Button {
btn.Type = "scancode_waitmsg"
btn.Name = name
btn.Key = key
btn.URL = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetPicSysPhotoButton 设置弹出系统拍照发图按钮
func (btn *Button) SetPicSysPhotoButton(name, key string) *Button {
btn.Type = "pic_sysphoto"
btn.Name = name
btn.Key = key
btn.URL = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetPicPhotoOrAlbumButton 设置弹出拍照或者相册发图类型按钮
func (btn *Button) SetPicPhotoOrAlbumButton(name, key string) *Button {
btn.Type = "pic_photo_or_album"
btn.Name = name
btn.Key = key
btn.URL = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetPicWeixinButton 设置弹出微信相册发图器类型按钮
func (btn *Button) SetPicWeixinButton(name, key string) *Button {
btn.Type = "pic_weixin"
btn.Name = name
btn.Key = key
btn.URL = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetLocationSelectButton 设置 弹出地理位置选择器 类型按钮
func (btn *Button) SetLocationSelectButton(name, key string) *Button {
btn.Type = "location_select"
btn.Name = name
btn.Key = key
btn.URL = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// SetMediaIDButton 设置 下发消息(除文本消息) 类型按钮
func (btn *Button) SetMediaIDButton(name, mediaID string) *Button {
btn.Type = "media_id"
btn.Name = name
btn.MediaID = mediaID
btn.Key = ""
btn.URL = ""
btn.SubButtons = nil
return btn
}
// SetViewLimitedButton 设置 跳转图文消息URL 类型按钮
func (btn *Button) SetViewLimitedButton(name, mediaID string) *Button {
btn.Type = "view_limited"
btn.Name = name
btn.MediaID = mediaID
btn.Key = ""
btn.URL = ""
btn.SubButtons = nil
return btn
}
// SetMiniprogramButton 设置 跳转小程序 类型按钮 (公众号后台必须已经关联小程序)
func (btn *Button) SetMiniprogramButton(name, url, appID, pagePath string) *Button {
btn.Type = "miniprogram"
btn.Name = name
btn.URL = url
btn.AppID = appID
btn.PagePath = pagePath
btn.Key = ""
btn.MediaID = ""
btn.SubButtons = nil
return btn
}
// NewSubButton 二级菜单
func NewSubButton(name string, subButtons []*Button) *Button {
return (&Button{}).SetSubButton(name, subButtons)
}
// NewClickButton btn 为click类型
func NewClickButton(name, key string) *Button {
return (&Button{}).SetClickButton(name, key)
}
// NewViewButton view类型
func NewViewButton(name, url string) *Button {
return (&Button{}).SetViewButton(name, url)
}
// NewScanCodePushButton 扫码推事件
func NewScanCodePushButton(name, key string) *Button {
return (&Button{}).SetScanCodePushButton(name, key)
}
// NewScanCodeWaitMsgButton 扫码推事件且弹出"消息接收中"提示框
func NewScanCodeWaitMsgButton(name, key string) *Button {
return (&Button{}).SetScanCodeWaitMsgButton(name, key)
}
// NewPicSysPhotoButton 弹出系统拍照发图按钮
func NewPicSysPhotoButton(name, key string) *Button {
return (&Button{}).SetPicSysPhotoButton(name, key)
}
// NewPicPhotoOrAlbumButton 弹出拍照或者相册发图类型按钮
func NewPicPhotoOrAlbumButton(name, key string) *Button {
return (&Button{}).SetPicPhotoOrAlbumButton(name, key)
}
// NewPicWeixinButton 弹出微信相册发图器类型按钮
func NewPicWeixinButton(name, key string) *Button {
return (&Button{}).SetPicWeixinButton(name, key)
}
// NewLocationSelectButton 弹出地理位置选择器 类型按钮
func NewLocationSelectButton(name, key string) *Button {
return (&Button{}).SetLocationSelectButton(name, key)
}
// NewMediaIDButton 下发消息(除文本消息) 类型按钮
func NewMediaIDButton(name, mediaID string) *Button {
return (&Button{}).SetMediaIDButton(name, mediaID)
}
// NewViewLimitedButton 跳转图文消息URL 类型按钮
func NewViewLimitedButton(name, mediaID string) *Button {
return (&Button{}).SetViewLimitedButton(name, mediaID)
}
// NewMiniprogramButton 跳转小程序 类型按钮 (公众号后台必须已经关联小程序)
func NewMiniprogramButton(name, url, appID, pagePath string) *Button {
return (&Button{}).SetMiniprogramButton(name, url, appID, pagePath)
}
vendor/github.com/silenceper/wechat/v2/officialaccount/menu/menu.go
Generated Vendored
+303
View File
@@ -0,0 +1,303 @@
package menu
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
menuCreateURL = "https://api.weixin.qq.com/cgi-bin/menu/create"
menuGetURL = "https://api.weixin.qq.com/cgi-bin/menu/get"
menuDeleteURL = "https://api.weixin.qq.com/cgi-bin/menu/delete"
menuAddConditionalURL = "https://api.weixin.qq.com/cgi-bin/menu/addconditional"
menuDeleteConditionalURL = "https://api.weixin.qq.com/cgi-bin/menu/delconditional"
menuTryMatchURL = "https://api.weixin.qq.com/cgi-bin/menu/trymatch"
menuSelfMenuInfoURL = "https://api.weixin.qq.com/cgi-bin/get_current_selfmenu_info"
)
// Menu struct
type Menu struct {
*context.Context
}
// reqMenu 设置菜单请求数据
type reqMenu struct {
Button []*Button `json:"button,omitempty"`
MatchRule *MatchRule `json:"matchrule,omitempty"`
}
// reqDeleteConditional 删除个性化菜单请求数据
type reqDeleteConditional struct {
MenuID int64 `json:"menuid"`
}
// reqMenuTryMatch 菜单匹配请求
type reqMenuTryMatch struct {
UserID string `json:"user_id"`
}
// resConditionalMenu 个性化菜单返回结果
type resConditionalMenu struct {
Button []Button `json:"button"`
MatchRule MatchRule `json:"matchrule"`
MenuID int64 `json:"menuid"`
}
// resMenuTryMatch 菜单匹配请求结果
type resMenuTryMatch struct {
util.CommonError
Button []Button `json:"button"`
}
// ResMenu 查询菜单的返回数据
type ResMenu struct {
util.CommonError
Menu struct {
Button []Button `json:"button"`
MenuID int64 `json:"menuid"`
} `json:"menu"`
Conditionalmenu []resConditionalMenu `json:"conditionalmenu"`
}
// ResSelfMenuInfo 自定义菜单配置返回结果
type ResSelfMenuInfo struct {
util.CommonError
IsMenuOpen int32 `json:"is_menu_open"`
SelfMenuInfo struct {
Button []SelfMenuButton `json:"button"`
} `json:"selfmenu_info"`
}
// SelfMenuButton 自定义菜单配置详情
type SelfMenuButton struct {
Type string `json:"type"`
Name string `json:"name"`
Key string `json:"key"`
URL string `json:"url,omitempty"`
Value string `json:"value,omitempty"`
SubButton struct {
List []SelfMenuButton `json:"list"`
} `json:"sub_button,omitempty"`
NewsInfo struct {
List []ButtonNew `json:"list"`
} `json:"news_info,omitempty"`
}
// ButtonNew 图文消息菜单
type ButtonNew struct {
Title string `json:"title"`
Author string `json:"author"`
Digest string `json:"digest"`
ShowCover int32 `json:"show_cover"`
CoverURL string `json:"cover_url"`
ContentURL string `json:"content_url"`
SourceURL string `json:"source_url"`
}
// MatchRule 个性化菜单规则
type MatchRule struct {
GroupID string `json:"group_id,omitempty"`
Sex string `json:"sex,omitempty"`
Country string `json:"country,omitempty"`
Province string `json:"province,omitempty"`
City string `json:"city,omitempty"`
ClientPlatformType string `json:"client_platform_type,omitempty"`
Language string `json:"language,omitempty"`
}
// NewMenu 实例
func NewMenu(context *context.Context) *Menu {
menu := new(Menu)
menu.Context = context
return menu
}
// SetMenu 设置按钮
func (menu *Menu) SetMenu(buttons []*Button) error {
accessToken, err := menu.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", menuCreateURL, accessToken)
reqMenu := &reqMenu{
Button: buttons,
}
response, err := util.PostJSON(uri, reqMenu)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "SetMenu")
}
// SetMenuByJSON 设置按钮
func (menu *Menu) SetMenuByJSON(jsonInfo string) error {
accessToken, err := menu.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", menuCreateURL, accessToken)
response, err := util.HTTPPost(uri, jsonInfo)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "SetMenuByJSON")
}
// GetMenu 获取菜单配置
func (menu *Menu) GetMenu() (resMenu ResMenu, err error) {
var accessToken string
accessToken, err = menu.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", menuGetURL, accessToken)
var response []byte
response, err = util.HTTPGet(uri)
if err != nil {
return
}
err = json.Unmarshal(response, &resMenu)
if err != nil {
return
}
if resMenu.ErrCode != 0 {
err = fmt.Errorf("GetMenu Error , errcode=%d , errmsg=%s", resMenu.ErrCode, resMenu.ErrMsg)
return
}
return
}
// DeleteMenu 删除菜单
func (menu *Menu) DeleteMenu() error {
accessToken, err := menu.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", menuDeleteURL, accessToken)
response, err := util.HTTPGet(uri)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "GetMenu")
}
// AddConditional 添加个性化菜单
func (menu *Menu) AddConditional(buttons []*Button, matchRule *MatchRule) error {
accessToken, err := menu.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", menuAddConditionalURL, accessToken)
reqMenu := &reqMenu{
Button: buttons,
MatchRule: matchRule,
}
response, err := util.PostJSON(uri, reqMenu)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "AddConditional")
}
// AddConditionalByJSON 添加个性化菜单
func (menu *Menu) AddConditionalByJSON(jsonInfo string) error {
accessToken, err := menu.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", menuAddConditionalURL, accessToken)
response, err := util.HTTPPost(uri, jsonInfo)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "AddConditional")
}
// DeleteConditional 删除个性化菜单
func (menu *Menu) DeleteConditional(menuID int64) error {
accessToken, err := menu.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", menuDeleteConditionalURL, accessToken)
reqDeleteConditional := &reqDeleteConditional{
MenuID: menuID,
}
response, err := util.PostJSON(uri, reqDeleteConditional)
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "DeleteConditional")
}
// MenuTryMatch 菜单匹配
func (menu *Menu) MenuTryMatch(userID string) (buttons []Button, err error) {
var accessToken string
accessToken, err = menu.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", menuTryMatchURL, accessToken)
reqMenuTryMatch := &reqMenuTryMatch{userID}
var response []byte
response, err = util.PostJSON(uri, reqMenuTryMatch)
if err != nil {
return
}
var resMenuTryMatch resMenuTryMatch
err = json.Unmarshal(response, &resMenuTryMatch)
if err != nil {
return
}
if resMenuTryMatch.ErrCode != 0 {
err = fmt.Errorf("MenuTryMatch Error , errcode=%d , errmsg=%s", resMenuTryMatch.ErrCode, resMenuTryMatch.ErrMsg)
return
}
buttons = resMenuTryMatch.Button
return
}
// GetCurrentSelfMenuInfo 获取自定义菜单配置接口
func (menu *Menu) GetCurrentSelfMenuInfo() (resSelfMenuInfo ResSelfMenuInfo, err error) {
var accessToken string
accessToken, err = menu.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", menuSelfMenuInfoURL, accessToken)
var response []byte
response, err = util.HTTPGet(uri)
if err != nil {
return
}
err = json.Unmarshal(response, &resSelfMenuInfo)
if err != nil {
return
}
if resSelfMenuInfo.ErrCode != 0 {
err = fmt.Errorf("GetCurrentSelfMenuInfo Error , errcode=%d , errmsg=%s", resSelfMenuInfo.ErrCode, resSelfMenuInfo.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/customer_message.go
Generated Vendored
+178
View File
@@ -0,0 +1,178 @@
package message
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
customerSendMessage = "https://api.weixin.qq.com/cgi-bin/message/custom/send"
)
// Manager 消息管理者，可以发送消息
type Manager struct {
*context.Context
}
// NewMessageManager 实例化消息管理者
func NewMessageManager(context *context.Context) *Manager {
return &Manager{
context,
}
}
// CustomerMessage 客服消息
type CustomerMessage struct {
ToUser string `json:"touser"` // 接受者OpenID
Msgtype MsgType `json:"msgtype"` // 客服消息类型
Text *MediaText `json:"text,omitempty"` // 可选
Image *MediaResource `json:"image,omitempty"` // 可选
Voice *MediaResource `json:"voice,omitempty"` // 可选
Video *MediaVideo `json:"video,omitempty"` // 可选
Music *MediaMusic `json:"music,omitempty"` // 可选
News *MediaNews `json:"news,omitempty"` // 可选
Mpnews *MediaResource `json:"mpnews,omitempty"` // 可选
Wxcard *MediaWxcard `json:"wxcard,omitempty"` // 可选
Msgmenu *MediaMsgmenu `json:"msgmenu,omitempty"` // 可选
Miniprogrampage *MediaMiniprogrampage `json:"miniprogrampage,omitempty"` // 可选
}
// NewCustomerTextMessage 文本消息结构体构造方法
func NewCustomerTextMessage(toUser, text string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeText,
Text: &MediaText{
text,
},
}
}
// NewCustomerImgMessage 图片消息的构造方法
func NewCustomerImgMessage(toUser, mediaID string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeImage,
Image: &MediaResource{
mediaID,
},
}
}
// NewCustomerVoiceMessage 语音消息的构造方法
func NewCustomerVoiceMessage(toUser, mediaID string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeVoice,
Voice: &MediaResource{
mediaID,
},
}
}
// NewCustomerMiniprogrampageMessage 小程序卡片消息的构造方法
func NewCustomerMiniprogrampageMessage(toUser, title, appID, pagePath, thumbMediaID string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
Msgtype: MsgTypeMiniprogrampage,
Miniprogrampage: &MediaMiniprogrampage{
Title: title,
AppID: appID,
Pagepath: pagePath,
ThumbMediaID: thumbMediaID,
},
}
}
// MediaText 文本消息的文字
type MediaText struct {
Content string `json:"content"`
}
// MediaResource 消息使用的永久素材id
type MediaResource struct {
MediaID string `json:"media_id"`
}
// MediaVideo 视频消息包含的内容
type MediaVideo struct {
MediaID string `json:"media_id"`
ThumbMediaID string `json:"thumb_media_id"`
Title string `json:"title"`
Description string `json:"description"`
}
// MediaMusic 音乐消息包括的内容
type MediaMusic struct {
Title string `json:"title"`
Description string `json:"description"`
Musicurl string `json:"musicurl"`
Hqmusicurl string `json:"hqmusicurl"`
ThumbMediaID string `json:"thumb_media_id"`
}
// MediaNews 图文消息的内容
type MediaNews struct {
Articles []MediaArticles `json:"articles"`
}
// MediaArticles 图文消息的内容的文章列表中的单独一条
type MediaArticles struct {
Title string `json:"title"`
Description string `json:"description"`
URL string `json:"url"`
Picurl string `json:"picurl"`
}
// MediaMsgmenu 菜单消息的内容
type MediaMsgmenu struct {
HeadContent string `json:"head_content"`
List []MsgmenuItem `json:"list"`
TailContent string `json:"tail_content"`
}
// MsgmenuItem 菜单消息的菜单按钮
type MsgmenuItem struct {
ID string `json:"id"`
Content string `json:"content"`
}
// MediaWxcard 卡券的id
type MediaWxcard struct {
CardID string `json:"card_id"`
}
// MediaMiniprogrampage 小程序消息
type MediaMiniprogrampage struct {
Title string `json:"title"`
AppID string `json:"appid"`
Pagepath string `json:"pagepath"`
ThumbMediaID string `json:"thumb_media_id"`
}
// Send 发送客服消息
func (manager *Manager) Send(msg *CustomerMessage) error {
accessToken, err := manager.Context.GetAccessToken()
if err != nil {
return err
}
uri := fmt.Sprintf("%s?access_token=%s", customerSendMessage, accessToken)
response, err := util.PostJSON(uri, msg)
if err != nil {
return err
}
var result util.CommonError
err = json.Unmarshal(response, &result)
if err != nil {
return err
}
if result.ErrCode != 0 {
err = fmt.Errorf("customer msg send error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return err
}
return nil
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/image.go
Generated Vendored
+17
View File
@@ -0,0 +1,17 @@
package message
// Image 图片消息
type Image struct {
CommonToken
Image struct {
MediaID string `xml:"MediaId"`
} `xml:"Image"`
}
// NewImage 回复图片消息
func NewImage(mediaID string) *Image {
image := new(Image)
image.Image.MediaID = mediaID
return image
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/message.go
Generated Vendored
+280
View File
@@ -0,0 +1,280 @@
package message
import (
"encoding/xml"
"github.com/silenceper/wechat/v2/officialaccount/device"
"github.com/silenceper/wechat/v2/officialaccount/freepublish"
)
// MsgType 基本消息类型
type MsgType string
// EventType 事件类型
type EventType string
// InfoType 第三方平台授权事件类型
type InfoType string
const (
// MsgTypeText 表示文本消息
MsgTypeText MsgType = "text"
// MsgTypeImage 表示图片消息
MsgTypeImage MsgType = "image"
// MsgTypeVoice 表示语音消息
MsgTypeVoice MsgType = "voice"
// MsgTypeVideo 表示视频消息
MsgTypeVideo MsgType = "video"
// MsgTypeMiniprogrampage 表示小程序卡片消息
MsgTypeMiniprogrampage MsgType = "miniprogrampage"
// MsgTypeShortVideo 表示短视频消息[限接收]
MsgTypeShortVideo MsgType = "shortvideo"
// MsgTypeLocation 表示坐标消息[限接收]
MsgTypeLocation MsgType = "location"
// MsgTypeLink 表示链接消息[限接收]
MsgTypeLink MsgType = "link"
// MsgTypeMusic 表示音乐消息[限回复]
MsgTypeMusic MsgType = "music"
// MsgTypeNews 表示图文消息[限回复]
MsgTypeNews MsgType = "news"
// MsgTypeTransfer 表示消息消息转发到客服
MsgTypeTransfer MsgType = "transfer_customer_service"
// MsgTypeEvent 表示事件推送消息
MsgTypeEvent MsgType = "event"
)
const (
// EventSubscribe 订阅
EventSubscribe EventType = "subscribe"
// EventUnsubscribe 取消订阅
EventUnsubscribe EventType = "unsubscribe"
// EventScan 用户已经关注公众号，则微信会将带场景值扫描事件推送给开发者
EventScan EventType = "SCAN"
// EventLocation 上报地理位置事件
EventLocation EventType = "LOCATION"
// EventClick 点击菜单拉取消息时的事件推送
EventClick EventType = "CLICK"
// EventView 点击菜单跳转链接时的事件推送
EventView EventType = "VIEW"
// EventScancodePush 扫码推事件的事件推送
EventScancodePush EventType = "scancode_push"
// EventScancodeWaitmsg 扫码推事件且弹出“消息接收中”提示框的事件推送
EventScancodeWaitmsg EventType = "scancode_waitmsg"
// EventPicSysphoto 弹出系统拍照发图的事件推送
EventPicSysphoto EventType = "pic_sysphoto"
// EventPicPhotoOrAlbum 弹出拍照或者相册发图的事件推送
EventPicPhotoOrAlbum EventType = "pic_photo_or_album"
// EventPicWeixin 弹出微信相册发图器的事件推送
EventPicWeixin EventType = "pic_weixin"
// EventLocationSelect 弹出地理位置选择器的事件推送
EventLocationSelect EventType = "location_select"
// EventTemplateSendJobFinish 发送模板消息推送通知
EventTemplateSendJobFinish EventType = "TEMPLATESENDJOBFINISH"
// EventMassSendJobFinish 群发消息推送通知
EventMassSendJobFinish EventType = "MASSSENDJOBFINISH"
// EventWxaMediaCheck 异步校验图片/音频是否含有违法违规内容推送事件
EventWxaMediaCheck EventType = "wxa_media_check"
// EventSubscribeMsgPopupEvent 订阅通知事件推送
EventSubscribeMsgPopupEvent EventType = "subscribe_msg_popup_event"
// EventPublishJobFinish 发布任务完成
EventPublishJobFinish EventType = "PUBLISHJOBFINISH"
)
const (
// 微信开放平台需要用到
// InfoTypeVerifyTicket 返回ticket
InfoTypeVerifyTicket InfoType = "component_verify_ticket"
// InfoTypeAuthorized 授权
InfoTypeAuthorized InfoType = "authorized"
// InfoTypeUnauthorized 取消授权
InfoTypeUnauthorized InfoType = "unauthorized"
// InfoTypeUpdateAuthorized 更新授权
InfoTypeUpdateAuthorized InfoType = "updateauthorized"
// InfoTypeNotifyThirdFasterRegister 注册审核事件推送
InfoTypeNotifyThirdFasterRegister InfoType = "notify_third_fasteregister"
)
// MixMessage 存放所有微信发送过来的消息和事件
type MixMessage struct {
CommonToken
// 基本消息
MsgID int64 `xml:"MsgId"` // 其他消息推送过来是MsgId
TemplateMsgID int64 `xml:"MsgID"` // 模板消息推送成功的消息是MsgID
Content string `xml:"Content"`
Recognition string `xml:"Recognition"`
PicURL string `xml:"PicUrl"`
MediaID string `xml:"MediaId"`
Format string `xml:"Format"`
ThumbMediaID string `xml:"ThumbMediaId"`
LocationX float64 `xml:"Location_X"`
LocationY float64 `xml:"Location_Y"`
Scale float64 `xml:"Scale"`
Label string `xml:"Label"`
Title string `xml:"Title"`
Description string `xml:"Description"`
URL string `xml:"Url"`
// 事件相关
Event EventType `xml:"Event"`
EventKey string `xml:"EventKey"`
Ticket string `xml:"Ticket"`
Latitude string `xml:"Latitude"`
Longitude string `xml:"Longitude"`
Precision string `xml:"Precision"`
MenuID string `xml:"MenuId"`
Status string `xml:"Status"`
SessionFrom string `xml:"SessionFrom"`
TotalCount int64 `xml:"TotalCount"`
FilterCount int64 `xml:"FilterCount"`
SentCount int64 `xml:"SentCount"`
ErrorCount int64 `xml:"ErrorCount"`
ScanCodeInfo struct {
ScanType string `xml:"ScanType"`
ScanResult string `xml:"ScanResult"`
} `xml:"ScanCodeInfo"`
SendPicsInfo struct {
Count int32 `xml:"Count"`
PicList []EventPic `xml:"PicList>item"`
} `xml:"SendPicsInfo"`
SendLocationInfo struct {
LocationX float64 `xml:"Location_X"`
LocationY float64 `xml:"Location_Y"`
Scale float64 `xml:"Scale"`
Label string `xml:"Label"`
Poiname string `xml:"Poiname"`
}
SubscribeMsgPopupEvent []struct {
List SubscribeMsgPopupEvent `xml:"List"`
} `xml:"SubscribeMsgPopupEvent"`
// 事件相关：发布能力
PublishEventInfo struct {
PublishID int64 `xml:"publish_id"` // 发布任务id
PublishStatus freepublish.PublishStatus `xml:"publish_status"` // 发布状态
ArticleID string `xml:"article_id"` // 当发布状态为0时（即成功）时，返回图文的 article_id，可用于“客服消息”场景
ArticleDetail struct {
Count uint `xml:"count"` // 文章数量
Item []struct {
Index uint `xml:"idx"` // 文章对应的编号
ArticleURL string `xml:"article_url"` // 图文的永久链接
} `xml:"item"`
} `xml:"article_detail"` // 当发布状态为0时（即成功）时，返回内容
FailIndex []uint `xml:"fail_idx"` // 当发布状态为2或4时，返回不通过的文章编号，第一篇为 1；其他发布状态则为空
} `xml:"PublishEventInfo"`
// 第三方平台相关
InfoType InfoType `xml:"InfoType"`
AppID string `xml:"AppId"`
ComponentVerifyTicket string `xml:"ComponentVerifyTicket"`
AuthorizerAppid string `xml:"AuthorizerAppid"`
AuthorizationCode string `xml:"AuthorizationCode"`
AuthorizationCodeExpiredTime int64 `xml:"AuthorizationCodeExpiredTime"`
PreAuthCode string `xml:"PreAuthCode"`
AuthCode string `xml:"auth_code"`
Info struct {
Name string `xml:"name"`
Code string `xml:"code"`
CodeType int `xml:"code_type"`
LegalPersonaWechat string `xml:"legal_persona_wechat"`
LegalPersonaName string `xml:"legal_persona_name"`
ComponentPhone string `xml:"component_phone"`
} `xml:"info"`
// 卡券相关
CardID string `xml:"CardId"`
RefuseReason string `xml:"RefuseReason"`
IsGiveByFriend int32 `xml:"IsGiveByFriend"`
FriendUserName string `xml:"FriendUserName"`
UserCardCode string `xml:"UserCardCode"`
OldUserCardCode string `xml:"OldUserCardCode"`
OuterStr string `xml:"OuterStr"`
IsRestoreMemberCard int32 `xml:"IsRestoreMemberCard"`
UnionID string `xml:"UnionId"`
// 内容审核相关
IsRisky bool `xml:"isrisky"`
ExtraInfoJSON string `xml:"extra_info_json"`
TraceID string `xml:"trace_id"`
StatusCode int `xml:"status_code"`
// 设备相关
device.MsgDevice
}
// SubscribeMsgPopupEvent 订阅通知事件推送的消息体
type SubscribeMsgPopupEvent struct {
TemplateID string `xml:"TemplateId"`
SubscribeStatusString string `xml:"SubscribeStatusString"`
PopupScene int `xml:"PopupScene"`
}
// EventPic 发图事件推送
type EventPic struct {
PicMd5Sum string `xml:"PicMd5Sum"`
}
// EncryptedXMLMsg 安全模式下的消息体
type EncryptedXMLMsg struct {
XMLName struct{} `xml:"xml" json:"-"`
ToUserName string `xml:"ToUserName" json:"ToUserName"`
EncryptedMsg string `xml:"Encrypt" json:"Encrypt"`
}
// ResponseEncryptedXMLMsg 需要返回的消息体
type ResponseEncryptedXMLMsg struct {
XMLName struct{} `xml:"xml" json:"-"`
EncryptedMsg string `xml:"Encrypt" json:"Encrypt"`
MsgSignature string `xml:"MsgSignature" json:"MsgSignature"`
Timestamp int64 `xml:"TimeStamp" json:"TimeStamp"`
Nonce string `xml:"Nonce" json:"Nonce"`
}
// CDATA 使用该类型,在序列化为 xml 文本时文本会被解析器忽略
type CDATA string
// MarshalXML 实现自己的序列化方法
func (c CDATA) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
return e.EncodeElement(struct {
string `xml:",cdata"`
}{string(c)}, start)
}
// CommonToken 消息中通用的结构
type CommonToken struct {
XMLName xml.Name `xml:"xml"`
ToUserName CDATA `xml:"ToUserName"`
FromUserName CDATA `xml:"FromUserName"`
CreateTime int64 `xml:"CreateTime"`
MsgType MsgType `xml:"MsgType"`
}
// SetToUserName set ToUserName
func (msg *CommonToken) SetToUserName(toUserName CDATA) {
msg.ToUserName = toUserName
}
// SetFromUserName set FromUserName
func (msg *CommonToken) SetFromUserName(fromUserName CDATA) {
msg.FromUserName = fromUserName
}
// SetCreateTime set createTime
func (msg *CommonToken) SetCreateTime(createTime int64) {
msg.CreateTime = createTime
}
// SetMsgType set MsgType
func (msg *CommonToken) SetMsgType(msgType MsgType) {
msg.MsgType = msgType
}
// GetOpenID get the FromUserName value
func (msg *CommonToken) GetOpenID() string {
return string(msg.FromUserName)
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/music.go
Generated Vendored
+24
View File
@@ -0,0 +1,24 @@
package message
// Music 音乐消息
type Music struct {
CommonToken
Music struct {
Title string `xml:"Title" `
Description string `xml:"Description" `
MusicURL string `xml:"MusicUrl" `
HQMusicURL string `xml:"HQMusicUrl" `
ThumbMediaID string `xml:"ThumbMediaId"`
} `xml:"Music"`
}
// NewMusic 回复音乐消息
func NewMusic(title, description, musicURL, hQMusicURL, thumbMediaID string) *Music {
music := new(Music)
music.Music.Title = title
music.Music.Description = description
music.Music.MusicURL = musicURL
music.Music.ThumbMediaID = thumbMediaID
return music
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/news.go
Generated Vendored
+35
View File
@@ -0,0 +1,35 @@
package message
// News 图文消息
type News struct {
CommonToken
ArticleCount int `xml:"ArticleCount"`
Articles []*Article `xml:"Articles>item,omitempty"`
}
// NewNews 初始化图文消息
func NewNews(articles []*Article) *News {
news := new(News)
news.ArticleCount = len(articles)
news.Articles = articles
return news
}
// Article 单篇文章
type Article struct {
Title string `xml:"Title,omitempty"`
Description string `xml:"Description,omitempty"`
PicURL string `xml:"PicUrl,omitempty"`
URL string `xml:"Url,omitempty"`
}
// NewArticle 初始化文章
func NewArticle(title, description, picURL, url string) *Article {
article := new(Article)
article.Title = title
article.Description = description
article.PicURL = picURL
article.URL = url
return article
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/reply.go
Generated Vendored
+15
View File
@@ -0,0 +1,15 @@
package message
import "errors"
// ErrInvalidReply 无效的回复
var ErrInvalidReply = errors.New("无效的回复消息")
// ErrUnsupportReply 不支持的回复类型
var ErrUnsupportReply = errors.New("不支持的回复消息")
// Reply 消息回复
type Reply struct {
MsgType MsgType
MsgData interface{}
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/subscribe.go
Generated Vendored
+147
View File
@@ -0,0 +1,147 @@
package message
import (
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
subscribeSendURL = "https://api.weixin.qq.com/cgi-bin/message/subscribe/bizsend"
subscribeTemplateListURL = "https://api.weixin.qq.com/wxaapi/newtmpl/gettemplate"
subscribeTemplateAddURL = "https://api.weixin.qq.com/wxaapi/newtmpl/addtemplate"
subscribeTemplateDelURL = "https://api.weixin.qq.com/wxaapi/newtmpl/deltemplate"
)
// Subscribe 订阅消息
type Subscribe struct {
*context.Context
}
// NewSubscribe 实例化
func NewSubscribe(context *context.Context) *Subscribe {
tpl := new(Subscribe)
tpl.Context = context
return tpl
}
// 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"` // 必须, 模板数据
MiniProgram struct {
AppID string `json:"appid"` // 所需跳转到的小程序appid（该小程序appid必须与发模板消息的公众号是绑定关联关系）
PagePath string `json:"pagepath"` // 所需跳转到小程序的具体页面路径，支持带参数,（示例index?foo=bar）
} `json:"miniprogram"` // 可选,跳转至小程序地址
}
// SubscribeDataItem 模版内某个 .DATA 的值
type SubscribeDataItem struct {
Value string `json:"value"`
}
// Send 发送订阅消息
func (tpl *Subscribe) Send(msg *SubscribeMessage) (err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", subscribeSendURL, accessToken)
response, err := util.PostJSON(uri, msg)
if err != nil {
return
}
return util.DecodeWithCommonError(response, "SendSubscribeMessage")
}
// PrivateSubscribeItem 私有订阅消息模板
type PrivateSubscribeItem struct {
PriTmplID string `json:"priTmplId"` // 添加至帐号下的模板 id，发送订阅通知时所需
Title string `json:"title"` // 模版标题
Content string `json:"content"` // 模版内容
Example string `json:"example"` // 模板内容示例
SubType int `json:"type"` // 模版类型，2 为一次性订阅，3 为长期订阅
}
type resPrivateSubscribeList struct {
util.CommonError
SubscriptionList []*PrivateSubscribeItem `json:"data"`
}
// List 获取私有订阅消息模板列表
func (tpl *Subscribe) List() (templateList []*PrivateSubscribeItem, err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", subscribeTemplateListURL, accessToken)
var response []byte
response, err = util.HTTPGet(uri)
if err != nil {
return
}
var res resPrivateSubscribeList
err = util.DecodeWithError(response, &res, "ListSubscribe")
if err != nil {
return
}
templateList = res.SubscriptionList
return
}
type resSubscribeAdd struct {
util.CommonError
TemplateID string `json:"priTmplId"`
}
// Add 添加订阅消息模板
func (tpl *Subscribe) Add(ShortID string, kidList []int, sceneDesc string) (templateID string, err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
var msg = struct {
TemplateIDShort string `json:"tid"`
SceneDesc string `json:"sceneDesc"`
KidList []int `json:"kidList"`
}{TemplateIDShort: ShortID, SceneDesc: sceneDesc, KidList: kidList}
uri := fmt.Sprintf("%s?access_token=%s", subscribeTemplateAddURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, msg)
if err != nil {
return
}
var result resSubscribeAdd
err = util.DecodeWithError(response, &result, "AddSubscribe")
if err != nil {
return
}
templateID = result.TemplateID
return
}
// Delete 删除私有模板
func (tpl *Subscribe) Delete(templateID string) (err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
var msg = struct {
TemplateID string `json:"priTmplId"`
}{TemplateID: templateID}
uri := fmt.Sprintf("%s?access_token=%s", subscribeTemplateDelURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, msg)
if err != nil {
return
}
return util.DecodeWithCommonError(response, "DeleteSubscribe")
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/template.go
Generated Vendored
+170
View File
@@ -0,0 +1,170 @@
package message
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
templateSendURL = "https://api.weixin.qq.com/cgi-bin/message/template/send"
templateListURL = "https://api.weixin.qq.com/cgi-bin/template/get_all_private_template"
templateAddURL = "https://api.weixin.qq.com/cgi-bin/template/api_add_template"
templateDelURL = "https://api.weixin.qq.com/cgi-bin/template/del_private_template"
)
// Template 模板消息
type Template struct {
*context.Context
}
// NewTemplate 实例化
func NewTemplate(context *context.Context) *Template {
tpl := new(Template)
tpl.Context = context
return tpl
}
// 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"` // 必须, 模板数据
MiniProgram struct {
AppID string `json:"appid"` // 所需跳转到的小程序appid（该小程序appid必须与发模板消息的公众号是绑定关联关系）
PagePath string `json:"pagepath"` // 所需跳转到小程序的具体页面路径，支持带参数,（示例index?foo=bar）
} `json:"miniprogram"` // 可选,跳转至小程序地址
}
// TemplateDataItem 模版内某个 .DATA 的值
type TemplateDataItem struct {
Value string `json:"value"`
Color string `json:"color,omitempty"`
}
type resTemplateSend struct {
util.CommonError
MsgID int64 `json:"msgid"`
}
// Send 发送模板消息
func (tpl *Template) Send(msg *TemplateMessage) (msgID int64, err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", templateSendURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, msg)
if err != nil {
return
}
var result resTemplateSend
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("template msg send error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
msgID = result.MsgID
return
}
// TemplateItem 模板消息.
type TemplateItem struct {
TemplateID string `json:"template_id"`
Title string `json:"title"`
PrimaryIndustry string `json:"primary_industry"`
DeputyIndustry string `json:"deputy_industry"`
Content string `json:"content"`
Example string `json:"example"`
}
type resTemplateList struct {
util.CommonError
TemplateList []*TemplateItem `json:"template_list"`
}
// List 获取模板列表
func (tpl *Template) List() (templateList []*TemplateItem, err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", templateListURL, accessToken)
var response []byte
response, err = util.HTTPGet(uri)
if err != nil {
return
}
var res resTemplateList
err = util.DecodeWithError(response, &res, "ListTemplate")
if err != nil {
return
}
templateList = res.TemplateList
return
}
type resTemplateAdd struct {
util.CommonError
TemplateID string `json:"template_id"`
}
// Add 添加模板.
func (tpl *Template) Add(shortID string) (templateID string, err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
var msg = struct {
ShortID string `json:"template_id_short"`
}{ShortID: shortID}
uri := fmt.Sprintf("%s?access_token=%s", templateAddURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, msg)
if err != nil {
return
}
var result resTemplateAdd
err = util.DecodeWithError(response, &result, "AddTemplate")
if err != nil {
return
}
templateID = result.TemplateID
return
}
// Delete 删除私有模板.
func (tpl *Template) Delete(templateID string) (err error) {
var accessToken string
accessToken, err = tpl.GetAccessToken()
if err != nil {
return
}
var msg = struct {
TemplateID string `json:"template_id"`
}{TemplateID: templateID}
uri := fmt.Sprintf("%s?access_token=%s", templateDelURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, msg)
if err != nil {
return
}
return util.DecodeWithCommonError(response, "DeleteTemplate")
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/text.go
Generated Vendored
+14
View File
@@ -0,0 +1,14 @@
package message
// Text 文本消息
type Text struct {
CommonToken
Content CDATA `xml:"Content"`
}
// NewText 初始化文本消息
func NewText(content string) *Text {
text := new(Text)
text.Content = CDATA(content)
return text
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/transfer_customer.go
Generated Vendored
+24
View File
@@ -0,0 +1,24 @@
package message
// TransferCustomer 转发客服消息
type TransferCustomer struct {
CommonToken
TransInfo *TransInfo `xml:"TransInfo,omitempty"`
}
// TransInfo 转发到指定客服
type TransInfo struct {
KfAccount string `xml:"KfAccount"`
}
// NewTransferCustomer 实例化
func NewTransferCustomer(kfAccount string) *TransferCustomer {
tc := new(TransferCustomer)
if kfAccount != "" {
transInfo := new(TransInfo)
transInfo.KfAccount = kfAccount
tc.TransInfo = transInfo
}
return tc
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/video.go
Generated Vendored
+21
View File
@@ -0,0 +1,21 @@
package message
// Video 视频消息
type Video struct {
CommonToken
Video struct {
MediaID string `xml:"MediaId"`
Title string `xml:"Title,omitempty"`
Description string `xml:"Description,omitempty"`
} `xml:"Video"`
}
// NewVideo 回复图片消息
func NewVideo(mediaID, title, description string) *Video {
video := new(Video)
video.Video.MediaID = mediaID
video.Video.Title = title
video.Video.Description = description
return video
}
vendor/github.com/silenceper/wechat/v2/officialaccount/message/voice.go
Generated Vendored
+17
View File
@@ -0,0 +1,17 @@
package message
// Voice 语音消息
type Voice struct {
CommonToken
Voice struct {
MediaID string `xml:"MediaId"`
} `xml:"Voice"`
}
// NewVoice 回复语音消息
func NewVoice(mediaID string) *Voice {
voice := new(Voice)
voice.Voice.MediaID = mediaID
return voice
}
vendor/github.com/silenceper/wechat/v2/officialaccount/oauth/oauth.go
Generated Vendored
+166
View File
@@ -0,0 +1,166 @@
package oauth
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
redirectOauthURL = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=%s&redirect_uri=%s&response_type=code&scope=%s&state=%s#wechat_redirect"
webAppRedirectOauthURL = "https://open.weixin.qq.com/connect/qrconnect?appid=%s&redirect_uri=%s&response_type=code&scope=%s&state=%s#wechat_redirect"
accessTokenURL = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=%s&secret=%s&code=%s&grant_type=authorization_code"
refreshAccessTokenURL = "https://api.weixin.qq.com/sns/oauth2/refresh_token?appid=%s&grant_type=refresh_token&refresh_token=%s"
userInfoURL = "https://api.weixin.qq.com/sns/userinfo?access_token=%s&openid=%s&lang=%s"
checkAccessTokenURL = "https://api.weixin.qq.com/sns/auth?access_token=%s&openid=%s"
)
// Oauth 保存用户授权信息
type Oauth struct {
*context.Context
}
// NewOauth 实例化授权信息
func NewOauth(context *context.Context) *Oauth {
auth := new(Oauth)
auth.Context = context
return auth
}
// 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地址
func (oauth *Oauth) GetWebAppRedirectURL(redirectURI, scope, state string) (string, error) {
urlStr := url.QueryEscape(redirectURI)
return fmt.Sprintf(webAppRedirectOauthURL, oauth.AppID, urlStr, scope, state), nil
}
// Redirect 跳转到网页授权
func (oauth *Oauth) Redirect(writer http.ResponseWriter, req *http.Request, redirectURI, scope, state string) error {
location, err := oauth.GetRedirectURL(redirectURI, scope, state)
if err != nil {
return err
}
http.Redirect(writer, req, location, http.StatusFound)
return nil
}
// ResAccessToken 获取用户授权access_token的返回结果
type ResAccessToken struct {
util.CommonError
AccessToken string `json:"access_token"`
ExpiresIn int64 `json:"expires_in"`
RefreshToken string `json:"refresh_token"`
OpenID string `json:"openid"`
Scope string `json:"scope"`
// UnionID 只有在用户将公众号绑定到微信开放平台帐号后，才会出现该字段。
// 公众号文档 https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421140842
UnionID string `json:"unionid"`
}
// GetUserAccessToken 通过网页授权的code 换取access_token(区别于context中的access_token)
func (oauth *Oauth) GetUserAccessToken(code string) (result ResAccessToken, err error) {
urlStr := fmt.Sprintf(accessTokenURL, oauth.AppID, oauth.AppSecret, code)
var response []byte
response, err = util.HTTPGet(urlStr)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetUserAccessToken error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// RefreshAccessToken 刷新access_token
func (oauth *Oauth) RefreshAccessToken(refreshToken string) (result ResAccessToken, err error) {
urlStr := fmt.Sprintf(refreshAccessTokenURL, oauth.AppID, refreshToken)
var response []byte
response, err = util.HTTPGet(urlStr)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetUserAccessToken error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
// CheckAccessToken 检验access_token是否有效
func (oauth *Oauth) CheckAccessToken(accessToken, openID string) (b bool, err error) {
urlStr := fmt.Sprintf(checkAccessTokenURL, accessToken, openID)
var response []byte
response, err = util.HTTPGet(urlStr)
if err != nil {
return
}
var result util.CommonError
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
b = false
return
}
b = true
return
}
// UserInfo 用户授权获取到用户信息
type UserInfo struct {
util.CommonError
OpenID string `json:"openid"`
Nickname string `json:"nickname"`
Sex int32 `json:"sex"`
Province string `json:"province"`
City string `json:"city"`
Country string `json:"country"`
HeadImgURL string `json:"headimgurl"`
Privilege []string `json:"privilege"`
Unionid string `json:"unionid"`
}
// GetUserInfo 如果scope为 snsapi_userinfo 则可以通过此方法获取到用户基本信息
func (oauth *Oauth) GetUserInfo(accessToken, openID, lang string) (result UserInfo, err error) {
if lang == "" {
lang = "zh_CN"
}
urlStr := fmt.Sprintf(userInfoURL, accessToken, openID, lang)
var response []byte
response, err = util.HTTPGet(urlStr)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetUserInfo error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/ocr/ocr.go
Generated Vendored
+287
View File
@@ -0,0 +1,287 @@
package ocr
import (
"fmt"
"net/url"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
ocrIDCardURL = "https://api.weixin.qq.com/cv/ocr/idcard"
ocrBankCardURL = "https://api.weixin.qq.com/cv/ocr/bankcard"
ocrDrivingURL = "https://api.weixin.qq.com/cv/ocr/driving"
ocrDrivingLicenseURL = "https://api.weixin.qq.com/cv/ocr/drivinglicense"
ocrBizLicenseURL = "https://api.weixin.qq.com/cv/ocr/bizlicense"
ocrCommonURL = "https://api.weixin.qq.com/cv/ocr/comm"
ocrPlateNumberURL = "https://api.weixin.qq.com/cv/ocr/platenum"
)
// OCR struct
type OCR struct {
*context.Context
}
// coordinate 坐标
type coordinate struct {
X int64 `json:"x,omitempty"`
Y int64 `json:"y,omitempty"`
}
// position 位置
type position struct {
LeftTop coordinate `json:"left_top"`
RightTop coordinate `json:"right_top"`
RightBottom coordinate `json:"right_bottom"`
LeftBottom coordinate `json:"left_bottom"`
}
// imageSize 图片尺寸
type imageSize struct {
Width int64 `json:"w,omitempty"`
Height int64 `json:"h,omitempty"`
}
// ResDriving 行驶证返回结果
type ResDriving struct {
util.CommonError
PlateNumber string `json:"plate_num,omitempty"`
VehicleType string `json:"vehicle_type,omitempty"`
Owner string `json:"owner,omitempty"`
Address string `json:"addr,omitempty"`
UseCharacter string `json:"use_character,omitempty"`
Model string `json:"model,omitempty"`
Vin string `json:"vin,omitempty"`
EngineNumber string `json:"engine_num,omitempty"`
RegisterDate string `json:"register_date,omitempty"`
IssueDate string `json:"issue_date,omitempty"`
PlateNumberB string `json:"plate_num_b,omitempty"`
Record string `json:"record,omitempty"`
PassengersNumber string `json:"passengers_num,omitempty"`
TotalQuality string `json:"total_quality,omitempty"`
PrepareQuality string `json:"prepare_quality,omitempty"`
OverallSize string `json:"overall_size,omitempty"`
CardPositionFront map[string]position `json:"card_position_front,omitempty"`
CardPositionBack map[string]position `json:"card_position_back,omitempty"`
ImageSize imageSize `json:"img_size,omitempty"`
}
// ResIDCard 身份证返回结果
type ResIDCard struct {
util.CommonError
Type string `json:"type,omitempty"`
Name string `json:"name,omitempty"`
ID string `json:"id,omitempty"`
Address string `json:"addr,omitempty"`
Gender string `json:"gender,omitempty"`
Nationality string `json:"nationality,omitempty"`
ValidDate string `json:"valid_date,omitempty"`
}
// ResBankCard 银行卡返回结果
type ResBankCard struct {
util.CommonError
Number string `json:"number,omitempty"`
}
// ResDrivingLicense 驾驶证返回结果
type ResDrivingLicense struct {
util.CommonError
IDNumber string `json:"id_num,omitempty"`
Name string `json:"name,omitempty"`
Sex string `json:"sex,omitempty"`
Nationality string `json:"nationality,omitempty"`
Address string `json:"address,omitempty"`
Birthday string `json:"birth_date,omitempty"`
IssueDate string `json:"issue_date,omitempty"`
CarClass string `json:"car_class,omitempty"`
ValidFrom string `json:"valid_from,omitempty"`
ValidTo string `json:"valid_to,omitempty"`
OfficialSeal string `json:"official_seal,omitempty"`
}
// ResBizLicense 营业执照返回结果
type ResBizLicense struct {
util.CommonError
RegisterNumber string `json:"reg_num,omitempty"`
Serial string `json:"serial,omitempty"`
LegalRepresentative string `json:"legal_representative,omitempty"`
EnterpriseName string `json:"enterprise_name,omitempty"`
TypeOfOrganization string `json:"type_of_organization,omitempty"`
Address string `json:"address,omitempty"`
TypeOfEnterprise string `json:"type_of_enterprise,omitempty"`
BusinessScope string `json:"business_scope,omitempty"`
RegisteredCapital string `json:"registered_capital,omitempty"`
PaidInCapital string `json:"paid_in_capital,omitempty"`
ValidPeriod string `json:"valid_period,omitempty"`
RegisterDate string `json:"registered_date,omitempty"`
CertPosition map[string]position `json:"cert_position,omitempty"`
ImageSize imageSize `json:"img_size,omitempty"`
}
// ResCommon 公共印刷品返回结果
type ResCommon struct {
util.CommonError
Items []commonItem `json:"items,omitempty"`
ImageSize imageSize `json:"img_size,omitempty"`
}
// commonItem 公共元素
type commonItem struct {
Position position `json:"pos"`
Text string `json:"text"`
}
// ResPlateNumber 车牌号返回结果
type ResPlateNumber struct {
util.CommonError
Number string `json:"number"`
}
// NewOCR 实例
func NewOCR(c *context.Context) *OCR {
ocr := new(OCR)
ocr.Context = c
return ocr
}
// IDCard 身份证OCR识别接口
func (ocr *OCR) IDCard(path string) (ResIDCard ResIDCard, err error) {
accessToken, err := ocr.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?img_url=%s&access_token=%s", ocrIDCardURL, url.QueryEscape(path), accessToken)
response, err := util.HTTPPost(uri, "")
if err != nil {
return
}
err = util.DecodeWithError(response, &ResIDCard, "OCRIDCard")
return
}
// BankCard 银行卡OCR识别接口
func (ocr *OCR) BankCard(path string) (ResBankCard ResBankCard, err error) {
accessToken, err := ocr.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?img_url=%s&access_token=%s", ocrBankCardURL, url.QueryEscape(path), accessToken)
response, err := util.HTTPPost(uri, "")
if err != nil {
return
}
err = util.DecodeWithError(response, &ResBankCard, "OCRBankCard")
return
}
// Driving 行驶证OCR识别接口
func (ocr *OCR) Driving(path string) (ResDriving ResDriving, err error) {
accessToken, err := ocr.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?img_url=%s&access_token=%s", ocrDrivingURL, url.QueryEscape(path), accessToken)
response, err := util.HTTPPost(uri, "")
if err != nil {
return
}
err = util.DecodeWithError(response, &ResDriving, "OCRDriving")
return
}
// DrivingLicense 驾驶证OCR识别接口
func (ocr *OCR) DrivingLicense(path string) (ResDrivingLicense ResDrivingLicense, err error) {
accessToken, err := ocr.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?img_url=%s&access_token=%s", ocrDrivingLicenseURL, url.QueryEscape(path), accessToken)
response, err := util.HTTPPost(uri, "")
if err != nil {
return
}
err = util.DecodeWithError(response, &ResDrivingLicense, "OCRDrivingLicense")
return
}
// BizLicense 营业执照OCR识别接口
func (ocr *OCR) BizLicense(path string) (ResBizLicense ResBizLicense, err error) {
accessToken, err := ocr.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?img_url=%s&access_token=%s", ocrBizLicenseURL, url.QueryEscape(path), accessToken)
response, err := util.HTTPPost(uri, "")
if err != nil {
return
}
err = util.DecodeWithError(response, &ResBizLicense, "OCRBizLicense")
return
}
// Common 通用印刷体OCR识别接口
func (ocr *OCR) Common(path string) (ResCommon ResCommon, err error) {
accessToken, err := ocr.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?img_url=%s&access_token=%s", ocrCommonURL, url.QueryEscape(path), accessToken)
response, err := util.HTTPPost(uri, "")
if err != nil {
return
}
err = util.DecodeWithError(response, &ResCommon, "OCRCommon")
return
}
// PlateNumber 车牌OCR识别接口
func (ocr *OCR) PlateNumber(path string) (ResPlateNumber ResPlateNumber, err error) {
accessToken, err := ocr.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?img_url=%s&access_token=%s", ocrPlateNumberURL, url.QueryEscape(path), accessToken)
response, err := util.HTTPPost(uri, "")
if err != nil {
return
}
err = util.DecodeWithError(response, &ResPlateNumber, "OCRPlateNumber")
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/officialaccount.go
Generated Vendored
+139
View File
@@ -0,0 +1,139 @@
package officialaccount
import (
"net/http"
"github.com/silenceper/wechat/v2/officialaccount/draft"
"github.com/silenceper/wechat/v2/officialaccount/freepublish"
"github.com/silenceper/wechat/v2/officialaccount/ocr"
"github.com/silenceper/wechat/v2/officialaccount/datacube"
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/officialaccount/basic"
"github.com/silenceper/wechat/v2/officialaccount/broadcast"
"github.com/silenceper/wechat/v2/officialaccount/config"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/officialaccount/device"
"github.com/silenceper/wechat/v2/officialaccount/js"
"github.com/silenceper/wechat/v2/officialaccount/material"
"github.com/silenceper/wechat/v2/officialaccount/menu"
"github.com/silenceper/wechat/v2/officialaccount/message"
"github.com/silenceper/wechat/v2/officialaccount/oauth"
"github.com/silenceper/wechat/v2/officialaccount/server"
"github.com/silenceper/wechat/v2/officialaccount/user"
)
// OfficialAccount 微信公众号相关API
type OfficialAccount struct {
ctx *context.Context
}
// NewOfficialAccount 实例化公众号API
func NewOfficialAccount(cfg *config.Config) *OfficialAccount {
defaultAkHandle := credential.NewDefaultAccessToken(cfg.AppID, cfg.AppSecret, credential.CacheKeyOfficialAccountPrefix, cfg.Cache)
ctx := &context.Context{
Config: cfg,
AccessTokenHandle: defaultAkHandle,
}
return &OfficialAccount{ctx: ctx}
}
// SetAccessTokenHandle 自定义access_token获取方式
func (officialAccount *OfficialAccount) SetAccessTokenHandle(accessTokenHandle credential.AccessTokenHandle) {
officialAccount.ctx.AccessTokenHandle = accessTokenHandle
}
// GetContext get Context
func (officialAccount *OfficialAccount) GetContext() *context.Context {
return officialAccount.ctx
}
// GetBasic qr/url 相关配置
func (officialAccount *OfficialAccount) GetBasic() *basic.Basic {
return basic.NewBasic(officialAccount.ctx)
}
// GetMenu 菜单管理接口
func (officialAccount *OfficialAccount) GetMenu() *menu.Menu {
return menu.NewMenu(officialAccount.ctx)
}
// GetServer 消息管理：接收事件，被动回复消息管理
func (officialAccount *OfficialAccount) GetServer(req *http.Request, writer http.ResponseWriter) *server.Server {
srv := server.NewServer(officialAccount.ctx)
srv.Request = req
srv.Writer = writer
return srv
}
// GetAccessToken 获取access_token
func (officialAccount *OfficialAccount) GetAccessToken() (string, error) {
return officialAccount.ctx.GetAccessToken()
}
// GetOauth oauth2网页授权
func (officialAccount *OfficialAccount) GetOauth() *oauth.Oauth {
return oauth.NewOauth(officialAccount.ctx)
}
// GetMaterial 素材管理
func (officialAccount *OfficialAccount) GetMaterial() *material.Material {
return material.NewMaterial(officialAccount.ctx)
}
// GetDraft 草稿箱
func (officialAccount *OfficialAccount) GetDraft() *draft.Draft {
return draft.NewDraft(officialAccount.ctx)
}
// GetFreePublish 发布能力
func (officialAccount *OfficialAccount) GetFreePublish() *freepublish.FreePublish {
return freepublish.NewFreePublish(officialAccount.ctx)
}
// GetJs js-sdk配置
func (officialAccount *OfficialAccount) GetJs() *js.Js {
return js.NewJs(officialAccount.ctx)
}
// GetUser 用户管理接口
func (officialAccount *OfficialAccount) GetUser() *user.User {
return user.NewUser(officialAccount.ctx)
}
// GetTemplate 模板消息接口
func (officialAccount *OfficialAccount) GetTemplate() *message.Template {
return message.NewTemplate(officialAccount.ctx)
}
// GetCustomerMessageManager 客服消息接口
func (officialAccount *OfficialAccount) GetCustomerMessageManager() *message.Manager {
return message.NewMessageManager(officialAccount.ctx)
}
// GetDevice 获取智能设备的实例
func (officialAccount *OfficialAccount) GetDevice() *device.Device {
return device.NewDevice(officialAccount.ctx)
}
// GetBroadcast 群发消息
// TODO 待完善
func (officialAccount *OfficialAccount) GetBroadcast() *broadcast.Broadcast {
return broadcast.NewBroadcast(officialAccount.ctx)
}
// GetDataCube 数据统计
func (officialAccount *OfficialAccount) GetDataCube() *datacube.DataCube {
return datacube.NewCube(officialAccount.ctx)
}
// GetOCR OCR接口
func (officialAccount *OfficialAccount) GetOCR() *ocr.OCR {
return ocr.NewOCR(officialAccount.ctx)
}
// GetSubscribe 公众号订阅消息
func (officialAccount *OfficialAccount) GetSubscribe() *message.Subscribe {
return message.NewSubscribe(officialAccount.ctx)
}
vendor/github.com/silenceper/wechat/v2/officialaccount/server/server.go
Generated Vendored
+250
View File
@@ -0,0 +1,250 @@
package server
import (
"encoding/xml"
"errors"
"fmt"
"io/ioutil"
"net/http"
"reflect"
"runtime/debug"
"strconv"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/officialaccount/message"
log "github.com/sirupsen/logrus"
"github.com/silenceper/wechat/v2/util"
)
// Server struct
type Server struct {
*context.Context
Writer http.ResponseWriter
Request *http.Request
skipValidate bool
openID string
messageHandler func(*message.MixMessage) *message.Reply
RequestRawXMLMsg []byte
RequestMsg *message.MixMessage
ResponseRawXMLMsg []byte
ResponseMsg interface{}
isSafeMode bool
random []byte
nonce string
timestamp int64
}
// NewServer init
func NewServer(context *context.Context) *Server {
srv := new(Server)
srv.Context = context
return srv
}
// SkipValidate set skip validate
func (srv *Server) SkipValidate(skip bool) {
srv.skipValidate = skip
}
// Serve 处理微信的请求消息
func (srv *Server) Serve() error {
if !srv.Validate() {
log.Error("Validate Signature Failed.")
return fmt.Errorf("请求校验失败")
}
echostr, exists := srv.GetQuery("echostr")
if exists {
srv.String(echostr)
return nil
}
response, err := srv.handleRequest()
if err != nil {
return err
}
// debug print request msg
log.Debugf("request msg =%s", string(srv.RequestRawXMLMsg))
return srv.buildResponse(response)
}
// Validate 校验请求是否合法
func (srv *Server) Validate() bool {
if srv.skipValidate {
return true
}
timestamp := srv.Query("timestamp")
nonce := srv.Query("nonce")
signature := srv.Query("signature")
log.Debugf("validate signature, timestamp=%s, nonce=%s", timestamp, nonce)
return signature == util.Signature(srv.Token, timestamp, nonce)
}
// HandleRequest 处理微信的请求
func (srv *Server) handleRequest() (reply *message.Reply, err error) {
// set isSafeMode
srv.isSafeMode = false
encryptType := srv.Query("encrypt_type")
if encryptType == "aes" {
srv.isSafeMode = true
}
// set openID
srv.openID = srv.Query("openid")
var msg interface{}
msg, err = srv.getMessage()
if err != nil {
return
}
mixMessage, success := msg.(*message.MixMessage)
if !success {
err = errors.New("消息类型转换失败")
}
srv.RequestMsg = mixMessage
reply = srv.messageHandler(mixMessage)
return
}
// GetOpenID return openID
func (srv *Server) GetOpenID() string {
return srv.openID
}
// getMessage 解析微信返回的消息
func (srv *Server) getMessage() (interface{}, error) {
var rawXMLMsgBytes []byte
var err error
if srv.isSafeMode {
var encryptedXMLMsg message.EncryptedXMLMsg
if err := xml.NewDecoder(srv.Request.Body).Decode(&encryptedXMLMsg); err != nil {
return nil, fmt.Errorf("从body中解析xml失败,err=%v", err)
}
// 验证消息签名
timestamp := srv.Query("timestamp")
srv.timestamp, err = strconv.ParseInt(timestamp, 10, 32)
if err != nil {
return nil, err
}
nonce := srv.Query("nonce")
srv.nonce = nonce
msgSignature := srv.Query("msg_signature")
msgSignatureGen := util.Signature(srv.Token, timestamp, nonce, encryptedXMLMsg.EncryptedMsg)
if msgSignature != msgSignatureGen {
return nil, fmt.Errorf("消息不合法，验证签名失败")
}
// 解密
srv.random, rawXMLMsgBytes, err = util.DecryptMsg(srv.AppID, encryptedXMLMsg.EncryptedMsg, srv.EncodingAESKey)
if err != nil {
return nil, fmt.Errorf("消息解密失败, err=%v", err)
}
} else {
rawXMLMsgBytes, err = ioutil.ReadAll(srv.Request.Body)
if err != nil {
return nil, fmt.Errorf("从body中解析xml失败, err=%v", err)
}
}
srv.RequestRawXMLMsg = rawXMLMsgBytes
return srv.parseRequestMessage(rawXMLMsgBytes)
}
func (srv *Server) parseRequestMessage(rawXMLMsgBytes []byte) (msg *message.MixMessage, err error) {
msg = &message.MixMessage{}
err = xml.Unmarshal(rawXMLMsgBytes, msg)
return
}
// SetMessageHandler 设置用户自定义的回调方法
func (srv *Server) SetMessageHandler(handler func(*message.MixMessage) *message.Reply) {
srv.messageHandler = handler
}
func (srv *Server) buildResponse(reply *message.Reply) (err error) {
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("panic error: %v\n%s", e, debug.Stack())
}
}()
if reply == nil {
// do nothing
return nil
}
msgType := reply.MsgType
switch msgType {
case message.MsgTypeText:
case message.MsgTypeImage:
case message.MsgTypeVoice:
case message.MsgTypeVideo:
case message.MsgTypeMusic:
case message.MsgTypeNews:
case message.MsgTypeTransfer:
default:
err = message.ErrUnsupportReply
return
}
msgData := reply.MsgData
value := reflect.ValueOf(msgData)
// msgData must be a ptr
kind := value.Kind().String()
if kind != "ptr" {
return message.ErrUnsupportReply
}
params := make([]reflect.Value, 1)
params[0] = reflect.ValueOf(srv.RequestMsg.FromUserName)
value.MethodByName("SetToUserName").Call(params)
params[0] = reflect.ValueOf(srv.RequestMsg.ToUserName)
value.MethodByName("SetFromUserName").Call(params)
params[0] = reflect.ValueOf(msgType)
value.MethodByName("SetMsgType").Call(params)
params[0] = reflect.ValueOf(util.GetCurrTS())
value.MethodByName("SetCreateTime").Call(params)
srv.ResponseMsg = msgData
srv.ResponseRawXMLMsg, err = xml.Marshal(msgData)
return
}
// Send 将自定义的消息发送
func (srv *Server) Send() (err error) {
replyMsg := srv.ResponseMsg
log.Debugf("response msg =%+v", replyMsg)
if srv.isSafeMode {
// 安全模式下对消息进行加密
var encryptedMsg []byte
encryptedMsg, err = util.EncryptMsg(srv.random, srv.ResponseRawXMLMsg, srv.AppID, srv.EncodingAESKey)
if err != nil {
return
}
// TODO 如果获取不到timestamp nonce 则自己生成
timestamp := srv.timestamp
timestampStr := strconv.FormatInt(timestamp, 10)
msgSignature := util.Signature(srv.Token, timestampStr, srv.nonce, string(encryptedMsg))
replyMsg = message.ResponseEncryptedXMLMsg{
EncryptedMsg: string(encryptedMsg),
MsgSignature: msgSignature,
Timestamp: timestamp,
Nonce: srv.nonce,
}
}
if replyMsg != nil {
srv.XML(replyMsg)
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/server/util.go
Generated Vendored
+58
View File
@@ -0,0 +1,58 @@
package server
import (
"encoding/xml"
"net/http"
)
var xmlContentType = []string{"application/xml; charset=utf-8"}
var plainContentType = []string{"text/plain; charset=utf-8"}
func writeContextType(w http.ResponseWriter, value []string) {
header := w.Header()
if val := header["Content-Type"]; len(val) == 0 {
header["Content-Type"] = value
}
}
// Render render from bytes
func (srv *Server) Render(bytes []byte) {
// debug
// fmt.Println("response msg = ", string(bytes))
srv.Writer.WriteHeader(200)
_, err := srv.Writer.Write(bytes)
if err != nil {
panic(err)
}
}
// String render from string
func (srv *Server) String(str string) {
writeContextType(srv.Writer, plainContentType)
srv.Render([]byte(str))
}
// XML render to xml
func (srv *Server) XML(obj interface{}) {
writeContextType(srv.Writer, xmlContentType)
bytes, err := xml.Marshal(obj)
if err != nil {
panic(err)
}
srv.Render(bytes)
}
// Query returns the keyed url query value if it exists
func (srv *Server) Query(key string) string {
value, _ := srv.GetQuery(key)
return value
}
// GetQuery is like Query(), it returns the keyed url query value
func (srv *Server) GetQuery(key string) (string, bool) {
req := srv.Request
if values, ok := req.URL.Query()[key]; ok && len(values) > 0 {
return values[0], true
}
return "", false
}
vendor/github.com/silenceper/wechat/v2/officialaccount/user/migrate.go
Generated Vendored
+87
View File
@@ -0,0 +1,87 @@
// Package user migrate 用于微信公众号账号迁移，获取openID变化
// 参考文档：https://kf.qq.com/faq/1901177NrqMr190117nqYJze.html
package user
import (
"errors"
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
changeOpenIDURL = "https://api.weixin.qq.com/cgi-bin/changeopenid"
)
// ChangeOpenIDResult OpenID迁移变化
type ChangeOpenIDResult struct {
OriOpenID string `json:"ori_openid"`
NewOpenID string `json:"new_openid"`
ErrMsg string `json:"err_msg,omitempty"`
}
// ChangeOpenIDResultList OpenID迁移变化列表
type ChangeOpenIDResultList struct {
util.CommonError
List []ChangeOpenIDResult `json:"result_list"`
}
// 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)
if len(openIDs) > 100 {
err = errors.New("openIDs length must be lt 100")
return
}
if fromAppID == "" {
err = errors.New("fromAppID is required")
return
}
accessToken, err := user.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf("%s?access_token=%s", changeOpenIDURL, accessToken)
var resp []byte
var req struct {
FromAppID string `json:"from_appid"`
OpenidList []string `json:"openid_list"`
}
req.FromAppID = fromAppID
req.OpenidList = append(req.OpenidList, openIDs...)
resp, err = util.PostJSON(uri, req)
if err != nil {
return
}
err = util.DecodeWithError(resp, list, "ListChangeOpenIDs")
if err != nil {
return
}
return
}
// 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)
for _, chunk := range chunks {
result, err := user.ListChangeOpenIDs(fromAppID, chunk...)
if err != nil {
return list, err
}
list = append(list, result.List...)
}
return
}
vendor/github.com/silenceper/wechat/v2/officialaccount/user/tag.go
Generated Vendored
+241
View File
@@ -0,0 +1,241 @@
package user
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
tagCreateURL = "https://api.weixin.qq.com/cgi-bin/tags/create?access_token=%s"
tagGetURL = "https://api.weixin.qq.com/cgi-bin/tags/get?access_token=%s"
tagUpdateURL = "https://api.weixin.qq.com/cgi-bin/tags/update?access_token=%s"
tagDeleteURL = "https://api.weixin.qq.com/cgi-bin/tags/delete?access_token=%s"
tagUserListURL = "https://api.weixin.qq.com/cgi-bin/user/tag/get?access_token=%s"
tagBatchtaggingURL = "https://api.weixin.qq.com/cgi-bin/tags/members/batchtagging?access_token=%s"
tagBatchuntaggingURL = "https://api.weixin.qq.com/cgi-bin/tags/members/batchuntagging?access_token=%s"
tagUserTidListURL = "https://api.weixin.qq.com/cgi-bin/tags/getidlist?access_token=%s"
)
// TagInfo 标签信息
type TagInfo struct {
ID int32 `json:"id"`
Name string `json:"name"`
Count int64 `json:"count"`
}
// TagOpenIDList 标签用户列表
type TagOpenIDList struct {
Count int `json:"count"`
Data struct {
OpenIDs []string `json:"openid"`
} `json:"data"`
NextOpenID string `json:"next_openid"`
}
// CreateTag 创建标签
func (user *User) CreateTag(tagName string) (tagInfo *TagInfo, err error) {
var accessToken string
accessToken, err = user.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(tagCreateURL, accessToken)
var response []byte
var request struct {
Tag struct {
Name string `json:"name"`
} `json:"tag"`
}
request.Tag.Name = tagName
response, err = util.PostJSON(uri, &request)
if err != nil {
return
}
var result struct {
util.CommonError
Tag *TagInfo `json:"tag"`
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("CreateTag Error , errcode=%d , errmsg=%s", result.ErrCode, result.ErrMsg)
return
}
return result.Tag, nil
}
// DeleteTag 删除标签
func (user *User) DeleteTag(tagID int32) (err error) {
accessToken, err := user.GetAccessToken()
if err != nil {
return
}
url := fmt.Sprintf(tagDeleteURL, accessToken)
var request struct {
Tag struct {
ID int32 `json:"id"`
} `json:"tag"`
}
request.Tag.ID = tagID
resp, err := util.PostJSON(url, &request)
if err != nil {
return
}
return util.DecodeWithCommonError(resp, "DeleteTag")
}
// UpdateTag 编辑标签
func (user *User) UpdateTag(tagID int32, tagName string) (err error) {
accessToken, err := user.GetAccessToken()
if err != nil {
return
}
url := fmt.Sprintf(tagUpdateURL, accessToken)
var request struct {
Tag struct {
ID int32 `json:"id"`
Name string `json:"name"`
} `json:"tag"`
}
request.Tag.ID = tagID
request.Tag.Name = tagName
resp, err := util.PostJSON(url, &request)
if err != nil {
return
}
return util.DecodeWithCommonError(resp, "UpdateTag")
}
// GetTag 获取公众号已创建的标签
func (user *User) GetTag() (tags []*TagInfo, err error) {
accessToken, err := user.GetAccessToken()
if err != nil {
return nil, err
}
url := fmt.Sprintf(tagGetURL, accessToken)
response, err := util.HTTPGet(url)
if err != nil {
return
}
var result struct {
util.CommonError
Tags []*TagInfo `json:"tags"`
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
return result.Tags, nil
}
// OpenIDListByTag 获取标签下粉丝列表
func (user *User) OpenIDListByTag(tagID int32, nextOpenID ...string) (userList *TagOpenIDList, err error) {
accessToken, err := user.GetAccessToken()
if err != nil {
return nil, err
}
url := fmt.Sprintf(tagUserListURL, accessToken)
var request = struct {
ID int32 `json:"tagid"`
OpenID string `json:"next_openid"`
}{
ID: tagID,
}
if len(nextOpenID) > 0 {
request.OpenID = nextOpenID[0]
}
response, err := util.PostJSON(url, &request)
if err != nil {
return nil, err
}
userList = new(TagOpenIDList)
err = json.Unmarshal(response, &userList)
if err != nil {
return
}
return
}
// BatchTag 批量为用户打标签
func (user *User) BatchTag(openIDList []string, tagID int32) (err error) {
accessToken, err := user.GetAccessToken()
if err != nil {
return
}
if len(openIDList) == 0 {
return
}
var request = struct {
OpenIDList []string `json:"openid_list"`
TagID int32 `json:"tagid"`
}{
OpenIDList: openIDList,
TagID: tagID,
}
url := fmt.Sprintf(tagBatchtaggingURL, accessToken)
resp, err := util.PostJSON(url, &request)
if err != nil {
return
}
return util.DecodeWithCommonError(resp, "BatchTag")
}
// BatchUntag 批量为用户取消标签
func (user *User) BatchUntag(openIDList []string, tagID int32) (err error) {
if len(openIDList) == 0 {
return
}
accessToken, err := user.GetAccessToken()
if err != nil {
return
}
url := fmt.Sprintf(tagBatchuntaggingURL, accessToken)
var request = struct {
OpenIDList []string `json:"openid_list"`
TagID int32 `json:"tagid"`
}{
OpenIDList: openIDList,
TagID: tagID,
}
resp, err := util.PostJSON(url, &request)
if err != nil {
return
}
return util.DecodeWithCommonError(resp, "BatchUntag")
}
// UserTidList 获取用户身上的标签列表
func (user *User) UserTidList(openID string) (tagIDList []int32, err error) {
accessToken, err := user.GetAccessToken()
if err != nil {
return
}
url := fmt.Sprintf(tagUserTidListURL, accessToken)
var request = struct {
OpenID string `json:"openid"`
TagID int32 `json:"tagid"`
}{
OpenID: openID,
}
resp, err := util.PostJSON(url, &request)
if err != nil {
return
}
var result struct {
util.CommonError
TagIDList []int32 `json:"tagid_list"`
}
err = json.Unmarshal(resp, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("UserTidList Error , errcode=%d , errmsg=%s", result.ErrCode, result.ErrMsg)
return
}
return result.TagIDList, nil
}
vendor/github.com/silenceper/wechat/v2/officialaccount/user/user.go
Generated Vendored
+157
View File
@@ -0,0 +1,157 @@
package user
import (
"encoding/json"
"fmt"
"net/url"
"github.com/silenceper/wechat/v2/officialaccount/context"
"github.com/silenceper/wechat/v2/util"
)
const (
userInfoURL = "https://api.weixin.qq.com/cgi-bin/user/info?access_token=%s&openid=%s&lang=zh_CN"
updateRemarkURL = "https://api.weixin.qq.com/cgi-bin/user/info/updateremark?access_token=%s"
userListURL = "https://api.weixin.qq.com/cgi-bin/user/get"
)
// User 用户管理
type User struct {
*context.Context
}
// NewUser 实例化
func NewUser(context *context.Context) *User {
user := new(User)
user.Context = context
return user
}
// Info 用户基本信息
type Info struct {
util.CommonError
Subscribe int32 `json:"subscribe"`
OpenID string `json:"openid"`
Nickname string `json:"nickname"`
Sex int32 `json:"sex"`
City string `json:"city"`
Country string `json:"country"`
Province string `json:"province"`
Language string `json:"language"`
Headimgurl string `json:"headimgurl"`
SubscribeTime int32 `json:"subscribe_time"`
UnionID string `json:"unionid"`
Remark string `json:"remark"`
GroupID int32 `json:"groupid"`
TagIDList []int32 `json:"tagid_list"`
SubscribeScene string `json:"subscribe_scene"`
QrScene int `json:"qr_scene"`
QrSceneStr string `json:"qr_scene_str"`
}
// OpenidList 用户列表
type OpenidList struct {
util.CommonError
Total int `json:"total"`
Count int `json:"count"`
Data struct {
OpenIDs []string `json:"openid"`
} `json:"data"`
NextOpenID string `json:"next_openid"`
}
// GetUserInfo 获取用户基本信息
func (user *User) GetUserInfo(openID string) (userInfo *Info, err error) {
var accessToken string
accessToken, err = user.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(userInfoURL, accessToken, openID)
var response []byte
response, err = util.HTTPGet(uri)
if err != nil {
return
}
userInfo = new(Info)
err = json.Unmarshal(response, userInfo)
if err != nil {
return
}
if userInfo.ErrCode != 0 {
err = fmt.Errorf("GetUserInfo Error , errcode=%d , errmsg=%s", userInfo.ErrCode, userInfo.ErrMsg)
return
}
return
}
// UpdateRemark 设置用户备注名
func (user *User) UpdateRemark(openID, remark string) (err error) {
var accessToken string
accessToken, err = user.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(updateRemarkURL, accessToken)
var response []byte
response, err = util.PostJSON(uri, map[string]string{"openid": openID, "remark": remark})
if err != nil {
return
}
return util.DecodeWithCommonError(response, "UpdateRemark")
}
// ListUserOpenIDs 返回用户列表
func (user *User) ListUserOpenIDs(nextOpenid ...string) (*OpenidList, error) {
accessToken, err := user.GetAccessToken()
if err != nil {
return nil, err
}
uri, _ := url.Parse(userListURL)
q := uri.Query()
q.Set("access_token", accessToken)
if len(nextOpenid) > 0 && nextOpenid[0] != "" {
q.Set("next_openid", nextOpenid[0])
}
uri.RawQuery = q.Encode()
response, err := util.HTTPGet(uri.String())
if err != nil {
return nil, err
}
userlist := OpenidList{}
err = util.DecodeWithError(response, &userlist, "ListUserOpenIDs")
if err != nil {
return nil, err
}
return &userlist, nil
}
// ListAllUserOpenIDs 返回所有用户OpenID列表
func (user *User) ListAllUserOpenIDs() ([]string, error) {
nextOpenid := ""
openids := make([]string, 0)
count := 0
for {
ul, err := user.ListUserOpenIDs(nextOpenid)
if err != nil {
return nil, err
}
openids = append(openids, ul.Data.OpenIDs...)
count += ul.Count
if ul.Total > count {
nextOpenid = ul.NextOpenID
} else {
return openids, nil
}
}
}
vendor/github.com/silenceper/wechat/v2/openplatform/README.md
Generated Vendored
+63
View File
@@ -0,0 +1,63 @@
# 微信开放平台
[官方文档](https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/Third_party_platform_appid.html)
## 快速入门
### 服务端处理
```go
wc := wechat.NewWechat()
memory := cache.NewMemory()
cfg := &openplatform.Config{
AppID: "xxx",
AppSecret: "xxx",
Token: "xxx",
EncodingAESKey: "xxx",
Cache: memory,
}
openPlatform := wc.GetOpenPlatform(cfg)
// 传入request和responseWriter
server := openPlatform.GetServer(req, rw)
//设置接收消息的处理方法
server.SetMessageHandler(func(msg *message.MixMessage) *message.Reply {
if msg.InfoType == message.InfoTypeVerifyTicket {
componentVerifyTicket, err := openPlatform.SetComponentAccessToken(msg.ComponentVerifyTicket)
if err != nil {
log.Println(err)
return nil
}
//debug
fmt.Println(componentVerifyTicket)
rw.Write([]byte("success"))
return nil
}
//handle other message
//
return nil
})
//处理消息接收以及回复
err := server.Serve()
if err != nil {
fmt.Println(err)
return
}
//发送回复的消息
server.Send()
```
### 待授权处理消息
```go
//授权的第三方公众号的appID
appID := "xxx"
openPlatform := wc.GetOpenPlatform(cfg)
openPlatform.GetOfficialAccount(appID)
```
vendor/github.com/silenceper/wechat/v2/openplatform/account/account.go
Generated Vendored
+34
View File
@@ -0,0 +1,34 @@
package account
import "github.com/silenceper/wechat/v2/openplatform/context"
// Account 开放平台张哈管理
// TODO 实现方法
type Account struct {
*context.Context
}
// NewAccount new
func NewAccount(ctx *context.Context) *Account {
return &Account{ctx}
}
// Create 创建开放平台帐号并绑定公众号/小程序
func (account *Account) Create(appID string) (string, error) {
return "", nil
}
// Bind 将公众号/小程序绑定到开放平台帐号下
func (account *Account) Bind(appID string) error {
return nil
}
// Unbind 将公众号/小程序从开放平台帐号下解绑
func (account *Account) Unbind(appID string, openAppID string) error {
return nil
}
// Get 获取公众号/小程序所绑定的开放平台帐号
func (account *Account) Get(appID string) (string, error) {
return "", nil
}
vendor/github.com/silenceper/wechat/v2/openplatform/config/config.go
Generated Vendored
+14
View File
@@ -0,0 +1,14 @@
package config
import (
"github.com/silenceper/wechat/v2/cache"
)
// Config .config for 微信开放平台
type Config struct {
AppID string `json:"app_id"` // appid
AppSecret string `json:"app_secret"` // appsecret
Token string `json:"token"` // token
EncodingAESKey string `json:"encoding_aes_key"` // EncodingAESKey
Cache cache.Cache
}
vendor/github.com/silenceper/wechat/v2/openplatform/context/accessToken.go
Generated Vendored
+258
View File
@@ -0,0 +1,258 @@
// Package context 开放平台相关context
package context
import (
"encoding/json"
"fmt"
"net/url"
"time"
"github.com/silenceper/wechat/v2/util"
)
const (
componentAccessTokenURL = "https://api.weixin.qq.com/cgi-bin/component/api_component_token"
getPreCodeURL = "https://api.weixin.qq.com/cgi-bin/component/api_create_preauthcode?component_access_token=%s"
queryAuthURL = "https://api.weixin.qq.com/cgi-bin/component/api_query_auth?component_access_token=%s"
refreshTokenURL = "https://api.weixin.qq.com/cgi-bin/component/api_authorizer_token?component_access_token=%s"
getComponentInfoURL = "https://api.weixin.qq.com/cgi-bin/component/api_get_authorizer_info?component_access_token=%s"
componentLoginURL = "https://mp.weixin.qq.com/cgi-bin/componentloginpage?component_appid=%s&pre_auth_code=%s&redirect_uri=%s&auth_type=%d&biz_appid=%s"
bindComponentURL = "https://mp.weixin.qq.com/safe/bindcomponent?action=bindcomponent&auth_type=%d&no_scan=1&component_appid=%s&pre_auth_code=%s&redirect_uri=%s&biz_appid=%s#wechat_redirect"
// TODO 获取授权方选项信息
// getComponentConfigURL = "https://api.weixin.qq.com/cgi-bin/component/api_get_authorizer_option?component_access_token=%s"
// TODO 获取已授权的账号信息
// getuthorizerListURL = "POST https://api.weixin.qq.com/cgi-bin/component/api_get_authorizer_list?component_access_token=%s"
)
// ComponentAccessToken 第三方平台
type ComponentAccessToken struct {
util.CommonError
AccessToken string `json:"component_access_token"`
ExpiresIn int64 `json:"expires_in"`
}
// GetComponentAccessToken 获取 ComponentAccessToken
func (ctx *Context) GetComponentAccessToken() (string, error) {
accessTokenCacheKey := fmt.Sprintf("component_access_token_%s", ctx.AppID)
val := ctx.Cache.Get(accessTokenCacheKey)
if val == nil {
return "", fmt.Errorf("cann't get component access token")
}
return val.(string), nil
}
// SetComponentAccessToken 通过component_verify_ticket 获取 ComponentAccessToken
func (ctx *Context) SetComponentAccessToken(verifyTicket string) (*ComponentAccessToken, error) {
body := map[string]string{
"component_appid": ctx.AppID,
"component_appsecret": ctx.AppSecret,
"component_verify_ticket": verifyTicket,
}
respBody, err := util.PostJSON(componentAccessTokenURL, body)
if err != nil {
return nil, err
}
at := &ComponentAccessToken{}
if err := json.Unmarshal(respBody, at); err != nil {
return nil, err
}
if at.ErrCode != 0 {
return nil, fmt.Errorf("SetComponentAccessToken Error , errcode=%d , errmsg=%s", at.ErrCode, at.ErrMsg)
}
accessTokenCacheKey := fmt.Sprintf("component_access_token_%s", ctx.AppID)
expires := at.ExpiresIn - 1500
if err := ctx.Cache.Set(accessTokenCacheKey, at.AccessToken, time.Duration(expires)*time.Second); err != nil {
return nil, nil
}
return at, nil
}
// GetPreCode 获取预授权码
func (ctx *Context) GetPreCode() (string, error) {
cat, err := ctx.GetComponentAccessToken()
if err != nil {
return "", err
}
req := map[string]string{
"component_appid": ctx.AppID,
}
uri := fmt.Sprintf(getPreCodeURL, cat)
body, err := util.PostJSON(uri, req)
if err != nil {
return "", err
}
var ret struct {
PreCode string `json:"pre_auth_code"`
}
if err := json.Unmarshal(body, &ret); err != nil {
return "", err
}
return ret.PreCode, nil
}
// GetComponentLoginPage 获取第三方公众号授权链接(扫码授权)
func (ctx *Context) GetComponentLoginPage(redirectURI string, authType int, bizAppID string) (string, error) {
code, err := ctx.GetPreCode()
if err != nil {
return "", err
}
return fmt.Sprintf(componentLoginURL, ctx.AppID, code, url.QueryEscape(redirectURI), authType, bizAppID), nil
}
// GetBindComponentURL 获取第三方公众号授权链接(链接跳转，适用移动端)
func (ctx *Context) GetBindComponentURL(redirectURI string, authType int, bizAppID string) (string, error) {
code, err := ctx.GetPreCode()
if err != nil {
return "", err
}
return fmt.Sprintf(bindComponentURL, authType, ctx.AppID, code, url.QueryEscape(redirectURI), bizAppID), nil
}
// ID 微信返回接口中各种类型字段
type ID struct {
ID int `json:"id"`
}
// AuthBaseInfo 授权的基本信息
type AuthBaseInfo struct {
AuthrAccessToken
FuncInfo []AuthFuncInfo `json:"func_info"`
}
// AuthFuncInfo 授权的接口内容
type AuthFuncInfo struct {
FuncscopeCategory ID `json:"funcscope_category"`
}
// AuthrAccessToken 授权方AccessToken
type AuthrAccessToken struct {
Appid string `json:"authorizer_appid"`
AccessToken string `json:"authorizer_access_token"`
ExpiresIn int64 `json:"expires_in"`
RefreshToken string `json:"authorizer_refresh_token"`
}
// QueryAuthCode 使用授权码换取公众号或小程序的接口调用凭据和授权信息
func (ctx *Context) QueryAuthCode(authCode string) (*AuthBaseInfo, error) {
cat, err := ctx.GetComponentAccessToken()
if err != nil {
return nil, err
}
req := map[string]string{
"component_appid": ctx.AppID,
"authorization_code": authCode,
}
uri := fmt.Sprintf(queryAuthURL, cat)
body, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
var ret struct {
util.CommonError
Info *AuthBaseInfo `json:"authorization_info"`
}
if err := json.Unmarshal(body, &ret); err != nil {
return nil, err
}
if ret.ErrCode != 0 {
err = fmt.Errorf("QueryAuthCode error : errcode=%v , errmsg=%v", ret.ErrCode, ret.ErrMsg)
return nil, err
}
return ret.Info, nil
}
// RefreshAuthrToken 获取（刷新）授权公众号或小程序的接口调用凭据（令牌）
func (ctx *Context) RefreshAuthrToken(appid, refreshToken string) (*AuthrAccessToken, error) {
cat, err := ctx.GetComponentAccessToken()
if err != nil {
return nil, err
}
req := map[string]string{
"component_appid": ctx.AppID,
"authorizer_appid": appid,
"authorizer_refresh_token": refreshToken,
}
uri := fmt.Sprintf(refreshTokenURL, cat)
body, err := util.PostJSON(uri, req)
if err != nil {
return nil, err
}
ret := &AuthrAccessToken{}
if err := json.Unmarshal(body, ret); err != nil {
return nil, err
}
authrTokenKey := "authorizer_access_token_" + appid
if err := ctx.Cache.Set(authrTokenKey, ret.AccessToken, time.Minute*80); err != nil {
return nil, err
}
return ret, nil
}
// GetAuthrAccessToken 获取授权方AccessToken
func (ctx *Context) GetAuthrAccessToken(appid string) (string, error) {
authrTokenKey := "authorizer_access_token_" + appid
val := ctx.Cache.Get(authrTokenKey)
if val == nil {
return "", fmt.Errorf("cannot get authorizer %s access token", appid)
}
return val.(string), nil
}
// AuthorizerInfo 授权方详细信息
type AuthorizerInfo struct {
NickName string `json:"nick_name"`
HeadImg string `json:"head_img"`
ServiceTypeInfo ID `json:"service_type_info"`
VerifyTypeInfo ID `json:"verify_type_info"`
UserName string `json:"user_name"`
PrincipalName string `json:"principal_name"`
BusinessInfo struct {
OpenStore string `json:"open_store"`
OpenScan string `json:"open_scan"`
OpenPay string `json:"open_pay"`
OpenCard string `json:"open_card"`
OpenShake string `json:"open_shake"`
}
Alias string `json:"alias"`
QrcodeURL string `json:"qrcode_url"`
}
// GetAuthrInfo 获取授权方的帐号基本信息
func (ctx *Context) GetAuthrInfo(appid string) (*AuthorizerInfo, *AuthBaseInfo, error) {
cat, err := ctx.GetComponentAccessToken()
if err != nil {
return nil, nil, err
}
req := map[string]string{
"component_appid": ctx.AppID,
"authorizer_appid": appid,
}
uri := fmt.Sprintf(getComponentInfoURL, cat)
body, err := util.PostJSON(uri, req)
if err != nil {
return nil, nil, err
}
var ret struct {
AuthorizerInfo *AuthorizerInfo `json:"authorizer_info"`
AuthorizationInfo *AuthBaseInfo `json:"authorization_info"`
}
if err := json.Unmarshal(body, &ret); err != nil {
return nil, nil, err
}
return ret.AuthorizerInfo, ret.AuthorizationInfo, nil
}
vendor/github.com/silenceper/wechat/v2/openplatform/context/context.go
Generated Vendored
+10
View File
@@ -0,0 +1,10 @@
package context
import (
"github.com/silenceper/wechat/v2/openplatform/config"
)
// Context struct
type Context struct {
*config.Config
}
vendor/github.com/silenceper/wechat/v2/openplatform/miniprogram/basic/basic.go
Generated Vendored
+52
View File
@@ -0,0 +1,52 @@
package basic
import (
"fmt"
openContext "github.com/silenceper/wechat/v2/openplatform/context"
"github.com/silenceper/wechat/v2/util"
)
const (
getAccountBasicInfoURL = "https://api.weixin.qq.com/cgi-bin/account/getaccountbasicinfo"
)
// Basic 基础信息设置
type Basic struct {
*openContext.Context
appID string
}
// NewBasic new
func NewBasic(opContext *openContext.Context, appID string) *Basic {
return &Basic{Context: opContext, appID: appID}
}
// AccountBasicInfo 基础信息
type AccountBasicInfo struct {
util.CommonError
}
// GetAccountBasicInfo 获取小程序基础信息
//reference:https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/Mini_Programs/Mini_Program_Information_Settings.html
func (basic *Basic) GetAccountBasicInfo() (*AccountBasicInfo, error) {
ak, err := basic.GetAuthrAccessToken(basic.AppID)
if err != nil {
return nil, err
}
url := fmt.Sprintf("%s?access_token=%s", getAccountBasicInfoURL, ak)
data, err := util.HTTPGet(url)
if err != nil {
return nil, err
}
result := &AccountBasicInfo{}
if err := util.DecodeWithError(data, result, "account/getaccountbasicinfo"); err != nil {
return nil, err
}
return result, nil
}
// modify_domain设置服务器域名
// TODO
// func (encryptor *Basic) modifyDomain() {
// }
vendor/github.com/silenceper/wechat/v2/openplatform/miniprogram/component/component.go
Generated Vendored
+69
View File
@@ -0,0 +1,69 @@
package component
import (
"fmt"
openContext "github.com/silenceper/wechat/v2/openplatform/context"
"github.com/silenceper/wechat/v2/util"
)
const (
fastregisterweappURL = "https://api.weixin.qq.com/cgi-bin/component/fastregisterweapp"
)
// Component 快速创建小程序
type Component struct {
*openContext.Context
}
// NewComponent new
func NewComponent(opContext *openContext.Context) *Component {
return &Component{opContext}
}
// RegisterMiniProgramParam 快速注册小程序参数
type RegisterMiniProgramParam struct {
Name string `json:"name"` // 企业名
Code string `json:"code"` // 企业代码
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"` // 第三方联系电话（方便法人与第三方联系）
}
// RegisterMiniProgram 快速创建小程
// reference: https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/Mini_Programs/Fast_Registration_Interface_document.html
func (component *Component) RegisterMiniProgram(param *RegisterMiniProgramParam) error {
componentAK, err := component.GetComponentAccessToken()
if err != nil {
return nil
}
url := fmt.Sprintf(fastregisterweappURL+"?action=create&component_access_token=%s", componentAK)
data, err := util.PostJSON(url, param)
if err != nil {
return err
}
return util.DecodeWithCommonError(data, "component/fastregisterweapp?action=create")
}
// GetRegistrationStatusParam 查询任务创建状态
type GetRegistrationStatusParam struct {
Name string `json:"name"` // 企业名
LegalPersonaWechat string `json:"legal_persona_wechat"` // 法人微信号
LegalPersonaName string `json:"legal_persona_name"` // 法人姓名（绑定银行卡）
}
// GetRegistrationStatus 查询创建任务状态.
func (component *Component) GetRegistrationStatus(param *GetRegistrationStatusParam) error {
componentAK, err := component.GetComponentAccessToken()
if err != nil {
return nil
}
url := fmt.Sprintf(fastregisterweappURL+"?action=search&component_access_token=%s", componentAK)
data, err := util.PostJSON(url, param)
if err != nil {
return err
}
return util.DecodeWithCommonError(data, "component/fastregisterweapp?action=search")
}
vendor/github.com/silenceper/wechat/v2/openplatform/miniprogram/miniprogram.go
Generated Vendored
+32
View File
@@ -0,0 +1,32 @@
package miniprogram
import (
openContext "github.com/silenceper/wechat/v2/openplatform/context"
"github.com/silenceper/wechat/v2/openplatform/miniprogram/basic"
"github.com/silenceper/wechat/v2/openplatform/miniprogram/component"
)
// MiniProgram 代小程序实现业务
type MiniProgram struct {
AppID string
openContext *openContext.Context
}
// NewMiniProgram 实例化
func NewMiniProgram(opCtx *openContext.Context, appID string) *MiniProgram {
return &MiniProgram{
openContext: opCtx,
AppID: appID,
}
}
// GetComponent get component
// 快速注册小程序相关
func (miniProgram *MiniProgram) GetComponent() *component.Component {
return component.NewComponent(miniProgram.openContext)
}
// GetBasic 基础信息设置
func (miniProgram *MiniProgram) GetBasic() *basic.Basic {
return basic.NewBasic(miniProgram.openContext, miniProgram.AppID)
}
vendor/github.com/silenceper/wechat/v2/openplatform/officialaccount/js/js.go
Generated Vendored
+57
View File
@@ -0,0 +1,57 @@
package js
import (
"fmt"
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/officialaccount/context"
officialJs "github.com/silenceper/wechat/v2/officialaccount/js"
"github.com/silenceper/wechat/v2/util"
)
// Js wx jssdk
type Js struct {
*context.Context
credential.JsTicketHandle
}
// NewJs init
func NewJs(context *context.Context, appID string) *Js {
js := new(Js)
js.Context = context
jsTicketHandle := credential.NewDefaultJsTicket(appID, credential.CacheKeyOfficialAccountPrefix, context.Cache)
js.SetJsTicketHandle(jsTicketHandle)
return js
}
// SetJsTicketHandle 自定义js ticket取值方式
func (js *Js) SetJsTicketHandle(ticketHandle credential.JsTicketHandle) {
js.JsTicketHandle = ticketHandle
}
// GetConfig 第三方平台 - 获取jssdk需要的配置参数
// uri 为当前网页地址
func (js *Js) GetConfig(uri, appid string) (config *officialJs.Config, err error) {
config = new(officialJs.Config)
var accessToken string
accessToken, err = js.GetAccessToken()
if err != nil {
return
}
var ticketStr string
ticketStr, err = js.GetTicket(accessToken)
if err != nil {
return
}
nonceStr := util.RandomStr(16)
timestamp := util.GetCurrTS()
str := fmt.Sprintf("jsapi_ticket=%s&noncestr=%s&timestamp=%d&url=%s", ticketStr, nonceStr, timestamp, uri)
sigStr := util.Signature(str)
config.AppID = appid
config.NonceStr = nonceStr
config.Timestamp = timestamp
config.Signature = sigStr
return
}
vendor/github.com/silenceper/wechat/v2/openplatform/officialaccount/oauth/oauth.go
Generated Vendored
+65
View File
@@ -0,0 +1,65 @@
package oauth
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"github.com/silenceper/wechat/v2/officialaccount/context"
officialOauth "github.com/silenceper/wechat/v2/officialaccount/oauth"
"github.com/silenceper/wechat/v2/util"
)
const (
platformRedirectOauthURL = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=%s&redirect_uri=%s&response_type=code&scope=%s&state=%s&component_appid=%s#wechat_redirect"
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网页授权
type Oauth struct {
*context.Context
}
// NewOauth 实例化平台代发起oauth2网页授权
func NewOauth(context *context.Context) *Oauth {
auth := new(Oauth)
auth.Context = context
return auth
}
// GetRedirectURL 第三方平台 - 获取跳转的url地址
func (oauth *Oauth) GetRedirectURL(redirectURI, scope, state, appID string) (string, error) {
// url encode
urlStr := url.QueryEscape(redirectURI)
return fmt.Sprintf(platformRedirectOauthURL, appID, urlStr, scope, state, oauth.AppID), nil
}
// Redirect 第三方平台 - 跳转到网页授权
func (oauth *Oauth) Redirect(writer http.ResponseWriter, req *http.Request, redirectURI, scope, state, appID string) error {
location, err := oauth.GetRedirectURL(redirectURI, scope, state, appID)
if err != nil {
return err
}
http.Redirect(writer, req, location, http.StatusFound)
return nil
}
// 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
response, err = util.HTTPGet(urlStr)
if err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
return
}
if result.ErrCode != 0 {
err = fmt.Errorf("GetUserAccessToken error : errcode=%v , errmsg=%v", result.ErrCode, result.ErrMsg)
return
}
return
}
vendor/github.com/silenceper/wechat/v2/openplatform/officialaccount/officialaccount.go
Generated Vendored
+60
View File
@@ -0,0 +1,60 @@
package officialaccount
import (
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/officialaccount"
offConfig "github.com/silenceper/wechat/v2/officialaccount/config"
opContext "github.com/silenceper/wechat/v2/openplatform/context"
"github.com/silenceper/wechat/v2/openplatform/officialaccount/js"
"github.com/silenceper/wechat/v2/openplatform/officialaccount/oauth"
)
// OfficialAccount 代公众号实现业务
type OfficialAccount struct {
// 授权的公众号的appID
appID string
*officialaccount.OfficialAccount
}
// NewOfficialAccount 实例化
// appID :为授权方公众号 APPID，非开放平台第三方平台 APPID
func NewOfficialAccount(opCtx *opContext.Context, appID string) *OfficialAccount {
officialAccount := officialaccount.NewOfficialAccount(&offConfig.Config{
AppID: opCtx.AppID,
EncodingAESKey: opCtx.EncodingAESKey,
Token: opCtx.Token,
Cache: opCtx.Cache,
})
// 设置获取access_token的函数
officialAccount.SetAccessTokenHandle(NewDefaultAuthrAccessToken(opCtx, appID))
return &OfficialAccount{appID: appID, OfficialAccount: officialAccount}
}
// PlatformOauth 平台代发起oauth2网页授权
func (officialAccount *OfficialAccount) PlatformOauth() *oauth.Oauth {
return oauth.NewOauth(officialAccount.GetContext())
}
// PlatformJs 平台代获取js-sdk配置
func (officialAccount *OfficialAccount) PlatformJs() *js.Js {
return js.NewJs(officialAccount.GetContext(), officialAccount.appID)
}
// DefaultAuthrAccessToken 默认获取授权ak的方法
type DefaultAuthrAccessToken struct {
opCtx *opContext.Context
appID string
}
// NewDefaultAuthrAccessToken New
func NewDefaultAuthrAccessToken(opCtx *opContext.Context, appID string) credential.AccessTokenHandle {
return &DefaultAuthrAccessToken{
opCtx: opCtx,
appID: appID,
}
}
// GetAccessToken 获取ak
func (ak *DefaultAuthrAccessToken) GetAccessToken() (string, error) {
return ak.opCtx.GetAuthrAccessToken(ak.appID)
}
vendor/github.com/silenceper/wechat/v2/openplatform/openplatform.go
Generated Vendored
+50
View File
@@ -0,0 +1,50 @@
package openplatform
import (
"net/http"
"github.com/silenceper/wechat/v2/officialaccount/server"
"github.com/silenceper/wechat/v2/openplatform/account"
"github.com/silenceper/wechat/v2/openplatform/config"
"github.com/silenceper/wechat/v2/openplatform/context"
"github.com/silenceper/wechat/v2/openplatform/miniprogram"
"github.com/silenceper/wechat/v2/openplatform/officialaccount"
)
// OpenPlatform 微信开放平台相关api
type OpenPlatform struct {
*context.Context
}
// NewOpenPlatform new openplatform
func NewOpenPlatform(cfg *config.Config) *OpenPlatform {
if cfg.Cache == nil {
panic("cache 未设置")
}
ctx := &context.Context{
Config: cfg,
}
return &OpenPlatform{ctx}
}
// GetServer get server
func (openPlatform *OpenPlatform) GetServer(req *http.Request, writer http.ResponseWriter) *server.Server {
off := officialaccount.NewOfficialAccount(openPlatform.Context, "")
return off.GetServer(req, writer)
}
// GetOfficialAccount 公众号代处理
func (openPlatform *OpenPlatform) GetOfficialAccount(appID string) *officialaccount.OfficialAccount {
return officialaccount.NewOfficialAccount(openPlatform.Context, appID)
}
// GetMiniProgram 小程序代理
func (openPlatform *OpenPlatform) GetMiniProgram(appID string) *miniprogram.MiniProgram {
return miniprogram.NewMiniProgram(openPlatform.Context, appID)
}
// GetAccountManager 账号管理
// TODO
func (openPlatform *OpenPlatform) GetAccountManager() *account.Account {
return account.NewAccount(openPlatform.Context)
}
vendor/github.com/silenceper/wechat/v2/pay/README.md
Generated Vendored
+5
View File
@@ -0,0 +1,5 @@
# 微信支付
[官方文档](https://pay.weixin.qq.com/wiki/doc/api/index.html)
## 快速入门
vendor/github.com/silenceper/wechat/v2/pay/config/config.go
Generated Vendored
+9
View File
@@ -0,0 +1,9 @@
package config
// Config .config for pay
type Config struct {
AppID string `json:"app_id"`
MchID string `json:"mch_id"`
Key string `json:"key"`
NotifyURL string `json:"notify_url"`
}
vendor/github.com/silenceper/wechat/v2/pay/notify/notify.go
Generated Vendored
+15
View File
@@ -0,0 +1,15 @@
package notify
import (
"github.com/silenceper/wechat/v2/pay/config"
)
// Notify 回调
type Notify struct {
*config.Config
}
// NewNotify new
func NewNotify(cfg *config.Config) *Notify {
return &Notify{cfg}
}
vendor/github.com/silenceper/wechat/v2/pay/notify/paid.go
Generated Vendored
+109
View File
@@ -0,0 +1,109 @@
package notify
import (
"fmt"
"reflect"
"sort"
"strings"
"github.com/fatih/structs"
"github.com/silenceper/wechat/v2/util"
"github.com/spf13/cast"
)
// doc: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_7&index=8
// PaidResult 下单回调
type PaidResult struct {
ReturnCode *string `xml:"return_code"`
ReturnMsg *string `xml:"return_msg"`
AppID *string `xml:"appid" json:"appid"`
MchID *string `xml:"mch_id"`
DeviceInfo *string `xml:"device_info"`
NonceStr *string `xml:"nonce_str"`
Sign *string `xml:"sign"`
SignType *string `xml:"sign_type"`
ResultCode *string `xml:"result_code"`
ErrCode *string `xml:"err_code"`
ErrCodeDes *string `xml:"err_code_des"`
OpenID *string `xml:"openid"`
IsSubscribe *string `xml:"is_subscribe"`
TradeType *string `xml:"trade_type"`
TradeState *string `xml:"trade_state"`
BankType *string `xml:"bank_type"`
TotalFee *int `xml:"total_fee"`
SettlementTotalFee *int `xml:"settlement_total_fee"`
FeeType *string `xml:"fee_type"`
CashFee *string `xml:"cash_fee"`
CashFeeType *string `xml:"cash_fee_type"`
CouponFee *int `xml:"coupon_fee"`
CouponCount *int `xml:"coupon_count"`
// coupon_type_$n 这里只声明 3 个，如果有更多的可以自己组合
CouponType0 *string `xml:"coupon_type_0"`
CouponType1 *string `xml:"coupon_type_1"`
CouponType2 *string `xml:"coupon_type_2"`
CouponID0 *string `xml:"coupon_id_0"`
CouponID1 *string `xml:"coupon_id_1"`
CouponID2 *string `xml:"coupon_id_2"`
CouponFee0 *string `xml:"coupon_fee_0"`
CouponFee1 *string `xml:"coupon_fee_1"`
CouponFee2 *string `xml:"coupon_fee_2"`
TransactionID *string `xml:"transaction_id"`
OutTradeNo *string `xml:"out_trade_no"`
Attach *string `xml:"attach"`
TimeEnd *string `xml:"time_end"`
}
// PaidResp 消息通知返回
type PaidResp struct {
ReturnCode string `xml:"return_code"`
ReturnMsg string `xml:"return_msg"`
}
// PaidVerifySign 支付成功结果验签
func (notify *Notify) PaidVerifySign(notifyRes PaidResult) bool {
// STEP1, 转换 struct 为 map，并对 map keys 做排序
resMap := structs.Map(notifyRes)
sortedKeys := make([]string, 0, len(resMap))
for k := range resMap {
sortedKeys = append(sortedKeys, k)
}
sort.Strings(sortedKeys)
// STEP2, 对key=value的键值对用&连接起来，略过空值 & sign
var signStrings string
for _, k := range sortedKeys {
value := fmt.Sprintf("%v", cast.ToString(resMap[k]))
if value != "" && strings.ToLower(k) != "sign" {
signStrings = signStrings + getTagKeyName(k, &notifyRes) + "=" + value + "&"
}
}
// STEP3, 在键值对的最后加上key=API_KEY
signStrings = signStrings + "key=" + notify.Key
// STEP4, 根据SignType计算出签名
var signType string
if notifyRes.SignType != nil {
signType = *notifyRes.SignType
}
sign, err := util.CalculateSign(signStrings, signType, notify.Key)
if err != nil {
return false
}
if sign != *notifyRes.Sign {
return false
}
return true
}
func getTagKeyName(key string, notifyRes *PaidResult) string {
s := reflect.TypeOf(notifyRes).Elem()
f, _ := s.FieldByName(key)
name := f.Tag.Get("xml")
return name
}
vendor/github.com/silenceper/wechat/v2/pay/notify/refund.go
Generated Vendored
+77
View File
@@ -0,0 +1,77 @@
package notify
import (
"crypto/md5"
"encoding/base64"
"encoding/hex"
"encoding/xml"
"errors"
"github.com/silenceper/wechat/v2/util"
)
// reference: https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_16&index=10
// RefundedResult 退款回调
type RefundedResult struct {
ReturnCode *string `xml:"return_code"`
ReturnMsg *string `xml:"return_msg"`
AppID *string `xml:"appid"`
MchID *string `xml:"mch_id"`
NonceStr *string `xml:"nonce_str"`
ReqInfo *string `xml:"req_info"`
}
// RefundedReqInfo 退款结果（明文）
type RefundedReqInfo struct {
TransactionID *string `xml:"transaction_id"`
OutTradeNO *string `xml:"out_trade_no"`
RefundID *string `xml:"refund_id"`
OutRefundNO *string `xml:"out_refund_no"`
TotalFee *int `xml:"total_fee"`
SettlementTotalFee *int `xml:"settlement_total_fee"`
RefundFee *int `xml:"refund_fee"`
SettlementRefundFee *int `xml:"settlement_refund_fee"`
RefundStatus *string `xml:"refund_status"`
SuccessTime *string `xml:"success_time"`
RefundRecvAccount *string `xml:"refund_recv_accout"`
RefundAccount *string `xml:"refund_account"`
RefundRequestSource *string `xml:"refund_request_source"`
}
// RefundedResp 消息通知返回
type RefundedResp struct {
ReturnCode string `xml:"return_code"`
ReturnMsg string `xml:"return_msg"`
}
// DecryptReqInfo 对退款结果进行解密
func (notify *Notify) DecryptReqInfo(result *RefundedResult) (*RefundedReqInfo, error) {
var err error
if result == nil || result.ReqInfo == nil {
return nil, errors.New("empty refunded_result or req_info")
}
base64Decode, err := base64.StdEncoding.DecodeString(*result.ReqInfo)
if err != nil {
return nil, err
}
hash := md5.New()
if _, err = hash.Write([]byte(notify.Key)); err != nil {
return nil, err
}
md5APIKey := hex.EncodeToString(hash.Sum(nil))
data, err := util.AesECBDecrypt(base64Decode, []byte(md5APIKey))
if err != nil {
return nil, err
}
res := &RefundedReqInfo{}
if err = xml.Unmarshal(data, res); err != nil {
return nil, err
}
return res, nil
}
vendor/github.com/silenceper/wechat/v2/pay/order/close.go
Generated Vendored
+98
View File
@@ -0,0 +1,98 @@
package order
import (
"encoding/xml"
"errors"
"github.com/silenceper/wechat/v2/util"
)
// https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=9_3
var closeGateway = "https://api.mch.weixin.qq.com/pay/closeorder"
// CloseParams 传入的参数
type CloseParams struct {
OutTradeNo string // 商户订单号
SignType string // 签名类型
}
// closeRequest 接口请求参数
type closeRequest struct {
AppID string `xml:"appid"` // 公众账号ID
MchID string `xml:"mch_id"` // 商户号
NonceStr string `xml:"nonce_str"` // 随机字符串
Sign string `xml:"sign"` // 签名
SignType string `xml:"sign_type,omitempty"` // 签名类型
OutTradeNo string `xml:"out_trade_no"` // 商户订单号
}
// CloseResult 关闭订单返回结果
type CloseResult struct {
ReturnCode *string `xml:"return_code"`
ReturnMsg *string `xml:"return_msg"`
AppID *string `xml:"appid" json:"appid"`
MchID *string `xml:"mch_id"`
NonceStr *string `xml:"nonce_str"`
Sign *string `xml:"sign"`
ResultCode *string `xml:"result_code"`
ResultMsg *string `xml:"result_msg"`
ErrCode *string `xml:"err_code"`
ErrCodeDes *string `xml:"err_code_des"`
}
// CloseOrder 关闭订单
func (o *Order) CloseOrder(p *CloseParams) (closeResult CloseResult, err error) {
nonceStr := util.RandomStr(32)
// 签名类型
if p.SignType == "" {
p.SignType = "MD5"
}
params := make(map[string]string)
params["appid"] = o.AppID
params["mch_id"] = o.MchID
params["nonce_str"] = nonceStr
params["out_trade_no"] = p.OutTradeNo
params["sign_type"] = p.SignType
var (
sign string
rawRet []byte
)
sign, err = util.ParamSign(params, o.Key)
if err != nil {
return
}
request := closeRequest{
AppID: o.AppID,
MchID: o.MchID,
NonceStr: nonceStr,
Sign: sign,
OutTradeNo: p.OutTradeNo,
SignType: p.SignType,
}
rawRet, err = util.PostXML(closeGateway, request)
if err != nil {
return
}
err = xml.Unmarshal(rawRet, &closeResult)
if err != nil {
return
}
if *closeResult.ReturnCode == SUCCESS {
// close success
if *closeResult.ResultCode == SUCCESS {
err = nil
return
}
err = errors.New(*closeResult.ErrCode + *closeResult.ErrCodeDes)
return
}
err = errors.New("[msg : xmlUnmarshalError] [rawReturn : " + string(rawRet) + "] [sign : " + sign + "]")
return
}

Some files were not shown because too many files have changed in this diff Show More