RoServer/RO_Server_Trunk-branch_0.1.39/roweb/serverlist/model/serverlist.go

package model

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"rocommon/service"
	"rocommon/util"
	"strconv"

	"github.com/gin-gonic/gin"
)

const (
	DefaultServer = 0 //0默认获取最新服务
	InnerServer   = 1 //1
	OuterServer   = 2 //2
	TAPTAPServer  = 3 //3 taptap
	CurServer     = 4 //4 当前外网服务器 4 先锋测试服务器
	PayServer     = 5 //5 拥有测试功能的服务器
	//SelfServerList = 6  //6
	//ServerListNum = 7	//7
	ServerByID      = 21 //21根据id获取对应服务器状态 http://127.0.0.1:8088/serverlist?type=21&id=1
	ServerRecommend = 22 //22获取推荐服务器（玩家自己登录过的游戏，和最后一个服务器） serverlist?type=3&openid=abcd
	ServerAll       = 23 //23所有服务器列表
	ServerGetIP     = 24 //24获取访问时的IP
)

// 前20个特殊服务器type和id相同
// /serverlist?type=1
// /1 内网服务器
// /2 外网服务器
// /3 taptap
// /4 当前外网服务器 4 先锋测试服务器
// /5 拥有测试功能的服务器
// /获取所有服务器列表
func GetServerList(c *gin.Context) {
	getType := c.DefaultQuery("type", "0") ///default 0
	serverListType, err := strconv.Atoi(getType)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"err": "type invalid!!!",
		})
		return
	}
	////检查是否是渠道黑名单
	//subplatform := c.DefaultQuery("subplatform", "") ///default 0
	//if subplatform != "" {
	//	if GetServiceConfig().IsPlatformBlackList(subplatform) {
	//		c.JSON(http.StatusOK, gin.H{
	//			"err": "no server node!!!",
	//		})
	//		return
	//	}
	//}

	//外网服务器
	var serviceNode *ServerNode = nil
	switch serverListType {
	case InnerServer:
		fallthrough //内网服务器 //固定ID
	case OuterServer:
		fallthrough //外网服务器
	case TAPTAPServer:
		fallthrough //外网TapTap服务器
	case CurServer:
		fallthrough
	case PayServer:
		serviceNode = GetServiceConfig().GetServerById(c, getType)
	case ServerByID: //21根据id获取对应服务器状态 http://127.0.0.1:8088/serverlist?type=21&id=1
		serviceId := c.DefaultQuery("id", "0")
		if serviceId != "0" {
			serviceNode = GetServiceConfig().GetServerById(c, serviceId)
		}
	case ServerRecommend: //22获取推荐服务器（玩家自己登录过的游戏，和最后一个服务器） serverlist?type=3&openid=abcd
		//openID登录的服务器信息
		errStr, ret := GetOpenIDServerList(c)
		if !ret {
			c.JSON(http.StatusOK, gin.H{
				"err": errStr,
			})
		}
		return
	case ServerAll: //获取所有服务器列表，根据页来获取，默认第一次返回最后一页数据
		//type=23&page=1
		pageId := c.DefaultQuery("page", "0")
		c.JSON(http.StatusOK, GetServiceConfig().GetServerList(c, pageId))
		return
	case ServerGetIP: //获取远端访问的IP
		remoteIp := c.ClientIP()
		c.JSON(http.StatusOK, gin.H{
			"RemoteIP": remoteIp,
		})
		return

	case DefaultServer: //获取最新服务器直接用来创建角色登录游戏(有角色就返回最近登录的服务器)
		GetDefaultServer(c)
		return
	}

	if serviceNode != nil {
		c.JSON(http.StatusOK, serviceNode)
	} else {
		c.JSON(http.StatusOK, gin.H{
			"err": "no server node!!!",
		})
	}
}

func ServerMaintain(c *gin.Context) {
	serverId := c.DefaultQuery("sid", "0")   ///default 0
	stateStr := c.DefaultQuery("state", "0") ///default 0
	tmpConfig := GetServiceConfig()
	serverNode := tmpConfig.GetServerById(c, serverId)
	if serverNode == nil {
		c.JSON(http.StatusOK, gin.H{
			"err": "no server node!!!",
		})
		return
	}

	//#5 表示维护
	//#1 ～ 4，分别表示服务器： 空闲、良好、繁忙、火爆 4种状态
	state, _ := strconv.Atoi(stateStr)
	if state == 1 {
		if serverNode.State == 5 {
			c.JSON(http.StatusOK, gin.H{
				"err": "当前服务器已经处在维护中",
			})
			return
		}
		serverNode.State = 5
		tmpConfig.Save()

		c.JSON(http.StatusOK, gin.H{
			"err": "当前服务器添加维护成功",
		})
	} else {
		if serverNode.State == 0 {
			c.JSON(http.StatusOK, gin.H{
				"err": "当前服务器已经解除维护",
			})
			return
		}
		serverNode.State = 0
		tmpConfig.Save()

		c.JSON(http.StatusOK, gin.H{
			"err": "当前服务器解除维护成功",
		})
	}
}

