slg init

conf/config.go

+package config
+
+var (
+	ApiAuthConfig = map[string]map[string]string{
+		"STREAMER": {
+			"md5": "1dBQmx2BPjXRUaMm",
+			"aes": "fFjhWCkzfLGhFVv2",
+			"rsa": "rsa/public.pem",
+		},
+	}
+)
+
+const (
+	// 签名超时时间
+	AppSignExpiry = "120"
+
+	// RSA Private File
+	AppRsaPrivateFile = "rsa/private.pem"
+
+	PASSWORD_DEFAULT = 13
+)

go.mod

+module slg
+
+go 1.16
+
+require (
+	github.com/astaxie/beego v1.12.3
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible
+	github.com/gin-gonic/gin v1.7.7
+	github.com/go-ini/ini v1.66.4
+	github.com/go-sql-driver/mysql v1.6.0
+	github.com/gomodule/redigo v2.0.0+incompatible
+	github.com/jinzhu/gorm v1.9.16
+	github.com/robfig/cron v1.2.0
+	github.com/stretchr/testify v1.7.0 // indirect
+	github.com/xinliangnote/go-util v0.0.0-20210703052933-7f9f6d961276
+	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
+	gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
+	gopkg.in/go-playground/validator.v9 v9.31.0
+)

main.go

+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"slg/models"
+	"slg/pkg/cron"
+	"slg/pkg/gredis"
+	"slg/pkg/setting"
+	"slg/pkg/util"
+	"slg/routers"
+)
+
+func init() {
+	setting.Setup()
+	models.Setup()
+	gredis.Setup()
+	util.Setup()
+	cron.Setup()
+}
+
+func main() {
+	gin.SetMode(setting.ServerSetting.RunMode)
+
+	routersInit := routers.InitRouter()
+	readTimeout := setting.ServerSetting.ReadTimeout
+	writeTimeout := setting.ServerSetting.WriteTimeout
+	endPoint := fmt.Sprintf(":%d", setting.ServerSetting.HttpPort)
+	maxHeaderBytes := 1 << 20
+
+	server := &http.Server{
+		Addr:           endPoint,
+		Handler:        routersInit,
+		ReadTimeout:    readTimeout,
+		WriteTimeout:   writeTimeout,
+		MaxHeaderBytes: maxHeaderBytes,
+	}
+
+	log.Printf("[info] start http server listening %s", endPoint)
+
+	server.ListenAndServe()
+
+}

middleware/auth/auth.go

+package auth
+
+import (
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/pkg/util"
+	"github.com/gin-gonic/gin"
+	"strings"
+)
+
+func AUTH() gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+
+		token := ctx.Request.Header.Get("Token")
+		user, _ := util.ParseToken(token)
+		if !strings.Contains(strings.ToLower(user.UserInfo.Username), "kefu") {
+			return
+		}
+
+		handlerName := strings.Split(ctx.HandlerName(), ".")[1]
+		handleAlowed := []string{"GetCoinChains", "GetUserChains", "AddOperationLog"}
+		_, handle := util.Contains(handleAlowed, handlerName)
+
+		if !handle {
+			handler.SendResponse(ctx, errno.PermissionDenied, nil)
+			ctx.Abort()
+			return
+		}
+
+		ctx.Next()
+	}
+}

middleware/jwt/jwt.go

+package jwt
+
+import (
+	"slg/pkg/e"
+	"slg/pkg/util"
+	"github.com/dgrijalva/jwt-go"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+func JWT() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var code int
+		var data interface{}
+
+		code = e.SUCCESS
+		token := c.Request.Header.Get("Token")
+		if token == "" {
+			code = e.INVALID_PARAMS
+		} else {
+			_, err := util.ParseToken(token)
+			if err != nil {
+				switch err.(*jwt.ValidationError).Errors {
+				case jwt.ValidationErrorExpired:
+					code = e.ERROR_AUTH_CHECK_TOKEN_TIMEOUT
+				default:
+					code = e.ERROR_AUTH_CHECK_TOKEN_FAIL
+				}
+			}
+		}
+
+		if code != e.SUCCESS {
+			c.JSON(http.StatusUnauthorized, gin.H{
+				"code": code,
+				"msg":  e.GetMsg(code),
+				"data": data,
+			})
+
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}

middleware/log/log.go

+package log
+
+import (
+	"slg/pkg/util"
+	"slg/service/operation_log_service"
+
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"strconv"
+	"strings"
+)
+
+func LogMiddleware(handlerTableName map[string]string) gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+		var operation string
+
+		// 获取当前用户信息
+		token := ctx.Request.Header.Get("Token")
+		user, err := util.ParseToken(token)
+		if err != nil {
+			ctx.Abort()
+			return
+		}
+		user_id := user.UserInfo.Uid
+		user_name := user.UserInfo.Username
+		platform_id := user.UserInfo.PlatformId
+
+		// 获取表名 这里会把前面 "加载的包名.HandlerName"
+		handlerName := strings.Split(ctx.HandlerName(), ".")[1]
+		if _, ok := handlerTableName[handlerName]; !ok {
+			ctx.Next()
+		}
+
+		tableDesc := strings.Split(handlerTableName[handlerName], ",")
+		if len(tableDesc) != 2 {
+			return // 存在映射，但是不完全则返回
+		}
+		tableName := tableDesc[0] // 0表名
+		desc := tableDesc[1]      // 1业务描述
+
+		switch ctx.Request.Method {
+		case "POST":
+			operation = "增加"
+		case "GET":
+			operation = "查询"
+		case "PUT":
+			operation = "更新"
+		case "DELETE":
+			operation = "删除"
+		default:
+			operation = "未知"
+		}
+
+		operationLogService := operation_log_service.OperationLog{
+			UserId:     user_id,
+			UserName:   user_name,
+			PlatformId: platform_id,
+			Ip:         ctx.ClientIP(),
+			Operation:  operation,
+			Business:   desc,
+			Table:      tableName,
+		}
+
+		if err := operationLogService.Add(); err != nil {
+			ctx.Abort()
+			return
+		}
+
+		return
+	}
+}
+
+func FirstMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		fmt.Println(c.Request.Method, c.ClientIP(), c.Request.Header.Get("Token"))
+		fmt.Println("first middleware before next()")
+		isAbort := c.Query("isAbort")
+		bAbort, err := strconv.ParseBool(isAbort)
+		if err != nil {
+			fmt.Printf("is abort value err, value %s\n", isAbort)
+			c.Next() // (2)
+		}
+		if bAbort {
+			fmt.Println("first middleware abort") //(3)
+			c.Abort()
+			//c.AbortWithStatusJSON(http.StatusOK, "abort is true")
+			return
+		} else {
+			fmt.Println("first middleware doesnot abort") //(4)
+			return
+		}
+
+		fmt.Println("first middleware after next()")
+	}
+}
+
+func SecondMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		fmt.Println("current inside of second middleware")
+	}
+}

middleware/sign/aes/aes.go

+package aes
+
+import (
+	config "slg/conf"
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/pkg/util"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"github.com/xinliangnote/go-util/aes"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var AppSecret string
+
+// MD5 组合加密
+func Aes() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		sign, err := verifySign(c)
+
+		if sign != nil {
+			handler.SendResponse(c, nil, sign)
+			c.Abort()
+			return
+		}
+
+		if err != nil {
+			handler.SendResponse(c, err, nil)
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}
+
+type Proof struct {
+	Ak    string `json:"ak"`
+	Sn    string `json:"sn"`
+	Ts    string `json:"ts"`
+	Debug string `json:"debug"`
+}
+
+// 验证签名
+func verifySign(c *gin.Context) (map[string]string, error) {
+	var params = make(map[string]interface{})
+	if c.Request.Method == "POST" || c.Request.Method == "PUT" {
+		c.ShouldBindBodyWith(&params, binding.JSON)
+
+		//var bodyBytes []byte
+		//if c.Request.Body != nil {
+		//	bodyBytes, _ = ioutil.ReadAll(c.Request.Body)
+		//}
+		//// 把刚刚读出来的再写进去
+		//c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
+		//json.Unmarshal(bodyBytes, &params)
+		//fmt.Println(params)
+	}
+
+	if "GET" == c.Request.Method {
+		keys := c.Request.URL.Query()
+		for k, v := range keys {
+			params[k] = v[0]
+		}
+	}
+	_ = c.Request.ParseForm()
+	req := c.Request.Form
+	for key, value := range params {
+		req.Set(key, util.ToString(value))
+	}
+
+	debug := strings.Join(req["debug"], "")
+	ak := strings.Join(req["ak"], "")
+	sn := strings.Join(req["sn"], "")
+	ts := strings.Join(req["ts"], "")
+
+	// 验证来源
+	value, ok := config.ApiAuthConfig[ak]
+	if ok {
+		AppSecret = value["aes"]
+	} else {
+		return nil, errno.ErrAk
+	}
+
+	if debug == "1" {
+		currentUnix := util.GetCurrentUnix()
+		req.Set("ts", strconv.FormatInt(currentUnix, 10))
+		sn, err := createSign(req)
+		if err != nil {
+			return nil, errno.ErrSn
+		}
+
+		res := map[string]string{
+			"ts": strconv.FormatInt(currentUnix, 10),
+			"sn": sn,
+		}
+		return res, nil
+	}
+
+	// 验证过期时间
+	timestamp := time.Now().Unix()
+	exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)
+	tsInt, _ := strconv.ParseInt(ts, 10, 64)
+	if tsInt > timestamp || timestamp-tsInt >= exp {
+		return nil, errno.ErrTs
+	}
+
+	// 验证签名
+	if sn == "" {
+		return nil, errno.ErrSn
+	}
+
+	decryptStr, decryptErr := aes.Decrypt(sn, []byte(AppSecret), AppSecret)
+	if decryptErr != nil {
+		return nil, errors.New(decryptErr.Error())
+	}
+	if decryptStr != createEncryptStr(req) {
+		return nil, errno.ErrSn
+	}
+	return nil, nil
+}
+
+// 创建签名
+func createSign(params url.Values) (string, error) {
+	return aes.Encrypt(createEncryptStr(params), []byte(AppSecret), AppSecret)
+}
+
+func createEncryptStr(params url.Values) string {
+	var key []string
+	var str = ""
+	for k := range params {
+		if k != "sn" && k != "debug" {
+			key = append(key, k)
+		}
+	}
+	sort.Strings(key)
+	for i := 0; i < len(key); i++ {
+		if i == 0 {
+			str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))
+		} else {
+			str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))
+		}
+	}
+	return str
+}

