OMC/be.ems
1
0
Fork 0
Code Issues Releases 3 Activity

feat: Implement Oauth2 login log service and repository

Browse Source 
- Added Oauth2LogLoginService for managing user authorization logs.
- Implemented methods for inserting logs, cleaning logs, and exporting log data.
- Created a new file for Oauth2 login log service.

refactor: Remove unused open_api module

- Deleted the open_api.go file as it was not utilized in the project.

fix: Update error codes in SysProfileController

- Changed error codes for binding errors and user authentication errors to more descriptive values.

fix: Update cache handling in SysConfig and SysDictType services

- Modified Redis set operations to include expiration time for cached values.

refactor: Update middleware authorization checks

- Replaced PreAuthorize middleware with AuthorizeUser across multiple routes in system and tool modules for consistency.

chore: Clean up trace and ws modules

- Updated middleware authorization in trace and ws modules to use AuthorizeUser.
This commit is contained in:
TsMask
2025-04-27 11:07:34 +08:00
parent b29a36e7b5
commit 56991a0b49
72 changed files with 2334 additions and 873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/modules/system/controller/sys_profile.go
View File

@@ -104,18 +104,18 @@ func (s *SysProfileController) UpdateProfile(c *gin.Context) {
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
c.JSON(422, resp.CodeMsg(422001, errMsgs))
return
}
// 登录用户信息
loginUser, err := reqctx.LoginUser(c)
info, err := reqctx.LoginUser(c)
if err != nil {
c.JSON(401, resp.CodeMsg(401, i18n.TKey(language, err.Error())))
c.JSON(401, resp.CodeMsg(401002, err.Error()))
return
}
userId := loginUser.UserId
userName := loginUser.User.UserName
userId := info.UserId
userName := info.User.UserName
// 检查手机号码格式并判断是否唯一
if body.Phone != "" {
@@ -172,10 +172,9 @@ func (s *SysProfileController) UpdateProfile(c *gin.Context) {
rows := s.sysUserService.Update(userInfo)
if rows > 0 {
// 更新缓存用户信息
loginUser.User = userInfo
// 刷新令牌信息
token.Cache(&loginUser)
info.User = userInfo
// 更新信息
token.UserInfoUpdate(info)
c.JSON(200, resp.Ok(nil))
return
}
@@ -203,17 +202,17 @@ func (s *SysProfileController) PasswordUpdate(c *gin.Context) {
}
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
c.JSON(422, resp.CodeMsg(422001, errMsgs))
return
}
// 登录用户信息
loginUser, err := reqctx.LoginUser(c)
info, err := reqctx.LoginUser(c)
if err != nil {
c.JSON(401, resp.CodeMsg(401, i18n.TKey(language, err.Error())))
c.JSON(401, resp.CodeMsg(401002, err.Error()))
return
}
userId := loginUser.UserId
userId := info.UserId
// 查询当前登录用户信息得到密码值
userInfo := s.sysUserService.FindById(userId)
@@ -317,7 +316,7 @@ func (s *SysProfileController) PasswordForce(c *gin.Context) {
// 更新缓存用户信息
userInfo.Password = ""
// 移除令牌信息
token.Remove(reqctx.Authorization(c))
token.UserInfoRemove(reqctx.Authorization(c))
c.JSON(200, resp.Ok(nil))
return
}

6
src/modules/system/service/sys_config.go
View File

@@ -99,7 +99,7 @@ func (s SysConfig) FindValueByKey(configKey string) string {
}
// 无缓存时读取数据放入缓存中
if configValue := s.sysConfigRepository.SelectValueByKey(configKey); configValue != "" {
_ = redis.Set("", cacheKey, configValue)
_ = redis.Set("", cacheKey, configValue, 0)
return configValue
}
return ""
@@ -113,7 +113,7 @@ func (s SysConfig) CacheLoad(configKey string) {
for _, v := range sysConfigs {
key := constants.CACHE_SYS_CONFIG + ":" + v.ConfigKey
_ = redis.Del("", key)
_ = redis.Set("", key, v.ConfigValue)
_ = redis.Set("", key, v.ConfigValue, 0)
}
return
}
@@ -122,7 +122,7 @@ func (s SysConfig) CacheLoad(configKey string) {
if cacheValue != "" {
key := constants.CACHE_SYS_CONFIG + ":" + configKey
_ = redis.Del("", key)
_ = redis.Set("", key, cacheValue)
_ = redis.Set("", key, cacheValue, 0)
}
}

4
src/modules/system/service/sys_dict_type.go
View File

@@ -137,7 +137,7 @@ func (s SysDictType) FindDataByType(dictType string) []model.SysDictData {
if len(data) > 0 {
_ = redis.Del("", key)
values, _ := json.Marshal(data)
_ = redis.Set("", key, string(values))
_ = redis.Set("", key, string(values), 0)
}
}
return data
@@ -176,7 +176,7 @@ func (s SysDictType) CacheLoad(dictType string) {
key := constants.CACHE_SYS_DICT + ":" + k
_ = redis.Del("", key)
values, _ := json.Marshal(v)
_ = redis.Set("", key, string(values))
_ = redis.Set("", key, string(values), 0)
}
}

