root
/
CellularManagement
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

修复仓储层接口和实现，优化查询和命令分离

feature/x1-owen-debug
root 4 weeks ago
parent
0960773766
commit
3ce31c4d05
10 changed files with 134 additions and 103 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 23
      src/X1.Domain/Repositories/Base/IBaseRepository.cs
  2. 23
      src/X1.Domain/Repositories/Base/IQueryRepository.cs
  3. 36
      src/X1.Infrastructure/Repositories/Base/BaseRepository.cs
  4. 63
      src/X1.Infrastructure/Repositories/CQRS/QueryRepository.cs
  5. 12
      src/X1.Infrastructure/Repositories/Device/CellularDeviceRepository.cs
  6. 14
      src/X1.Infrastructure/Repositories/Device/ProtocolVersionRepository.cs
  7. 18
      src/X1.Infrastructure/Repositories/Identity/LoginLogRepository.cs
  8. 18
      src/X1.Infrastructure/Repositories/Identity/PermissionRepository.cs
  9. 18
      src/X1.Infrastructure/Repositories/Identity/RolePermissionRepository.cs
  10. 12
      src/X1.Infrastructure/Repositories/Identity/UserRoleRepository.cs

23
src/X1.Domain/Repositories/Base/IBaseRepository.cs
View File

@ -110,29 +110,32 @@ namespace CellularManagement.Domain.Repositories.Base
/// 根据ID查询单个实体 /// 根据ID查询单个实体
/// </summary> /// </summary>
/// <param name="id">要查询的实体ID</param> /// <param name="id">要查询的实体ID</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>查询到的实体，如果不存在则返回 null</returns> /// <returns>查询到的实体，如果不存在则返回 null</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 使用主键进行查询，性能最优 /// 使用主键进行查询，性能最优
/// </remarks> /// </remarks>
Task<T?> GetByIdAsync(string id, CancellationToken cancellationToken = default); Task<T?> GetByIdAsync(string id, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询所有实体 /// 查询所有实体
/// </summary> /// </summary>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>所有实体的集合</returns> /// <returns>所有实体的集合</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 注意：对于大数据量的表，建议使用分页查询 /// 注意：对于大数据量的表，建议使用分页查询
/// </remarks> /// </remarks>
Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default); Task<IEnumerable<T>> GetAllAsync(Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 根据条件查询实体 /// 根据条件查询实体
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>符合条件的实体集合</returns> /// <returns>符合条件的实体集合</returns>
/// <remarks> /// <remarks>
@ -140,13 +143,14 @@ namespace CellularManagement.Domain.Repositories.Base
/// 使用 LINQ 表达式树构建查询条件 /// 使用 LINQ 表达式树构建查询条件
/// 条件查询会被转换为 SQL 语句在数据库端执行 /// 条件查询会被转换为 SQL 语句在数据库端执行
/// </remarks> /// </remarks>
Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 分页查询实体 /// 分页查询实体
/// </summary> /// </summary>
/// <param name="pageNumber">页码，从1开始</param> /// <param name="pageNumber">页码，从1开始</param>
/// <param name="pageSize">每页记录数</param> /// <param name="pageSize">每页记录数</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>分页查询结果，包含总记录数和当前页数据</returns> /// <returns>分页查询结果，包含总记录数和当前页数据</returns>
/// <remarks> /// <remarks>
@ -154,7 +158,7 @@ namespace CellularManagement.Domain.Repositories.Base
/// 分页查询可以有效减少数据传输量，提高性能 /// 分页查询可以有效减少数据传输量，提高性能
/// 建议在查询大数据量时使用 /// 建议在查询大数据量时使用
/// </remarks> /// </remarks>
Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, CancellationToken cancellationToken = default); Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 根据条件分页查询实体 /// 根据条件分页查询实体
@ -162,6 +166,7 @@ namespace CellularManagement.Domain.Repositories.Base
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="pageNumber">页码，从1开始</param> /// <param name="pageNumber">页码，从1开始</param>
/// <param name="pageSize">每页记录数</param> /// <param name="pageSize">每页记录数</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>分页查询结果，包含总记录数和当前页数据</returns> /// <returns>分页查询结果，包含总记录数和当前页数据</returns>
/// <remarks> /// <remarks>
@ -172,12 +177,14 @@ namespace CellularManagement.Domain.Repositories.Base
Expression<Func<T, bool>> predicate, Expression<Func<T, bool>> predicate,
int pageNumber, int pageNumber,
int pageSize, int pageSize,
Func<IQueryable<T>, IQueryable<T>>? include = null,
CancellationToken cancellationToken = default); CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询单个实体 /// 查询单个实体
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>查询到的实体，如果不存在则返回 null</returns> /// <returns>查询到的实体，如果不存在则返回 null</returns>
/// <remarks> /// <remarks>
@ -185,31 +192,33 @@ namespace CellularManagement.Domain.Repositories.Base
/// 如果查询结果包含多个实体，将返回第一个 /// 如果查询结果包含多个实体，将返回第一个
/// 建议在确定只会返回一个结果时使用 /// 建议在确定只会返回一个结果时使用
/// </remarks> /// </remarks>
Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询实体是否存在 /// 查询实体是否存在
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>是否存在符合条件的实体</returns> /// <returns>是否存在符合条件的实体</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 使用 EXISTS 语句在数据库端执行，性能优于获取完整实体 /// 使用 EXISTS 语句在数据库端执行，性能优于获取完整实体
/// </remarks> /// </remarks>
Task<bool> AnyAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<bool> AnyAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 统计符合条件的实体数量 /// 统计符合条件的实体数量
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>符合条件的实体数量</returns> /// <returns>符合条件的实体数量</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 使用 COUNT 语句在数据库端执行，性能优于获取完整实体 /// 使用 COUNT 语句在数据库端执行，性能优于获取完整实体
/// </remarks> /// </remarks>
Task<int> CountAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<int> CountAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 执行SQL复制查询 /// 执行SQL复制查询

