public async Task <IActionResult> GetAllOrders()
{
var query = new GetAllOrdersQuery();
var result = await _mediator.Send(query);
return(Ok(result));
}
public async Task <IEnumerable <OrderViewModel> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await _allMarktQueryContex
.Orders
.ToListAsync(cancellationToken);
List <OrderViewModel> result = new List <OrderViewModel>();
foreach (var order in orders)
{
var orderVM = new OrderViewModel();
orderVM.Id = order.Id;
orderVM.ShopId = order.Seller == null ? 0 : order.Seller.Id;
orderVM.ShopName = order.Seller == null ? "-" : (order.Seller.User == null ? "-" : order.Seller.User.DisplayName);
orderVM.CustomerId = order.Buyer == null ? 0 : order.Buyer.Id;
orderVM.CustomerName = order.Buyer == null ? "-" : (order.Buyer.User == null ? "-" : order.Buyer.User.DisplayName);
orderVM.DeliveryPhoneNumber = order.DeliveryPhoneNumber;
orderVM.DeliveryAddress = order.DeliveryAddress;
orderVM.TotalPrice = order.TotalPrice;
orderVM.TimeOfOrder = order.TimeOfOrder;
orderVM.AdditionalNotes = order.AdditionalNotes;
orderVM.OrderStatus = order.OrderStatus;
orderVM.AWB = order.AWB;
orderVM.OrderItems = GetOrderItemViewModels(order.OrderItems);
result.Add(orderVM);
}
return(result);
}
public async Task <IActionResult> GetAll(
[FromQuery] GetAllOrdersQuery filterModel,
[FromQuery] PaginationQuery paginModel
)
{
int requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var pagination = _mapper.Map <PaginationFilter>(paginModel);
var filter = _mapper.Map <GetAllOrdersFilter>(filterModel);
var orders = await _orderService
.GetAllAsync(pagination, filter, requestedUserId);
int totalOrders = await _orderService
.CountAllAsync(pagination, filter, requestedUserId);
var responseOrders = _mapper
.Map <List <OrderResponse> >(orders);
var paginationOrdersResponse = PaginationHelpers
.CreatePaginatedResponse(
_uriService,
pagination,
responseOrders,
totalOrders,
ApiRoutes.Order.GetAll
);
return(Ok(paginationOrdersResponse));
}
public async Task <ActionResult <IEnumerable <OrdersV> > > GetOrders()
{
var query = new GetAllOrdersQuery();
var orders = await _mediator.Send(query);
return(Ok(orders));
}
public async Task <IActionResult> GetAllOrders([FromQuery] PaginationQuery paginationQuery)
{
var query = new GetAllOrdersQuery(paginationQuery);
var result = await _mediator.Send(query);
return(Ok(result));
}
public IActionResult Get()
{
var query = new GetAllOrdersQuery();
var result = mediator.Send(query);
return(Ok(result));
}
public async Task <List <Order> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
return(await _context.Bestellingen
.Include(x => x.BesteldeProducten)
.ThenInclude(x => x.Product)
.Include(x => x.Employee)
.ToListAsync(cancellationToken));
}
public async Task <ActionResult> Get()
{
var query = new GetAllOrdersQuery();
var result = await _mediator.Send(query);
_logger.LogInformation($"Get all orders at {DateTime.Now}");
return(Ok(result));
}
public async Task <List <OrderResponse> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var entities = await _dbContext.Orders.ToListAsync(cancellationToken : cancellationToken);
var responses = entities.Select(x => x.ToResponse()).ToList();
return(responses);
}
public async Task <IEnumerable <OrderDto> > Handle(GetAllOrdersQuery request,
CancellationToken cancellationToken)
{
return(await _context.Orders
.ProjectTo <OrderDto>(_mapper.ConfigurationProvider)
.AsNoTracking()
.ToListAsync(cancellationToken));
}
public Task <List <OrderDTOs.Order> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orders = _storeDbContext.Orders
.Include(o => o.OrderItems)
.ThenInclude(oi => oi.Product)
.ToList();
return(Task.FromResult(_mapper.Map <List <OrderDTOs.Order> >(orders)));
}
public OrdersService(GetAllOrdersQuery queryAllOrders, GetAllItemsQuery queryAllItems,
GetOrderByIdQuery queryById, AddOrderQuery queryAdd,
DeleteOrderQuery queryDelete)
{
this.queryAll = queryAllOrders;
this.queryAllItems = queryAllItems;
this.queryById = queryById;
this.queryAdd = queryAdd;
this.queryDelete = queryDelete;
}
public async Task <IList <OrderModel> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
return(await _db.Orders.Select(x => new OrderModel
{
Id = x.Id,
No = x.No,
CustomerId = x.CustomerId,
Date = x.Date,
Total = x.Total
}).ToListAsync());
}
public async Task <List <OrderResponse> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
List <OrderResponse> orderResponses = new List <OrderResponse> {
new OrderResponse
{
OrderId = 1,
OrderName = "Pc"
}
};
return(await Task.FromResult(orderResponses));
}
private OrdersService CreateOrdersService(bool empty = false)
{
mockDb = empty ? TestDatabaseFactory.CreateEmptyDatabase() : TestDatabaseFactory.CreateDatabase();
mockQueryAllOrders = new GetAllOrdersQuery(mockDb);
mockQueryAllItems = new GetAllItemsQuery(mockDb);
mockQueryById = new GetOrderByIdQuery(mockDb);
mockQueryAddOrder = new AddOrderQuery(mockDb);
mockQueryDeleteOrder = new DeleteOrderQuery(mockDb);
return(new OrdersService(mockQueryAllOrders, mockQueryAllItems, mockQueryById, mockQueryAddOrder, mockQueryDeleteOrder));
}
void Should_Returns_2_Orders_When_Call_Query_To_Get_All_Orders()
{
var query = new GetAllOrdersQuery();
orderRepository.Setup(x => x.FindAll()).Returns(new List <Order> {
new Order(pizzaFixture.PizzaSmallCalabresa),
new Order(pizzaFixture.PizzaSmallCalabresaWithExtraBacon),
});
var result = orderQueryHandler.Handle(query);
Assert.Equal(2, result.Count());
}
public IActionResult Get()
{
var query = new GetAllOrdersQuery();
query.Validate();
if (query.Invalid)
{
return(BadRequest(query.Notifications));
}
return(Ok(orderQueryHandler.Handle(query)));
}
public async Task <PagedResponse <OrderDto> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var paginationFilter = _mapper.Map <PaginationFilter>(request.PaginationQuery);
var orders = await _ordersRepository.GetAllOrdersAsync(paginationFilter);
var mappedOrders = _mapper.Map <List <OrderDto> >(orders);
if (paginationFilter == null || paginationFilter.PageNumber < 1 || paginationFilter.PageSize < 1)
{
return(new PagedResponse <OrderDto>(mappedOrders));
}
return(PaginationHelpers.CreatePaginatedResponse(_uriService, paginationFilter, mappedOrders));
}
public async Task <List <OrderResponse> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orderList = new List <OrderResponse>();
orderList.Add(new OrderResponse()
{
OrderId = 5,
CustomerName = "Luis",
CustomerNumber = "1234"
});
return(orderList.ToList());
//var orders = await _ordersRepository.GetOrdersAsync();
//return _mapper.MapOrderDtosToOrderResponse(orders);
}
public async Task <IActionResult> GetAllOrders()
{
//MediatR
//Ideally, every method in the controller should only have this 3 lines
//the query or command
var query = new GetAllOrdersQuery();
//the send method
var result = await _mediator.Send(query);
//the result
return(Ok(result));
//var orders:List<OrderDto> = await _ordersRepository.GetOrdersAsync();
//var orderResponse:List < OrderResponse > = _mapper.MapOrderDtosToOrderResponse(orders);
//return Ok(orderResponse);
}
public async Task <List <OrderDto> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await _context.Orders
.Include(o => o.OrderItems)
.ToListAsync();
return(orders
.Select(order => new OrderDto(order)
{
SubTotal = _ordersDomainService.CalculateSubTotal(order),
Tax = _ordersDomainService.CalculateTax(order),
Discount = _ordersDomainService.CalculateDiscount(order),
Total = _ordersDomainService.CalculateTotalPrice(order)
})
.ToList());
}
public async Task <List <OrderDto> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orders = (await _orderDatabase.GetAllAsync());
if (orders.Count != 0)
{
Console.WriteLine($"Got a request get all orders");
var ordersListDto = _customDxos.MapOrdersDto(orders);
ordersListDto.ForEach(it =>
it.ProductNames = it.ProductIDs.Select(y => _productDatabase.GetOne(db => db.Id == new ObjectId(y)).Title).ToList()
);
return(ordersListDto);
}
return(null);
}
public async Task <Response <IEnumerable <OrderVm> > > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var response = await _orderService.GetOrders();
var result = response.Select(o =>
new OrderVm {
OrderId = o.OrderId,
UserId = o.UserId,
ProductOrders = o.Products.Select(p =>
new ProductOrderVm {
Price = p.Price,
ProductId = p.ProductId,
Quantity = p.Quantity
}).ToList()
});
return(Response.Ok200(result));
}
public async Task <ActionResult <IEnumerable <OrdersVm> > > GetAllOrders()
{
try
{
var query = new GetAllOrdersQuery();
var orders = await _mediator.Send(query);
if (orders == null)
{
return(NotFound());
}
return(Ok(orders));
}
catch (Exception ex)
{
_logger.LogError($"Error getting orders", ex);
throw new Exception($"Error getting orders", ex);
}
}
public async Task <ActionResult <IEnumerable <OrdersVm> > > GetAllOrders()
{
var query = new GetAllOrdersQuery();
var orders = await _mediator.Send(query);
if (orders != null)
{
return(new JsonResult(new ResponseModel
{
Success = true,
Data = orders
}));
}
else
{
return(new JsonResult(new ResponseModel
{
Success = false,
ErrorMessage = "Unable to get orders"
}));
}
}
public async Task <List <OrderResponse> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await _ordersRepository.GetOrdersAsync();
return(_mapper.MapOrderDtosToOrderResponses(orders));
}
public async Task <IEnumerable <OrderReadDto> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await _orderRepo.GetAllOrdersAsync();
return(_mapper.Map <IEnumerable <OrderReadDto> >(orders));
}
public async Task <IEnumerable <OrdersVm> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var orderList = await _orderRepository.GetAllAsync();
return(_mapper.Map <List <OrdersVm> >(orderList));
}
public async Task <IEnumerable <Order> > Handle(GetAllOrdersQuery query, CancellationToken cancellationToken)
{
var entityList = await _context.Orders.ToListAsync(cancellationToken);
return(entityList?.AsReadOnly());
}
public async Task <IEnumerable <Order> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
{
var ordersList = await _context.Orders.ToListAsync();
return(ordersList.AsReadOnly());
}
