【权限模块】

api/auth.go

@@ -0,0 +1,381 @@
+package api
+
+import (
+	"net/http"
+	"strconv"
+
+	jwt "github.com/appleboy/gin-jwt/v2"
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"joylink.club/bj-rtsts-server/dto"
+	"joylink.club/bj-rtsts-server/middleware"
+	"joylink.club/bj-rtsts-server/service"
+)
+
+func InitAuthRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
+	authed := api.Group("/v1/auth").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
+	authed.GET("/role/paging", pageQueryRole)
+	authed.GET("/role/list", listQueryRole)
+	authed.POST("/role", createRole)
+	authed.GET("/role/:id", queryRoleInfo)
+	authed.PUT("/role/:id", updateRoleInfo)
+	authed.DELETE("/role/:id", deleteRoleInfo)
+	authed.GET("/path/paging", pageQueryApiPath)
+	authed.GET("/path/list", listQueryApiPath)
+	authed.POST("/path", createApiPath)
+	authed.GET("/path/:id", queryApiPathInfo)
+	authed.PUT("/path/:id", updateApiPathInfo)
+	authed.DELETE("/path/:id", deleteApiPathInfo)
+	authed.POST("/userLinkRole", assignRoleToUser)
+
+}
+
+// 分页查询角色信息
+//
+//	@Summary		分页查询角色信息
+//
+//	@Security		JwtAuth
+//
+//	@Description	分页查询角色信息
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			PageQueryDto	query		dto.PageQueryDto	true	"分页信息"
+//	@Success		200	{object}	dto.PageDto
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/role/paging [get]
+func pageQueryRole(c *gin.Context) {
+	req := dto.PageQueryDto{}
+	if err := c.ShouldBind(&req); err != nil {
+		zap.S().Warn("分页查询参数绑定错误，使用默认参数", err)
+		req.Default()
+	}
+	page, err := service.PageAuthRoleQuery(&req)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err.Error())
+		return
+	}
+	c.JSON(http.StatusOK, page)
+}
+
+// 查询角色列表
+//
+//	@Summary		查询角色列表
+//
+//	@Security		JwtAuth
+//
+//	@Description	查询角色列表
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Success		200	{object}	dto.AuthRoleRspDto
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/role/list [get]
+func listQueryRole(c *gin.Context) {
+	page := service.ListAuthRoleQuery()
+	c.JSON(http.StatusOK, page)
+}
+
+// 创建角色
+//
+//	@Summary		创建角色
+//
+//	@Security		JwtAuth
+//
+//	@Description	创建角色
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			AuthRoleReqDto	query	dto.AuthRoleReqDto	true	"创建角色"
+//	@Success		200	{object}	bool
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/role [post]
+func createRole(c *gin.Context) {
+	req := dto.AuthRoleReqDto{}
+	if err := c.ShouldBind(&req); err != nil {
+		c.JSON(http.StatusBadRequest, "传入参数错误")
+		return
+	}
+	zap.S().Debug("保存数据", req)
+	c.JSON(http.StatusOK, service.CreateAuthRole(&req))
+}
+
+// 查询角色详情
+//
+//	@Summary		查询角色详情
+//
+//	@Security		JwtAuth
+//
+//	@Description	查询角色详情
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			id	path		int	true	"角色ID"
+//	@Success		200	{object}    dto.AuthRoleDetailRspDto
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/role/{id} [get]
+func queryRoleInfo(c *gin.Context) {
+	id, exist := c.Params.Get("id")
+	if !exist {
+		c.JSON(http.StatusBadRequest, "必要参数id不存在")
+		return
+	}
+	zap.S().Debug("传入参数id为" + id)
+	int64Id, _ := strconv.ParseInt(id, 10, 64)
+	c.JSON(http.StatusOK, service.QueryAuthRole(int32(int64Id)))
+}
+
+// 修改角色信息
+//
+//	@Summary		修改角色信息
+//
+//	@Security		JwtAuth
+//
+//	@Description	修改角色信息
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			id	path		int	true	"角色信息ID"
+//	@Param			authRoleReqDto	query	dto.AuthRoleReqDto	true	"修改的角色信息"
+//	@Success		200	{object}	bool
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/role/{id} [put]
+func updateRoleInfo(c *gin.Context) {
+	id, exist := c.Params.Get("id")
+	if !exist {
+		c.JSON(http.StatusBadRequest, "必要参数id不存在")
+		return
+	}
+	zap.S().Debug("传入参数id为" + id)
+	req := dto.AuthRoleReqDto{}
+	if err := c.ShouldBind(&req); err != nil {
+		c.JSON(http.StatusBadRequest, "保存参数出错")
+		return
+	}
+	int64Id, _ := strconv.ParseInt(id, 10, 64)
+	c.JSON(http.StatusOK, service.UpdateAuthRole(int32(int64Id), &req))
+}
+
+// 删除角色信息
+//
+//	@Summary		删除角色信息
+//
+//	@Security		JwtAuth
+//
+//	@Description	删除角色信息
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			id	path		int	true	"角色ID"
+//	@Success		200	{object}	bool
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/role/{id} [delete]
+func deleteRoleInfo(c *gin.Context) {
+	id, exist := c.Params.Get("id")
+	if !exist {
+		c.JSON(http.StatusBadRequest, "必要参数id不存在")
+		return
+	}
+	zap.S().Debug("传入参数id为" + id)
+	int64Id, _ := strconv.ParseInt(id, 10, 64)
+	c.JSON(http.StatusOK, service.DeleteAuthRole(int32(int64Id)))
+}
+
+// 分页查询接口路径信息
+//
+//	@Summary		分页查询接口路径信息
+//
+//	@Security		JwtAuth
+//
+//	@Description	分页查询接口路径信息
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			authApiPathPageReqDto	query		dto.AuthApiPathPageReqDto	true	"分页信息"
+//	@Success		200	{object}	dto.PageDto
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/path/paging [get]
+func pageQueryApiPath(c *gin.Context) {
+	req := dto.AuthApiPathPageReqDto{}
+	if err := c.ShouldBind(&req); err != nil {
+		zap.S().Warn("分页查询参数绑定错误，使用默认参数", err)
+		req.Default()
+	}
+	page, err := service.PageAuthApiPathQuery(&req)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err.Error())
+		return
+	}
+	c.JSON(http.StatusOK, page)
+}
+
+// 查询接口路径列表
+//
+//	@Summary		查询接口路径列表
+//
+//	@Security		JwtAuth
+//
+//	@Description	查询接口路径列表
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Success		200	{object}	model.AuthAPIPath
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/path/list [get]
+func listQueryApiPath(c *gin.Context) {
+	c.JSON(http.StatusOK, service.ListAuthApiPathQuery())
+}
+
+// 创建接口路径
+//
+//	@Summary		创建接口路径
+//
+//	@Security		JwtAuth
+//
+//	@Description	创建接口路径
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			authApiPathReqDto	query	dto.AuthApiPathReqDto	true	"创建路径信息"
+//	@Success		200	{object}	bool
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/path [post]
+func createApiPath(c *gin.Context) {
+	req := dto.AuthApiPathReqDto{}
+	if err := c.ShouldBind(&req); err != nil {
+		c.JSON(http.StatusBadRequest, "传入参数错误")
+		return
+	}
+	zap.S().Debug("保存数据", req)
+	c.JSON(http.StatusOK, service.CreateAuthApiPath(&req))
+}
+
+// 查询接口路径
+//
+//	@Summary		查询接口路径
+//
+//	@Security		JwtAuth
+//
+//	@Description	查询接口路径
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			id	path		int	true	"接口路径ID"
+//	@Success		200	{object}    model.AuthAPIPath
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/path/{id} [get]
+func queryApiPathInfo(c *gin.Context) {
+	id, exist := c.Params.Get("id")
+	if !exist {
+		c.JSON(http.StatusBadRequest, "必要参数id不存在")
+		return
+	}
+	zap.S().Debug("传入参数id为" + id)
+	int64Id, _ := strconv.ParseInt(id, 10, 64)
+	c.JSON(http.StatusOK, service.QueryAuthApiPath(int32(int64Id)))
+}
+
+// 修改接口路径
+//
+//	@Summary		修改接口路径
+//
+//	@Security		JwtAuth
+//
+//	@Description	修改接口路径
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			id	path		int	true	"接口路径ID"
+//	@Param			authApiPathReqDto	query	dto.AuthApiPathReqDto	true	"修改的接口路径"
+//	@Success		200	{object}	bool
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/path/{id} [put]
+func updateApiPathInfo(c *gin.Context) {
+	id, exist := c.Params.Get("id")
+	if !exist {
+		c.JSON(http.StatusBadRequest, "必要参数id不存在")
+		return
+	}
+	zap.S().Debug("传入参数id为" + id)
+	req := dto.AuthApiPathReqDto{}
+	if err := c.ShouldBind(&req); err != nil {
+		c.JSON(http.StatusBadRequest, "保存参数出错")
+		return
+	}
+	int64Id, _ := strconv.ParseInt(id, 10, 64)
+	c.JSON(http.StatusOK, service.UpdateAuthApiPath(int32(int64Id), &req))
+}
+
+// 删除接口路径
+//
+//	@Summary		删除接口路径
+//
+//	@Security		JwtAuth
+//
+//	@Description	删除接口路径
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			id	path		int	true	"接口路径ID"
+//	@Success		200	{object}	bool
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/path/{id} [delete]
+func deleteApiPathInfo(c *gin.Context) {
+	id, exist := c.Params.Get("id")
+	if !exist {
+		c.JSON(http.StatusBadRequest, "必要参数id不存在")
+		return
+	}
+	zap.S().Debug("传入参数id为" + id)
+	int64Id, _ := strconv.ParseInt(id, 10, 64)
+	c.JSON(http.StatusOK, service.DeleteAuthApiPath(int32(int64Id)))
+}
+
+// 用户关联角色
+//
+//	@Summary		用户关联角色
+//
+//	@Security		JwtAuth
+//
+//	@Description	用户关联角色
+//	@Tags			权限Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			authRoleUserReqDto	query	dto.AuthRoleUserReqDto	true	"关联角色信息"
+//	@Success		200	{object}	bool
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/auth/userLinkRole [post]
+func assignRoleToUser(c *gin.Context) {
+	req := dto.AuthRoleUserReqDto{}
+	if err := c.ShouldBind(&req); err != nil {
+		c.JSON(http.StatusBadRequest, "保存参数出错")
+		return
+	}
+	c.JSON(http.StatusOK, service.UserLinkRole(&req))
+}

api/category.go

@@ -13,7 +13,7 @@ import (
 )
 
 func InitCategoryRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/category").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/category").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.GET("/paging", pageQueryCategory)
 	authed.GET("/list", listQueryCategory)
 	authed.POST("", createCategory)

api/drafting.go

