RoServer/RO_Server_Trunk-branch_0.1.39/roserver/gmweb/msg/web_paymsg.go

package msg

import (
	"bytes"
	"crypto"
	"crypto/hmac"
	"crypto/md5"
	"crypto/rsa"
	"crypto/sha1"
	"crypto/x509"
	"database/sql"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"encoding/pem"
	"encoding/xml"
	"fmt"
	"io"
	"math/big"
	"net/http"
	"net/url"
	"rocommon/service"
	"rocommon/socket/mysql"
	"rocommon/util"
	"roserver/baseserver/model"
	gmweb "roserver/gmweb/model"
	selfmodel "roserver/gmweb/model"
	"roserver/serverproto"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
)

// https://blog.csdn.net/chunyouhai5703/article/details/100978656?utm_medium=distribute.pc_relevant.none-task-blog-title-1&spm=1001.2101.3001.4242
type QuickPayNotify struct {
	XMLName xml.Name    `xml:"quicksdk_message"`
	Message QuickTBData `xml:"message"`
}
type QuickTBData struct {
	IsTest       bool    `xml:"is_test"`
	Channel      string  `xml:"channel"`
	ChannelUid   string  `xml:"channel_uid"`
	GameOrder    string  `xml:"game_order"`
	PayTime      string  `xml:"pay_time"`
	Amount       float32 `xml:"amount"`
	Status       int32   `xml:"status"`
	ExtrasParams string  `xml:"extras_params"`
}

/*
<?xml version="1.0" encoding="UTF-8" standalone="no">
<quicksdk_message>
<message>
<is_test>0</is_test>
<channel>8888</channel>
<channel_uid>231845</channel_uid>
<game_order>123456789</game_order>
<order_no>12520160612114220441168433</order_no>
<pay_time>2016-06-12 11:42:20</pay_time>
<amount>1.00</amount>
<status>0</status>
<extras_params>{1}_{2}</extras_params>
</message>
</quicksdk_message>
*/
func WebPayQuickNotify(c *gin.Context) {
	//ntData := c.PostForm("nt_data")
	//sign := c.PostForm("sign")
	//md5Sign := c.PostForm("md5Sign")
	//
	//data := ntData + sign + service.GetServiceConfig().SDKConfig.QuickMd5key
	//tmpSign := md5.Sum([]byte(data))
	//md5Str := fmt.Sprintf("%x", tmpSign)
	//util.DebugF("WebPayQuickNotify ntData=%v sign=%v md5sign=%v tmpsign=%v", ntData, sign, md5Sign, md5Str)
	//if md5Str == md5Sign {
	//	util.InfoF("WebPayQuickNotify ok")
	//} else {
	//	util.ErrorF("WebPayQuickNotify sign invalid!!!")
	//	c.JSON(http.StatusOK, "FAILED")
	//	return
	//}
	//
	////decode nt_data
	//tmpNtDataList := strings.Split(ntData, "@")
	//tmpNtData := make([]byte, len(tmpNtDataList))
	//tmpKeyData := []byte(service.GetServiceConfig().SDKConfig.QuickCallbackKey)
	//for idx := 1; idx < len(tmpNtDataList); idx++ {
	//	tmpVal, _ := strconv.Atoi(tmpNtDataList[idx])
	//	tmpNtData[idx] = (byte)(tmpVal - (int)(0xff&tmpKeyData[(idx-1)%len(tmpKeyData)]))
	//}
	////字符串最前面会有一个空格
	//if string(tmpNtData[0]) == "\u0000" {
	//	tmpNtData = append(tmpNtData[:0], tmpNtData[1:]...)
	//}
	//util.InfoF("WebPayQuickNotify ntdata=%v", string(tmpNtData))
	//
	//tmpSt := &QuickPayNotify{}
	//err := xml.Unmarshal(tmpNtData, tmpSt)
	//if err != nil {
	//	util.ErrorF("WebPayQuickNotify xml decode err=%v", err)
	//	c.JSON(http.StatusOK, "FAILED")
	//	return
	//}
	//
	//ntfData := &WebNotifyData{}
	//ntfData.CpOrderId = tmpSt.Message.GameOrder
	//ntfData.SdkOrderId = ""
	//ntfData.PayMethod = ""
	//ntfData.PayCurrency = ""
	//ntfData.PayTime = uint64(util.GetTimeSeconds())
	//ntfData.PayChannel = ""
	//webPayNotify(ntfData, tmpSt.Message.Amount, c)
	//c.JSON(http.StatusOK, "SUCCESS")

	game_order := c.PostForm("game_order") //游戏订单号
	order_no := c.PostForm("order_no")     //SDK订单ID
	amount := c.PostForm("amount")         //充值金额
	PayChannel := c.PostForm("channel")    //充值渠道
	serverId := c.PostForm("server_id")    //充值服ID

	util.DebugF("收到充值订单：GameOrder=%v, SdkOfderId=%v, PauAmount=%v， PayChannel=%v, serverId=%v", game_order, order_no, amount, PayChannel, serverId)

	checkPayAmount, _ := model.Str2Float32(amount)

	ntfData := &WebNotifyData{}
	ntfData.CpOrderId = game_order
	ntfData.SdkOrderId = order_no
	ntfData.PayMethod = ""
	ntfData.PayCurrency = ""
	ntfData.PayTime = uint64(util.GetTimeSeconds())
	ntfData.PayChannel = PayChannel
	retState := webPayNotify(ntfData, checkPayAmount, c)

	//c.JSON(http.StatusOK, `success`)
	c.Data(http.StatusOK, "text/plain; charset=utf-8", []byte(retState))
}

