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

package service

import (
	"context"

	jsoniter "github.com/json-iterator/go"
	cutils "github.com/mhaya/extend/utils"
	"github.com/mhaya/game/game_cluster/internal/code"
	"github.com/mhaya/game/game_cluster/internal/constant"
	"github.com/mhaya/game/game_cluster/internal/data"
	"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/mongo"
	"gorm.io/gorm"
)

var (
	json = jsoniter.ConfigCompatibleWithStandardLibrary
)

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 {
		updateRecord, codeResult := a.GetPlayerLastestUpdateRecord(v.UserName)
		if codeResult != nil {
			mhayaLogger.Warnf("List GetPlayerLastestUpdateRecord error:%v", codeResult)
			return nil, codeResult
		}

		loginRecord, codeResult := a.GetPlayerLastestLoginRecord(v.UserName)
		if codeResult != nil {
			mhayaLogger.Warnf("List GetPlayerLastestLoginRecord error:%v", codeResult)
			return nil, codeResult
		}

		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) 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:查询的事件状态 -1表示查询全部
func (a *PlayerManage) GetWithdrawalCount(userName string, status int) (int64, *code.Result) {
	withdrawalWhere := &eventmodels.UserWithdrawEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
	}

	if status != -1 {
		withdrawalWhere.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:查询的事件状态 -1表示查询全部
func (a *PlayerManage) GetCumulativeWithdrawalAmount(userName, currency string, status int) (int64, *code.Result) {
	withdrawalAmountWhere := &eventmodels.UserWithdrawEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		Currency: currency,
	}

	if status != -1 {
		withdrawalAmountWhere.Status = status
	}

	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) GetRegisterRecord(userName string) (*eventmodels.UserRegisterEventContent, *code.Result) {
	var registerRecord *eventmodels.UserRegisterEventContent
	where := &eventmodels.UserRegisterEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: userName,
		},
		EventBasic: eventmodels.EventBasic{
			Status: 0,
		},
	}
	err := mdb.LogstashDB.Model(&eventmodels.UserRegisterEventContent{}).Where(where).First(&registerRecord).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		mhayaLogger.Warnf("GetRegisterRecord First registerRecord error:%v", err)
		return nil, common.NewResult(code.InternalError)
	}

	if err == gorm.ErrRecordNotFound {
		return nil, nil
	}

	return registerRecord, 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)
	}

	if err == gorm.ErrRecordNotFound {
		return nil, nil
	}

	return updateRecord, nil
}

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

	if err == gorm.ErrRecordNotFound {
		return nil, nil
	}

	return loginRecord, 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)
	}

	if err == gorm.ErrRecordNotFound {
		return nil, nil
	}

	return registerRecord, nil
}

// 获取玩家详情
func (a *PlayerManage) PlayerInfo(ctx context.Context, req entity.PlayerInfoReq) (*entity.PlayerInfoResp, *code.Result) {
	updateRecord, codeResult := a.GetPlayerLastestUpdateRecord(req.UserName)
	if codeResult != nil {
		mhayaLogger.Warnf("PlayerInfo GetPlayerLastestUpdateRecord error:%v", codeResult)
		return nil, codeResult
	}

	var registerRecord *eventmodels.UserRegisterEventContent
	if updateRecord == nil {
		record, codeResult := a.GetPlayerRegisterRecord(req.UserName)
		if codeResult != nil {
			mhayaLogger.Warnf("PlayerInfo GetPlayerRegisterRecord error:%v", codeResult)
			return nil, codeResult
		}

		if record == nil {
			mhayaLogger.Warnf("PlayerInfo registerRecord:%v", record)
			return nil, nil
		}

		registerRecord = record
	}

	loginRecord, codeResult := a.GetPlayerLastestLoginRecord(req.UserName)
	if codeResult != nil {
		mhayaLogger.Warnf("PlayerInfo GetPlayerLastestLoginRecord error:%v", codeResult)
		return nil, codeResult
	}

	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:    loginRecord.ContinuousDays,
		MaxSuccessions: loginRecord.ContinuousDaysMax,
		PrevTime: func() int64 {
			if loginRecord != nil {
				return loginRecord.CreateAt
			}

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

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

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

	var rewardRecords []*eventmodels.UserRewardEventContent

	where := &eventmodels.UserRewardEventContent{
		UserBasic: eventmodels.UserBasic{
			UserId: req.UserName,
		},
		Source: models.SourceDraw,
	}
	db := mdb.LogstashDB.Model(&eventmodels.UserRewardEventContent{}).Where(where).Order("create_at")

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

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

	var results []*entity.RewardListDetail
	for _, v := range rewardRecords {
		addReward := make([]*entity.ShowItemReward, 0, 8)

		addRewards := make([]eventmodels.ItemReward, 0, 8)
		if v.AddReward == "" {
			addRewards = nil
		} else {
			err := json.Unmarshal([]byte(v.AddReward), &addRewards)
			if err != nil {
				mhayaLogger.Warnf("RewardList Unmarshal v.AddReward error:%v", err)
				return nil, common.NewResult(code.InternalError)
			}
		}

		if addRewards == nil {
			addReward = nil
		} else {
			for _, item := range addRewards {
				addReward = append(addReward, a.packItemReward(item))
			}
		}

		var desc *entity.Desc
		if v.Desc != "" {
			descDraw := eventmodels.DescDraw{}
			err := json.Unmarshal([]byte(v.Desc), &descDraw)
			if err != nil {
				mhayaLogger.Warnf("RewardList Unmarshal v.Desc error:%v", err)
				return nil, common.NewResult(code.InternalError)
			}

			ret := make([]*entity.ShowItemReward, 0, 8)
			for _, item := range descDraw.Reward {
				ret = append(ret, a.packItemReward(item))
			}

			desc = &entity.Desc{
				ID:     descDraw.ID,
				CurID:  descDraw.CurID,
				Reward: ret,
			}
		}

		results = append(results, &entity.RewardListDetail{
			UserName:   v.UserId,
			AddReward:  addReward,
			Desc:       desc,
			CreateTime: v.CreateAt,
		})
	}

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

func (a *PlayerManage) packItemReward(reward eventmodels.ItemReward) *entity.ShowItemReward {
	itemName := ""
	cfg, exist := data.ItemConfig.Get(reward.ItemID)
	if exist {
		itemName = cfg.ItemKey
	}

	return &entity.ShowItemReward{
		ItemBaseType: reward.ItemBaseType,
		ItemID:       reward.ItemID,
		ItemName:     itemName,
		Amount: func() float64 {
			if itemName == "u" || itemName == "ton" {
				return cutils.QuoInt64ByRatioToFloat64(int64(reward.Amount), constant.MoneyRatio)
			}

			return float64(reward.Amount)
		}(),
	}
}