コード例 #1
0
        public async Task <IActionResult> GetAllOrders()
        {
            var query  = new GetAllOrdersQuery();
            var result = await _mediator.Send(query);

            return(Ok(result));
        }
コード例 #2
0
        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);
        }
コード例 #3
0
        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));
        }
コード例 #4
0
        public async Task <ActionResult <IEnumerable <OrdersV> > > GetOrders()
        {
            var query  = new GetAllOrdersQuery();
            var orders = await _mediator.Send(query);

            return(Ok(orders));
        }
コード例 #5
0
        public async Task <IActionResult> GetAllOrders([FromQuery] PaginationQuery paginationQuery)
        {
            var query  = new GetAllOrdersQuery(paginationQuery);
            var result = await _mediator.Send(query);

            return(Ok(result));
        }
コード例 #6
0
        public IActionResult Get()
        {
            var query  = new GetAllOrdersQuery();
            var result = mediator.Send(query);

            return(Ok(result));
        }
コード例 #7
0
 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));
 }
コード例 #8
0
        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));
        }
コード例 #9
0
        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);
        }
コード例 #10
0
 public async Task <IEnumerable <OrderDto> > Handle(GetAllOrdersQuery request,
                                                    CancellationToken cancellationToken)
 {
     return(await _context.Orders
            .ProjectTo <OrderDto>(_mapper.ConfigurationProvider)
            .AsNoTracking()
            .ToListAsync(cancellationToken));
 }
コード例 #11
0
        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)));
        }
コード例 #12
0
ファイル: OrdersService.cs プロジェクト: keithwillis/ShopApp
 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;
 }
コード例 #13
0
 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());
 }
コード例 #14
0
        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));
        }
コード例 #15
0
        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));
        }
コード例 #16
0
        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());
        }
コード例 #17
0
        public IActionResult Get()
        {
            var query = new GetAllOrdersQuery();

            query.Validate();

            if (query.Invalid)
            {
                return(BadRequest(query.Notifications));
            }

            return(Ok(orderQueryHandler.Handle(query)));
        }
コード例 #18
0
        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));
        }
コード例 #19
0
        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);
        }
コード例 #20
0
        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);
        }
コード例 #21
0
        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());
        }
コード例 #22
0
        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);
        }
コード例 #23
0
        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));
        }
コード例 #24
0
        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);
            }
        }
コード例 #25
0
        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"
                }));
            }
        }
コード例 #26
0
        public async Task <List <OrderResponse> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
        {
            var orders = await _ordersRepository.GetOrdersAsync();

            return(_mapper.MapOrderDtosToOrderResponses(orders));
        }
コード例 #27
0
        public async Task <IEnumerable <OrderReadDto> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
        {
            var orders = await _orderRepo.GetAllOrdersAsync();

            return(_mapper.Map <IEnumerable <OrderReadDto> >(orders));
        }
コード例 #28
0
        public async Task <IEnumerable <OrdersVm> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
        {
            var orderList = await _orderRepository.GetAllAsync();

            return(_mapper.Map <List <OrdersVm> >(orderList));
        }
コード例 #29
0
            public async Task <IEnumerable <Order> > Handle(GetAllOrdersQuery query, CancellationToken cancellationToken)
            {
                var entityList = await _context.Orders.ToListAsync(cancellationToken);

                return(entityList?.AsReadOnly());
            }
コード例 #30
0
            public async Task <IEnumerable <Order> > Handle(GetAllOrdersQuery request, CancellationToken cancellationToken)
            {
                var ordersList = await _context.Orders.ToListAsync();

                return(ordersList.AsReadOnly());
            }