func GetServerState(c *gin.Context) {
	serverId := c.DefaultQuery("sid", "0") ///default 0
	tmpConfig := GetServiceConfig()
	serverNode := tmpConfig.GetServerById(c, serverId)
	if serverNode != nil {
		c.JSON(http.StatusOK, *serverNode)
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"err": "no server node!!!",
	})
}

type SelfServerNodeDetail struct {
	ServerId    int32  `json:serverid`
	HeadFrameId int32  `json:headframeid`
	Level       int32  `json:level`
	RecordTime  uint32 `json:recordtime`
	JobCfgId    int32  `json:jobcfgid`
	Gender      int32  `json:gender` //1 female 2 male
	NickName    string `json:nickname`

	ServerName string `yaml:servername`
	Ip         string `yaml:ip`
	Port       []int  `yaml:port`
	Type       int    `yaml:type`
	STime      string `yaml:stime`
	State      int    `yaml:state`
	New        bool   `yaml:new`
}
type SelfServerNode struct {
	ServerId    int32  `json:serverid`
	HeadFrameId int32  `json:headframeid`
	Level       int32  `json:level`
	RecordTime  uint32 `json:recordtime`
	JobCfgId    int32  `json:jobcfgid`
	Gender      int32  `json:gender` //1 female 2 male
	NickName    string `json:nickname`
}

func GetOpenIDServerList(c *gin.Context) (string, bool) {
	var errStr = ""
	openId := c.DefaultQuery("openid", "")     ///default ""
	platform := c.DefaultQuery("platform", "") ///default ""
	resver := c.DefaultQuery("resver", "")     ///default ""
	if openId == "" {
		errStr = "openid invalid!!!"
		util.InfoF(errStr)
		return errStr, false
	}
	openId = ConvertPlatform(openId, platform)

	//sl:abc
	keyStr := "sl:" + openId
	valList, err := service.GetRedis().HVals(keyStr).Result()
	if err != nil {
		errStr := "openid invalid!!!" + err.Error()
		util.InfoF(errStr)
		return errStr, false
	}

	tmpConfig := GetServiceConfig()
	ip := c.ClientIP()
	//黑名单只看到特殊的IP列表
	bBlack := tmpConfig.IsBlackList(openId, ip, resver)
	if bBlack {
		var selfNodeList []*SelfServerNodeDetail
		if tmpConfig.BlackList.ServerList != nil {
			tmpNode := tmpConfig.BlackList.ServerList
			selfNode := &SelfServerNodeDetail{}
			selfNode.ServerId = int32(tmpNode.ServerId)
			selfNode.ServerName = (*tmpNode).ServerName
			selfNode.Ip = (*tmpNode).Ip
			selfNode.Port = (*tmpNode).Port
			selfNode.Type = (*tmpNode).Type
			selfNode.STime = (*tmpNode).STime
			selfNode.New = true

			selfNodeList = append(selfNodeList, selfNode)
		}
		c.JSON(http.StatusOK, selfNodeList)
		return "", true
	}

	subplatform := c.DefaultQuery("sub_platform", "") ///default 0
	bBlockPlatform := tmpConfig.IsPlatformBlackList(subplatform)

	bWhite := tmpConfig.IsWhiteList(openId, ip, resver)
	latestServerNode := tmpConfig.GetLatestServer(false)
	bFindLatest := false
	var selfNodeList []*SelfServerNodeDetail
	//var selfNodeList = make(map[int32]*SelfServerNodeDetail)
	for idx := range valList {
		selfNode := &SelfServerNodeDetail{}
		json.Unmarshal([]byte(valList[idx]), selfNode)

		serverNode := tmpConfig.GetServerById(c, strconv.Itoa(int(selfNode.ServerId)))
		if serverNode != nil {
			selfNode.ServerId = int32(serverNode.ServerId)
			selfNode.ServerName = (*serverNode).ServerName
			selfNode.Ip = (*serverNode).Ip
			selfNode.Port = (*serverNode).Port
			selfNode.Type = (*serverNode).Type
			selfNode.STime = (*serverNode).STime
			if bWhite {
				//白名单玩家状态修改
				//5维护 6待测试
				if selfNode.State != 6 {
					selfNode.State = 0
				}
			} else {
				selfNode.State = (*serverNode).State
				if bBlockPlatform {
					selfNode.State = 5
				}
			}

			selfNodeList = append(selfNodeList, selfNode)
		}
		//util.InfoF("node:%v", selfNode)

		if !bFindLatest && latestServerNode != nil && serverNode != nil && serverNode.ServerId == latestServerNode.ServerId {
			bFindLatest = true
			selfNode.New = true
		}
	}

	//添加最新服务器
	if latestServerNode != nil && !bFindLatest {
		selfNode := &SelfServerNodeDetail{}
		selfNode.ServerId = int32(latestServerNode.ServerId)
		selfNode.ServerName = (*latestServerNode).ServerName
		selfNode.Ip = (*latestServerNode).Ip
		selfNode.Port = (*latestServerNode).Port
		selfNode.Type = (*latestServerNode).Type
		selfNode.STime = (*latestServerNode).STime
		if bWhite {
			//白名单玩家状态修改
			//5维护 6待测试
			if selfNode.State != 6 {
				selfNode.State = 0
			}
		} else {
			selfNode.State = (*latestServerNode).State
			if bBlockPlatform {
				selfNode.State = 5
			}
		}
		selfNode.New = true

		selfNodeList = append(selfNodeList, selfNode)
	}

	c.JSON(http.StatusOK, selfNodeList)

	return "", true
}