middleware/sign/md5/md5.go

+package md5
+
+import (
+	config "slg/conf"
+	"slg/pkg/handler"
+	"slg/pkg/util"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var AppSecret string
+
+// MD5 组合加密
+func Md5() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		sign, err := verifySign(c)
+
+		if sign != nil {
+			handler.SendResponse(c, nil, sign)
+			c.Abort()
+			return
+		}
+
+		if err != nil {
+			handler.SendResponse(c, err, nil)
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}
+
+// 验证签名
+func verifySign(c *gin.Context) (map[string]string, error) {
+	var params = make(map[string]interface{})
+	if c.Request.Method == "POST" || c.Request.Method == "PUT" {
+		c.ShouldBindBodyWith(&params, binding.JSON)
+
+		//var bodyBytes []byte
+		//if c.Request.Body != nil {
+		//	bodyBytes, _ = ioutil.ReadAll(c.Request.Body)
+		//}
+		//// 把刚刚读出来的再写进去
+		//c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
+		//json.Unmarshal(bodyBytes, &params)
+		//fmt.Println(params)
+	}
+
+	if "GET" == c.Request.Method {
+		keys := c.Request.URL.Query()
+		for k, v := range keys {
+			params[k] = v[0]
+		}
+	}
+	_ = c.Request.ParseForm()
+	req := c.Request.Form
+	for key, value := range params {
+		req.Set(key, util.ToString(value))
+	}
+
+	debug := strings.Join(req["debug"], "")
+	ak := strings.Join(req["ak"], "")
+	sn := strings.Join(req["sn"], "")
+	ts := strings.Join(req["ts"], "")
+
+	// 验证来源
+	value, ok := config.ApiAuthConfig[ak]
+	if ok {
+		AppSecret = value["md5"]
+	} else {
+		return nil, errors.New("ak Error")
+	}
+
+	if debug == "1" {
+		currentUnix := util.GetCurrentUnix()
+		req.Set("ts", strconv.FormatInt(currentUnix, 10))
+		res := map[string]string{
+			"ts": strconv.FormatInt(currentUnix, 10),
+			"sn": createSign(req),
+		}
+		return res, nil
+	}
+
+	// 验证过期时间
+	timestamp := time.Now().Unix()
+	exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)
+	tsInt, _ := strconv.ParseInt(ts, 10, 64)
+	if tsInt > timestamp || timestamp-tsInt >= exp {
+		return nil, errors.New("ts Error")
+	}
+
+	// 验证签名
+	if sn == "" || sn != createSign(req) {
+		return nil, errors.New("sn Error")
+	}
+
+	return nil, nil
+}
+
+// 创建签名
+func createSign(params url.Values) string {
+	// 自定义 MD5 组合
+	return util.EncodeMD5(AppSecret + createEncryptStr(params) + AppSecret)
+}
+
+func createEncryptStr(params url.Values) string {
+	var key []string
+	var str = ""
+	for k := range params {
+		if k != "sn" && k != "debug" {
+			key = append(key, k)
+		}
+	}
+	sort.Strings(key)
+	for i := 0; i < len(key); i++ {
+		if i == 0 {
+			str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))
+		} else {
+			str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))
+		}
+	}
+	return str
+}

middleware/sign/rsa/rsa.go

+package rsa
+
+import (
+	config "slg/conf"
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/pkg/util"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"github.com/xinliangnote/go-util/rsa"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var AppSecret string
+
+// RSA 非对称加密
+func Rsa() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		sign, err := verifySign(c)
+
+		if sign != nil {
+			handler.SendResponse(c, nil, sign)
+			c.Abort()
+			return
+		}
+
+		if err != nil {
+			handler.SendResponse(c, err, nil)
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}
+
+// 验证签名
+func verifySign(c *gin.Context) (map[string]string, error) {
+	var params = make(map[string]interface{})
+	if c.Request.Method == "POST" || c.Request.Method == "PUT" {
+		c.ShouldBindBodyWith(&params, binding.JSON)
+
+		//var bodyBytes []byte
+		//if c.Request.Body != nil {
+		//	bodyBytes, _ = ioutil.ReadAll(c.Request.Body)
+		//}
+		//// 把刚刚读出来的再写进去
+		//c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
+		//json.Unmarshal(bodyBytes, &params)
+		//fmt.Println(params)
+	}
+
+	if "GET" == c.Request.Method {
+		keys := c.Request.URL.Query()
+		for k, v := range keys {
+			params[k] = v[0]
+		}
+	}
+	_ = c.Request.ParseForm()
+	req := c.Request.Form
+	for key, value := range params {
+		req.Set(key, util.ToString(value))
+	}
+
+	debug := strings.Join(req["debug"], "")
+	ak := strings.Join(req["ak"], "")
+	sn := strings.Join(req["sn"], "")
+	ts := strings.Join(req["ts"], "")
+
+	// 验证来源
+	value, ok := config.ApiAuthConfig[ak]
+	if ok {
+		AppSecret = value["rsa"]
+	} else {
+		return nil, errno.ErrAk
+	}
+
+	if debug == "1" {
+		currentUnix := util.GetCurrentUnix()
+		req.Set("ts", strconv.FormatInt(currentUnix, 10))
+
+		sn, err := createSign(req)
+		if err != nil {
+			return nil, errno.ErrSn
+		}
+
+		res := map[string]string{
+			"ts": strconv.FormatInt(currentUnix, 10),
+			"sn": sn,
+		}
+		return res, nil
+	}
+
+	// 验证过期时间
+	timestamp := time.Now().Unix()
+	exp, _ := strconv.ParseInt(config.AppSignExpiry, 10, 64)
+	tsInt, _ := strconv.ParseInt(ts, 10, 64)
+	if tsInt > timestamp || timestamp-tsInt >= exp {
+		return nil, errno.ErrTs
+	}
+
+	// 验证签名
+	if sn == "" {
+		return nil, errno.ErrSn
+	}
+
+	decryptStr, decryptErr := rsa.PrivateDecrypt(sn, config.AppRsaPrivateFile)
+	if decryptErr != nil {
+		return nil, errors.New(decryptErr.Error())
+	}
+	if decryptStr != createEncryptStr(req) {
+		return nil, errno.ErrSn
+	}
+	return nil, nil
+}
+
+// 创建签名
+func createSign(params url.Values) (string, error) {
+	return rsa.PublicEncrypt(createEncryptStr(params), AppSecret)
+}
+
+func createEncryptStr(params url.Values) string {
+	var key []string
+	var str = ""
+	for k := range params {
+		if k != "sn" && k != "debug" {
+			key = append(key, k)
+		}
+	}
+	sort.Strings(key)
+	for i := 0; i < len(key); i++ {
+		if i == 0 {
+			str = fmt.Sprintf("%v=%v", key[i], params.Get(key[i]))
+		} else {
+			str = str + fmt.Sprintf("&%v=%v", key[i], params.Get(key[i]))
+		}
+	}
+	return str
+}

models/bank.go

+package models
+
+import (
+	"slg/pkg/setting"
+)
+
+type Bank struct {
+	id            uint32  `gorm:"type:int(11);primary key"`
+	BankName      string `gorm:"type:varchar(64);not null"`
+}
+
+func (b Bank) TableName() string {
+	return setting.DatabaseSetting.Name + ".bank"
+}
+
+func AddBank(data map[string]interface{}) (error) {
+	bank := Bank{
+		BankName:      data["bankname"].(string),
+	}
+
+	if err := db.Create(&bank).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
\ No newline at end of file

models/model.go

+package models
+
+import (
+	"time"
+)
+
+type BaseModel struct {
+	ID        uint       `gorm:"primary_key"`
+	CreatedAt time.Time  `json:"createdAt"`
+	UpdatedAt time.Time  `json:"updatedAt"`
+	DeletedAt *time.Time `json:"deletedAt"`
+}

models/models.go

+package models
+
+import (
+	"fmt"
+	"log"
+
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/jinzhu/gorm"
+	_ "github.com/jinzhu/gorm/dialects/mysql"
+	"slg/pkg/setting"
+	"time"
+)
+
+var db *gorm.DB
+
+type Model struct {
+	ID         int `gorm:"primary_key" json:"id"`
+	//CreatedOn  int `json:"created_on"`
+	//ModifiedOn int `json:"modified_on"`
+	//DeletedOn  int `json:"deleted_on"`
+}
+
+// Setup initializes the database instance
+func Setup() {
+	var err error
+	db, err = gorm.Open(setting.DatabaseSetting.Type, fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=True&loc=Local",
+		setting.DatabaseSetting.User,
+		setting.DatabaseSetting.Password,
+		setting.DatabaseSetting.Host,
+		setting.DatabaseSetting.Name))
+
+	if err != nil {
+		log.Fatalf("models.Setup err: %v", err)
+	}
+
+	gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
+		//return setting.DatabaseSetting.TablePrefix + defaultTableName
+		return defaultTableName
+	}
+
+	db.SingularTable(true)
+	//db.Callback().Create().Replace("gorm:update_time_stamp", updateTimeStampForCreateCallback)
+	//db.Callback().Update().Replace("gorm:update_time_stamp", updateTimeStampForUpdateCallback)
+	//db.Callback().Delete().Replace("gorm:delete", deleteCallback)
+	db.DB().SetMaxIdleConns(10)
+	db.DB().SetMaxOpenConns(100)
+}
+
+// CloseDB closes database connection (unnecessary)
+func CloseDB() {
+	defer db.Close()
+}
+
+// updateTimeStampForCreateCallback will set `CreatedOn`, `ModifiedOn` when creating
+func updateTimeStampForCreateCallback(scope *gorm.Scope) {
+	if !scope.HasError() {
+		nowTime := time.Now().Unix()
+		if createTimeField, ok := scope.FieldByName("CreatedOn"); ok {
+			if createTimeField.IsBlank {
+				createTimeField.Set(nowTime)
+			}
+		}
+
+		if modifyTimeField, ok := scope.FieldByName("ModifiedOn"); ok {
+			if modifyTimeField.IsBlank {
+				modifyTimeField.Set(nowTime)
+			}
+		}
+	}
+}
+
+// updateTimeStampForUpdateCallback will set `ModifiedOn` when updating
+func updateTimeStampForUpdateCallback(scope *gorm.Scope) {
+	if _, ok := scope.Get("gorm:update_column"); !ok {
+		scope.SetColumn("ModifiedOn", time.Now().Unix())
+	}
+}
+
+// deleteCallback will set `DeletedOn` where deleting
+func deleteCallback(scope *gorm.Scope) {
+	if !scope.HasError() {
+		var extraOption string
+		if str, ok := scope.Get("gorm:delete_option"); ok {
+			extraOption = fmt.Sprint(str)
+		}
+
+		deletedOnField, hasDeletedOnField := scope.FieldByName("DeletedOn")
+
+		if !scope.Search.Unscoped && hasDeletedOnField {
+			scope.Raw(fmt.Sprintf(
+				"UPDATE %v SET %v=%v%v%v",
+				scope.QuotedTableName(),
+				scope.Quote(deletedOnField.DBName),
+				scope.AddToVars(time.Now().Unix()),
+				addExtraSpaceIfExist(scope.CombinedConditionSql()),
+				addExtraSpaceIfExist(extraOption),
+			)).Exec()
+		} else {
+			scope.Raw(fmt.Sprintf(
+				"DELETE FROM %v%v%v",
+				scope.QuotedTableName(),
+				addExtraSpaceIfExist(scope.CombinedConditionSql()),
+				addExtraSpaceIfExist(extraOption),
+			)).Exec()
+		}
+	}
+}
+
+// addExtraSpaceIfExist adds a separator
+func addExtraSpaceIfExist(str string) string {
+	if str != "" {
+		return " " + str
+	}
+	return ""
+}

