xpggame/modules/web/handler/rank.go

package handler

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	"server/call"
	"server/modules/web/app"
	"server/modules/web/values"
	"server/util"
)

func RankCfg(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := &values.RankCfgReq{}
	if !a.S(req) {
		return
	}
	if req.RankType == 0 {
		req.RankType = 1
	}
	a.GetUID()
	resp := &values.RankCfgResp{}
	a.Data = resp
	configRanks := call.GetConfigRank(req.RankType)
	for _, configRank := range configRanks {
		for rankCycle := range configRank.RankCycleMap {
			jackpot, rankLess := call.RankJackpotGet(req.RankType, rankCycle)
			rankData := values.RankData{
				RankCycle:   util.ToInt(rankCycle),
				Pumping:     configRank.FreeRatesMap[rankCycle],
				JackPot:     jackpot,
				JackPotLast: call.RankJackpotPreGet(req.RankType, rankCycle),
				AwardAtLess: rankLess,
			}
			if rankAwards, ok := configRank.RankAwardsMap[rankCycle]; ok {
				rankData.RankAwards = make([]values.RankAward, 0, len(rankAwards))
				for _, rankAward := range rankAwards {
					rankData.RankAwards = append(rankData.RankAwards, values.RankAward{
						MinRank: rankAward.SmallRank,
						MaxRank: rankAward.LargeRank,
						Award:   rankAward.AwardRate,
					})
				}
			}
			resp.RankData = append(resp.RankData, rankData)
		}
	}
}

// RankInfo 排行榜信息
func RankInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := &values.RankInfoReq{}
	if !a.S(req) {
		return
	}
	if req.RankType == 0 {
		req.RankType = 1
	}
	a.GetUID()
	resp := &values.RankInfoResp{
		RankData: new(values.RankData),
		Exist:    true,
	}
	a.Data = resp
	cycleMark := fmt.Sprintf("%d", req.RankCycle)
	configRank := call.GetConfigRankByCycle(req.RankType, cycleMark)
	if configRank == nil {
		resp.Exist = false
		return
	}
	resp.RankData.RankCycle = req.RankCycle
	resp.RankData.Pumping = configRank.FreeRatesMap[cycleMark]
	resp.RankData.JackPotLast = call.RankJackpotPreGet(req.RankType, cycleMark)

	jackpot, rankLess := call.RankJackpotGet(req.RankType, cycleMark)
	resp.RankData.JackPot = jackpot
	resp.RankData.AwardAtLess = rankLess

	if rankAwards, ok := configRank.RankAwardsMap[cycleMark]; ok {
		resp.RankData.RankAwards = make([]values.RankAward, 0, len(rankAwards))
		for _, rankAward := range rankAwards {
			resp.RankData.RankAwards = append(resp.RankData.RankAwards, values.RankAward{
				MinRank: rankAward.SmallRank,
				MaxRank: rankAward.LargeRank,
				Award:   rankAward.AwardRate,
			})
		}
	}
	// todo 补充排行榜数据
	rankUsers, count, err := call.RankUsersGet(req.RankType, cycleMark, req.Page, req.PageSize)
	if err != nil {
		log.Error(err.Error())
		a.Code = values.CodeRetry
		return
	}
	resp.RankData.RankUsersCount = count
	for index, rankUser := range rankUsers {
		rank := (req.Page-1)*req.PageSize + index + 1
		var userAward int
		var userAwardExpected int64
		award, ok := configRank.RankAwardsOneMap[cycleMark][rank]
		if ok {
			userAward = award.AwardRate
			userAwardExpected = int64(userAward) * jackpot / 10000
		}
		resp.RankData.RankUsers = append(resp.RankData.RankUsers, values.RankUser{
			UserName:          rankUser.UserInfo.Nick,
			UserCount:         rankUser.RankValue,
			UserIcon:          rankUser.UserInfo.Avatar,
			UserRank:          rank,
			UserAward:         userAward,
			UserAwardExpected: userAwardExpected,
		})
	}
}

// RankHistory 排行榜历史记录
func RankHistory(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := &values.RankHistoryReq{}
	if !a.S(req) {
		return
	}
	if req.RankType == 0 {
		req.RankType = 1
	}
	a.GetUID()
	resp := &values.RankHistoryResp{
		RankData: new(values.RankData),
	}
	a.Data = resp
	cycleMark := fmt.Sprintf("%d", req.RankCycle)
	resp.RankData.JackPotLast = call.RankJackpotPreGet(req.RankType, cycleMark)

	resp.RankData.RankCycle = req.RankCycle

	rankUsers, count, err := call.RankUsersPreGet(req.RankType, cycleMark, req.Page, req.PageSize)
	if err != nil {
		log.Error(err.Error())
		a.Code = values.CodeRetry
		return
	}
	resp.RankData.RankUsersCount = count
	for _, rankUser := range rankUsers {
		resp.RankData.RankUsers = append(resp.RankData.RankUsers, values.RankUser{
			UserName:          rankUser.UserInfo.Nick,
			UserCount:         rankUser.RankValue,
			UserIcon:          rankUser.UserInfo.Avatar,
			UserRank:          rankUser.Rank,
			UserAward:         rankUser.UserAward,
			UserAwardExpected: rankUser.UserAwardCount,
		})
	}
}

// RankReward 玩家中奖记录
func RankReward(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := &values.RankRewardReq{}
	if !a.S(req) {
		return
	}
	a.GetUID()
	resp := &values.RankRewardResp{}
	a.Data = resp

	rankAwards, count, err := call.UserRankAwardRecord(a.UID, req.Page, req.PageSize)
	if err != nil {
		log.Error(err.Error())
		a.Code = values.CodeRetry
		return
	}
	resp.Count = count
	resp.RankRewardDetails = make([]values.RankRewardDetails, 0, len(rankAwards))
	for _, rankAward := range rankAwards {
		resp.RankRewardDetails = append(resp.RankRewardDetails, values.RankRewardDetails{
			Rank:        rankAward.Rank,
			RankCycle:   rankAward.RankCycle,
			RewardAt:    rankAward.RankAt,
			RewardCount: rankAward.UserAwardCount,
		})
	}
}