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);
}
