tyj_admin/internal/serviceGame/loginUrl.go

package serviceGame

import (
	"context"
	"errors"
	"fmt"
	"github.com/gogf/gf/v2/encoding/gcharset"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/frame/g"
	"log"
	"strings"
	"tyj_admin/api/v1/game"
	"tyj_admin/internal/consts"
	"tyj_admin/internal/dao"
	"tyj_admin/internal/model/entity"
	"tyj_admin/internal/service"
	"tyj_admin/internal/serviceGame/internal"
	"tyj_admin/library/libUtils"
	"tyj_admin/library/liberr"
	"tyj_admin/utils"
)

type IGameLoginUrl interface {
	GetLoginUrl(ctx context.Context, req *game.GetLoginUrlReq) (res *game.GetLoginUrlRes, err error)
	GetServerConfigGeneral(ctx context.Context, req *game.GetServerConfigGeneralReq) (res *game.GetServerConfigGeneralRes, err error)
	AddServerConfigGeneral(ctx context.Context, req *game.AddServerConfigGeneralReq) (res *game.AddServerConfigGeneralRes, err error)
	GetAllLoginUrl(ctx context.Context, req *game.GetAllLoginUrlReq) (res *game.GetAllLoginUrlRes, err error)
	AddLoginUrl(ctx context.Context, req *game.AddLoginUrlReq) (res *game.AddLoginUrlRes, err error)
	DelLoginUrl(ctx context.Context, req *game.DelLoginUrlReq) (res *game.DelLoginUrlRes, err error)
	GetGameLoginUrl(ctx context.Context, req *game.GetGameLoginUrlReq) (res *game.GetGameLoginUrlRes, err error)
	ReConfigServer(ctx context.Context, req *game.ReConfigServerReq) (res *game.ReConfigServerRes, err error)
	GetAllCcdUrl(ctx context.Context, req *game.GetAllCcdUrlReq) (res *game.GetAllCcdUrlRes, err error)
	AddServerConfig(ctx context.Context, req *game.AddServerConfigReq) (res *game.AddServerConfigRes, err error)
	GetRouter(ctx context.Context, req *game.GetRouterReq) (res *game.GetRouterRes, err error)
	GetServerVersionList(ctx context.Context, req *game.GetServerVersionListReq) (res *game.GetServerVersionListRes, err error)
	UpdateRouter(ctx context.Context, req *game.AddRouterReq) (res *game.AddRouterRes, err error)
	ServerUpdateMsg(ctx context.Context, req *game.ServerUpdateMsgReq) (res *game.ServerUpdateMsgRes, err error)
}

type gameLoginUrlImpl struct {
}

var gameLoginUrlService = gameLoginUrlImpl{}

func GameLoginUrl() IGameLoginUrl {
	return &gameLoginUrlService
}
func (c *gameLoginUrlImpl) GetLoginUrl(ctx context.Context, req *game.GetLoginUrlReq) (res *game.GetLoginUrlRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetLoginUrlRes)
		model := dao.GameLoginUrl.Ctx(ctx)
		res.Total, err = model.Count()
		liberr.ErrIsNil(ctx, err, "mysql err")
		model = model.Page(req.PageNum, req.PageSize)
		err = model.Scan(&res.LoginUrlList)

		//service.Email().SendEmail(ctx, &system.SendEmailReq{})
	})
	return
}
func (c *gameLoginUrlImpl) GetServerConfigGeneral(ctx context.Context, req *game.GetServerConfigGeneralReq) (res *game.GetServerConfigGeneralRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetServerConfigGeneralRes)
		err = dao.GameServerJsonGeneral.Ctx(ctx).Scan(&res.List)
		liberr.ErrIsNil(ctx, err, "mysql err")
	})
	return
}

func (c *gameLoginUrlImpl) AddServerConfigGeneral(ctx context.Context, req *game.AddServerConfigGeneralReq) (res *game.AddServerConfigGeneralRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.AddServerConfigGeneralRes)
		_, err = dao.GameServerJsonGeneral.Ctx(ctx).Where("id=?", req.Id).Update(g.Map{
			dao.GameServerJsonGeneral.Columns().BackstageRechargeUrl: req.BackstageRechargeUrl,
			dao.GameServerJsonGeneral.Columns().IdentityCheckAddress: req.IdentityCheckAddress,
			dao.GameServerJsonGeneral.Columns().UniqueAddress:        req.UniqueAddress,
			dao.GameServerJsonGeneral.Columns().RechargeWhiteListIps: req.RechargeWhiteListIps,
			dao.GameServerJsonGeneral.Columns().GmWhiteListUrl:       req.GmWhiteListUrl,
			dao.GameServerJsonGeneral.Columns().SdkAddress:           req.SdkAddress,
		})
		liberr.ErrIsNil(ctx, err, "mysql err")
	})
	return
}

