base/backend/internal/logic/menu/getcurrentmenuslogic.go

// Code scaffolded by goctl. Safe to edit.
// goctl 1.9.2

package menu

import (
	"context"
	"fmt"

	"github.com/youruser/base/internal/svc"
	"github.com/youruser/base/internal/types"
	"github.com/youruser/base/model"

	"github.com/zeromicro/go-zero/core/logx"
)

type GetCurrentMenusLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

// 获取当前用户可见菜单
func NewGetCurrentMenusLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetCurrentMenusLogic {
	return &GetCurrentMenusLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *GetCurrentMenusLogic) GetCurrentMenus() (resp *types.MenuListResponse, err error) {
	// 获取用户角色
	roleStr, _ := l.ctx.Value("role").(string)
	if roleStr == "" {
		roleStr = model.RoleGuest
	}

	// 查找角色
	role, err := model.RoleFindOneByCode(l.ctx, l.svcCtx.DB, roleStr)
	if err != nil {
		return nil, fmt.Errorf("角色不存在: %v", err)
	}

	// 获取角色关联的菜单ID
	roleMenuIds, err := model.RoleMenuFindByRoleId(l.ctx, l.svcCtx.DB, role.Id)
	if err != nil {
		return nil, fmt.Errorf("获取角色菜单失败: %v", err)
	}

	// 构建菜单ID集合用于快速查找
	menuIdSet := make(map[int64]bool)
	for _, id := range roleMenuIds {
		menuIdSet[id] = true
	}

	// 获取所有菜单
	allMenus, err := model.MenuFindAll(l.ctx, l.svcCtx.DB)
	if err != nil {
		return nil, fmt.Errorf("获取菜单列表失败: %v", err)
	}

	// 过滤：包含角色关联的菜单或 type=default 且 visible=true
	includedIds := make(map[int64]bool)
	for _, m := range allMenus {
		if menuIdSet[m.Id] || (m.Type == "default" && m.Visible) {
			includedIds[m.Id] = true
		}
	}

	// 向上追溯：如果子菜单被包含，其所有祖先节点也必须包含（确保树形完整）
	menuById := make(map[int64]model.Menu)
	for _, m := range allMenus {
		menuById[m.Id] = m
	}
	for _, m := range allMenus {
		if includedIds[m.Id] {
			pid := m.ParentId
			for pid != 0 {
				if includedIds[pid] {
					break // 已在集合中，祖先链必然完整
				}
				includedIds[pid] = true
				if parent, ok := menuById[pid]; ok {
					pid = parent.ParentId
				} else {
					break
				}
			}
		}
	}

	var filteredMenus []model.Menu
	for _, m := range allMenus {
		if includedIds[m.Id] {
			filteredMenus = append(filteredMenus, m)
		}
	}

	// 构建树形结构
	tree := buildMenuTree(filteredMenus, 0)

	return &types.MenuListResponse{
		List: tree,
	}, nil
}

func buildMenuTree(menus []model.Menu, parentId int64) []types.MenuItem {
	var tree []types.MenuItem
	for _, m := range menus {
		if m.ParentId == parentId {
			item := types.MenuItem{
				Id:        m.Id,
				ParentId:  m.ParentId,
				Name:      m.Name,
				Path:      m.Path,
				Icon:      m.Icon,
				Component: m.Component,
				Type:      m.Type,
				SortOrder: m.SortOrder,
				Visible:   m.Visible,
				Status:    m.Status,
				Children:  buildMenuTree(menus, m.Id),
				CreatedAt: m.CreatedAt.Format("2006-01-02 15:04:05"),
				UpdatedAt: m.UpdatedAt.Format("2006-01-02 15:04:05"),
			}
			tree = append(tree, item)
		}
	}
	if tree == nil {
		tree = []types.MenuItem{}
	}
	return tree
}