Files
yunzerwebsiteallinone/go/services/wechatmini/push.go
T
2026-11-16 17:22:50 +08:00

388 lines
9.9 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package wechatmini
import (
"crypto/rand"
"encoding/json"
"encoding/xml"
"errors"
"fmt"
"math/big"
"strings"
"time"
"server/models"
"server/services/wechatmp"
"github.com/beego/beego/v2/client/orm"
beego "github.com/beego/beego/v2/server/web"
)
const (
DataFormatXML = "xml"
DataFormatJSON = "json"
)
type PushConfig struct {
AppID string
Token string
AESKey string
EncryptMode string
DataFormat string
ReplyText string
}
var ErrPushNotConfigured = errors.New("小程序消息推送未配置")
func pushConfigFromRow(row models.WechatMiniApp) (*PushConfig, error) {
cfg := &PushConfig{
AppID: strings.TrimSpace(row.AppID),
Token: strings.TrimSpace(row.Token),
EncryptMode: strings.TrimSpace(row.EncryptMode),
DataFormat: strings.ToLower(strings.TrimSpace(row.DataFormat)),
ReplyText: strings.TrimSpace(row.PushReply),
}
if cfg.EncryptMode == "" {
cfg.EncryptMode = wechatmp.EncryptModePlain
}
if cfg.DataFormat == "" {
cfg.DataFormat = DataFormatXML
}
if row.AESKey != "" {
plain, err := wechatmp.DecryptSecret(row.AESKey)
if err != nil {
return nil, err
}
cfg.AESKey = plain
}
return cfg, nil
}
func LoadPushConfigs() ([]PushConfig, error) {
var rows []models.WechatMiniApp
_, err := models.Orm.QueryTable(new(models.WechatMiniApp)).
Filter("delete_time__isnull", true).
OrderBy("id").
All(&rows)
if err != nil {
return nil, err
}
list := make([]PushConfig, 0, len(rows))
for _, r := range rows {
if strings.TrimSpace(r.Token) == "" {
continue
}
cfg, cerr := pushConfigFromRow(r)
if cerr != nil {
continue
}
list = append(list, *cfg)
}
return list, nil
}
func LoadPushConfigByAppID(appID string) (*PushConfig, error) {
appID = strings.TrimSpace(appID)
if appID == "" {
return nil, ErrPushNotConfigured
}
var row models.WechatMiniApp
err := models.Orm.QueryTable(new(models.WechatMiniApp)).
Filter("app_id", appID).
Filter("delete_time__isnull", true).
One(&row)
if err != nil {
if err == orm.ErrNoRows {
return nil, ErrPushNotConfigured
}
return nil, err
}
return pushConfigFromRow(row)
}
type SavePushConfigInput struct {
AppID string
Token string
AESKey string
EncryptMode string
DataFormat string
ReplyText string
}
func SavePushConfig(in SavePushConfigInput) error {
appID := strings.TrimSpace(in.AppID)
if appID == "" {
return errors.New("AppID 不能为空")
}
mode := strings.TrimSpace(in.EncryptMode)
switch mode {
case wechatmp.EncryptModePlain, wechatmp.EncryptModeCompatible, wechatmp.EncryptModeSafe:
case "":
mode = wechatmp.EncryptModePlain
default:
return errors.New("加解密方式无效(plain/compatible/safe)")
}
format := strings.ToLower(strings.TrimSpace(in.DataFormat))
switch format {
case DataFormatXML, DataFormatJSON:
case "":
format = DataFormatXML
default:
return errors.New("数据格式无效(xml/json)")
}
token := strings.TrimSpace(in.Token)
if token != "" && (len(token) < 3 || len(token) > 32) {
return errors.New("Token 长度需为 3-32 个字符")
}
var row models.WechatMiniApp
err := models.Orm.QueryTable(new(models.WechatMiniApp)).
Filter("app_id", appID).
Filter("delete_time__isnull", true).
One(&row)
if err != nil {
if err == orm.ErrNoRows {
return errors.New("小程序不存在或已删除")
}
return err
}
aesKey := strings.TrimSpace(in.AESKey)
if aesKey != "" && !wechatmp.IsMasked(aesKey) {
if len(aesKey) != 43 {
return errors.New("EncodingAESKey 长度必须为 43 位")
}
enc, eerr := wechatmp.EncryptSecret(aesKey)
if eerr != nil {
return eerr
}
row.AESKey = enc
}
if token != "" {
row.Token = token
}
row.EncryptMode = mode
row.DataFormat = format
row.PushReply = strings.TrimSpace(in.ReplyText)
now := time.Now()
row.UpdateTime = &now
_, err = models.Orm.Update(&row)
return err
}
func PushCallbackURL() string {
base, _ := beego.AppConfig.String("wechat_mini_callback_base")
if strings.TrimSpace(base) == "" {
base, _ = beego.AppConfig.String("wechat_mp_callback_base")
}
if strings.TrimSpace(base) == "" {
base, _ = beego.AppConfig.String("payment_callback_base")
}
base = strings.TrimRight(strings.TrimSpace(base), "/")
if base == "" {
return "/api/wechat/mini/callback"
}
return base + "/api/wechat/mini/callback"
}
const aesKeyAlphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
func randomString(alphabet string, n int) string {
b := []byte(alphabet)
out := make([]byte, n)
max := big.NewInt(int64(len(b)))
for i := range out {
idx, err := rand.Int(rand.Reader, max)
if err != nil {
out[i] = b[(time.Now().UnixNano()+int64(i))%int64(len(b))]
continue
}
out[i] = b[idx.Int64()]
}
return string(out)
}
func GeneratePushToken() string {
return randomString(aesKeyAlphabet, 24)
}
func GeneratePushAESKey() string {
return randomString(aesKeyAlphabet, 43)
}
type PushMessage struct {
ToUserName string
FromUserName string
CreateTime int64
MsgType string
Content string
Event string
EventKey string
MsgID int64
Encrypt string
MsgSignature string
TimeStamp string
Nonce string
}
func (m *PushMessage) IsEvent() bool { return strings.EqualFold(m.MsgType, "event") }
type pushXML struct {
XMLName struct{} `xml:"xml"`
ToUserName string `xml:"ToUserName"`
FromUserName string `xml:"FromUserName"`
CreateTime int64 `xml:"CreateTime"`
MsgType string `xml:"MsgType"`
Content string `xml:"Content"`
Event string `xml:"Event"`
EventKey string `xml:"EventKey"`
MsgID int64 `xml:"MsgId"`
Encrypt string `xml:"Encrypt"`
MsgSignature string `xml:"MsgSignature"`
TimeStamp string `xml:"TimeStamp"`
Nonce string `xml:"Nonce"`
}
type pushJSON struct {
ToUserName string `json:"ToUserName"`
FromUserName string `json:"FromUserName"`
CreateTime int64 `json:"CreateTime"`
MsgType string `json:"MsgType"`
Content string `json:"Content"`
Event string `json:"Event"`
EventKey string `json:"EventKey"`
MsgID int64 `json:"MsgId"`
Encrypt string `json:"Encrypt"`
MsgSignature string `json:"MsgSignature"`
TimeStamp string `json:"TimeStamp"`
Nonce string `json:"Nonce"`
}
func ParsePushXML(raw string) (*PushMessage, error) {
var p pushXML
if err := xml.Unmarshal([]byte(raw), &p); err != nil {
return nil, fmt.Errorf("解析微信推送消息失败: %w", err)
}
return &PushMessage{
ToUserName: p.ToUserName,
FromUserName: p.FromUserName,
CreateTime: p.CreateTime,
MsgType: p.MsgType,
Content: p.Content,
Event: p.Event,
EventKey: p.EventKey,
MsgID: p.MsgID,
Encrypt: p.Encrypt,
MsgSignature: p.MsgSignature,
TimeStamp: p.TimeStamp,
Nonce: p.Nonce,
}, nil
}
func ParsePushJSON(raw string) (*PushMessage, error) {
var p pushJSON
if err := json.Unmarshal([]byte(raw), &p); err != nil {
return nil, fmt.Errorf("解析微信推送消息失败: %w", err)
}
return &PushMessage{
ToUserName: p.ToUserName,
FromUserName: p.FromUserName,
CreateTime: p.CreateTime,
MsgType: p.MsgType,
Content: p.Content,
Event: p.Event,
EventKey: p.EventKey,
MsgID: p.MsgID,
Encrypt: p.Encrypt,
MsgSignature: p.MsgSignature,
TimeStamp: p.TimeStamp,
Nonce: p.Nonce,
}, nil
}
func DetectPushFormat(raw string) string {
trimmed := strings.TrimSpace(raw)
if strings.HasPrefix(trimmed, "{") {
return DataFormatJSON
}
return DataFormatXML
}
func BuildTextReply(format, toUser, fromUser, content string, timestamp int64) (string, error) {
if format == DataFormatJSON {
payload := map[string]interface{}{
"ToUserName": toUser,
"FromUserName": fromUser,
"CreateTime": timestamp,
"MsgType": "text",
"Content": content,
}
bs, err := json.Marshal(payload)
if err != nil {
return "", err
}
return string(bs), nil
}
esc := strings.NewReplacer("]]>", "]] >")
return fmt.Sprintf(
`<xml><ToUserName><![CDATA[%s]]></ToUserName><FromUserName><![CDATA[%s]]></FromUserName><CreateTime>%d</CreateTime><MsgType><![CDATA[text]]></MsgType><Content><![CDATA[%s]]></Content></xml>`,
esc.Replace(toUser), esc.Replace(fromUser), timestamp, esc.Replace(content)), nil
}
func BuildEncryptedReply(cfg *PushConfig, plainReply, timestamp, nonce, format string) (string, error) {
encrypt, err := wechatmp.EncryptMessage(cfg.AESKey, cfg.AppID, plainReply)
if err != nil {
return "", err
}
sig := wechatmp.MsgSignature(cfg.Token, timestamp, nonce, encrypt)
if format == DataFormatJSON {
payload := map[string]interface{}{
"Encrypt": encrypt,
"MsgSignature": sig,
"TimeStamp": timestamp,
"Nonce": nonce,
}
bs, merr := json.Marshal(payload)
if merr != nil {
return "", merr
}
return string(bs), nil
}
return fmt.Sprintf(
`<xml><Encrypt><![CDATA[%s]]></Encrypt><MsgSignature><![CDATA[%s]]></MsgSignature><TimeStamp>%s</TimeStamp><Nonce><![CDATA[%s]]></Nonce></xml>`,
encrypt, sig, timestamp, nonce), nil
}
func MatchPushConfigBySignature(cfgs []PushConfig, timestamp, nonce, signature string) (*PushConfig, bool) {
for i := range cfgs {
if wechatmp.CheckSignature(cfgs[i].Token, timestamp, nonce, signature) {
return &cfgs[i], true
}
}
return nil, false
}
func MatchPushConfigByMsgSignature(cfgs []PushConfig, timestamp, nonce, encrypt, msgSignature string) (*PushConfig, bool) {
for i := range cfgs {
if wechatmp.CheckMsgSignature(cfgs[i].Token, timestamp, nonce, encrypt, msgSignature) {
return &cfgs[i], true
}
}
return nil, false
}
func DecryptPushMessage(cfg *PushConfig, encrypt string) (string, error) {
return wechatmp.DecryptMessage(cfg.AESKey, cfg.AppID, encrypt)
}
var PushHandler func(cfg *PushConfig, msg *PushMessage) string
func HandlePushMessage(cfg *PushConfig, msg *PushMessage) string {
if PushHandler != nil {
return strings.TrimSpace(PushHandler(cfg, msg))
}
if cfg == nil {
return ""
}
return strings.TrimSpace(cfg.ReplyText)
}