func (c *gameLoginUrlImpl) GetAllLoginUrl(ctx context.Context, req *game.GetAllLoginUrlReq) (res *game.GetAllLoginUrlRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetAllLoginUrlRes)
		res.LoginUrlList = internal.ServerList
	})
	return
}

func (c *gameLoginUrlImpl) AddLoginUrl(ctx context.Context, req *game.AddLoginUrlReq) (res *game.AddLoginUrlRes, err error) {
	res = new(game.AddLoginUrlRes)
	err = g.Try(ctx, func(ctx context.Context) {
		server := []entity.GameLoginUrl{}
		model := dao.GameLoginUrl.Ctx(ctx)
		model.WherePri(req.Id).Scan(&server)
		if len(server) > 0 {
			data := g.Map{
				dao.GameLoginUrl.Columns().Id: req.Id,
			}
			if req.IsNew != "" {
				data[dao.GameLoginUrl.Columns().IsNew] = req.IsNew
			}
			if req.Recommend != "" {
				data[dao.GameLoginUrl.Columns().Recommend] = req.Recommend
			}
			if req.State != "" {
				data[dao.GameLoginUrl.Columns().State] = req.State
			}
			if req.Host != "" {
				data[dao.GameLoginUrl.Columns().Host] = req.Host
			}
			if req.Port != 0 {
				data[dao.GameLoginUrl.Columns().Port] = req.Port
			}
			_, err = model.WherePri(req.Id).Update(data)
		}
	})
	return
}

func (c *gameLoginUrlImpl) DelLoginUrl(ctx context.Context, req *game.DelLoginUrlReq) (res *game.DelLoginUrlRes, err error) {
	err = g.Try(ctx, func(ctx context.Context) {
		if req.Id == 0 {
			liberr.ErrIsNil(ctx, err, "错误的id")
			return
		}
		_, e := dao.GameLoginUrl.Ctx(ctx).Where("id=", req.Id).Delete()
		if e != nil {
			liberr.ErrIsNil(ctx, e, "删除通知失败")
			return
		}
	})

	return
}

func (c *gameLoginUrlImpl) GetGameLoginUrl(ctx context.Context, req *game.GetGameLoginUrlReq) (res *game.GetGameLoginUrlRes, err error) {
	res = new(game.GetGameLoginUrlRes)
	ip := libUtils.GetClientIp(ctx)
	list, _ := internal.GetWhiteList(ctx)
	blackList, _ := internal.GetBlackList(ctx)
	account := req.Account
	if req.Channel == consts.Channel_Editor && !strings.Contains(account, req.Channel) {
		account = req.Channel + account
	}

	g.Log().Debugf(ctx, "GetWhiteList -> ", req.Account, gjson.MustEncodeString(list), ip)
	err = g.Try(ctx, func(ctx context.Context) {
		var LoginUrlList []*entity.GameLoginUrl
		err = dao.GameLoginUrl.Ctx(ctx).Where("isShow=?", 1).Scan(&LoginUrlList)
		var unitData []*entity.GameUnit
		if req.Account != "" {
			err = dao.GameUnit.Ctx(ctx).Where("channel=?", req.Channel).Where("account=?", account).Scan(&unitData)
		}

		if err != nil || len(LoginUrlList) == 0 {
			liberr.ErrIsNil(ctx, err, "获取服务器失败")
			return
		}

		if req.Channel == "000005000000" && req.Version == "1.0.1" && req.VersionName != "" {
			req.Version = "1.0.2"
		}

		logTime := int64(0)
		last := 0
		channel := ";"
		if internal.LoginUrlChannelList(ctx, req.Channel+req.Version) == 1 {
			channel += req.Channel + req.Version
		} else if internal.LoginUrlChannelList(ctx, req.Channel) == 1 {
			channel += req.Channel
		} else if internal.LoginUrlChannelList(ctx, req.Version) == 1 {
			channel += req.Version
		}
		channel += ";"
		for _, v := range LoginUrlList {
			if v.IsShow != 1 {
				continue
			}
			if !strings.Contains(v.Channel, channel) {
				continue
			}

			var data = game.LoginUrlData{Id: v.Id, Host: v.Host, Port: v.Port, Difficulty: v.Difficulty, IsNew: v.IsNew,
				Recommend: v.Recommend, Name: v.Name, State: v.State, Area: v.Area, CreateTime: v.CDate.Unix()}
			if data.State == consts.Login_URL_STATE_WHITE {
				if utils.ContainsWhiteList(list, ip) || utils.ContainsWhiteList(list, req.Channel) {
					data.State = consts.Login_URL_STATE_NORMAL
				} else {
					data.State = consts.Login_URL_STATE_Maintenance
					data.Host = consts.DEFAULT_HOST
				}
			}
			if data.State == consts.Login_URL_STATE_BLACK {
				if !utils.ContainsBlackList(blackList, req.Channel) || utils.ContainsWhiteList(list, ip) {
					data.State = consts.Login_URL_STATE_NORMAL
				} else {
					data.State = consts.Login_URL_STATE_Maintenance
					data.Host = consts.DEFAULT_HOST
				}
			}
			for _, v1 := range unitData {
				if v1.Server == data.Id {
					data.AccountName = v1.Name
					data.Scale = v1.Scale
					if logTime < v1.LogTime {
						logTime = v1.LogTime
						last = v1.Server
					}
				}
			}
			res.UrlStr = append(res.UrlStr, data)
		}
		for i := 0; i < len(res.UrlStr); i++ {
			if res.UrlStr[i].Id == last {
				res.UrlStr[i].Last = 1
				break
			}
		}

		g.Log().Debugf(ctx, "GetGameLoginUrl -> ", req.Account, gjson.MustEncodeString(res), last)
		return
	})

	return
}

