Skip to content

S
so-operation-api
Commit 0c9d92ab authored by 黄智's avatar 黄智
Browse files
Options

菜单管理模块

parent 2d7aa2c2
Hide whitespace changes
Inline Side-by-side
Showing with 623 additions and 0 deletions
src/bean/entity/dictionary.go 0 → 100644
View file @ 0c9d92ab
package entity
import "time"
type DictionaryBase struct {
Id string `json:"id" xorm:"pk autoincr" ` //id
Class int `json:"class"` //菜单分组id
Name string `json:"name" ` //字典名称
ParentId int `json:"parent_id" ` //父级id
Status int32 `json:"status" ` //状态 1-启用 2-禁用
IsDelete int32 `json:"is_delete" ` //是否删除 1-是 0-否
DictType int32 `json:"dict_type" ` //字典类型（0-用户 1-系统）
Description string `json:"description" ` //描述
CreatedBy int `json:"created_by" ` //创建者
CreatedAt time.Time `json:"created_at" xorm:"created" ` //创建时间
UpdatedBy int `json:"updated_by" ` //更新者
UpdatedAt time.Time `json:"updated_at" xorm:"updated" ` //更新时间
Sort int64 `json:"sort" ` //排序字段 降序排列
}
src/bean/entity/system_menu.go 0 → 100644
View file @ 0c9d92ab
package entity
import "time"
type SystemMenu struct {
Id int32 `json:"id" xorm:"pk autoincr" ` //id
Level int `json:"level" xorm:"level"` //菜单等级
Sort int `json:"sort" xorm:"sort"` //菜单排序
MenuName string `json:"menu_name" xorm:"menu_name"` //菜单名称
MenuType int `json:"menu_type" xorm:"menu_type"` //菜单类型（0目录1菜单2子页面）
DictGroupId string `json:"dict_group_id" xorm:"dict_group_id"` //字典分组id
State int `json:"state" xorm:"state"` //状态0禁用1启用
MenuUrl string `json:"menu_url" xorm:"menu_url"` //菜单路径
MenuLogo string `json:"menu_logo" xorm:"menu_logo"` //菜单图标
CreatedBy int `json:"created_by" ` //创建者
CreatedTime time.Time `json:"created_time" xorm:"created" ` //创建时间
UpdatedBy int `json:"updated_by" ` //更新者
UpdatedTime time.Time `json:"updated_time" xorm:"updated" ` //更新时间
IsDeleted int `json:"is_deleted" xorm:"is_deleted"` //是否删除
MenuId string `json:"menu_id" xorm:"menu_id"` //菜单id
PMenuId string `json:"p_menu_id" xorm:"p_menu_id"` //上级菜单id
Source string `json:"source"`
NewWindow int `json:"new_window"`
Remark string `json:"remark"`
}
src/bean/vo/request/system_menu.go 0 → 100644
View file @ 0c9d92ab
package request
type SystemMenuReq struct {
MenuName string `json:"menu_name" vd:"len($)>0;msg:'请输入菜单名称'"`
Level int `json:"level"`
Sort int `json:"sort"`
MenuType int `json:"menu_type"`
DictGroupId string `json:"dict_group_id"`
State int `json:"state"`
MenuUrl string `json:"menu_url"`
MenuLogo string `json:"menu_logo"`
PMenuId string `json:"p_menu_id"`
Source string `json:"source"`
NewWindow int `json:"new_window"`
Remark string `json:"remark"`
}
// 组织排序参数
type MenuSortInput struct {
Id int64 `json:"id" xorm:"pk autoincr"` //id
Sort int `json:"sort"` //排序
}
src/bean/vo/response/system_menu.go 0 → 100644
View file @ 0c9d92ab
package response
import (
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/pkg/beagle/jsontime"
)
// 系统菜单表
type SystemMenuTree struct {
Id int32 `json:"id" xorm:"pk autoincr" ` //id
Level int `json:"level" xorm:"level"` //菜单等级
Sort int `json:"sort" xorm:"sort"` //菜单排序
MenuName string `json:"menu_name" xorm:"menu_name"` //菜单名称
MenuType int `json:"menu_type" xorm:"menu_type"` //菜单类型（0目录1菜单2子页面）
DictGroupId string `json:"dict_group_id" xorm:"dict_group_id"` //字典分组id
State int `json:"state" xorm:"state"` //状态0禁用1启用
MenuUrl string `json:"menu_url" xorm:"menu_url"` //菜单路径
MenuLogo string `json:"menu_logo" xorm:"menu_logo"` //菜单图标
CreatedTime jsontime.Time `json:"created_time" xorm:"created"` //创建时间
UpdatedTime jsontime.Time `json:"updated_time" xorm:"updated"` //更新时间
CreatedBy string `json:"created_by"` //创建者
UpdatedBy string `json:"updated_by"` //更新者
MenuId string `json:"menu_id" xorm:"menu_id"` //菜单id
PMenuId string `json:"p_menu_id" xorm:"p_menu_id"` //上级菜单id
Source string `json:"source" xorm:"source"` //源
Child []SystemMenuTree `xorm:"-"`
}
// 系统菜单表
type SystemMenuTreePer struct {
Id int32 `json:"id" xorm:"pk autoincr" ` //id
Level int `json:"level" xorm:"level"` //菜单等级
Sort int `json:"sort" xorm:"sort"` //菜单排序
MenuName string `json:"menuName" xorm:"menu_name"` //菜单名称
DictGroupId string `json:"dict_group_id" xorm:"dict_group_id"` //字典分类id
MenuType int `json:"menuType" xorm:"menu_type"` //菜单类型（0目录1菜单2子页面）
Path string `json:"path" xorm:"menu_url"` //菜单路径
ParentPath string `json:"parentPath" xorm:"-"`
Icon string `json:"icon" xorm:"menu_logo"` //菜单图标
MenuId string `json:"menu_id" xorm:"menu_id"` //菜单id
PMenuId string `json:"p_menu_id" xorm:"p_menu_id"` //上级菜单id
Children []SystemMenuTreePer `json:"children" xorm:"-"`
}
src/controller/system_menu.go 0 → 100644
View file @ 0c9d92ab
package controller
import (
"errors"
vd "github.com/bytedance/go-tagexpr/validator"
"github.com/gin-gonic/gin"
"github.com/spf13/cast"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/vo/request"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/pkg/beagle/resp"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/router/middleware/header"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/service"
)
func AddSystemMenu(c *gin.Context) {
input := request.SystemMenuReq{}
if err := c.ShouldBindJSON(&input); err != nil {
SendJsonResponse(c, resp.InvalidParam.ErrorDetail(err), nil)
return
}
if input.PMenuId != "" && input.MenuType == 0 && input.DictGroupId == "" {
SendJsonResponse(c, resp.InvalidParam.ErrorDetail(errors.New("请选择分组")), nil)
return
}
if input.PMenuId != "" && input.MenuUrl == "" {
SendJsonResponse(c, resp.InvalidParam.ErrorDetail(errors.New("请填写菜单路径")), nil)
return
}
sm := service.SystemMenu{User: header.GetUser(c)}
data, err := sm.AddSystemMenu(input)
if err != nil {
SendJsonResponse(c, err, nil)
return
}
SendJsonResponse(c, resp.OK, data)
}
func DeleteMenu(c *gin.Context) {
sm := service.SystemMenu{}
if err := sm.DeleteMenu(cast.ToInt64(c.Param("id"))); err != nil {
SendJsonResponse(c, err, nil)
return
}
SendJsonResponse(c, resp.OK, nil)
}
func MenuSort(c *gin.Context) {
var input []request.MenuSortInput
if err := c.ShouldBindJSON(&input); err != nil {
SendJsonResponse(c, resp.InvalidParam.ErrorDetail(err), nil)
return
}
sm := service.SystemMenu{User: header.GetUser(c)}
if err := sm.SortMenu(input); err != nil {
SendJsonResponse(c, err, nil)
return
}
SendJsonResponse(c, resp.OK, nil)
}
// 更新菜单
func UpdateMenu(c *gin.Context) {
var input request.SystemMenuReq
if err := c.ShouldBindJSON(&input); err != nil {
SendJsonResponse(c, resp.InvalidParam.ErrorDetail(err), nil)
return
}
//参数检测
if err := vd.Validate(input); err != nil {
SendJsonResponse(c, resp.InvalidParam.ErrorDetail(err), "")
return
}
sm := service.SystemMenu{User: header.GetUser(c)}
if err := sm.UpdateMenu(cast.ToInt64(c.Param("id")), input); err != nil {
SendJsonResponse(c, err, nil)
return
}
SendJsonResponse(c, resp.OK, nil)
}
func GetMenuTree(c *gin.Context) {
sm := service.SystemMenu{}
result, err := sm.GetMenuTree()
if err != nil {
SendJsonResponse(c, err, nil)
return
}
SendJsonResponse(c, resp.OK, result)
}
func GetGroupDict(c *gin.Context) {
sm := service.SystemMenu{}
result, err := sm.GetGroupDict()
if err != nil {
SendJsonResponse(c, err, nil)
return
}
SendJsonResponse(c, resp.OK, result)
}
func GetSystemTree(c *gin.Context) {
search := c.Query("search")
sm := service.SystemMenu{User: header.GetUser(c)}
result, err := sm.GetSystemTree(search)
if err != nil {
SendJsonResponse(c, err, nil)
return
}
SendJsonResponse(c, resp.OK, result)
}
src/router/router.go
View file @ 0c9d92ab
...@@ -38,6 +38,8 @@ func Load(r *gin.Engine, middleware ...gin.HandlerFunc) { ...@@ -38,6 +38,8 @@ func Load(r *gin.Engine, middleware ...gin.HandlerFunc) {
InitOrganizationRouter(r) InitOrganizationRouter(r)
// 初始化用户相关路由 // 初始化用户相关路由
InitSystemUserRouter(r) InitSystemUserRouter(r)
// 初始化菜单相关路由(r)
InitSystemMenuRouter(r)
// 初始化指标配置路由 // 初始化指标配置路由
InitMetricConfigRouter(r) InitMetricConfigRouter(r)
// 初始化prometheus路由 // 初始化prometheus路由
......
src/router/systemmenurouter.go 0 → 100644
View file @ 0c9d92ab
package router
import (
"fmt"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/common/conf"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/controller"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/router/middleware/header"
"github.com/gin-gonic/gin"
)
func InitSystemMenuRouter(e *gin.Engine) {
base := e.Group(fmt.Sprintf("%s/menu", conf.Options.Prefix), header.SetContext)
{
base.GET("/group/dict", controller.GetGroupDict) //获取字典分组
base.POST("/add", controller.AddSystemMenu) //新增菜单
base.PUT("/:id", controller.UpdateMenu) //菜单更新
base.GET("/tree", controller.GetMenuTree) //获取菜单树形结构
base.PUT("/sort", controller.MenuSort) //菜单排序
base.DELETE("/:id", controller.DeleteMenu) //删除菜单
base.GET("/user/tree", controller.GetSystemTree) //获取当前系统用户树
}
}
src/service/system_menu.go 0 → 100644
View file @ 0c9d92ab
package service
import (
"errors"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/entity"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/vo/request"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/bean/vo/response"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/common/client"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/common/conf"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/pkg/beagle/resp"
"gitlab.wodcloud.com/smart-operation/so-operation-api/src/util"
"xorm.io/xorm"
"go.uber.org/zap"
"strings"
"time"
)
type SystemMenu struct {
User entity.SystemUserInfo
}
func (s *SystemMenu) AddSystemMenu(input request.SystemMenuReq) (interface{}, error) {
db, err := client.GetDbClient()
if err != nil {
return nil, resp.DbConnectError.ErrorDetail(err)
}
var sameLevelMenu, parentMenu entity.SystemMenu
if input.PMenuId != "" {
has, err := db.Table("system_menu").Where("p_menu_id = ? and is_deleted = 0", input.PMenuId).Limit(1, 0).OrderBy("sort desc").Get(&sameLevelMenu)
if err != nil {
conf.Logger.Error("获取同级菜单信息失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
if !has {
_, err := db.Table("system_menu").Where("menu_id = ? and is_deleted = 0", input.PMenuId).Limit(1, 0).OrderBy("sort desc").Get(&parentMenu)
if err != nil {
conf.Logger.Error("获取父级菜单信息失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
input.Level = parentMenu.Level + 1
input.Sort = 1
} else {
input.Level = sameLevelMenu.Level
input.Sort = sameLevelMenu.Sort + 1
}
} else {
//查询根目录同级别sort
_, err := db.Table("system_menu").Where("is_deleted = 0 and level = 1").Limit(1, 0).OrderBy("sort desc").Get(&sameLevelMenu)
if err != nil {
conf.Logger.Error("获取同级菜单信息失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
input.Sort = sameLevelMenu.Sort + 1
input.Level = 1
}
if input.PMenuId != "" {
switch input.MenuType {
case 0:
//目录，不允许在level为2下的目录下新建目录
var pMenu entity.SystemMenu
_, err := db.Table("system_menu").Where("menu_id = ? and menu_type = 0", input.PMenuId).Get(&pMenu)
if err != nil {
conf.Logger.Error("获取上级目录失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
if pMenu.Level >= 3 {
conf.Logger.Error("创建失败，目录最多可创建两级！", zap.Error(errors.New("创建失败，目录最多可创建两级！")))
return nil, resp.DbSelectError.ErrorDetail(errors.New("创建失败，目录最多可创建三级！"))
}
case 1:
//菜单，只允许最多能查询到一个上级菜单，如果存在两个菜单，返回异常
var pMenu, ppMenu entity.SystemMenu
_, err := db.Table("system_menu").Where("menu_id = ? and menu_type = 1", input.PMenuId).Get(&pMenu)
if err != nil {
conf.Logger.Error("获取上级菜单失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
if pMenu.PMenuId != "" {
_, err = db.Table("system_menu").Where("menu_id = ? and menu_type = 1", pMenu.PMenuId).Get(&ppMenu)
if err != nil {
conf.Logger.Error("获取上上级菜单失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
if ppMenu.MenuId != "" {
conf.Logger.Error("创建失败，菜单最多可创建两级！", zap.Error(errors.New("创建失败，菜单最多可创建两级！")))
return nil, resp.DbSelectError.ErrorDetail(errors.New("创建失败，菜单最多可创建两级！"))
}
}
case 2:
//子页面，只允许最多能查询到两个上级菜单，如果存在两个菜单，返回异常
var pMenu, ppMenu, pppMenu entity.SystemMenu
_, err := db.Table("system_menu").Where("menu_id = ? and menu_type = 2", input.PMenuId).Get(&pMenu)
if err != nil {
conf.Logger.Error("获取上级子页面失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
if pMenu.PMenuId != "" {
_, err = db.Table("system_menu").Where("menu_id = ? and menu_type = 2", pMenu.PMenuId).Get(&ppMenu)
if err != nil {
conf.Logger.Error("获取上上级子页面失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
if ppMenu.MenuId != "" {
_, err = db.Table("system_menu").Where("menu_id = ? and menu_type = 2", ppMenu.PMenuId).Get(&pppMenu)
if err != nil {
conf.Logger.Error("获取上上上级子页面失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
if pppMenu.MenuId != "" {
conf.Logger.Error("创建失败，子页面最多可创建三级！", zap.Error(errors.New("创建失败，子页面最多可创建三级！")))
return nil, resp.DbSelectError.ErrorDetail(errors.New("创建失败，子页面最多可创建三级！"))
}
}
}
}
}
ins := s.GetInputToEntityMenu(input)
_, err = db.Table("system_menu").Insert(&ins)
if err != nil {
conf.Logger.Error("Insert AddSystemMenu", zap.String("error", err.Error()))
return nil, resp.DbInsertError.ErrorDetail(err)
}
return ins.MenuId, nil
}
func (s *SystemMenu) DeleteMenu(id int64) error {
db, err := client.GetDbClient()
if err != nil {
return resp.DbConnectError.ErrorDetail(err)
}
_, err = db.Transaction(func(session *xorm.Session) (interface{}, error) {
var menu entity.SystemMenu
basehas, err := session.Table("system_menu").ID(id).Where("is_deleted = 0").Get(&menu)
if err != nil {
conf.Logger.Error("查询基础组织信息失败", zap.Error(err))
return nil, resp.DbDeleteError.ErrorDetail(err)
}
//目录 目录没有下级可删除
if menu.MenuType == 0 {
if !basehas {
return nil, resp.DbDeleteError.ErrorDetail(errors.New("该目录不存在"))
}
//验证目录是否有下级
has, err := session.Table("system_menu").Where("is_deleted = 0 and p_menu_id = ?", menu.MenuId).Exist(&entity.SystemMenu{})
if err != nil {
conf.Logger.Error("验证目录是否有下级查询基础菜单信息失败", zap.Error(err))
return nil, resp.DbDeleteError.ErrorDetail(err)
}
if has {
return nil, resp.DbDeleteError.ErrorDetail(errors.New("该目录下有数据，不可删除！"))
}
}
//删除
_, err = session.Table("system_menu").Cols("is_deleted, updated_time, updated_by").ID(id).Update(&entity.SystemMenu{IsDeleted: 1, UpdatedBy: s.User.Id})
return nil, err
})
return err
}
// 菜单排序
func (s *SystemMenu) SortMenu(input []request.MenuSortInput) error {
db, err := client.GetDbClient()
if err != nil {
return resp.DbConnectError.ErrorDetail(err)
}
_, err = db.Transaction(func(x *xorm.Session) (interface{}, error) {
for _, v := range input {
_, err := x.Table("system_menu").Cols("sort, updated_time, updated_by").Where("id = ? and is_deleted = 0", v.Id).Update(
&entity.SystemMenu{
Sort: v.Sort,
UpdatedBy: s.User.Id,
})
if err != nil {
conf.Logger.Error("排序失败", zap.Error(err))
return nil, resp.DbUpdateError.ErrorDetail(err)
}
}
return nil, nil
})
return err
}
// 更新菜单
func (s *SystemMenu) UpdateMenu(id int64, input request.SystemMenuReq) error {
db, err := client.GetDbClient()
if err != nil {
return resp.DbConnectError.ErrorDetail(err)
}
var menu entity.SystemMenu
has, err := db.Table("system_menu").ID(id).Where("is_deleted = 0").Get(&menu)
if err != nil {
conf.Logger.Error("获取菜单信息失败", zap.Error(err))
return resp.DbSelectError.ErrorDetail(err)
}
if input.PMenuId != "" {
switch input.MenuType {
case 0:
//目录，不允许在level为2下的目录下新建目录
var pMenu entity.SystemMenu
_, err := db.Table("system_menu").Where("menu_id = ? and menu_type = 0", input.PMenuId).Get(&pMenu)
if err != nil {
conf.Logger.Error("获取上级目录失败", zap.Error(err))
return resp.DbSelectError.ErrorDetail(err)
}
if pMenu.Level >= 3 {
conf.Logger.Error("创建失败，目录最多可创建两级！", zap.Error(errors.New("创建失败，目录最多可创建两级！")))
return resp.DbSelectError.ErrorDetail(errors.New("创建失败，目录最多可创建两级！"))
}
case 1:
//菜单，只允许最多能查询到一个上级菜单，如果存在两个菜单，返回异常
var pMenu, ppMenu entity.SystemMenu
_, err := db.Table("system_menu").Where("menu_id = ? and menu_type = 1", input.PMenuId).Get(&pMenu)
if err != nil {
conf.Logger.Error("获取上级菜单失败", zap.Error(err))
return resp.DbSelectError.ErrorDetail(err)
}
if pMenu.PMenuId != "" {
_, err = db.Table("system_menu").Where("menu_id = ? and menu_type = 1", pMenu.PMenuId).Get(&ppMenu)
if err != nil {
conf.Logger.Error("获取上上级菜单失败", zap.Error(err))
return resp.DbSelectError.ErrorDetail(err)
}
if ppMenu.MenuId != "" {
conf.Logger.Error("创建失败，菜单最多可创建两级！", zap.Error(errors.New("创建失败，菜单最多可创建两级！")))
return resp.DbSelectError.ErrorDetail(errors.New("创建失败，菜单最多可创建两级！"))
}
}
}
}
if !has {
return resp.DbSelectError.ErrorDetail(errors.New("该菜单不存在"))
}
if _, err := db.Table("system_menu").Cols("menu_name, dict_group_id, state, menu_url, menu_logo, updated_by, updated_time", "source", "new_window", "remark").
Where("id = ?", id).Update(&entity.SystemMenu{
MenuName: input.MenuName,
DictGroupId: input.DictGroupId,
State: input.State,
MenuUrl: input.MenuUrl,
MenuLogo: input.MenuLogo,
UpdatedBy: s.User.Id,
UpdatedTime: time.Now(),
Source: input.Source,
NewWindow: input.NewWindow,
Remark: input.Remark,
}); err != nil {
conf.Logger.Error("更新菜单失败", zap.Error(err))
return resp.DbUpdateError.ErrorDetail(err)
}
return nil
}
// 查询菜单树
func (s *SystemMenu) GetMenuTree() (interface{}, error) {
db, err := client.GetDbClient()
if err != nil {
return nil, resp.DbConnectError.ErrorDetail(err)
}
var menus []response.SystemMenuTree
if err := db.Table("system_menu").Where("is_deleted = 0").OrderBy("level").OrderBy("sort").Find(&menus); err != nil {
conf.Logger.Error("查询菜单树失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
var result []response.SystemMenuTree
// 组装树形
for i, v := range menus {
if v.Level == 1 {
changeMenuTree(&menus[i], menus)
result = append(result, menus[i])
}
}
return result, nil
}
// 获取字典菜单分组
func (s *SystemMenu) GetGroupDict() (interface{}, error) {
db, err := client.GetDbClient()
if err != nil {
return nil, resp.DbConnectError.ErrorDetail(err)
}
dict := make([]entity.DictionaryBase, 0)
err = db.Table("dict").Where("is_delete = 0 and status = 1").And("class = 4").Find(&dict)
if err != nil {
conf.Logger.Error("查询字典失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
return dict, nil
}
// 查询系统用户菜单树
func (s *SystemMenu) GetSystemTree(search string) (interface{}, error) {
db, err := client.GetDbClient()
if err != nil {
return nil, resp.DbConnectError.ErrorDetail(err)
}
var menus []response.SystemMenuTreePer
if err := db.Table("system_user_role").Alias("sur").
Join("INNER", []string{"system_role_menu", "srm"}, "sur.role_id = srm.role_id").
Join("INNER", []string{"system_menu", "sm"}, "sm.menu_id = srm.menu_id").
Join("INNER", []string{"system_role", "sr"}, "sur.role_id = sr.role_id").
Select("max(sur.system_id::varchar) as system_id,sm.*").
Where("sm.is_deleted = 0 and sm.state = 1 and sur.role_id = ?", s.User.Id).
And("sr.state = 1 and sr.is_deleted = 0").
GroupBy("sm.id").
OrderBy("sm.level").OrderBy("sm.sort").Find(&menus); err != nil {
conf.Logger.Error("查询菜单树失败", zap.Error(err))
return nil, resp.DbSelectError.ErrorDetail(err)
}
var result []response.SystemMenuTreePer
// 组装树形
for i, v := range menus {
if v.Level == 1 {
if !strings.Contains(v.MenuName, search) {
continue
}
changeMenuTreePer(&menus[i], menus, search)
result = append(result, menus[i])
}
}
return result, nil
}
func (s *SystemMenu) GetInputToEntityMenu(input request.SystemMenuReq) (res entity.SystemMenu) {
//重置二级以下的菜单以及子页面
if input.Level > 2 && input.MenuType != 0 {
input.DictGroupId = ""
}
res = entity.SystemMenu{
Level: input.Level,
Sort: input.Sort,
MenuName: input.MenuName,
MenuType: input.MenuType,
DictGroupId: input.DictGroupId,
State: input.State,
MenuUrl: input.MenuUrl,
MenuLogo: input.MenuLogo,
CreatedBy: s.User.Id,
CreatedTime: time.Now(),
IsDeleted: 0,
MenuId: util.GetUUID(),
PMenuId: input.PMenuId,
Source: input.Source,
NewWindow: input.NewWindow,
Remark: input.Remark,
}
return res
}
func changeMenuTree(parent *response.SystemMenuTree, all []response.SystemMenuTree) {
for i, v := range all {
if v.PMenuId == parent.MenuId {
//二级以下分组继承
if v.Level > 2 {
all[i].DictGroupId = parent.DictGroupId
}
changeMenuTree(&all[i], all)
parent.Child = append(parent.Child, all[i])
}
}
}
func changeMenuTreePer(parent *response.SystemMenuTreePer, all []response.SystemMenuTreePer, search string) {
for i, v := range all {
if v.PMenuId == parent.MenuId {
//二级以下分组继承
if v.Level > 2 {
all[i].DictGroupId = parent.DictGroupId
}
all[i].ParentPath = parent.Path
changeMenuTreePer(&all[i], all, search)
parent.Children = append(parent.Children, all[i])
}
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment