hospital-admin-api/api/service/menu.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/menuResponse"
	"hospital-admin-api/global"
	"strconv"
)

type MenuService struct{}

// GetMenuList 获取菜单列表
func (r *MenuService) GetMenuList() ([]*menuResponse.GetMenuList, error) {
	// 获取全部菜单
	AdminMenuDao := dao.AdminMenuDao{}
	adminMenu, _ := AdminMenuDao.GetAdminMenuListSortOrderNum()
	if adminMenu == nil {
		return nil, nil
	}

	menuMap := make(map[int64]*menuResponse.GetMenuList)
	var menuTree []*menuResponse.GetMenuList

	for _, menu := range adminMenu {
		node := &menuResponse.GetMenuList{
			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 adminMenu {
		if menu.ParentId == 0 {
			if menuMap[menu.MenuId] == nil {
				continue
			}
			menuTree = append(menuTree, menuMap[menu.MenuId])
		} else if parent, ok := menuMap[menu.ParentId]; ok {
			parent.Children = append(parent.Children, menuMap[menu.MenuId])
		}
	}

	return menuTree, nil
}

// AddMenu 新增菜单
func (r *MenuService) AddMenu(AddMenuRequest requests.AddMenu) (bool, error) {
	AdminMenuDao := dao.AdminMenuDao{}
	AdminMenuApiDao := dao.AdminMenuApiDao{}
	AdminApiDao := dao.AdminApiDao{}

	ParentId, err := strconv.ParseInt(AddMenuRequest.ParentId, 10, 64)
	if err != nil {
		return false, errors.New("新增失败")
	}

	// 判断父级id
	if ParentId != 0 {
		adminMenu, _ := AdminMenuDao.GetAdminMenuById(ParentId)
		if adminMenu == nil {
			return false, errors.New("上级菜单错误")
		}
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 新增菜单
	AdminMenuModel := &model.AdminMenu{
		MenuName:   AddMenuRequest.MenuName,
		MenuTitle:  AddMenuRequest.MenuTitle,
		ParentId:   ParentId,
		MenuStatus: AddMenuRequest.MenuStatus,
		MenuType:   AddMenuRequest.MenuType,
		Permission: AddMenuRequest.Permission,
		OrderNum:   AddMenuRequest.OrderNum,
		Icon:       AddMenuRequest.Icon,
		Path:       AddMenuRequest.Path,
		Component:  AddMenuRequest.Component,
	}

	adminMenu, _ := AdminMenuDao.AddAdminMenu(tx, AdminMenuModel)
	if adminMenu == nil {
		tx.Rollback()
		return false, errors.New("新增失败")
	}

	// 新增菜单api
	if len(AddMenuRequest.ApiIds) > 0 {
		for _, v := range AddMenuRequest.ApiIds {
			// 将字符串转换为int64类型
			v, err := strconv.ParseInt(v, 10, 64)
			if err != nil {
				tx.Rollback()
				return false, errors.New("新增失败")
			}

			// 检测api
			adminApi, _ := AdminApiDao.GetAdminApiById(v)
			if adminApi == nil {
				tx.Rollback()
				return false, errors.New("接口不存在")
			}

			AdminMenuApiModel := &model.AdminMenuApi{
				MenuId: adminMenu.MenuId,
				ApiId:  v,
			}

			adminMenuApi, _ := AdminMenuApiDao.AddAdminMenuApi(tx, AdminMenuApiModel)
			if adminMenuApi == nil {
				tx.Rollback()
				return false, errors.New("新增失败")
			}
		}
	}

	tx.Commit()

	return true, nil
}

// PutMenu 修改菜单
func (r *MenuService) PutMenu(requestMenuId int64, PutMenuRequest requests.PutMenu) (bool, error) {
	AdminMenuDao := dao.AdminMenuDao{}
	AdminMenuApiDao := dao.AdminMenuApiDao{}
	AdminApiDao := dao.AdminApiDao{}

	// 获取当前菜单数据
	adminMenu, _ := AdminMenuDao.GetAdminMenuById(requestMenuId)
	if adminMenu == nil {
		return false, errors.New("菜单数据错误")
	}

	// 判断是否更改菜单类型
	if adminMenu.MenuType != PutMenuRequest.MenuType {
		return false, errors.New("如需更改类型，请删除后新增")
	}

	ParentId, err := strconv.ParseInt(PutMenuRequest.ParentId, 10, 64)
	if err != nil {
		return false, errors.New("新增失败")
	}

	// 判断父级id
	if ParentId != 0 {
		adminMenu, _ := AdminMenuDao.GetAdminMenuById(ParentId)
		if adminMenu == nil {
			return false, errors.New("上级菜单错误")
		}
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 修改菜单
	AdminMenuModel := &model.AdminMenu{
		MenuName:   PutMenuRequest.MenuName,
		MenuTitle:  PutMenuRequest.MenuTitle,
		ParentId:   ParentId,
		MenuStatus: PutMenuRequest.MenuStatus,
		MenuType:   PutMenuRequest.MenuType,
		Permission: PutMenuRequest.Permission,
		OrderNum:   PutMenuRequest.OrderNum,
		Icon:       PutMenuRequest.Icon,
		Path:       PutMenuRequest.Path,
		Component:  PutMenuRequest.Component,
	}

	err = AdminMenuDao.EditAdminMenuByIdWithStruct(tx, adminMenu.MenuId, AdminMenuModel)
	if err != nil {
		tx.Rollback()
		return false, errors.New("修改失败")
	}

	// 删除菜单关联api
	err = AdminMenuApiDao.DeleteAdminMenuApiByMenuId(tx, adminMenu.MenuId)
	if err != nil {
		tx.Rollback()
		return false, errors.New("修改失败")
	}

	// 新增菜单api
	if len(PutMenuRequest.ApiIds) > 0 {
		for _, v := range PutMenuRequest.ApiIds {
			// 将字符串转换为int64类型
			v, err := strconv.ParseInt(v, 10, 64)
			if err != nil {
				tx.Rollback()
				return false, errors.New("修改失败")
			}

			// 检测api
			adminApi, _ := AdminApiDao.GetAdminApiById(v)
			if adminApi == nil {
				tx.Rollback()
				return false, errors.New("关联接口api不存在")
			}

			AdminMenuApiModel := &model.AdminMenuApi{
				MenuId: adminMenu.MenuId,
				ApiId:  v,
			}

			adminMenuApi, _ := AdminMenuApiDao.AddAdminMenuApi(tx, AdminMenuApiModel)
			if adminMenuApi == nil {
				tx.Rollback()
				return false, errors.New("修改失败")
			}
		}
	}

	tx.Commit()

	return true, nil
}

// DeleteMenu 删除菜单
func (r *MenuService) DeleteMenu(c *gin.Context, DeleteMenuRequest requests.DeleteMenu) (bool, error) {
	// 获取当前登陆用户角色数据
	roleId := c.GetInt64("RoleId")
	if roleId == 0 {
		return false, errors.New("数据错误")
	}

	adminMenuDao := dao.AdminMenuDao{}
	adminMenuApiDao := dao.AdminMenuApiDao{}
	adminRoleMenuDao := dao.AdminRoleMenuDao{}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	for _, v := range DeleteMenuRequest.MenuIds {
		// 将字符串转换为int64类型
		v, err := strconv.ParseInt(v, 10, 64)
		if err != nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}

		// 获取菜单数据
		adminMenu, _ := adminMenuDao.GetAdminMenuById(v)
		if adminMenu == nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}

		// 判断是否特殊菜单
		if adminMenu.MenuId == 1 || adminMenu.ParentId == 1 {
			tx.Rollback()
			return false, errors.New("系统菜单，请勿删除")
		}

		// 检测菜单是否存在子级
		childrenAdminMenus, err := adminMenuDao.GetAdminMenuListByParentId(v)
		if err != nil || len(childrenAdminMenus) > 0 {
			tx.Rollback()
			return false, errors.New("存在下级菜单，删除失败")
		}

		// 删除菜单关联api
		err = adminMenuApiDao.DeleteAdminMenuApiByMenuId(tx, v)
		if err != nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}

		// 删除角色菜单表
		err = adminRoleMenuDao.DeleteAdminRoleMenuByMenuId(tx, v)
		if err != nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}

		// 删除菜单
		err = adminMenuDao.DeleteAdminMenuByMenuId(tx, v)
		if err != nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}
	}

	tx.Commit()

	return true, nil
}

// GetMenu 菜单详情
func (r *MenuService) GetMenu(menuId int64) (*model.AdminMenu, error) {
	adminMenuDao := dao.AdminMenuDao{}

	adminMenu, _ := adminMenuDao.GetAdminMenuById(menuId)
	if adminMenu == nil {
		return nil, errors.New("数据错误")
	}
	return adminMenu, nil
}

// GetAdminMenuApi 获取菜单关联api-菜单id
func (r *MenuService) GetAdminMenuApi(menuId int64) ([]*model.AdminMenuApi, error) {
	adminMenuApiDao := dao.AdminMenuApiDao{}
	adminMenuApis, err := adminMenuApiDao.GetAdminMenuApiListWithAPIByMenuID(menuId)
	if err != nil {
		return adminMenuApis, errors.New("数据错误")
	}

	return adminMenuApis, nil
}