projectx/internal/erpserver/biz/v1/system/menu.go

package system

import (
	"context"
	"encoding/json"
	"slices"
	"strconv"
	"strings"
	"time"

	"management/internal/db/model/dto"
	db "management/internal/db/sqlc"
	"management/internal/erpserver/model/view"
	"management/internal/global/keys"
	"management/internal/pkg/redis"
)

type MenuBiz interface {
	MenuExpansion
}

type MenuExpansion interface {
	Create(ctx context.Context, arg *db.CreateSysMenuParams) (*db.SysMenu, error)
	Update(ctx context.Context, arg *db.UpdateSysMenuParams) (*db.SysMenu, error)
	Get(ctx context.Context, id int32) (*db.SysMenu, error)
	GetSysMenuByUrl(ctx context.Context, url string) (*db.SysMenu, error)
	AllMenusCache(ctx context.Context) ([]*db.SysMenu, error)
	ListMenuTree(ctx context.Context) ([]*db.SysMenuDto, error)
	ListOwnerMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error)
	SetOwnerListMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error)
	RecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error)
	SetRecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error)
	MapOwnerMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error)
	SetOwnerMapMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error)
	RefreshMenus(ctx context.Context) error
	SetMenuViewData(ctx context.Context, roleID int32) ([]*dto.SetMenuDto, error)

	Tree(ctx context.Context, id int32) ([]*view.LayuiTree, error)
	XmSelectTree(ctx context.Context, id int32) ([]*view.XmSelectTree, error)
	SetMenu(ctx context.Context, roleID int32, menus []*db.SysMenu) error
}

type menuBiz struct {
	store db.Store
	redis redis.IRedis
}

var _ MenuBiz = (*menuBiz)(nil)

func NewMenu(store db.Store, redis redis.IRedis) *menuBiz {
	return &menuBiz{
		store: store,
		redis: redis,
	}
}

func (b *menuBiz) Create(ctx context.Context, arg *db.CreateSysMenuParams) (*db.SysMenu, error) {
	return b.store.CreateSysMenu(ctx, arg)
}

func (b *menuBiz) Update(ctx context.Context, arg *db.UpdateSysMenuParams) (*db.SysMenu, error) {
	return b.store.UpdateSysMenu(ctx, arg)
}

func (b *menuBiz) Get(ctx context.Context, id int32) (*db.SysMenu, error) {
	return b.store.GetSysMenu(ctx, id)
}

func (b *menuBiz) GetSysMenuByUrl(ctx context.Context, url string) (*db.SysMenu, error) {
	return b.store.GetSysMenuByUrl(ctx, url)
}

func (b *menuBiz) AllMenusCache(ctx context.Context) ([]*db.SysMenu, error) {
	key := keys.GetManageKey(ctx, keys.AllMenus)
	bs, err := b.redis.GetBytes(ctx, key)
	if err == nil {
		var res []*db.SysMenu
		if err := json.Unmarshal(bs, &res); err == nil {
			return res, nil
		}
	}

	all, err := b.store.AllSysMenu(ctx)
	if err != nil {
		return nil, err
	}

	bs, err = json.Marshal(all)
	if err != nil {
		return nil, err
	}

	_ = redis.Set(ctx, key, bs, time.Hour*6)
	return all, nil
}

func (b *menuBiz) ListMenuTree(ctx context.Context) ([]*db.SysMenuDto, error) {
	all, err := b.AllMenusCache(ctx)
	if err != nil {
		return nil, err
	}

	return toTreeSysMenu(0, all), nil
}

func (b *menuBiz) ListOwnerMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
	// 判断redis是否存储
	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
	bs, err := b.redis.GetBytes(ctx, key)
	if err == nil {
		var res []*dto.OwnerMenuDto
		if err := json.Unmarshal(bs, &res); err == nil {
			return res, nil
		}
	}

	return b.SetOwnerListMenuByRoleID(ctx, roleID)
}