func GetDefaultServer(c *gin.Context) {
	tmpConfig := GetServiceConfig()

	tmpNode := tmpConfig.GetLatestServer(false)
	var latestServerNode ServerNode
	if tmpNode != nil {
		latestServerNode = *tmpNode
	}
	ip := c.ClientIP()
	openId := c.DefaultQuery("openid", "")     ///default ""
	platform := c.DefaultQuery("platform", "") ///default ""
	resver := c.DefaultQuery("resver", "")     ///default ""
	openId = ConvertPlatform(openId, platform)

	//黑名单只看到特殊的IP列表
	bBlack := tmpConfig.IsBlackList(openId, ip, resver)
	if bBlack && tmpConfig.BlackList.ServerList != nil {
		latestServerNode = *tmpConfig.BlackList.ServerList
	}

	isWhiteList := tmpConfig.IsWhiteList(openId, ip, resver)
	if openId == "" {
		//白名单中玩家，服务器不进入维护状态
		if isWhiteList && !bBlack {
			tmpNode := tmpConfig.GetLatestServer(true)
			if tmpNode != nil {
				latestServerNode = *tmpNode
			}
			if latestServerNode.State > 0 {
				latestServerNode.State = 0
			}
		}
		c.JSON(http.StatusOK, latestServerNode)
		return
	}

	//白名单中玩家，服务器不进入维护状态
	if isWhiteList && !bBlack {
		tmpNode := tmpConfig.GetLatestServer(true)
		if tmpNode != nil {
			latestServerNode = *tmpNode
		}
		if latestServerNode.State > 0 {
			latestServerNode.State = 0
		}
	}

	subplatform := c.DefaultQuery("sub_platform", "") ///default 0
	bBlockPlatform := tmpConfig.IsPlatformBlackList(subplatform)
	if bBlockPlatform && latestServerNode.ServerId > 0 {
		latestServerNode.State = 5
	}

	//openId = ConvertPlatform(openId, platform)
	//sl:abc
	keyStr := "sl:" + openId
	valList, err := service.GetRedis().HVals(keyStr).Result()
	if err != nil {
		c.JSON(http.StatusOK, latestServerNode)
		return
	}

	var selfNodeInfo *SelfServerNodeDetail = nil
	for idx := range valList {
		tmpNode := &SelfServerNodeDetail{}
		err := json.Unmarshal([]byte(valList[idx]), tmpNode)
		if err != nil {
			continue
		}

		if selfNodeInfo == nil || tmpNode.RecordTime > selfNodeInfo.RecordTime {
			selfNodeInfo = tmpNode
		}
	}

	if selfNodeInfo != nil {
		serverNode := tmpConfig.GetServerById(c, strconv.Itoa(int(selfNodeInfo.ServerId)))
		if serverNode != nil {
			//白名单中玩家，服务器不进入维护状态
			tmpNode := *serverNode
			if tmpNode.State > 0 && isWhiteList {
				//白名单玩家状态修改
				//5维护 6待测试
				if tmpNode.State != 6 {
					tmpNode.State = 0
				}
				tmpNode.State = 0
			}
			if bBlockPlatform && tmpNode.ServerId > 0 {
				latestServerNode.State = 5
			}
			c.JSON(http.StatusOK, tmpNode)
			return
		}
	}
	c.JSON(http.StatusOK, latestServerNode)
}

