public async Task <IActionResult> CancelOrder(CancelOrderRequest request)
{
// TODO -- Make syncronous requests (Remove Await)
// Post to Customer to Minus Results (Sales count and lifetime value
using (var client = new HttpClient())
{
var url = $"https://localhost:{Mappings.addresses["customers"]}/api/customers/cancel";
var json = JsonConvert.SerializeObject(new { customerId = request.CustomerId, orderTotal = request.OrderTotal });
var stringContent = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, stringContent);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
}
// Post to Product to Add Quantities Which posts to Order which deletes the order
using (var client = new HttpClient())
{
var url = $"https://localhost:{Mappings.addresses["orders"]}/api/orders/cancel";
var json = JsonConvert.SerializeObject(new { orderId = request.OrderId });
var stringContent = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, stringContent);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
}
return(Ok("Deleted Order!"));
// Get a query that gets the ordersThatMatch CustomerId
//return Ok();
}
private bool CancelPinTuanOrder(Guid UserId, int OrderId)
{
Logger.Info($"拼团失败，取消以下订单,{UserId:D}/{OrderId}");
using (var client = new OrderOperationClient())
{
var request = new CancelOrderRequest
{
OrderId = OrderId,
UserID = UserId,
Remark = "用户参与拼团，下单24小时内未付款,订单取消"
};
var result = client.CancelOrderForApp(request);
if (!(result.Success && result.Result.IsSuccess))
{
if (result.Exception != null)
{
Logger.Warn($"订单取消失败，/{result.Exception.Message}");
}
else if (result.Result != null && result.Result.RespCode != 1)
{
Logger.Warn($"订单取消失败,{result.Result.Message}");
}
else
{
Logger.Warn($"订单取消失败,{UserId}/{OrderId}");
}
return(false);
}
return(true);
}
}
public static async Task <CancelOrderResponse> CancelOrder(string delta, string ClientID = null, long OrderID = -1)
{
var request = new CancelOrderRequest();
request.Symbol = delta;
if (ClientID != null)
{
request.OriginalClientOrderId = ClientID;
}
else if (OrderID != -1)
{
request.OrderId = OrderID;
}
else
{
return(null);
}
try { return(await client.CancelOrder(request)); }
catch (BinanceBadRequestException badRequestException) { Log.Error(badRequestException.Message); return(null); }
catch (BinanceServerException serverException) { Log.Error(serverException.Message); return(null); }
catch (BinanceTimeoutException timeoutException) { Log.Error(timeoutException.Message); return(null); }
catch (BinanceException unknownException) { Log.Error(unknownException); return(null); }
}
public Task <bool> CancelOrder(string orderId, CancellationToken ct = default(CancellationToken))
{
return(EpochNonce.Lock(_credentials.ApiKey, async nonce =>
{
var cmd = new CancelOrderRequest(orderId, _credentials, nonce);
using (var response = await _client.PostAsJsonAsync("cancel_order/", cmd, ct))
{
response.EnsureSuccessStatusCode();
var token = await response.Content.ReadAsAsync <JToken>(ct);
var errorToken = token.SelectToken("error");
if (errorToken != null)
{
if (errorToken.ToString().Contains("Order not found"))
{
// cex.io returns "Order not found" in both cases:
// 1 - Order has already been cancelled (this case is being caught here)
// 2 - Order doesn't even exist
return true;
}
throw new Exception($"Error in response: {errorToken}");
}
return (bool)token;
}
}));
}
private void CanceledOrder(List <UserOrderJobModel> dataList)
{
using (var client = new OrderOperationClient())
{
foreach (var item in dataList)
{
var request = new CancelOrderRequest
{
OrderId = item.OrderId,
UserID = item.UserId,
Remark = "拼团刷单订单取消",
FirstMenu = "拼团刷单订单取消",
SecondMenu = "拼团刷单订单取消"
};
var result = client.CancelOrderForApp(request);
if (!(result.Success && result.Result.IsSuccess))
{
if (result.Exception != null)
{
Logger.Warn($"订单取消失败，{item.UserId}/{item.OrderId}", result.Exception);
}
else if (result.Result != null && result.Result.RespCode != 1)
{
Logger.Warn($"订单取消失败,{result.Result.Message}");
}
}
}
}
}
public static CancelOrderResponse ReadFromBuffer(MessageHeader frame, ByteBuffer buf, int offset = 0)
{
if (buf.length - offset < StructSize)
{
return(null);
}
var resp = new CancelOrderResponse();
resp.OriginRequest = CancelOrderRequest.ReadFromBuffer(buf, offset);
if (resp.OriginRequest == null)
{
return(null);
}
offset += CancelOrderRequest.StructSize;
resp.InputTime = BitConverter.ToUInt64(buf.data, offset);
offset += PropInfo.GetSize(resp, o => o.InputTime);
resp.OutputTime = BitConverter.ToUInt64(buf.data, offset);
offset += PropInfo.GetSize(resp, o => o.OutputTime);
resp.SystemTime = BitConverter.ToUInt64(buf.data, offset);
offset += PropInfo.GetSize(resp, o => o.SystemTime);
resp.AmountCancelled = BitConverter.ToInt32(buf.data, offset);
offset += PropInfo.GetSize(resp, o => o.AmountCancelled);
resp.AmountRest = BitConverter.ToInt32(buf.data, offset);
offset += PropInfo.GetSize(resp, o => o.AmountRest);
resp.CancelReason = (CancelReason)buf.data[offset++];
return(resp);
}
public async Task <IActionResult> CancleOrder(
[FromRoute] int orderId,
[FromBody] CancelOrderRequest cancelRequest
)
{
int requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
CancelOrderReport cancelOrderReport = new CancelOrderReport
{
CancelReason = cancelRequest.CancelReason
};
var order = await _orderService
.GetByIdAsync(orderId, requestedUserId);
if (order == null)
{
return(NotFound());
}
var cancelResult = await _orderService.CancelOrderAsync(
order,
cancelOrderReport
);
if (cancelResult.IsSuccess == false)
{
return(BadRequest(cancelResult.Errors));
}
var orderResponse = _mapper.Map <OrderResponse>(order);
return(Ok(new Response <OrderResponse>(orderResponse)));
}
/// <summary>
/// Cancels an order based on the provided request
/// </summary>
/// <param name="request">The <see cref="CancelOrderRequest"/> that is used to define the order</param>
/// <param name="receiveWindow"></param>
/// <returns></returns>
public async Task <CancelOrderResponse> CancelOrder(CancelOrderRequest request, int receiveWindow = -1)
{
receiveWindow = SetReceiveWindow(receiveWindow);
Guard.AgainstNull(request.Symbol);
return(await _apiProcessor.ProcessDeleteRequest <CancelOrderResponse>(Endpoints.Account.CancelOrder(request), receiveWindow));
}
public static BinanceEndpointData CancelOrder(CancelOrderRequest request)
{
var queryString = GenerateQueryStringFromData(request);
return(new BinanceEndpointData(new Uri($"{BaseUrl}/{ApiVersion}/order?{queryString}"),
EndpointSecurityType.Signed));
}
private void processCancelOrder(IDownStreamAdaptor adaptor, CancelOrderRequest req)
{
if (adaptor != null)
{
try
{
adaptor.cancelOrder(req.orderId);
CancelOrderReply rsp = new CancelOrderReply();
rsp.result = true;
rsp.orderId = req.orderId;
rsp.exchangeAccount = req.exchangeAccount;
rsp.message = "success";
_manager.Publish(rsp);
}
catch (Exception e)
{
CancelOrderReply rsp = new CancelOrderReply();
rsp.result = false;
rsp.orderId = req.orderId;
rsp.exchangeAccount = req.exchangeAccount;
rsp.message = e.Message;
_manager.Publish(rsp);
}
}
else
{
CancelOrderReply rsp = new CancelOrderReply();
rsp.result = false;
rsp.orderId = req.orderId;
rsp.exchangeAccount = req.exchangeAccount;
rsp.message = req.exchangeAccount + " not exist";
_manager.Publish(rsp);
}
}
public override async Task <CancelOrderResponse> CancelOrder(CancelOrderRequest request, ServerCallContext context)
{
MeResponseModel response = await _matchingEngineClient.CancelLimitOrderAsync(request.OrderId);
if (response == null)
{
return(new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.Runtime, Message = ErrorMessages.MeNotAvailable
}
});
}
if (response.Status == MeStatusCodes.Ok || response.Status == MeStatusCodes.NotFound)
{
return new CancelOrderResponse {
Body = new CancelOrderResponse.Types.Body {
Payload = true
}
}
}
;
return(new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.Unknown, Message = $"ME status: {response.Status}, message: {response.Message}"
}
});
}
/// <summary>
/// Cancel order
/// </summary>
/// <returns>Order</returns>
public async Task <CallResult <HitBTCOrder> > CancelOrderAsync(string clientOrderId)
{
var request = new CancelOrderRequest(NextId(), clientOrderId);
var result = await Query <HitBTCSocketResponse <HitBTCOrder> >(request, true).ConfigureAwait(false);
return(new CallResult <HitBTCOrder>(result.Data?.Result, result.Error));
}
public async Task <CancelOrderResponse> CancelOrderAsync(CancelOrderRequest request)
{
//TODO: Place an order validation to here
await MakePrivateCallAsync(BuildUrl(_settings.PrivateUrl, "CancelTrade"), request);
return(new CancelOrderResponse(request.OrderId));
}
public async Task <ActionResult <CancelOrderResponse> > Cancel([FromRoute] CancelOrderRequest request)
{
_logger.LogInformation($"Cancel order service call for {request.OrderNumber}...");
var response = new CancelOrderResponse();
try
{
var order = await _orderProcessingService.GetOrderAsync(request.OrderNumber);
await _orderProcessingService.CancelOrderAsync(order);
response.OperationSucceded = true;
}
catch (OrderNotFoundException ex)
{
_logger.LogWarning($"{ex.Message}");
return(NotFound(ex.Message));
}
catch (ValidationException ex)
{
_logger.LogWarning($"Validations failures: {ex.Message}");
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
_logger.LogError($"Exception occured while canceling order: {ex.Message} {ex.StackTrace}");
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
return(Ok(response));
}
/// <summary>
/// Cancels an order based on the provided request
/// </summary>
/// <param name="request">The <see cref="CancelOrderRequest"/> that is used to define the order</param>
/// <param name="receiveWindow"></param>
/// <returns></returns>
public async Task <CancelOrderResponse> CancelOrder(CancelOrderRequest request, int receiveWindow = 100000000) // 5000)
{
Guard.AgainstNull(request.Symbol);
var ep = Endpoints.Account.CancelOrder(request);
return(await _apiProcessor.ProcessDeleteRequest <CancelOrderResponse>(ep, receiveWindow));
}
public void RequiresPaymentToken()
{
var request = new CancelOrderRequest()
{
Token = null
};
//Throws when token is null
Assert.ThrowsException <ArgumentNullException>
(
() =>
{
request.Validate();
}
);
request.Token = String.Empty;
//Throws when Token is empty string
Assert.ThrowsException <ArgumentException>
(
() =>
{
request.Validate();
}
);
//Does not throw when Token is not empty
request.Token = System.Guid.NewGuid().ToString();
request.Validate();
}
public void CancelOrderRequest()
{
CancelOrderRequest Req;
AutoGen.CancelOrderRequest D;
// Test the first constructor.
Req = new CancelOrderRequest(MERCHANT_ID, MERCHANT_KEY, "Sandbox", ORDER_NUMBER,
REASON);
D = ParseCancelOrderRequest(Req.GetXml());
Assert.AreEqual(ORDER_NUMBER, D.googleordernumber);
Assert.AreEqual(null, D.comment);
Assert.AreEqual(REASON, D.reason);
Assert.AreEqual(Req.GoogleOrderNumber, D.googleordernumber);
// Test the second constructor.
Req = new CancelOrderRequest(MERCHANT_ID, MERCHANT_KEY, "Sandbox", ORDER_NUMBER,
REASON, COMMENT);
D = ParseCancelOrderRequest(Req.GetXml());
Assert.AreEqual(ORDER_NUMBER, D.googleordernumber);
Assert.AreEqual(COMMENT, D.comment);
Assert.AreEqual(REASON, D.reason);
Req = new CancelOrderRequest(ORDER_NUMBER, REASON);
D = ParseCancelOrderRequest(Req.GetXml());
Req = new CancelOrderRequest(ORDER_NUMBER, REASON, COMMENT);
D = ParseCancelOrderRequest(Req.GetXml());
}
public override Task <CancelOrderResponse> CancelOrder(CancelOrderRequest request, grpc::ServerCallContext context)
{
Console.WriteLine("Handling Order cancellation request");
var result = new CancelOrderResponse();
try
{
var exists = orderManagementClient.OrderExists(new GetOrderRequest {
OrderID = request.OrderID
});
if (!exists.Exists)
{
result.Canceled = false;
return(Task.FromResult(result));
}
var originalOrder = orderManagementClient.GetOrder(new GetOrderRequest {
OrderID = request.OrderID
});
var evt = new OrderCanceledEvent
{
OrderID = request.OrderID,
UserID = request.UserID,
CreatedOn = (ulong)DateTime.UtcNow.Ticks,
ActivityID = Guid.NewGuid().ToString(),
};
if (eventEmitter.EmitOrderCanceledEvent(evt))
{
result.ConfirmationCode = Guid.NewGuid().ToString();
result.Canceled = true;
foreach (var li in originalOrder.LineItems)
{
eventEmitter.EmitInventoryReleasedEvent(new InventoryReleasedEvent
{
SKU = li.SKU,
ReleasedOn = (ulong)DateTime.UtcNow.Ticks,
Quantity = li.Quantity,
OrderID = request.OrderID,
UserID = request.UserID,
EventID = Guid.NewGuid().ToString()
});
}
}
else
{
result.Canceled = false;
}
return(Task.FromResult(result));
}
catch (Exception ex)
{
Console.WriteLine($"Failed to handle order cancellation {ex.ToString()}");
result.Canceled = false;
return(Task.FromResult(result));
}
}
public async Task CancelOrderAsync(long orderId, CancellationToken cancellationToken = default)
{
var request = new CancelOrderRequest
{
OrderId = orderId
};
await _client.PostAsync <object>("order_cancel", request, cancellationToken);
}
public CancelOrderResponse CancelOrder(int order_id)
{
CancelOrderRequest req = new CancelOrderRequest(Nonce, order_id);
string response = SendRequest(req, "POST");
CancelOrderResponse resp = CancelOrderResponse.FromJSON(response);
return(resp);
}
/// <summary>
/// 取消订单
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static async Task <OrderCancelResp> CancelOrder(CancelOrderRequest request)
{
using (var client = new OrderOperationClient())
{
var clientResult = client.CancelOrderForApp(request);
clientResult.ThrowIfException(true);
return(clientResult.Result);
}
}
public async Task <bool> CancelOrder(CancelOrderRequest request)
{
var arg = new StatusOrderRequest {
orderId = request.orderId, status = request.status
};
var result = await MoveOrderStatus(arg);
return(result.success);
}
public void CancelOrder(string OrderId)
{
CancelOrderRequest cancel = new CancelOrderRequest
{
OrderID = OrderId
};
AddMessageToQueue(cancel);
}
public override CancelOrderModel CancelOrder(CancelOrderRequestBase orderCancelRequest)
{
var orderCancel = new CancelOrderRequest(this)
{
Txid = orderCancelRequest.OrderId
};
return(orderCancel.Request <CancelOrderResponse>().Transform());
}
public async Task OnPostClose(int orderId)
{
CancelOrderRequest request = new CancelOrderRequest
{
OrderId = orderId
};
await mediator.Send(request);
}
public async Task <CancelOrderResponse> CancelOrder(CancelOrderRequest request)
{
Domain.Order order = await repo.GetOrder(request.OrderId);
order.Cancel();
order = await repo.SaveAsync(order);
return(new CancelOrderResponse(true, ResponseAction.Updated));
}
/// <summary>
/// Remove this order from outstanding queue: user is requesting a cancel.
/// </summary>
/// <param name="request">Request containing the specific order id to remove</param>
public OrderTicket CancelOrder(CancelOrderRequest request)
{
OrderTicket ticket;
if (!_orderTickets.TryGetValue(request.OrderId, out ticket))
{
Log.Error("BrokerageTransactionHandler.CancelOrder(): Unable to locate ticket for order.");
return(OrderTicket.InvalidCancelOrderId(_algorithm.Transactions, request));
}
try
{
// if we couldn't set this request as the cancellation then another thread/someone
// else is already doing it or it in fact has already been cancelled
if (!ticket.TrySetCancelRequest(request))
{
// the ticket has already been cancelled
request.SetResponse(OrderResponse.Error(request, OrderResponseErrorCode.InvalidRequest, "Cancellation is already in progress."));
return(ticket);
}
//Error check
var order = GetOrderByIdInternal(request.OrderId);
if (order != null && request.Tag != null)
{
order.Tag = request.Tag;
}
if (order == null)
{
Log.Error("BrokerageTransactionHandler.CancelOrder(): Cannot find this id.");
request.SetResponse(OrderResponse.UnableToFindOrder(request));
}
else if (order.Status.IsClosed())
{
Log.Error("BrokerageTransactionHandler.CancelOrder(): Order already " + order.Status);
request.SetResponse(OrderResponse.InvalidStatus(request, order));
}
else if (_algorithm.IsWarmingUp)
{
request.SetResponse(OrderResponse.WarmingUp(request));
}
else
{
// send the request to be processed
request.SetResponse(OrderResponse.Success(request), OrderRequestStatus.Processing);
_orderRequestQueue.Add(request);
}
}
catch (Exception err)
{
Log.Error(err);
request.SetResponse(OrderResponse.Error(request, OrderResponseErrorCode.ProcessingError, err.Message));
}
return(ticket);
}
/// <summary>
/// Cancel an order.
/// </summary>
/// <param name="apiKey">Your apiKey.</param>
/// <param name="apiSecret">Your apiSecretKey.</param>
/// <param name="ID">Order ID.</param>
/// <response code="200">Order is canceled.</response>
/// <response code="400_InvalidUrlParameters">Invalid URL parameters.</response>
/// <response code="400_MissingBody">Request body is missing.</response>
/// <response code="400_InvalidBody">Request validation errors. See InnerErrors.</response>
/// <response code="400_ValidationError">Request validation errors. See InnerErrors.</response>
/// <response code="403">Not authorized to use this endpoint.</response>
/// <response code="404">Order is not found.</response>
/// <response code="409">Cannot be canceled.</response>
/// <response code="500">Server error.</response>
/// <returns></returns>
public async Task <Result <bool, ErrorResponse> > CancelOrderAsync(string apiKey, string apiSecret, Guid?ID)
{
#region
if (ID == null || ID == Guid.Empty)
{
throw new ArgumentNullException(nameof(ID));
}
#endregion
string token = getAuthToken(apiKey, apiSecret);
var result = new Result <bool, ErrorResponse>();
string requestUri = $"{mEnv.BaseUrl}/v1/Orders/{ID}";
CancelOrderRequest bodyParams = new CancelOrderRequest();
string json = bodyParams.ToJson();
StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
HttpRequestMessage request = new HttpRequestMessage
{
Method = new HttpMethod("PATCH"),
RequestUri = new Uri(requestUri),
Content = content
};
try
{
using (HttpClient httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add(AUTHORIZATION, $"{BASIC} {token}");
using (HttpResponseMessage response = await httpClient.SendAsync(request))
{
if (response.IsSuccessStatusCode)
{
result.IsSuccess = true;
result.Data = true;
return(result);
}
string contentString = await response.Content.ReadAsStringAsync();
result.Error = ResponseHandler.GetError(response.StatusCode, requestUri, contentString);
}
}
}
catch (HttpRequestException)
{
result.IsSuccess = false;
result.Error = ResponseHandler.GetExceptionError();
}
return(result);
}
public async Task <CancelledOrder> CancelOrder(string symbol, string origClientOrderId = null, long orderId = -1)
{
var req = new CancelOrderRequest()
{
Symbol = symbol, OrigClientOrderId = origClientOrderId, OrderId = orderId
};
var resp = await _connecter.PrivateRequest(req);
return(JsonConvert.DeserializeObject <CancelledOrder>(resp.Content));
}
public void Cancel(string orderId, CancelOrderHttpRequest httpRequest)
{
var request = new CancelOrderRequest {
Reason = httpRequest.reason
};
var presenter = new CancelOrderPresenter(_accessor.HttpContext.Response);
var useCase = new CancelOrderUseCase(_repo, presenter);
useCase.Execute(orderId, request);
}
/// <summary>
/// Executes Cancel Order Command
/// </summary>
private void OnCanelOrderCommand(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(txtOrderId.Text))
return;
var request = new CancelOrderRequest { OrderId = int.Parse(txtOrderId.Text) };
var client = new WcfServiceOf_CancelOrderRequest_ErrorCodesClient("BasicHttpBinding_IWcfServiceOf_CancelOrderRequest_ErrorCodes");
client.ProcessCompleted += OnProcessCompleted;
client.ProcessAsync(request);
txtOrderId.Text = string.Empty;
}
