1661 lines
47 KiB
Go
1661 lines
47 KiB
Go
package svc
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/rpc"
|
|
"os"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
newMongo "go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
"mongo.games.com/goserver/core/basic"
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/core/task"
|
|
|
|
"github.com/globalsign/mgo"
|
|
"github.com/globalsign/mgo/bson"
|
|
newBson "go.mongodb.org/mongo-driver/bson"
|
|
|
|
"mongo.games.com/game/common"
|
|
"mongo.games.com/game/dbproxy/mongo"
|
|
"mongo.games.com/game/model"
|
|
)
|
|
|
|
var (
|
|
PlayerDBName = "user"
|
|
PlayerCollName = "user_playerinfo"
|
|
PlayerDelBackupCollName = "user_playerinfo_del_backup"
|
|
PlayerColError = errors.New("Playerinfo collection open failed")
|
|
)
|
|
|
|
func PlayerDataCollection(plt string) *mongo.Collection {
|
|
s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, PlayerDBName)
|
|
if s != nil {
|
|
c_playerdata, first := s.DB().C(PlayerCollName)
|
|
if first {
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"accountid"}, Unique: true, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"snid"}, Unique: true, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"channel"}, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"tel"}, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"name"}, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"createtime"}, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"-createtime"}, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"icode"}, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"psnid"}, Background: true, Sparse: true})
|
|
c_playerdata.EnsureIndex(mgo.Index{Key: []string{"pcode"}, Background: true, Sparse: true})
|
|
}
|
|
return c_playerdata
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type PlayerDelBackupDataSvc struct {
|
|
}
|
|
|
|
func PlayerDelBackupDataCollection(plt string) *mongo.Collection {
|
|
s := mongo.MgoSessionMgrSington.GetPltMgoSession(plt, PlayerDBName)
|
|
if s != nil {
|
|
c_playerdata, _ := s.DB().C(PlayerDelBackupCollName)
|
|
return c_playerdata
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type PlayerDataSvc struct {
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) InsertPlayerData(args *model.InsertPlayerDataParam, ret *model.PlayerDataRet) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
acc := args.AccId
|
|
pd := &model.PlayerData{}
|
|
fileName := fmt.Sprintf("%v.json", acc)
|
|
_, err = os.Stat(fileName)
|
|
if err == nil || os.IsExist(err) {
|
|
pd = model.RestorePlayerData(fileName)
|
|
err = os.Remove(fileName)
|
|
} else {
|
|
if acc != "" {
|
|
err = cplayerdata.Find(bson.M{"accountid": acc}).One(pd)
|
|
}
|
|
}
|
|
|
|
if err != nil && err.Error() == mgo.ErrNotFound.Error() {
|
|
logger.Logger.Trace("InsertPlayerData Find failed:", err)
|
|
|
|
if !bson.IsObjectIdHex(acc) {
|
|
logger.Logger.Warn("NewPlayer failed: acc is illeage ", acc)
|
|
return
|
|
}
|
|
var a *model.Account
|
|
a, err = _AccountSvc.getAccount(args.Plt, args.AccId)
|
|
if err != nil {
|
|
logger.Logger.Warnf("_AccountSvc.getAccount(%v,%v) failed:%v", args.Plt, args.AccId, err)
|
|
return
|
|
}
|
|
|
|
id := a.SnId
|
|
if id == 0 {
|
|
id, err = GetOnePlayerIdFromBucket()
|
|
if err != nil {
|
|
logger.Logger.Warn("NewPlayer failed:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
//name := model.GameParamData.GuestDefaultName //fmt.Sprintf("db%v", id)
|
|
name := args.NickName
|
|
if name == "" {
|
|
name = "Guest"
|
|
}
|
|
var dataParams model.PlayerParams
|
|
json.Unmarshal([]byte(a.Params), &dataParams)
|
|
pd = model.NewPlayerData(acc, name, args.HeadUrl, id, a.Channel, a.Platform, a.Params,
|
|
a.Tel, a.PackegeTag, dataParams.Ip, a.TagKey, a.AccountType, a.DeviceOs, a.ChannelId, a.ClientVer)
|
|
if pd != nil {
|
|
if pd.ICode == "" {
|
|
code, _ := GetInviteCode(pd.Platform, pd.SnId)
|
|
pd.ICode = code
|
|
pd.IScoreTs = time.Now()
|
|
}
|
|
err = cplayerdata.Insert(pd)
|
|
if err != nil {
|
|
logger.Logger.Trace("InsertPlayerData Insert failed:", err)
|
|
return
|
|
}
|
|
ret.Pd = pd
|
|
ret.IsNew = true
|
|
return
|
|
}
|
|
return
|
|
}
|
|
if CorrectData(pd) {
|
|
}
|
|
ret.Pd = pd
|
|
return nil
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) GetPlayerDataBySnId(args *model.GetPlayerDataBySnIdArgs, ret *model.PlayerDataRet) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
|
|
//defer func() {
|
|
// logger.Logger.Debugf("Player Data: snid:%v VCardCost:%v MoneyTotal:%v", ret.Pd.SnId, ret.Pd.VCardCost, ret.Pd.MoneyTotal)
|
|
//}()
|
|
|
|
f := func(p *model.PlayerData) {
|
|
// 更新一下绑定关系
|
|
if p.PSnId > 0 && p.PCode != "" {
|
|
return
|
|
}
|
|
c := InviteScoreCollection(args.Plt)
|
|
if c == nil {
|
|
return
|
|
}
|
|
res := new(model.LogInviteScore)
|
|
c.Find(bson.M{"downsnid": args.SnId, "tp": common.InviteScoreTypeBind}).One(res)
|
|
param := bson.M{}
|
|
if res.UpSnid > 0 {
|
|
p.PSnId = int32(res.UpSnid)
|
|
param["psnid"] = p.PSnId
|
|
code, _ := GetCodeBySnId(args.Plt, p.PSnId)
|
|
if code != "" {
|
|
p.PCode = code
|
|
param["pcode"] = code
|
|
}
|
|
cplayerdata.Update(bson.M{"snid": args.SnId}, bson.M{"$set": param})
|
|
}
|
|
if p.GuideStep >= 0 && p.CreateTime.Unix() < model.GameParamData.GuideTs {
|
|
p.GuideStep = -1
|
|
param["guidestep"] = p.GuideStep
|
|
cplayerdata.Update(bson.M{"snid": args.SnId}, bson.M{"$set": param})
|
|
}
|
|
}
|
|
|
|
var code string
|
|
err = cplayerdata.Find(bson.M{"snid": args.SnId}).One(&ret.Pd)
|
|
if err != nil {
|
|
logger.Logger.Tracef("from %v Get %v player data error:%v", args.Plt, args.SnId, err)
|
|
if args.CreateIfNotExist && err == mgo.ErrNotFound {
|
|
a, err := _AccountSvc.getAccountBySnId(args.Plt, args.SnId)
|
|
if err != nil {
|
|
logger.Logger.Warnf("model.getAccountBySnId(%v) failed:%v", args.SnId, err)
|
|
return err
|
|
}
|
|
|
|
var dataParams model.PlayerParams
|
|
json.Unmarshal([]byte(a.Params), &dataParams)
|
|
|
|
name := dataParams.Name
|
|
if name == "" {
|
|
name = model.GameParamData.GuestDefaultName //fmt.Sprintf("Guest%v", id)
|
|
}
|
|
if name == "" {
|
|
name = "Guest"
|
|
}
|
|
pd := model.NewPlayerData(a.AccountId.Hex(), name, "", a.SnId, a.Channel, a.Platform, a.Params,
|
|
a.Tel, a.PackegeTag, dataParams.Ip, a.TagKey, a.AccountType, a.DeviceOs, a.ChannelId, a.ClientVer)
|
|
if pd != nil {
|
|
if pd.ICode == "" {
|
|
code, _ = GetInviteCode(pd.Platform, pd.SnId)
|
|
pd.ICode = code
|
|
pd.IScoreTs = time.Now()
|
|
}
|
|
err = cplayerdata.Insert(pd)
|
|
if err != nil {
|
|
logger.Logger.Errorf("GetPlayerDataBySnId Insert err:%v acc:%v snid:%v", err, a.AccountId.Hex(), a.SnId)
|
|
return err
|
|
}
|
|
ret.IsNew = true
|
|
ret.Pd = pd
|
|
return nil
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
if ret.Pd.ICode == "" {
|
|
code, _ = GetInviteCode(ret.Pd.Platform, ret.Pd.SnId)
|
|
ret.Pd.ICode = code
|
|
ret.Pd.IScoreTs = time.Now()
|
|
cplayerdata.Update(bson.M{"snid": args.SnId}, bson.M{"$set": bson.M{"icode": code, "iscorets": ret.Pd.IScoreTs}})
|
|
}
|
|
if ret.Pd.VCardCost == 0 {
|
|
ret.Pd.VCardCost = GetItemCount(ret.Pd.Platform, ret.Pd.SnId, common.ItemIDVCard, 1)
|
|
}
|
|
if ret.Pd.MoneyTotal == 0 {
|
|
ret.Pd.MoneyTotal = GetMoneyTotal(ret.Pd.Platform, ret.Pd.SnId)
|
|
}
|
|
f(ret.Pd)
|
|
if args.CorrectData && ret.Pd != nil {
|
|
CorrectData(ret.Pd)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) GetPlayerDatasBySnIds(args *model.GetPlayerDatasBySnIdsArgs, ret *[]*model.PlayerData) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
err = cplayerdata.Find(bson.M{"snid": bson.M{"$in": args.SnIds}}).All(ret)
|
|
if err != nil {
|
|
logger.Logger.Tracef("GetPlayerDatasBySnIds(snids=%v) error:%v", args.SnIds, err)
|
|
return
|
|
}
|
|
|
|
if args.CorrectData {
|
|
for _, e := range *ret {
|
|
if CorrectData(e) {
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) GetPlayerTel(args *model.GetPlayerTelArgs, ret *model.GetPlayerTelRet) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Find(bson.M{"tel": args.Tel}).Select(bson.M{"snid": 1}).One(ret)
|
|
if err != nil {
|
|
logger.Logger.Warn("model.PlayerData.Find err:", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) GetPlayerCoin(args *model.GetPlayerCoinArgs, ret *model.GetPlayerCoinRet) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Find(bson.M{"snid": args.SnId}).Select(bson.M{"coin": 1, "safeboxcoin": 1}).One(ret)
|
|
if err != nil {
|
|
logger.Logger.Trace("GetPlayerCoin error:", err)
|
|
ret.Err = err
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func SavePlayerData(pd *model.PlayerData) (err error) {
|
|
cplayerdata := PlayerDataCollection(pd.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
if pd != nil {
|
|
model.RecalcuPlayerCheckSum(pd)
|
|
//todo 排除字段更新，有没有更新好的方法
|
|
pd.IScore, pd.INum, pd.IMoney, pd.IScoreTs, err = GetInviteData(pd.Platform, pd.SnId)
|
|
if err != nil {
|
|
logger.Logger.Errorf("model.SavePlayerData GetInviteData %v err:%v", pd.SnId, err)
|
|
return
|
|
}
|
|
_, err = cplayerdata.Upsert(bson.M{"_id": pd.Id}, pd)
|
|
if err != nil {
|
|
logger.Logger.Errorf("model.SavePlayerData %v err:%v", pd.SnId, err)
|
|
return
|
|
}
|
|
|
|
//清理coinWAL
|
|
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
|
RemoveCoinWALByCoinType(pd.Platform, pd.SnId, PayCoinLogType_Coin, pd.CoinPayTs)
|
|
RemoveCoinWALInGame(pd.Platform, pd.SnId, 0, pd.GameCoinTs)
|
|
return nil
|
|
}), nil, "RemoveCoinWAL").StartByFixExecutor("RemoveCoinWAL")
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 保存玩家的全部信息
|
|
*/
|
|
func (svc *PlayerDataSvc) SavePlayerData(pd *model.PlayerData, ret *bool) (err error) {
|
|
err = SavePlayerData(pd)
|
|
*ret = err == nil
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) RemovePlayer(args *model.RemovePlayerArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
err = cplayerdata.Remove(bson.M{"snid": args.SnId})
|
|
if err != nil {
|
|
logger.Logger.Info("Remove player failed.")
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) RemovePlayerByAcc(args *model.RemovePlayerByAccArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
err = cplayerdata.Remove(bson.M{"accountid": args.Acc})
|
|
if err != nil {
|
|
logger.Logger.Info("Remove player failed.")
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 检查手机号是否存在
|
|
*/
|
|
func (svc *PlayerDataSvc) GetPlayerSnid(args *model.GetPlayerSnidArgs, ret *int32) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Find(bson.M{"accountid": args.Acc}).Select(bson.M{"snid": 1}).One(ret)
|
|
if err != nil {
|
|
logger.Logger.Error("svc.GetPlayerSnid is error ", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 检查昵称是否存在
|
|
*/
|
|
func (svc *PlayerDataSvc) PlayerNickIsExist(args *model.PlayerNickIsExistArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Find(bson.M{"name": args.Name}).One(nil)
|
|
if err != nil {
|
|
logger.Logger.Error("svc.PlayerNickIsExist is error", err)
|
|
return err
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 检查玩家是否存在
|
|
*/
|
|
func (svc *PlayerDataSvc) PlayerIsExistBySnId(args *model.PlayerIsExistBySnIdArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Find(bson.M{"snid": args.SnId}).One(nil)
|
|
if err != nil {
|
|
logger.Logger.Error("svc.GetPlayerIsExistBySnId is error", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
// 修改推广包标识
|
|
func (svc *PlayerDataSvc) UpdatePlayerPackageId(args *model.UpdatePackageId, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.PlatformStr)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.M{"packageid": args.Tag,
|
|
"platform": strconv.Itoa(int(args.Platform)), "channel": strconv.Itoa(int(args.Channel)),
|
|
"beunderagentcode": strconv.Itoa(int(args.Promoter)), "inviterid": args.Inviterid, "promotertree": args.PromoterTree}}})
|
|
if err != nil {
|
|
logger.Logger.Error("Update player packageid error:", err)
|
|
return err
|
|
}
|
|
*ret = true
|
|
return nil
|
|
}
|
|
func (svc *PlayerDataSvc) UpdatePlayerPackageIdByStr(args *model.UpdatePackageId, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.PlatformStr)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.M{"packageid": args.Tag,
|
|
"platform": args.PlatformStr, "channel": args.ChannelStr,
|
|
"beunderagentcode": args.PromoterStr, "inviterid": args.Inviterid, "promotertree": args.PromoterTree}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("UpdatePlayerPackageIdByStr error:", err)
|
|
return err
|
|
}
|
|
|
|
*ret = true
|
|
return nil
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) UpdatePlayerPackageIdByAcc(args *model.UpdatePackageId, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.PlatformStr)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"accountid": args.AccId}, bson.D{{"$set", bson.M{"packageid": args.Tag,
|
|
"platform": args.PlatformStr, "channel": args.ChannelStr,
|
|
"beunderagentcode": args.PromoterStr, "inviterid": args.Inviterid, "promotertree": args.PromoterTree}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("UpdatePlayerPackageIdByAcc error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
// 修改平台
|
|
func (svc *PlayerDataSvc) UpdatePlayerPlatform(args *model.UpdatePackageId, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.PlatformStr)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set",
|
|
bson.D{{"platform", args.PlatformStr}, {"channel", args.ChannelStr}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player nick error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
// 修改玩家无级代推广员id
|
|
func (svc *PlayerDataSvc) UpdatePlayerPromoterTree(args *model.UpdatePackageId, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.PlatformStr)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"promotertree", args.PromoterTree}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("UpdatePlayerPromoterTree error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
// 修改玩家全民推广
|
|
func (svc *PlayerDataSvc) UpdatePlayerInviteID(args *model.UpdatePackageId, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.PlatformStr)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"inviterid", args.Inviterid}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("UpdatePlayerInviteID error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改昵称
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerNick(args *model.UpdatePlayerInfo, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Update(bson.M{"accountid": args.Acc}, bson.D{{"$set", bson.D{{"name", args.Nick}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player nick error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改黑名单类型
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerBlacklistType(args *model.UpdatePlayerBlacklistTypeArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"blacklisttype", args.BlackListType}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player blacklisttype error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改玩家备注信息
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerMarkInfo(args *model.UpdatePlayerMarkInfoArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"markinfo", args.MarkInfo}}}})
|
|
if err != nil {
|
|
logger.Logger.Warnf("Update player mark error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改玩家特殊白名单
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerWhiteFlag(args *model.UpdatePlayerWhiteFlagArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"whiteflag", args.WhiteFlag}}}})
|
|
if err != nil {
|
|
logger.Logger.Warnf("Update player whiteFlag error:", err)
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改玩家支付信息
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerPayAct(args *model.UpdatePlayerPayActArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"payactstate", args.PayActState}}}})
|
|
if err != nil {
|
|
logger.Logger.Warnf("Update player payact error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改玩家电销标记
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerTelephonePromoter(args *model.UpdatePlayerTelephonePromoterArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set",
|
|
bson.D{{"telephonepromoter", args.TelephonePromoter}}}})
|
|
if err != nil {
|
|
logger.Logger.Warnf("Update player telephonepromoter error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改玩家电销标记
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerTelephoneCallNum(args *model.UpdatePlayerTelephonePromoterArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set",
|
|
bson.D{{"telephonecallnum", args.TelephoneCallNum}}}})
|
|
if err != nil {
|
|
logger.Logger.Warnf("Update player telephonecallnum error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改头像
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayeIcon(args *model.UpdatePlayeIconArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Update(bson.M{"accountid": args.Acc}, bson.D{{"$set", bson.D{{"head", args.Head}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player icon error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改性别
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayeSex(args *model.UpdatePlayeSexArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Update(bson.M{"accountid": args.Acc}, bson.D{{"$set", bson.D{{"sex", args.Sex}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player sex error:", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 检查手机号是否存在
|
|
*/
|
|
func (svc *PlayerDataSvc) PlayerTelIsExist(args *model.PlayerTelIsExistArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Find(bson.M{"tel": args.Tel, "tagkey": args.TagKey}).One(nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 绑定手机号
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerTel(args *model.UpdatePlayerTelArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"tel", args.Tel}}}})
|
|
if err != nil {
|
|
logger.Logger.Warn("UpdatePlayerTel error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) ResetPlayer(args *model.ResetPlayerArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"tel", ""}, {"delete", 1}}}})
|
|
if err != nil {
|
|
logger.Logger.Warn("UpdatePlayerTel error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) CountAlipayAccountCount(args *model.CountAlipayAccountCountArgs, ret *int) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
n, err := cplayerdata.Find(bson.M{"alipayaccount": args.AliPayAccount}).Count()
|
|
if err != nil {
|
|
logger.Logger.Warn("CountAlipayAccountCount error:", err)
|
|
return err
|
|
}
|
|
*ret = n
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) CountBankAlipayNameCount(args *model.CountBankAlipayNameCountArgs, ret *int) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
var conds []bson.M
|
|
conds = append(conds, bson.M{"alipayaccname": args.AliPayAccName})
|
|
conds = append(conds, bson.M{"bankaccname": args.BankAccName})
|
|
n, err := cplayerdata.Find(bson.M{"snid": bson.M{"$ne": args.SnId}, "$or": conds}).Count()
|
|
if err != nil {
|
|
logger.Logger.Warn("CountBankAlipayNameCount error:", err)
|
|
return
|
|
}
|
|
*ret = n
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 绑定支付宝账号
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerAlipay(args *model.UpdatePlayerAlipayArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set",
|
|
bson.D{{"alipayaccount", args.AliPayAccount}, {"alipayaccname", args.AliPayAccName}}}})
|
|
if err != nil {
|
|
logger.Logger.Warn("UpdatePlayerAlipay error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) UpdatePlayerAlipayAccount(args *model.UpdatePlayerAlipayArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"alipayaccount", args.AliPayAccount}}}})
|
|
if err != nil {
|
|
logger.Logger.Warn("UpdatePlayerAlipay error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) UpdatePlayerAlipayName(args *model.UpdatePlayerAlipayArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set",
|
|
bson.D{{"alipayaccname", args.AliPayAccName}}}})
|
|
if err != nil {
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) CountBankAccountCount(args *model.CountBankAccountCountArgs, ret *int) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
n, err := cplayerdata.Find(bson.M{"bankaccount": args.BankAccount}).Count()
|
|
if err != nil {
|
|
logger.Logger.Warn("CountBankAccountCount error:", err)
|
|
return
|
|
}
|
|
*ret = n
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 绑定银行账号
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerBank(args *model.UpdatePlayerBankArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("user_playerinfo not open")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"bank", args.Bank},
|
|
{"bankaccount", args.BankAccount}, {"bankaccname", args.BankAccName}}}})
|
|
if err != nil {
|
|
logger.Logger.Warn("UpdatePlayerBank error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改玩家是否返利
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerIsRebate(args *model.UpdatePlayerIsRebateArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"iscanrebate", args.IsCanRebate}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player isRebate error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改玩家是否可以修改昵称
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdatePlayerIsStopRename(args *model.UpdatePlayerIsStopRenameArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("param err")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"isstoprename", args.IsStopReName}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player isRename error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) PlayerRebindSnId(args *model.PlayerRebindSnIdArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return errors.New("cplayerdata == nil")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"snid", args.NewSnId}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("PlayerRebindSnId error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 修改保险箱密码
|
|
*/
|
|
func (svc *PlayerDataSvc) UpdateSafeBoxPassword(args *model.PlayerSafeBoxArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Update(bson.M{"accountid": args.Acc, "safeboxpassword": args.OldPassWord},
|
|
bson.D{{"$set", bson.D{{"safeboxpassword", args.PassWord}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player safeboxpassword error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 找回保险箱密码
|
|
*/
|
|
func (svc *PlayerDataSvc) GetBackSafeBoxPassword(args *model.PlayerSafeBoxArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return errors.New("GetBackSafeBoxPassword error")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"tel": args.Tel, "tagkey": args.TagKey},
|
|
bson.D{{"$set", bson.D{{"safeboxpassword", args.PassWord}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Update player safeboxpassword error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 重置保险箱密码
|
|
*/
|
|
func (svc *PlayerDataSvc) ResetSafeBoxPassword(args *model.PlayerSafeBoxArgs, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return PlayerColError
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{{"safeboxpassword", args.PassWord}}}})
|
|
if err != nil {
|
|
logger.Logger.Trace("Reset player safeboxpassword error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) UpdatePlayerCoin(args *model.PlayerSafeBoxCoin, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return fmt.Errorf("db may be closed")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{
|
|
{"coin", args.Coin},
|
|
{"diamond", args.Diamond},
|
|
{"safeboxcoin", args.SafeBoxCoin},
|
|
{"coinpayts", args.CoinPayTs},
|
|
{"safeboxcoints", args.SafeBoxCoinTs},
|
|
{"moneypaytotal", args.Money},
|
|
{"shopid", args.ShopId}}}})
|
|
if err != nil {
|
|
logger.Logger.Error("UpdatePlayerCoin error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) UpdatePlayerSetCoin(args *model.PlayerSafeBoxCoin, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return fmt.Errorf("db may be closed")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{
|
|
{"coin", args.Coin}}}})
|
|
if err != nil {
|
|
logger.Logger.Error("svc.UpdatePlayerSetCoin error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) UpdatePlayerLastExchangeTime(args *model.PlayerSafeBoxCoin, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return fmt.Errorf("db may be closed")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{
|
|
{"lastexchangetime", args.LastexChangeTime}}}})
|
|
if err != nil {
|
|
logger.Logger.Error("svc.UpdateLastExchangeTime error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) UpdatePlayerExchageFlow(args *model.PlayerSafeBoxCoin, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return fmt.Errorf("db may be closed")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{
|
|
{"totalconvertibleflow", args.TotalConvertibleFlow},
|
|
{"totalflow", args.TotalFlow}}}})
|
|
if err != nil {
|
|
logger.Logger.Error("svc.UpdatePlayerExchageFlow error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) UpdatePlayerExchageFlowAndOrder(args *model.PlayerSafeBoxCoin, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return fmt.Errorf("db may be closed")
|
|
}
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bson.D{
|
|
{"totalconvertibleflow", args.TotalConvertibleFlow},
|
|
{"lastexchangeorder", args.LastexChangeOrder}}}})
|
|
if err != nil {
|
|
logger.Logger.Error("svc.UpdatePlayerExchageFlowAndOrder error:", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 查找用户
|
|
*/
|
|
func (svc *PlayerDataSvc) FindPlayerList(args *model.PlayerSelect, ret *[]*model.PlayerBaseInfo) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
|
|
var conds []bson.M
|
|
if args.Id != 0 {
|
|
conds = append(conds, bson.M{"snid": args.Id})
|
|
}
|
|
if len(args.Tel) > 0 {
|
|
conds = append(conds, bson.M{"tel": args.Tel})
|
|
}
|
|
if len(args.NickName) > 0 {
|
|
conds = append(conds, bson.M{"name": args.NickName})
|
|
}
|
|
if args.Coinl > 0 || args.Coinh > 0 {
|
|
conds = append(conds, bson.M{"coin": bson.M{"$gt": args.Coinl, "$lt": args.Coinh}})
|
|
}
|
|
if len(args.Alipay) > 0 {
|
|
conds = append(conds, bson.M{"alipayaccount": args.Alipay})
|
|
}
|
|
if args.Registerl > 0 || args.Registerh > 0 {
|
|
conds = append(conds, bson.M{"createtime": bson.M{"$gt": time.Unix(int64(args.Registerl), 0), "$lt": time.Unix(int64(args.Registerh), 0)}})
|
|
}
|
|
if len(args.Channel) > 0 {
|
|
conds = append(conds, bson.M{"channel": args.Channel})
|
|
}
|
|
selecter := bson.M{"$or": conds}
|
|
if args.Limit > 0 {
|
|
err = cplayerdata.Find(selecter).Limit(args.Limit).All(ret)
|
|
} else {
|
|
err = cplayerdata.Find(selecter).All(ret)
|
|
}
|
|
if err != nil {
|
|
logger.Logger.Error("svc.FindPlayerList is error", err)
|
|
return nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) UpdatePlayerElement(args *model.UpdateElement, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return fmt.Errorf("db may be close")
|
|
}
|
|
playerMap := make(map[string]interface{})
|
|
json.Unmarshal([]byte(args.PlayerMap), &playerMap)
|
|
|
|
var o model.PlayerData
|
|
r_t := reflect.TypeOf(o)
|
|
var bsonInfo bson.D
|
|
var docelem bson.DocElem
|
|
for k, v := range playerMap {
|
|
if f, ok := r_t.FieldByName(k); ok {
|
|
if reflect.TypeOf(v).ConvertibleTo(f.Type) {
|
|
docelem.Name = strings.ToLower(k)
|
|
docelem.Value = v
|
|
bsonInfo = append(bsonInfo, docelem)
|
|
} else {
|
|
logger.Logger.Warnf("UpdatePlayerElement Type not fit %v field, get %v", k, v)
|
|
}
|
|
} else {
|
|
logger.Logger.Warnf("UpdatePlayerElement no %v field", k)
|
|
}
|
|
}
|
|
|
|
err = cplayerdata.Update(bson.M{"snid": args.SnId}, bson.D{{"$set", bsonInfo}})
|
|
if err != nil {
|
|
logger.Logger.Warnf("UpdatePlayerElement error:%v", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) GetPlayerBaseInfo(args *model.GetPlayerBaseInfoArgs, ret *model.PlayerBaseInfo) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
err = cplayerdata.Find(bson.M{"snid": args.SnId, "platform": &args.Plt}).One(ret)
|
|
if err != nil && err != mgo.ErrNotFound {
|
|
logger.Logger.Error("svc.GetPlayerBaseInfo is error: ", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) SetBlackWhiteLevel(args *model.BlackWhiteLevel, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
cond := bson.M{"snid": args.SnId}
|
|
if args.Platform != "" {
|
|
cond["platform"] = args.Platform
|
|
}
|
|
err = cplayerdata.Update(cond, bson.D{{"$set", bson.D{{"wblevel", args.WBLevel},
|
|
{"wbcointotalin", args.WbCoinTotalIn},
|
|
{"wbcointotalout", args.WbCoinTotalOut}, {"wbcoinlimit", args.WbCoinLimit},
|
|
{"wbtime", args.T}, {"wbmaxnum", args.WbMaxNum}, {"wbstate", args.WbState}}}})
|
|
if err != nil {
|
|
logger.Logger.Info("SetBlackWhiteLevel error ", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) SetBlackWhiteLevelUnReset(args *model.BlackWhiteLevel, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
cond := bson.M{"snid": args.SnId}
|
|
err = cplayerdata.Update(cond, bson.D{{"$set", bson.D{{"wblevel", args.WBLevel},
|
|
{"wbcoinlimit", args.WbCoinLimit},
|
|
{"wbtime", args.T}, {"wbmaxnum", args.WbMaxNum}, {"wbstate", args.WbState}}}})
|
|
if err != nil {
|
|
logger.Logger.Info("SetBlackWhiteLevel error ", err)
|
|
return
|
|
}
|
|
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) UpdateAllPlayerPackageTag(args *model.UpdatePackageId, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.PlatformStr)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
|
|
info, err := cplayerdata.UpdateAll(bson.M{"packageid": args.PackageTag}, bson.D{{"$set",
|
|
bson.D{{"platform", args.PlatformStr}, {"channel", args.ChannelStr},
|
|
{"beunderagentcode", args.PromoterStr}, {"promotertree", args.PromoterTree}}}})
|
|
if err != nil {
|
|
logger.Logger.Info("svc.UpdateAllPlayerPackageTag error ", err)
|
|
return
|
|
}
|
|
logger.Logger.Info("svc.UpdateAllPlayerPackageTag result:", info)
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) SetVipLevel(args *model.SetPlayerAtt, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
cond := bson.M{"snid": args.SnId}
|
|
err = cplayerdata.Update(cond, bson.D{{"$set", bson.D{{"forcevip", args.VipLevel},
|
|
{"vip", args.VipLevel}}}})
|
|
if err != nil {
|
|
logger.Logger.Info("SetVipLevel error ", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) SetGMLevel(args *model.SetPlayerAtt, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
cond := bson.M{"snid": args.SnId}
|
|
err = cplayerdata.Update(cond, bson.D{{"$set", bson.D{{"gmlevel", args.GmLevel}}}})
|
|
if err != nil {
|
|
logger.Logger.Info("SetGMLevel error ", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) GetSameIpPlayer(args *model.GetSameParamPlayerArgs, ret *[]int32) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
|
|
//临时结构
|
|
var t []struct {
|
|
SnId int32
|
|
}
|
|
err = cplayerdata.Find(bson.M{"ip": args.Param}).Select(bson.M{"snid": 1}).All(&t)
|
|
if err != nil {
|
|
logger.Logger.Error("svc.GetSameIpPlayer is error", err)
|
|
return
|
|
}
|
|
for _, v := range t {
|
|
*ret = append(*ret, v.SnId)
|
|
}
|
|
|
|
fmt.Println("GetSameIpPlayer....", ret)
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) GetSameBankNamePlayer(args *model.GetSameParamPlayerArgs, ret *[]int32) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
//临时结构
|
|
var t []struct {
|
|
SnId int32
|
|
}
|
|
err = cplayerdata.Find(bson.M{"bankaccname": args.Param}).Select(bson.M{"snid": 1}).All(&t)
|
|
if err != nil {
|
|
logger.Logger.Error("svc.GetSameBankNamePlayer is error", err)
|
|
return
|
|
}
|
|
|
|
for _, value := range t {
|
|
*ret = append(*ret, value.SnId)
|
|
}
|
|
return
|
|
}
|
|
func (svc *PlayerDataSvc) GetSameBankCardPlayer(args *model.GetSameParamPlayerArgs, ret *[]int32) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Plt)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
//临时结构
|
|
var t []struct {
|
|
SnId int32
|
|
}
|
|
err = cplayerdata.Find(bson.M{"bankaccount": args.Param}).Select(bson.M{"snid": 1}).All(&t)
|
|
if err != nil {
|
|
logger.Logger.Error("svc.GetSameBankCardPlayer is error", err)
|
|
return
|
|
}
|
|
|
|
for _, value := range t {
|
|
*ret = append(*ret, value.SnId)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) GetRobotPlayers(limit int, ret *[]*model.PlayerData) (err error) {
|
|
cplayerdata := PlayerDataCollection(mongo.G_P)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
data := make([]*model.PlayerData, 0, limit)
|
|
err = cplayerdata.Find(bson.M{"isrob": true}).Limit(limit).All(&ret)
|
|
if err != nil {
|
|
logger.Logger.Error("svc.GetRobotPlayers is error", err)
|
|
return
|
|
}
|
|
|
|
*ret = data
|
|
return
|
|
}
|
|
|
|
/*
|
|
* 保存玩家的删除备份全部信息
|
|
*/
|
|
func (svc *PlayerDelBackupDataSvc) SaveDelBackupPlayerData(pd *model.PlayerData, ret *bool) (err error) {
|
|
tPlayerDelBackup := PlayerDelBackupDataCollection(pd.Platform)
|
|
if tPlayerDelBackup == nil {
|
|
return nil
|
|
}
|
|
if pd != nil {
|
|
model.RecalcuPlayerCheckSum(pd)
|
|
_, err = tPlayerDelBackup.UpsertId(pd.Id, pd)
|
|
if err != nil {
|
|
logger.Logger.Errorf("svc.SaveDelBackupPlayerData %v err:%v", pd.SnId, err)
|
|
return
|
|
}
|
|
*ret = true
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDelBackupDataSvc) GetPlayerData(req *model.PlayerIsExistBySnIdArgs, ret *model.PlayerData) error {
|
|
tPlayerDelBackup := PlayerDelBackupDataCollection(req.Plt)
|
|
if tPlayerDelBackup == nil {
|
|
return nil
|
|
}
|
|
return tPlayerDelBackup.Find(bson.M{"snid": req.SnId}).One(ret)
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) SetLogicLevel(args *model.LogicInfoArg, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return
|
|
}
|
|
cond := bson.M{"snid": bson.M{"$in": args.SnIds}}
|
|
var info *mgo.ChangeInfo
|
|
if args.LogicLevel == 0 { //清空所有分层信息
|
|
info, err = cplayerdata.UpdateAll(cond, bson.D{{"$set", bson.D{{"logiclevels", []int32{}}}}})
|
|
} else {
|
|
info, err = cplayerdata.UpdateAll(cond, bson.D{{"$addToSet", bson.D{{"logiclevels", args.LogicLevel}}}})
|
|
}
|
|
if err != nil {
|
|
logger.Logger.Error("SetLogicLevel error ", err)
|
|
return
|
|
}
|
|
*ret = true
|
|
logger.Logger.Tracef("SetLogicLevel UpdataAll:%#v", info)
|
|
return
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) ClrLogicLevel(args *model.LogicInfoArg, ret *bool) (err error) {
|
|
cplayerdata := PlayerDataCollection(args.Platform)
|
|
if cplayerdata == nil {
|
|
return nil
|
|
}
|
|
cond := bson.M{"snid": bson.M{"$in": args.SnIds}}
|
|
info, err := cplayerdata.UpdateAll(cond, bson.D{{"$pull", bson.D{{"logiclevels", args.LogicLevel}}}})
|
|
if err != nil {
|
|
logger.Logger.Error("ClrLogicLevel error ", err)
|
|
return err
|
|
}
|
|
*ret = true
|
|
logger.Logger.Tracef("ClrLogicLevel UpdataAll:%#v", info)
|
|
return nil
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) GetPlayerInviteSnid(req *model.PlayerIsExistBySnIdArgs, resp *int32) error {
|
|
c := PlayerDataCollection(req.Plt)
|
|
if c == nil {
|
|
return PlayerColError
|
|
}
|
|
|
|
type t struct {
|
|
PSnId int32
|
|
}
|
|
|
|
res := &t{}
|
|
|
|
err := c.Find(bson.M{"snid": req.SnId}).Select(bson.M{"psnid": 1}).One(res)
|
|
if err != nil && !errors.Is(err, mgo.ErrNotFound) {
|
|
return err
|
|
}
|
|
|
|
*resp = res.PSnId
|
|
|
|
return nil
|
|
}
|
|
|
|
func (svc *PlayerDataSvc) BindInviteSnId(args *model.BindArgs, ret *bool) error {
|
|
err := BindInviteSnId(args.Platform, args.SnId, args.PSnId, args.PCode)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*ret = true
|
|
return nil
|
|
}
|
|
|
|
func BindInviteSnId(platform string, snId, inviteSnId int32, code string) error {
|
|
c := PlayerDataCollection(platform)
|
|
if c == nil {
|
|
return PlayerColError
|
|
}
|
|
|
|
err := c.Update(bson.M{"snid": snId}, bson.M{"$set": bson.M{"psnid": inviteSnId, "pcode": code}})
|
|
if err != nil {
|
|
logger.Logger.Error("BindInviteSnId error ", err)
|
|
return err
|
|
}
|
|
err = c.Update(bson.M{"snid": inviteSnId}, bson.M{"$inc": bson.M{"inum": 1}})
|
|
if err != nil {
|
|
logger.Logger.Error("BindInviteSnId error ", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ClearInviteScore(platform string, snId int32, now time.Time) error {
|
|
c := PlayerDataCollection(platform)
|
|
if c == nil {
|
|
return PlayerColError
|
|
}
|
|
|
|
err := c.Update(bson.M{"snid": snId}, bson.M{"$set": bson.M{"iscore": 0, "iscorets": now}})
|
|
if err != nil {
|
|
logger.Logger.Error("ClearInviteScore error ", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func AddInviteScore(client *newMongo.Client, sc newMongo.SessionContext, platform string, psnId, snid, level, tp int32, num, rate, money int64, now time.Time, addMoney bool) error {
|
|
logger.Logger.Tracef("AddInviteScore ==> platform %v, psnId %v, snid %v, level %v, tp %v, num %v, rate %v, money %v, now %v, addMoney %v",
|
|
platform, psnId, snid, level, tp, num, rate, money, now, addMoney)
|
|
|
|
inviteCfg, b := mongo.MgoSessionMgrSington.GetCfg(platform, InviteScoreDBName)
|
|
if !b {
|
|
return InviteScoreColError
|
|
}
|
|
inviteC := client.Database(inviteCfg.Database).Collection(InviteScoreCollName)
|
|
if inviteC == nil {
|
|
return InviteScoreColError
|
|
}
|
|
playerCfg, b := mongo.MgoSessionMgrSington.GetCfg(platform, PlayerDBName)
|
|
if !b {
|
|
return PlayerColError
|
|
}
|
|
playerC := client.Database(playerCfg.Database).Collection(PlayerCollName)
|
|
if playerC == nil {
|
|
return PlayerColError
|
|
}
|
|
rankCfg, b := mongo.MgoSessionMgrSington.GetCfg(platform, RankInviteDBName)
|
|
if !b {
|
|
return RankDataDBErr
|
|
}
|
|
rankC := client.Database(rankCfg.Database).Collection(RankInviteCollName)
|
|
if rankC == nil {
|
|
return RankDataDBErr
|
|
}
|
|
|
|
// 积分变更记录
|
|
_, err := inviteC.InsertOne(sc, &model.NInviteScore{
|
|
UpSnid: psnId,
|
|
DownSnid: snid,
|
|
Level: level,
|
|
Tp: tp,
|
|
Rate: rate,
|
|
Score: num,
|
|
Money: money,
|
|
Ts: now.Unix(),
|
|
})
|
|
if err != nil {
|
|
logger.Logger.Error("AddInviteScore LogInviteScore error ", err)
|
|
return err
|
|
}
|
|
|
|
// 玩家积分和绑定数量
|
|
type m struct {
|
|
IScore int64
|
|
INum int64
|
|
}
|
|
res := &m{}
|
|
err = playerC.FindOne(sc, newBson.M{"snid": psnId}).Decode(res)
|
|
if err != nil {
|
|
logger.Logger.Error("AddInviteScore find error ", err)
|
|
return err
|
|
}
|
|
|
|
// 修改玩家积分
|
|
myMoney := money
|
|
if !addMoney {
|
|
myMoney = 0
|
|
}
|
|
|
|
//addNum := int64(0)
|
|
//if level == 0 && tp == common.InviteScoreTypeBind {
|
|
// addNum = 1
|
|
//}
|
|
|
|
_, err = playerC.UpdateOne(sc, newBson.M{"snid": psnId}, newBson.M{"$inc": bson.M{"iscore": num, "imoney": myMoney}, "$set": bson.M{"iscorets": now}})
|
|
if err != nil {
|
|
logger.Logger.Error("AddInviteScore error ", err)
|
|
return err
|
|
}
|
|
|
|
// 更新排行榜
|
|
data := model.RankInvite{
|
|
Platform: platform,
|
|
SnId: psnId,
|
|
Num: res.INum,
|
|
Score: res.IScore + num,
|
|
Ts: now.Unix(),
|
|
Week: common.GetWeekStartTs(now.Unix()),
|
|
}
|
|
_, err = rankC.UpdateOne(sc, newBson.M{"snid": psnId, "week": data.Week}, newBson.M{"$set": data}, options.Update().SetUpsert(true))
|
|
if err != nil {
|
|
logger.Logger.Tracef("SaveRankInvite error:%v", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func GetInviteData(platform string, snId int32) (iscore, inum, imoney int64, iscorets time.Time, err error) {
|
|
c := PlayerDataCollection(platform)
|
|
if c == nil {
|
|
err = PlayerColError
|
|
return
|
|
}
|
|
type M struct {
|
|
IScore, Imoney, Inum int64
|
|
IScoreTs time.Time
|
|
}
|
|
res := &M{}
|
|
err = c.Find(bson.M{"snid": snId}).Select(bson.M{"iscore": 1, "inum": 1, "imoney": 1, "iscorets": 1}).One(res)
|
|
if err != nil && !errors.Is(err, mgo.ErrNotFound) {
|
|
return
|
|
}
|
|
res.IScoreTs = res.IScoreTs.Local()
|
|
return res.IScore, res.Inum, res.Imoney, res.IScoreTs, nil
|
|
}
|
|
|
|
func GetPSnId(platform string, snId int32) (psnId int32, err error) {
|
|
c := PlayerDataCollection(platform)
|
|
if c == nil {
|
|
err = PlayerColError
|
|
return
|
|
}
|
|
type M struct {
|
|
PSnId int32
|
|
}
|
|
res := &M{}
|
|
err = c.Find(bson.M{"snid": snId}).Select(bson.M{"psnid": 1}).One(res)
|
|
if err != nil && !errors.Is(err, mgo.ErrNotFound) {
|
|
return 0, err
|
|
}
|
|
return res.PSnId, nil
|
|
}
|
|
|
|
func CorrectData(pd *model.PlayerData) bool {
|
|
//var coinTotal int64
|
|
dirty := false
|
|
//金币冲账
|
|
//coinlogs, err := GetCoinWALBySnidAndCoinTypeAndGreaterTs(pd.Platform, pd.SnId, PayCoinLogType_Coin, pd.CoinPayTs)
|
|
//if err == nil && len(coinlogs) != 0 {
|
|
// oldTs := pd.CoinPayTs
|
|
// oldCoin := pd.Coin
|
|
// var cnt int64
|
|
//
|
|
// for i := 0; i < len(coinlogs); i++ {
|
|
// cnt = coinlogs[i].Count
|
|
// pd.Coin += cnt
|
|
// coinTotal += cnt
|
|
//
|
|
// if coinlogs[i].LogType == common.GainWay_ShopBuy {
|
|
// pd.CoinPayTotal += cnt
|
|
// if pd.TodayGameData == nil {
|
|
// pd.TodayGameData = model.NewPlayerGameCtrlData()
|
|
// }
|
|
// pd.TodayGameData.RechargeCoin += cnt //累加当天充值金额
|
|
// }
|
|
// if coinlogs[i].Ts > pd.CoinPayTs {
|
|
// pd.CoinPayTs = coinlogs[i].Ts
|
|
// }
|
|
// dirty = true
|
|
// }
|
|
//
|
|
// newTs := pd.CoinPayTs
|
|
// newCoin := pd.Coin
|
|
// logger.Logger.Warnf("PlayerData(%v) CorrectData before:CoinPayTs=%v before:Coin=%v after:CoinPayTs=%v after:Coin=%v", pd.SnId, oldTs, oldCoin, newTs, newCoin)
|
|
//}
|
|
////保险箱冲账
|
|
//boxCoinLogs, err := GetCoinWALBySnidAndCoinTypeAndGreaterTs(pd.Platform, pd.SnId, PayCoinLogType_SafeBoxCoin, pd.SafeBoxCoinTs)
|
|
//if err == nil && len(boxCoinLogs) != 0 {
|
|
// oldTs := pd.SafeBoxCoinTs
|
|
// oldCoin := pd.SafeBoxCoin
|
|
// for i := 0; i < len(boxCoinLogs); i++ {
|
|
// pd.SafeBoxCoin += boxCoinLogs[i].Count
|
|
// coinTotal += boxCoinLogs[i].Count
|
|
// if boxCoinLogs[i].LogType == common.GainWay_ShopBuy {
|
|
// pd.CoinPayTotal += boxCoinLogs[i].Count
|
|
// if pd.TodayGameData == nil {
|
|
// pd.TodayGameData = model.NewPlayerGameCtrlData()
|
|
// }
|
|
// pd.TodayGameData.RechargeCoin += boxCoinLogs[i].Count //累加当天充值金额
|
|
// }
|
|
// if boxCoinLogs[i].Ts > pd.SafeBoxCoinTs {
|
|
// pd.SafeBoxCoinTs = boxCoinLogs[i].Ts
|
|
// }
|
|
// dirty = true
|
|
// }
|
|
//
|
|
// newTs := pd.SafeBoxCoinTs
|
|
// newCoin := pd.SafeBoxCoin
|
|
// logger.Logger.Warnf("PlayerData(%v) CorrectData before:SafeBoxCoinTs=%v before:SafeBoxCoin=%v after:SafeBoxCoinTs=%v after:SafeBoxCoin=%v", pd.SnId, oldTs, oldCoin, newTs, newCoin)
|
|
//}
|
|
//
|
|
////比赛入场券冲账
|
|
//ticketLogs, err := GetCoinWALBySnidAndCoinTypeAndGreaterTs(pd.Platform, pd.SnId, PayCoinLogType_Ticket, pd.TicketPayTs)
|
|
//if err == nil && len(ticketLogs) != 0 {
|
|
// oldTs := pd.TicketPayTs
|
|
// oldTicket := pd.Ticket
|
|
// for i := 0; i < len(ticketLogs); i++ {
|
|
// pd.Ticket += ticketLogs[i].Count
|
|
// pd.TicketTotal += ticketLogs[i].Count
|
|
// if ticketLogs[i].Ts > pd.TicketPayTs {
|
|
// pd.TicketPayTs = ticketLogs[i].Ts
|
|
// }
|
|
// dirty = true
|
|
// }
|
|
//
|
|
// newTs := pd.TicketPayTs
|
|
// newTicket := pd.Ticket
|
|
// logger.Logger.Warnf("PlayerData(%v) CorrectData before:TicketPayTs=%v before:Ticket=%v after:TicketPayTs=%v after:Ticket=%v", pd.SnId, oldTs, oldTicket, newTs, newTicket)
|
|
//}
|
|
|
|
//同步游服丢失的金币变化
|
|
if SyncGameCoin(pd, 0, pd.GameCoinTs) {
|
|
dirty = true
|
|
}
|
|
//确保金币不小于0
|
|
if pd.Coin < 0 {
|
|
logger.Logger.Warnf("PlayerData(%v) CorrectData found pd.Coin<0(%v)", pd.SnId, pd.Coin)
|
|
if pd.SafeBoxCoin > 0 {
|
|
pd.SafeBoxCoin += pd.Coin
|
|
if pd.SafeBoxCoin < 0 {
|
|
logger.Logger.Warnf("PlayerData(%v) CorrectData found pd.SafeBoxCoin<0(%v)", pd.SnId, pd.SafeBoxCoin)
|
|
pd.SafeBoxCoin = 0
|
|
}
|
|
}
|
|
pd.Coin = 0
|
|
dirty = true
|
|
}
|
|
|
|
if dirty {
|
|
SavePlayerData(pd)
|
|
}
|
|
|
|
return dirty
|
|
}
|
|
|
|
func SyncGameCoin(pd *model.PlayerData, sceneid int, enterts int64) bool {
|
|
dirty := false
|
|
//游服金币冲账
|
|
endts := time.Now().UnixNano()
|
|
gamecoinlogs, err := GetCoinWALBySnidAndInGameAndGreaterTs(pd.Platform, pd.SnId, int32(sceneid), enterts)
|
|
if err == nil && len(gamecoinlogs) != 0 {
|
|
oldCoin := pd.Coin
|
|
var cnt int64
|
|
for i := 0; i < len(gamecoinlogs); i++ {
|
|
ts := gamecoinlogs[i].Ts
|
|
if ts >= enterts && ts <= endts {
|
|
cnt = gamecoinlogs[i].Count
|
|
pd.Coin += cnt
|
|
if ts > pd.GameCoinTs {
|
|
pd.GameCoinTs = ts
|
|
}
|
|
dirty = true
|
|
}
|
|
}
|
|
|
|
newCoin := pd.Coin
|
|
newTs := pd.GameCoinTs
|
|
logger.Logger.Warnf("PlayerData(%v) SyncGameCoin before:enterts=%v before:Coin=%v after:GameCoinTs=%v after:Coin=%v", pd.SnId, enterts, oldCoin, newTs, newCoin)
|
|
}
|
|
return dirty
|
|
}
|
|
|
|
func init() {
|
|
rpc.Register(&PlayerDataSvc{})
|
|
rpc.Register(&PlayerDelBackupDataSvc{})
|
|
}
|