private async void OnRunTestClick(object sender, EventArgs e)
{
var currencyPair = (await _stockRestConnector.GetCurrencyPairs()).FirstOrDefault(item => item.Id == "DASHBTC");
var orderId = Guid.NewGuid();
var initialOrder = new Infrastructure.Common.Models.Trading.Order
{
CurrencyPair = currencyPair,
ClientId = orderId,
Role = OrderRoleType.ClosePosition,
OrderSide = OrderSide.Sell,
OrderType = OrderType.Limit,
OrderStateType = OrderStateType.Suspended,
TimeInForce = OrderTimeInForceType.GoodTillCancelled,
Quantity = 0.001m,
Price = 0.022m,
StopPrice = 0
};
var newOrder = await _stockRestConnector.CreateOrder(initialOrder, true);
var cancelledOrder = await _stockRestConnector.CancelOrder(newOrder);
var testOrder = await _stockRestConnector.GetOrderFromHistory(initialOrder.ClientId, currencyPair);
MessageBox.Show(@"Passed");
}
public async Task<Infrastructure.Common.Models.Trading.Order> CreateOrder(Infrastructure.Common.Models.Trading.Order initialOrder, bool usePostOnly = false)
{
var innerModel = initialOrder.ToInnerModel();
var connection = new HitBtcConnection();
var request = new RestRequest("order", Method.POST);
request.ConfigureRequest();
request.AddJsonBody(new
{
clientOrderId = innerModel.ClientId,
symbol = innerModel.CurrencyPairId,
side = innerModel.OrderSide,
type = innerModel.OrderType,
timeInForce = innerModel.TimeInForce,
quantity = innerModel.Quantity.ToString("#0.########################"),
price = innerModel.Price.ToString("#0.########################"),
stopPrice = innerModel.StopPrice.ToString("#0.########################"),
postOnly = usePostOnly
});
var exchangeConnectionSettings = _configurationService.GetExchangeConnectionSettings();
var response = await connection.DoRequest(
request,
exchangeConnectionSettings.ApiKey,
exchangeConnectionSettings.SecretKey);
var responseOrder = response
.ExtractResponseData<Order>()
?.ToOuterModel(initialOrder.CurrencyPair);
return responseOrder;
}
public async Task RequestCancelOrder(Infrastructure.Common.Models.Trading.Order order)
{
var request = new SingleSocketRequest <ChangeOrderStateRequestParameters>
{
RequestMethodName = "cancelOrder",
NeedResponse = false,
RequestParameters = new ChangeOrderStateRequestParameters()
{
ExistingClientId = order.ClientId.ToString("N"),
}
};
await _connection.DoRequest <Order>(request);
}
public async Task RequestReplaceOrder(Infrastructure.Common.Models.Trading.Order changedOrder, Guid newClientId, Action replacementErrorCallback)
{
var request = new SingleSocketRequest <ChangeOrderStateRequestParameters>
{
RequestMethodName = "cancelReplaceOrder",
NeedResponse = false,
RequestParameters = new ChangeOrderStateRequestParameters()
{
ExistingClientId = changedOrder.ClientId.ToString("N"),
NewClientId = newClientId.ToString("N"),
Price = changedOrder.Price,
StopPrice = changedOrder.StopPrice ?? 0,
Quantity = changedOrder.Quantity
}
};
await _connection.DoRequest <Order>(request, replacementErrorCallback);
}
public async Task<Infrastructure.Common.Models.Trading.Order> CancelOrder(Infrastructure.Common.Models.Trading.Order initialOrder)
{
var innerModel = initialOrder.ToInnerModel();
var connection = new HitBtcConnection();
var request = new RestRequest(String.Format("order/{0}", innerModel.ClientId), Method.DELETE);
request.ConfigureRequest();
var exchangeConnectionSettings = _configurationService.GetExchangeConnectionSettings();
var response = await connection.DoRequest(
request,
exchangeConnectionSettings.ApiKey,
exchangeConnectionSettings.SecretKey);
var responseOrder = response
.ExtractResponseData<Order>()
?.ToOuterModel(initialOrder.CurrencyPair);
return responseOrder;
}
public static Order ToInnerModel(this Infrastructure.Common.Models.Trading.Order source, Order target = null)
{
if (target == null)
{
target = new Order();
}
target.Id = source.ExtId;
target.ClientId = source.ClientId.ToString("N");
target.CurrencyPairId = source.CurrencyPair.Id;
switch (source.OrderSide)
{
case OrderSide.Sell:
target.OrderSide = "sell";
break;
case OrderSide.Buy:
target.OrderSide = "buy";
break;
default:
throw new ConnectorException("Undefined order side", null);
}
switch (source.OrderType)
{
case OrderType.Limit:
target.OrderType = "limit";
break;
case OrderType.Market:
target.OrderType = "market";
break;
case OrderType.StopLimit:
target.OrderType = "stopLimit";
break;
case OrderType.StopMarket:
target.OrderType = "stopMarket";
break;
default:
throw new ConnectorException("Undefined order type", null);
}
switch (source.OrderStateType)
{
case OrderStateType.New:
target.OrderStateType = "new";
break;
case OrderStateType.Suspended:
target.OrderStateType = "suspended";
break;
case OrderStateType.PartiallyFilled:
target.OrderStateType = "partiallyFilled";
break;
case OrderStateType.Filled:
target.OrderStateType = "filled";
break;
case OrderStateType.Cancelled:
target.OrderStateType = "canceled";
break;
case OrderStateType.Expired:
target.OrderStateType = "expired";
break;
default:
throw new ConnectorException("Undefined order state type", null);
}
//TODO Check how will be processed partially filled order
switch (source.TimeInForce)
{
case OrderTimeInForceType.GoodTillCancelled:
target.TimeInForce = "GTC";
break;
case OrderTimeInForceType.ImmediateOrCancel:
target.TimeInForce = "IOC";
break;
case OrderTimeInForceType.FillOrKill:
target.TimeInForce = "FOK";
break;
case OrderTimeInForceType.UntillTheEndOfTheDay:
target.TimeInForce = "Day";
break;
case OrderTimeInForceType.GoodTillDate:
target.TimeInForce = "GTD";
break;
default:
throw new ConnectorException(String.Format("Undefined TimeInForce state type: {0}", source.TimeInForce), null);
}
target.Quantity = source.Quantity;
target.Price = source.Price;
target.StopPrice = source.StopPrice ?? 0;
target.Created = source.Created;
target.Updated = source.Updated;
target.PostOnly = false;
return(target);
}
public static Infrastructure.Common.Models.Trading.Order ToOuterModel(this Order source, CurrencyPair currencyPair)
{
var target = new Infrastructure.Common.Models.Trading.Order();
target.ExtId = (Int64)source.Id;
target.ClientId = Guid.Parse(source.ClientId);
target.CurrencyPair = currencyPair ??
throw new ConnectorException(String.Format("Undefined currency: {0}", source.CurrencyPairId), null);
switch (source.OrderSide)
{
case "sell":
target.OrderSide = OrderSide.Sell;
break;
case "buy":
target.OrderSide = OrderSide.Buy;
break;
default:
throw new ConnectorException(String.Format("Undefined Order Side: {0}", source.OrderSide), null);
}
switch (source.OrderType)
{
case "limit":
target.OrderType = OrderType.Limit;
break;
case "market":
target.OrderType = OrderType.Market;
break;
case "stopLimit":
target.OrderType = OrderType.StopLimit;
break;
case "stopMarket":
target.OrderType = OrderType.StopMarket;
break;
default:
throw new ConnectorException(String.Format("Undefined Order Type: {0}", source.OrderType), null);
}
switch (source.OrderStateType)
{
case "new":
target.OrderStateType = OrderStateType.New;
break;
case "suspended":
target.OrderStateType = OrderStateType.Suspended;
break;
case "partiallyFilled":
target.OrderStateType = OrderStateType.PartiallyFilled;
break;
case "filled":
target.OrderStateType = OrderStateType.Filled;
break;
case "canceled":
target.OrderStateType = OrderStateType.Cancelled;
break;
case "expired":
target.OrderStateType = OrderStateType.Expired;
break;
default:
throw new ConnectorException(String.Format("Undefined Order State: {0}", source.OrderStateType), null);
}
switch (source.TimeInForce)
{
case "GTC":
target.TimeInForce = OrderTimeInForceType.GoodTillCancelled;
break;
case "IOC":
target.TimeInForce = OrderTimeInForceType.ImmediateOrCancel;
break;
case "FOK":
target.TimeInForce = OrderTimeInForceType.FillOrKill;
break;
case "Day":
target.TimeInForce = OrderTimeInForceType.UntillTheEndOfTheDay;
break;
case "GTD":
target.TimeInForce = OrderTimeInForceType.GoodTillDate;
break;
default:
throw new ConnectorException(String.Format("Undefined TimeIn Force: {0}", source.TimeInForce), null);
}
target.Quantity = source.Quantity;
target.Price = source.Price;
target.StopPrice = source.StopPrice;
target.Created = source.Created;
target.Updated = source.Updated;
return(target);
}
public Task RequestReplaceOrder(Infrastructure.Common.Models.Trading.Order changedOrder, Guid newClientId, Action replacementErrorCallback)
{
throw new NotImplementedException();
}
public Task RequestCancelOrder(Infrastructure.Common.Models.Trading.Order order)
{
throw new NotImplementedException();
}
