Exemple #1
0
        public async Task <IActionResult> RemoveItem([FromBody] RemoveItemModel model)
        {
            var useCase = new RemoveItemFromBasket(model.BasketId, model.ProductId, model.Quantity);
            var cmd     = new Command <RemoveItemFromBasket>(useCase);

            var basket = await _commandHandler.Execute <PendingBasket>(cmd);

            return(Ok(BasketModel.FromAggregateRoot(basket)));
        }
        public IHttpActionResult RemoveItem([FromBody] RemoveItemModel model)
        {
            var cmd = new RemoveItemFromBasket(
                model.BasketId,
                model.ProductId,
                model.Quantity);

            var basket = _commandDispatcher.ExecuteCommand <BasketAggregate>(cmd);

            return(Ok(BasketModel.FromAggregate(basket)));
        }
Exemple #3
0
        private BasketEvent RemoveItemToBasketAction(RemoveItemFromBasket message)
        {
            var basketItem = BasketState.Items.Find(item => item.Id == message.BasketItemId);

            switch (basketItem)
            {
            case BasketItem _:
                BasketState.Items.Remove(basketItem);
                return(new ItemRemoved());

            default:
                return(new ItemNotFound());
            }
        }
        public BasketEvent RemoveItemToBasketAction(RemoveItemFromBasket message)
        {
            var basketItem = this.BasketState.Items.Find(item => item.Id == message.BasketItemId);

            if (basketItem is BasketItem)
            {
                this.BasketState.Items.Remove(basketItem);
                return(new ItemRemoved());
            }
            else
            {
                return(new ItemNotFound());
            }
        }
Exemple #5
0
        public void When_RemoveItemBelowZero_ItemRemoved()
        {
            Given(InitialEvents.ToArray());

            var command = new RemoveItemFromBasket(id, productId, 15);

            command.Metadata.CausationId   = command.Metadata.CommandId;
            command.Metadata.CorrelationId = causationAndCorrelationId;

            When(command);

            var expectedEvent = new BasketItemRemoved(id, productId, 10);

            expectedEvent.Metadata.CausationId   = command.Metadata.CommandId;
            expectedEvent.Metadata.CorrelationId = causationAndCorrelationId;
            expectedEvent.Metadata.ProcessId     = command.Metadata.ProcessId;

            Then(expectedEvent);
        }
Exemple #6
0
        internal void RemoveItemFromBasket(RemoveItemFromBasket cmd)
        {
            if (State != BasketState.Pending)
            {
                throw new InvalidStateException(AggregateId, $"Cannot remove item. Basket is {State}");
            }

            var basketId  = cmd.AggregateId;
            var productId = cmd.ProductId;
            var quantity  = cmd.Quantity;

            var orderLine = OrderLines.SingleOrDefault(ol => ol.ProductId == productId);

            if (orderLine != null)
            {
                if (orderLine.Quantity < quantity)
                {
                    quantity = orderLine.Quantity;
                }
                RaiseEvent(new BasketItemRemoved(basketId, productId, quantity));
            }
        }