public void DispatchShouldSupportMultipleHandlers()
{
// Arrange.
var evt = new OrderCancelledEvent();
var executed = 0;
var handler1 = new OrderCancelledEventHandler1(() => { executed++; });
var handler2 = new OrderCancelledEventHandler2(() => { executed++; });
var map = new MessageHandlerMap();
map.Add(typeof(OrderCancelledEvent), handler1.GetType());
map.Add(typeof(OrderCancelledEvent), handler2.GetType());
var container = A.Fake <IContainer>();
A.CallTo(() => container.Resolve(handler1.GetType())).Returns(handler1);
A.CallTo(() => container.Resolve(handler2.GetType())).Returns(handler2);
var dispatcher = new MessageDispatcher(container, map);
// Act.
dispatcher.Dispatch("CreateOrder", new Envelope <OrderCancelledEvent>(evt)).Wait();
// Assert.
Assert.Equal(2, executed);
}
public void DispatchShouldThrowIfHandlerNull()
{
// Arrange.
var evt = new OrderCancelledEvent();
var map = new MessageHandlerMap();
map.Add(typeof(OrderCancelledEvent), typeof(OrderCancelledEventHandler1));
var container = A.Fake <IContainer>();
A.CallTo(() => container.Resolve(typeof(OrderCancelledEventHandler1))).Returns(null);
// Act.
Assert.Throws <NullReferenceException>(() =>
{
try
{
var dispatcher = new MessageDispatcher(container, map);
dispatcher.Dispatch("CreateOrder", new Envelope <OrderCancelledEvent>(evt)).Wait();
}
catch (AggregateException ex)
{
throw ex.InnerException;
}
});
}
public void DispatchShouldSupportGiveAccessToSession()
{
// Arrange.
var evt = new OrderCancelledEvent();
var handler = new SessionOrderCancelledEventHandler();
var map = new MessageHandlerMap();
map.Add(typeof(OrderCancelledEvent), handler.GetType());
var container = A.Fake <IContainer>();
A.CallTo(() => container.Resolve(handler.GetType())).Returns(handler);
var dispatcher = new MessageDispatcher(container, map);
var session = A.Fake <ISession>();
// Act.
var envelope = new Envelope <OrderCancelledEvent>(evt);
dispatcher.Dispatch("CreateOrder", envelope, session).Wait();
// Assert.
Assert.Equal(session, handler.Session);
}
private void Apply(OrderCancelledEvent e, bool isNew)
{
if (Status == State.Cancelled)
{
return;
}
AddEvent(e, isNew);
Status = State.Cancelled;
}
public void Cancel()
{
var e = new OrderCancelledEvent()
{
OrderNumber = this.OrderNumber,
Version = LastVersionNumber() + 1
};
Apply(e, true);
}
public Task Handle(OrderCancelledEvent evnt)
{
var order = _dbContext.Orders.FirstOrDefault(o => o.OrderId == evnt.EntityId);
if (order != null)
{
order.CancellationReason = evnt.CancellationReason;
order.State = OrderState.Cancelled;
}
return(Task.CompletedTask);
}
/// <summary>
/// Handle order cancelled event
/// </summary>
/// <param name="eventMessage">Event message</param>
public void HandleEvent(OrderCancelledEvent eventMessage)
{
if (eventMessage.Order == null)
{
return;
}
//ensure that Avalara tax provider is active
if (_taxService.LoadActiveTaxProvider(eventMessage.Order.Customer) is AvalaraTaxProvider taxProvider)
{
//void tax transaction
taxProvider.VoidTaxTransaction(eventMessage.Order);
}
}
/// <summary>
/// Handle order cancelled event
/// </summary>
/// <param name="eventMessage">Event message</param>
public void HandleEvent(OrderCancelledEvent eventMessage)
{
if (eventMessage.Order == null)
{
return;
}
//ensure that Avalara tax provider is active
if (!_taxPluginManager.IsPluginActive(AvalaraTaxDefaults.SystemName))
{
return;
}
//void tax transaction
_avalaraTaxManager.VoidTaxTransaction(eventMessage.Order);
}
/// <summary>
/// Handle order cancelled event
/// </summary>
/// <param name="eventMessage">Event message</param>
/// <returns>A task that represents the asynchronous operation</returns>
public async Task HandleEventAsync(OrderCancelledEvent eventMessage)
{
if (eventMessage.Order == null)
{
return;
}
//ensure that Avalara tax provider is active
if (!await _taxPluginManager.IsPluginActiveAsync(AvalaraTaxDefaults.SystemName))
{
return;
}
//async Task tax transaction
await _avalaraTaxManager.VoidTaxTransactionAsync(eventMessage.Order);
}
public async Task CancelOrder(Guid orderId)
{
var player = await _playerRepo.GetPlayer(Context.User);
var order = await _repo.GetOrder(orderId);
if (order.OwnerId != player.PlayerId)
{
throw new UnauthorizedAccessException("User does not own the order");
}
var evnt = new OrderCancelledEvent(orderId, player)
{
CancellationReason = OrderCancellationReason.User,
};
await _eventStore.ProduceAsync(evnt);
}
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);
}
}
public async Task Handle(OrderCancelledEvent message, CancellationToken cancellationToken)
{
await _inventoryService.RefillOrderProducts(message.OrderProducts);
}
public async Task When([FromBody] OrderCancelledEvent @event) =>
ReadModelForOrderContext.locker.Lock(() =>
{
var existingOrder = ReadModelForOrderContext.Orders.SingleOrDefault(o => o.Id == @event.OrderId);
existingOrder.OrderStatus = "Cancelled";
});
public void HandleEvent(OrderCancelledEvent eventMessage)
{
if (!_smsSettings.Enabled)
{
return;
}
if (!_smsSettings.EnableOrderCanceled)
{
return;
}
if (_smsSettings.IgnnoreUserIDs.Split(',').Contains(eventMessage.Order.CustomerId.ToString()))
{
eventMessage.Order.OrderNotes.Add(new OrderNote
{
Note = "SMS alert not send. user:"******" in Ignore Lit",
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(eventMessage.Order);
return;
}
string template = "";
if (eventMessage.Order.CustomerLanguageId == _smsSettings.SecondLanguageID)
{
// second language
template = _smsSettings.TemplateOrderCanceled2;
}
else
{
if (eventMessage.Order.CustomerLanguageId == _smsSettings.ThirdLanguageID)
{
// Third language
template = _smsSettings.TemplateOrderCanceled3;
}
else
{
// default
template = _smsSettings.TemplateOrderCanceled;
}
}
if (string.IsNullOrEmpty(template))
{
template = _smsSettings.TemplateOrderCanceled;
}
try
{
template = string.Format(template, eventMessage.Order.Id, eventMessage.Order.OrderTotal);
}
catch { }
var pluginDescriptor = _pluginFinder.GetPluginDescriptorBySystemName("SMS.Notifications");
if (pluginDescriptor == null)
{
return;
}
if (!_pluginFinder.AuthenticateStore(pluginDescriptor, _storeContext.CurrentStore.Id))
{
return;
}
var plugin = pluginDescriptor.Instance() as SMSNotificationsProvider;
if (plugin == null)
{
return;
}
string phonenum = string.IsNullOrEmpty(eventMessage.Order.Customer.BillingAddress.PhoneNumber) ?
eventMessage.Order.Customer.ShippingAddress.PhoneNumber :
eventMessage.Order.Customer.BillingAddress.PhoneNumber;
phonenum = ParcePhoneNumbe(phonenum);
string resText = "";
if (plugin.SendSms(phonenum, template, out resText))
{
eventMessage.Order.OrderNotes.Add(new OrderNote
{
Note = "\"Order canceled\" SMS alert has been sent to phone:" + phonenum,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(eventMessage.Order);
}
else
{
eventMessage.Order.OrderNotes.Add(new OrderNote
{
Note = "\"Order canceled\" SMS alert can't send to phone:" + phonenum + ". Error " + resText,
DisplayToCustomer = false,
CreatedOnUtc = DateTime.UtcNow
});
_orderService.UpdateOrder(eventMessage.Order);
}
}
private Task ProcessMessageAsync(ExecutionEvent message)
{
var orders = message.Orders.Select(x => new OrderModel
{
Id = Guid.Parse(x.ExternalId),
WalletId = Guid.Parse(x.WalletId),
Volume = decimal.Parse(x.Volume),
AssetPairId = x.AssetPairId,
CreateDt = x.CreatedAt,
LowerLimitPrice = ParseNullabe(x.LowerLimitPrice),
LowerPrice = ParseNullabe(x.LowerPrice),
MatchDt = x.LastMatchTime,
MatchingId = Guid.Parse(x.Id),
Price = ParseNullabe(x.Price),
RegisterDt = x.Registered,
RejectReason = x.RejectReason,
RemainingVolume = ParseNullabe(x.RemainingVolume),
Side = (Contracts.Cqrs.Models.Enums.OrderSide)(int) x.Side,
Status = (Contracts.Cqrs.Models.Enums.OrderStatus)(int) x.Status,
StatusDt = x.StatusDate,
Straight = x.OrderType == OrderType.Limit || x.OrderType == OrderType.StopLimit || x.Straight,
Type = (Contracts.Cqrs.Models.Enums.OrderType)(int) x.OrderType,
UpperLimitPrice = ParseNullabe(x.UpperLimitPrice),
UpperPrice = ParseNullabe(x.UpperPrice),
Trades = x.Trades?.Select(t => new TradeModel
{
Id = Guid.Parse(t.TradeId),
WalletId = Guid.Parse(x.WalletId),
AssetPairId = x.AssetPairId,
BaseAssetId = t.BaseAssetId,
BaseVolume = decimal.Parse(t.BaseVolume),
Price = decimal.Parse(t.Price),
Timestamp = t.Timestamp,
QuotingAssetId = t.QuotingAssetId,
QuotingVolume = decimal.Parse(t.QuotingVolume),
Index = t.Index,
Role = (Contracts.Cqrs.Models.Enums.TradeRole)(int) t.Role,
FeeSize = ParseNullabe(t.Fees?.FirstOrDefault()?.Volume),
FeeAssetId = t.Fees?.FirstOrDefault()?.AssetId,
OppositeWalletId = Guid.Parse(t.OppositeWalletId),
}).ToList()
}).ToList();
foreach (var order in orders.Where(x => _walletIds.Contains(x.WalletId.ToString())))
{
_log.Info("Order from ME", $"order: {new {order.Id, order.Status, message.Header.SequenceNumber}.ToJson()}");
}
var @event = new ExecutionProcessedEvent
{
SequenceNumber = message.Header.SequenceNumber,
Orders = orders
};
_cqrsEngine.PublishEvent(@event, BoundedContext.Name);
foreach (var order in orders.Where(x => x.Trades != null && x.Trades.Any()))
{
var tradeProcessedEvent = new ManualOrderTradeProcessedEvent
{
Order = order
};
_cqrsEngine.PublishEvent(tradeProcessedEvent, BoundedContext.Name);
}
foreach (var order in message.Orders.Where(x => x.Trades != null && x.Trades.Count > 0))
{
var orderType = order.OrderType == OrderType.Market ? FeeOperationType.Trade : FeeOperationType.LimitTrade;
var orderId = order.Id;
foreach (var trade in order.Trades)
{
if (trade.Fees != null)
{
var feeEvent = new FeeChargedEvent
{
OperationId = orderId,
OperationType = orderType,
Fee = trade.Fees.ToJson()
};
_cqrsEngine.PublishEvent(feeEvent, BoundedContext.Name);
}
}
}
var limitOrders = orders.Where(x => x.Type == Contracts.Cqrs.Models.Enums.OrderType.Limit ||
x.Type == Contracts.Cqrs.Models.Enums.OrderType.StopLimit).ToList();
foreach (var order in limitOrders.Where(x => x.Status == OrderStatus.Cancelled))
{
var orderCancelledEvent = new OrderCancelledEvent
{
OrderId = order.Id,
Status = order.Status,
AssetPairId = order.AssetPairId,
Price = order.Price,
Timestamp = order.StatusDt,
Volume = order.Volume,
WalletId = order.WalletId
};
_cqrsEngine.PublishEvent(orderCancelledEvent, BoundedContext.Name);
}
foreach (var order in limitOrders.Where(x => x.Status == OrderStatus.Placed))
{
var orderPlacedEvent = new OrderPlacedEvent
{
OrderId = order.Id,
Status = order.Status,
AssetPairId = order.AssetPairId,
Price = order.Price,
Timestamp = order.StatusDt,
Volume = order.Volume,
WalletId = order.WalletId,
CreateDt = order.CreateDt
};
_cqrsEngine.PublishEvent(orderPlacedEvent, BoundedContext.Name);
}
foreach (var order in limitOrders.Where(x =>
(x.Status == OrderStatus.Matched || x.Status == OrderStatus.PartiallyMatched) &&
x.Trades.Any(t => t.Role == TradeRole.Taker)))
{
var orderPlacedEvent = new OrderPlacedEvent
{
OrderId = order.Id,
Status = order.Status,
AssetPairId = order.AssetPairId,
Price = order.Price,
Timestamp = order.StatusDt,
Volume = order.Volume,
WalletId = order.WalletId,
CreateDt = order.CreateDt
};
_cqrsEngine.PublishEvent(orderPlacedEvent, BoundedContext.Name);
}
return(Task.CompletedTask);
}
/// <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(OrderCancelledEvent @event, System.Threading.CancellationToken cancellationToken)
{
var urlBuilder_ = new System.Text.StringBuilder();
urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/v1/Projections/order-cancelled");
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(OrderCancelledEvent @event)
{
return(WhenAsync(@event, System.Threading.CancellationToken.None));
}
private void When(OrderCancelledEvent @event) =>
With(this, state =>
{
state.OrderStatus = OrderStatus.Cancelled;
});
