public void Handle(OrderShippedEvent message)
{
// here we should check the state
// and if saga allready done this step => saga repository
// ...
var currentState = this._orderSagaRepository.GetSagaState(message.OrderId);
var newState = message.State;
Console.WriteLine();
Console.WriteLine("-----------------------------------");
Console.WriteLine(DateTime.Now);
Console.WriteLine("Handling OrderShippedEvent '{0}'...", message.OrderId);
Console.WriteLine("-----------------------------------");
Console.WriteLine();
this.Bus.Send(
new OrderShippedMessage
{
OrderId = message.OrderId,
OrderState = message.State
});
// save current saga state
this.Data.OrderState = message.State;
this._orderSagaRepository.SaveSagaState(this.Data);
MarkAsComplete();
}
public void Handle(OrderShippedEvent message)
{
this._repository.Update(
new OrderViewModel
{
OrderState = message.State
});
}
public async Task Consume(ConsumeContext <OrderShippedEvent> context)
{
OrderShippedEvent orderShippedEvent = context.Message;
NotificationCorrelationId notificationCorrelationId = new NotificationCorrelationId($"{orderShippedEvent.Username}-{orderShippedEvent.OrderId}-{orderShippedEvent.ShipmentId}");
Username username = new Username(orderShippedEvent.Username);
NotificationTitle notificationTitle = new NotificationTitle($"Order Shipped");
NotificationContent notificationContent = new NotificationContent($"#{orderShippedEvent.OrderId} order is shipped at {orderShippedEvent.ShipmentDate}");
CreateNotificationCommand createNotificationCommand = new CreateNotificationCommand(notificationCorrelationId, username, notificationTitle, notificationContent, orderShippedEvent.ShipmentDate);
await SendCreateNotificationCommandAsync(createNotificationCommand);
}
public PerformanceTests()
{
_model = TypeModel.Create();
_model.Add(typeof(Event), true);
_stream = new MemoryStream();
for (var i = 0; i < 1000 * 1000; i++)
{
var id = Guid.NewGuid();
var item = new OrderPlacedEvent(id,
"Ordered by customer number" + i.ToString(CultureInfo.InvariantCulture),
new[] { new OrderItem("Test product", i) });
var shipment = new OrderShippedEvent(id, DateTime.Now);
_model.SerializeWithLengthPrefix(_stream, item, typeof(Event), Prefix, 0);
_model.SerializeWithLengthPrefix(_stream, shipment, typeof(Event), Prefix, 0);
}
}
public PerformanceTests()
{
_model = TypeModel.Create();
_model.Add(typeof(Event), true);
_stream = new MemoryStream();
for (var i = 0; i < 1000 * 1000; i++)
{
var id = Guid.NewGuid();
var item = new OrderPlacedEvent(id,
"Ordered by customer number" + i.ToString(CultureInfo.InvariantCulture),
new[] { new OrderItem("Test product", i) });
var shipment = new OrderShippedEvent(id, DateTime.Now);
_model.SerializeWithLengthPrefix(_stream, item, typeof(Event), Prefix, 0);
_model.SerializeWithLengthPrefix(_stream, shipment, typeof(Event), Prefix, 0);
}
}
public async Task Handle(JObject jObject, ILog log, CancellationToken cancellationToken)
{
var orderValidated = jObject.ToObject <OrderValidatedEvent>();
if (orderValidated.IsValid)
{
var orderShippedEvent = new OrderShippedEvent
{
Id = orderValidated.OrderId
};
await _producer.Send(orderShippedEvent, "ReactiveMicroservices");
}
else
{
var orderCancelledEvent = new OrderCancelledEvent
{
Id = orderValidated.OrderId
};
await _producer.Send(orderCancelledEvent, "ReactiveMicroservices");
}
}
public async Task Handle(JObject jObject, ILog log, CancellationToken cancellationToken)
{
var orderValidated = jObject.ToObject <OrderValidatedEvent>();
if (orderValidated.IsValid)
{
var orderShippedEvent = new OrderShippedEvent {
Data = orderValidated.Data, OrderId = orderValidated.OrderId
};
await _shipedEventSources.InserEvent(orderShippedEvent, cancellationToken);
await _producer.Send(orderShippedEvent, AppGlobalTopic.PosTopic);
}
else
{
var orderCanceledEvent = new OrderCancelledEvent {
Data = orderValidated.Data, OrderId = orderValidated.OrderId
};
await _cancelledEventSources.InserEvent(orderCanceledEvent, cancellationToken);
await _producer.Send(orderCanceledEvent, AppGlobalTopic.PosTopic);
}
}
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>Success</returns>
/// <exception cref="ApiException">A server side error occurred.</exception>
public async System.Threading.Tasks.Task WhenAsync(OrderShippedEvent @event, System.Threading.CancellationToken cancellationToken)
{
var urlBuilder_ = new System.Text.StringBuilder();
urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/v1/Projections/order-shipped");
var client_ = _httpClient;
try
{
using (var request_ = new System.Net.Http.HttpRequestMessage())
{
var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(@event, _settings.Value));
content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
request_.Content = content_;
request_.Method = new System.Net.Http.HttpMethod("PUT");
PrepareRequest(client_, request_, urlBuilder_);
var url_ = urlBuilder_.ToString();
request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
PrepareRequest(client_, request_, url_);
var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
try
{
var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
if (response_.Content != null && response_.Content.Headers != null)
{
foreach (var item_ in response_.Content.Headers)
{
headers_[item_.Key] = item_.Value;
}
}
ProcessResponse(client_, response_);
var status_ = ((int)response_.StatusCode).ToString();
if (status_ == "200")
{
return;
}
else
if (status_ != "200" && status_ != "204")
{
var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new ApiException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
}
}
finally
{
if (response_ != null)
{
response_.Dispose();
}
}
}
}
finally
{
}
}
/// <returns>Success</returns>
/// <exception cref="ApiException">A server side error occurred.</exception>
public System.Threading.Tasks.Task WhenAsync(OrderShippedEvent @event)
{
return(WhenAsync(@event, System.Threading.CancellationToken.None));
}
private void When(OrderShippedEvent @event) =>
With(this, state =>
{
state.OrderStatus = OrderStatus.Shipped;
});
public async Task <IActionResult> OrderShipped([FromBody] OrderShippedEvent orderShippedEvent)
{
await _busControl.Publish(orderShippedEvent);
return(StatusCode((int)HttpStatusCode.Accepted));
}
public async Task When([FromBody] OrderShippedEvent @event) =>
ReadModelForOrderContext.locker.Lock(() =>
{
var existingOrder = ReadModelForOrderContext.Orders.SingleOrDefault(o => o.Id == @event.OrderId);
existingOrder.OrderStatus = "Shipped";
});
public OrderShipmentStatusTrackerData FindBy(OrderShippedEvent message)
{
return(FindByOrderId(message.OrderId));
}
public void Handle(OrderShippedEvent @event)
{
Data.OrderId = @event.OrderId;
Data.ShipmentId = @event.ShipmentId;
CompleteIfPossible();
}
public void Handle(OrderShippedEvent domainEvent)
{
System.Console.WriteLine("[Event] - NotificationsHandler.Handle(domainEvent)");
_notifier.Notify(string.Format("Your order has finally been shipped. Address : \"{0}\"", domainEvent.Order.ShipmentAddress));
}