func (b *menuBiz) SetOwnerListMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
	menus, err := b.ownerMenusByRoleID(ctx, roleID)
	if err != nil {
		return nil, err
	}

	var res []*dto.OwnerMenuDto
	for _, menu := range menus {
		res = append(res, &dto.OwnerMenuDto{
			ID:          menu.ID,
			DisplayName: menu.DisplayName,
			Url:         menu.Url,
			ParentID:    menu.ParentID,
			Avatar:      menu.Avatar,
			Style:       menu.Style,
			IsList:      menu.IsList,
		})
	}

	bs, err := json.Marshal(res)
	if err != nil {
		return nil, err
	}

	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
	_ = redis.Set(ctx, key, bs, time.Hour*6)
	return res, nil
}

func (b *menuBiz) RecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
	// 判断redis是否存储
	key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
	bs, err := b.redis.GetBytes(ctx, key)
	if err == nil {
		var res []*dto.MenuUIDto
		if err := json.Unmarshal(bs, &res); err == nil {
			return res, nil
		}
	}

	return b.SetRecursiveSysMenus(ctx, roleID)
}

func (b *menuBiz) SetRecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
	// 判断当前用户是否有vip角色
	role, err := b.store.GetSysRole(ctx, roleID)
	if err != nil {
		return nil, err
	}

	var menus []*db.SysMenu
	if role.Vip {
		// vip 用户
		all, err := b.store.RecursiveSysMenus(ctx)
		if err != nil {
			return nil, err
		}
		menus = convertToMenuUIDto(all)

	} else {
		// not vip
		all, err := b.store.RecursiveSysMenusByRoleID(ctx, roleID)
		if err != nil {
			return nil, err
		}
		menus = convertToMenuUIDto2(all)
	}
	menuList := uniqueSysMenus(menus)
	if len(menuList) == 0 {
		return nil, nil
	}

	tree := convertToUITree(menuList, 0)
	bs, err := json.Marshal(tree)
	if err != nil {
		return nil, err
	}

	key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
	_ = redis.Set(ctx, key, bs, time.Hour*6)
	return tree, nil
}

func (b *menuBiz) MapOwnerMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
	// 判断redis是否存储
	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
	bs, err := b.redis.GetBytes(ctx, key)
	if err == nil {
		var res map[string]*dto.OwnerMenuDto
		if err := json.Unmarshal(bs, &res); err == nil {
			return res, nil
		}
	}

	return b.SetOwnerMapMenuByRoleID(ctx, roleID)
}

func (b *menuBiz) SetOwnerMapMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
	result := make(map[string]*dto.OwnerMenuDto)
	menus, err := b.ownerMenusByRoleID(ctx, roleID)
	if err != nil {
		return result, err
	}

	for _, menu := range menus {
		result[menu.Url] = &dto.OwnerMenuDto{
			ID:          menu.ID,
			DisplayName: menu.DisplayName,
			Url:         menu.Url,
			ParentID:    menu.ParentID,
			Avatar:      menu.Avatar,
			Style:       menu.Style,
			IsList:      menu.IsList,
		}
	}

	bs, err := json.Marshal(result)
	if err != nil {
		return nil, err
	}

	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
	_ = redis.Set(ctx, key, bs, time.Hour*6)
	return result, nil
}

func (b *menuBiz) RefreshMenus(ctx context.Context) error {
	all, err := b.store.AllSysMenu(ctx)
	if err != nil {
		return err
	}

	bs, err := json.Marshal(all)
	if err != nil {
		return err
	}

	key := keys.GetManageKey(ctx, keys.AllMenus)
	err = redis.Set(ctx, key, bs, time.Hour*6)
	return err
}

func (b *menuBiz) Tree(ctx context.Context, id int32) ([]*view.LayuiTree, error) {
	all, err := b.AllMenusCache(ctx)
	if err != nil {
		return nil, err
	}

	return b.toTree(id, all), nil
}

