private async void handleCreateOrderCommand(CreateOrderCommand createOrderCommand)
{
OrderCreatedEvent orderCreatedEvent = Order.processCreateOrderCommand(createOrderCommand);
#if (!DEBUG)
try
{
await _orderRepository.InsertOneAsync(orderCreatedEvent.order);
}
catch (Exception ex)
{
Console.WriteLine($"Error occured with MongoDB: {ex}");
}
#endif
orderCreatedEvent.getEvents().ForEach(e =>
{
if (e.eventType == EventType.BEVERAGE_ORDER_IN)
{
sendBaristaOrder(e);
}
else if (e.eventType == EventType.KITCHEN_ORDER_IN)
{
sendKitchenOrder(e);
}
});
}
private void ProccessSubscription(OrderCreatedEvent order)
{
using var scope = factory.CreateScope();
var context = scope.ServiceProvider.GetRequiredService <AppDbContext>();
using var transaction = context.Database.BeginTransaction();
try
{
context.Client.Add(new Client
{
OrderId = order.Id,
Name = order.Subscription.Name,
SubscriptionId = order.Subscription.Id,
Address = order.Subscription.Address,
Domain = order.Subscription.Domain,
IntegrationApiKey = new Random().Next(1, 999999)
});
context.SaveChanges();
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
}
}
public void ProcessMessage(IHandlerContext <CreateOrderCommand> context)
{
// simulate slow processing
Thread.Sleep(1000);
var message = context.Message;
var order = new Order(message.OrderNumber, message.OrderDate)
{
Customer = new OrderCustomer(message.CustomerName, message.CustomerEMail)
};
foreach (var item in message.Items)
{
order.AddItem(item.Description, item.Price);
}
using (_databaseContextFactory.Create(OrderingData.ConnectionStringName))
{
_repository.Add(order);
}
var orderCreatedEvent = new OrderCreatedEvent
{
OrderId = order.Id,
OrderNumber = message.OrderNumber,
OrderDate = message.OrderDate,
CustomerName = message.CustomerName,
CustomerEMail = message.CustomerEMail
};
orderCreatedEvent.Items.AddRange(message.Items);
context.Publish(orderCreatedEvent);
}
internal void Apply(OrderCreatedEvent ev)
{
id = ev.aggregateId;
customerId = ev.customerId;
orderDate = ev.orderDate;
orderStatus = ev.orderStatus;
}
public Task Handle(OrderCreatedEvent message, IMessageHandlerContext context)
{
//TODO: actual business logic goes here
log.Info($"Order created from CartId {message.CartId}");
MarkAsComplete();
return(Task.CompletedTask);
}
private ConsumeContext <OrderCreatedEvent> GetContext()
{
var orderCreatedEvent = new OrderCreatedEvent {
OrderItems = orderItems
};
return(Mock.Of <ConsumeContext <OrderCreatedEvent> >(x => x.Message == orderCreatedEvent));
}
private async Task PublishEventToEventGridAsync(Order orderMessage, string operationId, MessageCorrelationInfo correlationInfo)
{
var orderCreatedEvent = new OrderCreatedEvent(operationId, orderMessage.Id, orderMessage.Amount, orderMessage.ArticleNumber,
$"{orderMessage.Customer.FirstName} {orderMessage.Customer.LastName}", correlationInfo);
await _eventGridPublisher.PublishAsync(orderCreatedEvent);
Logger.LogInformation("Event {EventId} was published with subject {EventSubject}", orderCreatedEvent.Id, orderCreatedEvent.Subject);
}
private ConsumeContext <OrderCreatedEvent> GetContext(string userId = userId)
{
var orderCreatedEvent = new OrderCreatedEvent {
UserId = userId
};
return(Mock.Of <ConsumeContext <OrderCreatedEvent> >(x => x.Message == orderCreatedEvent));
}
private void Apply(OrderCreatedEvent e)
{
Version = e.Version;
description = e.Description;
address = e.Address;
isDeleted = false;
orderItems = e.OrderItems;
}
public void PublishOrderCreatedEvent(OrderCreatedEvent @event)
{
var message = JsonConvert.SerializeObject(@event);
var headers = new Dictionary <string, object>();
headers.Add("type", "OrderCreatedEvent");
_publisher.Publish(message: message, routingKey: "order.events", headers);
}
public void Test_Should_Create_PaymentRecord_when_Handle_OrderCreatedEvent_()
{
var repository = Substitute.For <IRepository <Payment> >();
var handler = new OrderCreatedEventHandler(repository);
handler.Handle(OrderCreatedEvent.Raise(Guid.NewGuid(), 43900));
repository.Received(1).Save(Arg.Any <Payment>());
}
public Task Handle(CreateOrderCommand message, IMessageHandlerContext context)
{
//TODO: create order
var orderCreated = new OrderCreatedEvent
{
CartId = message.CartId
};
return(context.Publish(orderCreated));
}
private Order(Guid id, string customerName) : this()
{
var orderCreatedEvent = new OrderCreatedEvent()
{
Customer = customerName,
OrderId = id
};
this.ApplyChange(orderCreatedEvent);
}
public async Task ProcessOrderCreatedEvent(OrderCreatedEvent eventDto)
{
eventDto.EventTarget = nameof(ProcessOrderCreatedEvent);
var hasProcessed = await _tracker.HasProcessedAsync(eventDto);
if (!hasProcessed)
{
await _wareHouserSrv.BlockQtyAsync(eventDto, _tracker);
}
}
public async Task HandleAsync(CreateNewOrderCommand command)
{
var orderId = Id.From(command.OrderId);
var clientId = Id.From(command.ClientId);
Order order = await _factory.CreateOrder(orderId, clientId);
await _ordeRepository.Save(order);
var paymentEvent = new OrderCreatedEvent(order.Id, order.Client.Id, CurrentDateTime.Local);
await EventBus.Current.PublishAsync(paymentEvent);
}
public static OrderCreatedEvent ToCreatedEvent(
this Order order)
{
var result = new OrderCreatedEvent
{
Id = order.Id,
Name = order.Name,
Quantity = order.Quantity
};
return(result);
}
public async Task <IActionResult> Post([FromBody] string value)
{
var order = new OrderCreatedEvent
{
Product = "Bicycle",
Quantity = 100
};
await _pubSubServiceHelper.Publish(order).ConfigureAwait(true);
return(Ok());
}
public async Task Handle(OrderCreatedEvent message, CancellationToken cancellationToken)
{
var result = await _inventoryService.DebitOrderProducts(message.OrderProducts);
if (result)
{
await _mediatorHandler.PublishEvent(new OrderInventoryConfirmedEvent(message.OrderId, message.CustomerId, message.Total, message.OrderProducts, message.CardName, message.CardNumber, message.CardExpiryDate, message.CardCvvCode));
}
else
{
await _mediatorHandler.PublishEvent(new OrderInventoryRejectedEvent(message.OrderId, message.CustomerId));
}
}
public void RaiseEvent_Should_write_to_db_saga_contents()
{
// Arrange
const string orderId = "1";
var orderConfirmedEvent = new OrderCreatedEvent(orderId);
// Act
_manager.ProcessMessage(orderConfirmedEvent);
// Assert
Assert.IsTrue(_repository.Values.ContainsKey(orderConfirmedEvent.OrderId));
Assert.IsTrue(orderId == _repository.Values[orderId].OrderId);
}
public void PartiallySelectedTypes()
{
var schema = new UnionSchema(new[]
{
new RecordSchema(nameof(OrderCancelledEvent))
{
Fields = new[]
{
new RecordField("timestamp", new StringSchema()),
},
},
new RecordSchema(nameof(OrderCreatedEvent))
{
Fields = new[]
{
new RecordField("timestamp", new StringSchema()),
new RecordField(
"total",
new BytesSchema
{
LogicalType = new DecimalLogicalType(5, 2),
}),
},
},
});
var deserialize = deserializerBuilder.BuildDelegate <OrderCreatedEvent>(schema);
var serialize = new JsonSerializerBuilder(JsonSerializerBuilder
.CreateDefaultCaseBuilders()
.Prepend(builder => new OrderSerializerBuilderCase(builder)))
.BuildDelegate <OrderEvent>(schema);
var value = new OrderCreatedEvent
{
Timestamp = DateTime.UtcNow,
Total = 40M,
};
using (stream)
{
serialize(value, new Utf8JsonWriter(stream));
}
var reader = new Utf8JsonReader(stream.ToArray());
var result = deserialize(ref reader);
Assert.Equal(value.Timestamp, result.Timestamp);
Assert.Equal(value.Total, result.Total);
}
private static async Task RaiseCampaignOrderAcceptedEvent(OrderCreatedEvent orderCreatedEvent, Campaign campaign, string subject)
{
await EventPublisher.TriggerEventGridTopic <CampaignOrderAcceptedEvent>(null,
new CampaignOrderAcceptedEvent()
{
OrderId = orderCreatedEvent.OrderId,
ActualOrderedUnit = orderCreatedEvent.NumberOfOrderedUnit,
AvailableUnit = campaign.NumberOfAvailableUnit
},
Constants.EVG_EVENT_CAMPAIGN_ORDER_ACCEPTED,
subject,
Settings.GetCampaignExternalizationsEventGridTopicUrl(),
Settings.GetCampaignExternalizationsEventGridTopicApiKey());
}
public void Should_process_reference_type_states()
{
var order = new Order {
State = new State {
RawMode = "Created"
}
};
var @event = new OrderCreatedEvent();
var result = _stator.Go(order, @event);
Assert.True(result.Success);
Assert.Equal("Delivered", result.Entity.State.RawMode);
}
public static Order Create(string accountId, IEnumerable <OrderItem> orderItems)
{
Order order = new Order(accountId);
OrderCreatedEvent orderCreatedEvent = new OrderCreatedEvent(order);
order.AddDomainEvent(orderCreatedEvent);
foreach (OrderItem orderItem in orderItems)
{
OrderLine orderLine = OrderLine.Create(order, orderItem);
order._orderLines.Add(orderLine);
}
return(order);
}
public void Create(IEnumerable <Product> orderItems, ShippingInfo shippingInfo)
{
var subtotal = 0m;
foreach (var item in orderItems)
{
ApplyChange(OrderItemAddedEvent.Raise(Id, item.Id, item.ItemName, item.UnitPrice));
subtotal += item.UnitPrice;
}
ApplyChange(ShippingInfoUpdatedEvent.Raise(Id, shippingInfo.ContactName, shippingInfo.ContactPhone,
shippingInfo.ShippingAddress));
ApplyChange(OrderCreatedEvent.Raise(Id, subtotal));
}
/// <summary>
/// 锁定库存
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task BlockQtyAsync(OrderCreatedEvent eventDto, IMessageTracker tracker)
{
var blockQtyProductsInfo = eventDto.Data.Products.ToDictionary(x => x.ProductId, x => x.Qty);
var warehouses = await _warehouseRepo.Where(x => blockQtyProductsInfo.Keys.Contains(x.ProductId.Value), noTracking : false).ToListAsync();
var products = await _productRepo.Where(x => blockQtyProductsInfo.Keys.Contains(x.Id)).ToListAsync();
var result = await _warehouseManager.BlockQtyAsync(eventDto.Data.OrderId, blockQtyProductsInfo, warehouses, products);
//库存都符合锁定条件才能批量更新数据库
if (result)
{
await _warehouseRepo.UpdateRangeAsync(warehouses);
await tracker?.MarkAsProcessedAsync(eventDto);
}
}
private async void handleCreateOrderCommand(CreateOrderCommand createOrderCommand)
{
OrderCreatedEvent orderCreatedEvent = Order.processCreateOrderCommand(createOrderCommand);
//await _orderRepository.InsertOneAsync(orderCreatedEvent.order);
orderCreatedEvent.getEvents().ForEach(e =>
{
if (e.eventType == EventType.BEVERAGE_ORDER_IN)
{
sendBaristaOrder(e);
}
else if (e.eventType == EventType.KITCHEN_ORDER_IN)
{
sendKitchenOrder(e);
}
});
}
public void TryMapOrderCreatedEventToCampaign(OrderCreatedEvent orderCreatedEvent)
{
if (CampaignStatus == CampaignStatus.Running)
{
if (!hasAvailableUnitToOrder(orderCreatedEvent.NumberOfOrderedUnit))
{
throw new Exception("Unfortunaltely we do not have available items to order. Try by reducing the unit.");
}
this.NumberOfAvailableUnit = this.NumberOfUnit - orderCreatedEvent.NumberOfOrderedUnit;
if (this.NumberOfUnit == this.NumberOfAvailableUnit)
{
this.SetCampaignStatusToFinished();
}
}
}
public async void Run(
[EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{
log.LogInformation($"EVGH_OrderCreatedEventExternalization2Campaign triggered....EventGridEvent" +
$"\n\tId:{ eventGridEvent.Id }" +
$"\n\tTopic:{ eventGridEvent.Topic }" +
$"\n\tSubject:{ eventGridEvent.Subject }" +
$"\n\tType:{ eventGridEvent.EventType }" +
$"\n\tData:{ eventGridEvent.Data }");
OrderCreatedEvent orderCreatedEvent = null;
Campaign existingCampaign = null;
try
{
orderCreatedEvent = JsonConvert.DeserializeObject <OrderCreatedEvent>(eventGridEvent.Data.ToString());
if (orderCreatedEvent == null)
{
throw new Exception("order is null!");
}
log.LogInformation($"EVGH_OrderCreatedExternalization2Campaign transaction {orderCreatedEvent.OrderId}");
if (orderCreatedEvent == null || string.IsNullOrEmpty(orderCreatedEvent.CampaignId))
{
throw new Exception("A order with a valid CampaignId must be attached to the order!!");
}
existingCampaign = await campaigns.Find(v => v.Id == orderCreatedEvent.CampaignId).FirstOrDefaultAsync();
existingCampaign.TryMapOrderCreatedEventToCampaign(orderCreatedEvent);
var replacedItem = await campaigns.ReplaceOneAsync(t => t.Id == existingCampaign.Id, existingCampaign);
await RaiseCampaignOrderAcceptedEvent(orderCreatedEvent, existingCampaign, Constants.EVG_EVENT_CAMPAIGN_ORDER_ACCEPTED);
}
catch (Exception e)
{
var error = $"Updating Campaign failed: {e.Message}";
logger.LogError(error);
await RaiseCampaignOrderRejectedEvent(orderCreatedEvent, existingCampaign, error, Constants.EVG_EVENT_CAMPAIGN_ORDER_REJECTED);
}
}
public void WhenCreateIsInvoked_ThenGenerateOrderCreatedEvent()
{
//arrange
string id = Guid.NewGuid().ToString();
string serverName = "John";
IEnumerable <global::Orders.Models.OrderDetail> details = new List <global::Orders.Models.OrderDetail> {
new global::Orders.Models.OrderDetail("Mocka", 1, 10)
};
OrderCreatedEvent expected = new OrderCreatedEvent(1, id, details.ToDictionary(k => k.ItemName, v => v.Quntaty));;
Order target = new Order();
//act
target.Create(id, serverName, details);
OrderCreatedEvent actual = target.IterateEvent().First() as OrderCreatedEvent;
//assert
actual.Should().Equals(expected);
}
public Task Handle(OrderCreatedEvent evnt)
{
var player = _state.Players[evnt.OwnerId];
var order = new BrokerOrder
{
OrderId = evnt.EntityId,
OwnerId = evnt.OwnerId,
ItemId = evnt.ItemId,
Quantity = evnt.Quantity,
Price = evnt.Price,
OrderType = evnt.OrderType,
State = OrderState.Active,
Owner = player,
};
_state.Orders.Add(evnt.EntityId, order);
return(Task.CompletedTask);
}
public void OnOrderCreated(OrderCreatedEvent evnt)
{
_orders.Add(new Order(this, evnt.OrderId));
}