func getMd5Sign(callbackKey string, params map[string]string) string {
	// 删除参数中的 sign 字段
	delete(params, "sign")

	// 按参数名进行升序排序
	var keys []string
	for key := range params {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	// 拼接参数和值
	var signKey strings.Builder
	for _, key := range keys {
		signKey.WriteString(key)
		signKey.WriteString("=")
		signKey.WriteString(params[key])
		signKey.WriteString("&")
	}

	// 添加回调密钥
	signKey.WriteString(callbackKey)

	// 计算 MD5
	hash := md5.Sum([]byte(signKey.String()))
	return hex.EncodeToString(hash[:])
}

func getMd5SignXiaoqi(params map[string]string) string {
	// 删除参数中的 sign 字段
	delete(params, "sign_data")

	// 按参数名进行升序排序
	var keys []string
	for key := range params {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	// 拼接参数和值
	var signKey strings.Builder
	for _, key := range keys {
		signKey.WriteString(key)
		signKey.WriteString("=")
		signKey.WriteString(params[key])
		signKey.WriteString("&")
	}

	return signKey.String()
}

func getMd5RuSign(callbackKey string, params map[string]string) string {
	// 删除参数中的 sign 字段
	delete(params, "sign")

	// 按参数名进行升序排序
	var keys []string
	for key := range params {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	// 拼接参数和值
	var signKey strings.Builder
	for i, key := range keys {
		signKey.WriteString(key)
		signKey.WriteString("=")
		signKey.WriteString(params[key])
		if i != len(keys)-1 {
			signKey.WriteString("&")
		}
	}
	// 添加回调密钥
	signKey.WriteString(callbackKey)

	// 计算 MD5
	hash := md5.Sum([]byte(signKey.String()))
	return hex.EncodeToString(hash[:])
}

func getMd5DnSign(callbackKey string, username, order_id, server, amount, extra, sandbox, timestamp string) string {

	// 拼接参数和值
	var signKey strings.Builder
	signKey.WriteString(username)
	signKey.WriteString(order_id)
	signKey.WriteString(server)
	signKey.WriteString(amount)
	signKey.WriteString(extra)
	signKey.WriteString(sandbox)
	signKey.WriteString(timestamp)
	// 添加回调密钥
	signKey.WriteString(callbackKey)

	// 计算 MD5
	hash := md5.Sum([]byte(signKey.String()))
	return hex.EncodeToString(hash[:])
}

type Extras struct {
	ServerId    int    `json:"serverId"`
	Platform    string `json:"platform"`
	SubPlatform string `json:"subPlatform"`
	Bima        string `json:"bima"`
	CpOrderId   string `json:"cpOrderId"`
}

type ExtrasRu struct {
	AccountId     string `json:"accountId"`
	Money         string `json:"money"`
	Addtime       string `json:"addtime"`
	OrderId       string `json:"orderId"`
	CustomorderId string `json:"customorderId"`
	Paytype       string `json:"paytype"`
	Success       string `json:"success"`
}

type ExtrasDn struct {
	OrderNo   string `json:"orderNo"`
	Uid       string `json:"uid"`
	Platform  string `json:"platform"`
	GoodsId   int32  `json:"goodsId"`
	GoodsType int32  `json:"goodsType"`
}

type ExtrasDnIos struct {
	OrderNo   string `json:"biwb"`
	Uid       string `json:"uid"`
	Platform  string `json:"bivz"`
	GoodsId   int32  `json:"goodsId"`
	GoodsType int32  `json:"goodsType"`
}

// 海外版quick回调
func WebPayHwQuickNotify(c *gin.Context) {
	//util.DebugF("支付回调信息:%v", c.Request.PostForm)
	params := make(map[string]string)
	if err := c.Request.ParseForm(); err != nil {
		util.InfoF("parseForm falied")
		c.String(http.StatusOK, "FAILED")
		return
	}
	util.DebugF("支付回调信息2:%v", c.Request.PostForm)
	for key, value := range c.Request.PostForm {
		params[key] = value[0] // 假设每个参数只有一个值
	}
	sign := params["sign"]
	info2 := params["extrasParams"]
	info := strings.ReplaceAll(info2, "\\", "")
	var extras Extras
	err := json.Unmarshal([]byte(info), &extras)
	if err != nil {
		util.ErrorF("支付回调参数解析错误:%v", err)
	}
	util.InfoF("支付签名认证:%v   params:%v", extras, params)
	if extras.Platform == "SDKYOUYI_IOS" || extras.Bima == "SDKYOUYI_IOS" {
		util.ErrorF("ios 支付签名认证:%v", info)
		newSign := getMd5Sign("58696021497436514481898335416221", params)
		if newSign != sign {
			util.ErrorF("签名错误%v", sign)
			c.String(http.StatusOK, "FAILED")
			return
		}
	} else if extras.Platform == "SDKYOUYI_IOS_MyCard" || extras.Platform == "SDKHwQuick_MyCard" {
		util.ErrorF("mycard 支付签名认证:%v", info)
		newSign := getMd5Sign("03422134397322604272901806704074", params)
		if newSign != sign {
			util.ErrorF("签名错误%v", sign)
			c.String(http.StatusOK, "FAILED")
			return
		}
	} else {
		util.ErrorF("android 支付签名认证:%v", info)
		newSign := getMd5Sign("47409863970932353623015025039223", params)
		if newSign != sign {
			util.ErrorF("签名错误%v", sign)
			c.String(http.StatusOK, "FAILED")
			return
		}
	}
	uid := c.PostForm("uid")
	cpOrderId := c.PostForm("cpOrderNo")
	if cpOrderId == "" {
		if extras.CpOrderId != "" {
			cpOrderId = extras.CpOrderId
		} else {
			util.ErrorF("mycard pay cporderId is nil extras:%v", extras)
		}
	}
	orderNo := c.PostForm("orderNo")
	payAmount := c.PostForm("payAmount")
	payCurrency := c.PostForm("payCurrency")
	payType := c.PostForm("payType")
	usdAmount := c.PostForm("usdAmount")
	ntfData := &WebNotifyData{}
	ntfData.CpOrderId = cpOrderId
	ntfData.SdkOrderId = orderNo
	ntfData.PayMethod = payType
	ntfData.PayCurrency = payCurrency
	ntfData.PayTime = uint64(util.GetTimeSeconds())
	ntfData.PayChannel = "qk_hw"
	util.WarnF("paycallback uid=%v cpOrderNo=%v orderNo=%v payAmount=%v payCurrency=%v payType=%v usdAmount=%v",
		uid, cpOrderId, orderNo, payAmount, payCurrency, payType, usdAmount)
	f64, err := strconv.ParseFloat(usdAmount, 32)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	webPayNotify(ntfData, float32(f64), c)

	c.String(http.StatusOK, "SUCCESS")
}

const xiaoqiIoskey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDdP+3oq+95l5CvsqmZvzgTdueiIWur64OePQkKeNUaKTAR3ar4NU9laEvgI+pkN6q+7BoPpprTB/aBqoU5eLNFnPt/6T0Dq5245e+HGij4qUYiORsU12O+pex5jxWg/knnW1g5F8SrLtAr9lwJbOc4lNPFKi+U+1fdayC64qxmjQIDAQAB"
const xiaoqiAndroidkey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDCfYd3FqSaWqCpWLSktBSSgAelt0F6T+tO4C25YKR/6X/sPacDBbX662/0fW+H+YbXigHWFB/yangkhiZTpD/VmiOo5lISX6L0/m+13ti9b8jzTZcfVngfLsP+Ztbk81N1Jk0gWF4bndZxREJ3IxcEDHnIrwXgLGA2GJ89kdgudwIDAQAB"

// 海外版xiaoqi回调
func WebPayHwXiaoQiNotify(c *gin.Context) {
	//util.DebugF("支付回调信息:%v", c.Request.PostForm)
	params := make(map[string]string)
	if err := c.Request.ParseForm(); err != nil {
		util.InfoF("parseForm falied")
		c.String(http.StatusOK, "FAILED")
		return
	}
	util.DebugF("支付回调信息2:%v", c.Request.PostForm)
	for key, value := range c.Request.PostForm {
		params[key] = value[0] // 假设每个参数只有一个值
	}
	info2 := params["extends_info_data"]
	info := strings.ReplaceAll(info2, "\\", "")
	var extras Extras
	err := json.Unmarshal([]byte(info), &extras)
	if err != nil {
		util.ErrorF("支付回调参数解析错误:%v", err)
	}
	var myData map[string]string
	var err3 error
	util.InfoF("xiaoqi 透传参数:%v   params:%v", extras, params)
	if extras.Platform == "IOS_X7" || extras.Bima == "IOS_X7" {
		util.ErrorF("xiaoqi ios 支付签名认证:%v", info)
		b, err2 := VerifySignature(params, xiaoqiIoskey)
		if err2 != nil || !b {
			util.ErrorF("签名错误%v", err2)
			c.String(http.StatusOK, "FAILED")
			return
		}
		myData, err3 = DecryptDataToMap(params["encryp_data"], xiaoqiIoskey)
		if err3 != nil {
			util.ErrorF("解析encryp_data error:%v", err3)
			c.String(http.StatusOK, "FAILED")
			return
		}
	} else {
		util.ErrorF("android 支付签名认证:%v", info)
		b, err2 := VerifySignature(params, xiaoqiAndroidkey)
		if err2 != nil || !b {
			util.ErrorF("签名错误%v", err2)
			c.String(http.StatusOK, "FAILED")
			return
		}
		myData, err3 = DecryptDataToMap(params["encryp_data"], xiaoqiAndroidkey)
		if err3 != nil {
			util.ErrorF("解析encryp_data error:%v", err3)
			c.String(http.StatusOK, "FAILED")
			return
		}
	}

	uid := myData["uid"]
	cpOrderId := myData["game_orderid"]
	if cpOrderId == "" {
		if extras.CpOrderId != "" {
			cpOrderId = extras.CpOrderId
		} else {
			util.ErrorF("mycard pay cporderId is nil extras:%v", extras)
		}
	}
	orderNo := myData["xiao7_goid"]
	payCurrency := myData["game_currency"]
	payType := myData["game_currency"]
	usdAmount := myData["pay_price"]
	ntfData := &WebNotifyData{}
	ntfData.CpOrderId = cpOrderId
	ntfData.SdkOrderId = orderNo
	ntfData.PayMethod = payType
	ntfData.PayCurrency = payCurrency
	ntfData.PayTime = uint64(util.GetTimeSeconds())
	ntfData.PayChannel = "xiaoqi"
	util.WarnF("paycallback uid=%v cpOrderNo=%v orderNo=%v payAmount=%v payCurrency=%v payType=%v usdAmount=%v",
		uid, cpOrderId, orderNo, usdAmount, payCurrency, payType, usdAmount)
	f64, err := strconv.ParseFloat(usdAmount, 32)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	webPayNotify(ntfData, float32(f64), c)

	c.String(http.StatusOK, "success")
}

// 使用公钥解密（对应 PHP 的 openssl_public_decrypt）
func DecryptDataToMap(encrypDataBase64 string, publicKeyStr string) (map[string]string, error) {
	// 1. Base64 解码得到 raw_encryp_data
	rawEncrypData, err := decodeBase64Compat(encrypDataBase64)
	if err != nil {
		return nil, fmt.Errorf("base64解码失败: %v", err)
	}

	// 2. 使用 RSA 公钥解密
	decryptedData, err := rsaPublicDecrypt(rawEncrypData, publicKeyStr)
	if err != nil {
		return nil, fmt.Errorf("RSA解密失败: %v", err)
	}

	// 3. 解析查询字符串为 map
	return parseQueryStringToMap(string(decryptedData)), nil
}

func rsaPublicDecrypt(ciphertext []byte, publicKeyStr string) ([]byte, error) {
	// 解析公钥
	publicKey, err := parsePublicKey(publicKeyStr)
	if err != nil {
		return nil, fmt.Errorf("解析公钥失败: %v", err)
	}

	keySize := (publicKey.N.BitLen() + 7) / 8
	if keySize == 0 {
		return nil, fmt.Errorf("无效RSA公钥")
	}

	if len(ciphertext)%keySize != 0 {
		return nil, fmt.Errorf("密文长度非法: len=%d keySize=%d", len(ciphertext), keySize)
	}

	// 兼容长消息分段密文（每段一个 RSA block）。
	plainData := make([]byte, 0, len(ciphertext))
	e := big.NewInt(int64(publicKey.E))
	for offset := 0; offset < len(ciphertext); offset += keySize {
		block := ciphertext[offset : offset+keySize]
		c := new(big.Int).SetBytes(block)
		if c.Cmp(publicKey.N) > 0 {
			return nil, fmt.Errorf("密文块超出模数范围")
		}

		m := new(big.Int).Exp(c, e, publicKey.N)
		em := leftPadToSize(m.Bytes(), keySize)
		plainBlock, err := unpadPKCS1v15ForPublicDecrypt(em)
		if err != nil {
			return nil, fmt.Errorf("块解密失败: %v", err)
		}
		plainData = append(plainData, plainBlock...)
	}

	return plainData, nil
}

func decodeBase64Compat(raw string) ([]byte, error) {
	// form-urlencoded 场景下，+ 可能被自动转为空格。
	s := strings.TrimSpace(strings.ReplaceAll(raw, " ", "+"))
	if s == "" {
		return nil, fmt.Errorf("空字符串")
	}

	encodings := []*base64.Encoding{
		base64.StdEncoding,
		base64.RawStdEncoding,
		base64.URLEncoding,
		base64.RawURLEncoding,
	}

	var lastErr error
	for _, enc := range encodings {
		data, err := enc.DecodeString(s)
		if err == nil {
			return data, nil
		}
		lastErr = err
	}
	return nil, lastErr
}

func leftPadToSize(src []byte, size int) []byte {
	if len(src) >= size {
		return src
	}
	dst := make([]byte, size)
	copy(dst[size-len(src):], src)
	return dst
}

// unpadPKCS1v15ForPublicDecrypt 兼容 openssl_public_decrypt 的 PKCS#1 v1.5 去填充。
func unpadPKCS1v15ForPublicDecrypt(em []byte) ([]byte, error) {
	if len(em) < 11 {
		return nil, fmt.Errorf("EM 长度过短")
	}
	if em[0] != 0x00 {
		return nil, fmt.Errorf("EM 格式错误: 缺少前导0x00")
	}

	switch em[1] {
	case 0x01:
		i := 2
		for i < len(em) && em[i] == 0xFF {
			i++
		}
		if i < 10 {
			return nil, fmt.Errorf("PKCS#1 type1 填充长度不足")
		}
		if i >= len(em) || em[i] != 0x00 {
			return nil, fmt.Errorf("PKCS#1 type1 分隔符缺失")
		}
		return em[i+1:], nil
	case 0x02:
		// 某些渠道可能走普通公钥加密块，这里也做兼容。
		i := 2
		for i < len(em) && em[i] != 0x00 {
			i++
		}
		if i < 10 {
			return nil, fmt.Errorf("PKCS#1 type2 填充长度不足")
		}
		if i >= len(em) || em[i] != 0x00 {
			return nil, fmt.Errorf("PKCS#1 type2 分隔符缺失")
		}
		return em[i+1:], nil
	default:
		return nil, fmt.Errorf("不支持的填充类型: 0x%02x", em[1])
	}
}

// 解析查询字符串为 map
func parseQueryStringToMap(queryStr string) map[string]string {
	result := make(map[string]string)

	// 按 & 分割
	pairs := strings.Split(queryStr, "&")
	for _, pair := range pairs {
		if pair == "" {
			continue
		}
		// 按 = 分割
		kv := strings.SplitN(pair, "=", 2)
		if len(kv) == 2 {
			// URL decode 值（如果需要）
			value, err := url.QueryUnescape(kv[1])
			if err != nil {
				value = kv[1]
			}
			result[kv[0]] = value
		} else if len(kv) == 1 {
			result[kv[0]] = ""
		}
	}

	return result
}

func VerifySignature(params map[string]string, publicKeyStr string) (bool, error) {
	// 1. 获取并解码 sign_data 参数
	signDataBase64, ok := params["sign_data"]
	if !ok {
		return false, fmt.Errorf("缺少 sign_data 参数")
	}

	// base64_decode 得到 raw_sign_data
	rawSignData, err := decodeBase64Compat(signDataBase64)
	if err != nil {
		return false, fmt.Errorf("base64解码失败: %v", err)
	}

	// 2. 构建 source_str（排除 sign_data，其他参数按字典序排序）
	sourceStr := buildSourceString(params)

	// 3. 验证签名
	err = verifyWithPublicKey(sourceStr, rawSignData, publicKeyStr)
	if err != nil {
		return false, err
	}

	return true, nil
}

// buildSourceString 构建查询字符串（排除 sign_data，按字典序排序）
func buildSourceString(params map[string]string) string {
	// 收集除 sign_data 外的所有键
	keys := make([]string, 0)
	for key := range params {
		if key != "sign_data" {
			keys = append(keys, key)
		}
	}

	// 字典序排序
	sort.Strings(keys)

	// 拼接成 key=value&key=value 格式
	var pairs []string
	for _, key := range keys {
		value := params[key]
		pairs = append(pairs, fmt.Sprintf("%s=%s", key, value))
	}

	return strings.Join(pairs, "&")
}

// verifyWithPublicKey 使用公钥验证签名
func verifyWithPublicKey(data string, signature []byte, publicKeyStr string) error {
	// 1. 解析公钥（支持多种格式）
	publicKey, err := parsePublicKey(publicKeyStr)
	if err != nil {
		return fmt.Errorf("解析公钥失败: %v", err)
	}

	// 2. 计算 SHA1 哈希
	hash := sha1.Sum([]byte(data))

	// 3. 验证签名
	err = rsa.VerifyPKCS1v15(publicKey, crypto.SHA1, hash[:], signature)
	if err != nil {
		return fmt.Errorf("签名验证失败: %v", err)
	}

	return nil
}

// parsePublicKey 解析 PEM 格式的公钥
func parsePublicKey(publicKeyStr string) (*rsa.PublicKey, error) {
	// 去除空白字符
	publicKeyStr = strings.TrimSpace(publicKeyStr)

	// 如果公钥字符串不包含 PEM 头，尝试添加
	if !strings.Contains(publicKeyStr, "-----BEGIN") {
		publicKeyStr = "-----BEGIN PUBLIC KEY-----\n" +
			publicKeyStr +
			"\n-----END PUBLIC KEY-----"
	}

	// 解码 PEM
	block, _ := pem.Decode([]byte(publicKeyStr))
	if block == nil {
		return nil, fmt.Errorf("PEM解码失败")
	}

	// 解析公钥
	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}

	publicKey, ok := pubInterface.(*rsa.PublicKey)
	if !ok {
		return nil, fmt.Errorf("不是RSA公钥")
	}

	return publicKey, nil
}

// parsePublicKey 解析 PEM 格式的公钥
//func parsePublicKey(publicKeyStr string) (*rsa.PublicKey, error) {
//	// 去除可能的空白字符
//	publicKeyStr = strings.TrimSpace(publicKeyStr)
//
//	// 如果公钥字符串不包含 PEM 头，尝试添加
//	if !strings.Contains(publicKeyStr, "-----BEGIN") {
//		publicKeyStr = "-----BEGIN PUBLIC KEY-----\n" +
//			publicKeyStr +
//			"\n-----END PUBLIC KEY-----"
//	}
//
//	// 解码 PEM
//	block, _ := pem.Decode([]byte(publicKeyStr))
//	if block == nil {
//		return nil, fmt.Errorf("PEM 解码失败")
//	}
//
//	// 解析公钥
//	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
//	if err != nil {
//		return nil, err
//	}
//
//	publicKey, ok := pubInterface.(*rsa.PublicKey)
//	if !ok {
//		return nil, fmt.Errorf("不是 RSA 公钥")
//	}
//
//	return publicKey, nil
//}

func WebPayHwRuNotify(c *gin.Context) {
	//util.DebugF("支付回调信息:%v", c.Request.PostForm)
	params := make(map[string]string)
	if err := c.Request.ParseForm(); err != nil {
		util.InfoF("parseForm falied")
		c.String(http.StatusOK, "FAILED")
		return
	}
	util.DebugF("支付回调信息2:%v", c.Request.PostForm)
	for key, value := range c.Request.PostForm {
		params[key] = value[0] // 假设每个参数只有一个值
	}
	sign := params["sign"]
	info2 := params["custominfo"]
	info := strings.ReplaceAll(info2, "\\", "")
	var extras Extras
	err := json.Unmarshal([]byte(info), &extras)
	if err != nil {
		util.ErrorF("支付回调参数解析错误:%v", err)
	}
	util.InfoF("支付签名认证:%v   params:%v", extras, params)
	if extras.Platform == "ZT_IOS" || extras.Bima == "ZT_IOS" {
		util.ErrorF("ios 支付签名认证:%v", info)
		newSign := getMd5RuSign("80c648e7df8aaa72", params)
		if newSign != sign {
			util.ErrorF("签名错误%v", sign)
			c.String(http.StatusOK, "FAILED")
			return
		}
	} else if extras.Platform == "SDKYOUYI_IOS_MyCard" || extras.Platform == "SDKHwQuick_MyCard" {
		util.ErrorF("mycard 支付签名认证:%v", info)
		newSign := getMd5Sign("03422134397322604272901806704074", params)
		if newSign != sign {
			util.ErrorF("签名错误%v", sign)
			c.String(http.StatusOK, "FAILED")
			return
		}
	} else {
		util.ErrorF("android 支付签名认证:%v", info)
		newSign := getMd5RuSign("80c648e7df8aaa72", params)
		if newSign != sign {
			util.ErrorF("签名错误%v", sign)
			c.String(http.StatusOK, "FAILED")
			return
		}
	}
	uid := c.PostForm("account")
	cpOrderId := c.PostForm("customorderid")
	orderNo := c.PostForm("orderid")
	payAmount := c.PostForm("money")
	payCurrency := c.PostForm("currency")
	payType := c.PostForm("paytype")
	usdAmount := c.PostForm("doller")
	ntfData := &WebNotifyData{}
	ntfData.CpOrderId = cpOrderId
	ntfData.SdkOrderId = orderNo
	ntfData.PayMethod = payType
	ntfData.PayCurrency = payCurrency
	ntfData.PayTime = uint64(util.GetTimeSeconds())
	ntfData.PayChannel = "qk_hw"
	util.WarnF("paycallback uid=%v cpOrderNo=%v orderNo=%v payAmount=%v payCurrency=%v payType=%v usdAmount=%v",
		uid, cpOrderId, orderNo, payAmount, payCurrency, payType, usdAmount)
	f64, err := strconv.ParseFloat(payAmount, 32)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	webPayNotify(ntfData, float32(f64), c)

	//// 简单粗暴，直接给其他服转发，不需要确认是哪个服
	//payPostRouter := service.GetServiceConfig().SDKConfig.PayPostRouter
	//util.WarnF("paycallback payPostRouter：%v\n", payPostRouter)
	//// 组装转发body
	//params["sign"] = sign
	//var routerStr strings.Builder
	//for key, value := range params {
	//	routerStr.WriteString(key)
	//	routerStr.WriteString("=")
	//	routerStr.WriteString(value)
	//	routerStr.WriteString("&")
	//}
	//routerString := routerStr.String()
	//util.WarnF("paycallback routerString：%v\n", routerString)
	//go sendPosts(payPostRouter, routerString)
	c.String(http.StatusOK, "success")
}

func WebPayHwDn2Notify(c *gin.Context) {
	//util.DebugF("支付回调信息:%v", c.Request.PostForm)
	orderId := c.DefaultQuery("order_id", "")
	payAmount := c.DefaultQuery("amount", "")
	sign := c.DefaultQuery("sign", "")
	extra := c.DefaultQuery("extra", "")
	username := c.DefaultQuery("username", "")
	server := c.DefaultQuery("server", "")
	sandbox := c.DefaultQuery("sandbox", "")
	timestamp := c.DefaultQuery("timestamp", "")
	var extras ExtrasDn
	err := json.Unmarshal([]byte(extra), &extras)
	if err != nil {
		util.ErrorF("支付回调参数解析错误:%v", err)
	}
	//cpOrderId := extras.OrderNo
	util.ErrorF("支付回调信息东南亚2:orderId:%v,payAmount:%v,sign:%v,extra:%v,username:%v,server:%v,sandbox:%v,timestamp:%v", orderId, payAmount, sign, extra, username, server, sandbox, timestamp)
	if extras.Platform == "XUAN_YOU_Google_Android" {
		if sign != getMd5DnSign("e81c2bd2ffb7feb7f0df477dc02b0bbd", username, orderId, server, payAmount, extra, sandbox, timestamp) {
			c.JSON(http.StatusOK, gin.H{"status": 1, "msg": "sign error"})
			return
		}
	} else if extras.Platform == "XUAN_YOU_IOS" {
		if sign != getMd5DnSign("3f8e9fec0794443f76d3a27cd41e2711", username, orderId, server, payAmount, extra, sandbox, timestamp) {
			c.JSON(http.StatusOK, gin.H{"status": 1, "msg": "sign error"})
			return
		}

	} else {
		if sign != getMd5DnSign("cee1b45a9aa02a75f9d720d6b9e7b7d4", username, orderId, server, payAmount, extra, sandbox, timestamp) {
			c.JSON(http.StatusOK, gin.H{"status": 1, "msg": "sign error"})
			return
		}
	}
	cpOrderId := extras.OrderNo
	if cpOrderId != "" {
		//f64, err := strconv.ParseFloat(payAmount, 64)
		//if err != nil {
		//	fmt.Println("Error:", err)
		//	return
		//}
		util.WarnF("paycallbackDn2 uid=%v cpOrderNo=%v orderNo=%v payAmount=%v",
			extras.Uid, cpOrderId, orderId, payAmount)
		res := webPayNotifyDn(cpOrderId, payAmount, orderId)
		if res == "SUCCESS" {
			c.JSON(http.StatusOK, gin.H{"status": 0})
		} else {
			c.JSON(http.StatusOK, gin.H{"status": 1, "msg": "order already complete"})
		}
	} else { //走的网页支付流程游戏这边没有orderid，只发代金券礼包
		for _, v := range ResDnyPayInfo.GiftList {
			if v.Id == strconv.Itoa(int(extras.GoodsId)) {
				//发送对应奖励
				var bfInfo *WebBriefInfo
				service.GetMysql().Operate(func(rawClient interface{}) interface{} {
					wrapper := mysql.NewWrapper(rawClient.(*sql.DB))

					wrapper.Query("select uid,nick_name,base_level,create_date,last_login_date,ban_date,map_level,fight_power,active_code,open_id,serverid from role where open_id=?", username).Each(func(wrapper2 *mysql.Wrapper) bool {
						bfInfo = parseUserInfo(wrapper2)

						return true
					})

					if wrapper.Err != nil {
						util.ErrorF("uid=%v WebGmProcessUserGet err=%v", username, wrapper.Err)
					}
					return nil
				})
				if bfInfo == nil {
					util.ErrorF("uid=%v not found err=%v", username)
					c.JSON(http.StatusOK, gin.H{"status": 1, "msg": "not found user"})
					return
				}
				uidStr := bfInfo.Uid
				titleStr := "system award"
				contentStr := v.Desc
				rewardStr := v.Reward
				// list表示获取邮件列表
				// attach添加替换邮件
				// del删除延迟发送邮件
				//mailType := c.DefaultQuery("type", "")

				//uid
				var uidList []uint64
				uidList = append(uidList, uidStr)

				//reward
				var rewardList []*serverproto.KeyValueType
				rewardStrList := strings.Split(rewardStr, ",")
				for idx := 0; idx < len(rewardStrList); idx++ {
					key, val := model.Str2Res(rewardStrList[idx])
					if key > 0 && val > 0 {
						rewardList = append(rewardList, &serverproto.KeyValueType{Key: key, Value: val})
					}
				}
				util.ErrorF("东南亚网页支付:orderId:%v,payAmount:%v,sign:%v,extra:%v,username:%v,server:%v,sandbox:%v,timestamp:%v,award:%v", orderId, payAmount, sign, extra, username, server, sandbox, timestamp, rewardStr)
				gmweb.GetMailUpdateMag().AttachMail2Update(1, uidList, titleStr, contentStr, util.GetTimeMilliseconds(), rewardList)
				c.JSON(http.StatusOK, gin.H{"status": 0})

			}
		}
	}
}

func WebPayHwDnOpenServerNotify(c *gin.Context) {
	//util.DebugF("支付回调信息:%v", c.Request.PostForm)
	sidStr := c.DefaultQuery("sid", "")
	nameStr := c.DefaultQuery("name", "")
	timeStr := c.DefaultQuery("time", "")       //2019-01-01 12:00:00
	gameIdStr := c.DefaultQuery("gameid", "")   //2019-01-01 12:00:00
	signKeyStr := c.DefaultQuery("signkey", "") //2019-01-01 12:00:00
	if nameStr == "" || sidStr == "" || timeStr == "" || gameIdStr == "" {
		c.JSON(http.StatusOK, "param error:"+nameStr+sidStr+timeStr)
		return
	}
	reqUrl := "https://i.dze-game.com/game/center/sync_server"
	now := strconv.FormatInt(time.Now().Unix(), 10)
	// 准备表单数据
	formData := url.Values{}
	formData.Add("GAME_ID", gameIdStr)
	formData.Add("SID", sidStr)
	formData.Add("_SID", sidStr)
	formData.Add("NAME", nameStr)
	formData.Add("START_TIME", timeStr)
	formData.Add("sign", Md5Dn(gameIdStr, nameStr, sidStr, timeStr, sidStr, now, signKeyStr))
	formData.Add("timestamp", now)
	resp, err := http.Post(
		reqUrl,
		"application/x-www-form-urlencoded",
		strings.NewReader(formData.Encode()),
	)
	if err != nil {
		util.ErrorF("req error:%v", err)
		c.JSON(http.StatusOK, "req error:"+nameStr+sidStr+timeStr)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		util.ErrorF("red body error:%v", err)
		c.JSON(http.StatusOK, "res error:"+nameStr+sidStr+timeStr)
		return
	}

	util.ErrorF("东南亚开服信息,sid:%v,name:%v,time:%v,response:%v", sidStr, nameStr, timeStr, string(body))
	c.JSON(http.StatusOK, gin.H{"status": 0})

}

func Md5Dn(gameId, name, sid, time, _sid, timestamp, signKey string) string {
	key := gameId + name + sid + time + _sid + timestamp + signKey
	hash := md5.Sum([]byte(key))
	return hex.EncodeToString(hash[:])
}

func WebPayHwDnNotify(c *gin.Context) {
	//util.DebugF("支付回调信息:%v", c.Request.PostForm)
	params := make(map[string]string)
	if err := c.Request.ParseForm(); err != nil {
		util.InfoF("parseForm falied")
		c.String(http.StatusOK, "FAILED")
		return
	}
	util.ErrorF("支付回调信息东南亚:%v", c.Request.PostForm)
	for key, value := range c.Request.PostForm {
		params[key] = value[0] // 假设每个参数只有一个值
	}
	cpOrderId := params["order_code"]
	payAmount := params["amount"]
	//f64, err := strconv.ParseFloat(payAmount, 32)
	//if err != nil {
	//	fmt.Println("Error:", err)
	//	return
	//}
	res := webPayNotifyDn(cpOrderId, payAmount, "")

	//// 简单粗暴，直接给其他服转发，不需要确认是哪个服
	//payPostRouter := service.GetServiceConfig().SDKConfig.PayPostRouter
	//util.WarnF("paycallback payPostRouter：%v\n", payPostRouter)
	//// 组装转发body
	//params["sign"] = sign
	//var routerStr strings.Builder
	//for key, value := range params {
	//	routerStr.WriteString(key)
	//	routerStr.WriteString("=")
	//	routerStr.WriteString(value)
	//	routerStr.WriteString("&")
	//}
	//routerString := routerStr.String()
	//util.WarnF("paycallback routerString：%v\n", routerString)
	//go sendPosts(payPostRouter, routerString)
	if res == "SUCCESS" {
		c.JSON(http.StatusOK, gin.H{"processingStatus": "completed"})
	} else {
		c.JSON(404, gin.H{"code": "ORDER_CODE_NOT_FOUND", "message": "order_code does not exist"})
	}
}

func sendPosts(urls []string, routerString string) {
	for i := 0; i < len(urls); i++ {
		sendPostToOtherServer(urls[i], []byte(routerString))
	}
}

// http://110.40.223.119:8002/pay/hwQucikFromS1GmWeb
func WebPayHwQuickNotifyFromS1GmWeb(c *gin.Context) {

	params := make(map[string]string)
	if err := c.Request.ParseForm(); err != nil {
		util.InfoF("parseForm falied")
		c.String(http.StatusOK, "FAILED")
		return
	}
	for key, value := range c.Request.PostForm {
		params[key] = value[0] // 假设每个参数只有一个值
	}
	sign := params["sign"]
	newSign := getMd5Sign("03422134397322604272901806704074", params)
	util.ErrorF("sign:%v", sign)
	util.ErrorF("newSign:%v", newSign)
	util.ErrorF("params:%v", params)
	if newSign != sign {
		util.ErrorF("签名错误%v", sign)
		c.String(http.StatusOK, "FAILED")
		return
	}
	uid := c.PostForm("uid")
	cpOrderId := c.PostForm("cpOrderNo")
	orderNo := c.PostForm("orderNo")
	payAmount := c.PostForm("payAmount")
	payCurrency := c.PostForm("payCurrency")
	payType := c.PostForm("payType")
	usdAmount := c.PostForm("usdAmount")
	ntfData := &WebNotifyData{}
	ntfData.CpOrderId = cpOrderId
	ntfData.SdkOrderId = orderNo
	ntfData.PayMethod = payType
	ntfData.PayCurrency = payCurrency
	ntfData.PayTime = uint64(util.GetTimeSeconds())
	ntfData.PayChannel = "qk_hw"
	util.DebugF("uid=%v cpOrderNo=%v orderNo=%v payAmount=%v payCurrency=%v payType=%v usdAmount=%v",
		uid, cpOrderId, orderNo, payAmount, payCurrency, payType, usdAmount)
	f64, err := strconv.ParseFloat(usdAmount, 32)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	webPayNotify(ntfData, float32(f64), c)
	c.JSON(http.StatusOK, "SUCCESS")
}

// sendPostToOtherServer 发送给其他服务器
func sendPostToOtherServer(url string, body []byte) {
	// 创建请求
	req, err := http.NewRequest("POST", url, bytes.NewReader(body))
	if err != nil {
		util.ErrorF("r1 NewRequest:%v \n", err.Error())
	}

	// 设置Header
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Set("Custom-Header", "custom-value")

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		util.ErrorF("r1 client.Do(req):%v \n", err.Error())
		return
	}
	defer resp.Body.Close()

}

type KVSt struct {
	ParamKey string
	ParamVal string
}

func WebPayNBSDKNotify(c *gin.Context) {
	tmpReq := c.Request
	err := tmpReq.ParseMultipartForm(32 << 20)
	if err != nil {
		return
	}
	formCache := tmpReq.PostForm
	//util.DebugF("formCache2=%v", formCache)

	var kvList []*KVSt
	for k, v := range formCache {
		if k == "sign" {
			continue
		}
		kv := &KVSt{
			ParamKey: k,
			ParamVal: v[0],
		}
		kvList = append(kvList, kv)
	}
	sort.Slice(kvList, func(i, j int) bool {
		return kvList[i].ParamKey < kvList[j].ParamKey
	})
	//util.DebugF("kvlist=%v", kvList)
	verifyStr := ""
	for idx := 0; idx < len(kvList); idx++ {
		key := url.QueryEscape(kvList[idx].ParamKey)
		val := url.QueryEscape(kvList[idx].ParamVal)
		if idx == 0 {
			verifyStr += key + "=" + val
		} else {
			verifyStr += "&" + key + "=" + val
		}
	}

	sign := c.PostForm("sign")
	sdkOrderId := c.PostForm("sdk_order_id") //SDK订单ID
	cpOrderId := c.PostForm("cp_order_id")   //游戏方订单ID，由游戏客户端生成(服务器生成给到客户端)
	serverId := c.PostForm("server_id")      //游戏区服ID
	pfUid := c.PostForm("pf_uid")            //渠道平台的UID
	roleId := c.PostForm("role_id")          //游戏方自己的角色ID
	payAmount := c.PostForm("pay_amount")    //支付金额(int,单位分,CP方需要验证是否与计费点金额一致，不做此判断，后果自负哦！！！)

	gameKey := service.GetServiceConfig().SDKConfig.NbGameKey
	tmpHmac := hmac.New(md5.New, []byte(gameKey))
	tmpHmac.Write([]byte(verifyStr))
	tmpSign := hex.EncodeToString(tmpHmac.Sum([]byte("")))
	util.DebugF("uid=%v verifyStr=%v cpOrderId=%v pfUid=%v sdkOrderId=%v serverId=%v tmpSign=%v sign=%v gamekey=%v", roleId, verifyStr, cpOrderId, pfUid,
		sdkOrderId, serverId, tmpSign, sign, gameKey)
	if tmpSign != sign {
		util.InfoF("uid=%v WebPayNBSDKNotify sign verify failed cpOrderId=%v", roleId, cpOrderId)
		return
	}

	checkPayAmount, _ := model.Str2Num(payAmount)

	ntfData := &WebNotifyData{}
	ntfData.CpOrderId = cpOrderId
	ntfData.SdkOrderId = sdkOrderId
	ntfData.PayMethod = ""
	ntfData.PayCurrency = ""
	ntfData.PayTime = uint64(util.GetTimeSeconds())
	ntfData.PayChannel = ""
	ret := webPayNotify(ntfData, float32(checkPayAmount)/100, c)

	//c.JSON(http.StatusOK, `success`)
	c.Data(http.StatusOK, "text/plain; charset=utf-8", []byte(ret))
}

type UniSDKPayExtraST struct {
	Aid           int    `json:"aid"` //用户唯一标识
	PrivateParam  string `json:"privateparam"`
	PayChannel    string `json:"paychannel"` //支付渠道
	AppChannel    string `json:"appchannel"` //appchannel
	Platform      string `json:"platfrom"`
	UidId         string `json:"uidid"`       //设备id
	GoodsCount    int    `json:"goodscount"`  //商品数量
	PayMoney      string `json:"paymoney"`    //玩家实际支付金额
	FreeMoney     string `json:"freemoney"`   //免费总价，供游戏服写运营日志（如果渠道不提供，该字段为0）
	PayCurrency   string `json:"paycurrency"` //玩家实际支付币种
	Deduct        int    `json:"deduct"`
	DeductPercent string `json:"deductpercent"`
	DeductReason  string `json:"deductreason"` //扣除原因，是黑设备还是黑币种
	JsonData      string `json:"jsondata"`
	InitTime      int    `json:"inittime"` //订单创建时间戳，精确到秒;若订单不通过create_order接口创建（例如web 支付），则此值为0
	PayTime       int    `json:"paytime"`  //订单支付时间戳，精确到秒
	IsTest        int    `json:"istest"`   //订单来源：0，正式环境订单；1，测试环境订单(v3.6.2新增)
	FreeYuanBao   int    `json:"free_yuanbao"`
	PayYuanBao    int    `json:"pay_yuanbao"`
	PayMethod     string `json:"paymethod"`
}
type UniSDKPayST struct {
	GameId    string `json:"gameid"`
	HostId    int    `json:"hostid"`
	RoleId    string `json:"roleid"`
	GoodsId   string `json:"goodsid"`
	UserName  string `json:"username"`  //玩家渠道帐号(玩家帐号被sdk渠道转换之后的字符串)
	SN        string `json:"sn"`        //游戏订单号
	ConsumeSN string `json:"consumesn"` //渠道流水订单号(苹果渠道对应为transaction-id)
	ExtraData UniSDKPayExtraST
}
type UniSDKPayResponseST struct {
	Code int         `json:"code"`
	Msg  string      `json:"msg"`
	Data interface{} `json:"data"`
}

func WebPayUniSDKNotify(c *gin.Context) {
	sign := c.GetHeader("Gas-Ship-Signature")

	payInfo := &UniSDKPayST{}
	bodyData, err := c.GetRawData()
	if err != nil {
		util.ErrorF("WebPayUniSDKNotify body get error=%v", err)
		return
	}
	err = json.Unmarshal(bodyData, payInfo)
	if err != nil {
		util.ErrorF("WebPayUniSDKNotify body Unmarshal error=%v", err)
		return
	}

	secretKey := service.GetServiceConfig().SDKConfig.UniSecretKey
	tmpHmac := hmac.New(md5.New, []byte(secretKey))
	tmpHmac.Write(bodyData)
	tmpSign := hex.EncodeToString(tmpHmac.Sum([]byte("")))
	if tmpSign != sign {
		util.InfoF("uid=%v WebPayUniSDKNotify sign verify failed cpOrderId=%v", payInfo.RoleId, payInfo.SN)
		c.Header("Gas-Ship-Signature", tmpSign)
		responseSt := &UniSDKPayResponseST{
			Code: 403,
			Msg:  "ok",
			Data: nil,
		}
		c.JSON(http.StatusOK, responseSt)
		return
	}

	checkPayAmount, _ := model.Str2Num(payInfo.ExtraData.PayMoney)

	ntfData := &WebNotifyData{}
	ntfData.CpOrderId = payInfo.SN
	ntfData.SdkOrderId = payInfo.ConsumeSN
	ntfData.PayMethod = payInfo.ExtraData.PayMethod
	ntfData.PayCurrency = payInfo.ExtraData.PayCurrency
	ntfData.PayTime = uint64(payInfo.ExtraData.PayTime)
	ntfData.PayChannel = payInfo.ExtraData.PayChannel
	ret := webPayNotify(ntfData, float32(checkPayAmount)/100, c)

	if ret == "FAILED" {
		c.JSON(http.StatusOK, "FAILED")
	}
	c.Header("Gas-Ship-Signature", tmpSign)
	responseSt := &UniSDKPayResponseST{
		Code: 200,
		Msg:  "ok",
		Data: nil,
	}
	c.JSON(http.StatusOK, responseSt)
}

func WebPayNBH5Notify(c *gin.Context) {
	sdkOrderId := c.PostForm("sdk_order_id") //SDK订单ID
	cpOrderId := c.PostForm("cp_order_id")   //游戏方订单ID，由游戏客户端生成(服务器生成给到客户端)
	serverId := c.PostForm("server_id")      //游戏区服ID
	pfUid := c.PostForm("pf_uid")            //渠道平台的UID
	roleId := c.PostForm("role_id")          //游戏方自己的角色ID(uid)
	payAmount := c.PostForm("pay_amount")    //支付金额(int,单位分,CP方需要验证是否与计费点金额一致，不做此判断，后果自负哦！！！)
	goodsType := c.PostForm("goods_type")
	goodsID := c.PostForm("goods_id")

	util.InfoF("WebPayH5Notify roleId=%v pfUid=%v sdkOrderId=%v serverId=%v", roleId, pfUid, sdkOrderId, serverId)
	if cpOrderId == "" {
		cpOrderId = "WebPayH5Notify"
	}
	gameRoleId, _ := model.Str2NumU64(roleId)
	checkPayAmount, _ := model.Str2Num(payAmount)
	if gameRoleId <= 0 || checkPayAmount <= 0 {
		c.Data(http.StatusOK, "text/plain; charset=utf-8", []byte("FAILED"))
		return
	}

	ntfData := &WebNotifyData{}
	ntfData.GameRoleId = gameRoleId
	ntfData.CpOrderId = cpOrderId
	ntfData.SdkOrderId = sdkOrderId
	ntfData.PayMethod = ""
	ntfData.PayCurrency = ""
	ntfData.PayTime = uint64(util.GetTimeSeconds())
	ntfData.PayChannel = "WebPayH5Notify"
	ntfData.GoodsType, _ = model.Str2NumU64(goodsType)
	ntfData.GoodsID, _ = model.Str2NumU64(goodsID)
	ret := webPayNotifyH5(ntfData, float32(checkPayAmount)/100, c)

	c.Data(http.StatusOK, "text/plain; charset=utf-8", []byte(ret))
}

type WebNotifyData struct {
	CpOrderId   string
	SdkOrderId  string
	PayMethod   string
	PayCurrency string
	PayTime     uint64
	PayChannel  string
	GameRoleId  uint64
	GoodsType   uint64
	GoodsID     uint64
}

func webPayNotify(webNtf *WebNotifyData, payAmount float32, c *gin.Context) string {
	//流程处理gmweb保存订单状态到redis中设置为 成功充值状态
	//发送给gameserver，成功收到后设置订单状态为成功获取充值状态，如果gameserver没有收到
	//每次玩家上线时，重新获取一次订单状态如果是成功充值，但是没有获取成功就获取一次
	// 充值成功获取对应的ntdata数据
	// 1，回复成/失败消息给quick
	// 2，订单状态写入redis（判重处理），并发送给social做获取奖励处理
	msgStr, err := service.GetRedis().HGet(model.PayOrderPrefix, webNtf.CpOrderId).Result()
	if err != nil {
		//util.ErrorF("WebPayQuickNotify order not exist err=%v", err)
		util.ErrorF("WebPayQuickNotify order not exist err=%v, cpOrderId=%v, sdkOrderId=%v", err, webNtf.CpOrderId, webNtf.SdkOrderId)
		//c.JSON(http.StatusOK, "FAILED")

		//return "FAILED"
		return fmt.Sprintf("FAILED,cpOrderId=%v err=%v", webNtf.CpOrderId, err)
	}

	payInfo := &serverproto.PayOrderSaveInfo{}
	err = model.GetDecodeMessage(payInfo, msgStr)
	if err != nil {
		util.ErrorF("WebPayQuickNotify GetDecodeMessage err=%， cpOrderId=%v, sdkOrderId=%v", err, webNtf.CpOrderId, webNtf.SdkOrderId)
		//util.ErrorF("WebPayQuickNotify GetDecodeMessage err=%v", err)
		//c.JSON(http.StatusOK, "FAILED")
		//return "FAILED"
		return fmt.Sprintf("FAILED,cpOrderId=%v err=%v", webNtf.CpOrderId, err)
	}
	if payInfo.OrderState == int32(serverproto.PayOrderState_EPayOrderState_Gen) {
		//实际支付 == 订单的钱,否则为支付失败
		//payAmount := int32(payAmount * 100) //该渠道是以分为单位（游戏以卢布为单位）
		//服务器订单实际金额：
		//orderAmount := int32(payInfo.Amount * 1000)
		if payAmount == payInfo.Amount {
			payInfo.OrderState = int32(serverproto.PayOrderState_EPayOrderState_PayOk)
		} else {
			payInfo.OrderState = int32(serverproto.PayOrderState_EPayOrderState_PayFailed)
			util.ErrorF("uid=%v WebPayQuickNotify failed payAmount:%v order=%v", payInfo.Uid, payAmount, payInfo)
			return "FAILED"
		}
		payInfo.OrderProcessTime = util.GetTimeMilliseconds()
		payInfo.SdkOrderId = webNtf.SdkOrderId //sdk订单id\
		payInfo.PayMethod = webNtf.PayMethod
		payInfo.PayCurrency = webNtf.PayCurrency
		payInfo.PayTime = webNtf.PayTime
		payInfo.PayChannel = webNtf.PayChannel

		//订单状态修改，写入数据库(后续玩家发货成功后会再次修改订单状态为PayOrderState_EPayOrderState_PayOkReward)
		err, newPayInfoStr := model.GetEncodeMessage(payInfo)
		if err == nil {
			service.GetRedis().HSet(model.PayOrderPrefix, webNtf.CpOrderId, newPayInfoStr)
		}
		//完成订单id列表(避免上次发货不成功，玩家下次登陆时可以重新获取一次奖励)
		uidStr := strconv.FormatUint(payInfo.Uid, 10)
		okListKeyStr := model.PayOrderOKIdListPrefix + uidStr
		service.GetRedis().SAdd(okListKeyStr, payInfo.CpOrderId)

		if payInfo.OrderState == int32(serverproto.PayOrderState_EPayOrderState_PayOk) {
			ssNtfMsg := &serverproto.SSPayInfoOrderNtf{
				PayOrderInfo: payInfo,
			}
			selfmodel.SendSocial(ssNtfMsg)
		}
		util.InfoF("uid=%v WebPayQuickNotify ok order=%v", payInfo.Uid, payInfo)
	} else {
		util.ErrorF("WebPayQuickNotify uid=%v state error state=%v", payInfo.Uid, payInfo.OrderState)
		//return "FAILED"
		return fmt.Sprintf("FAILED,cpOrderId=%v state error=%v", webNtf.CpOrderId, payInfo.OrderState)
	}
	return "SUCCESS"
}

func webPayNotifyDn(cpOrderId string, Amount, sdkOrderId string) string {
	//流程处理gmweb保存订单状态到redis中设置为 成功充值状态
	//发送给gameserver，成功收到后设置订单状态为成功获取充值状态，如果gameserver没有收到
	//每次玩家上线时，重新获取一次订单状态如果是成功充值，但是没有获取成功就获取一次
	// 充值成功获取对应的ntdata数据
	// 1，回复成/失败消息给quick
	// 2，订单状态写入redis（判重处理），并发送给social做获取奖励处理
	msgStr, err := service.GetRedis().HGet(model.PayOrderPrefix, cpOrderId).Result()
	if err != nil {
		//util.ErrorF("WebPayQuickNotify order not exist err=%v", err)
		util.ErrorF("WebPayQuickNotify order not exist err=%v, cpOrderId=%v, sdkOrderId=%v", err, cpOrderId, 0)
		//c.JSON(http.StatusOK, "FAILED")

		//return "FAILED"
		return fmt.Sprintf("FAILED,cpOrderId=%v err=%v", cpOrderId, err)
	}

	payInfo := &serverproto.PayOrderSaveInfo{}
	err = model.GetDecodeMessage(payInfo, msgStr)
	if err != nil {
		util.ErrorF("WebPayQuickNotify GetDecodeMessage err=%， cpOrderId=%v, sdkOrderId=%v", err, cpOrderId, 0)
		//util.ErrorF("WebPayQuickNotify GetDecodeMessage err=%v", err)
		//c.JSON(http.StatusOK, "FAILED")
		//return "FAILED"
		return fmt.Sprintf("FAILED,cpOrderId=%v err=%v", cpOrderId, err)
	}
	if payInfo.OrderState == int32(serverproto.PayOrderState_EPayOrderState_Gen) {
		//实际支付 == 订单的钱,否则为支付失败
		//payAmount := int32(Amount * 1000)
		////服务器订单实际金额：
		orderAmount := fmt.Sprintf("%.2f", payInfo.Amount)
		if Amount == orderAmount {
			payInfo.OrderState = int32(serverproto.PayOrderState_EPayOrderState_PayOk)
		} else {
			payInfo.OrderState = int32(serverproto.PayOrderState_EPayOrderState_PayFailed)
			util.ErrorF("uid=%v WebPayQuickNotify failed payAmount:%v order=%v ,price=%v", payInfo.Uid, Amount, payInfo, orderAmount)
			return ""
		}
		//payInfo.OrderState = int32(serverproto.PayOrderState_EPayOrderState_PayOk)
		payInfo.OrderProcessTime = util.GetTimeMilliseconds()
		payInfo.SdkOrderId = sdkOrderId //sdk订单id\
		//payInfo.PayMethod = webNtf.PayMethod
		//payInfo.PayCurrency = webNtf.PayCurrency
		payInfo.PayTime = util.GetTimeMilliseconds()
		payInfo.PayChannel = "dn"

		//订单状态修改，写入数据库(后续玩家发货成功后会再次修改订单状态为PayOrderState_EPayOrderState_PayOkReward)
		err, newPayInfoStr := model.GetEncodeMessage(payInfo)
		if err == nil {
			service.GetRedis().HSet(model.PayOrderPrefix, cpOrderId, newPayInfoStr)
		}
		//完成订单id列表(避免上次发货不成功，玩家下次登陆时可以重新获取一次奖励)
		uidStr := strconv.FormatUint(payInfo.Uid, 10)
		okListKeyStr := model.PayOrderOKIdListPrefix + uidStr
		service.GetRedis().SAdd(okListKeyStr, payInfo.CpOrderId)

		if payInfo.OrderState == int32(serverproto.PayOrderState_EPayOrderState_PayOk) {
			ssNtfMsg := &serverproto.SSPayInfoOrderNtf{
				PayOrderInfo: payInfo,
			}
			selfmodel.SendSocial(ssNtfMsg)
		}
		util.InfoF("uid=%v WebPayQuickNotify ok order=%v", payInfo.Uid, payInfo)
	} else {
		util.ErrorF("WebPayQuickNotify uid=%v state error state=%v", payInfo.Uid, payInfo.OrderState)
		//return "FAILED"
		return fmt.Sprintf("FAILED,cpOrderId=%v state error=%v", cpOrderId, payInfo.OrderState)
	}
	return "SUCCESS"
}

// 外层发起主动充值(不走游戏流程)
func webPayNotifyH5(webNtf *WebNotifyData, payAmount float32, c *gin.Context) string {
	payInfo := &serverproto.PayOrderSaveInfo{}
	payInfo.Uid = webNtf.GameRoleId
	payInfo.Amount = payAmount
	payInfo.OrderProcessTime = util.GetTimeMilliseconds()
	payInfo.SdkOrderId = webNtf.SdkOrderId //sdk订单id\
	payInfo.PayMethod = webNtf.PayMethod
	payInfo.PayCurrency = webNtf.PayCurrency
	payInfo.PayTime = webNtf.PayTime
	payInfo.PayChannel = webNtf.PayChannel
	payInfo.GoodsType = int32(webNtf.GoodsType)
	payInfo.GoodsId = int32(webNtf.GoodsID)

	rewardStr := c.DefaultQuery("reward", "")
	//reward
	rewardStrList := strings.Split(rewardStr, ",")
	for idx := 0; idx < len(rewardStrList); idx++ {
		key, val := model.Str2Res(rewardStrList[idx])
		if key > 0 && val > 0 {
			payInfo.RewardList = append(payInfo.RewardList, &serverproto.KeyValueType{Key: key, Value: val})
		}
	}
	payInfo.OrderState = int32(serverproto.PayOrderState_EPayOrderState_PayOk)

	//订单状态修改，写入数据库(后续玩家发货成功后会再次修改订单状态为PayOrderState_EPayOrderState_PayOkReward)
	err, newPayInfoStr := model.GetEncodeMessage(payInfo)
	if err == nil {
		service.GetRedis().HSet(model.PayOrderPrefix, webNtf.CpOrderId, newPayInfoStr)
	}
	//完成订单id列表(避免上次发货不成功，玩家下次登陆时可以重新获取一次奖励)
	uidStr := strconv.FormatUint(payInfo.Uid, 10)
	okListKeyStr := model.PayOrderOKIdListPrefix + uidStr
	service.GetRedis().SAdd(okListKeyStr, payInfo.CpOrderId)

	util.InfoF("webPayNotifyH5: %v", payInfo)

	ssNtfMsg := &serverproto.SSPayInfoOrderNtf{
		PayOrderInfo: payInfo,
	}
	selfmodel.SendSocial(ssNtfMsg)

	return "SUCCESS"
}