Medical_OAuth/app/admin/service/sys_menu.go

package service

import (
	dto2 "Medical_OAuth/common/dto"
	"Medical_OAuth/common/global"
	"encoding/json"
	"fmt"
	"gogs.baozhida.cn/zoie/OAuth-core/service"
	"sort"
	"strings"

	"github.com/pkg/errors"
	"gorm.io/gorm"

	"Medical_OAuth/app/admin/model"
	"Medical_OAuth/app/admin/service/dto"
	"gogs.baozhida.cn/zoie/OAuth-core/pkg"
)

type SysMenu struct {
	service.Service
}

// GetPage 获取SysMenu列表
func (e *SysMenu) GetPage(c *dto.SysMenuGetPageReq, menus *[]model.SysMenu) *SysMenu {
	var menu = make([]model.SysMenu, 0)
	err := e.getPage(c, &menu).Error
	if err != nil {
		_ = e.AddError(global.GetFailedErr)
		return e
	}
	for i := 0; i < len(menu); i++ {
		if menu[i].ParentId != 0 {
			continue
		}
		menusInfo := menuCall(&menu, menu[i])
		*menus = append(*menus, menusInfo)
	}

	if len(*menus) == 0 {
		parentMap, flag := getMenuParent(&menu)
		if flag {
			for i := 0; i < len(menu); i++ {
				if parentMap[menu[i].ParentId] {
					continue
				}
				menusInfo := menuCall(&menu, menu[i])
				*menus = append(*menus, menusInfo)
			}
		} else {
			for i := 0; i < len(menu); i++ {
				menusInfo := menuCall(&menu, menu[i])
				*menus = append(*menus, menusInfo)
			}
		}
	}

	return e
}

func getMenuParent(menuList *[]model.SysMenu) (map[int]bool, bool) {
	list := *menuList
	var flag = false
	var parentMap = map[int]bool{}
	for j := 0; j < len(list); j++ {
		parentMap[list[j].ParentId] = false
	}

	for j := 0; j < len(list); j++ {
		if _, ok := parentMap[list[j].Id]; !ok {
			continue
		}
		parentMap[list[j].Id] = true
		flag = true
	}
	return parentMap, flag
}

// getPage 菜单分页列表
func (e *SysMenu) getPage(c *dto.SysMenuGetPageReq, list *[]model.SysMenu) *SysMenu {
	var err error
	var data model.SysMenu
	var tempList []model.SysMenu
	var temp2List []model.SysMenu
	var temp3List []dto.SysMenu
	err = e.Orm.Model(&data).
		Scopes(dto2.MakeCondition(c.GetNeedSearch())).
		Find(&tempList).Error
	if err != nil {
		e.Log.Errorf("getSysMenuPage error: %s", err)
		_ = e.AddError(err)
		return e
	}

	// 获取菜单及其子菜单下ID
	for _, menu := range tempList {
		var menuList = make([]model.SysMenu, 0)
		err = e.Orm.Where("menu_path like ?", menu.MenuPath+"%").Order(fmt.Sprintf("sort %s", c.SortOrder)).Find(&menuList).Error
		temp2List = append(temp2List, menuList...)
	}

	ids := DeduplicateSysMenuIds(temp2List)
	err = e.Orm.Table("sys_menu").
		Select("*,sys_menu.id as id,sys_menu.parent_id as parent_id,sys_menu.visible as visible").
		Joins("left join serv_menu on sys_menu.service_menu_id=serv_menu.id and sys_menu.service_id=serv_menu.service_id").
		Where("sys_menu.id in (?) and serv_menu.name like ?", ids, "%"+c.Name+"%").
		Scan(&temp3List).Error
	for _, menu := range temp3List {
		*list = append(*list, menu.Generate())
	}
	return e
}

// DeduplicateSysMenuIds  去掉重复的ID
func DeduplicateSysMenuIds(list []model.SysMenu) (deduplicated []int) {
	seen := make(map[string]bool)

	for _, v := range list {
		// 将结构体编码为 JSON 字符串
		key, err := json.Marshal(v)
		if err != nil {
			// 处理错误
			continue
		}
		// 将 JSON 字符串作为键插入到 map 中
		if _, ok := seen[string(key)]; !ok {
			seen[string(key)] = true
			deduplicated = append(deduplicated, v.Id)
		}
	}

	return deduplicated
}

// Get 获取SysMenu对象
func (e *SysMenu) Get(d *dto.SysMenuGetReq, menuModel *model.SysMenu) *SysMenu {
	err := e.Orm.First(menuModel, d.GetId()).Error
	if err != nil {
		e.Log.Errorf("db error: %s", err)
		if errors.Is(err, gorm.ErrRecordNotFound) {
			err = global.GetNotFoundErr
		} else {
			err = global.GetFailedErr
		}
		_ = e.AddError(err)
		return e
	}
	var servMenu model.ServMenu
	_ = e.Orm.Where("id = ? and service_id = ?", menuModel.ServiceMenuId, menuModel.ServiceId).First(&servMenu).Error
	menuModel.Name = servMenu.Name
	menuModel.MenuType = servMenu.MenuType
	menuModel.Icon = servMenu.Icon
	menuModel.Component = servMenu.Component
	menuModel.IsFrame = servMenu.IsFrame
	menuModel.Path = servMenu.Path
	menuModel.Permission = servMenu.Permission
	return e
}