150
src/modules/system/system.go
View File

@@ -20,31 +20,31 @@ func Setup(router *gin.Engine) {
sysConfigGroup := router.Group("/system/config")
{
sysConfigGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:list"}}),
controller.NewSysConfig.List,
)
sysConfigGroup.GET("/:configId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:query"}}),
controller.NewSysConfig.Info,
)
sysConfigGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysConfig.Add,
)
sysConfigGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysConfig.Edit,
)
sysConfigGroup.DELETE("/:configId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysConfig.Remove,
)
sysConfigGroup.PUT("/refresh",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_OTHER)),
controller.NewSysConfig.Refresh,
)
@@ -57,12 +57,12 @@ func Setup(router *gin.Engine) {
controller.NewSysConfig.ConfigKey,
)
sysConfigGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysConfig.Export,
)
sysConfigGroup.PUT("/change-value",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:edit"}, "hasRoles": {"admin"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:config:edit"}, "hasRoles": {"admin"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysConfig.ConfigValue,
)
@@ -72,38 +72,38 @@ func Setup(router *gin.Engine) {
sysDeptGroup := router.Group("/system/dept")
{
sysDeptGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:list"}}),
controller.NewSysDept.List,
)
sysDeptGroup.GET("/:deptId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:query"}}),
controller.NewSysDept.Info,
)
sysDeptGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDept", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysDept.Add,
)
sysDeptGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDept", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysDept.Edit,
)
sysDeptGroup.DELETE("/:deptId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDept", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysDept.Remove,
)
sysDeptGroup.GET("/list/exclude/:deptId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:list"}}),
controller.NewSysDept.ExcludeChild,
)
sysDeptGroup.GET("/tree",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:list", "system:user:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:list", "system:user:list"}}),
controller.NewSysDept.Tree,
)
sysDeptGroup.GET("/tree/role/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:query", "system:user:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dept:query", "system:user:edit"}}),
controller.NewSysDept.TreeRole,
)
}
@@ -112,34 +112,34 @@ func Setup(router *gin.Engine) {
sysDictDataGroup := router.Group("/system/dict/data")
{
sysDictDataGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:list"}}),
controller.NewSysDictData.List,
)
sysDictDataGroup.GET("/:dataId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictData.Info,
)
sysDictDataGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysDictData.Add,
)
sysDictDataGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysDictData.Edit,
)
sysDictDataGroup.DELETE("/:dataId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysDictData.Remove,
)
sysDictDataGroup.GET("/type/:dictType",
middleware.PreAuthorize(nil),
middleware.AuthorizeUser(nil),
controller.NewSysDictData.DictType,
)
sysDictDataGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysDictData.Export,
)
@@ -149,39 +149,39 @@ func Setup(router *gin.Engine) {
sysDictTypeGroup := router.Group("/system/dict/type")
{
sysDictTypeGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:list"}}),
controller.NewSysDictType.List,
)
sysDictTypeGroup.GET("/:dictId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictType.Info,
)
sysDictTypeGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysDictType.Add,
)
sysDictTypeGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysDictType.Edit,
)
sysDictTypeGroup.DELETE("/:dictId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysDictType.Remove,
)
sysDictTypeGroup.PUT("/refresh",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_OTHER)),
controller.NewSysDictType.Refresh,
)
sysDictTypeGroup.GET("/options",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictType.Options,
)
sysDictTypeGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:dict:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysDictType.Export,
)
@@ -191,21 +191,21 @@ func Setup(router *gin.Engine) {
sysLogLoginGroup := router.Group("/system/log/login")
{
sysLogLoginGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:log:login:list"}}),
controller.NewSysLogLogin.List,
)
sysLogLoginGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:log:login:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogLogin", middleware.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogLogin.Clean,
)
sysLogLoginGroup.PUT("/unlock/:userName",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:unlock"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:log:login:unlock"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogLogin", middleware.BUSINESS_TYPE_OTHER)),
controller.NewSysLogLogin.Unlock,
)
sysLogLoginGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:log:login:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogLogin", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogLogin.Export,
)
@@ -215,16 +215,16 @@ func Setup(router *gin.Engine) {
sysLogOperateGroup := router.Group("/system/log/operate")
{
sysLogOperateGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:log:operate:list"}}),
controller.NewSysLogOperate.List,
)
sysLogOperateGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:log:operate:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogOper", middleware.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogOperate.Clean,
)
sysLogOperateGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:log:operate:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogOper", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogOperate.Export,
)
@@ -234,34 +234,34 @@ func Setup(router *gin.Engine) {
sysMenuGroup := router.Group("/system/menu")
{
sysMenuGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list"}, "hasRoles": {"admin"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:menu:list"}, "hasRoles": {"admin"}}),
controller.NewSysMenu.List,
)
sysMenuGroup.GET("/:menuId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:menu:query"}}),
controller.NewSysMenu.Info,
)
sysMenuGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:menu:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysMenu", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysMenu.Add,
)
sysMenuGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:menu:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysMenu", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysMenu.Edit,
)
sysMenuGroup.DELETE("/:menuId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:menu:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysMenu", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysMenu.Remove,
)
sysMenuGroup.GET("/tree",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list", "system:role:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:menu:list", "system:role:query"}}),
controller.NewSysMenu.Tree,
)
sysMenuGroup.GET("/tree/role/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list", "system:role:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:menu:list", "system:role:query"}}),
controller.NewSysMenu.TreeRole,
)
}
@@ -270,30 +270,30 @@ func Setup(router *gin.Engine) {
sysPostGroup := router.Group("/system/post")
{
sysPostGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:post:list"}}),
controller.NewSysPost.List,
)
sysPostGroup.GET("/:postId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:post:query"}}),
controller.NewSysPost.Info,
)
sysPostGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:post:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysPost.Add,
)
sysPostGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:post:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysPost.Edit,
)
sysPostGroup.DELETE("/:postId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:post:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysPost.Remove,
)
sysPostGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:post:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysPost.Export,
)
@@ -303,21 +303,21 @@ func Setup(router *gin.Engine) {
sysProfileGroup := router.Group("/system/user/profile")
{
sysProfileGroup.GET("",
middleware.PreAuthorize(nil),
middleware.AuthorizeUser(nil),
controller.NewSysProfile.Info,
)
sysProfileGroup.PUT("",
middleware.PreAuthorize(nil),
middleware.AuthorizeUser(nil),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysProfile", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.UpdateProfile,
)
sysProfileGroup.PUT("/password",
middleware.PreAuthorize(nil),
middleware.AuthorizeUser(nil),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysProfile", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.PasswordUpdate,
)
sysProfileGroup.PUT("/password-force",
middleware.PreAuthorize(nil),
middleware.AuthorizeUser(nil),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysProfile", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.PasswordForce,
)
@@ -327,51 +327,51 @@ func Setup(router *gin.Engine) {
sysRoleGroup := router.Group("/system/role")
{
sysRoleGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:role:list"}}),
controller.NewSysRole.List,
)
sysRoleGroup.GET("/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:role:query"}}),
controller.NewSysRole.Info,
)
sysRoleGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:role:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysRole.Add,
)
sysRoleGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:role:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.Edit,
)
sysRoleGroup.DELETE("/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:role:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysRole.Remove,
)
sysRoleGroup.PUT("/status",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:role:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.Status,
)
sysRoleGroup.PUT("/data-scope",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.DataScope,
)
sysRoleGroup.GET("/user/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:list"}}),
controller.NewSysRole.UserAuthList,
)
sysRoleGroup.PUT("/user/auth",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_GRANT)),
controller.NewSysRole.UserAuthChecked,
)
sysRoleGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysRole.Export,
)
@@ -381,50 +381,50 @@ func Setup(router *gin.Engine) {
sysUserGroup := router.Group("/system/user")
{
sysUserGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:list"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:list"}}),
controller.NewSysUser.List,
)
sysUserGroup.GET("/:userId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:query"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:query"}}),
controller.NewSysUser.Info,
)
sysUserGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:add"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:add"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysUser.Add,
)
sysUserGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Edit,
)
sysUserGroup.DELETE("/:userId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:remove"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysUser.Remove,
)
sysUserGroup.PUT("/password",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:resetPwd"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:resetPwd"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Password,
)
sysUserGroup.PUT("/status",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:edit"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Status,
)
sysUserGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:export"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysUser.Export,
)
sysUserGroup.GET("/import/template",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:import"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:import"}}),
controller.NewSysUser.Template,
)
sysUserGroup.POST("/import",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:import"}}),
middleware.AuthorizeUser(map[string][]string{"hasPerms": {"system:user:import"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_IMPORT)),
controller.NewSysUser.Import,
)