sk_gm_server/app/api/game/gameAction.go

1925 lines
61 KiB
Go
Raw Normal View History

2023-03-20 13:38:28 +08:00
package game
import (
"context"
"encoding/json"
"fmt"
"github.com/gogf/gf/container/garray"
"github.com/gogf/gf/container/glist"
"github.com/gogf/gf/container/gmap"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/ghttp"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/util/gconv"
"gmanager/library/base"
"gmanager/library/codeutil"
"gmanager/library/mongo/gameinfo"
"gmanager/library/mongo/gm"
"gmanager/library/mongo/util"
"gmanager/library/netutil"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"log"
"strconv"
"strings"
"time"
)
type CEntity struct {
Id int `orm:"id,primary" json:"id"` // 主键
Num int `orm:"num" json:"num"` // 主键
}
type Action struct {
base.BaseRouter
}
func (action *Action) MainDate(r *ghttp.Request) {
//gameinfo.ModelLiucun.FindLiuCun()
form := base.NewForm(r.GetQueryMap())
page := g.ListAnyAny{}
alluser, allnum := gameinfo.ModelRegister.CollectionCount()
fmt.Println(alluser, allnum)
regMap := gameinfo.ModelRegister.FindRegTime()
loginMap := gameinfo.ModeLogin.FindDau()
for i, m := range regMap {
dtime := m["date"]
regCount := m["count"]
loginCounr := loginMap[i]["count"]
dmap := gmap.NewStrAnyMap()
dmap.Set("time", dtime)
dmap.Set("regCount", regCount)
dmap.Set("loginCount", loginCounr)
page = append(page, gconv.Map(dmap))
}
fmt.Println(page)
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
func (action *Action) Liucun(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
page := g.ListAnyAny{}
date := g.Config().GetString("startday")
startTime := gtime.NewFromStr(date)
//l := g.ListAnyAny{}
if form.Params["searchData"] != "" {
stime := gconv.MapStrStr(form.Params["searchData"])["0"]
etime := gconv.MapStrStr(form.Params["searchData"])["1"]
//fmt.Println("============================", stime, etime)
//startTime = gtime.NewFromStr(stime)
//如果开始时间小于配置的开始时间 取配置好的时间
if startTime.DayOfYear() < gtime.NewFromStr(stime).DayOfYear() {
startTime = gtime.NewFromStr(stime)
}
endTime := gtime.NewFromStr(etime)
for {
strtime := startTime.Format("Y-m-d")
bs := bson.D{{"creatday", strtime}}
dayinfo := gameinfo.ModelLiucun.FindLiuCun(bs, gconv.String(form.Params["serverid"]))
dayMap := gmap.New()
dayMap.Set("creatday", strtime)
for dayinfo.Next(context.TODO()) {
var elem gameinfo.LogLiucun
err := dayinfo.Decode(&elem)
dayMap.Set("new", elem.NewUser)
dayMap.Set("day"+gconv.String(elem.Day), elem.DayCount)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
}
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() > endTime.DayOfYear() {
break
}
}
} else {
//fmt.Println("=============", gtime.Now().AddDate(0, 0, -7).Format("Y-m-d"))
//不选择默认查询一周的数据
startTime = gtime.Now().AddDate(0, 0, -7)
for {
strtime := startTime.Format("Y-m-d")
bs := bson.D{{"creatday", strtime}}
dayinfo := gameinfo.ModelLiucun.FindLiuCun(bs, gconv.String(form.Params["serverid"]))
dayMap := gmap.New()
dayMap.Set("creatday", strtime)
for dayinfo.Next(context.TODO()) {
var elem gameinfo.LogLiucun
err := dayinfo.Decode(&elem)
dayMap.Set("new", elem.NewUser)
dayMap.Set("day"+gconv.String(elem.Day), elem.DayCount)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
}
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() >= gtime.Now().DayOfYear() {
break
}
}
}
fmt.Println(page)
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
// 付费用户留存
func (action *Action) PayLiucun(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
page := g.ListAnyAny{}
date := g.Config().GetString("startday")
startTime := gtime.NewFromStr(date)
//l := g.ListAnyAny{}
if form.Params["searchData"] != "" {
stime := gconv.MapStrStr(form.Params["searchData"])["0"]
etime := gconv.MapStrStr(form.Params["searchData"])["1"]
//fmt.Println("============================", stime, etime)
//startTime = gtime.NewFromStr(stime)
//如果开始时间小于配置的开始时间 取配置好的时间
if startTime.DayOfYear() < gtime.NewFromStr(stime).DayOfYear() {
startTime = gtime.NewFromStr(stime)
}
endTime := gtime.NewFromStr(etime)
for {
strtime := startTime.Format("Y-m-d")
bs := bson.D{{"creatday", strtime}}
dayinfo := gameinfo.ModelPayLiucun.FindLiuCun(bs, gconv.String(form.Params["serverid"]))
dayMap := gmap.New()
dayMap.Set("creatday", strtime)
for dayinfo.Next(context.TODO()) {
var elem gameinfo.LogPayLiucun
err := dayinfo.Decode(&elem)
dayMap.Set("new", elem.NewUser)
dayMap.Set("day"+gconv.String(elem.Day), elem.DayCount)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
}
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() > endTime.DayOfYear() {
break
}
}
} else {
//fmt.Println("=============", gtime.Now().AddDate(0, 0, -7).Format("Y-m-d"))
//不选择默认查询一周的数据
startTime = gtime.Now().AddDate(0, 0, -7)
for {
strtime := startTime.Format("Y-m-d")
bs := bson.D{{"creatday", strtime}}
dayinfo := gameinfo.ModelPayLiucun.FindLiuCun(bs, gconv.String(form.Params["serverid"]))
dayMap := gmap.New()
dayMap.Set("creatday", strtime)
for dayinfo.Next(context.TODO()) {
var elem gameinfo.LogPayLiucun
err := dayinfo.Decode(&elem)
dayMap.Set("new", elem.NewUser)
dayMap.Set("day"+gconv.String(elem.Day), elem.DayCount)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
}
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() >= gtime.Now().DayOfYear() {
break
}
}
}
fmt.Println(page)
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
func (action *Action) Hour(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
bs := bson.D{}
var stime, etime string
if form.Params != nil {
if form.Params["searchData"] != "" {
stime = gconv.MapStrStr(form.Params["searchData"])["0"]
etime = gconv.MapStrStr(form.Params["searchData"])["1"]
bs = bson.D{{"creatday", bson.D{{"$gte", stime}, {"$lte", etime}}}}
} else {
stime = gtime.Now().AddDate(0, 0, -15).Format("Y-m-d")
etime = gtime.Now().AddDate(0, 0, 0).Format("Y-m-d")
bs = bson.D{{"creatday", bson.D{{"$gte", stime}, {"$lte", etime}}}}
}
}
startTime := gtime.NewFromStr(stime)
endTime := gtime.NewFromStr(etime)
userListMap := gmap.New(false)
for {
userList := garray.New(false)
accountList := garray.New(false)
daystartTime := startTime.Local().TimestampMilli()
dayendTime := startTime.Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
var oneDayAll *mongo.Cursor
if form.Params["serverid"] == "" {
oneDayAll = gameinfo.ModelRegister.FindAllBson(bson.D{{"register.registerTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}}})
} else {
oneDayAll = gameinfo.ModelRegister.FindAllBson(bson.D{{"register.serverId", gconv.String(form.Params["serverid"])}, {"register.registerTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}}})
}
var oneDayAllM []bson.M
if err := oneDayAll.All(context.TODO(), &oneDayAllM); err != nil {
fmt.Println(err)
}
for _, v1 := range oneDayAllM {
loginTime := v1["register"].(primitive.M)
if !userList.Contains(loginTime["uid"]) {
userList.Append(loginTime["uid"])
}
if !accountList.Contains(loginTime["openId"]) {
accountList.Append(loginTime["openId"])
}
}
userListMap.Set(startTime.Format("Y-m-d"), userList)
userListMap.Set("account"+startTime.Format("Y-m-d"), accountList)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() > endTime.DayOfYear() {
break
}
}
page := g.ListAnyAny{}
var hourInfo *mongo.Cursor
if form.Params["serverid"] == "" {
hourInfo = gameinfo.ModelHour.FindAllBson(bs)
} else {
hourInfo = gameinfo.ModelHour.FindListByServer(bs, form.Params["serverid"])
}
dayMap := gmap.New()
for hourInfo.Next(context.TODO()) {
value := dayMap.Get("creatday")
var hour gameinfo.LogHour
err := hourInfo.Decode(&hour)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
//第一条数据 直接赋值到map
if value == nil {
dayMap.Set("creatday", hour.CreatDay)
dayMap.Set("hour"+gconv.String(hour.Hour), hour.NewUser)
} else {
//取map中存在的日期
creatday := dayMap.Get("creatday")
//如果遍历到了新的一天
if creatday != hour.CreatDay {
//将map数据添加到返回集合
dayMap.Set("accountcount", len(gconv.Interfaces(userListMap.Get("account"+gconv.String(creatday)))))
dayMap.Set("count", len(gconv.Interfaces(userListMap.Get(creatday))))
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
//清空map 添加新的数据
dayMap.Clear()
dayMap.Set("creatday", hour.CreatDay)
dayMap.Set("hour"+gconv.String(hour.Hour), hour.NewUser)
} else {
//如果是同一天 只添加对应的时间人数即可
dayMap.Set("hour"+gconv.String(hour.Hour), hour.NewUser)
}
}
}
//fmt.Println("dayMap===========================", dayMap)
dayMap.Set("accountcount", len(gconv.Interfaces(userListMap.Get("account"+gconv.String(dayMap.Get("creatday"))))))
dayMap.Set("count", len(gconv.Interfaces(userListMap.Get(gconv.String(dayMap.Get("creatday"))))))
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
//fmt.Println(page)
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
func (action *Action) HourLogin(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
bs := bson.D{}
var stime, etime string
if form.Params != nil {
if form.Params["searchData"] != "" {
stime = gconv.MapStrStr(form.Params["searchData"])["0"]
etime = gconv.MapStrStr(form.Params["searchData"])["1"]
bs = bson.D{{"creatday", bson.D{{"$gte", stime}, {"$lte", etime}}}}
} else {
stime = gtime.Now().AddDate(0, 0, -15).Format("Y-m-d")
etime = gtime.Now().AddDate(0, 0, 0).Format("Y-m-d")
bs = bson.D{{"creatday", bson.D{{"$gte", stime}, {"$lte", etime}}}}
}
}
startTime := gtime.NewFromStr(stime)
endTime := gtime.NewFromStr(etime)
userListMap := gmap.New(false)
for {
userList := garray.New(false)
accountList := garray.New(false)
daystartTime := startTime.Local().TimestampMilli()
dayendTime := startTime.Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
var oneDayAll *mongo.Cursor
if form.Params["serverid"] == "" {
oneDayAll = gameinfo.ModeLogin.FindAllBson(bson.D{{"loginTime.loginTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}}})
} else {
oneDayAll = gameinfo.ModeLogin.FindAllBson(bson.D{{"loginTime.serverId", gconv.String(form.Params["serverid"])}, {"loginTime.loginTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}}})
}
var oneDayAllM []bson.M
if err := oneDayAll.All(context.TODO(), &oneDayAllM); err != nil {
fmt.Println(err)
}
for _, v1 := range oneDayAllM {
loginTime := v1["loginTime"].(primitive.M)
if !userList.Contains(loginTime["uid"]) {
userList.Append(loginTime["uid"])
}
if !accountList.Contains(loginTime["openId"]) {
accountList.Append(loginTime["openId"])
}
}
userListMap.Set(startTime.Format("Y-m-d"), userList)
userListMap.Set("account"+startTime.Format("Y-m-d"), accountList)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() > endTime.DayOfYear() {
break
}
}
//fmt.Println("=========", userListMap)
var hourLoginList *mongo.Cursor
if form.Params["serverid"] == "" {
hourLoginList = gameinfo.ModelHourLogin.FindAllBson(bs)
} else {
hourLoginList = gameinfo.ModelHourLogin.FindListByServer(bs, form.Params["serverid"])
}
page := g.ListAnyAny{}
dayMap := gmap.New()
for hourLoginList.Next(context.TODO()) {
value := dayMap.Get("creatday")
var hourLogin gameinfo.LogHourLogin
err := hourLoginList.Decode(&hourLogin)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
//第一条数据 直接赋值到map
if value == nil {
dayMap.Set("creatday", hourLogin.CreatDay)
dayMap.Set("hour"+gconv.String(hourLogin.Hour), hourLogin.NewUser)
} else {
//取map中存在的日期
creatday := dayMap.Get("creatday")
//如果遍历到了新的一天
if creatday != hourLogin.CreatDay {
//将map数据添加到返回集合
dayMap.Set("accountcount", len(gconv.Interfaces(userListMap.Get("account"+gconv.String(creatday)))))
dayMap.Set("count", len(gconv.Interfaces(userListMap.Get(creatday))))
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
//清空map 添加新的数据
dayMap.Clear()
dayMap.Set("creatday", hourLogin.CreatDay)
dayMap.Set("hour"+gconv.String(hourLogin.Hour), hourLogin.NewUser)
} else {
//如果是同一天 只添加对应的时间人数即可
dayMap.Set("hour"+gconv.String(hourLogin.Hour), hourLogin.NewUser)
}
}
}
//fmt.Println("dayMap===========================", dayMap)
dayMap.Set("accountcount", len(gconv.Interfaces(userListMap.Get("account"+gconv.String(dayMap.Get("creatday"))))))
dayMap.Set("count", len(gconv.Interfaces(userListMap.Get(gconv.String(dayMap.Get("creatday"))))))
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
//fmt.Println(page)
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
func (action *Action) GetLtvList(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
page := g.ListAnyAny{}
date := g.Config().GetString("startday")
startTime := gtime.NewFromStr(date)
if form.Params["searchData"] != "" {
stime := gconv.MapStrStr(form.Params["searchData"])["0"]
etime := gconv.MapStrStr(form.Params["searchData"])["1"]
//如果开始时间小于配置的开始时间 取配置好的时间
if startTime.DayOfYear() < gtime.NewFromStr(stime).DayOfYear() {
startTime = gtime.NewFromStr(stime)
}
endTime := gtime.NewFromStr(etime)
for {
var sum float64 = 0
strtime := startTime.Format("Y-m-d")
bs := bson.D{{"creatday", strtime}}
dayinfo := gameinfo.ModelLtv.FindLiuCun(bs, gconv.String(form.Params["serverid"]))
dayMap := gmap.New()
dayMap.Set("creatday", strtime)
for dayinfo.Next(context.TODO()) {
var logLtv gameinfo.LogLTV
err := dayinfo.Decode(&logLtv)
money1, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", float64(logLtv.DayAmount)/float64(100)), 64)
sum = sum + money1
dayMap.Set("new", logLtv.NewUser)
dayMap.Set("day"+gconv.String(logLtv.Day), money1)
dayMap.Set("daysum"+gconv.String(logLtv.Day), sum)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
}
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() > endTime.DayOfYear() {
break
}
}
} else {
//fmt.Println("=============", gtime.Now().AddDate(0, 0, -7).Format("Y-m-d"))
//不选择默认查询30天的数据
startTime = gtime.Now().AddDate(0, 0, -30)
for {
var sum float64 = 0
strtime := startTime.Format("Y-m-d")
bs := bson.D{{"creatday", strtime}}
dayinfo := gameinfo.ModelLtv.FindLiuCun(bs, gconv.String(form.Params["serverid"]))
dayMap := gmap.New()
dayMap.Set("creatday", strtime)
for dayinfo.Next(context.TODO()) {
var logLtv gameinfo.LogLTV
err := dayinfo.Decode(&logLtv)
money1, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", float64(logLtv.DayAmount)/float64(100)), 64)
sum = sum + money1
dayMap.Set("new", logLtv.NewUser)
dayMap.Set("day"+gconv.String(logLtv.Day), money1)
dayMap.Set("daysum"+gconv.String(logLtv.Day), sum)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
}
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
startTime = startTime.AddDate(0, 0, 1)
if startTime.DayOfYear() >= gtime.Now().DayOfYear() {
break
}
}
}
fmt.Println(page)
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
func getCont(m map[string]interface{}) int {
count := 0
for k, v := range m {
//key包含hour 把value相加
if strings.Contains(k, "hour") {
count = count + gconv.Int(v)
}
}
return count
}
func (action *Action) PlayerInfo(r *ghttp.Request) {
form := base.NewForm(r.GetQueryMap())
page := g.ListAnyAny{}
//f:=&form
name := r.Form.Get("uid")
sdkuid := r.Form.Get("sdkuid")
serverid := r.Form.Get("serverid")
openid := r.Form.Get("openid")
//name := "东里帛薇"
var bs bson.D
if name != "" {
bs = bson.D{{"playerManager.nickName", name}}
} else if sdkuid != "" {
bs = bson.D{{"_id", gconv.Int(sdkuid)}}
} else if openid != "" {
bs = bson.D{{"playerManager.openId", gconv.String(openid)}}
} else {
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
return
}
var userInfo *mongo.Cursor
if serverid == "" {
userInfo = gameinfo.ModelM5User.FindUser(bs, g.Config().GetString("mongo-port"))
} else {
userInfo = gameinfo.ModelM5User.FindUser(bs, serverid)
}
var showsWithInfo []bson.M
if err := userInfo.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
if showsWithInfo == nil {
base.Resp(r, 1, "无角色信息", nil)
return
}
data := showsWithInfo[0]
dmap := gmap.NewStrAnyMap()
dmap.Set("id", data["_id"])
player := data["playerManager"].(bson.M)
dmap.Set("nickName", player["nickName"])
dmap.Set("openId", player["openId"])
dmap.Set("level", player["level"])
dmap.Set("createTime", gconv.Time(player["createTime"]).String())
dmap.Set("loginTime", gconv.Time(player["loginTime"]).String())
page = append(page, gconv.Map(dmap))
fmt.Println(len(page))
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
func (action *Action) Lv(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
serverid := form.Params["serverid"]
page := g.ListAnyAny{}
lvinfo := gameinfo.ModelM5User.FindLV(gconv.String(serverid))
var showsWithInfo []bson.M
if err := lvinfo.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
//treeMap := gmap.NewTreeMap(gutil.ComparatorInt, true)
for _, m := range showsWithInfo {
//treeMap.Set(m["_id"],m["value"])
dayMap := gmap.New()
dayMap.Set("level", m["_id"])
dayMap.Set("count", m["value"])
page = append(page, gconv.Map(dayMap))
}
fmt.Println(len(page))
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
func (action *Action) Vip(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
serverid := form.Params["serverid"]
page := g.ListAnyAny{}
vipinfo := gameinfo.ModelM5User.FindVIP(gconv.String(serverid))
var showsWithInfo []bson.M
if err := vipinfo.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
//treeMap := gmap.NewTreeMap(gutil.ComparatorInt, true)
for _, m := range showsWithInfo {
//treeMap.Set(m["_id"],m["value"])
dayMap := gmap.New()
dayMap.Set("vipLevel", m["_id"])
dayMap.Set("count", m["value"])
page = append(page, gconv.Map(dayMap))
}
//fmt.Println(len(page))
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
//服务器信息列表
func (action *Action) ServerInfo(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
bs := bson.D{}
if form.Params != nil {
if form.Params["name"] != "" {
bs1 := bson.E{"name", bson.D{{"$regex", form.Params["name"]}}}
bs = append(bs, bs1)
}
if form.Params["channel"] != "" {
bs1 := bson.E{"channel", bson.D{{"$regex", form.Params["channel"]}}}
bs = append(bs, bs1)
}
if form.Params["state"] != "" {
if form.Params["state"] == "0" {
bs1 := bson.E{"state", bson.D{{"$ne", "-1"}}}
bs = append(bs, bs1)
} else {
bs1 := bson.E{"state", form.Params["state"]}
bs = append(bs, bs1)
}
}
if form.Params["isNew"] != "" {
bs1 := bson.E{"is_new", form.Params["isNew"]}
bs = append(bs, bs1)
}
if form.Params["isBanreg"] != "" {
bs1 := bson.E{"is_banreg", form.Params["isBanreg"]}
bs = append(bs, bs1)
}
}
data := g.ListAnyAny{}
count := gameinfo.ModelServer.GetListCount(bs)
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
Total: gconv.Int64(count),
}
serverInfoList := gameinfo.ModelServer.GetPageList(bs, page)
dayMap := gmap.New()
for serverInfoList.Next(context.TODO()) {
var serverInfo gameinfo.ServerInfo
err := serverInfoList.Decode(&serverInfo)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", serverInfo.Id)
dayMap.Set("name", serverInfo.Name)
dayMap.Set("ip", serverInfo.Ip)
dayMap.Set("port", serverInfo.Port)
dayMap.Set("serverId", serverInfo.ServerId)
dayMap.Set("channel", serverInfo.Channel)
dayMap.Set("subChannel", serverInfo.SubChannel)
dayMap.Set("state", serverInfo.State)
dayMap.Set("plat", serverInfo.Plat)
dayMap.Set("openTime", serverInfo.OpenTime)
dayMap.Set("openType", serverInfo.OpenType)
dayMap.Set("isNew", serverInfo.IsNew)
dayMap.Set("isBanreg", serverInfo.IsBanreg)
dayMap.Set("isWhite", serverInfo.IsWhite)
dayMap.Set("serverVersion", serverInfo.ServerVersion)
dayMap.Set("gmip", serverInfo.GMIp)
dayMap.Set("gmport", serverInfo.GMPort)
dayMap.Set("currency", serverInfo.Currency)
dayMap.Set("timezone", serverInfo.Timezone)
dayMap.Set("exportdata", serverInfo.Exportdata)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
fmt.Println(data)
base.Succ(r,
g.Map{
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
//保存服务器信息
func (action *Action) SaveServer(r *ghttp.Request) {
id := r.Form.Get("id")
name := r.Form.Get("name")
ip := r.Form.Get("ip")
port := r.Form.Get("port")
serverId := r.Form.Get("serverId")
channel := r.Form.Get("channel")
subChannel := r.Form.Get("subChannel")
state := r.Form.Get("state")
plat := r.Form.Get("plat")
openTime := r.Form.Get("openTime")
openType := r.Form.Get("openType")
isNew := r.Form.Get("isNew")
isBanreg := r.Form.Get("isBanreg")
isWhite := r.Form.Get("isWhite")
serverVersion := r.Form.Get("serverVersion")
gmip := r.Form.Get("gmip")
gmport := r.Form.Get("gmport")
currency := r.Form.Get("currency")
timezone := r.Form.Get("timezone")
exportdata := r.Form.Get("exportdata")
serverInfo := new(gameinfo.ServerInfo)
serverInfo.Id = gconv.Int(id)
serverInfo.Name = name
serverInfo.Ip = ip
serverInfo.Port = port
serverInfo.ServerId = serverId
serverInfo.Channel = channel
serverInfo.SubChannel = subChannel
serverInfo.State = state
serverInfo.Plat = plat
serverInfo.OpenTime = openTime
serverInfo.OpenType = openType
serverInfo.IsNew = isNew
serverInfo.IsBanreg = isBanreg
serverInfo.IsWhite = isWhite
serverInfo.ServerVersion = serverVersion
serverInfo.GMIp = gmip
serverInfo.GMPort = gmport
serverInfo.Currency = currency
serverInfo.Timezone = timezone
serverInfo.Exportdata = exportdata
// 判断添加还是修改
flag := true
singleResult := gameinfo.ModelServer.FindAllBson(bson.D{})
for singleResult.Next(context.TODO()) {
var si gameinfo.ServerInfo
err := singleResult.Decode(&si)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
// 转成同类型 判断服务器是否存在
if gconv.Int(si.Id) == gconv.Int(serverInfo.Id) {
flag = false
}
}
if flag {
// 添加
gameinfo.ModelServer.AddServer(serverInfo)
base.Resp(r, 0, "添加成功", nil)
} else {
// 修改
res := gameinfo.ModelServer.UpdateServer(gconv.Int(id), serverInfo)
if res.ModifiedCount > 0 {
base.Resp(r, 0, "修改成功", nil)
} else {
base.Resp(r, 1, "修改失败", nil)
}
}
}
//根据id查询服务器信息
func (action *Action) GetServerDetail(r *ghttp.Request) {
id := r.GetInt64("id")
bs := bson.D{{"_id", gconv.Int(id)}}
serverInfoList := gameinfo.ModelServer.FindServerInfoList(bs)
dayMap := gmap.New()
for serverInfoList.Next(context.TODO()) {
var serverInfo gameinfo.ServerInfo
err := serverInfoList.Decode(&serverInfo)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", serverInfo.Id)
dayMap.Set("name", serverInfo.Name)
dayMap.Set("ip", serverInfo.Ip)
dayMap.Set("port", serverInfo.Port)
dayMap.Set("serverId", serverInfo.ServerId)
dayMap.Set("channel", serverInfo.Channel)
dayMap.Set("subChannel", serverInfo.SubChannel)
dayMap.Set("state", serverInfo.State)
dayMap.Set("plat", serverInfo.Plat)
dayMap.Set("openTime", serverInfo.OpenTime)
dayMap.Set("openType", serverInfo.OpenType)
dayMap.Set("isNew", serverInfo.IsNew)
dayMap.Set("isBanreg", serverInfo.IsBanreg)
dayMap.Set("isWhite", serverInfo.IsWhite)
dayMap.Set("serverVersion", serverInfo.ServerVersion)
dayMap.Set("gmip", serverInfo.GMIp)
dayMap.Set("gmport", serverInfo.GMPort)
dayMap.Set("currency", serverInfo.Currency)
dayMap.Set("timezone", serverInfo.Timezone)
dayMap.Set("exportdata", serverInfo.Exportdata)
}
fmt.Println("dayMap=", dayMap)
base.Succ(r, dayMap)
}
//删除服务器信息
func (action *Action) DelServer(r *ghttp.Request) {
id := r.GetInt64("id")
bs := bson.D{{"_id", gconv.Int(id)}}
deleteResult := gameinfo.ModelServer.DelServer(bs)
fmt.Println(deleteResult.DeletedCount)
base.Succ(r, g.Map{"code": 0, "result": deleteResult.DeletedCount})
}
//获取服务器列表
func (action *Action) GetServerList(r *ghttp.Request) {
list := glist.New()
2023-08-15 11:46:55 +08:00
//bs := bson.D{{"$where", "this.server_id == this.real_server_id"}}
2023-03-20 13:38:28 +08:00
bs := bson.D{}
serverInfoList := gameinfo.ModelServer.FindServerInfoList(bs)
for serverInfoList.Next(context.TODO()) {
dayMap := gmap.New()
var serverInfo gameinfo.ServerInfo
err := serverInfoList.Decode(&serverInfo)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", serverInfo.Id)
dayMap.Set("name", serverInfo.Name)
dayMap.Set("gmip", serverInfo.GMIp)
dayMap.Set("gmport", serverInfo.GMPort)
dayMap.Set("serverid", serverInfo.ServerId)
list.PushFront(dayMap)
}
base.Succ(r, list)
}
//白名单列表
func (action *Action) WhiteList(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
bs := bson.D{}
if form.Params != nil {
if form.Params["openId"] != "" {
bs1 := bson.E{"openId", bson.D{{"$regex", form.Params["openId"]}}}
bs = append(bs, bs1)
}
}
count := gameinfo.ModelWhiteList.GetListCount(bs)
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
Total: gconv.Int64(count),
}
data := g.ListAnyAny{}
whiteListData := gameinfo.ModelWhiteList.FindWhiteList(bs, page)
dayMap := gmap.New()
for whiteListData.Next(context.TODO()) {
var whiteList gameinfo.WhiteList
err := whiteListData.Decode(&whiteList)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", whiteList.Id)
dayMap.Set("openId", whiteList.OpenId)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
fmt.Println(data)
base.Succ(r,
g.Map{
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
//保存白名单
func (action *Action) SaveWhiteList(r *ghttp.Request) {
id := r.Form.Get("id")
openid := r.Form.Get("openId")
obj_id := primitive.NewObjectID()
if id != "" {
obj_id, _ = primitive.ObjectIDFromHex(id)
}
whiteList := new(gameinfo.WhiteList)
whiteList.Id = obj_id
whiteList.OpenId = openid
res := gameinfo.ModelWhiteList.AddBlackList(id, openid, whiteList)
if res > 0 {
base.Succ(r, g.Map{"code": 0, "result": "操作成功"})
} else {
base.Succ(r, g.Map{"code": 1, "result": "操作失败"})
}
}
func (action *Action) GetWhiteListDetail(r *ghttp.Request) {
id := r.GetString("id")
obj_id, _ := primitive.ObjectIDFromHex(id)
bs := bson.D{{"_id", obj_id}}
page := util.Page{
PageSize: 1,
CurrentPage: 1,
Total: 1,
}
whiteListData := gameinfo.ModelWhiteList.FindWhiteList(bs, page)
dayMap := gmap.New()
for whiteListData.Next(context.TODO()) {
var whiteList gameinfo.WhiteList
err := whiteListData.Decode(&whiteList)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", whiteList.Id)
dayMap.Set("openId", whiteList.OpenId)
}
fmt.Println("dayMap=", dayMap)
base.Succ(r, dayMap)
}
//删除白名单信息
func (action *Action) DelWhiteList(r *ghttp.Request) {
id := r.GetString("id")
obj_id, _ := primitive.ObjectIDFromHex(id)
bs := bson.D{{"_id", obj_id}}
deleteResult := gameinfo.ModelWhiteList.DelWhiteList(bs)
fmt.Println(deleteResult.DeletedCount)
base.Succ(r, g.Map{"code": 0, "result": deleteResult.DeletedCount})
}
//黑名单列表
func (action *Action) BlackList(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
bs := bson.D{}
if form.Params != nil {
if form.Params["openId"] != "" {
bs1 := bson.E{"openId", bson.D{{"$regex", form.Params["openId"]}}}
bs = append(bs, bs1)
}
}
data := g.ListAnyAny{}
count := gameinfo.ModelBlackList.GetListCount(bs)
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
Total: gconv.Int64(count),
}
blackListData := gameinfo.ModelBlackList.FindBlackList(bs, page)
dayMap := gmap.New()
for blackListData.Next(context.TODO()) {
var blackList gameinfo.BlackList
err := blackListData.Decode(&blackList)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", blackList.Id)
dayMap.Set("openId", blackList.OpenId)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
fmt.Println(data)
base.Succ(r,
g.Map{
//"page": page.PageSize,
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
//保存黑名单
func (action *Action) SaveBlackList(r *ghttp.Request) {
id := r.Form.Get("id")
openid := r.Form.Get("openId")
obj_id := primitive.NewObjectID()
if id != "" {
obj_id, _ = primitive.ObjectIDFromHex(id)
}
blackList := new(gameinfo.BlackList)
blackList.Id = obj_id
blackList.OpenId = openid
res := gameinfo.ModelBlackList.AddBlackList(id, openid, blackList)
if res > 0 {
base.Succ(r, g.Map{"code": 0, "result": "操作成功"})
} else {
base.Succ(r, g.Map{"code": 1, "result": "操作失败"})
}
}
func (action *Action) GetBlackListDetail(r *ghttp.Request) {
id := r.GetString("id")
obj_id, _ := primitive.ObjectIDFromHex(id)
bs := bson.D{{"_id", obj_id}}
page := util.Page{
PageSize: 1,
CurrentPage: 1,
Total: 1,
}
blackListData := gameinfo.ModelBlackList.FindBlackList(bs, page)
dayMap := gmap.New()
for blackListData.Next(context.TODO()) {
var blackList gameinfo.BlackList
err := blackListData.Decode(&blackList)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", blackList.Id)
dayMap.Set("openId", blackList.OpenId)
}
fmt.Println("GetBlackListDetail-dayMap=", dayMap)
base.Succ(r, dayMap)
}
//删除黑名单信息
func (action *Action) DelBlackList(r *ghttp.Request) {
id := r.GetString("id")
obj_id, _ := primitive.ObjectIDFromHex(id)
bs := bson.D{{"_id", obj_id}}
deleteResult := gameinfo.ModelBlackList.DelBlackList(bs)
fmt.Println(deleteResult.DeletedCount)
base.Succ(r, g.Map{"code": 0, "result": deleteResult.DeletedCount})
}
//公告信息列表
func (action *Action) NoticeInfo(r *ghttp.Request) {
var timeLayoutStr = "2006-01-02 15:04:05"
form := base.NewForm(r.GetMap())
bs := bson.D{}
data := g.ListAnyAny{}
count := gameinfo.ModelNoticeInfo.GetListCount(bs)
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
Total: gconv.Int64(count),
}
noticeInfoData := gameinfo.ModelNoticeInfo.GetPageList(bs, page)
dayMap := gmap.New()
for noticeInfoData.Next(context.TODO()) {
var noticeInfo gameinfo.NoticeInfo
err := noticeInfoData.Decode(&noticeInfo)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", noticeInfo.Id)
dayMap.Set("title", noticeInfo.Title)
dayMap.Set("content", noticeInfo.Content)
dayMap.Set("grade", noticeInfo.Grade)
st := time.Unix(noticeInfo.PublishTime/1000, 0).Format(timeLayoutStr)
dayMap.Set("publishtime", st)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
fmt.Println(data)
base.Succ(r,
g.Map{
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
//保存公告
func (action *Action) SaveNoticeInfo(r *ghttp.Request) {
//var timeLayoutStr = "2006-01-02 15:04:05"
id := r.Form.Get("id")
title := r.Form.Get("title")
content := r.Form.Get("content")
grade := r.Form.Get("grade")
time := r.Form.Get("publishtime")
fmt.Println("time================", time)
publishtime := gtime.NewFromStr(time)
noticeInfo := new(gameinfo.NoticeInfo)
noticeInfo.Id = id
noticeInfo.Title = title
noticeInfo.Content = content
noticeInfo.Grade = grade
noticeInfo.PublishTime = gconv.Int64(publishtime.TimestampMilliStr())
res := gameinfo.ModelNoticeInfo.AddNoticeInfo(gconv.String(id), noticeInfo)
fmt.Println("res=", res.MatchedCount)
if res.ModifiedCount > 0 {
base.Succ(r, g.Map{"code": 0, "result": "操作成功"})
} else {
base.Succ(r, g.Map{"code": 1, "result": "操作失败"})
}
}
func (action *Action) GetNoticeInfoDetail(r *ghttp.Request) {
id := r.GetInt64("id")
bs := bson.D{{"_id", gconv.String(id)}}
noticeInfoData := gameinfo.ModelNoticeInfo.FindNoticeInfo(bs)
dayMap := gmap.New()
for noticeInfoData.Next(context.TODO()) {
var noticeInfo gameinfo.NoticeInfo
err := noticeInfoData.Decode(&noticeInfo)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("id", noticeInfo.Id)
dayMap.Set("title", noticeInfo.Title)
dayMap.Set("content", noticeInfo.Content)
dayMap.Set("grade", noticeInfo.Grade)
dayMap.Set("publishtime", noticeInfo.PublishTime)
}
fmt.Println("dayMap=", dayMap)
base.Succ(r, dayMap)
}
//删除公告
func (action *Action) DelNoticeInfo(r *ghttp.Request) {
id := r.GetInt64("id")
bs := bson.D{{"_id", gconv.String(id)}}
deleteResult := gameinfo.ModelNoticeInfo.DelNoticeInfo(bs)
fmt.Println(deleteResult.DeletedCount)
base.Succ(r, g.Map{"code": 0, "result": deleteResult.DeletedCount})
}
// 整体数据
func (action *Action) GetRechargeStatisticsList(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
bs := bson.D{}
if form.Params != nil {
if form.Params["searchData"] != "" {
stime := gconv.MapStrStr(form.Params["searchData"])["0"]
etime := gconv.MapStrStr(form.Params["searchData"])["1"]
bs = bson.D{{"creatday", bson.D{{"$gte", stime}, {"$lte", etime}}}}
}
}
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
}
var statisticalRechargeList *mongo.Cursor
if form.Params["serverid"] == "" {
count := gameinfo.ModelStatisticalRecharge.GetListCount(bs)
page.Total = gconv.Int64(count)
statisticalRechargeList = gameinfo.ModelStatisticalRecharge.GetDataByTimeDesc(bs, page)
} else {
count := gameinfo.ModelStatisticalRecharge.GetListCountByServer(bs, form.Params["serverid"])
page.Total = gconv.Int64(count)
statisticalRechargeList = gameinfo.ModelStatisticalRecharge.GetDataByServerTimeDesc(bs, page, form.Params["serverid"])
}
data := g.ListAnyAny{}
dayMap := gmap.New()
regMap := gameinfo.ModelRegister.FindRegTime()
loginMap := gameinfo.ModeLogin.FindDau()
for statisticalRechargeList.Next(context.TODO()) {
var statisticalRecharge gameinfo.StatisticalRecharge
err := statisticalRechargeList.Decode(&statisticalRecharge)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
creatDay := statisticalRecharge.CreatDay
dayMap.Set("creatday", creatDay) //日期
dayMap.Set("newrechargenum", statisticalRecharge.NewRechargeNum) //新增充值人数
newRechargeAmount1, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", float64(statisticalRecharge.NewRechargeAmount)/float64(100)), 64)
dayMap.Set("newrechargeamount", newRechargeAmount1) //新增充值总额
dayMap.Set("newrechargecount", statisticalRecharge.NewRechargeCount) //新增充值次数
dayMap.Set("rechargenum", statisticalRecharge.RechargeNum) //充值人数
rechargeAmount1, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", float64(statisticalRecharge.RechargeAmount)/float64(100)), 64)
dayMap.Set("rechargeamount", rechargeAmount1) //充值总额
dayMap.Set("rechargecount", statisticalRecharge.RechargeCount) //充值次数
dayMap.Set("oldrechargenum", gconv.Int(statisticalRecharge.RechargeNum)-gconv.Int(statisticalRecharge.NewRechargeNum)) //老用户充值人数
dayMap.Set("oldrechargeamount", rechargeAmount1-newRechargeAmount1) //老用户充值总额
//var registerNum, loginNum, oldLoginNum int
if form.Params["serverid"] == "" {
//新增角色、DAU(账号)赋初始值
dayMap.Set("newrole", 0)
dayMap.Set("pDayu", 0)
for _, m := range regMap {
if gconv.String(m["date"]) == creatDay {
//新增角色
dayMap.Set("newrole", m["count"])
}
}
for _, m := range loginMap {
if gconv.String(m["date"]) == creatDay {
//DAU(账号)
dayMap.Set("pDayu", m["count"])
}
}
////查询注册人数
//registerNum := gameinfo.ModelHour.GetOneDayRegister(creatDay)
//查询当日注册账号数
registerAccountNum := gameinfo.ModelRegister.GetOneDayRegisterAccount(creatDay, "")
startTime := gtime.NewFromStr(creatDay)
userList := garray.New(false)
userAccountList := garray.New(false)
daystartTime := startTime.Local().TimestampMilli()
dayendTime := startTime.Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
oneDayAll := gameinfo.ModeLogin.FindAllBson(bson.D{{"loginTime.loginTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}}})
var oneDayAllM []bson.M
if err := oneDayAll.All(context.TODO(), &oneDayAllM); err != nil {
fmt.Println(err)
}
for _, v1 := range oneDayAllM {
loginTime := v1["loginTime"].(primitive.M)
if !userList.Contains(loginTime["uid"]) {
userList.Append(loginTime["uid"])
}
if !userAccountList.Contains(loginTime["openId"]) {
userAccountList.Append(loginTime["openId"])
}
}
//登录角色数
loginNum := userList.Len()
//查询登录账号数
loginAccountNum := userAccountList.Len()
//当日或自定义时间段的老用户登录数
oldLoginNum := gameinfo.ModelHourLogin.GetOldUserLoginNum(creatDay)
//新增付费率 (新增充值人数 / 当日注册人数(账号))
dayMap.Set("newrate", gconv.String(gconv.Float64(statisticalRecharge.NewRechargeNum)/gconv.Float64(registerAccountNum)*100))
//登录付费率 (总充值人数 / 登录人数(账号))|
dayMap.Set("loginrate", gconv.String(gconv.Float64(statisticalRecharge.RechargeNum)/gconv.Float64(loginAccountNum)*100))
//arppu (充值总额 / 充值人数)|
dayMap.Set("arppu", gconv.String(gconv.Float64(rechargeAmount1)/gconv.Float64(statisticalRecharge.RechargeNum)))
//老用户付费率 (老用户充值人数 / 当日或自定义时间段的老用户登录数)|
dayMap.Set("oldrate", gconv.String(gconv.Float64(gconv.Float64(statisticalRecharge.RechargeNum)-gconv.Float64(statisticalRecharge.NewRechargeNum))/gconv.Float64(oldLoginNum)*100))
//新增arpu (新增充值总额 / 当日注册人数(账号))|
dayMap.Set("newarpu", gconv.String(gconv.Float64(newRechargeAmount1)/gconv.Float64(registerAccountNum)))
//老玩家arpu (老用户充值总额 / 当日或自定义时间段的老用户登录数)
dayMap.Set("oldarpu", gconv.String(gconv.Float64(rechargeAmount1-newRechargeAmount1)/gconv.Float64(oldLoginNum)))
//活跃arpu (充值总额 / 登录人数(账号))
dayMap.Set("activearpu", gconv.String(gconv.Float64(rechargeAmount1)/gconv.Float64(loginAccountNum)))
////当日ltv (当日充值总额 / 当日登录人数)
//dayMap.Set("ltv", gconv.String(gconv.Float64(statisticalRecharge.RechargeAmount)/gconv.Float64(loginNum)))
//新增(账号)
dayMap.Set("regnum", registerAccountNum)
//总登角色
dayMap.Set("count", loginNum)
} else {
//查询注册人数
registerNum := gameinfo.ModelHour.GetOneDayRegisterByServer(creatDay, gconv.String(form.Params["serverid"]))
//查询当日注册账号数
registerAccountNum := gameinfo.ModelRegister.GetOneDayRegisterAccount(creatDay, gconv.String(form.Params["serverid"]))
//fmt.Println("==================================", registerNum, creatDay, registerAccountNum)
startTime := gtime.NewFromStr(creatDay)
userList := garray.New(false)
daystartTime := startTime.Local().TimestampMilli()
dayendTime := startTime.Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
oneDayAll := gameinfo.ModeLogin.FindAllBson(bson.D{{"loginTime.serverId", gconv.String(form.Params["serverid"])}, {"loginTime.loginTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}}})
var oneDayAllM []bson.M
if err := oneDayAll.All(context.TODO(), &oneDayAllM); err != nil {
fmt.Println(err)
}
for _, v1 := range oneDayAllM {
loginTime := v1["loginTime"].(primitive.M)
if !userList.Contains(loginTime["uid"]) {
userList.Append(loginTime["uid"])
}
}
//查询登录人数
loginNum := userList.Len()
////查询登录人数
//loginNum = gameinfo.ModelHourLogin.GetOneDayRegisterByServer(creatDay, gconv.String(form.Params["serverid"]))
//当日或自定义时间段的老用户登录数
oldLoginNum := gameinfo.ModelHourLogin.GetOldUserLoginNumByServer(creatDay, gconv.String(form.Params["serverid"]))
//新增付费率 (该服新增充值角色数 / 当日该服新增角色数)
dayMap.Set("newrate", gconv.String(gconv.Float64(statisticalRecharge.NewRechargeNum)/gconv.Float64(registerNum)*100))
//登录付费率 (该服当日总充值角色数 / 当日该服登录角色数)
dayMap.Set("loginrate", gconv.String(gconv.Float64(statisticalRecharge.RechargeNum)/gconv.Float64(loginNum)*100))
//arppu (该服当日充值总额 / 该服当日充值角色数(排重))
dayMap.Set("arppu", gconv.String(gconv.Float64(rechargeAmount1)/gconv.Float64(statisticalRecharge.RechargeNum)))
//老用户付费率 (该服老用户充值角色数 / 当日或自定义时间段的老用户角色登录数)
dayMap.Set("oldrate", gconv.String(gconv.Float64(gconv.Float64(statisticalRecharge.RechargeNum)-gconv.Float64(statisticalRecharge.NewRechargeNum))/gconv.Float64(oldLoginNum)*100))
//新增arpu (该服当日新增充值总额 / 该服当日新增角色数)
dayMap.Set("newarpu", gconv.String(gconv.Float64(newRechargeAmount1)/gconv.Float64(registerNum)))
//老玩家arpu (该服老用户角色充值总额 / 当日或自定义时间段的老用户角色登录数)
dayMap.Set("oldarpu", gconv.String(gconv.Float64(rechargeAmount1-newRechargeAmount1)/gconv.Float64(oldLoginNum)))
//活跃arpu (该服充值总额 / 该服当日登录角色数)
dayMap.Set("activearpu", gconv.String(gconv.Float64(rechargeAmount1)/gconv.Float64(loginNum)))
////当日ltv (当日该服充值总额 / 当日该服登录角色数)
//dayMap.Set("ltv", gconv.String(gconv.Float64(statisticalRecharge.RechargeAmount)/gconv.Float64(loginNum)))
//新增(账号)
dayMap.Set("regnum", registerAccountNum)
//总登角色
dayMap.Set("count", loginNum)
//新增角色、DAU(账号)
dayMap.Set("newrole", registerNum)
dayMap.Set("pDayu", loginNum)
}
//获取今天新增的玩家
daystartTime := gtime.NewFromStr(creatDay).Local().TimestampMilli()
dayendTime := gtime.NewFromStr(creatDay).Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
todayUsers := garray.New(false)
//查询当日新增玩家累计付费信息
var todayRes interface{}
if form.Params["serverid"] == "" {
todayUsers = gameinfo.ModelRegister.FindNew(daystartTime, dayendTime)
todayRes = gameinfo.ModelPay.GetTodayNewCumulativeRecharge(gconv.SliceAny(todayUsers), creatDay, "")
} else {
todayUsers = gameinfo.ModelRegister.FindNewByServerId(daystartTime, dayendTime, form.Params["serverid"])
todayRes = gameinfo.ModelPay.GetTodayNewCumulativeRecharge(gconv.SliceAny(todayUsers), creatDay, form.Params["serverid"])
}
todaymap := gconv.Map(todayRes)
//当日新增玩家累计付费人数
if todaymap["num"] != "" {
dayMap.Set("todaynewcumulativerechargenum", todaymap["num"])
} else {
dayMap.Set("todaynewcumulativerechargenum", 0)
}
//当日新增玩家累计付费金额
if todaymap["amount"] != "" {
amount, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", gconv.Float64(todaymap["amount"])/float64(100)), 64)
dayMap.Set("todaynewcumulativerechargeamount", amount)
} else {
dayMap.Set("todaynewcumulativerechargeamount", 0)
}
//当日新增玩家累计付费次数
if todaymap["count"] != "" {
dayMap.Set("todaynewcumulativerechargecount", todaymap["count"])
} else {
dayMap.Set("todaynewcumulativerechargecount", 0)
}
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
base.Succ(r,
g.Map{
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
//消费流水
func (action *Action) RechargeFlow(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
bs := bson.D{}
if form.Params != nil {
if form.Params["uid"] != "" {
bs1 := bson.E{"uid", gconv.Int32(form.Params["uid"])}
bs = append(bs, bs1)
}
if form.Params["serverid"] != "" {
bs1 := bson.E{"region", gconv.Int32(form.Params["serverid"])}
bs = append(bs, bs1)
}
if form.Params["orderId"] != "" {
bs1 := bson.E{"billno", form.Params["orderId"]}
bs = append(bs, bs1)
}
if form.Params["payItem"] != "" {
bs1 := bson.E{"pay_item", form.Params["payItem"]}
bs = append(bs, bs1)
}
if form.Params["payStatus"] != "" {
if form.Params["payStatus"] == "1" {
bs1 := bson.E{"status", gconv.Int32(1)}
bs = append(bs, bs1)
bs2 := bson.E{"handlestatus", gconv.Int32(1)}
bs = append(bs, bs2)
}
}
if form.Params["searchData"] != "" {
stime := gconv.MapStrStr(form.Params["searchData"])["0"]
etime := gconv.MapStrStr(form.Params["searchData"])["1"]
bs1 := bson.E{"creattime", bson.D{{"$gte", gconv.String(stime)}, {"$lte", gconv.String(etime)}}}
bs = append(bs, bs1)
}
}
data := g.ListAnyAny{}
count := gameinfo.ModelPay.GetListCount(bs)
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
Total: gconv.Int64(count),
}
payList := gameinfo.ModelPay.FindHour(bs, page)
dayMap := gmap.New()
for payList.Next(context.TODO()) {
var pay gameinfo.Pay
err := payList.Decode(&pay)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("uid", pay.Uid)
dayMap.Set("region", pay.Region)
dayMap.Set("status", pay.Status)
dayMap.Set("handlestatus", pay.Handlestatus)
dayMap.Set("payItem", pay.PayItem)
dayMap.Set("billno", pay.Billno)
money1, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", gconv.Float64(pay.Money)/float64(100)), 64)
dayMap.Set("money", money1)
dayMap.Set("cporderId", pay.CporderId)
dayMap.Set("level", pay.Level)
dayMap.Set("vipLevel", pay.VipLevel)
dayMap.Set("creattime", pay.Creattime)
dayMap.Set("callbaktime", pay.Callbaktime)
dayMap.Set("handletime", pay.Handlestatus)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
fmt.Println(data)
base.Succ(r,
g.Map{
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
type ChatInfo struct {
Uid int `json:"uid"`
Name string `json:"name"`
Type int `json:"type"`
Message string `json:"message"`
Time int64 `json:"time"`
Status int `json:"status"`
}
//获取聊天信息
func (action *Action) GetChatInfoList(r *ghttp.Request) {
const CHAT_INFO_CACHE = "CHAT_INFO_CACHE"
const separator = ":"
const timeLayoutStr = "2006-01-02 15:04:05"
serverId := g.Config().GetString("mongo-port")
//1世界;2公会
paramType := "1"
form := base.NewForm(r.GetMap())
if form.Params != nil {
if form.Params["serverid"] != "" {
serverId = form.Params["serverid"]
}
if form.Params["ctype"] != "" {
paramType = form.Params["ctype"]
}
}
page := g.ListAnyAny{}
jsonStr, _ := g.Redis().DoVar("LRANGE", serverId+separator+CHAT_INFO_CACHE+separator+paramType, "0", "-1")
res := jsonStr.Array()
for _, v := range res {
var chatInfo ChatInfo
e := json.Unmarshal([]byte(gconv.String(v)), &chatInfo)
if e != nil {
fmt.Println("转换json出现错误")
base.Succ(r,
g.Map{
"page": form.Page,
"rows": g.ListAnyAny{},
"total": form.TotalPage,
"records": form.TotalSize,
})
}
dayMap := gmap.New()
dayMap.Set("uid", chatInfo.Uid)
dayMap.Set("serverId", serverId)
dayMap.Set("name", chatInfo.Name)
dayMap.Set("type", chatInfo.Type)
dayMap.Set("message", chatInfo.Message)
dayMap.Set("status", chatInfo.Status)
dayMap.Set("time", time.Unix(chatInfo.Time/1000, 0).Format(timeLayoutStr))
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
}
fmt.Println(page)
base.Succ(r,
g.Map{
"page": form.Page,
"rows": page,
"total": form.TotalPage,
"records": form.TotalSize,
})
}
//设置禁言状态
func (action *Action) SetSilence(r *ghttp.Request) {
const cmdStr = "silence"
id := r.GetString("id")
stype := r.GetString("type")
serverid := r.GetString("serverId")
if serverid == "undefined" {
base.Fail(r, "请选择服务器后再试一下")
}
ages := id + " " + stype
//根据服务器id查询gmip,gmport,服务器名称
singleResult := gameinfo.ModelServer.FindOne("server_id", serverid)
var serverInfo gameinfo.ServerInfo
err := singleResult.Decode(&serverInfo)
gmip := serverInfo.GMIp
gmport := serverInfo.GMPort
servername := serverInfo.Name
if err != nil {
base.Fail(r, "查询服务器信息出现异常,"+serverid)
}
cmd := netutil.Gmcmd{
ServerIp: gmip,
ServerPort: gmport,
Cmd: cmdStr,
Args: ages,
}
fmt.Println(cmd)
res := cmd.Creatcdk() //0 成功
if res == -100 {
base.Resp(r, 1, "thrift解析地址时出错", nil)
} else if res == -101 {
base.Resp(r, 1, "thrift打开服务器socket出错", nil)
}
//保存日志
var silenceLog gm.SilenceLog
silenceLog.Id = primitive.NewObjectID()
silenceLog.ServerId = serverid
silenceLog.ServerName = servername
silenceLog.Uid = gconv.Int(id)
silenceLog.Stype = gconv.Int(stype)
silenceLog.Cmd = gconv.String(cmdStr)
silenceLog.UpdateUser = base.GetUser(r).Username
silenceLog.UpdateTime = time.Now().Unix()
gm.ModelSilence.InsertOne(silenceLog)
if res == 0 {
base.Resp(r, 0, "修改成功", nil)
} else {
base.Resp(r, 1, "修改失败", nil)
}
}
2023-08-15 11:46:55 +08:00
//发送跑马灯
func (action *Action) SendMsg(r *ghttp.Request) {
const cmdStr = "sendmsg"
speed := r.GetString("speed")
multime := r.GetString("multime")
sendTime := r.GetString("sendTime")
content := r.GetString("content")
serverid := r.GetFormVar("serverId").Map()
serverids := make([]string, 0, len(serverid))
serverNames := make([]string, 0, len(serverid))
for _, v := range serverid {
serverids = append(serverids, gconv.String(v))
}
ages := speed + " " + multime + " " + sendTime + " " + content
serverInfoList := gameinfo.ModelServer.FindServerInfoList(bson.M{"server_id": bson.M{"$in": serverids}})
for serverInfoList.Next(context.TODO()) {
var serverInfo gameinfo.ServerInfo
err := serverInfoList.Decode(&serverInfo)
if err != nil {
//log.Fatal(err)
base.Fail(r, "查询服务器信息出现异常,"+serverInfo.ServerId)
log.Println(err)
continue
}
serverNames = append(serverNames, serverInfo.Name)
gmip := serverInfo.GMIp
gmport := serverInfo.GMPort
cmd := netutil.Gmcmd{
ServerIp: gmip,
ServerPort: gmport,
Cmd: cmdStr,
Args: ages,
}
res := cmd.Creatcdk() //0 成功
if res == -100 {
base.Resp(r, 1, "thrift解析地址时出错", serverInfo)
} else if res == -101 {
base.Resp(r, 1, "thrift打开服务器socket出错", serverInfo)
}
if res == 0 {
} else {
base.Resp(r, 1, "新增失败", nil)
}
}
var sendMsgLog gm.SendMsgLog
sendMsgLog.Id = primitive.NewObjectID()
sendMsgLog.Content = content
sendMsgLog.SendTime = gconv.Int64(sendTime)
sendMsgLog.MulTimes = gconv.Int32(multime)
sendMsgLog.ServerIdList = serverids
sendMsgLog.ServerNameList = serverNames
sendMsgLog.Speed = gconv.Int32(speed)
sendMsgLog.UpdateUser = base.GetUser(r).Username
sendMsgLog.UpdateTime = time.Now().Unix()
gm.ModelSendMsg.InsertOne(sendMsgLog)
base.Resp(r, 0, "发布成功", nil)
}
//查询跑马灯列表
func (action *Action) GetSendMsgList(r *ghttp.Request) {
var timeLayoutStr = "2006-01-02 15:04:05"
form := base.NewForm(r.GetMap())
bs := bson.D{{}}
data := g.ListAnyAny{}
count := gm.ModelSendMsg.GetListCount(bs)
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
Total: gconv.Int64(count),
}
sendMsgLogList := gm.ModelSendMsg.GetPageList(bs, page)
dayMap := gmap.New()
for sendMsgLogList.Next(context.TODO()) {
var sendMsgLog gm.SendMsgLog
err := sendMsgLogList.Decode(&sendMsgLog)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("serverNameList", sendMsgLog.ServerNameList)
dayMap.Set("content", sendMsgLog.Content)
dayMap.Set("sendTime", time.Unix(sendMsgLog.SendTime/1000, 0).Format(timeLayoutStr))
dayMap.Set("speed", sendMsgLog.Speed)
dayMap.Set("mulTimes", sendMsgLog.MulTimes)
dayMap.Set("updateUser", sendMsgLog.UpdateUser)
st := time.Unix(sendMsgLog.UpdateTime, 0).Format(timeLayoutStr)
dayMap.Set("updateTime", st)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
fmt.Println(data)
base.Succ(r,
g.Map{
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
2023-03-20 13:38:28 +08:00
//获取在线人数
func (action *Action) GetOnlineNumList(r *ghttp.Request) {
const ONLINE_NUM = "ONLINE_NUM"
const separator = ":"
page := g.ListAnyAny{}
bs := bson.D{}
serverInfoList := gameinfo.ModelServer.FindServerInfoList(bs)
for serverInfoList.Next(context.TODO()) {
var serverInfo gameinfo.ServerInfo
err := serverInfoList.Decode(&serverInfo)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
jsonStr, _ := g.Redis().DoVar("GET", ONLINE_NUM+separator+serverInfo.ServerId)
res := jsonStr.Array()
onlineNum := 0
dayMap := gmap.New()
for _, v := range res {
e := json.Unmarshal([]byte(gconv.String(v)), &onlineNum)
if e != nil {
fmt.Println("转换json出现错误")
base.Succ(r,
g.Map{
"rows": g.ListAnyAny{},
})
}
}
dayMap.Set("serverName", serverInfo.Name)
dayMap.Set("onlineNum", gconv.String(onlineNum))
page = append(g.ListAnyAny{gconv.Map(dayMap)}, page...)
}
fmt.Println(page)
base.Succ(r,
g.Map{
"rows": page,
})
}
//用户操作记录
func (action *Action) GetItemLogList(r *ghttp.Request) {
// 读取配置表
itemConfig := codeutil.GetItemConfig()
reasonConfig := codeutil.GetReasonConfig()
const timeLayoutStr = "2006-01-02 15:04:05"
form := base.NewForm(r.GetMap())
bs := bson.D{}
// 默认查询配置中的服务器
serverId := g.Config().GetString("mongo-port")
if form.Params != nil {
if form.Params["uid"] != "" {
bs1 := bson.E{"uid", gconv.Int32(form.Params["uid"])}
bs = append(bs, bs1)
}
if form.Params["serverid"] != "" {
serverId = gconv.String(form.Params["serverid"])
}
if form.Params["typenum"] != "" {
bs1 := bson.E{"type", gconv.Int32(form.Params["typenum"])}
bs = append(bs, bs1)
}
if form.Params["reasonid"] != "" {
bs1 := bson.E{"reason", gconv.Int32(form.Params["reasonid"])}
bs = append(bs, bs1)
}
if form.Params["itemId"] != "" {
bs1 := bson.E{"itemId", gconv.Int32(form.Params["itemId"])}
bs = append(bs, bs1)
}
if form.Params["searchData"] != "" {
stime := gconv.MapStrStr(form.Params["searchData"])["0"]
etime := gconv.MapStrStr(form.Params["searchData"])["1"]
startTime := gtime.NewFromStr(stime).Local().TimestampMilli()
endTime := gtime.NewFromStr(etime).Local().TimestampMilli()
bs = append(bs, bson.E{"time", bson.D{{"$gte", gconv.String(startTime)}, {"$lte", gconv.String(endTime)}}})
}
}
data := g.ListAnyAny{}
bsCount := len(bs)
count := 0
if bsCount > 0 {
count = gameinfo.ModelItemlog.GetListCountByServer2(bs, serverId)
}
page := util.Page{
PageSize: gconv.Int64(form.Rows),
CurrentPage: gconv.Int64(form.Page),
Total: gconv.Int64(count),
}
dayMap := gmap.New()
if bsCount > 0 {
payList := gameinfo.ModelItemlog.GetDataByServerTimeDesc2(bs, page, serverId)
for payList.Next(context.TODO()) {
var itemLog gameinfo.ItemLog
err := payList.Decode(&itemLog)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
dayMap.Set("uid", itemLog.Uid)
dayMap.Set("typenum", itemLog.Type)
dayMap.Set("level", itemLog.Level)
dayMap.Set("time", gconv.Time(itemLog.Time).Format(timeLayoutStr))
dayMap.Set("reasonid", itemLog.Reason)
reasonNotes, _ := reasonConfig.Get(gconv.String(itemLog.Reason))
dayMap.Set("reason", gconv.Map(reasonNotes)["Notes"])
dayMap.Set("itemid", itemLog.ItemId)
goodsName, _ := itemConfig.Get(gconv.String(itemLog.ItemId))
dayMap.Set("itemname", goodsName)
dayMap.Set("itemnum", itemLog.ItemNum)
dayMap.Set("itemtotalnum", itemLog.ItemTotalNum)
dayMap.Set("exitInfo", itemLog.ExitInfo)
dayMap.Set("totalnum", 0)
dayMap.Set("state", 0)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
}
if form.Params["itemId"] != "" && form.Params["uid"] != "" {
for res := range data {
if res == form.Rows-1 || res == len(data)-1 {
continue
}
//fmt.Println(item)
item := gconv.MapStrStr(data[res])
nextItem := gconv.MapStrStr(data[res+1])
typenum := gconv.MapStrStr(data[res+1])["typenum"]
// 0:获得1:消耗
if typenum == "0" {
// 正常情况是相等的
num := gconv.Int(nextItem["itemtotalnum"]) - gconv.Int(nextItem["itemnum"])
if gconv.Int(item["itemtotalnum"]) == num {
item["totalnum"] = gconv.String(num)
item["state"] = "0"
} else {
item["totalnum"] = gconv.String(num)
item["state"] = "1"
}
} else if typenum == "1" {
// 正常情况是相等的
num := gconv.Int(nextItem["itemtotalnum"]) + gconv.Int(nextItem["itemnum"])
if gconv.Int(item["itemtotalnum"]) == num {
item["totalnum"] = gconv.String(num)
item["state"] = "0"
} else {
item["totalnum"] = gconv.String(num)
item["state"] = "1"
}
} else {
item["totalnum"] = "0"
item["state"] = "1"
}
data[res] = gconv.Map(item)
}
}
itemConfig.Close()
reasonConfig.Close()
base.Succ(r,
g.Map{
"rows": data,
"total": page.Total,
"current": page.CurrentPage,
})
}
// 一键修改状态
func (action *Action) SaveUpdateStatue(r *ghttp.Request) {
form := base.NewForm(r.GetMap())
if form.Params != nil && form.Params["ids"] != "" && form.Params["state"] != "" {
ids := gconv.MapStrStr(form.Params["ids"])
for _, v := range ids {
gameinfo.ModelServer.InsUpdate2(gconv.Int32(v), gconv.String(form.Params["state"]))
}
base.Resp(r, 0, "修改成功", nil)
} else {
base.Resp(r, 1, "操作异常", nil)
}
}
//查询玩家身上的道具
func (action *Action) GetUserItemList(r *ghttp.Request) {
// 读取配置表
itemConfig := codeutil.GetItemConfig()
form := base.NewForm(r.GetMap())
bs := bson.M{}
// 默认查询配置中的服务器
serverId := g.Config().GetString("mongo-port")
var itemId string = ""
if form.Params != nil {
if form.Params["serverid"] != "" {
serverId = gconv.String(form.Params["serverid"])
}
2023-08-15 11:46:55 +08:00
if form.Params["uid"] != "" {
uidStrArray := strings.Split(form.Params["uid"], "#")
2023-03-20 13:38:28 +08:00
uidArray := gconv.Int32s(uidStrArray)
2023-08-15 11:46:55 +08:00
bs = bson.M{"_id": bson.M{"$in": uidArray}}
2023-03-20 13:38:28 +08:00
if form.Params["itemId"] != "" {
itemId = gconv.String(form.Params["itemId"])
}
}
}
2023-08-15 11:46:55 +08:00
projection := bson.M{"itemManager.itemMap": 1, "playerManager.vipLevel": 1}
2023-03-20 13:38:28 +08:00
data := g.ListAnyAny{}
bsCount := len(bs)
if bsCount > 0 {
itemList := gameinfo.ModelM5User.FindUserList(bs, serverId, projection)
for itemList.Next(context.TODO()) {
dayMap := gmap.New()
var userInfo bson.M
err := itemList.Decode(&userInfo)
if err != nil {
//log.Fatal(err)
log.Println(err)
continue
}
iteMap := userInfo["itemManager"].(bson.M)["itemMap"].(bson.M)
vipLevel := userInfo["playerManager"].(bson.M)["vipLevel"]
item := bson.M{}
2023-08-15 11:46:55 +08:00
if itemId != "" {
if iteMap[itemId] != nil {
item = iteMap[itemId].(bson.M)
dayMap.Set("uid", userInfo["_id"])
dayMap.Set("vipLevel", vipLevel)
if len(item) > 0 {
goodsName, _ := itemConfig.Get(gconv.String(item["itemId"]))
dayMap.Set("itemId", item["itemId"])
dayMap.Set("itemNum", item["itemNum"])
dayMap.Set("itemName", goodsName)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
}
} else {
for k := range iteMap {
item = iteMap[k].(bson.M)
dayMap.Set("uid", userInfo["_id"])
dayMap.Set("vipLevel", vipLevel)
if len(item) > 0 {
goodsName, _ := itemConfig.Get(gconv.String(item["itemId"]))
dayMap.Set("itemId", item["itemId"])
dayMap.Set("itemNum", item["itemNum"])
dayMap.Set("itemName", goodsName)
data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
}
}
2023-03-20 13:38:28 +08:00
}
}
}
itemConfig.Close()
base.Succ(r,
g.Map{
"rows": data,
"total": 0,
"current": 0,
})
}