pkg/cron/cron.go

+package cron
+
+import (
+	"github.com/robfig/cron"
+)
+
+var c *cron.Cron
+
+func Setup() {
+	c = cron.New()
+
+	c.AddFunc("* * * * * *", func() {
+
+	})
+
+	c.Start()
+}

pkg/e/code.go

+package e
+
+const (
+	SUCCESS        = 200
+	ERROR          = 500
+	INVALID_PARAMS = 400
+
+	ERROR_AUTH_CHECK_TOKEN_FAIL    = 40001
+	ERROR_AUTH_CHECK_TOKEN_TIMEOUT = 40002
+	ERROR_AUTH_TOKEN               = 40003
+	ERROR_AUTH                     = 40004
+)

pkg/e/msg.go

+package e
+
+var MsgFlags = map[int]string{
+	SUCCESS:        "ok",
+	ERROR:          "fail",
+	INVALID_PARAMS: "请求参数错误",
+}
+
+// GetMsg get error information based on Code
+func GetMsg(code int) string {
+	msg, ok := MsgFlags[code]
+	if ok {
+		return msg
+	}
+
+	return MsgFlags[ERROR]
+}

pkg/encrypt/encrypt.go

+package encrypt
+
+import (
+	config "slg/conf"
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/base64"
+	"golang.org/x/crypto/bcrypt"
+)
+
+// 加密 aes_128_cbc
+func AesEncrypt(encryptStr string, key []byte, iv string) (string, error) {
+	encryptBytes := []byte(encryptStr)
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+
+	blockSize := block.BlockSize()
+	encryptBytes = pkcs5Padding(encryptBytes, blockSize)
+
+	blockMode := cipher.NewCBCEncrypter(block, []byte(iv))
+	encrypted := make([]byte, len(encryptBytes))
+	blockMode.CryptBlocks(encrypted, encryptBytes)
+	return base64.URLEncoding.EncodeToString(encrypted), nil
+}
+
+// 解密
+func AesDecrypt(decryptStr string, key []byte, iv string) (string, error) {
+	decryptBytes, err := base64.URLEncoding.DecodeString(decryptStr)
+	if err != nil {
+		return "", err
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+
+	blockMode := cipher.NewCBCDecrypter(block, []byte(iv))
+	decrypted := make([]byte, len(decryptBytes))
+
+	blockMode.CryptBlocks(decrypted, decryptBytes)
+	decrypted = pkcs5UnPadding(decrypted)
+	return string(decrypted), nil
+}
+
+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(decrypted []byte) []byte {
+	length := len(decrypted)
+	unPadding := int(decrypted[length-1])
+	return decrypted[:(length - unPadding)]
+}
+
+func HashPassword(password string) (string, error) {
+	bytes, err := bcrypt.GenerateFromPassword([]byte(password), config.PASSWORD_DEFAULT)
+	return string(bytes), err
+}
+
+func CheckPasswordHash(password, hash string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
+	return err == nil
+}

pkg/errno/errno.go

+package errno
+
+import "fmt"
+
+type Errno struct {
+	Code    int
+	Message string
+}
+
+func (err Errno) Error() string {
+	return err.Message
+}
+
+// Err represents an error
+type Err struct {
+	Code    int
+	Message string
+	Err     error
+}
+
+func New(errno *Errno, err error) *Err {
+	return &Err{Code: errno.Code, Message: errno.Message, Err: err}
+}
+
+func (err *Err) Add(message string) error {
+	err.Message += " " + message
+	return err
+}
+
+func (err *Err) Addf(format string, args ...interface{}) error {
+	err.Message += " " + fmt.Sprintf(format, args...)
+	return err
+}
+
+func (err *Err) Error() string {
+	return fmt.Sprintf("Err - code: %d, message: %s, error: %s", err.Code, err.Message, err.Err)
+}
+
+func DecodeErr(err error) (int, string) {
+	if err == nil {
+		return OK.Code, OK.Message
+	}
+
+	switch typed := err.(type) {
+	case *Err:
+		return typed.Code, typed.Message
+	case *Errno:
+		return typed.Code, typed.Message
+	default:
+	}
+
+	return InternalServerError.Code, err.Error()
+}
+
+var (
+	// Common errors
+	OK                  = &Errno{Code: 0, Message: "OK"}
+	InternalServerError = &Errno{Code: 10001, Message: "Internal server error"}
+	ErrBind             = &Errno{Code: 10002, Message: "Error occurred while binding the request body to the struct."}
+
+	ErrValidation = &Errno{Code: 20001, Message: "Validation failed."}
+	ErrDatabase   = &Errno{Code: 20002, Message: "Database error."}
+	ErrTs         = &Errno{Code: 20003, Message: "Ts error."}
+	ErrSn         = &Errno{Code: 20004, Message: "Sn error."}
+	ErrAk         = &Errno{Code: 20005, Message: "Ak error."}
+
+	PermissionDenied = &Errno{Code: 403, Message: "Permission Denied"}
+
+	// bank errors
+	ErrBankNotFound       = &Errno{Code: 20101, Message: "银行账号绑定未找到."}
+	ErrAddBank           = &Errno{Code: 20102, Message: "银行账号绑定失败."}
+	ErrUpdateBank         = &Errno{Code: 20103, Message: "银行账号更新失败."}
+	ErrDeleteBank         = &Errno{Code: 20104, Message: "银行账号删除失败."}
+)

pkg/file/file.go

+package file
+
+import (
+	"fmt"
+	"io/ioutil"
+	"mime/multipart"
+	"os"
+	"path"
+)
+
+// GetSize get the file size
+func GetSize(f multipart.File) (int, error) {
+	content, err := ioutil.ReadAll(f)
+
+	return len(content), err
+}
+
+// GetExt get the file ext
+func GetExt(fileName string) string {
+	return path.Ext(fileName)
+}
+
+// CheckNotExist check if the file exists
+func CheckNotExist(src string) bool {
+	_, err := os.Stat(src)
+
+	return os.IsNotExist(err)
+}
+
+// CheckPermission check if the file has permission
+func CheckPermission(src string) bool {
+	_, err := os.Stat(src)
+
+	return os.IsPermission(err)
+}
+
+// IsNotExistMkDir create a directory if it does not exist
+func IsNotExistMkDir(src string) error {
+	if notExist := CheckNotExist(src); notExist == true {
+		if err := MkDir(src); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// MkDir create a directory
+func MkDir(src string) error {
+	err := os.MkdirAll(src, os.ModePerm)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Open a file according to a specific mode
+func Open(name string, flag int, perm os.FileMode) (*os.File, error) {
+	f, err := os.OpenFile(name, flag, perm)
+	if err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+// MustOpen maximize trying to open the file
+func MustOpen(fileName, filePath string) (*os.File, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return nil, fmt.Errorf("os.Getwd err: %v", err)
+	}
+
+	src := dir + "/" + filePath
+	perm := CheckPermission(src)
+	if perm == true {
+		return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
+	}
+
+	err = IsNotExistMkDir(src)
+	if err != nil {
+		return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
+	}
+
+	f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("Fail to OpenFile :%v", err)
+	}
+
+	return f, nil
+}

pkg/gredis/cache.go

+package gredis
+
+import (
+	"slg/pkg/util"
+	"github.com/gomodule/redigo/redis"
+	"time"
+)
+
+var (
+	DEFAULT = time.Duration(0)  // 过期时间 不设置
+	FOREVER = time.Duration(-1) // 过期时间不设置
+)
+
+type Cache struct {
+	pool              *redis.Pool
+	defaultExpiration time.Duration
+}
+
+// 返回cache 对象, 在多个工具之间建立一个 中间初始化的时候使用
+func NewRedisCache(db int, host string, defaultExpiration time.Duration) Cache {
+	pool := &redis.Pool{
+		MaxActive:   100,                              //  最大连接数，即最多的tcp连接数，一般建议往大的配置，但不要超过操作系统文件句柄个数（centos下可以ulimit -n查看）
+		MaxIdle:     100,                              // 最大空闲连接数，即会有这么多个连接提前等待着，但过了超时时间也会关闭。
+		IdleTimeout: time.Duration(100) * time.Second, // 空闲连接超时时间，但应该设置比redis服务器超时时间短。否则服务端超时了，客户端保持着连接也没用
+		Wait:        true,                             // 当超过最大连接数 是报错还是等待， true 等待 false 报错
+		Dial: func() (redis.Conn, error) {
+			conn, err := redis.Dial("tcp", host, redis.DialDatabase(db))
+			if err != nil {
+				return nil, err
+			}
+			return conn, nil
+		},
+	}
+	return Cache{pool: pool, defaultExpiration: defaultExpiration}
+}
+
+// string 类型 添加, v 可以是任意类型
+func (c Cache) StringSet(name string, v interface{}) error {
+	conn := c.pool.Get()
+	s, _ := util.Serialization(v) // 序列化
+	defer conn.Close()
+	_, err := conn.Do("SET", name, s)
+	return err
+}
+
+// 获取 字符串类型的值
+func (c Cache) StringGet(name string, v interface{}) error {
+	conn := c.pool.Get()
+	defer conn.Close()
+	temp, _ := redis.Bytes(conn.Do("Get", "yang"))
+	err := util.Deserialization(temp, &v) // 反序列化
+	return err
+}
+
+func (c Cache) stringGetTest() {
+	//var need []string
+	//var need int32
+	var need int64
+	//Deserialization(aa, &need)
+	c.StringGet("yang", &need)
+}
+
+// 判断所在的 key 是否存在
+func (c Cache) Exist(name string) (bool, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	v, err := redis.Bool(conn.Do("EXISTS", name))
+	return v, err
+}
+
+// 自增
+func (c Cache) StringIncr(name string) (int, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	v, err := redis.Int(conn.Do("INCR", name))
+	return v, err
+}
+
+// 设置过期时间 （单位 秒）
+func (c Cache) Expire(name string, newSecondsLifeTime int64) error {
+	// 设置key 的过期时间
+	conn := c.pool.Get()
+	defer conn.Close()
+	_, err := conn.Do("EXPIRE", name, newSecondsLifeTime)
+	return err
+}
+
+// 删除指定的键
+func (c Cache) Delete(keys ...interface{}) (bool, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	v, err := redis.Bool(conn.Do("DEL", keys...))
+	return v, err
+}
+
+// 查看指定的长度
+func (c Cache) StrLen(name string) (int, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	v, err := redis.Int(conn.Do("STRLEN", name))
+	return v, err
+}
+
+// //////////////////  hash ///////////
+// 删除指定的 hash 键
+func (c Cache) Hdel(name, key string) (bool, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	var err error
+	v, err := redis.Bool(conn.Do("HDEL", name, key))
+	return v, err
+}
+
+// 查看hash 中指定是否存在
+func (c Cache) HExists(name, field string) (bool, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	var err error
+	v, err := redis.Bool(conn.Do("HEXISTS", name, field))
+	return v, err
+}
+
+// 获取hash 的键的个数
+func (c Cache) HLen(name string) (int, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	v, err := redis.Int(conn.Do("HLEN", name))
+	return v, err
+}
+
+// 传入的 字段列表获得对应的值
+func (c Cache) HMget(name string, fields ...string) ([]interface{}, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	args := []interface{}{name}
+	for _, field := range fields {
+		args = append(args, field)
+	}
+	value, err := redis.Values(conn.Do("HMGET", args...))
+
+	return value, err
+}
+
+// 设置单个值, value 还可以是一个 map slice 等
+func (c Cache) HSet(name string, key string, value interface{}) (err error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	v, _ := util.Serialization(value)
+	_, err = conn.Do("HSET", name, key, v)
+	return
+}
+
+// 设置多个值 , obj 可以是指针 slice map struct
+func (c Cache) HMSet(name string, obj interface{}) (err error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	_, err = conn.Do("HSET", redis.Args{}.Add(name).AddFlat(&obj)...)
+	return
+}
+
+// 获取单个hash 中的值
+func (c Cache) HGet(name, field string, v interface{}) (err error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	temp, _ := redis.Bytes(conn.Do("Get", name, field))
+	err = util.Deserialization(temp, &v) // 反序列化
+	return
+}
+
+// set 集合
+
+// 获取 set 集合中所有的元素, 想要什么类型的自己指定
+func (c Cache) Smembers(name string, v interface{}) (err error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	temp, _ := redis.Bytes(conn.Do("smembers", name))
+	err = util.Deserialization(temp, &v)
+	return err
+}
+
+// 获取集合中元素的个数
+func (c Cache) ScardInt64s(name string) (int64, error) {
+	conn := c.pool.Get()
+	defer conn.Close()
+	v, err := redis.Int64(conn.Do("SCARD", name))
+	return v, err
+}

pkg/gredis/redis.go

+package gredis
+
+import (
+	"slg/pkg/setting"
+	"encoding/json"
+	"github.com/gomodule/redigo/redis"
+	"time"
+)
+
+var RedisConn *redis.Pool
+
+func Setup() error {
+	RedisConn = &redis.Pool{
+		MaxIdle:     setting.RedisSetting.MaxIdle,
+		MaxActive:   setting.RedisSetting.MaxActive,
+		IdleTimeout: setting.RedisSetting.IdleTimeout,
+		Dial: func() (redis.Conn, error) {
+			c, err := redis.Dial("tcp", setting.RedisSetting.Host)
+			if err != nil {
+				return nil, err
+			}
+			if setting.RedisSetting.Password != "" {
+				if _, err := c.Do("AUTH", setting.RedisSetting.Password); err != nil {
+					c.Close()
+					return nil, err
+				}
+			}
+			return c, err
+		},
+		TestOnBorrow: func(c redis.Conn, t time.Time) error {
+			_, err := c.Do("PING")
+			return err
+		},
+	}
+
+	return nil
+}
+
+//设置指定 key 的值
+func Set(key string, data interface{}, time int, db int) error {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	value, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return err
+	}
+
+	_, err = conn.Do("SET", key, value)
+	if err != nil {
+		return err
+	}
+
+	_, err = conn.Do("EXPIRE", key, time)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+//获取指定 key 的值
+func Get(key string, db int) ([]byte, error) {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	reply, err := redis.Bytes(conn.Do("GET", key))
+	if err != nil {
+		return nil, err
+	}
+
+	return reply, nil
+}
+
+func Exists(key string, db int) bool {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return false
+	}
+
+	exists, err := redis.Bool(conn.Do("EXISTS", key))
+	if err != nil {
+		return false
+	}
+
+	return exists
+}
+
+//向有序集合添加一个或多个成员，或者更新已存在成员的分数
+func ZAdd(key string, score int, data interface{}, db int) error {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	value, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return err
+	}
+
+	_, err = conn.Do("ZADD", key, score, value)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func HashSet(key, field string, data interface{}, db int) error {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return err
+	}
+
+	_, err := conn.Do("HSet", key, field, data)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func HashGet(key, field string, db int) ([]byte, error) {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	val, err := redis.Bytes(conn.Do("hget", key, field))
+	if err != nil {
+		return nil, err
+	}
+
+	return val, nil
+
+}
+
+//通过索引区间返回有序集合指定区间内的成员
+func ZRange(key string, start, stop int, db int) ([]string, error) {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	rep, err := redis.Strings(conn.Do("ZRANGE", key, start, stop))
+	if err != nil {
+		return nil, err
+	}
+
+	return rep, nil
+}
+
+func Delete(key string, db int) (bool, error) {
+	conn := RedisConn.Get()
+	defer conn.Close()
+
+	if _, err := conn.Do("SELECT", db); err != nil {
+		conn.Close()
+		return false, err
+	}
+
+	return redis.Bool(conn.Do("DEL", key))
+}

pkg/handler/handler.go

+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"slg/pkg/errno"
+)
+
+//返回数据的结构体
+type Response struct {
+	Code int         `json:"code"`
+	Msg  string      `json:"msg"`
+	Data interface{} `json:"data"`
+}
+
+func SendResponse(c *gin.Context, err error, data interface{}) {
+	if errno.ErrBind == err {
+		code, _ := errno.DecodeErr(err)
+		msg := data.(string)
+		c.JSON(http.StatusOK, Response{
+			Code: code,
+			Msg:  msg,
+			Data: nil,
+		})
+	} else {
+		code, msg := errno.DecodeErr(err)
+		c.JSON(http.StatusOK, Response{
+			Code: code,
+			Msg:  msg,
+			Data: data,
+		})
+	}
+}

pkg/setting/setting.go

+package setting
+
+import (
+	"log"
+	"time"
+
+	"github.com/go-ini/ini"
+)
+
+type App struct {
+	JwtSecret string
+	Audience  string
+	Issuer    string
+	PageSize  int
+	Timeout   int
+	PrefixUrl string
+
+	RuntimeRootPath string
+
+	ImageSavePath  string
+	ImageMaxSize   int
+	ImageAllowExts []string
+
+	FileSavePath  string
+	FileMaxSize   int
+	FileAllowExts []string
+
+	ExportSavePath string
+	QrCodeSavePath string
+	FontSavePath   string
+
+	LogSavePath string
+	LogSaveName string
+	LogFileExt  string
+	TimeFormat  string
+}
+
+var AppSetting = &App{}
+
+type Server struct {
+	RunMode      string
+	HttpPort     int
+	ReadTimeout  time.Duration
+	WriteTimeout time.Duration
+}
+
+var ServerSetting = &Server{}
+
+type Database struct {
+	Type         string
+	User         string
+	Password     string
+	Host         string
+	Name string
+	TablePrefix  string
+}
+
+var DatabaseSetting = &Database{}
+
+type Redis struct {
+	Host        string
+	Password    string
+	MaxIdle     int
+	MaxActive   int
+	IdleTimeout time.Duration
+}
+
+var RedisSetting = &Redis{}
+
+type Oss struct {
+	AccessKeyId     string
+	AccessKeySecret string
+	Endpoint        string
+	Bucket          string
+}
+
+var OssSetting = &Oss{}
+
+var cfg *ini.File
+
+// Setup initialize the configuration instance
+func Setup() {
+	var err error
+	cfg, err = ini.Load("conf/app.ini")
+	if err != nil {
+		log.Fatalf("setting.Setup, fail to parse 'conf/h5.ini': %v", err)
+	}
+
+	mapTo("h5", AppSetting)
+	mapTo("server", ServerSetting)
+	mapTo("database", DatabaseSetting)
+	mapTo("redis", RedisSetting)
+	mapTo("oss", OssSetting)
+
+	AppSetting.ImageMaxSize = AppSetting.ImageMaxSize * 1024 * 1024
+	AppSetting.FileMaxSize = AppSetting.FileMaxSize * 1024 * 1024
+	ServerSetting.ReadTimeout = ServerSetting.ReadTimeout * time.Second
+	ServerSetting.WriteTimeout = ServerSetting.ReadTimeout * time.Second
+	RedisSetting.IdleTimeout = RedisSetting.IdleTimeout * time.Second
+}
+
+// mapTo map section
+func mapTo(section string, v interface{}) {
+	err := cfg.Section(section).MapTo(v)
+	if err != nil {
+		log.Fatalf("Cfg.MapTo RedisSetting err: %v", err)
+	}
+}

pkg/snowflake/snowflake.go

+// Package snowflake provides a very simple Twitter snowflake generator and parser.
+package snowflake
+
+import (
+	"encoding/base64"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"strconv"
+	"sync"
+	"time"
+)
+
+var (
+	// Epoch is set to the twitter snowflake epoch of Nov 04 2010 01:42:54 UTC in milliseconds
+	// You may customize this to set a different epoch for your application.
+	Epoch int64 = 1288834974657
+
+	// NodeBits holds the number of bits to use for Node
+	// Remember, you have a total 22 bits to share between Node/Step
+	NodeBits uint8 = 10
+
+	// StepBits holds the number of bits to use for Step
+	// Remember, you have a total 22 bits to share between Node/Step
+	StepBits uint8 = 12
+
+	// DEPRECATED: the below four variables will be removed in a future release.
+	mu        sync.Mutex
+	nodeMax   int64 = -1 ^ (-1 << NodeBits)
+	nodeMask        = nodeMax << StepBits
+	stepMask  int64 = -1 ^ (-1 << StepBits)
+	timeShift       = NodeBits + StepBits
+	nodeShift       = StepBits
+)
+
+const encodeBase32Map = "ybndrfg8ejkmcpqxot1uwisza345h769"
+
+var decodeBase32Map [256]byte
+
+const encodeBase58Map = "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+
+var decodeBase58Map [256]byte
+
+// A JSONSyntaxError is returned from UnmarshalJSON if an invalid ID is provided.
+type JSONSyntaxError struct{ original []byte }
+
+func (j JSONSyntaxError) Error() string {
+	return fmt.Sprintf("invalid snowflake ID %q", string(j.original))
+}
+
+// ErrInvalidBase58 is returned by ParseBase58 when given an invalid []byte
+var ErrInvalidBase58 = errors.New("invalid base58")
+
+// ErrInvalidBase32 is returned by ParseBase32 when given an invalid []byte
+var ErrInvalidBase32 = errors.New("invalid base32")
+
+// Create maps for decoding Base58/Base32.
+// This speeds up the process tremendously.
+func init() {
+
+	for i := 0; i < len(encodeBase58Map); i++ {
+		decodeBase58Map[i] = 0xFF
+	}
+
+	for i := 0; i < len(encodeBase58Map); i++ {
+		decodeBase58Map[encodeBase58Map[i]] = byte(i)
+	}
+
+	for i := 0; i < len(encodeBase32Map); i++ {
+		decodeBase32Map[i] = 0xFF
+	}
+
+	for i := 0; i < len(encodeBase32Map); i++ {
+		decodeBase32Map[encodeBase32Map[i]] = byte(i)
+	}
+}
+
+// A Node struct holds the basic information needed for a snowflake generator
+// node
+type Node struct {
+	mu    sync.Mutex
+	epoch time.Time
+	time  int64
+	node  int64
+	step  int64
+
+	nodeMax   int64
+	nodeMask  int64
+	stepMask  int64
+	timeShift uint8
+	nodeShift uint8
+}
+
+// An ID is a custom type used for a snowflake ID.  This is used so we can
+// attach methods onto the ID.
+type ID int64
+
+// NewNode returns a new snowflake node that can be used to generate snowflake
+// IDs
+func NewNode(node int64) (*Node, error) {
+
+	// re-calc in case custom NodeBits or StepBits were set
+	// DEPRECATED: the below block will be removed in a future release.
+	mu.Lock()
+	nodeMax = -1 ^ (-1 << NodeBits)
+	nodeMask = nodeMax << StepBits
+	stepMask = -1 ^ (-1 << StepBits)
+	timeShift = NodeBits + StepBits
+	nodeShift = StepBits
+	mu.Unlock()
+
+	n := Node{}
+	n.node = node
+	n.nodeMax = -1 ^ (-1 << NodeBits)
+	n.nodeMask = n.nodeMax << StepBits
+	n.stepMask = -1 ^ (-1 << StepBits)
+	n.timeShift = NodeBits + StepBits
+	n.nodeShift = StepBits
+
+	if n.node < 0 || n.node > n.nodeMax {
+		return nil, errors.New("Node number must be between 0 and " + strconv.FormatInt(n.nodeMax, 10))
+	}
+
+	var curTime = time.Now()
+	// add time.Duration to curTime to make sure we use the monotonic clock if available
+	n.epoch = curTime.Add(time.Unix(Epoch/1000, (Epoch%1000)*1000000).Sub(curTime))
+
+	return &n, nil
+}
+
+// Generate creates and returns a unique snowflake ID
+// To help guarantee uniqueness
+// - Make sure your system is keeping accurate system time
+// - Make sure you never have multiple nodes running with the same node ID
+func (n *Node) Generate() ID {
+
+	n.mu.Lock()
+
+	now := time.Since(n.epoch).Nanoseconds() / 1000000
+
+	if now == n.time {
+		n.step = (n.step + 1) & n.stepMask
+
+		if n.step == 0 {
+			for now <= n.time {
+				now = time.Since(n.epoch).Nanoseconds() / 1000000
+			}
+		}
+	} else {
+		n.step = 0
+	}
+
+	n.time = now
+
+	r := ID((now)<<n.timeShift |
+		(n.node << n.nodeShift) |
+		(n.step),
+	)
+
+	n.mu.Unlock()
+	return r
+}
+
+// Int64 returns an int64 of the snowflake ID
+func (f ID) Int64() int64 {
+	return int64(f)
+}
+
+// ParseInt64 converts an int64 into a snowflake ID
+func ParseInt64(id int64) ID {
+	return ID(id)
+}
+
+// String returns a string of the snowflake ID
+func (f ID) String() string {
+	return strconv.FormatInt(int64(f), 10)
+}
+
+// ParseString converts a string into a snowflake ID
+func ParseString(id string) (ID, error) {
+	i, err := strconv.ParseInt(id, 10, 64)
+	return ID(i), err
+
+}
+
+// Base2 returns a string base2 of the snowflake ID
+func (f ID) Base2() string {
+	return strconv.FormatInt(int64(f), 2)
+}
+
+// ParseBase2 converts a Base2 string into a snowflake ID
+func ParseBase2(id string) (ID, error) {
+	i, err := strconv.ParseInt(id, 2, 64)
+	return ID(i), err
+}
+
+// Base32 uses the z-base-32 character set but encodes and decodes similar
+// to base58, allowing it to create an even smaller result string.
+// NOTE: There are many different base32 implementations so becareful when
+// doing any interoperation.
+func (f ID) Base32() string {
+
+	if f < 32 {
+		return string(encodeBase32Map[f])
+	}
+
+	b := make([]byte, 0, 12)
+	for f >= 32 {
+		b = append(b, encodeBase32Map[f%32])
+		f /= 32
+	}
+	b = append(b, encodeBase32Map[f])
+
+	for x, y := 0, len(b)-1; x < y; x, y = x+1, y-1 {
+		b[x], b[y] = b[y], b[x]
+	}
+
+	return string(b)
+}
+
+// ParseBase32 parses a base32 []byte into a snowflake ID
+// NOTE: There are many different base32 implementations so becareful when
+// doing any interoperation.
+func ParseBase32(b []byte) (ID, error) {
+
+	var id int64
+
+	for i := range b {
+		if decodeBase32Map[b[i]] == 0xFF {
+			return -1, ErrInvalidBase32
+		}
+		id = id*32 + int64(decodeBase32Map[b[i]])
+	}
+
+	return ID(id), nil
+}
+
+// Base36 returns a base36 string of the snowflake ID
+func (f ID) Base36() string {
+	return strconv.FormatInt(int64(f), 36)
+}
+
+// ParseBase36 converts a Base36 string into a snowflake ID
+func ParseBase36(id string) (ID, error) {
+	i, err := strconv.ParseInt(id, 36, 64)
+	return ID(i), err
+}
+
+// Base58 returns a base58 string of the snowflake ID
+func (f ID) Base58() string {
+
+	if f < 58 {
+		return string(encodeBase58Map[f])
+	}
+
+	b := make([]byte, 0, 11)
+	for f >= 58 {
+		b = append(b, encodeBase58Map[f%58])
+		f /= 58
+	}
+	b = append(b, encodeBase58Map[f])
+
+	for x, y := 0, len(b)-1; x < y; x, y = x+1, y-1 {
+		b[x], b[y] = b[y], b[x]
+	}
+
+	return string(b)
+}
+
+// ParseBase58 parses a base58 []byte into a snowflake ID
+func ParseBase58(b []byte) (ID, error) {
+
+	var id int64
+
+	for i := range b {
+		if decodeBase58Map[b[i]] == 0xFF {
+			return -1, ErrInvalidBase58
+		}
+		id = id*58 + int64(decodeBase58Map[b[i]])
+	}
+
+	return ID(id), nil
+}
+
+// Base64 returns a base64 string of the snowflake ID
+func (f ID) Base64() string {
+	return base64.StdEncoding.EncodeToString(f.Bytes())
+}
+
+// ParseBase64 converts a base64 string into a snowflake ID
+func ParseBase64(id string) (ID, error) {
+	b, err := base64.StdEncoding.DecodeString(id)
+	if err != nil {
+		return -1, err
+	}
+	return ParseBytes(b)
+
+}
+
+// Bytes returns a byte slice of the snowflake ID
+func (f ID) Bytes() []byte {
+	return []byte(f.String())
+}
+
+// ParseBytes converts a byte slice into a snowflake ID
+func ParseBytes(id []byte) (ID, error) {
+	i, err := strconv.ParseInt(string(id), 10, 64)
+	return ID(i), err
+}
+
+// IntBytes returns an array of bytes of the snowflake ID, encoded as a
+// big endian integer.
+func (f ID) IntBytes() [8]byte {
+	var b [8]byte
+	binary.BigEndian.PutUint64(b[:], uint64(f))
+	return b
+}
+
+// ParseIntBytes converts an array of bytes encoded as big endian integer as
+// a snowflake ID
+func ParseIntBytes(id [8]byte) ID {
+	return ID(int64(binary.BigEndian.Uint64(id[:])))
+}
+
+// Time returns an int64 unix timestamp in milliseconds of the snowflake ID time
+// DEPRECATED: the below function will be removed in a future release.
+func (f ID) Time() int64 {
+	return (int64(f) >> timeShift) + Epoch
+}
+
+// Node returns an int64 of the snowflake ID node number
+// DEPRECATED: the below function will be removed in a future release.
+func (f ID) Node() int64 {
+	return int64(f) & nodeMask >> nodeShift
+}
+
+// Step returns an int64 of the snowflake step (or sequence) number
+// DEPRECATED: the below function will be removed in a future release.
+func (f ID) Step() int64 {
+	return int64(f) & stepMask
+}
+
+// MarshalJSON returns a json byte array string of the snowflake ID.
+func (f ID) MarshalJSON() ([]byte, error) {
+	buff := make([]byte, 0, 22)
+	buff = append(buff, '"')
+	buff = strconv.AppendInt(buff, int64(f), 10)
+	buff = append(buff, '"')
+	return buff, nil
+}
+
+// UnmarshalJSON converts a json byte array of a snowflake ID into an ID type.
+func (f *ID) UnmarshalJSON(b []byte) error {
+	if len(b) < 3 || b[0] != '"' || b[len(b)-1] != '"' {
+		return JSONSyntaxError{b}
+	}
+
+	i, err := strconv.ParseInt(string(b[1:len(b)-1]), 10, 64)
+	if err != nil {
+		return err
+	}
+
+	*f = ID(i)
+	return nil
+}

pkg/util/convert.go

+package util
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// ToString returns the string result converted by src.
+func ToString(src interface{}) string {
+	switch v := src.(type) {
+	case int, int8, int16, int32, int64:
+		return strconv.FormatInt(ToInt64(v), 10)
+	case uint, uint8, uint16, uint32, uint64, uintptr:
+		return strconv.FormatUint(ToUint64(v), 10)
+	case float32, float64, complex64, complex128:
+		return strconv.FormatFloat(ToFloat64(v), 'f', -1, 64)
+	case string:
+		return v
+	case []byte:
+		return string(v)
+	case []rune:
+		return string(v)
+	case bool:
+		return strconv.FormatBool(v)
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+// ToBool returns the bool result converted by src.
+func ToBool(src interface{}) bool {
+	switch v := src.(type) {
+	case int, int8, int16, int32, int64:
+		return ToInt64(v) > 0
+	case uint, uint8, uint16, uint32, uint64, uintptr:
+		return ToUint64(v) > 0
+	case float32, float64, complex64, complex128:
+		return ToFloat64(v) > 0
+	case bool:
+		return v
+	case string, []byte, []rune:
+		result, _ := strconv.ParseBool(ToString(v))
+		return result
+	default:
+		return false
+	}
+}
+
+// ToInt returns the int result converted by src.
+func ToInt(src interface{}) int {
+	return int(ToInt64(src))
+}
+
+// ToInt32 returns the int32 result converted by src.
+func ToInt32(src interface{}) int32 {
+	return int32(ToInt64(src))
+}
+
+// ToInt64 returns the int64 result converted by src.
+func ToInt64(src interface{}) int64 {
+	switch v := src.(type) {
+	case int:
+		return int64(v)
+	case int8:
+		return int64(v)
+	case int16:
+		return int64(v)
+	case int32:
+		return int64(v)
+	case int64:
+		return v
+	case uint:
+		return int64(v)
+	case uint8:
+		return int64(v)
+	case uint16:
+		return int64(v)
+	case uint32:
+		return int64(v)
+	case uint64:
+		return int64(v)
+	case uintptr:
+		return int64(v)
+	case float32:
+		return int64(v)
+	case float64:
+		return int64(v)
+	case complex64:
+		return int64(real(v))
+	case complex128:
+		return int64(real(v))
+	case bool:
+		if v {
+			return 1
+		}
+		return 0
+	case string:
+		v = strings.TrimSpace(v)
+		index := strings.Index(v, ".")
+		if index != -1 {
+			v = v[:index]
+		}
+		result, _ := strconv.ParseInt(v, 10, 64)
+		return result
+	case []byte:
+		return BytesToInt64(v)
+	default:
+		return 0
+	}
+}
+
+// ToUint returns the uint result converted by src.
+func ToUint(src interface{}) uint {
+	return uint(ToUint64(src))
+}
+
+// ToUint32 returns the uint32 result converted by src.
+func ToUint32(src interface{}) uint32 {
+	return uint32(ToUint64(src))
+}
+
+// ToUint64 returns the uint64 result converted by src.
+func ToUint64(src interface{}) uint64 {
+	switch v := src.(type) {
+	case int:
+		return uint64(v)
+	case int8:
+		return uint64(v)
+	case int16:
+		return uint64(v)
+	case int32:
+		return uint64(v)
+	case int64:
+		return uint64(v)
+	case uint:
+		return uint64(v)
+	case uint8:
+		return uint64(v)
+	case uint16:
+		return uint64(v)
+	case uint32:
+		return uint64(v)
+	case uint64:
+		return v
+	case uintptr:
+		return uint64(v)
+	case float32:
+		return uint64(v)
+	case float64:
+		return uint64(v)
+	case complex64:
+		return uint64(real(v))
+	case complex128:
+		return uint64(real(v))
+	case bool:
+		if v {
+			return 1
+		}
+		return 0
+	case string:
+		v = strings.TrimSpace(v)
+		index := strings.Index(v, ".")
+		if index != -1 {
+			v = v[:index]
+		}
+		result, _ := strconv.ParseUint(v, 10, 64)
+		return result
+	case []byte:
+		return BytesToUint64(v)
+	default:
+		return 0
+	}
+}
+
+// ToFloat returns the float64 result converted by src.
+func ToFloat(src interface{}) float64 {
+	return ToFloat64(src)
+}
+
+// ToFloat32 returns the float32 result converted by src.
+func ToFloat32(src interface{}) float32 {
+	return float32(ToFloat64(src))
+}
+
+// ToFloat64 returns the float64 result converted by src.
+func ToFloat64(src interface{}) float64 {
+	switch v := src.(type) {
+	case int, int8, int16, int32, int64:
+		return float64(ToInt64(v))
+	case uint, uint8, uint16, uint32, uint64, uintptr:
+		return float64(ToUint64(v))
+	case float32:
+		return float64(v)
+	case float64:
+		return v
+	case complex64:
+		return float64(real(v))
+	case complex128:
+		return real(v)
+	case bool:
+		if v {
+			return 1
+		}
+		return 0
+	case string:
+		v = strings.TrimSpace(v)
+		result, _ := strconv.ParseFloat(v, 64)
+		return result
+	case []byte:
+		return BytesToFloat64(v)
+	default:
+		return 0
+	}
+}
+
+// BytesToInt64 returns the int64 result converted by byte slice bytes.
+func BytesToInt64(bytes []byte) int64 {
+	return int64(BytesToUint64(bytes))
+}
+
+// Int64ToBytes returns the byte slice result converted by int64 i.
+func Int64ToBytes(i int64) []byte {
+	return Uint64ToBytes(uint64(i))
+}
+
+// BytesToUint64 returns the uint64 result converted by byte slice bytes.
+func BytesToUint64(bytes []byte) uint64 {
+	return binary.BigEndian.Uint64(bytes)
+}
+
+// Uint64ToBytes returns the byte slice result converted by uint64 i.
+func Uint64ToBytes(i uint64) []byte {
+	bytes := make([]byte, 8)
+	binary.BigEndian.PutUint64(bytes, i)
+	return bytes
+}
+
+// BytesToFloat64 returns the float64 result converted by byte slice bytes.
+func BytesToFloat64(bytes []byte) float64 {
+	bits := binary.BigEndian.Uint64(bytes)
+	return math.Float64frombits(bits)
+}
+
+// Float64ToBytes returns the byte slice result converted by float64 f.
+func Float64ToBytes(f float64) []byte {
+	bits := math.Float64bits(f)
+	bytes := make([]byte, 8)
+	binary.BigEndian.PutUint64(bytes, bits)
+	return bytes
+}
+
+// isStruct reports whether i is struct.
+func isStruct(i interface{}) (reflect.Value, bool) {
+	v := reflect.ValueOf(i)
+	if v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			return reflect.Value{}, false
+		}
+		v = v.Elem()
+	}
+	if v.Kind() != reflect.Struct {
+		return reflect.Value{}, false
+	}
+	return v, true
+}
+
+// getStructFieldName returns the struct field name.
+func getStructFieldName(sf reflect.StructField) string {
+	name := strings.SplitN(sf.Tag.Get("json"), ",", 2)[0]
+	if name == "-" {
+		return ""
+	} else if name == "" {
+		return sf.Name
+	}
+	return name
+}
+
+// StructToInterfaceMap returns the map[string]interface{} result converted by struct s.
+func StructToInterfaceMap(s interface{}, ignoreZeroValue ...bool) map[string]interface{} {
+	m := make(map[string]interface{})
+	v, flag := isStruct(s)
+	if !flag {
+		return m
+	}
+
+	ignore := false
+	if len(ignoreZeroValue) != 0 {
+		ignore = ignoreZeroValue[0]
+	}
+
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		f := v.Field(i)
+		name := getStructFieldName(t.Field(i))
+		if name == "" || (ignore && f.IsZero()) {
+			continue
+		}
+		if f.Kind() == reflect.Ptr && !f.IsNil() {
+			f = f.Elem()
+		}
+		m[name] = f.Interface()
+	}
+
+	return m
+}
+
+// StructToStringMap returns the map[string]string result converted by struct s.
+func StructToStringMap(s interface{}, ignoreZeroValue ...bool) map[string]string {
+	m := make(map[string]string)
+	v, flag := isStruct(s)
+	if !flag {
+		return m
+	}
+
+	ignore := false
+	if len(ignoreZeroValue) != 0 {
+		ignore = ignoreZeroValue[0]
+	}
+
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		f := v.Field(i)
+		name := getStructFieldName(t.Field(i))
+		if name == "" || (ignore && f.IsZero()) {
+			continue
+		}
+		if f.Kind() == reflect.Ptr && !f.IsNil() {
+			f = f.Elem()
+		}
+		m[name] = ToString(f.Interface())
+	}
+
+	return m
+}
+
+// ObjToMapString 将struct结构体转换成map
+func ObjToMapString(obj interface{}) map[string]string {
+	m := make(map[string]string)
+	elem := reflect.ValueOf(obj).Elem()
+	relType := elem.Type()
+
+	for i := 0; i < relType.NumField(); i++ {
+		m[relType.Field(i).Name] = ToString(elem.Field(i).Interface())
+	}
+	return m
+}
+
+// JsonToMapString 将json结构体转换成map
+func JsonToMapString(in interface{}) map[string]string {
+	m := make(map[string]interface{})
+	j, _ := json.Marshal(in)
+	var s string
+	decoder := json.NewDecoder(strings.NewReader(string(j)))
+	decoder.UseNumber()
+	decoder.Decode(&m)
+
+	//json.Unmarshal(j, &m)
+	ret := make(map[string]string)
+	for k, v := range m {
+		s = fmt.Sprintf("%v", v)
+		if s == "" {
+			continue
+		}
+		ret[k] = s
+	}
+	return ret
+}

