public void Handle(OrderCreated message)
{
Receive(message, m =>
{
if (IsCancelled)
{
return;
}
LineItems = m.LineItems
.Select(li => new LineItem
{
ProductId = li.ProductId,
AmountRequested = li.Quantity
})
.ToList();
foreach (var lineItem in LineItems)
{
Send(new StockRequest
{
Id = Guid.NewGuid(),
ProductId = lineItem.ProductId,
AmountRequested = lineItem.AmountRequested,
OrderFulfillmentId = Id
});
}
});
}
public void Handle(OrderCreated evnt)
{
_connection.Insert(
new { Id = evnt.Id, Customer = evnt.Customer, CreatedTime = evnt.CreatedTime },
"eventsourcing_sample_order",
_transaction);
}
public Order(Guid id)
{
var e = new OrderCreated(id);
Apply(e);
AddEvent(e);
}
public void When(OrderCreated @event)
{
Id = @event.AggregateId;
CreatedOn = @event.CreatedOn;
OrderNumber = @event.OrderNumber;
Owner = @event.Owner;
}
public void When_OrderCreated_ReserveProducts()
{
AggregateRepository.CreateGuid = () => orderId;
SetupPreviousEvents();
orderId = AddProcessedEvent <BasketAggregate>(new BasketCheckedOut(basketId, OrderLines, shippingAddress));
var nonProcessedEvent = new OrderCreated(orderId, basketId, shippingAddress);
AddPreviousEvent <OrderAggregate>(nonProcessedEvent);
SetInitalMetadata();
Given(_initialEvents.ToArray());
WhenProcessed(nonProcessedEvent);
var expectedCommands = new List <ICommand> {
new ReserveProduct(productOneId, 10), new ReserveProduct(productTwoId, 20),
};
var expectedEvents = new List <IEvent> {
new EventProcessed(orderId, nonProcessedEvent)
};
SetMetadata(nonProcessedEvent, expectedCommands, expectedEvents);
Then(expectedCommands.ToArray());
Then(expectedEvents.ToArray());
}
public async Task Handle(OrderCreated notification, CancellationToken cancellationToken)
{
// DO WORK HERE
IEnumerable <ISagaContextMetadata> metadata = new List <ISagaContextMetadata>();
await _coordinator.ProcessAsync(notification,
SagaContext.Create((SagaId)notification.OrderId.ToString(), notification.GetType().Name, metadata));
}
protected override void OnCommand(object message)
{
switch (message)
{
case CreateNewOrder m:
{
var orderCreated = new OrderCreated(m.CustomerId, m.OrderId);
Context.PublishEvent(orderCreated);
Persist(orderCreated, CreateNewOrder);
}
break;
case IOrderMessage m:
{
var actor = GetExistingOrderActor(m);
actor.Forward(m);
}
break;
case Terminated m:
{
var msg = m;
var terminatedOrderId = _actorsToOrders.First(x => Equals(x.Value, m.ActorRef));
_actorsToOrders.Remove(terminatedOrderId);
}
break;
default:
Unhandled(message);
break;
}
}
protected void CreateNewOrder(OrderCreated message)
{
var newActor = Context.ActorOf(OrderActor.Props(message.OrderId, message.CustomerId));
Context.Watch(newActor);
_actorsToOrders[message.OrderId] = newActor;
}
public void Handle(OrderCreated @event)
{
using (var context = _contextFactory.Invoke())
{
var identicalAddresses = from a in context.Query <AddressDetails>()
where a.AccountId == @event.AccountId
where (a.Apartment ?? string.Empty) == (@event.PickupAddress.Apartment ?? string.Empty)
where a.FullAddress == @event.PickupAddress.FullAddress
where (a.RingCode ?? string.Empty) == (@event.PickupAddress.RingCode ?? string.Empty)
// ReSharper disable once CompareOfFloatsByEqualityOperator
where a.Latitude == @event.PickupAddress.Latitude
// ReSharper disable once CompareOfFloatsByEqualityOperator
where a.Longitude == @event.PickupAddress.Longitude
select a;
if (!identicalAddresses.Any())
{
var address = new AddressDetails();
Mapper.Map(@event.PickupAddress, address);
address.Id = Guid.NewGuid();
address.AccountId = @event.AccountId;
address.IsHistoric = true;
context.Save(address);
}
}
}
public async Task Handle(CreateOrder message, IMessageHandlerContext context)
{
Log.Info($"Received {nameof(CreateOrder)}, OrderId = {message.OrderId}, created by {message.CreatedBy} on {message.CreatedOn}");
try
{
/*
* var command = new ShipOrder
* {
* OrderId = Guid.NewGuid().ToString(),
* CreatedBy = "Mohammed",
* CreatedOn = DateTime.Now
* };
*
* await context.Send(command).ConfigureAwait(false);*/
// Perform task(s) to create order and publish a "created" event.
var orderCreatedEvent = new OrderCreated
{
OrderId = Guid.NewGuid().ToString(),
CreatedBy = "Mohammed",
CreatedOn = DateTime.Now
};
await context.Publish(orderCreatedEvent);
}
catch (Exception e)
{
Log.Error(e.Message, e);
throw;
}
// return Task.CompletedTask;
}
public void when_order_created_no_duplicate_address_is_added_to_history_even_if_optional_fields_are_not_set()
{
var command = new OrderCreated
{
SourceId = Guid.NewGuid(),
AccountId = Guid.NewGuid(),
PickupAddress = new Address {
FullAddress = "1234 rue Saint-Hubert"
},
CreatedDate = DateTime.Now.AddDays(-1)
};
// Use the same address twice
Sut.Handle(command);
Sut.Handle(command);
using (var context = new BookingDbContext(DbName))
{
var list =
context.Query <AddressDetails>().Where(
x => x.AccountId == command.AccountId && x.IsHistoric.Equals(true));
Assert.AreEqual(1, list.Count());
var dto = list.Single();
Assert.AreEqual(command.AccountId, dto.AccountId);
Assert.AreEqual(null, dto.Apartment);
Assert.AreEqual("1234 rue Saint-Hubert", dto.FullAddress);
Assert.AreEqual(null, dto.RingCode);
Assert.AreEqual(default(double), dto.Latitude);
Assert.AreEqual(default(double), dto.Longitude);
}
}
public Order(Guid id, Guid userId, string number, decimal price)
{
var @event = new OrderCreated(id, userId, number, price);
Enqueue(@event);
Apply(@event);
}
internal void ApplyOrderCreated(IDomainEvent evt)
{
OrderCreated createdEvet = evt as OrderCreated;
Id = createdEvet?.AggregateId;
CustomerId = createdEvet?.CustomerId;
}
public Task Handle(OrderCreated message, IMessageHandlerContext context)
{
Data.OrderId = message.OrderId;
Data.OrderCreated = true;
return(Task.CompletedTask);
}
public async Task Handle(CreateOrder command)
{
Domain.Order order = new Domain.Order
{
Id = Guid.NewGuid(),
BookId = command.BookId
};
try
{
await _repository.Add(order);
OrderCreated orderCreated = new OrderCreated
{
OrderId = order.Id,
TransactionId = command.TransactionId
};
await _bus.PublishAsync(orderCreated);
}
catch (Exception exception)
{
CreateOrderFailed failed = new CreateOrderFailed
{
OrderId = order.Id,
Message = exception.Message
};
await _bus.PublishAsync(failed);
}
}
public void when_converting_to_a_storage_event_it_succeeds()
{
var id = Guid.NewGuid();
var body = new OrderCreated("TEST-ORDER");
var metadata = new TestMetadata {
Value = "TEST-VALUE"
};
var sut = new DocumentDbStorageEvent
{
StreamId = "TEST-STREAM",
Body = JObject.FromObject(body),
BodyType = "OrderCreated",
Metadata = JObject.FromObject(metadata),
MetadataType = "TestMetadata",
EventNumber = 1,
EventId = id
};
var typeMap = new ConfigurableSerializationTypeMap().RegisterTypes(
typeof(OrderCreated).GetTypeInfo().Assembly,
t => t.Namespace != null && t.Namespace.EndsWith("Events"),
t => t.Name);
var result = sut.ToStorageEvent(typeMap);
Assert.That(result.StreamId, Is.EqualTo(sut.StreamId));
Assert.That(((OrderCreated)result.EventBody).OrderId, Is.EqualTo(body.OrderId));
Assert.That(((TestMetadata)result.Metadata).Value, Is.EqualTo(metadata.Value));
Assert.That(result.EventNumber, Is.EqualTo(sut.EventNumber));
Assert.That(result.EventId, Is.EqualTo(sut.EventId));
}
private void CreateOrder(Order order)
{
order.Status = OrderStatus.Created;
order.Time = DateTime.UtcNow;
orders.Add(order);
Console.WriteLine($"order added to book: {order}");
var bid = WorkingOrders(Side.Buy).FirstOrDefault();
if (bid != null && bid.Price > sessionMaxBidPrice)
{
sessionMaxBidPrice = bid.Price;
}
var ask = WorkingOrders(Side.Sell).FirstOrDefault();
if (ask != null && ask.Price > sessionMinAskPrice)
{
sessionMinAskPrice = ask.Price;
}
OrderCreated?.Invoke(this, new OrderCreatedEventArgs(order));
}
public async Task HandleAsync(CreateOrder command)
{
var exists = await _repository.ExistsAsync(o => o.Id == command.OrderId);
if (exists)
{
throw new InvalidOperationException($"Order with given id: {command.OrderId} already exists!");
}
_logger.LogInformation($"Fetching a price for order with id: {command.OrderId}...");
var pricingDto = await _pricingServiceClient.GetAsync(command.OrderId);
if (pricingDto is null)
{
throw new InvalidOperationException($"Pricing was not found for order: {command.OrderId}");
}
_logger.LogInformation($"Order with id: {command.OrderId} will cost: {pricingDto.TotalAmount}$.");
var order = new Order(command.OrderId, command.CustomerId, pricingDto.TotalAmount);
await _repository.AddAsync(order);
_logger.LogInformation($"Created an order with id: {command.OrderId}, customer: {command.CustomerId}.");
var spanContext = _tracer.ActiveSpan.Context.ToString();
var @event = new OrderCreated(order.Id);
if (_outbox.Enabled)
{
await _outbox.SendAsync(@event, spanContext : spanContext);
return;
}
await _publisher.PublishAsync(@event, spanContext : spanContext);
}
public Task Handle(OrderCreated message, IMessageHandlerContext context)
{
Log.Info($"Received {nameof(OrderCreated)} event/message");
Data.OrderCreated = true;
// return Task.CompletedTask;
return(ProcessOrder(context));
}
public Order(Guid id)
{
for (int i = 0; i < 2; i++)
{
var @event = new OrderCreated(id, "1", "remark");
Enqueue(@event);
}
}
public async Task HandleAsync(OrderCreated message, ISagaContext context)
{
var tasks = Data.ParcelIds.Select(id =>
_publisher.SendAsync(new AddParcelToOrder(Data.OrderId, id, Data.CustomerId),
_accessor.CorrelationContext));
await Task.WhenAll(tasks);
}
public async Task <IActionResult> OrderCreated([FromBody] OrderCreatedDTO dto)
{
// [FromRoute] Guid id
var notification = new OrderCreated(dto.OrderId);
await _mediator.Publish(notification);
return(Ok());
}
public string CreateJson(string orderId, string sellerId)
{
var obj = new OrderCreated();
obj.OrderId = orderId;
obj.SellerId = sellerId;
return(JsonSerializer.Serialize(obj));
}
public void When(OrderCreated @event)
{
this.Id = @event.EntityId;
this.TableNo = @event.TableNo;
this.Status = OrderStatus.Initial;
this.orderItems = @event.OrderItems?.ToList() ?? new List <OrderItem>();
this.CreatedDate = @event.CreatedDate;
}
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 void NotifyOrderCreated()
{
var bus = BusManager.Instance;
var evt = new OrderCreated();
bus.Publish(evt);
bus.Publish(evt);
}
private static ProcessBurgerOrder CreateProcessBurgerOrder(OrderCreated burgerOrder)
{
return(new ProcessBurgerOrder
{
CorrelationId = burgerOrder.AggregateId,
OrderId = burgerOrder.AggregateId,
OrderDate = burgerOrder.Timestamp,
});
}
public void Should_throw_for_missing_correlation()
{
var @event = new OrderCreated(Guid.NewGuid(), 100, 0, 0);
var definition = new OrderProcessManagerNoCorrelation();
var instance = new Instance <OrderProcessManagerData>(definition);
Action act = () => instance.ProcessEvent(@event);
act.Should().Throw <Exception>();
}
private void Apply(OrderCreated evt)
{
State = OrderState.Pending;
OrderLines = new List <OrderLine>();
AggregateId = evt.AggregateId;
BasketId = evt.BasketId;
ProcessId = evt.Metadata.ProcessId;
ShippingAddress = evt.ShippingAddress;
}
public async Task Handle(OrderCreated notification, CancellationToken cancellationToken)
{
IEnumerable <ISagaContextMetadata> metadata = new List <ISagaContextMetadata>();
await _coordinator.ProcessAsync(notification,
SagaContext.Create((SagaId)notification.OrderId.ToString(), notification.GetType().Name, metadata));
// once every thing is processed in the handler, commit changes to DB.
// This can be moved else where depending on the user needs.
await SagaUnitOfWork.CommitAsync();
}
public void setStateHandler_on_first_event()
{
var @event = new OrderCreated(Guid.NewGuid(), 100, 0, 0);
var definition = new OrderProcessManager2();
var instance = new Instance <OrderProcessManagerData>(definition);
instance.ProcessEvent(@event);
instance.Data.Amount.Should().Be(100);
}
public void InsertOrUpdate(OrderCreated ordercreated)
{
if (ordercreated.Id == default(System.Guid)) {
// New entity
ordercreated.Id = Guid.NewGuid();
context.OrderCreateds.Add(ordercreated);
} else {
// Existing entity
context.Entry(ordercreated).State = EntityState.Modified;
}
}
public ActionResult Create(OrderCreated ordercreated)
{
if (ModelState.IsValid) {
ordercreatedRepository.InsertOrUpdate(ordercreated);
ordercreatedRepository.Save();
return RedirectToAction("Index");
} else {
ViewBag.PossibleWaiters = waiterRepository.All;
ViewBag.PossibleRestaurants = restaurantRepository.All;
return View();
}
}
async private Task<ICommandHandler> Handle(OrderCreated e)
{
var envelope = new EventEnvelope<OrderCreated>
{
Timestamp = DateTime.UtcNow
,
Event = e
,
Username = "******"
};
return await ((ICommandHandler)this).Handle(envelope);
}
private void Handle(OrderCreated evt)
{
var existinBasket = _indexer.Get<Basket>(evt.BasketId);
existinBasket.BasketState = BasketState.Paid;
_indexer.Index(existinBasket);
_graphClient.Cypher
.Match("(customer:Customer)-[:HAS_BASKET]->(basket:Basket)-[]->(product:Product)")
.Where((Basket basket) => basket.Id == evt.BasketId)
.Create("customer-[:BOUGHT]->product")
.ExecuteWithoutResults();
}
public ProcessProductRequest[] Split(OrderCreated message)
{
var parts = from m in message.OrderItems
select new ProcessProductRequest() {OrderId = message.Id, Pieces = m.Pieces, ProductId = m.Product};
return parts.ToArray();
}
private void Apply(OrderCreated obj)
{
_orderState = OrderState.Created;
Id = obj.Id;
}
protected virtual void Handle(OrderCreated evnt)
{
_entityManager.BuildAndSave<OrderEntity>(evnt);
}
