xpggame/modules/pay/base/callback.go

package base

import (
	"encoding/json"
	"io"
	"net"
	"net/http"
	"reflect"
	"server/call"
	"server/common"
	"server/db"
	"server/modules/pay/values"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	iptool "github.com/liangdas/mqant/utils/ip"
)

func (b *Base) PayCallback(c *gin.Context) {
	b.C = c
	if len(b.WhiteIPs) > 0 {
		ip := iptool.RealIP(c.Request)
		if strings.Contains(ip, ":") {
			ip, _, _ = net.SplitHostPort(ip)
		}
		white := false
		for _, v := range b.WhiteIPs {
			if v == ip {
				white = true
				break
			}
		}
		if !white {
			return
		}
	}
	var str string
	var err error
	if b.HttpType == HttpTypeJson {
		str, err = b.CallbackJson(c)
	} else if b.HttpType == HttpTypeForm {
		str, err = b.CallbackForm(c)
	}
	defer func() {
		c.String(http.StatusOK, b.CallbackResp.Msg)
	}()
	if err != nil || !b.CheckSign(str) {
		b.CallbackResp.Msg = "callback fail"
		return
	}
	orderID := b.CallbackResp.OrderID
	or := &common.RechargeOrder{OrderID: orderID}
	db.Mysql().Get(or)
	if or.ID == 0 {
		log.Error("order:%v not exist", orderID)
		return
	}
	if or.Status == common.StatusROrderPay {
		log.Error("order:%v exec done", orderID)
		return
	}
	success := b.CallbackResp.Success
	if err := call.RechargeCallback(or, success, "", ""); err != nil {
		b.CallbackResp.Msg = "callback fail"
		return
	}
	if success {
		values.PayCallback(b.Channel)
	}
}

func (b *Base) WithdrawCallback(c *gin.Context) {
	b.C = c
	var str string
	var err error
	if b.HttpType == HttpTypeJson {
		str, err = b.CallbackJson(c)
	} else if b.HttpType == HttpTypeForm {
		str, err = b.CallbackForm(c)
	}
	defer func() {
		c.String(http.StatusOK, b.CallbackResp.Msg)
	}()
	if err != nil || !b.CheckSign(str) {
		b.CallbackResp.Msg = "callback fail"
		return
	}
	orderID := b.CallbackResp.OrderID
	or := &common.WithdrawOrder{OrderID: orderID}
	db.Mysql().Get(or)
	if or.ID == 0 {
		log.Error("order:%v not exist", orderID)
		return
	}
	if or.APIPayID == "" {
		or.APIPayID = b.CallbackResp.APIOrderID
	}
	success := b.CallbackResp.Success
	or.FailReason = b.CallbackResp.FailMessage
	if success {
		or.Status = common.StatusROrderFinish
	} else {
		or.Status = common.StatusROrderFail
	}
	if err := call.WithdrawCallback(or); err != nil {
		b.CallbackResp.Msg = "callback fail"
		return
	}
}

func (b *Base) CallbackJson(c *gin.Context) (str string, err error) {
	log.Debug("CallbackJson:%+v", *c.Request)
	var tmp []byte
	tmp, err = io.ReadAll(c.Request.Body)
	defer func() {
		c.Request.Body.Close()
	}()
	if err != nil {
		log.Error("err:%v", err)
		return
	}
	str = string(tmp)
	log.Debug("CallbackJson body:%v", str)
	err = json.Unmarshal(tmp, b.CallbackReq)
	if err != nil {
		log.Error("err:%v", err)
		return
	}
	return
}

func (b *Base) CallbackForm(c *gin.Context) (str string, err error) {
	req := b.CallbackReq
	typ := reflect.TypeOf(req).Elem()
	val := reflect.ValueOf(req).Elem()
	for i := 0; i < typ.NumField(); i++ {
		val.Field(i).SetString(c.PostForm(typ.Field(i).Tag.Get("json")))
	}
	str = values.GetSignStrForm(c, b.SignPassStr...)
	return
}