package main

import (
	"crypto/md5"
	"encoding/hex"
	"errors"
	"fmt"
	"io"
	"reflect"
	"slices"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/etcd"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
	"mongo.games.com/goserver/core/task"
	"mongo.games.com/goserver/core/transact"

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/mq"
	"mongo.games.com/game/proto"
	"mongo.games.com/game/protocol/bag"
	loginproto "mongo.games.com/game/protocol/login"
	playerproto "mongo.games.com/game/protocol/player"
	"mongo.games.com/game/protocol/server"
	"mongo.games.com/game/protocol/shop"
	webapiproto "mongo.games.com/game/protocol/webapi"
	"mongo.games.com/game/srvdata"
	"mongo.games.com/game/webapi"
)

const (
	WebAPITransactParam_Path = iota
	WebAPITransactParam_CreateTime
)

func init() {
	transact.RegisteHandler(common.TransTypeWebApi, &WebAPITranscateHandler{})
}

var WebAPIHandlerMgrSingleton = &WebAPIHandlerMgr{wshMap: make(map[string]WebAPIHandler)}

type WebAPITranscateHandler struct {
}

var WebAPIStats = make(map[string]*model.APITransactStats)

// 返利配置
//type RebateInfos struct {
//	Platform           string                //平台名称
//	RebateSwitch       bool                  //返利开关
//	RebateManState     int                   //返利是开启个人返利  0 关闭  1 开启
//	ReceiveMode        int                   //领取方式  0实时领取  1次日领取
//	NotGiveOverdue     int                   //0不过期   1过期不给  2过期邮件给
//	RebateGameCfg      []*RebateGameCfg      //key为"gameid"+"gamemode"
//	RebateGameThirdCfg []*RebateGameThirdCfg //第三方key
//	Version            int                   //活动版本 后台控制
//}

func (this *WebAPITranscateHandler) OnExcute(tNode *transact.TransNode, ud interface{}) transact.TransExeResult {
	logger.Logger.Trace("WebAPITranscateHandler.OnExcute ")
	req := &common.M2GWebApiRequest{}
	err := netlib.UnmarshalPacketNoPackId(ud.([]byte), req)
	if err == nil {
		wsh := WebAPIHandlerMgrSingleton.GetWebAPIHandler(req.Path)
		if wsh == nil {
			logger.Logger.Trace("WebAPITranscateHandler no registe WebAPIHandler ", req.Path)
			return transact.TransExeResult_Failed
		}

		tNode.TransEnv.SetField(WebAPITransactParam_Path, req.Path)
		tNode.TransEnv.SetField(WebAPITransactParam_CreateTime, time.Now())

		tag, msg := wsh.Handler(tNode, req.Body)
		tNode.TransRep.RetFiels = msg
		switch tag {
		case common.ResponseTag_Ok:
			return transact.TransExeResult_Success
		case common.ResponseTag_TransactYield:
			return transact.TransExeResult_Yield
		}
	}
	logger.Logger.Trace("WebAPITranscateHandler.OnExcute err:", err)
	return transact.TransExeResult_Failed
}

func (this *WebAPITranscateHandler) OnCommit(tNode *transact.TransNode) transact.TransExeResult {
	logger.Logger.Trace("WebAPITranscateHandler.OnCommit ")
	paramPath := tNode.TransEnv.GetField(WebAPITransactParam_Path)
	paramCreateTime := tNode.TransEnv.GetField(WebAPITransactParam_CreateTime)
	if path, ok := paramPath.(string); ok {
		var stats *model.APITransactStats
		var exist bool
		if stats, exist = WebAPIStats[path]; !exist {
			stats = &model.APITransactStats{}
			WebAPIStats[path] = stats
		}

		if stats != nil {
			stats.RunTimes++
			runingTime := int64(time.Now().Sub(paramCreateTime.(time.Time)) / time.Millisecond)
			if runingTime > stats.MaxRuningTime {
				stats.MaxRuningTime = runingTime
			}
			stats.TotalRuningTime += runingTime
			stats.SuccessTimes++
		}
	}
	return transact.TransExeResult_Success
}

func (this *WebAPITranscateHandler) OnRollBack(tNode *transact.TransNode) transact.TransExeResult {
	logger.Logger.Trace("WebAPITranscateHandler.OnRollBack ")
	paramPath := tNode.TransEnv.GetField(WebAPITransactParam_Path)
	paramCreateTime := tNode.TransEnv.GetField(WebAPITransactParam_CreateTime)
	if path, ok := paramPath.(string); ok {
		var stats *model.APITransactStats
		var exist bool
		if stats, exist = WebAPIStats[path]; !exist {
			stats = &model.APITransactStats{}
			WebAPIStats[path] = stats
		}

		if stats != nil {
			stats.RunTimes++
			runingTime := int64(time.Now().Sub(paramCreateTime.(time.Time)) / time.Millisecond)
			if runingTime > stats.MaxRuningTime {
				stats.MaxRuningTime = runingTime
			}
			stats.TotalRuningTime += runingTime
			stats.FailedTimes++
		}
	}
	return transact.TransExeResult_Success
}

func (this *WebAPITranscateHandler) OnChildTransRep(tNode *transact.TransNode, hChild transact.TransNodeID, retCode int,
	ud interface{}) transact.TransExeResult {
	logger.Logger.Trace("WebAPITranscateHandler.OnChildTransRep ")
	return transact.TransExeResult_Success
}

type WebAPIHandler interface {
	Handler(*transact.TransNode, []byte) (int, proto.Message)
}

type WebAPIHandlerWrapper func(*transact.TransNode, []byte) (int, proto.Message)

func (wshw WebAPIHandlerWrapper) Handler(tNode *transact.TransNode, params []byte) (int, proto.Message) {
	return wshw(tNode, params)
}

type WebAPIHandlerMgr struct {
	wshMap       map[string]WebAPIHandler
	DataWaitList sync.Map
}

func (this *WebAPIHandlerMgr) RegisteWebAPIHandler(name string, wsh WebAPIHandler) {
	this.wshMap[name] = wsh
}

func (this *WebAPIHandlerMgr) GetWebAPIHandler(name string) WebAPIHandler {
	if wsh, exist := this.wshMap[name]; exist {
		return wsh
	}
	return nil
}