// Insert 创建SysMenu对象
func (e *SysMenu) Insert(c *dto.SysMenuInsertReq) *SysMenu {
	var err error
	var data model.SysMenu
	c.Generate(&data)
	err = e.Orm.Create(&data).Error
	if err != nil {
		e.Log.Errorf("db error: %s", err)
		_ = e.AddError(global.CreateFailedErr)
	}
	c.Id = data.Id
	err = e.initPaths(&data)
	if err != nil {
		e.Log.Errorf("db error: %s", err)
		_ = e.AddError(err)
	}
	return e
}

// initPaths 初始化菜单paths
func (e *SysMenu) initPaths(menu *model.SysMenu) error {
	var err error
	var data model.SysMenu
	parentMenu := new(model.SysMenu)
	if menu.ParentId != 0 {
		e.Orm.Model(&data).First(parentMenu, menu.ParentId)
		if parentMenu.MenuPath == "" {
			err = errors.New("父级paths异常，请尝试对当前节点父级菜单进行更新操作！")
			return err
		}
		menu.MenuPath = parentMenu.MenuPath + "/" + pkg.IntToString(menu.Id)
	} else {
		menu.MenuPath = "/0/" + pkg.IntToString(menu.Id)
	}
	e.Orm.Model(&data).Where("id = ?", menu.Id).Update("menu_path", menu.MenuPath)
	return err
}

// Update 修改SysMenu对象
func (e *SysMenu) Update(c *dto.SysMenuUpdateReq) *SysMenu {
	var err error
	tx := e.Orm.Debug().Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	var menuModel = model.SysMenu{}
	err = tx.First(&menuModel, c.GetId()).Error
	if err != nil {
		e.Log.Errorf("db error: %s", err)
		if errors.Is(err, gorm.ErrRecordNotFound) {
			err = global.UpdateNotFoundOrNoPermissionErr
		} else {
			err = global.UpdateFailedErr
		}
		_ = e.AddError(err)
		return e
	}
	oldPath := menuModel.MenuPath

	c.Generate(&menuModel)
	err = tx.Model(&menuModel).Save(&menuModel).Error
	if err != nil {
		e.Log.Errorf("db error: %s", err)
		_ = e.AddError(global.UpdateFailedErr)
		return e
	}
	var menuList []model.SysMenu
	tx.Where("paths like ?", oldPath+"%").Find(&menuList)
	for _, v := range menuList {
		v.MenuPath = strings.Replace(v.MenuPath, oldPath, menuModel.MenuPath, 1)
		tx.Model(&v).Update("paths", v.MenuPath)
	}
	return e
}

// Remove 删除SysMenu
func (e *SysMenu) Remove(d *dto.SysMenuDeleteReq) *SysMenu {
	var err error

	tx := e.Orm.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	var menuList = make([]model.SysMenu, 0)
	tx.Where("id in (?)", d.GetId(), d.GetId()).Find(&menuList)
	if len(menuList) == 0 {
		return e
	}

	for _, menu := range menuList {
		err = e.Orm.Where("menu_path like ?", menu.MenuPath+"%").Delete(&model.SysMenu{}).Error
		if err != nil {
			e.Log.Errorf("Delete error: %s", err)
			_ = e.AddError(global.DeleteFailedErr)
			return e
		}
	}
	return e
}

// GetList 获取菜单数据
func (e *SysMenu) GetList(c *dto.SysMenuGetPageReq, list *[]model.SysMenu) error {
	var err error

	var tempList []dto.SysMenu
	err = e.Orm.Table("sys_menu").
		Select("sys_menu.id as id,sys_menu.parent_id as parent_id,sys_menu.visible as visible,name").
		Joins("left join serv_menu on sys_menu.service_menu_id=serv_menu.id and sys_menu.service_id=serv_menu.service_id").
		Where("serv_menu.name like ?", "%"+c.Name+"%").
		Scan(&tempList).Error
	if err != nil {
		e.Log.Errorf("db error: %s", err)
		return global.GetFailedErr
	}
	for _, menu := range tempList {
		*list = append(*list, menu.Generate())
	}
	return nil
}

// SetLabel 修改角色中 设置菜单基础数据
func (e *SysMenu) SetLabel() (m []dto.MenuLabel, err error) {
	var list []model.SysMenu
	err = e.GetList(&dto.SysMenuGetPageReq{}, &list)
	if err != nil {
		return
	}

	m = make([]dto.MenuLabel, 0)
	for i := 0; i < len(list); i++ {
		if list[i].ParentId != 0 {
			continue
		}
		e := dto.MenuLabel{}
		e.Id = list[i].Id
		e.Label = list[i].Name
		menuInfo := menuLabelCall(&list, e)

		m = append(m, menuInfo)
	}
	return
}