func (b *menuBiz) XmSelectTree(ctx context.Context, id int32) ([]*view.XmSelectTree, error) {
	all, err := b.AllMenusCache(ctx)
	if err != nil {
		return nil, err
	}

	return b.toXmSelectTree(id, all), nil
}

func (b *menuBiz) SetMenu(ctx context.Context, roleID int32, menus []*db.SysMenu) error {
	return b.store.ExecTx(ctx, func(q *db.Queries) error {
		err := q.DeleteRoleMneuByRoleID(ctx, roleID)
		if err != nil {
			return err
		}

		for _, m := range menus {
			err := q.CreateRoleMenu(ctx, &db.CreateRoleMenuParams{
				RoleID: roleID,
				MenuID: m.ID,
			})
			if err != nil {
				return err
			}
		}

		return nil
	})
}

func (b *menuBiz) SetMenuViewData(ctx context.Context, roleID int32) ([]*dto.SetMenuDto, error) {
	// 获取该用户已经有的权限
	hs, err := b.store.ListSysMenuIDByRoleID(ctx, roleID)
	if err != nil {
		return nil, err
	}

	all, err := b.AllMenusCache(ctx)
	if err != nil {
		return nil, err
	}

	return toSetMenuTree(all, hs, 0), nil
}

func (b *menuBiz) ownerMenusByRoleID(ctx context.Context, roleID int32) ([]*db.SysMenu, error) {
	// 判断当前用户是否有vip角色
	role, err := b.store.GetSysRole(ctx, roleID)
	if err != nil {
		return nil, err
	}

	var e error
	var menus []*db.SysMenu
	if role.Vip {
		// vip 用户
		menus, e = b.store.AllSysMenu(ctx)
		if e != nil {
			return nil, err
		}

	} else {
		// not vip
		menus, e = b.store.ListSysMenuByRoleID(ctx, roleID)
		if e != nil {
			return nil, err
		}
	}

	return menus, nil
}

func (b *menuBiz) toTree(parentId int32, data []*db.SysMenu) []*view.LayuiTree {
	var res []*view.LayuiTree
	for _, v := range data {
		if v.ParentID == parentId {
			item := view.LayuiTree{}
			item.ID = strconv.FormatInt(int64(v.ID), 10)
			item.Title = v.DisplayName
			item.Children = b.toTree(v.ID, data)
			if v.ParentID == 0 {
				item.Spread = true
			}
			res = append(res, &item)
		}
	}

	return res
}

func (b *menuBiz) toXmSelectTree(parentId int32, data []*db.SysMenu) []*view.XmSelectTree {
	var res []*view.XmSelectTree
	for _, v := range data {
		if v.ParentID == parentId {
			item := view.XmSelectTree{
				Name:     v.DisplayName,
				Value:    strconv.FormatInt(int64(v.ID), 10),
				Children: b.toXmSelectTree(v.ID, data),
			}
			res = append(res, &item)
		}
	}

	return res
}

func toTreeSysMenu(parentId int32, data []*db.SysMenu) []*db.SysMenuDto {
	var res []*db.SysMenuDto
	for _, v := range data {
		if v.ParentID == parentId {
			item := db.SysMenuDto{}
			item.ID = v.ID
			item.Name = v.Name
			item.DisplayName = v.DisplayName
			item.Url = v.Url
			item.Type = v.Type
			item.ParentID = v.ParentID
			item.ParentPath = v.ParentPath
			item.Avatar = v.Avatar
			item.Style = v.Style
			item.Visible = v.Visible
			item.IsList = v.IsList
			item.Status = v.Status
			item.Sort = v.Sort
			item.CreatedAt = v.CreatedAt
			item.UpdatedAt = v.UpdatedAt
			item.Children = toTreeSysMenu(v.ID, data)
			res = append(res, &item)
		}
	}

	return res
}

