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()); }