func AddOpenIDServer(c *gin.Context) {
	var errStr = ""
	openId := c.DefaultQuery("openid", "") ///default ""
	if openId == "" {
		errStr = "openid invalid!!!"
		util.InfoF(errStr)
		c.JSON(http.StatusOK, gin.H{
			"err": errStr,
		})
		return
	}

	serverIdStr := c.PostForm("ServerId")
	serverId, err1 := strconv.Atoi(serverIdStr)
	headFrameId, err2 := strconv.Atoi(c.PostForm("HeadFrameId"))
	level, err3 := strconv.Atoi(c.PostForm("Level"))
	jobCfgId, err3 := strconv.Atoi(c.PostForm("JobCfgId"))
	gender, err3 := strconv.Atoi(c.PostForm("Gender"))
	nickName := c.PostForm("NickName")
	if err1 != nil || err2 != nil || err3 != nil || serverId == 0 || headFrameId == 0 || level == 0 {
		errStr = "param invalid!!!"
		c.JSON(http.StatusOK, gin.H{
			"err": errStr,
		})
		return
	}

	addServerNode, _ := json.Marshal(
		&SelfServerNode{
			ServerId:    int32(serverId),
			HeadFrameId: int32(headFrameId),
			Level:       int32(level),
			JobCfgId:    int32(jobCfgId),
			Gender:      int32(gender),
			RecordTime:  uint32(util.GetTimeSeconds()),
			NickName:    nickName,
		})
	util.InfoF("openid=%v content=%v", openId, string(addServerNode))

	//sl:abc
	keyStr := "sl:" + openId
	_, err := service.GetRedis().HSet(keyStr, serverIdStr, string(addServerNode)).Result()
	if err != nil {
		util.InfoF("AddOpenIDServer err:%v", err)
	}
}

func UploadFile(c *gin.Context) {
	battleRecordIdStr := c.DefaultPostForm("id", "") ///default ""
	_, err := strconv.ParseUint(battleRecordIdStr, 10, 64)
	if err != nil {
		c.String(http.StatusOK, fmt.Sprintf("upload failed!"))
		return
	}

	file, _ := c.FormFile("file")
	util.InfoF("filename=%v", file.Filename)

	err = c.SaveUploadedFile(file, service.GetServiceConfig().Node.RecordFile+"/"+file.Filename)
	if err != nil {
		c.String(http.StatusOK, fmt.Sprintf("'%s' upload failed!", file.Filename))
	} else {
		c.String(http.StatusOK, fmt.Sprintf("'%s' upload ok!", file.Filename))
	}
}

func DownloadFile(c *gin.Context) {
	//recordType := c.DefaultQuery("recordtype", "")
	//mapId := c.DefaultQuery("mapid", "")
	//mapLevel := c.DefaultQuery("maplevel", "")
	//uid := c.DefaultQuery("uid", "")

	//todo...
	fName := "READMEv2.md"
	c.Writer.Header().Add("Content-Disposition", fmt.Sprintf("attachment;filename=%s", fName))
	c.Writer.Header().Add("Content-Type", "application/octet-stream")
	c.File("./record/" + fName)
}

// serverlist redis
const (
	ServerListWhiteListPrefix = "sl:whitelist" //白名单 ->map
	ServerListDetailPrefix    = "sl:server"    //服务器详情 json格式 ->map
	ServerListDefault         = "sl:default"   //推荐服务器 默认为最后一个开放服务器(需要后台设置) ->map

	ServerListOpenIDPrefix = "sl:" //玩家创建角色服务器列表
)

type ServerNodJson struct {
	ServerId   int    `json:"ServerId"`
	ServerName string `json:"ServerName"`
	Ip         string `json:"Ip"`
	Port       []int  `json:"Port"`
	Type       int    `json:"Type"`
	STime      string `json:"STime"`
	State      int    `json:"State"`
	Invisible  int    `json:"Invisible"`
	STimeStamp uint64
	New        bool
}

type SelfServerNodeDetailJson struct {
	ServerId    int32  `json:serverid`
	HeadFrameId int32  `json:headframeid`
	Level       int32  `json:level`
	RecordTime  uint32 `json:recordtime`
	JobCfgId    int32  `json:jobcfgid`
	Gender      int32  `json:gender` //1 female 2 male
	NickName    string `json:nickname`

	ServerName string `yaml:servername`
	Ip         string `yaml:ip`
	Port       []int  `yaml:port`
	Type       int    `yaml:type`
	STime      string `yaml:stime`
	State      int    `yaml:state`
	New        bool   `yaml:new`
	STimeStamp uint64
}

