'normal'

apis/game/qmbz.go

@@ -0,0 +1,135 @@
+package game
+
+import (
+	"encoding/json"
+	"fmt"
+	"ordonnance/common/auth"
+	"ordonnance/common/db"
+	"ordonnance/common/util"
+	"ordonnance/server/dao"
+	"ordonnance/server/model"
+	"ordonnance/server/response"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 注册
+func Register(c *gin.Context) {
+	username, _ := c.GetPostForm("username")
+	password, _ := c.GetPostForm("password")
+
+	if len(password) != 32 || len(username) < 3 {
+		response.ReturnErrMsg(response.PASSWD_ERR, c)
+		return
+	}
+	if _, err := dao.GetUserByName(username); err != nil {
+		response.ReturnErrMsg(response.PLAYER_EXIST, c)
+		return
+	}
+	user := model.User{
+		Username: username,
+		Nickname: username,
+		Password: password,
+	}
+
+	if err := db.GDB.Create(&user).Error; err != nil {
+		response.ReturnErrMsg(response.PLAYER_EXIST, c)
+		return
+	}
+	curtime := int(time.Now().UnixNano() / 1000000)
+	data := fmt.Sprintf("%d|%d|-1", user.UserId, curtime)
+	msg := response.NewMessage(response.OK)
+	msg.Token = auth.AesEncrypt(data)
+	msg.Uid = user.UserId
+	c.JSON(200, msg)
+}
+
+// 登入
+func Login(c *gin.Context) {
+	username, _ := c.GetPostForm("username")
+	password, _ := c.GetPostForm("password")
+
+	if len(password) != 32 || len(username) < 3 {
+		response.ReturnErrMsg(response.PASSWD_ERR, c)
+		return
+	}
+	user, err := dao.GetUserByName(username)
+	if err != nil {
+		response.ReturnErrMsg(response.PLAYER_NOT_EXIST, c)
+		return
+	}
+	curtime := int(time.Now().UnixNano() / 1000000)
+
+	if user.Password != password {
+		response.ReturnErrMsg(response.PASSWD_ERR, c)
+		return
+	}
+
+	data := strconv.Itoa(user.UserId) + "|" + strconv.Itoa(curtime) + "|-1"
+	token := auth.AesEncrypt(data)
+	msg := response.NewMessage(response.OK)
+	msg.Token = token
+	msg.Uid = user.UserId
+
+	if v, err := dao.GetValidBulletin(); err == nil {
+		msg.Data = v
+	}
+	return
+}
+
+// 获取服务器
+func ServerList(c *gin.Context) {
+	token := c.PostForm("token")
+	tokenData, err := util.ParseToken(token)
+	if err != nil {
+		response.ReturnErrMsg(response.ERR_PARM, c)
+		return
+	}
+	version := c.DefaultPostForm("version", "B")
+	userID := tokenData.UserId
+	historyList, _ := dao.GetIUserServerByUid(userID, version)
+	serverList, _ := dao.GetAllServer(version)
+	retData := struct {
+		HistoryList interface{} `json:"historyList"`
+		ServerList  interface{} `json:"serverList"`
+	}{
+		HistoryList: historyList,
+		ServerList:  serverList,
+	}
+	c.JSON(200, retData)
+}
+
+func GetGate(c *gin.Context) {
+	tokenData, err := util.ParseToken(c.PostForm("token"))
+	if err != nil {
+		response.ReturnErrMsg(response.ERR_PARM, c)
+		return
+	}
+	version := c.DefaultPostForm("version", "B")
+	version = strings.TrimSpace(version)
+	serverID := c.PostForm("serverId")
+	data := fmt.Sprintf("%v|%v|%v|%v", tokenData.UserId, time.Now().UnixNano()/1000000, 0, 2)
+	token := auth.AesEncrypt(data)
+	rowServer, _ := dao.GetServerInfo(serverID)
+	retData := model.Server{
+		Server:          map[string]string{"0": rowServer.Name},
+		Net:             model.ServerNet{},
+		GamePlatform:    rowServer.GamePlatform,
+		Path:            model.ServerPath{},
+		IsDebugVersions: 1 == rowServer.IsDebugVersions,
+		Tpl:             model.ServerTpl{},
+		Opendns:         []string{},
+		Token:           token,
+		RealAuth:        2,
+	}
+	json.Unmarshal([]byte(rowServer.Net), &retData.Net)
+	json.Unmarshal([]byte(rowServer.Tpl), &retData.Tpl)
+	json.Unmarshal([]byte(rowServer.Opendns), &retData.Opendns)
+	msg := response.NewMessage(response.OK)
+	// tmpData, _ := util.ParseToken(token)
+	msg.Data = retData
+	c.JSON(200, msg)
+}

common/auth/auth.go

@@ -0,0 +1,114 @@
+package auth
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/hex"
+)
+
+var secret = "0a113ef6b61820daa5611c870ed8d5ee"
+
+func AesDecrypt(token string) string {
+	tokenByte, err := hex.DecodeString(token)
+	if err != nil {
+		return ""
+	}
+	block, err := aes.NewCipher([]byte(secret))
+	if err != nil {
+		//fmt.Println("err is:", err)
+		return ""
+	}
+	blockMode := NewECBDecrypter(block)
+	origData := make([]byte, len(tokenByte))
+	blockMode.CryptBlocks(origData, []byte(tokenByte))
+	origData = PKCS5UnPadding(origData)
+	return string(origData)
+}
+
+func AesEncrypt(src string) string {
+	block, err := aes.NewCipher([]byte(secret))
+	if err != nil {
+		return ""
+	}
+	//src := fmt.Sprintf("%v|%v|%v", uid, time.Now().UnixNano()/1000000, areaId)
+	ecb := NewECBEncrypter(block)
+	content := []byte(src)
+	content = PKCS5Padding(content, block.BlockSize())
+	crypted := make([]byte, len(content))
+	ecb.CryptBlocks(crypted, content)
+
+	return hex.EncodeToString(crypted)
+}
+
+func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+func PKCS5UnPadding(origData []byte) []byte {
+	length := len(origData)
+	unpadding := int(origData[length-1])
+	return origData[:(length - unpadding)]
+}
+
+type ecb struct {
+	b         cipher.Block
+	blockSize int
+}
+
+func newECB(b cipher.Block) *ecb {
+	return &ecb{
+		b:         b,
+		blockSize: b.BlockSize(),
+	}
+}
+
+type ecbEncrypter ecb
+
+// NewECBEncrypter returns a BlockMode which encrypts in electronic code book
+// mode, using the given Block.
+func NewECBEncrypter(b cipher.Block) cipher.BlockMode {
+	return (*ecbEncrypter)(newECB(b))
+}
+func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
+func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
+	if len(src)%x.blockSize != 0 {
+		panic("crypto/cipher: input not full blocks")
+	}
+	if len(dst) < len(src) {
+		panic("crypto/cipher: output smaller than input")
+	}
+	for len(src) > 0 {
+		x.b.Encrypt(dst, src[:x.blockSize])
+		src = src[x.blockSize:]
+		dst = dst[x.blockSize:]
+	}
+}
+
+type ecbDecrypter ecb
+
+// NewECBDecrypter returns a BlockMode which decrypts in electronic code book
+// mode, using the given Block.
+func NewECBDecrypter(b cipher.Block) cipher.BlockMode {
+	return (*ecbDecrypter)(newECB(b))
+}
+func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
+func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
+	if len(src)%x.blockSize != 0 {
+		panic("crypto/cipher: input not full blocks")
+	}
+	if len(dst) < len(src) {
+		panic("crypto/cipher: output smaller than input")
+	}
+	for len(src) > 0 {
+		x.b.Decrypt(dst, src[:x.blockSize])
+		src = src[x.blockSize:]
+		dst = dst[x.blockSize:]
+	}
+}
+
+func CalSign() (string, error) {
+	return "", nil
+}

