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()
	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)
	}
}

//获取在线人数
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["itemId"] != "" && 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(iteMap[itemId] != nil) {
				item = iteMap[itemId].(bson.M)
			}
			dayMap.Set("uid",userInfo["_id"])
			dayMap.Set("vipLevel",vipLevel)
			if(len(item) > 0) {
				dayMap.Set("itemId",item["itemId"])
				dayMap.Set("itemNum",item["itemNum"])
				data = append(g.ListAnyAny{gconv.Map(dayMap)}, data...)
			}

		}
	}
	itemConfig.Close()
	base.Succ(r,
		g.Map{
			"rows":    data,
			"total":   0,
			"current": 0,
		})
}