pkg/util/jwt.go

+package util
+
+import (
+	"slg/pkg/setting"
+	"github.com/dgrijalva/jwt-go"
+	"time"
+)
+
+var jwtSecret []byte
+
+type Claims struct {
+	UserInfo UserInfo `json:"user"`
+	jwt.StandardClaims
+}
+
+type UserInfo struct {
+	Uid        int    `json:"uid"`
+	Username   string `json:"username"`
+}
+
+func GenerateToken(username, password string) (string, error) {
+	//nowTime := time.Now()
+	//expireTime := nowTime.Add(3 * time.Hour)
+	expiresTime := time.Now().Unix() + int64(60*60*24)
+
+	claims := jwt.StandardClaims{
+		Audience:  setting.AppSetting.Audience,
+		Issuer:    setting.AppSetting.Issuer,
+		ExpiresAt: expiresTime,
+		IssuedAt:  time.Now().Unix(),
+		NotBefore: time.Now().Unix(),
+		Subject:   "login",
+	}
+	var jwtSecret = []byte(setting.AppSetting.JwtSecret)
+
+	tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	token, err := tokenClaims.SignedString(jwtSecret)
+
+	return token, err
+}
+
+func ParseToken(token string) (*Claims, error) {
+	tokenClaims, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (interface{}, error) {
+		return jwtSecret, nil
+	})
+
+	if tokenClaims != nil {
+		if claims, ok := tokenClaims.Claims.(*Claims); ok && tokenClaims.Valid {
+			return claims, nil
+		}
+	}
+
+	return nil, err
+}

