Esempio n. 1
0
 private void Handle(ProductQuantityChanged @event)
 {
     if (TryGetOrderItem(@event.Sku, out var item))
     {
         item.Quantity = @event.To;
     }
 }
Esempio n. 2
0
        internal void ApplyProductQuantityChanged(IDomainEvent ev)
        {
            ProductQuantityChanged pqChangedEvent = ev as ProductQuantityChanged;
            var existingItem = Items.Single(x => x.ProductId == pqChangedEvent?.ProductId);

            Items.Remove(existingItem);
            Items.Add(existingItem.WithQuantity(pqChangedEvent?.NewQuantity ?? 0));
        }
        private void OnProductQuantityChanged(ProductQuantityChanged evt)
        {
            var product = GetProduct(evt);

            product.Quantity       += evt.Difference;
            product.LastEventNumber = evt.Metadata.EventNumber;
            _ctx.SaveChanges();
        }
Esempio n. 4
0
        public async Task HandleAsync(ProductQuantityChanged @event)
        {
            var cartItemId = OrderItemReadModel.IdFor(@event.AggregateId.IdAsString(), @event.ProductId.IdAsString());
            var cartItem   = (await orderItemRepository
                              .FindAllAsync(x => x.Id == cartItemId))
                             .Single();
            var cart = await orderRepository.GetByIdAsync(@event.AggregateId.IdAsString());

            cart.TotalItems  += @event.NewQuantity - @event.OldQuantity;
            cartItem.Quantity = @event.NewQuantity;

            await orderRepository.UpdateAsync(cart);

            await orderItemRepository.UpdateAsync(cartItem);
        }
Esempio n. 5
0
        public Task OnProductQuantityChanged(ProductQuantityChanged e)
        {
            Console.WriteLine($"{_count++}: receive ProductQuantityChanged.");

            using (var session = new Session(_connectionFactory))
            {
                const string sql = @"
                    update products
                       set quantity = @Quantity
                     where id = @Id";

                return(session.ExecuteAsync(sql, new
                {
                    Id = e.AggregateRootId,
                    Quantity = e.Target.Value
                }));
            }
        }
Esempio n. 6
0
        public void When_AddProductToStock_ProductQuantityChanged()
        {
            Given(new ProductCreated(id, "Test Product", 2));

            var command = new AddProductToStock(id, 5);

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

            When(command);

            var expectedEvent = new ProductQuantityChanged(id, 5);

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

            Then(expectedEvent);
        }
Esempio n. 7
0
 private void Apply(ProductQuantityChanged evt)
 {
     Quantity += evt.Difference;
 }