23
src/X1.Domain/Repositories/Base/IQueryRepository.cs
View File

@ -21,29 +21,32 @@ public interface IQueryRepository<T> where T : class
/// 根据ID查询单个实体 /// 根据ID查询单个实体
/// </summary> /// </summary>
/// <param name="id">要查询的实体ID</param> /// <param name="id">要查询的实体ID</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>查询到的实体，如果不存在则返回 null</returns> /// <returns>查询到的实体，如果不存在则返回 null</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 使用主键进行查询，性能最优 /// 使用主键进行查询，性能最优
/// </remarks> /// </remarks>
Task<T?> GetByIdAsync(string id, CancellationToken cancellationToken = default); Task<T?> GetByIdAsync(string id, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询所有实体 /// 查询所有实体
/// </summary> /// </summary>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>所有实体的集合</returns> /// <returns>所有实体的集合</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 注意：对于大数据量的表，建议使用分页查询 /// 注意：对于大数据量的表，建议使用分页查询
/// </remarks> /// </remarks>
Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default); Task<IEnumerable<T>> GetAllAsync(Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 根据条件查询实体 /// 根据条件查询实体
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>符合条件的实体集合</returns> /// <returns>符合条件的实体集合</returns>
/// <remarks> /// <remarks>
@ -51,13 +54,14 @@ public interface IQueryRepository<T> where T : class
/// 使用 LINQ 表达式树构建查询条件 /// 使用 LINQ 表达式树构建查询条件
/// 条件查询会被转换为 SQL 语句在数据库端执行 /// 条件查询会被转换为 SQL 语句在数据库端执行
/// </remarks> /// </remarks>
Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 分页查询实体 /// 分页查询实体
/// </summary> /// </summary>
/// <param name="pageNumber">页码，从1开始</param> /// <param name="pageNumber">页码，从1开始</param>
/// <param name="pageSize">每页记录数</param> /// <param name="pageSize">每页记录数</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>分页查询结果，包含总记录数和当前页数据</returns> /// <returns>分页查询结果，包含总记录数和当前页数据</returns>
/// <remarks> /// <remarks>
@ -65,7 +69,7 @@ public interface IQueryRepository<T> where T : class
/// 分页查询可以有效减少数据传输量，提高性能 /// 分页查询可以有效减少数据传输量，提高性能
/// 建议在查询大数据量时使用 /// 建议在查询大数据量时使用
/// </remarks> /// </remarks>
Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, CancellationToken cancellationToken = default); Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 根据条件分页查询实体 /// 根据条件分页查询实体
@ -73,6 +77,7 @@ public interface IQueryRepository<T> where T : class
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="pageNumber">页码，从1开始</param> /// <param name="pageNumber">页码，从1开始</param>
/// <param name="pageSize">每页记录数</param> /// <param name="pageSize">每页记录数</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>分页查询结果，包含总记录数和当前页数据</returns> /// <returns>分页查询结果，包含总记录数和当前页数据</returns>
/// <remarks> /// <remarks>
@ -83,12 +88,14 @@ public interface IQueryRepository<T> where T : class
Expression<Func<T, bool>> predicate, Expression<Func<T, bool>> predicate,
int pageNumber, int pageNumber,
int pageSize, int pageSize,
Func<IQueryable<T>, IQueryable<T>>? include = null,
CancellationToken cancellationToken = default); CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询单个实体 /// 查询单个实体
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>查询到的实体，如果不存在则返回 null</returns> /// <returns>查询到的实体，如果不存在则返回 null</returns>
/// <remarks> /// <remarks>
@ -96,31 +103,33 @@ public interface IQueryRepository<T> where T : class
/// 如果查询结果包含多个实体，将返回第一个 /// 如果查询结果包含多个实体，将返回第一个
/// 建议在确定只会返回一个结果时使用 /// 建议在确定只会返回一个结果时使用
/// </remarks> /// </remarks>
Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 查询实体是否存在 /// 查询实体是否存在
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>是否存在符合条件的实体</returns> /// <returns>是否存在符合条件的实体</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 使用 EXISTS 语句在数据库端执行，性能优于获取完整实体 /// 使用 EXISTS 语句在数据库端执行，性能优于获取完整实体
/// </remarks> /// </remarks>
Task<bool> AnyAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<bool> AnyAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 统计符合条件的实体数量 /// 统计符合条件的实体数量
/// </summary> /// </summary>
/// <param name="predicate">查询条件表达式</param> /// <param name="predicate">查询条件表达式</param>
/// <param name="include">查询条件表达式</param>
/// <param name="cancellationToken">取消令牌，用于取消异步操作</param> /// <param name="cancellationToken">取消令牌，用于取消异步操作</param>
/// <returns>符合条件的实体数量</returns> /// <returns>符合条件的实体数量</returns>
/// <remarks> /// <remarks>
/// 这是一个异步操作，因为需要等待数据库的查询操作完成 /// 这是一个异步操作，因为需要等待数据库的查询操作完成
/// 使用 COUNT 语句在数据库端执行，性能优于获取完整实体 /// 使用 COUNT 语句在数据库端执行，性能优于获取完整实体
/// </remarks> /// </remarks>
Task<int> CountAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default); Task<int> CountAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default);
/// <summary> /// <summary>
/// 执行SQL复制查询 /// 执行SQL复制查询