pkg/util/md5.go

+package util
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+)
+
+func EncodeMD5(value string) string{
+	m:= md5.New()
+	m.Write([]byte(value))
+
+	return hex.EncodeToString(m.Sum(nil))
+}
\ No newline at end of file

pkg/util/pagination.go

+package util
+
+import (
+	"github.com/gin-gonic/gin"
+	"slg/pkg/setting"
+)
+
+// GetPage get page parameters
+func GetPage(c *gin.Context) int {
+	result := 0
+	page := ToInt(c.DefaultQuery("page", "1"))
+	size := ToInt(c.DefaultQuery("size", "0"))
+
+	if size == 0 {
+		size = setting.AppSetting.PageSize
+	}
+	if page > 0 {
+		result = (page - 1) * size
+	}
+
+	return result
+}
+
+// GetLimit get page parameters
+func GetLimit(c *gin.Context) int {
+	result := setting.AppSetting.PageSize
+	size := ToInt(c.DefaultQuery("size", "0"))
+	if size > 0 {
+		result = size
+	}
+
+	return result
+}

pkg/util/time.go

+package util
+
+import "time"
+
+func GetCurrentDate() string {
+	return time.Now().Format("2006/01/02 15:04:05")
+}
+
+func GetCurrentUnix() int64 {
+	return time.Now().Unix()
+}
+
+func GetCurrentMilliUnix() int64 {
+	return time.Now().UnixNano() / 1000000
+}
+
+func GetCurrentNanoUnix() int64 {
+	return time.Now().UnixNano()
+}
+
+func FormatUnix(time_tmp int64) string {
+	return time.Unix(time_tmp, 0).Format("2006-01-02 15:04:05")
+}

