private async Task SaveCandle(BinanceStreamKline kline, NatsClient natsClient) { if (kline.Final) { Candle candle = kline.ToCandle(); long? id = await _candlesProcessor.Create(candle); _logger.LogTrace($"Saved candle from {Exchange.Description} - {candle.Symbol}"); await natsClient.PubAsJsonAsync(_settings.Value.CandlesQueueName, new Notification <Candle>() { Code = ActionCode.CREATED.Code, Payload = candle }); } }
public async Task StopLoss(Trade trade, PairConfig config) { await WithConnection(async (connection, transaction) => { IExchangeCode exchangeCode = ExchangeCode.Create(trade.ExchangeCode); IEnumerable <Deal> deals = await _dealManager.GetOpenDeals(trade.ExchangeCode, trade.Symbol, connection, transaction); foreach (Deal deal in deals) { deal.Orders = await _orderManager.GetOrdersByDealId(deal.Id, connection, transaction) as List <Order>; if (deal.StopLoss.HasValue && trade.Price < deal.StopLoss.Value) { foreach (Order dealOrder in deal.Orders) { if (dealOrder.OrderStatusCode == OrderStatusCode.PENDING.Code || dealOrder.OrderStatusCode == OrderStatusCode.EXPIRED.Code || dealOrder.OrderStatusCode == OrderStatusCode.HOLD.Code) { await _orderManager.Delete(dealOrder.Id, connection, transaction); } else if (dealOrder.OrderStatusCode == OrderStatusCode.LISTED.Code) { dealOrder.OrderStatusCode = OrderStatusCode.CANCELED.Code; dealOrder.Updated = DateTime.UtcNow; dealOrder.UpdateRequired = true; await _orderManager.Update(dealOrder, connection, transaction); NatsClient client = _connector.Client; await client.PubAsJsonAsync(_settings.Value.OrdersQueueName, new Notification <Order>() { Code = ActionCode.UPDATED.Code, Payload = dealOrder }); } } Order order = new Order(); order.ExchangeCode = trade.ExchangeCode; order.Symbol = trade.Symbol; order.TradingModeCode = TradingModeCode.AUTO; order.FillPoliticsCode = FillPoliticsCode.GTC; order.OrderStatusCode = OrderStatusCode.PENDING; order.DealId = deal.Id; order.OrderTypeCode = OrderTypeCode.MKT; order.OrderSideCode = OrderSideCode.SELL; order.Amount = deal.Amount; order.Id = await _orderManager.Create(order, connection, transaction); } } return(Task.CompletedTask); }); }
protected override async Task DoWork(PairConfig pair, CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { try { using (BinanceSocketClient client = new BinanceSocketClient()) { ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString); using (NatsClient natsClient = new NatsClient(cnInfo)) { if (!natsClient.IsConnected) { natsClient.Connect(); } CallResult <UpdateSubscription> successKline = null; successKline = client.SubscribeToTradeUpdates(pair.Symbol, async(data) => { Trade trade = data.ToEntity(); if (!_settings.Value.DisadleDealsSaving) { long id = await _tradesProcessor.Create(trade); } await natsClient.PubAsJsonAsync(_settings.Value.TradesQueueName, new Notification <Trade>() { Code = ActionCode.CREATED.Code, Payload = trade }); }); successKline.Data.ConnectionLost += () => { _logger.LogError($"Connection to {Exchange} is lost"); }; successKline.Data.ConnectionRestored += (data) => { _logger.LogError($"Connection to {Exchange} is Restored"); }; while (!stoppingToken.IsCancellationRequested) { } natsClient.Disconnect(); await client.Unsubscribe(successKline.Data); } } } catch (Exception ex) { _logger.LogError($"{Exchange.Description} Trades service failed with message {ex.Message}", ex); } } }
public async Task Should_be_able_to_publish_and_consume_JSON_payloads_asynchronously() { var orgItem = EncodingTestItem.Create(); EncodingTestItem decodedItem = null; await _client.SubAsync("ClientProtobufEncodingTests", stream => stream.Subscribe(msg => { decodedItem = msg.FromJson <EncodingTestItem>(); ReleaseOne(); })); await _client.PubAsJsonAsync("ClientProtobufEncodingTests", orgItem); WaitOne(); orgItem.Should().BeEquivalentTo(decodedItem); }
public async Task Should_be_able_to_publish_and_consume_JSON_payloads_asynchronously() { var subject = Context.GenerateSubject(); var orgItem = EncodingTestItem.Create(); EncodingTestItem decodedItem = null; _sync = Sync.MaxOne(); _client = await Context.ConnectClientAsync(); await _client.SubAsync(subject, stream => stream.Subscribe(msg => { decodedItem = msg.FromJson <EncodingTestItem>(); _sync.Release(); })); await _client.PubAsJsonAsync(subject, orgItem); _sync.WaitForAll(); orgItem.Should().BeEquivalentTo(decodedItem); }
public async Task <IActionResult> CreateOrder(OrderModel model) { if (ModelState.IsValid) { Deal deal = await _dealProcessor.CreateForOrder(model.ToOrder()); try { NatsClient client = _connector.Client; await client.PubAsJsonAsync(_settings.Value.OrdersQueueName, new Notification <Deal>() { Code = ActionCode.CREATED.Code, Payload = deal }); } catch (Exception ex) { _logger.LogError("Can't send Nata notification", ex); } return(RedirectToAction("CreateOrder")); } return(View(model)); }
public static async Task RunAsync(ConnectionInfo cnInfo) { using (var client = new NatsClient("Publisher", cnInfo)) { client.Connect(); while (true) { Console.WriteLine("Say what? (blank=quit)"); var message = Console.ReadLine(); if (string.IsNullOrWhiteSpace(message)) { break; } await client.PubAsJsonAsync("demo.greeting", new Greeting { Message = message, SentBy = Environment.UserName }); } } }
protected override async Task DoWork(PairConfig config, CancellationToken stoppingToken) { ExchangeConfig exchangeConfig = await _exchangeConfigProcessor.GetExchangeConfig(Exchange.Code); while (!stoppingToken.IsCancellationRequested) { try { string listenKey = String.Empty; using (BinanceClient client = new BinanceClient()) { listenKey = client.StartUserStream().Data; } using (BinanceSocketClient socketClient = new BinanceSocketClient()) { ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString); using (NatsClient natsClient = new NatsClient(cnInfo)) { if (!natsClient.IsConnected) { natsClient.Connect(); } CallResult <UpdateSubscription> successAccount = socketClient.SubscribeToUserDataUpdates(listenKey, accountData => { }, async orderData => { Order order = orderData.ToOrder(); Deal deal = await _dealProcessor.UpdateForOrder(order, config); await natsClient.PubAsJsonAsync(_settings.Value.OrdersQueueName, new Notification <Deal>() { Code = ActionCode.UPDATED.Code, Payload = deal }); }, ocoOrderData => { }, async balancesData => { IEnumerable <Balance> balances = balancesData.Select(x => x.ToBalance()); foreach (Balance balance in balances) { await _balanceProcessor.UpdateOrCreate(balance); } }, onAccountBalanceUpdate => { }); while (!stoppingToken.IsCancellationRequested) { } natsClient.Disconnect(); await socketClient.UnsubscribeAll(); } } } catch (Exception ex) { _logger.LogError(ex.Message); } } }