type AllServerST struct {
	ServerList  []*ServerNodJson
	ServerNum   int
	Page        int
	MaxServerId int
}

func GetHeadInfo(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"err": "OK",
	})
}

func GetServerDownLoad(c *gin.Context) {
	platform := c.DefaultQuery("platform", "0")
	if serviceConfig != nil {
		var url string
		url = serviceConfig.DownLoadUrl.CdnUrl
		if platform == "PC" {
			url = serviceConfig.DownLoadUrl.IpUrl
		}
		c.JSON(http.StatusOK, url)
	} else {
		c.JSON(http.StatusOK, gin.H{
			"err": "config invalid!!!",
		})
	}
}

func GetServerListNew(c *gin.Context) {
	//util.InfoF("RequestURL=%v", c.Request.RequestURI)
	getType := c.DefaultQuery("type", "0") ///default 0
	serverListType, err := strconv.Atoi(getType)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"err": "type invalid!!!",
		})
		return
	}

	//maxServerId := 0
	//for idx := 0; idx < len(GetServiceConfig().serverNormalList); idx++ {
	//	tmpItem := GetServiceConfig().serverNormalList[idx]
	//
	//	tmpNode := &ServerNodJson{
	//		ServerId:   tmpItem.ServerId,
	//		ServerName: tmpItem.ServerName,
	//		Ip:         tmpItem.Ip,
	//		Port:       tmpItem.Port,
	//		STime:      tmpItem.STime,
	//		State:      tmpItem.State,
	//		Invisible:  tmpItem.Invisible,
	//	}
	//
	//	tmpBytes, err := json.Marshal(tmpNode)
	//	if err == nil {
	//		msgStr := base64.StdEncoding.EncodeToString(tmpBytes)
	//		service.GetRedis().HSet(ServerListDetailPrefix, strconv.Itoa(tmpNode.ServerId), string(msgStr))
	//	}
	//	if tmpItem.ServerId > maxServerId {
	//		maxServerId = tmpItem.ServerId
	//	}
	//}
	//service.GetRedis().HSet(ServerListDefault, "node", 3)
	//service.GetRedis().HSet(ServerListDefault, "maxnode", 4)
	//service.GetRedis().HSet(ServerListDefault, "wmaxnode", 11)
	//service.GetRedis().SAdd(ServerListWhiteListPrefix, "192.168.10.156")

	//redis中无数据直接使用配置文件数据
	if getServerListNum() <= 0 {
		GetServerList(c)
		return
	}

	//tmpNode := &ServerNodJson{
	//	ServerId:   1,
	//	ServerName: string("1服"),
	//	Ip:         "127.0.0.1",
	//	Port:       []int{21001, 21002, 21003, 21004},
	//	STime:      "2021-01-05 17:50:26",
	//	State:      5,
	//	Invisible:  1,
	//}
	//tmpNode.Invisible = 0
	//tmpBytes, err := json.Marshal(tmpNode)
	//service.GetRedis().HSet(ServerListDetailPrefix, "1", string(tmpBytes))
	//tmpNode.ServerId = 2
	//tmpNode.ServerName = "2服"
	//tmpBytes, err = json.Marshal(tmpNode)
	//service.GetRedis().HSet(ServerListDetailPrefix, "2", string(tmpBytes))
	//tmpNode.ServerId = 3
	//tmpNode.ServerName = "3服"
	//tmpBytes, err = json.Marshal(tmpNode)
	//service.GetRedis().HSet(ServerListDetailPrefix, "3", string(tmpBytes))
	//
	//service.GetRedis().SAdd(ServerListWhiteListPrefix, "127.0.0.1")
	//service.GetRedis().SAdd(ServerListWhiteListPrefix, "192.168.10.75")
	//
	//service.GetRedis().HSet(ServerListDefault, "node", "1")
	//
	//serverNodeId, err := service.GetRedis().HGet(ServerListDetailPrefix, "1").Result()
	//log.Printf("serverNodeId=%v", serverNodeId)

	var serviceNode *ServerNodJson = nil
	switch serverListType {
	case ServerByID: //21根据id获取对应服务器状态 http://127.0.0.1:8088/serverlist?type=21&id=1
		serviceNode = GetServerByIDFromRedis(c)
	case ServerRecommend: //22获取推荐服务器（玩家自己登录过的游戏，和最后一个服务器） serverlist?type=3&openid=abcd
		//openID登录的服务器信息
		errStr, ret := GetServerByOpenIdFromRedis(c)
		if !ret {
			c.JSON(http.StatusOK, gin.H{
				"err": errStr,
			})
		}
		return
	case ServerAll:
		c.JSON(http.StatusOK, GetServerListFromRedis(c))
		return
	case DefaultServer:
		GetDefaultServerFromRedis(c)
		return
	}

	if serviceNode != nil {
		c.JSON(http.StatusOK, serviceNode)
	} else {
		c.JSON(http.StatusOK, gin.H{
			"err": "no server node!!!",
		})
	}
}

