public Task <IQueryable <Category> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var Categories = _categoryRepository
.FindBy(c => c is Category);
return(Task.FromResult(Categories));
}
public async Task <IActionResult> GetCategories(int libraryId, CancellationToken token = default(CancellationToken))
{
var query = new GetCategoriesQuery(libraryId);
var categories = await _queryProcessor.ExecuteAsync(query, cancellationToken : token);
return(new OkObjectResult(_categoryRenderer.Render(categories, libraryId)));
}
public async Task <IEnumerable <Category> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var categoriesForUser = _dbContext.Categories
.FromSqlRaw("SELECT * FROM dbo.category where user_id = {0} ORDER BY id DESC", request.UserId);
return(categoriesForUser);
}
public async Task <IList <CategoryDto> > GetAll()
{
var request = new GetCategoriesQuery();
var categories = await _mediator.Send(request);
return(categories);
}
public async Task <ActionResult <IEnumerable <CategoryDto> > > GetAllCategoriesAsync()
{
var query = new GetCategoriesQuery();
var result = await _mediator.Send(query);
return(Ok(result));
}
public void GetCategoriesQueryReturnsAllCategories()
{
var categoryList = new List <Category>
{
new Category
{
CategoryId = 1,
CategoryName = "Software Architecture",
Products = new List <Product>()
},
new Category
{
CategoryId = 2,
CategoryName = "Mobile Programming",
Products = new List <Product>()
}
};
_mockCategorySet.Setup(m => m.AddRange(It.IsAny <IList <Category> >())).Returns(categoryList);
_mockContext.Setup(x => x.Categories).Returns(_mockCategorySet.Object);
var query = new GetCategoriesQuery(_mockContext.Object);
var categories = query.GetCategories();
Assert.NotNull(categories);
Assert.True(categories.Count() == 2);
}
public async Task <IList <CategoryInfoForList> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
return(await _dbContext.Categories
.Include(x => x.SubCategories)
.OrderBy(x => x.Name)
.ProjectTo <CategoryInfoForList>(_mapper.ConfigurationProvider)
.ToListAsync(cancellationToken: cancellationToken));
}
protected override IQueryable <CategoryDto> Handle(GetCategoriesQuery request)
{
return(_dbContext.Categories
.AsNoTracking()
.Select(x => new CategoryDto {
Id = x.Id, Name = x.Name
}));
}
public async Task <List <CategoryDto> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var categories = await _categoryRepository.FindAllAsync();
var categoriesDto = _mapper.Map <List <Category>, List <CategoryDto> >(categories);
return(categoriesDto);
}
public Task <IReadOnlyList <Category> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
return(_cache.GetOrCreateAsync(CacheDivision.General, "allcats", async entry =>
{
entry.SlidingExpiration = TimeSpan.FromHours(1);
var list = await _catRepo.SelectAsync(Category.EntitySelector);
return list;
}));
}
public async Task <IActionResult> GetCategories()
{
var query = new GetCategoriesQuery();
var queryResult = await _mediator.Send(query);
var result = _mapper.Map <IEnumerable <CategoryResponseModel> >(queryResult);
return(Ok(result));
}
public async Task <IEnumerable <CategoryDto> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var categories = await _context.Categories
.Include(category => category.SubCategories)
.Where(category => category.ParentCategoryId == null)
.ToListAsync();
return(_mapper.Map <IEnumerable <CategoryDto> >(categories));
}
public async Task <IActionResult> GetAllAsync()
{
var query = new GetCategoriesQuery();
var categoryDtos = await _mediator.Send(query);
var categoryViewModels = _mapper.Map <IEnumerable <CategoryViewModel> >(categoryDtos);
return(View("Index", categoryViewModels));
}
public Task <IEnumerable <CategoryDto> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var categories = applicationDataContext.ProductCategories
.Include(c => c.Parent)
.Include(c => c.ChildCategories);
return(Task.FromResult(mapper.ProjectTo <CategoryDto>(categories).AsEnumerable()));
}
public async Task Category_GetQueries_Success()
{
//Arrange
GetCategoriesQuery query = new GetCategoriesQuery();
_categoryRepository.Setup(x => x.GetListAsync(It.IsAny <Expression <Func <Category, bool> > >()))
.ReturnsAsync(new List <Category> {
new Category() /*TODO:propertyler buraya yazılacak CategoryId = 1, CategoryName = "test"*/ }
{
});
public async Task <List <CategoryListViewModel> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var categories = await _context.Categories.Select(x => new CategoryListViewModel
{
Id = x.Id,
Name = x.Name,
NoOfBlogs = x.Blogs.Where(y => !y.IsDraft).Count()
}).ToListAsync();
return(categories);
}
public async Task <List <Category> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var categories = await _context.Categories.ToListAsync();
if (categories == null)
{
throw new RestException(HttpStatusCode.NoContent, "No categories");
}
return(categories);
}
public async Task <FilteredDataViewModel <CategoryViewModel> > Handle(GetCategoriesQuery request,
CancellationToken cancellationToken)
{
IEnumerable <CategoryViewModel> categories = await _categoryService.GetCategoriesAsync(request.SearchParams);
int categoriesCount = await _categoryService.GetCategoriesCountAsync(request.SearchParams);
return(new FilteredDataViewModel <CategoryViewModel>
{
Data = categories,
Count = categoriesCount,
});
}
protected override IQueryable <CategoryDto> Handle(GetCategoriesQuery request)
{
if (request is null)
{
throw new System.ArgumentNullException(nameof(request));
}
return(_dbContext.Categories
.AsNoTracking()
.Select(x => new CategoryDto {
Id = x.Id, Name = x.Name
}));
}
public async Task <IList <GetCategoriesModel> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
return(await _context.Categories.Select(ctg => new GetCategoriesModel
{
Id = ctg.Id,
Name = ctg.Name,
Movies = ctg.Movies.Select(movies => new MovieModel
{
Id = movies.Id,
Name = movies.Name
}).ToList()
}).ToListAsync());
}
private async Task <IEnumerable <ListItem <int> > > SetupCategories(IEnumerable <int> selectedCategories)
{
var query = new GetCategoriesQuery();
var categoryDtos = await _mediator.Send(query);
var listItems = categoryDtos.Select(agency => new ListItem <int>
{
Key = agency.Name,
Value = agency.Id,
IsSelected = selectedCategories?.Contains(agency.Id) ?? false
});
return(listItems);
}
public async Task <IActionResult> GetCategoriesForUser(string userId)
{
var query = new GetCategoriesQuery(userId);
var categoriesList = await _mediator.Send(query);
if (categoriesList == null)
{
return(NotFound());
}
else
{
return(Ok(categoriesList));
}
}
private async Task <IEnumerable <ListItem <int> > > SetupCategories(int selectedCategoryId)
{
var getCategoriesQuery = new GetCategoriesQuery();
var categories = await _mediator.Send(getCategoriesQuery);
var listItems = categories.Select(category => new ListItem <int>
{
Key = category.Name,
Value = category.Id,
IsSelected = category.Id == selectedCategoryId
});
return(listItems);
}
public async Task <IEnumerable <CategoryDto> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var categories = _context.Categories
.Where(c => c.IsDeleted == false)
.Include(c => c.Items)
.Select(c => new Category
{
Id = c.Id, Name = c.Name, Icon = c.Icon, Items = c.Items.Where(i => !i.IsDeleted && !i.IsOutOfStock).ToList()
})
.AsNoTracking();
var cateDtos = _mapper.Map <IEnumerable <CategoryDto> >(categories);
return(cateDtos);
}
public async Task Handle_ReturnsCorrectVmAndListCount()
{
var query = new GetCategoriesQuery();
var handler = new GetCategoriesQuery.GetCategorysQueryHandler(_context, _mapper);
var result = await handler.Handle(query, CancellationToken.None);
result.ShouldBeOfType <CategoriesVm>();
result.Categories.Count.ShouldBe(1);
var list = result.Categories.First();
list.Products.Count.ShouldBe(5);
}
public async Task <PagedSearchResultDto <CategoryDto> > Get(GetCategoriesQuery query)
{
var searchParameters = new SearchParameters
{
IncludeTotalResultCount = true,
Top = query.Take,
Skip = query.Skip,
};
var searchResults = await this.WildcardSearch("*", searchParameters);
var mappedResults = searchResults.Results.Select(x =>
new CategoryDto(x.Document.Id, x.Document.Name, x.Document.Description, x.Document.SortOrder)).ToList();
return(new PagedSearchResultDto <CategoryDto>(mappedResults, searchResults.Count.Value));
}
public Task <PagedList <CategoryView> > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
var storeId = _infrastructureService.Cache.Store.Id;
var categories = _categoryService
.GetAllCategories(string.Empty, storeId, request.Paged.PageIndex, request.Paged.PageSize,
showHidden: true)
.ConvertPagedList <Category, CategoryView>();
categories.Source.ForEach(c =>
{
var categoryAttributeMappings = _categoryService.GetCategoryAttributeMappingsByCategoryId(c.Id);
var categoryAttributes = _categoryService.GetAllCategoryAttributesByCategoryId(c.Id);
c.Attributes = AutoMapperConfiguration.Mapper.Map <IEnumerable <CategoryAttributeMappingView> >(categoryAttributes);
c.Attributes.ToList().ForEach(cAttribute => AutoMapperConfiguration.Mapper.Map(categoryAttributeMappings.FirstOrDefault(x => x.CategoryAttributeId == cAttribute.Id), cAttribute));
});
return(Task.FromResult(categories));
}
public async Task <IEnumerable <CategoryDto> > Handle(GetCategoriesQuery request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(await _redisCacheService.GetOrSetAsync(CacheKeys.CategoriesKey, async() =>
{
Func <MainDbContext, IAsyncEnumerable <Category> > getCategoriesHandler =
EF.CompileAsyncQuery((MainDbContext context) => context.Categories.AsNoTracking());
var categories = await getCategoriesHandler(_dbContext).ToListAsync(cancellationToken);
return categories.Select(x => new CategoryDto {
Id = x.Id, Name = x.Name
});
}));
}
public async Task <IActionResult> GetCategories([FromServices] GetCategoriesQuery getCategoriesQuery)
{
List <Category> categories = await getCategoriesQuery.Build().ToListAsync();
return(Json(categories));
}
public async Task <IDataResult <IEnumerable <Category> > > Handle(GetCategoriesQuery request, CancellationToken cancellationToken)
{
return(new SuccessDataResult <IEnumerable <Category> >(await _categoryDal.GetListAsync()));
}
