public async Task <PageResult <GetCategoryDto> > GetCategoryByPage(CategoryFilterDto input)
{
var counts = 0;
var results = _categoryRepository
.GetAll()
.WhereIf(!String.IsNullOrEmpty(input.CategoryName), x => x.Name.Contains(input.CategoryName))
.Select(value => new GetCategoryDto
{
Id = value.Id,
Name = value.Name
});
counts = results.Count();
var result = new PageResult <GetCategoryDto>
{
Count = counts,
PageIndex = input.PageIndex,
PageSize = input.PageSize,
Items = await results.Skip((input.PageIndex - 1) *input.PageSize).Take(input.PageSize).ToListAsync()
};
return(result);
}
/// <summary>
/// Finds paged users.
/// </summary>
/// <param name="userFilterDto">The filtering DTO</param>
/// <returns>The User DTO page</returns>
internal IPagedList <T> FindPaged <T, U>(CategoryFilterDto categoryFilterDto) where T : CategoryDto, new() where U : Category
{
return(_modelContext.Set <U>()
.OrderBy(x => x.Name)
.Select(x => new T()
{
Id = x.Id, Name = x.Name
})
.ToPagedList(categoryFilterDto.Page, categoryFilterDto.PageSize));
}
public IHttpActionResult Get([FromUri] CategoryFilterDto categoryFilterDto)
{
if (categoryFilterDto == null)
{
categoryFilterDto = new CategoryFilterDto();
}
var categories = categoryFilterDto.SkipAndTake(categoryFilterDto.ApplyTo(shoppingEntities.Categories)).ToList();
var categoryDtos = categories.ConvertAll(t => new CategoryDto(t));
return(Ok(categoryDtos));
}
internal ListReferenceDto FindAllReferences <T>(CategoryFilterDto categoryFilterDto) where T : Category
{
Dictionary <Guid, string> references = _modelContext.Set <T>()
.Where(ExpressionQueryBuilder.BuildWhere <T>(categoryFilterDto))
.OrderBy(x => x.Name)
.Select(x => new { Id = x.Id, Name = x.Name })
.ToDictionary(x => x.Id, x => x.Name);
return(new ListReferenceDto()
{
References = references
});
}
public async Task <IActionResult> GetAllCategories(CategoryFilterDto filterDto)
{
try
{
var records = await _categoryService.GetAllAsync(filterDto);
return(PagedOk(records, filterDto, records.TotalPageCount));
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
private int TotalElements(CategoryFilterDto filter)
{
var sql = new StringBuilder(@" SELECT count(id) FROM categories ");
var parameters = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(filter.Name))
{
sql.Append(" WHERE UPPER(name) LIKE UPPER(@name)");
parameters.Add("name", "%" + filter.Name + "%");
}
return(_connection.ExecuteScalar <int>(sql.ToString(), parameters));
}
protected override IQuery<Category> ApplyWhereClause(IQuery<Category> query, CategoryFilterDto filter)
{
if (filter.Names == null || !filter.Names.Any())
{
return query;
}
var categoryNamePredicates = new List<IPredicate>(filter.Names
.Select(name => new SimplePredicate(
nameof(Category.Name),
ValueComparingOperator.Equal,
name)));
var predicate = new CompositePredicate(categoryNamePredicates, LogicalOperator.OR);
return query.Where(predicate);
}
public static IQueryable <Category> SetFilter(
this IQueryable <Category> query,
CategoryFilterDto filter)
{
if (!string.IsNullOrWhiteSpace(filter.Title))
{
query = query.Where(_ => _.Title.Contains(filter.Title));
}
if (filter.LangId.HasValue)
{
query = query.Where(_ => _.LangId == filter.LangId.Value);
}
return(query);
}
public async Task <Paged <CategoryDto> > GetAllAsync(CategoryFilterDto filterDto)
{
var result = await _categoryRepository.GetCategoriesAsync(filterDto);
var list = result.List.Select(x => x.Adapt <CategoryDto>()).ToList();
var returnDto = new Paged <CategoryDto>
{
List = list,
PageIndex = filterDto.PageIndex,
PageSize = filterDto.PageSize,
TotalPageCount = result.TotalPageCount,
FilteredCount = result.FilteredCount,
TotalCount = result.TotalCount
};
return(returnDto);
}
public async Task <Paged <Category> > GetCategoriesAsync(CategoryFilterDto filterDto)
{
var query = _ctx.Categories.Include(x => x.Articles).Where(x => !x.IsDeleted);
var totalPagesCount = query.CalculatePageCount(filterDto.PageSize);
var categories = await query.AsQueryable().OrderBy(filterDto.Ordination)
.SkipTake(filterDto.PageIndex, filterDto.PageSize)
.ToListAsync();
return(new Paged <Category>
{
List = categories,
PageIndex = filterDto.PageIndex,
PageSize = filterDto.PageSize,
TotalPageCount = totalPagesCount
});
}
public ResponsePaginationDto <Category> Search(CategoryFilterDto filter)
{
var sql = new StringBuilder(@" SELECT * FROM categories ");
var parameters = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(filter.Name))
{
sql.Append(" WHERE UPPER(name) LIKE UPPER(@name)");
parameters.Add("name", "%" + filter.Name + "%");
}
sql.Append(" LIMIT @page, @size ");
parameters.Add("page", filter.Page != 0 ? filter.Page * filter.Size : filter.Page);
parameters.Add("size", filter.Size == 0 ? 5 : filter.Size);
var categories = _connection.Query <Category>(sql.ToString(), parameters);
return(new ResponsePaginationDto <Category>(TotalElements(filter), categories));
}
public static async Task <List <CategoryDto> > GetCategories(CategoryFilterDto filter = null)
{
return(await ApiCall <List <CategoryDto> >(baseUrl + "/Category/GetAll", filter));
}
public IPagedList <ProductCategoryDto> ReadAdministrationPaged(CategoryFilterDto categoryFilterDto)
{
return(_categoryDao.FindPaged <ProductCategoryDto, ProductCategory>(categoryFilterDto));
}
public ActionResult <ResponsePaginationDto <Category> > Get([Required][FromQuery] CategoryFilterDto filter)
{
return(Ok(_service.Search(filter)));
}
public ActionResult GetAllCategoryReferences(CategoryFilterDto categoryFilterDto)
{
return(Json(GetService().GetAllReferences(categoryFilterDto).References.ToList()));
}
public ActionResult PagedList(CategoryFilterDto categoryFilterDto)
{
ViewBag.FilterDto = categoryFilterDto;
return(PartialView(WebConstants.VIEW_PAGED_LIST, GetService().ReadAdministrationPaged(categoryFilterDto)));
}
public ListReferenceDto GetAllReferences(CategoryFilterDto categoryFilterDto)
{
return(_categoryDao.FindAllReferences <U>(categoryFilterDto));
}
public ResponsePaginationDto <Category> Search(CategoryFilterDto filter)
{
return(_repository.Search(filter));
}
public ActionResult <ResponsePaginationDto <Category> > Get([FromQuery][Required] CategoryFilterDto filter)
{
return(Ok(_repository.Search(filter)));
}