git/wechat
1
0
Fork 0
mirror of https://github.com/silenceper/wechat.git synced 2026-02-23 13:42:25 +08:00
Code Issues Projects Releases Wiki Activity

Merge branch 'v2' into miniapp-program-subscribe-server

Browse Source
This commit is contained in:
houseme
2023-10-11 08:55:59 -05:00
committed by GitHub
parent c5c764dcc9 038037b89d
commit 82257f38cf
214 changed files with 17130 additions and 1125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
miniprogram/README.md
View File

@@ -2,11 +2,12 @@
[官方文档](https://developers.weixin.qq.com/miniprogram/dev/framework/)
## 包说明
- analysis 数据分析相关API
- analysis 数据分析相关 API
## 快速入门
```go
wc := wechat.NewWechat()
memory := cache.NewMemory()
@@ -17,4 +18,36 @@ cfg := &miniConfig.Config{
}
miniprogram := wc.GetMiniProgram(cfg)
miniprogram.GetAnalysis().GetAnalysisDailyRetain()
```
### 小程序虚拟支付
#### `注意：需要传入 Appkey、OfferID 的值`
相关文档：[小程序虚拟支付](https://developers.weixin.qq.com/miniprogram/dev/platform-capabilities/industry/virtual-payment.html)
```go
wc := wechat.NewWechat()
miniprogram := wc.GetMiniProgram(&miniConfig.Config{
AppID: "xxx",
AppSecret: "xxx",
AppKey: "xxx",
OfferID: "xxx",
Cache: cache.NewRedis(&redis.Options{
Addr: "",
}),
})
virtualPayment := miniprogram.GetVirtualPayment()
virtualPayment.SetSessionKey("xxx")
// 查询用户余额
var (
res *virtualPayment.QueryUserBalanceResponse
err error
)
if res, err = virtualPayment.QueryUserBalance(context.TODO(), &virtualPayment.QueryUserBalanceRequest{
OpenID: "xxx",
Env: virtualPayment.EnvProduction,
UserIP: "xxx",
}); err != nil {
panic(err)
}
```

10
miniprogram/analysis/analysis.go
View File

@@ -32,12 +32,12 @@ const (
getAnalysisVisitPageURL = "https://api.weixin.qq.com/datacube/getweanalysisappidvisitpage?access_token=%s"
)
//Analysis analyis 数据分析
// Analysis analyis 数据分析
type Analysis struct {
*context.Context
}
//NewAnalysis new
// NewAnalysis new
func NewAnalysis(ctx *context.Context) *Analysis {
return &Analysis{ctx}
}
@@ -190,9 +190,9 @@ func (analysis *Analysis) GetAnalysisWeeklyVisitTrend(beginDate, endDate string)
// UserPortraitItem 用户画像项目
type UserPortraitItem struct {
ID int `json:"id"` // 属性值id
Name string `json:"name"` // 属性值名称
AccessSourceVisitUV int `json:"access_source_visit_uv"` // 该场景访问uv
ID int `json:"id"` // 属性值id
Name string `json:"name"` // 属性值名称
Value int `json:"value"` // 该场景访问uv
}
// UserPortrait 用户画像

114
miniprogram/auth/auth.go
View File

@@ -1,6 +1,7 @@
package auth
import (
context2 "context"
"encoding/json"
"fmt"
@@ -10,14 +11,18 @@ import (
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 登录/用户信息
// Auth 登录/用户信息
type Auth struct {
*context.Context
}
//NewAuth new auth
// NewAuth new auth
func NewAuth(ctx *context.Context) *Auth {
return &Auth{ctx}
}
@@ -31,16 +36,26 @@ type ResCode2Session struct {
UnionID string `json:"unionid"` // 用户在开放平台的唯一标识符，在满足UnionID下发条件的情况下会返回
}
//Code2Session 登录凭证校验。
// RspCheckEncryptedData .
type RspCheckEncryptedData struct {
util.CommonError
Vaild bool `json:"vaild"` // 是否是合法的数据
CreateTime uint64 `json:"create_time"` // 加密数据生成的时间戳
}
// Code2Session 登录凭证校验。
func (auth *Auth) Code2Session(jsCode string) (result ResCode2Session, err error) {
urlStr := fmt.Sprintf(code2SessionURL, auth.AppID, auth.AppSecret, jsCode)
return auth.Code2SessionContext(context2.Background(), jsCode)
}
// Code2SessionContext 登录凭证校验。
func (auth *Auth) Code2SessionContext(ctx context2.Context, jsCode string) (result ResCode2Session, err error) {
var response []byte
response, err = util.HTTPGet(urlStr)
if err != nil {
if response, err = util.HTTPGetContext(ctx, fmt.Sprintf(code2SessionURL, auth.AppID, auth.AppSecret, jsCode)); err != nil {
return
}
err = json.Unmarshal(response, &result)
if err != nil {
if err = json.Unmarshal(response, &result); err != nil {
return
}
if result.ErrCode != 0 {
@@ -50,7 +65,86 @@ func (auth *Auth) Code2Session(jsCode string) (result ResCode2Session, err error
return
}
//GetPaidUnionID 用户支付完成后，获取该用户的 UnionId，无需用户授权
// GetPaidUnionID 用户支付完成后，获取该用户的 UnionId，无需用户授权
func (auth *Auth) GetPaidUnionID() {
//TODO
// 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
}
// 由于GetPhoneNumberContext需要传入JSON，所以HTTPPostContext入参改为[]byte
if response, err = util.HTTPPostContext(ctx, fmt.Sprintf(checkEncryptedDataURL, at), []byte("encrypted_msg_hash="+encryptedMsgHash), nil); 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"` // 数据水印
}
// GetPhoneNumberContext 小程序通过code获取用户手机号
func (auth *Auth) GetPhoneNumberContext(ctx context2.Context, code string) (*GetPhoneNumberResponse, error) {
var response []byte
var (
at string
err error
)
if at, err = auth.GetAccessToken(); err != nil {
return nil, err
}
body := map[string]interface{}{
"code": code,
}
bodyBytes, err := json.Marshal(body)
if err != nil {
return nil, err
}
header := map[string]string{"Content-Type": "application/json;charset=utf-8"}
if response, err = util.HTTPPostContext(ctx, fmt.Sprintf(getPhoneNumber, at), bodyBytes, header); err != nil {
return nil, err
}
var result GetPhoneNumberResponse
if err = util.DecodeWithError(response, &result, "phonenumber.getPhoneNumber"); err != nil {
return nil, err
}
return &result, nil
}
// GetPhoneNumber 小程序通过code获取用户手机号
func (auth *Auth) GetPhoneNumber(code string) (*GetPhoneNumberResponse, error) {
return auth.GetPhoneNumberContext(context2.Background(), code)
}

13
miniprogram/business/business.go Normal file
View File

@@ -0,0 +1,13 @@
package business
import "github.com/silenceper/wechat/v2/miniprogram/context"
// Business 业务
type Business struct {
*context.Context
}
// NewBusiness init
func NewBusiness(ctx *context.Context) *Business {
return &Business{ctx}
}

54
miniprogram/business/phone_number.go Normal file
View File

@@ -0,0 +1,54 @@
package business
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
getPhoneNumberURL = "https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=%s"
)
// GetPhoneNumberRequest 获取手机号请求
type GetPhoneNumberRequest struct {
Code string `json:"code"` // 手机号获取凭证
}
// PhoneInfo 手机号信息
type PhoneInfo struct {
PhoneNumber string `json:"phoneNumber"` // 用户绑定的手机号（国外手机号会有区号）
PurePhoneNumber string `json:"purePhoneNumber"` // 没有区号的手机号
CountryCode string `json:"countryCode"` // 区号
Watermark struct {
AppID string `json:"appid"` // 小程序appid
Timestamp int64 `json:"timestamp"` // 用户获取手机号操作的时间戳
} `json:"watermark"`
}
// GetPhoneNumber code换取用户手机号。 每个code只能使用一次，code的有效期为5min
func (business *Business) GetPhoneNumber(in *GetPhoneNumberRequest) (info PhoneInfo, err error) {
accessToken, err := business.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(getPhoneNumberURL, accessToken)
response, err := util.PostJSON(uri, in)
if err != nil {
return
}
// 使用通用方法返回错误
var resp struct {
util.CommonError
PhoneInfo PhoneInfo `json:"phone_info"`
}
err = util.DecodeWithError(response, &resp, "business.GetPhoneNumber")
if nil != err {
return
}
info = resp.PhoneInfo
return
}

12
miniprogram/config/config.go
View File

@@ -1,15 +1,17 @@
// Package config 小程序config配置
// Package config 小程序 config 配置
package config
import (
"github.com/silenceper/wechat/v2/cache"
)
// Config config for 小程序
// Config .config for 小程序
type Config struct {
AppID string `json:"app_id"` // app_id
AppSecret string `json:"app_secret"` // app_secret
AppID string `json:"app_id"` // appid
AppSecret string `json:"app_secret"` // appSecret
AppKey string `json:"app_key"` // appKey
OfferID string `json:"offer_id"` // offerId
Token string `json:"token"` // token
EncodingAESKey string `json:"encoding_aes_key"` // encoding_aes_key
EncodingAESKey string `json:"encoding_aes_key"` // EncodingAESKey
Cache cache.Cache
}

65
miniprogram/content/content.go Normal file
View File

@@ -0,0 +1,65 @@
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 需要检测的文字
// Deprecated
// 采用 security.MsgCheckV1 替代，返回值更加丰富
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 图片文件的绝对路径
// Deprecated
// 采用 security.ImageCheckV1 替代，返回值更加丰富
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")
}

8
miniprogram/encryptor/encryptor.go
View File

@@ -6,16 +6,17 @@ import (
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
)
//Encryptor struct
// Encryptor struct
type Encryptor struct {
*context.Context
}
//NewEncryptor 实例
// NewEncryptor 实例
func NewEncryptor(context *context.Context) *Encryptor {
basic := new(Encryptor)
basic.Context = context
@@ -90,6 +91,9 @@ func GetCipherText(sessionKey, encryptedData, iv string) ([]byte, error) {
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

15
miniprogram/encryptor/encryptor_test.go Normal file
View File

@@ -0,0 +1,15 @@
package encryptor
import (
"encoding/base64"
"testing"
"github.com/stretchr/testify/assert"
)
func TestGetCipherText_BadIV(t *testing.T) {
keyData := base64.StdEncoding.EncodeToString([]byte("1234567890123456"))
badData := base64.StdEncoding.EncodeToString([]byte("1"))
_, err := GetCipherText(keyData, badData, badData)
assert.Error(t, err)
}

17
miniprogram/message/consts.go
View File

@@ -12,16 +12,20 @@ type EventType string
type InfoType string
const (
//MsgTypeText 文本消息
// MsgTypeText 文本消息
MsgTypeText MsgType = "text"
//MsgTypeImage 图片消息
// MsgTypeImage 图片消息
MsgTypeImage = "image"
//MsgTypeLink 图文链接
// MsgTypeLink 图文链接
MsgTypeLink = "link"
//MsgTypeMiniProgramPage 小程序卡片
// MsgTypeMiniProgramPage 小程序卡片
MsgTypeMiniProgramPage = "miniprogrampage"
//MsgTypeEvent 表示事件推送消息
MsgTypeEvent = "event"
// MsgTypeEvent 事件
MsgTypeEvent MsgType = "event"
// DataTypeXML XML格式数据
DataTypeXML = "xml"
// DataTypeJSON JSON格式数据
DataTypeJSON = "json"
)
const (
@@ -87,6 +91,7 @@ type MiniProgramMixMessage struct {
} `xml:"SubscribeMsgSentEvent"`
}
// SubscribeMessageList 订阅消息事件列表
type SubscribeMessageList struct {
TemplateId string `xml:"TemplateId"`
SubscribeStatusString string `xml:"SubscribeStatusString"`

34
miniprogram/message/customer_message.go
View File

@@ -11,29 +11,29 @@ const (
customerSendMessage = "https://api.weixin.qq.com/cgi-bin/message/custom/send"
)
//Manager 消息管理者，可以发送消息
// Manager 消息管理者，可以发送消息
type Manager struct {
*context.Context
}
//NewCustomerMessageManager 实例化消息管理者
// NewCustomerMessageManager 实例化消息管理者
func NewCustomerMessageManager(context *context.Context) *Manager {
return &Manager{
context,
}
}
//MediaText 文本消息的文字
// MediaText 文本消息的文字
type MediaText struct {
Content string `json:"content"`
}
//MediaResource 消息使用的临时素材id
// MediaResource 消息使用的临时素材id
type MediaResource struct {
MediaID string `json:"media_id"`
}
//MediaMiniprogrampage 小程序卡片
// MediaMiniprogrampage 小程序卡片
type MediaMiniprogrampage struct {
Title string `json:"title"`
Appid string `json:"appid"`
@@ -49,17 +49,17 @@ type MediaLink struct {
ThumbURL string `json:"thumb_url"`
}
//CustomerMessage 客服消息
// 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"` //可选
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 文本消息结构体构造方法
// NewCustomerTextMessage 文本消息结构体构造方法
func NewCustomerTextMessage(toUser, text string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
@@ -70,7 +70,7 @@ func NewCustomerTextMessage(toUser, text string) *CustomerMessage {
}
}
//NewCustomerImgMessage 图片消息的构造方法
// NewCustomerImgMessage 图片消息的构造方法
func NewCustomerImgMessage(toUser, mediaID string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
@@ -81,7 +81,7 @@ func NewCustomerImgMessage(toUser, mediaID string) *CustomerMessage {
}
}
//NewCustomerLinkMessage 图文链接消息的构造方法
// NewCustomerLinkMessage 图文链接消息的构造方法
func NewCustomerLinkMessage(toUser, title, description, url, thumbURL string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
@@ -95,7 +95,7 @@ func NewCustomerLinkMessage(toUser, title, description, url, thumbURL string) *C
}
}
//NewCustomerMiniprogrampageMessage 小程序卡片消息的构造方法
// NewCustomerMiniprogrampageMessage 小程序卡片消息的构造方法
func NewCustomerMiniprogrampageMessage(toUser, title, pagepath, thumbMediaID string) *CustomerMessage {
return &CustomerMessage{
ToUser: toUser,
@@ -108,7 +108,7 @@ func NewCustomerMiniprogrampageMessage(toUser, title, pagepath, thumbMediaID str
}
}
//Send 发送客服消息
// Send 发送客服消息
func (manager *Manager) Send(msg *CustomerMessage) error {
accessToken, err := manager.Context.GetAccessToken()
if err != nil {

375
miniprogram/message/message.go Normal file
View File

@@ -0,0 +1,375 @@
package message
import (
"encoding/json"
"encoding/xml"
"errors"
"io"
"net/http"
"sort"
"strings"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/miniprogram/security"
"github.com/silenceper/wechat/v2/util"
)
// ConfirmReceiveMethod 确认收货方式
type ConfirmReceiveMethod int8
const (
// EventTypeTradeManageRemindAccessAPI 提醒接入发货信息管理服务API
// 小程序完成账期授权时/小程序产生第一笔交易时/已产生交易但从未发货的小程序，每天一次
EventTypeTradeManageRemindAccessAPI EventType = "trade_manage_remind_access_api"
// EventTypeTradeManageRemindShipping 提醒需要上传发货信息
// 曾经发过货的小程序，订单超过48小时未发货时
EventTypeTradeManageRemindShipping EventType = "trade_manage_remind_shipping"
// EventTypeTradeManageOrderSettlement 订单将要结算或已经结算
// 订单完成发货时/订单结算时
EventTypeTradeManageOrderSettlement EventType = "trade_manage_order_settlement"
// EventTypeAddExpressPath 运单轨迹更新事件
EventTypeAddExpressPath EventType = "add_express_path"
// EventTypeSecvodUpload 短剧媒资上传完成事件
EventTypeSecvodUpload EventType = "secvod_upload_event"
// EventTypeSecvodAudit 短剧媒资审核状态事件
EventTypeSecvodAudit EventType = "secvod_audit_event"
// EventTypeWxaMediaCheck 媒体内容安全异步审查结果通知
EventTypeWxaMediaCheck EventType = "wxa_media_check"
// EventTypeXpayGoodsDeliverNotify 道具发货推送事件
EventTypeXpayGoodsDeliverNotify EventType = "xpay_goods_deliver_notify"
// EventTypeXpayCoinPayNotify 代币支付推送事件
EventTypeXpayCoinPayNotify EventType = "xpay_coin_pay_notify"
// ConfirmReceiveMethodAuto 自动确认收货
ConfirmReceiveMethodAuto ConfirmReceiveMethod = 1
// ConfirmReceiveMethodManual 手动确认收货
ConfirmReceiveMethodManual ConfirmReceiveMethod = 2
)
// PushReceiver 接收消息推送
// 暂仅支付Aes加密方式
type PushReceiver struct {
*context.Context
}
// NewPushReceiver 实例化
func NewPushReceiver(ctx *context.Context) *PushReceiver {
return &PushReceiver{
Context: ctx,
}
}
// GetMsg 获取接收到的消息(如果是加密的返回解密数据)
func (receiver *PushReceiver) GetMsg(r *http.Request) (string, []byte, error) {
// 判断请求格式
var dataType string
contentType := r.Header.Get("Content-Type")
if strings.HasPrefix(contentType, "text/xml") {
// xml格式
dataType = DataTypeXML
} else {
// json格式
dataType = DataTypeJSON
}
// 读取参数，验证签名
signature := r.FormValue("signature")
timestamp := r.FormValue("timestamp")
nonce := r.FormValue("nonce")
encryptType := r.FormValue("encrypt_type")
// 验证签名
tmpArr := []string{
receiver.Token,
timestamp,
nonce,
}
sort.Strings(tmpArr)
tmpSignature := util.Signature(tmpArr...)
if tmpSignature != signature {
return dataType, nil, errors.New("signature error")
}
if encryptType == "aes" {
// 解密
var reqData DataReceived
if dataType == DataTypeXML {
if err := xml.NewDecoder(r.Body).Decode(&reqData); err != nil {
return dataType, nil, err
}
} else {
if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
return dataType, nil, err
}
}
_, rawMsgBytes, err := util.DecryptMsg(receiver.AppID, reqData.Encrypt, receiver.EncodingAESKey)
return dataType, rawMsgBytes, err
}
// 不加密
byteData, err := io.ReadAll(r.Body)
return dataType, byteData, err
}
// GetMsgData 获取接收到的消息(解密数据)
func (receiver *PushReceiver) GetMsgData(r *http.Request) (MsgType, EventType, PushData, error) {
dataType, decryptMsg, err := receiver.GetMsg(r)
if err != nil {
return "", "", nil, err
}
var (
msgType MsgType
eventType EventType
)
if dataType == DataTypeXML {
var commonToken CommonPushData
if err := xml.Unmarshal(decryptMsg, &commonToken); err != nil {
return "", "", nil, err
}
msgType, eventType = commonToken.MsgType, commonToken.Event
} else {
var commonToken CommonPushData
if err := json.Unmarshal(decryptMsg, &commonToken); err != nil {
return "", "", nil, err
}
msgType, eventType = commonToken.MsgType, commonToken.Event
}
if msgType == MsgTypeEvent {
pushData, err := receiver.getEvent(dataType, eventType, decryptMsg)
// 暂不支持其他事件类型
return msgType, eventType, pushData, err
}
// 暂不支持其他消息类型
return msgType, eventType, decryptMsg, nil
}
// getEvent 获取事件推送的数据
func (receiver *PushReceiver) getEvent(dataType string, eventType EventType, decryptMsg []byte) (PushData, error) {
switch eventType {
case EventTypeTradeManageRemindAccessAPI:
// 提醒接入发货信息管理服务API
var pushData PushDataRemindAccessAPI
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeTradeManageRemindShipping:
// 提醒需要上传发货信息
var pushData PushDataRemindShipping
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeTradeManageOrderSettlement:
// 订单将要结算或已经结算
var pushData PushDataOrderSettlement
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeWxaMediaCheck:
// 媒体内容安全异步审查结果通知
var pushData MediaCheckAsyncData
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeAddExpressPath:
// 运单轨迹更新
var pushData PushDataAddExpressPath
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeSecvodUpload:
// 短剧媒资上传完成
var pushData PushDataSecVodUpload
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeSecvodAudit:
// 短剧媒资审核状态
var pushData PushDataSecVodAudit
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeXpayGoodsDeliverNotify:
// 道具发货推送事件
var pushData PushDataXpayGoodsDeliverNotify
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
case EventTypeXpayCoinPayNotify:
// 代币支付推送事件
var pushData PushDataXpayCoinPayNotify
err := receiver.unmarshal(dataType, decryptMsg, &pushData)
return &pushData, err
}
// 暂不支持其他事件类型，直接返回解密后的数据，由调用方处理
return decryptMsg, nil
}
// unmarshal 解析推送的数据
func (receiver *PushReceiver) unmarshal(dateType string, decryptMsg []byte, pushData interface{}) error {
if dateType == DataTypeXML {
return xml.Unmarshal(decryptMsg, pushData)
}
return json.Unmarshal(decryptMsg, pushData)
}
// DataReceived 接收到的数据
type DataReceived struct {
Encrypt string `json:"Encrypt" xml:"Encrypt"` // 加密的消息体
}
// PushData 推送的数据(已转对应的结构体)
type PushData interface{}
// CommonPushData 推送数据通用部分
type CommonPushData struct {
XMLName xml.Name `json:"-" xml:"xml"`
MsgType MsgType `json:"MsgType" xml:"MsgType"` // 消息类型，为固定值 "event"
Event EventType `json:"Event" xml:"Event"` // 事件类型
ToUserName string `json:"ToUserName" xml:"ToUserName"` // 小程序的原始 ID
FromUserName string `json:"FromUserName" xml:"FromUserName"` // 发送方账号（一个 OpenID，此时发送方是系统账号）
CreateTime int64 `json:"CreateTime" xml:"CreateTime"` // 消息创建时间 （整型），时间戳
}
// MediaCheckAsyncData 媒体内容安全异步审查结果通知
type MediaCheckAsyncData struct {
CommonPushData
Appid string `json:"appid" xml:"appid"`
TraceID string `json:"trace_id" xml:"trace_id"`
Version int `json:"version" xml:"version"`
Detail []*MediaCheckDetail `json:"detail" xml:"detail"`
Errcode int `json:"errcode" xml:"errcode"`
Errmsg string `json:"errmsg" xml:"errmsg"`
Result MediaCheckAsyncResult `json:"result" xml:"result"`
}
// MediaCheckDetail 检测结果详情
type MediaCheckDetail struct {
Strategy string `json:"strategy" xml:"strategy"`
Errcode int `json:"errcode" xml:"errcode"`
Suggest security.CheckSuggest `json:"suggest" xml:"suggest"`
Label int `json:"label" xml:"label"`
Prob int `json:"prob" xml:"prob"`
}
// MediaCheckAsyncResult 检测结果
type MediaCheckAsyncResult struct {
Suggest security.CheckSuggest `json:"suggest" xml:"suggest"`
Label security.CheckLabel `json:"label" xml:"label"`
}
// PushDataOrderSettlement 订单将要结算或已经结算通知
type PushDataOrderSettlement struct {
CommonPushData
TransactionID string `json:"transaction_id" xml:"transaction_id"` // 支付订单号
MerchantID string `json:"merchant_id" xml:"merchant_id"` // 商户号
SubMerchantID string `json:"sub_merchant_id" xml:"sub_merchant_id"` // 子商户号
MerchantTradeNo string `json:"merchant_trade_no" xml:"merchant_trade_no"` // 商户订单号
PayTime int64 `json:"pay_time" xml:"pay_time"` // 支付成功时间，秒级时间戳
ShippedTime int64 `json:"shipped_time" xml:"shipped_time"` // 发货时间，秒级时间戳
EstimatedSettlementTime int64 `json:"estimated_settlement_time" xml:"estimated_settlement_time"` // 预计结算时间，秒级时间戳。发货时推送才有该字段
ConfirmReceiveMethod ConfirmReceiveMethod `json:"confirm_receive_method" xml:"confirm_receive_method"` // 确认收货方式：1. 自动确认收货；2. 手动确认收货。结算时推送才有该字段
ConfirmReceiveTime int64 `json:"confirm_receive_time" xml:"confirm_receive_time"` // 确认收货时间，秒级时间戳。结算时推送才有该字段
SettlementTime int64 `json:"settlement_time" xml:"settlement_time"` // 订单结算时间，秒级时间戳。结算时推送才有该字段
}
// PushDataRemindShipping 提醒需要上传发货信息
type PushDataRemindShipping struct {
CommonPushData
TransactionID string `json:"transaction_id" xml:"transaction_id"` // 微信支付订单号
MerchantID string `json:"merchant_id" xml:"merchant_id"` // 商户号
SubMerchantID string `json:"sub_merchant_id" xml:"sub_merchant_id"` // 子商户号
MerchantTradeNo string `json:"merchant_trade_no" xml:"merchant_trade_no"` // 商户订单号
PayTime int64 `json:"pay_time" xml:"pay_time"` // 支付成功时间，秒级时间戳
Msg string `json:"msg" xml:"msg"` // 消息文本内容
}
// PushDataRemindAccessAPI 提醒接入发货信息管理服务API信息
type PushDataRemindAccessAPI struct {
CommonPushData
Msg string `json:"msg" xml:"msg"` // 消息文本内容
}
// PushDataAddExpressPath 运单轨迹更新信息
type PushDataAddExpressPath struct {
CommonPushData
DeliveryID string `json:"DeliveryID" xml:"DeliveryID"` // 快递公司ID
WayBillID string `json:"WaybillId" xml:"WaybillId"` // 运单ID
OrderID string `json:"OrderId" xml:"OrderId"` // 订单ID
Version int `json:"Version" xml:"Version"` // 轨迹版本号（整型）
Count int `json:"Count" xml:"Count"` // 轨迹节点数（整型）
Actions []*PushDataAddExpressPathAction `json:"Actions" xml:"Actions"` // 轨迹节点列表
}
// PushDataAddExpressPathAction 轨迹节点
type PushDataAddExpressPathAction struct {
ActionTime int64 `json:"ActionTime" xml:"ActionTime"` // 轨迹节点 Unix 时间戳
ActionType int `json:"ActionType" xml:"ActionType"` // 轨迹节点类型
ActionMsg string `json:"ActionMsg" xml:"ActionMsg"` // 轨迹节点详情
}
// PushDataSecVodUpload 短剧媒资上传完成
type PushDataSecVodUpload struct {
CommonPushData
UploadEvent SecVodUploadEvent `json:"upload_event" xml:"upload_event"` // 上传完成事件
}
// SecVodUploadEvent 短剧媒资上传完成事件
type SecVodUploadEvent struct {
MediaID string `json:"media_id" xml:"media_id"` // 媒资id
SourceContext string `json:"source_context" xml:"source_context"` // 透传上传接口中开发者设置的值。
Errcode int `json:"errcode" xml:"errcode"` // 错误码，上传失败时该值非
Errmsg string `json:"errmsg" xml:"errmsg"` // 错误提示
}
// PushDataSecVodAudit 短剧媒资审核状态
type PushDataSecVodAudit struct {
CommonPushData
AuditEvent SecVodAuditEvent `json:"audit_event" xml:"audit_event"` // 审核状态事件
}
// SecVodAuditEvent 短剧媒资审核状态事件
type SecVodAuditEvent struct {
DramaID string `json:"drama_id" xml:"drama_id"` // 剧目id
SourceContext string `json:"source_context" xml:"source_context"` // 透传上传接口中开发者设置的值
AuditDetail DramaAuditDetail `json:"audit_detail" xml:"audit_detail"` // 剧目审核结果，单独每一集的审核结果可以根据drama_id查询剧集详情得到
}
// DramaAuditDetail 剧目审核结果
type DramaAuditDetail struct {
Status int `json:"status" xml:"status"` // 审核状态，0为无效值；1为审核中；2为最终失败；3为审核通过；4为驳回重填
CreateTime int64 `json:"create_time" xml:"create_time"` // 提审时间戳
AuditTime int64 `json:"audit_time" xml:"audit_time"` // 审核时间戳
}
// PushDataXpayGoodsDeliverNotify 道具发货推送
type PushDataXpayGoodsDeliverNotify struct {
CommonPushData
OpenID string `json:"OpenId" xml:"OpenId"` // 用户openid
OutTradeNo string `json:"OutTradeNo" xml:"OutTradeNo"` // 业务订单号
Env int `json:"Env" xml:"Env"` //，环境配置 0：现网环境（也叫正式环境）1：沙箱环境
WeChatPayInfo WeChatPayInfo `json:"WeChatPayInfo" xml:"WeChatPayInfo"` // 微信支付信息 非微信支付渠道可能没有
GoodsInfo GoodsInfo `json:"GoodsInfo" xml:"GoodsInfo"` // 道具参数信息
}
// WeChatPayInfo 微信支付信息
type WeChatPayInfo struct {
MchOrderNo string `json:"MchOrderNo" xml:"MchOrderNo"` // 微信支付商户单号
TransactionID string `json:"TransactionId" xml:"TransactionId"` // 交易单号（微信支付订单号）
PaidTime int64 `json:"PaidTime" xml:"PaidTime"` // 用户支付时间，Linux秒级时间戳
}
// GoodsInfo 道具参数信息
type GoodsInfo struct {
ProductID string `json:"ProductId" xml:"ProductId"` // 道具ID
Quantity int `json:"Quantity" xml:"Quantity"` // 数量
OrigPrice int64 `json:"OrigPrice" xml:"OrigPrice"` // 物品原始价格 （单位：分）
ActualPrice int64 `json:"ActualPrice" xml:"ActualPrice"` // 物品实际支付价格（单位：分）
Attach string `json:"Attach" xml:"Attach"` // 透传信息
}
// PushDataXpayCoinPayNotify 代币支付推送
type PushDataXpayCoinPayNotify struct {
CommonPushData
OpenID string `json:"OpenId" xml:"OpenId"` // 用户openid
OutTradeNo string `json:"OutTradeNo" xml:"OutTradeNo"` // 业务订单号
Env int `json:"Env" xml:"Env"` //，环境配置 0：现网环境（也叫正式环境）1：沙箱环境
WeChatPayInfo WeChatPayInfo `json:"WeChatPayInfo" xml:"WeChatPayInfo"` // 微信支付信息 非微信支付渠道可能没有
CoinInfo CoinInfo `json:"CoinInfo" xml:"CoinInfo"` // 代币参数信息
}
// CoinInfo 代币参数信息
type CoinInfo struct {
Quantity int `json:"Quantity" xml:"Quantity"` // 数量
OrigPrice int64 `json:"OrigPrice" xml:"OrigPrice"` // 物品原始价格 （单位：分）
ActualPrice int64 `json:"ActualPrice" xml:"ActualPrice"` // 物品实际支付价格（单位：分）
Attach string `json:"Attach" xml:"Attach"` // 透传信息
}

100
miniprogram/minidrama/constant.go Normal file
View File

@@ -0,0 +1,100 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
package minidrama
const (
// Success 错误码 0、成功
Success ErrCode = 0
// SystemError 错误码 -1、系统错误
SystemError ErrCode = -1
// InitError 错误码 -2 初始化未完成，请稍后再试
InitError ErrCode = -2
// FormatError 错误码 47001 输入格式错误
FormatError ErrCode = 47001
// ParamError 错误码 47003 参数不符合要求
ParamError ErrCode = 47003
// PostError 错误码 44002 POST 内容为空
PostError ErrCode = 44002
// MethodError 错误码 43002 HTTP 请求必须使用 POST 方法
MethodError ErrCode = 43002
// VideoTypeError 错误码 10090001 视频类型不支持
VideoTypeError ErrCode = 10090001
// ImageTypeError 错误码 10090002 图片类型不支持
ImageTypeError ErrCode = 10090002
// ImageURLError 错误码 10090003 图片 URL 无效
ImageURLError ErrCode = 10090003
// ResourceType 错误码 10090005 resource_type 无效
ResourceType ErrCode = 10090005
// OperationError 错误码 10093011 操作失败
OperationError ErrCode = 10093011
// ParamError2 错误码 10093014 参数错误（包括参数格式、类型等错误）
ParamError2 ErrCode = 10093014
// OperationFrequentError 错误码 10093023 操作过于频繁
OperationFrequentError ErrCode = 10093023
// ResourceNotExistError 错误码 10093030 资源不存在
ResourceNotExistError ErrCode = 10093030
)
const (
// singleFileUpload 单个文件上传，上传媒体（和封面）文件，上传小文件（小于 10MB）时使用。上传大文件请使用分片上传接口。
singleFileUpload = "https://api.weixin.qq.com/wxa/sec/vod/singlefileupload?access_token="
// pullUpload 拉取上传，该接口用于将一个网络上的视频拉取上传到平台。
pullUpload = "https://api.weixin.qq.com/wxa/sec/vod/pullupload?access_token="
// getTask 查询任务，该接口用于查询拉取上传的任务状态。
getTask = "https://api.weixin.qq.com/wxa/sec/vod/gettask?access_token="
// applyUpload 申请分片上传
applyUpload = "https://api.weixin.qq.com/wxa/sec/vod/applyupload?access_token="
// uploadPart 上传分片
uploadPart = "https://api.weixin.qq.com/wxa/sec/vod/uploadpart?access_token="
// commitUpload 确认上传，该接口用于完成整个分片上传流程，合并所有文件分片，确认媒体文件（和封面图片文件）上传到平台的结果，返回文件的 ID。请求中需要给出每一个分片的 part_number 和 etag，用来校验分片的准确性。
commitUpload = "https://api.weixin.qq.com/wxa/sec/vod/commitupload?access_token="
// listMedia 获取媒体列表
listMedia = "https://api.weixin.qq.com/wxa/sec/vod/listmedia?access_token="
// getMedia 获取媒资详细信息，该接口用于获取已上传到平台的指定媒资信息，用于开发者后台管理使用。用于给用户客户端播放的链接应该使用 getmedialink 接口获取。
getMedia = "https://api.weixin.qq.com/wxa/sec/vod/getmedia?access_token="
// getMediaLink 获取媒资播放链接，该接口用于获取视频临时播放链接，用于给用户的播放使用。只有审核通过的视频才能通过该接口获取播放链接。
getMediaLink = "https://api.weixin.qq.com/wxa/sec/vod/getmedialink?access_token="
// deleteMedia 删除媒体，该接口用于删除指定媒资。
deleteMedia = "https://api.weixin.qq.com/wxa/sec/vod/deletemedia?access_token="
// auditDrama 审核剧本
auditDrama = "https://api.weixin.qq.com/wxa/sec/vod/auditdrama?access_token="
// listDramas 获取剧目列表
listDramas = "https://api.weixin.qq.com/wxa/sec/vod/listdramas?access_token="
// getDrama 获取剧目信息，该接口用于查询已提交的剧目。
getDrama = "https://api.weixin.qq.com/wxa/sec/vod/getdrama?access_token="
// getCdnUsageData 查询 CDN 用量数据，该接口用于查询点播 CDN 的流量数据。
getCdnUsageData = "https://api.weixin.qq.com/wxa/sec/vod/getcdnusagedata?access_token="
// getCdnLogs 查询 CDN 日志，该接口用于查询点播 CDN 的日志。
getCdnLogs = "https://api.weixin.qq.com/wxa/sec/vod/getcdnlogs?access_token="
)

32
miniprogram/minidrama/doc.go Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
// Package minidrama Mini Program entertainment mini-drama related interface
package minidrama
import (
"github.com/silenceper/wechat/v2/miniprogram/context"
)
// NewMiniDrama 实例化小程序娱乐直播 API
func NewMiniDrama(ctx *context.Context) *MiniDrama {
return &MiniDrama{
ctx: ctx,
}
}

440
miniprogram/minidrama/domain.go Normal file
View File

@@ -0,0 +1,440 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
package minidrama
import (
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
// MiniDrama mini program entertainment live broadcast related
type MiniDrama struct {
ctx *context.Context
}
// ErrCode error code
type ErrCode int
// SingleFileUploadRequest 单文件上传请求
// Content-Type 需要指定为 multipart/form-data; boundary=<delimiter>
// <箭头括号> 表示必须替换为有效值的变量。
// 不填写 cover_type，cover_data 字段时默认截取视频首帧作为视频封面。
type SingleFileUploadRequest struct {
MediaName string `json:"media_name"` // 媒体文件名称 文件名，需按照“剧目名 - 对应剧集数”格式命名文件，示例值："我的演艺 - 第 1 集"。
MediaType string `json:"media_type"` // 媒体文件类型 视频格式，支持：MP4，TS，MOV，MXF，MPG，FLV，WMV，AVI，M4V，F4V，MPEG，3GP，ASF，MKV，示例值："MP4"。
MediaData []byte `json:"media_data"` // 媒体文件数据 视频文件内容，二进制。
CoverType string `json:"cover_type,omitempty"` // 视频封面图片格式，支持：JPG、JPEG、PNG、BMP、TIFF、AI、CDR、EPS、TIF，示例值："JPG"。
CoverData []byte `json:"cover_data,omitempty"` // 视频封面图片内容，二进制。
SourceContext string `json:"source_context,omitempty"` // 来源上下文，会在上传完成事件中透传给开发者。
}
// SingleFileUploadResponse 单文件上传响应
type SingleFileUploadResponse struct {
util.CommonError
MediaID int64 `json:"media_id"` // 媒体文件唯一标识，用于发布视频。
}
// PullUploadRequest 拉取上传请求
// 不填写 cover_url 字段时默认截取视频首帧作为封面。
// Content-Type 需要指定为 application/json
// 该接口为异步接口，上传完成会推送上传完成事件到开发者服务器，开发者也可以调用"查询任务"接口来轮询上传结果。
type PullUploadRequest struct {
MediaName string `json:"media_name"` // 媒体文件名称 文件名，需按照“剧目名 - 对应剧集数”格式命名文件，示例值："我的演艺 - 第 1 集"。
MediaURL string `json:"media_url"` // 视频 URL，示例值："https://developers.weixin.qq.com/test.mp4"。
CoverURL string `json:"cover_url,omitempty"` // 视频封面 URL，示例值："https://developers.weixin.qq.com/test.jpg"。
SourceContext string `json:"source_context,omitempty"` // 来源上下文，会在上传完成事件中透传给开发者。
}
// PullUploadResponse 拉取上传响应
type PullUploadResponse struct {
util.CommonError
TaskID int64 `json:"task_id"` // 任务 ID，用于查询拉取上传任务的结果。
}
// GetTaskRequest 查询任务请求
// 该接口用于查询拉取上传的任务状态。
// Content-Type 需要指定为 application/json。
type GetTaskRequest struct {
TaskID int64 `json:"task_id"` // 任务 ID，用于查询拉取上传任务的结果。
}
// GetTaskResponse 查询任务响应
type GetTaskResponse struct {
util.CommonError
TaskInfo TaskInfo `json:"task_info"` // 任务信息。
}
// TaskInfo 任务信息
type TaskInfo struct {
ID int64 `json:"id"` // 任务 ID。
TaskType int `json:"task_type"` // 任务类型，1：拉取上传任务。
Status int `json:"status"` // 任务状态枚举值：1. 等待中；2. 正在处理；3. 已完成；4. 失败。
ErrCode int `json:"errcode"` // 任务错误码，0 表示成功，其它表示失败。
ErrMsg string `json:"errmsg"` // 任务错误原因。
CreateTime int64 `json:"create_time"` // 任务创建时间，时间戳，单位：秒。
FinishTime int64 `json:"finish_time"` // 任务完成时间，时间戳，单位：秒。
MediaID int64 `json:"media_id"` // 媒体文件唯一标识，用于发布视频。
}
// ApplyUploadRequest 申请上传请求
// 上传大文件时需使用分片上传方式，分为 3 个步骤：
//
// 申请分片上传，确定文件名、格式类型，返回 upload_id，唯一标识本次分片上传。
// 上传分片，多次调用上传文件分片，需要携带 part_number 和 upload_id，其中 part_number 为分片的编号，支持乱序上传。当传入 part_number 和 upload_id 都相同的时候，后发起上传请求的分片将覆盖之前的分片。
// 确认分片上传，当上传完所有分片后，需要完成整个文件的合并。请求体中需要给出每一个分片的 part_number 和 etag，用来校验分片的准确性，最后返回文件的 media_id。
// 如果填写了 cover_type，表明本次分片上传除上传媒体文件外还需要上传封面图片，不填写 cover_type 则默认截取视频首帧作为封面。
// Content-Type 需要指定为 application/json。
type ApplyUploadRequest struct {
MediaName string `json:"media_name"` // 媒体文件名称 文件名，需按照“剧目名 - 对应剧集数”格式命名文件，示例值："我的演艺 - 第 1 集"。
MediaType string `json:"media_type"` // 媒体文件类型 视频格式，支持：MP4，TS，MOV，MXF，MPG，FLV，WMV，AVI，M4V，F4V，MPEG，3GP，ASF，MKV，示例值："MP4"。
CoverType string `json:"cover_type,omitempty"` // 视频封面图片格式，支持：JPG、JPEG、PNG、BMP、TIFF、AI、CDR、EPS、TIF，示例值："JPG"。
SourceContext string `json:"source_context,omitempty"` // 来源上下文，会在上传完成事件中透传给开发者。
}
// ApplyUploadResponse 申请上传响应
type ApplyUploadResponse struct {
util.CommonError
UploadID string `json:"upload_id"` // 本次分片上传的唯一标识。
}
// UploadPartRequest 上传分片请求
// 将文件的其中一个分片上传到平台，最多支持 100 个分片，每个分片大小为 5MB，最后一个分片可以小于 5MB。该接口适用于视频和封面图片。视频最大支持 500MB，封面图片最大支持 10MB。
// 调用该接口之前必须先调用申请分片上传接口。
// 在申请分片上传时，如果不填写 cover_type，则默认截取视频首帧作为封面。
// Content-Type 需要指定为 multipart/form-data; boundary=<delimiter>，<箭头括号>表示必须替换为有效值的变量。
// part_number 从 1 开始。如除了上传视频外还需要上传封面图片，则封面图片的 part_number 需重新从 1 开始编号。
type UploadPartRequest struct {
UploadID string `json:"upload_id"` // 一次分片上传的唯一标识，由申请分片上传接口返回。
PartNumber int `json:"part_number"` // 本次上传的分片的编号，范围在 1 - 100。
ResourceType int `json:"resource_type"` // 指定该分片属于视频还是封面图片的枚举值：1. 视频，2. 封面图片。
Data []byte `json:"data"` // 分片内容，二进制。
}
// UploadPartResponse 上传分片响应
type UploadPartResponse struct {
util.CommonError
ETag string `json:"etag"` // 上传分片成功后返回的分片标识，用于后续确认分片上传接口。
}
// CommitUploadRequest 确认分片上传请求
// 该接口用于完成整个分片上传流程，合并所有文件分片，确认媒体文件（和封面图片文件）上传到平台的结果，返回文件的 ID。请求中需要给出每一个分片的 part_number 和 etag，用来校验分片的准确性。
// 注意事项
// Content-Type 需要指定为 application/json。
// 调用该接口之前必须先调用申请分片上传接口以及上传分片接口。
// 如本次分片上传除上传媒体文件外还需要上传封面图片，则请求中还需提供 cover_part_infos 字段以用于合并封面图片文件分片。
// 请求中 media_part_infos 和 cover_part_infos 字段必须按 part_number 从小到大排序，part_number 必须从 1 开始，连续且不重复。
type CommitUploadRequest struct {
UploadID string `json:"upload_id"`
MediaPartInfos []*PartInfo `json:"media_part_infos"`
CoverPartInfos []*PartInfo `json:"cover_part_infos,omitempty"`
}
// PartInfo 分片信息
type PartInfo struct {
PartNumber int `json:"part_number"` // 分片编号。
Etag string `json:"etag"` // 使用上传分片接口上传成功后返回的 etag 的值
}
// CommitUploadResponse 确认分片上传响应
type CommitUploadResponse struct {
util.CommonError
MediaID int64 `json:"media_id"` // 媒体文件唯一标识，用于发布视频。
}
// ListMediaRequest 查询媒体列表请求
// 该接口用于查询已经上传到平台的媒体文件列表。
// 注意事项
// Content-Type 需要指定为 application/json。
// 本接口返回的视频或图片链接均为临时链接，不应将其保存下来。
// media_name 参数支持模糊匹配，当需要模糊匹配时可以在前面或后面加上 %，否则为精确匹配。例如 "test%" 可以匹配到 "test123", "testxxx", "test"。
// 调用方式
type ListMediaRequest struct {
DramaID int64 `json:"drama_id,omitempty"` // 剧目 ID，可通过查询剧目列表接口获取。
MediaName string `json:"media_name,omitempty"` // 媒体文件名称，可通过查询媒体列表接口获取，模糊匹配。
StartTime int64 `json:"start_time,omitempty"` // 媒资上传时间>=start_time，Unix 时间戳，单位：秒。
EndTime int64 `json:"end_time,omitempty"` // 媒资上传时间<end_time，Unix 时间戳，单位：秒。
Limit int `json:"limit,omitempty"` // 分页拉取的最大返回结果数。默认值：100；最大值：100。
Offset int `json:"offset,omitempty"` // 分页拉取的起始偏移量。默认值：0。
}
// MediaInfo 媒体信息
type MediaInfo struct {
MediaID int64 `json:"media_id"` // 媒资文件 id。
CreateTime int64 `json:"create_time"` // 上传时间，时间戳。
ExpireTime int64 `json:"expire_time"` // 过期时间，时间戳。
DramaID int64 `json:"drama_id"` // 所属剧目 id。
FileSize int64 `json:"file_size"` // 媒资文件大小，单位：字节。
Duration int64 `json:"duration"` // 播放时长，单位：秒。
Name string `json:"name"` // 媒资文件名。
Description string `json:"description"` // 描述。
CoverURL string `json:"cover_url"` // 封面图临时链接。
OriginalURL string `json:"original_url"` // 原始视频临时链接。
Mp4URL string `json:"mp4_url"` // mp4 格式临时链接。
HlsURL string `json:"hls_url"` // hls 格式临时链接。
AuditDetail *MediaAuditDetail `json:"audit_detail"` // 审核信息。
}
// MediaAuditDetail 媒体审核详情
type MediaAuditDetail struct {
Status int `json:"status"` // 审核状态 0 为无效值；1 为审核中；2 为审核驳回；3 为审核通过；4 为驳回重填。需要注意可能存在单个剧集的状态为审核通过，但是剧目整体是未通过的情况，而能不能获取播放链接取决于剧目的审核状态。
CreateTime int `json:"create_time"` // 提审时间戳。
AuditTime int `json:"audit_time"` // 审核时间戳。
Reason string `json:"reason"` // 审核备注。该值可能为空。
EvidenceMaterialIDList []string `json:"evidence_material_id_list"` // 审核证据截图 id 列表，截图 id 可以用作 get_material 接口的参数来获得截图内容。
}
// ListMediaResponse 查询媒体列表响应
type ListMediaResponse struct {
util.CommonError
MediaInfoList []*MediaInfo `json:"media_info_list"` // 媒体信息列表。
}
// GetMediaRequest 获取媒体请求
// 该接口用于获取已上传到平台的指定媒资信息，用于开发者后台管理使用。用于给用户客户端播放的链接应该使用 getmedialink 接口获取。
// Content-Type 需要指定为 application/json。
// 本接口返回的视频或图片链接均为临时链接，不应将其保存下来。
type GetMediaRequest struct {
MediaID int64 `json:"media_id"` // 媒资文件 id。
}
// GetMediaResponse 获取媒体响应
type GetMediaResponse struct {
util.CommonError
MediaInfo MediaInfo `json:"media_info"` // 媒体信息。
}
// GetMediaLinkRequest 获取媒体链接请求
// 该接口用于获取视频临时播放链接，用于给用户的播放使用。只有审核通过的视频才能通过该接口获取播放链接。
// 注意事项
// Content-Type 需要指定为 application/json。
// 本接口返回的视频或图片链接均为临时链接，不应将其保存下来。
// 能不能获取播放链接取决于剧目审核状态，可能存在单个剧集的状态为审核通过，但是剧目整体是未通过的情况，这种情况也没法获取播放链接。
// 开发者如需区分不同渠道的播放流量或次数，可以在 us 参数中传入渠道标识，这样得到的播放链接中 us 参数的前半部分就包含有渠道标识。开发者把这个带有渠道标识的链接分发给对应的渠道播放，就能统计到不同渠道播放情况。统计的数据来源为 CDN 日志（从 getcdnlogs 接口得到），CDN 日志中“文件路径”列中的参数也带有该标识，再结合日志中“字节数”列的流量数值，估算每个渠道所消耗的流量。另需注意日志统计的流量和扣费流量的差异，详情参考 getcdnlogs 接口中的注意事项。
type GetMediaLinkRequest struct {
MediaID int64 `json:"media_id"` // 媒资文件 id。
T int64 `json:"t"` // 播放地址的过期时间戳。有效的时间最长不能超过 2 小时后。
US string `json:"us,omitempty"` // 链接标识。平台默认会生成一个仅包含小写字母和数字的字符串用于增强链接的唯一性 (如 us=647488c4792c15185b8fd2a6)。如开发者需要增加自己的标识，比如区分播放的渠道，可使用该参数，该参数最终的值是"开发者标识 - 平台标识"（如开发者传入 abcd，则最终的临时链接中 us=abcd-647488c4792c15185b8fd2a6）
Expr int `json:"expr,omitempty"` // 试看时长，单位：秒，最大值不能超过视频长度
RLimit int `json:"rlimit,omitempty"` // 最多允许多少个不同 IP 的终端播放，以十进制表示，最大值为 9，不填表示不做限制。当限制 URL 只能被 1 个人播放时，建议 rlimit 不要严格限制成 1（例如可设置为 3），因为移动端断网后重连 IP 可能改变。
WHref string `json:"whref,omitempty"` // 允许访问的域名列表，支持 1 条 - 10 条，用半角逗号分隔。域名前不要带协议名（http://和 https://），域名为前缀匹配（如填写 abc.com，则 abc.com/123 和 abc.com.cn 也会匹配），且支持通配符（如 *.abc.com）
BkRef string `json:"bkref,omitempty"` // 禁止访问的域名列表，支持 1 条 - 10 条，用半角逗号分隔。域名前不要带协议名（http://和 https://），域名为前缀匹配（如填写 abc.com，则 abc.com/123 和 abc.com.cn 也会匹配），且支持通配符（如 *.abc.com）。
}
// GetMediaLinkResponse 获取媒体链接响应
type GetMediaLinkResponse struct {
util.CommonError
MediaInfo MediaPlaybackInfo `json:"media_info"` // 媒体播放信息。
}
// MediaPlaybackInfo 媒体播放信息
type MediaPlaybackInfo struct {
MediaID int64 `json:"media_id"` // 媒资文件 id。
Duration int64 `json:"duration"` // 播放时长，单位：秒。
Name string `json:"name"` // 媒资文件名。
Description string `json:"description"` // 描述。
CoverURL string `json:"cover_url"` // 封面图临时链接。
Mp4URL string `json:"mp4_url"` // mp4 格式临时链接。
HlsURL string `json:"hls_url"` // hls 格式临时链接。
}
// DeleteMediaRequest 删除媒体请求
// 该接口用于删除已上传到平台的指定媒资文件，用于开发者后台管理使用。
// Content-Type 需要指定为 application/json。
type DeleteMediaRequest struct {
MediaID int64 `json:"media_id"` // 媒资文件 id。
}
// DeleteMediaResponse 删除媒体响应
type DeleteMediaResponse struct {
util.CommonError
}
// AuditDramaRequest 审核剧目请求
// 该接口用于审核剧目，审核通过后，剧目下所有剧集都会被审核通过。
// 注意事项
// Content-Type 需要指定为 application/json。
// 剧目信息与审核材料在首次提审时为必填，重新提审时根据是否需要修改选填，
// 本接口中使用的临时图片 material_id 可通过新增临时素材接口上传得到，对应临时素材接口中的 media_id，本文档中为避免与剧集的 media_id 混淆，称其为 material_id。
// 新增临时素材接口可以被小程序调用，调用的小程序账号和剧目提审的小程序账号必须是同一个，否则提交审核时会无法识别素材 id。
type AuditDramaRequest struct {
DramaID int64 `json:"drama_id,omitempty"` // 剧目 ID，可通过查询剧目列表接口获取。首次提审不需要填该参数，重新提审时必填
Name string `json:"name,omitempty"` // 剧名，首次提审时必填，重新提审时根据是否需要修改选填。
MediaCount int `json:"media_count,omitempty"` // 剧集数目。首次提审时必填，重新提审时可不填，如要填写也要和第一次提审时一样。
MediaIDList []int64 `json:"media_id_list,omitempty"` // 剧集媒资 media_id 列表。首次提审时必填，而且元素个数必须与 media_count 一致。重新提审时为可选，如果剧集有内容有变化，可以通过新的列表替换未通过的剧集（推荐使用 replace_media_list 进行替换，避免顺序和原列表不一致）。
Producer string `json:"producer,omitempty"` // 制作方。首次提审时必填，重新提审时根据是否需要修改选填。
Description string `json:"description,omitempty"` // 剧描述。首次提审时必填，重新提审时根据是否需要修改选填。
CoverMaterialID string `json:"cover_material_id,omitempty"` // 封面图片临时 media_id。首次提审时必填，重新提审时根据是否需要修改选填。
RegistrationNumber string `json:"registration_number,omitempty"` // 剧目备案号。首次提审时剧目备案号与网络剧片发行许可证编号二选一。重新提审时根据是否需要修改选填
AuthorizedMaterialID string `json:"authorized_material_id,omitempty"` // 剧目播放授权材料 material_id。如果小程序主体名称和制作方完全一致，则不需要填，否则必填
PublishLicense string `json:"publish_license,omitempty"` // 网络剧片发行许可证编号。首次提审时剧目备案号与网络剧片发行许可证编号二选一。重新提审时根据是否需要修改选填
PublishLicenseMaterialID string `json:"publish_license_material_id,omitempty"` // 网络剧片发行许可证图片，首次提审时如果网络剧片发行许可证编号非空，则该改字段也非空。重新提审时根据是否变化选填
Expedited int `json:"expedited,omitempty"` // 是否加急审核，填 1 表示审核加急，0 或不填为不加急。每天有 5 次加急机会。该字段在首次提审时才有效，重新提审时会沿用首次提审时的属性，重新提审不会扣次数。最终是否为加急单，可以根据 DramaInfo.expedited 属性判断
ReplaceMediaList []*ReplaceInfo `json:"replace_media_list,omitempty"` // 重新提审时，如果剧目内容有变化，可以通过该字段替换未通过的剧集。用于重新提审时替换审核不通过的剧集。
}
// ReplaceInfo 替换信息
type ReplaceInfo struct {
Old int64 `json:"old"` // 旧的 media_id
New int64 `json:"new"` // 新的 media_id
}
// AuditDramaResponse 审核剧目响应
type AuditDramaResponse struct {
util.CommonError
DramaID int64 `json:"drama_id"` // 剧目 ID。
}
// ListDramasRequest 查询剧目列表请求
// 该接口用于获取已提交的剧目列表。
// 注意事项
// Content-Type 需要指定为 application/json。
// 本接口返回的图片链接均为临时链接，不应将其保存下来。
// 如果剧目审核结果为失败或驳回，则具体每一集的具体驳回理由及证据截图可通过“获取媒资列表”或者“获取媒资详细信息”接口来获取。
type ListDramasRequest struct {
Limit int `json:"limit,omitempty"` // 分页拉取的最大返回结果数。默认值：100；最大值：100。
Offset int `json:"offset,omitempty"` // 分页拉取的起始偏移量。默认值：0。
}
// DramaInfo 剧目信息
type DramaInfo struct {
DramaID int64 `json:"drama_id"` // 剧目 id。
CreateTime int64 `json:"create_time"` // 创建时间，时间戳。
Name string `json:"name"` // 剧名。
Playwright string `json:"playwright"` // 编剧。
Producer string `json:"producer"` // 制作方。
ProductionLicense string `json:"production_license"` // 广播电视节目制作经营许可证。
CoverURL string `json:"cover_url"` // 封面图临时链接，根据提审时提交的 cover_material_id 转存得到。
MediaCount int `json:"media_count"` // 剧集数目。
Description string `json:"description"` // 剧描述。
MediaList []*DramaMediaInfo `json:"media_list"` // 剧集信息列表。
AuditDetail *DramaAuditDetail `json:"audit_detail"` // 审核状态。
Expedited int `json:"expedited"` // 是否加急审核，1 表示审核加急，0 或空为非加急审核。
}
// DramaMediaInfo 剧目媒体信息
type DramaMediaInfo struct {
MediaID int64 `json:"media_id"`
}
// DramaAuditDetail 剧目审核详情
type DramaAuditDetail struct {
Status int `json:"status"` // 审核状态 0 为无效值；1 为审核中；2 为审核驳回；3 为审核通过；4 为驳回重填。
CreateTime int64 `json:"create_time"` // 提审时间戳。
AuditTime int64 `json:"audit_time"` // 审核时间戳。
}
// ListDramasResponse 查询剧目列表响应
type ListDramasResponse struct {
util.CommonError
DramaInfoList []*DramaInfo `json:"drama_info_list"` // 剧目信息列表。
}
// GetDramaRequest 获取剧目请求
// 该接口用于查询已提交的剧目。
// 注意事项
// Content-Type 需要指定为 application/json。
// 本接口返回的图片链接均为临时链接，不应将其保存下来。
// 如果剧目审核结果为失败或驳回，则具体每一集的具体驳回理由及证据截图可通过“获取媒资列表”或者“获取媒资详细信息”接口来获取。
type GetDramaRequest struct {
DramaID int64 `json:"drama_id"` // 剧目 id。
}
// GetDramaResponse 获取剧目响应
type GetDramaResponse struct {
util.CommonError
DramaInfo *DramaInfo `json:"drama_info"` // 剧目信息。
}
// GetCdnUsageDataRequest 获取 CDN 用量数据请求
// 该接口用于查询点播 CDN 的流量数据。
// 注意事项
// 可以查询最近 365 天内的 CDN 用量数据。
// 查询时间跨度不超过 90 天。
// 可以指定用量数据的时间粒度，支持 5 分钟、1 小时、1 天的时间粒度。
// 流量为查询时间粒度内的总流量。
type GetCdnUsageDataRequest struct {
StartTime int64 `json:"start_time"` // 查询起始时间，Unix 时间戳，单位：秒。
EndTime int64 `json:"end_time"` // 查询结束时间，Unix 时间戳，单位：秒。
DataInterval int `json:"data_interval"` // 用量数据的时间粒度，单位：分钟，取值有：5:5 分钟粒度，返回指定查询时间内 5 分钟粒度的明细数据。60：小时粒度，返回指定查询时间内 1 小时粒度的数据。1440：天粒度，返回指定查询时间内 1 天粒度的数据。默认值为 1440，返回天粒度的数据。
}
// DataItem 数据项
type DataItem struct {
Time int64 `json:"time"` // 时间戳，单位：秒。
Value int64 `json:"value"` // 用量数值。
}
// GetCdnUsageDataResponse 获取 CDN 用量数据响应
type GetCdnUsageDataResponse struct {
util.CommonError
DataInterval int `json:"data_interval"`
ItemList []*DataItem `json:"item_list"`
}
// GetCdnLogsRequest 获取 CDN 日志下载链接请求
// 该接口用于获取点播 CDN 日志下载链接。
// 注意事项
// 可以查询最近 30 天内的 CDN 日志下载链接。
// 默认情况下 CDN 每小时生成一个日志文件，如果某一个小时没有 CDN 访问，不会生成日志文件。
// CDN 日志下载链接的有效期为 24 小时。
// 日志字段依次为：请求时间、客户端 IP、访问域名、文件路径、字节数、省级编码、运营商编码、HTTP 状态码、referer、Request-Time、UA、range、HTTP Method、协议标识、缓存 HIT / MISS，日志数据打包存在延迟，正常情况下 3 小时后数据包趋于完整日志中的字节数为应用层数据大小，未考虑网络协议包头、加速重传等开销，因此与计费数据存在一定差异。
// CDN 日志中记录的下行字节数统计而来的流量数据，是应用层数据。在实际网络传输中，产生的网络流量要比纯应用层流量多 5%-15%，比如 TCP/IP 协议的包头消耗、网络丢包重传等，这些无法被应用层统计到。在业内标准中，计费用流量一般在应用层流量的基础上加上上述开销，媒资管理服务中计费的加速流量约为日志计算加速流量的 110%。
// 省份映射
// 22：北京；86：内蒙古；146：山西；1069：河北；1177：天津；119：宁夏；152：陕西；1208：甘肃；1467：青海；1468：新疆；145：黑龙江；1445：吉林；1464：辽宁；2：福建；120：江苏；121：安徽；122：山东；1050：上海；1442：浙江；182：河南；1135：湖北；1465：江西；1466：湖南；118：贵州；153：云南；1051：重庆；1068：四川；1155：西藏；4：广东；173：广西；1441：海南；0：其他；1：港澳台；-1：海外。
// 运营商映射
// 2：中国电信；26：中国联通；38：教育网；43：长城宽带；1046：中国移动；3947：中国铁通；-1：海外运营商；0：其他运营商。
type GetCdnLogsRequest struct {
StartTime int64 `json:"start_time"` // 查询起始时间，Unix 时间戳，单位：秒。
EndTime int64 `json:"end_time"` // 查询结束时间，Unix 时间戳，单位：秒。
Limit int `json:"limit,omitempty"` // 分页拉取的最大返回结果数。默认值：100；最大值：100。
Offset int `json:"offset,omitempty"` // 分页拉取的起始偏移量。默认值：0。
}
// CdnLogInfo CDN 日志信息
type CdnLogInfo struct {
Date int64 `json:"date"` // 日志日期，格式为 YYYYMMDD。
Name string `json:"name"` // 日志文件名
URL string `json:"url"` // 日志下载链接，24 小时内下载有效。
StartTime int64 `json:"start_time"` // 查询起始时间，Unix 时间戳，单位：秒。
EndTime int64 `json:"end_time"` // 查询结束时间，Unix 时间戳，单位：秒。
}
// GetCdnLogsResponse 获取 CDN 日志下载链接响应
type GetCdnLogsResponse struct {
util.CommonError
TotalCount int `json:"total_count"` // 日志总条数。
DomesticCdnLogs []*CdnLogInfo `json:"domestic_cdn_logs"` // 日志信息列表，国内 CDN 节点的日志下载列表。
}
// AsyncMediaUploadEvent 异步媒体上传事件
// see: https://developers.weixin.qq.com/miniprogram/dev/platform-capabilities/industry/mini-drama/mini_drama.html#_5-1-%E5%AA%92%E8%B5%84%E4%B8%8A%E4%BC%A0%E5%AE%8C%E6%88%90%E4%BA%8B%E4%BB%B6
type AsyncMediaUploadEvent struct {
util.CommonError
MediaID int64 `json:"media_id"` // 媒资文件 id。
SourceContext string `json:"source_context"` // 来源上下文，开发者可自定义该字段内容。
}
// AsyncMediaAuditEvent 异步媒体审核事件
// see: https://developers.weixin.qq.com/miniprogram/dev/platform-capabilities/industry/mini-drama/mini_drama.html#_5-2-%E5%AE%A1%E6%A0%B8%E7%8A%B6%E6%80%81%E4%BA%8B%E4%BB%B6
type AsyncMediaAuditEvent struct {
DramaID int64 `json:"drama_id"` // 剧目 id。
SourceContext string `json:"source_context"` // 来源上下文，开发者可自定义该字段内容。
AuditDetail *DramaAuditDetail `json:"audit_detail"` // 审核状态。
}

346
miniprogram/minidrama/minidrama.go Normal file
View File

@@ -0,0 +1,346 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
package minidrama
import (
"context"
"strconv"
"github.com/silenceper/wechat/v2/util"
)
// SingleFileUpload 单文件上传
func (s *MiniDrama) SingleFileUpload(ctx context.Context, in *SingleFileUploadRequest) (out SingleFileUploadResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, singleFileUpload); err != nil {
return
}
var (
fields = []util.MultipartFormField{
{
IsFile: true,
Fieldname: "media_data",
Filename: string(in.MediaData),
}, {
IsFile: false,
Fieldname: "media_name",
Value: []byte(in.MediaName),
}, {
IsFile: false,
Fieldname: "media_type",
Value: []byte(in.MediaType),
},
}
response []byte
)
if in.CoverType != "" && in.CoverData != nil {
fields = append(fields, util.MultipartFormField{
IsFile: false,
Fieldname: "cover_type",
Value: []byte(in.CoverType),
})
fields = append(fields, util.MultipartFormField{
IsFile: true,
Fieldname: "cover_data",
Filename: string(in.CoverData),
})
}
if in.SourceContext != "" {
fields = append(fields, util.MultipartFormField{
IsFile: false,
Fieldname: "source_context",
Value: []byte(in.SourceContext),
})
}
if response, err = util.PostMultipartForm(fields, address); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "SingleFileUpload")
return
}
// PullUpload 拉取上传
func (s *MiniDrama) PullUpload(ctx context.Context, in *PullUploadRequest) (out PullUploadResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, pullUpload); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "PullUpload")
return
}
// GetTask 查询任务状态
func (s *MiniDrama) GetTask(ctx context.Context, in *GetTaskRequest) (out GetTaskResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, getTask); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "GetTask")
return
}
// ApplyUpload 申请分片上传
func (s *MiniDrama) ApplyUpload(ctx context.Context, in *ApplyUploadRequest) (out ApplyUploadResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, applyUpload); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "ApplyUpload")
return
}
// UploadPart 上传分片
// Content-Type 需要指定为 multipart/form-data; boundary=<delimiter>，<箭头括号>表示必须替换为有效值的变量。
func (s *MiniDrama) UploadPart(ctx context.Context, in *UploadPartRequest) (out UploadPartResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, uploadPart); err != nil {
return
}
var (
fields = []util.MultipartFormField{
{
IsFile: true,
Fieldname: "data",
Filename: string(in.Data),
}, {
IsFile: false,
Fieldname: "upload_id",
Value: []byte(in.UploadID),
}, {
IsFile: false,
Fieldname: "part_number",
Value: []byte(strconv.Itoa(in.PartNumber)),
}, {
IsFile: false,
Fieldname: "resource_type",
Value: []byte(strconv.Itoa(in.PartNumber)),
},
}
response []byte
)
if response, err = util.PostMultipartForm(fields, address); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "UploadPart")
return
}
// CommitUpload 确认上传
func (s *MiniDrama) CommitUpload(ctx context.Context, in *CommitUploadRequest) (out CommitUploadResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, commitUpload); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "CommitUpload")
return
}
// ListMedia 获取媒体列表
func (s *MiniDrama) ListMedia(ctx context.Context, in *ListMediaRequest) (out ListMediaResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, listMedia); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "ListMedia")
return
}
// GetMedia 获取媒资详细信息
func (s *MiniDrama) GetMedia(ctx context.Context, in *GetMediaRequest) (out GetMediaResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, getMedia); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "GetMedia")
return
}
// GetMediaLink 获取媒资播放链接
func (s *MiniDrama) GetMediaLink(ctx context.Context, in *GetMediaLinkRequest) (out GetMediaLinkResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, getMediaLink); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "GetMediaLink")
return
}
// DeleteMedia 删除媒体
func (s *MiniDrama) DeleteMedia(ctx context.Context, in *DeleteMediaRequest) (out DeleteMediaResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, deleteMedia); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "DeleteMedia")
return
}
// AuditDrama 审核剧本
func (s *MiniDrama) AuditDrama(ctx context.Context, in *AuditDramaRequest) (out AuditDramaResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, auditDrama); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "AuditDrama")
return
}
// ListDramas 获取剧目列表
func (s *MiniDrama) ListDramas(ctx context.Context, in *ListDramasRequest) (out ListDramasResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, listDramas); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "ListDramas")
return
}
// GetDrama 获取剧目信息
func (s *MiniDrama) GetDrama(ctx context.Context, in *GetDramaRequest) (out GetDramaResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, getDrama); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "GetDrama")
return
}
// GetCdnUsageData 查询 CDN 用量数据
func (s *MiniDrama) GetCdnUsageData(ctx context.Context, in *GetCdnUsageDataRequest) (out GetCdnUsageDataResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, getCdnUsageData); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "GetCdnUsageData")
return
}
// GetCdnLogs 查询 CDN 日志
func (s *MiniDrama) GetCdnLogs(ctx context.Context, in *GetCdnLogsRequest) (out GetCdnLogsResponse, err error) {
var address string
if address, err = s.requestAddress(ctx, getCdnLogs); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "GetCdnLogs")
return
}
// requestAddress 请求地址
func (s *MiniDrama) requestAddress(_ context.Context, url string) (string, error) {
accessToken, err := s.ctx.GetAccessToken()
if err != nil {
return "", err
}
return url + accessToken, nil
}

