CellularManagement/src/X1.Infrastructure/Repositories/Base/BaseRepository.cs

using Microsoft.Extensions.Logging;
using CellularManagement.Domain.Repositories;
using CellularManagement.Domain.Repositories.Base;

namespace CellularManagement.Infrastructure.Repositories.Base;

/// <summary>
/// 基础仓储实现类
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
public abstract class BaseRepository<T> : IBaseRepository<T> where T : class
{
    /// <summary>
    /// 命令仓储
    /// </summary>
    protected readonly ICommandRepository<T> CommandRepository;

    /// <summary>
    /// 查询仓储
    /// </summary>
    protected readonly IQueryRepository<T> QueryRepository;

    /// <summary>
    /// 日志记录器
    /// </summary>
    protected readonly ILogger<BaseRepository<T>> Logger;

    /// <summary>
    /// 初始化仓储
    /// </summary>
    protected BaseRepository(
        ICommandRepository<T> commandRepository,
        IQueryRepository<T> queryRepository,
        ILogger<BaseRepository<T>> logger)
    {
        CommandRepository = commandRepository;
        QueryRepository = queryRepository;
        Logger = logger;
    }

    #region ICommandRepository<T> 实现

    /// <summary>
    /// 添加实体
    /// </summary>
    public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationToken = default)
    {
        return await CommandRepository.AddAsync(entity, cancellationToken);
    }

    /// <summary>
    /// 批量添加实体
    /// </summary>
    public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)
    {
        return await CommandRepository.AddRangeAsync(entities, cancellationToken);
    }

    /// <summary>
    /// 更新实体
    /// </summary>
    public virtual void Update(T entity)
    {
        CommandRepository.Update(entity);
    }

    /// <summary>
    /// 批量更新实体
    /// </summary>
    public virtual void UpdateRange(IEnumerable<T> entities)
    {
        CommandRepository.UpdateRange(entities);
    }

    /// <summary>
    /// 删除实体
    /// </summary>
    public virtual void Delete(T entity)
    {
        CommandRepository.Delete(entity);
    }

    /// <summary>
    /// 批量删除实体
    /// </summary>
    public virtual void DeleteRange(IEnumerable<T> entities)
    {
        CommandRepository.DeleteRange(entities);
    }

    /// <summary>
    /// 根据ID删除实体
    /// </summary>
    public virtual async Task<bool> DeleteByIdAsync(string id, CancellationToken cancellationToken = default)
    {
        return await CommandRepository.DeleteByIdAsync(id, cancellationToken);
    }

    /// <summary>
    /// 根据条件删除实体
    /// </summary>
    public virtual async Task<int> DeleteWhereAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
    {
        return await CommandRepository.DeleteWhereAsync(predicate, cancellationToken);
    }

    #endregion

    #region IQueryRepository<T> 实现

    /// <summary>
    /// 根据ID查询实体
    /// </summary>
    public virtual async Task<T?> GetByIdAsync(string id, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.GetByIdAsync(id, include, cancellationToken);
    }

    /// <summary>
    /// 查询所有实体
    /// </summary>
    public virtual async Task<IEnumerable<T>> GetAllAsync(Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.GetAllAsync(include, cancellationToken);
    }

    /// <summary>
    /// 根据条件查询实体
    /// </summary>
    public virtual async Task<IEnumerable<T>> FindAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.FindAsync(predicate, include, cancellationToken);
    }

    /// <summary>
    /// 分页查询实体
    /// </summary>
    public virtual async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.GetPagedAsync(pageNumber, pageSize, include, cancellationToken);
    }

    /// <summary>
    /// 根据条件分页查询实体
    /// </summary>
    public virtual async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, int pageNumber, int pageSize, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.GetPagedAsync(predicate, pageNumber, pageSize, include, cancellationToken);
    }

    /// <summary>
    /// 查询单个实体
    /// </summary>
    public virtual async Task<T?> FirstOrDefaultAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.FirstOrDefaultAsync(predicate, include, cancellationToken);
    }

    /// <summary>
    /// 查询实体是否存在
    /// </summary>
    public virtual async Task<bool> AnyAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.AnyAsync(predicate, include, cancellationToken);
    }

    /// <summary>
    /// 统计符合条件的实体数量
    /// </summary>
    public virtual async Task<int> CountAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.CountAsync(predicate, include, cancellationToken);
    }

    /// <summary>
    /// 执行SQL复制查询
    /// </summary>
    public virtual async Task<IEnumerable<T>> ExecuteSqlQueryAsync(string sql, object[] parameters, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.ExecuteSqlQueryAsync(sql, parameters, cancellationToken);
    }

    /// <summary>
    /// 执行SQL查询并映射到自定义类型
    /// </summary>
    public virtual async Task<IEnumerable<TResult>> ExecuteSqlQueryAsync<TResult>(string sql, object[] parameters, CancellationToken cancellationToken = default)
    {
        return await QueryRepository.ExecuteSqlQueryAsync<TResult>(sql, parameters, cancellationToken);
    }

    #endregion
}