【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（五）角色管理、菜单管理模块

窝来辣😁

下面是前几篇的内容：

第一篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（一）搭建项目

第二篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（二）日志输出中间件、校验token中间件、配置路由、基础工具函数。

第三篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（三）日志管理（登录日志、操作日志）、用户登录模块

第四篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（四）用户管理、部门管理模块

碎碎念：这几天变得好冷，厚衣服穿得好累😂多穿几天可能就习惯了🤣

本篇内容是角色管理、菜单管理模块，有角色菜单关联权限。废话不多说，直接看代码

角色管理

controller层：sys_role.go

package sys

import (
	"github.com/gofiber/fiber/v2"
	"github.com/mozillazg/go-pinyin"
	"go-web2/app/common/config"
	"go-web2/app/common/util"
	"go-web2/app/model/sys"
	"strings"
)

type RoleController struct{}

// 角色列表分页
func (RoleController) GetPage(c *fiber.Ctx) error {
	role := sys.SysRole{}
	role.RoleKey = c.Query("code")
	role.RoleName = c.Query("name")
	pageSize := c.QueryInt("pageSize", 10)
	pageNum := c.QueryInt("pageNum", 1)
	return c.Status(200).JSON(config.Success(role.GetPage(pageSize, pageNum)))
}

// 根据id获取角色
func (RoleController) GetById(c *fiber.Ctx) error {
	role := sys.SysRole{}
	role.Id = c.Params("id")
	role.GetById()
	return c.Status(200).JSON(config.Success(role))
}

// 生成角色代码
func (RoleController) CreateCode(c *fiber.Ctx) error {
	roleName := c.Query("roleName")
	p := pinyin.NewArgs()
	p.Style = pinyin.FirstLetter
	roleKey := util.ConvertToPinyin(roleName, p)
	return c.Status(200).JSON(config.Success(roleKey))
}

// 新增角色
func (RoleController) Insert(c *fiber.Ctx) error {
	role := sys.SysRole{}
	if err := c.BodyParser(&role); err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	role.Token = c.Get(config.TokenHeader)
	err := role.Insert()
	if err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	return c.Status(200).JSON(config.Success(nil))
}