@@ -14,7 +14,7 @@ import (
 )
 
 func InitDraftingRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/drafting").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/drafting").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.GET("/paging", pageQueryDrafting)
 	authed.POST("", createDrafting)
 	authed.POST("/:id/saveAs", saveAsDrafting)

api/generate.go

@@ -9,10 +9,11 @@ import (
 	"joylink.club/bj-rtsts-server/ats/verify/protos/graphicData"
 	"joylink.club/bj-rtsts-server/ats/verify/simulation/wayside/memory"
 	"joylink.club/bj-rtsts-server/dto"
+	"joylink.club/bj-rtsts-server/middleware"
 )
 
 func InitGenerateGiRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/generate").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/generate").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.POST("/calculatelink", generateCalculateLinkData)
 }
 

api/project.go

@@ -13,7 +13,7 @@ import (
 )
 
 func InitProjectRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/project").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/project").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.GET("/paging", pageQueryProject)
 	authed.GET("/list", listQueryProject)
 	authed.POST("", createProject)

api/projectLink.go

@@ -8,13 +8,15 @@ import (
 	"github.com/gin-gonic/gin"
 	"go.uber.org/zap"
 	"joylink.club/bj-rtsts-server/dto"
+	"joylink.club/bj-rtsts-server/middleware"
 	"joylink.club/bj-rtsts-server/service"
 )
 
 func InitProjectLinkRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/projectLink").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/projectLink").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.GET("/info/:id", queryProjectLinkInfo)
 	authed.GET("/mapInfo/trainSize/:id", queryTrainSizeByMapId)
+	authed.GET("/project/trainSize/:id", queryTrainSizeByPId)
 	authed.POST("", saveProjectLinkInfo)
 }
 
@@ -45,6 +47,33 @@ func queryProjectLinkInfo(c *gin.Context) {
 	c.JSON(http.StatusOK, service.QueryProjectLinkInfo(int32(int64Id)))
 }
 
+// 通过项目ID查询项目的关联列车尺寸信息
+//
+//	@Summary		通过项目ID查询项目的关联列车尺寸信息
+//
+//	@Security		JwtAuth
+//
+//	@Description	通过项目ID查询项目的关联列车尺寸信息
+//	@Tags			项目关联信息Api
+//	@Accept			json
+//	@Produce		json
+//	@Param			id	path		int	true	"地图ID"
+//	@Success		200	{object}    dto.TrainSizeDto
+//	@Failure		401	{object}	dto.ErrorDto
+//	@Failure		404	{object}	dto.ErrorDto
+//	@Failure		500	{object}	dto.ErrorDto
+//	@Router			/api/v1/projectLink/project/trainSize/{id} [get]
+func queryTrainSizeByMapId(c *gin.Context) {
+	id, exist := c.Params.Get("id")
+	if !exist {
+		c.JSON(http.StatusBadRequest, "必要参数id不存在")
+		return
+	}
+	zap.S().Debug("传入参数id为" + id)
+	int64Id, _ := strconv.ParseInt(id, 10, 64)
+	c.JSON(http.StatusOK, service.QueryTrainSizeByMapId(int32(int64Id)))
+}
+
 // 通过地图ID查询项目的关联列车尺寸信息
 //
 //	@Summary		通过地图ID查询项目的关联列车尺寸信息
@@ -61,7 +90,7 @@ func queryProjectLinkInfo(c *gin.Context) {
 //	@Failure		404	{object}	dto.ErrorDto
 //	@Failure		500	{object}	dto.ErrorDto
 //	@Router			/api/v1/projectLink/mapInfo/trainSize/{id} [get]
-func queryTrainSizeByMapId(c *gin.Context) {
+func queryTrainSizeByPId(c *gin.Context) {
 	id, exist := c.Params.Get("id")
 	if !exist {
 		c.JSON(http.StatusBadRequest, "必要参数id不存在")
@@ -69,7 +98,8 @@ func queryTrainSizeByMapId(c *gin.Context) {
 	}
 	zap.S().Debug("传入参数id为" + id)
 	int64Id, _ := strconv.ParseInt(id, 10, 64)
-	c.JSON(http.StatusOK, service.QueryTrainSizeByMapId(int32(int64Id)))
+	trainSizeArr := service.QueryProjectTrainSize(int32(int64Id))
+	c.JSON(http.StatusOK, dto.ConvertFromTrainSizeDto(trainSizeArr))
 }
 
 // 保存项目的所有关联信息

api/publishedGi.go

@@ -15,7 +15,7 @@ import (
 )
 
 func InitPublishedGiRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/publishedGi").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/publishedGi").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.GET("/paging", pageQueryPublishedGi)
 	authed.GET("/list", listQueryPublishedGi)
 	authed.GET("/:id", getPublishedGiById)

api/simulation.go

@@ -15,11 +15,12 @@ import (
 	"joylink.club/bj-rtsts-server/ats/verify/simulation/wayside/memory"
 	"joylink.club/bj-rtsts-server/dto"
 	apiproto "joylink.club/bj-rtsts-server/grpcproto"
+	"joylink.club/bj-rtsts-server/middleware"
 	"joylink.club/bj-rtsts-server/service"
 )
 
 func InitSimulationRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/simulation").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/simulation").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.POST("/create", create)
 	authed.GET("/state/:id", findSimulationState)
 	authed.POST("/destroy/:id", destroy)

api/trainManage.go

@@ -9,11 +9,12 @@ import (
 	"github.com/gin-gonic/gin"
 	"go.uber.org/zap"
 	"joylink.club/bj-rtsts-server/dto"
+	"joylink.club/bj-rtsts-server/middleware"
 	"joylink.club/bj-rtsts-server/service"
 )
 
 func InitTrainManageRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
-	authed := api.Group("/v1/trainManage").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/trainManage").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.GET("/model/paging", pageQueryTrainModel)
 	authed.GET("/model/list", queryTrainModelList)
 	authed.POST("/model", createTrainModel)

api/user.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"net/http"
+
 	jwt "github.com/appleboy/gin-jwt/v2"
 	"github.com/gin-gonic/gin"
 	"go.uber.org/zap"
@@ -8,7 +10,6 @@ import (
 	"joylink.club/bj-rtsts-server/dto"
 	"joylink.club/bj-rtsts-server/middleware"
 	"joylink.club/bj-rtsts-server/service"
-	"net/http"
 )
 
 func InitUserRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
@@ -16,7 +17,7 @@ func InitUserRouter(api *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware)
 	unauthed.POST("/login", login(authMiddleware))
 	unauthed.POST("/register", register)
 
-	authed := api.Group("/v1/user").Use(authMiddleware.MiddlewareFunc())
+	authed := api.Group("/v1/user").Use(authMiddleware.MiddlewareFunc(), middleware.PermissMiddleware)
 	authed.GET("/paging", pageQueryUser)
 	authed.GET("/current", findUserInfo)
 }

db/dbquery/auth_api_path.gen.go

