You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

225 lines
7.3 KiB

package internal
import (
"context"
"errors"
"fmt"
"github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gtime"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"log"
"strconv"
"tyj_admin/api/v1/game"
"tyj_admin/internal/consts"
)
func GetRankAward(ctx context.Context, id int32, aType int32) (all []map[string]interface{}, err error) {
filter := bson.M{"_t": "RankAward"}
if id != 0 {
filter["_id"] = id
}
if aType != 0 {
filter["Type"] = aType
}
err = MongoDatabaseList["0"].Collection("RankAward").Find(ctx, filter).All(&all)
for _, v := range all {
v["StringId"] = fmt.Sprint(v["_id"])
}
if err != nil {
return
}
return all, err
}
func UpdateRankAward(ctx context.Context, data map[string]interface{}) (err error) {
if g.IsEmpty(data["StringId"]) {
delete(data, "StringId")
log.Print("InsertAward", data)
data["_id"] = gtime.TimestampNano()
data["_t"] = "RankAward"
//var ss *qmgo.InsertOneResult
ss, err := MongoDatabaseList["0"].Collection("RankAward").InsertOne(ctx, data)
log.Print("InsertAward %v", ss, err)
return err
}
filter := bson.M{"_t": "RankAward"}
filter["_id"], _ = strconv.ParseInt(fmt.Sprint(data["StringId"]), 10, 64)
delete(data, "StringId")
delete(data, "_id")
//filter["Type"] = data["Type"]
log.Print("UpdateAward", filter, data)
err = MongoDatabaseList["0"].Collection("RankAward").UpdateOne(ctx, filter, bson.M{"$set": data})
log.Print("RankAward", filter, data, err)
return
}
func InsertRankAward(ctx context.Context, data map[string]interface{}) (err error) {
data["_id"] = gtime.TimestampNano()
data["_t"] = "RankAward"
log.Print("InsertAward", data)
ss, err := MongoDatabaseList["0"].Collection("RankAward").InsertOne(ctx, data)
log.Print("InsertAward %v", ss)
return
}
func GetRank(ctx context.Context, req *game.GetRankReq) (res *game.GetRankRes, err error) {
filter := bson.M{}
if req.Type != 0 {
filter["Type"] = req.Type
}
if req.Style != 0 {
filter["Style"] = req.Style
}
if req.Year != 0 {
setStart := fmt.Sprintf("%d-01-01 00:00:00", req.Year)
setStop := fmt.Sprintf("%d-01-01 00:00:00", req.Year+1)
//dateFormat := "2006-01-02 15:04:05"
//loc, _ := time.LoadLocation("Local") //重要:获取时区
//starTimeObj, _ := time.ParseInLocation(dateFormat, setStart, loc)
//stopTimeObj, _ := time.ParseInLocation(dateFormat, setStop, loc)
filter["BeginTime"] = bson.M{"$gte": setStart, "$lt": setStop}
fmt.Println("GetRank ", setStart, setStop, filter)
}
fmt.Println("GetRank ", filter)
res = new(game.GetRankRes)
err = MongoDatabaseList["0"].Collection("Rank").Find(ctx, filter).Sort("BeginTime").All(&res.Rank)
for _, v := range res.Rank {
v["StringId"] = fmt.Sprint(v["_id"])
}
fmt.Println("GetRank ", res)
return
}
func UpdateRank(ctx context.Context, data map[string]interface{}) (err error) {
if g.IsEmpty(data["StringId"]) {
data["_id"] = gtime.TimestampNano()
data["_t"] = "RankDaily"
if data["Type"] == 0 {
data["Type"] = consts.AWARD_DAILY
}
int64Num, _ := strconv.ParseInt(fmt.Sprint(data["Type"]), 10, 64)
if int64Num == consts.AWARD_STAGE {
data["_t"] = "RankStage"
}
log.Print("UpdateRank InsertRank", int64Num == consts.AWARD_STAGE, data)
delete(data, "StringId")
ss, err := MongoDatabaseList["0"].Collection("Rank").InsertOne(ctx, data)
log.Print("UpdateRank InsertOne %v", ss)
return err
}
filter := bson.M{"_t": "RankDaily"}
if data["Type"] == 0 {
data["Type"] = consts.AWARD_DAILY
data["_t"] = "RankDaily"
}
int64Num, _ := strconv.ParseInt(fmt.Sprint(data["Type"]), 10, 64)
if int64Num == consts.AWARD_STAGE {
data["_t"] = "RankStage"
filter["_t"] = "RankStage"
}
filter["_id"], _ = strconv.ParseInt(fmt.Sprint(data["StringId"]), 10, 64)
//filter["Type"] = data["Type"]
delete(data, "StringId")
delete(data, "_id")
log.Print("UpdateRank", filter, data)
err = MongoDatabaseList["0"].Collection("Rank").UpdateOne(ctx, filter, bson.M{"$set": data})
log.Print("UpdateRank", filter, data, err)
return
}
func InsertRank(ctx context.Context, data map[string]interface{}) (err error) {
data["_id"] = gtime.TimestampNano()
if data["Type"] == 0 {
data["Type"] = consts.AWARD_DAILY
}
if data["Type"] == consts.AWARD_STAGE {
data["_t"] = "RankStage"
} else {
data["_t"] = "RankDaily"
}
log.Print("InsertRank", data["Type"] == consts.AWARD_STAGE, data)
delete(data, "StringId")
ss, err := MongoDatabaseList["0"].Collection("Rank").InsertOne(ctx, data)
log.Print("InsertRank %v", ss)
return
}
func DelRank(ctx context.Context, id string) (err error) {
log.Print("DelRank", id)
idInt, _ := strconv.ParseInt(id, 10, 64)
err = MongoDatabaseList["0"].Collection("Rank").RemoveId(ctx, idInt)
return
}
func CheckRank(ctx context.Context, data map[string]interface{}) (total int64, res string, err error) {
log.Print("DelRank", data)
filter := bson.M{"$and": bson.A{bson.M{"$or": bson.A{
bson.M{"$and": bson.A{
bson.M{"BeginTime": bson.M{"$lte": fmt.Sprint(data["BeginTime"])}},
bson.M{"EndTime": bson.M{"$gt": fmt.Sprint(data["BeginTime"])}}}},
bson.M{"$and": bson.A{
bson.M{"BeginTime": bson.M{"$lt": fmt.Sprint(data["EndTime"])}},
bson.M{"EndTime": bson.M{"$gte": fmt.Sprint(data["EndTime"])}}}},
bson.M{"$and": bson.A{
bson.M{"BeginTime": bson.M{"$gte": fmt.Sprint(data["BeginTime"])}},
bson.M{"BeginTime": bson.M{"$lt": fmt.Sprint(data["EndTime"])}}}}}},
bson.M{"_t": "RankStage"}}}
log.Print("CheckPropExchange filter %v", filter)
all := make([]map[string]interface{}, 1)
total, err = MongoDatabaseList["0"].Collection("Rank").Find(ctx, filter).Count()
err = MongoDatabaseList["0"].Collection("Rank").Find(ctx, filter).All(&all)
log.Print("CheckPropExchange filter %v", res)
for _, v := range all {
res = fmt.Sprint(v["_id"])
}
return total, res, err
}
func AddRankGroup(ctx context.Context, req *game.AddRankGroupReq) (res *game.AddRankGroupRes, err error) {
log.Print("AddRankGroup", req)
filter := bson.M{"Name": req.Name, "StageGroupId": req.StageGroupId}
res = new(game.AddRankGroupRes)
log.Print("AddRankGroup filter %v", filter)
err = MongoDatabaseList["0"].Collection("RankGroupName").Find(ctx, filter).All(&res)
err = MongoDatabaseList["0"].Collection("RankGroupName").UpdateOne(ctx, filter, bson.M{"$set": filter})
return res, err
}
func GetRankGroup(ctx context.Context, req *game.AddRankGroupReq) (res *game.AddRankGroupRes, err error) {
log.Print("AddRankGroup", req)
filter := bson.M{"Name": req.Name, "StageGroupId": req.StageGroupId}
log.Print("AddRankGroup filter %v", filter)
err = MongoDatabaseList["0"].Collection("RankGroupName").UpdateOne(ctx, filter, bson.M{"$set": filter})
res = new(game.AddRankGroupRes)
return res, err
}
func GetGameRank(ctx context.Context, req *game.GetGameRankReq) (res *game.GetGameRankRes, err error) {
log.Printf("GetGameRank: %s", gjson.MustEncodeString(req))
res = new(game.GetGameRankRes)
mongo, ok := MongoDatabaseList[fmt.Sprint(req.ServerId)]
if !ok {
return res, errors.New("数据库为空!")
}
err = mongo.Collection(req.Name).Find(ctx, bson.M{}).All(&res.Groups)
chillren := res.Groups[0]["Children"].(primitive.A)
for _, v := range chillren {
v1 := v.(map[string]interface{})
if v1["UnitId"] != nil {
v1["StringId"] = fmt.Sprint(v1["UnitId"])
v1["uid"], _ = GetStringIdToUid(ctx, fmt.Sprint(v1["UnitId"]))
}
}
return res, err
}