You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
554 lines
13 KiB
554 lines
13 KiB
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 := int64(v.BetAmount * common.DecimalDigits) |
|
// betResp = base.SessionBet(&base.BetReq{ |
|
// UID: uid, |
|
// CurrencyType: ct, |
|
// // SettleAmount: int64(req.WinLoseAmount * common.DecimalDigits), |
|
// BetAmount: betAmount, |
|
// // TurnOver: int64(req.TurnOver * common.DecimalDigits), |
|
// // Preserve: int64(req.Preserve * common.DecimalDigits), |
|
// SessionType: base.SessionTypeBet, |
|
// GameID: gameID, |
|
// Provider: provider, |
|
// BetID: v.PlatformTxId, |
|
// SessionID: v.RoundId, |
|
// Time: betTime, |
|
// }) |
|
|
|
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: base.SessionTypeBet, |
|
Time: 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, |
|
// CurrencyType: ct, |
|
// SettleAmount: int64(req.WinLoseAmount * common.DecimalDigits), |
|
// BetAmount: int64(v.BetAmount * common.DecimalDigits), |
|
// TurnOver: int64(req.TurnOver * common.DecimalDigits), |
|
// Preserve: int64(req.Preserve * common.DecimalDigits), |
|
SessionType: base.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() |
|
} |
|
// settleResp = base.Settle(&base.SettleReq{ |
|
// UID: uid, |
|
// // CurrencyType: ct, |
|
// SettleAmount: int64(v.WinAmount * common.DecimalDigits), |
|
// BetAmount: int64(v.BetAmount * common.DecimalDigits), |
|
// TurnOver: int64(v.TurnOver * common.DecimalDigits), |
|
// // Preserve: int64(v.Preserve * common.DecimalDigits), |
|
// GameID: gameID, |
|
// Provider: provider, |
|
// BetID: v.PlatformTxId, |
|
// SessionID: v.RoundId, |
|
// Time: settleTime, |
|
// }) |
|
record := &common.ProviderBetRecord{ |
|
UID: uid, |
|
Provider: provider.ProviderID, |
|
UUID: v.PlatformTxId, |
|
Type: base.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: base.SessionTypeSettle, |
|
}) { |
|
continue |
|
} |
|
ct = record.CurrencyType |
|
uuid = v.PlatformTxId |
|
settleAmount := int64(v.WinAmount * common.DecimalDigits) |
|
betAmount := int64(v.BetAmount * common.DecimalDigits) |
|
turnOver := int64(v.TurnOver * common.DecimalDigits) |
|
if err := db.Mysql().Create(&common.ProviderBetRecord{ |
|
UID: uid, |
|
Provider: provider.ProviderID, |
|
Currency: ct.GetCurrencyName(), |
|
CurrencyType: ct, |
|
GameID: gameID, |
|
UUID: v.PlatformTxId, |
|
Type: base.SessionTypeSettle, |
|
Time: 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 |
|
} |
|
// else { |
|
// balance = call.GetUserCurrency(uid, ct) |
|
// } |
|
// call.UpdatePlayerProfile(&common.ESGameData{ |
|
// UID: thisUID, |
|
// Provider: provider.ProviderID, |
|
// GameID: gameID, |
|
// UUID: uuid, |
|
// Type: ct, |
|
// BetAmount: v.TotalTurnover, |
|
// SettleAmount: v.TotalSettle, |
|
// MyUUID: fmt.Sprintf("%d", myUUID), |
|
// }) |
|
|
|
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: int64(v.Amount * common.DecimalDigits), |
|
Provider: provider, |
|
BetID: v.PromotionTxId + v.PromotionId, |
|
Ess: v.PromotionTypeId, |
|
Type: base.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: int64(v.WinAmount * common.DecimalDigits), |
|
Provider: provider, |
|
BetID: v.PlatformTxId, |
|
}) |
|
} |
|
resp.Status = "0000" |
|
if settleResp.Code != base.CodeOk { |
|
resp.Status = "9999" |
|
} |
|
}
|
|
|