hospital-admin-api/api/service/role.go

package service

import (
	"errors"
	"github.com/gin-gonic/gin"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/dto"
	"hospital-admin-api/api/model"
	"hospital-admin-api/api/requests"
	"hospital-admin-api/global"
	"strconv"
)

type RoleService struct{}

// GetRoleMenuList 获取角色菜单
func (r *RoleService) GetRoleMenuList(roleId int64, isAdmin bool) ([]*dto.AdminRoleMenuDto, error) {
	// 获取角色菜单
	adminRoleMenuDao := dao.AdminRoleMenuDao{}
	adminMenuDao := dao.AdminMenuDao{}
	var menuIDs []int64
	var err error

	if isAdmin {
		// 超级管理员
		menuIDs, err = adminMenuDao.GetAdminMenuId()
		if err != nil {
			return nil, nil
		}
	} else {
		// 普通用户
		menuIDs, err = adminRoleMenuDao.GetAdminRoleMenuIdByRoleId(roleId)
		if err != nil {
			return nil, nil
		}
	}

	// 获取全部正常非按钮菜单列表
	adminMenu, _ := adminMenuDao.GetAdminMenuListNonButtonNormalSortOrderNum()
	if adminMenu == nil {
		return nil, nil
	}

	var getRoleMenuListResponse []*dto.AdminRoleMenuDto

	if len(menuIDs) > 0 {
		// 构建菜单树
		getRoleMenuListResponse = buildMenuTree(menuIDs, adminMenu)
		if getRoleMenuListResponse == nil {
			return nil, nil
		}
	}

	return getRoleMenuListResponse, nil
}

// GetRoleMenuButtonList 获取角色菜单按钮
func (r *RoleService) GetRoleMenuButtonList(roleId int64) ([]string, error) {
	// 获取角色菜单
	adminRoleMenuDao := dao.AdminRoleMenuDao{}
	var buttons []string

	adminRoleMenus, err := adminRoleMenuDao.GetAdminRoleMenuListWithMenuByRoleId(roleId)
	if err != nil {
		return buttons, nil
	}

	if adminRoleMenus != nil {
		for _, v := range adminRoleMenus {
			if v.Menu != nil {
				if v.Menu.MenuType != 3 {
					continue
				}

				buttons = append(buttons, v.Menu.Permission)
			}
		}
	}

	return buttons, nil
}

// 获取角色菜单-构建菜单树
func buildMenuTree(menuIds []int64, menuData []*model.AdminMenu) []*dto.AdminRoleMenuDto {
	menuMap := make(map[int64]*dto.AdminRoleMenuDto)
	rootNodes := make([]*dto.AdminRoleMenuDto, 0)

	// 构建菜单映射
	for _, menu := range menuData {
		for _, v := range menuIds {
			if v == menu.MenuId {
				node := &dto.AdminRoleMenuDto{
					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 menuMap[menu.MenuId] == nil {
			continue
		}
		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{}

	// 修改角色状态
	err := AdminRoleDao.EditAdminRoleStatusById(roleId, roleStatus)
	if err != nil {
		return false, errors.New(err.Error())
	}
	return true, nil
}

// GetRole 角色详情
func (r *RoleService) GetRole(roleId int64, isAdmin bool) (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
	if isAdmin {
		adminMenuDao := dao.AdminMenuDao{}
		menuIds, err = adminMenuDao.GetAdminMenuId()
		if err != nil {
			return nil, nil, errors.New("角色权限菜单获取失败")
		}
	} else {
		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{}

	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(requestRoleId int64, PutRoleRequest requests.PutRole) (bool, error) {

	adminRoleDao := dao.AdminRoleDao{}
	AdminMenuDao := dao.AdminMenuDao{}

	// 获取角色数据
	adminRole, err := adminRoleDao.GetAdminRoleFirstById(requestRoleId)
	if err != nil || adminRole == nil {
		return false, errors.New("修改失败")
	}

	if len(PutRoleRequest.MenuIds) > 0 {
		if adminRole.IsAdmin == 1 {
			return false, errors.New("无法修改管理员菜单")
		}
	}

	// 判断菜单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
}

// GetRoleIden 获取角色身份
func (r *RoleService) GetRoleIden(c *gin.Context) (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 adminRole.IsAdmin == 0 {
		return false, nil
	}
	return true, nil
}