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.
649 lines
24 KiB
649 lines
24 KiB
package serviceGame |
|
|
|
import ( |
|
"context" |
|
"crypto/md5" |
|
"encoding/json" |
|
"errors" |
|
"fmt" |
|
"github.com/gogf/gf/v2/encoding/gcharset" |
|
"github.com/gogf/gf/v2/encoding/gjson" |
|
"github.com/gogf/gf/v2/errors/gerror" |
|
"github.com/gogf/gf/v2/frame/g" |
|
"log" |
|
"strconv" |
|
"time" |
|
"tyj_admin/api/v1/game" |
|
"tyj_admin/internal/consts" |
|
"tyj_admin/internal/dao" |
|
"tyj_admin/internal/model/do" |
|
"tyj_admin/internal/model/entity" |
|
"tyj_admin/internal/service" |
|
"tyj_admin/internal/serviceGame/internal" |
|
"tyj_admin/library/libUtils" |
|
"tyj_admin/utils" |
|
) |
|
|
|
type IGameOrder interface { |
|
GetOrders(ctx context.Context, req *game.OrderSearchReq) (res *game.OrderSearchRes, err error) |
|
GetOrderCount(ctx context.Context, req *game.OrderCountReq) (res *game.OrderCountRes, err error) |
|
ChangeCoin(ctx context.Context, req *game.AddCoinReq) (res *game.AddCoinRes, err error) |
|
Deposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error) |
|
GetOrderLog(ctx context.Context, req *game.OrderLogReq) (res *game.OrderLogRes, err error) |
|
GetOrderLogPlatform(ctx context.Context, req *game.OrderLogPlatformReq) (res *game.OrderLogPlatformRes, err error) |
|
GetOrderBehavior(ctx context.Context, req *game.OrderBehaviorReq) (res *game.OrderBehaviorRes, err error) |
|
GetRechargePer(ctx context.Context, req *game.RechargePerReq) (res *game.RechargePerRes, err error) |
|
GameRechargeControl(ctx context.Context, req *game.RechargeControlReq) (res *game.RechargeControlRes, err error) |
|
GetRechargeControl(ctx context.Context, req *game.GetRechargeControlReq) (res *game.GetRechargeControlRes, err error) |
|
AddRechargeControl(ctx context.Context, req *game.AddRechargeControlReq) (res *game.AddRechargeControlRes, err error) |
|
DeleteRechargeControl(ctx context.Context, req *game.DeleteRechargeControlReq) (res *game.DeleteRechargeControlRes, err error) |
|
ChangeOrderState(ctx context.Context, req *game.ChangeOrderStateReq) (res *game.ChangeOrderStateRes, err error) |
|
GetGMOrderList(ctx context.Context, req *game.GetGMOrderListReq) (res *game.GetGMOrderListRes, err error) |
|
CheckRechargeSign(ctx context.Context, req *game.CheckRechargeSignReq) (res *game.CheckRechargeSignRes, err error) |
|
AddRechargeSign(ctx context.Context, req *game.AddRechargeSignReq) (res *game.AddRechargeSignRes, err error) |
|
ResetRechargeSign(ctx context.Context, req *game.ResetRechargeSignReq) (res *game.ResetRechargeSignRes, err error) |
|
GetTransactionId(ctx context.Context, req *game.GetTransactionIdReq) (res *game.GetTransactionIdRes, err error) |
|
GetHuaWeiOrderList(ctx context.Context, req *game.GetHuaWeiOrderListReq) (res *game.GetHuaWeiOrderListRes, err error) |
|
} |
|
|
|
type gameOrderImpl struct { |
|
} |
|
|
|
var gameOrderService = gameOrderImpl{} |
|
|
|
func GameOrder() IGameOrder { |
|
return &gameOrderService |
|
} |
|
|
|
func (o gameOrderImpl) ChangeCoin(ctx context.Context, req *game.AddCoinReq) (res *game.AddCoinRes, err error) { |
|
res = new(game.AddCoinRes) |
|
mqttMoney := internal.MqttChangeMoney{} |
|
mqttMoney.Body.Money = req.Amount |
|
mqttMoney.Body.Uids = req.Uid |
|
mqttMoney.Body.Type = req.AmountType |
|
mqttMoney.Body.ModuleType = "changeMoney" |
|
mqttMoney.ModuleId = "webadmin" |
|
mqttMoney.ReqId = 1 |
|
js, err := json.Marshal(mqttMoney) |
|
connectCh := make(chan bool) |
|
server := "192.168.2.100:3005" |
|
internal.SendMqttMoney(js, connectCh, server) |
|
defer close(connectCh) |
|
var result bool |
|
for { |
|
select { |
|
case result = <-connectCh: |
|
if result == false { |
|
err = gerror.New("失败") |
|
return |
|
} else { |
|
return |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
type AndroIdRecharge struct { |
|
GmMessage string `json:"gmMessage"` |
|
Md5Sign string `json:"md5Sign"` |
|
} |
|
|
|
type Recharge struct { |
|
Uid string `json:"uid"` |
|
Server string `json:"server"` |
|
Channel string `json:"channel"` |
|
RechargeId string `json:"rechargeId"` |
|
OrderNo string `json:"orderNo"` |
|
PayTime string `json:"payTime"` |
|
Amount string `json:"amount"` |
|
Status string `json:"status"` |
|
} |
|
|
|
type IosRecharge struct { |
|
OrderId string `json:"orderId"` |
|
Account string `json:"uid"` |
|
Receipt string `json:"receipt"` |
|
Server string `json:"server"` |
|
TimeStamp string `json:"timeStamp"` |
|
ItemId string `json:"itemId"` |
|
Gm string `json:"gm"` |
|
Token string `json:"token"` |
|
} |
|
|
|
type DepositResult struct { |
|
Status int `json:"status"` |
|
Code interface{} `json:"code"` |
|
Msg string `json:"msg"` |
|
} |
|
|
|
func checkQuickMd5(nt_data string, sign string, md5Sign string) bool { |
|
return md5Sign == fmt.Sprintf("%x", md5.Sum([]byte(nt_data+sign+internal.Md5key))) |
|
} |
|
func encryptData(code_data string) string { |
|
dataArr := []rune(code_data) |
|
keyArr := []byte(internal.CallbackKey) |
|
keyLen := len(keyArr) |
|
|
|
var tmpList []int |
|
|
|
for index, value := range dataArr { |
|
base := int(value) |
|
dataString := base + int(0xFF&keyArr[index%keyLen]) |
|
tmpList = append(tmpList, dataString) |
|
} |
|
|
|
var str string |
|
|
|
for _, value := range tmpList { |
|
str += "@" + fmt.Sprintf("%d", value) |
|
} |
|
return str |
|
} |
|
|
|
func (o gameOrderImpl) Deposit(ctx context.Context, req *game.OrderDepositReq) (res *game.OrderDepositRes, err error) { |
|
gmMessage := Recharge{} |
|
//gmMessage.Server = fmt.Sprint(req.ServerId) |
|
gmMessage.RechargeId = fmt.Sprint(req.DepositId) |
|
//gmMessage.Channel = req.Channel |
|
|
|
gmMessage.OrderNo = fmt.Sprintf("GM%v%v", req.Uid, time.Now().UnixMilli()) |
|
//gmMessage.OrderNo = fmt.Sprintf("GM%v%v%v", req.Uid, 11111111111, 22222) |
|
if req.Count == 1 { |
|
gmMessage.OrderNo = fmt.Sprintf("G2M%v%v", req.Uid, time.Now().UnixMilli()) |
|
} |
|
gmMessage.PayTime = time.Now().Format(consts.TIME_FORMAT) |
|
gmMessage.Amount = fmt.Sprint(req.Amount) |
|
gmMessage.Status = "SUCCESS" |
|
unit, err := internal.GetUnitByUid(ctx, req.Uid, req.ServerId) |
|
//uid, err := internal.GetIdToUid(ctx, req.Uid) |
|
if err != nil { |
|
log.Println("GetOrders 1 : ", req.Uid) |
|
return nil, err |
|
} |
|
if req.ServerId != unit.Server { |
|
var serverInfo entity.GameLoginUrl |
|
for _, v := range internal.ServerList { |
|
if v.Id == unit.Server { |
|
serverInfo = v |
|
break |
|
} |
|
} |
|
return nil, errors.New("区服选择错误！当前id在<" + fmt.Sprint(serverInfo.Id) + "><" + serverInfo.Name + ">区") |
|
} |
|
gmMessage.Server = fmt.Sprint(unit.Server) |
|
gmMessage.Channel = unit.Channel |
|
gmMessage.Uid = fmt.Sprint(unit.Uid) |
|
recharge := AndroIdRecharge{} |
|
data, _ := json.Marshal(gmMessage) |
|
recharge.GmMessage = encryptData(string(data)) |
|
recharge.Md5Sign = fmt.Sprintf("%x", md5.Sum([]byte(recharge.GmMessage+internal.Md5key))) |
|
fmt.Println("Deposit - json: ", string(data), recharge.Md5Sign) |
|
url := internal.RechargeServer + "/gmPay/notify" |
|
rs, err := g.Client().Post(ctx, url, recharge) |
|
if err != nil { |
|
log.Println("Post 1 : ", req.Uid, url, gjson.MustEncodeString(recharge)) |
|
return nil, err |
|
} |
|
|
|
src := string(rs.ReadAll()) |
|
tmp, _ := gcharset.ToUTF8("UTF-8", src) |
|
fmt.Println("Deposit - json: ", tmp) |
|
|
|
go insertRechargeLog(ctx, gmMessage, tmp) |
|
if tmp != "SUCCESS" { |
|
g.Log().Info(ctx, " Deposit === DecodeToJson err ", req.Uid, err.Error()) |
|
return nil, errors.New(tmp) |
|
} |
|
|
|
return |
|
} |
|
|
|
func insertRechargeLog(ctx context.Context, req Recharge, remark string) (err error) { |
|
_, err = dao.GameRechargeLog.Ctx(ctx).Insert(&do.GameRechargeLog{ |
|
UnitId: req.Uid, |
|
Channel: req.Channel, |
|
Server: req.Server, |
|
Amount: req.Amount, |
|
Config: req.RechargeId, |
|
TradeNo: req.OrderNo, |
|
User: service.Context().GetLoginUser(ctx).UserName, |
|
Remark: remark, |
|
}) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetOrders(ctx context.Context, req *game.OrderSearchReq) (res *game.OrderSearchRes, err error) { |
|
if req.PageSize == 0 { |
|
req.PageSize = 10 |
|
} |
|
orderModel := dao.GameRecharge.Ctx(ctx) |
|
if req.Account != "" { |
|
uid, err := internal.AccountToUids(ctx, utils.GetAccount(req.Account, req.Channel)) |
|
if err != nil { |
|
return nil, err |
|
} |
|
orderModel = orderModel.Where(`unitId in (?) `, uid) |
|
} else if req.Id != "" { |
|
uid, err := strconv.ParseInt(req.Id, 10, 64) |
|
if err != nil { |
|
return nil, err |
|
} |
|
orderModel = orderModel.Where(`unitId=? `, uid) |
|
} else if req.Uid != 0 { |
|
uid, err := internal.GetIdToUid(ctx, int64(req.Uid)) |
|
if err != nil { |
|
return nil, err |
|
} |
|
orderModel = orderModel.Where(`unitId=? `, uid) |
|
} |
|
if req.Channel != "" { |
|
orderModel = orderModel.Where(`channel=?`, req.Channel) |
|
} |
|
if req.ExternalOrderId != "" { |
|
orderModel = orderModel.Where(`externalTradeNo=?`, req.ExternalOrderId) |
|
} |
|
if req.OrderId != "" { |
|
orderModel = orderModel.Where(`tradeNo=?`, req.OrderId) |
|
} |
|
if req.Status != 0 { |
|
orderModel = orderModel.Where(`status=?`, req.Status) |
|
} |
|
|
|
res = new(game.OrderSearchRes) |
|
res.Total, err = orderModel.Count() |
|
if err != nil { |
|
log.Println("GetOrdersBy", err.Error()) |
|
} |
|
|
|
orderModel.Page(int(req.PageNum), int(req.PageSize)).OrderDesc("createTime").Scan(&res.Orders) |
|
for k, v := range res.Orders { |
|
res.Orders[k].StringId = fmt.Sprint(v.UnitId) |
|
uid, _ := internal.GetIdToUid(ctx, v.UnitId) |
|
res.Orders[k].Uid = int32(uid) |
|
} |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetOrderCount(ctx context.Context, req *game.OrderCountReq) (res *game.OrderCountRes, err error) { |
|
res = new(game.OrderCountRes) |
|
sql := fmt.Sprintf(`select unitId,sum(amount) as amount,max(server) as server from game_recharge where 1=1 and status=2`) |
|
if req.GM == 0 { |
|
sql = fmt.Sprintf(`%s and tradeNo NOT LIKE 'GM%%'`, sql) |
|
} |
|
if req.Server != 0 { |
|
sql = fmt.Sprintf(`%s and server=%d`, sql, req.Server) |
|
} |
|
sql = fmt.Sprintf(`%s group by unitId`, sql) |
|
|
|
sql = fmt.Sprintf(`select u.account,r.unitId as id,r.amount as allMoney,r.server as serverId from (%s) as r inner join game_unit as u on u.uid=r.unitId where 1=1`, sql) |
|
sql = internal.CompareSqlType(sql, req.Amount, "r.amount", req.CompareType) |
|
res.Total, err = g.Model().Raw(sql).Count() |
|
if err != nil { |
|
log.Println("GetOrderCount 1 : ", err.Error()) |
|
return |
|
} |
|
err = g.Model().Raw(sql).Page(req.PageNum, req.PageSize).OrderAsc("u.account").Scan(&res.Orders) |
|
if err != nil { |
|
log.Println("GetOrderCount 2 : ", err.Error()) |
|
return |
|
} |
|
for k, v := range res.Orders { |
|
if v.Id == 0 { |
|
continue |
|
} |
|
res.Orders[k].StringId = fmt.Sprint(v.Id) |
|
log.Println("GetOrderCount 31 : ", v.Id) |
|
uid, err := internal.GetIdToUid(ctx, v.Id) |
|
if err != nil { |
|
log.Println("GetOrderCount 3 : ", v.Id, uid, err.Error()) |
|
continue |
|
} |
|
res.Orders[k].Uid = int32(uid) |
|
} |
|
log.Println("GetOrderCount 4 : ", gjson.MustEncodeString(res.Orders)) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetOrderLog(ctx context.Context, req *game.OrderLogReq) (res *game.OrderLogRes, err error) { |
|
res = new(game.OrderLogRes) |
|
|
|
g.Try(ctx, func(ctx context.Context) { |
|
modelTotal := dao.GameRegister.Ctx(ctx) |
|
if req.StartTime != 0 { |
|
modelTotal = modelTotal.Where(`UNIX_TIMESTAMP(create_time)>?`, req.StartTime/1000) |
|
} |
|
if req.EndTime != 0 { |
|
modelTotal = modelTotal.Where(`UNIX_TIMESTAMP(create_time)<?`, req.EndTime/1000) |
|
} |
|
if req.Channel != "" { |
|
modelTotal = modelTotal.Where(`channel=?`, req.Channel) |
|
if req.ServerId != 0 { |
|
modelTotal = modelTotal.Where(`server like ?`, "<"+fmt.Sprint(req.ServerId)+">") |
|
} |
|
} |
|
modelTotal.Group("channel").FieldMax("channel", "channel").FieldCount("account", "totalAccount").Scan(&res.AccountTotal) |
|
|
|
var sql = fmt.Sprintf("select max(r.channel) as channel, sum(r.amount) as amount, u.account from game_recharge as r inner join game_unit as u on u.uid=r.unitId where r.status=2 and r.tradeNo NOT LIKE 'GM%%' ") |
|
if req.StartTime != 0 { |
|
sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)>%d`, req.StartTime/1000) |
|
} |
|
if req.EndTime != 0 { |
|
sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)<%d`, req.EndTime/1000) |
|
} |
|
if req.RechargeTotal > 0 { |
|
sql = internal.CompareSqlType(sql, req.RechargeTotal, "r.amount", req.CompareType1) |
|
} |
|
if req.Channel != "" { |
|
sql += fmt.Sprintf(` and r.channel="%s"`, req.Channel) |
|
if req.ServerId != 0 { |
|
sql += fmt.Sprintf(` and r.server=%d`, req.ServerId) |
|
} |
|
} |
|
sql += fmt.Sprint(" group by u.account,r.channel") |
|
|
|
amountSql := fmt.Sprintf(`select max(a.channel) as channel, sum(a.amount) as totalAmount from (%s) as a WHERE 1=1 `, sql) |
|
if req.RechargeMin > 0 { |
|
amountSql = internal.CompareSqlType(amountSql, req.RechargeMin, "a.amount", req.CompareType) |
|
} |
|
amountSql += " group by a.channel" |
|
g.Model().Raw(amountSql).Scan(&res.AmountTotal) |
|
|
|
accountSql := fmt.Sprintf(`select max(a.channel) as channel, count(1) as totalAccount from (%s) as a WHERE 1=1 `, sql) |
|
if req.RechargeMin > 0 { |
|
accountSql = internal.CompareSqlType(accountSql, req.RechargeMin, "a.amount", req.CompareType) |
|
} |
|
accountSql += " group by a.channel" |
|
g.Model().Raw(accountSql).Scan(&res.RechargeAccountTotal) |
|
|
|
log.Printf("GetOrderLog: %v, %v, %v", gjson.MustEncodeString(res.AmountTotal), gjson.MustEncodeString(res.AccountTotal), gjson.MustEncodeString(res.RechargeAccountTotal)) |
|
}) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetOrderLogPlatform(ctx context.Context, req *game.OrderLogPlatformReq) (res *game.OrderLogPlatformRes, err error) { |
|
res = new(game.OrderLogPlatformRes) |
|
|
|
g.Try(ctx, func(ctx context.Context) { |
|
var sql = fmt.Sprintf("select r.channel, sum(r.amount) as amount,u.account, r.platform from game_recharge as r inner join game_unit as u on u.uid=r.unitId where r.status=2 and r.tradeNo NOT LIKE 'GM%%' ") |
|
if req.StartTime != 0 { |
|
sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)>%d`, req.StartTime/1000) |
|
} |
|
if req.EndTime != 0 { |
|
sql += fmt.Sprintf(` and UNIX_TIMESTAMP(r.createTime)<%d`, req.EndTime/1000) |
|
} |
|
if req.RechargeTotal > 0 { |
|
sql = internal.CompareSqlType(sql, req.RechargeTotal, "r.amount", req.CompareType1) |
|
} |
|
if req.Channel != "" { |
|
sql += fmt.Sprintf(` and r.channel="%s"`, req.Channel) |
|
if req.ServerId != 0 { |
|
sql += fmt.Sprintf(` and r.server=%d`, req.ServerId) |
|
} |
|
} |
|
sql += fmt.Sprint(" group by u.account,r.channel,r.platform") |
|
|
|
amountSql := fmt.Sprintf(`select a.channel, sum(a.amount) as totalAmount, a.platform from (%s) as a WHERE 1=1 `, sql) |
|
if req.RechargeMin > 0 { |
|
amountSql = internal.CompareSqlType(amountSql, req.RechargeMin, "a.amount", req.CompareType) |
|
} |
|
amountSql += " group by a.channel,a.platform" |
|
g.Model().Raw(amountSql).Scan(&res.AmountTotal) |
|
|
|
log.Printf("GetOrderLog: %v, %v, %v", gjson.MustEncodeString(res.AmountTotal), gjson.MustEncodeString(res.AccountTotal), gjson.MustEncodeString(res.RechargeAccountTotal)) |
|
}) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetOrderBehavior(ctx context.Context, req *game.OrderBehaviorReq) (res *game.OrderBehaviorRes, err error) { |
|
res = new(game.OrderBehaviorRes) |
|
if req.StartTime == "" { |
|
return nil, errors.New("填写注册时间！") |
|
} |
|
err = g.Try(ctx, func(ctx context.Context) { |
|
modelTotal := dao.GameRegister.Ctx(ctx) |
|
modelTotal = modelTotal.Where(`STR_TO_DATE(create_time, "%Y-%m-%d")=?`, req.StartTime) |
|
modelTotal.Fields("max(channel) as channel, count(1) as totalAccount").Group("channel").Scan(&res.Account) |
|
|
|
sql := fmt.Sprintf(`select account from game_register where STR_TO_DATE(create_time, "%%Y-%%m-%%d")="%s"`, req.StartTime) |
|
sql = fmt.Sprintf(`select u.account,u.uid from game_unit as u inner join (%s) as a on a.account=u.account`, sql) |
|
|
|
amountSql := fmt.Sprintf(`select max(r.channel) as channel, sum(r.amount) as totalAmount, STR_TO_DATE(r.createTime, "%%Y-%%m-%%d") as createTime |
|
from game_recharge as r inner join (%s) as c on c.uid=r.unitId where r.status=2 and r.tradeNo NOT LIKE 'GM%%' group by r.channel,STR_TO_DATE(r.createTime, "%%Y-%%m-%%d")`, sql) |
|
g.Model().Raw(amountSql).Scan(&res.AmountList) |
|
|
|
accountSql := fmt.Sprintf(`SELECT max( a.channel ) AS channel,count(a.account) as totalAccount,a.createTime as createTime |
|
FROM (SELECT max( r.channel ) AS channel, c.account AS account,min(STR_TO_DATE( r.createTime, "%%Y-%%m-%%d" )) AS createTime |
|
FROM game_recharge AS r INNER JOIN (%s) AS c ON c.uid = r.unitId WHERE r.STATUS = 2 AND r.tradeNo NOT LIKE 'GM%%' GROUP BY r.channel, c.account) as a |
|
GROUP BY a.channel,a.createTime`, sql) |
|
g.Model().Raw(accountSql).Scan(&res.RechargeAccount) |
|
|
|
log.Printf("GetOrderBehavior: %v, %v, %v", gjson.MustEncodeString(res.Account), gjson.MustEncodeString(res.AmountList), gjson.MustEncodeString(res.RechargeAccount)) |
|
}) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetRechargePer(ctx context.Context, req *game.RechargePerReq) (res *game.RechargePerRes, err error) { |
|
res = new(game.RechargePerRes) |
|
if req.StartTime == "" || req.EndTime == "" { |
|
return nil, errors.New("填写注册时间！") |
|
} |
|
err = g.Try(ctx, func(ctx context.Context) { |
|
modelTotal := dao.GameRegister.Ctx(ctx) |
|
modelTotal = modelTotal.Where(`tradeNo NOT LIKE 'GM%'`).Where(`STR_TO_DATE(create_time, "%Y-%m-%d")>=?`, req.StartTime).Where(`STR_TO_DATE(create_time, "%Y-%m-%d")<=?`, req.EndTime) |
|
modelTotal.Fields("max(channel) as channel, count(1) as totalAccount, STR_TO_DATE(create_time, \"%Y-%m-%d\") as createTime").Group("channel,STR_TO_DATE(create_time, \"%Y-%m-%d\")").Scan(&res.Account) |
|
|
|
sql := fmt.Sprintf(`select account,STR_TO_DATE(create_time, "%%Y-%%m-%%d") as createTime from game_register where STR_TO_DATE(create_time, "%%Y-%%m-%%d")>="%s" and STR_TO_DATE(create_time, "%%Y-%%m-%%d")<="%s"`, req.StartTime, req.EndTime) |
|
sql = fmt.Sprintf(`select u.account,u.uid,a.createTime from game_unit as u inner join (%s) as a on a.account=u.account`, sql) |
|
accountSql := fmt.Sprintf(`select max(r.channel) as channel, count(DISTINCT c.account) as totalAccount, c.createTime |
|
from game_recharge as r inner join (%s) as c on c.uid=r.unitId where status=2 and tradeNo NOT LIKE 'GM%%' group by r.channel,c.createTime`, sql) |
|
g.Model().Raw(accountSql).Scan(&res.RechargeAccount) |
|
|
|
log.Printf("GetOrderBehavior: %v, %v", gjson.MustEncodeString(res.Account), gjson.MustEncodeString(res.RechargeAccount)) |
|
}) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GameRechargeControl(ctx context.Context, req *game.RechargeControlReq) (res *game.RechargeControlRes, err error) { |
|
res = new(game.RechargeControlRes) |
|
model := dao.GameRechargeControl.Ctx(ctx) |
|
var list []*entity.GameRechargeControl |
|
model.Where("channel=?", req.Channel).Scan(&list) |
|
if len(list) == 0 { |
|
res.State = 1 |
|
} |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetRechargeControl(ctx context.Context, req *game.GetRechargeControlReq) (res *game.GetRechargeControlRes, err error) { |
|
res = new(game.GetRechargeControlRes) |
|
dao.GameRechargeControl.Ctx(ctx).Scan(&res.Control) |
|
|
|
return |
|
} |
|
|
|
func (o gameOrderImpl) AddRechargeControl(ctx context.Context, req *game.AddRechargeControlReq) (res *game.AddRechargeControlRes, err error) { |
|
res = new(game.AddRechargeControlRes) |
|
_, err = dao.GameRechargeControl.Ctx(ctx).Insert(do.GameRechargeControl{Channel: req.Channel}) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) DeleteRechargeControl(ctx context.Context, req *game.DeleteRechargeControlReq) (res *game.DeleteRechargeControlRes, err error) { |
|
res = new(game.DeleteRechargeControlRes) |
|
_, err = dao.GameRechargeControl.Ctx(ctx).Where("channel=?", req.Channel).Delete() |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) ChangeOrderState(ctx context.Context, req *game.ChangeOrderStateReq) (res *game.ChangeOrderStateRes, err error) { |
|
res = new(game.ChangeOrderStateRes) |
|
update := g.Map{ |
|
dao.GameRecharge.Columns().Status: req.State, |
|
} |
|
if req.Remark != "" { |
|
update[dao.GameRecharge.Columns().Remark] = req.Remark |
|
} |
|
_, err = dao.GameRecharge.Ctx(ctx).Where(dao.GameRecharge.Columns().TradeNo, req.Order).Update(update) |
|
if err == nil { |
|
res.ResData = 1 |
|
} |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetGMOrderList(ctx context.Context, req *game.GetGMOrderListReq) (res *game.GetGMOrderListRes, err error) { |
|
res = new(game.GetGMOrderListRes) |
|
model := dao.GameRechargeLog.Ctx(ctx) |
|
if req.Uid != 0 { |
|
id, _ := internal.GetIdToUid(ctx, int64(req.Uid)) |
|
model = model.Where("unitId=?", id) |
|
} |
|
if req.ServerId != 0 { |
|
model = model.Where("server=?", req.ServerId) |
|
} |
|
if req.TradeNo != "" { |
|
model = model.Where("tradeNo=?", req.TradeNo) |
|
} |
|
if req.CTime != "" { |
|
t, _ := time.ParseInLocation(consts.TIME_FORMAT, req.CTime, time.Local) |
|
model = model.Where("UNIX_TIMESTAMP(create_time)>=?", t.Unix()) |
|
} |
|
if req.ETime != "" { |
|
t, _ := time.ParseInLocation(consts.TIME_FORMAT, req.ETime, time.Local) |
|
model = model.Where("createTime<=?", t.Unix()) |
|
} |
|
if req.User != "" { |
|
model = model.Where("user=?", req.User) |
|
} |
|
if req.Config != 0 { |
|
model = model.Where("config=?", req.Config) |
|
} |
|
if req.Channel != "" { |
|
model = model.Where("channel=?", req.Channel) |
|
} |
|
res.Total, err = model.Count() |
|
if err != nil { |
|
return nil, err |
|
} |
|
err = model.Page(req.PageNum, req.PageSize).Scan(&res.List) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) CheckRechargeSign(ctx context.Context, req *game.CheckRechargeSignReq) (res *game.CheckRechargeSignRes, err error) { |
|
res = new(game.CheckRechargeSignRes) |
|
if req.ServerId == 0 { |
|
ip := libUtils.GetClientIp(ctx) |
|
data := []entity.GameRouter{} |
|
err := dao.GameRouter.Ctx(ctx).Where("router_ip=?", ip).Scan(&data) |
|
//log.Printf("data: %s", gjson.MustEncodeString(data)) |
|
if len(data) == 0 { |
|
return nil, err |
|
} |
|
req.ServerId = int32(data[0].Id) |
|
} |
|
if req.Id == 0 || req.ServerId == 0 { |
|
return res, errors.New("账号为空") |
|
} |
|
list := []entity.GameRechargeLevel{} |
|
err = dao.GameRechargeLevel.Ctx(ctx).Where("unitId=?", req.Id).Where("server=?", req.ServerId).Scan(&list) |
|
if err != nil { |
|
log.Printf("CheckRechargeSign: %v, %v", gjson.MustEncodeString(res), err) |
|
return res, err |
|
} |
|
for _, v := range list { |
|
res.List = append(res.List, v.Config) |
|
} |
|
return |
|
} |
|
|
|
// http://192.168.2.100:4111/frontApi/game/setOrderLevel?unitId=1&server=&time=250726&token&config=101 |
|
func (o gameOrderImpl) AddRechargeSign(ctx context.Context, req *game.AddRechargeSignReq) (res *game.AddRechargeSignRes, err error) { |
|
serverId := req.ServerId |
|
if serverId == 0 { |
|
ip := libUtils.GetClientIp(ctx) |
|
data := []entity.GameRouter{} |
|
err := dao.GameRouter.Ctx(ctx).Where("router_ip=?", ip).Scan(&data) |
|
//log.Printf("AddRechargeSign data: %s", gjson.MustEncodeString(data)) |
|
if len(data) == 0 { |
|
log.Printf("AddRechargeSign err : %s", err.Error()) |
|
return nil, err |
|
} |
|
serverId = int32(data[0].Id) |
|
} |
|
|
|
if req.Id == 0 || serverId == 0 || req.Config == 0 || req.Time == 0 { |
|
return nil, errors.New("参数为空") |
|
} |
|
token := fmt.Sprintf("%x", md5.Sum([]byte("#colony"+fmt.Sprint(req.Id)+fmt.Sprint(req.ServerId)+fmt.Sprint(req.Config)+fmt.Sprint(req.Time)+"$"))) |
|
if req.Token != token { |
|
log.Printf("[%s]AddRechargeSign failed, token error, md5: %s", gjson.MustEncodeString(req), token) |
|
return nil, errors.New("token err") |
|
} |
|
req.ServerId = serverId |
|
|
|
count, err := dao.GameRechargeLevel.Ctx(ctx).Where("unitId=?", req.Id).Where("server=?", req.ServerId).Where("config=?", req.Config).Count() |
|
if err != nil { |
|
log.Printf("req: %s, AddRechargeSign: err: %v", gjson.MustEncodeString(req), err) |
|
return nil, err |
|
} |
|
if count > 0 { |
|
log.Printf("req: %s, AddRechargeSign: count：%v", gjson.MustEncodeString(req), count) |
|
return nil, errors.New("is in list") |
|
} |
|
|
|
_, err = dao.GameRechargeLevel.Ctx(ctx).Insert(do.GameRechargeLevel{UnitId: req.Id, Server: req.ServerId, Config: req.Config}) |
|
if err != nil { |
|
log.Printf("req: %s, AddRechargeSign: %v, err: %v", gjson.MustEncodeString(req), gjson.MustEncodeString(res), err) |
|
return nil, err |
|
} |
|
return nil, errors.New("ok") |
|
} |
|
|
|
func (o gameOrderImpl) ResetRechargeSign(ctx context.Context, req *game.ResetRechargeSignReq) (res *game.ResetRechargeSignRes, err error) { |
|
user := service.Context().GetLoginUser(ctx) |
|
fulluser, err1 := service.User().GetUserByUsername(ctx, user.UserName) |
|
if err1 != nil { |
|
return nil, err1 |
|
} |
|
password := libUtils.EncryptPassword(req.Password, fulluser.UserSalt) |
|
if fulluser.UserPassword != password { |
|
log.Printf("ResetRechargeSign 密码错误! fulluser: %v, pwd: %s", gjson.MustEncodeString(fulluser), password) |
|
return nil, errors.New("密码错误!") |
|
} |
|
result, err := dao.GameRechargeLevel.Ctx(ctx).Where("1=1").Delete() |
|
if err != nil { |
|
log.Printf("ResetRechargeSign: %v", err) |
|
return nil, err |
|
} |
|
rows, err := result.RowsAffected() |
|
if err != nil { |
|
log.Printf("ResetRechargeSign: %v", err) |
|
return nil, err |
|
} |
|
log.Printf("ResetRechargeSign: %v", rows) |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetTransactionId(ctx context.Context, req *game.GetTransactionIdReq) (res *game.GetTransactionIdRes, err error) { |
|
res = new(game.GetTransactionIdRes) |
|
|
|
// 查询订单（示例订单号） |
|
order, err := internal.QueryAppleOrder(req.Order) |
|
if err != nil { |
|
log.Printf("查询失败: %v", err) |
|
return |
|
} |
|
res.Order = order |
|
return |
|
} |
|
|
|
func (o gameOrderImpl) GetHuaWeiOrderList(ctx context.Context, req *game.GetHuaWeiOrderListReq) (res *game.GetHuaWeiOrderListRes, err error) { |
|
res = new(game.GetHuaWeiOrderListRes) |
|
startAt, _ := strconv.ParseInt(req.StartAt, 10, 64) |
|
endAt, _ := strconv.ParseInt(req.EndAt, 10, 64) |
|
order, err := service.GetHuaWeiOrderList(req.ContinuationToken, startAt, endAt) |
|
if err != nil { |
|
log.Printf("查询失败: %v", err) |
|
return |
|
} |
|
res.Order = *order |
|
return |
|
}
|
|
|