public async Task <IActionResult> PutMyOrders([FromRoute] int id, [FromBody] MyOrders myOrders)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != myOrders.MyOrderId)
{
return(BadRequest());
}
_context.Entry(myOrders).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MyOrdersExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Cancel orders. Send multiple order IDs to cancel in bulk.
/// </summary>
/// <param name="order_ids"></param>
/// <returns></returns>
public async ValueTask <MyOrders> CancelOrders(string[] order_ids)
{
var _result = new MyOrders();
var _params = new Dictionary <string, object>();
{
_params.Add("orderID", order_ids);
}
var _response = await privateClient.CallApiDelete2Async("/api/v1/order", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _orders = privateClient.DeserializeObject <List <BPlaceOrderItem> >(_response.Content);
if (_orders != null)
{
_result.result.AddRange(_orders);
_result.SetSuccess();
}
}
else
{
var _message = privateClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
private async Task LoadMoreOrders()
{
if (HasMoreOrders)
{
await Task.Delay(200);
PageIndex += 1;
var orderHistoryRequest = new OrderHistoryRequest
{
CustomerId = GlobalSettings.User.Id,
Page = PageIndex,
PageSize = GlobalSettings.AppConst.PageSize
};
await WebRequestExecuter.Execute(async() => await _wooCommerceService.GetOrders(orderHistoryRequest), myOrders =>
{
if (myOrders != null && myOrders.Any())
{
foreach (var order in myOrders)
{
MyOrders.Add(order);
}
HasMoreOrders = myOrders.Count >= orderHistoryRequest.PageSize ? true : false;
}
else
{
PageIndex -= 1;
HasMoreOrders = false;
}
return(Task.CompletedTask);
});
}
}
/// <summary>
/// Create a new limit bulk order.
/// </summary>
/// <param name="orders"></param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public async Task <MyOrders> CreateBulkOrder(List <BBulkOrderItem> orders, Dictionary <string, object> args = null)
{
var _result = new MyOrders();
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
{
var _params = tradeClient.MergeParamsAndArgs(
new Dictionary <string, object>
{
{ "orders", orders }
},
args
);
var _json_value = await tradeClient.CallApiPost1Async("/api/v1/order/bulk", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orders = tradeClient.DeserializeObject <List <BMyOrderItem> >(_json_value.Content);
{
_result.result = _orders.ToList <IMyOrderItem>();
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Cancels all of your orders.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> CancelAllOrdersAsync(Dictionary <string, object> args = null)
{
var _result = new MyOrders();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(args);
var _json_value = await tradeClient.CallApiDelete1Async("/api/v1/order/all", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <List <BPlaceOrderItem> >(_json_value.Content);
{
_result.result.AddRange(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// View Exchange Orders
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="timeframe">time frame interval (optional): default "1d"</param>
/// <param name="since">return committed data since given time (milli-seconds) (optional): default 0</param>
/// <param name="limit">maximum number of items (optional): default 20</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrders> FetchMyOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limit = 20, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _timeframe = tradeClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = tradeClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("currency_pair", _market.result.symbol);
_params.Add("offset", 0);
_params.Add("limit", limit);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async("/user/orders", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <List <KMyOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(o => o.symbol == _market.result.symbol && o.timestamp >= since)
.OrderByDescending(o => o.timestamp)
.Take(limit);
foreach (var _o in _orders)
{
if (_o.price == 0)
{
_o.price = _o.avg_price;
}
_o.amount = _o.price * _o.quantity;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Returns your open orders for a given market.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("command", "returnOpenOrders");
_params.Add("currencyPair", _market.result.symbol);
if (args != null)
{
foreach (var _a in args)
{
if (_params.ContainsKey(_a.Key) == true)
{
_params.Remove(_a.Key);
}
_params.Add(_a.Key, _a.Value);
}
}
}
var _json_value = await tradeClient.CallApiPost1Async("", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orders = tradeClient.DeserializeObject <List <PMyOrderItem> >(_json_value.Content);
{
foreach (var _o in _orders)
{
_o.orderStatus = OrderStatus.Open;
_o.orderType = OrderType.Limit;
_o.symbol = _market.result.symbol;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// To get open orders on a symbol.
/// </summary>
/// <param name="symbol">Instrument symbol. Send a bare series (e.g. XBT) to get data for the nearest expiring contract in that series.</param>
/// <param name="count">Number of results to fetch.</param>
/// <param name="start">Starting point for results.</param>
/// <returns></returns>
public async ValueTask <MyOrders> GetOrders(string symbol, long count = 0, long start = 0)
{
var _result = new MyOrders();
await Task.Delay(0);
return(_result);
}
/// <summary>
/// Returns your open orders for all markets.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchAllOpenOrders(Dictionary <string, object> args = null)
{
var _result = new MyOrders();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("command", "returnOpenOrders");
_params.Add("currencyPair", "all");
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orders = tradeClient.DeserializeObject <Dictionary <string, List <PMyOrderItem> > >(_json_value.Content);
{
foreach (var _o in _orders)
{
var _market = _markets.GetMarketBySymbol(_o.Key);
if (_market == null)
{
continue;
}
foreach (var _order in _o.Value)
{
_order.symbol = _market.symbol;
_order.orderStatus = OrderStatus.Open;
_order.orderType = OrderType.Limit;
_result.result.Add(_order);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// To get open orders on a symbol.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchOpenOrdersAsync(string base_name, string quote_name, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("reverse", true);
_params.Add("filter", new CArgument
{
isJson = true,
value = new Dictionary <string, object>
{
{ "open", true }
}
});
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async("/api/v1/order", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
//var _multiplier = publicApi.publicClient.ExchangeInfo.GetAmountMultiplier(_market.result.symbol, 1.0m);
var _orders = tradeClient.DeserializeObject <List <BMyOrderItem> >(_json_value.Content);
foreach (var _o in _orders)
{
_o.makerType = MakerType.Maker;
_o.amount = _o.price * _o.quantity;
_o.filled = Math.Max(_o.quantity - _o.remaining, 0);
_o.cost = _o.price * _o.filled;
_result.result.Add(_o);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Get your orders.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="timeframe">time frame interval (optional): default "1d"</param>
/// <param name="since">return committed data since given time (milli-seconds) (optional): default 0</param>
/// <param name="limits">maximum number of items (optional): default 20</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchMyOrdersAsync(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _timeframe = tradeClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = tradeClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("count", limits);
if (since > 0)
{
_params.Add("startTime", CUnixTime.ConvertToUtcTimeMilli(since).ToString("yyyy-MM-dd HH:mm"));
}
_params.Add("reverse", true);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async("/api/v1/order", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <List <BMyOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(o => o.symbol == _market.result.symbol && o.timestamp >= since)
.OrderByDescending(o => o.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.amount = _o.price * _o.quantity;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// To get open orders on a symbol.
/// </summary>
/// <param name="symbol">Instrument symbol. Send a bare series (e.g. XBT) to get data for the nearest expiring contract in that series.</param>
/// <param name="count">Number of results to fetch.</param>
/// <param name="start">Starting point for results.</param>
/// <returns></returns>
public async ValueTask <MyOrders> GetOrders(string symbol, long count = 0, long start = 0)
{
var _result = new MyOrders();
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", symbol);
if (count > 0)
{
_params.Add("count", count);
}
_params.Add("start", start);
_params.Add("reverse", true);
_params.Add("filter", new CArgument
{
isJson = true,
value = new Dictionary <string, object>
{
{ "open", true }
}
});
}
var _response = await privateClient.CallApiGet2Async("/api/v1/order", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _orders = privateClient.DeserializeObject <List <BMyOrderItem> >(_response.Content);
if (_orders != null)
{
foreach (var _o in _orders)
{
_o.makerType = MakerType.Maker;
_o.amount = _o.price * _o.quantity;
_o.filled = Math.Max(_o.quantity - _o.remaining, 0);
_o.cost = _o.price * _o.filled;
}
_result.result = _orders.ToList <IMyOrderItem>();
_result.SetSuccess();
}
}
else
{
var _message = privateClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
/// <summary>
/// Cancel Open Orders
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_ids"></param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> CancelOrdersAsync(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("order_id", String.Join(",", order_ids));
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/v1/cancel_order.do", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <OCancelOrders>(_json_value.Content);
foreach (var _o in _json_data.result)
{
var _order = new OPlaceOrderItem
{
symbol = _market.result.symbol,
orderId = _o.orderId,
orderType = OrderType.Limit,
orderStatus = OrderStatus.Canceled,
//sideType = sideType,
//quantity = quantity,
//price = price,
//amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
timestamp = CUnixTime.NowMilli,
success = _o.success
};
_result.result.Add(_order);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
private void UIDeliveryInfoSetup(MyOrders o)
{
RP_straat.Text = o._straatnaam;
RP_postcode.Text = o._postcode;
RP_plaats.Text = o._plaats;
RP_ontvanger.Text = o._ontvanger;
RP_land.Text = o._land;
RP_huisnr.Text = o._huisnr;
}
private void RefreshOrders()
{
if (_omniEve != null)
{
MyOrders myOrders = new MyOrders();
myOrders.OnMyOrdersFinished += OnMyOrdersFinished;
_omniEve.AddAction(myOrders);
}
}
/// <summary>
/// Get all open orders on a symbol. Careful when accessing this with no symbol.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchOpenOrdersAsync(string base_name, string quote_name, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
okexClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("order_id", -1); // if order_id is -1, then return all unfilled orders, otherwise return the order specified
tradeClient.MergeParamsAndArgs(_params, args);
}
var _end_point = okexClient.CheckFuturesUrl(_market.result, "/order_info.do", "/future_order_info.do", _params);
var _json_value = await okexClient.CallApiPost1Async(_end_point.endPoint, _end_point.args);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = okexClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = okexClient.DeserializeObject <OMyOrders>(_json_value.Content);
if (_json_data.success == true)
{
var _orders = _json_data.result
.Where(o => o.symbol == _market.result.symbol)
.OrderByDescending(o => o.timestamp);
foreach (var _o in _orders)
{
_o.amount = _o.price * _o.quantity;
_result.result.Add(_o);
}
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Cancel Open Orders
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_ids"></param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrders> CancelOrders(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("currency_pair", _market.result.symbol);
_params.Add("id", new CArgument {
isArray = true, value = order_ids
});
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/user/orders/cancel", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <List <KCancelOrderItem> >(_json_value.Content);
{
foreach (var _o in _json_data)
{
var _order = new KMyOrderItem
{
orderId = _o.orderId,
symbol = _market.result.symbol,
timestamp = CUnixTime.NowMilli,
orderStatus = _o.status == "success" ? OrderStatus.Canceled : OrderStatus.Unknown,
orderType = OrderType.Limit
};
_result.result.Add(_order);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// List Open Orders
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("currency_pair", _market.result.symbol);
_params.Add("offset", 0);
_params.Add("limit", 50);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async("/user/orders/open", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orders = tradeClient.DeserializeObject <List <KMyOpenOrderItem> >(_json_value.Content);
{
foreach (var _o in _orders)
{
_o.symbol = _market.result.symbol;
_o.quantity = _o.totalValue.value;
_o.price = _o.priceValue.value;
_o.amount = _o.quantity * _o.price;
_o.filled = _o.quantity - _o.openValue.value;
_o.cost = _o.filled * _o.price;
_o.orderStatus = OrderStatus.Open;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Get all orders that you currently have opened. A specific market can be requested.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
if (args.ContainsKey("account-id") && args["account-id"].ToString() != "")
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("account-id", args["account-id"].ToString());
_params.Add("symbol", _market.result.symbol);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async("/v1/order/openOrders", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orders = tradeClient.DeserializeObject <HMyOrders>(_json_value.Content);
{
foreach (var _order in _orders.result)
{
_order.orderStatus = OrderStatus.Open;
//_order.filled = _order.quantity - _order.remaining;
_order.amount = _order.price * _order.quantity;
_result.result.Add(_order);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetFailure("required args[account-id]");
}
}
else
{
_result.SetResult(_market);
}
return(_result);
}
private void RunMyOrders()
{
Logging.Log("Automation:RunMyOrders", "MyOrders State - Begin", Logging.Debug);
MyOrders myOrders = new MyOrders();
myOrders.OnMyOrdersFinished += MyOrdersFinished;
myOrders.OnMyOrdersFinished += OnMyOrdersFinished;
RunAction(myOrders);
ChangeState(State.Processing);
}
public HttpResponseMessage postall(MyOrders objMyOrders)
{
try
{
DataTable dt = objMyOrdersBL.postAllData(objMyOrders);
return(Request.CreateResponse(HttpStatusCode.OK, dt));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
/// <summary>
/// View your latest inactive orders.
/// Limited to last 3 days and 1 request per minute.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="timeframe">time frame interval (optional): default "1d"</param>
/// <param name="since">return committed data since given time (milli-seconds) (optional): default 0</param>
/// <param name="limits">maximum number of items (optional): default 20</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchMyOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _timeframe = tradeClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = tradeClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("states", "pre-submitted,submitted,partial-filled,partial-canceled,filled,canceled");
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async("/v1/order/orders", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <HMyOrders>(_json_value.Content);
{
var _orders = _json_data.result
.Where(o => o.symbol == _market.result.symbol && o.timestamp >= since)
.OrderByDescending(o => o.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.amount = _o.price * _o.quantity;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public async Task <IActionResult> PostMyOrders([FromBody] MyOrders myOrders)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.MyOrders.Add(myOrders);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMyOrders", new { id = myOrders.MyOrderId }, myOrders));
}
/// <summary>
/// With best effort, cancel open orders. The response is a list of ids of the canceled orders.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_ids"></param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrders> CancelOrders(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("product_id", _market.result.symbol);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiDelete1Async($"/orders", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <JArray>(_json_value.Content);
{
foreach (var _o in _json_data)
{
var _order = new GMyOrderItem
{
orderId = _o.Value <string>(),
symbol = _market.result.symbol,
timestamp = CUnixTime.NowMilli,
orderStatus = OrderStatus.Canceled,
orderType = OrderType.Limit
};
_result.result.Add(_order);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// 주문 리스트 조회
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchOpenOrdersAsync(string base_name, string quote_name, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("status", 0);
_params.Add("current_page", 1);
_params.Add("page_length", 100);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/v1/order_history.do", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <OMyOrders>(_json_value.Content);
if (_json_data.success == true)
{
foreach (var _o in _json_data.result)
{
_o.amount = _o.price * _o.quantity;
_result.result.Add(_o);
}
}
else
{
_json_result.SetFailure(_json_data.message);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Get all open orders
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchAllOpenOrdersAsync(Dictionary <string, object> args = null)
{
var _result = new MyOrders();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(args);
var _json_value = await tradeClient.CallApiPost1Async("/0/private/OpenOrders", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <KResponse <KMyOpenOrders> >(_json_value.Content);
{
var _orders = _json_data.result.open
.OrderByDescending(o => o.Value.timestamp);
foreach (var _o in _orders)
{
_o.Value.orderId = _o.Key;
var _market = _markets.result.Values.Where(m => (m as KMarketItem).altname == _o.Value.symbol).SingleOrDefault();
if (_market != null)
{
_o.Value.symbol = _market.symbol;
}
_o.Value.price = _o.Value.descr.price != 0.0m ? _o.Value.descr.price : _o.Value.price;
_o.Value.amount = _o.Value.price * _o.Value.quantity;
_result.result.Add(_o.Value);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
private void GetMyOrders()
{
// получаем все отзывы
var reviews = _unitOfWork.ClientReviews.GetAll().ToList();
// получаем заказы. далее для отображения ищем заказы определенного пользователя
var orders = _unitOfWork.Orders.GetAll().ToList().Where(o => o.UserId == ClientReview.UserId)
//такие, на которые еще нет отзывов
.Where(o => !reviews.Exists(r => r.OrderId == o.Id));
MyOrders.Clear();
MyOrders.AddItems(orders);
}
public UserIndex Update(IUserOrder newUserOrder)
{
var index = MyOrders.IndexOf(newUserOrder);
if (index >= 0)
{
throw new InvalidOperationException(string.Format("MyOrders already contains user order {0}.", newUserOrder));
}
var newMyOrder = MyOrders.Add(newUserOrder);
return(new UserIndex(User, newUserOrder.Transaction, newMyOrder, AssigningOrders));
}
public UserIndex Update(IAssignedUserOrder assignedUserOrder)
{
var index = MyOrders.IndexOf(assignedUserOrder);
if (index < 0)
{
throw new InvalidOperationException(string.Format("MyOrders does not contains user order {0}.", assignedUserOrder));
}
var newMyOrders = MyOrders.SetItem(index, assignedUserOrder);
return(new UserIndex(User, LastTransaction, newMyOrders, AssigningOrders));
}
/// <summary>
/// Order_V2 - My Limit Orders
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null)
{
var _result = new MyOrders(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.symbol);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/v2/order/limit_orders", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orders = tradeClient.DeserializeObject <CMyOpenOrders>(_json_value.Content);
if (_orders.success == true)
{
foreach (var _order in _orders.limitOrders)
{
_order.symbol = _market.result.symbol;
_order.amount = _order.quantity * _order.price;
_result.result.Add(_order);
}
}
else
{
_json_result.SetResult(_orders);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
