public async Task <IDataResult <IEnumerable <Product> > > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var result = new SuccessDataResult <IEnumerable <Product> >(await _productDal.GetListAsync());
_messageBrokerHelper.QueueMessage($"GetProductsQuery Komutuyla Bütün Ürünler Sorgulandı.");
return(result);
}
public async Task <List <ProductDto> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var result = await _context.Products
.ToListAsync();
return(_mapper.Map <List <ProductDto> >(result));
}
public async Task ShouldReturnPricesIncreasedBy20Percent()
{
//
var products = new List <Product>
{
new Product {
ProductId = "1", Description = "Desc1", Name = "p1", UnitPrice = 100.0
}
};
Mock <IProductRepository> productRepoMock = new Mock <IProductRepository>();
productRepoMock.Setup(repo => repo.GetAllAsync())
.ReturnsAsync(products);
ProductDxos productDxos = new ProductDxos();
var handlr = new GetProductsHandler(productRepoMock.Object, productDxos, new NullLogger <GetProductsHandler>());
GetProductsQuery queryObj = new GetProductsQuery();
var productDtos = await handlr.Handle(queryObj, CancellationToken.None);
Assert.AreEqual(120.0, productDtos[0].Price);
}
public async Task <PagedList <ProductItemDTO> > GetProductItemsAsync(GetProductsQuery query)
{
// 搜索
var filter = Builders <ProductItemDTO> .Filter.Empty;
if (query.Keyword.IsPresent())
{
var itemNoFilter = Builders <ProductItemDTO> .Filter.Regex(x => x.ItemNo, query.Keyword);
var keywordFilter = Builders <ProductItemDTO> .Filter.Regex(x => x.ProductName, query.Keyword);
filter = Builders <ProductItemDTO> .Filter.Or(itemNoFilter, keywordFilter);
}
// 输出数据
var fluent = DB.ProductItems.Find(filter);
var total = await fluent.CountDocumentsAsync().ConfigureAwait(false);
fluent = fluent.SortByDescending(x => x.CreatedOnUtc);
if (query.PageSize > 0 && query.PageIndex > 0)
{
fluent = fluent
.Skip((query.PageIndex - 1) * query.PageSize)
.Limit(query.PageSize);
}
var list = await fluent.ToListAsync().ConfigureAwait(false);
return(new PagedList <ProductItemDTO>(total, query.PageSize, list));
}
public Task <PagedList <ProductDTO> > GetProductsAsync(GetProductsQuery query)
{
var where = new StringBuilder();
if (query.Keyword.IsPresent())
{
where.AppendFormat(" AND (ASIN LIKE '%{0}%' OR ProductName LIKE '%{0}%')", query.Keyword);
}
if (query.Status.HasValue)
{
where.AppendFormat(" AND Status = {0}", (int)query.Status.Value);
}
string orderBy = "CreatedOnUtc";
switch (query.OrderBy.GetValueOrDefault())
{
case 1:
orderBy = "ASIN";
break;
}
orderBy += " " + query.SortDirection;
return(base.GetPagedListAsync <ProductDTO>(query.PageSize, query.PageIndex, "Product", "*", where.ToString(), orderBy));
}
public async Task Handle_ValidAscOrderBy_ReturnProducts(
List <Entities.Product> products,
[Frozen] Mock <IRepository <Entities.Product> > productRepoMock,
GetProductsQueryHandler sut,
GetProductsQuery query
)
{
//Arrange
productRepoMock.Setup(x => x.ListAsync(
It.IsAny <GetProductsPaginatedSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync(products);
query.OrderBy = "asc(name)";
//Act
var result = await sut.Handle(query, CancellationToken.None);
//Assert
result.Should().NotBeNull();
productRepoMock.Verify(x => x.ListAsync(
It.IsAny <ISpecification <Entities.Product> >(),
It.IsAny <CancellationToken>()
));
for (int i = 0; i < result.Products.Count; i++)
{
result.Products[i].ProductNumber.Should().Be(products[i].ProductNumber);
}
}
public IEnumerable <Product> Handle(GetProductsQuery message)
{
var products = this._database
.Products
.Include(p => p.Category)
.Include(p => p.FieldValues)
.Include(p => p.FieldValues.Select(fv => fv.Field))
;
if (message.CategoryId.HasValue)
{
products = products.Where(p => p.CategoryId == message.CategoryId);
}
if (message.FieldValues != null)
{
var fieldIds = message.FieldValues.Select(fv => fv.Key).ToList();
var fields = _database.Fields.Where(f => fieldIds.Contains(f.Id)).ToList();
products = this.FilterFields(message.FieldValues, fields, products);
}
return(products
.OrderBy(p => p.Id)
.Skip((message.Page - 1) * message.Take)
.Take(message.Take)
.ToList());
}
public Task <List <ProductDto> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var products = _repository.GetAll().ToList();
var productsDtos = _mapper.Map <List <Product>, List <ProductDto> >(products);
return(Task.FromResult(productsDtos));
}
public async Task GetProducts_ShouldReturnProducts_WhenProductsExist(
[Frozen] Mock <IMediator> mockMediator,
List <Core.Handlers.GetProduct.Product> products,
[Greedy] ProductController sut,
GetProductsQuery query
)
{
//Arrange
var dto = new GetProductsDto
{
TotalProducts = products.Count,
Products = products
};
mockMediator.Setup(x => x.Send(It.IsAny <GetProductsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(dto);
//Act
var actionResult = await sut.GetProducts(query);
//Assert
var okObjectResult = actionResult as OkObjectResult;
okObjectResult.Should().NotBeNull();
var response = okObjectResult.Value as Models.GetProductsResult;
response.TotalProducts.Should().Be(products.Count);
response.Products.Count.Should().Be(products.Count);
for (int i = 0; i < products.Count; i++)
{
response.Products[i].ProductNumber.Should().Be(products[i].ProductNumber);
}
}
public async Task <ActionResult <Result <ProductsVm> > > GetProducts()
{
var query = new GetProductsQuery();
var result = await _mediatR.Send(query);
return(Ok(result));
}
public async Task <IEnumerable <GetProductsDto> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var products = await searchProductService
.GetProducts(request.FilteringData);
return(mapper.Map <List <GetProductsDto> >(products));
}
public void Handle_NoProductsExists_ThrowArgumentNullException(
[Frozen] Mock <IRepository <Entities.Product> > productRepoMock,
GetProductsQueryHandler sut,
GetProductsQuery query
)
{
// Arrange
query.OrderBy = "";
productRepoMock.Setup(x => x.ListAsync(
It.IsAny <GetProductsPaginatedSpecification>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync((List <Entities.Product>)null);
//Act
Func <Task> func = async() => await sut.Handle(query, CancellationToken.None);
//Assert
func.Should().ThrowAsync <ArgumentNullException>();
productRepoMock.Verify(x => x.ListAsync(
It.IsAny <ISpecification <Entities.Product> >(),
It.IsAny <CancellationToken>()
));
}
private string AppentFilters(GetProductsQuery query)
{
var sqlQuery = string.Empty;
if (!string.IsNullOrEmpty(query.Name))
{
sqlQuery = sqlQuery.AddWhere("[Name] LIKE @Name ");
}
if (query.CategoryId.HasValue)
{
sqlQuery = sqlQuery.AddWhere(
"EXISTS (SELECT [Id] FROM [ProductCategories] " +
"WHERE [ProductId] = Products.Id " +
"AND [CategoryId] = @CategoryId) ");
}
if (query.AttributeValues.Any())
{
sqlQuery = sqlQuery.AddWhere(
"EXISTS (SELECT [Id] FROM [ProductAttributeValues] " +
"WHERE [ProductId] = Products.Id " +
$"AND ([AttributeValueId] ={string.Join(" OR [AttributeValueId] = ", query.AttributeValues)})) ");
}
sqlQuery = sqlQuery.AddWhere("[Price] > @MinPrice ");
sqlQuery = sqlQuery.AddWhere("[Price] < @MaxPrice ");
return(sqlQuery);
}
public async Task <IEnumerable <ProductDto> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var products = await _dbContext.Produts.ToListAsync();
var response = _mapper.Map <IEnumerable <ProductDto> >(products);
return(response);
}
public ProductsControllersTests()
{
_getProductsQuery = A.Fake <GetProductsQuery>();
_searchProductsQuery = A.Fake <SearchProductsQuery>();
_getProductBundles = A.Fake <GetProductBundlesQuery>();
_productController = new ProductsController(_getProductsQuery, _searchProductsQuery, _getProductBundles);
}
public GetProductsQueryHandlerTests(ITestOutputHelper output)
{
_output = output;
_handler = new GetProductsQueryHandler(Context, Mapper);
_query = new GetProductsQuery();
}
public async Task <List <ProductDto> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var entities = await _context.Products.ToListAsync();
var responseDto = _mapper.Map <List <Product>, List <ProductDto> >(entities);
return(responseDto);
}
public async Task <IEnumerable <ProductQueryModel> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
_logger.Debug("Handling GetProductsQuery");
var products = await _productQueryRepository.GetAllProducts().ConfigureAwait(false);
return(products);
}
public async Task <IActionResult> Get()
{
var query = new GetProductsQuery();
var result = await _mediator.Send(query);
return(Ok(result));
}
public Product Get(int ID)
{
IQuery query = new GetProductsQuery();
using (var connection = new SqlConnection(connectionString))
{
return(connection.Query <Product>(query.Sql, new { ID }).First());
}
}
public Task <IQueryable <Product> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var selectedPropertiesList = request.GraphQLContext.GetSelectedPropertiesListAsString();
var results = _context
.Products
.Select <Product>($"new({selectedPropertiesList})");
return(Task.FromResult(results));
}
public async Task <List <ProductResponse> > Handle(
GetProductsQuery request,
CancellationToken cancellationToken)
{
var products = await productRepository
.GetAllAsync(request.Filter, request.Pagination, request.Sorting)
.ConfigureAwait(false);
return(mapper.Map <List <ProductResponse> >(products));
}
public async Task <IEnumerable <ProductDTO> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
return(await _context.Product.Select(x => new ProductDTO()
{
Guid = x.Guid,
Id = x.Id,
Name = x.Name,
ShortName = x.ShortName,
Price = x.Price.Where(y => y.CurrentPrice == true).FirstOrDefault().Price1
}).ToListAsync());
}
public async Task <BaseDto <IList <ProductInput> > > Handle(GetProductsQuery request, CancellationToken cancellationToken) =>
new BaseDto <IList <ProductInput> >
{
Message = "Success retrieve Product datas",
Status = true,
Data = await _context.products.OrderBy(x => x.id).Select(result => new ProductInput {
merchant_id = result.merchant_id,
name = result.name,
price = result.price
}).ToListAsync()
};
public virtual ActionResult List()
{
var request = new GetProductsQuery()
{
UserId = CurrentUserId()
};
var result = mediator.Send(request);
return(View(result));
}
public async Task ShouldReturnProductList()
{
// Arrange
var request = new GetProductsQuery();
// Act
List <ProductListDto> list = await SendAsync(request);
// Assert
list.Should().Contain(x => x.Id == ProductId);
}
public async Task <IEnumerable <Product> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
IEnumerable <Product> products = await _productRepository.GetProductsAsync();
if (products == null)
{
throw new ApplicationException("Failed to load products");
}
return(products);
}
public async Task <IList <GetProductDto> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var result = new List <GetProductDto>();
List <Product> products = await _context.Products.ToListAsync();
if (products != null)
{
result = _mapper.Map <List <GetProductDto> >(products);
}
return(result);
}
public IEnumerable <Product> Handle(GetProductsQuery query)
{
if (!string.IsNullOrEmpty(query.Name))
{
return(productRepository.GetByName(query.Name));
}
else
{
return(productRepository.GetAll());
}
}
public async Task <IList <ProductDto> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
return
(await _context.Products.Select(product => new ProductDto
{
Id = product.Id,
Name = product.Name,
Price = product.Price,
Quentity = product.Quantity,
}).ToListAsync(cancellationToken));
}