pkg/util/util.go

+package util
+
+import (
+	"crypto/md5"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math"
+	"net"
+	"reflect"
+	"slg/pkg/setting"
+	"strconv"
+)
+
+// Setup Initialize the util
+func Setup() {
+	jwtSecret = []byte(setting.AppSetting.JwtSecret)
+}
+
+// IPString2Long 把ip字符串转为数值
+func IPString2Long(ip string) (uint, error) {
+	b := net.ParseIP(ip).To4()
+	if b == nil {
+		return 0, errors.New("invalid ipv4 format")
+	}
+
+	return uint(b[3]) | uint(b[2])<<8 | uint(b[1])<<16 | uint(b[0])<<24, nil
+}
+
+// Long2IPString 把数值转为ip字符串
+func Long2IPString(i uint) (string, error) {
+	if i > math.MaxUint32 {
+		return "", errors.New("beyond the scope of ipv4")
+	}
+
+	ip := make(net.IP, net.IPv4len)
+	ip[0] = byte(i >> 24)
+	ip[1] = byte(i >> 16)
+	ip[2] = byte(i >> 8)
+	ip[3] = byte(i)
+
+	return ip.String(), nil
+}
+
+func Serialization(value interface{}) ([]byte, error) {
+	if bytes, ok := value.([]byte); ok {
+		return bytes, nil
+	}
+
+	switch v := reflect.ValueOf(value); v.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return []byte(strconv.FormatInt(v.Int(), 10)), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return []byte(strconv.FormatUint(v.Uint(), 10)), nil
+	case reflect.Map:
+	}
+	k, err := json.Marshal(value)
+	return k, err
+}
+
+func Deserialization(byt []byte, ptr interface{}) (err error) {
+	if bytes, ok := ptr.(*[]byte); ok {
+		*bytes = byt
+		return
+	}
+	if v := reflect.ValueOf(ptr); v.Kind() == reflect.Ptr {
+		switch p := v.Elem(); p.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			var i int64
+			i, err = strconv.ParseInt(string(byt), 10, 64)
+			if err != nil {
+				fmt.Printf("Deserialization: failed to parse int '%s': %s", string(byt), err)
+			} else {
+				p.SetInt(i)
+			}
+			return
+
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			var i uint64
+			i, err = strconv.ParseUint(string(byt), 10, 64)
+			if err != nil {
+				fmt.Printf("Deserialization: failed to parse uint '%s': %s", string(byt), err)
+			} else {
+				p.SetUint(i)
+			}
+			return
+		}
+	}
+	err = json.Unmarshal(byt, &ptr)
+	return
+}
+
+func StringToMd5(str string) string {
+	m5 := md5.New()
+	_, err := m5.Write([]byte(str))
+	if err != nil {
+		panic(err)
+	}
+	md5String := hex.EncodeToString(m5.Sum(nil))
+	return md5String
+}
+
+func Contains(slice []string, val string) (int, bool) {
+	for i, item := range slice {
+		if item == val {
+			return i, true
+		}
+	}
+	return -1, false
+}
+
+func FormatFloat(num float64, decimal int) string {
+	// 默认乘1
+	d := float64(1)
+	if decimal > 0 {
+		// 10的N次方
+		d = math.Pow10(decimal)
+	}
+	// math.trunc作用就是返回浮点数的整数部分
+	// 再除回去，小数点后无效的0也就不存在了
+	return strconv.FormatFloat(math.Trunc(num*d)/d, 'f', -1, 64)
+}
+
+func Float64FromBytes(bytes []byte) float64 {
+	bits := binary.LittleEndian.Uint64(bytes)
+	float := math.Float64frombits(bits)
+	return float
+}
+
+func Float64Bytes(float float64) []byte {
+	bits := math.Float64bits(float)
+	bytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(bytes, bits)
+	return bytes
+}