func convertToMenuUIDto(data []*db.RecursiveSysMenusRow) []*db.SysMenu {
	var res []*db.SysMenu

	for _, item := range data {
		temp := &db.SysMenu{
			ID:          item.ID,
			Name:        item.Name,
			DisplayName: item.DisplayName,
			Url:         item.Url,
			Type:        item.Type,
			ParentID:    item.ParentID,
			ParentPath:  item.ParentPath,
			Avatar:      item.Avatar,
			Style:       item.Style,
			Visible:     item.Visible,
			IsList:      item.IsList,
			Status:      item.Status,
			Sort:        item.Sort,
			CreatedAt:   item.CreatedAt,
			UpdatedAt:   item.UpdatedAt,
		}
		res = append(res, temp)
	}

	return res
}

func convertToMenuUIDto2(data []*db.RecursiveSysMenusByRoleIDRow) []*db.SysMenu {
	var res []*db.SysMenu

	for _, item := range data {
		temp := &db.SysMenu{
			ID:          item.ID,
			Name:        item.Name,
			DisplayName: item.DisplayName,
			Url:         item.Url,
			Type:        item.Type,
			ParentID:    item.ParentID,
			ParentPath:  item.ParentPath,
			Avatar:      item.Avatar,
			Style:       item.Style,
			Visible:     item.Visible,
			IsList:      item.IsList,
			Status:      item.Status,
			Sort:        item.Sort,
			CreatedAt:   item.CreatedAt,
			UpdatedAt:   item.UpdatedAt,
		}
		res = append(res, temp)
	}

	return res
}

func convertToUITree(data []*db.SysMenu, parentID int32) []*dto.MenuUIDto {
	var root []*dto.MenuUIDto
	for _, item := range data {
		if item.ParentID == parentID {
			if item.IsList {
				temp := &dto.MenuUIDto{
					ID:       strings.ToLower(item.Url),
					Title:    item.DisplayName,
					Icon:     item.Avatar,
					Type:     1,
					OpenType: "_iframe",
					// OpenType: "_component",
					Href: item.Url,
				}
				root = append(root, temp)
			} else {
				temp := &dto.MenuUIDto{
					ID:    strconv.Itoa(int(item.ID)),
					Title: item.DisplayName,
					Icon:  item.Avatar,
					Type:  0,
				}
				temp.Children = convertToUITree(data, item.ID)
				root = append(root, temp)
			}
		}
	}
	return root
}

func uniqueSysMenus(sm []*db.SysMenu) []*db.SysMenu {
	res := make([]*db.SysMenu, 0) // 返回的新切片
	m1 := make(map[int32]byte)    // 用来去重的临时map
	for _, v := range sm {
		if _, ok := m1[v.ID]; !ok {
			m1[v.ID] = 1
			res = append(res, v)
		}
	}
	return res
}

func toSetMenuTree(data []*db.SysMenu, ids []int32, parentID int32) []*dto.SetMenuDto {
	var res []*dto.SetMenuDto
	for _, v := range data {
		if v.ParentID == parentID {
			isSelect := hasValueInArray(ids, v.ID)
			if v.IsList {
				item := dto.SetMenuDto{
					ID:       v.ID,
					Name:     v.DisplayName,
					Link:     v.Type,
					IsList:   v.IsList,
					IsSelect: isSelect,
				}
				item.Items = []*dto.SetMenuDto{
					{
						ID:       v.ID,
						Name:     "列表",
						Link:     "btn",
						IsList:   false,
						IsSelect: isSelect,
						Items:    toSetMenuTree(data, ids, v.ID),
					},
				}
				item.Items = append(item.Items, toSetMenuTree(data, ids, v.ID)...)
				res = append(res, &item)
			} else {
				item := dto.SetMenuDto{
					ID:       v.ID,
					Name:     v.DisplayName,
					Link:     v.Type,
					IsList:   v.IsList,
					IsSelect: isSelect,
					Items:    toSetMenuTree(data, ids, v.ID),
				}
				res = append(res, &item)
			}
		}
	}

	return res
}

func hasValueInArray(data []int32, id int32) bool {
	return slices.Contains(data, id)
}