common/util/game.go

@@ -0,0 +1,51 @@
+package util
+
+import (
+	"errors"
+	"ordonnance/common/auth"
+	"strconv"
+	"strings"
+)
+
+type TokenDsta struct {
+	UserId      int   `json:"userId"`
+	MilliSecond int64 `json:"milliSecond"`
+	AreaId      int   `json:"areaId"`
+	AuthFlg     int   `json:"authFlg"`
+}
+
+func ParseToken(tokenStr string) (*TokenDsta, error) {
+	retErr := errors.New("parse token err")
+	if len(tokenStr) < 1 {
+		return nil, retErr
+	}
+	srcToken := auth.AesDecrypt(tokenStr)
+	if len(srcToken) < 10 {
+		return nil, retErr
+	}
+	srcSplic := strings.Split(srcToken, "|")
+	if len(srcSplic) != 3 && len(srcSplic) != 4 {
+		return nil, retErr
+	}
+	userId, err := strconv.ParseInt(srcSplic[0], 10, 64)
+	if err != nil || userId < 1 {
+		return nil, retErr
+	}
+	milliSecond, err := strconv.ParseInt(srcSplic[1], 10, 64)
+	if err != nil || milliSecond < 1 {
+		return nil, retErr
+	}
+	areaId, err := strconv.ParseInt(srcSplic[2], 10, 64)
+	if err != nil {
+		return nil, retErr
+	}
+	tokenData := &TokenDsta{
+		UserId:      int(userId),
+		MilliSecond: milliSecond,
+		AreaId:      int(areaId),
+	}
+	if len(srcSplic) == 4 {
+		tokenData.AuthFlg, _ = strconv.Atoi(srcSplic[3])
+	}
+	return tokenData, nil
+}

route/index.go

@@ -1,6 +1,7 @@
 package route
 
 import (
+	"ordonnance/apis/game"
 	"ordonnance/apis/third"
 	"ordonnance/common/corn"
 	"ordonnance/common/middleware"
@@ -17,6 +18,11 @@ func RunService(myport string) {
 	// base
 	r.GET("/ordonnance/qrcode/:ordonnanceId", third.GetordonnanceQrcode)
 	r.POST("/ordonnance/detail/:ordonnanceId", third.GetordonnanceDetail)
+
+	r.POST("/account/login", game.Login)
+	r.POST("/account/register", game.Register)
+	r.POST("/account/serverList", game.ServerList)
+	r.POST("/account/getGate", game.GetGate)
 	//
 	logger.Infof("strat http server @port=%s", myport)
 	r.Run(":" + myport)

server/dao/bulletin.go

@@ -0,0 +1,13 @@
+package dao
+
+import (
+	"ordonnance/common/db"
+	"ordonnance/server/model"
+	"time"
+)
+
+func GetValidBulletin() (list []model.Bulletin, err error) {
+	now := time.Now().Format("2006-01-02 15:04:05")
+	err = db.GDB.Where("startTime<? and endTime>? AND status=0", now, now).Find(&list).Error
+	return
+}

server/dao/game.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"ordonnance/common/db"
+	"ordonnance/server/model"
+)
+
+func GetIUserServerByUid(uid int, version string) (list []model.LUserServer, err error) {
+	err = db.GDB.Where("userId=? AND version=?", uid, version).
+		Find(&list).Error
+	return
+}
+
+func GetAllServer(version string) (list []model.TServer, err error) {
+	err = db.GDB.Where("version=?", version).
+		Find(&list).Error
+	return
+}
+
+func GetServerInfo(serverId string) (info model.TServerInfo, err error) {
+	err = db.GDB.Where("id=?", serverId).
+		First(&info).Error
+	return
+}

server/dao/user.go

@@ -0,0 +1,12 @@
+package dao
+
+import (
+	"ordonnance/common/db"
+	"ordonnance/server/model"
+)
+
+// 获取 药方
+func GetUserByName(name string) (info model.User, err error) {
+	err = db.GDB.Where("username=?", name).First(&info).Error
+	return
+}

server/model/bulletin.go

@@ -0,0 +1,12 @@
+package model
+
+type Bulletin struct {
+	Id        int    `json:"id" gorm:"primaryKey"`
+	StartTime string `json:"startTime"`
+	EndTime   string `json:"endTime"`
+	Detail    string `json:"detail"`
+}
+
+func (t Bulletin) TableName() string {
+	return "bulletin"
+}

server/model/game.go

@@ -0,0 +1,67 @@
+package model
+
+type LUserServer struct {
+	Id       int    `json:"id" gorm:"primaryKey"`
+	UserId   int    `json:"userId"`
+	Version  string `json:"version"`
+	ServerId int    `json:"serverId"`
+}
+
+func (t LUserServer) TableName() string {
+	return "l_user_server"
+}
+
+type TServer struct {
+	Id          int    `json:"id" gorm:"primaryKey"`
+	Version     string `json:"version"`
+	Name        string `json:"name"`
+	IsNew       int8   `json:"isNew"`
+	Status      int    `json:"status"`
+	IsRecommend int    `json:"isRecommend"`
+}
+
+type TServerInfo struct {
+	TServer
+	Host            string `json:"-"`
+	Port            int    `json:"-"`
+	Protocal        string `json:"-"`
+	Path            string `json:"-"`
+	Net             string `json:"-"`
+	GamePlatform    int    `json:"-"`
+	IsDebugVersions int    `json:"-"`
+	Tpl             string `json:"-"`
+	Opendns         string `json:"-"`
+	AreaId          int    `json:"-"`
+}
+
+func (t TServer) TableName() string {
+	return "t_server"
+}
+
+type Server struct {
+	Server          interface{} `json:"server"`
+	Net             ServerNet   `json:"net"`
+	GamePlatform    int         `json:"gamePlatform"`
+	Path            ServerPath  `json:"path"`
+	IsDebugVersions bool        `json:"isDebugVersions"`
+	Tpl             ServerTpl   `json:"tpl"`
+	Opendns         []string    `json:"opendns"`
+	Token           string      `json:"token"`
+	RealAuth        int         `json:"realAuth"`
+}
+type ServerNet struct {
+	BaseUrl     string `json:"baseUrl"`
+	LoginUrl    string `json:"loginUrl"`
+	RegUrl      string `json:"regUrl"`
+	GateHost    string `json:"gateHost"`
+	GatePort    string `json:"gatePort"`
+	HttpRequest string `json:"httpRequest"`
+}
+type ServerPath struct {
+	Res  string `json:"res"`
+	Anim string `json:"anim"`
+	Data string `json:"data"`
+}
+type ServerTpl struct {
+	Path string `json:"path"`
+}

server/model/user.go

@@ -0,0 +1,12 @@
+package model
+
+type User struct {
+	UserId   int    `json:"userId" gorm:"primaryKey"`
+	Username string `json:"username"`
+	Nickname string `json:"nickname"`
+	Password string `json:"password"`
+}
+
+func (User) TableName() string {
+	return "t_user"
+}

server/response/retmsg.go

@@ -0,0 +1,109 @@
+package response
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+var codeMsg map[int]string
+
+type Message struct {
+	Code  int         `json:"code"`
+	Msg   string      `json:"msg"`
+	Data  interface{} `json:"data,omitempty"`
+	Token string      `json:"token,omitempty"`
+	Uid   int         `json:"uid,omitempty"`
+}
+
+//var MessageMap map[int]*Message
+func NewMessage(code int) *Message {
+	if _, ok := codeMsg[code]; !ok {
+		code = ERR_PARM
+	}
+	return &Message{
+		Code: code,
+		Msg:  codeMsg[code],
+	}
+}
+
+const (
+	OK              int = 200
+	LOGOUT          int = 401
+	USER_PASWD_FAIL int = 402
+	IP_ERR          int = 404
+	NOT_ADMIN       int = 405
+	PLOT_END        int = 501
+
+	ERR_PARM int = 10000
+	ERR_SYS  int = 10001
+	DB_ERROR int = 10003
+
+	ERR_PARSING int = 10004
+	METHOD_ERR  int = 10005
+
+	PLAYER_NOT_EXIST int = 5205
+	PLAYER_EXIST     int = 5206
+
+	FRIEND_ALREADY_INVITE int = 57001
+	FRIEND_OFFLINE        int = 57002
+
+	USERNAME_NOT_EXIST int = 1021
+	PASSWD_ERR         int = 1022
+	USERNAME_ERR       int = 1025
+	IDNUM_ERR          int = 1026
+	NAME_ERR           int = 1027
+
+	TPL_UPDATE_ERR int = 2001
+
+	TRANS_FILE_ERR        int = 3001
+	TRANS_FILE_UPLOAD_ERR int = 3002
+	TRANS_FILE_CREATE_ERR int = 3003
+	TRANS_FILE_WRITE_ERR  int = 3004
+
+	SERVER_OFF int = 3005
+
+	FILTER_LIST_ERR int = 4001
+)
+
+func init() {
+	codeMsg = make(map[int]string)
+	codeMsg[OK] = "成功"
+	codeMsg[LOGOUT] = "用户未登陆"
+	codeMsg[USER_PASWD_FAIL] = "用户名或密码错误"
+	codeMsg[IP_ERR] = "IP不合法"
+	codeMsg[NOT_ADMIN] = "非超级管理员"
+
+	codeMsg[PLOT_END] = "剧情结束"
+
+	codeMsg[ERR_PARM] = "参数错误"
+	codeMsg[ERR_SYS] = "系统错误"
+	codeMsg[DB_ERROR] = "数据库异常"
+	codeMsg[ERR_PARSING] = "解析JSON出错"
+	codeMsg[METHOD_ERR] = "Method not allowed"
+
+	codeMsg[PLAYER_NOT_EXIST] = "玩家不存在"
+	codeMsg[PLAYER_EXIST] = "玩家已存在"
+
+	codeMsg[FRIEND_ALREADY_INVITE] = "已经申请"
+	codeMsg[FRIEND_OFFLINE] = "对方离线"
+
+	codeMsg[USERNAME_NOT_EXIST] = "用户不存在"
+	codeMsg[PASSWD_ERR] = "密码错误"
+	codeMsg[USERNAME_ERR] = "用户名异常"
+	codeMsg[IDNUM_ERR] = "身份证号码异常"
+	codeMsg[NAME_ERR] = "名字异常"
+
+	codeMsg[TPL_UPDATE_ERR] = "模板今天数据更新失败"
+
+	codeMsg[TRANS_FILE_ERR] = "transFile err"
+	codeMsg[TRANS_FILE_UPLOAD_ERR] = "Read file error"
+	codeMsg[TRANS_FILE_CREATE_ERR] = "Create file error"
+	codeMsg[TRANS_FILE_WRITE_ERR] = "Write file error"
+	codeMsg[SERVER_OFF] = "服务器关闭"
+
+	codeMsg[FILTER_LIST_ERR] = "敏感词更新失败"
+}
+
+func ReturnErrMsg(code int, c *gin.Context) {
+	// 开始时间
+	c.JSON(200, NewMessage(code))
+}