static async Task Start(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press '1' to publish the OrderReceived event");
Console.WriteLine("Press any other key to exit");
#region PublishLoop
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var orderReceivedId = Guid.NewGuid();
if (key.Key == ConsoleKey.D1)
{
var orderReceived = new OrderReceived
{
OrderId = orderReceivedId
};
await endpointInstance.Publish(orderReceived)
.ConfigureAwait(false);
Console.WriteLine($"Published OrderReceived Event with Id {orderReceivedId}.");
}
else
{
return;
}
}
#endregion
}
private async void OnExchangeOrderEventHandler(object sender, OrderEventArgs args)
{
// todo: remove warranty outputs if cancel/rejected/partially_filled/filled
var order = args.Order;
try
{
if (order.Status == OrderStatus.Pending)
{
OnError(TerminalService.Exchange, $"Invalid order status {order.Status}");
return;
}
// resolve order wallets
await order
.ResolveWallets(Account)
.ConfigureAwait(false);
var result = await Account
.UpsertOrderAsync(order)
.ConfigureAwait(false);
if (!result)
{
OnError(TerminalService.Exchange, "Error adding order");
}
OrderReceived?.Invoke(this, args);
}
catch (Exception e)
{
OnError(TerminalService.Exchange, e);
}
}
static void Start(IBus bus)
{
Console.WriteLine("Press '1' to publish OrderReceived event");
Console.WriteLine("Press any other key to exit");
#region PublishLoop
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var orderId = Guid.NewGuid();
if (key.Key == ConsoleKey.D1)
{
var orderReceived = new OrderReceived
{
OrderId = orderId
};
bus.Publish(orderReceived);
Console.WriteLine($"Published the OrderReceived event with OrderId {orderId}.");
}
else
{
return;
}
}
#endregion
}
public static OrderReceivedModel ToHydratedModel(this OrderReceived anOrderReceivedEntity)
{
var result = anOrderReceivedEntity.ToModel();
result.ReceivedContainer = anOrderReceivedEntity.ReceivedContainer.ToModel();
return(result);
}
private void OnOrderHandler(MemoryStream stream)
{
var response = Schemes.Order.DeserializeWithLengthPrefix(stream);
response.Data.ResolveRelationshipsByName(Schemes.Currencies, Schemes.Symbols);
OrderReceived?.Invoke(this, new OrderEventArgs(response.Data));
}
public async Task PublishAsyncSendsAMessageThatMatchesTheEvents()
{
using (var messageBody = new MemoryStream())
{
var message = default(BrokeredMessage);
var configuration = new ServiceBusTopicEventPublisherConfiguration <EventBase>();
Func <BrokeredMessage, Task> sendMessage = msg =>
{
msg.GetBody <Stream>().CopyTo(messageBody);
messageBody.Seek(0, SeekOrigin.Begin);
message = msg.Clone();
return(Task.CompletedTask);
};
var @event = new OrderReceived
{
OrderId = "ABC123",
PartnerCode = "SQUIRE",
Id = Guid.NewGuid(),
CorrelationId = Guid.NewGuid().ToString(),
OccurredTimeUtc = new DateTime(2017, 01, 05, 5, 10, 30, DateTimeKind.Utc),
CurrentUser = null,
Sequence = 65
};
var testPublisher = new TestPublisher <EventBase>(Mock.Of <ILogger>(), configuration, sendMessage);
await testPublisher.PublishAsync(@event);
message.CorrelationId.Should().Be(@event.CorrelationId, "because the correlation id should have been copied to the message");
message.MessageId.Should().Be(@event.Id.ToString(), "because the event id should have been copied to the message");
message.ContentType.Should().Be(MimeTypes.Json, "becaue the message should have the correct type");
var serializer = new JsonSerializer {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
serializer.Converters.Add(new StringEnumConverter());
var messageEvent = default(EventBase);
using (var reader = new StreamReader(messageBody))
using (var jsonReader = new JsonTextReader(reader))
{
messageEvent = serializer.Deserialize <EventBase>(jsonReader);
reader.Close();
jsonReader.Close();
}
messageEvent.ShouldBeEquivalentTo(@event, "because the events should match");
messageBody?.Close();
message?.Dispose();
}
}
public void Connect(string endpoint, int port)
{
if (manager != null)
{
throw new InvalidOperationException();
}
var listener = new EventBasedNetListener();
manager = new NetManager(listener);
manager.Start();
manager.Connect(endpoint, port, nameof(MultiplayerTest));
listener.PeerConnectedEvent += peer => server = peer;
var processor = new NetPacketProcessor();
processor.RegisterNestedType <Order>(() => new Order());
processor.SubscribeReusable <OrderPacket>(packet =>
{
foreach (var order in packet.Orders)
{
OrderReceived?.Invoke(order);
}
});
listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
var type = (PacketType)dataReader.GetByte();
switch (type)
{
case PacketType.StartGame:
var players = dataReader.GetInt();
GameStarted?.Invoke(players);
break;
case PacketType.Orders:
processor.ReadAllPackets(dataReader);
break;
}
dataReader.Recycle();
};
writer = new NetDataWriter();
thread = new Thread(Run)
{
IsBackground = true
};
thread.Start();
}
public static OrderReceivedModel ToModel(this OrderReceived anOrderReceivedEntity)
{
return(new OrderReceivedModel()
{
OrderId = anOrderReceivedEntity.OrderId,
ReceivedNum = anOrderReceivedEntity.ReceivedNum,
ReceivedContainerId = anOrderReceivedEntity.ReceivedContainerId,
ReceivedContainerQty = anOrderReceivedEntity.ReceivedContainerQty,
ReceivedDate = anOrderReceivedEntity.ReceivedDate,
ReceivedTime = anOrderReceivedEntity.ReceivedTime,
ReceivedTimeString = (new DateTime(anOrderReceivedEntity.ReceivedTime.Ticks)).ToString("h:mm tt")
});
}
public async Task <Guid> PublishingOrder()
{
var orderReceivedId = Guid.NewGuid();
var orderReceived = new OrderReceived
{
OrderId = orderReceivedId
};
await _endpointInstance.Publish(orderReceived)
.ConfigureAwait(false);
return(orderReceivedId);
}
public async Task <Data.Domains.Order> SaveOrderAsync(OrderReceived dto)
{
var products = await _stockService.GetAvailableStockProductAsync(dto.OrderReceivedItems);
decimal totalAmountToPay = 0;
Data.Domains.Order orderToSave = new();
List <OrderItem> orderItemsToSave = new();
if (!await _dbContext.Customers.AnyAsync(c => c.Id == dto.CustomerId))
{
orderToSave.Customer = new Customer
{
Id = dto.CustomerId,
Email = dto.Email,
Mobile = dto.Mobile,
Name = dto.CustomerName,
};
await _dbContext.Customers.AddAsync(orderToSave.Customer);
}
dto.OrderReceivedItems.ForEach(c =>
{
var productToUpdate = products.FirstOrDefault(p => p.Id == c.ProductId);
var price = productToUpdate.Price * c.Qty;
totalAmountToPay += price;
orderItemsToSave.Add(new OrderItem
{
Price = price,
ProductId = c.ProductId,
Qty = c.Qty
});
c.ProductName = productToUpdate.Name;
productToUpdate.HoldQty += c.Qty;
_dbContext.Products.Update(productToUpdate);
});
orderToSave.CustomerId = dto.CustomerId;
orderToSave.AmountToPay = totalAmountToPay;
orderToSave.CustomerId = dto.CustomerId;
orderToSave.OrderdAt = DateTimeOffset.UtcNow;
orderToSave.ShipmentAddress = dto.ShippingAddress;
orderToSave.OrderItems = orderItemsToSave;
await _dbContext.Orders.AddAsync(orderToSave);
await _dbContext.SaveChangesAsync();
return(orderToSave);
}
public void Handle(OrderReceived message)
{
if (Data.Cancelled)
{
MarkAsComplete();
Context.IsSagaComplete = true;
}
else
{
Data.OrderId = message.OrderId;
Data.ProductIds = message.ProductIds;
RequestTimeout <CancelPolicyTimeout>(TimeSpan.FromMinutes(1));
}
Data.Submitted = true;
}
public async Task <IActionResult> CreateOrder([FromBody] OrderReceived dto)
{
dto.CustomerId = Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
dto.Email ??= User.FindFirstValue(ClaimTypes.Email);
dto.Mobile ??= User.FindFirstValue("phone_number");
var isValidStock = await _mediator.Send(new AvailableStockQueryDto { OrderReceivedItems = dto.OrderReceivedItems });
if (!isValidStock)
{
throw new BadRequestException("Sorry, Out of Stock!");
}
await _publishEndpoint.Send(dto);
await _redisCacheClient.RemoveAsync($"order-{ dto.CustomerId}");
return(Accepted());
}
public bool Visit(OrderReceived msg)
{
if (msg.ClientOrderId == null)
{
return(false);
}
Order order;
if (!_manager._newOrders.TryGetValue(msg.ClientOrderId, out order))
{
return(false);
}
Condition.Requires(msg.Size, "msg.Size").IsNotNull();
Condition.Requires(msg.OrderId, "msg.OrderId").IsNotNull();
_manager._openOrders.Add(msg.OrderId, order);
Condition.Requires(_manager._newOrders.Remove(msg.ClientOrderId)).IsTrue();
order.OrderId = msg.OrderId;
order.Unfilled = msg.Size.Value;
PublishUpdate(msg, order, fill: null, finished: false);
return(false);
}
private void Run()
{
var turn = 1;
var writer = new NetDataWriter();
var processor = new NetPacketProcessor();
processor.RegisterNestedType <Order>(() => new Order());
while (manager != null)
{
manager.PollEvents();
Thread.Sleep(100);
if (gameStarted)
{
writer.Reset();
writer.Put((byte)PacketType.Orders);
var orderPacket = new OrderPacket()
{
Turn = turn,
Orders = orders.ToArray()
};
processor.Write(writer, orderPacket);
manager.SendToAll(writer, DeliveryMethod.ReliableOrdered);
foreach (var order in orders)
{
OrderReceived?.Invoke(order);
}
orders.Clear();
turn++;
}
}
}
protected virtual void OnOrderReceived(OrderReceivedEventArgs e)
{
OrderReceived?.Invoke(this, e);
}
public Task Handle(OrderReceived <T> message, IMessageHandlerContext context)
{
log.Info($"Subscriber has received OrderReceived event with OrderId {message.OrderId}.");
return(Task.CompletedTask);
}
void IXSpi.ProcessQryOrder(OrderField order, bool last)
{
OrderReceived?.Invoke(this, order, last);
}
public void OrderReceivedInvoke(RemoteHostInfo hostInfo, EventOrderArgs args) => OrderReceived?.Invoke(hostInfo, args);
private void OnOrderHandler(MemoryStream stream)
{
var response = Schemes.Order.DeserializeWithLengthPrefix(stream);
OrderReceived?.Invoke(this, new OrderEventArgs(response.Data));
}
protected virtual void OnOrderReceived(Order order) => OrderReceived?.Invoke(this, order);
private void ProcessOrder_MessageReceived(object sender, Openfin.Desktop.Messaging.MessageBusMessageEventArgs <Order> e)
{
OrderReceived?.Invoke(this, new ProcessOrderEventArgs(e.Message));
}
public void EventDataHandler(object sender, EventDataArg <string> e)
{
Logger.Info($"Invoked EventDataHandler for {e.HostInfo.Host} via {e.HostInfo.Protocol}, message {e.Data}");
IMessage message = Deserializing.GetMessage(e.Data, out MessageType type);
Logger.Debug($"File {message} deserialized to {type} for {e.HostInfo.Host} via {e.HostInfo.Protocol}, message {e.Data}");
if (message == default(IMessage))
{
Logger.Error("Desirializing error");
return;
}
switch (type)
{
case MessageType.Command:
{
CommandMessageReceived?.Invoke(e.HostInfo, new EventCommandMessageArgs(message as CommandMessage));
break;
}
case MessageType.Connect:
{
ConnectMessageReceived?.Invoke(e.HostInfo, new EventMessageConnectArgs(message as ConnectMessage));
break;
}
case MessageType.Request:
{
RequestReceived?.Invoke(e.HostInfo, new EventRequestArgs(message as Request));
break;
}
case MessageType.Telemetry:
{
TelemetryReceived?.Invoke(e.HostInfo, new EventTelemetryArgs(message as Telemetry));
break;
}
case MessageType.Call:
{
CallReceived?.Invoke(e.HostInfo, new EventCallArgs(message as Call));
break;
}
case MessageType.Order:
{
OrderReceived?.Invoke(e.HostInfo, new EventOrderArgs(message as Order));
break;
}
//TODO ВСЕХ НЕВЕРНЫХ СЖЕЧЬ!.. Всмысле, в error
case MessageType.Err:
{
ErrorMessageReceived?.Invoke(e.HostInfo, new EventErrArgs(message as ErrorMessage));
break;
}
default:
Logger.Error("Desirializing error unknow MessageType");
return;
}
}
public void Handle(OrderReceived message)
{
RequestUtcTimeout <PlaceOrder>(TimeSpan.FromSeconds(10));
}
