public void RunMultipleTimes() { Ioc.Configure <Demo.V4.V4Registry>(); var handler = Ioc.Container.GetInstance <V4.CreateInvoiceWhenSalesOrderShipped>(); var evt = new OrderShipped { OrderId = 1, ShippingType = ShippingType.Standard }; var allResults = new int[100] .Select(o => handler.HandleInternal(evt)) .ToArray(); var aggregate = allResults.Aggregate(); aggregate.IsFailure.Should().BeTrue(); Console.WriteLine(new string('-', 20)); Console.WriteLine("Failures: " + string.Join(Environment.NewLine, aggregate.Failure.GroupBy(o => o) .OrderByDescending(o => o.Count()) .Select(o => $"{o.Key}: {o.Count()}"))); Console.WriteLine(new string('-', 20)); var successes = allResults.Where(o => o.IsSuccess).Aggregate(); successes.IsSuccess.Should().BeTrue(); Console.WriteLine($"Successes: {successes.Success.Count()}"); }
private static void Handle <T>(OrderShipped evt) where T : Registry, new() { Ioc.Configure <T>(); var handler = Ioc.Container.GetInstance <IHandler <OrderShipped> >(); handler.Handle(evt); }
public Task Handle(OrderShipped message, IMessageHandlerContext context) { Logger.Log($"OrderProcessManager: Order {Data.OrderId} and type {Data.ChocolateType} on partition { PartitionInformation.Name } done."); MarkAsComplete(); return(Task.CompletedTask); }
private void OrderShipped(OrderShipped message) { EventLog.Add("Order Shipped"); var order = Program.system.ActorOf(Props.Create(() => new EmailActor($"{OrderId}"))); order.Tell(new SendEmailItemShipped()); }
public string createJson(string orderID, string sellerID) { var obj = new OrderShipped(); obj.OrderId = orderID; obj.SellerId = sellerID; return(JsonSerializer.Serialize(obj)); }
private void OnOrderShipped(OrderShipped evt) { var order = GetOrder(evt); order.State = "Shipped"; order.LastEventNumber = evt.Metadata.EventNumber; _ctx.SaveChanges(); }
private void TestEventSourcing(IDocumentStore store) { var userId = Guid.NewGuid(); var streamId = Guid.NewGuid(); var catalogId1 = Guid.NewGuid(); var catalogId2 = Guid.NewGuid(); var orderId = Guid.NewGuid(); using var session = store.OpenSession(); var catalogAdded1 = new CatalogAdded { CatalogId = catalogId1, Quantity = 5, UserId = userId }; var catalogAdded2 = new CatalogAdded { CatalogId = catalogId2, Quantity = 3, UserId = userId }; // Assume user adds 2 catalog first session.Events.StartStream(streamId, catalogAdded1, catalogAdded2); session.SaveChanges(); var catalogRemoved = new CatalogRemoved { CatalogId = catalogId1, Quantity = 2, UserId = userId }; var orderCreated = new OrderCreated { UserId = userId, OrderId = orderId, TotalMoney = 10000000 }; var orderChangeStatus = new OrderStatusChangeToPaid { OrderId = orderId }; var orderConfirmed = new OrderConfirmed { OrderId = orderId }; var orderShipped = new OrderShipped { OrderId = orderId }; var orderCompleted = new OrderCompleted { OrderId = orderId }; session.Events.Append(streamId, orderCreated, catalogRemoved, orderChangeStatus, orderConfirmed, orderShipped, orderCompleted); session.SaveChanges(); }
public string createJson(string orderID, string sellerID) { //var date1 = new DateTime(); var obj = new OrderShipped(); obj.OrderId = orderID; obj.ActualShipDate = DateTime.Now; obj.SellerId = sellerID; return(JsonSerializer.Serialize(obj)); }
public void Handle(ShipOrder message) { var orderShipped = new OrderShipped { Id = message.OrderId, ShippingDate = DateTime.UtcNow, }; session.Save(orderShipped); }
public Task Handle(ShipOrder message, IMessageHandlerContext context) { var session = context.SynchronizedStorageSession.RavenSession(); var orderShipped = new OrderShipped { OrderId = message.OrderId, ShippingDate = DateTime.UtcNow, }; return(session.StoreAsync(orderShipped)); }
private void Apply(OrderShipped evt) { _state = OrderAggregate.OrderState.Shipped; var reservedOrders = _orderLines.Values.Where(ol => _reservations.Any(r => r.Key == ol.ProductId && r.Value)); foreach (var ol in reservedOrders) { DispatchCommand <ProductAggregate>(new PurchaseReservedProduct(ol.ProductId, ol.Quantity)); } DispatchCommand <DummyNotifier>(new NotifyCustomer(AggregateRepository.CreateGuid())); }
public void Handle(OrderAccepted message) { log.Info($"Shipping order {message.OrderId} for {message.Value}"); chaos.Invoke(); var orderShipped = new OrderShipped { OrderId = message.OrderId, Value = message.Value }; bus.Publish(orderShipped); }
public void when_predicate_false_should_not_complete() { var orderId = Guid.NewGuid(); var orderCreated = new OrderCreated(orderId, 100, 0, 0); var orderShipped = new OrderShipped(orderId, DateTime.Parse("2019-09-09")); var definition = new OrderProcessManager7(); var instance = new Instance <OrderProcessManagerData>(definition); instance.ProcessEvent(orderCreated); instance.ProcessEvent(orderShipped); instance.State.Should().Be(InstanceStates.Started); }
public Task Handle(ShipOrder message, IMessageHandlerContext context) { var session = context.SynchronizedStorageSession.Session(); var orderShipped = new OrderShipped { Id = message.OrderId, ShippingDate = DateTime.UtcNow, }; session.Save(orderShipped); return(Task.CompletedTask); }
public CommandHandlingResult Ship() { if (this.Status != OrderStatus.Completed) { return(CommandHandlingResult.Fail("Error: only completed orders can be shipped.")); } var e = new OrderShipped(this.OrderNumber); Handle(e); return(CommandHandlingResult.Success(e)); }
public async Task Handle(ShipOrder message, IMessageHandlerContext context) { Log.Info($"******************* Received ShipOrder, OrderId = {message.OrderId} ******************"); Thread.Sleep(25000); // cause OrderShippingPickupTimeExceeded to happen before OrderShipped var orderShipped = new OrderShipped { OrderId = message.OrderId }; await context.Publish(orderShipped); }
public void HandleMessage(PlaceOrder message) { if (_pickListService.GetPickLists(message.OrderId) .Any()) { return; } Console.WriteLine("Place order."); Customer customer = _customerService .GetCustomer( message.CustomerName, message.CustomerAddress); List <OrderLine> orderLines = message.Lines .Select(line => new OrderLine { Customer = customer, Product = _productService .GetProduct( line.ProductNumber), Quantity = line.Quantity }) .ToList(); List <PickList> pickLists = _inventoryAllocationService .AllocateInventory( message.OrderId, orderLines); _pickListService.SavePickLists(pickLists); var orderShippedEvent = new OrderShipped { OrderId = message.OrderId, OrderDate = message.OrderDate, CustomerName = message.CustomerName, CustomerAddress = message.CustomerAddress, Shipments = pickLists .Select(p => new Messages.Shipment { ProductNumber = p.Product.ProductNumber, Quantity = p.Quantity, TrackingNumber = "123-45" }) .ToList() }; _subscriptionRegistry.Publish(orderShippedEvent); }
public async Task Handle(OrderAccepted message, IMessageHandlerContext context) { log.Info($"Shipping order {message.OrderId} for {message.Value}"); await chaos.Invoke() .ConfigureAwait(false); var orderShipped = new OrderShipped { OrderId = message.OrderId, Value = message.Value }; await context.Publish(orderShipped) .ConfigureAwait(false); }
private async void Handle(OrderShipped e) { Console.WriteLine($"Order #{e.OrderNumber} shipped."); using (var dbContext = new StoreDBContext()) { var order = dbContext.Orders.FirstOrDefault(o => o.OrderNumber == e.OrderNumber); if (order != null) { order.Status = "Shipped"; await dbContext.SaveChangesAsync(); } } }
public void ProcessEvent() { OrderShipped orderShipped = JsonSerializer.Deserialize <OrderShipped>(JsonString); var db = mongo.GetDatabase("SellersDatabase"); var collection = db.GetCollection <Object>("SellersOrders"); var findSellerFilter = Builders <Object> .Filter.Eq("SellerId", orderShipped.SellerId); var sellerDocument = (Seller)collection.Find <Object>(findSellerFilter).FirstOrDefault(); if (sellerDocument == null) { Seller seller = new Seller(); seller.SellerId = orderShipped.SellerId; collection.InsertOne(seller); sellerDocument = (Seller)collection.Find <Object>(findSellerFilter).FirstOrDefault(); } var findOrderFilter = Builders <Object> .Filter.Eq("OrderId", orderShipped.OrderId); var orderDocument = (Order)collection.Find <Object>(findOrderFilter).FirstOrDefault(); if (orderDocument == null) { try { // adding a new order Order order = new Order(); order.OrderId = orderShipped.OrderId; order.ActualShipDate = orderShipped.ActualShipDate; order.SellerId = sellerDocument.Id.ToString(); // insert collection.InsertOne(order); } catch (Exception e) { Console.WriteLine(e.Message); } } else { // update information in the order var updmanyresult = collection.UpdateMany( Builders <Object> .Filter.Eq("OrderId", orderShipped.OrderId), Builders <Object> .Update .Set("ActualShipDate", orderShipped.ActualShipDate)); } }
public async Task HandleOrderShippedMessageCorrectly() { AssumeSagaCanBeMatched(); var context = new TestableMessageHandlerContext(); var message = new OrderShipped { OrderId = _orderId, }; await _target.Handle(message, context); await _orderHubMessageDispatcher.Received().SendToGroupAsync(UserId, "StatusUpdated", Arg.Is <OrderStatus>(s => s.OrderId == message.OrderId && s.Status == "Order Shipped")); _target.Completed.Should().BeTrue(); }
private async void Handle(OrderShipped e) { Console.WriteLine($"Order #{e.OrderNumber} shipped."); using (var dbContext = new StoreDBContext()) { var order = dbContext.Orders.FirstOrDefault(o => o.OrderNumber == e.OrderNumber); if (order != null) { // here shipping should be handled // e.g. a shipping manifest for the shipping provider is printed order.Shipped = true; await dbContext.SaveChangesAsync(); } } }
public void When_ShipOrder_OrderShipped() { Given(InitialEvents); var command = new ShipOrder(id); command.Metadata.CausationId = command.Metadata.CommandId; command.Metadata.CorrelationId = causationAndCorrelationId; When(command); var expectedEvent = new OrderShipped(id); expectedEvent.Metadata.CausationId = command.Metadata.CommandId; expectedEvent.Metadata.CorrelationId = causationAndCorrelationId; expectedEvent.Metadata.ProcessId = command.Metadata.ProcessId; Then(expectedEvent); }
public async Task Handle(OrderConfirmed message, IMessageHandlerContext context) { var orderToShip = await orders.GetById(message.OrderId); if (orderToShip == null) { throw new Exception($"Order {message.OrderId} was not received yet."); } orderToShip.State = OrderState.Shipped; await orders.Update(orderToShip); this.log.Info($"Shipped {orderToShip.Products.Count} items to customer {orderToShip.CustomerId} (order {orderToShip.OrderId})"); var shippedOrder = new OrderShipped { OrderId = message.OrderId }; await context.Publish(shippedOrder); }
public void When_OrderShipped_DecreaseProductQuantity_And_NotifyCustomer() { var notificationId = Guid.NewGuid(); AggregateRepository.CreateGuid = () => notificationId; SetupPreviousEvents(); orderId = AddProcessedEvent <BasketAggregate>(new BasketCheckedOut(basketId, OrderLines, shippingAddress)); AddProcessedEvent <OrderAggregate>(new OrderCreated(orderId, basketId, shippingAddress), orderId); AddProcessedEvent <ProductAggregate>(new ProductReserved(productOneId, 10), orderId); AddProcessedEvent <OrderAggregate>(new OrderLineAdded(orderId, OrderLines[0]), orderId); AddProcessedEvent <ProductAggregate>(new ProductReserved(productTwoId, 20), orderId); AddProcessedEvent <OrderAggregate>(new OrderLineAdded(orderId, OrderLines[1]), orderId); AddProcessedEvent <OrderAggregate>(new OrderReadyForShipping(orderId), orderId); var evt = new OrderShipped(orderId); AddPreviousEvent <OrderAggregate>(evt); SetInitalMetadata(); Given(_initialEvents.ToArray()); WhenProcessed(evt); var expectedCommands = new List <ICommand> { new PurchaseReservedProduct(productOneId, 10), new PurchaseReservedProduct(productTwoId, 20), new NotifyCustomer(notificationId) }; var expectedEvents = new List <IEvent> { new EventProcessed(orderId, evt) }; SetMetadata(evt, expectedCommands, expectedEvents); Then(expectedCommands.ToArray()); Then(expectedEvents.ToArray()); }
private void Handle(OrderShipped e) { this.Status = OrderStatus.Shipped; }
public void Handle(OrderShipped message) { Logger.InfoFormat("Order {0}: Order shipped to customer", Data.OrderId); }
private void Apply(OrderShipped evt) { State = OrderState.Shipped; }
public async Task Handle(OrderShipped message, IMessageHandlerContext context) { Data.Status = "Order Shipped"; MarkAsComplete(); await SendStatusUpdate().ConfigureAwait(false); }
private void OnOrderShipped(OrderShipped evt) { _orderProcessEventHandler.HandleEvent <OrderShipped, OrderProcessManager>(evt); SetLastEventNumber(evt); }