func GetServerByIDFromRedis(c *gin.Context) *ServerNodJson {
	serviceId := c.DefaultQuery("id", "0")
	_, err := strconv.Atoi(serviceId)
	if err != nil {
		return nil
	}

	ip := c.ClientIP()
	bWhite := checkWhiteList(ip, "")
	serverNode := getServerByIDFromRedis(serviceId, bWhite)
	if serverNode == nil {
		return nil
	}
	return serverNode
}

// openID登录的服务器信息/推荐服务器
func GetServerByOpenIdFromRedis(c *gin.Context) (string, bool) {
	var errStr = ""
	openId := c.DefaultQuery("openid", "")     ///default ""
	platform := c.DefaultQuery("platform", "") ///default ""
	if openId == "" {
		errStr = "openid invalid!!!"
		util.InfoF(errStr)
		return errStr, false
	}
	openId = ConvertPlatform(openId, platform)

	keyStr := ServerListOpenIDPrefix + openId
	valList, err := service.GetRedis().HVals(keyStr).Result()
	if err != nil {
		errStr := "openid invalid!!!" + err.Error()
		util.InfoF(errStr)
		return errStr, false
	}

	ip := c.ClientIP()
	bWhite := checkWhiteList(ip, openId)

	recommendServerNode := getRecommendServer(false)
	bFindRecommend := false
	var selfNodeList []*SelfServerNodeDetailJson
	for idx := range valList {
		selfNode := &SelfServerNodeDetailJson{}
		err := json.Unmarshal([]byte(valList[idx]), selfNode)
		if err != nil {
			continue
		}

		tmpServerIdStr := strconv.Itoa(int(selfNode.ServerId))
		tmpServerNode := getServerByIDFromRedis(tmpServerIdStr, bWhite)
		if tmpServerNode == nil {
			continue
		}
		selfNode.ServerName = tmpServerNode.ServerName
		selfNode.Ip = tmpServerNode.Ip
		selfNode.Port = tmpServerNode.Port
		selfNode.Type = tmpServerNode.Type
		selfNode.STime = tmpServerNode.STime

		tmpSTime := util.GetTimeByStr(tmpServerNode.STime)
		selfNode.STimeStamp = uint64(tmpSTime.Unix())

		if !bWhite {
			selfNode.State = tmpServerNode.State
		}

		if recommendServerNode != nil && recommendServerNode.ServerId == int(selfNode.ServerId) {
			selfNode.New = true
			bFindRecommend = true
		}
		selfNodeList = append(selfNodeList, selfNode)
	}

	if !bFindRecommend && recommendServerNode != nil {
		selfNode := &SelfServerNodeDetailJson{}

		selfNode.ServerId = int32(recommendServerNode.ServerId)
		selfNode.ServerName = recommendServerNode.ServerName
		selfNode.Ip = recommendServerNode.Ip
		selfNode.Port = recommendServerNode.Port
		selfNode.Type = recommendServerNode.Type
		selfNode.STime = recommendServerNode.STime

		tmpSTime := util.GetTimeByStr(recommendServerNode.STime)
		selfNode.STimeStamp = uint64(tmpSTime.Unix())

		if !bWhite {
			selfNode.State = recommendServerNode.State
		}
		selfNode.New = true
		selfNodeList = append(selfNodeList, selfNode)
	}
	c.JSON(http.StatusOK, selfNodeList)
	return "", true
}

