124 lines
2.8 KiB
Go
124 lines
2.8 KiB
Go
package gin
|
|
|
|
import (
|
|
"fmt"
|
|
"framework_v2/internal/app/facades"
|
|
"framework_v2/internal/app/helpers"
|
|
"framework_v2/internal/app/user"
|
|
http2 "framework_v2/internal/middleware/http"
|
|
ginzap "github.com/gin-contrib/zap"
|
|
"github.com/gin-gonic/gin"
|
|
"net/http"
|
|
"reflect"
|
|
"time"
|
|
)
|
|
|
|
func InitGin() {
|
|
gin.SetMode(gin.ReleaseMode)
|
|
|
|
facades.Router = gin.New()
|
|
|
|
facades.Router.Use(ginzap.Ginzap(facades.Logger, time.RFC3339, true))
|
|
//access.Router.Use(gin.Recovery())
|
|
//access.Router.Use(ginzap.RecoveryWithZap(access.Logger, true))
|
|
}
|
|
|
|
//func HandleRoute(method httpMethod, relativePath string, controller HandlerFunc, middlewares ...gin.HandlerFunc) {
|
|
// access.Router.Handle(method.String(), relativePath, func(c *gin.Context) {
|
|
// for _, middleware := range middlewares {
|
|
// middleware(c)
|
|
// }
|
|
//
|
|
// if !c.IsAborted() {
|
|
// handleWithMetadata(c, controller)
|
|
// }
|
|
// })
|
|
//}
|
|
|
|
//func handleWithMetadata(c *gin.Context, controller HandlerFunc) {
|
|
// var metadata = &consts.Request{
|
|
// Http: c,
|
|
// User: GetAuthFromCtx(c),
|
|
// }
|
|
//
|
|
// controller(metadata)
|
|
//}
|
|
|
|
func GET(relativePath string, handlers ...interface{}) {
|
|
facades.Router.GET(relativePath, func(c *gin.Context) {
|
|
doHandler(c, handlers...)
|
|
})
|
|
}
|
|
|
|
func POST(relativePath string, handlers ...interface{}) {
|
|
facades.Router.POST(relativePath, func(c *gin.Context) {
|
|
doHandler(c, handlers...)
|
|
})
|
|
}
|
|
|
|
func PUT(relativePath string, handlers ...interface{}) {
|
|
facades.Router.PUT(relativePath, func(c *gin.Context) {
|
|
doHandler(c, handlers...)
|
|
})
|
|
}
|
|
|
|
func PATCH(relativePath string, handlers ...interface{}) {
|
|
facades.Router.PATCH(relativePath, func(c *gin.Context) {
|
|
doHandler(c, handlers...)
|
|
})
|
|
}
|
|
|
|
func DELETE(relativePath string, handlers ...interface{}) {
|
|
facades.Router.DELETE(relativePath, func(c *gin.Context) {
|
|
doHandler(c, handlers...)
|
|
})
|
|
}
|
|
|
|
func doHandler(c *gin.Context, handlers ...interface{}) {
|
|
for _, handler := range handlers {
|
|
if c.IsAborted() {
|
|
// 是否已经响应
|
|
if c.Writer.Written() {
|
|
return
|
|
} else {
|
|
helpers.ResponseError(c, http.StatusBadRequest, http2.ErrEmptyResponse)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
wrapHandler(c, handler)
|
|
}
|
|
}
|
|
|
|
func wrapHandler(c *gin.Context, f interface{}) {
|
|
fnValue := reflect.ValueOf(f)
|
|
fnType := fnValue.Type()
|
|
|
|
var args []reflect.Value
|
|
|
|
for i := 0; i < fnType.NumIn(); i++ {
|
|
argType := fnType.In(i)
|
|
|
|
var argValue reflect.Value
|
|
switch argType {
|
|
case reflect.TypeOf((*gin.Context)(nil)):
|
|
argValue = reflect.ValueOf(c)
|
|
case reflect.TypeOf((*user.User)(nil)):
|
|
userInfo := http2.DIJWTAuth(c)
|
|
if userInfo == nil {
|
|
helpers.ResponseError(c, http.StatusUnauthorized, http2.ErrNotValidToken)
|
|
return
|
|
}
|
|
argValue = reflect.ValueOf(userInfo)
|
|
default:
|
|
helpers.ResponseError(c, http.StatusBadRequest, fmt.Errorf("invalid argument type: %s", argType.String()))
|
|
return
|
|
}
|
|
|
|
args = append(args, argValue)
|
|
}
|
|
|
|
fnValue.Call(args)
|
|
}
|