/// <inheritdoc /> public async Task NewMarketOrderAsync( string clOrdId, string symbol, string side, decimal orderQty, ulong account, string timeInForce = null, string[] execInst = null, ulong positionId = 0, decimal stopLossPrice = 0, decimal takeProfitPrice = 0, string text = null, string groupId = null) { var command = OrderExtensions.NewMarketOrder( clOrdId, symbol, side, orderQty, account, timeInForce, execInst, positionId, stopLossPrice, takeProfitPrice, text, groupId); await SendCommandAsync(command).ConfigureAwait(false); }
/// <inheritdoc /> public async Task <ExecutionReport> NewMarketOrderAsync( string clOrdId, string symbol, string side, decimal orderQty, ulong account, string timeInForce = null, string[] execInst = null, ulong positionId = 0, decimal stopLossPrice = 0, decimal takeProfitPrice = 0, string text = null, string groupId = null, CancellationToken cancellationToken = default) { var command = OrderExtensions.NewMarketOrder( clOrdId, symbol, side, orderQty, account, timeInForce, execInst, positionId, stopLossPrice, takeProfitPrice, text, groupId); return(await NewOrderAsync(command, cancellationToken).ConfigureAwait(false)); }
private async Task TakeProfitForExistingPositionAsync() { var command = OrderExtensions.NewLimitOrder(CommonFuncs.NewClOrdId("stop-order"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 10000); command.ForPosition(12345); await _wsClient.SendCommandAsync(command).ConfigureAwait(false); }
public void IsCatalogueSolutionsSectionComplete_CatalogueSolutionsNotViewed_ReturnsFalse() { var order = OrderBuilder.Create().WithCatalogueSolutionsViewed(false).Build(); var actual = OrderExtensions.IsCatalogueSolutionsSectionComplete(order); actual.Should().BeFalse(); }
public void IsServiceRecipientsSectionComplete_ServiceRecipientsViewedFalse_ReturnsFalse() { var order = OrderBuilder.Create().WithServiceRecipientsViewed(false).Build(); var actual = OrderExtensions.IsServiceRecipientsSectionComplete(order); actual.Should().BeFalse(); }
private void RecreateOrder(Order order, bool copyDeviationInfo = false) { var newOrder = CreateOrder(order.LeavesQty, order.GetOpenClose(true)); if (copyDeviationInfo) { var info = OrderExtensions.GetOrderInfo(newOrder); var old = OrderExtensions.GetOrderInfo(order); info.DeviationInfo = old.DeviationInfo; } if (OpenOrder == order) { ClearOrder(ref OpenOrder); OpenOrder = newOrder; } else if (CloseOrder == order) { ClearOrder(ref CloseOrder); CloseOrder = newOrder; } else if (CloseTodayOrder == order) { ClearOrder(ref CloseTodayOrder); CloseTodayOrder = newOrder; } }
private async Task SltpGroupAsync(CancellationToken cancellationToken) { var id = CommonFuncs.NewClOrdId("limit-sltp-1"); var command = OrderExtensions.NewLimitOrder(id, "XBTUSD", Side.Sell, 1M, MarginAccountId, 10600); command.AddTrailingStopLoss(500); command.AddTakeProfit(10000); var executionReport = await _restClient.NewOrderAsync(command, cancellationToken).ConfigureAwait(false); HandleOrderReport(executionReport); // OR executionReport = await _restClient.NewLimitOrderAsync( CommonFuncs.NewClOrdId("limit-sltp-2"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 10600, trailingOffset : 500, takeProfitPrice : 10000, cancellationToken : cancellationToken).ConfigureAwait(false); HandleOrderReport(executionReport); }
public async Task OrderTypes_SelectedSymbol() { // Arrange var cxlToken = new CancellationToken(); var exchangeApi = ExchangeServiceHelper.GetExchangeService(); var exchangeService = new WpfExchangeService(exchangeApi); var tradeViewModel = new TradeViewModel(exchangeService, new DebugLogger()); var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(Exchange.Test, cxlToken); var trx = symbols.Single(s => s.Name.Equals("TRXBTC")); tradeViewModel.SetSymbols(symbols.ToList()); tradeViewModel.SelectedSymbol = trx; // Act var orderTypes = tradeViewModel.OrderTypes; // Assert Assert.AreEqual(tradeViewModel.SelectedSymbol, trx); var missing = OrderExtensions.OrderTypes().Except(tradeViewModel.OrderTypes).ToList(); foreach (var orderType in missing) { if (orderType != OrderExtensions.GetOrderTypeName(Interface.Model.OrderType.StopLoss) && orderType != OrderExtensions.GetOrderTypeName(Interface.Model.OrderType.TakeProfit)) { Assert.Fail(); } } }
private async Task StopOrderAsync() { await _wsClient.NewStopOrderAsync(CommonFuncs.NewClOrdId("stop-order"), "BTC/USDT", Side.Sell, 0.01M, SpotAccountId, 9500).ConfigureAwait(false); var command = OrderExtensions.NewStopOrder(CommonFuncs.NewClOrdId("stop-order"), "BTC/USDT", Side.Sell, 0.01M, SpotAccountId, 9500); await _wsClient.SendCommandAsync(command).ConfigureAwait(false); }
private void Clear() { OrderExtensions.GetOrderInfo(Order).Processor = null; ClearOrder(ref OpenOrder); ClearOrder(ref CloseOrder); ClearOrder(ref CloseTodayOrder); Agent.RemoveProcessor(this); }
private void ClearOrder(ref Order order) { if (order != null) { OrderExtensions.GetOrderInfo(order).Processor = null; order = null; } }
private void Clear() { OrderExtensions.GetOrderInfo(_order).processor = null; ClearOrder(ref openOrder); ClearOrder(ref closeOrder); ClearOrder(ref closeTodayOrder); _agent.RemoveProcessor(this); }
private static void ClearOrder(ref Order order) { if (order == null) { return; } OrderExtensions.GetOrderInfo(order).processor = null; order = null; }
public async Task Test_NewOrder() { var command = OrderExtensions.NewLimitOrder(NewClOrdId("limit"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 10000M); var er = await _restClient.NewOrderAsync(command, _token).ConfigureAwait(false); er.Should().NotBeNull(); er.Should().NotBeNull(); er.ExecType.Should().Be(ExecType.PendingNewExec); }
public OrderProcessor(OrderAgent agent, Order order, Logger logger) { _agent = agent; _order = order; _position = agent.GetPosition(order); _record = new OrderRecord(order); _info = OrderExtensions.GetOrderInfo(order); _logger = logger; listNode = agent.AddProcessor(this); InitRules(); }
public OrderProcessor(OrderAgent agent, Order order, Logger logger) { Agent = agent; Order = order; Manager = agent.GetPositionManager(order.strategyId); ListNode = agent.AddProcessor(this); _record = new OrderRecord(order); _info = OrderExtensions.GetOrderInfo(order); _logger = logger; InitRules(); }
private async Task TakeProfitForExistingPositionAsync(CancellationToken cancellationToken) { var id = CommonFuncs.NewClOrdId("stop-order"); var command = OrderExtensions.NewLimitOrder(id, "XBTUSD", Side.Sell, 1M, MarginAccountId, 10000); command.ForPosition(12345); var executionReport = await _restClient.NewOrderAsync(command, cancellationToken).ConfigureAwait(false); HandleOrderReport(executionReport); }
static void UsingKafka() { try { var order = OrderExtensions.Create(); KafkaHelper.Produce(order.CreateMessage(Topics.OrderCreated)); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public virtual void OnReminder(DateTime dateTime, Order order) { var info = OrderExtensions.GetOrderInfo(order); if (CheckTryCount(info)) { _logger.Debug($"{Order.Id}, time deviation {info.DeviationInfo.TryCount}."); Agent.Cancel(order); } else { DoFailed(order); } }
static void Normal() { try { var order = OrderExtensions.Create(); order.Validate(); order.Ship(); order.SendToERP(); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
private async Task SltpGroupAsync() { var command = OrderExtensions.NewLimitOrder(CommonFuncs.NewClOrdId("limit-sltp"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 10600); command.AddTrailingStopLoss(500); command.AddTakeProfit(10000); await _wsClient.SendCommandAsync(command).ConfigureAwait(false); await _wsClient.NewLimitOrderAsync( CommonFuncs.NewClOrdId("limit-sltp"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 10600, trailingOffset : 500, takeProfitPrice : 10000).ConfigureAwait(false); }
public async Task Test_CancelOrder() { var newOrderCmd = OrderExtensions.NewLimitOrder(NewClOrdId("limit"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 10000M); var er = await _restClient.NewOrderAsync(newOrderCmd, _token).ConfigureAwait(false); er.Should().NotBeNull(); er.Should().NotBeNull(); er.ExecType.Should().Be(ExecType.PendingNewExec); var cancelOrderCmd = er.ToOrderCancelRequest(NewClOrdId("cancel")); var cancelOrderResponse = await _restClient.CancelOrderAsync(cancelOrderCmd, _token).ConfigureAwait(false); cancelOrderResponse.Should().NotBeNull(); cancelOrderResponse.Should().NotBeNull(); cancelOrderResponse.ExecType.Should().Be(ExecType.CanceledExec); }
/// <summary> /// Gets an order /// </summary> /// <param name="orderId">The order identifier</param> /// <returns>Order</returns> public override Nop.Core.Domain.Orders.Order GetOrderById(int orderId) { var miscPlugins = _pluginFinder.GetPlugins <MyOrderServicePlugin>(storeId: _storeContext.CurrentStore.Id).ToList(); if (miscPlugins.Count > 0) { var order = base.GetOrderById(orderId); if (order == null) { order = new OrderExtensions().GetOrderById(orderId, true); } return(order); } else { return(base.GetOrderById(orderId)); } }
public async Task Test_ReplaceOrderSingle() { var newOrderCmd = OrderExtensions.NewLimitOrder(NewClOrdId("limit"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 10000M); var newOrderEr = await _restClient.NewOrderAsync(newOrderCmd, _token).ConfigureAwait(false); newOrderEr.Should().NotBeNull(); newOrderEr.Should().NotBeNull(); newOrderEr.ExecType.Should().Be(ExecType.PendingNewExec); var replaceOrderCmd = newOrderEr.ToOrderCancelReplaceRequest(NewClOrdId("cancel")); replaceOrderCmd.Price = 10500M.ToFixString(); var replaceOrderEr = await _restClient.ReplaceOrderAsync(replaceOrderCmd, _token).ConfigureAwait(false); replaceOrderEr.Should().NotBeNull(); replaceOrderEr.Should().NotBeNull(); replaceOrderEr.ExecType.Should().Be(ExecType.PendingReplaceExec); }
private async Task InfinitePlaceCancelAsync() { _wsClient.RemoveListener <ExecutionReport>(); _wsClient.RemoveListener <BalanceIncrementalRefresh>(); var placeInterval = TimeSpan.FromMilliseconds(500); _wsClient.Listen <ExecutionReport>(async(client, er) => { _logger.LogInformation($"ER {er.ClOrdId} ExecType {er.ExecType}"); if (er.ExecType != ExecType.NewExec) { return; } var cancelCommand = er.ToOrderCancelRequest(CommonFuncs.NewClOrdId("cancel-order")); try { await client.SendCommandAsync(cancelCommand).ConfigureAwait(false); } catch (Exception ex) { _logger.LogError($"Failed to cancel order {er.ClOrdId}: {ex.Message}"); } }); while (true) { var limitCommand = OrderExtensions.NewLimitOrder(CommonFuncs.NewClOrdId("limit-order"), "BTC/USDT", Side.Sell, 0.01M, SpotAccountId, 10500); try { await _wsClient.SendCommandAsync(limitCommand).ConfigureAwait(false); } catch (Exception ex) { _logger.LogError($"Failed to place limit order: {ex.Message}"); } await Task.Delay(placeInterval).ConfigureAwait(false); } }
private void CheckPriceDeviation(Order order) { var price = Order.Instrument.Trade.Price; var ask = Order.Instrument.Ask.Price; var bid = Order.Instrument.Bid.Price; if (IsDone(order) || IsNotSent(order)) { return; } var info = OrderExtensions.GetOrderInfo(order); if (Math.Abs(order.Price - price) > _info.DeviationInfo.Threshold) { Do(); } if (_info.DeviationMode == OrderDeviationMode.QuoteAndTrade) { if ((order.Side == OrderSide.Buy && Math.Abs(order.Price - ask) > _info.DeviationInfo.Threshold) || (order.Side == OrderSide.Sell && Math.Abs(order.Price - bid) > _info.DeviationInfo.Threshold)) { Do(); } } void Do() { if (CheckTryCount(info)) { _logger.Debug($"{Order.Id}, price deviation {info.DeviationInfo.TryCount}."); Agent.Cancel(order); } else { DoFailed(order); } } }
private async Task LimitOrderAsync() { await _wsClient.NewLimitOrderAsync( CommonFuncs.NewClOrdId("limit-order"), "BTC/USDT", Side.Sell, 0.01M, SpotAccountId, 10500, text : "order comment 1") .ConfigureAwait(false); var command = OrderExtensions.NewLimitOrder( CommonFuncs.NewClOrdId("limit-order"), "BTC/USDT", Side.Sell, 0.01M, SpotAccountId, 10500, text: "order comment 2"); await _wsClient.SendCommandAsync(command).ConfigureAwait(false); }
private async Task StopLossForExistingPositionAsync(CancellationToken cancellationToken) { var id = CommonFuncs.NewClOrdId("stop-order-1"); var command = OrderExtensions.NewStopOrder(id, "XBTUSD", Side.Sell, 1M, MarginAccountId, 9500); command.ForPosition(12345); var executionReport = await _restClient.NewOrderAsync(command, cancellationToken).ConfigureAwait(false); HandleOrderReport(executionReport); // OR executionReport = await _restClient.NewStopOrderAsync( CommonFuncs.NewClOrdId("stop-order-2"), "XBTUSD", Side.Sell, 1M, MarginAccountId, 9500, positionId : 12345, cancellationToken : cancellationToken) .ConfigureAwait(false); HandleOrderReport(executionReport); }
private Order CreateOrder(double qty, OpenCloseType openClose) { var order = Agent.CreateOrder(Order, qty); order.SetOpenClose(openClose); if (openClose == OpenCloseType.Open) { order.TimeInForce = Order.TimeInForce; } else { if (OpenOrder == null) { order.TimeInForce = Order.TimeInForce; } } var info = OrderExtensions.GetOrderInfo(order); info.Processor = this; info.ParentOrderId = Order.Id; info.DeviationInfo = _info.DeviationInfo; info.DeviationMode = _info.DeviationMode; return(order); }
public static void IsCatalogueSolutionsSectionComplete_NullOrder_ReturnsFalse() { var actual = OrderExtensions.IsCatalogueSolutionsSectionComplete(null); actual.Should().BeFalse(); }