@@ -0,0 +1,392 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dbquery
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"joylink.club/bj-rtsts-server/db/model"
+)
+
+func newAuthAPIPath(db *gorm.DB, opts ...gen.DOOption) authAPIPath {
+	_authAPIPath := authAPIPath{}
+
+	_authAPIPath.authAPIPathDo.UseDB(db, opts...)
+	_authAPIPath.authAPIPathDo.UseModel(&model.AuthAPIPath{})
+
+	tableName := _authAPIPath.authAPIPathDo.TableName()
+	_authAPIPath.ALL = field.NewAsterisk(tableName)
+	_authAPIPath.ID = field.NewInt32(tableName, "id")
+	_authAPIPath.Name = field.NewString(tableName, "name")
+	_authAPIPath.Path = field.NewString(tableName, "path")
+	_authAPIPath.Method = field.NewString(tableName, "method")
+
+	_authAPIPath.fillFieldMap()
+
+	return _authAPIPath
+}
+
+type authAPIPath struct {
+	authAPIPathDo
+
+	ALL    field.Asterisk
+	ID     field.Int32  // 主键
+	Name   field.String // 功能名称
+	Path   field.String // 请求路径
+	Method field.String // 请求方式
+
+	fieldMap map[string]field.Expr
+}
+
+func (a authAPIPath) Table(newTableName string) *authAPIPath {
+	a.authAPIPathDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a authAPIPath) As(alias string) *authAPIPath {
+	a.authAPIPathDo.DO = *(a.authAPIPathDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *authAPIPath) updateTableName(table string) *authAPIPath {
+	a.ALL = field.NewAsterisk(table)
+	a.ID = field.NewInt32(table, "id")
+	a.Name = field.NewString(table, "name")
+	a.Path = field.NewString(table, "path")
+	a.Method = field.NewString(table, "method")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *authAPIPath) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := a.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (a *authAPIPath) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 4)
+	a.fieldMap["id"] = a.ID
+	a.fieldMap["name"] = a.Name
+	a.fieldMap["path"] = a.Path
+	a.fieldMap["method"] = a.Method
+}
+
+func (a authAPIPath) clone(db *gorm.DB) authAPIPath {
+	a.authAPIPathDo.ReplaceConnPool(db.Statement.ConnPool)
+	return a
+}
+
+func (a authAPIPath) replaceDB(db *gorm.DB) authAPIPath {
+	a.authAPIPathDo.ReplaceDB(db)
+	return a
+}
+
+type authAPIPathDo struct{ gen.DO }
+
+type IAuthAPIPathDo interface {
+	gen.SubQuery
+	Debug() IAuthAPIPathDo
+	WithContext(ctx context.Context) IAuthAPIPathDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IAuthAPIPathDo
+	WriteDB() IAuthAPIPathDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IAuthAPIPathDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IAuthAPIPathDo
+	Not(conds ...gen.Condition) IAuthAPIPathDo
+	Or(conds ...gen.Condition) IAuthAPIPathDo
+	Select(conds ...field.Expr) IAuthAPIPathDo
+	Where(conds ...gen.Condition) IAuthAPIPathDo
+	Order(conds ...field.Expr) IAuthAPIPathDo
+	Distinct(cols ...field.Expr) IAuthAPIPathDo
+	Omit(cols ...field.Expr) IAuthAPIPathDo
+	Join(table schema.Tabler, on ...field.Expr) IAuthAPIPathDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthAPIPathDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IAuthAPIPathDo
+	Group(cols ...field.Expr) IAuthAPIPathDo
+	Having(conds ...gen.Condition) IAuthAPIPathDo
+	Limit(limit int) IAuthAPIPathDo
+	Offset(offset int) IAuthAPIPathDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthAPIPathDo
+	Unscoped() IAuthAPIPathDo
+	Create(values ...*model.AuthAPIPath) error
+	CreateInBatches(values []*model.AuthAPIPath, batchSize int) error
+	Save(values ...*model.AuthAPIPath) error
+	First() (*model.AuthAPIPath, error)
+	Take() (*model.AuthAPIPath, error)
+	Last() (*model.AuthAPIPath, error)
+	Find() ([]*model.AuthAPIPath, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthAPIPath, err error)
+	FindInBatches(result *[]*model.AuthAPIPath, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.AuthAPIPath) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IAuthAPIPathDo
+	Assign(attrs ...field.AssignExpr) IAuthAPIPathDo
+	Joins(fields ...field.RelationField) IAuthAPIPathDo
+	Preload(fields ...field.RelationField) IAuthAPIPathDo
+	FirstOrInit() (*model.AuthAPIPath, error)
+	FirstOrCreate() (*model.AuthAPIPath, error)
+	FindByPage(offset int, limit int) (result []*model.AuthAPIPath, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IAuthAPIPathDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (a authAPIPathDo) Debug() IAuthAPIPathDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a authAPIPathDo) WithContext(ctx context.Context) IAuthAPIPathDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a authAPIPathDo) ReadDB() IAuthAPIPathDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a authAPIPathDo) WriteDB() IAuthAPIPathDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a authAPIPathDo) Session(config *gorm.Session) IAuthAPIPathDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a authAPIPathDo) Clauses(conds ...clause.Expression) IAuthAPIPathDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a authAPIPathDo) Returning(value interface{}, columns ...string) IAuthAPIPathDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a authAPIPathDo) Not(conds ...gen.Condition) IAuthAPIPathDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a authAPIPathDo) Or(conds ...gen.Condition) IAuthAPIPathDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a authAPIPathDo) Select(conds ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a authAPIPathDo) Where(conds ...gen.Condition) IAuthAPIPathDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a authAPIPathDo) Order(conds ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a authAPIPathDo) Distinct(cols ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a authAPIPathDo) Omit(cols ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a authAPIPathDo) Join(table schema.Tabler, on ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a authAPIPathDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a authAPIPathDo) RightJoin(table schema.Tabler, on ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a authAPIPathDo) Group(cols ...field.Expr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a authAPIPathDo) Having(conds ...gen.Condition) IAuthAPIPathDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a authAPIPathDo) Limit(limit int) IAuthAPIPathDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a authAPIPathDo) Offset(offset int) IAuthAPIPathDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a authAPIPathDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthAPIPathDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a authAPIPathDo) Unscoped() IAuthAPIPathDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a authAPIPathDo) Create(values ...*model.AuthAPIPath) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a authAPIPathDo) CreateInBatches(values []*model.AuthAPIPath, batchSize int) error {
+	return a.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (a authAPIPathDo) Save(values ...*model.AuthAPIPath) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a authAPIPathDo) First() (*model.AuthAPIPath, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthAPIPath), nil
+	}
+}
+
+func (a authAPIPathDo) Take() (*model.AuthAPIPath, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthAPIPath), nil
+	}
+}
+
+func (a authAPIPathDo) Last() (*model.AuthAPIPath, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthAPIPath), nil
+	}
+}
+
+func (a authAPIPathDo) Find() ([]*model.AuthAPIPath, error) {
+	result, err := a.DO.Find()
+	return result.([]*model.AuthAPIPath), err
+}
+
+func (a authAPIPathDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthAPIPath, err error) {
+	buf := make([]*model.AuthAPIPath, 0, batchSize)
+	err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (a authAPIPathDo) FindInBatches(result *[]*model.AuthAPIPath, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a authAPIPathDo) Attrs(attrs ...field.AssignExpr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a authAPIPathDo) Assign(attrs ...field.AssignExpr) IAuthAPIPathDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a authAPIPathDo) Joins(fields ...field.RelationField) IAuthAPIPathDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a authAPIPathDo) Preload(fields ...field.RelationField) IAuthAPIPathDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a authAPIPathDo) FirstOrInit() (*model.AuthAPIPath, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthAPIPath), nil
+	}
+}
+
+func (a authAPIPathDo) FirstOrCreate() (*model.AuthAPIPath, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthAPIPath), nil
+	}
+}
+
+func (a authAPIPathDo) FindByPage(offset int, limit int) (result []*model.AuthAPIPath, count int64, err error) {
+	result, err = a.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = a.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (a authAPIPathDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = a.Count()
+	if err != nil {
+		return
+	}
+
+	err = a.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (a authAPIPathDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a authAPIPathDo) Delete(models ...*model.AuthAPIPath) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+func (a *authAPIPathDo) withDO(do gen.Dao) *authAPIPathDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}

db/dbquery/auth_role.gen.go

@@ -0,0 +1,392 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dbquery
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"joylink.club/bj-rtsts-server/db/model"
+)
+
+func newAuthRole(db *gorm.DB, opts ...gen.DOOption) authRole {
+	_authRole := authRole{}
+
+	_authRole.authRoleDo.UseDB(db, opts...)
+	_authRole.authRoleDo.UseModel(&model.AuthRole{})
+
+	tableName := _authRole.authRoleDo.TableName()
+	_authRole.ALL = field.NewAsterisk(tableName)
+	_authRole.ID = field.NewInt32(tableName, "id")
+	_authRole.Name = field.NewString(tableName, "name")
+	_authRole.Weight = field.NewInt32(tableName, "weight")
+	_authRole.CreateTime = field.NewTime(tableName, "create_time")
+
+	_authRole.fillFieldMap()
+
+	return _authRole
+}
+
+type authRole struct {
+	authRoleDo
+
+	ALL        field.Asterisk
+	ID         field.Int32  // 主键
+	Name       field.String // 角色名字
+	Weight     field.Int32  // 角色
+	CreateTime field.Time
+
+	fieldMap map[string]field.Expr
+}
+
+func (a authRole) Table(newTableName string) *authRole {
+	a.authRoleDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a authRole) As(alias string) *authRole {
+	a.authRoleDo.DO = *(a.authRoleDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *authRole) updateTableName(table string) *authRole {
+	a.ALL = field.NewAsterisk(table)
+	a.ID = field.NewInt32(table, "id")
+	a.Name = field.NewString(table, "name")
+	a.Weight = field.NewInt32(table, "weight")
+	a.CreateTime = field.NewTime(table, "create_time")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *authRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := a.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (a *authRole) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 4)
+	a.fieldMap["id"] = a.ID
+	a.fieldMap["name"] = a.Name
+	a.fieldMap["weight"] = a.Weight
+	a.fieldMap["create_time"] = a.CreateTime
+}
+
+func (a authRole) clone(db *gorm.DB) authRole {
+	a.authRoleDo.ReplaceConnPool(db.Statement.ConnPool)
+	return a
+}
+
+func (a authRole) replaceDB(db *gorm.DB) authRole {
+	a.authRoleDo.ReplaceDB(db)
+	return a
+}
+
+type authRoleDo struct{ gen.DO }
+
+type IAuthRoleDo interface {
+	gen.SubQuery
+	Debug() IAuthRoleDo
+	WithContext(ctx context.Context) IAuthRoleDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IAuthRoleDo
+	WriteDB() IAuthRoleDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IAuthRoleDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IAuthRoleDo
+	Not(conds ...gen.Condition) IAuthRoleDo
+	Or(conds ...gen.Condition) IAuthRoleDo
+	Select(conds ...field.Expr) IAuthRoleDo
+	Where(conds ...gen.Condition) IAuthRoleDo
+	Order(conds ...field.Expr) IAuthRoleDo
+	Distinct(cols ...field.Expr) IAuthRoleDo
+	Omit(cols ...field.Expr) IAuthRoleDo
+	Join(table schema.Tabler, on ...field.Expr) IAuthRoleDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthRoleDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IAuthRoleDo
+	Group(cols ...field.Expr) IAuthRoleDo
+	Having(conds ...gen.Condition) IAuthRoleDo
+	Limit(limit int) IAuthRoleDo
+	Offset(offset int) IAuthRoleDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthRoleDo
+	Unscoped() IAuthRoleDo
+	Create(values ...*model.AuthRole) error
+	CreateInBatches(values []*model.AuthRole, batchSize int) error
+	Save(values ...*model.AuthRole) error
+	First() (*model.AuthRole, error)
+	Take() (*model.AuthRole, error)
+	Last() (*model.AuthRole, error)
+	Find() ([]*model.AuthRole, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthRole, err error)
+	FindInBatches(result *[]*model.AuthRole, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.AuthRole) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IAuthRoleDo
+	Assign(attrs ...field.AssignExpr) IAuthRoleDo
+	Joins(fields ...field.RelationField) IAuthRoleDo
+	Preload(fields ...field.RelationField) IAuthRoleDo
+	FirstOrInit() (*model.AuthRole, error)
+	FirstOrCreate() (*model.AuthRole, error)
+	FindByPage(offset int, limit int) (result []*model.AuthRole, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IAuthRoleDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (a authRoleDo) Debug() IAuthRoleDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a authRoleDo) WithContext(ctx context.Context) IAuthRoleDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a authRoleDo) ReadDB() IAuthRoleDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a authRoleDo) WriteDB() IAuthRoleDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a authRoleDo) Session(config *gorm.Session) IAuthRoleDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a authRoleDo) Clauses(conds ...clause.Expression) IAuthRoleDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a authRoleDo) Returning(value interface{}, columns ...string) IAuthRoleDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a authRoleDo) Not(conds ...gen.Condition) IAuthRoleDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a authRoleDo) Or(conds ...gen.Condition) IAuthRoleDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a authRoleDo) Select(conds ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a authRoleDo) Where(conds ...gen.Condition) IAuthRoleDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a authRoleDo) Order(conds ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a authRoleDo) Distinct(cols ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a authRoleDo) Omit(cols ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a authRoleDo) Join(table schema.Tabler, on ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a authRoleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a authRoleDo) RightJoin(table schema.Tabler, on ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a authRoleDo) Group(cols ...field.Expr) IAuthRoleDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a authRoleDo) Having(conds ...gen.Condition) IAuthRoleDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a authRoleDo) Limit(limit int) IAuthRoleDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a authRoleDo) Offset(offset int) IAuthRoleDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a authRoleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthRoleDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a authRoleDo) Unscoped() IAuthRoleDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a authRoleDo) Create(values ...*model.AuthRole) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a authRoleDo) CreateInBatches(values []*model.AuthRole, batchSize int) error {
+	return a.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (a authRoleDo) Save(values ...*model.AuthRole) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a authRoleDo) First() (*model.AuthRole, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRole), nil
+	}
+}
+
+func (a authRoleDo) Take() (*model.AuthRole, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRole), nil
+	}
+}
+
+func (a authRoleDo) Last() (*model.AuthRole, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRole), nil
+	}
+}
+
+func (a authRoleDo) Find() ([]*model.AuthRole, error) {
+	result, err := a.DO.Find()
+	return result.([]*model.AuthRole), err
+}
+
+func (a authRoleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthRole, err error) {
+	buf := make([]*model.AuthRole, 0, batchSize)
+	err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (a authRoleDo) FindInBatches(result *[]*model.AuthRole, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a authRoleDo) Attrs(attrs ...field.AssignExpr) IAuthRoleDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a authRoleDo) Assign(attrs ...field.AssignExpr) IAuthRoleDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a authRoleDo) Joins(fields ...field.RelationField) IAuthRoleDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a authRoleDo) Preload(fields ...field.RelationField) IAuthRoleDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a authRoleDo) FirstOrInit() (*model.AuthRole, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRole), nil
+	}
+}
+
+func (a authRoleDo) FirstOrCreate() (*model.AuthRole, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRole), nil
+	}
+}
+
+func (a authRoleDo) FindByPage(offset int, limit int) (result []*model.AuthRole, count int64, err error) {
+	result, err = a.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = a.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (a authRoleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = a.Count()
+	if err != nil {
+		return
+	}
+
+	err = a.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (a authRoleDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a authRoleDo) Delete(models ...*model.AuthRole) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+func (a *authRoleDo) withDO(do gen.Dao) *authRoleDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}

db/dbquery/auth_role_api_path.gen.go

@@ -0,0 +1,388 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dbquery
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"joylink.club/bj-rtsts-server/db/model"
+)
+
+func newAuthRoleAPIPath(db *gorm.DB, opts ...gen.DOOption) authRoleAPIPath {
+	_authRoleAPIPath := authRoleAPIPath{}
+
+	_authRoleAPIPath.authRoleAPIPathDo.UseDB(db, opts...)
+	_authRoleAPIPath.authRoleAPIPathDo.UseModel(&model.AuthRoleAPIPath{})
+
+	tableName := _authRoleAPIPath.authRoleAPIPathDo.TableName()
+	_authRoleAPIPath.ALL = field.NewAsterisk(tableName)
+	_authRoleAPIPath.ID = field.NewInt32(tableName, "id")
+	_authRoleAPIPath.Rid = field.NewInt32(tableName, "rid")
+	_authRoleAPIPath.Pid = field.NewInt32(tableName, "pid")
+
+	_authRoleAPIPath.fillFieldMap()
+
+	return _authRoleAPIPath
+}
+
+type authRoleAPIPath struct {
+	authRoleAPIPathDo
+
+	ALL field.Asterisk
+	ID  field.Int32 // 主键
+	Rid field.Int32 // 角色ID
+	Pid field.Int32 // 路径ID
+
+	fieldMap map[string]field.Expr
+}
+
+func (a authRoleAPIPath) Table(newTableName string) *authRoleAPIPath {
+	a.authRoleAPIPathDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a authRoleAPIPath) As(alias string) *authRoleAPIPath {
+	a.authRoleAPIPathDo.DO = *(a.authRoleAPIPathDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *authRoleAPIPath) updateTableName(table string) *authRoleAPIPath {
+	a.ALL = field.NewAsterisk(table)
+	a.ID = field.NewInt32(table, "id")
+	a.Rid = field.NewInt32(table, "rid")
+	a.Pid = field.NewInt32(table, "pid")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *authRoleAPIPath) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := a.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (a *authRoleAPIPath) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 3)
+	a.fieldMap["id"] = a.ID
+	a.fieldMap["rid"] = a.Rid
+	a.fieldMap["pid"] = a.Pid
+}
+
+func (a authRoleAPIPath) clone(db *gorm.DB) authRoleAPIPath {
+	a.authRoleAPIPathDo.ReplaceConnPool(db.Statement.ConnPool)
+	return a
+}
+
+func (a authRoleAPIPath) replaceDB(db *gorm.DB) authRoleAPIPath {
+	a.authRoleAPIPathDo.ReplaceDB(db)
+	return a
+}
+
+type authRoleAPIPathDo struct{ gen.DO }
+
+type IAuthRoleAPIPathDo interface {
+	gen.SubQuery
+	Debug() IAuthRoleAPIPathDo
+	WithContext(ctx context.Context) IAuthRoleAPIPathDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IAuthRoleAPIPathDo
+	WriteDB() IAuthRoleAPIPathDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IAuthRoleAPIPathDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IAuthRoleAPIPathDo
+	Not(conds ...gen.Condition) IAuthRoleAPIPathDo
+	Or(conds ...gen.Condition) IAuthRoleAPIPathDo
+	Select(conds ...field.Expr) IAuthRoleAPIPathDo
+	Where(conds ...gen.Condition) IAuthRoleAPIPathDo
+	Order(conds ...field.Expr) IAuthRoleAPIPathDo
+	Distinct(cols ...field.Expr) IAuthRoleAPIPathDo
+	Omit(cols ...field.Expr) IAuthRoleAPIPathDo
+	Join(table schema.Tabler, on ...field.Expr) IAuthRoleAPIPathDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthRoleAPIPathDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IAuthRoleAPIPathDo
+	Group(cols ...field.Expr) IAuthRoleAPIPathDo
+	Having(conds ...gen.Condition) IAuthRoleAPIPathDo
+	Limit(limit int) IAuthRoleAPIPathDo
+	Offset(offset int) IAuthRoleAPIPathDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthRoleAPIPathDo
+	Unscoped() IAuthRoleAPIPathDo
+	Create(values ...*model.AuthRoleAPIPath) error
+	CreateInBatches(values []*model.AuthRoleAPIPath, batchSize int) error
+	Save(values ...*model.AuthRoleAPIPath) error
+	First() (*model.AuthRoleAPIPath, error)
+	Take() (*model.AuthRoleAPIPath, error)
+	Last() (*model.AuthRoleAPIPath, error)
+	Find() ([]*model.AuthRoleAPIPath, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthRoleAPIPath, err error)
+	FindInBatches(result *[]*model.AuthRoleAPIPath, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.AuthRoleAPIPath) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IAuthRoleAPIPathDo
+	Assign(attrs ...field.AssignExpr) IAuthRoleAPIPathDo
+	Joins(fields ...field.RelationField) IAuthRoleAPIPathDo
+	Preload(fields ...field.RelationField) IAuthRoleAPIPathDo
+	FirstOrInit() (*model.AuthRoleAPIPath, error)
+	FirstOrCreate() (*model.AuthRoleAPIPath, error)
+	FindByPage(offset int, limit int) (result []*model.AuthRoleAPIPath, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IAuthRoleAPIPathDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (a authRoleAPIPathDo) Debug() IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a authRoleAPIPathDo) WithContext(ctx context.Context) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a authRoleAPIPathDo) ReadDB() IAuthRoleAPIPathDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a authRoleAPIPathDo) WriteDB() IAuthRoleAPIPathDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a authRoleAPIPathDo) Session(config *gorm.Session) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a authRoleAPIPathDo) Clauses(conds ...clause.Expression) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a authRoleAPIPathDo) Returning(value interface{}, columns ...string) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a authRoleAPIPathDo) Not(conds ...gen.Condition) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a authRoleAPIPathDo) Or(conds ...gen.Condition) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a authRoleAPIPathDo) Select(conds ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a authRoleAPIPathDo) Where(conds ...gen.Condition) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a authRoleAPIPathDo) Order(conds ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a authRoleAPIPathDo) Distinct(cols ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a authRoleAPIPathDo) Omit(cols ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a authRoleAPIPathDo) Join(table schema.Tabler, on ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a authRoleAPIPathDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a authRoleAPIPathDo) RightJoin(table schema.Tabler, on ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a authRoleAPIPathDo) Group(cols ...field.Expr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a authRoleAPIPathDo) Having(conds ...gen.Condition) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a authRoleAPIPathDo) Limit(limit int) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a authRoleAPIPathDo) Offset(offset int) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a authRoleAPIPathDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a authRoleAPIPathDo) Unscoped() IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a authRoleAPIPathDo) Create(values ...*model.AuthRoleAPIPath) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a authRoleAPIPathDo) CreateInBatches(values []*model.AuthRoleAPIPath, batchSize int) error {
+	return a.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (a authRoleAPIPathDo) Save(values ...*model.AuthRoleAPIPath) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a authRoleAPIPathDo) First() (*model.AuthRoleAPIPath, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleAPIPath), nil
+	}
+}
+
+func (a authRoleAPIPathDo) Take() (*model.AuthRoleAPIPath, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleAPIPath), nil
+	}
+}
+
+func (a authRoleAPIPathDo) Last() (*model.AuthRoleAPIPath, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleAPIPath), nil
+	}
+}
+
+func (a authRoleAPIPathDo) Find() ([]*model.AuthRoleAPIPath, error) {
+	result, err := a.DO.Find()
+	return result.([]*model.AuthRoleAPIPath), err
+}
+
+func (a authRoleAPIPathDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthRoleAPIPath, err error) {
+	buf := make([]*model.AuthRoleAPIPath, 0, batchSize)
+	err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (a authRoleAPIPathDo) FindInBatches(result *[]*model.AuthRoleAPIPath, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a authRoleAPIPathDo) Attrs(attrs ...field.AssignExpr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a authRoleAPIPathDo) Assign(attrs ...field.AssignExpr) IAuthRoleAPIPathDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a authRoleAPIPathDo) Joins(fields ...field.RelationField) IAuthRoleAPIPathDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a authRoleAPIPathDo) Preload(fields ...field.RelationField) IAuthRoleAPIPathDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a authRoleAPIPathDo) FirstOrInit() (*model.AuthRoleAPIPath, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleAPIPath), nil
+	}
+}
+
+func (a authRoleAPIPathDo) FirstOrCreate() (*model.AuthRoleAPIPath, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleAPIPath), nil
+	}
+}
+
+func (a authRoleAPIPathDo) FindByPage(offset int, limit int) (result []*model.AuthRoleAPIPath, count int64, err error) {
+	result, err = a.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = a.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (a authRoleAPIPathDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = a.Count()
+	if err != nil {
+		return
+	}
+
+	err = a.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (a authRoleAPIPathDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a authRoleAPIPathDo) Delete(models ...*model.AuthRoleAPIPath) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+func (a *authRoleAPIPathDo) withDO(do gen.Dao) *authRoleAPIPathDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}

db/dbquery/auth_role_user.gen.go

@@ -0,0 +1,388 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dbquery
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"joylink.club/bj-rtsts-server/db/model"
+)
+
+func newAuthRoleUser(db *gorm.DB, opts ...gen.DOOption) authRoleUser {
+	_authRoleUser := authRoleUser{}
+
+	_authRoleUser.authRoleUserDo.UseDB(db, opts...)
+	_authRoleUser.authRoleUserDo.UseModel(&model.AuthRoleUser{})
+
+	tableName := _authRoleUser.authRoleUserDo.TableName()
+	_authRoleUser.ALL = field.NewAsterisk(tableName)
+	_authRoleUser.ID = field.NewInt32(tableName, "id")
+	_authRoleUser.Rid = field.NewInt32(tableName, "rid")
+	_authRoleUser.UID = field.NewInt32(tableName, "uid")
+
+	_authRoleUser.fillFieldMap()
+
+	return _authRoleUser
+}
+
+type authRoleUser struct {
+	authRoleUserDo
+
+	ALL field.Asterisk
+	ID  field.Int32 // 主键
+	Rid field.Int32 // 角色ID
+	UID field.Int32 // 用户ID
+
+	fieldMap map[string]field.Expr
+}
+
+func (a authRoleUser) Table(newTableName string) *authRoleUser {
+	a.authRoleUserDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a authRoleUser) As(alias string) *authRoleUser {
+	a.authRoleUserDo.DO = *(a.authRoleUserDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *authRoleUser) updateTableName(table string) *authRoleUser {
+	a.ALL = field.NewAsterisk(table)
+	a.ID = field.NewInt32(table, "id")
+	a.Rid = field.NewInt32(table, "rid")
+	a.UID = field.NewInt32(table, "uid")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *authRoleUser) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := a.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (a *authRoleUser) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 3)
+	a.fieldMap["id"] = a.ID
+	a.fieldMap["rid"] = a.Rid
+	a.fieldMap["uid"] = a.UID
+}
+
+func (a authRoleUser) clone(db *gorm.DB) authRoleUser {
+	a.authRoleUserDo.ReplaceConnPool(db.Statement.ConnPool)
+	return a
+}
+
+func (a authRoleUser) replaceDB(db *gorm.DB) authRoleUser {
+	a.authRoleUserDo.ReplaceDB(db)
+	return a
+}
+
+type authRoleUserDo struct{ gen.DO }
+
+type IAuthRoleUserDo interface {
+	gen.SubQuery
+	Debug() IAuthRoleUserDo
+	WithContext(ctx context.Context) IAuthRoleUserDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IAuthRoleUserDo
+	WriteDB() IAuthRoleUserDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IAuthRoleUserDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IAuthRoleUserDo
+	Not(conds ...gen.Condition) IAuthRoleUserDo
+	Or(conds ...gen.Condition) IAuthRoleUserDo
+	Select(conds ...field.Expr) IAuthRoleUserDo
+	Where(conds ...gen.Condition) IAuthRoleUserDo
+	Order(conds ...field.Expr) IAuthRoleUserDo
+	Distinct(cols ...field.Expr) IAuthRoleUserDo
+	Omit(cols ...field.Expr) IAuthRoleUserDo
+	Join(table schema.Tabler, on ...field.Expr) IAuthRoleUserDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthRoleUserDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IAuthRoleUserDo
+	Group(cols ...field.Expr) IAuthRoleUserDo
+	Having(conds ...gen.Condition) IAuthRoleUserDo
+	Limit(limit int) IAuthRoleUserDo
+	Offset(offset int) IAuthRoleUserDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthRoleUserDo
+	Unscoped() IAuthRoleUserDo
+	Create(values ...*model.AuthRoleUser) error
+	CreateInBatches(values []*model.AuthRoleUser, batchSize int) error
+	Save(values ...*model.AuthRoleUser) error
+	First() (*model.AuthRoleUser, error)
+	Take() (*model.AuthRoleUser, error)
+	Last() (*model.AuthRoleUser, error)
+	Find() ([]*model.AuthRoleUser, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthRoleUser, err error)
+	FindInBatches(result *[]*model.AuthRoleUser, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.AuthRoleUser) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IAuthRoleUserDo
+	Assign(attrs ...field.AssignExpr) IAuthRoleUserDo
+	Joins(fields ...field.RelationField) IAuthRoleUserDo
+	Preload(fields ...field.RelationField) IAuthRoleUserDo
+	FirstOrInit() (*model.AuthRoleUser, error)
+	FirstOrCreate() (*model.AuthRoleUser, error)
+	FindByPage(offset int, limit int) (result []*model.AuthRoleUser, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IAuthRoleUserDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (a authRoleUserDo) Debug() IAuthRoleUserDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a authRoleUserDo) WithContext(ctx context.Context) IAuthRoleUserDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a authRoleUserDo) ReadDB() IAuthRoleUserDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a authRoleUserDo) WriteDB() IAuthRoleUserDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a authRoleUserDo) Session(config *gorm.Session) IAuthRoleUserDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a authRoleUserDo) Clauses(conds ...clause.Expression) IAuthRoleUserDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a authRoleUserDo) Returning(value interface{}, columns ...string) IAuthRoleUserDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a authRoleUserDo) Not(conds ...gen.Condition) IAuthRoleUserDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a authRoleUserDo) Or(conds ...gen.Condition) IAuthRoleUserDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a authRoleUserDo) Select(conds ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a authRoleUserDo) Where(conds ...gen.Condition) IAuthRoleUserDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a authRoleUserDo) Order(conds ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a authRoleUserDo) Distinct(cols ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a authRoleUserDo) Omit(cols ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a authRoleUserDo) Join(table schema.Tabler, on ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a authRoleUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a authRoleUserDo) RightJoin(table schema.Tabler, on ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a authRoleUserDo) Group(cols ...field.Expr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a authRoleUserDo) Having(conds ...gen.Condition) IAuthRoleUserDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a authRoleUserDo) Limit(limit int) IAuthRoleUserDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a authRoleUserDo) Offset(offset int) IAuthRoleUserDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a authRoleUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthRoleUserDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a authRoleUserDo) Unscoped() IAuthRoleUserDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a authRoleUserDo) Create(values ...*model.AuthRoleUser) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a authRoleUserDo) CreateInBatches(values []*model.AuthRoleUser, batchSize int) error {
+	return a.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (a authRoleUserDo) Save(values ...*model.AuthRoleUser) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a authRoleUserDo) First() (*model.AuthRoleUser, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleUser), nil
+	}
+}
+
+func (a authRoleUserDo) Take() (*model.AuthRoleUser, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleUser), nil
+	}
+}
+
+func (a authRoleUserDo) Last() (*model.AuthRoleUser, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleUser), nil
+	}
+}
+
+func (a authRoleUserDo) Find() ([]*model.AuthRoleUser, error) {
+	result, err := a.DO.Find()
+	return result.([]*model.AuthRoleUser), err
+}
+
+func (a authRoleUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthRoleUser, err error) {
+	buf := make([]*model.AuthRoleUser, 0, batchSize)
+	err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (a authRoleUserDo) FindInBatches(result *[]*model.AuthRoleUser, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a authRoleUserDo) Attrs(attrs ...field.AssignExpr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a authRoleUserDo) Assign(attrs ...field.AssignExpr) IAuthRoleUserDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a authRoleUserDo) Joins(fields ...field.RelationField) IAuthRoleUserDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a authRoleUserDo) Preload(fields ...field.RelationField) IAuthRoleUserDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a authRoleUserDo) FirstOrInit() (*model.AuthRoleUser, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleUser), nil
+	}
+}
+
+func (a authRoleUserDo) FirstOrCreate() (*model.AuthRoleUser, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.AuthRoleUser), nil
+	}
+}
+
+func (a authRoleUserDo) FindByPage(offset int, limit int) (result []*model.AuthRoleUser, count int64, err error) {
+	result, err = a.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = a.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (a authRoleUserDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = a.Count()
+	if err != nil {
+		return
+	}
+
+	err = a.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (a authRoleUserDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a authRoleUserDo) Delete(models ...*model.AuthRoleUser) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+func (a *authRoleUserDo) withDO(do gen.Dao) *authRoleUserDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}

db/dbquery/gen.go

@@ -17,6 +17,10 @@ import (
 
 var (
 	Q                    = new(Query)
+	AuthAPIPath          *authAPIPath
+	AuthRole             *authRole
+	AuthRoleAPIPath      *authRoleAPIPath
+	AuthRoleUser         *authRoleUser
 	Category             *category
 	Drafting             *drafting
 	Project              *project
@@ -31,6 +35,10 @@ var (
 
 func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	*Q = *Use(db, opts...)
+	AuthAPIPath = &Q.AuthAPIPath
+	AuthRole = &Q.AuthRole
+	AuthRoleAPIPath = &Q.AuthRoleAPIPath
+	AuthRoleUser = &Q.AuthRoleUser
 	Category = &Q.Category
 	Drafting = &Q.Drafting
 	Project = &Q.Project
@@ -46,6 +54,10 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 	return &Query{
 		db:                   db,
+		AuthAPIPath:          newAuthAPIPath(db, opts...),
+		AuthRole:             newAuthRole(db, opts...),
+		AuthRoleAPIPath:      newAuthRoleAPIPath(db, opts...),
+		AuthRoleUser:         newAuthRoleUser(db, opts...),
 		Category:             newCategory(db, opts...),
 		Drafting:             newDrafting(db, opts...),
 		Project:              newProject(db, opts...),
@@ -62,6 +74,10 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 type Query struct {
 	db *gorm.DB
 
+	AuthAPIPath          authAPIPath
+	AuthRole             authRole
+	AuthRoleAPIPath      authRoleAPIPath
+	AuthRoleUser         authRoleUser
 	Category             category
 	Drafting             drafting
 	Project              project
@@ -79,6 +95,10 @@ func (q *Query) Available() bool { return q.db != nil }
 func (q *Query) clone(db *gorm.DB) *Query {
 	return &Query{
 		db:                   db,
+		AuthAPIPath:          q.AuthAPIPath.clone(db),
+		AuthRole:             q.AuthRole.clone(db),
+		AuthRoleAPIPath:      q.AuthRoleAPIPath.clone(db),
+		AuthRoleUser:         q.AuthRoleUser.clone(db),
 		Category:             q.Category.clone(db),
 		Drafting:             q.Drafting.clone(db),
 		Project:              q.Project.clone(db),
@@ -103,6 +123,10 @@ func (q *Query) WriteDB() *Query {
 func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 	return &Query{
 		db:                   db,
+		AuthAPIPath:          q.AuthAPIPath.replaceDB(db),
+		AuthRole:             q.AuthRole.replaceDB(db),
+		AuthRoleAPIPath:      q.AuthRoleAPIPath.replaceDB(db),
+		AuthRoleUser:         q.AuthRoleUser.replaceDB(db),
 		Category:             q.Category.replaceDB(db),
 		Drafting:             q.Drafting.replaceDB(db),
 		Project:              q.Project.replaceDB(db),
@@ -117,6 +141,10 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 }
 
 type queryCtx struct {
+	AuthAPIPath          IAuthAPIPathDo
+	AuthRole             IAuthRoleDo
+	AuthRoleAPIPath      IAuthRoleAPIPathDo
+	AuthRoleUser         IAuthRoleUserDo
 	Category             ICategoryDo
 	Drafting             IDraftingDo
 	Project              IProjectDo
@@ -131,6 +159,10 @@ type queryCtx struct {
 
 func (q *Query) WithContext(ctx context.Context) *queryCtx {
 	return &queryCtx{
+		AuthAPIPath:          q.AuthAPIPath.WithContext(ctx),
+		AuthRole:             q.AuthRole.WithContext(ctx),
+		AuthRoleAPIPath:      q.AuthRoleAPIPath.WithContext(ctx),
+		AuthRoleUser:         q.AuthRoleUser.WithContext(ctx),
 		Category:             q.Category.WithContext(ctx),
 		Drafting:             q.Drafting.WithContext(ctx),
 		Project:              q.Project.WithContext(ctx),

db/model/auth_api_path.gen.go

@@ -0,0 +1,20 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+const TableNameAuthAPIPath = "auth_api_path"
+
+// AuthAPIPath mapped from table <auth_api_path>
+type AuthAPIPath struct {
+	ID     int32  `gorm:"column:id;primaryKey;autoIncrement:true;comment:主键" json:"id"` // 主键
+	Name   string `gorm:"column:name;comment:功能名称" json:"name"`                         // 功能名称
+	Path   string `gorm:"column:path;comment:请求路径" json:"path"`                         // 请求路径
+	Method string `gorm:"column:method;comment:请求方式" json:"method"`                     // 请求方式
+}
+
+// TableName AuthAPIPath's table name
+func (*AuthAPIPath) TableName() string {
+	return TableNameAuthAPIPath
+}

db/model/auth_role.gen.go

@@ -0,0 +1,24 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"time"
+)
+
+const TableNameAuthRole = "auth_role"
+
+// AuthRole mapped from table <auth_role>
+type AuthRole struct {
+	ID         int32     `gorm:"column:id;primaryKey;autoIncrement:true;comment:主键" json:"id"` // 主键
+	Name       string    `gorm:"column:name;comment:角色名字" json:"name"`                         // 角色名字
+	Weight     int32     `gorm:"column:weight;comment:角色" json:"weight"`                       // 角色
+	CreateTime time.Time `gorm:"column:create_time" json:"create_time"`
+}
+
+// TableName AuthRole's table name
+func (*AuthRole) TableName() string {
+	return TableNameAuthRole
+}

db/model/auth_role_api_path.gen.go

@@ -0,0 +1,19 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+const TableNameAuthRoleAPIPath = "auth_role_api_path"
+
+// AuthRoleAPIPath mapped from table <auth_role_api_path>
+type AuthRoleAPIPath struct {
+	ID  int32 `gorm:"column:id;primaryKey;autoIncrement:true;comment:主键" json:"id"` // 主键
+	Rid int32 `gorm:"column:rid;comment:角色ID" json:"rid"`                           // 角色ID
+	Pid int32 `gorm:"column:pid;comment:路径ID" json:"pid"`                           // 路径ID
+}
+
+// TableName AuthRoleAPIPath's table name
+func (*AuthRoleAPIPath) TableName() string {
+	return TableNameAuthRoleAPIPath
+}

db/model/auth_role_user.gen.go

@@ -0,0 +1,19 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+const TableNameAuthRoleUser = "auth_role_user"
+
+// AuthRoleUser mapped from table <auth_role_user>
+type AuthRoleUser struct {
+	ID  int32 `gorm:"column:id;primaryKey;autoIncrement:true;comment:主键" json:"id"` // 主键
+	Rid int32 `gorm:"column:rid;comment:角色ID" json:"rid"`                           // 角色ID
+	UID int32 `gorm:"column:uid;comment:用户ID" json:"uid"`                           // 用户ID
+}
+
+// TableName AuthRoleUser's table name
+func (*AuthRoleUser) TableName() string {
+	return TableNameAuthRoleUser
+}

docs/docs.go

@@ -378,6 +378,551 @@ const docTemplate = `{
                 }
             }
         },
+        "/api/v1/auth/path": {
+            "post": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "创建接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "创建接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "method",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "path",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/path/list": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询接口路径列表",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询接口路径列表",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/model.AuthAPIPath"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/path/paging": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "分页查询接口路径信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "分页查询接口路径信息",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "example": 1,
+                        "description": "页码",
+                        "name": "current",
+                        "in": "query",
+                        "required": true
+                    },
+                    {
+                        "type": "integer",
+                        "example": 10,
+                        "description": "页面行数",
+                        "name": "size",
+                        "in": "query",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.PageDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/path/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "接口路径ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/model.AuthAPIPath"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "修改接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "修改接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "接口路径ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    },
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "method",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "path",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "删除接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "删除接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "接口路径ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/role/list": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询角色列表",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询角色列表",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.AuthRoleRspDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/role/paging": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "分页查询角色信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "分页查询角色信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "example": 1,
+                        "description": "页码",
+                        "name": "current",
+                        "in": "query",
+                        "required": true
+                    },
+                    {
+                        "type": "integer",
+                        "example": 10,
+                        "description": "页面行数",
+                        "name": "size",
+                        "in": "query",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.PageDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/userLinkRole": {
+            "post": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "用户关联角色",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "用户关联角色",
+                "parameters": [
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "addRids",
+                        "in": "query"
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "delRids",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "uid",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/category": {
             "post": {
                 "security": [
@@ -1407,6 +1952,61 @@ const docTemplate = `{
                 }
             }
         },
+        "/api/v1/projectLink/project/trainSize/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "通过项目ID查询项目的关联列车尺寸信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "项目关联信息Api"
+                ],
+                "summary": "通过项目ID查询项目的关联列车尺寸信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "地图ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.TrainSizeDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/publishedGi/list": {
             "get": {
                 "security": [
@@ -1741,6 +2341,271 @@ const docTemplate = `{
                 }
             }
         },
+        "/api/v1/role": {
+            "post": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "创建角色",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "创建角色",
+                "parameters": [
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "addPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "delPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/role/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询角色详情",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询角色详情",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "角色ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.AuthRoleDetailRspDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "修改角色信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "修改角色信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "角色信息ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "addPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "delPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "删除角色信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "删除角色信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "角色ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/simulation/check/data": {
             "post": {
                 "security": [
@@ -3449,6 +4314,34 @@ const docTemplate = `{
                 }
             }
         },
+        "dto.AuthRoleDetailRspDto": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "integer"
+                },
+                "name": {
+                    "type": "string"
+                },
+                "paths": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/model.AuthAPIPath"
+                    }
+                }
+            }
+        },
+        "dto.AuthRoleRspDto": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "integer"
+                },
+                "name": {
+                    "type": "string"
+                }
+            }
+        },
         "dto.CheckMapDataReqDto": {
             "type": "object",
             "required": [
@@ -3724,6 +4617,27 @@ const docTemplate = `{
                 "PictureType_Psl"
             ]
         },
+        "model.AuthAPIPath": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "description": "主键",
+                    "type": "integer"
+                },
+                "method": {
+                    "description": "请求方式",
+                    "type": "string"
+                },
+                "name": {
+                    "description": "功能名称",
+                    "type": "string"
+                },
+                "path": {
+                    "description": "请求路径",
+                    "type": "string"
+                }
+            }
+        },
         "model.Category": {
             "type": "object",
             "properties": {

docs/swagger.json

@@ -371,6 +371,551 @@
                 }
             }
         },
+        "/api/v1/auth/path": {
+            "post": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "创建接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "创建接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "method",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "path",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/path/list": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询接口路径列表",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询接口路径列表",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/model.AuthAPIPath"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/path/paging": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "分页查询接口路径信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "分页查询接口路径信息",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "example": 1,
+                        "description": "页码",
+                        "name": "current",
+                        "in": "query",
+                        "required": true
+                    },
+                    {
+                        "type": "integer",
+                        "example": 10,
+                        "description": "页面行数",
+                        "name": "size",
+                        "in": "query",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.PageDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/path/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "接口路径ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/model.AuthAPIPath"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "修改接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "修改接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "接口路径ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    },
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "method",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "path",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "删除接口路径",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "删除接口路径",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "接口路径ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/role/list": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询角色列表",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询角色列表",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.AuthRoleRspDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/role/paging": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "分页查询角色信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "分页查询角色信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "example": 1,
+                        "description": "页码",
+                        "name": "current",
+                        "in": "query",
+                        "required": true
+                    },
+                    {
+                        "type": "integer",
+                        "example": 10,
+                        "description": "页面行数",
+                        "name": "size",
+                        "in": "query",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.PageDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/auth/userLinkRole": {
+            "post": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "用户关联角色",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "用户关联角色",
+                "parameters": [
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "addRids",
+                        "in": "query"
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "delRids",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "uid",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/category": {
             "post": {
                 "security": [
@@ -1400,6 +1945,61 @@
                 }
             }
         },
+        "/api/v1/projectLink/project/trainSize/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "通过项目ID查询项目的关联列车尺寸信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "项目关联信息Api"
+                ],
+                "summary": "通过项目ID查询项目的关联列车尺寸信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "地图ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.TrainSizeDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/publishedGi/list": {
             "get": {
                 "security": [
@@ -1734,6 +2334,271 @@
                 }
             }
         },
+        "/api/v1/role": {
+            "post": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "创建角色",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "创建角色",
+                "parameters": [
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "addPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "delPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/role/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "查询角色详情",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "查询角色详情",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "角色ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.AuthRoleDetailRspDto"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "修改角色信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "修改角色信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "角色信息ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "addPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "collectionFormat": "csv",
+                        "name": "delPaths",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "id",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "name",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "JwtAuth": []
+                    }
+                ],
+                "description": "删除角色信息",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "权限Api"
+                ],
+                "summary": "删除角色信息",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "角色ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "type": "boolean"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorDto"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/simulation/check/data": {
             "post": {
                 "security": [
@@ -3442,6 +4307,34 @@
                 }
             }
         },
+        "dto.AuthRoleDetailRspDto": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "integer"
+                },
+                "name": {
+                    "type": "string"
+                },
+                "paths": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/model.AuthAPIPath"
+                    }
+                }
+            }
+        },
+        "dto.AuthRoleRspDto": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "integer"
+                },
+                "name": {
+                    "type": "string"
+                }
+            }
+        },
         "dto.CheckMapDataReqDto": {
             "type": "object",
             "required": [
@@ -3717,6 +4610,27 @@
                 "PictureType_Psl"
             ]
         },
+        "model.AuthAPIPath": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "description": "主键",
+                    "type": "integer"
+                },
+                "method": {
+                    "description": "请求方式",
+                    "type": "string"
+                },
+                "name": {
+                    "description": "功能名称",
+                    "type": "string"
+                },
+                "path": {
+                    "description": "请求路径",
+                    "type": "string"
+                }
+            }
+        },
         "model.Category": {
             "type": "object",
             "properties": {

docs/swagger.yaml

@@ -36,6 +36,24 @@ definitions:
         description: 新添加的列车的索引
         type: string
     type: object
+  dto.AuthRoleDetailRspDto:
+    properties:
+      id:
+        type: integer
+      name:
+        type: string
+      paths:
+        items:
+          $ref: '#/definitions/model.AuthAPIPath'
+        type: array
+    type: object
+  dto.AuthRoleRspDto:
+    properties:
+      id:
+        type: integer
+      name:
+        type: string
+    type: object
   dto.CheckMapDataReqDto:
     properties:
       data:
@@ -222,6 +240,21 @@ definitions:
     x-enum-varnames:
     - PictureType_StationLayout
     - PictureType_Psl
+  model.AuthAPIPath:
+    properties:
+      id:
+        description: 主键
+        type: integer
+      method:
+        description: 请求方式
+        type: string
+      name:
+        description: 功能名称
+        type: string
+      path:
+        description: 请求路径
+        type: string
+    type: object
   model.Category:
     properties:
       code:
@@ -610,6 +643,353 @@ paths:
       summary: 分页查询项目信息
       tags:
       - 项目信息Api
+  /api/v1/auth/path:
+    post:
+      consumes:
+      - application/json
+      description: 创建接口路径
+      parameters:
+      - in: query
+        name: id
+        type: integer
+      - in: query
+        name: method
+        type: string
+      - in: query
+        name: name
+        type: string
+      - in: query
+        name: path
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            type: boolean
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 创建接口路径
+      tags:
+      - 权限Api
+  /api/v1/auth/path/{id}:
+    delete:
+      consumes:
+      - application/json
+      description: 删除接口路径
+      parameters:
+      - description: 接口路径ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            type: boolean
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 删除接口路径
+      tags:
+      - 权限Api
+    get:
+      consumes:
+      - application/json
+      description: 查询接口路径
+      parameters:
+      - description: 接口路径ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/model.AuthAPIPath'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 查询接口路径
+      tags:
+      - 权限Api
+    put:
+      consumes:
+      - application/json
+      description: 修改接口路径
+      parameters:
+      - description: 接口路径ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      - in: query
+        name: id
+        type: integer
+      - in: query
+        name: method
+        type: string
+      - in: query
+        name: name
+        type: string
+      - in: query
+        name: path
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            type: boolean
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 修改接口路径
+      tags:
+      - 权限Api
+  /api/v1/auth/path/list:
+    get:
+      consumes:
+      - application/json
+      description: 查询接口路径列表
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/model.AuthAPIPath'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 查询接口路径列表
+      tags:
+      - 权限Api
+  /api/v1/auth/path/paging:
+    get:
+      consumes:
+      - application/json
+      description: 分页查询接口路径信息
+      parameters:
+      - in: query
+        name: name
+        type: string
+      - description: 页码
+        example: 1
+        in: query
+        name: current
+        required: true
+        type: integer
+      - description: 页面行数
+        example: 10
+        in: query
+        name: size
+        required: true
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/dto.PageDto'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 分页查询接口路径信息
+      tags:
+      - 权限Api
+  /api/v1/auth/role/list:
+    get:
+      consumes:
+      - application/json
+      description: 查询角色列表
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/dto.AuthRoleRspDto'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 查询角色列表
+      tags:
+      - 权限Api
+  /api/v1/auth/role/paging:
+    get:
+      consumes:
+      - application/json
+      description: 分页查询角色信息
+      parameters:
+      - description: 页码
+        example: 1
+        in: query
+        name: current
+        required: true
+        type: integer
+      - description: 页面行数
+        example: 10
+        in: query
+        name: size
+        required: true
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/dto.PageDto'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 分页查询角色信息
+      tags:
+      - 权限Api
+  /api/v1/auth/userLinkRole:
+    post:
+      consumes:
+      - application/json
+      description: 用户关联角色
+      parameters:
+      - collectionFormat: csv
+        in: query
+        items:
+          type: integer
+        name: addRids
+        type: array
+      - collectionFormat: csv
+        in: query
+        items:
+          type: integer
+        name: delRids
+        type: array
+      - in: query
+        name: uid
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            type: boolean
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 用户关联角色
+      tags:
+      - 权限Api
   /api/v1/category:
     post:
       consumes:
@@ -1265,6 +1645,41 @@ paths:
       summary: 通过地图ID查询项目的关联列车尺寸信息
       tags:
       - 项目关联信息Api
+  /api/v1/projectLink/project/trainSize/{id}:
+    get:
+      consumes:
+      - application/json
+      description: 通过项目ID查询项目的关联列车尺寸信息
+      parameters:
+      - description: 地图ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/dto.TrainSizeDto'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 通过项目ID查询项目的关联列车尺寸信息
+      tags:
+      - 项目关联信息Api
   /api/v1/publishedGi/{id}:
     delete:
       consumes:
@@ -1476,6 +1891,175 @@ paths:
       summary: 从发布数据拉取信息到草稿
       tags:
       - 发布的图形数据Api
+  /api/v1/role:
+    post:
+      consumes:
+      - application/json
+      description: 创建角色
+      parameters:
+      - collectionFormat: csv
+        in: query
+        items:
+          type: integer
+        name: addPaths
+        type: array
+      - collectionFormat: csv
+        in: query
+        items:
+          type: integer
+        name: delPaths
+        type: array
+      - in: query
+        name: id
+        type: integer
+      - in: query
+        name: name
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            type: boolean
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 创建角色
+      tags:
+      - 权限Api
+  /api/v1/role/{id}:
+    delete:
+      consumes:
+      - application/json
+      description: 删除角色信息
+      parameters:
+      - description: 角色ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            type: boolean
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 删除角色信息
+      tags:
+      - 权限Api
+    get:
+      consumes:
+      - application/json
+      description: 查询角色详情
+      parameters:
+      - description: 角色ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/dto.AuthRoleDetailRspDto'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 查询角色详情
+      tags:
+      - 权限Api
+    put:
+      consumes:
+      - application/json
+      description: 修改角色信息
+      parameters:
+      - description: 角色信息ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      - collectionFormat: csv
+        in: query
+        items:
+          type: integer
+        name: addPaths
+        type: array
+      - collectionFormat: csv
+        in: query
+        items:
+          type: integer
+        name: delPaths
+        type: array
+      - in: query
+        name: id
+        type: integer
+      - in: query
+        name: name
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            type: boolean
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/dto.ErrorDto'
+      security:
+      - JwtAuth: []
+      summary: 修改角色信息
+      tags:
+      - 权限Api
   /api/v1/simulation/check/data:
     post:
       consumes:

dto/auth.go

@@ -0,0 +1,75 @@
+package dto
+
+import "joylink.club/bj-rtsts-server/db/model"
+
+// 角色创建
+type AuthRoleReqDto struct {
+	Id       int32   `json:"id" form:"id"`
+	Name     string  `json:"name" form:"name"`
+	DelPaths []int32 `json:"delPaths" form:"delPaths"`
+	AddPaths []int32 `json:"addPaths" form:"addPaths"`
+}
+
+type AuthRoleRspDto struct {
+	Id   int32  `json:"id" form:"id"`
+	Name string `json:"name" form:"name"`
+}
+
+func ConvertFromAuthRole(auths []*model.AuthRole) []*AuthRoleRspDto {
+	var result = make([]*AuthRoleRspDto, len(auths))
+	for i, a := range auths {
+		result[i] = &AuthRoleRspDto{Id: a.ID, Name: a.Name}
+	}
+	return result
+}
+
+type AuthRoleDetailRspDto struct {
+	Id    int32                `json:"id" form:"id"`
+	Name  string               `json:"name" form:"name"`
+	Paths []*model.AuthAPIPath `json:"paths" form:"paths"`
+}
+
+type AuthApiPathPageReqDto struct {
+	PageQueryDto
+	Name string `json:"name" form:"name"`
+}
+
+type AuthApiPathReqDto struct {
+	Id     int32  `json:"id" form:"id"`
+	Name   string `json:"name" form:"name"`
+	Path   string `json:"path" form:"path"`
+	Method string `json:"method" form:"method"`
+}
+
+type AuthRoleUserReqDto struct {
+	Uid     int32   `json:"uid" form:"uid"`
+	AddRids []int32 `json:"addRids" form:"addRids"`
+	DelRids []int32 `json:"delRids" form:"delRids"`
+}
+
+// 角色类型
+type AuthRoleType int32
+
+const (
+	ADMIN AuthRoleType = iota
+	USER
+)
+
+type AuthUserStorageDto struct {
+	IsAdmin   bool        `json:"isAdmin" form:"isAdmin"`
+	RoleIds   []int32     `json:"roleIds" form:"roleIds"`
+	AuthPaths []*AuthPath `json:"authPath" form:"authPath"`
+}
+
+type AuthPath struct {
+	Path   string `json:"path" form:"path"`
+	Method string `json:"method" form:"method"`
+}
+
+func ConvertFromAuthPath(paths []*model.AuthAPIPath) []*AuthPath {
+	var result = make([]*AuthPath, len(paths))
+	for i, a := range paths {
+		result[i] = &AuthPath{Path: a.Path, Method: a.Method}
+	}
+	return result
+}

main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+
 	swaggerFiles "github.com/swaggo/files"
 	ginSwagger "github.com/swaggo/gin-swagger"
 	"joylink.club/bj-rtsts-server/api"
@@ -26,7 +27,6 @@ import (
 func main() {
 	engine := InitServer()
 	authMiddleware := middleware.InitGinJwtMiddleware()
-
 	router := engine.Group("/api")
 	api.InitUserRouter(router, authMiddleware)
 	api.InitDraftingRouter(router, authMiddleware)
@@ -34,11 +34,10 @@ func main() {
 	api.InitSimulationRouter(router, authMiddleware)
 	api.InitCategoryRouter(router, authMiddleware)
 	api.InitGenerateGiRouter(router, authMiddleware)
-
 	api.InitProjectRouter(router, authMiddleware)
 	api.InitTrainManageRouter(router, authMiddleware)
 	api.InitProjectLinkRouter(router, authMiddleware)
-
+	api.InitAuthRouter(router, authMiddleware)
 	docs.SwaggerInfo.Title = "CBTC测试系统API"
 	engine.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
 

middleware/auth.go

@@ -0,0 +1,78 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"joylink.club/bj-rtsts-server/db/model"
+	"joylink.club/bj-rtsts-server/dto"
+	"joylink.club/bj-rtsts-server/service"
+)
+
+// 用户权限缓存
+var userAuthPathMap = make(map[int32]*dto.AuthUserStorageDto)
+
+var PermissMiddleware = permissionMiddleware()
+
+// 权限验证信息0
+func permissionMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		user, _ := c.Get(IdentityKey)
+		if user == nil { // 用户未登录
+			c.Next()
+		} else {
+			uid := user.(*model.User).ID
+			zap.S().Debugf("获取用户ID:%d", uid)
+			userAuth := userAuthPathMap[uid]
+			if userAuth == nil {
+				userAuthPathMap[uid] = service.QueryUserAuthApiPath(uid)
+				userAuth = userAuthPathMap[uid]
+			}
+			if userAuth.IsAdmin { // 用户是超级管理员
+				c.Next()
+			} else {
+				path, method := c.Request.URL.Path, c.Request.Method
+				zap.S().Debugf("获取请求路径：%s, 方法：%s", path, method)
+				isVaild := validateUserPath(path, method, userAuth.AuthPaths)
+				if isVaild { // 用户有权限
+					c.Next()
+				} else {
+					c.JSON(http.StatusUnauthorized, "无权限访问")
+				}
+			}
+		}
+	}
+}
+
+// 验证路径
+func validateUserPath(path, method string, paths []*dto.AuthPath) bool {
+	reqPathArr := strings.Split(path, "/")
+	for _, p := range paths {
+		if p.Method == "*" || p.Method == method {
+			authPathArr := strings.Split(p.Path, "/")
+			isValid := true
+			for i, p := range reqPathArr {
+				if p == "{id}" || p == ":id" || p == authPathArr[i] {
+					continue
+				} else if authPathArr[i] == "*" {
+					isValid = true
+					break
+				} else {
+					isValid = false
+					break
+				}
+			}
+			if isValid {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// 重新登录时移除权限
+func clearUserPermission(userId int32) {
+	delete(userAuthPathMap, userId)
+}

middleware/jwt.go

@@ -51,7 +51,8 @@ func InitGinJwtMiddleware() (authMiddleware *jwt.GinJWTMiddleware) {
 			if err != nil {
 				return nil, jwt.ErrFailedAuthentication
 			}
-
+			// 清理权限
+			clearUserPermission(user.ID)
 			return user, nil
 		},
 		// Authorizator: func(data interface{}, c *gin.Context) bool {

service/auth.go

@@ -0,0 +1,281 @@
+package service
+
+import (
+	"fmt"
+	"time"
+
+	"joylink.club/bj-rtsts-server/db/dbquery"
+	"joylink.club/bj-rtsts-server/db/model"
+	"joylink.club/bj-rtsts-server/dto"
+)
+
+// 查询权限角色信息列表
+func PageAuthRoleQuery(query *dto.PageQueryDto) (*dto.PageDto, error) {
+	d := dbquery.AuthRole
+	records, total, err := d.Debug().Select(d.ID, d.Name).Order(d.CreateTime).FindByPage(query.Offset(), query.Size)
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	return &dto.PageDto{Total: int(total), PageQueryDto: *query, Records: dto.ConvertFromAuthRole(records)}, nil
+}
+
+// 获取角色列表
+func ListAuthRoleQuery() []*dto.AuthRoleRspDto {
+	d := dbquery.AuthRole
+	records, err := d.Debug().Select(d.ID, d.Name).Order(d.CreateTime).Find()
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	return dto.ConvertFromAuthRole(records)
+}
+
+// 创建权限角色
+func CreateAuthRole(a *dto.AuthRoleReqDto) bool {
+	createTime := time.Now()
+	d := model.AuthRole{Name: a.Name, CreateTime: createTime}
+	aq := dbquery.AuthRole
+	err := aq.Save(&d)
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	n := len(a.AddPaths)
+	if n > 0 {
+		// 查询刚插入的角色
+		newAuthRole, _ := aq.Where(aq.Name.Eq(a.Name), aq.CreateTime.Eq(createTime)).First()
+		rolePaths := make([]*model.AuthRoleAPIPath, n)
+		for i, v := range a.AddPaths {
+			rolePaths[i] = &model.AuthRoleAPIPath{Rid: newAuthRole.ID, Pid: v}
+		}
+		dbquery.AuthRoleAPIPath.Save(rolePaths...)
+		return true
+	}
+	return false
+}
+
+// 查询角色详情
+func QueryAuthRole(rid int32) *dto.AuthRoleDetailRspDto {
+	// 查询用户角色信息
+	role, err := dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).First()
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	rsp := &dto.AuthRoleDetailRspDto{Id: role.ID, Name: role.Name}
+	// 查询角色与路径关联信息
+	linkPids, err2 := dbquery.AuthRoleAPIPath.Distinct(dbquery.AuthRoleAPIPath.Pid).Where(dbquery.AuthRoleAPIPath.Rid.Eq(rid)).Find()
+	if err2 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
+	}
+	pn := len(linkPids)
+	if pn > 0 {
+		pids := make([]int32, pn)
+		for i, r := range linkPids {
+			pids[i] = r.Pid
+		}
+		apiPaths, err4 := dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.In(pids...)).Find()
+		if err4 != nil {
+			panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err4.Error()})
+		}
+		rsp.Paths = apiPaths
+	}
+	return rsp
+}
+
+// 编辑角色信息
+func UpdateAuthRole(rid int32, info *dto.AuthRoleReqDto) bool {
+	// 查询用户角色信息
+	role, err := dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).First()
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	if role.Weight == int32(dto.ADMIN) {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: "超级管理员不可编辑"})
+	}
+	role.Name = info.Name
+	// 更新名称
+	dbquery.AuthRole.Updates(role)
+	// 删除关联
+	dqarap := dbquery.AuthRoleAPIPath
+	rn := len(info.DelPaths)
+	if rn > 0 {
+		dqarap.Where(dqarap.Rid.Eq(rid), dqarap.Pid.In(info.DelPaths...)).Delete()
+	}
+	// 增加关联
+	an := len(info.AddPaths)
+	if an > 0 {
+		rolePaths := make([]*model.AuthRoleAPIPath, an)
+		for i, v := range info.AddPaths {
+			rolePaths[i] = &model.AuthRoleAPIPath{Rid: rid, Pid: v}
+		}
+		dqarap.Save(rolePaths...)
+	}
+	return true
+}
+
+// 删除权限角色
+func DeleteAuthRole(rid int32) bool {
+	oldD, err1 := dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).First()
+	if err1 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
+	}
+	if oldD.Weight == int32(dto.ADMIN) {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: "超级管理员不可删除"})
+	}
+	// 如果有用户关联则不删除
+	count, err2 := dbquery.AuthRoleUser.Where(dbquery.AuthRoleUser.Rid.Eq(rid)).Count()
+	if err2 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
+	}
+	if count > 0 {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: "有用户关联该角色"})
+	}
+	// 删除用户关联关系
+	dbquery.AuthRoleUser.Where(dbquery.AuthRoleUser.Rid.Eq(rid)).Delete()
+	// 删除路径关联关系
+	dbquery.AuthRoleAPIPath.Where(dbquery.AuthRoleAPIPath.Rid.Eq(rid)).Delete()
+	// 删除角色
+	dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).Delete()
+	return true
+}
+
+// 查询接口路径信息列表
+func PageAuthApiPathQuery(query *dto.AuthApiPathPageReqDto) (*dto.PageDto, error) {
+	d := dbquery.AuthAPIPath
+	dq := d.Where()
+	if query.Name != "" {
+		dq = dq.Where(d.Name.Like(fmt.Sprintf("%%%s%%", query.Name)))
+	}
+	records, total, err := dq.Debug().FindByPage(query.Offset(), query.Size)
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	return &dto.PageDto{Total: int(total), PageQueryDto: query.PageQueryDto, Records: records}, nil
+}
+
+// 查询接口路径信息列表
+func ListAuthApiPathQuery() []*model.AuthAPIPath {
+	records, err := dbquery.AuthAPIPath.Find()
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	return records
+}
+
+// 创建接口路径信息
+func CreateAuthApiPath(ap *dto.AuthApiPathReqDto) bool {
+	d := model.AuthAPIPath{Name: ap.Name, Path: ap.Path, Method: ap.Method}
+	err := dbquery.AuthAPIPath.Save(&d)
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	return true
+}
+
+// 查询接口路径信息
+func QueryAuthApiPath(id int32) *model.AuthAPIPath {
+	data, err := dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.Eq(id)).Debug().First()
+	if err != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
+	}
+	return data
+}
+
+// 更新接口路径信息
+func UpdateAuthApiPath(id int32, a *dto.AuthApiPathReqDto) bool {
+	dbqa := dbquery.AuthAPIPath
+	oldD, err1 := dbqa.Where(dbqa.ID.Eq(id)).Debug().First()
+	if oldD == nil || err1 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
+	}
+	oldD.Name = a.Name
+	oldD.Path = a.Path
+	oldD.Method = a.Method
+	_, err2 := dbqa.Updates(oldD)
+	if err2 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
+	}
+	return true
+}
+
+// 删除接口路径信息
+func DeleteAuthApiPath(id int32) bool {
+	_, err1 := dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.Eq(id)).First()
+	if err1 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
+	}
+	// 删除角色中的路径信息
+	dbquery.AuthRoleAPIPath.Where(dbquery.AuthRoleAPIPath.Pid.Eq(id)).Delete()
+	// 删除接口路径信息
+	dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.Eq(id)).Delete()
+	return true
+}
+
+// 用户关联角色信息
+func UserLinkRole(linkInfo *dto.AuthRoleUserReqDto) bool {
+	dbar := dbquery.AuthRoleUser
+	// 删除角色关联信息
+	_, err1 := dbar.Where(dbar.UID.Eq(linkInfo.Uid), dbar.Rid.In(linkInfo.DelRids...)).Delete()
+	if err1 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
+	}
+	// 插入关联关系
+	n := len(linkInfo.AddRids)
+	if n > 0 {
+		arul := make([]*model.AuthRoleUser, n)
+		for i, l := range linkInfo.AddRids {
+			arul[i] = &model.AuthRoleUser{UID: linkInfo.Uid, Rid: l}
+		}
+		err2 := dbar.Save(arul...)
+		if err2 != nil {
+			panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
+		}
+	}
+	return true
+}
+
+// 查询用户权限信息
+func QueryUserAuthApiPath(uid int32) *dto.AuthUserStorageDto {
+	linkRids, err1 := dbquery.AuthRoleUser.Where(dbquery.AuthRoleUser.UID.Eq(uid)).Find()
+	if err1 != nil {
+		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
+	}
+	authUser := &dto.AuthUserStorageDto{IsAdmin: false}
+	rn := len(linkRids)
+	if rn > 0 {
+		rids := make([]int32, rn)
+		for i, r := range linkRids {
+			rids[i] = r.Rid
+		}
+		authUser.RoleIds = rids // 用户角色ID
+		// 查询用户角色信息
+		roles, err2 := dbquery.AuthRole.Where(dbquery.AuthRole.ID.In(rids...)).Find()
+		if err2 != nil {
+			panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
+		}
+		// 判断是否是管理员
+		for _, r := range roles {
+			authUser.IsAdmin = (authUser.IsAdmin || (r.Weight == int32(dto.ADMIN)))
+		}
+		// 非管理员时，查询角色权限路径
+		if !authUser.IsAdmin {
+			// 查询角色与路径关联信息
+			linkPids, err3 := dbquery.AuthRoleAPIPath.Distinct(dbquery.AuthRoleAPIPath.Pid).Where(dbquery.AuthRoleAPIPath.Rid.In(rids...)).Find()
+			if err3 != nil {
+				panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err3.Error()})
+			}
+			pn := len(linkPids)
+			if pn > 0 {
+				pids := make([]int32, pn)
+				for i, r := range linkPids {
+					pids[i] = r.Pid
+				}
+				apiPaths, err4 := dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.In(pids...)).Find()
+				if err4 != nil {
+					panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err4.Error()})
+				}
+				// 赋值路径数组
+				authUser.AuthPaths = dto.ConvertFromAuthPath(apiPaths)
+			}
+		}
+	}
+	return authUser
+}