func init() {
	// 后台加币加钻石
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/AddCoinByIdAndPT", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAAddCoinByIdAndPT{}
			msg := &webapiproto.ASAddCoinByIdAndPT{}
			err1 := proto.Unmarshal(params, msg)
			if err1 != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err1.Error()
				return common.ResponseTag_ParamError, pack
			}
			member_snid := msg.GetID()
			billNo := int(msg.GetBillNo())
			platform := msg.GetPlatform()

			if CacheDataMgr.CacheBillCheck(billNo, platform) {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "Bill number repeated!"
				return common.ResponseTag_ParamError, pack
			}
			CacheDataMgr.CacheBillNumber(billNo, platform) //防止手抖点两下
			player := PlayerMgrSington.GetPlayerBySnId(member_snid)

			var remainNum int64
			var addcoin, diamond int64 = msg.GetGold(), 0
			var logtype = int32(common.GainWay_API_AddCoin)
			if msg.GetLogType() == 1 {
				addcoin = 0
				diamond = msg.GetGold()
			}
			money := msg.Money
			//玩家在线
			if player != nil {
				if msg.GetLogType() == 1 {
					remainNum = player.Diamond
				} else {
					remainNum = player.Coin
				}
				//玩家在游戏内
				if player.scene != nil {
					CacheDataMgr.ClearCacheBill(billNo, platform)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "Unsupported!!! because player in scene!"
					return common.ResponseTag_ParamError, pack
				}
				if len(platform) > 0 && player.Platform != platform {
					CacheDataMgr.ClearCacheBill(billNo, platform)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "player platform forbit!"
					return common.ResponseTag_ParamError, pack
				}
				if player.Coin+addcoin < 0 || player.Diamond+diamond < 0 {
					CacheDataMgr.ClearCacheBill(billNo, platform)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "coin not enough!"
					return common.ResponseTag_ParamError, pack
				}
				//增加帐变记录
				coinlogex := model.NewCoinLogEx(&model.CoinLogParam{
					Platform:   player.Platform,
					SnID:       player.SnId,
					Channel:    player.Channel,
					ChangeType: msg.GetLogType(),
					ChangeNum:  msg.GetGold(),
					RemainNum:  remainNum + msg.GetGold(),
					Add:        0,
					LogType:    logtype,
					GameID:     0,
					GameFreeID: 0,
					BaseCoin:   0,
					Operator:   msg.GetOper(),
					Remark:     msg.GetDesc(),
				})
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					err := model.InsertCoinLog(coinlogex)
					if err != nil {
						//回滚到对账日志
						model.RemoveCoinLogOne(platform, coinlogex.LogId)
						logger.Logger.Errorf("model.InsertCoinLogs err:%v log:%v", err, coinlogex)
						return err
					}
					return nil
				}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
					CacheDataMgr.ClearCacheBill(billNo, platform)
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "success."
					if data != nil {
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = data.(error).Error()
					} else {
						player.Coin += addcoin
						player.Diamond += diamond
						if addcoin+diamond > 0 {
							player.UpdateShopID(msg.GetShopId())
						}
						if money > 0 {
							player.AddMoneyPayTotal(money)
							TaskSubjectSingleton.Touch(common.TaskTypePay, &TaskData{
								SnId: player.SnId,
								Num:  money,
							})
							InviteTask(msg.Platform, player.PSnId, player.SnId, common.InviteScoreTypePay, money)
						}
						player.SendDiffData()
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				}), "AddCoinByIdAndPT").Start()
			} else {
				//玩家不在线
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					findPlayer, _ := model.GetPlayerDataBySnId(platform, int32(member_snid), false, true)
					if findPlayer != nil {
						if len(platform) > 0 && findPlayer.Platform != platform {
							CacheDataMgr.ClearCacheBill(billNo, platform)
							pack.Msg = "player platform forbit!"
							return nil
						}
						if findPlayer.Coin+addcoin < 0 || findPlayer.Diamond+diamond < 0 {
							CacheDataMgr.ClearCacheBill(billNo, platform)
							pack.Msg = "coin not enough!"
							return nil
						}

						// 首次购买现金商品，获得翻倍;标记商品已经购买过
						if addcoin+diamond > 0 {
							if m := ShopMgrSington.GetConfig(platform).ShopInfos; m != nil {
								if shopInfo, ok := m[msg.GetShopId()]; ok && shopInfo != nil {
									if shopInfo.FirstSwitch {
										if !slices.Contains(findPlayer.ShopID, int(msg.GetShopId())) {
											findPlayer.ShopID = append(findPlayer.ShopID, int(msg.GetShopId()))
										}
									}
								}
							}
						}

						if msg.GetLogType() == 1 {
							remainNum = findPlayer.Diamond
						} else {
							remainNum = findPlayer.Coin
						}

						//增加帐变记录
						coinlogex := model.NewCoinLogEx(&model.CoinLogParam{
							Platform:   findPlayer.Platform,
							SnID:       findPlayer.SnId,
							Channel:    findPlayer.Channel,
							ChangeType: msg.GetLogType(),
							ChangeNum:  msg.GetGold(),
							RemainNum:  remainNum + msg.GetGold(),
							Add:        0,
							LogType:    logtype,
							GameID:     0,
							GameFreeID: 0,
							BaseCoin:   0,
							Operator:   msg.GetOper(),
							Remark:     msg.GetDesc(),
						})

						err := model.UpdatePlayerCoin(findPlayer.Platform, findPlayer.SnId, findPlayer.Coin+addcoin,
							findPlayer.Diamond+diamond, findPlayer.SafeBoxCoin, findPlayer.CoinPayTs, findPlayer.SafeBoxCoinTs, findPlayer.MoneyPayTotal+money, findPlayer.ShopID)
						if err != nil {
							logger.Logger.Errorf("model.UpdatePlayerCoin err:%v.", err)
							return nil
						}

						// 充值金额记录
						if money > 0 {
							err = model.InsertDbShopLog(model.NewDbShop(findPlayer.Platform, ShopPageBackend, nil, "", 0, 0, int32(money),
								0, nil, 0, "", findPlayer.SnId, 3, "后台离线加币", nil))
							if err != nil {
								logger.Logger.Errorf("model.InsertDbShopLog err:%v.", err)
								return nil
							}
							InviteTask(msg.Platform, findPlayer.PSnId, findPlayer.SnId, common.InviteScoreTypePay, money)
						}

						//账变记录
						err = model.InsertCoinLog(coinlogex)
						if err != nil {
							//回滚到对账日志
							model.RemoveCoinLogOne(platform, coinlogex.LogId)
							logger.Logger.Errorf("model.InsertCoinLogs err:%v log:%v", err, coinlogex)
							return err
						}
					}
					return findPlayer
				}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
					if data == nil {
						pack.Tag = webapiproto.TagCode_FAILED
						if pack.Msg == "" {
							pack.Msg = "Player not find."
						}
					} else {
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = "success."
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				}), "AddCoinByIdAndPT").Start()

			}

			return common.ResponseTag_TransactYield, pack
		}))

	// 后台重置游戏池
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/ResetGamePool", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAResetGamePool{}
			msg := &webapiproto.ASResetGamePool{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			if msg.GameFreeId == 0 {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "GameFreeId id zero"
				return common.ResponseTag_ParamError, pack
			}
			gs := GameSessMgrSington.GetGameSess(int(msg.ServerId))
			if gs != nil {
				msg := &server.WGResetCoinPool{
					Platform:   proto.String(msg.GetPlatform()),
					GameFreeId: proto.Int32(msg.GameFreeId),
					ServerId:   proto.Int32(msg.ServerId),
					GroupId:    proto.Int32(msg.GroupId),
					PoolType:   proto.Int32(msg.PoolType),
					Value:      proto.Int64(msg.Value),
				}
				proto.SetDefaults(msg)
				gs.Send(int(server.SSPacketID_PACKET_WG_RESETCOINPOOL), msg)
			} else {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "no find srvId"
				return common.ResponseTag_ParamError, pack
			}
			pack.Tag = webapiproto.TagCode_SUCCESS
			pack.Msg = "reset game pool success"
			return common.ResponseTag_Ok, pack
		}))

	// 更新水池
	// 修改本地缓存，修改数据库，同步到gamesrv
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/UpdateGamePool", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAUpdateGamePool{}
			msg := &webapiproto.ASUpdateGamePool{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			coinPoolSetting := msg.GetCoinPoolSetting()
			if coinPoolSetting == nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "GetCoinPoolSetting is nil"
				return common.ResponseTag_ParamError, pack
			}
			var old *model.CoinPoolSetting
			cps := model.GetCoinPoolSetting(msg.GetGameFreeId(), msg.GetServerId(), msg.GetGroupId(), msg.GetPlatform())
			if cps == nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "CoinPoolSettingDatas is nil"
				return common.ResponseTag_NoData, pack
			}
			temp := *cps
			old = &temp
			// 修改worldsrv中的水池配置
			cps.InitValue = coinPoolSetting.GetInitValue()
			cps.LowerLimit = coinPoolSetting.GetLowerLimit()
			cps.UpperLimit = coinPoolSetting.GetUpperLimit()
			cps.QuDu = coinPoolSetting.GetQuDu()
			cps.UpperOdds = coinPoolSetting.GetUpperOdds()
			cps.UpperOddsMax = coinPoolSetting.GetUpperOddsMax()
			cps.LowerOdds = coinPoolSetting.GetLowerOdds()
			cps.LowerOddsMax = coinPoolSetting.GetLowerOddsMax()
			cps.ProfitRate = coinPoolSetting.GetProfitRate()
			cps.ResetTime = coinPoolSetting.GetResetTime()
			cps.Switch = coinPoolSetting.GetSwitch()
			cps.InitNoviceValue = coinPoolSetting.GetInitNoviceValue()
			cps.CtrlRate = coinPoolSetting.GetCtrlRate()
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				// 新配置更新到user_coinpoolsetting,旧配置保存到log_coinpoolsetting
				return model.UpsertCoinPoolSetting(cps, old)
			}), task.CompleteNotifyWrapper(func(data interface{}, task task.Task) {
				if data != nil {
					logger.Logger.Errorf("model.UpsertCoinPoolSetting cps:%v err:%v", cps, data)
				}
			}), "UpsertCoinPoolSetting").Start()
			// 水池配置同步到gamesrv
			gs := GameSessMgrSington.GetGameSess(int(cps.ServerId))
			if gs != nil {
				var msg = &webapiproto.CoinPoolSetting{
					Platform:        cps.Platform,
					GroupId:         cps.GroupId,
					GameFreeId:      cps.GameFreeId,
					ServerId:        cps.ServerId,
					InitValue:       cps.InitValue,
					LowerLimit:      cps.LowerLimit,
					UpperLimit:      cps.UpperLimit,
					QuDu:            cps.QuDu,
					UpperOdds:       cps.UpperOdds,
					UpperOddsMax:    cps.UpperOddsMax,
					LowerOdds:       cps.LowerOdds,
					LowerOddsMax:    cps.LowerOddsMax,
					ProfitRate:      cps.ProfitRate,
					ResetTime:       cps.ResetTime,
					Switch:          cps.Switch,
					CtrlRate:        cps.CtrlRate,
					InitNoviceValue: cps.InitNoviceValue,
				}
				proto.SetDefaults(msg)
				gs.Send(int(server.SSPacketID_PACKET_WG_COINPOOLSETTING), msg)
			}
			pack.Tag = webapiproto.TagCode_SUCCESS
			pack.Msg = "update game pool success"
			return common.ResponseTag_Ok, pack
		}))

	//查询水池gameid
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/QueryGamePoolByGameId", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAQueryGamePoolByGameId{}
			msg := &webapiproto.ASQueryGamePoolByGameId{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			StartQueryCoinPoolTransact(tNode, msg.GetGameId(), msg.GetGameMode(), msg.GetPlatform(), msg.GetGroupId())
			return common.ResponseTag_TransactYield, nil
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Cache/GetRoom", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAGetRoom{}
			msg := &webapiproto.ASGetRoom{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			roomId := int(msg.GetSceneId())
			snid := msg.GetSnId()
			pack.Tag = webapiproto.TagCode_SUCCESS
			if roomId == 0 {
				if snid != 0 {
					p := PlayerMgrSington.GetPlayerBySnId(snid)
					if p != nil && p.scene != nil {
						roomId = p.scene.sceneId
					}
				}
			}
			s := SceneMgrSingleton.GetScene(roomId)
			if s == nil {
				pack.Msg = "no found"
				return common.ResponseTag_NoData, pack
			} else {
				gameFreeId := int32(0)
				if s.dbGameFree != nil {
					gameFreeId = s.dbGameFree.GetId()
				}
				si := &webapiproto.RoomInfo{
					Platform:   s.platform.Name,
					SceneId:    int32(s.sceneId),
					GameId:     int32(s.gameId),
					GameMode:   int32(s.gameMode),
					SceneMode:  int32(s.sceneMode),
					GroupId:    s.groupId,
					GameFreeId: gameFreeId,
					Creator:    s.creator,
					ReplayCode: s.replayCode,
					Params:     common.CopySliceInt64ToInt32(s.params),
					PlayerCnt:  int32(len(s.players) - s.robotNum),
					RobotCnt:   int32(s.robotNum),
					CreateTime: s.createTime.Unix(),
					BaseScore:  s.dbGameFree.BaseScore,
				}
				if common.IsLocalGame(s.gameId) {
					si.BaseScore = s.BaseScore
				}
				if s.starting {
					si.Start = 1
				} else {
					si.Start = 0
				}
				if s.gameSess != nil {
					si.SrvId = s.gameSess.GetSrvId()
				}
				cnt := 0
				total := len(s.players)
				robots := []int32{}
				//优先显示玩家
				for id, p := range s.players {
					if !p.IsRob || total < 10 {
						si.PlayerIds = append(si.PlayerIds, id)
						cnt++
					} else {
						robots = append(robots, id)
					}
					if cnt > 10 {
						break
					}
				}
				//不够再显示机器人
				if total > cnt && cnt < 10 && len(robots) != 0 {
					for i := 0; cnt < 10 && i < len(robots); i++ {
						si.PlayerIds = append(si.PlayerIds, robots[i])
						cnt++
						if cnt > 10 {
							break
						}
					}
				}
				pack.RoomInfo = si
			}
			return common.ResponseTag_Ok, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Cache/ListRoom", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAListRoom{}
			msg := &webapiproto.ASListRoom{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}

			pageNo := msg.GetPageNo()
			pageSize := msg.GetPageSize()
			//数据校验
			if pageNo == 0 {
				pageNo = 1
			}
			if pageSize == 0 {
				pageSize = 20
			}
			pack.Tag = webapiproto.TagCode_SUCCESS
			start := (pageNo - 1) * pageSize
			end := pageNo * pageSize
			roomList, count, roomSum := SceneMgrSingleton.MarshalAllRoom(msg.GetPlatform(), int(msg.GetGroupId()), int(msg.GetGameId()),
				int(msg.GetGameMode()), int(msg.GetClubId()), int(msg.GetRoomType()), int(msg.GetSceneId()),
				msg.GamefreeId, msg.GetSnId(), msg.GetIsCustom() == 1, msg.GetRoomConfigId(), start, end, pageSize)
			if count < pageNo {
				pageNo = 1
			}
			pack.RoomInfo = roomList
			pack.PageCount = count
			pack.PageNo = pageNo
			pack.TotalList = roomSum
			return common.ResponseTag_Ok, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Cache/DestroyRoom", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SADestroyRoom{}
			msg := &webapiproto.ASDestroyRoom{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			pack.Tag = webapiproto.TagCode_SUCCESS
			platform := msg.GetPlatform()
			if len(platform) == 0 {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "the platform is nil"
				return common.ResponseTag_ParamError, pack
			}
			switch msg.DestroyType {
			case 1: //删除所有空房间
				for _, s := range SceneMgrSingleton.scenes {
					if !s.IsPlatform(platform) {
						continue
					}
					if s != nil && !s.deleting && len(s.players) == 0 {
						logger.Logger.Warnf("WebService SpecailEmptySceneId destroyroom scene:%v", s.sceneId)
						s.SendGameDestroy(false)
					}
				}
			case 2: //删除所有未开始的房间
				for _, s := range SceneMgrSingleton.scenes {
					if !s.IsPlatform(platform) {
						continue
					}
					if s != nil && !s.deleting && !s.starting && !s.IsHundredScene() {
						logger.Logger.Warnf("WebService SpecailUnstartSceneId destroyroom scene:%v", s.sceneId)
						s.TryForceDeleteMatchInfo()
						s.SendGameDestroy(false)
					}
				}
			default: //删除指定房间
				if len(msg.SceneIds) == 0 {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "the sceneid is nil"
					return common.ResponseTag_NoFindRoom, pack
				}
				for _, sceneId := range msg.GetSceneIds() {
					s := SceneMgrSingleton.GetScene(int(sceneId))
					if s == nil {
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = "the sceneid is nil"
						return common.ResponseTag_NoFindRoom, pack
					}
					if !s.IsPlatform(platform) {
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = "the sceneid is not ower platform"
						return common.ResponseTag_NoFindRoom, pack
					}
					logger.Logger.Warnf("WebService destroyroom scene:%v", s.sceneId)
					s.TryForceDeleteMatchInfo()
					s.SendGameDestroy(false)
				}
			}
			return common.ResponseTag_Ok, pack
		}))

	///////////////////////////玩家信息///////////////////////////
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Player/PlayerData", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAGetPlayerData{}
			msg := &webapiproto.ASGetPlayerData{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			id := msg.GetID()
			platform := msg.GetPlatform()
			player := PlayerMgrSington.GetPlayerBySnId(id)
			var playerRankScore *model.PlayerRankSeason
			var playerBagInfo *model.BagInfo
			if player == nil {
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					data, _ := model.GetPlayerDataBySnId(platform, id, true, false)
					if data == nil || data.SnId == 0 {
						data = model.GetDelBackupPlayerData(platform, id)
					}
					ret, _ := model.FindPlayerRankSeason(&model.FindPlayerRankSeasonArgs{
						Platform: platform,
						Id:       []int32{id},
					})
					if len(ret.List) > 0 {
						playerRankScore = ret.List[0]
					}
					playerBagInfo, _ = model.GetBagInfo(id, platform)
					return data
				}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
					playerData, ok := data.(*model.PlayerData)
					if !ok || playerData == nil {
						pack.Msg = "no find player"
						pack.Tag = webapiproto.TagCode_FAILED
					} else {
						pack.Tag = webapiproto.TagCode_SUCCESS
						pdfw := model.ConvertPlayerDataToWebData(getPlayerDataParam(&playerDataParam{
							P:      playerData,
							Season: playerRankScore,
							Items:  playerBagInfo,
						}))

						pdfw.Online = false
						pack.PlayerData = pdfw
					}
					logger.Logger.Trace("PlayerData==>", pack)
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				}), "PlayerData").Start()
				return common.ResponseTag_TransactYield, pack
			} else {
				if len(platform) > 0 && player.Platform == platform {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pwdf := model.ConvertPlayerDataToWebData(getPlayerDataParam(&playerDataParam{player.PlayerData, nil, nil}))
					pwdf.Online = player.IsOnLine()
					if pwdf != nil {
						if player.scene != nil && player.scene.sceneId != common.DgSceneId && !player.scene.IsTestScene() {
							pwdf.Coin = player.sceneCoin
						}
					}
					pack.PlayerData = pwdf
				} else {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "no find player"
				}
				logger.Logger.Trace("PlayerData==>", pack)
				return common.ResponseTag_Ok, pack
			}
		}))
	//多个玩家数据
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Player/MorePlayerData", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAMorePlayerData{}
			msg := &webapiproto.ASMorePlayerData{}
			err := proto.Unmarshal(params, msg)
			pack.Tag = webapiproto.TagCode_FAILED
			if err != nil {
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			if len(msg.GetSnIds()) == 0 {
				pack.Msg = "IDs value error!"
				return common.ResponseTag_ParamError, pack
			}
			if len(msg.GetSnIds()) > model.GameParamData.MorePlayerLimit {
				pack.Msg = "IDs too more error!"
				return common.ResponseTag_ParamError, pack
			}
			pack.Tag = webapiproto.TagCode_SUCCESS
			var leavePlayer []int32
			var playerRankScore = map[int32]*model.PlayerRankSeason{}
			var playerItems = map[int32]*model.BagInfo{}
			for _, snid := range msg.GetSnIds() {
				player := PlayerMgrSington.GetPlayerBySnId(snid)
				if player != nil {
					pwdf := model.ConvertPlayerDataToWebData(getPlayerDataParam(&playerDataParam{player.PlayerData, nil, nil}))
					if pwdf != nil {
						pwdf.Online = true
						if player.scene != nil && player.scene.sceneId != common.DgSceneId {
							pwdf.Coin = player.sceneCoin
						}
						pack.PlayerData = append(pack.PlayerData, pwdf)
					}
				} else {
					leavePlayer = append(leavePlayer, snid)
				}
			}
			if len(leavePlayer) == 0 {
				return common.ResponseTag_Ok, pack
			}
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				ret, _ := model.FindPlayerRankSeason(&model.FindPlayerRankSeasonArgs{
					Platform: msg.GetPlatform(),
					Id:       leavePlayer,
				})
				for _, v := range ret.List {
					playerRankScore[v.SnId] = v
					//todo 优化
					items, _ := model.GetBagInfo(v.SnId, msg.GetPlatform())
					playerItems[v.SnId] = items
				}

				return model.GetPlayerDatasBySnIds(msg.Platform, leavePlayer, false)
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data != nil {
					playerDatas, _ := data.([]*model.PlayerData)
					for _, v := range playerDatas {
						pdfw := model.ConvertPlayerDataToWebData(getPlayerDataParam(&playerDataParam{v, playerRankScore[v.SnId], playerItems[v.SnId]}))
						if pdfw != nil {
							pdfw.Online = false
							pack.PlayerData = append(pack.PlayerData, pdfw)
						}
					}
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "PlayerData").Start()
			return common.ResponseTag_TransactYield, pack
		}))
	//更新玩家数据
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Cache/UpdatePlayerElement", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAUpdatePlayerElement{}
			msg := &webapiproto.ASUpdatePlayerElement{}
			uerr := proto.Unmarshal(params, msg)
			pack.Tag = webapiproto.TagCode_FAILED
			if uerr != nil {
				pack.Msg = "数据序列化失败" + uerr.Error()
				return common.ResponseTag_ParamError, pack
			}
			//简单校验接收到的数据
			if msg.SnId == 0 || len(msg.GetPlayerEleArgs()) == 0 {
				pack.Msg = "error: ID or ElementList is nil"
				return common.ResponseTag_Ok, pack
			}

			playerMap := make(map[string]interface{})
			for _, v := range msg.GetPlayerEleArgs() {
				playerMap[v.Key] = v.Val
			}
			listBan := [...]string{"Id", "SnId", "AccountId"}
			for i := 0; i < len(listBan); i++ {
				if _, exist := playerMap[listBan[i]]; exist {
					delete(playerMap, listBan[i])
				}
			}
			if len(playerMap) == 0 {
				pack.Msg = "no any data"
				return common.ResponseTag_Ok, pack
			}

			f := func(plt string, snid int32) {
				var alipayAcc, alipayAccName, bankAccount, bankAccName, channelId string
				if val, ok := playerMap["AlipayAccount"]; ok {
					if str, ok := val.(string); ok {
						alipayAcc = str
					}
				}
				if val, ok := playerMap["AlipayAccName"]; ok {
					if str, ok := val.(string); ok {
						alipayAccName = str
					}
				}
				if val, ok := playerMap["BankAccount"]; ok {
					if str, ok := val.(string); ok {
						bankAccount = str
					}
				}
				if val, ok := playerMap["BankAccName"]; ok {
					if str, ok := val.(string); ok {
						bankAccName = str
					}
				}
				if val, ok := playerMap["ChannelId"]; ok {
					if str, ok := val.(string); ok {
						channelId = str
					}
				}

				if alipayAcc != "" || alipayAccName != "" {
					task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
						model.NewBankBindLog(msg.SnId, msg.Platform, model.BankBindLogType_Ali,
							alipayAccName, alipayAcc, 2)
						return nil
					}), nil, "NewBankBindLog").Start()
				}
				if bankAccount != "" || bankAccName != "" {
					task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
						model.NewBankBindLog(msg.SnId, msg.Platform, model.BankBindLogType_Bank,
							bankAccName, bankAccount, 2)
						return nil
					}), nil, "NewBankBindLog").Start()
				}
				if channelId != "" {
					task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
						a, err := model.GetAccountBySnid(plt, snid)
						if err != nil {
							logger.Logger.Errorf("GetAccountBySnid error: %v", err)
							return nil
						}
						a.ChannelId = channelId
						if err = model.UpdateAccount(a); err != nil {
							logger.Logger.Errorf("UpdateAccount error: %v", err)
						}
						return nil
					}), nil).StartByExecutor("UpdateChannelId")
				}
			}

			pack.Tag = webapiproto.TagCode_SUCCESS
			player := PlayerMgrSington.GetPlayerBySnId(msg.SnId)
			if player != nil {
				if len(msg.Platform) > 0 && player.Platform != msg.Platform {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "Platform error."
					return common.ResponseTag_NoFindUser, pack
				} else {
					//玩家在线
					//获取玩家数据
					var pd *model.PlayerData
					pd = player.PlayerData
					SetInfo := func(u *model.PlayerData, o interface{}, playerMap map[string]interface{}) *model.PlayerData {
						t := reflect.TypeOf(o)
						v := reflect.ValueOf(o)
						s := reflect.ValueOf(u).Elem()
						for k, n := range playerMap {
							if f, ok := t.FieldByName(k); ok {
								if v.FieldByName(k).CanInterface() {
									switch f.Type.Kind() {
									case reflect.Int64, reflect.Int32:
										a, _ := strconv.ParseInt(fmt.Sprintf("%v", n), 10, 64)
										s.FieldByName(k).SetInt(a)
									case reflect.Bool:
										s.FieldByName(k).SetBool(n.(bool))
									case reflect.String:
										s.FieldByName(k).SetString(n.(string))
									default:
										logger.Logger.Warn("type not in the player !!")
									}
								}
							}
						}
						return u
					}
					pd = SetInfo(pd, *pd, playerMap)
					player.dirty = true
					player.SendDiffData()
					pack.Msg = "success"
					f(pd.Platform, pd.SnId)
					return common.ResponseTag_Ok, pack
				}
			} else {
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					//玩家不在线
					//先检测是否有玩家
					if len(msg.Platform) > 0 {
						pbi := model.GetPlayerBaseInfo(msg.Platform, msg.SnId)
						if pbi == nil {
							return errors.New("no player")
						}
					}
					//直接操作数据库
					err := model.UpdatePlayerElement(msg.Platform, msg.SnId, playerMap)
					if err == nil {
						f(msg.Platform, msg.SnId)
					} else if err != nil {
						logger.Logger.Error("UpdatePlayerElement task marshal data error:", err)
					}
					return err
				}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
					if data == nil {
						pack.Msg = "success"
					} else {
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = fmt.Sprintf("%v", data)
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				}), "UpdatePlayerElement").Start()
				return common.ResponseTag_TransactYield, pack
			}
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Player/KickPlayer", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAKickPlayer{}
			msg := &webapiproto.ASKickPlayer{}
			err := proto.Unmarshal(params, msg)
			pack.Tag = webapiproto.TagCode_FAILED
			if err != nil {
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			if msg.SnId == 0 {
				pack.Msg = "snid is zero"
				return common.ResponseTag_ParamError, pack
			}
			player := PlayerMgrSington.GetPlayerBySnId(msg.SnId)
			if player != nil {
				if msg.Platform == "" || msg.Platform != player.Platform {
					pack.Msg = "platform is dif"
					return common.ResponseTag_ParamError, pack
				}
				sid := player.sid
				endTime := time.Now().Unix() + int64(time.Minute.Seconds())*int64(msg.Minute)
				ls := LoginStateMgrSington.GetLoginStateBySid(sid)
				if ls != nil {
					if ls.als != nil && ls.als.acc != nil {
						ls.als.acc.State = endTime
					}
				}
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					return model.FreezeAccount(msg.Platform, player.AccountId, int(msg.Minute))
				}), nil, "FreezeAccount").Start()
				player.Kick(common.KickReason_Freeze)
				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = "success"
			} else {
				pack.Msg = "the player not online or no player."
			}
			return common.ResponseTag_Ok, pack
		}))
	//获取在线统计
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Report/OnlineReportTotal", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAOnlineReportTotal{}
			msg := &webapiproto.ASOnlineReportTotal{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			//inGameCnt := make(map[int]int32)
			pack.OnlineReport = &webapiproto.OnlineReport{}
			tNow := time.Now()
			for _, p := range PlayerMgrSington.players {
				if !p.IsOnLine() {
					continue
				}
				if len(msg.Platform) != 0 && msg.Platform != "0" && p.Platform != msg.Platform {
					continue
				}
				if len(msg.Channel) != 0 && p.Channel != msg.Channel {
					continue
				}
				if len(msg.Promoter) != 0 && p.BeUnderAgentCode != msg.Promoter {
					continue
				}
				pack.OnlineReport.TotalCnt++
				if p.DeviceOS == common.DeviceOS_Android {
					pack.OnlineReport.AndroidOnlineCnt++
				} else if p.DeviceOS == common.DeviceOS_IOS {
					pack.OnlineReport.IosOnlineCnt++
				}
				if p.scene == nil {
					pack.OnlineReport.DatingPlayers++
				} else {
					pack.OnlineReport.OnRoomPlayers++
					//inGameCnt[p.scene.gameId]++
				}
				if common.InSameDay(p.CreateTime, tNow) {
					pack.OnlineReport.TodayRegisterOnline++
				} else {
					if common.DiffDay(tNow, p.CreateTime) <= 7 {
						pack.OnlineReport.SevenDayRegisterOnline++
					}
				}
			}
			//var onlineGameCnt []*webapi_proto.OnlineGameCnt
			//for gameId, cnt := range inGameCnt {
			//	onlineGameCnt = append(onlineGameCnt, &webapi_proto.OnlineGameCnt{
			//		GameId: int32(gameId),
			//		Cnt:    cnt},
			//	)
			//}
			pack.Tag = webapiproto.TagCode_SUCCESS
			//pack.OnlineReport.GameCount = onlineGameCnt
			return common.ResponseTag_Ok, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Report/QueryOnlineReportList", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAQueryOnlineReportList{}
			msg := &webapiproto.ASQueryOnlineReportList{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			platform := msg.Platform
			pageNo := msg.PageNo
			pageSize := msg.PageSize
			orderColumn := msg.OrderColumn
			orderType := msg.OrderType
			channel := msg.Channel

			start := (pageNo - 1) * pageSize
			end := pageNo * pageSize
			count := len(PlayerMgrSington.players)
			if count < int(start) || count == 0 {
				pack.Tag = webapiproto.TagCode_SUCCESS
				return common.ResponseTag_Ok, pack
			}
			var players []*Player
			for _, p := range PlayerMgrSington.players {
				if !p.IsOnLine() {
					continue
				}
				if msg.GameFreeId == 0 {
					if msg.GameId != 0 && (p.scene == nil || p.scene.gameId != int(msg.GameId)) {
						continue
					}
				} else {
					if p.scene == nil || p.scene.dbGameFree.GetId() != msg.GameFreeId {
						continue
					}
				}
				if platform != DefaultPlatform && p.Platform != platform {
					continue
				}
				if channel != "" && p.Channel != channel {
					continue
				}
				players = append(players, p)
			}
			// 排序
			var sortFunc func(i, j int) bool
			switch orderColumn {
			case common.OrderColumnCoinPayTotal:
				sortFunc = func(i, j int) bool {
					if players[i].CoinPayTotal == players[j].CoinPayTotal {
						return false
					}
					return players[i].CoinPayTotal > players[j].CoinPayTotal
				}
			case common.OrderColumnCoinExchangeTotal:
				sortFunc = func(i, j int) bool {
					if players[i].CoinExchangeTotal == players[j].CoinExchangeTotal {
						return false
					}
					return players[i].CoinExchangeTotal > players[j].CoinExchangeTotal
				}
			case common.OrderColumnTaxTotal:
				sortFunc = func(i, j int) bool {
					if players[i].GameTax == players[j].GameTax {
						return false
					}
					return players[i].GameTax > players[j].GameTax
				}
			case common.OrderColumnRegisterTime:
				sortFunc = func(i, j int) bool {
					if players[i].CreateTime.Equal(players[j].CreateTime) {
						return false
					}
					return players[i].CreateTime.After(players[j].CreateTime)
				}
			case common.OrderColumnRoomNumber:
				sortFunc = func(i, j int) bool {
					a, b := players[i], players[j]
					if a.scene == nil && b.scene == nil {
						return false
					}
					if a.scene != nil && b.scene == nil {
						return true
					}
					if a.scene == nil && b.scene != nil {
						return false
					}
					if a.scene.sceneId == b.scene.sceneId {
						return false
					}
					return a.scene.sceneId > b.scene.sceneId
				}
			case common.OrderColumnLose:
				sortFunc = func(i, j int) bool {
					if players[i].FailTimes == players[j].FailTimes {
						return false
					}
					return players[i].FailTimes > players[j].FailTimes
				}
			case common.OrderColumnWin:
				sortFunc = func(i, j int) bool {
					if players[i].WinTimes == players[j].WinTimes {
						return false
					}
					return players[i].WinTimes > players[j].WinTimes
				}
			case common.OrderColumnDraw:
				sortFunc = func(i, j int) bool {
					if players[i].DrawTimes == players[j].DrawTimes {
						return false
					}
					return players[i].DrawTimes > players[j].DrawTimes
				}
			case common.OrderColumnWinCoin:
				sortFunc = func(i, j int) bool {
					if players[i].WinCoin == players[j].WinCoin {
						return false
					}
					return players[i].WinCoin > players[j].WinCoin
				}
			case common.OrderColumnLoseCoin:
				sortFunc = func(i, j int) bool {
					if players[i].FailCoin == players[j].FailCoin {
						return false
					}
					return players[i].FailCoin > players[j].FailCoin
				}
			default:
			}
			if sortFunc != nil {
				sort.Slice(players, func(i, j int) bool {
					if orderType == 0 {
						return sortFunc(i, j)
					}
					return !sortFunc(i, j)
				})
			}
			count = len(players)
			if int(end) > count {
				end = int32(count)
			}
			for i := start; i < end; i++ {
				p := players[i]
				if p != nil {
					pb := model.ConvertPlayerDataToWebData(getPlayerDataParam(&playerDataParam{p.PlayerData, nil, nil}))
					if p.scene != nil {
						pb.GameFreeId = p.scene.dbGameFree.Id
						pb.SceneId = int32(p.scene.sceneId)
					}
					pack.PlayerData = append(pack.PlayerData, pb)
				}
			}
			pack.Tag = webapiproto.TagCode_SUCCESS
			pack.PageCount = int32(count)
			pack.PageNo = pageNo
			pack.PageSize = pageSize
			return common.ResponseTag_Ok, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Player/WhiteBlackControl", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAWhiteBlackControl{}
			msg := &webapiproto.ASWhiteBlackControl{}
			err := proto.Unmarshal(params, msg)
			pack.Tag = webapiproto.TagCode_FAILED
			if err != nil {
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			//if msg.SnId == 0 {
			//	pack.Msg = "snid is zero"
			//	return common.ResponseTag_ParamError, pack
			//}
			idMap := make(map[int32]struct{})
			if msg.SnId > 0 {
				idMap[msg.SnId] = struct{}{}
			}
			for _, id := range msg.SnIds {
				idMap[id] = struct{}{}
			}
			wbCoinLimit := msg.WBCoinLimit
			maxNum := msg.MaxNum
			resetTotalCoin := msg.ResetTotalCoin
			wbState := msg.State

			tNow := time.Now()
			var errMsg interface{}
			wg := new(sync.WaitGroup)
			wg.Add(len(idMap))
			for id := range idMap {
				snid := id
				player := PlayerMgrSington.GetPlayerBySnId(snid)
				if player != nil {
					if len(msg.Platform) == 0 || player.Platform == msg.Platform {
						player.WBLevel = msg.WBLevel
						player.WBCoinLimit = wbCoinLimit
						player.WBMaxNum = maxNum
						if resetTotalCoin == 1 {
							player.WBCoinTotalIn = 0
							player.WBCoinTotalOut = 0
						}
						player.WBTime = tNow
						//出去比赛场
						if player.scene != nil && !player.scene.IsMatchScene() {
							//if !WBCtrlCfgMgr.GetRealCtrl(msg.Platform) {
							//	wbState = 0
							//}
							//同步刷到游服
							wgpack := &server.WGSetPlayerBlackLevel{
								SnId:           proto.Int(int(snid)),
								WBLevel:        proto.Int32(msg.WBLevel),
								WBCoinLimit:    proto.Int64(wbCoinLimit),
								MaxNum:         proto.Int32(maxNum),
								ResetTotalCoin: proto.Bool(resetTotalCoin != 0),
								State:          proto.Int32(wbState),
							}
							player.SendToGame(int(server.SSPacketID_PACKET_WG_SETPLAYERBLACKLEVEL), wgpack)
						}
					}
				}
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					if resetTotalCoin == 1 {
						//后台sql有统计这里屏蔽掉
						//log := model.NewBlackWhiteCoinLog(snid, msg.WBLevel, 0, int32(resetTotalCoin), msg.Platform)
						//if log != nil {
						//	model.InsertBlackWhiteCoinLog(log)
						//}
						return model.SetBlackWhiteLevel(snid, msg.WBLevel, int32(maxNum), wbState, 0, 0, wbCoinLimit, msg.Platform, tNow)
					} else {
						//后台sql有统计这里屏蔽掉
						//log := model.NewBlackWhiteCoinLog(snid, msg.WBLevel, wbCoinLimit, int32(resetTotalCoin), msg.Platform)
						//if log != nil {
						//	model.InsertBlackWhiteCoinLog(log)
						//}
						return model.SetBlackWhiteLevelUnReset(snid, msg.WBLevel, int32(maxNum), wbState, wbCoinLimit, msg.Platform, tNow)
					}
				}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
					defer wg.Done()
					if data == nil {
						delete(idMap, snid)
					} else {
						errMsg = data
					}
				}), "SetBlackWhiteLevel").Start()
			}
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				wg.Wait()
				if errMsg != nil || len(idMap) > 0 {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = fmt.Sprintf("数据库写入错误：%v , 玩家id：%v", errMsg, idMap)
				} else {
					pack.Tag = webapiproto.TagCode_SUCCESS
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
				return nil
			}), nil).Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Ctrl/ListServerStates", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAListServerStates{}
			msg := &webapiproto.ASListServerStates{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			pack.Tag = webapiproto.TagCode_SUCCESS
			pack.ServerInfo = GameSessMgrSington.ListServerState(int(msg.SrvId), int(msg.SrvType))
			return common.ResponseTag_Ok, pack
		}))

	//邮件
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/CreateShortMessage", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SACreateShortMessage{}
			msg := &webapiproto.ASCreateShortMessage{}
			err1 := proto.Unmarshal(params, msg)
			if err1 != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err1.Error()
				return common.ResponseTag_ParamError, pack
			}

			title := msg.GetNoticeTitle()
			content := msg.GetNoticeContent()
			platform := msg.GetPlatform()
			srcSnid := msg.GetSrcSnid()
			destSnid := msg.GetDestSnid()
			messageType := msg.GetMessageType()
			coin := msg.GetCoin()
			diamond := msg.GetDiamond()
			otherParams := msg.GetParams()
			showId := msg.GetShowId()
			channel := msg.GetOnChannelName()
			if destSnid > 0 {
				channel = []string{}
			}

			if messageType == model.MSGTYPE_ITEM && len(otherParams) != 0 && len(otherParams)%2 != 0 {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "otherParams is err"
				return common.ResponseTag_ParamError, pack
			}

			//由于多线程问题,次数组只能在此处和task.new 内使用,在其它地方使用会引起多线程崩溃的问题
			var onlinePlayerSnid []int32
			if destSnid == 0 {
				for _, p := range PlayerMgrSington.snidMap {
					if p.IsRob == true { //排除掉机器人
						continue
					}
					if len(channel) > 0 && !common.InSliceString(channel, p.LastChannel) { // 渠道过滤
						continue
					}
					if platform == "" || p.Platform == platform {
						onlinePlayerSnid = append(onlinePlayerSnid, p.SnId)
					}
				}
			}

			var newMsg *model.Message
			var dbMsgs []*model.Message
			var err error
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				code := loginproto.OpResultCode_OPRC_Sucess
				//如果不是群发则检查一下该用户snid是不是存在，不存在就返回，在这里不关心玩家帐变是否正确，不做校正
				if destSnid != 0 {
					playerData, _ := model.GetPlayerDataBySnId(platform, destSnid, true, false)
					if playerData == nil {
						code = loginproto.OpResultCode_OPRC_Error
						return code
					}
				}
				// var otherParams []int32

				newMsg = model.NewMessage("", int32(srcSnid), "", int32(destSnid), int32(messageType), title, content, coin, diamond,
					model.MSGSTATE_UNREAD, time.Now().Unix(), model.MSGATTACHSTATE_DEFAULT, "", common.CopySliceInt32ToInt64(otherParams), platform, showId, channel)
				if newMsg != nil {
					err := model.InsertMessage(platform, newMsg)
					if err != nil {
						code = loginproto.OpResultCode_OPRC_Error
						logger.Logger.Errorf("/api/Game/CreateShortMessage,InsertMessage err:%v title:%v content:%v platform:%v srcSnid:%v destSnid:%v messageType:%v ", err, title, content, platform, srcSnid, destSnid, messageType)
						return code
					}
				}

				if destSnid == 0 {
					for _, psnid := range onlinePlayerSnid {
						newMsg := model.NewMessage(newMsg.Id.Hex(), newMsg.SrcId, "", psnid, newMsg.MType, newMsg.Title, newMsg.Content, newMsg.Coin, newMsg.Diamond,
							newMsg.State, newMsg.CreatTs, newMsg.AttachState, newMsg.GiftId, common.CopySliceInt32ToInt64(otherParams), platform, newMsg.ShowId, channel)
						if newMsg != nil {
							dbMsgs = append(dbMsgs, newMsg)
						}
					}
					if len(dbMsgs) > 0 {
						err := model.InsertMessage(platform, dbMsgs...)
						if err != nil {
							logger.Logger.Errorf("/api/Game/CreateShortMessage,InsertMessage err:%v title:%v content:%v platform:%v srcSnid:%v destSnid:%v messageType:%v ", err, title, content, platform, srcSnid, destSnid, messageType)
						}
					}
				}
				return code
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if code, ok := data.(loginproto.OpResultCode); ok {
					if code != loginproto.OpResultCode_OPRC_Sucess {
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = ""
					} else {
						pp := PlayerMgrSington.GetPlayerBySnId(int32(destSnid))
						if pp != nil {
							//单独消息
							pp.AddMessage(newMsg)
						} else {
							if destSnid == 0 { //群发消息
								MsgMgrSington.AddMsg(newMsg)

								if len(platform) > 0 { //特定渠道消息
									for _, m := range dbMsgs {
										pp := PlayerMgrSington.GetPlayerBySnId(m.SnId)
										if pp != nil && pp.Platform == platform {
											pp.AddMessage(m)
										}
									}
								} else { //全渠道消息
									for _, m := range dbMsgs {
										pp := PlayerMgrSington.GetPlayerBySnId(m.SnId)
										if pp != nil {
											pp.AddMessage(m)
										}
									}
								}
							}
						}
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = ""
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
					if err != nil {
						logger.Logger.Error("Marshal CreateShortMessage response data error:", err)
					}
				} else {
					logger.Logger.Error("CreateShortMessage task result data covert failed.")
				}
			}), "CreateShortMessage").Start()

			return common.ResponseTag_TransactYield, pack
		}))

	//查询邮件
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/QueryShortMessageList", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAQueryShortMessageList{}
			msg := &webapiproto.ASQueryShortMessageList{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			startTime := msg.GetStartTime()
			endTime := msg.GetEndTime()
			pageNo := msg.GetPageNo()
			pageSize := msg.GetPageSize()
			messageType := msg.GetMessageType()
			platform := msg.GetPlatform()
			destSnid := msg.GetDestSnid()
			if destSnid == 0 {
				destSnid = -1
			}
			start := (pageNo - 1) * pageSize
			end := pageNo * pageSize

			var msgs []model.Message
			var count int
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				mas := &model.MsgArgs{
					Platform:  platform,
					StartTs:   startTime,
					EndTs:     endTime,
					ToIndex:   int(end),
					DestSnId:  int(destSnid),
					MsgType:   int(messageType),
					FromIndex: int(start),
				}
				retMsgs, err := model.GetMessageInRangeTsLimitByRange(mas)
				count = retMsgs.Count
				msgs = retMsgs.Msg
				return err
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data != nil {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = ""
				} else {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = ""
					pack.Count = int32(count)
					for i := 0; i < len(msgs); i++ {
						giftState := int32(0)
						mi := &webapiproto.MessageInfo{
							Id:         msgs[i].Id.Hex(),
							MType:      msgs[i].MType,
							Title:      msgs[i].Title,
							Content:    msgs[i].Content,
							State:      msgs[i].State,
							CreateTime: msgs[i].CreatTs,
							SrcSnid:    msgs[i].SrcId,
							DestSnid:   msgs[i].SnId,
							Coin:       msgs[i].Coin,
							GiftId:     msgs[i].GiftId,
							GiftState:  giftState,
							Platform:   msgs[i].Platform,
						}
						pack.MessageInfo = append(pack.MessageInfo, mi)
					}
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "QueryShortMessageList").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	//删除邮件
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/DeleteShortMessage", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SADeleteShortMessage{}
			msg := &webapiproto.ASDeleteShortMessage{}
			err1 := proto.Unmarshal(params, msg)
			if err1 != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err1.Error()
				return common.ResponseTag_ParamError, pack
			}
			msgId := msg.GetId()
			platform := msg.GetPlatform()
			if len(msgId) == 0 {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "not find msg id"
				return common.ResponseTag_ParamError, pack
			}
			var delMsg *model.Message
			var err error
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				delMsg, err = model.GetMessageById(msgId, platform)
				if err == nil {
					if len(platform) > 0 && msg.Platform != platform {
						return errors.New("Platform error.")
					}
					args := &model.DelMsgArgs{
						Platform: platform,
						Id:       delMsg.Id,
					}
					err = model.DelMessage(args) // 真删除
				}
				return err
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data != nil || delMsg == nil {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "not find msg id"
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
					return
				}
				/*if delMsg.State == model.MSGSTATE_REMOVEED {
					pack.Tag = webapi_proto.TagCode_FAILED
					pack.Msg = "repeate delete"
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
					return
				}*/
				pp := PlayerMgrSington.GetPlayerBySnId(delMsg.SnId)
				if pp != nil {
					pp.WebDelMessage(delMsg.Id.Hex())
				} else {
					MsgMgrSington.RemoveMsg(delMsg)
				}

				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = ""
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "DeleteShortMessage").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	//删除玩家已经删除的邮件
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/DeleteAllShortMessage", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SADeleteShortMessage{}
			msg := &webapiproto.ASDeleteShortMessage{}
			err1 := proto.Unmarshal(params, msg)
			if err1 != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err1.Error()
				return common.ResponseTag_ParamError, pack
			}
			platform := msg.GetPlatform()
			if len(platform) == 0 {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "platform is nil"
				return common.ResponseTag_ParamError, pack
			}
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.DelAllMessage(&model.DelAllMsgArgs{Platform: platform})
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data != nil {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "del err:" + data.(error).Error()
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
					return
				}
				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = "del success."
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "DeleteShortMessage").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	//黑名单
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Player/BlackBySnId", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SABlackBySnId{}
			msg := &webapiproto.ASBlackBySnId{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			player := PlayerMgrSington.GetPlayerBySnId(msg.SnId)
			if player != nil {
				if player.Platform != msg.Platform {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "Platform is dif"
					return common.ResponseTag_ParamError, pack
				}
				pack.Tag = webapiproto.TagCode_SUCCESS
				player.BlacklistType = msg.BlacklistType
				player.dirty = true
				player.Time2Save()
				//在线需要踢掉玩家
				if uint(msg.BlacklistType)&BlackState_Login != 0 {
					logger.Logger.Infof("found platform:%v player:%d snid in blacklist", msg.Platform, player.SnId)
					player.Kick(int32(loginproto.SSDisconnectTypeCode_SSDTC_BlackList))
				}
				return common.ResponseTag_Ok, pack
			} else {
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					data, _ := model.GetPlayerDataBySnId(msg.Platform, msg.SnId, true, false)
					if data != nil {
						model.UpdatePlayerBlacklistType(msg.Platform, msg.SnId, msg.BlacklistType)
					}
					return data
				}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
					playerData, ok := data.(*model.PlayerData)
					if !ok || playerData == nil {
						pack.Msg = "no find player"
						pack.Tag = webapiproto.TagCode_FAILED
					} else {
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = "success"
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				}), "PlayerData").Start()
				return common.ResponseTag_TransactYield, pack
			}
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Message/QueryHorseRaceLampList", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAQueryHorseRaceLampList{}
			msg := &webapiproto.ASQueryHorseRaceLampList{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			start := (msg.PageNo - 1) * msg.PageSize
			end := msg.PageNo * msg.PageSize
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				ret, erro := model.GetHorseRaceLampInRangeTsLimitByRange(msg.Platform, msg.MsgType, msg.State, start, end)
				if erro != nil {
					logger.Logger.Error("api GetNoticeInRangeTsLimitByRange is error", erro)
					return nil
				}
				return ret
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data == nil {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "no these msg"
				} else {
					noticesRet := data.(*model.QueryHorseRaceLampRet)
					if noticesRet != nil {
						var apiNoticMsgList []*webapiproto.HorseRaceLamp
						for _, notice := range noticesRet.Data {
							apiNoticeMsg := &webapiproto.HorseRaceLamp{
								Id:         notice.Id.Hex(),
								Platform:   notice.Platform,
								Title:      notice.Title,
								Content:    notice.Content,
								Footer:     notice.Footer,
								StartTime:  notice.StartTime,
								Frequency:  notice.Interval,
								State:      notice.State,
								CreateTime: notice.CreateTime,
								Count:      notice.Count,
								Priority:   notice.Priority,
								MsgType:    notice.MsgType,
								Target:     notice.Target,
								StandSec:   notice.StandSec,
							}
							apiNoticMsgList = append(apiNoticMsgList, apiNoticeMsg)
						}
						pack.PageCount = int32(noticesRet.Count)
						pack.HorseRaceLamp = apiNoticMsgList
					}
					pack.Tag = webapiproto.TagCode_SUCCESS
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
				if err != nil {
					logger.Logger.Error("Marshal notice msg list error:", err)
				}
			}), "QueryHorseRaceLampList").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	//WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Message/CreateHorseRaceLamp", WebAPIHandlerWrapper(
	//	func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
	//		pack := &webapiproto.SACreateHorseRaceLamp{}
	//		msg := &webapiproto.ASCreateHorseRaceLamp{}
	//		err := proto.Unmarshal(params, msg)
	//		if err != nil {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "数据序列化失败" + err.Error()
	//			return common.ResponseTag_ParamError, pack
	//		}
	//		platform := msg.Platform
	//		title := msg.Title
	//		content := msg.Content
	//		footer := msg.Footer
	//		count := msg.Count
	//		state := msg.State
	//		startTime := msg.StartTime
	//		priority := msg.Priority
	//		msgType := msg.MsgType
	//		standSec := msg.StandSec
	//		target := msg.Target
	//		var horseRaceLamp *model.HorseRaceLamp
	//		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
	//			horseRaceLamp = model.NewHorseRaceLamp("", platform, title, content, footer, startTime, standSec, count,
	//				priority, state, msgType, target, standSec)
	//			return model.InsertHorseRaceLamp(platform, horseRaceLamp)
	//		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
	//			if data != nil {
	//				pack.Tag = webapiproto.TagCode_FAILED
	//				pack.Msg = data.(error).Error()
	//				tNode.TransRep.RetFiels = pack
	//				tNode.Resume()
	//				return
	//			}
	//			HorseRaceLampMgrSingleton.AddHorseRaceLampMsg(horseRaceLamp.Id.Hex(), "", platform, title, content, footer, startTime, standSec,
	//				count, msgType, state, priority, horseRaceLamp.CreateTime, target, standSec)
	//			pack.Tag = webapiproto.TagCode_SUCCESS
	//			tNode.TransRep.RetFiels = pack
	//			tNode.Resume()
	//		}), "CreateHorseRaceLamp").Start()
	//		return common.ResponseTag_TransactYield, pack
	//	}))
	//
	//WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Message/GetHorseRaceLampById", WebAPIHandlerWrapper(
	//	func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
	//		pack := &webapiproto.SAGetHorseRaceLampById{}
	//		msg := &webapiproto.ASGetHorseRaceLampById{}
	//		err := proto.Unmarshal(params, msg)
	//		if err != nil {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "数据序列化失败" + err.Error()
	//			return common.ResponseTag_ParamError, pack
	//		}
	//		noticeKey := msg.NoticeId
	//		platform := msg.Platform
	//		horseRaceLamp := HorseRaceLampMgrSingleton.HorseRaceLampMsgList[noticeKey]
	//		if horseRaceLamp == nil || (len(platform) > 0 && horseRaceLamp.Platform != platform) {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "not find data"
	//		} else {
	//			pack.HorseRaceLamp = &webapiproto.HorseRaceLamp{
	//				Id:         noticeKey,
	//				Title:      horseRaceLamp.Title,
	//				Content:    horseRaceLamp.Content,
	//				Footer:     horseRaceLamp.Footer,
	//				StartTime:  horseRaceLamp.StartTime,
	//				Frequency:  horseRaceLamp.Interval,
	//				Count:      horseRaceLamp.Count,
	//				State:      horseRaceLamp.State,
	//				CreateTime: horseRaceLamp.CreateTime,
	//				Priority:   horseRaceLamp.Priority,
	//				MsgType:    horseRaceLamp.MsgType,
	//			}
	//			pack.Tag = webapiproto.TagCode_SUCCESS
	//		}
	//		return common.ResponseTag_Ok, pack
	//	}))
	//
	//WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Message/EditHorseRaceLamp", WebAPIHandlerWrapper(
	//	func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
	//		pack := &webapiproto.SAEditHorseRaceLamp{}
	//		msg := &webapiproto.ASEditHorseRaceLamp{}
	//		err := proto.Unmarshal(params, msg)
	//		if err != nil {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "数据序列化失败" + err.Error()
	//			return common.ResponseTag_ParamError, pack
	//		}
	//		noticeKey := msg.HorseRaceLamp.Id
	//		if len(noticeKey) == 0 {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "NoticeMsg id is nil"
	//			return common.ResponseTag_ParamError, pack
	//		}
	//		hrl := msg.HorseRaceLamp
	//		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
	//			notice, err2 := model.GetHorseRaceLamp(hrl.Platform, bson.ObjectIdHex(noticeKey))
	//			if err2 != nil {
	//				logger.Logger.Error("api GetNotice is error", err2)
	//				return nil
	//			}
	//			model.EditHorseRaceLamp(&model.HorseRaceLamp{
	//				Id:         bson.ObjectIdHex(noticeKey),
	//				Channel:    "",
	//				Title:      hrl.Title,
	//				Content:    hrl.Content,
	//				Footer:     hrl.Footer,
	//				StartTime:  hrl.StartTime,
	//				Interval:   hrl.Frequency,
	//				Count:      hrl.Count,
	//				CreateTime: hrl.CreateTime,
	//				Priority:   hrl.Priority,
	//				MsgType:    hrl.MsgType,
	//				Platform:   hrl.Platform,
	//				State:      hrl.State,
	//				Target:     hrl.Target,
	//				StandSec:   hrl.StandSec,
	//			})
	//			return notice
	//		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
	//			if data == nil {
	//				pack.Tag = webapiproto.TagCode_FAILED
	//				pack.Msg = "api GetNotice is error"
	//				tNode.TransRep.RetFiels = pack
	//				tNode.Resume()
	//				if err != nil {
	//					logger.Logger.Error("Marshal EditHorseRaceLamp response data error1:", err)
	//				}
	//				return
	//			} else {
	//				cache := HorseRaceLampMgrSingleton.EditHorseRaceLampMsg(&HorseRaceLamp{
	//					Key:        noticeKey,
	//					Channel:    "",
	//					Title:      hrl.Title,
	//					Content:    hrl.Content,
	//					Footer:     hrl.Footer,
	//					StartTime:  hrl.StartTime,
	//					Interval:   hrl.Frequency,
	//					Count:      hrl.Count,
	//					CreateTime: hrl.CreateTime,
	//					Priority:   hrl.Priority,
	//					MsgType:    hrl.MsgType,
	//					Platform:   hrl.Platform,
	//					State:      hrl.State,
	//					Target:     hrl.Target,
	//					StandSec:   hrl.StandSec,
	//				})
	//				if !cache {
	//					pack.Tag = webapiproto.TagCode_FAILED
	//					pack.Msg = "api EditNoticeMsg is error"
	//					tNode.TransRep.RetFiels = pack
	//					tNode.Resume()
	//					return
	//				}
	//			}
	//			pack.Tag = webapiproto.TagCode_SUCCESS
	//			tNode.TransRep.RetFiels = pack
	//			tNode.Resume()
	//			if err != nil {
	//				logger.Logger.Error("Marshal EditHorseRaceLamp response data error3:", err)
	//			}
	//		}), "EditHorseRaceLamp").Start()
	//
	//		return common.ResponseTag_TransactYield, pack
	//	}))
	//
	//WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Message/RemoveHorseRaceLampById", WebAPIHandlerWrapper(
	//	func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
	//		pack := &webapiproto.SARemoveHorseRaceLampById{}
	//		msg := &webapiproto.ASRemoveHorseRaceLampById{}
	//		err := proto.Unmarshal(params, msg)
	//		if err != nil {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "数据序列化失败" + err.Error()
	//			return common.ResponseTag_ParamError, pack
	//		}
	//		noticeKey := msg.GetHorseRaceId()
	//		platform := msg.GetPlatform()
	//		notice := HorseRaceLampMgrSingleton.HorseRaceLampMsgList[noticeKey]
	//		if notice == nil {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "not find data"
	//			return common.ResponseTag_Ok, pack
	//		}
	//		if len(platform) > 0 && notice.Platform != notice.Platform {
	//			pack.Tag = webapiproto.TagCode_FAILED
	//			pack.Msg = "not find data"
	//			return common.ResponseTag_Ok, pack
	//		}
	//		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
	//			return model.RemoveHorseRaceLamp(platform, noticeKey)
	//		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
	//			if data != nil {
	//				pack.Tag = webapiproto.TagCode_FAILED
	//				pack.Msg = "RemoveNotice is error" + data.(error).Error()
	//				tNode.TransRep.RetFiels = pack
	//				tNode.Resume()
	//				return
	//			}
	//			HorseRaceLampMgrSingleton.DelHorseRaceLampMsg(noticeKey)
	//			pack.Tag = webapiproto.TagCode_SUCCESS
	//			tNode.TransRep.RetFiels = pack
	//			tNode.Resume()
	//		}), "ResponseTag_TransactYield").Start()
	//		return common.ResponseTag_TransactYield, pack
	//	}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Ctrl/ResetEtcdData", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAResetEtcdData{}
			msg := &webapiproto.ASResetEtcdData{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			etcd.Restart()
			pack.Tag = webapiproto.TagCode_SUCCESS
			pack.Msg = "Etcd Reset success"
			return common.ResponseTag_Ok, nil
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/CreateJYB", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SACreateJYB{}
			msg := &webapiproto.ASCreateJYB{}

			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			if msg.CodeType == 1 && (msg.Code == "" || len(msg.Code) > 11) {
				pack.Tag = webapiproto.TagCode_JYB_DATA_ERROR
				pack.Msg = "CreateJYB Code failed"
				return common.ResponseTag_Ok, pack
			}
			// (plt, name, content string, startTs, endTs int64, max int32, award *JybInfoAward)
			award := &model.JybInfoAward{}
			if msg.GetAward() != nil {
				award.Coin = msg.GetAward().Coin
				award.Diamond = msg.GetAward().Diamond
				if msg.GetAward().GetItemId() != nil {
					for _, item := range msg.GetAward().ItemId {
						if v := srvdata.GameItemMgr.Get(msg.Platform, item.ItemId); item != nil {
							if item.ItemNum == 0 {
								pack.Tag = webapiproto.TagCode_JYB_DATA_ERROR
								pack.Msg = "ItemNum failed"
								return common.ResponseTag_Ok, pack
							}
							award.Item = append(award.Item, &model.Item{
								ItemId:     v.Id,
								ItemNum:    item.ItemNum,
								ObtainTime: time.Now().Unix(),
							})
						} else {
							pack.Tag = webapiproto.TagCode_JYB_DATA_ERROR
							pack.Msg = "ItemId failed"
							return common.ResponseTag_Ok, pack
						}
					}
				}
			}
			jyb := model.NewJybInfo(msg.Platform, msg.Name, msg.Content, msg.Code, msg.StartTime, msg.EndTime, msg.Max, msg.CodeType, award)
			args := &model.CreateJyb{
				JybInfo: jyb,
				Codelen: msg.CodeLen,
				Num:     uint64(msg.Max),
			}
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.CreateJybInfo(args)
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data == nil {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "CreateJYB success"
				} else {
					logger.Logger.Trace("err: ", data.(error))
					if data.(error) == model.ErrJYBCode {
						pack.Tag = webapiproto.TagCode_JYB_CODE_EXIST
					} else {
						pack.Tag = webapiproto.TagCode_FAILED
					}
					pack.Msg = "CreateJYB failed"
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "webCreateJybInfo").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Game/UpdateJYB", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAUpdateJYB{}
			msg := &webapiproto.ASUpdateJYB{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}

			if msg.Opration == 1 {
				args := &model.GetJybInfoArgs{
					Id:  msg.JYBID,
					Plt: msg.Platform,
				}
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					return model.DelJybInfo(args)
				}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
					if data == nil {
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = "UpdateJYB success"

					} else {
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = "UpdateJYB failed"
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				}), "webDelJybInfo").Start()
				return common.ResponseTag_TransactYield, pack
			}

			return common.ResponseTag_Ok, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/Customer/UpExchangeStatus", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAUpExchangeStatus{}
			msg := &webapiproto.ASUpExchangeStatus{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			snid := msg.Snid
			platform := msg.Platform
			player := PlayerMgrSington.GetPlayerBySnId(snid)
			if msg.Status != Shop_Status_Revoke {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "Status is Revoke"
				return common.ResponseTag_ParamError, pack
			}
			//cdata := ShopMgrSington.GetExchangeData(msg.GoodsId)
			item := srvdata.GameItemMgr.Get(platform, common.ItemIDVCard)
			if item == nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "item is nil"
				return common.ResponseTag_ParamError, pack
			}
			addvcoin := msg.NeedNum
			jPrice := msg.JPrice
			dPrice := msg.DPrice
			var items []*model.Item
			//V卡
			if addvcoin > 0 {
				items = append(items, &model.Item{ItemId: common.ItemIDVCard, ItemNum: int64(addvcoin)})
			}
			//金券
			if jPrice > 0 {
				items = append(items, &model.Item{ItemId: common.ItemIDJCard, ItemNum: int64(jPrice)})
			}
			//娃娃积分
			if dPrice > 0 {
				items = append(items, &model.Item{ItemId: common.ItemDollCard, ItemNum: int64(dPrice)})
			}
			remark := fmt.Sprintf("兑换撤单 %v-%v", msg.GoodsId, msg.Name)
			if player != nil {
				// 在线
				if _, code, _ := BagMgrSingleton.AddItems(&model.AddItemParam{
					Platform: player.Platform,
					SnId:     player.SnId,
					Change:   items,
					GainWay:  common.GainWay_Exchange,
					Operator: "system",
					Remark:   remark,
				}); code != bag.OpResultCode_OPRC_Sucess { // 领取失败
					logger.Logger.Errorf("UpExchangeStatus AddItems err", code)
					pack.Msg = "AddItems err"
					return common.ResponseTag_ParamError, pack
				}
				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = "UpExchange success"
				return common.ResponseTag_Ok, pack
			} else {
				BagMgrSingleton.AddItemsOffline(&model.AddItemParam{
					Platform: platform,
					SnId:     snid,
					Change:   items,
					GainWay:  common.GainWay_Exchange,
					Operator: "system",
					Remark:   remark,
				}, func(err error) {
					if err != nil {
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = "UpExchange failed:" + err.Error()
					} else {
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = "UpExchange success"
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				})
				return common.ResponseTag_TransactYield, pack
			}
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/pay/CallbackPayment", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			logger.Logger.Tracef("api /api/pay/CallbackPayment")
			msg := &webapiproto.ASCallbackPayment{}
			pack := &webapiproto.SACallbackPayment{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "数据序列化失败" + err.Error()
				return common.ResponseTag_ParamError, pack
			}
			if msg.OrderId == "" || msg.Platform == "" {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "OrderId == nil || msg.Platform == nil"
				return common.ResponseTag_ParamError, pack
			}

			retFail := func(errorMsg string) {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = errorMsg
				if tNode != nil {
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				}
			}

			var info *model.DbShop
			var state int32
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				info = model.GetDbShopLog(msg.Platform, msg.OrderId)
				if info == nil {
					return errors.New("info is nil")
				}
				logger.Logger.Tracef("/api/pay/CallbackPayment ShopLog %+v", *info)
				if info.State != 0 {
					return errors.New("the order state not 0 " + info.LogId.Hex())
				}
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if i != nil || info == nil {
					logger.Logger.Errorf("CallbackPayment error %v shoplog:%#v", i, info)
					retFail("购买记录查询失败")
					return
				}

				state = msg.GetState()
				player := PlayerMgrSington.GetPlayerBySnId(info.SnId)
				if player == nil {
					if info.State == 1 {
						state = 3
					}
				}
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					err := model.UpdateDbShopState(msg.Platform, msg.OrderId, state)
					if err != nil {
						logger.Logger.Error("CallbackPayment UpdateDbShopState error:", err)
						return err
					}
					return nil
				}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
					if i != nil {
						retFail("购买记录状态修改失败")
						return
					}
					if player != nil {
						player.DoShopInfo(info, false)
						// 邀请积分
						InviteTask(msg.Platform, player.PSnId, info.SnId, common.InviteScoreTypePay, int64(info.ConsumeNum))
					} else {
						// 邀请积分
						task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
							psnid, err := model.GetPlayerInviteSnid(msg.Platform, info.SnId)
							if err != nil {
								logger.Logger.Error("CallbackPayment GetPlayerInviteSnid error:", err)
								return err
							}
							InviteTask(msg.Platform, psnid, info.SnId, common.InviteScoreTypePay, int64(info.ConsumeNum))
							return nil
						}), nil, "InvitePayTask").Start()
					}
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "success"
					if tNode != nil {
						tNode.TransRep.RetFiels = pack
						tNode.Resume()
					}
				})).StartByExecutor(fmt.Sprintf("Player%v", info.SnId))
			})).StartByFixExecutor("CallbackPayment")
			return common.ResponseTag_TransactYield, pack
		}))

	//======= 资源更新通知 =======
	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/game/resource", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAResource{}
			msg := &webapiproto.ASResource{}
			err := proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = fmt.Sprintf("err:%v", err.Error())
				return common.ResponseTag_ParamError, pack
			}

			// 通知所有玩家
			playerMsg := &playerproto.SCResource{
				Msg: msg.GetMsg(),
			}
			PlayerMgrSington.BroadcastMessage(int(playerproto.PlayerPacketID_PACKET_SC_RESOURCE), playerMsg)

			pack.Tag = webapiproto.TagCode_SUCCESS
			pack.Msg = ""
			return common.ResponseTag_Ok, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/player/update_tel", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAUpdateTel{}
			msg := &webapiproto.ASUpdateTel{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				return common.ResponseTag_ParamError, pack
			}
			logger.Logger.Tracef(
				"WebAPIHandlerMgrSingleton.RegisteWebAPIHandler /api/player/update_tel snid:%v, tel:%v ,platform:%v", msg.GetSnid(), msg.GetTel(), msg.GetPlatform())

			p := PlayerMgrSington.GetPlayerBySnId(msg.GetSnid())
			if p != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "玩家在线，只能离线修改"
				return common.ResponseTag_ParamError, pack
			}

			var snid int32
			var a *model.Account
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				// 手机号是否已经被绑定
				snid, _ = model.GetPlayerTel(msg.GetTel(), msg.GetPlatform(), 0) // tagKey没用了，给0就行
				if snid != 0 {
					return nil
				}

				a, err = model.GetAccountBySnid(msg.GetPlatform(), msg.GetSnid())
				if err != nil || a == nil {
					return nil
				}
				if a.Tel == "" {
					return nil
				}

				// 绑定手机号
				if err = model.BindTelAccount(a.AccountId.Hex(), msg.GetTel(), msg.GetPlatform()); err != nil {
					logger.Logger.Errorf("BindTelAccount err: %v", err)
					return nil
				}

				if err = model.UpdatePlayerTel(msg.GetPlatform(), msg.GetSnid(), msg.GetTel()); err != nil {
					logger.Logger.Errorf("UpdatePlayerTel err: %v", err)
					return nil
				}
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if err != nil {
					// 修改错误
					logger.Logger.Errorf("update tel %v err: %v", msg.GetSnid(), err)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "修改失败"
				} else if snid != 0 {
					// 手机号已经绑定
					pack.Tag = webapiproto.TagCode_TelExist
					pack.Msg = "手机号已使用"
				} else if a == nil {
					// 手机号已经绑定
					pack.Tag = webapiproto.TagCode_AccountNotFound
					pack.Msg = "账号没找到"
				} else if a.Tel == "" {
					// 没有绑定手机号
					pack.Tag = webapiproto.TagCode_TelNotBind
					pack.Msg = "原账号没有绑定手机号，请自行绑定"
				} else {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "修改成功"
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
				logger.Logger.Tracef("update tel %v ret: %v", msg.GetSnid(), pack)
			})).StartByFixExecutor(fmt.Sprintf("Platform%v", msg.GetPlatform()))
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/player/delete", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAPlayerDelete{}
			msg := &webapiproto.ASPlayerDelete{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil || msg.Snid <= 0 {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				return common.ResponseTag_ParamError, pack
			}
			logger.Logger.Tracef("/api/player/delete %v", msg)

			// 踢掉玩家
			p := PlayerMgrSington.GetPlayerBySnId(msg.GetSnid())
			if p != nil {
				ls := LoginStateMgrSington.GetLoginStateBySid(p.sid)
				if ls != nil {
					if ls.als != nil && ls.als.acc != nil {
						ls.als.acc.State = time.Now().AddDate(0, 0, 1).Unix()
					}
				}

				p.Kick(common.KickReason_Freeze)
				PlayerMgrSington.DelPlayer(p.SnId)
				LoginStateMgrSington.DelAccountByAccid(p.AccountId)
			}

			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				pd, _ := model.GetPlayerDataBySnId(msg.Platform, msg.Snid, false, false)
				if pd == nil || pd.SnId == 0 {
					err = errors.New("player not found")
					return nil
				}
				// 冻结
				err = model.FreezeAccount(pd.Platform, pd.AccountId, 24*60)
				if err != nil {
					return nil
				}
				// 备份账号
				var account *model.Account
				account, err = model.GetAccount(pd.Platform, pd.AccountId)
				if err != nil {
					return nil
				}
				err = model.SaveToDelBackupAccount(account)
				if err != nil {
					return nil
				}
				//if !model.SaveDelBackupPlayerData(pd) {
				//	err = errors.New("SaveDelBackupPlayerData failed")
				//	return nil
				//}
				// 删除账号
				err = model.RemoveAccount(pd.Platform, pd.AccountId)
				if err != nil {
					return nil
				}
				err = model.ResetPlayer(pd.Platform, pd.SnId)
				if err != nil {
					return nil
				}
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if err != nil {
					logger.Logger.Errorf("player delete %v err: %v", msg, err)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "删除失败"
				} else {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "删除成功"
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
				logger.Logger.Tracef("player delete %v ret: %v", msg.GetSnid(), pack)
			})).StartByExecutor(fmt.Sprint(msg.GetSnid()))
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/player/AddItem", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAAddItemById{}
			msg := &webapiproto.ASAddItemById{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil || msg.Snid <= 0 {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				return common.ResponseTag_ParamError, pack
			}
			var items []*model.Item
			var has bool
			for _, info := range msg.ItemInfo {
				items = append(items, &model.Item{
					ItemId:     info.ItemId,  // 物品id
					ItemNum:    info.ItemNum, // 数量
					ObtainTime: time.Now().Unix(),
				})
				if info.ItemNum < 0 {
					has = true
				}
			}
			p := PlayerMgrSington.GetPlayerBySnId(msg.GetSnid())
			if p != nil {
				if p.scene != nil && has {
					logger.Logger.Warnf("游戏中不能减道具")
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "游戏中不能减道具"
					return common.ResponseTag_Ok, pack
				}

				//获取道具Id
				_, _, ok := BagMgrSingleton.AddItems(&model.AddItemParam{
					Platform: p.Platform,
					SnId:     p.SnId,
					Change:   items,
					GainWay:  msg.GetTypeId(),
					Operator: "system",
					Remark:   msg.GetRemark(),
				})
				if !ok {
					logger.Logger.Errorf("player delete %v err: %v", msg, err)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "修改道具失败"
					return common.ResponseTag_Ok, pack
				}
				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = "修改道具成功"
				return common.ResponseTag_Ok, pack
			} else {
				BagMgrSingleton.AddItemsOffline(&model.AddItemParam{
					Platform: msg.GetPlatform(),
					SnId:     msg.GetSnid(),
					Change:   items,
					GainWay:  msg.GetTypeId(),
					Operator: "system",
					Remark:   msg.GetRemark(),
				}, func(err error) {
					if err != nil {
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = "AddItem failed:" + err.Error()
					} else {
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = "AddItem success"
					}
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
				})
				return common.ResponseTag_TransactYield, pack
			}
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/game/show_lottery", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			logger.Logger.Tracef("/api/game/show_lottery %v", params)
			pack := &webapiproto.SAShowLottery{}
			msg := &webapiproto.ASShowLottery{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				logger.Logger.Errorf("/api/game/show_lottery Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}

			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				err = model.UpdateLotteryMedia(msg.GetPlatform(), msg.GetLogId(), msg.GetList())
				if err != nil {
					logger.Logger.Errorf("/api/game/show_lottery UpdateLotteryMedia %v err: %v", msg, err)
					return err
				}
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if err != nil {
					logger.Logger.Errorf("/api/game/show_lottery %v err: %v", msg, err)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "修改失败"
				} else {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "修改成功"
					mq.Write(&model.LotteryLog{Platform: msg.GetPlatform()}, mq.RankLotteryLog)
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
				logger.Logger.Tracef("/api/game/show_lottery ret: %v", pack)
			}), "modify_show_lottery").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/game/send_sms", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {

			pack := &webapiproto.SASendSMSCode{}
			msg := &webapiproto.ASSendSMSCode{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				logger.Logger.Errorf("/api/game/send_sms Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}
			logger.Logger.Tracef("/api/game/send_sms %v", msg)

			msg.Tel = strings.TrimPrefix(msg.GetTel(), "0")
			if !telRule.MatchString(msg.GetTel()) {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "手机号格式错误"
				return common.ResponseTag_ParamError, pack
			}

			telKey := common.GetTelLoginCodeKey(msg.GetPlatform(), msg.GetTel())
			validTime := common.SMSCodeValidTimeTelLogin

			key := fmt.Sprintf("key%s", telKey)
			code := CacheMemory.Get(key) // 频率限制
			if code != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "发送频率过快"
				return common.ResponseTag_ParamError, pack
			}

			if model.GameParamData.FakeVerifyCode != "" {
				CacheMemory.Put(telKey, model.GameParamData.FakeVerifyCode, validTime)
				CacheMemory.Put(key, model.GameParamData.FakeVerifyCode, common.SMSCodeValidTime)
				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = "发送成功"
				return common.ResponseTag_Ok, pack
			}

			//先设置注册码，防止多次注册
			smsCode := common.RandSmsCode()
			CacheMemory.Put(telKey, smsCode, validTime)
			CacheMemory.Put(key, smsCode, common.SMSCodeValidTime)
			logger.Logger.Trace("CSPlayerSMSCode smsCode ", smsCode)

			var res []byte
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				param := &webapiproto.ASSendSms{
					Phone:    msg.GetTel(),
					Code:     smsCode,
					Platform: msg.GetPlatform(),
					TypeID:   common.SMSCodeTelLogin,
				}
				res, err = webapi.ApiSendSMS(common.GetAppId(), param)
				return nil
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if err != nil || res == nil {
					logger.Logger.Errorf("API_SendSms err %v", err)
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "发送失败"
				} else {
					var info webapiproto.SASendSms
					proto.Unmarshal(res, &info)
					if info.Tag == webapiproto.TagCode_SUCCESS {
						CacheMemory.Put(telKey, smsCode, validTime)
						pack.Tag = webapiproto.TagCode_SUCCESS
						pack.Msg = "发送成功"
					} else {
						if info.Tag == webapiproto.TagCode_Limit {
							logger.Logger.Warnf("API_SendSms Limit tel:%s", msg.GetTel())
							pack.Tag = webapiproto.TagCode_Limit
							pack.Msg = "发送频率过快"
						} else {
							logger.Logger.Errorf("API_SendSms err %v", err)
							pack.Tag = webapiproto.TagCode_FAILED
							pack.Msg = "发送失败"
						}
					}
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "API_SendSms").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/game/web_login", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAWebLogin{
				Tag: webapiproto.TagCode_FAILED,
				Msg: "未知错误",
			}
			msg := &webapiproto.ASWebLogin{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				logger.Logger.Errorf("/api/game/web_login Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}
			logger.Logger.Tracef("/api/game/web_login %v", msg)

			var acc *model.Account
			ls := LoginStateMgrSington.GetLoginStateByName(UserKey(msg.GetUsername(), msg.GetPlatform(), 0))
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				if ls != nil && ls.acc != nil {
					if msg.GetLoginType() == 2 && ls.acc.Tel == msg.GetUsername() {
						acc = ls.acc
					}
					if msg.GetLoginType() != 2 && ls.acc.UserName == msg.GetUsername() {
						acc = ls.acc
					}
				}
				if acc == nil {
					acc, err = model.GetAccountByName(msg.GetPlatform(), msg.GetUsername())
				}
				return nil
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if err != nil || acc == nil {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "查询账号失败"
				} else {
					switch msg.GetLoginType() {
					case 1, 3, 4: // 账号密码登录 google登录 facebook登录
						if acc.UserName == msg.GetUsername() {
							raw := fmt.Sprintf("%v%v%v", acc.PassWord, common.GetAppId(), msg.GetTimestamp())
							h := md5.New()
							io.WriteString(h, raw)
							pwd := hex.EncodeToString(h.Sum(nil))
							if pwd == msg.GetPassword() {
								pack.Tag = webapiproto.TagCode_SUCCESS
								pack.Msg = "登录成功"
								pack.Platform = ls.acc.Platform
								pack.SnId = ls.acc.SnId
							} else {
								pack.Tag = webapiproto.TagCode_FAILED
								pack.Msg = "密码错误"
							}
						}

					case 2: // 手机号验证码登录
						if acc.Tel == msg.GetUsername() {
							code := CacheMemory.Get(common.GetTelLoginCodeKey(msg.GetPlatform(), msg.GetUsername()))
							// 验证码错误
							if code != msg.GetSMSCode() {
								pack.Tag = webapiproto.TagCode_FAILED
								pack.Msg = "验证码错误"
							} else {
								pack.Tag = webapiproto.TagCode_SUCCESS
								pack.Msg = "登录成功"
								pack.Platform = acc.Platform
								pack.SnId = acc.SnId
							}
						}

					default:
						pack.Tag = webapiproto.TagCode_FAILED
						pack.Msg = "未知登录类型"
					}
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "GetAccount").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/player/address", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAGetAddress{
				Tag: webapiproto.TagCode_FAILED,
				Msg: "未知错误",
			}
			msg := &webapiproto.ASGetAddress{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				logger.Logger.Errorf("/api/player/address Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}
			logger.Logger.Tracef("/api/player/address %v", msg)

			p := PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
			if p != nil {
				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = "获取成功"
				pack.List = p.Addr
				return common.ResponseTag_Ok, pack
			}

			// 离线获取
			var address []string
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				address, err = model.GetPlayerAddress(msg.GetPlatform(), msg.GetSnId())
				return nil
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if err != nil {
					pack.Tag = webapiproto.TagCode_FAILED
					pack.Msg = "获取失败"
				} else {
					pack.Tag = webapiproto.TagCode_SUCCESS
					pack.Msg = "获取成功"
					pack.List = address
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "GetAddress").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/player/update_address", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAUpdateAddress{
				Tag: webapiproto.TagCode_FAILED,
				Msg: "未知错误",
			}
			msg := &webapiproto.ASUpdateAddress{}

			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				pack.Msg = "参数错误"
				logger.Logger.Errorf("/api/player/update_address Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}
			logger.Logger.Tracef("/api/player/update_address %v", msg)

			UpdatePlayerAddress(msg.GetPlatform(), msg.GetSnId(), msg.GetOpType(), msg.GetAddr(), msg.GetId(), func(address []string) {
				pack.Tag = webapiproto.TagCode_SUCCESS
				pack.Msg = "修改成功"
				pack.List = address
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			})
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/game/exchange_list", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAGetExchangeShop{
				Tag: webapiproto.TagCode_FAILED,
			}
			msg := &webapiproto.ASGetExchangeShop{}
			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				logger.Logger.Errorf("/api/game/exchange_list Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}

			logger.Logger.Tracef("/api/game/exchange_list %v", msg)

			var b []byte
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				b, err = webapi.API_ExchangeList(common.GetAppId(), msg)
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if err != nil || b == nil {
					logger.Logger.Errorf("/api/game/exchange_list API_ExchangeList err: %v", err)
					pack.Tag = webapiproto.TagCode_FAILED
				} else {
					err = proto.Unmarshal(b, pack)
					if err != nil {
						logger.Logger.Errorf("/api/game/exchange_list Unmarshal err: %v", err)
					}
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "/api/game/exchange_list").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/game/exchange_order", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAGetExchangeOrder{
				Tag: webapiproto.TagCode_FAILED,
			}
			msg := &webapiproto.ASGetExchangeOrder{}
			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil {
				pack.Tag = webapiproto.TagCode_FAILED
				logger.Logger.Errorf("/api/game/exchange_order Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}

			logger.Logger.Tracef("/api/game/exchange_order %v", msg)

			var b []byte
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				b, err = webapi.API_ExchangeRecord(common.GetAppId(), msg)
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if err != nil || b == nil {
					logger.Logger.Errorf("/api/game/exchange_order API_ExchangeList err: %v", err)
					pack.Tag = webapiproto.TagCode_FAILED
				} else {
					err = proto.Unmarshal(b, pack)
					if err != nil {
						logger.Logger.Errorf("/api/game/exchange_order Unmarshal err: %v", err)
					}
				}
				tNode.TransRep.RetFiels = pack
				tNode.Resume()
			}), "/api/game/exchange_order").Start()
			return common.ResponseTag_TransactYield, pack
		}))

	WebAPIHandlerMgrSingleton.RegisteWebAPIHandler("/api/game/exchange_create", WebAPIHandlerWrapper(
		func(tNode *transact.TransNode, params []byte) (int, proto.Message) {
			pack := &webapiproto.SAWebCreateExchange{
				Tag: webapiproto.ExchangeCreateCode_OPRC_Error,
			}
			msg := &webapiproto.ASWebCreateExchange{}
			var err error
			err = proto.Unmarshal(params, msg)
			if err != nil || msg.Amount <= 0 || msg.Amount > 100 {
				logger.Logger.Errorf("/api/game/exchange_create Unmarshal err: %v", err)
				return common.ResponseTag_ParamError, pack
			}

			logger.Logger.Tracef("/api/game/exchange_create %v", msg)

			var pd *model.PlayerData
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				p := PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
				if p == nil {
					pd, _ = model.GetPlayerDataBySnId(msg.GetPlatform(), msg.GetSnId(), false, false)
				} else {
					pd = p.PlayerData
				}
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if pd == nil {
					logger.Logger.Errorf("/api/game/exchange_create GetPlayerData err: %v", err)
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
					return
				}

				_, f := BlackListMgrSington.CheckExchange(pd)
				if !f {
					logger.Logger.Errorf("/api/game/exchange_order Unmarshal err: %v", err)
					tNode.TransRep.RetFiels = pack
					tNode.Resume()
					return
				}

				ShopMgrSington.Exchange(&ExchangeParam{
					Platform:       msg.GetPlatform(),
					SnId:           msg.GetSnId(),
					VipLevel:       pd.VIP,
					Tel:            pd.Tel,
					Name:           pd.Name,
					PackageId:      pd.PackageID,
					ExchangeTypeId: msg.GetExchangeTypeId(),
					Id:             msg.GetId(),
					UserName:       msg.GetUserName(),
					Mobile:         msg.GetMobile(),
					Address:        msg.GetComment(),
					Num:            msg.GetAmount(),
					GiveType:       msg.GetExchangeType(),
					TelId:          msg.GetTelId(),
					CallBackFunc: func(code shop.OpResultCode) {
						pack.Tag = webapiproto.ExchangeCreateCode(code)
						pack.Id = msg.GetId()
						logger.Logger.Tracef("/api/game/exchange_create return %v", pack)
						tNode.TransRep.RetFiels = pack
						tNode.Resume()
					},
				})
			}), "exchange_create").Start()
			return common.ResponseTag_TransactYield, pack
		}))
}