36
src/X1.Infrastructure/Repositories/Base/BaseRepository.cs
View File

@ -111,69 +111,65 @@ public abstract class BaseRepository<T> : IBaseRepository<T> where T : class
/// <summary> /// <summary>
/// 根据ID查询实体 /// 根据ID查询实体
/// </summary> /// </summary>
public virtual async Task<T?> GetByIdAsync(string id, CancellationToken cancellationToken = default) public virtual async Task<T?> GetByIdAsync(string id, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.GetByIdAsync(id, cancellationToken); return await QueryRepository.GetByIdAsync(id, include, cancellationToken);
} }
/// <summary> /// <summary>
/// 查询所有实体 /// 查询所有实体
/// </summary> /// </summary>
public virtual async Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default) public virtual async Task<IEnumerable<T>> GetAllAsync(Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.GetAllAsync(cancellationToken); return await QueryRepository.GetAllAsync(include, cancellationToken);
} }
/// <summary> /// <summary>
/// 根据条件查询实体 /// 根据条件查询实体
/// </summary> /// </summary>
public virtual async Task<IEnumerable<T>> FindAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) 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, cancellationToken); return await QueryRepository.FindAsync(predicate, include, cancellationToken);
} }
/// <summary> /// <summary>
/// 分页查询实体 /// 分页查询实体
/// </summary> /// </summary>
public virtual async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, CancellationToken cancellationToken = default) 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, cancellationToken); return await QueryRepository.GetPagedAsync(pageNumber, pageSize, include, cancellationToken);
} }
/// <summary> /// <summary>
/// 根据条件分页查询实体 /// 根据条件分页查询实体
/// </summary> /// </summary>
public virtual async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync( 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)
System.Linq.Expressions.Expression<Func<T, bool>> predicate,
int pageNumber,
int pageSize,
CancellationToken cancellationToken = default)
{ {
return await QueryRepository.GetPagedAsync(predicate, pageNumber, pageSize, cancellationToken); return await QueryRepository.GetPagedAsync(predicate, pageNumber, pageSize, include, cancellationToken);
} }
/// <summary> /// <summary>
/// 查询单个实体 /// 查询单个实体
/// </summary> /// </summary>
public virtual async Task<T?> FirstOrDefaultAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) 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, cancellationToken); return await QueryRepository.FirstOrDefaultAsync(predicate, include, cancellationToken);
} }
/// <summary> /// <summary>
/// 查询实体是否存在 /// 查询实体是否存在
/// </summary> /// </summary>
public virtual async Task<bool> AnyAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) 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, cancellationToken); return await QueryRepository.AnyAsync(predicate, include, cancellationToken);
} }
/// <summary> /// <summary>
/// 统计符合条件的实体数量 /// 统计符合条件的实体数量
/// </summary> /// </summary>
public virtual async Task<int> CountAsync(System.Linq.Expressions.Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) 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, cancellationToken); return await QueryRepository.CountAsync(predicate, include, cancellationToken);
} }
/// <summary> /// <summary>

63
src/X1.Infrastructure/Repositories/CQRS/QueryRepository.cs
View File