func (c *gameLoginUrlImpl) ReConfigServer(ctx context.Context, req *game.ReConfigServerReq) (res *game.ReConfigServerRes, err error) {
	if req.SType == 2 {
		service.AliYunSms().ConfigInit()
		service.Email().ConfigInit()
		service.TencentSms().ConfigInit()
		internal.InitChannel(ctx)
		internal.WebHookInit(ctx)
	} else {
		internal.InitServer(ctx)
		internal.InitRechargeServer(ctx)
		internal.InitRouterServer(ctx)
		internal.MongoInit(ctx)
	}
	return
}

func (c *gameLoginUrlImpl) GetAllCcdUrl(ctx context.Context, req *game.GetAllCcdUrlReq) (res *game.GetAllCcdUrlRes, err error) {
	res = new(game.GetAllCcdUrlRes)
	g.Try(ctx, func(ctx context.Context) {
		err = dao.GameCcdVersion.Ctx(ctx).Scan(&res.List)
		log.Printf("ccdBox: %v", res.List)
	})
	return
}

func (c *gameLoginUrlImpl) GetRouter(ctx context.Context, req *game.GetRouterReq) (res *game.GetRouterRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetRouterRes)
		model := dao.GameRouter.Ctx(ctx)
		res.Total, err = model.Count()
		liberr.ErrIsNil(ctx, err, "mysql err")
		model = model.Page(req.PageNum, req.PageSize)
		err = model.Scan(&res.List)
		liberr.ErrIsNil(ctx, err, "mysql err")
	})
	return
}

func (c *gameLoginUrlImpl) AddServerConfig(ctx context.Context, req *game.AddServerConfigReq) (res *game.AddServerConfigRes, err error) {
	res = new(game.AddServerConfigRes)
	err = g.Try(ctx, func(ctx context.Context) {
		server := []entity.GameLoginUrl{}
		model := dao.GameLoginUrl.Ctx(ctx)
		model.WherePri(req.Id).Scan(&server)
		if len(server) > 0 {
			_, err = model.WherePri(req.Id).Update(g.Map{
				dao.GameLoginUrl.Columns().Id:         req.Id,
				dao.GameLoginUrl.Columns().GameDbUrl:  req.GameDbUrl,
				dao.GameLoginUrl.Columns().GameDbName: req.GameDbName,
				dao.GameLoginUrl.Columns().Platform:   req.Platform,
				dao.GameLoginUrl.Columns().InnerIp:    req.InnerIp,
				dao.GameLoginUrl.Columns().CreateTime: req.CreateTime,
				dao.GameLoginUrl.Columns().Difficulty: req.Difficulty,
				dao.GameLoginUrl.Columns().Channel:    req.Channel,
			})
		}
	})
	return
}

