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( `%d`, 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( `%s`, 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) }