baize/framework/core/api/router.go

package api

import (
	"errors"
	"net/http"

	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/gin-gonic/gin"
)

// Handler 请求处理函数
type Handler func(c *Context)

// Router 路由接口
type Router interface {
	// AddMiddlewares 添加中间件
	AddMiddlewares(middlewares ...Handler) Router

	// RegisterVersionedRouter 注册版本路由
	RegisterVersionedRouter(version string, middlewares ...Handler) Router

	// VersionedRouter 获取版本路由
	VersionedRouter(version string) Router

	// AddRoute 添加路由路径
	AddRoute(method string, relativePath string, handlers ...Handler) Router

	// Static 静态路由(指向目录)
	Static(relativePath string, root string)

	// StaticFile 静态路由(指向文件)
	StaticFile(relativePath string, filepath string)

	// BasePath 路由的基础路径，即去掉http://ip:port之后的URL部分(不包括AddRoute的RelativePath)
	BasePath() string

	// DumpPermissionItems 获取权限条目
	DumpPermissionItems() []PermissionItem
}

type PermissionItem struct {
	Group              string `json:"group"`
	Name               string `json:"name"`
	Description        string `json:"description"`
	Resource           string `json:"resource"`
	Action             string `json:"action"`
	NeedCheckExpire    bool   `json:"needCheckExpire"`
	SensitiveWordScene int    `json:"sensitiveWordScene"`
	Privilege          bool   `json:"privilege"`
	// 添加字段后，注意在下面needUpdate添加判断
}

func (p *PermissionItem) check() error {
	if strutils.IsStringEmpty(p.Name) {
		return errors.New("没有权限条目名称")
	}

	if strutils.IsStringEmpty(p.Resource) {
		return errors.New("没有权限条目resource")
	}

	if strutils.IsStringEmpty(p.Action) {
		return errors.New("没有权限条目action")
	}

	return nil
}

func (p *PermissionItem) needUpdate(oldPermissionItem PermissionItem) bool {
	return p.Group != oldPermissionItem.Group ||
		p.Name != oldPermissionItem.Name ||
		p.Description != oldPermissionItem.Description ||
		p.NeedCheckExpire != oldPermissionItem.NeedCheckExpire ||
		p.SensitiveWordScene != oldPermissionItem.SensitiveWordScene ||
		p.Privilege != oldPermissionItem.Privilege
}

type RootRouter struct {
	engine    *gin.Engine
	versioned map[string]*PrefixRouter

	// 由于gin的router的保证，不会有重复的条目
	permissionItems []PermissionItem
}

func newRootRouter(engine *gin.Engine) *RootRouter {
	return &RootRouter{
		engine:    engine,
		versioned: make(map[string]*PrefixRouter),
	}
}

func (r *RootRouter) AddMiddlewares(middlewares ...Handler) Router {
	r.engine.Use(transferHandlers(middlewares...)...)
	return r
}

func (r *RootRouter) RegisterVersionedRouter(version string, middlewares ...Handler) Router {
	if _, ok := r.versioned[version]; ok {
		panic("重复注册版本路: " + version)
	}

	versioned := r.engine.Group(version, transferHandlers(middlewares...)...)
	r.versioned[version] = newPrefixRouter(versioned)

	return r.versioned[version]
}

func (r *RootRouter) Static(relativePath string, root string) {
	r.engine.Static(relativePath, root)
}

func (r *RootRouter) StaticFile(relativePath string, filepath string) {
	r.engine.StaticFile(relativePath, filepath)
}

func (r *RootRouter) BasePath() string {
	return r.engine.BasePath()
}

// VersionedRouter returns a specific versioned router based on the provided version string
// This is a method of the RootRouter struct that allows accessing version-specific routing configurations
func (r *RootRouter) VersionedRouter(version string) Router {
	// Return the router associated with the specified version from the versioned map
	return r.versioned[version]
}

func (r *RootRouter) DumpPermissionItems() []PermissionItem {
	permissionItems := r.permissionItems
	for _, versioned := range r.versioned {
		permissionItems = append(permissionItems, versioned.DumpPermissionItems()...)
	}

	return permissionItems
}

func (r *RootRouter) AddRoute(method string, relativePathPattern string, handlers ...Handler) Router {
	relativePath, permissionItem, err := parseRelativePathPerm(r.engine.BasePath(), relativePathPattern, method)
	if err != nil {
		panic(err)
	}

	r.engine.Handle(method, relativePath, transferHandlers(handlers...)...)

	if permissionItem != nil {
		r.permissionItems = append(r.permissionItems, *permissionItem)
	}

	return r
}

func (r *RootRouter) ServerHttp(w http.ResponseWriter, req *http.Request) {
	r.engine.ServeHTTP(w, req)
}

type PrefixRouter struct {
	groupRouter *gin.RouterGroup
	versioned   map[string]*PrefixRouter

	// 由于gin的router的保证，不会有重复的条目
	permissionItems []PermissionItem
}

func newPrefixRouter(group *gin.RouterGroup) *PrefixRouter {
	return &PrefixRouter{
		groupRouter: group,
		versioned:   make(map[string]*PrefixRouter),
	}
}

func (r *PrefixRouter) AddMiddlewares(middlewares ...Handler) Router {
	r.groupRouter.Use(transferHandlers(middlewares...)...)
	return r
}

func (r *PrefixRouter) RegisterVersionedRouter(version string, middlewares ...Handler) Router {
	if _, ok := r.versioned[version]; ok {
		panic("重复注册版本路: " + version)
	}

	ginMiddlewares := make([]gin.HandlerFunc, 0)
	for _, m := range middlewares {
		innerM := m
		ginMiddlewares = append(ginMiddlewares, func(c *gin.Context) {
			innerM(&Context{Context: c})
		})
	}

	versioned := r.groupRouter.Group(version, ginMiddlewares...)
	r.versioned[version] = newPrefixRouter(versioned)

	return r.versioned[version]
}

func (r *PrefixRouter) VersionedRouter(version string) Router {
	return r.versioned[version]
}

func (r *PrefixRouter) AddRoute(method string, relativePathPattern string, handlers ...Handler) Router {
	relativePath, permissionItem, err := parseRelativePathPerm(r.groupRouter.BasePath(), relativePathPattern, method)
	if err != nil {
		panic(err)
	}

	r.groupRouter.Handle(method, relativePath, transferHandlers(handlers...)...)

	if permissionItem != nil {
		r.permissionItems = append(r.permissionItems, *permissionItem)
	}

	return r
}

func (r *PrefixRouter) Static(relativePath string, root string) {
	r.groupRouter.Static(relativePath, root)
}

func (r *PrefixRouter) StaticFile(relativePath string, filepath string) {
	r.groupRouter.StaticFile(relativePath, filepath)
}

func (r *PrefixRouter) BasePath() string {
	return r.groupRouter.BasePath()
}

func (r *PrefixRouter) DumpPermissionItems() []PermissionItem {
	permissionItems := r.permissionItems
	for _, versioned := range r.versioned {
		permissionItems = append(permissionItems, versioned.DumpPermissionItems()...)
	}

	return permissionItems
}

func transferHandlers(handlers ...Handler) []gin.HandlerFunc {
	ginHandlers := make([]gin.HandlerFunc, 0)
	for _, handler := range handlers {
		innerHandler := handler
		ginHandlers = append(ginHandlers, func(c *gin.Context) {
			innerHandler(&Context{Context: c})
		})
	}

	return ginHandlers
}