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)); }