routers/api/h5/bank.go

+package h5
+
+import (
+	"github.com/gin-gonic/gin"
+	"slg/pkg/errno"
+	"slg/pkg/handler"
+	"slg/service/bank_service"
+	"slg/validate_service"
+	"strings"
+)
+
+func GetBank(c *gin.Context) {
+
+	handler.SendResponse(c, nil, nil)
+}
+
+func AddBank(c *gin.Context) {
+	bank := validate_service.Bank{}
+	c.ShouldBindJSON(&bank)
+
+	if ok, errors := validate_service.ValidateInputs(bank); !ok {
+		for _, err := range errors {
+			handler.SendResponse(c, errno.ErrBind, strings.Join(err, " "))
+			return
+		}
+	}
+
+	bank_service := bank_service.Bank{
+		BankName: bank.BankName,
+	}
+
+	if err := bank_service.Add(); err != nil {
+		handler.SendResponse(c, errno.ErrAddBank, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, nil)
+}
+
+func UpdateBank(c *gin.Context) {
+
+	handler.SendResponse(c, nil, nil)
+}
+
+func DeleteBank(c *gin.Context) {
+
+	handler.SendResponse(c, nil, nil)
+}
\ No newline at end of file

routers/router.go

+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"slg/middleware/jwt"
+	"slg/routers/api/h5"
+)
+
+func InitRouter() *gin.Engine {
+	r := gin.New()
+	r.Use(gin.Logger())
+	r.Use(gin.Recovery())
+
+	client := r.Group("/h5")
+	client.GET("/banks", h5.GetBank)
+	client.POST("/add-bank", h5.AddBank)
+	client.PUT("/update-bank", h5.UpdateBank)
+	client.DELETE("/delete-bank", h5.DeleteBank)
+
+	api := r.Group("/api")
+	api.Use(jwt.JWT())
+	{
+
+	}
+
+	return r
+}