func (c *gameLoginUrlImpl) UpdateRouter(ctx context.Context, req *game.AddRouterReq) (res *game.AddRouterRes, err error) {
	res = new(game.AddRouterRes)
	err = g.Try(ctx, func(ctx context.Context) {
		server := []entity.GameRouter{}
		model := dao.GameRouter.Ctx(ctx)
		model.WherePri(req.Id).Scan(&server)
		if len(server) > 0 {
			_, err = model.WherePri(req.Id).Update(g.Map{
				dao.GameRouter.Columns().Id:         req.Id,
				dao.GameRouter.Columns().RealmIp:    req.RealmIp,
				dao.GameRouter.Columns().RealmPort:  req.RealmPort,
				dao.GameRouter.Columns().RealmNum:   req.RealmNum,
				dao.GameRouter.Columns().RealmStep:  req.RealmStep,
				dao.GameRouter.Columns().RouterIp:   req.RouterIp,
				dao.GameRouter.Columns().RouterPort: req.RouterPort,
				dao.GameRouter.Columns().RouterNum:  req.RouterNum,
				dao.GameRouter.Columns().RouterStep: req.RouterStep,
			})
		} else {
			_, err = model.Insert(g.Map{
				dao.GameRouter.Columns().Id:         req.Id,
				dao.GameRouter.Columns().RealmIp:    req.RealmIp,
				dao.GameRouter.Columns().RealmPort:  req.RealmPort,
				dao.GameRouter.Columns().RealmNum:   req.RealmNum,
				dao.GameRouter.Columns().RealmStep:  req.RealmStep,
				dao.GameRouter.Columns().RouterIp:   req.RouterIp,
				dao.GameRouter.Columns().RouterPort: req.RouterPort,
				dao.GameRouter.Columns().RouterNum:  req.RouterNum,
				dao.GameRouter.Columns().RouterStep: req.RouterStep,
			})
		}
	})
	return
}

func (c *gameLoginUrlImpl) GetServerVersionList(ctx context.Context, req *game.GetServerVersionListReq) (res *game.GetServerVersionListRes, err error) {
	res = new(game.GetServerVersionListRes)
	ip := internal.ServerConfig[fmt.Sprint(req.Server)]
	url := "http://" + ip + "/get_version"
	bytes := g.Client().GetBytes(ctx, url)
	//fmt.Println("GetOnlineList: ", url, bytes)
	src := string(bytes)
	if g.IsEmpty(src) {
		res.Version = "获取失败"
		return
	}

	srcCharset := "UTF-8"
	tmp, _ := gcharset.ToUTF8(srcCharset, src)
	json, err := gjson.DecodeToJson(tmp)
	if err != nil {
		res.Version = "获取失败"
		return
	}
	//fmt.Println("GetOnlineList - json: ", tmp, gjson.MustEncodeString(json.Get("Accounts").Array()))
	if json.Get("Error").Int() == 200 {
		res.Version = json.Get("Message").String()
	} else {
		res.Version = "获取失败"
	}
	return
}

func (c *gameLoginUrlImpl) ServerUpdateMsg(ctx context.Context, req *game.ServerUpdateMsgReq) (res *game.ServerUpdateMsgRes, err error) {
	//url := "https://open.feishu.cn/open-apis/bot/v2/hook/4033c60d-08b4-4d28-8eab-1d4159df98ed"
	//url := "https://open.feishu.cn/open-apis/bot/v2/hook/6c2ebace-6815-49a8-9964-eb580ec0a56b"
	url := internal.Webhook
	if len(url) == 0 {
		return nil, errors.New("地址为空！")
	}
	normal_v2 := map[string]interface{}{"default": "normal", "pc": "normal", "mobile": "heading"}
	text_size := map[string]interface{}{"normal_v2": normal_v2}
	style := map[string]interface{}{"text_size": text_size}
	config := map[string]interface{}{"update_multi": true, "style": style}
	elements := []map[string]interface{}{
		{
			"tag":        "markdown",
			"content":    req.Content,
			"text_align": "left",
			"text_size":  "normal_v2",
			"margin":     "0px 0px 0px 0px",
		},
	}
	body1 := map[string]interface{}{"direction": "vertical", "padding": "12px 12px 12px 12px", "elements": elements}
	title := map[string]interface{}{"tag": "plain_text", "content": req.Title}
	subtitle := map[string]interface{}{"tag": "plain_text", "content": req.Subtitle}
	header := map[string]interface{}{"title": title, "template": "blue", "subtitle": subtitle, "padding": "12px 12px 12px 12px"}
	card := map[string]interface{}{"schema": "2.0", "config": config, "body": body1, "header": header}
	body := map[string]interface{}{"msg_type": "interactive", "card": card}
	fmt.Println("GetOnlineList - body: ", gjson.MustEncodeString(body))
	bytes := g.Client().PostBytes(ctx, url, gjson.MustEncodeString(body))
	src := string(bytes)
	if g.IsEmpty(src) {
		return
	}

	srcCharset := "UTF-8"
	tmp, _ := gcharset.ToUTF8(srcCharset, src)
	json, err := gjson.DecodeToJson(tmp)
	if err != nil {
		return
	}
	fmt.Println("GetOnlineList - json: ", tmp)
	if json.Get("code").Int() != 0 {
		err = errors.New(json.Get("msg").String())
	}
	return
}