93
miniprogram/miniprogram.go
View File

@@ -2,26 +2,38 @@ package miniprogram
import (
"github.com/silenceper/wechat/v2/credential"
"github.com/silenceper/wechat/v2/internal/openapi"
"github.com/silenceper/wechat/v2/miniprogram/analysis"
"github.com/silenceper/wechat/v2/miniprogram/auth"
"github.com/silenceper/wechat/v2/miniprogram/business"
"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/minidrama"
"github.com/silenceper/wechat/v2/miniprogram/order"
"github.com/silenceper/wechat/v2/miniprogram/privacy"
"github.com/silenceper/wechat/v2/miniprogram/qrcode"
"github.com/silenceper/wechat/v2/miniprogram/server"
"github.com/silenceper/wechat/v2/miniprogram/riskcontrol"
"github.com/silenceper/wechat/v2/miniprogram/security"
"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/urlscheme"
"github.com/silenceper/wechat/v2/miniprogram/virtualpayment"
"github.com/silenceper/wechat/v2/miniprogram/werun"
"net/http"
)
//MiniProgram 微信小程序相关API
// MiniProgram 微信小程序相关 API
type MiniProgram struct {
ctx *context.Context
}
//NewMiniProgram 实例化小程序API
// NewMiniProgram 实例化小程序 API
func NewMiniProgram(cfg *config.Config) *MiniProgram {
defaultAkHandle := credential.NewDefaultAccessToken(cfg.AppID, cfg.AppSecret, credential.CacheKeyMiniProgramPrefix, cfg.Cache)
ctx := &context.Context{
@@ -31,7 +43,7 @@ func NewMiniProgram(cfg *config.Config) *MiniProgram {
return &MiniProgram{ctx}
}
//SetAccessTokenHandle 自定义access_token获取方式
// SetAccessTokenHandle 自定义 access_token 获取方式
func (miniProgram *MiniProgram) SetAccessTokenHandle(accessTokenHandle credential.AccessTokenHandle) {
miniProgram.ctx.AccessTokenHandle = accessTokenHandle
}
@@ -46,27 +58,37 @@ func (miniProgram *MiniProgram) GetEncryptor() *encryptor.Encryptor {
return encryptor.NewEncryptor(miniProgram.ctx)
}
//GetAuth 登录/用户信息相关接口
// GetAuth 登录/用户信息相关接口
func (miniProgram *MiniProgram) GetAuth() *auth.Auth {
return auth.NewAuth(miniProgram.ctx)
}
//GetAnalysis 数据分析
// GetAnalysis 数据分析
func (miniProgram *MiniProgram) GetAnalysis() *analysis.Analysis {
return analysis.NewAnalysis(miniProgram.ctx)
}
//GetQRCode 小程序码相关API
// GetBusiness 业务接口
func (miniProgram *MiniProgram) GetBusiness() *business.Business {
return business.NewBusiness(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
// GetTcb 小程序云开发 API
func (miniProgram *MiniProgram) GetTcb() *tcb.Tcb {
return tcb.NewTcb(miniProgram.ctx)
}
//GetSubscribe 小程序订阅消息
// GetSubscribe 小程序订阅消息
func (miniProgram *MiniProgram) GetSubscribe() *subscribe.Subscribe {
return subscribe.NewSubscribe(miniProgram.ctx)
}
@@ -88,3 +110,58 @@ func (miniProgram *MiniProgram) GetServer(req *http.Request, write http.Response
srv.Write = write
return srv
}
// 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)
}
// GetRiskControl 安全风控接口
func (miniProgram *MiniProgram) GetRiskControl() *riskcontrol.RiskControl {
return riskcontrol.NewRiskControl(miniProgram.ctx)
}
// GetSecurity 内容安全接口
func (miniProgram *MiniProgram) GetSecurity() *security.Security {
return security.NewSecurity(miniProgram.ctx)
}
// GetShortLink 小程序短链接口
func (miniProgram *MiniProgram) GetShortLink() *shortlink.ShortLink {
return shortlink.NewShortLink(miniProgram.ctx)
}
// GetSURLScheme 小程序 URL Scheme 接口
func (miniProgram *MiniProgram) GetSURLScheme() *urlscheme.URLScheme {
return urlscheme.NewURLScheme(miniProgram.ctx)
}
// GetOpenAPI openApi 管理接口
func (miniProgram *MiniProgram) GetOpenAPI() *openapi.OpenAPI {
return openapi.NewOpenAPI(miniProgram.ctx)
}
// GetVirtualPayment 小程序虚拟支付
func (miniProgram *MiniProgram) GetVirtualPayment() *virtualpayment.VirtualPayment {
return virtualpayment.NewVirtualPayment(miniProgram.ctx)
}
// GetMessageReceiver 获取消息推送接收器
func (miniProgram *MiniProgram) GetMessageReceiver() *message.PushReceiver {
return message.NewPushReceiver(miniProgram.ctx)
}
// GetShipping 小程序发货信息管理服务
func (miniProgram *MiniProgram) GetShipping() *order.Shipping {
return order.NewShipping(miniProgram.ctx)
}
// GetMiniDrama 小程序娱乐微短剧
func (miniProgram *MiniProgram) GetMiniDrama() *minidrama.MiniDrama {
return minidrama.NewMiniDrama(miniProgram.ctx)
}

269
miniprogram/order/shipping.go Normal file
View File

@@ -0,0 +1,269 @@
package order
import (
"fmt"
"time"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
// 发货信息录入
uploadShippingInfoURL = "https://api.weixin.qq.com/wxa/sec/order/upload_shipping_info?access_token=%s"
// 查询订单发货状态
getShippingOrderURL = "https://api.weixin.qq.com/wxa/sec/order/get_order?access_token=%s"
// 查询订单列表
getShippingOrderListURL = "https://api.weixin.qq.com/wxa/sec/order/get_order_list?access_token=%s"
// 确认收货提醒接口
notifyConfirmReceiveURL = "https://api.weixin.qq.com/wxa/sec/order/notify_confirm_receive?access_token=%s"
)
// Shipping 发货信息管理
type Shipping struct {
*context.Context
}
// NewShipping init
func NewShipping(ctx *context.Context) *Shipping {
return &Shipping{ctx}
}
// UploadShippingInfo 发货信息录入
// see https://developers.weixin.qq.com/miniprogram/dev/platform-capabilities/business-capabilities/order-shipping/order-shipping.html
func (shipping *Shipping) UploadShippingInfo(in *UploadShippingInfoRequest) (err error) {
accessToken, err := shipping.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(uploadShippingInfoURL, accessToken)
response, err := util.PostJSON(uri, in)
if err != nil {
return
}
// 使用通用方法返回错误
return util.DecodeWithCommonError(response, "UploadShippingInfo")
}
// GetShippingOrder 查询订单发货状态
func (shipping *Shipping) GetShippingOrder(in *GetShippingOrderRequest) (res ShippingOrderResponse, err error) {
accessToken, err := shipping.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(getShippingOrderURL, accessToken)
response, err := util.PostJSON(uri, in)
if err != nil {
return
}
err = util.DecodeWithError(response, &res, "GetShippingOrder")
return
}
// GetShippingOrderList 查询订单列表
func (shipping *Shipping) GetShippingOrderList(in *GetShippingOrderListRequest) (res GetShippingOrderListResponse, err error) {
accessToken, err := shipping.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(getShippingOrderListURL, accessToken)
response, err := util.PostJSON(uri, in)
if err != nil {
return
}
err = util.DecodeWithError(response, &res, "GetShippingOrderList")
return
}
// NotifyConfirmReceive 确认收货提醒接口
func (shipping *Shipping) NotifyConfirmReceive(in *NotifyConfirmReceiveRequest) (err error) {
accessToken, err := shipping.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(notifyConfirmReceiveURL, accessToken)
response, err := util.PostJSON(uri, in)
if err != nil {
return
}
// 使用通用方法返回错误
return util.DecodeWithCommonError(response, "NotifyConfirmReceive")
}
// UploadShippingInfoRequest 发货信息录入请求参数
type UploadShippingInfoRequest struct {
OrderKey *ShippingOrderKey `json:"order_key"` // 订单，需要上传物流信息的订单
LogisticsType LogisticsType `json:"logistics_type"` // 物流模式
DeliveryMode DeliveryMode `json:"delivery_mode"` // 发货模式
IsAllDelivered bool `json:"is_all_delivered"` // 分拆发货模式时必填，用于标识分拆发货模式下是否已全部发货完成
ShippingList []*ShippingInfo `json:"shipping_list"` // 物流信息列表，发货物流单列表，支持统一发货（单个物流单）和分拆发货（多个物流单）两种模式
UploadTime *time.Time `json:"upload_time"` // 上传时间，用于标识请求的先后顺序
Payer *ShippingPayer `json:"payer"` // 支付人信息
}
// ShippingOrderKey 订单
type ShippingOrderKey struct {
OrderNumberType NumberType `json:"order_number_type"` // 订单单号类型，用于确认需要上传详情的订单。枚举值1，使用下单商户号和商户侧单号；枚举值2，使用微信支付单号。
TransactionID string `json:"transaction_id"` // 原支付交易对应的微信订单号
Mchid string `json:"mchid"` // 支付下单商户的商户号，由微信支付生成并下发
OutTradeNo string `json:"out_trade_no"` // 商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一
}
// ShippingPayer 支付者信息
type ShippingPayer struct {
Openid string `json:"openid"` // 用户标识，用户在小程序appid下的唯一标识
}
// ShippingInfo 物流信息
type ShippingInfo struct {
TrackingNo string `json:"tracking_no"` // 物流单号，物流快递发货时必填
ExpressCompany string `json:"express_company"` // 物流公司编码，快递公司ID，物流快递发货时必填；参见「查询物流公司编码列表」
ItemDesc string `json:"item_desc"` // 商品信息，例如：微信红包抱枕*1个，限120个字以内
Contact ShippingContact `json:"contact"` // 联系方式，当发货的物流公司为顺丰时，联系方式为必填，收件人或寄件人联系方式二选一
}
// ShippingContact 联系方式
type ShippingContact struct {
ConsignorContact string `json:"consignor_contact"` // 寄件人联系方式，寄件人联系方式，采用掩码传输，最后4位数字不能打掩码
ReceiverContact string `json:"receiver_contact"` // 收件人联系方式，收件人联系方式，采用掩码传输，最后4位数字不能打掩码
}
// DeliveryMode 发货模式
type DeliveryMode uint8
const (
// DeliveryModeUnifiedDelivery 统一发货
DeliveryModeUnifiedDelivery DeliveryMode = 1
// DeliveryModeSplitDelivery 分拆发货
DeliveryModeSplitDelivery DeliveryMode = 2
)
// LogisticsType 物流模式
type LogisticsType uint8
const (
// LogisticsTypeExpress 实体物流配送采用快递公司进行实体物流配送形式
LogisticsTypeExpress LogisticsType = 1
// LogisticsTypeSameCity 同城配送
LogisticsTypeSameCity LogisticsType = 2
// LogisticsTypeVirtual 虚拟商品，虚拟商品，例如话费充值，点卡等，无实体配送形式
LogisticsTypeVirtual LogisticsType = 3
// LogisticsTypeSelfPickup 用户自提
LogisticsTypeSelfPickup LogisticsType = 4
)
// NumberType 订单单号类型
type NumberType uint8
const (
// NumberTypeOutTradeNo 使用下单商户号和商户侧单号
NumberTypeOutTradeNo NumberType = 1
// NumberTypeTransactionID 使用微信支付单号
NumberTypeTransactionID NumberType = 2
)
// GetShippingOrderRequest 查询订单发货状态参数
type GetShippingOrderRequest struct {
TransactionID string `json:"transaction_id"` // 原支付交易对应的微信订单号
MerchantID string `json:"merchant_id"` // 支付下单商户的商户号，由微信支付生成并下发
SubMerchantID string `json:"sub_merchant_id"` //二级商户号
MerchantTradeNo string `json:"merchant_trade_no"` //商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一。
}
// ShippingItem 物流信息
type ShippingItem struct {
TrackingNo string `json:"tracking_no"` // 物流单号，示例值: "323244567777
ExpressCompany string `json:"express_company"` // 物流公司编码，快递公司ID，物流快递发货时必填；参见「查询物流公司编码列表」
UploadTime int64 `json:"upload_time"` // 上传物流信息时间，时间戳形式
}
// ShippingDetail 发货信息
type ShippingDetail struct {
DeliveryMode DeliveryMode `json:"delivery_mode"` // 发货模式
LogisticsType LogisticsType `json:"logistics_type"` // 物流模式
FinishShipping bool `json:"finish_shipping"` // 是否已全部发货
FinishShippingCount int `json:"finish_shipping_count"` // 已完成全部发货的次数
GoodsDesc string `json:"goods_desc"` // 在小程序后台发货信息录入页录入的商品描述
ShippingList []*ShippingItem `json:"shipping_list"` // 物流信息列表
}
// ShippingOrder 订单发货状态
type ShippingOrder struct {
TransactionID string `json:"transaction_id"` // 原支付交易对应的微信订单号
MerchantTradeNo string `json:"merchant_trade_no"` // 商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一
MerchantID string `json:"merchant_id"` // 支付下单商户的商户号，由微信支付生成并下发
SubMerchantID string `json:"sub_merchant_id"` // 二级商户号
Description string `json:"description"` // 以分号连接的该支付单的所有商品描述，当超过120字时自动截断并以 “...” 结尾
PaidAmount int64 `json:"paid_amount"` // 支付单实际支付金额，整型，单位：分钱
Openid string `json:"openid"` // 支付者openid
TradeCreateTime int64 `json:"trade_create_time"` // 交易创建时间，时间戳形式
PayTime int64 `json:"pay_time"` // 支付时间，时间戳形式
InComplaint bool `json:"in_complaint"` // 是否处在交易纠纷中
OrderState State `json:"order_state"` // 订单状态枚举：(1) 待发货；(2) 已发货；(3) 确认收货；(4) 交易完成；(5) 已退款
Shipping *ShippingDetail `json:"shipping"` // 订单发货信息
}
// ShippingOrderResponse 查询订单发货状态返回参数
type ShippingOrderResponse struct {
util.CommonError
Order ShippingOrder `json:"order"` // 订单发货信息
}
// State 订单状态
type State uint8
const (
// StateWaitShipment 待发货
StateWaitShipment State = 1
// StateShipped 已发货
StateShipped State = 2
// StateConfirm 确认收货
StateConfirm State = 3
// StateComplete 交易完成
StateComplete State = 4
// StateRefund 已退款
StateRefund State = 5
)
// GetShippingOrderListRequest 查询订单列表请求参数
type GetShippingOrderListRequest struct {
PayTimeRange *TimeRange `json:"pay_time_range"` // 支付时间范围
OrderState State `json:"order_state,omitempty"` // 订单状态
Openid string `json:"openid,omitempty"` // 支付者openid
LastIndex string `json:"last_index,omitempty"` // 翻页时使用，获取第一页时不用传入，如果查询结果中 has_more 字段为 true，则传入该次查询结果中返回的 last_index 字段可获取下一页
PageSize int64 `json:"page_size"` // 每页数量，最多50条
}
// TimeRange 时间范围
type TimeRange struct {
BeginTime int64 `json:"begin_time,omitempty"` // 查询开始时间，时间戳形式
EndTime int64 `json:"end_time,omitempty"` // 查询结束时间，时间戳形式
}
// GetShippingOrderListResponse 查询订单列表返回参数
type GetShippingOrderListResponse struct {
util.CommonError
OrderList []*ShippingOrder `json:"order_list"`
LastIndex string `json:"last_index"`
HasMore bool `json:"has_more"`
}
// NotifyConfirmReceiveRequest 确认收货提醒接口请求参数
type NotifyConfirmReceiveRequest struct {
TransactionID string `json:"transaction_id"` // 原支付交易对应的微信订单号
MerchantID string `json:"merchant_id"` // 支付下单商户的商户号，由微信支付生成并下发
SubMerchantID string `json:"sub_merchant_id"` // 二级商户号
MerchantTradeNo string `json:"merchant_trade_no"` // 商户系统内部订单号，只能是数字、大小写字母`_-*`且在同一个商户号下唯一
ReceivedTime int64 `json:"received_time"` // 收货时间，时间戳形式
}

167
miniprogram/privacy/privacy.go Normal file
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
}

14
miniprogram/qrcode/qrcode.go
View File

@@ -15,12 +15,12 @@ const (
getWXACodeUnlimitURL = "https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=%s"
)
//QRCode struct
// QRCode struct
type QRCode struct {
*context.Context
}
//NewQRCode 实例
// NewQRCode 实例
func NewQRCode(context *context.Context) *QRCode {
qrCode := new(QRCode)
qrCode.Context = context
@@ -40,16 +40,20 @@ type QRCoder struct {
Page string `json:"page,omitempty"`
// path 扫码进入的小程序页面路径
Path string `json:"path,omitempty"`
// checkPath 检查page 是否存在，为 true 时 page 必须是已经发布的小程序存在的页面（否则报错）；为 false 时允许小程序未发布或者 page 不存在， 但page 有数量上限（60000个）请勿滥用，默认true
CheckPath *bool `json:"check_path,omitempty"`
// width 图片宽度
Width int `json:"width,omitempty"`
// scene 最大32个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()*+,/:;=?@-._~，其它字符请自行编码为合法字符（因不支持%，中文无法使用 urlencode 处理，请使用其他编码方式）
Scene string `json:"scene,omitempty"`
// autoColor 自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调
// autoColor 自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调，默认false
AutoColor bool `json:"auto_color,omitempty"`
// lineColor AutoColor 为 false 时生效，使用 rgb 设置颜色 例如 {"r":"xxx","g":"xxx","b":"xxx"},十进制表示
LineColor Color `json:"line_color,omitempty"`
// isHyaline 是否需要透明底色
LineColor *Color `json:"line_color,omitempty"`
// isHyaline 是否需要透明底色，默认false
IsHyaline bool `json:"is_hyaline,omitempty"`
// envVersion 要打开的小程序版本。正式版为 "release"，体验版为 "trial"，开发版为 "develop"
EnvVersion string `json:"env_version,omitempty"`
}
// fetchCode 请求并返回二维码二进制数据

60
miniprogram/riskcontrol/riskcontrol.go Normal file
View File

@@ -0,0 +1,60 @@
package riskcontrol
import (
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
getUserRiskRankURL = "https://api.weixin.qq.com/wxa/getuserriskrank?access_token=%s"
)
// RiskControl 安全风控
type RiskControl struct {
*context.Context
}
// NewRiskControl init
func NewRiskControl(ctx *context.Context) *RiskControl {
return &RiskControl{ctx}
}
// UserRiskRankRequest 获取用户安全等级请求
type UserRiskRankRequest struct {
AppID string `json:"appid"` // 小程序 app id
OpenID string `json:"openid"` // 用户的 openid
Scene uint8 `json:"scene"` // 场景值，0:注册，1:营销作弊
ClientIP string `json:"client_ip"` // 用户访问源ip
Mobile string `json:"mobile_no"` // 用户手机号
Email string `json:"email_address"` // 用户邮箱地址
ExtendedInfo string `json:"extended_info"` // 额外补充信息
IsTest bool `json:"is_test"` // false：正式调用，true：测试调用
}
// UserRiskRank 用户安全等级
type UserRiskRank struct {
util.CommonError
UnionID int64 `json:"union_id"` // 唯一请求标识
RiskRank uint8 `json:"risk_rank"` // 用户风险等级
}
// GetUserRiskRank 根据提交的用户信息数据获取用户的安全等级 risk_rank，无需用户授权。
func (riskControl *RiskControl) GetUserRiskRank(in *UserRiskRankRequest) (res UserRiskRank, err error) {
accessToken, err := riskControl.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(getUserRiskRankURL, accessToken)
response, err := util.PostJSON(uri, in)
if err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &res, "GetUserRiskRank")
return
}

256
miniprogram/security/security.go Normal file
View File

@@ -0,0 +1,256 @@
package security
import (
"fmt"
"strconv"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
const (
mediaCheckAsyncURL = "https://api.weixin.qq.com/wxa/media_check_async?access_token=%s"
imageCheckURL = "https://api.weixin.qq.com/wxa/img_sec_check?access_token=%s"
msgCheckURL = "https://api.weixin.qq.com/wxa/msg_sec_check?access_token=%s"
)
// Security 内容安全
type Security struct {
*context.Context
}
// NewSecurity init
func NewSecurity(ctx *context.Context) *Security {
return &Security{ctx}
}
// MediaCheckAsyncV1Request 图片/音频异步校验请求参数
type MediaCheckAsyncV1Request struct {
MediaURL string `json:"media_url"` // 要检测的图片或音频的url，支持图片格式包括jpg, jepg, png, bmp, gif（取首帧），支持的音频格式包括mp3, aac, ac3, wma, flac, vorbis, opus, wav
MediaType uint8 `json:"media_type"` // 1:音频;2:图片
}
// MediaCheckAsyncV1 异步校验图片/音频是否含有违法违规内容
// Deprecated
// 在2021年9月1日停止更新，请尽快更新至 2.0 接口。建议使用 MediaCheckAsync
func (security *Security) MediaCheckAsyncV1(in *MediaCheckAsyncV1Request) (traceID string, err error) {
accessToken, err := security.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(mediaCheckAsyncURL, accessToken)
response, err := util.PostJSON(uri, in)
if err != nil {
return
}
// 使用通用方法返回错误
var res struct {
util.CommonError
TraceID string `json:"trace_id"`
}
err = util.DecodeWithError(response, &res, "MediaCheckAsyncV1")
if err != nil {
return
}
traceID = res.TraceID
return
}
// MediaCheckAsyncRequest 图片/音频异步校验请求参数
type MediaCheckAsyncRequest struct {
MediaURL string `json:"media_url"` // 要检测的图片或音频的url，支持图片格式包括jpg, jepg, png, bmp, gif（取首帧），支持的音频格式包括mp3, aac, ac3, wma, flac, vorbis, opus, wav
MediaType uint8 `json:"media_type"` // 1:音频;2:图片
OpenID string `json:"openid"` // 用户的openid（用户需在近两小时访问过小程序）
Scene uint8 `json:"scene"` // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
}
// MediaCheckAsync 异步校验图片/音频是否含有违法违规内容
func (security *Security) MediaCheckAsync(in *MediaCheckAsyncRequest) (traceID string, err error) {
accessToken, err := security.GetAccessToken()
if err != nil {
return
}
var req struct {
MediaCheckAsyncRequest
Version uint `json:"version"` // 接口版本号，2.0版本为固定值2
}
req.MediaCheckAsyncRequest = *in
req.Version = 2
uri := fmt.Sprintf(mediaCheckAsyncURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return
}
// 使用通用方法返回错误
var res struct {
util.CommonError
TraceID string `json:"trace_id"`
}
err = util.DecodeWithError(response, &res, "MediaCheckAsync")
if err != nil {
return
}
traceID = res.TraceID
return
}
// ImageCheckV1 校验一张图片是否含有违法违规内容（同步）
// https://developers.weixin.qq.com/miniprogram/dev/framework/security.imgSecCheck.html
// Deprecated
// 在2021年9月1日停止更新。建议使用 MediaCheckAsync
func (security *Security) ImageCheckV1(filename string) (err error) {
accessToken, err := security.GetAccessToken()
if err != nil {
return
}
uri := fmt.Sprintf(imageCheckURL, accessToken)
response, err := util.PostFile("media", filename, uri)
if err != nil {
return
}
// 使用通用方法返回错误
return util.DecodeWithCommonError(response, "ImageCheckV1")
}
// CheckSuggest 检查建议
type CheckSuggest string
const (
// CheckSuggestRisky 违规风险建议
CheckSuggestRisky CheckSuggest = "risky"
// CheckSuggestPass 安全
CheckSuggestPass CheckSuggest = "pass"
// CheckSuggestReview 需要审查
CheckSuggestReview CheckSuggest = "review"
)
// MsgScene 文本场景
type MsgScene uint8
const (
// MsgSceneMaterial 资料文件检查场景
MsgSceneMaterial MsgScene = iota + 1
// MsgSceneComment 评论
MsgSceneComment
// MsgSceneForum 论坛
MsgSceneForum
// MsgSceneSocialLog 社交日志
MsgSceneSocialLog
)
// CheckLabel 检查命中标签
type CheckLabel int
func (cl CheckLabel) String() string {
switch cl {
case 100:
return "正常"
case 10001:
return "广告"
case 20001:
return "时政"
case 20002:
return "色情"
case 20003:
return "辱骂"
case 20006:
return "违法犯罪"
case 20008:
return "欺诈"
case 20012:
return "低俗"
case 20013:
return "版权"
case 21000:
return "其他"
default:
return strconv.Itoa(int(cl))
}
}
// MsgCheckRequest 文本检查请求
type MsgCheckRequest struct {
OpenID string `json:"openid"` // 用户的openid（用户需在近两小时访问过小程序）
Scene MsgScene `json:"scene"` // 场景枚举值（1 资料；2 评论；3 论坛；4 社交日志）
Content string `json:"content"` // 需检测的文本内容，文本字数的上限为 2500 字，需使用 UTF-8 编码
Nickname string `json:"nickname"` // （非必填）用户昵称，需使用UTF-8编码
Title string `json:"title"` // （非必填）文本标题，需使用UTF-8编码
Signature string `json:"signature"` // （非必填）个性签名，该参数仅在资料类场景有效(scene=1)，需使用UTF-8编码
}
// MsgCheckResponse 文本检查响应
type MsgCheckResponse struct {
util.CommonError
TraceID string `json:"trace_id"` // 唯一请求标识
Result struct {
Suggest CheckSuggest `json:"suggest"` // 建议
Label CheckLabel `json:"label"` // 命中标签
} `json:"result"` // 综合结果
Detail []struct {
ErrCode int64 `json:"errcode"` // 错误码，仅当该值为0时，该项结果有效
Strategy string `json:"strategy"` // 策略类型
Suggest string `json:"suggest"` // 建议
Label CheckLabel `json:"label"` // 命中标签
Prob uint `json:"prob"` // 置信度。0-100，越高代表越有可能属于当前返回的标签（label）
Keyword string `json:"keyword"` // 命中的自定义关键词
} `json:"detail"` // 详细检测结果
}
// MsgCheckV1 检查一段文本是否含有违法违规内容
// Deprecated
// 在2021年9月1日停止更新，请尽快更新至 2.0 接口。建议使用 MsgCheck
func (security *Security) MsgCheckV1(content string) (res MsgCheckResponse, err error) {
accessToken, err := security.GetAccessToken()
if err != nil {
return
}
var req struct {
Content string `json:"content"`
}
req.Content = content
uri := fmt.Sprintf(msgCheckURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &res, "security.MsgCheckV1")
return
}
// MsgCheck 检查一段文本是否含有违法违规内容
func (security *Security) MsgCheck(in *MsgCheckRequest) (res MsgCheckResponse, err error) {
accessToken, err := security.GetAccessToken()
if err != nil {
return
}
var req struct {
MsgCheckRequest
Version uint `json:"version"`
}
req.MsgCheckRequest = *in
req.Version = 2
uri := fmt.Sprintf(msgCheckURL, accessToken)
response, err := util.PostJSON(uri, req)
if err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &res, "security.MsgCheck")
return
}

86
miniprogram/shortlink/shortlink.go Normal file
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,
})
}

