IOT/SERVER/IotAdmin/app/system/router/router.go

package router

import (
	"IotAdmin/app/system/apis"
	"IotAdmin/common/middleware"
	"IotAdmin/common/middleware/handler"
	"IotAdmin/core/logger"
	"IotAdmin/core/sdk"
	"IotAdmin/core/sdk/config"
	jwt "IotAdmin/core/sdk/pkg/jwt-auth"
	"IotAdmin/core/sdk/pkg/ws"
	"mime"
	"os"

	"github.com/gin-gonic/gin"
	swaggerfiles "github.com/swaggo/files"
	ginSwagger "github.com/swaggo/gin-swagger"

	_ "IotAdmin/docs/admin"
)

var (
	routerNoCheckRole = make([]func(*gin.RouterGroup), 0)
	routerCheckRole   = make([]func(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware), 0)
)

// InitRouter 路由初始化
func InitRouter() {
	var r *gin.Engine
	h := sdk.Runtime.GetEngine()
	if h == nil {
		logger.Fatal("未发现Engine...")
		os.Exit(-1)
	}
	switch h.(type) {
	case *gin.Engine:
		r = h.(*gin.Engine)
	default:
		logger.Fatal("不支持其他engine")
		os.Exit(-1)
	}

	// the jwt middleware
	authMiddleware, err := middleware.AuthInit()
	if err != nil {
		logger.Fatalf("JWT初始化错误, %s", err.Error())
	}
	// 注册系统路由
	initSysRouter(r, authMiddleware)
	// 注册业务路由
	noCheckRoleRouter(r)
	checkRoleRouter(r, authMiddleware)
}

func initSysRouter(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) *gin.RouterGroup {
	g := r.Group("")
	sysBaseRouter(g, authMiddleware)
	// 静态文件
	sysStaticFileRouter(g)
	// swagger；注意：生产环境可以注释掉
	if config.ApplicationConfig.Mode != "prod" {
		sysSwaggerRouter(g)
	}
	return g
}

func sysBaseRouter(r *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {

	go ws.WebsocketManager.Start()
	go ws.WebsocketManager.SendService()
	go ws.WebsocketManager.SendAllService()

	if config.ApplicationConfig.Mode != "prod" {
		r.GET("/", apis.Admin)
	}
	r.GET("/info", handler.Ping)
	r1 := r.Group("/api/")
	{
		r1.POST("/login", authMiddleware.LoginHandler)
		// Refresh time can be longer than token timeout
		r1.GET("/refresh-token", authMiddleware.RefreshHandler)
		// 验证码
		r1.GET("/captcha", (&apis.SystemApi{}).GenerateCaptchaHandler)
	}
	r2 := r.Group("/api/").Use(authMiddleware.MiddlewareFunc())
	{
		r2.POST("/logout", handler.LogOut)
	}
	wss := r.Group("").Use(authMiddleware.MiddlewareFunc())
	{
		wss.GET("/ws/:id/:channel", ws.WebsocketManager.WsClient)
		wss.GET("/ws-logout/:id/:channel", ws.WebsocketManager.UnWsClient)
	}

}

func sysStaticFileRouter(r *gin.RouterGroup) {
	err := mime.AddExtensionType(".js", "application/javascript")
	if err != nil {
		return
	}
	r.Static("/static", "./static")
	if config.ApplicationConfig.Mode != "prod" {
		r.Static("/form-generator", "./static/form-generator")
	}
}

func sysSwaggerRouter(r *gin.RouterGroup) {
	r.GET("/swagger/admin/*any", ginSwagger.WrapHandler(swaggerfiles.NewHandler(), ginSwagger.InstanceName("admin")))
}

// 无需认证的路由
func noCheckRoleRouter(r *gin.Engine) *gin.Engine {
	// 可根据业务需求来设置接口版本
	v1 := r.Group("/api")
	for _, f := range routerNoCheckRole {
		f(v1)
	}
	return r
}

// 需要认证的路由
func checkRoleRouter(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) *gin.Engine {
	// 可根据业务需求来设置接口版本
	v1 := r.Group("/api")
	for _, f := range routerCheckRole {
		f(v1, authMiddleware)
	}
	return r
}