@ -44,82 +44,99 @@ public class QueryRepository<T> : IQueryRepository<T> where T : class
/// <summary> /// <summary>
/// 根据ID查询单个实体 /// 根据ID查询单个实体
/// </summary> /// </summary>
public async Task<T?> GetByIdAsync(string id, CancellationToken cancellationToken = default) public async Task<T?> GetByIdAsync(string id, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await _dbSet.FindAsync(new object[] { id }, cancellationToken); IQueryable<T> query = _dbSet;
if (include != null)
query = include(query);
return await query.FirstOrDefaultAsync(e => EF.Property<string>(e, "Id") == id, cancellationToken);
} }
/// <summary> /// <summary>
/// 查询所有实体 /// 查询所有实体
/// </summary> /// </summary>
public async Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default) public async Task<IEnumerable<T>> GetAllAsync(Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await _dbSet.ToListAsync(cancellationToken); IQueryable<T> query = _dbSet;
if (include != null)
query = include(query);
return await query.ToListAsync(cancellationToken);
} }
/// <summary> /// <summary>
/// 根据条件查询实体 /// 根据条件查询实体
/// </summary> /// </summary>
public async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) public async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await _dbSet.Where(predicate).ToListAsync(cancellationToken); IQueryable<T> query = _dbSet.Where(predicate);
if (include != null)
query = include(query);
return await query.ToListAsync(cancellationToken);
} }
/// <summary> /// <summary>
/// 分页查询实体 /// 分页查询实体
/// </summary> /// </summary>
public async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, CancellationToken cancellationToken = default) public async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(int pageNumber, int pageSize, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
var totalCount = await _dbSet.CountAsync(cancellationToken); IQueryable<T> query = _dbSet;
var items = await _dbSet if (include != null)
query = include(query);
var totalCount = await query.CountAsync(cancellationToken);
var items = await query
.Skip((pageNumber - 1) * pageSize) .Skip((pageNumber - 1) * pageSize)
.Take(pageSize) .Take(pageSize)
.ToListAsync(cancellationToken); .ToListAsync(cancellationToken);
return (totalCount, items); return (totalCount, items);
} }
/// <summary> /// <summary>
/// 根据条件分页查询实体 /// 根据条件分页查询实体
/// </summary> /// </summary>
public async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync( public async Task<(int TotalCount, IEnumerable<T> Items)> GetPagedAsync(Expression<Func<T, bool>> predicate, int pageNumber, int pageSize, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
Expression<Func<T, bool>> predicate,
int pageNumber,
int pageSize,
CancellationToken cancellationToken = default)
{ {
var query = _dbSet.Where(predicate); IQueryable<T> query = _dbSet.Where(predicate);
if (include != null)
query = include(query);
var totalCount = await query.CountAsync(cancellationToken); var totalCount = await query.CountAsync(cancellationToken);
var items = await query var items = await query
.Skip((pageNumber - 1) * pageSize) .Skip((pageNumber - 1) * pageSize)
.Take(pageSize) .Take(pageSize)
.ToListAsync(cancellationToken); .ToListAsync(cancellationToken);
return (totalCount, items); return (totalCount, items);
} }
/// <summary> /// <summary>
/// 查询单个实体 /// 查询单个实体
/// </summary> /// </summary>
public async Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) public async Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await _dbSet.FirstOrDefaultAsync(predicate, cancellationToken); IQueryable<T> query = _dbSet.Where(predicate);
if (include != null)
query = include(query);
return await query.FirstOrDefaultAsync(cancellationToken);
} }
/// <summary> /// <summary>
/// 查询实体是否存在 /// 查询实体是否存在
/// </summary> /// </summary>
public async Task<bool> AnyAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) public async Task<bool> AnyAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await _dbSet.AnyAsync(predicate, cancellationToken); IQueryable<T> query = _dbSet.Where(predicate);
if (include != null)
query = include(query);
return await query.AnyAsync(cancellationToken);
} }
/// <summary> /// <summary>
/// 统计符合条件的实体数量 /// 统计符合条件的实体数量
/// </summary> /// </summary>
public async Task<int> CountAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default) public async Task<int> CountAsync(Expression<Func<T, bool>> predicate, Func<IQueryable<T>, IQueryable<T>>? include = null, CancellationToken cancellationToken = default)
{ {
return await _dbSet.CountAsync(predicate, cancellationToken); IQueryable<T> query = _dbSet.Where(predicate);
if (include != null)
query = include(query);
return await query.CountAsync(cancellationToken);
} }
/// <summary> /// <summary>

12
src/X1.Infrastructure/Repositories/Device/CellularDeviceRepository.cs
View File