84
miniprogram/subscribe/subscribe.go
View File

@@ -8,14 +8,22 @@ import (
)
const (
//发送订阅消息
//https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.send.html
// 发送订阅消息
// 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"
@@ -33,21 +41,21 @@ func NewSubscribe(ctx *context.Context) *Subscribe {
// Message 订阅消息请求参数
type Message struct {
ToUser string `json:"touser"` //必选，接收者（用户）的 openid
TemplateID string `json:"template_id"` //必选，所需下发的订阅模板id
Page string `json:"page"` //可选，点击模板卡片后的跳转页面，仅限本小程序内的页面。支持带参数,（示例index?foo=bar）。该字段不填则模板无跳转。
Data map[string]*DataItem `json:"data"` //必选, 模板内容
MiniprogramState string `json:"miniprogram_state"` //可选，跳转小程序类型：developer为开发版；trial为体验版；formal为正式版；默认为正式版
Lang string `json:"lang"` //入小程序查看”的语言类型，支持zh_CN(简体中文)、en_US(英文)、zh_HK(繁体中文)、zh_TW(繁体中文)，默认为zh_CN
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 的值
// DataItem 模版内某个 .DATA 的值
type DataItem struct {
Value interface{} `json:"value"`
Color string `json:"color"`
}
//TemplateItem template item
// TemplateItem template item
type TemplateItem struct {
PriTmplID string `json:"priTmplId"`
Title string `json:"title"`
@@ -56,7 +64,7 @@ type TemplateItem struct {
Type int64 `json:"type"`
}
//TemplateList template list
// TemplateList template list
type TemplateList struct {
util.CommonError
Data []TemplateItem `json:"data"`
@@ -77,7 +85,7 @@ func (s *Subscribe) Send(msg *Message) (err error) {
return util.DecodeWithCommonError(response, "Send")
}
//ListTemplates 获取当前帐号下的个人模板列表
// 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()
@@ -133,3 +141,55 @@ func (s *Subscribe) UniformSend(msg *UniformMessage) (err error) {
}
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")
}

2
miniprogram/tcb/README.md
View File

@@ -21,7 +21,9 @@ wcTcb := wc.GetTcb()
```
### 举例
#### 触发云函数
```golang
res, err := wcTcb.InvokeCloudFunction("test-xxxx", "add", `{"a":1,"b":2}`)
if err != nil {

9
miniprogram/tcb/cloudfunction.go
View File

@@ -7,17 +7,18 @@ import (
)
const (
//触发云函数
// 触发云函数
invokeCloudFunctionURL = "https://api.weixin.qq.com/tcb/invokecloudfunction"
)
//InvokeCloudFunctionRes 云函数调用返回结果
// InvokeCloudFunctionRes 云函数调用返回结果
type InvokeCloudFunctionRes struct {
util.CommonError
RespData string `json:"resp_data"` //云函数返回的buffer
RespData string `json:"resp_data"` // 云函数返回的buffer
}
//InvokeCloudFunction 云函数调用
// 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()

209
miniprogram/tcb/database.go
View File

@@ -7,191 +7,192 @@ import (
)
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 冲突处理模式 插入
ConflictModeInster ConflictMode = 1
//ConflictModeUpsert 冲突处理模式 更新
// ConflictModeUpsert 冲突处理模式 更新
ConflictModeUpsert ConflictMode = 2
//FileTypeJSON 的合法值 json
// FileTypeJSON 的合法值 json
FileTypeJSON FileType = 1
//FileTypeCsv 的合法值 csv
// FileTypeCsv 的合法值 csv
FileTypeCsv FileType = 2
)
//ConflictMode 冲突处理模式
// ConflictMode 冲突处理模式
type ConflictMode int
//FileType 文件上传和导出的允许文件类型
// FileType 文件上传和导出的允许文件类型
type FileType int
//ValidDirections 合法的direction值
// ValidDirections 合法的direction值
var ValidDirections = []string{"1", "-1", "2dsphere"}
//DatabaseMigrateExportReq 数据库出 请求参数
// 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"` //导出条件
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 数据库导出 返回结果
// DatabaseMigrateExportRes 数据库导出 返回结果
type DatabaseMigrateExportRes struct {
util.CommonError
JobID int64 `json:"job_id"` //导出任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
JobID int64 `json:"job_id"` // 导出任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
}
//DatabaseMigrateImportReq 数据库导入 请求参数
// 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
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 数据库导入 返回结果
// DatabaseMigrateImportRes 数据库导入 返回结果
type DatabaseMigrateImportRes struct {
util.CommonError
JobID int64 `json:"job_id"` //导入任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
JobID int64 `json:"job_id"` // 导入任务ID，可使用数据库迁移进度查询 API 查询导入进度及结果
}
//DatabaseMigrateQueryInfoRes 数据库迁移状态查询
// 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"` //导出文件下载地址
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 变更数据库索引 请求参数
// 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"` //删除索引
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 新增索引
// CreateIndex 新增索引
type CreateIndex struct {
Name string `json:"name,omitempty"` //索引名
Unique bool `json:"unique,omitempty"` //是否唯一
Keys []CreateIndexKey `json:"keys,omitempty"` //索引字段
Name string `json:"name,omitempty"` // 索引名
Unique bool `json:"unique,omitempty"` // 是否唯一
Keys []CreateIndexKey `json:"keys,omitempty"` // 索引字段
}
//CreateIndexKey create index key
// CreateIndexKey create index key
type CreateIndexKey struct {
Name string `json:"name,omitempty"` //字段名
Direction string `json:"direction,omitempty"` //字段排序
Name string `json:"name,omitempty"` // 字段名
Direction string `json:"direction,omitempty"` // 字段排序
}
//DropIndex 删除索引
// DropIndex 删除索引
type DropIndex struct {
Name string `json:"name,omitempty"`
}
//DatabaseCollectionReq 新增/删除集合请求参数
// DatabaseCollectionReq 新增/删除集合请求参数
type DatabaseCollectionReq struct {
Env string `json:"env,omitempty"` //云环境ID
CollectionName string `json:"collection_name,omitempty"` //集合名称
Env string `json:"env,omitempty"` // 云环境ID
CollectionName string `json:"collection_name,omitempty"` // 集合名称
}
//DatabaseCollectionGetReq 获取特定云环境下集合信息请求
// DatabaseCollectionGetReq 获取特定云环境下集合信息请求
type DatabaseCollectionGetReq struct {
Env string `json:"env,omitempty"` //云环境ID
Limit int64 `json:"limit,omitempty"` //获取数量限制
Offset int64 `json:"offset,omitempty"` //偏移量
Env string `json:"env,omitempty"` // 云环境ID
Limit int64 `json:"limit,omitempty"` // 获取数量限制
Offset int64 `json:"offset,omitempty"` // 偏移量
}
//DatabaseCollectionGetRes 获取特定云环境下集合信息结果
// DatabaseCollectionGetRes 获取特定云环境下集合信息结果
type DatabaseCollectionGetRes struct {
util.CommonError
Pager struct {
Limit int64 `json:"limit"` //单次查询限制
Offset int64 `json:"offset"` //偏移量
Total int64 `json:"total"` //符合查询条件的记录总数
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"` //索引占用大小，单位：字节
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 数据库插入/删除/更新/查询/统计记录请求参数
// DatabaseReq 数据库插入/删除/更新/查询/统计记录请求参数
type DatabaseReq struct {
Env string `json:"env,omitempty"` //云环境ID
Query string `json:"query,omitempty"` //数据库操作语句
Env string `json:"env,omitempty"` // 云环境ID
Query string `json:"query,omitempty"` // 数据库操作语句
}
//DatabaseAddRes 数据库插入记录返回结果
// DatabaseAddRes 数据库插入记录返回结果
type DatabaseAddRes struct {
util.CommonError
IDList []string `json:"id_list"` //插入成功的数据集合主键_id。
IDList []string `json:"id_list"` // 插入成功的数据集合主键_id。
}
//DatabaseDeleteRes 数据库删除记录返回结果
// DatabaseDeleteRes 数据库删除记录返回结果
type DatabaseDeleteRes struct {
util.CommonError
Deleted int64 `json:"deleted"` //删除记录数量
Deleted int64 `json:"deleted"` // 删除记录数量
}
//DatabaseUpdateRes 数据库更新记录返回结果
// DatabaseUpdateRes 数据库更新记录返回结果
type DatabaseUpdateRes struct {
util.CommonError
Matched int64 `json:"matched"` //更新条件匹配到的结果数
Modified int64 `json:"modified"` //修改的记录数，注意：使用set操作新插入的数据不计入修改数目
Matched int64 `json:"matched"` // 更新条件匹配到的结果数
Modified int64 `json:"modified"` // 修改的记录数，注意：使用set操作新插入的数据不计入修改数目
ID string `json:"id"`
}
//DatabaseQueryRes 数据库查询记录 返回结果
// DatabaseQueryRes 数据库查询记录 返回结果
type DatabaseQueryRes struct {
util.CommonError
Pager struct {
Limit int64 `json:"limit"` //单次查询限制
Offset int64 `json:"offset"` //偏移量
Total int64 `json:"total"` //符合查询条件的记录总数
Limit int64 `json:"limit"` // 单次查询限制
Offset int64 `json:"offset"` // 偏移量
Total int64 `json:"total"` // 符合查询条件的记录总数
} `json:"pager"`
Data []string `json:"data"`
}
//DatabaseCountRes 统计集合记录数或统计查询语句对应的结果记录数 返回结果
// DatabaseCountRes 统计集合记录数或统计查询语句对应的结果记录数 返回结果
type DatabaseCountRes struct {
util.CommonError
Count int64 `json:"count"` //记录数量
Count int64 `json:"count"` // 记录数量
}
//DatabaseMigrateImport 数据库导入
// 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()
@@ -208,7 +209,8 @@ func (tcb *Tcb) DatabaseMigrateImport(req *DatabaseMigrateImportReq) (*DatabaseM
return databaseMigrateImportRes, err
}
//DatabaseMigrateExport 数据库导出
// 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()
@@ -225,7 +227,8 @@ func (tcb *Tcb) DatabaseMigrateExport(req *DatabaseMigrateExportReq) (*DatabaseM
return databaseMigrateExportRes, err
}
//DatabaseMigrateQueryInfo 数据库迁移状态查询
// 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()
@@ -245,8 +248,8 @@ func (tcb *Tcb) DatabaseMigrateQueryInfo(env string, jobID int64) (*DatabaseMigr
return databaseMigrateQueryInfoRes, err
}
//UpdateIndex 变更数据库索引
//https://developers.weixin.qq.com/miniprogram/dev/wxcloud/reference-http-api/database/updateIndex.html
// 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 {
@@ -260,7 +263,8 @@ func (tcb *Tcb) UpdateIndex(req *UpdateIndexReq) error {
return util.DecodeWithCommonError(response, "UpdateIndex")
}
//DatabaseCollectionAdd 新增集合
// 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()
@@ -278,7 +282,8 @@ func (tcb *Tcb) DatabaseCollectionAdd(env, collectionName string) error {
return util.DecodeWithCommonError(response, "DatabaseCollectionAdd")
}
//DatabaseCollectionDelete 删除集合
// 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()
@@ -296,7 +301,8 @@ func (tcb *Tcb) DatabaseCollectionDelete(env, collectionName string) error {
return util.DecodeWithCommonError(response, "DatabaseCollectionDelete")
}
//DatabaseCollectionGet 获取特定云环境下集合信息
// 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()
@@ -317,7 +323,8 @@ func (tcb *Tcb) DatabaseCollectionGet(env string, limit, offset int64) (*Databas
return databaseCollectionGetRes, err
}
//DatabaseAdd 数据库插入记录
// 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()
@@ -337,7 +344,8 @@ func (tcb *Tcb) DatabaseAdd(env, query string) (*DatabaseAddRes, error) {
return databaseAddRes, err
}
//DatabaseDelete 数据库插入记录
// 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()
@@ -357,7 +365,8 @@ func (tcb *Tcb) DatabaseDelete(env, query string) (*DatabaseDeleteRes, error) {
return databaseDeleteRes, err
}
//DatabaseUpdate 数据库插入记录
// 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()
@@ -377,7 +386,8 @@ func (tcb *Tcb) DatabaseUpdate(env, query string) (*DatabaseUpdateRes, error) {
return databaseUpdateRes, err
}
//DatabaseQuery 数据库查询记录
// 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()
@@ -397,7 +407,8 @@ func (tcb *Tcb) DatabaseQuery(env, query string) (*DatabaseQueryRes, error) {
return databaseQueryRes, err
}
//DatabaseCount 统计集合记录数或统计查询语句对应的结果记录数
// 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()

51
miniprogram/tcb/file.go
View File

@@ -7,60 +7,60 @@ import (
)
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 上传文件请求值
// UploadFileReq 上传文件请求值
type UploadFileReq struct {
Env string `json:"env,omitempty"`
Path string `json:"path,omitempty"`
}
//UploadFileRes 上传文件返回结果
// 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
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 上传文件请求值
// BatchDownloadFileReq 上传文件请求值
type BatchDownloadFileReq struct {
Env string `json:"env,omitempty"`
FileList []*DownloadFile `json:"file_list,omitempty"`
}
//DownloadFile 文件信息
// DownloadFile 文件信息
type DownloadFile struct {
FileID string `json:"fileid"` //文件ID
MaxAge int64 `json:"max_age"` //下载链接有效期
FileID string `json:"fileid"` // 文件ID
MaxAge int64 `json:"max_age"` // 下载链接有效期
}
//BatchDownloadFileRes 上传文件返回结果
// 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"` //该文件错误信息
FileID string `json:"file_id"` // 文件ID
DownloadURL string `json:"download_url"` // 下载链接
Status int64 `json:"status"` // 状态码
ErrMsg string `json:"errmsg"` // 该文件错误信息
} `json:"file_list"`
}
//BatchDeleteFileReq 批量删除文件请求参数
// BatchDeleteFileReq 批量删除文件请求参数
type BatchDeleteFileReq struct {
Env string `json:"env,omitempty"`
FileIDList []string `json:"fileid_list,omitempty"`
}
//BatchDeleteFileRes 批量删除文件返回结果
// BatchDeleteFileRes 批量删除文件返回结果
type BatchDeleteFileRes struct {
util.CommonError
DeleteList []struct {
@@ -70,7 +70,8 @@ type BatchDeleteFileRes struct {
} `json:"delete_list"`
}
//UploadFile 上传文件
// 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()
@@ -91,7 +92,8 @@ func (tcb *Tcb) UploadFile(env, path string) (*UploadFileRes, error) {
return uploadFileRes, err
}
//BatchDownloadFile 获取文件下载链接
// 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()
@@ -112,7 +114,8 @@ func (tcb *Tcb) BatchDownloadFile(env string, fileList []*DownloadFile) (*BatchD
return batchDownloadFileRes, err
}
//BatchDeleteFile 批量删除文件
// 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()

4
miniprogram/tcb/tcb.go
View File

@@ -2,12 +2,12 @@ package tcb
import "github.com/silenceper/wechat/v2/miniprogram/context"
//Tcb Tencent Cloud Base
// Tcb Tencent Cloud Base
type Tcb struct {
*context.Context
}
//NewTcb new Tencent Cloud Base
// NewTcb new Tencent Cloud Base
func NewTcb(context *context.Context) *Tcb {
return &Tcb{
context,

52
miniprogram/urllink/query.go Normal file
View File

@@ -0,0 +1,52 @@
package urllink
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const queryURL = "https://api.weixin.qq.com/wxa/query_urllink"
// ULQueryResult 返回的结果
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-link/urllink.query.html 返回值
type ULQueryResult struct {
util.CommonError
URLLinkInfo struct {
Appid string `json:"appid"`
Path string `json:"path"`
Query string `json:"query"`
CreateTime int64 `json:"create_time"`
ExpireTime int64 `json:"expire_time"`
EnvVersion string `json:"env_version"`
CloudBase struct {
Env string `json:"env"`
Domain string `json:"domain"`
Path string `json:"path"`
Query string `json:"query"`
ResourceAppid string `json:"resource_appid"`
} `json:"cloud_base"`
} `json:"url_link_info"`
VisitOpenid string `json:"visit_openid"`
}
// Query 查询小程序 url_link 配置。
func (u *URLLink) Query(urlLink string) (*ULQueryResult, error) {
accessToken, err := u.GetAccessToken()
if err != nil {
return nil, err
}
uri := fmt.Sprintf("%s?access_token=%s", queryURL, accessToken)
response, err := util.PostJSON(uri, map[string]string{"url_link": urlLink})
if err != nil {
return nil, err
}
var resp ULQueryResult
err = util.DecodeWithError(response, &resp, "URLLink.Query")
if err != nil {
return nil, err
}
return &resp, nil
}

72
miniprogram/urllink/urllink.go Normal file
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
}

70
miniprogram/urlscheme/query.go Normal file
View File

@@ -0,0 +1,70 @@
package urlscheme
import (
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
querySchemeURL = "https://api.weixin.qq.com/wxa/queryscheme?access_token=%s"
)
// QueryScheme 获取小程序访问scheme
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.query.html#参数
type QueryScheme struct {
// 小程序 scheme 码
Scheme string `json:"scheme"`
}
// SchemeInfo scheme 配置
type SchemeInfo struct {
// 小程序 appid。
AppID string `json:"appid"`
// 小程序页面路径。
Path string `json:"path"`
// 小程序页面query。
Query string `json:"query"`
// 创建时间，为 Unix 时间戳。
CreateTime int64 `json:"create_time"`
// 到期失效时间，为 Unix 时间戳，0 表示永久生效
ExpireTime int64 `json:"expire_time"`
// 要打开的小程序版本。正式版为"release"，体验版为"trial"，开发版为"develop"。
EnvVersion EnvVersion `json:"env_version"`
}
// resQueryScheme 返回结构体
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.query.html#参数
type resQueryScheme struct {
// 通用错误
*util.CommonError
// scheme 配置
SchemeInfo SchemeInfo `json:"scheme_info"`
// 访问该链接的openid，没有用户访问过则为空字符串
VisitOpenid string `json:"visit_openid"`
}
// QueryScheme 查询小程序 scheme 码
func (u *URLScheme) QueryScheme(querySchemeParams QueryScheme) (schemeInfo SchemeInfo, visitOpenid string, err error) {
var accessToken string
accessToken, err = u.GetAccessToken()
if err != nil {
return
}
urlStr := fmt.Sprintf(querySchemeURL, accessToken)
var response []byte
response, err = util.PostJSON(urlStr, querySchemeParams)
if err != nil {
return
}
// 使用通用方法返回错误
var res resQueryScheme
err = util.DecodeWithError(response, &res, "QueryScheme")
if err != nil {
return
}
return res.SchemeInfo, res.VisitOpenid, nil
}

85
miniprogram/urlscheme/urlscheme.go Normal file
View File

@@ -0,0 +1,85 @@
package urlscheme
import (
"fmt"
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
// URLScheme 小程序 URL Scheme
type URLScheme struct {
*context.Context
}
// NewURLScheme 实例化
func NewURLScheme(ctx *context.Context) *URLScheme {
return &URLScheme{Context: ctx}
}
const generateURL = "https://api.weixin.qq.com/wxa/generatescheme"
// TExpireType 失效类型 (指定时间戳/指定间隔)
type TExpireType int
// EnvVersion 要打开的小程序版本
type EnvVersion string
const (
// ExpireTypeTime 指定时间戳后失效
ExpireTypeTime TExpireType = 0
// ExpireTypeInterval 间隔指定天数后失效
ExpireTypeInterval TExpireType = 1
// EnvVersionRelease 正式版为"release"
EnvVersionRelease EnvVersion = "release"
// EnvVersionTrial 体验版为"trial"
EnvVersionTrial EnvVersion = "trial"
// EnvVersionDevelop 开发版为"develop"
EnvVersionDevelop EnvVersion = "develop"
)
// JumpWxa 跳转到的目标小程序信息
type JumpWxa struct {
Path string `json:"path"`
Query string `json:"query"`
// envVersion 要打开的小程序版本。正式版为 "release"，体验版为 "trial"，开发版为 "develop"
EnvVersion EnvVersion `json:"env_version,omitempty"`
}
// USParams 请求参数
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.generate.html#请求参数
type USParams struct {
JumpWxa *JumpWxa `json:"jump_wxa"`
ExpireType TExpireType `json:"expire_type"`
ExpireTime int64 `json:"expire_time"`
ExpireInterval int `json:"expire_interval"`
}
// USResult 返回的结果
// https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/url-scheme/urlscheme.generate.html#返回值
type USResult struct {
util.CommonError
OpenLink string `json:"openlink"`
}
// Generate 生成url link
func (u *URLScheme) Generate(params *USParams) (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 USResult
err = util.DecodeWithError(response, &resp, "URLScheme.Generate")
if err != nil {
return "", err
}
return resp.OpenLink, nil
}

134
miniprogram/virtualpayment/constant.go Normal file
View File

@@ -0,0 +1,134 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
package virtualpayment
const (
// EnvProduction 环境 0-正式环境 1-沙箱环境
EnvProduction Env = 0
// EnvSandbox 环境 0-正式环境 1-沙箱环境
EnvSandbox Env = 1
)
const (
// Success 错误码 0、成功
Success ErrCode = 0
// SystemError 错误码 -1、系统错误
SystemError ErrCode = -1
// OpenIDError 错误码 268490001、openid 错误
OpenIDError ErrCode = 268490001
// RequestParamError 错误码 268490002、请求参数字段错误，具体看 errmsg
RequestParamError ErrCode = 268490002
// SignError 错误码 268490003、签名错误
SignError ErrCode = 268490003
// RepeatOperationError 错误码 268490004、重复操作（赠送和代币支付相关接口会返回，表示之前的操作已经成功）
RepeatOperationError ErrCode = 268490004
// OrderRefundedError 错误码 268490005、订单已经通过 cancel_currency_pay 接口退款，不支持再退款
OrderRefundedError ErrCode = 268490005
// InsufficientBalanceError 错误码 268490006、代币的退款/支付操作金额不足
InsufficientBalanceError ErrCode = 268490006
// SensitiveContentError 错误码 268490007、图片或文字存在敏感内容，禁止使用
SensitiveContentError ErrCode = 268490007
// TokenNotPublishedError 错误码 268490008、代币未发布，不允许进行代币操作
TokenNotPublishedError ErrCode = 268490008
// SessionKeyExpiredError 错误码 268490009、用户 session_key 不存在或已过期，请重新登录
SessionKeyExpiredError ErrCode = 268490009
// BillGeneratingError 错误码 268490011、账单数据生成中，请稍后调用本接口获取
BillGeneratingError ErrCode = 268490011
)
const (
// OrderStatusInit 订单状态 当前状态 0-订单初始化（未创建成功，不可用于支付）
OrderStatusInit OrderStatus = 0
// OrderStatusCreated 订单状态 当前状态 1-订单创建成功
OrderStatusCreated OrderStatus = 1
// OrderStatusPaid 订单状态 当前状态 2-订单已经支付，待发货
OrderStatusPaid OrderStatus = 2
// OrderStatusDelivering 订单状态 当前状态 3-订单发货中
OrderStatusDelivering OrderStatus = 3
// OrderStatusDelivered 订单状态 当前状态 4-订单已发货
OrderStatusDelivered OrderStatus = 4
// OrderStatusRefunded 订单状态 当前状态 5-订单已经退款
OrderStatusRefunded OrderStatus = 5
// OrderStatusClosed 订单状态 当前状态 6-订单已经关闭（不可再使用）
OrderStatusClosed OrderStatus = 6
// OrderStatusRefundFailed 订单状态 当前状态 7-订单退款失败
OrderStatusRefundFailed OrderStatus = 7
)
const (
// baseSite 基础网址
baseSite = "https://api.weixin.qq.com"
// queryUserBalance 查询虚拟支付余额
queryUserBalance = "/xpay/query_user_balance"
// currencyPay 扣减代币（一般用于代币支付）
currencyPay = "/xpay/currency_pay"
// queryOrder 查询创建的订单（现金单，非代币单）
queryOrder = "/xpay/query_order"
// cancelCurrencyPay 代币支付退款 (currency_pay 接口的逆操作)
cancelCurrencyPay = "/xpay/cancel_currency_pay"
// notifyProvideGoods 通知已经发货完成（只能通知现金单）,正常通过 xpay_goods_deliver_notify 消息推送返回成功就不需要调用这个 api 接口。这个接口用于异常情况推送不成功时手动将单改成已发货状态
notifyProvideGoods = "/xpay/notify_provide_goods"
// presentCurrency 代币赠送接口，由于目前不支付按单号查赠送单的功能，所以当需要赠送的时候可以一直重试到返回 0 或者返回 268490004（重复操作）为止
presentCurrency = "/xpay/present_currency"
// downloadBill 下载账单
downloadBill = "/xpay/download_bill"
// refundOrder 退款 对使用 jsapi 接口下的单进行退款
refundOrder = "/xpay/refund_order"
// createWithdrawOrder 创建提现单
createWithdrawOrder = "/xpay/create_withdraw_order"
// queryWithdrawOrder 查询提现单
queryWithdrawOrder = "/xpay/query_withdraw_order"
// startUploadGoods 启动批量上传道具任务
startUploadGoods = "/xpay/start_upload_goods"
// queryUploadGoods 查询批量上传道具任务状态
queryUploadGoods = "/xpay/query_upload_goods"
// startPublishGoods 启动批量发布道具任务
startPublishGoods = "/xpay/start_publish_goods"
// queryPublishGoods 查询批量发布道具任务状态
queryPublishGoods = "/xpay/query_publish_goods"
)
const (
// signature user mode signature
signature = "signature"
// paySignature payment signature
paySignature = "pay_sig"
// accessToken access_token authorization tokens
accessToken = "access_token"
// EmptyString empty string
EmptyString = ""
)

32
miniprogram/virtualpayment/doc.go Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
// Package virtualpayment mini program virtual payment
package virtualpayment
import (
"github.com/silenceper/wechat/v2/miniprogram/context"
)
// NewVirtualPayment 实例化小程序虚拟支付 API
func NewVirtualPayment(ctx *context.Context) *VirtualPayment {
return &VirtualPayment{
ctx: ctx,
}
}

427
miniprogram/virtualpayment/domain.go Normal file
View File

@@ -0,0 +1,427 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
package virtualpayment
import (
"github.com/silenceper/wechat/v2/miniprogram/context"
"github.com/silenceper/wechat/v2/util"
)
// VirtualPayment mini program virtual payment
// https://developers.weixin.qq.com/miniprogram/dev/platform-capabilities/industry/virtual-payment.html#_2-3-%E6%9C%8D%E5%8A%A1%E5%99%A8API
type VirtualPayment struct {
ctx *context.Context
sessionKey string
}
// Env Environment 0 - Production environment 1 - Sandbox environment
type Env int
// ErrCode error code
type ErrCode int
// OrderStatus 订单状态
type OrderStatus int
// CommonRequest common request parameters
type CommonRequest struct {
OpenID string `json:"openid"` // The user's openID
Env Env `json:"env"` // Environment 0 - Production environment 1 - Sandbox environment
}
// PaymentRequest payment request parameters
type PaymentRequest struct {
SignData string `json:"sign_data"` // 具体支付参数见 signData, 该参数需以 string 形式传递，例如 signData: '{"offerId":"123","buyQuantity":1,"env":0,"currencyType":"CNY","platform":"android","productId":"testproductId","goodsPrice":10,"outTradeNo":"xxxxxx","attach":"testdata"}'
Mode string `json:"mode"` // 支付模式，枚举值：short_series_goods: 道具直购，short_series_coin: 代币充值
PaySig string `json:"pay_sig"` // 支付签名，具体生成方式见下方说明
Signature string `json:"signature"` // 用户态签名，具体生成方式见下方说明
}
// SignData 签名数据
type SignData struct {
OfferID string `json:"offerId"` // 在米大师侧申请的应用 id, mp-支付基础配置中的 offerid
BuyQuantity int `json:"buyQuantity"` // 购买数量
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
CurrencyType string `json:"currencyType"` // 币种 默认值：CNY 人民币
Platform string `json:"platform,omitempty"` // 申请接入时的平台，platform 与应用 id 有关 默认值：android 安卓平台
ProductID string `json:"productId,omitempty"` // 道具 ID, **该字段仅 mode=short_series_goods 时可用**
GoodsPrice int `json:"goodsPrice"` // 道具单价 (分), **该字段仅 mode=short_series_goods 时可用**, 用来校验价格与后台道具价格是否一致，避免用户在业务商城页看到的价格与实际价格不一致导致投诉
OutTradeNo string `json:"outTradeNo"` // 业务订单号，每个订单号只能使用一次，重复使用会失败 (极端情况不保证唯一，不建议业务强依赖唯一性). 要求 8-32 个字符内，只能是数字、大小写字母、符号 _-|*@组成，不能以下划线 (_) 开头
Attach string `json:"attach"` // 透传数据，发货通知时会透传给开发者
}
// QueryUserBalanceRequest 查询用户代币余额，请求参数
// 1. 需要用户态签名与支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type QueryUserBalanceRequest struct {
CommonRequest
UserIP string `json:"user_ip"` // 用户 ip，例如:1.1.1.1
}
// QueryUserBalanceResponse 查询虚拟支付余额 响应参数
type QueryUserBalanceResponse struct {
util.CommonError
Balance int `json:"balance"` // 代币总余额，包括有价和赠送部分
PresentBalance int `json:"present_balance"` // 赠送账户的代币余额
SumSave int `json:"sum_save"` // 累计有价货币充值数量
SumPresent int `json:"sum_present"` // 累计赠送无价货币数量
SumBalance int `json:"sum_balance"` // 历史总增加的代币金额
SumCost int `json:"sum_cost"` // 历史总消耗代币金额
FirstSaveFlag int `json:"first_save_flag"` // 是否满足首充活动标记。0:不满足。1:满足
}
// CurrencyPayRequest 扣减代币（一般用于代币支付）
// 1. 需要用户态签名与支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type CurrencyPayRequest struct {
CommonRequest
UserIP string `json:"user_ip"` // 用户 ip，例如：1.1.1.1
Amount int `json:"amount"` // 支付的代币数量
OrderID string `json:"order_id"` // 商户订单号，需要保证唯一性
PayItem string `json:"payitem"` // 物品信息。记录到账户流水中。如:[{"productid":"物品 id", "unit_price": 单价，"quantity": 数量}]
Remark string `json:"remark"` // 备注信息。需要在账单中展示
DeviceType string `json:"device_type"` // 平台类型 1-安卓 2-苹果
}
// PayItem 物品信息
type PayItem struct {
ProductID string `json:"productid"` // 物品 id
UnitPrice int `json:"unit_price"` // 单价
Quantity int `json:"quantity"` // 数量
}
// CurrencyPayResponse 扣减代币（一般用于代币支付）响应参数
type CurrencyPayResponse struct {
util.CommonError
OrderID string `json:"order_id"` // 商户订单号
Balance int `json:"balance"` // 总余额，包括有价和赠送部分
UsedPresentAmount int `json:"used_present_amount"` // 使用赠送部分的代币数量
}
// QueryOrderRequest 查询创建的订单（现金单，非代币单），请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type QueryOrderRequest struct {
CommonRequest
OrderID string `json:"order_id,omitempty"` // 商户订单号 创建的订单号
WxOrderID string `json:"wx_order_id,omitempty"` // 微信内部单号 (与 order_id 二选一)
}
// OrderItem 订单信息
type OrderItem struct {
OrderID string `json:"order_id"` // 商户订单号
CreateTime int64 `json:"create_time"` // 订单创建时间
UpdateTime int64 `json:"update_time"` // 订单更新时间
Status OrderStatus `json:"status"` // 订单状态 当前状态 0-订单初始化（未创建成功，不可用于支付）1-订单创建成功 2-订单已经支付，待发货 3-订单发货中 4-订单已发货 5-订单已经退款 6-订单已经关闭（不可再使用）7-订单退款失败
BizType int `json:"biz_type"` // 业务类型 0-短剧
OrderFee int `json:"order_fee"` // 订单金额，单位：分
CouponFee int `json:"coupon_fee"` // 优惠金额，单位：分
PaidFee int `json:"paid_fee"` // 用户支付金额，单位：分
OrderType int `json:"order_type"` // 订单类型 0-支付单 1-退款单
RefundFee int `json:"refund_fee"` // 当类型为退款单时表示退款金额，单位分
PaidTime int64 `json:"paid_time"` // 支付/退款时间，unix秒级时间戳
ProvideTime int64 `json:"provide_time"` // 发货时间，unix 秒级时间戳
BizMeta string `json:"biz_meta"` // 业务自定义数据 订单创建时传的信息
EnvType int `json:"env_type"` // 环境类型 1-现网 2-沙箱
Token string `json:"token"` // 下单时米大师返回的 token
LeftFee int `json:"left_fee"` // 支付单类型时表示此单经过退款还剩余的金额，单位：分
WxOrderID string `json:"wx_order_id"` // 微信内部单号
ChannelOrderID string `json:"channel_order_id"` // 渠道订单号，为用户微信支付详情页面上的商户单号
WxPayOrderID string `json:"wxpay_order_id"` // 微信支付交易单号，为用户微信支付详情页面上的交易单号
}
// QueryOrderResponse 查询创建的订单（现金单，非代币单）响应参数
type QueryOrderResponse struct {
util.CommonError
Order *OrderItem `json:"order"` // 订单信息
}
// CancelCurrencyPayRequest 取消订单（现金单，非代币单），请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type CancelCurrencyPayRequest struct {
CommonRequest
UserIP string `json:"user_ip"` // 用户 ip，例如：1.1.1.1
PayOrderID string `json:"pay_order_id"` // 支付单号 代币支付 (调用 currency_pay 接口时) 时传的 order_id
OrderID string `json:"order_id"` // 本次退款单的单号
Amount int `json:"amount"` // 退款金额
DeviceType int `json:"device_type"` // 平台类型 1-安卓 2-苹果
}
// CancelCurrencyPayResponse 取消订单（现金单，非代币单）响应参数
type CancelCurrencyPayResponse struct {
util.CommonError
OrderID string `json:"order_id"` // 退款订单号
}
// NotifyProvideGoodsRequest 通知发货，请求参数
// 通知已经发货完成（只能通知现金单）,正常通过 xpay_goods_deliver_notify 消息推送返回成功就不需要调用这个 api 接口。这个接口用于异常情况推送不成功时手动将单改成已发货状态
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type NotifyProvideGoodsRequest struct {
OrderID string `json:"order_id,omitempty"` // 商户订单号 下单时传的单号
WxOrderID string `json:"wx_order_id,omitempty"` // 微信内部单号 (与 order_id 二选一)
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
}
// NotifyProvideGoodsResponse 通知发货响应参数
type NotifyProvideGoodsResponse struct {
util.CommonError
}
// PresentCurrencyRequest 赠送代币，请求参数
// 代币赠送接口，由于目前不支付按单号查赠送单的功能，所以当需要赠送的时候可以一直重试到返回 0 或者返回 268490004（重复操作）为止
// 1. 需要用户态签名与支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type PresentCurrencyRequest struct {
CommonRequest
OrderID string `json:"order_id"` // 赠送单号，商户订单号，需要保证唯一性
Amount int `json:"amount"` // 赠送的代币数量
DeviceType string `json:"device_type"` // 平台类型 1-安卓 2-苹果
}
// PresentCurrencyResponse 赠送代币响应参数
type PresentCurrencyResponse struct {
util.CommonError
Balance int `json:"balance"` // 赠送后用户的代币余额
OrderID string `json:"order_id"` // 赠送单号
PresentBalance int `json:"present_balance"` // 用户收到的总赠送金额
}
// DownloadBillRequest 下载账单，请求参数
// 用于下载小程序账单，第一次调用触发生成下载 url，可以间隔轮训来获取最终生成的下载 url。账单中金额相关字段是以分为单位。
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type DownloadBillRequest struct {
BeginDs string `json:"begin_ds"` // 账单开始日期，格式为 yyyymmdd 起始时间（如 20230801）
EndDs string `json:"end_ds"` // 账单结束日期，格式为 yyyymmdd 结束时间（如 20230801）
}
// DownloadBillResponse 下载账单响应参数
type DownloadBillResponse struct {
util.CommonError
URL string `json:"url"` // 账单下载地址
}
// RefundOrderRequest 退款，请求参数
// 对使用 jsapi 接口下的单进行退款
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type RefundOrderRequest struct {
CommonRequest
OrderID string `json:"order_id"` // 商户订单号，需要保证唯一性
WxOrderID string `json:"wx_order_id"` // 微信内部单号 (与 order_id 二选一)
RefundOrderID string `json:"refund_order_id"` // 退款单号，本次退款时需要传的单号，长度为 [8,32]，字符只允许使用字母、数字、'_'、'-'
LeftFee int `json:"left_fee"` // 退款金额，单位：分 当前单剩余可退金额，单位分，可以通过调用 query_order 接口查到
RefundFee int `json:"refund_fee"` // 退款金额，单位：分 需要 (0,left_fee] 之间
BizMeta string `json:"biz_meta"` // 商家自定义数据，传入后可在 query_order 接口查询时原样返回，长度需要 [0,1024]
RefundReason string `json:"refund_reason"` // 退款原因，当前仅支持以下值 0-暂无描述 1-产品问题，影响使用或效果不佳 2-售后问题，无法满足需求 3-意愿问题，用户主动退款 4-价格问题 5:其他原因
ReqFrom string `json:"req_from"` // 退款来源，当前仅支持以下值 1-人工客服退款，即用户电话给客服，由客服发起退款流程 2-用户自己发起退款流程 3-其它
}
// RefundOrderResponse 退款响应参数
type RefundOrderResponse struct {
util.CommonError
RefundOrderID string `json:"refund_order_id"` // 退款单号
RefundWxOrderID string `json:"refund_wx_order_id"` // 退款单的微信侧单号
PayOrderID string `json:"pay_order_id"` // 该退款单对应的支付单单号
PayWxOrderID string `json:"pay_wx_order_id"` // 该退款单对应的支付单微信侧单号
}
// CreateWithdrawOrderRequest 创建提现单，请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type CreateWithdrawOrderRequest struct {
WithdrawNO string `json:"withdraw_no"` // 提现单单号，长度为 [8,32]，字符只允许使用字母、数字、'_'、'-'
WithdrawAmount string `json:"withdraw_amount"` // 提现的金额，单位元，例如提现 1 分钱请使用 0.01
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
}
// CreateWithdrawOrderResponse 创建提现单响应参数
type CreateWithdrawOrderResponse struct {
util.CommonError
WithdrawNO string `json:"withdraw_no"` // 提现单单号
WxWithdrawNO string `json:"wx_withdraw_no"` // 提现单的微信侧单号
}
// QueryWithdrawOrderRequest 查询提现单，请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type QueryWithdrawOrderRequest struct {
WithdrawNO string `json:"withdraw_no"` // 提现单单号，长度为 [8,32]，字符只允许使用字母、数字、'_'、'-' (与 wx_withdraw_no 二选一)
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
}
// QueryWithdrawOrderResponse 查询提现单响应参数
type QueryWithdrawOrderResponse struct {
util.CommonError
WithdrawNO string `json:"withdraw_no"` // 提现单单号
Status int `json:"status"` // 提现单的微信侧单号 1-创建成功，提现中 2-提现成功 3-提现失败
WithdrawAmount string `json:"withdraw_amount"` // 提现的金额，单位元，例如提现 1 分钱请使用 0.01
WxWithdrawNo string `json:"wx_withdraw_no"` // 提现单的微信侧单号
WithdrawSuccessTimestamp int64 `json:"withdraw_success_timestamp"` // 提现单成功的秒级时间戳，unix 秒级时间戳
CreateTime string `json:"create_time"` // 提现单创建时间
FailReason string `json:"failReason"` // 提现失败的原因
}
// StartUploadGoodsRequest 启动批量上传道具任务，请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type StartUploadGoodsRequest struct {
UploadItem []*UploadItem `json:"upload_item"` // 道具信息
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
}
// UploadItem 道具信息
type UploadItem struct {
ID string `json:"id"` // 道具 id，长度 (0,64]，字符只允许使用字母、数字、'_'、'-'
Name string `json:"name"` // 道具名称，长度 (0,1024]
Price int `json:"price"` // 道具单价，单位分，需要大于 0
Remark string `json:"remark"` // 道具备注，长度 (0,1024]
ItemURL string `json:"item_url"` // 道具图片的 url 地址，当前仅支持 jpg,png 等格式
UploadStatus int `json:"upload_status,omitempty"` // 上传状态 0-上传中 1-id 已经存在 2-上传成功 3-上传失败
ErrMsg string `json:"errmsg,omitempty"` // 上传失败的原因
}
// StartUploadGoodsResponse 启动批量上传道具任务响应参数
type StartUploadGoodsResponse struct {
util.CommonError
}
// QueryUploadGoodsRequest 查询批量上传道具任务，请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type QueryUploadGoodsRequest struct {
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
}
// QueryUploadGoodsResponse 查询批量上传道具任务响应参数
type QueryUploadGoodsResponse struct {
util.CommonError
UploadItem []*UploadItem `json:"upload_item"` // 道具信息列表
Status int `json:"status"` // 任务状态 0-无任务在运行 1-任务运行中 2-上传失败或部分失败（上传任务已经完成）3-上传成功
}
// StartPublishGoodsRequest 启动批量发布道具任务，请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type StartPublishGoodsRequest struct {
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
PublishItem []*PublishItem `json:"publish_item"` // 道具信息 发布的商品列表
}
// PublishItem 道具信息
type PublishItem struct {
ID string `json:"id"` // 道具 id，添加到开发环境时传的道具 id，长度 (0,64]，字符只允许使用字母、数字、'_'、'-'
PublishStatus int `json:"publish_status,omitempty"` // 发布状态 0-上传中 1-id 已经存在 2-发布成功 3-发布失败
ErrMsg string `json:"errmsg,omitempty"` // 发布失败的原因
}
// StartPublishGoodsResponse 启动批量发布道具任务响应参数
type StartPublishGoodsResponse struct {
util.CommonError
}
// QueryPublishGoodsRequest 查询批量发布道具任务，请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type QueryPublishGoodsRequest struct {
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
}
// QueryPublishGoodsResponse 查询批量发布道具任务响应参数
type QueryPublishGoodsResponse struct {
util.CommonError
PublishItem []*PublishItem `json:"publish_item"` // 道具信息列表
Status int `json:"status"` // 任务状态 0-无任务在运行 1-任务运行中 2-上传失败或部分失败（上传任务已经完成）3-上传成功
}
// AsyncXPayGoodsDeliverNotifyRequest 异步通知发货，请求参数
// 1. 使用支付签名
// POST，请求参数为 json 字符串，Content-Type 为 application/json
type AsyncXPayGoodsDeliverNotifyRequest struct {
ToUserName string `json:"ToUserName"` // 小程序的原始 ID
FromUserName string `json:"FromUserName"` // 发送方帐号（一个 OpenID）该事件消息的 openid，道具发货场景固定为微信官方的 openid
CreateTime int `json:"CreateTime"` // 消息发送时间（整型）
MsgType string `json:"MsgType"` // 消息类型，此时固定为：event
Event string `json:"Event"` // 事件类型，此时固定为：xpay_goods_deliver_notify
Openid string `json:"openid"` // 用户 openid
OutTradeNo string `json:"OutTradeNo"` // 业务订单号
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
WechatPayInfo *WeChatPayInfo `json:"WechatPayInfo"` // 微信支付订单信息
GoodsInfo *GoodsInfo `json:"GoodsInfo"` // 道具信息
}
// WeChatPayInfo 微信支付信息 非微信支付渠道可能没有
type WeChatPayInfo struct {
MchOrderNo string `json:"MchOrderNo"` // 商户订单号
TransactionID string `json:"TransactionId"` // 微信支付订单号
}
// GoodsInfo 道具参数信息
type GoodsInfo struct {
ProductID string `json:"ProductId"` // 道具 ID
Quantity int `json:"Quantity"` // 数量
OrigPrice int `json:"OrigPrice"` // 物品原始价格（单位：分）
ActualPrice int `json:"ActualPrice"` // 物品实际支付价格（单位：分）
Attach string `json:"Attach"` // 透传信息
}
// AsyncXPayGoodsDeliverNotifyResponse 异步通知发货响应参数
type AsyncXPayGoodsDeliverNotifyResponse struct {
util.CommonError
}
// AsyncXPayCoinPayNotifyRequest 异步通知代币支付推送，请求参数
type AsyncXPayCoinPayNotifyRequest struct {
ToUserName string `json:"ToUserName"` // 小程序的原始 ID
FromUserName string `json:"FromUserName"` // 发送方帐号（一个 OpenID）该事件消息的 openid，道具发货场景固定为微信官方的 openid
CreateTime int `json:"CreateTime"` // 消息发送时间（整型）
MsgType string `json:"MsgType"` // 消息类型，此时固定为：event
Event string `json:"Event"` // 事件类型，此时固定为：xpay_goods_deliver_notify
Openid string `json:"openid"` // 用户 openid
OutTradeNo string `json:"OutTradeNo"` // 业务订单号
Env Env `json:"env"` // 环境 0-正式环境 1-沙箱环境
WechatPayInfo *WeChatPayInfo `json:"WechatPayInfo"` // 微信支付订单信息
CoinInfo *CoinInfo `json:"GoodsInfo"` // 道具信息
}
// CoinInfo 代币信息
type CoinInfo struct {
Quantity int `json:"Quantity"` // 数量
OrigPrice int `json:"OrigPrice"` // 物品原始价格（单位：分）
ActualPrice int `json:"ActualPrice"` // 物品实际支付价格（单位：分）
Attach string `json:"Attach"` // 透传信息
}
// AsyncXPayCoinPayNotifyResponse 异步通知代币支付推送响应参数
type AsyncXPayCoinPayNotifyResponse struct {
util.CommonError
}
// URLParams url parameter
type URLParams struct {
Path string `json:"path"`
AccessToken string `json:"access_token"`
PaySign string `json:"paySign"`
Signature string `json:"signature"`
Content string `json:"content"`
}

