private void When(OrderStartedEvent @event) =>
With(this, state =>
{
state.Id = new OrderId(@event.OrderId);
state._buyerId = new CustomerId(@event.BuyerId);
state._address = Address.Create(@event.Street, @event.City, string.Empty, string.Empty, string.Empty);
state.OrderStatus = OrderStatus.Submitted;
state._orderDate = DateTime.Now;
});
public When_event_is_projected()
{
var @event = new OrderStartedEvent(ORDERID, "123", "Amsterdam", "Fake-1", DateTime.UtcNow);
When(async() =>
{
await The <IProjector>().ProjectAsync(@event).ConfigureAwait(false);
});
}
public void Handle(OrderPlaced t)
{
Console.WriteLine("Creating Event source 'Order Placed'");
var evnt = new OrderStartedEvent()
{
OrderId = t.Order.OrderId
};
StoreEvent(evnt);
}
public async Task <IActionResult> StartOrder(string productName, int quantity)
{
var orderStartedEvent = new OrderStartedEvent
{
ProductName = productName,
Quantity = quantity
};
await _eventBus.PublishAsync("orders", orderStartedEvent);
return(Accepted());
}
public async Task When([FromBody] OrderStartedEvent @event) =>
ReadModelForOrderContext.locker.Lock(() =>
{
ReadModelForOrderContext.Orders.Add(new Order
{
BuyerId = @event.BuyerId,
City = @event.City,
Id = @event.OrderId,
Street = @event.Street,
OrderStatus = "Started"
});
});
public async Task Handle(OrderStartedEvent message, CancellationToken cancellationToken)
{
bool IsStockReservedForOrder = await _stockService.DebitStock(message.OrderProducts);
if (IsStockReservedForOrder)
{
await _mediatrHandler.PublishEvent(new StockReservedForOrderEvent(message.CustomerId, message.OrderId, message.TotalPrice, message.CardName, message.CardNumber,
message.CardExpirationDate, message.CardCvv, message.OrderProducts));
}
else
{
await _mediatrHandler.PublishEvent(new InsufficientStockForOrderEvent(message.CustomerId, message.OrderId));
}
}
public async Task Handle(OrderStartedEvent message, CancellationToken cancellationToken)
{
var result = await _courseService.EnrolCourse(message.CoursesOrder);
if (result)
{
await _mediatorHandler.PublishEvent(new OrderEnrolledAcceptedEvent(message.OrderId,
message.ClientId,
message.Total,
message.CoursesOrder,
message.NameCard,
message.NumberCard,
message.ExpirationDateCard,
message.CvvCard));
}
else
{
await _mediatorHandler.PublishEvent(new OrderEnrolledRejectedEvent(message.OrderId, message.ClientId));
}
}
/// <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(OrderStartedEvent @event, System.Threading.CancellationToken cancellationToken)
{
var urlBuilder_ = new System.Text.StringBuilder();
urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/v1/Projections/order-started");
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("POST");
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(OrderStartedEvent @event)
{
return(WhenAsync(@event, System.Threading.CancellationToken.None));
}