// 修改角色
func (RoleController) Update(c *fiber.Ctx) error {
	role := sys.SysRole{}
	if err := c.BodyParser(&role); err != nil {
		//log.Error(err.Error())
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	err := role.Update()
	if err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	return c.Status(200).JSON(config.Success(nil))
}

// 修改角色状态
func (RoleController) UpdateState(c *fiber.Ctx) error {
	role := sys.SysRole{}
	if err := c.BodyParser(&role); err != nil {
		//log.Error(err.Error())
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	err := role.UpdateState()
	if err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	return c.Status(200).JSON(config.Success(nil))
}

// 删除角色
func (RoleController) Delete(c *fiber.Ctx) error {
	role := sys.SysRole{}
	if err := c.BodyParser(&role); err != nil {
		//log.Error(err.Error())
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	ids := strings.Split(role.Id, ",")
	if err := role.Delete(ids); err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	return c.Status(200).JSON(config.Success(nil))
}

// 角色下拉列表
func (RoleController) GetSelectList(c *fiber.Ctx) error {
	role := sys.SysRole{}
	return c.Status(200).JSON(config.Success(role.GetSelectList()))
}

model层：sys_role.go

package sys

import (
	"fmt"
	"github.com/google/uuid"
	"github.com/pkg/errors"
	"go-web2/app/common/config"
	"strings"
	"time"
)

// 角色管理
type SysRole struct {
	config.BaseModel
	RoleKey  string   `json:"roleKey" form:"roleKey"`          // 角色代码
	RoleName string   `json:"roleName" form:"roleName"`        // 角色名称
	IsOpen   bool     `json:"isOpen" form:"isOpen"`            // 菜单树是否展开（0折叠 1展开 ）
	State    int      `json:"state" form:"state"`              // 角色状态（1正常 2停用 3删除）
	Remark   string   `json:"remark" form:"remark"`            // 备注
	MenuIds  []string `gorm:"-" json:"menuIds" form:"menuIds"` // 菜单组
}

// 获取表名
func (SysRole) TableName() string {
	return "sys_role"
}

// 列表
func (e *SysRole) GetPage(pageSize int, pageNum int) config.PageInfo {
	var list []SysRole // 查询结果
	var total int64    // 总数
	query := config.DB.Table(e.TableName())
	if e.RoleName != "" {
		query.Where("role_name like ?", fmt.Sprintf("%%%s%%", e.RoleName))
	}
	if e.RoleKey != "" {
		query.Where("role_key like ?", fmt.Sprintf("%%%s%%", e.RoleKey))
	}
	offset := (pageNum - 1) * pageSize                                                 // 计算跳过的记录数
	query.Debug().Order("create_time desc").Offset(offset).Limit(pageSize).Find(&list) // 分页查询，根据offset和limit来查询
	query.Count(&total)
	return config.PageInfo{list, total}
}

// 详情
func (e *SysRole) GetById() {
	config.DB.Table(e.TableName()).Where("id = ?", e.Id).Find(e)
}

// 新增
func (e *SysRole) Insert() (err error) {
	// 校验角色名称和角色代码
	if checkRoleNameAndKey(e.RoleName, "", "") {
		err = errors.New("角色名称已存在！")
		return
	}
	if checkRoleNameAndKey("", e.RoleKey, "") {
		err = errors.New("角色代码已存在！")
		return
	}
	e.Id = strings.ReplaceAll(uuid.NewString(), "-", "")
	e.CreatorId = GetLoginId(e.Token)
	e.CreateTime = time.Now()
	config.DB.Table(e.TableName()).Create(e)
	// 保存菜单树
	roleMenu := SysRoleMenu{RoleId: e.Id}
	roleMenu.Insert(e.MenuIds)
	return
}

// 修改
func (e *SysRole) Update() (err error) {
	// 校验角色名称和角色代码
	if checkRoleNameAndKey(e.RoleName, "", e.Id) {
		err = errors.New("角色名称已存在！")
		return
	}
	if checkRoleNameAndKey("", e.RoleKey, e.Id) {
		err = errors.New("角色代码已存在！")
		return
	}
	config.DB.Model(&SysRole{}).Select("role_key", "role_name", "is_open", "state", "remark").Where("id = ?", e.Id).Save(e)
	// 保存菜单树
	roleMenu := SysRoleMenu{RoleId: e.Id}
	roleMenu.Insert(e.MenuIds)
	return
}

// 修改状态
func (e *SysRole) UpdateState() (err error) {
	config.DB.Model(&SysRole{}).Select("state").Where("id = ?", e.Id).Save(e)
	return
}

// 删除
func (e *SysRole) Delete(ids []string) (err error) {
	for _, id := range ids {
		e.Id = id
		e.GetById()
		// 首先查询角色是否已分配用户
		if CheckRoleExistUser(id) {
			err = errors.New(fmt.Sprintf("%s角色已分配，不允许删除", e.RoleName))
			return
		}
	}
	if err = config.DB.Table(e.TableName()).Delete(&SysRole{}, ids).Error; err != nil {
		return
	}
	// 删除角色同时删除角色菜单关联
	roleMenu := &SysRoleMenu{}
	roleMenu.Delete(ids)
	return
}

// 角色下拉列表
func (e *SysRole) GetSelectList() []SysRole {
	var list []SysRole // 查询结果
	config.DB.Table(e.TableName()).Find(&list)
	return list
}

// 校验角色名称和代码是否存在
func checkRoleNameAndKey(roleName, roleKey, id string) bool {
	var count int64
	query := config.DB.Table(SysRole{}.TableName())
	if roleName != "" {
		query.Where("role_name = ?", roleName)
	}
	if roleKey != "" {
		query.Where("role_key = ?", roleKey)
	}
	if id != "" {
		query.Where("id <> ?", id)
	}
	query.Count(&count)
	return count > 0
}

菜单管理

controller层：sys_menu.go

package sys

import (
	"github.com/gofiber/fiber/v2"
	"go-web2/app/common/config"
	"go-web2/app/model/sys"
)

type MenuController struct{}

// 菜单树列表
func (MenuController) GetList(c *fiber.Ctx) error {
	menu := sys.SysMenu{}
	menu.Name = c.Query("name")
	menu.State = c.QueryInt("state")
	return c.Status(200).JSON(config.Success(menu.GetList()))
}

// 路由列表
func (MenuController) GetRouters(c *fiber.Ctx) error {
	menu := sys.SysMenu{}
	token := c.Get(config.TokenHeader)
	menu.Id = sys.GetLoginUser(token).RoleId
	return c.Status(200).JSON(config.Success(menu.GetRouters()))
}

// 根据id获取菜单
func (MenuController) GetById(c *fiber.Ctx) error {
	menu := sys.SysMenu{}
	menu.Id = c.Params("id")
	menu.GetById()
	return c.Status(200).JSON(config.Success(menu))
}

// 获取对应角色菜单列表树
func (MenuController) RoleMenuTree(c *fiber.Ctx) error {
	menu := sys.SysMenu{}
	roleMenu := sys.SysRoleMenu{}
	roleMenu.RoleId = c.Params("roleId")
	checkedIds := roleMenu.GetMenuIdByRoleId() // 根据角色id获取当前角色选中的菜单id
	result := map[string]any{}
	result["menus"] = menu.GetList()   // 获取所有菜单
	result["checkedKeys"] = checkedIds // 当前角色选中的菜单id
	return c.Status(200).JSON(config.Success(result))
}

// 新增菜单
func (MenuController) Insert(c *fiber.Ctx) error {
	menu := sys.SysMenu{}
	if err := c.BodyParser(&menu); err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	menu.Token = c.Get(config.TokenHeader)
	err := menu.Insert()
	if err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	return c.Status(200).JSON(config.Success(nil))
}

// 修改菜单
func (MenuController) Update(c *fiber.Ctx) error {
	menu := sys.SysMenu{}
	if err := c.BodyParser(&menu); err != nil {
		//log.Error(err.Error())
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	err := menu.Update()
	if err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	return c.Status(200).JSON(config.Success(nil))
}

// 删除菜单
func (MenuController) Delete(c *fiber.Ctx) error {
	menu := sys.SysMenu{}
	menu.Id = c.Params("id")
	if err := menu.Delete(); err != nil {
		return c.Status(200).JSON(config.Error(err.Error()))
	}
	return c.Status(200).JSON(config.Success(nil))
}

model层：sys_menu.go

package sys

import (
	"fmt"
	"github.com/google/uuid"
	"github.com/pkg/errors"
	"go-web2/app/common/config"
	"strings"
	"time"
)

// 菜单管理
type SysMenu struct {
	config.BaseModel
	ParentId   string    `json:"parentId" form:"parentId"`     // 上级部门id
	Name       string    `json:"name" form:"name"`             // 菜单名称
	Sort       int       `json:"sort" form:"sort"`             // 排序
	Url        string    `json:"url" form:"url"`               // 访问路径
	Path       string    `son:"path" form:"path"`              // 组件名称
	Type       string    `json:"type" form:"type"`             // 菜单类型（M目录 C菜单 F按钮）
	State      int       `json:"state" form:"state"`           // 菜单状态（1正常 2停用 3删除）
	Perms      string    `json:"perms" form:"perms"`           // 权限标识
	Visible    bool      `json:"visible" form:"visible"`       // 显示状态（0隐藏  1显示）
	Icon       string    `json:"icon" form:"icon"`             // 菜单图标
	ActiveMenu string    `json:"activeMenu" form:"activeMenu"` // 菜单高亮
	IsFrame    bool      `json:"isFrame" form:"isFrame"`       // 是否外链（0 否 1 是）
	Remark     string    `json:"remark" form:"remark"`         // 备注
	Children   []SysMenu `gorm:"-" json:"children"`            // 子级数据
}

type Meta struct {
	Title      string `json:"title"`      // 设置该路由在侧边栏和面包屑中展示的名字
	Icon       string `json:"icon"`       // 菜单图标
	ActiveMenu string `json:"activeMenu"` // 菜单高亮
	RedDot     bool   `json:"redDot" `
}

// 前端路由
type Router struct {
	Name       string   `json:"name"`       // 菜单名称
	Path       string   `json:"path"`       // 组件名称
	Hidden     bool     `json:"hidden"`     // 是否隐藏路由，当设置 true 的时候该路由不会再侧边栏出现
	Redirect   string   `json:"redirect"`   // 重定向地址，当设置 noRedirect 的时候该路由在面包屑导航中不可被点击
	Component  string   `json:"component"`  // 组件地址
	AlwaysShow bool     `json:"alwaysShow"` // 当你一个路由下面的 children 声明的路由大于1个时，自动会变成嵌套的模式--如组件页面
	ActiveMenu string   `json:"activeMenu"` // 菜单高亮
	Meta       Meta     `json:"meta"`       // 其他元素
	Children   []Router `json:"children"`   // 子级数据
}

// 获取表名
func (SysMenu) TableName() string {
	return "sys_menu"
}

// 查询菜单列表的sql
var sql = `
		select a.id,parent_id,name,type,url,path,state,ifnull(perms,'') as perms,icon, sort,visible,active_menu,is_frame
        from sys_menu a
        left join sys_role_menu b on a.id = b.menu_id
`

// 树形菜单列表
func (e *SysMenu) GetList() interface{} {
	var list []SysMenu // 查询结果
	query := config.DB.Table(e.TableName())
	if e.Id != "" { // 角色id不为空，根据角色获取菜单
		where := sql + " where b.role_id = ?"
		args := []interface{}{e.Id}
		if e.Name != "" {
			where += " and name like ?"
			args = append(args, fmt.Sprintf("%%%s%%", e.Name))
		}
		if e.State != 0 {
			where += " and state = ?"
			args = append(args, e.State)
		}
		query.Debug().Order("parent_id,sort asc").Raw(where, args...).Find(&list)
	} else {
		if e.Name != "" {
			query.Where("name like ?", fmt.Sprintf("%%%s%%", e.Name))
		}
		if e.State != 0 {
			query.Where("state = ?", e.State)
		}
		query.Debug().Order("parent_id,sort asc").Find(&list)
	}
	return e.BuildTree(list, "ROOT")
}

// 获取路由（根据当前用户的角色id）
func (e *SysMenu) GetRouters() interface{} {
	var list []SysMenu // 查询结果
	where := ` where b.role_id = ? and type in ('M', 'C') and a.state = 1`
	where = sql + where
	config.DB.Table(e.TableName()).Debug().Order("parent_id,sort asc").Raw(where, e.Id).Find(&list)
	return buildMenus(e.BuildTree(list, "ROOT"))
}

// 详情
func (e *SysMenu) GetById() {
	config.DB.Table(e.TableName()).Where("id = ?", e.Id).Find(e)
}

// 根据角色id获取菜单权限标识
func GetPermsMenuByRoleId(roleId string) []string {
	var list []SysMenu
	sql := `
		select a.id,perms
        from sys_menu a
        left join sys_role_menu b on a.id = b.menu_id
        where b.role_id = ?
        order by parent_id,sort
	`
	config.DB.Raw(sql, roleId).Find(&list)
	var result []string
	for _, menu := range list {
		result = append(result, menu.Perms)
	}
	return result
}

// 新增
func (e *SysMenu) Insert() (err error) {
	var count int64
	// 校验角色名称和角色代码
	query := config.DB.Table(e.TableName())
	if e.ParentId == "0" {
		e.ParentId = "ROOT"
	}
	query.Where("name = ? and parent_id = ?", e.Name, e.ParentId).Count(&count)
	if count > 0 {
		err = errors.New("菜单名称已存在！")
		return
	}
	e.Id = strings.ReplaceAll(uuid.NewString(), "-", "")
	e.CreatorId = GetLoginId(e.Token)
	e.CreateTime = time.Now()
	config.DB.Table(e.TableName()).Create(e)
	return
}

// 修改
func (e *SysMenu) Update() (err error) {
	var count int64
	// 校验角色名称和角色代码
	query := config.DB.Table(e.TableName())
	if e.ParentId == "0" {
		e.ParentId = "ROOT"
	}
	if e.Id == e.ParentId {
		err = errors.New("上级菜单不能是自己！")
		return
	}
	query.Where("name = ? and parent_id = ? and id <> ?", e.Name, e.ParentId, e.Id).Count(&count)
	if count > 0 {
		err = errors.New("菜单名称已存在！")
		return
	}
	//config.DB.Model(&SysMenu{}).Select("parent_id", "name", "sort", "url", "path", "type", "state", "perms", "visible", "icon", "active_menu", "is_frame", "remark").Where("id = ?", e.Id).Save(e)
	config.DB.Model(&SysMenu{}).Omit("id", "create_time").Where("id = ?", e.Id).Save(e)
	return
}

// 删除
func (e *SysMenu) Delete() (err error) {
	// 1、校验是否存在下级
	var count int64
	query := config.DB.Table(e.TableName())
	query.Where("parent_id = ?", e.Id).Count(&count)
	if count > 0 {
		err = errors.New("存在子级菜单,不允许删除")
		return
	}
	// 2、校验是否存在用户
	if CheckMenuExistRole(e.Id) {
		err = errors.New("菜单已分配,不允许删除")
		return
	}
	if err = config.DB.Table(e.TableName()).Where("id = ?", e.Id).Delete(SysMenu{}).Error; err != nil {
		return
	}
	return
}

// 构建树结构
func (e *SysMenu) BuildTree(list []SysMenu, parentId string) []SysMenu {
	var tree []SysMenu
	for _, item := range list {
		if item.ParentId == parentId {
			children := e.BuildTree(list, item.Id)
			if len(children) > 0 {
				item.Children = children
			}
			tree = append(tree, item)
		}
	}
	return tree
}

// 构建前端所需要的路由菜单
func buildMenus(menus []SysMenu) []Router {
	routerList := []Router{}
	for _, menu := range menus {
		router := Router{Hidden: menu.Visible, Name: strings.Title(menu.Path), Path: getRouterPath(menu), Component: menu.Url}
		meta := Meta{Title: menu.Name, Icon: menu.Icon, ActiveMenu: menu.ActiveMenu}
		router.Meta = meta
		cMenus := menu.Children
		if len(cMenus) > 0 && menu.Type == "M" {
			router.AlwaysShow = true
			router.Redirect = "noRedirect"
			router.Children = buildMenus(cMenus)
		} else if menu.Type == "C" && menu.ParentId == "ROOT" {
			childrenList := []Router{}
			children := Router{Name: strings.Title(menu.Path), Path: menu.Path, Component: menu.Url}
			childMeta := Meta{Title: menu.Name, Icon: menu.Icon, ActiveMenu: menu.ActiveMenu}
			children.Meta = childMeta
			childrenList = append(childrenList, children)
			router.Children = childrenList
		}
		routerList = append(routerList, router)
	}
	return routerList
}

// 获取路由地址
func getRouterPath(menu SysMenu) string {
	routerPath := menu.Path
	if menu.Type == "M" {
		if menu.Url != config.PARENT_VIEW {
			routerPath = "/" + menu.Path
		}
	} else if menu.Type == "C" && menu.ParentId == "ROOT" {
		routerPath = "/"
	}
	return routerPath
}

角色菜单关联

model层：sys_role_menu.go

package sys

import "go-web2/app/common/config"

// 角色菜单关联
type SysRoleMenu struct {
	RoleId string `json:"roleId" form:"roleId"` // 角色ID
	MenuId string `json:"menuId" form:"menuId"` // 菜单ID
}

// 获取表名
func (SysRoleMenu) TableName() string {
	return "sys_role_menu"
}

// 新增角色和菜单关联
func (e *SysRoleMenu) Insert(menuIds []string) {
	// 先删除当前角色关联的菜单id
	config.DB.Table(e.TableName()).Where("role_id = ?", e.RoleId).Delete(SysRoleMenu{})
	// 再添加当前角色关联的菜单id
	var list []SysRoleMenu // 存放要添加的数据
	for _, menuId := range menuIds {
		item := SysRoleMenu{RoleId: e.RoleId, MenuId: menuId}
		list = append(list, item)
	}
	config.DB.Table(e.TableName()).Create(&list)
}

// 删除角色和菜单关联
func (e *SysRoleMenu) Delete(roleIds []string) {
	// DELETE FROM `sys_role_menu` WHERE role_id in ('1','2','3')
	config.DB.Table(e.TableName()).Where("role_id in (?)", roleIds).Delete(SysRoleMenu{})
}

// 根据角色id获取菜单列表id
func (e *SysRoleMenu) GetMenuIdByRoleId() []string {
	var list []SysRoleMenu
	var result []string
	query := config.DB.Table(e.TableName())
	query.Where("role_id = ?", e.RoleId)
	query.Find(&list)
	for _, menu := range list {
		result = append(result, menu.MenuId)
	}
	return result
}

// 根据菜单id校验该菜单是否已分配给角色
func CheckMenuExistRole(menuId string) bool {
	var count int64
	config.DB.Table(SysRoleMenu{}.TableName()).Where("menu_id = ?", menuId).Count(&count)
	return count > 0
}

最后

好像没啥需要特别注意的地方。

好啦，以上就是本篇文章的全部内容辣，等我更完这个项目的全部文章，我会放出完整代码的地址，到现在的话，大概还剩下一篇文章的内容了，很快这个专栏就能更完了，欢迎大家多多点赞支持下，最后可以关注我不迷路~