xpggame/modules/backend/app/response.go

package app

import (
	"encoding/json"
	"fmt"
	"net/http"
	"reflect"
	"server/call"
	"server/common"
	"server/db"
	"server/modules/backend/bdb"
	"server/modules/backend/values"
	"server/natsClient"
	"server/pb"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	"gorm.io/gorm"
)

type Gin struct {
	C *gin.Context
	R
	User *values.User
}

type R struct {
	Data interface{} `json:"data"`
	Msg  string      `json:"msg"`
	Code int         `json:"code"`
}

func NewApp(c *gin.Context) *Gin {
	g := &Gin{C: c, R: R{Code: values.CodeOK, Msg: "ok"}}
	user, ex := c.Get("user")
	if ex {
		g.User = user.(*values.User)
		if len(g.User.Channels) > 0 {
			json.Unmarshal([]byte(g.User.Channels), &g.User.SChannels)
		}
	}
	return g
}

// Response setting gin.JSON
func (g *Gin) Response() {
	if g.Code == values.CodeRetry {
		g.Msg = "内部错误"
	} else if g.Code == values.CodePower {
		g.Msg = "您无权操作此项"
	}
	g.C.JSON(http.StatusOK, g.R)
}

func (g *Gin) RecordEdit(t int, detail string) {
	u, _ := g.C.Get("user")
	user := u.(*values.User)
	one := &values.EditHistory{Model: t, Detail: detail, Time: time.Now().Unix(), Operator: user.Name, UID: int(user.ID)}
	bdb.BackDB.Create(one)
}

func (g *Gin) S(one interface{}) (pass bool) {
	err := g.C.ShouldBind(one)
	if err != nil {
		g.R.Code = values.CodeParam
		g.R.Msg = err.Error()
		log.Error("bind %v err:%v", reflect.TypeOf(one), err)
		return
	}
	pass = true
	return
}

// U 统一json解析方法
func (g *Gin) U(src []byte, tar interface{}) (pass bool) {
	err := json.Unmarshal(src, tar)
	if err != nil {
		log.Error("%v err:%v", reflect.TypeOf(tar), err)
		g.R.Code = values.CodeRetry
		g.R.Msg = err.Error()
		return
	}
	pass = true
	return
}

// 从数据库中读取数据
func (g *Gin) MGet(tar interface{}) (pass bool) {
	err := db.Mysql().Get(tar)
	if err != nil {
		log.Error("err:%v", err)
		g.R.Code = values.CodeRetry
		g.R.Msg = err.Error()
		return
	}
	pass = true
	return
}

// 从数据库中读取数据
func (g *Gin) MGetAll(model, tar interface{}) (pass bool) {
	sql, sort := values.CheckQueryControl(model)
	if _, err := db.Mysql().QueryAll(sql, sort, model, tar); err != nil {
		log.Error("err:%v", err)
		g.Code = values.CodeRetry
		g.R.Msg = err.Error()
		return
	}
	pass = true
	return
}

func (g *Gin) MUpdateAll(updates []map[string]interface{}, element interface{}) (pass bool) {
	for _, v := range updates {
		tmp := reflect.New(reflect.TypeOf(element).Elem()).Interface()
		// log.Debug("%v", v)
		tmpbyte, _ := json.Marshal(v)
		err := json.Unmarshal(tmpbyte, &tmp)
		if err != nil {
			log.Error("err%v", err)
			return
		}
		// mapstructure.Decode(v, &tmp)
		// log.Debug("%+v", tmp)
		values.CheckUpdateControl(tmp)
		ref := reflect.ValueOf(tmp).Elem()
		reft := reflect.TypeOf(tmp).Elem()
		id := reflect.ValueOf(tmp).Elem().FieldByName("ID").Int()
		if id == 0 {
			if err := db.Mysql().Create(tmp); err != nil {
				g.Code = values.CodeRetry
				return
			}
		} else {
			update := map[string]interface{}{}
			for k := range v {
				field, ok := reft.FieldByName(k)
				if !ok {
					continue
				}
				tag := field.Tag.Get("web")
				if tag == "" || tag == "-" {
					continue
				}
				update[tag] = ref.FieldByName(k).Interface()
			}
			// update := util.StructToMap(tmp, "web")
			model := reflect.New(reflect.TypeOf(element).Elem())
			model.Elem().FieldByName("ID").SetInt(id)
			// log.Debug("element:%v", element)
			log.Debug("update:%v", update)
			// log.Debug("model:%v", model)
			if err := db.Mysql().Update(model.Interface(), update); err != nil {
				g.Code = values.CodeRetry
				return
			}
		}
	}
	pass = true
	return
}

func (g *Gin) MDel(id int, element interface{}) (pass bool) {
	tmp := reflect.New(reflect.TypeOf(element).Elem())
	tmp.Elem().FieldByName("ID").SetInt(int64(id))
	if !db.Mysql().Exist(tmp.Interface()) {
		g.Code = values.CodeParam
		g.Msg = "该id不存在"
		return
	}
	if err := db.Mysql().Del(tmp.Interface()); err != nil {
		g.Code = values.CodeRetry
		return
	}
	pass = true
	return
}

// MCommit 提交事务
func (g *Gin) MCommit(tx *gorm.DB) {
	if g.Code == values.CodeOK {
		if err := tx.Commit().Error; err != nil {
			tx.Rollback()
			return
		}
	} else {
		tx.Rollback()
		return
	}
}

// CheckPower 检查权限是否合法
func (g *Gin) CheckPower(power string) bool {
	newMap := map[int][]int{}
	if err := json.Unmarshal([]byte(power), &newMap); err != nil {
		log.Error("err:%v", err)
		g.Code = values.CodeParam
		g.Msg = err.Error()
		return false
	}
	for i := range newMap {
		if !values.IsValidPower(i) {
			log.Error("invalid power:%v", i)
			g.Code = values.CodeParam
			g.Msg = fmt.Sprintf("未知权限参数%v", i)
			return false
		}
	}
	return true
}

func (g *Gin) CommonConfig() {
	path := g.C.Request.URL.Path
	index := strings.LastIndex(path, "/")
	opt := path[index+1:]
	path = path[:index]
	index = strings.LastIndex(path, "/")
	t := path[index+1:]
	reloadType := values.GetControlType(t)
	element, list := common.GetConfigStructByType(reloadType)
	var resp interface{}
	if opt == "list" {
		if !g.MGetAll(element, list) {
			return
		}
		resp = values.GMConfigCommonListResp{Config: list}
	} else if opt == "edit" {
		req := new(values.GMConfigCommonEditReq)
		if !g.S(req) {
			return
		}
		if !g.MUpdateAll(req.Config, element) {
			return
		}
		call.Publish(natsClient.TopicReloadConfig, &pb.ReloadGameConfig{Type: int32(reloadType)})
	} else if opt == "del" {
		req := new(values.GMConfigCommonDelReq)
		if !g.S(req) {
			return
		}
		if !g.MDel(req.ID, element) {
			return
		}
		call.Publish(natsClient.TopicReloadConfig, &pb.ReloadGameConfig{Type: int32(reloadType)})
	}
	g.Data = resp
}