DMS/DMS.Application/Services/Management/MenuManagementService.cs

using DMS.Application.Events;
using DMS.Application.Interfaces;
using DMS.Application.Interfaces.Management;
using DMS.Core.Enums;
using DMS.Core.Models;

namespace DMS.Application.Services.Management;

/// <summary>
/// 菜单管理服务，负责菜单相关的业务逻辑。
/// </summary>
public class MenuManagementService : IMenuManagementService
{
    private readonly IMenuAppService _menuService;
    private readonly IAppDataService _appDataService;
    private readonly IEventService _eventService;

    /// <summary>
    /// 当菜单数据发生变化时触发
    /// </summary>
    public event EventHandler<MenuChangedEventArgs> MenuChanged;

    public MenuManagementService(IMenuAppService menuService, IAppDataService appStorageService, IEventService eventService)
    {
        _menuService = menuService;
        _appDataService = appStorageService;
        _eventService = eventService;
    }

    /// <summary>
    /// 异步获取所有菜单列表。
    /// </summary>
    public async Task<List<MenuBean>> GetAllMenusAsync()
    {
        return await _menuService.GetAllMenusAsync();
    }

    /// <summary>
    /// 异步根据ID获取菜单。
    /// </summary>
    public async Task<MenuBean> GetMenuByIdAsync(int id)
    {
        return await _menuService.GetMenuByIdAsync(id);
    }

    /// <summary>
    /// 异步创建一个新菜单。
    /// </summary>
    public async Task<MenuBean> AddAsync(MenuBean menu)
    {
        var resMenu = await _menuService.AddAsync(menu);
        
        // 创建成功后，将菜单添加到内存中
        if (resMenu is not null)
        {
            if (_appDataService.Menus.TryAdd(resMenu.Id, resMenu))
            {
                MenuBean parentMenu = null;
                if (resMenu.ParentId > 0 && _appDataService.Menus.TryGetValue(resMenu.ParentId.Value, out var parent))
                {
                    parentMenu = parent;
                    parent.Children.Add(resMenu);
                }

                _eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Added, resMenu));
            }
        }
        
        return resMenu;
    }

    /// <summary>
    /// 异步更新一个已存在的菜单。
    /// </summary>
    public async Task<int> UpdateAsync(MenuBean menu)
    {
        var result = await _menuService.UpdateAsync(menu);
        
        // 更新成功后，更新内存中的菜单
        if (result > 0)
        {
            if (_appDataService.Menus.TryGetValue(menu.Id,out var mMenu))
            {
                mMenu.Header = menu.Header;
            }

            _eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Updated, menu));
        }

        return result;
    }

    /// <summary>
    /// 异步删除一个菜单。
    /// </summary>
    public async Task<bool> DeleteAsync(MenuBean menu)
    {
        var result = await _menuService.DeleteAsync(menu);
        
        // 删除成功后，从内存中移除菜单
        if (result && menu != null)
        {
            if (_appDataService.Menus.TryRemove(menu.Id, out var menuData))
            {
                // 从父菜单中移除子菜单
                if (menuData.ParentId > 0 && _appDataService.Menus.TryGetValue(menuData.ParentId.Value, out var parentMenu))
                {
                    parentMenu.Children.Remove(menuData);
                }
                
                _eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Deleted, menuData));
            }
        }

        return result;
    }




    /// <summary>
    /// 构建菜单树。
    /// </summary>
    public void BuildMenuTrees()
    {
        // 创建一个新的临时列表来存储根菜单
        var newRootMenus = new List<MenuBean>();

        // 首先，确保所有菜单项的Children集合是干净的
        foreach (var menu in _appDataService.Menus.Values)
        {
            // 避免循环引用，清空Children集合
            menu.Children.Clear();
        }

        // 遍历所有菜单项，构建树形结构
        foreach (var menu in _appDataService.Menus.Values)
        {
            var parentMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.Id == menu.ParentId);
            // 检查是否有父ID，并且父ID不为0（通常0或null表示根节点）
            if (parentMenu != null && menu.ParentId != 0)
            {
                // 将当前菜单添加到父菜单的Children列表中
                if (!parentMenu.Children.Contains(menu))
                {
                    parentMenu.Children.Add(menu);
                }
            }
            else
            {
                // 如果没有父ID，则这是一个根菜单
                newRootMenus.Add(menu);
            }
        }

        // 在UI线程安全地更新MenuTrees集合
        _appDataService.MenuTrees.Clear();
        foreach (var rootMenu in newRootMenus)
        {
            _appDataService.MenuTrees.TryAdd(rootMenu.Id,rootMenu);
        }
    }

    /// <summary>
    /// 触发菜单变更事件
    /// </summary>
    protected virtual void OnMenuChanged(MenuChangedEventArgs e)
    {
        _eventService.RaiseMenuChanged(this, e);
    }

    /// <summary>
    /// 异步加载所有菜单数据到内存中。
    /// </summary>
    public async Task LoadAllMenusAsync()
    {
        _appDataService.Menus.Clear();
        _appDataService.MenuTrees.Clear();
        var menus = await _menuService.GetAllMenusAsync();
        // 将菜单添加到安全字典
        foreach (var menuBean in menus)
        {
            _appDataService.Menus.TryAdd(menuBean.Id, menuBean);
        }

        BuildMenuTrees();
    }
}