388 lines
9.7 KiB
Go
388 lines
9.7 KiB
Go
package service
|
|
|
|
import (
|
|
"errors"
|
|
"github.com/gin-gonic/gin"
|
|
"hospital-admin-api/api/dao"
|
|
"hospital-admin-api/api/model"
|
|
"hospital-admin-api/api/requests"
|
|
"hospital-admin-api/api/responses/roleResponse"
|
|
"hospital-admin-api/global"
|
|
"strconv"
|
|
)
|
|
|
|
type RoleService struct{}
|
|
|
|
// GetRoleMenuList 获取角色菜单
|
|
func (r *RoleService) GetRoleMenuList(roleId int64) ([]*roleResponse.GetRoleMenuList, error) {
|
|
// 获取角色菜单
|
|
AdminRoleMenuDao := dao.AdminRoleMenuDao{}
|
|
adminRoleMenu, _ := AdminRoleMenuDao.GetAdminRoleMenuListByRoleId(roleId)
|
|
if adminRoleMenu == nil {
|
|
return []*roleResponse.GetRoleMenuList{}, nil
|
|
}
|
|
|
|
// 获取全部正常菜单列表
|
|
AdminMenuDao := dao.AdminMenuDao{}
|
|
adminMenu, _ := AdminMenuDao.GetAdminMenuListNormalSortOrderNum()
|
|
if adminMenu == nil {
|
|
return []*roleResponse.GetRoleMenuList{}, nil
|
|
}
|
|
|
|
var menuIDs []int64
|
|
var menuTree []*roleResponse.GetRoleMenuList
|
|
|
|
if len(adminRoleMenu) > 0 {
|
|
for _, roleMenu := range adminRoleMenu {
|
|
menuIDs = append(menuIDs, roleMenu.MenuID)
|
|
}
|
|
|
|
if len(menuIDs) > 0 {
|
|
// 构建菜单树
|
|
menuTree = buildMenuTree(menuIDs, adminMenu)
|
|
if menuTree == nil {
|
|
return nil, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return menuTree, nil
|
|
}
|
|
|
|
// 获取角色菜单-构建菜单树
|
|
func buildMenuTree(menuIds []int64, menuData []*model.AdminMenu) []*roleResponse.GetRoleMenuList {
|
|
menuMap := make(map[int64]*roleResponse.GetRoleMenuList)
|
|
rootNodes := make([]*roleResponse.GetRoleMenuList, 0)
|
|
|
|
// 构建菜单映射
|
|
for _, menu := range menuData {
|
|
for _, v := range menuIds {
|
|
if v == menu.MenuId {
|
|
node := &roleResponse.GetRoleMenuList{
|
|
MenuId: strconv.FormatInt(menu.MenuId, 10),
|
|
MenuName: menu.MenuName,
|
|
MenuTitle: menu.MenuTitle,
|
|
ParentId: strconv.FormatInt(menu.ParentId, 10),
|
|
MenuStatus: menu.MenuStatus,
|
|
MenuType: menu.MenuType,
|
|
Permission: menu.Permission,
|
|
OrderNum: menu.OrderNum,
|
|
Icon: menu.Icon,
|
|
Path: menu.Path,
|
|
Component: menu.Component,
|
|
Children: nil,
|
|
}
|
|
|
|
menuMap[menu.MenuId] = node
|
|
}
|
|
}
|
|
}
|
|
|
|
// 构建菜单树
|
|
for _, menu := range menuData {
|
|
if menu.ParentId == 0 {
|
|
if menuMap[menu.MenuId] == nil {
|
|
continue
|
|
}
|
|
rootNodes = append(rootNodes, menuMap[menu.MenuId])
|
|
} else if parent, ok := menuMap[menu.ParentId]; ok && parent != nil {
|
|
parent.Children = append(parent.Children, menuMap[menu.MenuId])
|
|
}
|
|
}
|
|
|
|
return rootNodes
|
|
}
|
|
|
|
// PutRoleStatus 角色禁用/启用
|
|
func (r *RoleService) PutRoleStatus(roleId int64, roleStatus int) (bool, error) {
|
|
// 获取请求角色数据
|
|
AdminRoleDao := dao.AdminRoleDao{}
|
|
adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
|
|
if err != nil || adminRole == nil {
|
|
return false, errors.New("非法操作")
|
|
}
|
|
|
|
// 检测是否为超级管理员
|
|
if adminRole.IsAdmin == 1 {
|
|
return false, errors.New("请勿修改超级管理员数据")
|
|
}
|
|
|
|
// 修改角色状态
|
|
err = AdminRoleDao.EditAdminRoleStatusById(roleId, roleStatus)
|
|
if err != nil {
|
|
return false, errors.New(err.Error())
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// GetRole 角色详情
|
|
func (r *RoleService) GetRole(roleId int64) (adminRole *model.AdminRole, menuIds []int64, err error) {
|
|
// 获取请求角色数据
|
|
AdminRoleDao := dao.AdminRoleDao{}
|
|
adminRole, err = AdminRoleDao.GetAdminRoleFirstById(roleId)
|
|
if err != nil || adminRole == nil {
|
|
return nil, nil, errors.New("非法操作")
|
|
}
|
|
|
|
// 获取角色权限菜单id
|
|
AdminRoleMenuDao := dao.AdminRoleMenuDao{}
|
|
menuIds, err = AdminRoleMenuDao.GetAdminRoleMenuIdByRoleId(roleId)
|
|
if err != nil {
|
|
return nil, nil, errors.New("角色权限菜单获取失败")
|
|
}
|
|
|
|
return adminRole, menuIds, nil
|
|
}
|
|
|
|
// AddRole 新增角色
|
|
func (r *RoleService) AddRole(c *gin.Context, AddRoleRequest requests.AddRole) (bool, error) {
|
|
roleId := c.GetInt64("RoleId")
|
|
if roleId == 0 {
|
|
return false, errors.New("数据错误")
|
|
}
|
|
|
|
// 获取当前登陆用户角色数据
|
|
AdminRoleDao := dao.AdminRoleDao{}
|
|
adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
|
|
if err != nil || adminRole == nil {
|
|
return false, errors.New("非法操作")
|
|
}
|
|
|
|
if AddRoleRequest.IsAdmin == 1 && adminRole.IsAdmin == 0 {
|
|
return false, errors.New("您当前为普通用户，无法添加管理员角色")
|
|
}
|
|
|
|
AdminMenuDao := dao.AdminMenuDao{}
|
|
|
|
// 判断菜单id
|
|
for _, menuId := range AddRoleRequest.MenuIds {
|
|
// 将字符串转换为int64类型
|
|
menuId, err := strconv.ParseInt(menuId, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("菜单错误")
|
|
}
|
|
|
|
adminMenu, _ := AdminMenuDao.GetAdminMenuById(menuId)
|
|
if adminMenu == nil {
|
|
return false, errors.New("菜单错误")
|
|
}
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
// 新增角色
|
|
AdminRoleModel := &model.AdminRole{
|
|
RoleName: AddRoleRequest.RoleName,
|
|
IsAdmin: AddRoleRequest.IsAdmin,
|
|
}
|
|
|
|
adminRole, _ = AdminRoleDao.AddAdminRole(tx, AdminRoleModel)
|
|
if adminRole == nil {
|
|
tx.Rollback()
|
|
return false, errors.New("新增失败")
|
|
}
|
|
|
|
// 新增角色菜单
|
|
AdminRoleMenuDao := dao.AdminRoleMenuDao{}
|
|
for _, menuId := range AddRoleRequest.MenuIds {
|
|
// 将字符串转换为int64类型
|
|
menuId, err := strconv.ParseInt(menuId, 10, 64)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("菜单错误")
|
|
}
|
|
|
|
AdminRoleMenuModel := &model.AdminRoleMenu{
|
|
RoleID: adminRole.RoleId,
|
|
MenuID: menuId,
|
|
}
|
|
|
|
adminRoleMenu, _ := AdminRoleMenuDao.AddAdminRoleMenu(tx, AdminRoleMenuModel)
|
|
if adminRoleMenu == nil {
|
|
tx.Rollback()
|
|
return false, errors.New("新增失败")
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// PutRole 修改角色
|
|
func (r *RoleService) PutRole(c *gin.Context, requestRoleId int64, PutRoleRequest requests.PutRole) (bool, error) {
|
|
// 获取当前登陆用户数据
|
|
roleId := c.GetInt64("RoleId")
|
|
if roleId == 0 {
|
|
return false, errors.New("数据错误")
|
|
}
|
|
|
|
AdminRoleDao := dao.AdminRoleDao{}
|
|
adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
|
|
if err != nil || adminRole == nil {
|
|
return false, errors.New("非法操作")
|
|
}
|
|
|
|
if PutRoleRequest.IsAdmin == 1 && adminRole.IsAdmin == 0 {
|
|
return false, errors.New("您当前为普通用户，无法设置管理员")
|
|
}
|
|
|
|
AdminMenuDao := dao.AdminMenuDao{}
|
|
|
|
// 判断菜单id
|
|
for _, menuId := range PutRoleRequest.MenuIds {
|
|
// 将字符串转换为int64类型
|
|
menuId, err := strconv.ParseInt(menuId, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("菜单错误")
|
|
}
|
|
|
|
adminMenu, _ := AdminMenuDao.GetAdminMenuById(menuId)
|
|
if adminMenu == nil {
|
|
return false, errors.New("菜单错误")
|
|
}
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
// 修改角色
|
|
data := make(map[string]interface{})
|
|
data["role_name"] = PutRoleRequest.RoleName
|
|
data["is_admin"] = PutRoleRequest.IsAdmin
|
|
err = AdminRoleDao.EditAdminRoleById(tx, requestRoleId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("修改失败")
|
|
}
|
|
|
|
AdminRoleMenuDao := dao.AdminRoleMenuDao{}
|
|
// 删除角色菜单
|
|
err = AdminRoleMenuDao.DeleteAdminRoleMenuByRoleId(tx, requestRoleId)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("修改失败")
|
|
}
|
|
|
|
// 新增角色菜单
|
|
for _, menuId := range PutRoleRequest.MenuIds {
|
|
// 将字符串转换为int64类型
|
|
menuId, err := strconv.ParseInt(menuId, 10, 64)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("新增失败")
|
|
}
|
|
|
|
AdminRoleMenuModel := &model.AdminRoleMenu{
|
|
RoleID: requestRoleId,
|
|
MenuID: menuId,
|
|
}
|
|
|
|
adminRoleMenu, _ := AdminRoleMenuDao.AddAdminRoleMenu(tx, AdminRoleMenuModel)
|
|
if adminRoleMenu == nil {
|
|
tx.Rollback()
|
|
return false, errors.New("新增失败")
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// DeleteRole 删除角色-批量
|
|
func (r *RoleService) DeleteRole(c *gin.Context, DeleteRoleRequest requests.DeleteRole) (bool, error) {
|
|
// 获取当前登陆用户角色数据
|
|
roleId := c.GetInt64("RoleId")
|
|
if roleId == 0 {
|
|
return false, errors.New("数据错误")
|
|
}
|
|
|
|
AdminUserDao := dao.AdminUserDao{}
|
|
AdminRoleMenuDao := dao.AdminRoleMenuDao{}
|
|
|
|
AdminRoleDao := dao.AdminRoleDao{}
|
|
adminRole, err := AdminRoleDao.GetAdminRoleFirstById(roleId)
|
|
if err != nil || adminRole == nil {
|
|
return false, errors.New("非法操作")
|
|
}
|
|
|
|
if adminRole.IsAdmin == 0 {
|
|
return false, errors.New("暂无权限，请联系管理员删除")
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
for _, v := range DeleteRoleRequest.RoleIds {
|
|
// 将字符串转换为int64类型
|
|
v, err := strconv.ParseInt(v, 10, 64)
|
|
if err != nil {
|
|
return false, errors.New("菜单错误")
|
|
}
|
|
|
|
if v == adminRole.RoleId {
|
|
tx.Rollback()
|
|
return false, errors.New("非法操作，请勿删除自己所属角色")
|
|
}
|
|
|
|
// 检测角色id
|
|
adminRole, err := AdminRoleDao.GetAdminRoleFirstById(v)
|
|
if err != nil || adminRole == nil {
|
|
tx.Rollback()
|
|
return false, errors.New("无法删除不存在的角色")
|
|
}
|
|
|
|
// 获取绑定该角色的用户
|
|
maps := make(map[string]interface{})
|
|
maps["role_id"] = v
|
|
AdminUser, err := AdminUserDao.GetAdminUserList(maps)
|
|
if AdminUser != nil {
|
|
for _, user := range AdminUser {
|
|
// 修改对应用户角色id为0
|
|
data := make(map[string]interface{})
|
|
data["role_id"] = nil
|
|
err = AdminUserDao.EditAdminUserById(tx, user.UserID, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("删除失败")
|
|
}
|
|
}
|
|
}
|
|
|
|
// 删除角色关联菜单
|
|
err = AdminRoleMenuDao.DeleteAdminRoleMenuByRoleId(tx, v)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("删除失败")
|
|
}
|
|
|
|
// 删除角色
|
|
err = AdminRoleDao.DeleteAdminRoleByRoleId(tx, v)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("删除失败")
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
return true, nil
|
|
}
|