service/bank_service/bank.go

+package bank_service
+
+import "slg/models"
+
+type Bank struct {
+	BankName      string
+}
+
+func (b *Bank) Add() error {
+	bank := map[string]interface{}{
+		"bankname":      b.BankName,
+	}
+
+	if err := models.AddBank(bank); err != nil {
+		return err
+	}
+
+	return nil
+}
\ No newline at end of file

validate_service/bank.go

+package validate_service
+
+type Bank struct {
+	BankName      string `json:"name" validate:"required"`
+}

validate_service/validate.go

+package validate_service
+
+import (
+	"gopkg.in/go-playground/validator.v9"
+	"reflect"
+	"strings"
+)
+
+func ValidateInputs(dataSet interface{}) (bool, map[string][]string) {
+	validate := validator.New()
+
+	err := validate.Struct(dataSet)
+
+	if err != nil {
+
+		//Validation syntax is invalid
+		if err, ok := err.(*validator.InvalidValidationError); ok {
+			panic(err)
+		}
+
+		//Validation errors occurred
+		errors := make(map[string][]string)
+		//Use reflector to reverse engineer struct
+		reflected := reflect.ValueOf(dataSet)
+		for _, err := range err.(validator.ValidationErrors) {
+
+			// Attempt to find field by name and get json tag name
+			field, _ := reflected.Type().FieldByName(err.StructField())
+			var name string
+
+			//If json tag doesn't exist, use lower case of name
+			if name = field.Tag.Get("json"); name == "" {
+				name = strings.ToLower(err.StructField())
+			}
+
+			switch err.Tag() {
+			case "required":
+				errors[name] = append(errors[name], "The "+name+" is required")
+				break
+			case "email":
+				errors[name] = append(errors[name], "The "+name+" should be a valid email")
+				break
+			case "url":
+				errors[name] = append(errors[name], "The "+name+" should be a valid url")
+				break
+			case "eqfield":
+				errors[name] = append(errors[name], "The "+name+" should be equal to the "+err.Param())
+				break
+			default:
+				errors[name] = append(errors[name], "The "+name+" is invalid")
+				break
+			}
+		}
+
+		return false, errors
+	}
+	return true, nil
+}
+