func GetServerListFromRedis(c *gin.Context) interface{} {
	pageIdStr := c.DefaultQuery("page", "0")
	pageId, err := strconv.Atoi(pageIdStr)
	if err != nil {
		return nil
	}

	ip := c.ClientIP()
	bWhite := checkWhiteList(ip, "")

	var allServer AllServerST
	serverNum := getServerListNum()
	allServer.ServerNum = serverNum
	allServer.Page = 10
	if !bWhite {
		maxServerIdStr, err := service.GetRedis().HGet(ServerListDefault, "maxnode").Result()
		if err == nil {
			allServer.MaxServerId, _ = strconv.Atoi(maxServerIdStr)
		}
	} else {
		maxServerIdStr, err := service.GetRedis().HGet(ServerListDefault, "wmaxnode").Result()
		if err == nil {
			allServer.MaxServerId, _ = strconv.Atoi(maxServerIdStr)
		}
	}

	if pageId <= 0 {
		pageId = allServer.MaxServerId / 10
		if allServer.MaxServerId%10 != 0 {
			pageId += 1
		}
		if pageId <= 0 {
			pageId = 1
		}
	}

	eIdx := pageId * 10
	sIdx := eIdx - 10
	if eIdx > allServer.MaxServerId {
		eIdx = allServer.MaxServerId
	}

	recommendServerNode := getRecommendServer(false)
	for idx := sIdx; idx < eIdx; idx++ {
		idxStr := strconv.Itoa(idx + 1)
		serverNode := getServerByIDFromRedis(idxStr, bWhite)
		if serverNode == nil {
			continue
		}

		if !bWhite && serverNode.Invisible > 0 {
			continue
		}
		if serverNode.ServerId == recommendServerNode.ServerId {
			serverNode.New = true
		}

		allServer.ServerList = append(allServer.ServerList, serverNode)
	}
	return allServer
}

func GetDefaultServerFromRedis(c *gin.Context) {
	recommendServerNode := getRecommendServer(false)

	openId := c.DefaultQuery("openid", "")     ///default ""
	platform := c.DefaultQuery("platform", "") ///default ""
	openId = ConvertPlatform(openId, platform)
	ip := c.ClientIP()
	bWhite := checkWhiteList(ip, "")

	if openId == "" {
		//白名单中玩家，服务器不进入维护状态
		if bWhite && recommendServerNode != nil {
			recommendServerNode.State = 0
			recommendServerNode.Invisible = 0
		}
		c.JSON(http.StatusOK, recommendServerNode)
		return
	}

	if bWhite && recommendServerNode != nil {
		recommendServerNode.State = 0
		recommendServerNode.Invisible = 0
	}

	keyStr := ServerListOpenIDPrefix + openId
	valList, err := service.GetRedis().HVals(keyStr).Result()
	if err != nil {
		c.JSON(http.StatusOK, recommendServerNode)
		return
	}
	var selfNodeInfo *SelfServerNodeDetailJson = nil
	for idx := range valList {
		tmpNode := &SelfServerNodeDetailJson{}
		err := json.Unmarshal([]byte(valList[idx]), tmpNode)
		if err != nil {
			continue
		}

		if selfNodeInfo == nil || tmpNode.RecordTime > selfNodeInfo.RecordTime {
			selfNodeInfo = tmpNode
		}
	}
	if selfNodeInfo != nil {
		tmpServerIdStr := strconv.Itoa(int(selfNodeInfo.ServerId))
		tmpServerNode := getServerByIDFromRedis(tmpServerIdStr, bWhite)
		if tmpServerNode != nil {
			c.JSON(http.StatusOK, tmpServerNode)
			return
		}
	}
	c.JSON(http.StatusOK, recommendServerNode)
}

func SetServerInfo(c *gin.Context) {
	severDetailInfoJson := c.DefaultQuery("info", "") ///default ""
	serverNodId := c.DefaultQuery("id", "")
	recommendStr := c.DefaultQuery("recommend", "0")

	_, err := strconv.Atoi(serverNodId)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"err": "服务器id有误",
		})
		return
	}

	serverNode := &ServerNodJson{}
	err = json.Unmarshal([]byte(severDetailInfoJson), serverNode)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"err": "服务器信息有误",
		})
		return
	}
	msgStr := base64.StdEncoding.EncodeToString([]byte(severDetailInfoJson))
	_, err = service.GetRedis().HSet(ServerListDetailPrefix, serverNodId, msgStr).Result()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{
			"err": "服务器信息保存出错",
		})
		return
	}

	//推荐服务器
	if recommendStr != "0" {
		_, err = service.GetRedis().HSet(ServerListDefault, "node", serverNodId).Result()
		if err != nil {
			c.JSON(http.StatusOK, gin.H{
				"err": "推荐服务器信息保存出错",
			})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"err": "服务器信息保存成功(并设置为推荐服务器)",
		})
	} else {
		c.JSON(http.StatusOK, gin.H{
			"err": "服务器信息保存成功",
		})
	}
}

