public async Task <IActionResult> CancelLimitOrder([FromBody] CancelLimitOrderRequest request)
{
try
{
if (!long.TryParse(request.OrderId, out var orderId))
{
return(BadRequest("OrderId should be long"));
}
var result = await GetAuthenticatedExchange().CancelOrder(orderId, TimeSpan.FromSeconds(DefaultTimeOutSeconds));
return(Ok(new CancelLimitOrderResponse {
OrderId = result.ToString(CultureInfo.InvariantCulture)
}));
}
catch (ApiException e)
{
if (e.ErrorCode == ApiErrorCode.OrderNotFound || e.ApiStatusCode == HttpStatusCode.NotFound)
{
return(NotFound(new ErrorModel(e.Message, e.ErrorCode)));
}
if (e.ApiStatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest(new ErrorModel(e.Message, e.ErrorCode)));
}
return(StatusCode((int)HttpStatusCode.InternalServerError, new ErrorModel(e.Message, e.ErrorCode)));
}
}
public override async Task <CancelLimitOrderResponse> CancelLimitOrderAsync([FromBody] CancelLimitOrderRequest request)
{
if (Guid.TryParse(request.OrderId, out Guid orderId))
{
await Api.CancelLimitOrderAsync(orderId);
}
return(new CancelLimitOrderResponse
{
OrderId = request.OrderId
});
}
public override async Task <CancelLimitOrderResponse> CancelLimitOrderAsync([FromBody] CancelLimitOrderRequest request)
{
var cancelled = await Api.CancelOrder(request.OrderId);
if (!cancelled)
{
_log.Warning($"The order with id = {request.OrderId} has not been cancelled");
}
return(new CancelLimitOrderResponse {
OrderId = request.OrderId
});
}
public override async Task <CancelLimitOrderResponse> CancelLimitOrderAsync(
[FromBody] CancelLimitOrderRequest request)
{
OrdersCanceled response = await Api.CancelOpenOrder(request.OrderId);
if (response.Count != 1)
{
_log.Warning($"Expected single order canceled, but count = {response.Count}");
}
return(new CancelLimitOrderResponse {
OrderId = request.OrderId
});
}
public async Task <IActionResult> CancelOrder([FromBody] CancelLimitOrderRequest request)
{
if (request?.OrderId == null)
{
return(BadRequest("Incorect parameters - null"));
}
await _meclient.CancelLimitOrderAsync(request.OrderId);
var resp = new CancelLimitOrderResponse()
{
OrderId = request?.OrderId
};
return(Ok(resp));
}
public void CancelLimitOrder(OsEngine.Entity.Order order)
{
var cancelOrders = new CancelLimitOrderRequest
{
ExpireControl = new RequestExpired
{
Now = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds,
Ttl = ttl
},
CurrencyPair = order.SecurityNameCode.Replace("_", "/"),
Id = Convert.ToInt64(order.NumberMarket)
};
string token = "CancelOrder_" + order.NumberUser;
SendAuthMessage(_secKey, token, WsRequestMetaData.WsRequestMsgType.CancelLimitOrder, cancelOrders);
}
public async Task <CancelLimitOrderResponse> CancelLimitOrderAsync([FromBody] CancelLimitOrderRequest request)
{
InternalOrder internalOrder = await _internalOrderService.GetByIdAsync(request.OrderId);
if (internalOrder == null)
{
throw new ValidationApiException(HttpStatusCode.NotFound, "Order not found");
}
if (internalOrder.Status != InternalOrderStatus.Cancelled &&
internalOrder.Status != InternalOrderStatus.Rejected &&
internalOrder.Status != InternalOrderStatus.Completed)
{
throw new ValidationApiException(HttpStatusCode.BadRequest, "Can not cancel order");
}
return(new CancelLimitOrderResponse
{
OrderId = request.OrderId
});
}
public override async Task <CancelLimitOrderResponse> CancelLimitOrderAsync(
[FromBody] CancelLimitOrderRequest request)
{
CancelOrderResponse response;
try
{
response = await Api.CancelOrderAsync(request.OrderId);
}
catch (OrderNotFoundException)
{
return(new CancelLimitOrderResponse {
OrderId = request.OrderId
});
}
await _limitOrderRepository.UpdateStatusAsync(response.Id, OrderStatus.Canceled);
return(new CancelLimitOrderResponse {
OrderId = response.Id
});
}
public virtual Task <CancelLimitOrderResponse> CancelLimitOrderAsync([FromBody] CancelLimitOrderRequest request)
{
throw new System.NotImplementedException();
}
//[Fact]
public async Task CanPlaceAndCancelLimitOrder()
{
var client = _factory.CreateClient();
var createOrderRequest = new LimitOrderRequest
{
TradeType = TradeType.Buy, Instrument = "BTCUSD", Price = 1500m, Volume = 0.01m
};
// Place new order
var createResponse = await client.PostAsync(
"/spot/createLimitOrder",
new StringContent(
JsonConvert.SerializeObject(createOrderRequest),
Encoding.UTF8,
"application/json"));
Assert.True(createResponse.StatusCode == HttpStatusCode.OK);
var orderIdResponse = await createResponse.Content.ReadAsAsync <OrderIdResponse>();
var cancelOrderRequest = new CancelLimitOrderRequest {
OrderId = orderIdResponse.OrderId
};
// Cancel order
var cancelResponse = await client.PostAsync(
"/spot/cancelOrder",
new StringContent(
JsonConvert.SerializeObject(cancelOrderRequest),
Encoding.UTF8,
"application/json"));
Assert.True(cancelResponse.StatusCode == HttpStatusCode.OK);
var cancelOrderResponse = await cancelResponse.Content.ReadAsAsync <CancelLimitOrderResponse>();
Assert.Equal(cancelOrderResponse.OrderId, orderIdResponse.OrderId);
// Cancel same order again, should return 200 OK
var cancelSubsequentResponse = await client.PostAsync(
"/spot/cancelOrder",
new StringContent(
JsonConvert.SerializeObject(cancelOrderRequest),
Encoding.UTF8,
"application/json"));
Assert.True(cancelSubsequentResponse.StatusCode == HttpStatusCode.OK);
var cancelOrderSubsequentResponse =
await cancelSubsequentResponse.Content.ReadAsAsync <CancelLimitOrderResponse>();
Assert.Equal(cancelOrderSubsequentResponse.OrderId, orderIdResponse.OrderId);
// Get previously created and cancelled order status
var statusResponse = await client.GetAsync($"/spot/limitOrderStatus?orderId={orderIdResponse.OrderId}");
Assert.True(statusResponse.StatusCode == HttpStatusCode.OK);
var statusOrderResponse = await statusResponse.Content.ReadAsAsync <OrderModel>();
Assert.Equal(statusOrderResponse.Id, orderIdResponse.OrderId);
Assert.Equal(OrderStatus.Canceled, statusOrderResponse.ExecutionStatus);
}
