protected EfCoreControllerBase(
IEfQueryRepository <TEntity> queryRepository,
IEfRepositoryAsync <TEntity> mutateRepository)
{
QueryRepository = queryRepository;
MutateRepository = mutateRepository;
}
public GetTasksService(
IEfQueryRepository <Domain.Task> taskRepo,
IOptions <PaginationOption> paginationOption)
{
_taskRepo = taskRepo;
_paginationOption = paginationOption;
}
internal static async Task <PaginatedItem <TResponse> > QueryAsync <TDbContext, TEntity, TResponse>(
this IEfQueryRepository <TDbContext, TEntity> repo,
Criterion criterion,
Expression <Func <TEntity, TResponse> > selector,
params Expression <Func <TEntity, object> >[] includeProperties)
where TDbContext : DbContext
where TEntity : class, IEntity
{
return(await GetDataAsync(repo, criterion, selector, null, includeProperties));
}
public static async Task <PaginatedItem <TResponse> > QueryAsync <TDbContext, TEntity, TResponse>(
this IEfQueryRepository <TDbContext, TEntity> repo,
Criterion criterion,
Expression <Func <TEntity, TResponse> > selector,
Func <IQueryable <TEntity>, IIncludableQueryable <TEntity, object> > include = null,
bool disableTracking = true)
where TDbContext : DbContext
where TEntity : class, IAggregateRoot
{
return(await GetDataAsync(repo, criterion, selector, null, include, disableTracking));
}
public CartService(
IEfQueryRepository <Domain.Cart> queryRepository,
IEfRepositoryAsync <Domain.Cart> mutateRepository,
IEfRepositoryAsync <CartItem> cartItemMutateRepository,
ICatalogService catalogService)
{
_catalogService = catalogService;
_queryRepository = queryRepository;
_mutateRepository = mutateRepository;
_cartItemMutateRepository = cartItemMutateRepository;
}
public TaskController(
IUnitOfWorkAsync unitOfWork,
IEfQueryRepository <Domain.Task> taskQuery,
IGetTasksService getTasksService,
IOptions <PaginationOption> paginationOption)
{
_taskRepository = unitOfWork.Repository <Domain.Task>() as IEfRepositoryAsync <Domain.Task>;
_taskQuery = taskQuery;
_getTasksService = getTasksService;
_paginationOption = paginationOption;
}
private static async Task <PaginatedItem <TResponse> > GetDataAsync <TDbContext, TEntity, TResponse>(
IEfQueryRepository <TDbContext, TEntity> repo,
Criterion criterion,
Expression <Func <TEntity, TResponse> > selector,
Expression <Func <TEntity, bool> > filter = null,
params Expression <Func <TEntity, object> >[] includeProperties)
where TDbContext : DbContext
where TEntity : class, IEntity
{
if (criterion.PageSize < 1 || criterion.PageSize > criterion.DefaultPagingOption.PageSize)
{
criterion.SetPageSize(criterion.DefaultPagingOption.PageSize);
}
var queryable = repo.Queryable();
if (includeProperties != null && includeProperties.Count() > 0)
{
queryable = includeProperties.Aggregate(
queryable,
(current, include) => current.Include(include));
}
if (filter != null)
{
queryable = queryable.Where(filter);
}
if (!string.IsNullOrWhiteSpace(criterion.SortBy))
{
var isDesc = string.Equals(criterion.SortOrder, "desc", StringComparison.OrdinalIgnoreCase) ? true : false;
queryable = queryable.OrderByPropertyName(criterion.SortBy, isDesc);
}
var results = await queryable
.Skip(criterion.CurrentPage *criterion.PageSize)
.Take(criterion.PageSize)
.AsNoTracking()
.Select(selector)
.ToListAsync();
var totalRecord = await queryable.CountAsync();
var totalPages = (int)Math.Ceiling((double)totalRecord / criterion.PageSize);
if (criterion.CurrentPage > totalPages)
{
criterion.SetCurrentPage(totalPages);
}
return(new PaginatedItem <TResponse>(totalRecord, totalPages, results));
}
private static async Task <PaginatedItem <TResponse> > GetDataAsync <TDbContext, TEntity, TResponse>(
IEfQueryRepository <TDbContext, TEntity> repo,
Criterion criterion,
Expression <Func <TEntity, TResponse> > selector,
Expression <Func <TEntity, bool> > filter = null,
Func <IQueryable <TEntity>, IIncludableQueryable <TEntity, object> > include = null,
bool disableTracking = true)
where TDbContext : DbContext
where TEntity : class, IAggregateRoot
{
var queryable = repo.Queryable();
if (disableTracking)
{
queryable = queryable.AsNoTracking();
}
if (include != null)
{
queryable = include.Invoke(queryable);
}
if (filter != null)
{
queryable = queryable.Where(filter);
}
if (!string.IsNullOrWhiteSpace(criterion.SortBy))
{
var isDesc = string.Equals(criterion.SortOrder, "desc", StringComparison.OrdinalIgnoreCase)
? true
: false;
queryable = queryable.OrderByPropertyName(criterion.SortBy, isDesc);
}
var results = await queryable
.Skip(criterion.CurrentPage *criterion.PageSize)
.Take(criterion.PageSize)
.Select(selector)
.ToListAsync();
var totalRecord = await queryable.CountAsync();
var totalPages = (int)Math.Ceiling((double)totalRecord / criterion.PageSize);
if (criterion.CurrentPage > totalPages)
{
// criterion.SetCurrentPage(totalPages);
}
return(new PaginatedItem <TResponse>(totalRecord, totalPages, results));
}
public static async Task <Domain.Cart> GetFullCart(this IEfQueryRepository <Domain.Cart> cartRepo, Guid cartId)
{
var cart = await cartRepo.GetByIdAsync(
cartId,
cartQueryable => cartQueryable
.Include(x => x.CartItems)
.ThenInclude((CartItem cartItem) => cartItem.Product));
if (cart == null)
{
throw new Exception($"Could not find the cart[{cartId}]");
}
return(cart);
}
internal static async Task <TEntity> FindOneAsync <TDbContext, TEntity>(
this IEfQueryRepository <TDbContext, TEntity> repo,
Expression <Func <TEntity, bool> > filter,
params Expression <Func <TEntity, object> >[] includeProperties)
where TDbContext : DbContext
where TEntity : class, IEntity
{
var dbSet = repo.Queryable();
foreach (var includeProperty in includeProperties)
{
dbSet = dbSet.Include(includeProperty);
}
return(await dbSet.FirstOrDefaultAsync(filter));
}
public static async Task <IReadOnlyList <TEntity> > ListAsync <TDbContext, TEntity>(
this IEfQueryRepository <TDbContext, TEntity> repo,
Func <IQueryable <TEntity>, IIncludableQueryable <TEntity, object> > include = null,
bool disableTracking = true)
where TDbContext : DbContext
where TEntity : class, IEntity
{
IQueryable <TEntity> queryable = repo.Queryable();
if (disableTracking)
{
queryable = queryable.AsNoTracking() as IQueryable <TEntity>;
}
include?.Invoke(queryable);
return(await queryable.ToListAsync());
}
public static async Task <IReadOnlyList <TEntity> > ListAsync <TDbContext, TEntity>(
this IEfQueryRepository <TDbContext, TEntity> repo,
params Expression <Func <TEntity, object> >[] includeProperties)
where TDbContext : DbContext
where TEntity : class, IEntity
{
var queryable = repo.Queryable().AsNoTracking() as IQueryable <TEntity>;
if (includeProperties != null)
{
foreach (var includeProperty in includeProperties)
{
queryable = queryable.Include(includeProperty);
}
}
return(await queryable.ToListAsync());
}
public static async Task <TEntity> FindOneAsync <TDbContext, TEntity>(
this IEfQueryRepository <TDbContext, TEntity> repo,
Expression <Func <TEntity, bool> > filter,
Func <IQueryable <TEntity>, IIncludableQueryable <TEntity, object> > include = null,
bool disableTracking = true)
where TDbContext : DbContext
where TEntity : class, IEntity
{
IQueryable <TEntity> queryable = repo.Queryable();
include?.Invoke(queryable);
if (disableTracking)
{
queryable = queryable.AsNoTracking() as IQueryable <TEntity>;
}
return(await queryable.FirstOrDefaultAsync(filter));
}
public static async Task <TEntity> GetByIdAsync <TDbContext, TEntity>(
this IEfQueryRepository <TDbContext, TEntity> repo,
Guid id,
params Expression <Func <TEntity, object> >[] includeProperties)
where TDbContext : DbContext
where TEntity : class, IEntity
{
var queryable = repo.Queryable().AsNoTracking() as IQueryable <TEntity>;
if (includeProperties != null)
{
foreach (var includeProperty in includeProperties)
{
queryable = queryable.Include(includeProperty);
}
}
return(await queryable.SingleOrDefaultAsync(e => e.Id.Equals(id)));
}
public static async Task <TEntity> GetByIdAsync <TDbContext, TEntity>(
this IEfQueryRepository <TDbContext, TEntity> repo,
Guid id,
Func <IQueryable <TEntity>, IIncludableQueryable <TEntity, object> > include = null,
bool disableTracking = true)
where TDbContext : DbContext
where TEntity : class, IAggregateRoot
{
var queryable = repo.Queryable();
if (disableTracking)
{
queryable = queryable.AsNoTracking();
}
if (include != null)
{
queryable = include.Invoke(queryable);
}
return(await queryable.SingleOrDefaultAsync(e => e.Id.Equals(id)));
}
public InventoryService(IEfQueryRepository <Domain.Inventory> repo)
{
_repo = repo;
}
public QueryFluent(IEfQueryRepository <TEntity> repository)
{
_repository = repository;
_includes = new List <Expression <Func <TEntity, object> > >();
}
protected CrudControllerBase(
IEfQueryRepository <TEntity> queryRepository,
IEfRepositoryAsync <TEntity> mutateRepository)
: base(queryRepository, mutateRepository)
{
}
public QueryFluent(IEfQueryRepository <TEntity> repository, IQueryObject <TEntity> queryObject)
: this(repository) { _filter = queryObject.Query(); }
public QueryFluent(IEfQueryRepository <TEntity> repository, Expression <Func <TEntity, bool> > filter)
: this(repository) { _filter = filter; }
