sk_gm_server/library/mongo/gamedao.go

1069 lines
35 KiB
Go
Raw Normal View History

2023-03-20 13:38:28 +08:00
package dao
import (
"context"
"fmt"
"github.com/gogf/gf/container/gmap"
"github.com/gogf/gf/frame/g"
"gmanager/library/base"
"gmanager/library/mongo/util"
"log"
"github.com/gogf/gf/container/garray"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/util/gconv"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// 查询多个
func (m *Mgo) FindAllItemm(form *base.BaseForm) (*mongo.Cursor, int) {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
sid := 0
itemType := ""
if form.Params["operTable"] != "" {
sid = gconv.Int(form.Params["operTable"])
}
filter := bson.D{{"serverid", sid}}
SORT := bson.D{{"_id", 1}} //filter := bson.D{{key,value}}
Limit := gconv.Int64(form.Rows)
Skip := form.Page - 1
SkipNum := gconv.Int64(Skip) * Limit
groupStage := bson.D{{"$group", bson.D{
{"_id", ""},
{"sum", bson.D{{"$sum", "$itemNum"}}},
{"count", bson.D{{"$sum", 1}}},
}}}
matchStage := bson.D{{"$match", bson.D{{"serverid", sid}}}}
if form.Params["logType"] != "" {
itemType = form.Params["logType"]
filter = bson.D{{"serverid", sid}, {"type", itemType}}
matchStage = bson.D{{"$match", bson.D{{"serverid", sid}, {"type", itemType}}}}
}
showInfoCursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{matchStage, groupStage})
var showsWithInfo []bson.M
if err = showInfoCursor.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
if showsWithInfo == nil {
return nil, 0
}
datarow := gconv.Int(showsWithInfo[0]["count"])
datasum := gconv.Int(showsWithInfo[0]["sum"])
form.TotalSize = datarow
form.TotalPage = datarow / form.Rows
fmt.Println(len(showsWithInfo))
findOptions := options.Find().SetSort(SORT).SetLimit(Limit).SetSkip(SkipNum)
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult, datasum
}
func (m *Mgo) FindAllTime(form *base.BaseForm) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//collection.
starttime := form.Params["starttime"]
if starttime == "" {
starttime = gtime.Now().Format("Y-m-d")
} else {
starttime = gtime.New(gconv.Time(starttime)).Format("Y-m-d")
}
fmt.Println("--=-" + starttime)
filter := bson.D{{"checkTimeday", starttime}}
singleResult, _ := collection.Find(context.TODO(), filter)
return singleResult
}
func (m *Mgo) FindDauTime(starttime string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
filter := bson.D{{"logTime", starttime}}
singleResult, _ := collection.Find(context.TODO(), filter)
return singleResult
}
func (m *Mgo) FindDauTimeUser(starttime string, roles interface{}, time string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection + "_" + starttime).Clone()
filter := bson.D{{"userid", bson.M{"$in": roles}}}
singleResult, _ := collection.Find(context.TODO(), filter)
return singleResult
}
func (m *Mgo) FindDauTimeChannel(starttime string, channel string) int {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection + "_" + starttime).Clone()
filter := bson.D{{"channelId", channel}}
values, err := collection.Distinct(context.TODO(), "userid", filter)
if err != nil {
//log.Fatal(err)
log.Println(err)
}
return len(values)
}
func (m *Mgo) FindRegTime() []bson.M {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
dateBson := bson.M{"$dateToString": bson.M{"format": "%Y-%m-%d", "date": bson.M{"$add": bson.A{gconv.Time(28800), "$register.registerTime"}}}}
pipe := []bson.M{
{"$project": bson.M{"date": dateBson, "user_id": "$register.openId"}},
{"$group": bson.M{"_id": bson.M{"date": "$date", "user": "$user_id"}}},
{"$group": bson.M{"_id": "$_id.date", "count": bson.M{"$sum": 1}}},
{"$project": bson.M{"date": "$_id", "count": 1, "_id": 0}},
}
ginfo, err := collection.Aggregate(context.TODO(), pipe)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = ginfo.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
//listMap := gmap.NewListMap(true)
//for _, b := range showsWithInfo {
// listMap.Set(b["count"],b["date"])
//
//}
fmt.Println(showsWithInfo)
return showsWithInfo
}
func (m *Mgo) FindDau() []bson.M {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
dateBson := bson.M{"$dateToString": bson.M{"format": "%Y-%m-%d", "date": bson.M{"$add": bson.A{gconv.Time(28800), "$loginTime.loginTime"}}}}
pipe := []bson.M{
{"$project": bson.M{"date": dateBson, "user_id": "$loginTime.openId"}},
{"$group": bson.M{"_id": bson.M{"date": "$date", "user": "$user_id"}}},
{"$group": bson.M{"_id": "$_id.date", "count": bson.M{"$sum": 1}}},
{"$project": bson.M{"date": "$_id", "count": 1, "_id": 0}},
}
ginfo, err := collection.Aggregate(context.TODO(), pipe)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = ginfo.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
fmt.Println(showsWithInfo)
return showsWithInfo
}
func (m *Mgo) FindNew(startTime int64, endTime int64) *garray.Array {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//filter := bson.D{bson.M{"register.registerTime":bson.D{{"$gte",startTime},{"$lte",endTime}}}, "_id": 1}
filter := bson.D{{"register.registerTime", bson.D{{"$gte", startTime}, {"$lte", endTime}}}}
//oppo:=bson.M{"register.openId": 1}
var findoptions *options.FindOptions
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
for _, b := range showsWithInfo {
s2 := b["register"].(primitive.M)
list.Append(s2["uid"])
}
return list
}
func (m *Mgo) FindNewByServerId(startTime int64, endTime int64, serverId string) *garray.Array {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//filter := bson.D{bson.M{"register.registerTime":bson.D{{"$gte",startTime},{"$lte",endTime}}}, "_id": 1}
filter := bson.D{{"register.serverId", serverId}, {"register.registerTime", bson.D{{"$gte", startTime}, {"$lte", endTime}}}}
//oppo:=bson.M{"register.openId": 1}
var findoptions *options.FindOptions
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
for _, b := range showsWithInfo {
s2 := b["register"].(primitive.M)
list.Append(s2["uid"])
}
return list
}
func (m *Mgo) FindLogin(startTime int64, endTime int64, roles interface{}) int {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//filter := bson.D{bson.M{"register.registerTime":bson.D{{"$gte",startTime},{"$lte",endTime}}}, "_id": 1}
filter := bson.D{
{"loginTime.loginTime", bson.D{{"$gte", startTime}, {"$lte", endTime}}},
{"loginTime.uid", bson.M{"$in": roles}}}
//oppo:=bson.M{"register.openId": 1}
var findoptions *options.FindOptions
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
for _, b := range showsWithInfo {
s2 := b["loginTime"].(primitive.M)
if list.Contains(s2["uid"]) {
continue
}
list.Append(s2["uid"])
}
return list.Len()
}
// 充值过的用户
func (m *Mgo) FindPay(startTime string, endTime string, roles interface{}, serverId string) int {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//filter := bson.D{bson.M{"register.registerTime":bson.D{{"$gte",startTime},{"$lte",endTime}}}, "_id": 1}
filter := bson.D{}
if serverId == "" {
filter = bson.D{
{"creattime", bson.D{{"$gte", startTime}, {"$lte", endTime}}},
{"status", gconv.Int32(1)},
{"handlestatus", gconv.Int32(1)},
{"uid", bson.M{"$in": roles}}}
} else {
filter = bson.D{
{"creattime", bson.D{{"$gte", startTime}, {"$lte", endTime}}},
{"status", gconv.Int32(1)},
{"handlestatus", gconv.Int32(1)},
{"region", gconv.Int32(serverId)},
{"uid", bson.M{"$in": roles}}}
}
//oppo:=bson.M{"register.openId": 1}
var findoptions *options.FindOptions
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
for _, b := range showsWithInfo {
if list.Contains(b["uid"]) {
continue
}
list.Append(b["uid"])
}
return list.Len()
}
func (m *Mgo) FindLogin1(startTime int64, endTime int64, roles interface{}, serverId string) int {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//filter := bson.D{bson.M{"register.registerTime":bson.D{{"$gte",startTime},{"$lte",endTime}}}, "_id": 1}
filter := bson.D{
{"loginTime.loginTime", bson.D{{"$gte", startTime}, {"$lte", endTime}}},
{"loginTime.serverId", serverId},
{"loginTime.uid", bson.M{"$in": roles}}}
//oppo:=bson.M{"register.openId": 1}
var findoptions *options.FindOptions
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
for _, b := range showsWithInfo {
s2 := b["loginTime"].(primitive.M)
if list.Contains(s2["uid"]) {
continue
}
list.Append(s2["uid"])
}
return list.Len()
}
func (m *Mgo) FindLogin2(startTime int64, endTime int64) int {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//filter := bson.D{bson.M{"register.registerTime":bson.D{{"$gte",startTime},{"$lte",endTime}}}, "_id": 1}
filter := bson.D{
{"loginTime.loginTime", bson.D{{"$gte", startTime}, {"$lte", endTime}}}}
//oppo:=bson.M{"register.openId": 1}
var findoptions *options.FindOptions
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
for _, b := range showsWithInfo {
s2 := b["loginTime"].(primitive.M)
if list.Contains(s2["uid"]) {
continue
}
list.Append(s2["uid"])
}
return list.Len()
}
//查询各服务器的注册人数
func (m *Mgo) FindRegisterByServer(startTime int64, endTime int64) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
groupStage := bson.D{{"$group", bson.D{
{"_id", "$register.serverId"},
{"count", bson.D{{"$sum", 1}}},
}}}
matchStage := bson.D{{"$match", bson.D{{"register.registerTime", bson.D{{"$gte", startTime}, {"$lte", endTime}}}}}}
showInfoCursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{matchStage, groupStage})
if err != nil {
fmt.Println(err)
}
return showInfoCursor
}
//查询各服务器的登录人数
func (m *Mgo) FindLoginByServer(startTime int64, endTime int64) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
pipe := []bson.M{
{"$match": bson.M{"loginTime.loginTime": bson.M{"$gte": startTime, "$lte": endTime}}},
{"$group": bson.M{"_id": bson.M{"serverId": "$loginTime.serverId", "uid": "$loginTime.uid"}, "count": bson.M{"$sum": 1}}},
{"$project": bson.M{"serverId": "$_id.serverId", "uid": "$_id.uid", "count": 1}},
}
showInfoCursor, err := collection.Aggregate(context.TODO(), pipe)
if err != nil {
fmt.Println(err)
}
return showInfoCursor
}
func (m *Mgo) FindLiuCun(filter bson.D, serverId string) *mongo.Cursor {
client := DB.Mongo
if serverId == "" {
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
//oppo:=bson.M{"register.openId": 1}
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return singleResult
} else {
collection, _ := client.Database(m.database).Collection(m.collection + "_" + serverId).Clone()
//oppo:=bson.M{"register.openId": 1}
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return singleResult
}
}
func (m *Mgo) FindHour(filter bson.D, page util.Page) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
SORT := bson.D{{"_id", -1}} //1:升序; -1:降序
findOptions := options.Find().SetSort(SORT).SetLimit(page.PageSize).SetSkip(gconv.Int64(page.PageSize * (page.CurrentPage - 1)))
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult
}
func (m *Mgo) GetDataByTimeDesc(filter bson.D, page util.Page) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
SORT := bson.D{{"creatday", -1}} //1:升序; -1:降序
findOptions := options.Find().SetSort(SORT).SetLimit(page.PageSize).SetSkip(gconv.Int64(page.PageSize * (page.CurrentPage - 1)))
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult
}
func (m *Mgo) GetDataByServerTimeDesc(filter bson.D, page util.Page, serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection + "_" + serverId).Clone()
SORT := bson.D{{"creatday", -1}} //1:升序; -1:降序
findOptions := options.Find().SetSort(SORT).SetLimit(page.PageSize).SetSkip(gconv.Int64(page.PageSize * (page.CurrentPage - 1)))
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult
}
func (m *Mgo) GetDataByServerTimeDesc2(filter bson.D, page util.Page, serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database + serverId).Collection(m.collection).Clone()
SORT := bson.D{{"time", -1}} //1:升序; -1:降序
findOptions := options.Find().SetSort(SORT).SetLimit(page.PageSize).SetSkip(gconv.Int64(page.PageSize * (page.CurrentPage - 1)))
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult
}
func (m *Mgo) FindHourByServer(filter bson.D, page util.Page, serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection + "_" + serverId).Clone()
SORT := bson.D{{"_id", -1}} //1:升序; -1:降序
findOptions := options.Find().SetSort(SORT).SetLimit(page.PageSize).SetSkip(gconv.Int64(page.PageSize * (page.CurrentPage - 1)))
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult
}
func (m *Mgo) FindListByServer(filter bson.D, serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection + "_" + serverId).Clone()
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return singleResult
}
func (m *Mgo) FindUser(filter bson.D, serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database + serverId).Collection(m.collection).Clone()
//oppo:=bson.M{"register.openId": 1}
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return singleResult
}
func (m *Mgo) FindLV(serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database + serverId).Collection(m.collection).Clone()
pipe := []bson.M{
{"$group": bson.M{"_id": "$playerManager.level", "value": bson.M{"$sum": 1}}},
{"$sort": bson.M{"_id": 1}},
}
showInfoCursor, err := collection.Aggregate(context.TODO(), pipe)
if err != nil {
fmt.Println(err)
}
return showInfoCursor
}
func (m *Mgo) FindVIP(serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database + serverId).Collection(m.collection).Clone()
pipe := []bson.M{
{"$group": bson.M{"_id": "$playerManager.vipLevel", "value": bson.M{"$sum": 1}}},
{"$sort": bson.M{"_id": 1}},
}
showInfoCursor, err := collection.Aggregate(context.TODO(), pipe)
if err != nil {
fmt.Println(err)
}
return showInfoCursor
}
2023-08-15 11:46:55 +08:00
func (m *Mgo) FindServerInfoList(filter interface{}) *mongo.Cursor {
2023-03-20 13:38:28 +08:00
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return singleResult
}
// 新增服务器信息
func (m *Mgo) AddServer(value interface{}) *mongo.InsertOneResult {
client := DB.Mongo
collection := client.Database(m.database).Collection(m.collection)
insertResult, err := collection.InsertOne(context.TODO(), value)
if err != nil {
fmt.Println(err)
}
return insertResult
}
// 更新服务器信息
func (m *Mgo) UpdateServer(id int, value interface{}) *mongo.UpdateResult {
serverInfo := gconv.Map(value)
client := DB.Mongo
collection := client.Database(m.database).Collection(m.collection)
filter := bson.D{{"_id", id}}
update := bson.D{{"$set", bson.D{
{"name", gconv.String(serverInfo["Name"])},
{"ip", gconv.String(serverInfo["Ip"])},
{"port", gconv.String(serverInfo["Port"])},
{"plat", gconv.String(serverInfo["Plat"])},
{"state", gconv.String(serverInfo["State"])},
{"open_time", gconv.String(serverInfo["OpenTime"])},
{"open_type", gconv.String(serverInfo["OpenType"])},
{"is_banreg", gconv.String(serverInfo["IsBanreg"])},
{"is_new", gconv.String(serverInfo["IsNew"])},
{"server_version", gconv.String(serverInfo["ServerVersion"])},
{"gm_ip", gconv.String(serverInfo["GMIp"])},
{"gm_port", gconv.String(serverInfo["GMPort"])},
{"isWhite", gconv.String(serverInfo["IsWhite"])},
{"currency", gconv.String(serverInfo["Currency"])},
{"time_zone", gconv.String(serverInfo["Timezone"])},
{"exportdata", gconv.String(serverInfo["Exportdata"])},
}}}
updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
fmt.Println(updateResult)
if err != nil {
fmt.Println(err)
}
return updateResult
}
func (m *Mgo) DelServer(filter bson.D) *mongo.DeleteResult {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
deleteResult, err := collection.DeleteOne(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return deleteResult
}
//白名单列表
func (m *Mgo) FindWhiteList(filter bson.D, page util.Page) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
SORT := bson.D{{"_id", -1}} //1:升序; -1:降序
findOptions := options.Find().SetSort(SORT).SetLimit(page.PageSize).SetSkip(gconv.Int64(page.PageSize * (page.CurrentPage - 1)))
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult
}
//黑名单列表
func (m *Mgo) FindBlackList(filter bson.D, page util.Page) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
SORT := bson.D{{"_id", -1}} //1:升序; -1:降序
findOptions := options.Find().SetSort(SORT).SetLimit(page.PageSize).SetSkip(gconv.Int64(page.PageSize * (page.CurrentPage - 1)))
singleResult, err := collection.Find(context.TODO(), filter, findOptions)
if err != nil {
fmt.Println(err)
}
return singleResult
}
//新增、更新单个
func (m *Mgo) AddWhiteList(id int, value interface{}) *mongo.UpdateResult {
client := DB.Mongo
collection := client.Database(m.database).Collection(m.collection)
filter := bson.D{{"_id", id}}
update := bson.D{{"$set", value}}
fmt.Println(value)
options1 := options.Update().SetUpsert(true)
updateResult, err := collection.UpdateOne(context.TODO(), filter, update, options1)
fmt.Println(updateResult)
if err != nil {
fmt.Println(err)
}
return updateResult
}
//新增、更新单个
func (m *Mgo) AddBlackList(id string, openid string, value interface{}) int {
res := 1
client := DB.Mongo
collection := client.Database(m.database).Collection(m.collection)
//如果id为空 添加
if id == "" {
insertResult, err := collection.InsertOne(context.TODO(), value)
fmt.Println(insertResult)
if err != nil {
res = 0
fmt.Println(err)
}
} else {
obj_id, _ := primitive.ObjectIDFromHex(id)
filter := bson.D{{"_id", obj_id}}
update := bson.D{{"$set", value}}
//options1 := options.Update().SetUpsert(true)
updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
fmt.Println(updateResult)
if err != nil {
res = 0
fmt.Println(err)
}
}
return res
}
func (m *Mgo) DelWhiteList(filter bson.D) *mongo.DeleteResult {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
deleteResult, err := collection.DeleteOne(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return deleteResult
}
func (m *Mgo) DelBlackList(filter bson.D) *mongo.DeleteResult {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
deleteResult, err := collection.DeleteOne(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return deleteResult
}
//公告
func (m *Mgo) FindNoticeInfo(filter bson.D) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return singleResult
}
//新增、更新单个
func (m *Mgo) AddNoticeInfo(id string, value interface{}) *mongo.UpdateResult {
client := DB.Mongo
collection := client.Database(m.database).Collection(m.collection)
filter := bson.D{{"_id", id}}
update := bson.D{{"$set", value}}
fmt.Println(value)
options1 := options.Update().SetUpsert(true)
updateResult, err := collection.UpdateOne(context.TODO(), filter, update, options1)
fmt.Println(updateResult)
if err != nil {
fmt.Println(err)
}
return updateResult
}
func (m *Mgo) DelNoticeInfo(filter bson.D) *mongo.DeleteResult {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
deleteResult, err := collection.DeleteOne(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return deleteResult
}
func (m *Mgo) FindRechargeInfo(filter bson.D, serverId string) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database + serverId).Collection(m.collection).Clone()
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println("err==================", err)
}
return singleResult
}
//查询一天的注册/登录人数 例creatDay = "2021-06-08"
func (m *Mgo) GetOneDayRegister(creatDay string) int {
client := DB.Mongo
sum := 0
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
matchStage := bson.D{{"$match", bson.D{{"creatday", creatDay}}}}
groupStage := bson.D{{"$group", bson.D{
{"_id", "$creatday"},
{"sum", bson.D{{"$sum", "$newuser"}}},
}}}
singleResult, err := collection.Aggregate(context.TODO(), mongo.Pipeline{matchStage, groupStage})
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
for _, b := range showsWithInfo {
sum = sum + gconv.Int(b["sum"])
}
return sum
}
func (m *Mgo) GetOneDayRegisterByServer(creatDay string, serverId string) int {
client := DB.Mongo
sum := 0
collection, _ := client.Database(m.database).Collection(m.collection + "_" + serverId).Clone()
matchStage := bson.D{{"$match", bson.D{{"creatday", creatDay}}}}
groupStage := bson.D{{"$group", bson.D{
{"_id", "$creatday"},
{"sum", bson.D{{"$sum", "$newuser"}}},
}}}
singleResult, err := collection.Aggregate(context.TODO(), mongo.Pipeline{matchStage, groupStage})
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
for _, b := range showsWithInfo {
sum = sum + gconv.Int(b["sum"])
}
return sum
}
//查询注册账号数
func (m *Mgo) GetOneDayRegisterAccount(creatDay string, serverId string) int {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
startTime := gtime.NewFromStr(creatDay)
//时间范围
daystartTime := startTime.Local().TimestampMilli()
dayendTime := startTime.Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
//注册时间条件
pipe := []bson.M{}
if serverId == "" {
pipe = []bson.M{
{"$match": bson.M{"register.registerTime": bson.M{"$gte": daystartTime, "$lte": dayendTime}}},
{"$group": bson.M{"_id": bson.M{"openId": "$register.openId"}, "count": bson.M{"$sum": 1}}},
{"$project": bson.M{"openId": "$_id.openId", "count": 1}},
}
} else {
pipe = []bson.M{
{"$match": bson.M{"register.serverId": serverId, "register.registerTime": bson.M{"$gte": daystartTime, "$lte": dayendTime}}},
{"$group": bson.M{"_id": bson.M{"openId": "$register.openId"}, "count": bson.M{"$sum": 1}}},
{"$project": bson.M{"openId": "$_id.openId", "count": 1}},
}
}
showInfoCursor, err := collection.Aggregate(context.TODO(), pipe)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = showInfoCursor.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
return len(showsWithInfo)
}
func (m *Mgo) GetLoginNum(filter bson.D) int {
sum := 0
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
for _, b := range showsWithInfo {
sum = sum + gconv.Int(b["newuser"])
}
return sum
}
//获得当天老用户登录数(当天登录人数-当天注册人数)
func (m *Mgo) GetOldUserLoginNum(creatDay string) int {
client := DB.Mongo
startTime := gtime.NewFromStr(creatDay)
//时间范围
daystartTime := startTime.Local().TimestampMilli()
dayendTime := startTime.Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
//注册时间条件
filter := bson.D{{"register.registerTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}}}
var findoptions *options.FindOptions
collection, _ := client.Database(g.Config().GetString("db.core")).Collection("logRegister").Clone()
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
//遍历加入注册用户集合
for _, b := range showsWithInfo {
s2 := b["register"].(primitive.M)
list.Append(s2["uid"])
}
//fmt.Println("注册=======================", list)
usersList := gconv.SliceAny(list)
collection1, _ := client.Database(g.Config().GetString("db.core")).Collection("logLogin").Clone()
//查询登录用户条件
filter1 := bson.D{
{"loginTime.loginTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}},
{"loginTime.uid", bson.M{"$nin": gconv.Ints(usersList)}}}
var findoptions1 *options.FindOptions
singleResult1, err := collection1.Find(context.TODO(), filter1, findoptions1)
if err != nil {
fmt.Println(err)
}
var showsWithInfo1 []bson.M
if err = singleResult1.All(context.TODO(), &showsWithInfo1); err != nil {
fmt.Println(err)
}
list1 := garray.New(false)
for _, b := range showsWithInfo1 {
s2 := b["loginTime"].(primitive.M)
if list1.Contains(s2["uid"]) {
continue
}
list1.Append(s2["uid"])
}
//fmt.Println("登录=======================",list1)
return list1.Len()
}
func (m *Mgo) GetOldUserLoginNumByServer(creatDay string, serverId string) int {
client := DB.Mongo
startTime := gtime.NewFromStr(creatDay)
//时间范围
daystartTime := startTime.Local().TimestampMilli()
dayendTime := startTime.Clone().AddDate(0, 0, 1).Local().TimestampMilli() - 1
//注册时间条件
filter := bson.D{
{"register.serverId", serverId},
{"register.registerTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}},
}
var findoptions *options.FindOptions
collection, _ := client.Database(g.Config().GetString("db.core")).Collection("logRegister").Clone()
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
list := garray.New(false)
//遍历加入注册用户集合
for _, b := range showsWithInfo {
s2 := b["register"].(primitive.M)
list.Append(s2["uid"])
}
//fmt.Println("注册=======================", list)
usersList := gconv.SliceAny(list)
collection1, _ := client.Database(g.Config().GetString("db.core")).Collection("logLogin").Clone()
//查询登录用户条件
filter1 := bson.D{
{"loginTime.serverId", serverId},
{"loginTime.loginTime", bson.D{{"$gte", daystartTime}, {"$lte", dayendTime}}},
{"loginTime.uid", bson.M{"$nin": gconv.Ints(usersList)}}}
var findoptions1 *options.FindOptions
singleResult1, err := collection1.Find(context.TODO(), filter1, findoptions1)
if err != nil {
fmt.Println(err)
}
var showsWithInfo1 []bson.M
if err = singleResult1.All(context.TODO(), &showsWithInfo1); err != nil {
fmt.Println(err)
}
list1 := garray.New(false)
for _, b := range showsWithInfo1 {
s2 := b["loginTime"].(primitive.M)
if list1.Contains(s2["uid"]) {
continue
}
list1.Append(s2["uid"])
}
//fmt.Println("登录=======================",list1)
return list1.Len()
}
func (m *Mgo) GetPayInfoTask(filter bson.D) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
singleResult, err := collection.Find(context.TODO(), filter)
if err != nil {
fmt.Println(err)
}
return singleResult
}
//插入单个
func (m *Mgo) InsertOneByServer(value interface{}, serverId string) *mongo.InsertOneResult {
client := DB.Mongo
collection := client.Database(m.database).Collection(m.collection + "_" + serverId)
insertResult, err := collection.InsertOne(context.TODO(), value)
if err != nil {
fmt.Println(err)
}
return insertResult
}
// 添加修改 统计充值汇总
func (m *Mgo) InsertAndUpdateStatisticalRecharge(id primitive.ObjectID, value interface{}, serverId string) *mongo.UpdateResult {
statisticalRecharge := gconv.Map(value)
client := DB.Mongo
filter := bson.D{{"_id", id}}
update := bson.D{{"$set", bson.D{
{"creatday", gconv.String(statisticalRecharge["creatday"])},
{"new_recharge_num", gconv.Int32(statisticalRecharge["newrechargenum"])},
{"new_recharge_amount", gconv.Float64(statisticalRecharge["newrechargeamount"])},
{"new_recharge_count", gconv.Int32(statisticalRecharge["newrechargecount"])},
{"recharge_num", gconv.Int32(statisticalRecharge["rechargenum"])},
{"recharge_amount", gconv.Float64(statisticalRecharge["rechargeamount"])},
{"recharge_count", gconv.Int32(statisticalRecharge["rechargecount"])},
}}}
options := options.Update().SetUpsert(true)
if serverId == "" {
collection := client.Database(m.database).Collection(m.collection)
updateResult, err := collection.UpdateOne(context.TODO(), filter, update, options)
if err != nil {
fmt.Println(err)
}
return updateResult
} else {
collection := client.Database(m.database).Collection(m.collection + "_" + serverId)
updateResult, err := collection.UpdateOne(context.TODO(), filter, update, options)
if err != nil {
fmt.Println(err)
}
return updateResult
}
}
// pay表 取符合条件的服务器id
func (m *Mgo) GetPayServerId(filter bson.D) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
pipe := []bson.M{
{"$match": filter},
{"$group": bson.M{"_id": bson.M{"region": "$region"}}},
{"$project": bson.M{"region": "$_id.region"}},
}
showInfoCursor, err := collection.Aggregate(context.TODO(), pipe)
if err != nil {
fmt.Println(err)
}
return showInfoCursor
}
//查询当日新增玩家累计付费信息
func (m *Mgo) GetTodayNewCumulativeRecharge(todayUsers []interface{}, creatDay string, serverid string) interface{} {
amount, count, num := 0, 0, 0
resMap := gmap.New()
userList := garray.New(false)
todayBs := bson.D{}
if serverid == "" {
todayBs = bson.D{
{"uid", bson.M{"$in": gconv.Ints(todayUsers)}},
{"status", gconv.Int32(1)},
{"handlestatus", gconv.Int32(1)},
{"creattime", bson.D{{"$lte", creatDay + " 23:59:59"}}}}
} else {
todayBs = bson.D{
{"uid", bson.M{"$in": gconv.Ints(todayUsers)}},
{"status", gconv.Int32(1)},
{"handlestatus", gconv.Int32(1)},
{"region", gconv.Int32(serverid)},
{"creattime", bson.D{{"$lte", creatDay + " 23:59:59"}}}}
}
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
singleResult, err := collection.Find(context.TODO(), todayBs)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
for _, v := range showsWithInfo {
if !userList.Contains(v["uid"]) {
num = num + 1
}
userList.Append(v["uid"])
count = count + 1
amount = amount + gconv.Int(v["money"])
}
resMap.Set("amount", amount)
resMap.Set("count", count)
resMap.Set("num", num)
return resMap
}
func (m *Mgo) GetLtvStatistical(startTime string, endTime string, roles interface{}, serverId string) int64 {
var res int64
res = 0
client := DB.Mongo
collection, _ := client.Database(m.database).Collection(m.collection).Clone()
filter := bson.D{}
2023-08-15 11:46:55 +08:00
if serverId == "" {
2023-03-20 13:38:28 +08:00
filter = bson.D{
{"creattime", bson.D{{"$gte", startTime}, {"$lte", endTime}}},
{"uid", bson.M{"$in": roles}},
{"status", gconv.Int32(1)},
{"handlestatus", gconv.Int32(1)},
}
} else {
filter = bson.D{
{"creattime", bson.D{{"$gte", startTime}, {"$lte", endTime}}},
{"uid", bson.M{"$in": roles}},
{"region", gconv.Int32(serverId)},
{"status", gconv.Int32(1)},
{"handlestatus", gconv.Int32(1)},
}
}
var findoptions *options.FindOptions
singleResult, err := collection.Find(context.TODO(), filter, findoptions)
if err != nil {
fmt.Println(err)
}
var showsWithInfo []bson.M
if err = singleResult.All(context.TODO(), &showsWithInfo); err != nil {
fmt.Println(err)
}
for _, b := range showsWithInfo {
res = res + (gconv.Int64(b["money"]))
}
return res
}
func (m *Mgo) FindUserList(filter bson.M, serverId string, projection bson.M) *mongo.Cursor {
client := DB.Mongo
collection, _ := client.Database(m.database + serverId).Collection(m.collection).Clone()
//oppo:=bson.M{"register.openId": 1}
options := options.Find().SetProjection(projection)
2023-08-15 11:46:55 +08:00
singleResult, err := collection.Find(context.TODO(), filter, options)
2023-03-20 13:38:28 +08:00
if err != nil {
fmt.Println(err)
}
return singleResult
}