generated from root/miduo_server
2242 lines
70 KiB
Go
2242 lines
70 KiB
Go
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
|
||
}
|
||
|
||
type MailParam struct {
|
||
Id int `json:"uid"` // 主键
|
||
Content string `json:"content"` // 内容
|
||
Title string `json:"title"` // 标题
|
||
Param string `json:"param"` // 参数
|
||
}
|
||
|
||
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) PlayerRegisterInfo(r *ghttp.Request) {
|
||
form := base.NewForm(r.GetQueryMap())
|
||
page := g.ListAnyAny{}
|
||
//f:=&form
|
||
openid := r.Form.Get("openid")
|
||
id := r.Form.Get("id")
|
||
if openid == "" && id == "" {
|
||
base.Succ(r,
|
||
g.Map{
|
||
"page": form.Page,
|
||
"rows": page,
|
||
"total": form.TotalPage,
|
||
"records": form.TotalSize,
|
||
})
|
||
return
|
||
}
|
||
var result *mongo.SingleResult
|
||
if openid != "" {
|
||
result = gameinfo.ModelUserRegisterInfo.FindOne("openId", openid)
|
||
} else {
|
||
result = gameinfo.ModelUserRegisterInfo.FindOne("_id", id)
|
||
}
|
||
var userRegisterInfo gameinfo.UserRegisterInfo
|
||
err := result.Decode(&userRegisterInfo)
|
||
if err != nil {
|
||
base.Fail(r, "查询失败")
|
||
return
|
||
}
|
||
dmap := gmap.NewStrAnyMap()
|
||
dmap.Set("id", userRegisterInfo.Id)
|
||
dmap.Set("openId", userRegisterInfo.OpenId)
|
||
page = append(page, gconv.Map(dmap))
|
||
fmt.Println(len(page))
|
||
|
||
base.Succ(r,
|
||
g.Map{
|
||
"rows": page,
|
||
})
|
||
|
||
}
|
||
|
||
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("changeTime", serverInfo.ChangeTime)
|
||
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")
|
||
changeTimeStr := r.Form.Get("changeTime")
|
||
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
|
||
if changeTimeStr != "" {
|
||
serverInfo.ChangeTime = gconv.Int64(changeTimeStr)
|
||
}
|
||
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("changeTime", serverInfo.ChangeTime)
|
||
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()
|
||
//bs := bson.D{{"$where", "this.server_id == this.real_server_id"}}
|
||
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) {
|
||
var timeLayoutStr = "2006-01-02 15:04:05"
|
||
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)
|
||
if blackList.UnblockTime > 0 {
|
||
dayMap.Set("unblockTime", time.Unix(blackList.UnblockTime, 0).Format(timeLayoutStr))
|
||
} else {
|
||
dayMap.Set("unblockTime", "永久封禁")
|
||
}
|
||
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")
|
||
blockTime := gconv.Int64(r.Form.Get("time"))
|
||
obj_id := primitive.NewObjectID()
|
||
if id != "" {
|
||
obj_id, _ = primitive.ObjectIDFromHex(id)
|
||
}
|
||
blackList := new(gameinfo.BlackList)
|
||
blackList.Id = obj_id
|
||
blackList.OpenId = openid
|
||
if blockTime > 0 {
|
||
blackList.UnblockTime = time.Now().Unix() + blockTime*60
|
||
} else {
|
||
blackList.UnblockTime = -1
|
||
}
|
||
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) SaveSingleBlackList(r *ghttp.Request) {
|
||
id := r.Form.Get("id")
|
||
uid := r.Form.Get("uid")
|
||
serverId := r.Form.Get("serverId")
|
||
blockTime := gconv.Int64(r.Form.Get("time"))
|
||
|
||
obj_id := primitive.NewObjectID()
|
||
if id != "" {
|
||
obj_id, _ = primitive.ObjectIDFromHex(id)
|
||
}
|
||
blackList := new(gameinfo.SingleBlackList)
|
||
blackList.Id = obj_id
|
||
blackList.Uid = uid
|
||
blackList.ServerId = serverId
|
||
blackList.CreateTime = time.Now().Unix()
|
||
if blockTime > 0 {
|
||
blackList.UnblockTime = time.Now().Unix() + blockTime*60
|
||
} else {
|
||
blackList.UnblockTime = -1
|
||
}
|
||
ages := uid + " " + strconv.FormatInt(blackList.UnblockTime, 10)
|
||
cmdStr := "addblack"
|
||
singleResult := gameinfo.ModelServer.FindOne("server_id", serverId)
|
||
var serverInfo gameinfo.ServerInfo
|
||
err := singleResult.Decode(&serverInfo)
|
||
gmip := serverInfo.GMIp
|
||
gmport := serverInfo.GMPort
|
||
if err != nil {
|
||
base.Fail(r, "查询服务器信息出现异常,"+serverId)
|
||
}
|
||
blackList.ServerName = serverInfo.Name
|
||
|
||
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)
|
||
} else if res != 0 {
|
||
base.Resp(r, 1, "操作失败", nil)
|
||
}
|
||
res1 := gameinfo.ModelSingleBlackList.AddBlackList(id, "", blackList)
|
||
if res1 > 0 {
|
||
base.Succ(r, g.Map{"code": 0, "result": "操作成功"})
|
||
} else {
|
||
base.Succ(r, g.Map{"code": 1, "result": "操作失败"})
|
||
}
|
||
}
|
||
|
||
//黑名单列表
|
||
func (action *Action) SingleBlackList(r *ghttp.Request) {
|
||
var timeLayoutStr = "2006-01-02 15:04:05"
|
||
form := base.NewForm(r.GetMap())
|
||
bs := bson.D{}
|
||
if form.Params != nil {
|
||
if form.Params["uid"] != "" {
|
||
bs1 := bson.E{"uid", form.Params["uid"]}
|
||
bs = append(bs, bs1)
|
||
}
|
||
if form.Params["serverId"] != "" {
|
||
bs1 := bson.E{"serverId", form.Params["serverId"]}
|
||
bs = append(bs, bs1)
|
||
}
|
||
}
|
||
data := g.ListAnyAny{}
|
||
count := gameinfo.ModelSingleBlackList.GetListCount(bs)
|
||
page := util.Page{
|
||
PageSize: gconv.Int64(form.Rows),
|
||
CurrentPage: gconv.Int64(form.Page),
|
||
Total: gconv.Int64(count),
|
||
}
|
||
blackListData := gameinfo.ModelSingleBlackList.FindBlackList(bs, page)
|
||
dayMap := gmap.New()
|
||
for blackListData.Next(context.TODO()) {
|
||
var blackList gameinfo.SingleBlackList
|
||
err := blackListData.Decode(&blackList)
|
||
if err != nil {
|
||
//log.Fatal(err)
|
||
log.Println(err)
|
||
continue
|
||
}
|
||
dayMap.Set("id", blackList.Id)
|
||
dayMap.Set("uid", blackList.Uid)
|
||
dayMap.Set("serverName", blackList.ServerName)
|
||
dayMap.Set("createTime", time.Unix(blackList.CreateTime, 0).Format(timeLayoutStr))
|
||
if blackList.UnblockTime > 0 {
|
||
dayMap.Set("unblockTime", time.Unix(blackList.UnblockTime, 0).Format(timeLayoutStr))
|
||
} else {
|
||
dayMap.Set("unblockTime", "永久封禁")
|
||
}
|
||
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) DelSingleBlackList(r *ghttp.Request) {
|
||
id := r.GetString("id")
|
||
obj_id, _ := primitive.ObjectIDFromHex(id)
|
||
bs := bson.D{{"_id", obj_id}}
|
||
result := gameinfo.ModelSingleBlackList.FindOne("_id", obj_id)
|
||
var blackList gameinfo.SingleBlackList
|
||
err := result.Decode(&blackList)
|
||
if err != nil {
|
||
base.Fail(r, "删除失败")
|
||
return
|
||
}
|
||
ages := blackList.Uid + " " + "1"
|
||
cmdStr := "addblack"
|
||
singleResult := gameinfo.ModelServer.FindOne("server_id", blackList.ServerId)
|
||
var serverInfo gameinfo.ServerInfo
|
||
err = singleResult.Decode(&serverInfo)
|
||
gmip := serverInfo.GMIp
|
||
gmport := serverInfo.GMPort
|
||
if err != nil {
|
||
base.Fail(r, "查询服务器信息出现异常,"+blackList.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)
|
||
} else if res != 0 {
|
||
base.Resp(r, 1, "操作失败", nil)
|
||
}
|
||
deleteResult := gameinfo.ModelSingleBlackList.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(¬iceInfo)
|
||
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(¬iceInfo)
|
||
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)
|
||
}
|
||
}
|
||
|
||
//发送跑马灯
|
||
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,
|
||
})
|
||
}
|
||
|
||
//获取在线人数
|
||
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"])
|
||
}
|
||
if form.Params["uid"] != "" {
|
||
uidStrArray := strings.Split(form.Params["uid"], "#")
|
||
uidArray := gconv.Int32s(uidStrArray)
|
||
bs = bson.M{"_id": bson.M{"$in": uidArray}}
|
||
if form.Params["itemId"] != "" {
|
||
itemId = gconv.String(form.Params["itemId"])
|
||
}
|
||
}
|
||
}
|
||
projection := bson.M{"itemManager.itemMap": 1, "playerManager.vipLevel": 1}
|
||
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{}
|
||
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...)
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
itemConfig.Close()
|
||
base.Succ(r,
|
||
g.Map{
|
||
"rows": data,
|
||
"total": 0,
|
||
"current": 0,
|
||
})
|
||
}
|
||
|
||
//查询充值排行榜
|
||
func (action *Action) GetRechargeRank(r *ghttp.Request) {
|
||
var timeLayoutStr = "2006-01-02 15:04:05"
|
||
form := base.NewForm(r.GetMap())
|
||
startTimeStr := form.Params["startTime"]
|
||
endTimeStr := form.Params["endTime"]
|
||
serverId := gconv.Int(form.Params["serverid"])
|
||
if startTimeStr == "" || endTimeStr == "" {
|
||
base.Fail(r, "请选择查询的时间范围")
|
||
}
|
||
startTime, err := time.Parse(timeLayoutStr, startTimeStr)
|
||
if err != nil {
|
||
base.Fail(r, "时间格式有误")
|
||
}
|
||
endTime, err := time.Parse(timeLayoutStr, endTimeStr)
|
||
if err != nil {
|
||
base.Fail(r, "时间格式有误")
|
||
}
|
||
duration := endTime.Sub(startTime)
|
||
if duration.Milliseconds() > 1000*3600*24*92 {
|
||
base.Fail(r, "时间范围不可超过三个月")
|
||
}
|
||
bs := bson.A{}
|
||
if serverId != 0 {
|
||
serverMatch := bson.D{{
|
||
"$match", bson.D{{
|
||
"region", serverId,
|
||
}},
|
||
}}
|
||
bs = append(bs, serverMatch)
|
||
}
|
||
statusMatch := bson.D{{
|
||
"$match", bson.D{{
|
||
"status", 1,
|
||
}},
|
||
}}
|
||
bs = append(bs, statusMatch)
|
||
match := bson.D{{
|
||
"$match", bson.D{{
|
||
"creattime", bson.D{{"$gte", startTimeStr}, {"$lte", endTimeStr}},
|
||
}},
|
||
}}
|
||
group := bson.D{{
|
||
"$group", bson.D{
|
||
{"_id", "$openid"},
|
||
{"totalMoney", bson.D{{"$sum", "$money"}}},
|
||
},
|
||
}}
|
||
sort := bson.D{{
|
||
"$sort", bson.D{
|
||
{"totalMoney", -1},
|
||
},
|
||
}}
|
||
limit := bson.D{{
|
||
"$limit", 50,
|
||
}}
|
||
bs = append(bs, match, group, sort, limit)
|
||
allBson := gameinfo.ModelRechargeTotal.FindPipeline(bs)
|
||
data := g.ListAnyAny{}
|
||
for allBson.Next(context.TODO()) {
|
||
var rechargeTotal gameinfo.RechargeTotal
|
||
err := allBson.Decode(&rechargeTotal)
|
||
if err != nil {
|
||
fmt.Printf("%s", err)
|
||
continue
|
||
}
|
||
dataMap := gmap.New()
|
||
dataMap.Set("openId", rechargeTotal.OpenId)
|
||
dataMap.Set("totalMoney", rechargeTotal.TotalMoney)
|
||
var registerInfo gameinfo.UserRegisterInfo
|
||
result := gameinfo.ModelUserRegisterInfo.FindOne("openId", rechargeTotal.OpenId)
|
||
err = result.Decode(®isterInfo)
|
||
if err != nil {
|
||
fmt.Printf("%s", err)
|
||
data = append(data, gconv.Map(dataMap))
|
||
continue
|
||
}
|
||
dataMap.Set("id", registerInfo.Id)
|
||
if serverId != 0 {
|
||
var userInfo gameinfo.UserInfo
|
||
result1 := gameinfo.ModelUserInfo.FindOneByBson(bson.D{{"serverId", gconv.String(serverId)}, {"openId", rechargeTotal.OpenId}})
|
||
err = result1.Decode(&userInfo)
|
||
if err != nil {
|
||
fmt.Printf("%s", err)
|
||
data = append(data, gconv.Map(dataMap))
|
||
continue
|
||
}
|
||
dataMap.Set("uid", userInfo.Uid)
|
||
}
|
||
data = append(data, gconv.Map(dataMap))
|
||
}
|
||
base.Succ(r,
|
||
g.Map{
|
||
"rows": data,
|
||
"total": 0,
|
||
"current": 0,
|
||
})
|
||
}
|