DMS/DMS.Infrastructure/Repositories/MenuRepository.cs

using System.Diagnostics;
using AutoMapper;
using DMS.Core.Enums;
using DMS.Core.Interfaces.Repositories;
using DMS.Core.Models;
using DMS.Infrastructure.Data;
using DMS.Infrastructure.Entities;
using Microsoft.Extensions.Logging;

namespace DMS.Infrastructure.Repositories;

/// <summary>
/// 菜单仓储实现类，负责菜单数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbMenu}"/> 并实现 <see cref="IMenuRepository"/> 接口。
/// </summary>
public class MenuRepository : BaseRepository<DbMenu>, IMenuRepository
{
    private readonly IMapper _mapper;

    /// <summary>
    /// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
    /// </summary>
    /// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
    /// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
    /// <param name="logger">日志记录器实例。</param>
    public MenuRepository(IMapper mapper, SqlSugarDbContext dbContext, ILogger<MenuRepository> logger)
        : base(dbContext, logger)
    {
        _mapper = mapper;
    }

    /// <summary>
    /// 异步获取所有菜单树结构。
    /// </summary>
    /// <returns>包含所有菜单树结构的列表。</returns>
    public async Task<List<MenuBean>> GetMenuTreesAsync()
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        var dbMenuTree = await _dbContext.GetInstance().Queryable<DbMenu>()
                                 .ToTreeAsync(dm => dm.Childrens, dm => dm.ParentId, 0);
        stopwatch.Stop();
        _logger.LogInformation($"获取菜单树耗时：{stopwatch.ElapsedMilliseconds}ms");
        return _mapper.Map<List<MenuBean>>(dbMenuTree);
    }

    /// <summary>
    /// 异步根据ID获取单个菜单。
    /// </summary>
    /// <param name="id">菜单的唯一标识符。</param>
    /// <returns>对应的菜单实体，如果不存在则为null。</returns>
    public async Task<MenuBean> GetByIdAsync(int id)
    {
        var dbMenu = await base.GetByIdAsync(id);
        return _mapper.Map<MenuBean>(dbMenu);
    }

    /// <summary>
    /// 异步获取所有菜单。
    /// </summary>
    /// <returns>包含所有菜单实体的列表。</returns>
    public async Task<List<MenuBean>> GetAllAsync()
    {
        var dbList = await base.GetAllAsync();
        return _mapper.Map<List<MenuBean>>(dbList);
    }

    /// <summary>
    /// 异步添加新菜单。
    /// </summary>
    /// <param name="entity">要添加的菜单实体。</param>
    /// <returns>添加成功后的菜单实体（包含数据库生成的ID等信息）。</returns>
    public async Task<MenuBean> AddAsync(MenuBean entity)
    {
        var dbMenu = await base.AddAsync(_mapper.Map<DbMenu>(entity));
        return _mapper.Map(dbMenu, entity);
    }

    /// <summary>
    /// 异步更新现有菜单。
    /// </summary>
    /// <param name="entity">要更新的菜单实体。</param>
    /// <returns>受影响的行数。</returns>
    public async Task<int> UpdateAsync(MenuBean entity) => await base.UpdateAsync(_mapper.Map<DbMenu>(entity));

    /// <summary>
    /// 异步删除菜单。
    /// </summary>
    /// <param name="entity">要删除的菜单实体。</param>
    /// <returns>受影响的行数。</returns>
    public async Task<int> DeleteAsync(MenuBean entity) => await base.DeleteAsync(new List<DbMenu> { _mapper.Map<DbMenu>(entity) });



    /// <summary>
    /// 异步根据菜单ID删除菜单树（包括子菜单）。
    /// </summary>
    /// <param name="id">要删除菜单树的根菜单ID。</param>
    /// <returns>受影响的行数。</returns>
    public async Task<int> DeleteMenuTreeByIdAsync(int id)
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        int delConut = 0;
        var childList = await _dbContext.GetInstance().Queryable<DbMenu>()
                                .ToChildListAsync(c => c.ParentId, id);
        delConut = await _dbContext.GetInstance().Deleteable<DbMenu>(childList)
                           .ExecuteCommandAsync();
        delConut += await _dbContext.GetInstance().Deleteable<DbMenu>()
                            .Where(m => m.Id == id)
                            .ExecuteCommandAsync();
        stopwatch.Stop();
        _logger.LogInformation($"Delete {typeof(DbMenu)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
        return delConut;
    }

    /// <summary>
    /// 异步根据菜单类型和目标ID删除菜单树。
    /// </summary>
    /// <param name="menuType">菜单类型。</param>
    /// <param name="targetId">目标ID。</param>
    /// <returns>受影响的行数。</returns>
    public async Task<int> DeleteMenuTreeByTargetIdAsync(MenuType menuType, int targetId)
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();
        var menu = await _dbContext.GetInstance().Queryable<DbMenu>().FirstAsync(m => m.MenuType == menuType && m.TargetId == targetId);
        if (menu == null) return 0;
        var childList = await _dbContext.GetInstance().Queryable<DbMenu>()
            .ToChildListAsync(c => c.ParentId, menu.Id);
        var delConut = await _dbContext.GetInstance().Deleteable<DbMenu>(childList)
            .ExecuteCommandAsync();
        stopwatch.Stop();
        _logger.LogInformation($"Delete {typeof(DbMenu)},TargetId={targetId},耗时：{stopwatch.ElapsedMilliseconds}ms");
        return delConut;
    }

    /// <summary>
    /// 异步根据菜单类型和目标ID获取菜单。
    /// </summary>
    /// <param name="menuType">菜单类型。</param>
    /// <param name="targetId">目标ID。</param>
    /// <returns>对应的菜单实体，如果不存在则为null。</returns>
    public async Task<MenuBean> GetMenuByTargetIdAsync(MenuType menuType, int targetId)
    {
        var dbMenu = await _dbContext.GetInstance().Queryable<DbMenu>().FirstAsync(m => m.MenuType == menuType && m.TargetId == targetId);
        return _mapper.Map<MenuBean>(dbMenu);
    }


    public async Task<List<MenuBean>> AddBatchAsync(List<MenuBean> entities)
    {
        var dbEntities = _mapper.Map<List<DbMenu>>(entities);
        var addedEntities = await base.AddBatchAsync(dbEntities);
        return _mapper.Map<List<MenuBean>>(addedEntities);
    }

    /// <summary>
    /// 异步根据实体列表批量删除菜单。
    /// </summary>
    /// <param name="entities">要删除的菜单实体列表。</param>
    /// <returns>受影响的行数。</returns>
    public async Task<int> DeleteAsync(List<MenuBean> entities)
    {
        var dbEntities = _mapper.Map<List<DbMenu>>(entities);
        return await base.DeleteAsync(dbEntities);
    }
}