game_sync/model/gamedetailedlog.go

package model

import (
	"errors"
	"time"

	"github.com/globalsign/mgo"
	"github.com/globalsign/mgo/bson"
	"mongo.games.com/goserver/core/logger"
)

var (
	GameDetailedLogDBName   = "log"
	GameDetailedLogCollName = "log_gamedetailed"
)

// 水池上下文
type CoinPoolCtx struct {
	LowerLimit int64 //水池下限
	UpperLimit int64 //水池上限
	CurrValue  int32 //当前水位
	CurrMode   int32 //当前水位模式
	Controlled bool  //被水池控制了
}

type GameDetailedLog struct {
	Id               bson.ObjectId `bson:"_id"`
	Platform         string        // 平台
	LogId            string        // 记录ID，每局游戏唯一
	GameDif          string        // 游戏组
	GameId           int32         // 游戏id
	GameClass        int32         // 游戏类型
	GameMode         int32         // 游戏模式，弃用
	GameType         int32         // 游戏类型
	GameFreeId       int32         // 场次id
	CycleId          string        // 房卡场id，多轮有相同的id
	MatchId          int64         // 比赛ID，应该用字符串的
	SceneId          int32         // 房间id，会重复
	PlayerCount      int32         // 玩家数量
	GameTiming       int32         // 游戏用时，秒
	GameBaseBet      int32         // 游戏底分
	Ts               int64         // 时间戳
	Time             time.Time     // 记录时间
	GameDetailedNote string        // 游戏详情
	GameDetailVer    int32         // 游戏详情版本

	CpCtx         CoinPoolCtx // 水池上下文信息
	Trend20Lately string      // 最近游戏走势
	CtrlType      int         // 1控赢 2控输 0不控
	PlayerPool    map[int]int // 个人水池分 玩家id:分
}

type GameDetailedLogType struct {
	PageNo   int                //当前页码
	PageSize int                //每页数量
	PageSum  int                //总页码
	Data     []*GameDetailedLog //当页数据
}

type GameDetailedLogRet struct {
	Gplt GameDetailedLogType
}

func InsertGameDetailedLog(log *GameDetailedLog) (err error) {
	if rpcCli == nil {
		logger.Logger.Error("model.InsertGameDetailedLog rpcCli == nil")
		return
	}
	var ret bool
	err = rpcCli.CallWithTimeout("GameDetailedSvc.InsertGameDetailedLog", log, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Warn("model.InsertGameDetailedLog error:", err)
		return
	}
	return
}

type RemoveGameDetailedLogArg struct {
	Plt string
	Ts  time.Time
}

func RemoveGameDetailedLog(plt string, ts time.Time) (*mgo.ChangeInfo, error) {
	if rpcCli == nil {
		logger.Logger.Error("model.RemoveGameDetailedLog rpcCli == nil")
		return nil, errors.New("rpcCli is nil")
	}
	args := &RemoveGameDetailedLogArg{
		Plt: plt,
		Ts:  ts,
	}
	var ret mgo.ChangeInfo
	err := rpcCli.CallWithTimeout("GameDetailedSvc.RemoveGameDetailedLog", args, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Warn("model.RemoveGameDetailedLog error:", err)
		return nil, err
	}
	return &ret, nil
}

type GameDetailedArg struct {
	Plt                string
	StartTime, EndTime int64
}

func GetAllGameDetailedLogsByTs(plt string, startTime, endTime int64) (data []GameDetailedLog) {
	if rpcCli == nil {
		logger.Logger.Error("model.GetAllGameDetailedLogsByTs rpcCli == nil")
		return nil
	}
	args := &GameDetailedArg{
		Plt:       plt,
		StartTime: startTime,
		EndTime:   endTime,
	}

	err := rpcCli.CallWithTimeout("GameDetailedSvc.GetAllGameDetailedLogsByTs", args, &data, time.Second*30)
	if err != nil {
		logger.Logger.Error("model.GetAllGameDetailedLogsByTs is error", err)
		return nil
	}
	return
}

type GetPlayerHistoryArg struct {
	Plt   string
	LogId string
}

func GetPlayerHistory(plt, logid string) *GameDetailedLog {
	if rpcCli == nil {
		logger.Logger.Error("model.GetPlayerHistory rpcCli == nil")
		return nil
	}
	args := &GetPlayerHistoryArg{
		Plt:   plt,
		LogId: logid,
	}
	var ret GameDetailedLog
	err := rpcCli.CallWithTimeout("GameDetailedSvc.GetPlayerHistory", args, &ret, time.Second*30)
	if err != nil {
		logger.Logger.Error("model.GetPlayerHistory is error", err)
		return nil
	}
	return &ret
}

type GameDetailedGameIdAndArg struct {
	Plt      string
	Gameid   int
	LimitNum int
}

func GetAllGameDetailedLogsByGameIdAndTs(plt string, gameid int, limitnum int) (data []GameDetailedLog) {
	if rpcCli == nil {
		logger.Logger.Error("model.GetAllGameDetailedLogsByGameIdAndTs rpcCli == nil")
		return nil
	}
	args := &GameDetailedGameIdAndArg{
		Plt:      plt,
		Gameid:   gameid,
		LimitNum: limitnum,
	}

	err := rpcCli.CallWithTimeout("GameDetailedSvc.GetAllGameDetailedLogsByGameIdAndTs", args, &data, time.Second*30)
	if err != nil {
		logger.Logger.Error("model.GetAllGameDetailedLogsByGameIdAndTs is error", err)
		return nil
	}
	return
}

type GetPlayerHistoryAPIArg struct {
	//SnId               int32
	Platform           string
	StartTime, EndTime int64
	PageNo, PageSize   int
}

func GetPlayerHistoryAPI(snId int32, platform string, startTime, endTime int64, pageno, pagesize int) (gdt GameDetailedLogType) {
	if rpcCli == nil {
		logger.Logger.Error("model.GetPlayerHistoryAPI rpcCli == nil")
		return
	}
	args := &GetPlayerHistoryAPIArg{
		//SnId:      snId,
		Platform:  platform,
		StartTime: startTime,
		EndTime:   endTime,
		PageNo:    pageno,
		PageSize:  pagesize,
	}
	ret := &GameDetailedLogRet{}
	err := rpcCli.CallWithTimeout("GameDetailedSvc.GetPlayerHistoryAPI", args, ret, time.Second*30)
	if err != nil {
		logger.Logger.Error("model.GetPlayerHistoryAPI is error", err)
		return
	}
	return ret.Gplt
}