/// <summary>
/// Fetch array of recent trades data
/// </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 <CompleteOrders> FetchCompleteOrdersAsync(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
var _limits = limits <= 1 ? 1
: limits <= 1000 ? limits
: 1000;
_params.Add("product_id", _market.result.symbol);
_params.Add("limit", _limits);
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/executions", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <QCompleteOrders>(_json_value.Content);
{
var _orders = _json_data.result
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.fillType = FillType.Fill;
_o.orderType = OrderType.Limit;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 Task<CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary<string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary<string, object>();
{
_params.Add("currency", _market.result.symbol);
_params.Add("period", _timeframe); // period[String] Period. Default value: hour. Allowed values: hour, day
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/trades", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject<CCompleteOrders>(_json_value.Content);
if (_json_data.success == true)
{
var _orders = _json_data.result
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.fillType = FillType.Fill;
_o.orderType = OrderType.Limit;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
else
{
_json_result.SetFailure(_json_data.message);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return _result;
}
/// <summary>
/// Fetch array of recent trades data
/// </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 Task <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("currency_pair", _market.result.symbol);
//_params.Add("time", "hour"); // default hour, The time period you want to query. If this parameter is specified as minute,
// it queries data within the last minute, hour means the last hour, day means the last 24 hours.
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/transactions", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <KCompleteOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.orderType = OrderType.Limit;
_o.fillType = FillType.Fill;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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: contract_type(this_week, next_week, month, quarter)</param>
/// <returns></returns>
public override async ValueTask <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
okexapiClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = okexapiClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = okexapiClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
okexapiClient.MergeParamsAndArgs(_params, args);
}
var _end_point = okexapiClient.CheckFuturesUrl(_market.result, "/trades.do", "/future_trades.do", _params);
var _json_value = await okexapiClient.CallApiGet1Async(_end_point.endPoint, _end_point.args);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = okexapiClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = okexapiClient.DeserializeObject <List <OCompleteOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.orderType = OrderType.Limit;
_o.fillType = FillType.Fill;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 Task <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async($"/trade_history/{_market.result.symbol}/", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <CCompleteOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _t in _orders)
{
_t.orderType = OrderType.Limit;
_t.fillType = FillType.Fill;
_t.amount = _t.quantity * _t.price;
_result.result.Add(_t);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public async Task FetchOrders()
{
try
{
OrderDetails.Clear();
RequestedOrders.Clear();
CancelOrders.Clear();
CompleteOrders.Clear();
ProductList.Clear();
CustomerOrders orders = await this.orderDataService.GetOrderedItemsAsync();
if (orders != null)
{
foreach (var item in orders.Data.CustomerInvoiceData)
{
OrderDetails.Add(item);
if (!string.IsNullOrEmpty(item.OrderStatus))
{
if (item.OrderStatus.ToLower() == "inprogress")
{
RequestedOrders.Add(item);
}
else if (item.OrderStatus.ToLower() == "rejected")
{
CancelOrders.Add(item);
}
else if (item.OrderStatus.ToLower() == "delivered")
{
CompleteOrders.Add(item);
}
}
}
foreach (var item in orders.Data.InvocieLineItems)
{
ProductList.Add(item);
}
}
}
catch (Exception e)
{
await App.Current.MainPage.DisplayAlert("msg", "Unable to load order list", "ok");
}
finally
{
IsBusy = false;
}
}
/// <summary>
/// Fetch array of recent trades data
/// </summary>
/// <param name="symbol">The type of trading base-currency of which information you want to query for.</param>
/// <param name="limits">maximum number of items (optional): default 25</param>
/// <returns></returns>
public async ValueTask <CompleteOrders> GetCompleteOrders(string symbol, int limits = 25)
{
var _result = new CompleteOrders();
var _params = new Dictionary <string, object>();
{
var _limits = limits <= 1 ? 1
: limits <= 500 ? limits
: 500;
_params.Add("symbol", symbol);
_params.Add("count", _limits);
_params.Add("reverse", true);
}
var _response = await publicClient.CallApiGet2Async("/api/v1/trade", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _orders = publicClient.DeserializeObject <List <BCompleteOrderItem> >(_response.Content);
foreach (var _o in _orders)
{
_o.orderType = OrderType.Limit;
_o.fillType = FillType.Fill;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
_result.SetSuccess();
}
else
{
var _message = publicClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </summary>
/// <param name="symbol">The type of trading base-currency of which information you want to query for.</param>
/// <param name="limits">maximum number of items (optional): default 25</param>
/// <returns></returns>
public async ValueTask <CompleteOrders> GetCompleteOrders(string symbol, int limits = 100)
{
var _result = new CompleteOrders();
var _params = new Dictionary <string, object>();
{
_params.Add("instrument_name", symbol);
_params.Add("count", limits);
_params.Add("include_old", "true");
_params.Add("sorting", "desc");
}
var _response = await publicClient.CallApiGet2Async("/api/v2/public/get_last_trades_by_instrument", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _orders = publicClient.DeserializeObject <DRResults <DCompleteOrders> >(_response.Content);
foreach (var _o in _orders.result.trades)
{
_o.orderType = OrderType.Limit;
_o.fillType = FillType.Fill;
_o.makerType = MakerType.Taker;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
_result.SetSuccess();
}
else
{
var _message = publicClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
// Update is called once per frame
void Update()
{
failed = GameMaster.Instance.OrderManager.CountFailed;
current = GameMaster.Instance.OrderManager.CountOpen;
complete = GameMaster.Instance.OrderManager.CountCompleted;
customersat.SetText((GameMaster.Instance.Player.Business.CustomerTolerance_Total * 100).ToString("f0") + "%");
markUp.SetText((GameMaster.Instance.Player.Business.MarkupPercentage_Total * 100).ToString() + "%");
amount.SetText(" $" + GameMaster.Instance.DebtAmounts [GameMaster.Instance.WeekCurrent].ToString());
date.SetText(GameMaster.Instance.DebtDates[GameMaster.Instance.WeekCurrent].ToShortDateString());
company.SetText((GameMaster.Instance.Player.Business.Name).ToString());
money.SetText("$ " + (GameMaster.Instance.Player.Business.Money).ToString());
time.SetText(GameMaster.Instance.GameTimeString12());
failedOrders.SetText(failed.ToString());
CompleteOrders.SetText(complete.ToString());
currentOrders.SetText(current.ToString());
}
/// <summary>
/// Fetch array of recent trades data
/// </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 Task <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
if (since > 0)
{
_params.Add("startTime", since);
_params.Add("endTime", since + 3600 * 1000); // More than 1 hours between startTime and endTime
}
if (limits > 0)
{
_params.Add("limit", limits);
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/aggTrades", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <BCompleteOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.fillType = FillType.Fill;
_o.orderType = OrderType.Limit;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 Task <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
var _limit = limits <= 1 ? 1
: limits <= 1000 ? limits
: 1000;
_params.Add("sort", "-1"); // if = -1 it sorts results returned with old < new
_params.Add("limit", _limit);
if (since > 0)
{
_params.Add("start", since); // timestamp false [time] Only show trades at or after this timestamp
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _section = "hist"; // Section(string) REQUIRED Available values: "last", "hist"
var _json_value = await publicClient.CallApiGet1Async($"/v2/trades/t{_market.result.symbol.ToUpper()}/{_section}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <JArray> >(_json_value.Content);
{
var _orders = new List <BCompleteOrderItem>();
foreach (var _o in _json_data)
{
var _transactionId = _o[0].Value <string>();
var _timevalue = _o[1].Value <long>();
var _quantity = _o[2].Value <decimal>();
var _price = _o[3].Value <decimal>();
var _sideValue = (_quantity < 0) ? "sell" : "buy";
if (_quantity < 0)
{
_quantity = -_quantity;
}
_orders.Add(new BCompleteOrderItem()
{
transactionId = _transactionId,
timestamp = _timevalue,
fillType = FillType.Fill,
sideType = SideTypeConverter.FromString(_sideValue),
orderType = OrderType.Limit,
quantity = _quantity,
price = _price,
amount = _quantity * _price
});
}
_result.result.AddRange(
_orders
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits)
);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 <CompleteOrders> FetchCompleteOrdersAsync(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("command", "returnTradeHistory");
_params.Add("currencyPair", _market.result.symbol);
if (since > 0)
{
since /= 1000;
var _till_time = CUnixTime.Now;
var _from_time = _till_time - (30 * 24 * 60 * 60);
if (_from_time < since)
{
_from_time = since;
}
_params.Add("start", _from_time);
_params.Add("end", _till_time);
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <PCompleteOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.orderType = OrderType.Limit;
_o.fillType = FillType.Fill;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("market", _market.result.symbol);
_params.Add("count", limits);
publicClient.MergeParamsAndArgs(_params, args);
}
var _url = "";
if (limits <= 80)
{
_url = "/1/trade";
}
else
{
_url = "/1/tradeHistory";
}
var _json_value = await publicClient.CallApiGet1Async($"{_url}/{_market.result.symbol}", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <GCompleteOrders>(_json_value.Content);
{
var _orders = _json_data.result
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.fillType = FillType.Fill;
//_o.orderType = OrderType.Limit;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
if (since > 0)
{
since /= 1000;
var _till_time = CUnixTime.Now;
var _from_time = _till_time - (7 * 24 * 60 * 60 - 60 * 10);
if (_from_time < since)
{
_from_time = since;
}
_params.Add("since", _from_time); // Optional. Only return trades after this timestamp. See Data Types: Timestamps for more information. If not present, will show the most recent trades. For backwards compatibility, you may also use the alias 'since'.
}
_params.Add("limit_trades", limits); // Optional. The maximum number of trades to return. The default is 50.
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async($"/v1/trades/{_market.result.symbol}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <GCompleteOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.orderType = OrderType.Limit;
_o.fillType = FillType.Fill;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limit = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
var _limit = limit <= 1 ? 1
: limit <= 100 ? limit
: 100;
//_params.Add("cont_no", 0); // 체결 번호
_params.Add("count", _limit);
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async($"/transaction_history/{_market.result.symbol}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <BCompleteOrders>(_json_value.Content);
if (_json_data.success == true)
{
var _orders = _json_data.result
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limit);
foreach (var _o in _orders)
{
_o.fillType = FillType.Fill;
_o.orderType = OrderType.Limit;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
else
{
var _message = publicClient.GetErrorMessage(_json_data.statusCode);
_json_result.SetFailure(
_message,
ErrorCode.ResponseDataError
);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 <CompleteOrders> FetchCompleteOrdersAsync(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("pair", _market.result.symbol);
if (since > 0)
{
_params.Add("since", since * 1000000);
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/0/public/Trades", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <JObject>(_json_value.Content);
{
var _json_orders = JArray.FromObject((_json_data["result"] as JObject)[_market.result.symbol]);
var _orders = new List <KCompleteOrderItem>();
foreach (var _o in _json_orders)
{
var _sideValue = _o[3].Value <string>();
var _orderValue = _o[4].Value <string>();
var _timeValue = (long)(_o[2].Value <decimal>() * 1000m);
var _price = _o[0].Value <decimal>();
var _quantity = _o[1].Value <decimal>();
_orders.Add(new KCompleteOrderItem
{
transactionId = (_timeValue * 1000).ToString(),
timestamp = _timeValue,
sideType = SideTypeConverter.FromString(_sideValue),
orderType = OrderTypeConverter.FromString(_orderValue),
price = _price,
quantity = _quantity,
amount = _quantity * _price
});
}
_result.result.AddRange(
_orders
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits)
);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch array of recent trades data
/// </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 Task <CompleteOrders> FetchCompleteOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
var _limit = limits <= 1 ? 1
: limits <= 500 ? limits
: 500;
_params.Add("symbol", _market.result.symbol);
_params.Add("count", limits);
_params.Add("reverse", true);
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 publicClient.CallApiGet1Async("/api/v1/trade", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <BCompleteOrderItem> >(_json_value.Content);
{
var _orders = _json_data
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits);
foreach (var _o in _orders)
{
_o.orderType = OrderType.Limit;
_o.fillType = FillType.Fill;
_o.amount = _o.quantity * _o.price;
_result.result.Add(_o);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public async Task FetchOrders()
{
if (CrossConnectivity.Current.IsConnected)
{
try
{
OrderDetails.Clear();
RequestedOrders.Clear();
CancelOrders.Clear();
CompleteOrders.Clear();
ProductList.Clear();
CustomerOrders orders = await this.orderDataService.GetOrderedItemsAsync();
if (orders != null)
{
foreach (var item in orders.Data.CustomerInvoiceData)
{
OrderDetails.Add(item);
if (!string.IsNullOrEmpty(item.OrderStatus))
{
if (item.OrderStatus.ToLower().Replace(" ", "") == "ontheway" || item.OrderStatus.ToLower().Replace(" ", "") == "packed" ||
item.OrderStatus.ToLower().Replace(" ", "") == "inprogress" || item.OrderStatus.ToLower().Replace(" ", "") == "accepted")
{
RequestedOrders.Add(item);
}
else if (item.OrderStatus.ToLower() == "cancelled" || item.OrderStatus.ToLower() == "rejected")
{
CancelOrders.Add(item);
}
else if (item.OrderStatus.ToLower() == "delivered")
{
CompleteOrders.Add(item);
}
}
}
foreach (var item in orders.Data.InvocieLineItems)
{
ProductList.Add(item);
}
}
}
catch (Exception e)
{
try
{
DependencyService.Get <IToastMessage>().LongTime("Unable to load order list");
}
catch { }
}
finally
{
IsBusy = false;
}
}
else
{
try
{
DependencyService.Get <IToastMessage>().LongTime("Check your Internet Connection to reload the list");
}
catch { }
IsBusy = false;
}
}
