server/game/game_cluster/nodes/webadmin/service/playerMange.go

package service

import (
	"context"
	"time"

	mhayaTime "github.com/mhaya/extend/time"
	"github.com/mhaya/game/game_cluster/internal/code"
	"github.com/mhaya/game/game_cluster/internal/constant"
	"github.com/mhaya/game/game_cluster/internal/mdb"
	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
	"github.com/mhaya/game/game_cluster/internal/mdb/models"
	"github.com/mhaya/game/game_cluster/nodes/webadmin/common"
	"github.com/mhaya/game/game_cluster/nodes/webadmin/entity"
	mhayaLogger "github.com/mhaya/logger"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"gorm.io/gorm"
)

type PlayerManage struct {
	db *mongo.Database
}

func NewPlayerManage() *PlayerManage {
	return &PlayerManage{
		db: mdb.MDB,
	}
}

// 获取玩家列表
func (a *PlayerManage) List(ctx context.Context, req entity.PlayerListReq) (*entity.PlayerListResp, *code.Result) {
	page, pageSize := checkPageParam(req.Page, req.Size)

	var registerRecords []*eventmodels.UserRegisterEventContent

	where := &eventmodels.UserRegisterEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId:       req.UserName,
			TgId:         req.OpenId,
			XId:          req.XID,
			ParentUserId: req.Pid,
			TonWall:      req.TonWall,
			Email:        req.Email,
			UserStatus:   req.Status,
		},
	}
	db := mdb.LogstashDB.Model(&eventmodels.UserRegisterEventContent{}).Where(where).Order("create_at")

	if req.LevelMin > 0 && req.LevelMax == 0 {
		db = db.Where("level >= ? and level <= ?", req.LevelMin, 1000) // 等级最大值 暂定1000
	}

	if req.LevelMin > 0 && req.LevelMax > 0 && req.LevelMin <= req.LevelMax {
		db = db.Where("level >= ? and level <= ?", req.LevelMin, req.LevelMax)
	}

	if req.JoinTimeMin > 0 && req.JoinTimeMax > 0 && req.JoinTimeMin <= req.JoinTimeMax {
		db = db.Where("create_at >= ? and create_at <= ?", req.JoinTimeMin, req.JoinTimeMax)
	}

	pages := Paginate(db, page, pageSize)
	err := db.Scopes(pages.Limit).Find(&registerRecords).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		mhayaLogger.Warnf("List Find error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	var results []*entity.PlayerListDetail
	for _, v := range registerRecords {
		// 获取最新的用户信息更新记录
		var updateRecord *eventmodels.UserUpdateInfoEventContent
		updateWhere := &eventmodels.UserUpdateInfoEventContent{
			UserBasic: eventmodels.UserBasic{UserId: v.UserName, TgId: v.TgId},
		}
		err := mdb.LogstashDB.Model(&eventmodels.UserUpdateInfoEventContent{}).Where(updateWhere).Order("create_at desc").First(&updateRecord).Error
		if err != nil && err != gorm.ErrRecordNotFound {
			mhayaLogger.Warnf("List First updateRecord error:%v", err)
			return nil, common.NewResult(code.InternalError)
		}

		// 获取最新的用户登录记录
		var loginRecord *eventmodels.UserLoginEventContent
		loginWhere := &eventmodels.UserLoginEventContent{
			UserBasic: eventmodels.UserBasic{UserId: v.UserName, TgId: v.TgId},
		}
		err = mdb.LogstashDB.Model(&eventmodels.UserLoginEventContent{}).Where(loginWhere).Order("create_at desc").First(&loginRecord).Error
		if err != nil && err != gorm.ErrRecordNotFound {
			mhayaLogger.Warnf("List First loginRecord error:%v", err)
			return nil, common.NewResult(code.InternalError)
		}

		results = append(results, &entity.PlayerListDetail{
			UserName: v.UserId,
			OpenId: func() string {
				if updateRecord == nil {
					return v.TgId
				}

				return updateRecord.TgId
			}(),
			NickName: func() string {
				if updateRecord == nil {
					return v.UserName
				}

				return updateRecord.UserName
			}(),
			Pid: func() string {
				if updateRecord == nil {
					return v.ParentUserId
				}

				return updateRecord.ParentUserId
			}(),
			XID: func() string {
				if updateRecord == nil {
					return v.XId
				}

				return updateRecord.XId
			}(),
			TonWall: func() string {
				if updateRecord == nil {
					return v.TonWall
				}

				return updateRecord.TonWall
			}(),
			Email: func() string {
				if updateRecord == nil {
					return v.Email
				}

				return updateRecord.Email
			}(),
			Level: func() int {
				if updateRecord == nil {
					return v.Level
				}

				return updateRecord.Level
			}(),
			Status: func() int {
				if updateRecord == nil {
					return v.UserStatus
				}

				return updateRecord.UserStatus
			}(),
			LoginTime: func() int64 {
				if loginRecord != nil {
					return loginRecord.CreateAt
				}

				return 0
			}(),
			LoginIP: func() string {
				if loginRecord != nil {
					return loginRecord.Ip
				}

				return ""
			}(),
			JoinIP:   v.Ip,
			JoinTime: v.CreateAt,
		})
	}

	return &entity.PlayerListResp{
		Details: results,
		Total:   pages.Count,
	}, nil
}