516
miniprogram/virtualpayment/virtualpayment.go Normal file
View File

@@ -0,0 +1,516 @@
/*
* Copyright silenceper/wechat Author(https://silenceper.com/wechat/). All Rights Reserved.
*
* 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.
*
* You can obtain one at https://github.com/silenceper/wechat.
*
*/
package virtualpayment
import (
"context"
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"strings"
"github.com/silenceper/wechat/v2/util"
)
// SetSessionKey 设置 sessionKey
func (s *VirtualPayment) SetSessionKey(sessionKey string) {
s.sessionKey = sessionKey
}
// QueryUserBalance 查询虚拟支付余额
func (s *VirtualPayment) QueryUserBalance(ctx context.Context, in *QueryUserBalanceRequest) (out QueryUserBalanceResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: queryUserBalance,
Content: string(jsonByte),
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "QueryUserBalance")
return
}
// CurrencyPay currency pay 扣减代币（一般用于代币支付）
func (s *VirtualPayment) CurrencyPay(ctx context.Context, in *CurrencyPayRequest) (out CurrencyPayResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: currencyPay,
Content: string(jsonByte),
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "CurrencyPay")
return
}
// QueryOrder 查询创建的订单（现金单，非代币单）
func (s *VirtualPayment) QueryOrder(ctx context.Context, in *QueryOrderRequest) (out QueryOrderResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: queryOrder,
Signature: EmptyString,
Content: string(jsonByte),
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "QueryOrder")
return
}
// CancelCurrencyPay 取消订单 代币支付退款 (currency_pay 接口的逆操作)
func (s *VirtualPayment) CancelCurrencyPay(ctx context.Context, in *CancelCurrencyPayRequest) (out CancelCurrencyPayResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: cancelCurrencyPay,
Content: string(jsonByte),
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "CancelCurrencyPay")
return
}
// NotifyProvideGoods 通知发货
// 通知已经发货完成（只能通知现金单）,正常通过 xpay_goods_deliver_notify 消息推送返回成功就不需要调用这个 api 接口。这个接口用于异常情况推送不成功时手动将单改成已发货状态
func (s *VirtualPayment) NotifyProvideGoods(ctx context.Context, in *NotifyProvideGoodsRequest) (out NotifyProvideGoodsResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: notifyProvideGoods,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "NotifyProvideGoods")
return
}
// PresentCurrency 代币赠送接口，由于目前不支付按单号查赠送单的功能，所以当需要赠送的时候可以一直重试到返回 0 或者返回 268490004（重复操作）为止
func (s *VirtualPayment) PresentCurrency(ctx context.Context, in *PresentCurrencyRequest) (out PresentCurrencyResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: presentCurrency,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "PresentCurrency")
return
}
// DownloadBill 下载订单交易账单
func (s *VirtualPayment) DownloadBill(ctx context.Context, in *DownloadBillRequest) (out DownloadBillResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: downloadBill,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "DownloadBill")
return
}
// RefundOrder 退款 对使用 jsapi 接口下的单进行退款
func (s *VirtualPayment) RefundOrder(ctx context.Context, in *RefundOrderRequest) (out RefundOrderResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: refundOrder,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "RefundOrder")
return
}
// CreateWithdrawOrder 创建提现单
func (s *VirtualPayment) CreateWithdrawOrder(ctx context.Context, in *CreateWithdrawOrderRequest) (out CreateWithdrawOrderResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: createWithdrawOrder,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "CreateWithdrawOrder")
return
}
// QueryWithdrawOrder 查询提现单
func (s *VirtualPayment) QueryWithdrawOrder(ctx context.Context, in *QueryWithdrawOrderRequest) (out QueryWithdrawOrderResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: queryWithdrawOrder,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "QueryWithdrawOrder")
return
}
// StartUploadGoods 开始上传商品
func (s *VirtualPayment) StartUploadGoods(ctx context.Context, in *StartUploadGoodsRequest) (out StartUploadGoodsResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: startUploadGoods,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "StartUploadGoods")
return
}
// QueryUploadGoods 查询上传商品
func (s *VirtualPayment) QueryUploadGoods(ctx context.Context, in *QueryUploadGoodsRequest) (out QueryUploadGoodsResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: queryUploadGoods,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "QueryUploadGoods")
return
}
// StartPublishGoods 开始发布商品
func (s *VirtualPayment) StartPublishGoods(ctx context.Context, in *StartPublishGoodsRequest) (out StartPublishGoodsResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: startPublishGoods,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "StartPublishGoods")
return
}
// QueryPublishGoods 查询发布商品
func (s *VirtualPayment) QueryPublishGoods(ctx context.Context, in *QueryPublishGoodsRequest) (out QueryPublishGoodsResponse, err error) {
var jsonByte []byte
if jsonByte, err = json.Marshal(in); err != nil {
return
}
var (
params = URLParams{
Path: queryPublishGoods,
Content: string(jsonByte),
Signature: EmptyString,
}
address string
)
if address, err = s.requestAddress(params); err != nil {
return
}
var response []byte
if response, err = util.PostJSONContext(ctx, address, in); err != nil {
return
}
// 使用通用方法返回错误
err = util.DecodeWithError(response, &out, "QueryPublishGoods")
return
}
// hmacSha256 hmac sha256
func (s *VirtualPayment) hmacSha256(key, data string) string {
h := hmac.New(sha256.New, []byte(key))
h.Write([]byte(data))
return hex.EncodeToString(h.Sum(nil))
}
// PaySign pay sign
func (s *VirtualPayment) PaySign(url, data string) (string, error) {
if strings.TrimSpace(s.ctx.Config.AppKey) == "" {
return "", errors.New("appKey is empty")
}
return s.hmacSha256(s.ctx.Config.AppKey, url+"&"+data), nil
}
// Signature user signature
func (s *VirtualPayment) Signature(data string) (string, error) {
if strings.TrimSpace(s.sessionKey) == "" {
return "", errors.New("sessionKey is empty")
}
return s.hmacSha256(s.sessionKey, data), nil
}
// PaySignature pay sign and signature
func (s *VirtualPayment) PaySignature(url, data string) (paySign, signature string, err error) {
if paySign, err = s.PaySign(url, data); err != nil {
return
}
if signature, err = s.Signature(data); err != nil {
return
}
return
}
// requestURL .组合 URL
func (s *VirtualPayment) requestAddress(params URLParams) (url string, err error) {
switch params.Path {
case queryUserBalance:
case currencyPay:
case cancelCurrencyPay:
if params.PaySign, params.Signature, err = s.PaySignature(params.Path, params.Content); err != nil {
return
}
case queryOrder:
case notifyProvideGoods:
case presentCurrency:
case downloadBill:
case refundOrder:
case createWithdrawOrder:
case queryWithdrawOrder:
case startUploadGoods:
case queryUploadGoods:
case startPublishGoods:
case queryPublishGoods:
if params.PaySign, err = s.PaySign(params.Path, params.Content); err != nil {
return
}
default:
err = errors.New("path is not exist")
return
}
if params.AccessToken, err = s.ctx.GetAccessToken(); err != nil {
return
}
url = baseSite + params.Path + "?" + accessToken + "=" + params.AccessToken
if params.PaySign != EmptyString {
url += "&" + paySignature + "=" + params.PaySign
}
if params.Signature != EmptyString {
url += "&" + signature + "=" + params.Signature
}
return
}