// menuLabelCall 递归构造组织数据
func menuLabelCall(eList *[]model.SysMenu, organ dto.MenuLabel) dto.MenuLabel {
	list := *eList

	min := make([]dto.MenuLabel, 0)
	for j := 0; j < len(list); j++ {

		if organ.Id != list[j].ParentId {
			continue
		}
		mi := dto.MenuLabel{}
		mi.Id = list[j].Id
		mi.Label = list[j].Name
		mi.Children = []dto.MenuLabel{}
		if list[j].MenuType != "F" {
			ms := menuLabelCall(eList, mi)
			min = append(min, ms)
		} else {
			min = append(min, mi)
		}
	}
	if len(min) > 0 {
		organ.Children = min
	} else {
		organ.Children = nil
	}
	return organ
}

// menuCall 构建菜单树
func menuCall(menuList *[]model.SysMenu, menu model.SysMenu) model.SysMenu {
	list := *menuList

	min := make([]model.SysMenu, 0)
	for j := 0; j < len(list); j++ {

		if menu.Id != list[j].ParentId {
			continue
		}
		mi := model.SysMenu{}
		mi.Id = list[j].Id
		mi.Name = list[j].Name
		mi.Icon = list[j].Icon
		mi.Path = list[j].Path
		mi.MenuType = list[j].MenuType
		mi.Permission = list[j].Permission
		mi.ParentId = list[j].ParentId
		mi.Component = list[j].Component
		mi.Sort = list[j].Sort
		mi.Visible = list[j].Visible
		mi.CreatedAt = list[j].CreatedAt
		mi.Children = []model.SysMenu{}
		ms := menuCall(menuList, mi)
		min = append(min, ms)
	}
	menu.Children = min
	return menu
}

// 去掉重复菜单
func menuDistinct(menuList []model.SysMenu) (result []model.SysMenu) {
	distinctMap := make(map[int]struct{}, len(menuList))
	for _, menu := range menuList {
		if _, ok := distinctMap[menu.Id]; !ok {
			distinctMap[menu.Id] = struct{}{}
			result = append(result, menu)
		}
	}
	return result
}

func recursiveSetMenu(orm *gorm.DB, mIds []int, menus *[]model.SysMenu) error {
	if len(mIds) == 0 || menus == nil {
		return nil
	}
	var subMenus []model.SysMenu
	err := orm.Where("id in ?", mIds).Find(&subMenus).Error
	if err != nil {
		return err
	}

	subIds := make([]int, 0)
	for _, menu := range subMenus {
		if menu.ParentId != 0 {
			subIds = append(subIds, menu.ParentId)
		}
		//if menu.MenuType != cModel.Button {
		//	*menus = append(*menus, menu)
		//}
		*menus = append(*menus, menu)
	}
	return recursiveSetMenu(orm, subIds, menus)
}

// SetMenuRole 获取左侧菜单树使用
func (e *SysMenu) SetMenuRole(roleName string) (m []model.SysMenu, err error) {
	// 从缓存获取角色关联的菜单
	if err := model.GetRoleMenuCache(roleName, &m); err == nil {
		return m, nil
	}
	menus, err := e.getByRoleName(roleName)
	if err != nil {
		return m, global.GetFailedErr
	}
	menuIds := make([]int, 0)
	for _, menu := range menus {
		menuIds = append(menuIds, menu.Id)
	}
	var tempList []dto.SysMenu
	var menuList []model.SysMenu
	err = e.Orm.Table("sys_menu").
		Select("*,sys_menu.id as id,sys_menu.parent_id as parent_id,sys_menu.visible as visible").
		Joins("left join serv_menu on sys_menu.service_menu_id=serv_menu.id and sys_menu.service_id=serv_menu.service_id").
		Where("sys_menu.id in (?) and sys_menu.visible = 1", menuIds).
		Order("sys_menu.sort").
		Scan(&tempList).Error
	for _, menu := range tempList {
		menuList = append(menuList, menu.Generate())
	}
	sort.Sort(model.SysMenuSlice(menuList))
	m = make([]model.SysMenu, 0)
	for i := 0; i < len(menuList); i++ {
		if menuList[i].ParentId != 0 {
			continue
		}
		menusInfo := menuCall(&menuList, menuList[i])
		m = append(m, menusInfo)
	}
	// 保存角色菜单到缓存
	_ = model.SetRoleMenuCache(roleName, m)
	return
}

// 通过roleName获取菜单列表
func (e *SysMenu) getByRoleName(roleName string) ([]model.SysMenu, error) {
	var err error

	data := make([]model.SysMenu, 0)

	if roleName == "admin" {
		err = e.Orm.Find(&data).Error
	} else {
		roleMenuIds := make([]int, 0)
		err = e.Orm.Model(&model.SysRoleMenu{}).Select("menu_id").Where("role_key = ? ", roleName).Scan(&roleMenuIds).Error

		if len(roleMenuIds) > 0 {
			if err = recursiveSetMenu(e.Orm, roleMenuIds, &data); err != nil {
				return nil, err
			}
			// 菜单id及父id 去重
			data = menuDistinct(data)
		}
	}

	return data, err
}