public IActionResult AddItemToCart(
     [FromRoute] CartId cartId,
     AddItemToCartModel addItemToCart,
     [FromServices] IRequestHandler <AddItemToCartRequest, Result <Unit> > handler)
 => handler
 .Handle(new AddItemToCartRequest(cartId, addItemToCart.ItemId, addItemToCart.Quantity))
 .ToActionResult();
        public IActionResult AddItemToCart(
            Guid cartId,
            AddItemToCartModel addItemToCart,
            [FromServices] IRequestHandler <AddItemToCartRequest, AddItemToCartResponse> handler)
        {
            try
            {
                _ = handler.Handle(
                    new AddItemToCartRequest
                {
                    CartId   = cartId,
                    ItemId   = addItemToCart.ItemId,
                    Quantity = addItemToCart.Quantity
                });

                return(NoContent());
            }
            catch (ValidationException vex)
            {
                return(BadRequest(vex.Message));
            }
            catch (NotFoundException nex)
            {
                return(NotFound(nex.Message));
            }
        }
        public IActionResult AddItemToCart(
            Guid cartId,
            AddItemToCartModel addItemToCart,
            [FromServices] IRequestHandler <AddItemToCartRequest, AddItemToCartResponse> handler)
        {
            _logger.LogInformation("Starting {actionName}", nameof(AddItemToCart));
            try
            {
                _ = handler.Handle(
                    new AddItemToCartRequest
                    (
                        cartId,
                        addItemToCart.ItemId,
                        addItemToCart.Quantity
                    ));

                return(NoContent());
            }
            catch (ValidationException vex)
            {
                return(BadRequest(vex.Message));
            }
            catch (NotFoundException nex)
            {
                return(NotFound(nex.Message));
            }
            finally
            {
                _logger.LogInformation("Ending {actionName}", nameof(AddItemToCart));
            }
        }
        public async Task <ServiceResult> AddItemToCart(Guid id, [FromBody] AddItemToCartModel apiEntity)
        {
            var result = await _cartService.AddItemToCartAsync(id, apiEntity.ShopItemDetailId, apiEntity.Count ?? 1);

            if (result.TryCastModel(out Cart cart))
            {
                result.ViewModel = CartViewModel.Map(cart);
            }

            return(result);
        }
 public IActionResult AddItemToCart(Guid cartId, AddItemToCartModel addItemToCart)
 {
     _logger.LogInformation("Starting {actionName}", nameof(AddItemToCart));
     try
     {
         _cartsService.AddItemToCart(cartId, addItemToCart.ItemId, addItemToCart.Quantity);
         return(NoContent());
     }
     catch (ValidationException vex)
     {
         return(BadRequest(vex.Message));
     }
     catch (NotFoundException nex)
     {
         return(NotFound(nex.Message));
     }
     finally
     {
         _logger.LogInformation("Ending {actionName}", nameof(AddItemToCart));
     }
 }
示例#6
0
        public IActionResult AddItemToCart(Guid cartId, AddItemToCartModel addItemToCart)
        {
            _logger.LogInformation("Starting {actionName}", nameof(AddItemToCart));
            try
            {
                // do some validations
                if (cartId == default ||
                    addItemToCart.ItemId == default ||
                    addItemToCart.Quantity <= 0)
                {
                    return(BadRequest());
                }

                var cart = _cartRepository.Get(cartId);
                if (cart is null)
                {
                    return(NotFound());
                }

                var item = _itemRepository.Get(addItemToCart.ItemId);
                if (item is null)
                {
                    return(NotFound());
                }

                var cartItem = cart.Items?.FirstOrDefault(i => i.ItemId == addItemToCart.ItemId);
                if (cartItem != null)
                {
                    // item already on cart
                    return(BadRequest());
                }

                _logger.LogInformation("Checking if can add item to cart");

                if ((item.MaximumQuantity ?? int.MaxValue) < addItemToCart.Quantity)
                {
                    return(BadRequest());
                }

                if ((item.MinimumTimeOfDayToSell ?? TimeSpan.Zero) > DateTime.Now.TimeOfDay)
                {
                    return(BadRequest());
                }

                _logger.LogInformation("Adding item to cart");

                // every place we want to add an item, we have the same repeated logic...
                cartItem = new CartItem
                {
                    ItemId   = addItemToCart.ItemId,
                    Quantity = addItemToCart.Quantity
                };

                if (cart.Items is null)
                {
                    cart.Items = new[] { cartItem };
                }
                else
                {
                    cart.Items = cart.Items.Concat(new[] { cartItem });
                }

                _cartRepository.Save(cart);

                _logger.LogInformation("Checking if need to notify someone");
                if (item.IsInWatchlist)
                {
                    _notifier.Notify(item.Id);
                }

                // ...
                return(NoContent());
            }
            finally
            {
                _logger.LogInformation("Ending {actionName}", nameof(AddItemToCart));
            }
        }