// 获取累计登录次数
func (a *PlayerManage) GetMaxSuccessions(userName string) (int64, *code.Result) {
	loginWhere := &eventmodels.UserLoginEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
	}
	loginDb := mdb.LogstashDB.Model(&eventmodels.UserLoginEventContent{}).Where(loginWhere).Order("create_at")
	var loginCount int64
	err := loginDb.Count(&loginCount).Error
	if err != nil {
		mhayaLogger.Warnf("GetMaxSuccessions loginCount error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return loginCount, nil
}

// 获取用户骰子点击次数
func (a *PlayerManage) GetDiceHits(userName string) (int64, *code.Result) {
	diceClickWhere := &eventmodels.ClickEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		ClickName: string(constant.DiceClickName),
	}
	clickDb := mdb.LogstashDB.Model(&eventmodels.ClickEventContent{}).Where(diceClickWhere).Order("create_at")
	var diceHits int64
	err := clickDb.Count(&diceHits).Error
	if err != nil {
		mhayaLogger.Warnf("GetDiceHits diceHits error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return diceHits, nil
}

// 获取邀请点击次数
func (a *PlayerManage) GetInvitationHits(userName string) (int64, *code.Result) {
	inviteClickWhere := &eventmodels.ClickEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		ClickName: string(constant.InviteClickName),
	}
	clickDb := mdb.LogstashDB.Model(&eventmodels.ClickEventContent{}).Where(inviteClickWhere).Order("create_at")
	var invitationHits int64
	err := clickDb.Count(&invitationHits).Error
	if err != nil {
		mhayaLogger.Warnf("GetInvitationHits invitationHits error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return invitationHits, nil
}

// 获取转盘点击次数
func (a *PlayerManage) GetTurntableClicks(userName string) (int64, *code.Result) {
	turntableClickWhere := &eventmodels.ClickEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		ClickName: string(constant.TurntableClickName),
	}
	clickDb := mdb.LogstashDB.Model(&eventmodels.ClickEventContent{}).Where(turntableClickWhere).Order("create_at")
	var turntableClicks int64
	err := clickDb.Count(&turntableClicks).Error
	if err != nil {
		mhayaLogger.Warnf("GetTurntableClicks turntableClicks error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return turntableClicks, nil
}

// 获取转盘实际抽奖次数
func (a *PlayerManage) GetTurntableRuns(userName string) (int64, *code.Result) {
	turntableWhere := &eventmodels.TurntableEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
	}
	turntableDb := mdb.LogstashDB.Model(&eventmodels.TurntableEventContent{}).Where(turntableWhere).Order("create_at")
	var turntableRuns int64
	err := turntableDb.Count(&turntableRuns).Error
	if err != nil {
		mhayaLogger.Warnf("GetTurntableRuns turntableRuns error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return turntableRuns, nil
}

// 获取邀请成功人数 status:查询的事件状态
func (a *PlayerManage) GetSuccessfulInvitations(userName string, status int) (int64, *code.Result) {
	inviteWhere := &eventmodels.InviteEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		EventBasic: eventmodels.EventBasic{
			Status: status,
		},
	}
	inviteDb := mdb.LogstashDB.Model(&eventmodels.InviteEventContent{}).Where(inviteWhere).Order("create_at")
	var successfulInvitations int64
	err := inviteDb.Count(&successfulInvitations).Error
	if err != nil {
		mhayaLogger.Warnf("GetSuccessfulInvitations successfulInvitations error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return successfulInvitations, nil
}

// 获取提现次数 status:查询的事件状态
func (a *PlayerManage) GetWithdrawalCount(userName string, status int) (int64, *code.Result) {
	withdrawalWhere := &eventmodels.UserWithdrawEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		EventBasic: eventmodels.EventBasic{
			Status: status,
		},
	}
	withdrawalDb := mdb.LogstashDB.Model(&eventmodels.UserWithdrawEventContent{}).Where(withdrawalWhere).Order("create_at")
	var withdrawals int64
	err := withdrawalDb.Count(&withdrawals).Error
	if err != nil {
		mhayaLogger.Warnf("GetWithdrawalCount withdrawals error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return withdrawals, nil
}

// 获取累计提现金额 currency:货币类型 status:查询的事件状态
func (a *PlayerManage) GetCumulativeWithdrawalAmount(userName, currency string, status int) (int64, *code.Result) {
	withdrawalAmountWhere := &eventmodels.UserWithdrawEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		EventBasic: eventmodels.EventBasic{
			Status: status,
		},
		Currency: currency,
	}
	var cumulativeWithdrawalAmount int64
	err := mdb.LogstashDB.Model(&eventmodels.UserWithdrawEventContent{}).Where(withdrawalAmountWhere).Pluck("SUM(amount) as total_amount", &cumulativeWithdrawalAmount).Error
	if err != nil {
		mhayaLogger.Warnf("GetCumulativeWithdrawalAmount Pluck currency error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return cumulativeWithdrawalAmount, nil
}

// 获取的是注册的总人数
func (a *PlayerManage) GetPlayerTotalCount() (int64, *code.Result) {
	where := &eventmodels.UserRegisterEventContent{
		EventBasic: eventmodels.EventBasic{
			Status: 0,
		},
	}
	db := mdb.LogstashDB.Model(&eventmodels.UserRegisterEventContent{}).Where(where).Order("create_at")

	var count int64
	err := db.Count(&count).Error
	if err != nil {
		mhayaLogger.Warnf("GetPlayerTotalCount Count error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return count, nil
}

// 获取的是登录过的总人数 根据user_id去重
func (a *PlayerManage) GetLoginedPlayerTotalCount() (int64, *code.Result) {
	where := &eventmodels.UserLoginEventContent{
		EventBasic: eventmodels.EventBasic{
			Status: 0,
		},
	}
	db := mdb.LogstashDB.Model(&eventmodels.UserLoginEventContent{}).Distinct("user_id").Where(where)

	var count int64
	err := db.Count(&count).Error
	if err != nil {
		mhayaLogger.Warnf("GetLoginedPlayerTotalCount Count error:%v", err)
		return 0, common.NewResult(code.InternalError)
	}

	return count, nil
}

// 获取最新的用户信息更新记录
func (a *PlayerManage) GetPlayerLastestUpdateRecord(userName string) (*eventmodels.UserUpdateInfoEventContent, *code.Result) {
	var updateRecord *eventmodels.UserUpdateInfoEventContent
	updateWhere := &eventmodels.UserUpdateInfoEventContent{
		UserBasic: eventmodels.UserBasic{UserId: userName},
	}
	err := mdb.LogstashDB.Model(&eventmodels.UserUpdateInfoEventContent{}).Where(updateWhere).Order("create_at desc").First(&updateRecord).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		mhayaLogger.Warnf("GetPlayerLastestUpdateRecord First updateRecord error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	return updateRecord, nil
}

func (a *PlayerManage) GetPlayerRegisterRecord(userName string) (*eventmodels.UserRegisterEventContent, *code.Result) {
	var registerRecord *eventmodels.UserRegisterEventContent
	where := &eventmodels.UserRegisterEventContent{
		UserBasic: eventmodels.UserBasic{UserId: userName},
	}
	err := mdb.LogstashDB.Model(&eventmodels.UserRegisterEventContent{}).Where(where).First(&registerRecord).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		mhayaLogger.Warnf("GetPlayerRegisterRecord First registerRecord error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	return registerRecord, nil
}

// 获取玩家详情
func (a *PlayerManage) PlayerInfo(ctx context.Context, req entity.PlayerInfoReq) (*entity.PlayerInfoResp, *code.Result) {
	// 获取最新的用户信息更新记录
	var updateRecord *eventmodels.UserUpdateInfoEventContent
	updateWhere := &eventmodels.UserUpdateInfoEventContent{
		UserBasic: eventmodels.UserBasic{UserId: req.UserName},
	}
	err := mdb.LogstashDB.Model(&eventmodels.UserUpdateInfoEventContent{}).Where(updateWhere).Order("create_at desc").First(&updateRecord).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		mhayaLogger.Warnf("PlayerInfo First updateRecord error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	var registerRecord *eventmodels.UserRegisterEventContent
	if updateRecord == nil {
		where := &eventmodels.UserRegisterEventContent{
			UserBasic: eventmodels.UserBasic{UserId: req.UserName},
		}
		err := mdb.LogstashDB.Model(&eventmodels.UserRegisterEventContent{}).Where(where).First(&registerRecord).Error
		if err != nil && err != gorm.ErrRecordNotFound {
			mhayaLogger.Warnf("PlayerInfo First registerRecord error:%v", err)
			return nil, common.NewResult(code.InternalError)
		}
	}

	// 获取最新的用户登录记录
	var loginRecord *eventmodels.UserLoginEventContent
	loginWhere := &eventmodels.UserLoginEventContent{
		UserBasic: eventmodels.UserBasic{UserId: req.UserName},
	}
	err = mdb.LogstashDB.Model(&eventmodels.UserLoginEventContent{}).Where(loginWhere).Order("create_at desc").First(&loginRecord).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		mhayaLogger.Warnf("PlayerInfo First loginRecord error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	return &entity.PlayerInfoResp{
		UserName: func() string {
			if updateRecord != nil {
				return updateRecord.UserId
			}

			if registerRecord != nil {
				return registerRecord.UserId
			}

			return ""
		}(),
		OpenId: func() string {
			if updateRecord != nil {
				return updateRecord.TgId
			}

			if registerRecord != nil {
				return registerRecord.TgId
			}

			return ""
		}(),
		NickName: func() string {
			if updateRecord != nil {
				return updateRecord.UserName
			}

			if registerRecord != nil {
				return registerRecord.UserName
			}

			return ""
		}(),
		Pid: func() string {
			if updateRecord != nil {
				return updateRecord.ParentUserId
			}

			if registerRecord != nil {
				return registerRecord.ParentUserId
			}

			return ""
		}(),
		XID: func() string {
			if updateRecord != nil {
				return updateRecord.XId
			}

			if registerRecord != nil {
				return registerRecord.XId
			}

			return ""
		}(),
		TonWall: func() string {
			if updateRecord != nil {
				return updateRecord.TonWall
			}

			if registerRecord != nil {
				return registerRecord.TonWall
			}

			return ""
		}(),
		Email: func() string {
			if updateRecord != nil {
				return updateRecord.Email
			}

			if registerRecord != nil {
				return registerRecord.Email
			}

			return ""
		}(),
		Level: func() int {
			if updateRecord != nil {
				return updateRecord.Level
			}

			if registerRecord != nil {
				return registerRecord.Level
			}

			return 0
		}(),
		Status: func() int {
			if updateRecord != nil {
				return updateRecord.UserStatus
			}

			if registerRecord != nil {
				return registerRecord.UserStatus
			}

			return 0
		}(),
		LoginTime: func() int64 {
			if loginRecord != nil {
				return loginRecord.CreateAt
			}

			return 0
		}(),
		LoginIP: func() string {
			if loginRecord != nil {
				return loginRecord.Ip
			}

			return ""
		}(),
		JoinIP: func() string {
			if registerRecord != nil {
				return registerRecord.Ip
			}

			return ""
		}(),
		JoinTime: func() int64 {
			if registerRecord != nil {
				return registerRecord.CreateAt
			}

			return 0
		}(),
		Avatar: "",
		IsRobot: func() int {
			if updateRecord != nil && updateRecord.IsRobot {
				return 1
			}

			if registerRecord != nil && registerRecord.IsRobot {
				return 1
			}

			return 0
		}(),
		IsLeader: func() int {
			if updateRecord != nil && updateRecord.IsLeader {
				return 1
			}

			return 0
		}(),
		IsVip: func() int {
			if updateRecord != nil && updateRecord.IsVip {
				return 1
			}

			return 0
		}(),
		Successions:    0, // TODO
		MaxSuccessions: 0, // TODO
		PrevTime: func() int64 {
			if loginRecord != nil {
				return loginRecord.CreateAt
			}

			return 0
		}(),
		UpdateTime: func() int64 {
			if updateRecord != nil {
				return updateRecord.CreateAt
			}

			return 0
		}(),
		IsDrawShare:   0,
		DrawShareTime: 0,
		FirstReward:   0,
		// TODO 其他玩家信息
	}, nil
}

// 获取玩家中奖记录(默认查询最近三天)
func (a *PlayerManage) RewardList(ctx context.Context, req entity.RewardListReq) (*entity.RewardListResp, *code.Result) {
	page, pageSize := checkPageParam(req.Page, req.Size)

	// 构建查询条件
	filter := bson.M{}
	if req.UserName != "" {
		filter["userName"] = bson.M{"$regex": escapeRegex(req.UserName), "$options": "i"}
	}
	filter["source"] = models.SourceDraw

	startTime := mhayaTime.Now().Add(-3 * 24 * time.Hour).Unix()
	endTime := mhayaTime.Now().Unix()
	if req.StartTime > 0 && req.StartTime >= startTime {
		if req.StartTime <= req.EndTime || req.EndTime == 0 {
			startTime = req.StartTime
		}
	}

	if req.EndTime > 0 && req.EndTime <= endTime {
		if req.StartTime <= req.EndTime {
			endTime = req.EndTime
		}
	}

	filter["createTime"] = bson.M{
		"$gte": startTime,
		"$lte": endTime,
	}

	// 设置分页选项
	skip := (page - 1) * pageSize
	limit := pageSize
	findOptions := options.Find().SetSkip(int64(skip)).SetLimit(int64(limit))

	collection := a.db.Collection(constant.CNamePlayerReward)
	// 获取总数total
	count, err := collection.CountDocuments(ctx, filter)
	if err != nil {
		mhayaLogger.Warnf("RewardList count error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	// 执行查询
	cursor, err := collection.Find(ctx, filter, findOptions)
	if err != nil {
		mhayaLogger.Warnf("RewardList Find error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}
	defer func() {
		if closeErr := cursor.Close(ctx); closeErr != nil {
			mhayaLogger.Warnf("Error closing cursor: %v", closeErr)
		}
	}()

	// 解析结果
	results := make([]*models.ToPlayerRewardBase, 0)
	for cursor.Next(ctx) {
		var result models.PlayerRewardBase
		if err := cursor.Decode(&result); err != nil {
			mhayaLogger.Warnf("RewardList Decode error:%v", err)
			return nil, common.NewResult(code.InternalError)
		}
		results = append(results, result.To())
	}
	if err := cursor.Err(); err != nil {
		mhayaLogger.Warnf("RewardList cursor error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	return &entity.RewardListResp{
		Details: results,
		Total:   count,
	}, nil
}