func getServerListNum() int {
	serverNum, err := service.GetRedis().HLen(ServerListDetailPrefix).Result()
	//serverNum, err := service.GetRedis().LLen(SeverListPrefix).Result()
	if err != nil {
		return 0
	}
	return int(serverNum)
}

func getRecommendServer(bForce bool) *ServerNodJson {
	recommendNodeStr, err := service.GetRedis().HGet(ServerListDefault, "node").Result()
	if err != nil && err != service.NIL {
		return nil
	}

	serverNode := getServerByIDFromRedis(recommendNodeStr, false)
	if serverNode == nil {
		serverNode = getServerByIDFromRedis("1", false) //默认第一个服务器
		//maxNodeId, err := service.GetRedis().HGet(ServerListDefault, "maxnodeid").Result()
		//if err != nil {
		//	return nil
		//}
		//serverNode = getServerByIDFromRedis(maxNodeId)
	}
	return serverNode
}

func getServerByIDFromRedis(nodeId string, bWhite bool) *ServerNodJson {
	msgStr, err := service.GetRedis().HGet(ServerListDetailPrefix, nodeId).Result()
	if err != nil {
		return nil
	}

	if err == service.NIL {
		return nil
	}

	serverDetail, _ := base64.StdEncoding.DecodeString(string(msgStr))
	serverNode := &ServerNodJson{}
	err = json.Unmarshal([]byte(serverDetail), serverNode)
	if err != nil {
		return nil
	}
	//白名单玩家状态修改
	//5维护 6待测试
	if bWhite {
		if serverNode.State != 6 {
			serverNode.State = 0
		}
	}
	serverNode.STimeStamp = uint64(util.GetTimeByStr(serverNode.STime).Unix())
	return serverNode
}

func checkWhiteList(clientIp string, openId string) bool {
	if clientIp != "" {
		bWhite, err := service.GetRedis().SIsMember(ServerListWhiteListPrefix, clientIp).Result()
		if err != nil {
			return false
		}
		if bWhite {
			return true
		}
	}
	if openId != "" {
		bWhite, err := service.GetRedis().SIsMember(ServerListWhiteListPrefix, openId).Result()
		if err != nil {
			return false
		}
		if bWhite {
			return true
		}
	}
	return false
}

/*
#白名单列表
whitelist:
  ip:
  - 192.168.1.10
  - 192.168.1.11
  openid:
  - 123123213
  - dfsdfdf
#服务器列表
  #5 表示维护
  #1 ～ 4，分别表示服务器： 空闲、良好、繁忙、火爆 4种状态
serverlist:
- {serverid: 10001,servername: 内网服, ip: 172.16.13.111, port: [21001],type: 1, stime: 2019-12-02 12:00:00, state: 5}
- {serverid: 10002,servername: 外网, ip: 120.55.48.172, port: [21001,21002],type: 2}
- {serverid: 10003,servername: Tap服务器, ip: www.wtgame.cn, port: [21005,21006],type: 3}
- {serverid: 10004,servername: 拥有测试功能的服务器, ip: www.wtgame.cn, port: [21011],type: 5}

- {serverid: 1,servername: 陈海益服, ip: 192.168.10.213, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 2,servername: 内网服, ip: 192.168.10.213, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 3,servername: 王兆灿服, ip: 192.168.10.233, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 4,servername: 陈海益服状态测试, ip: 192.168.10.213, port: [21001,21003], stime: 2020-10-29 12:00:00, state: 4}
- {serverid: 5,servername: 万里辉服, ip: 192.168.10.244, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 6,servername: 王亚兰服, ip: 192.168.10.137, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 7,servername: 黄瑾服, ip: 192.168.10.237, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 8,servername: 顾杰服, ip: 192.168.10.128, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 9,servername: 林江服, ip: 192.168.10.236, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 10,servername: 李嘉颖服, ip: 192.168.10.23, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 11,servername: 李慧勇服, ip: 192.168.10.235, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 12,servername: 徐晨服, ip: 192.168.10.125, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 13,servername: 陈一鸣服, ip: 192.168.10.168, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 14,servername: 刘亦周服, ip: 192.168.10.87, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 15,servername: 王子博服, ip: 192.168.10.222, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 16,servername: 张曦轶服, ip: 192.168.10.138, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 17,servername: 方世琪服, ip: 192.168.10.225, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 18,servername: 吴泽榕服, ip: 192.168.10.207, port: [21001], stime: 2020-10-29 12:00:00}
- {serverid: 1000,servername: 内网服, ip: 192.168.10.213, port: [21001], stime: 2020-10-29 12:00:00}

*/