type playerDataParam struct {
	P      *model.PlayerData
	Season *model.PlayerRankSeason
	Items  *model.BagInfo
}

func getPlayerDataParam(param *playerDataParam) *model.WebPlayerDataParam {
	if param.P == nil {
		return nil
	}

	data := PlatformMgrSingleton.GetConfig(param.P.Platform).PlayerPool

	rankScore := make(map[int64]int64)
	if param.Season == nil {
		rankScore = RankMgrSingleton.GetPlayerRankScoreInt64(param.P.SnId)
	} else {
		for k, v := range param.Season.RankType {
			if v != nil {
				rankScore[int64(k)] = v.Score
			}
		}
	}
	var long, permitScore int64
	var items []*model.WebItem
	if param.Items == nil {
		b := BagMgrSingleton.GetBagInfo(param.P.SnId)
		for _, v := range b.BagItem {
			e := srvdata.GameItemMgr.Get(param.P.Platform, v.ItemId)
			if e == nil || v.ItemNum <= 0 {
				continue
			}
			items = append(items, &model.WebItem{
				Id:   int64(e.Id),
				N:    v.ItemNum,
				Name: e.Name,
			})
			if e.Id == common.ItemIDLong {
				long += v.ItemNum
			}
			if e.Id == common.ItemIDPermit {
				permitScore += v.ItemNum
			}
		}
	} else {
		for _, v := range param.Items.BagItem {
			e := srvdata.GameItemMgr.Get(param.P.Platform, v.ItemId)
			if e == nil || v.ItemNum <= 0 {
				continue
			}
			items = append(items, &model.WebItem{
				Id:   int64(e.Id),
				N:    v.ItemNum,
				Name: e.Name,
			})
			if e.Id == common.ItemIDLong {
				long += v.ItemNum
			}
			if e.Id == common.ItemIDPermit {
				permitScore += v.ItemNum
			}
		}
	}

	//人物加成
	award := int32(0)
	level := param.P.Roles.ModUnlock[2000002]
	if level > 0 {
		roleInfo := srvdata.RolePetMgrSington.GetRoleByRoleIdAndLevel(2000002, level)
		if roleInfo != nil {
			award = roleInfo.Award
		}
	}
	vipAdded := VipMgrSington.GetVipDiamondExtra(param.P.Platform, param.P.VIP)
	var vipExp int64
	vipConfig := VipMgrSington.GetVIPcfg(param.P.Platform)
	if vipConfig != nil {
		vipExp = int64(float64(param.P.MoneyPayTotal) * vipConfig.MoneyRatio)
	}
	ret := &model.WebPlayerDataParam{
		PlayerData:        param.P,
		RankScore:         rankScore,
		PlayerPoolUpper:   param.P.GetPoolUpper(data),
		PlayerPoolLower:   param.P.GetPoolLower(data),
		PlayerPoolCurrent: param.P.GetPoolCurrent(),
		PlayerPoolOdds:    param.P.GetPoolOdds(data),
		RoleAdded:         int64(award),
		VipAdded:          int64(vipAdded),
		VipExp:            vipExp,
		Items:             items,
		IsPermit:          !param.P.Permit.IsZero(),
		Long:              long,
		PermitScore:       permitScore,
	}

	return ret
}