public async Task <IEnumerable <ItemDto> > Handle(GetItemsQuery request, CancellationToken cancellationToken)
{
var items = _context.Items.Where(c => c.IsDeleted == false).Include(i => i.Category).AsNoTracking();
var itemDtos = _mapper.Map <IEnumerable <ItemDto> >(items);
return(itemDtos);
}
public async Task <IEnumerable <SimpleItemModel> > Retrieve(GetItemsQuery query)
{
using (var conn = DatabaseManager.Instance.CreateSqlConnection()) {
using (var cmd = conn.CreateCommand()) {
await conn.OpenAsync();
cmd.CommandType = CommandType.Text;
cmd.CommandText = "select * from [Catalog].[Item]";
// TODO use dapper
IList <SimpleItemModel> results = new List <SimpleItemModel>();
var reader = await cmd.ExecuteReaderAsync();
while (await reader.ReadAsync())
{
var result = new SimpleItemModel();
result.ItemId = Convert.ToInt32(reader["ItemId"]);
result.Description = reader["Description"].ToString();
result.Title = reader["Title"].ToString();
results.Add(result);
}
return(results);
}
}
}
public ActionResult Items()
{
var query = new GetItemsQuery(100);
var items = MvcApplication.DbClient.Execute(query);
ModelFactory.ReplaceUrl(items);
return Json(items, JsonRequestBehavior.AllowGet);
}
public async Task ValidateExisting(TDto value, CustomContext context, CancellationToken cancellationToken)
{
var query = new GetItemsQuery <TDto>()
{
Filters = new List <Filter>()
};
List <string> columnNames = new List <string>();
foreach (var selector in selectors)
{
string columnName = GetColumnName(selector);
columnNames.Add(columnName);
query.Filters.Add(new Filter(columnName, "=", selector.Compile().Invoke(value).ToString()));
}
IEnumerable <TDto> items = await mediator.Send(query, cancellationToken);
if (items.Count() > 0)
{
bool valueBelongsToValidatingItem = items.Any(item => item.Id == value.Id);
if (!valueBelongsToValidatingItem)
{
context.AddFailure($"n-tuple ({string.Join(", ", columnNames)}) must be unique.");
}
}
}
public async Task <List <ItemDto> > Handle(GetItemsQuery request, CancellationToken cancellationToken)
{
return(await _context.Items
.ProjectTo <ItemDto>(_mapper.ConfigurationProvider)
.OrderBy(t => t.Name)
.ToListAsync(cancellationToken));
}
public ActionResult Items()
{
var query = new GetItemsQuery(100);
var items = MvcApplication.DbClient.Execute(query);
ModelFactory.ReplaceUrl(items);
return(Json(items, JsonRequestBehavior.AllowGet));
}
public async Task <ItemResponse <List <ItemEntity> > > Handle(GetItemsQuery request, CancellationToken cancellationToken)
{
var res = await _itemRepository.FindAllItems();
return(new ItemResponse <List <ItemEntity> >
{
RequestStatus = CustomEnum.RequestStatus.Success,
TransactionTs = DateTime.Now.ToString(),
ItemData = res
});
}
public async Task <IActionResult> GetAll([FromQuery] ItemParameters itemParameters)
{
GetItemsQuery query = new GetItemsQuery(itemParameters);
(int, IEnumerable <ItemsResponse>)queryResult = await _mediator.Send(query);
int totalCount = queryResult.Item1;
IEnumerable <ItemsListResponse> items = _mapper.Map <IEnumerable <ItemsListResponse> >(queryResult.Item2);
return(Ok(new { totalCount, items }));
}
public Task <IQueryable <ShoppingCartItemDto> > Handle(GetItemsQuery request, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var shoppingCartItems = applicationDataContext.ShoppingCartItems
.Include("Product")
.Include("ProductVariant")
.Include("Discount");
return(Task.FromResult(mapper.ProjectTo <ShoppingCartItemDto>(shoppingCartItems)));
}
public GetItemsQueryHandlerTest()
{
this.mockItemRepository = new Mock <IItemRepository>(MockBehavior.Strict);
this.mockUserRepository = new Mock <IUserRepository>(MockBehavior.Strict);
this.mockMemoryCache = new Mock <IMemoryCache>(MockBehavior.Strict);
this.mockCacheEntry = new Mock <ICacheEntry>(MockBehavior.Strict);
this.query = new GetItemsQuery(10);
this.handler = new GetItemsQueryHandler(
mockItemRepository.Object,
mockUserRepository.Object,
mockMemoryCache.Object);
}
public async Task <IList <VTransactionDto> > Handle(GetItemsQuery request, CancellationToken cancellationToken)
{
List <VTransactionDto> Items = new List <VTransactionDto>();
_itemDxos = new ItemDxos(request.AudRate);
// read json data
var transactions = _jsonRepository.GetAll();
foreach (var item in transactions)
{
Items.Add(_itemDxos.MapTransactionItemToDto(item));
}
return(Items);
}
public virtual async Task <IEnumerable <TDto> > Handle(GetItemsQuery <TDto> request, CancellationToken cancellationToken)
{
var query = ctx.Set <TDal>().AsNoTracking();
query = query.ApplyFilterData(request.Filters, CreateWherePredicate);
query = query.ApplySort(request.Sort, OrderSelectors);
if (request.Paging != null && request.Paging.Count > 0)
{
query = query.Skip(request.Paging.From)
.Take(request.Paging.Count);
}
var data = await query.Select(Selector)
.ToListAsync(cancellationToken);
return(data);
}
public IActionResult GetItem(int itemId, [FromQuery] bool returnFull = false)
{
Item result;
if (returnFull)
{
var query = new GetFullItemsQuery(itemId);
result = mediator.Send(query).Result.FirstOrDefault();
}
else
{
var query = new GetItemsQuery(itemId);
result = mediator.Send(query).Result.FirstOrDefault();
}
if (result != null)
{
return(Ok(result));
}
return(NotFound());
}
public IActionResult GetItems([FromQuery] bool returnFull = false)
{
List <Item> result;
if (returnFull)
{
var query = new GetFullItemsQuery();
result = mediator.Send(query).Result;
}
else
{
var query = new GetItemsQuery();
result = mediator.Send(query).Result;
}
if (result.Any())
{
return(Ok(result));
}
return(NotFound());
}
public async Task ValidateExisting(string value, CustomContext context, CancellationToken cancellationToken)
{
string columnName = GetColumnName(context);
UpdateCommand <TDto> validatingObject = (UpdateCommand <TDto>)context.InstanceToValidate;
var query = new GetItemsQuery <TDto>()
{
Filters = new List <Filter>
{
new Filter(columnName, "=", value.Trim())
}
};
IEnumerable <TDto> items = await mediator.Send(query, cancellationToken);
if (items.Count() > 0)
{
bool valueBelongsToValidatingItem = items.Any(item => item.Id == validatingObject.Dto.Id);
if (!valueBelongsToValidatingItem)
{
context.AddFailure($"{columnName} must be unique. Value {value} has been already used!");
}
}
}
public virtual async Task <Items <T> > GetAll([FromQuery] LoadParams loadParams, [FromServices] IMediator mediator, [FromServices] IMapper mapper)
{
var filters = FilterStringParser.Parse(loadParams.Filter);
var result = new Items <T>();
var countRequest = new GetCountQuery <T>
{
Filters = filters
};
result.Count = await mediator.Send(countRequest);
if (result.Count > 0)
{
var dataRequest = new GetItemsQuery <T>
{
Paging = mapper.Map <LoadParams, PagingData>(loadParams),
Sort = CreateSort(loadParams),
Filters = filters
};
result.Data = await mediator.Send(dataRequest);
}
return(result);
}
public async Task <IEnumerable <Item> > Handle(GetItemsQuery request, CancellationToken cancellationToken)
{
return(await _db.Items.ToListAsync(cancellationToken));
}
public async Task <ActionResult <GetItemsQueryResponse> > GetOrders([FromRoute] GetItemsQuery query, CancellationToken token) => await mediator.Query <GetItemsQuery, GetItemsQueryResponse>(query, token);
public IActionResult Index(GetItemsQuery query)
{
return(View());
}
