Exemple #1
0
        public async Task <IActionResult> Update([FromRoute] Int64 cartItemId, [FromBody] UpdateCartItemRequest updateCartItem)
        {
            var item = await _cartItemService.GetCarItemtByIdAsync(cartItemId);

            if (item != null)
            {
                var CartItem = new CartItem
                {
                    Id        = cartItemId,
                    CartId    = item.CartId,
                    ProductId = item.ProductId,
                    Quantity  = updateCartItem.Quantity,
                    UpdatedAt = DateTime.Now
                };

                var status = await _cartItemService.UpdateCartItemAsync(CartItem);


                if (status == 1)
                {
                    return(Ok(CartItem));
                }
            }
            return(NotFound(new ErrorResponse
            {
                message = "Not Found",
                status = NotFound().StatusCode
            }));
        }
        public async Task <IActionResult> UpdateCartItem([FromRoute] string cartId, [FromBody] UpdateCartItemRequest payload)
        {
            _logger.LogInformation("UpdateCartItem: {cartId} {@payload}", cartId, payload);

            var cart = await _cartRepository.UpdateCartItem(cartId, payload);

            var response = _mapper.Map <CartResponse>(cart);

            _logger.LogInformation("UpdateCartItem: {@response}", response);

            return(Ok(response));
        }
Exemple #3
0
        public async Task <Entities.Cart> UpdateCartItem(string cartId, UpdateCartItemRequest payload)
        {
            var databaseCart = await GetCartById(cartId);

            if (databaseCart == null)
            {
                throw new CartNotFoundException($"Cart {cartId} not found");
            }

            if (databaseCart.Status != STATUS_PENDING)
            {
                throw new InvalidCartException($"Cart {databaseCart.Id} has status {databaseCart.Status}");
            }

            var requiredCartItem = databaseCart.Items.SingleOrDefault(item => item.Product.SKU == payload.SKU);

            if (requiredCartItem == null && payload.Quantity > 0)
            {
                var product = await GetProductBySKU(payload.SKU);

                var newCartItems = new List <CartItem>(databaseCart.Items);

                newCartItems.Add(new CartItem()
                {
                    Price    = product.Price.Amount * payload.Quantity,
                    Quantity = payload.Quantity,
                    Scale    = product.Price.Scale,
                    Product  = product
                });

                databaseCart.Items = newCartItems;
            }
            else if (requiredCartItem != null)
            {
                requiredCartItem.Quantity += payload.Quantity;
                requiredCartItem.Price     = requiredCartItem.Product.Price.Amount * requiredCartItem.Quantity;

                if (requiredCartItem.Quantity <= 0)
                {
                    databaseCart.Items = databaseCart.Items.Where(cartItem => cartItem.Product.SKU != payload.SKU);
                }
            }
            else
            {
                return(databaseCart);
            }

            await _cartsCollection.ReplaceOneAsync(cart => cart.Id == cartId, databaseCart);

            return(databaseCart);
        }