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