device-manage-server/device-manage/app/admin/router/router.go

package router

import (
	"device-manage/app/admin/apis/business"
	"device-manage/app/admin/middleware"
	"device-manage/pkg/jwtauth"
	jwt "device-manage/pkg/jwtauth"

	"github.com/gin-gonic/gin"
	_ "github.com/gin-gonic/gin"
)

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

// 路由示例
func InitBusinessRouter(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) *gin.Engine {

	// 无需认证的路由
	businessNoCheckRoleRouter(r)
	// 需要认证的路由
	businessCheckRoleRouter(r, authMiddleware)

	return r
}

// 无需认证的路由示例
func businessNoCheckRoleRouter(r *gin.Engine) {
	// 可根据业务需求来设置接口版本
	v1 := r.Group("/api/v1")
	// 空接口防止v1定义无使用报错
	v1.GET("/nilcheckrole", nil)

	for _, f := range routerNoCheckRole {
		f(v1)
	}

	// {{无需认证路由自动补充在此处请勿删除}}
	registerSysFileInfoRouter(v1)
	registerSysFileDirRouter(v1)
}

// 需要认证的路由示例
func businessCheckRoleRouter(r *gin.Engine, authMiddleware *jwtauth.GinJWTMiddleware) {
	// 可根据业务需求来设置接口版本
	v1 := r.Group("/api/v1")
	// 空接口防止v1定义无使用报错
	//v1.GET("/checkrole", nil)

	/*for _, f := range routerCheckRole {
		f(v1, authMiddleware)
	}
	*/
	// {{认证路由自动补充在此处请勿删除}}
	//registerSysContentRouter(v1, authMiddleware)
	registerBusinessPageRouter(v1, authMiddleware)
	registerSysCategoryRouter(v1, authMiddleware)
	registerDeviceListRouter(v1, authMiddleware)
	registerDeviceMonitorRouter(v1, authMiddleware)
	registerDeviceLogRouter(v1, authMiddleware)
	registerDownloadDeviceLogRouter(v1, authMiddleware)
	registerApplicationRouter(v1, authMiddleware)
	registerAppPublishRouter(v1, authMiddleware)
	registerAppDeviceRouter(v1, authMiddleware)
	registerAppGroupRouter(v1, authMiddleware)
	registerUpgradeFileRouter(v1, authMiddleware)
	registerUpgradeFileDownloadRouter(v1, authMiddleware)
	registerGroupRouter(v1, authMiddleware)
	registerVideoRouter(v1, authMiddleware)
	registerMediaVisitRouter(v1, authMiddleware)
	registerPlayMenuRouter(v1, authMiddleware)
	registerPlayItemRouter(v1, authMiddleware)
	registerPlayAttrisRouter(v1, authMiddleware)
	registerMediaPublishMangeRouter(v1, authMiddleware)
	registerDevicesUsualRouter(v1, authMiddleware)
	registerUpgradeRecordRouter(v1, authMiddleware)

}

func registerBusinessPageRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.POST("/devicelist", business.GetDeviceList)
		sysuser.POST("/recordlist", business.GetUpgradeRecordList)
		sysuser.POST("/monitorlist", business.GetMonitorList)
		sysuser.POST("/loglist", business.GetLogList)
		sysuser.POST("/applicationlist", business.GetApplicationList)
		sysuser.POST("/upgradefilelist", business.GetUpgradeFileList)
		sysuser.GET("/videolist", business.GetVideoList)
		sysuser.POST("/grouplist", business.GetGroupList)
		sysuser.POST("/app/device/bindlist", business.GetAppDeviceBindedList)
		sysuser.POST("/app/device/unbindlist", business.GetAppDeviceUnBindedList)
		sysuser.POST("/app/group/bindlist", business.GetAppGroupBindedList)
		sysuser.POST("/app/group/unbindlist", business.GetAppGroupUnBindedList)
	}
}

func registerDeviceListRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/device/list").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.POST("", business.InsertDevice)
		sysuser.POST("/statistics", business.GetDeviceStatistics)
		sysuser.POST("/import", business.ImportDevice)
		sysuser.GET("/:deviceId", business.GetDevice)
		sysuser.DELETE("/:deviceId", business.DeleteDevice)
		sysuser.PUT("", business.UpdateDevice)
	}
}

func registerDeviceMonitorRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/device/monitor").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.GET("/log/:deviceId", business.GetDeviceLog)
		sysuser.POST("/reboot/:deviceId", business.RebootDevice)
	}
}

func registerDeviceLogRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/device/log").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.POST("/list", business.GetSingleDeviceLogList)
		sysuser.DELETE("/:logId", business.DeleteDeviceLog)
	}
}

func registerDownloadDeviceLogRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/device/log")
	{
		sysuser.GET("/download", business.DownloadDeviceLog)
	}
}

func registerApplicationRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/app/application").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.POST("", business.InsertApplication)
		sysuser.GET("/:appId", business.GetApplication)
		sysuser.PUT("", business.UpdateApplication)
		sysuser.DELETE("/:appId", business.DeleteApplication)
	}
}

func registerAppPublishRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/app/publish").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.POST("/device", business.PublishApp2Devices)
		sysuser.POST("/group", business.PublishApp2Groups)
	}
}

func registerAppDeviceRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/app/device").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.POST("/bind", business.InsertAppDeviceBinded)
		sysuser.DELETE("/unbind/:bindId", business.DeleteAppDeviceBinded)
	}
}

func registerAppGroupRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/app/group").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.POST("/bind", business.InsertAppGroupBinded)
		sysuser.DELETE("/unbind/:bindId", business.DeleteAppGroupBinded)
	}
}

func registerUpgradeFileRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/app/upgradefile").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.GET("/:upgradefileId", business.GetVersion)
		//sysuser.POST("/download/:upgradefileId", business.DownloadUpgradeFile)
		sysuser.POST("/upload", business.UploadUpgradeFile)
		sysuser.PUT("", business.UpdateUpgradeFile)
		sysuser.DELETE("/:upgradefileId", business.DeleteUpgradeFile)
	}
}

func registerUpgradeFileDownloadRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/app/upgradefile/download")
	{
		r.GET("", business.DownloadUpgradeFile)
	}
}

func registerGroupRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/group/manage").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		sysuser.GET("/:groupId", business.GetGroup)
		sysuser.POST("", business.InsertGroup)
		sysuser.PUT("", business.UpdateGroup)
		sysuser.DELETE("/:groupId", business.DeleteGroup)
	}
}

func registerVideoRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	sysuser := v1.Group("/media/video").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		//download and get video info api
		sysuser.GET("/:videoId", business.GetVideoHandler)
		sysuser.POST("/upload", business.UploadVideo)
		sysuser.POST("/upload/form", business.UploadVideoFormInfo)
		sysuser.PUT("", business.UpdateVideo)
		sysuser.DELETE("/:videoId", business.DeleteVideo)
	}
}

func registerMediaVisitRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/media/visit")
	{
		r.GET("/cover/:id", business.VideoCover)
		r.GET("/video/:id", business.PlayVideo)
		r.GET("/picture/:id", business.Picture)
	}
}

func registerPlayMenuRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/media/menu").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		r.GET("", business.GetPlayMenuList)
		r.POST("", business.AddPlayMenu)
		r.DELETE("/:id", business.DeletePlayMenu)
		r.PUT("", business.UpdatePlayMenu)
	}
}

func registerPlayItemRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/media/item").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		r.GET("/:menuId", business.GetPlayItemList)
		r.POST("", business.AddPlayItemVideo)
		r.DELETE("/:id", business.DeletePlayItem)
	}
}

func registerPlayAttrisRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/media/attri").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		r.GET("/:menuid", business.GetPlayAttris)
		r.PUT("", business.UpdatePlayAttris)
	}

}

func registerMediaPublishMangeRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/media/publish").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		r.POST("/:devids", business.PublishMedia2Devices)
	}

}

//设备接口专用路由,去掉角色检验,直接能够调用.

func registerDevicesUsualRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/device/usual")
	{
		r.GET("/upgradefile/download", business.DeviceDownloadUpgradeFile)
		r.POST("/log/upload", business.DeviceUploadLog)
	}
}

func registerUpgradeRecordRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	r := v1.Group("/device/record").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
	{
		r.DELETE("/:recordId", business.DeleteUpgradeRecord)
	}

}