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.
1193 lines
38 KiB
1193 lines
38 KiB
package internal |
|
|
|
import ( |
|
"context" |
|
"database/sql" |
|
"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" |
|
"github.com/gogf/gf/v2/os/gtime" |
|
"go.mongodb.org/mongo-driver/bson" |
|
"go.mongodb.org/mongo-driver/bson/primitive" |
|
"log" |
|
"strconv" |
|
"strings" |
|
"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/library/libUtils" |
|
"tyj_admin/library/liberr" |
|
) |
|
|
|
func LogInit() { |
|
for k, sv := range ServerConfig { |
|
go loadServeronline(k, sv) |
|
} |
|
return |
|
} |
|
func loadServeronline(k, sv string) { |
|
ctx := context.TODO() |
|
model := dao.LoginOutLog.Ctx(ctx) |
|
srcCharset := "UTF-8" |
|
ids := []int64{} |
|
url := "http://" + sv + "/GetOnline" |
|
g.Client().SetHeader("Content-Type", "application/json;charset=UTF-8") |
|
bytes := g.Client().GetBytes(ctx, url) |
|
src := string(bytes) |
|
if g.IsEmpty(src) { |
|
g.Log().Info(ctx, " GetOnline === return nil ", sv) |
|
return |
|
} |
|
tmp, _ := gcharset.ToUTF8(srcCharset, src) |
|
json, err := gjson.DecodeToJson(tmp) |
|
if err != nil { |
|
g.Log().Info(ctx, " GetOnline === DecodeToJson err ", sv, err.Error()) |
|
return |
|
} |
|
g.Log().Info(ctx, " GetOnline === ", sv, json) |
|
if json.Get("Error").Int() == 200 { |
|
accounts := json.Get("Accounts").Array() |
|
g.Log().Info(ctx, " InitMysql === ", accounts) |
|
for _, v := range accounts { |
|
account := v.(string) |
|
uv1, _ := strconv.ParseInt(account, 0, 64) |
|
ids = append(ids, uv1) |
|
} |
|
g.Log().Info(ctx, " InitMysql ids=== ", ids) |
|
} |
|
|
|
if len(ids) > 0 { |
|
model = model.WhereNotIn("uid", ids) |
|
} |
|
id, err := strconv.Atoi(k) |
|
model.Where("server=?", id).Where("e_date=?", 0).Update("e_date=c_date") |
|
g.Log().Info(ctx, "a== ", ids) |
|
} |
|
|
|
func GetRoleList(ctx context.Context, req *game.RoleSearchReq) (res *game.RoleSearchRes, err error) { |
|
query := bson.M{"_t": "Unit"} |
|
if req.Id != "" { |
|
query["_id"], _ = strconv.ParseInt(req.Id, 10, 64) |
|
} |
|
if req.ServerId == 0 { |
|
return |
|
} |
|
if req.Account != "" { |
|
query["_id"], err = GetAccountUid2(ctx, req.Account, fmt.Sprint(req.ServerId)) |
|
if err != nil { |
|
return |
|
} |
|
} |
|
if req.Uid != 0 { |
|
query["UniqueId"] = req.Uid |
|
} |
|
|
|
fmt.Println("GetRoleList: query ", query) |
|
res = new(game.RoleSearchRes) |
|
mongo, ok := MongoDatabaseList[fmt.Sprint(req.ServerId)] |
|
|
|
if !ok { |
|
return |
|
} |
|
|
|
res.Total, err = mongo.Collection("Unit").Find(ctx, query).Count() |
|
err = mongo.Collection("Unit").Find(ctx, query).Skip((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).All(&res.RoleList) |
|
for _, v := range res.RoleList { |
|
v["StringId"] = fmt.Sprint(v["_id"]) |
|
if _, ok := v["C"]; ok { |
|
c1 := v["C"].(primitive.A) |
|
for _, c2 := range c1 { |
|
c22 := c2.(map[string]interface{}) |
|
c22["StringId"] = fmt.Sprint(c22["_id"]) |
|
if _, ok := c22["Children"]; ok { |
|
children, _ := c22["Children"].(primitive.A) |
|
for _, c := range children { |
|
cc1 := c.(map[string]interface{}) |
|
cc1["StringId"] = fmt.Sprint(cc1["_id"]) |
|
if _, ok := cc1["C"]; ok { |
|
cc := cc1["C"].(primitive.A) |
|
for _, cK := range cc { |
|
cK1 := cK.(map[string]interface{}) |
|
cK1["StringId"] = fmt.Sprint(cK1["_id"]) |
|
if _, ok := cK1["SlotDic"]; ok { |
|
cKs := cK1["SlotDic"].(primitive.A) |
|
cK1["SlotDic"] = cKs |
|
for k, cKsv := range cKs { |
|
cKsv1 := cKsv.(primitive.A) |
|
cKs[k] = append(cKsv1, fmt.Sprint(cKsv1[1])) |
|
} |
|
} |
|
if _, ok := cK1["Children"]; ok { |
|
cKs := cK1["Children"].(primitive.A) |
|
cK1["Children"] = cKs |
|
for _, cKsv := range cKs { |
|
cKsv1 := cKsv.(map[string]interface{}) |
|
cKsv1["StringId"] = fmt.Sprint(cKsv1["_id"]) |
|
} |
|
} |
|
if _, ok := cK1["Mates"]; ok { |
|
cKs := cK1["Mates"].(primitive.A) |
|
cK1["Mates"] = cKs |
|
for k, cKsv := range cKs { |
|
cKs[k] = fmt.Sprint(cKsv) |
|
} |
|
} |
|
if _, ok := cK1["MyChildren"]; ok { |
|
cKs := cK1["MyChildren"].(primitive.A) |
|
cK1["MyChildren"] = cKs |
|
for k, cKsv := range cKs { |
|
cKs[k] = fmt.Sprint(cKsv) |
|
} |
|
} |
|
if _, ok := cK1["Parents"]; ok { |
|
cKs := cK1["Parents"].(primitive.A) |
|
cK1["Parents"] = cKs |
|
for k, cKsv := range cKs { |
|
cKs[k] = fmt.Sprint(cKsv) |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if err != nil { |
|
return |
|
} |
|
return res, err |
|
} |
|
|
|
func DelRole(ctx context.Context, uid int64, server string) (roleDetail map[string]interface{}, err error) { |
|
err = MongoDatabaseList[server].Collection("Unit").RemoveId(ctx, uid) |
|
return roleDetail, err |
|
} |
|
|
|
func DelAccount(ctx context.Context, uid int64, server string) (roleDetail map[string]interface{}, err error) { |
|
err = MongoDatabaseList[server].Collection("Account").RemoveId(ctx, uid) |
|
return roleDetail, err |
|
} |
|
|
|
func DelFriendUnit(ctx context.Context, uid int64, server string) (roleDetail map[string]interface{}, err error) { |
|
err = MongoDatabaseList[server].Collection("FriendUnit").RemoveId(ctx, uid) |
|
return roleDetail, err |
|
} |
|
|
|
func DelBaseInfo(ctx context.Context, uid int64, server string) (roleDetail map[string]interface{}, err error) { |
|
err = MongoDatabaseList[server].Collection("BaseInfo").RemoveId(ctx, uid) |
|
return roleDetail, err |
|
} |
|
|
|
func DelBazaar(ctx context.Context, uid int64, server string) (roleDetail map[string]interface{}, err error) { |
|
err = MongoDatabaseList[server].Collection("Bazaar").RemoveId(ctx, uid) |
|
return roleDetail, err |
|
} |
|
|
|
func GetUnitByUid(ctx context.Context, uid int64, serverId int) (unit *entity.GameUnit, err error) { |
|
srcId, err1 := GetIdToUid(ctx, uid) |
|
if err1 != nil { |
|
g.Log().Error(ctx, "GetUnit 获取账号ID err : ", err1) |
|
return nil, err1 |
|
} |
|
if g.IsEmpty(srcId) { |
|
g.Log().Error(ctx, "GetUnit 账号ID不存在 : ", fmt.Sprint(srcId)+"-"+fmt.Sprint(uid)) |
|
return nil, gerror.New("IDIsNull") |
|
} |
|
units := []entity.GameUnit{} |
|
err = dao.GameUnit.Ctx(ctx).Where("uid=?", srcId).Scan(&units) |
|
if err != nil { |
|
g.Log().Error(ctx, "GetUnit scan 1 : ", srcId, gjson.MustEncodeString(units)) |
|
return nil, err |
|
} |
|
if len(units) == 0 { |
|
g.Log().Errorf(ctx, "[%d]GetUnit unit is null, %s", srcId, gjson.MustEncodeString(units)) |
|
return nil, errors.New("UnitIsNull") |
|
} |
|
serverList := "" |
|
for _, v := range units { |
|
if v.Server == serverId { |
|
return &v, err |
|
} |
|
serverList += fmt.Sprint(v.Server) + ";" |
|
} |
|
if len(units) > 1 { |
|
return nil, errors.New("查询失败，包含多个用户,区服在：" + serverList) |
|
} |
|
return &units[0], err |
|
} |
|
|
|
func GetUnitByStringUid(ctx context.Context, uid string, serverId int) (unit *entity.GameUnit, err error) { |
|
srcId, err1 := GetStringIdToUid(ctx, uid) |
|
if err1 != nil { |
|
g.Log().Error(ctx, "GetUnit 获取账号ID err : ", err1) |
|
return nil, err1 |
|
} |
|
if g.IsEmpty(srcId) { |
|
g.Log().Error(ctx, "GetUnit 账号ID不存在 : ", fmt.Sprint(srcId)+"-"+fmt.Sprint(uid)) |
|
return nil, gerror.New("IDIsNull") |
|
} |
|
units := []entity.GameUnit{} |
|
err = dao.GameUnit.Ctx(ctx).Where("uid=?", srcId).Scan(&units) |
|
if err != nil { |
|
g.Log().Error(ctx, "GetUnit scan 1 : ", srcId, gjson.MustEncodeString(units)) |
|
return nil, err |
|
} |
|
if len(units) == 0 { |
|
g.Log().Errorf(ctx, "[%d]GetUnit unit is null, %s", srcId, gjson.MustEncodeString(units)) |
|
return nil, errors.New("UnitIsNull") |
|
} |
|
serverList := "" |
|
for _, v := range units { |
|
if v.Server == serverId { |
|
return &v, err |
|
} |
|
serverList += fmt.Sprint(v.Server) + ";" |
|
} |
|
if len(units) > 1 { |
|
return nil, errors.New("查询失败，包含多个用户,区服在：" + serverList) |
|
} |
|
return &units[0], err |
|
} |
|
|
|
func GetUnitById(ctx context.Context, srcId int64, serverId int) (unit *entity.GameUnit, err error) { |
|
if g.IsEmpty(srcId) { |
|
g.Log().Error(ctx, "GetAccount 账号ID不存在 : ", fmt.Sprint(srcId)) |
|
return nil, gerror.New("IDIsNull") |
|
} |
|
units := []entity.GameUnit{} |
|
err = dao.GameUnit.Ctx(ctx).Where("uid=?", srcId).Scan(&units) |
|
if err != nil { |
|
g.Log().Error(ctx, "GetAccount scan 1 : ", srcId, gjson.MustEncodeString(units)) |
|
return nil, err |
|
} |
|
if len(units) == 0 { |
|
g.Log().Errorf(ctx, "[%d]GetAccount unit is null, %s", srcId, gjson.MustEncodeString(units)) |
|
return nil, errors.New("UnitIsNull") |
|
} |
|
serverList := "" |
|
for _, v := range units { |
|
if v.Server == serverId { |
|
return &v, err |
|
} |
|
} |
|
if len(units) > 1 { |
|
return nil, errors.New("查询失败，包含多个用户,区服在：" + serverList) |
|
} |
|
return &units[0], err |
|
} |
|
|
|
func GetAccount(ctx context.Context, req *game.AccountReq) (res *game.AccountRes, err error) { |
|
query := bson.M{} |
|
server := fmt.Sprint(req.ServerId) |
|
if req.Id != "" { |
|
id, _ := strconv.ParseInt(req.Id, 10, 64) |
|
unit, err1 := GetUnitById(ctx, id, req.ServerId) |
|
if err1 != nil { |
|
err = err1 |
|
g.Log().Error(ctx, "GetUnit:", err1) |
|
return |
|
} |
|
query["_id"] = unit.Uid |
|
if server != fmt.Sprint(unit.Server) { |
|
var serverInfo entity.GameLoginUrl |
|
for _, v := range ServerList { |
|
if v.Id == unit.Server { |
|
serverInfo = v |
|
break |
|
} |
|
} |
|
return nil, errors.New("区服选择错误！当前id在<" + fmt.Sprint(serverInfo.Id) + "><" + serverInfo.Name + ">区") |
|
} |
|
} |
|
if req.Uid != 0 { |
|
unit, err1 := GetUnitByUid(ctx, int64(req.Uid), req.ServerId) |
|
if err1 != nil { |
|
err = err1 |
|
g.Log().Error(ctx, "GetUnit:", err1) |
|
return |
|
} |
|
query["_id"] = unit.Uid |
|
if server != fmt.Sprint(unit.Server) { |
|
var serverInfo entity.GameLoginUrl |
|
for _, v := range ServerList { |
|
if v.Id == unit.Server { |
|
serverInfo = v |
|
break |
|
} |
|
} |
|
return nil, errors.New("区服选择错误！当前区服在<" + fmt.Sprint(serverInfo.Id) + "><" + serverInfo.Name + ">区") |
|
} |
|
} |
|
if req.Account != "" { |
|
query["AccountName"] = req.Account |
|
} |
|
if req.Ident != "" { |
|
query["Identity"] = req.Ident |
|
} |
|
if req.Name != "" { |
|
query["RealName"] = req.Name |
|
} |
|
if req.Name != "" { |
|
query["RealName"] = req.Name |
|
} |
|
if req.GmState != "" { |
|
gm, _ := strconv.Atoi(req.GmState) |
|
query["AccountType"] = gm |
|
} |
|
mongo, ok := MongoDatabaseList[server] |
|
if !ok { |
|
return nil, errors.New("不存在数据库！") |
|
} |
|
|
|
res = new(game.AccountRes) |
|
res.Total, err = mongo.Collection("Account").Find(ctx, query).Count() |
|
err = mongo.Collection("Account").Find(ctx, query).Skip((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).All(&res.Accounts) |
|
for _, v := range res.Accounts { |
|
v["StringId"] = fmt.Sprint(v["_id"]) |
|
v["uid"], _ = GetIdToUid(ctx, v["_id"].(int64)) |
|
} |
|
if err != nil { |
|
return |
|
} |
|
return res, err |
|
} |
|
|
|
func GetAccountUidBy(ctx context.Context, req *game.AccountReq, server string) (uid int64, err error) { |
|
query := bson.M{} |
|
if req.Id != "" { |
|
query["_id"], _ = strconv.ParseInt(req.Id, 10, 64) |
|
} |
|
if req.Uid != 0 { |
|
query["UniqueId"], _ = GetIdToUid(ctx, int64(req.Uid)) |
|
} |
|
if req.Account != "" { |
|
query["AccountName"] = req.Account |
|
} |
|
if req.Ident != "" { |
|
query["Identity"] = req.Ident |
|
} |
|
if req.Name != "" { |
|
query["RealName"] = req.Name |
|
} |
|
|
|
all1 := make([]map[string]interface{}, 1) |
|
err = MongoDatabaseList[server].Collection("Account").Find(ctx, query).All(&all1) |
|
if len(all1) == 0 { |
|
return 0, gerror.New("获取失败") |
|
} |
|
uid = all1[0]["_id"].(int64) |
|
return uid, err |
|
} |
|
|
|
func GetAccountByUid(ctx context.Context, uid int64, server string) (account map[string]interface{}, err error) { |
|
filtter := bson.M{} |
|
if uid != 0 { |
|
filtter["_id"] = uid |
|
} |
|
log.Println("GetAccountByUid: ", filtter) |
|
all1 := make([]map[string]interface{}, 1) |
|
mongo, ok := MongoDatabaseList[server] |
|
if !ok { |
|
log.Println("GetAccountUid: 获取失败 ", all1, err) |
|
return account, gerror.New("获取失败") |
|
} |
|
err = mongo.Collection("Account").Find(ctx, filtter).All(&all1) |
|
if err != nil || len(all1) == 0 { |
|
log.Println("GetAccountUid: 获取失败 ", all1, err) |
|
return account, gerror.New("获取失败") |
|
} |
|
account = all1[0] |
|
log.Println("GetAccountByUid: accountData ", account) |
|
return account, err |
|
} |
|
|
|
func GetAccountUid(ctx context.Context, account string, server string) (uid int, err error) { |
|
filtter := bson.M{} |
|
if len(account) > 0 { |
|
filtter["AccountName"] = account |
|
} |
|
log.Println("GetAccountUid: ", filtter) |
|
all1 := make([]map[string]interface{}, 1) |
|
err = MongoDatabaseList[server].Collection("Account").Find(ctx, filtter).All(&all1) |
|
if len(all1) == 0 { |
|
return 0, gerror.New("获取失败") |
|
} |
|
log.Println("GetAccountUid: all", all1, all1[0]) |
|
uid = all1[0]["UniqueId"].(int) |
|
log.Println("GetAccountUid: accountData ", uid) |
|
return uid, err |
|
} |
|
|
|
func AccountToUids(ctx context.Context, account string) (uid []int64, err error) { |
|
log.Println("GetAccountUid: ", account) |
|
var all1 []*entity.Account |
|
err = dao.GameUnit.Ctx(ctx).Where("account=?", account).Scan(&all1) |
|
if len(all1) == 0 { |
|
return []int64{}, gerror.New("获取失败") |
|
} |
|
log.Println("GetAccountUid: all", all1) |
|
uid = []int64{} |
|
for _, e := range all1 { |
|
uid = append(uid, e.Uid) |
|
} |
|
|
|
log.Println("GetAccountUid: accountData ", uid) |
|
return uid, err |
|
} |
|
|
|
func UidToServer(ctx context.Context, unitId string) (server int, err error) { |
|
log.Println("GetAccountUid: ", unitId) |
|
var all1 []*entity.GameUnit |
|
err = dao.GameUnit.Ctx(ctx).Where("uid=?", unitId).Scan(&all1) |
|
if len(all1) == 0 { |
|
return 0, gerror.New("获取失败") |
|
} |
|
log.Println("GetAccountUid: all", gjson.MustEncodeString(all1)) |
|
return all1[0].Server, err |
|
} |
|
|
|
func GetAccountUid2(ctx context.Context, account string, server string) (uid int64, err error) { |
|
filtter := bson.M{} |
|
if len(account) > 0 { |
|
filtter["AccountName"] = account |
|
} |
|
log.Println("GetAccountUid: ", filtter) |
|
all1 := make([]map[string]interface{}, 1) |
|
err = MongoDatabaseList[server].Collection("Account").Find(ctx, filtter).All(&all1) |
|
if len(all1) == 0 { |
|
return 0, gerror.New("获取失败") |
|
} |
|
log.Println("GetAccountUid: all", all1, all1[0]) |
|
uid = all1[0]["_id"].(int64) |
|
log.Println("GetAccountUid: accountData ", uid) |
|
return uid, err |
|
} |
|
|
|
func GetAccountIdentity(ctx context.Context, account string, server string) (Identity string, err error) { |
|
filtter := bson.M{} |
|
if len(account) > 0 { |
|
filtter["AccountName"] = account |
|
} |
|
log.Println("GetAccountUid: ", filtter) |
|
all1 := make([]map[string]interface{}, 1) |
|
err = MongoDatabaseList[server].Collection("Account").Find(ctx, filtter).All(&all1) |
|
log.Println("GetAccountUid: all", all1, all1[0]) |
|
Identity = all1[0]["Identity"].(string) |
|
log.Println("GetAccountUid: accountData ", Identity) |
|
return Identity, err |
|
} |
|
|
|
type GameUnitGameTime struct { |
|
Id int64 `json:"id" description:""` |
|
Account string `json:"account" description:"账号"` |
|
Channel string `json:"channel" description:"渠道"` |
|
Uid int64 `json:"uid" description:"账号Id"` |
|
Server int `json:"server" description:"区服"` |
|
Scale int `json:"scale" description:"规模"` |
|
Name string `json:"name" description:"桃谷名称"` |
|
LogTime int64 `json:"logTime" description:""` |
|
CreateTime *gtime.Time `json:"createTime" description:"账号创建时间"` |
|
VillagerNum int `json:"villagerNum" description:"村民数量"` |
|
Prosperity int `json:"prosperity" description:"繁荣值"` |
|
GoldIngot int `json:"goldIngot" description:"桃花石"` |
|
BaseFood int `json:"baseFood" description:"基础食物"` |
|
Day int `json:"day" description:"游戏天数"` |
|
GameTime int `json:"game_time" description:"游戏时间"` |
|
Recharge int64 `json:"recharge" description:"充值"` |
|
} |
|
|
|
func SearchAccount(ctx context.Context, req *game.SearchAccountReq) (res *game.SearchAccountRes, err error) { |
|
res = new(game.SearchAccountRes) |
|
model := dao.GameUnit.Ctx(ctx) |
|
switch req.Type { |
|
case 1: |
|
{ |
|
model = checkDaoIntCompareType(model, req.CompareType, "day", req.Data) |
|
break |
|
} |
|
case 2: |
|
{ |
|
model = checkDaoIntCompareType(model, req.CompareType, "scale", req.Data) |
|
break |
|
} |
|
case 3: |
|
{ |
|
sql := fmt.Sprintf(`select uid, max(game_time) as game_time, max(day) as day from login_logout_info group by uid`) |
|
sql = fmt.Sprintf(`select u.day,u.scale,u.villager_num,u.account,u.uid, b.game_time as game_time, b.day as mDay from (%s) as b inner join game_unit as u on u.uid=b.uid where 1=1`, sql) |
|
if req.ServerId > 0 { |
|
sql += fmt.Sprintf(" and u.server=%d", req.ServerId) |
|
} |
|
if req.StartTime != 0 { |
|
sql += fmt.Sprintf(" and UNIX_TIMESTAMP(u.create_time)>%d", req.StartTime/1000) |
|
} |
|
if req.EndTime != 0 { |
|
sql += fmt.Sprintf(" and UNIX_TIMESTAMP(u.create_time)<%d", req.EndTime/1000) |
|
} |
|
|
|
sql = fmt.Sprintf(`select a.game_time,a.day,a.scale,a.villager_num,a.account,a.uid from (%s) as a where a.day=1 %s`, sql, CompareSqlType("", req.Data, "a.game_time", req.CompareType)) |
|
|
|
dayAvgDetail := []*Avg{} |
|
scaleAvgDetail := []*Avg{} |
|
|
|
daysql := fmt.Sprintf(`select avg(c.day) as data from (%s) as c `, sql) |
|
g.Model().Raw(daysql).Scan(&dayAvgDetail) |
|
scalesql := fmt.Sprintf(`select avg(c.scale) as data from (%s) as c `, sql) |
|
g.Model().Raw(scalesql).Scan(&scaleAvgDetail) |
|
countsql := fmt.Sprintf(`select count(1) as data from (%s) as d`, sql) |
|
count := []*Count{} |
|
g.Model().Raw(countsql).Scan(&count) |
|
if len(count) > 0 { |
|
res.Total = count[0].Data |
|
} |
|
res.AvgScale = scaleAvgDetail[0].Data |
|
res.AvgDay = dayAvgDetail[0].Data |
|
accountSql := fmt.Sprintf(`select d.uid,d.account,d.day, d.scale,d.villager_num, d.game_time from (%s) as d LIMIT %d,%d`, sql, (req.PageNum-1)*req.PageSize, req.PageSize) |
|
accounts := []*GameUnitGameTime{} |
|
g.Model().Raw(accountSql).Scan(&accounts) |
|
for _, v := range accounts { |
|
res.Accounts = append(res.Accounts, map[string]interface{}{"stringId": fmt.Sprint(v.Uid), "game_time": v.GameTime, "account": v.Account, "scale": v.Scale, "day": v.Day, "villagerNum": v.VillagerNum}) |
|
} |
|
fmt.Println("SearchAccount: ", res.Total, fmt.Sprint(dayAvgDetail[0].Data), fmt.Sprint(scaleAvgDetail[0].Data)) |
|
return |
|
} |
|
default: |
|
return res, gerror.New("无查询条件") |
|
} |
|
if req.ServerId > 0 { |
|
model = model.Where("server=?", req.ServerId) |
|
} |
|
if req.StartTime != 0 { |
|
model = model.Where(`UNIX_TIMESTAMP(create_time)>?`, req.StartTime/1000) |
|
} |
|
if req.EndTime != 0 { |
|
model = model.Where(`UNIX_TIMESTAMP(create_time)<?`, req.EndTime/1000) |
|
} |
|
dayAvgDetail := []*Avg{} |
|
scaleAvgDetail := []*Avg{} |
|
err = model.FieldAvg("day", "data").Scan(&dayAvgDetail) |
|
err = model.FieldAvg("scale", "data").Scan(&scaleAvgDetail) |
|
res.Total, err = model.Count() |
|
if err != nil { |
|
return res, err |
|
} |
|
res.AvgScale = scaleAvgDetail[0].Data |
|
res.AvgDay = dayAvgDetail[0].Data |
|
accounts := []*entity.GameUnit{} |
|
err = model.Page(req.PageNum, req.PageSize).Scan(&accounts) |
|
for _, v := range accounts { |
|
res.Accounts = append(res.Accounts, map[string]interface{}{"stringId": fmt.Sprint(v.Uid), "account": v.Account, "scale": v.Scale, "day": v.Day, "villagerNum": v.VillagerNum}) |
|
} |
|
fmt.Println("SearchAccount: ", res.Total, fmt.Sprint(dayAvgDetail[0].Data), fmt.Sprint(scaleAvgDetail[0].Data)) |
|
return |
|
} |
|
|
|
type Avg struct { |
|
Data float64 `json:"data" bson:"data" ` |
|
} |
|
|
|
type Count struct { |
|
Data int `json:"data" bson:"data" ` |
|
} |
|
|
|
func GetLoginOut(ctx context.Context, req *game.GetLoginOutReq) (res *game.GetLoginOutRes, err error) { |
|
res = new(game.GetLoginOutRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.LoginLogoutInfo.Ctx(ctx) |
|
if req.Account != "" { |
|
uid, _ := GetAccountUid2(ctx, req.Account, fmt.Sprint(req.ServerId)) |
|
if uid == 0 { |
|
//g.Log().Debugf(ctx, "LoginOut -> "+fmt.Sprint(uid)) |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} else if req.Uid != "" { |
|
uid, _ := strconv.ParseInt(req.Uid, 10, 64) |
|
if uid == 0 { |
|
//g.Log().Debugf(ctx, "LoginOut -> "+fmt.Sprint(uid)) |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} |
|
if req.State != 0 { |
|
model = model.Where("state=? ", req.State) |
|
} |
|
res.Total, err = model.Count() |
|
err = model.Page(req.PageNum, req.PageSize).OrderDesc("c_date").Scan(&res.Logs) |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}) |
|
return |
|
} |
|
|
|
func GetLoginOutLog(ctx context.Context, req *game.GetLoginOutLogReq) (res *game.GetLoginOutLogRes, err error) { |
|
res = new(game.GetLoginOutLogRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.LoginOutLog.Ctx(ctx) |
|
if req.Account != "" { |
|
uid, _ := GetAccountUid2(ctx, req.Account, fmt.Sprint(req.ServerId)) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} else if req.Id != "" { |
|
uid, _ := strconv.ParseInt(req.Id, 10, 64) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} else if req.Uid != "" { |
|
srcId, err1 := GetStringIdToUid(ctx, req.Uid) |
|
if err1 != nil { |
|
g.Log().Error(ctx, "GetUnit 获取账号ID err : ", err1, req.Uid) |
|
return |
|
} |
|
if g.IsEmpty(srcId) { |
|
g.Log().Error(ctx, "GetUnit 账号ID不存在 : ", srcId) |
|
return |
|
} |
|
uid, _ := strconv.ParseInt(srcId, 10, 64) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} |
|
|
|
res.Total, err = model.Count() |
|
err = model.Page(req.PageNum, req.PageSize).OrderDesc("c_date").Scan(&res.Logs) |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}) |
|
return |
|
} |
|
|
|
func GetItemLog(ctx context.Context, req *game.GetItemLogReq) (res *game.GetItemLogRes, err error) { |
|
res = new(game.GetItemLogRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.ItemIncomeExpenseRecords.Ctx(ctx) |
|
if req.Account != "" { |
|
uid, _ := GetAccountUid2(ctx, req.Account, fmt.Sprint(req.ServerId)) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
model = model.Where("server=? ", req.ServerId) |
|
} else if req.Uid != "" { |
|
|
|
uid, _ := strconv.ParseInt(req.Uid, 10, 64) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
model = model.Where("server=? ", req.ServerId) |
|
} else if req.Id != "" { |
|
uid, _ := strconv.ParseInt(req.Id, 10, 64) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
model = model.Where("server=? ", req.ServerId) |
|
} |
|
if req.ItemId != 0 { |
|
model = model.Where("item_id=? ", req.ItemId) |
|
} |
|
res.Total, err = model.Count() |
|
err = model.Page(req.PageNum, req.PageSize).Order("c_time desc").Scan(&res.Logs) |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}) |
|
return |
|
} |
|
|
|
func GetRegister(ctx context.Context, req *game.GetRegisterReq) (res *game.GetRegisterRes, err error) { |
|
res = new(game.GetRegisterRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.ItemIncomeExpenseRecords.Ctx(ctx) |
|
if req.Account != "" { |
|
uid, _ := GetAccountUid2(ctx, req.Account, fmt.Sprint(req.ServerId)) |
|
if uid == 0 { |
|
//g.Log().Debugf(ctx, "LoginOut -> "+fmt.Sprint(uid)) |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} else if req.Uid != "" { |
|
uid, _ := strconv.ParseInt(req.Uid, 10, 64) |
|
if uid == 0 { |
|
//g.Log().Debugf(ctx, "LoginOut -> "+fmt.Sprint(uid)) |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} |
|
|
|
res.Total, err = model.Count() |
|
err = model.Page(req.PageNum, req.PageSize).Scan(&res.Logs) |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}) |
|
return |
|
} |
|
|
|
var online = map[int]int64{} |
|
|
|
func GameRegister(ctx context.Context, req *game.RegisterReq) (res *game.RegisterRes, err error) { |
|
if req.Account == "" { |
|
err = gerror.New("请填写账号！") |
|
return |
|
} |
|
if req.Uid == 0 { |
|
err = gerror.New("请填写账号！") |
|
return |
|
} |
|
g.Try(ctx, func(ctx context.Context) { |
|
registerData := []entity.GameRegister{} |
|
register := dao.GameRegister.Ctx(ctx) |
|
register.Where("account=?", req.Account).Where("channel=?", req.Channel).Scan(®isterData) |
|
//g.Log().Debugf(ctx, "GameRegister -> "+gjson.MustEncodeString(registerData)) |
|
if len(registerData) > 0 { |
|
if !strings.Contains(registerData[0].Server, fmt.Sprintf("<%d>", req.Server)) { |
|
_, err = register.Where("account=?", req.Account).Where("channel=?", req.Channel).Update(g.Map{ |
|
dao.GameRegister.Columns().Server: registerData[0].Server + fmt.Sprintf("<%d>", req.Server), |
|
}) |
|
} |
|
} else { |
|
_, err = register.Insert(&do.GameRegister{ |
|
Account: req.Account, |
|
Channel: req.Channel, |
|
CreateType: req.CreateType, |
|
Platform: req.Platform, |
|
Server: fmt.Sprintf("<%d>", req.Server), |
|
}) |
|
} |
|
_, err = dao.GameUnit.Ctx(ctx).Insert(&do.GameUnit{ |
|
Account: req.Account, |
|
Channel: req.Channel, |
|
Uid: req.Uid, |
|
Server: req.Server, |
|
OAID: req.OAID, |
|
Idfv: req.Idfv, |
|
AndroidId: req.AndroidId, |
|
}) |
|
|
|
if req.Channel == consts.Channel_TAPTAP { |
|
req1 := new(game.DeepADReq) |
|
req1.OAID = req.OAID |
|
req1.State = consts.ADDVERTISEMENT_REGISTER |
|
_, err = DeepAdvertise(ctx, req1) |
|
} |
|
return |
|
}) |
|
return |
|
} |
|
func setAccount(ctx context.Context, req *game.LoginOutReq) { |
|
g.Try(ctx, func(ctx context.Context) { |
|
account, err := GetAccountByUid(ctx, req.Uid, fmt.Sprint(req.Server)) |
|
if err != nil || account["AccountName"] == "" { |
|
log.Printf("GameUnit nil uid: %d, server: %d", req.Uid, req.Server) |
|
} else { |
|
save := game.RegisterReq{} |
|
save.Channel = fmt.Sprintf("%06d", account["Channel"]) + fmt.Sprintf("%06d", account["SubChannel"]) |
|
accountName := fmt.Sprint(account["AccountName"]) |
|
if !strings.HasPrefix(accountName, save.Channel) { |
|
accountName = save.Channel + accountName |
|
} |
|
save.Account = accountName |
|
save.Uid = req.Uid |
|
save.Server = req.Server |
|
save.Platform = 3 |
|
save.CreateType = 4 |
|
_, err = GameRegister(ctx, &save) |
|
if err != nil { |
|
log.Printf("GameRegister nil uid: %d, server: %d", req.Uid, req.Server) |
|
} |
|
|
|
} |
|
}) |
|
} |
|
|
|
func LoginOut(ctx context.Context, req *game.LoginOutReq) (res *game.LoginOutRes, err error) { |
|
g.Try(ctx, func(ctx context.Context) { |
|
count := 0 |
|
modelLog := dao.LoginOutLog.Ctx(ctx) |
|
var loginLog []entity.LoginOutLog |
|
err = modelLog.Where(dao.LoginOutLog.Columns().Uid, req.Uid).Where(dao.LoginOutLog.Columns().EDate, 0).Scan(&loginLog) |
|
//g.Log().Debugf(ctx, "LoginOut -> "+gjson.MustEncodeString(loginLog)) |
|
if len(loginLog) > 0 { |
|
if req.State == consts.LogOut_State { |
|
count = 1 |
|
} |
|
modelLog.WherePri(loginLog[0].Id).Update(g.Map{ |
|
dao.LoginOutLog.Columns().EDate: gtime.Timestamp(), |
|
}) |
|
} |
|
if req.State == consts.LogIn_State { |
|
_, err = modelLog.Insert(&do.LoginOutLog{ |
|
Uid: req.Uid, |
|
CDate: gtime.Timestamp(), |
|
Server: req.Server, |
|
}) |
|
count = 1 |
|
go sendAdvertisement(ctx, req.Uid) |
|
} |
|
|
|
if count == 1 { |
|
var result sql.Result |
|
result, err = dao.GameUnit.Ctx(ctx).Where("uid=?", req.Uid).Where("server=?", req.Server).Update(g.Map{ |
|
dao.GameUnit.Columns().Name: req.Name, |
|
dao.GameUnit.Columns().Scale: req.Scale, |
|
dao.GameUnit.Columns().LogTime: time.Now().Unix(), |
|
dao.GameUnit.Columns().VillagerNum: req.VillagerNum, |
|
dao.GameUnit.Columns().Day: req.Day, |
|
dao.GameUnit.Columns().GoldIngot: req.GoldIngot, |
|
dao.GameUnit.Columns().BaseFood: req.BaseFood, |
|
dao.GameUnit.Columns().Prosperity: req.Prosperity, |
|
}) |
|
affect, err := result.RowsAffected() |
|
if err != nil || affect == 0 { |
|
go setAccount(ctx, req) |
|
} |
|
|
|
model := dao.LoginLogoutInfo.Ctx(ctx) |
|
_, err = model.Insert(&do.LoginLogoutInfo{ |
|
Uid: req.Uid, |
|
State: req.State, |
|
Day: req.Day, |
|
GameTime: req.GameTime, |
|
Scale: req.Scale, |
|
VillagerNum: req.VillagerNum, |
|
Copper: req.Copper, |
|
GoldIngot: req.GoldIngot, |
|
BaseFood: req.BaseFood, |
|
Prosperity: req.Prosperity, |
|
Server: req.Server, |
|
VouchersNum: req.VouchersNum, |
|
RechargeTotal: req.RechargeTotal, |
|
StoreSum: req.StoreSum, |
|
StoneAmount: req.StoneAmount, |
|
}) |
|
if req.StoneAmount > 50000 || req.VouchersNum > 400 || (req.RechargeTotal == 0 && req.VouchersNum > 10) { |
|
_, err = dao.LoginLogoutInfoGm.Ctx(ctx).Insert(&do.LoginLogoutInfoGm{ |
|
Uid: req.Uid, |
|
State: req.State, |
|
Day: req.Day, |
|
GameTime: req.GameTime, |
|
Scale: req.Scale, |
|
VillagerNum: req.VillagerNum, |
|
Copper: req.Copper, |
|
GoldIngot: req.GoldIngot, |
|
BaseFood: req.BaseFood, |
|
Prosperity: req.Prosperity, |
|
Server: req.Server, |
|
VouchersNum: req.VouchersNum, |
|
RechargeTotal: req.RechargeTotal, |
|
StoreSum: req.StoreSum, |
|
StoneAmount: req.StoneAmount, |
|
}) |
|
} |
|
} |
|
if gtime.Timestamp()-online[req.Server] > 2 { |
|
online[req.Server] = gtime.Timestamp() |
|
|
|
var onlineData []entity.OnlineData |
|
onlineModel := g.Model("login_out_log", "a"). |
|
Fields("count(1) as num,b.channel") |
|
if req.Server != 0 { |
|
onlineModel.Where("a.server=?", req.Server) |
|
} |
|
err1 := onlineModel.Where("a.e_date", 0). |
|
InnerJoin("game_unit", "b", "b.uid=a.uid"). |
|
Group("b.channel"). |
|
Scan(&onlineData) |
|
//g.Log().Debugf(ctx, "onlineData -> "+gjson.MustEncodeString(onlineData)) |
|
if err1 == nil { |
|
var insertData []do.GameOnline |
|
for _, v := range onlineData { |
|
g.Log().Debugf(ctx, "onlineData -> "+gjson.MustEncodeString(v)+" channel:"+v.Channel) |
|
insertData = append(insertData, do.GameOnline{Channel: v.Channel, Server: req.Server, Num: v.Num}) |
|
} |
|
dao.GameOnline.Ctx(ctx).Insert(insertData) |
|
} |
|
} |
|
|
|
return |
|
}) |
|
return |
|
} |
|
|
|
func sendAdvertisement(ctx context.Context, uid int64) { |
|
units := []entity.GameUnit{} |
|
err := dao.GameUnit.Ctx(ctx).Where("uid=?", uid).Where("OAID<>''").Scan(&units) |
|
if err != nil { |
|
log.Printf("sendAdvertisement===Scan: err: %s", err.Error()) |
|
} |
|
if len(units) == 0 || units[0].OAID == "" || units[0].Channel != consts.Channel_TAPTAP { |
|
return |
|
} |
|
req1 := new(game.DeepADReq) |
|
req1.OAID = units[0].OAID |
|
req1.State = consts.ADDVERTISEMENT_TWO |
|
_, err = DeepAdvertise(ctx, req1) |
|
if err != nil { |
|
log.Printf("sendAdvertisement===DeepAdvertise: err: %s", err.Error()) |
|
return |
|
} |
|
log.Printf("sendAdvertisement: uid: %d, req1: %s", uid, gjson.MustEncodeString(req1)) |
|
} |
|
|
|
func GameUnitChangeName(ctx context.Context, req *game.UnitChangeNameReq) (res *game.UnitChangeNameRes, err error) { |
|
if req.Uid == 0 { |
|
err = gerror.New("请填写账号！") |
|
return |
|
} |
|
g.Try(ctx, func(ctx context.Context) { |
|
_, err = dao.GameUnit.Ctx(ctx).WherePri(req.Uid).Where("server=?", req.Server).Update(g.Map{ |
|
dao.GameUnit.Columns().Name: req.Name, |
|
}) |
|
return |
|
}) |
|
return |
|
} |
|
|
|
func ItemIncomeExpenseRecords(ctx context.Context, req *game.ItemRecordReq) (res *game.ItemRecordRes, err error) { |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.ItemIncomeExpenseRecords.Ctx(ctx) |
|
_, err = model.Insert(&do.ItemIncomeExpenseRecords{ |
|
Uid: req.Uid, |
|
ItemId: req.ItemId, |
|
Num: req.Num, |
|
Way: req.Way, |
|
State: req.State, |
|
Server: req.Server, |
|
}) |
|
return |
|
}) |
|
return |
|
} |
|
|
|
func ShopRecords(ctx context.Context, req *game.ShopRecordReq) (res *game.ShopRecordRes, err error) { |
|
res = new(game.ShopRecordRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.GameShopLog.Ctx(ctx) |
|
_, err = model.Insert(&do.GameShopLog{ |
|
Uid: req.Uid, |
|
ItemId: req.ItemId, |
|
Price: req.Price, |
|
Num: req.Num, |
|
ServerId: req.ServerId, |
|
ConfigType: req.ConfigType, |
|
}) |
|
return |
|
}) |
|
|
|
return |
|
} |
|
|
|
func GetShopItemLog(ctx context.Context, req *game.GetShopItemLogReq) (res *game.GetShopItemLogRes, err error) { |
|
res = new(game.GetShopItemLogRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
shopLogSql := fmt.Sprintf(`select u.account,s.itemId,s.num,s.price,s.config_type from game_shop_log s inner join game_unit u on s.uid=u.uid and s.serverId=u.server where 1=1`) |
|
rechargeSql := fmt.Sprintf(`select DISTINCT u.account from game_recharge r inner join game_unit u on r.unitId=u.uid inner join game_register rr on rr.account=u.account where r.status=2`) |
|
if req.LowTime != "" { |
|
rechargeSql += fmt.Sprintf(` and rr.create_time>"%s"`, req.LowTime) |
|
shopLogSql += fmt.Sprintf(` and s.c_date>"%s"`, req.LowTime) |
|
} |
|
if req.Uptime != "" { |
|
rechargeSql = fmt.Sprintf(`%s and rr.create_time<"%s"`, rechargeSql, req.Uptime) |
|
shopLogSql = fmt.Sprintf(`%s and s.c_date<"%s"`, shopLogSql, req.Uptime) |
|
} |
|
if req.ServerId != 0 { |
|
rechargeSql = fmt.Sprintf(`%s and u.server=%d`, rechargeSql, req.ServerId) |
|
shopLogSql = fmt.Sprintf(`%s and u.server=%d`, shopLogSql, req.ServerId) |
|
} |
|
if req.Channel != "" { |
|
rechargeSql = fmt.Sprintf(`%s and u.channel="%s"`, rechargeSql, req.Channel) |
|
shopLogSql = fmt.Sprintf(`%s and u.channel="%s"`, shopLogSql, req.Channel) |
|
} |
|
if req.GM == 0 { |
|
rechargeSql = fmt.Sprintf(`%s and r.tradeNo NOT LIKE "GM%%"`, rechargeSql) |
|
} |
|
shopLogSql = fmt.Sprintf(`select a.account, a.itemId, a.config_type from (%s) as a group by a.itemId,a.config_type,a.account`, shopLogSql) |
|
shopLogSql = fmt.Sprintf(`select count(1) as num, b.itemId, b.config_type from (%s) as b group by b.itemId,b.config_type`, shopLogSql) |
|
res.Total, err = g.Model().Raw(shopLogSql).Count() |
|
err = g.Model().Raw(shopLogSql).Page(req.PageNum, req.PageSize).Scan(&res.Logs) |
|
res.RechargeTotal, err = g.Model().Raw(rechargeSql).Count() |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}) |
|
return |
|
} |
|
|
|
func GetShopItemList(ctx context.Context, req *game.GetShopItemListReq) (res *game.GetShopItemListRes, err error) { |
|
res = new(game.GetShopItemListRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.GameShopLog.Ctx(ctx) |
|
if req.LowTime != "" { |
|
model = model.Where("c_date>?", req.LowTime) |
|
} |
|
if req.Uptime != "" { |
|
model = model.Where("c_date<?", req.Uptime) |
|
} |
|
if req.ServerId != 0 { |
|
model = model.Where("serverId=?", req.ServerId) |
|
} |
|
if req.Uid != 0 { |
|
id, _ := GetIdToUid(ctx, int64(req.Uid)) |
|
model = model.Where("uid=?", id) |
|
} |
|
err = model.Page(req.PageNum, req.PageSize).OrderDesc("c_date").Scan(&res.Logs) |
|
res.Total, err = model.Count() |
|
for k, v := range res.Logs { |
|
res.Logs[k].StringId = fmt.Sprint(v.Uid) |
|
res.Logs[k].UniqueId, _ = GetStringIdToUid(ctx, res.Logs[k].StringId) |
|
account, err := GetUnitById(ctx, v.Uid, v.ServerId) |
|
if err != nil { |
|
continue |
|
} |
|
res.Logs[k].Account = fmt.Sprint(account.Account) |
|
} |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}) |
|
return |
|
} |
|
|
|
func GameUserDel(ctx context.Context, req *game.UserDelReq) (res *game.UserDelRes, err error) { |
|
err = g.Try(ctx, func(ctx context.Context) { |
|
res = new(game.UserDelRes) |
|
user := service.Context().GetLoginUser(ctx) |
|
fulluser, err1 := service.User().GetUserByUsername(ctx, user.UserName) |
|
if err != nil { |
|
liberr.ErrIsNil(ctx, err1) |
|
return |
|
} |
|
password := libUtils.EncryptPassword(req.Password, fulluser.UserSalt) |
|
g.Log().Info(ctx, fmt.Sprint("密码错误! pwd:"+fmt.Sprintf("%v", fulluser)+", req.pwd:"+password)) |
|
if fulluser.UserPassword != password { |
|
liberr.ErrIsNil(ctx, errors.New("密码错误! pwd:"+fulluser.UserPassword+", req.pwd:"+password)) |
|
return |
|
} |
|
|
|
units := []entity.GameUnit{} |
|
err = dao.GameUnit.Ctx(ctx).Where("account=?", req.Account).Scan(&units) |
|
data, _ := json.Marshal(units) |
|
log.Printf("GameUserDel: %s", string(data)) |
|
_, err = dao.GameRegister.Ctx(ctx).Delete("account=?", req.Account) |
|
_, err = dao.GameUnit.Ctx(ctx).Delete("account=?", req.Account) |
|
uids := []int64{} |
|
for _, v := range units { |
|
if v.Account == req.Account { |
|
uids = append(uids, v.Uid) |
|
} |
|
} |
|
|
|
log.Printf("GameUserDel: %s", fmt.Sprint(uids)) |
|
//_, err = dao.GameRecharge.Ctx(ctx).Delete("unitId in (?)", uids) |
|
//_, err = dao.GameRechargeLog.Ctx(ctx).Delete("unitId in (?)", uids) |
|
//_, err = dao.LoginLogoutInfo.Ctx(ctx).Delete("uid in (?)", uids) |
|
//_, err = dao.LoginOutLog.Ctx(ctx).Delete("uid in (?)", uids) |
|
//_, err = dao.ItemIncomeExpenseRecords.Ctx(ctx).Delete("uid in (?)", uids) |
|
//_, err = dao.ItemIncomeExpenseRecords.Ctx(ctx).Delete("uid in (?)", uids) |
|
if err != nil { |
|
log.Printf("GameUserDel: %s", err.Error()) |
|
} |
|
|
|
res.Data = 1 |
|
}) |
|
return |
|
} |
|
|
|
func GetOperLog(ctx context.Context, req *game.GetOperLogReq) (res *game.GetOperLogRes, err error) { |
|
res = new(game.GetOperLogRes) |
|
err = g.Try(ctx, func(ctx context.Context) { |
|
if req.Label == "" { |
|
req.Label = "/api/v1/game/mange/setclientgm" |
|
} |
|
model := dao.SysOperLog.Ctx(ctx).Where("oper_url=?", req.Label) |
|
res.Total, err = model.Count() |
|
err = model.Page(req.PageNum, req.PageSize).Order("oper_time desc").Scan(&res.List) |
|
}) |
|
return |
|
} |
|
|
|
func GetLoginOutGm(ctx context.Context, req *game.GetLoginOutGmReq) (res *game.GetLoginOutGmRes, err error) { |
|
res = new(game.GetLoginOutGmRes) |
|
g.Try(ctx, func(ctx context.Context) { |
|
model := dao.LoginLogoutInfoGm.Ctx(ctx) |
|
if req.Account != "" { |
|
uid, _ := GetAccountUid2(ctx, req.Account, fmt.Sprint(req.ServerId)) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} else if req.Uid != "" { |
|
uid, _ := strconv.ParseInt(req.Uid, 10, 64) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} else if req.UnitId != 0 { |
|
uid, _ := GetIdToUid(ctx, req.UnitId) |
|
if uid == 0 { |
|
err = gerror.New("获取账号失败！") |
|
return |
|
} |
|
model = model.Where("uid=? ", uid) |
|
} |
|
if req.RechargeTotal > 0 { |
|
model = checkDaoIntCompareType(model, req.CompareType, "rechargeTotal", req.RechargeTotal) |
|
} |
|
if req.State > 0 && req.State < 3 { |
|
model = model.Where("state=? ", req.State) |
|
} |
|
if req.CDate != 0 { |
|
model = model.Where("c_date>? ", time.UnixMilli(req.CDate).Format(consts.TIME_FORMAT)) |
|
} |
|
if req.VouchersNum > 0 { |
|
model = model.Where("vouchersNum>? ", req.VouchersNum) |
|
} |
|
if req.StoneAmount > 0 { |
|
model = model.Where("stoneAmount>? ", req.StoneAmount) |
|
} |
|
res.Total, err = model.Count() |
|
err = model.Page(req.PageNum, req.PageSize).OrderDesc("c_date").Scan(&res.Logs) |
|
for k, v := range res.Logs { |
|
res.Logs[k].Uid, _ = GetIdToUid(ctx, v.Uid) |
|
} |
|
if err != nil { |
|
return |
|
} |
|
return |
|
}) |
|
return |
|
}
|
|
|