xpggame/modules/web/handler/game.go

package handler

import (
	"fmt"
	"server/call"
	"server/common"
	"server/db"
	"server/modules/web/app"
	"server/modules/web/providers/all"
	"server/modules/web/providers/base"
	"server/modules/web/values"
	"server/util"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	"github.com/olivere/elastic/v7"
)

func GameList(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameListReq)
	if !a.S(req) {
		return
	}
	resp := &values.GameListResp{Provider: req.Provider}
	a.Data = resp
	var list, tmp []*common.ConfigGameList
	if req.Provider == -1 {
		req.Provider = 0
	}
	if req.Mark == -1 {
		req.Mark = 0
	}
	if req.Type == -1 || req.Type == 1 {
		req.Type = 0
	}
	tmp = call.GetConfigGameList(0, req.Provider, req.Mark, req.Type)
	if len(req.Name) > 0 {
		reqName := strings.ToLower(req.Name)
		for _, v := range tmp {
			if strings.Contains(strings.ToLower(v.Name), reqName) {
				list = append(list, v)
			}
		}
	} else {
		list = tmp
	}

	start := req.Page * req.Num
	end := (req.Page + 1) * req.Num

	if start > len(list)-1 {
		return
	}
	if end > len(list) {
		end = len(list)
	}
	resp.List = list[start:end]
	call.GetGameInfo(resp.List)
	for _, v := range resp.List {
		v.Jackpot = call.GetJackpot(common.JackpotTypeGame, v.GameID)
	}
}

func EnterGame(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.EnterGameReq)
	if !a.S(req) {
		return
	}
	provider := call.GetConfigGameProvider(req.Provider)
	resp := new(values.EnterGameResp)
	if provider != nil {
		resp.Method = provider.Method
	}
	a.Data = resp
	// step:特殊逻辑处理
	providerId := 0
	if req.Provider == common.ProviderPGSoft {
		providerId = common.ProviderPG2
	}
	if req.Provider == common.ProviderJili {
		providerId = common.ProviderJiLi2
	}
	if providerId > 0 {
		provider = call.GetConfigGameProvider(providerId)
		game := call.GetConfigGameListByID(providerId, req.GameID)
		if game != nil && game.Open == 1 {
			req.Provider = providerId
			resp.Method = provider.Method
		}
	}

	if req.IsDemo {
		log.Debug("player enter demo game %+v", *req)
		enter := &base.EnterGameReq{
			ProviderID:   req.Provider,
			GameID:       req.GameID,
			Lang:         a.Lang,
			CurrencyType: req.Currency,
			IsDemo:       true,
			SubID:        req.SubID,
			IP:           a.GetRemoteIP(),
			DeviceType:   a.DeviceType,
			ChannelID:    a.Channel,
		}
		resp.URL = all.EnterGame(enter)
		return
	}
	if !req.Currency.IsValid() {
		a.Code = values.CodeParam
		return
	}
	token := c.GetHeader("token")
	uid, _ := db.Redis().GetInt(common.GetRedisKeyToken(token))
	if uid == 0 {
		a.Code = values.CodeToken
		return
	}
	c.Set("uid", uid)
	c.Set("token", token)
	util.Go(func() {
		db.Redis().AddUserExpire(uid, token)
	})
	log.Debug("player %d enter game %+v", uid, *req)
	enter := &base.EnterGameReq{
		ProviderID:   req.Provider,
		GameID:       req.GameID,
		UID:          uid,
		Token:        token,
		Lang:         a.Lang,
		CurrencyType: req.Currency,
		IsDemo:       false,
		SubID:        req.SubID,
		IP:           a.GetRemoteIP(),
		DeviceType:   a.DeviceType,
		ChannelID:    a.Channel,
	}
	resp.URL = all.EnterGame(enter)
	if resp.URL == "" {
		a.Code = values.CodeParam
		a.Msg = "Under Maintenance,please try later."
		return
	}
	util.Go(func() {
		// 记录玩家的记录
		err := call.AddGameRecord(uid, req.Provider, req.GameID)
		if err != nil {
			log.Error("AddGameRecord uid:%v, err:%v", uid, err)
			return
		}
	})
}

func GameHistory(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameHistoryReq)
	if !a.S(req) {
		return
	}
	if req.UID > 0 && req.UID != a.UID {
		a.Code = values.CodeParam
		return
	}
	log.Debug("player %d GameHistory %+v", a.UID, *req)
	if req.Num > 100 {
		return
	}
	resp := new(values.GameHistoryResp)
	a.Data = resp
	q := elastic.NewBoolQuery()
	if req.UID > 0 {
		q.Filter(elastic.NewTermQuery("UID", req.UID))
	}
	list := []common.ESGameData{}
	db.ES().QueryList(common.ESIndexGameData, req.Page, req.Num, q, &list, "Time", false)
	for _, v := range list {
		one := values.BetRecord{
			UID:          v.UID,
			Vip:          call.GetVIP(v.UID).Level,
			Provider:     v.Provider,
			GameID:       v.GameID,
			Time:         v.Time,
			BetAmount:    v.BetAmount,
			SettleAmount: v.SettleAmount,
			Multiplier:   util.FormatFloat(float64(v.SettleAmount)/float64(v.BetAmount), 4),
			CurrencyType: v.Type,
		}
		ga := call.GetConfigGameListByID(v.Provider, v.GameID)
		if ga != nil {
			one.GameName = ga.Name
		}
		player, _ := call.GetUserXInfo(v.UID, "nick", "avatar")
		one.Avatar = player.Avatar
		one.Nick = player.Nick
		resp.List = append(resp.List, one)
	}
}

func GameProfile(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	resp := new(values.GameProfileResp)
	a.Data = resp

	p, _ := call.GetUserXInfo(a.UID, "birth")
	resp.Birth = p.Birth
	// 拉取profile
	for i := common.CurrencyTypeZero + 1; i < common.CurrencyAll; i++ {
		profile := common.PlayerProfile{}
		db.Mysql().C().Table(fmt.Sprintf("player_profile_%s", i.GetCurrencyName())).Where("uid = ?", a.UID).Scan(&profile)
		resp.Statistics = append(resp.Statistics, profile)
	}

	q := elastic.NewBoolQuery()
	q.Filter(elastic.NewTermQuery("UID", a.UID))
	q.Filter(elastic.NewRangeQuery("SettleAmount").Gt(0))
	list := []common.ESGameData{}
	db.ES().QueryList(common.ESIndexGameData, 0, 10, q, &list, "SettleAmount", false)
	for _, v := range list {
		one := values.TopWins{
			Provider:     v.Provider,
			GameID:       v.GameID,
			Time:         v.Time,
			BetAmount:    v.BetAmount,
			SettleAmount: v.SettleAmount,
			CurrencyType: v.Type,
		}
		ga := call.GetConfigGameListByID(v.Provider, v.GameID)
		if ga != nil {
			one.GameName = ga.Name
		}
		resp.TopWins = append(resp.TopWins, one)
	}
}

func GameSearch(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameSearchReq)
	if !a.S(req) {
		return
	}
	resp := &values.GameSearchResp{}
	a.Data = resp
	list := call.GetConfigGameListByName(req.Name)
	start := req.Page * req.Num
	end := (req.Page + 1) * req.Num
	if start > len(list)-1 {
		return
	}
	if end > len(list) {
		end = len(list)
	}
	resp.List = list[start:end]
}