WCS/Cowain.Base/Helpers/PageViewMenuHelper.cs

using Avalonia.Media;
using Cowain.Base.Attributes;
using Cowain.Base.Models.Menu;
using Cowain.Base.ViewModels;
using Ke.Bee.Localization.Localizer.Abstractions;
using System;
using System.Collections.ObjectModel;

namespace Cowain.Base.Helpers;

[Singleton]
public class PageViewMenuHelper
{
    /// <summary>
    /// 菜单数据
    /// </summary>
    private readonly List<MenuItem> _menuItems;

    private readonly ILocalizer _l;
    public PageViewMenuHelper(MenuConfigurationContext menuContext, ILocalizer localizer)
    {
        _menuItems = menuContext.Menus;
        _l = localizer;
    }

    /// <summary>
    /// MenuItem 到 MenuItemViewModel 的转换器
    /// </summary>
    public Func<MenuItem, MenuItemViewModel> MenuItemToViewModel => x => new MenuItemViewModel(_l[x.LocaleKey])
    {
        Key = x.Key,
        IsActive = x.IsActive == true,
        Icon = string.IsNullOrWhiteSpace(x.Icon) ? null : StreamGeometry.Parse(x.Icon),
        CommandParameter = x.CommandParameter,
        PageActions = x.PageActions,
        Items = x.Items.Select(MenuItemToViewModel).ToList(),
    };

    /// <summary>
    /// 返回组菜单列表
    /// </summary>
    public IEnumerable<MenuItemViewModel> GetGroupMenus(string group)
    {
        return _menuItems.Where(x => x.Group == group).Select(MenuItemToViewModel);
    }

    /// <summary>
    /// 清除所有菜单的Active状态
    /// </summary>
    public void ClearMenuActives(IEnumerable<MenuItemViewModel>? menus)
    {
        if (menus is null)
        {
            return;
        }
        foreach (var menu in menus)
        {
            menu.IsActive = false;
            if (menu.Items != null && menu.Items.Any())
            {
                ClearMenuActives(menu.Items);
            }
        }
    }

    /// <summary>
    /// 根据菜单keys列表，设置Active状态
    /// </summary>
    public void SetMenuActiveByKeys(IEnumerable<MenuItemViewModel>? menus, List<string>? menuKeys)
    {
        if (menuKeys is null)
        {
            return;
        }
        if (menus is null)
        {
            return;
        }
        foreach (var menu in menus)
        {
            if (menuKeys.Contains(menu.Key))
            {
                menu.IsActive = true;
            }
            if (menu.Items != null && menu.Items.Any())
            {
                SetMenuActiveByKeys(menu.Items, menuKeys);
            }
        }
    }

    /// <summary>
    /// 返回所有激活的菜单
    /// </summary>
    public IEnumerable<UserRoleMenuViewModel>? GetActiveMenus(IEnumerable<MenuItemViewModel>? menus)
    {
        if (menus is null)
        {
            return null;
        }
        //递归返回所有选中的菜单
        return menus.Where(menu => menu.IsActive)
                    .Select(menu => new UserRoleMenuViewModel
                    {
                        Id = 0, // 这里可以根据需要设置实际的 Id
                        RoleId = 0, // 这里可以根据需要设置实际的 RoleId
                        MenuKey = menu.Key,
                        MenuName = menu.Text,
                        MenuActions = new ObservableCollection<string>(menu.PageActions ?? Array.Empty<string>())
                    })
                    .Concat(menus.SelectMany(menu => GetActiveMenus(menu.Items) ?? Enumerable.Empty<UserRoleMenuViewModel>()));
    }




    /// <summary>
    /// 根据菜单的key，获取菜单页面权限
    /// </summary>
    /// <returns></returns>
    public List<string>? GetMenuActionsByKey(string? key)
    {
        if (string.IsNullOrEmpty(key))
        {
            return null;
        }
        var menuItem = FindMenuItem(_menuItems, key);
        return menuItem?.PageActions?.ToList();
    }

    public string? GetMenuName(string? menuKey)
    {
        if (string.IsNullOrWhiteSpace(menuKey))
        {
            return null;
        }
        var menuItem = FindMenuItem(_menuItems, menuKey);
        return menuItem != null ? _l[menuItem.LocaleKey] : null;
    }


    /// <summary>
    /// 在菜单集合中查找指定Key的菜单项
    /// </summary>
    /// <param name="menus">菜单集合</param>
    /// <param name="key">菜单项的Key</param>
    /// <returns>找到的菜单项</returns>
    public MenuItem? FindMenuItem(IEnumerable<MenuItem>? menus, string? key)
    {
        if (menus == null || key == null)
        {
            return null;
        }

        foreach (var menu in menus)
        {
            if (menu.Key == key)
            {
                return menu;
            }

            var found = FindMenuItem(menu.Items, key);
            if (found != null)
            {
                return found;
            }
        }

        return null;
    }
}