rag/internal/providers/gin.go

package providers

import (
	"fmt"
	"framework_v2/internal/access"
	"framework_v2/internal/consts"
	"framework_v2/internal/helper"
	ginzap "github.com/gin-contrib/zap"
	"github.com/gin-gonic/gin"
	"net/http"
	"reflect"
	"time"
)

func InitGin() {
	gin.SetMode(gin.ReleaseMode)

	access.Router = gin.New()

	access.Router.Use(ginzap.Ginzap(access.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{}) {
	access.Router.GET(relativePath, func(c *gin.Context) {
		doHandler(c, handlers...)
	})
}

func POST(relativePath string, handlers ...interface{}) {
	access.Router.POST(relativePath, func(c *gin.Context) {
		doHandler(c, handlers...)
	})
}

func PUT(relativePath string, handlers ...interface{}) {
	access.Router.PUT(relativePath, func(c *gin.Context) {
		doHandler(c, handlers...)
	})
}

func PATCH(relativePath string, handlers ...interface{}) {
	access.Router.PATCH(relativePath, func(c *gin.Context) {
		doHandler(c, handlers...)
	})
}

func DELETE(relativePath string, handlers ...interface{}) {
	access.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 {
				helper.ResponseError(c, http.StatusBadRequest, 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((*consts.User)(nil)):
			userInfo := DIJWTAuth(c)
			if userInfo == nil {
				helper.ResponseError(c, http.StatusUnauthorized, ErrNotValidToken)
				return
			}
			argValue = reflect.ValueOf(userInfo)
		default:
			helper.ResponseError(c, http.StatusBadRequest, fmt.Errorf("invalid argument type: %s", argType.String()))
			return
		}

		args = append(args, argValue)
	}

	fnValue.Call(args)
}