@ -64,7 +64,7 @@ public class CellularDeviceRepository : BaseRepository<CellularDevice>, ICellula
/// </summary> /// </summary>
public async Task<IList<CellularDevice>> GetAllDevicesAsync(CancellationToken cancellationToken = default) public async Task<IList<CellularDevice>> GetAllDevicesAsync(CancellationToken cancellationToken = default)
{ {
var devices = await QueryRepository.GetAllAsync(cancellationToken); var devices = await QueryRepository.GetAllAsync(cancellationToken: cancellationToken);
return devices.ToList(); return devices.ToList();
} }
@ -73,7 +73,7 @@ public class CellularDeviceRepository : BaseRepository<CellularDevice>, ICellula
/// </summary> /// </summary>
public async Task<CellularDevice?> GetDeviceByIdAsync(string id, CancellationToken cancellationToken = default) public async Task<CellularDevice?> GetDeviceByIdAsync(string id, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.GetByIdAsync(id, cancellationToken); return await QueryRepository.GetByIdAsync(id, cancellationToken: cancellationToken);
} }
@ -85,7 +85,7 @@ public class CellularDeviceRepository : BaseRepository<CellularDevice>, ICellula
/// </summary> /// </summary>
public async Task<CellularDevice?> GetDeviceBySerialNumberAsync(string serialNumber, CancellationToken cancellationToken = default) public async Task<CellularDevice?> GetDeviceBySerialNumberAsync(string serialNumber, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.FirstOrDefaultAsync(d => d.SerialNumber == serialNumber, cancellationToken); return await QueryRepository.FirstOrDefaultAsync(d => d.SerialNumber == serialNumber, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -95,7 +95,7 @@ public class CellularDeviceRepository : BaseRepository<CellularDevice>, ICellula
string? keyword, string? keyword,
CancellationToken cancellationToken = default) CancellationToken cancellationToken = default)
{ {
var query = await QueryRepository.FindAsync(d => true, cancellationToken); var query = await QueryRepository.FindAsync(d => true, cancellationToken: cancellationToken);
if (!string.IsNullOrWhiteSpace(keyword)) if (!string.IsNullOrWhiteSpace(keyword))
{ {
@ -118,7 +118,7 @@ public class CellularDeviceRepository : BaseRepository<CellularDevice>, ICellula
/// </summary> /// </summary>
public async Task<bool> ExistsAsync(string id, CancellationToken cancellationToken = default) public async Task<bool> ExistsAsync(string id, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.AnyAsync(d => d.Id == id, cancellationToken); return await QueryRepository.AnyAsync(d => d.Id == id, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -126,6 +126,6 @@ public class CellularDeviceRepository : BaseRepository<CellularDevice>, ICellula
/// </summary> /// </summary>
public async Task<bool> SerialNumberExistsAsync(string serialNumber, CancellationToken cancellationToken = default) public async Task<bool> SerialNumberExistsAsync(string serialNumber, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.AnyAsync(d => d.SerialNumber == serialNumber, cancellationToken); return await QueryRepository.AnyAsync(d => d.SerialNumber == serialNumber, cancellationToken: cancellationToken);
} }
} }

14
src/X1.Infrastructure/Repositories/Device/ProtocolVersionRepository.cs
View File

@ -62,7 +62,7 @@ public class ProtocolVersionRepository : BaseRepository<ProtocolVersion>, IProto
/// </summary> /// </summary>
public async Task<IList<ProtocolVersion>> GetAllProtocolVersionsAsync(CancellationToken cancellationToken = default) public async Task<IList<ProtocolVersion>> GetAllProtocolVersionsAsync(CancellationToken cancellationToken = default)
{ {
var protocolVersions = await QueryRepository.GetAllAsync(cancellationToken); var protocolVersions = await QueryRepository.GetAllAsync(cancellationToken:cancellationToken);
return protocolVersions.ToList(); return protocolVersions.ToList();
} }
@ -71,7 +71,7 @@ public class ProtocolVersionRepository : BaseRepository<ProtocolVersion>, IProto
/// </summary> /// </summary>
public async Task<ProtocolVersion?> GetProtocolVersionByIdAsync(string id, CancellationToken cancellationToken = default) public async Task<ProtocolVersion?> GetProtocolVersionByIdAsync(string id, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.GetByIdAsync(id, cancellationToken); return await QueryRepository.GetByIdAsync(id, cancellationToken:cancellationToken);
} }
/// <summary> /// <summary>
@ -79,7 +79,7 @@ public class ProtocolVersionRepository : BaseRepository<ProtocolVersion>, IProto
/// </summary> /// </summary>
public async Task<ProtocolVersion?> GetProtocolVersionByVersionAsync(string version, CancellationToken cancellationToken = default) public async Task<ProtocolVersion?> GetProtocolVersionByVersionAsync(string version, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.FirstOrDefaultAsync(pv => pv.Version == version, cancellationToken); return await QueryRepository.FirstOrDefaultAsync(pv => pv.Version == version, cancellationToken:cancellationToken);
} }
/// <summary> /// <summary>
@ -89,7 +89,7 @@ public class ProtocolVersionRepository : BaseRepository<ProtocolVersion>, IProto
string? keyword, string? keyword,
CancellationToken cancellationToken = default) CancellationToken cancellationToken = default)
{ {
var query = await QueryRepository.FindAsync(pv => true, cancellationToken); var query = await QueryRepository.FindAsync(pv => true, cancellationToken:cancellationToken);
if (!string.IsNullOrWhiteSpace(keyword)) if (!string.IsNullOrWhiteSpace(keyword))
{ {
@ -108,7 +108,7 @@ public class ProtocolVersionRepository : BaseRepository<ProtocolVersion>, IProto
/// </summary> /// </summary>
public async Task<bool> ExistsAsync(string id, CancellationToken cancellationToken = default) public async Task<bool> ExistsAsync(string id, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.AnyAsync(pv => pv.Id == id, cancellationToken); return await QueryRepository.AnyAsync(pv => pv.Id == id, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -116,7 +116,7 @@ public class ProtocolVersionRepository : BaseRepository<ProtocolVersion>, IProto
/// </summary> /// </summary>
public async Task<bool> VersionExistsAsync(string version, CancellationToken cancellationToken = default) public async Task<bool> VersionExistsAsync(string version, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.AnyAsync(pv => pv.Version == version, cancellationToken); return await QueryRepository.AnyAsync(pv => pv.Version == version, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -124,7 +124,7 @@ public class ProtocolVersionRepository : BaseRepository<ProtocolVersion>, IProto
/// </summary> /// </summary>
public async Task<IList<ProtocolVersion>> GetEnabledProtocolVersionsAsync(CancellationToken cancellationToken = default) public async Task<IList<ProtocolVersion>> GetEnabledProtocolVersionsAsync(CancellationToken cancellationToken = default)
{ {
var protocolVersions = await QueryRepository.FindAsync(pv => pv.IsEnabled, cancellationToken); var protocolVersions = await QueryRepository.FindAsync(pv => pv.IsEnabled, cancellationToken: cancellationToken);
return protocolVersions.ToList(); return protocolVersions.ToList();
} }
} }

18
src/X1.Infrastructure/Repositories/Identity/LoginLogRepository.cs
View File

@ -55,7 +55,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
{ {
var logs = await QueryRepository.FindAsync( var logs = await QueryRepository.FindAsync(
log => log.UserId == userId, log => log.UserId == userId,
cancellationToken); cancellationToken: cancellationToken);
return logs.OrderByDescending(l => l.LoginTime) return logs.OrderByDescending(l => l.LoginTime)
.Take(count) .Take(count)
@ -72,7 +72,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
log => log.IpAddress == ipAddress && log => log.IpAddress == ipAddress &&
!log.IsSuccess && !log.IsSuccess &&
log.LoginTime >= windowStart, log.LoginTime >= windowStart,
cancellationToken); cancellationToken: cancellationToken);
return failedAttempts >= MaxLoginAttempts; return failedAttempts >= MaxLoginAttempts;
} }
@ -87,7 +87,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
log => log.IpAddress == ipAddress && log => log.IpAddress == ipAddress &&
!log.IsSuccess && !log.IsSuccess &&
log.LoginTime >= windowStart, log.LoginTime >= windowStart,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -114,7 +114,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
{ {
return await QueryRepository.FindAsync( return await QueryRepository.FindAsync(
log => log.UserId == userId, log => log.UserId == userId,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -124,7 +124,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
{ {
return await QueryRepository.FindAsync( return await QueryRepository.FindAsync(
log => true, log => true,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -134,7 +134,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
{ {
return await QueryRepository.FindAsync( return await QueryRepository.FindAsync(
log => !log.IsSuccess && log.CreatedAt >= startTime && log.CreatedAt <= endTime, log => !log.IsSuccess && log.CreatedAt >= startTime && log.CreatedAt <= endTime,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -144,7 +144,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
{ {
return await QueryRepository.FindAsync( return await QueryRepository.FindAsync(
log => log.IpAddress == ipAddress, log => log.IpAddress == ipAddress,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -154,7 +154,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
{ {
var oldLogs = await QueryRepository.FindAsync( var oldLogs = await QueryRepository.FindAsync(
log => log.CreatedAt < before, log => log.CreatedAt < before,
cancellationToken); cancellationToken: cancellationToken);
if (oldLogs.Any()) if (oldLogs.Any())
{ {
@ -172,7 +172,7 @@ public class LoginLogRepository : BaseRepository<LoginLog>, ILoginLogRepository
{ {
var logs = await QueryRepository.FindAsync( var logs = await QueryRepository.FindAsync(
log => log.CreatedAt >= startTime && log.CreatedAt <= endTime, log => log.CreatedAt >= startTime && log.CreatedAt <= endTime,
cancellationToken); cancellationToken: cancellationToken);
return new LoginStatistics return new LoginStatistics
{ {

18
src/X1.Infrastructure/Repositories/Identity/PermissionRepository.cs
View File

@ -53,7 +53,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task DeletePermissionAsync(string permissionId, CancellationToken cancellationToken = default) public async Task DeletePermissionAsync(string permissionId, CancellationToken cancellationToken = default)
{ {
var permission = await QueryRepository.GetByIdAsync(permissionId, cancellationToken); var permission = await QueryRepository.GetByIdAsync(permissionId, cancellationToken: cancellationToken);
if (permission != null) if (permission != null)
{ {
CommandRepository.Delete(permission); CommandRepository.Delete(permission);
@ -81,7 +81,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task DeletePermissionsAsync(IEnumerable<string> permissionIds, CancellationToken cancellationToken = default) public async Task DeletePermissionsAsync(IEnumerable<string> permissionIds, CancellationToken cancellationToken = default)
{ {
var permissions = await QueryRepository.FindAsync(p => permissionIds.Contains(p.Id), cancellationToken); var permissions = await QueryRepository.FindAsync(p => permissionIds.Contains(p.Id), cancellationToken: cancellationToken);
if (permissions.Any()) if (permissions.Any())
{ {
CommandRepository.DeleteRange(permissions); CommandRepository.DeleteRange(permissions);
@ -97,7 +97,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task<IEnumerable<Permission>> GetAllPermissionsAsync(CancellationToken cancellationToken = default) public async Task<IEnumerable<Permission>> GetAllPermissionsAsync(CancellationToken cancellationToken = default)
{ {
return await QueryRepository.GetAllAsync(cancellationToken); return await QueryRepository.GetAllAsync(cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -105,7 +105,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task<Permission?> GetPermissionByIdAsync(string permissionId, CancellationToken cancellationToken = default) public async Task<Permission?> GetPermissionByIdAsync(string permissionId, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.GetByIdAsync(permissionId, cancellationToken); return await QueryRepository.GetByIdAsync(permissionId, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -113,7 +113,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task<Permission?> GetPermissionByNameAsync(string name, CancellationToken cancellationToken = default) public async Task<Permission?> GetPermissionByNameAsync(string name, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.FirstOrDefaultAsync(p => p.Name == name, cancellationToken); return await QueryRepository.FirstOrDefaultAsync(p => p.Name == name, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -121,7 +121,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task<IEnumerable<Permission>> GetPermissionsByTypeAsync(string type, CancellationToken cancellationToken = default) public async Task<IEnumerable<Permission>> GetPermissionsByTypeAsync(string type, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.FindAsync(p => p.Type == type, cancellationToken); return await QueryRepository.FindAsync(p => p.Type == type, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -129,7 +129,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task<bool> ExistsAsync(string permissionId, CancellationToken cancellationToken = default) public async Task<bool> ExistsAsync(string permissionId, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.AnyAsync(p => p.Id == permissionId, cancellationToken); return await QueryRepository.AnyAsync(p => p.Id == permissionId, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -137,7 +137,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task<bool> NameExistsAsync(string name, CancellationToken cancellationToken = default) public async Task<bool> NameExistsAsync(string name, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.AnyAsync(p => p.Name == name, cancellationToken); return await QueryRepository.AnyAsync(p => p.Name == name, cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -145,7 +145,7 @@ public class PermissionRepository : BaseRepository<Permission>, IPermissionRepos
/// </summary> /// </summary>
public async Task<Permission?> GetByNameAsync(string name, CancellationToken cancellationToken = default) public async Task<Permission?> GetByNameAsync(string name, CancellationToken cancellationToken = default)
{ {
return await QueryRepository.FirstOrDefaultAsync(p => p.Name == name, cancellationToken); return await QueryRepository.FirstOrDefaultAsync(p => p.Name == name, cancellationToken: cancellationToken);
} }
#endregion #endregion

18
src/X1.Infrastructure/Repositories/Identity/RolePermissionRepository.cs
View File

@ -45,10 +45,10 @@ public class RolePermissionRepository : BaseRepository<RolePermission>, IRolePer
{ {
var rolePermissions = await QueryRepository.FindAsync( var rolePermissions = await QueryRepository.FindAsync(
rp => rp.RoleId == roleId, rp => rp.RoleId == roleId,
cancellationToken); cancellationToken: cancellationToken);
var permissionIds = rolePermissions.Select(rp => rp.PermissionId); var permissionIds = rolePermissions.Select(rp => rp.PermissionId);
return await _permissionQueryRepository.FindAsync(p => permissionIds.Contains(p.Id), cancellationToken); return await _permissionQueryRepository.FindAsync(p => permissionIds.Contains(p.Id), cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -58,10 +58,10 @@ public class RolePermissionRepository : BaseRepository<RolePermission>, IRolePer
{ {
var rolePermissions = await QueryRepository.FindAsync( var rolePermissions = await QueryRepository.FindAsync(
rp => rp.PermissionId == permissionId, rp => rp.PermissionId == permissionId,
cancellationToken); cancellationToken: cancellationToken);
var roleIds = rolePermissions.Select(rp => rp.RoleId); var roleIds = rolePermissions.Select(rp => rp.RoleId);
return await _roleQueryRepository.FindAsync(r => roleIds.Contains(r.Id), cancellationToken); return await _roleQueryRepository.FindAsync(r => roleIds.Contains(r.Id), cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -71,7 +71,7 @@ public class RolePermissionRepository : BaseRepository<RolePermission>, IRolePer
{ {
return await QueryRepository.AnyAsync( return await QueryRepository.AnyAsync(
rp => rp.RoleId == roleId && rp.PermissionId == permissionId, rp => rp.RoleId == roleId && rp.PermissionId == permissionId,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -92,7 +92,7 @@ public class RolePermissionRepository : BaseRepository<RolePermission>, IRolePer
{ {
var rolePermissions = await QueryRepository.FindAsync( var rolePermissions = await QueryRepository.FindAsync(
rp => rp.RoleId == roleId && permissionIds.Contains(rp.PermissionId), rp => rp.RoleId == roleId && permissionIds.Contains(rp.PermissionId),
cancellationToken); cancellationToken: cancellationToken);
if (rolePermissions.Any()) if (rolePermissions.Any())
{ {
@ -110,7 +110,7 @@ public class RolePermissionRepository : BaseRepository<RolePermission>, IRolePer
{ {
return await QueryRepository.FindAsync( return await QueryRepository.FindAsync(
rp => rp.RoleId == roleId, rp => rp.RoleId == roleId,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -120,7 +120,7 @@ public class RolePermissionRepository : BaseRepository<RolePermission>, IRolePer
{ {
var rolePermissions = await QueryRepository.FindAsync( var rolePermissions = await QueryRepository.FindAsync(
rp => rp.RoleId == roleId && permissionIds.Contains(rp.PermissionId), rp => rp.RoleId == roleId && permissionIds.Contains(rp.PermissionId),
cancellationToken); cancellationToken: cancellationToken);
return rolePermissions.Count() == permissionIds.Count(); return rolePermissions.Count() == permissionIds.Count();
} }
@ -132,7 +132,7 @@ public class RolePermissionRepository : BaseRepository<RolePermission>, IRolePer
{ {
var rolePermissions = await QueryRepository.FindAsync( var rolePermissions = await QueryRepository.FindAsync(
rp => rp.RoleId == roleId && permissionIds.Contains(rp.PermissionId), rp => rp.RoleId == roleId && permissionIds.Contains(rp.PermissionId),
cancellationToken); cancellationToken: cancellationToken);
var existingPermissionIds = rolePermissions.Select(rp => rp.PermissionId); var existingPermissionIds = rolePermissions.Select(rp => rp.PermissionId);
return permissionIds.Except(existingPermissionIds); return permissionIds.Except(existingPermissionIds);

12
src/X1.Infrastructure/Repositories/Identity/UserRoleRepository.cs
View File

@ -45,7 +45,7 @@ public class UserRoleRepository : BaseRepository<UserRole>, IUserRoleRepository
{ {
var userRole = await QueryRepository.FirstOrDefaultAsync( var userRole = await QueryRepository.FirstOrDefaultAsync(
ur => ur.UserId == userId && ur.RoleId == roleId, ur => ur.UserId == userId && ur.RoleId == roleId,
cancellationToken); cancellationToken: cancellationToken);
if (userRole != null) if (userRole != null)
{ {
@ -68,7 +68,7 @@ public class UserRoleRepository : BaseRepository<UserRole>, IUserRoleRepository
{ {
var userRoles = await QueryRepository.FindAsync( var userRoles = await QueryRepository.FindAsync(
ur => ur.UserId == userId && roleIds.Contains(ur.RoleId), ur => ur.UserId == userId && roleIds.Contains(ur.RoleId),
cancellationToken); cancellationToken: cancellationToken);
if (userRoles.Any()) if (userRoles.Any())
{ {
@ -87,7 +87,7 @@ public class UserRoleRepository : BaseRepository<UserRole>, IUserRoleRepository
{ {
var userRoles = await QueryRepository.FindAsync( var userRoles = await QueryRepository.FindAsync(
ur => ur.UserId == userId, ur => ur.UserId == userId,
cancellationToken); cancellationToken: cancellationToken);
return userRoles.Select(ur => ur.RoleId).ToList(); return userRoles.Select(ur => ur.RoleId).ToList();
} }
@ -99,7 +99,7 @@ public class UserRoleRepository : BaseRepository<UserRole>, IUserRoleRepository
{ {
var userRoles = await QueryRepository.FindAsync( var userRoles = await QueryRepository.FindAsync(
ur => ur.RoleId == roleId, ur => ur.RoleId == roleId,
cancellationToken); cancellationToken: cancellationToken);
return userRoles.Select(ur => ur.UserId).ToList(); return userRoles.Select(ur => ur.UserId).ToList();
} }
@ -111,7 +111,7 @@ public class UserRoleRepository : BaseRepository<UserRole>, IUserRoleRepository
{ {
return await QueryRepository.AnyAsync( return await QueryRepository.AnyAsync(
ur => ur.UserId == userId && ur.RoleId == roleId, ur => ur.UserId == userId && ur.RoleId == roleId,
cancellationToken); cancellationToken: cancellationToken);
} }
/// <summary> /// <summary>
@ -121,7 +121,7 @@ public class UserRoleRepository : BaseRepository<UserRole>, IUserRoleRepository
{ {
return await QueryRepository.FirstOrDefaultAsync( return await QueryRepository.FirstOrDefaultAsync(
ur => ur.UserId == userId && ur.RoleId == roleId, ur => ur.UserId == userId && ur.RoleId == roleId,
cancellationToken); cancellationToken: cancellationToken);
} }
#endregion #endregion

Write Preview
Loading…
Cancel
Save