xpggame/modules/web/providers/awc/handler.go

package awc

import (
	"encoding/json"
	"fmt"
	"server/call"
	"server/common"
	"server/db"
	"server/modules/web/app"
	"server/modules/web/providers/base"
	"server/natsClient"
	"server/pb"
	"server/util"
	"time"

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

func AWC(e *gin.RouterGroup) {
	e.POST("", Callback)
}

func Callback(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	key := c.PostForm("key")
	message := c.PostForm("message")
	log.Debug("awc callback key:%v,message:%v", key, message)
	if key != APIKey {
		return
	}
	// message, err := strconv.Unquote(message)
	// if err != nil {
	// 	log.Error("err:%v", err)
	// }
	a.TmpData = message

	act := new(Action)
	json.Unmarshal([]byte(message), act)

	switch act.Action {
	case "getBalance":
		uid, ct := base.GetUIDAndCurrency(act.UserId)
		if uid <= 0 || !ct.IsValid() {
			a.RetData = &CommonResp{Status: "1002"}
			return
		}
		a.UID = uid
		a.TmpData = ct
		getBalance(a)
	case "bet":
		placeBet(a)
	case "cancelBet":
		cancelBet(a)
	case "voidBet":
		cancelBet(a)
	case "settle":
		settle(a)
	case "voidSettle":
		viodSettle(a)
	case "give":
		give(a)
	case "resettle":
		resettle(a)
	default:
		a.RetData = &CommonResp{Status: "1036"}
		return
	}
}

func getBalance(a *app.Gin) {
	resp := &GetBalanceResp{}
	a.RetData = resp
	// currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(a.UID))
	// if err != nil {
	// 	log.Error("err:%v", err)
	// 	resp.Status = "1036"
	// 	return
	// }
	resp.Status = "0000"
	resp.Balance = call.GetUserCurrencyFloat(a.UID, a.TmpData.(common.CurrencyType), 4)
	resp.UserId = fmt.Sprintf("%v", a.UID)
	resp.BalanceTs = time.Now().Format(TimeFormatString)
}

func placeBet(a *app.Gin) {
	req := new(PlaceBetReq)
	message := a.TmpData.(string)
	resp := &PlaceBetResp{}
	a.RetData = resp
	err := json.Unmarshal([]byte(message), req)
	if err != nil {
		log.Error("err:%v", err)
		resp.Status = "1036"
		return
	}
	// log.Debug("placeBet:%+v", req)
	now := time.Now().Unix()
	var totalBet int64
	var uid int
	var ct common.CurrencyType
	myUUID := call.SnowNode().Generate().Int64()
	for _, v := range req.Txns {
		uid = util.GetIntFromString(v.UserId)
		if uid <= 0 {
			resp.Status = "1036"
			return
		}
		ctName := v.Currency
		if ctName == "USD" {
			ctName = "USDT"
		}
		ct = common.GetCurrencyID(ctName)
		if !ct.IsValid() {
			log.Debug("unknown ct:%v", ct)
			resp.Status = "1036"
			return
		}
		gameID := 0
		var provider *common.ConfigGameProvider
		if v.Platform == "SEXYBCRT" {
			fmt.Sscanf(v.GameCode, "MX-LIVE-%d", &gameID)
			provider = call.GetConfigGameProvider(common.ProviderSexy)
		}
		var betTime int64
		t, err := time.Parse(TimeFormatString, v.BetTime)
		if err != nil {
			betTime = now
		} else {
			betTime = t.Unix()
		}
		betAmount := common.CashFloat64ToInt64(v.BetAmount)
		record := &common.ProviderBetRecord{
			UID:      uid,
			Provider: provider.ProviderID,
			UUID:     v.PlatformTxId,
		}
		db.Mysql().Get(record)
		if record.ID > 0 {
			resp.Status = "1036"
			return
		}
		if err := db.Mysql().Create(&common.ProviderBetRecord{
			UID:          uid,
			Provider:     provider.ProviderID,
			Currency:     ct.GetCurrencyName(),
			CurrencyType: ct,
			GameID:       gameID,
			UUID:         v.PlatformTxId,
			MyUUID:       myUUID,
			Type:         common.SessionTypeBet,
			Time:         now,
			ProviderTime: betTime,
			Amount:       betAmount,
			SessionID:    v.RoundId,
			// TurnOver:     req.TurnOver,
			// Preserve:     req.Preserve,
			Esi: base.SessionSuccess,
		}); err != nil {
			log.Error("err:%v", err)
			resp.Status = "1036"
			return
		}
		totalBet += betAmount
		// log.Debug("betResp:%+v", betResp)
	}
	pro := call.MineCurrencyProReal(
		&common.UpdateCurrency{
			CurrencyBalance: &common.CurrencyBalance{
				UID:   uid,
				Type:  ct,
				Event: common.CurrencyEventGameBet,
				Value: -totalBet,
				Exs1:  fmt.Sprintf("%d", myUUID),
				// Exs2:  req.BetID,
				// Exs3:  req.SessionID,
			},
		},
	)
	if pro.Err != nil {
		log.Error("err:%v", pro.Err)
		resp.Status = "1036"
		if pro.Err == call.ErrNotEnoughBalance {
			resp.Status = "1018"
		}
		return
	}
	resp.Status = "0000"
	resp.Balance = util.Decimal(float64(pro.Balance)/common.DecimalDigits, 4)
	resp.BalanceTs = time.Now().Format(TimeFormatString)
}

func cancelBet(a *app.Gin) {
	req := new(CancelBetReq)
	message := a.TmpData.(string)
	resp := &CancelBetResp{}
	a.RetData = resp
	err := json.Unmarshal([]byte(message), req)
	if err != nil {
		log.Error("err:%v", err)
		resp.Status = "1036"
		return
	}
	now := time.Now().Unix()
	var betResp base.BetResp
	for _, v := range req.Txns {
		uid := util.GetIntFromString(v.UserId)
		if uid <= 0 {
			resp.Status = "1036"
			return
		}
		gameID := 0
		var provider *common.ConfigGameProvider
		if v.Platform == "SEXYBCRT" {
			fmt.Sscanf(v.GameCode, "MX-LIVE-%d", &gameID)
			provider = call.GetConfigGameProvider(common.ProviderSexy)
		}
		var betTime int64
		t, err := time.Parse(TimeFormatString, v.BetTime)
		if err != nil {
			betTime = now
		} else {
			betTime = t.Unix()
		}
		betResp = base.CancelSessionBet(&base.BetReq{
			UID:         uid,
			SessionType: common.SessionTypeBet,
			GameID:      gameID,
			Provider:    provider,
			BetID:       v.PlatformTxId,
			SessionID:   v.RoundId,
			Time:        betTime,
			VoidType:    v.VoidType,
		})
	}
	resp.Status = "0000"
	resp.Balance = util.Decimal(float64(betResp.Balance)/common.DecimalDigits, 4)
	resp.BalanceTs = time.Now().Format(TimeFormatString)
}

type SettleUser struct {
	UID           int
	TotalSettle   int64
	TotalBet      int64
	TotalTurnover int64
}

func settle(a *app.Gin) {
	req := new(SettleReq)
	message := a.TmpData.(string)
	resp := &SettleResp{}
	a.RetData = resp
	err := json.Unmarshal([]byte(message), req)
	if err != nil {
		log.Error("err:%v", err)
		resp.Status = "1036"
		return
	}
	now := time.Now().Unix()
	var settleResp base.SettleResp
	var uid int
	var ct common.CurrencyType
	myUUID := call.SnowNode().Generate().Int64()
	provider := new(common.ConfigGameProvider)
	gameID := 0
	uuid := ""
	settles := map[int]SettleUser{}
	for _, v := range req.Txns {
		uid = util.GetIntFromString(v.UserId)
		if uid <= 0 {
			resp.Status = "1036"
			return
		}
		if v.Platform == "SEXYBCRT" {
			fmt.Sscanf(v.GameCode, "MX-LIVE-%d", &gameID)
			provider = call.GetConfigGameProvider(common.ProviderSexy)
		}
		var settleTime int64
		t, err := time.Parse(TimeFormatString, v.UpdateTime)
		if err != nil {
			settleTime = now
		} else {
			settleTime = t.Unix()
		}
		record := &common.ProviderBetRecord{
			UID:      uid,
			Provider: provider.ProviderID,
			UUID:     v.PlatformTxId,
			Type:     common.SessionTypeBet,
		}
		db.Mysql().Get(record)
		if record.ID == 0 {
			resp.Status = "1036"
			return
		}
		// 重复结算，忽略
		if db.Mysql().Exist(&common.ProviderBetRecord{
			UID:      uid,
			Provider: provider.ProviderID,
			UUID:     v.PlatformTxId,
			Type:     common.SessionTypeSettle,
		}) {
			continue
		}
		ct = record.CurrencyType
		uuid = v.PlatformTxId
		settleAmount := common.CashFloat64ToInt64(v.WinAmount)
		betAmount := common.CashFloat64ToInt64(v.BetAmount)
		turnOver := common.CashFloat64ToInt64(v.TurnOver)
		if err := db.Mysql().Create(&common.ProviderBetRecord{
			UID:          uid,
			Provider:     provider.ProviderID,
			Currency:     ct.GetCurrencyName(),
			CurrencyType: ct,
			GameID:       gameID,
			UUID:         v.PlatformTxId,
			Type:         common.SessionTypeSettle,
			Time:         now,
			ProviderTime: settleTime,
			Amount:       betAmount,
			SessionID:    v.RoundId,
			MyUUID:       myUUID,
			Settle:       settleAmount,
			Esi:          base.SessionSuccess,
		}); err != nil {
			log.Error("err:%v", err)
			resp.Status = "1036"
			return
		}
		user, ok := settles[uid]
		if ok {
			user.TotalBet += betAmount
			user.TotalSettle += settleAmount
			user.TotalTurnover += turnOver
			settles[uid] = user
		} else {
			settles[uid] = SettleUser{
				TotalBet:      betAmount,
				TotalSettle:   settleAmount,
				TotalTurnover: turnOver,
			}
		}
	}
	for i, v := range settles {
		thisUID := i
		if v.TotalSettle != 0 {
			pro := call.UpdateCurrencyProReal(
				&common.UpdateCurrency{
					CurrencyBalance: &common.CurrencyBalance{
						UID:   thisUID,
						Type:  ct,
						Event: common.CurrencyEventGameSettle,
						Value: v.TotalSettle,
						Exs1:  fmt.Sprintf("%d", myUUID),
						// Exs2:  req.BetID,
						// Exs3:  req.SessionID,
					},
				},
			)
			if pro.Err != nil {
				log.Error("err:%v", pro.Err)
				resp.Status = "1036"
				return
			}
			// balance = pro.Balance
		}

		util.IndexTryS(func() error {
			return call.Publish(natsClient.TopicInnerAfterSettle, &pb.InnerAfterSettle{
				UID:          int64(thisUID),
				ProviderID:   int64(provider.ProviderID),
				GameID:       int64(gameID),
				UUID:         uuid,
				CurrencyType: int64(ct),
				TotalBet:     v.TotalTurnover,
				OriginSettle: v.TotalSettle,
				FinalSettle:  v.TotalSettle,
				MyUUID:       fmt.Sprintf("%d", myUUID),
			})
		})
	}
	resp.Status = "0000"
	if settleResp.Code != base.CodeOk {
		resp.Status = "9999"
	}
}

func viodSettle(a *app.Gin) {
	req := new(SettleReq)
	message := a.TmpData.(string)
	resp := &SettleResp{}
	a.RetData = resp
	err := json.Unmarshal([]byte(message), req)
	if err != nil {
		log.Error("err:%v", err)
		resp.Status = "1036"
		return
	}
	// var settleResp base.SettleResp
	for _, v := range req.Txns {
		uid := util.GetIntFromString(v.UserId)
		if uid <= 0 {
			resp.Status = "1036"
			return
		}
		gameID := 0
		var provider *common.ConfigGameProvider
		if v.Platform == "SEXYBCRT" {
			fmt.Sscanf(v.GameCode, "MX-LIVE-%d", &gameID)
			provider = call.GetConfigGameProvider(common.ProviderSexy)
		}
		base.VoidSettle(&base.VoidSettleReq{
			UID:      uid,
			Provider: provider,
			BetID:    v.PlatformTxId,
		})
	}
	resp.Status = "0000"
}

func give(a *app.Gin) {
	req := new(GiveReq)
	message := a.TmpData.(string)
	resp := &GiveResp{}
	a.RetData = resp
	err := json.Unmarshal([]byte(message), req)
	if err != nil {
		log.Error("err:%v", err)
		resp.Status = "1036"
		return
	}
	now := time.Now().Unix()
	// var settleResp base.SettleResp
	for _, v := range req.Txns {
		uid := util.GetIntFromString(v.UserId)
		if uid <= 0 {
			resp.Status = "1036"
			return
		}
		ctName := v.Currency
		if ctName == "USD" {
			ctName = "USDT"
		}
		ct := common.GetCurrencyID(ctName)
		if !ct.IsValid() {
			resp.Status = "1036"
			return
		}
		var provider *common.ConfigGameProvider
		if v.Platform == "SEXYBCRT" {
			provider = call.GetConfigGameProvider(common.ProviderSexy)
		}
		var txTime int64
		t, err := time.Parse(TimeFormatString, v.TxTime)
		if err != nil {
			txTime = now
		} else {
			txTime = t.Unix()
		}
		base.Adjustment(&base.AdjustmentReq{
			Time:         txTime,
			UID:          uid,
			CurrencyType: ct,
			Amount:       common.CashFloat64ToInt64(v.Amount),
			Provider:     provider,
			BetID:        v.PromotionTxId + v.PromotionId,
			Ess:          v.PromotionTypeId,
			Type:         common.SessionTypeActivity,
		})
	}
	resp.Status = "0000"
}

func resettle(a *app.Gin) {
	req := new(SettleReq)
	message := a.TmpData.(string)
	resp := &SettleResp{}
	a.RetData = resp
	err := json.Unmarshal([]byte(message), req)
	if err != nil {
		log.Error("err:%v", err)
		resp.Status = "1036"
		return
	}
	var settleResp base.ReSettleResp
	for _, v := range req.Txns {
		uid := util.GetIntFromString(v.UserId)
		if uid <= 0 {
			resp.Status = "1036"
			return
		}
		var provider *common.ConfigGameProvider
		if v.Platform == "SEXYBCRT" {
			provider = call.GetConfigGameProvider(common.ProviderSexy)
		}
		settleResp = base.Resettle(&base.ReSettleReq{
			UID:          uid,
			SettleAmount: common.CashFloat64ToInt64(v.WinAmount),
			Provider:     provider,
			BetID:        v.PlatformTxId,
		})
	}
	resp.Status = "0000"
	if settleResp.Code != base.CodeOk {
		resp.Status = "9999"
	}
}