public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
var api = ApiProviderPrivate.GetApi(context);
var body = CreatePostBody();
body.Add("method", ApiMethodsConfig[ApiMethodNamesTiLiWe.TradeHistory]);
if (context.HasMarket)
{
body.Add("pair", context.Market.ToTicker(this).ToLower());
}
var r = await api.GetOrderHistoryAsync(body).ConfigureAwait(false);
CheckResponse(r);
var orders = new List <TradeOrderStatus>();
if (r.return_ != null)
{
foreach (var order in r.return_)
{
orders.Add(ParseTradeOrderStatus(order.Key, order.Value));
}
}
return(new TradeOrdersResponse(orders));
}
public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
if (!context.HasMarket)
{
throw new MarketNotSpecifiedException(this);
}
var ticker = context.Market.ToTicker(this);
var api = ApiProvider.GetApi(context);
var rRaw = await api.GetAllOrdersAsync(ticker).ConfigureAwait(false);
CheckResponseErrors(rRaw);
var rOrders = rRaw.GetContent();
var orders = new List <TradeOrderStatus>();
foreach (var rOrder in rOrders.Where(x => !x.status.Equals("NEW") && !x.status.Equals("PARTIALLY_FILLED")))
{
var isBuy = rOrder.side.Equals("BUY", StringComparison.OrdinalIgnoreCase);
orders.Add(new TradeOrderStatus(Network, rOrder.orderId.ToString(), isBuy, false, false)
{
AmountInitial = rOrder.origQty,
Rate = rOrder.price,
AmountRemaining = rOrder.origQty - rOrder.executedQty,
Market = context.Market
});
}
return(new TradeOrdersResponse(orders)
{
ApiHitsCount = 5 // From API docs: Weight = 5.
});
}
/// <summary>
/// Gets the history of trade orders.
/// Limited to last 3 days and 1 request per minute. Affects rate limiter only for this endpoint.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
var api = ApiProvider.GetApi(context);
var body = new BitfinexSchema.OrdersHistoryRequest.Descriptor();
var rRaw = await api.GetOrdersHistoryAsync(body).ConfigureAwait(false);
CheckBitfinexResponseErrors(rRaw);
var r = rRaw.GetContent();
var orders = new List <TradeOrderStatus>();
foreach (var rOrder in r)
{
var isBuy = rOrder.side.Equals("buy", StringComparison.OrdinalIgnoreCase);
orders.Add(new TradeOrderStatus(Network, rOrder.id.ToString(), isBuy, false, rOrder.is_cancelled)
{
Rate = rOrder.type.Equals("exchange limit", StringComparison.OrdinalIgnoreCase) ? rOrder.price : rOrder.avg_execution_price,
Market = rOrder.symbol.ToAssetPair(this, 3),
AmountInitial = rOrder.original_amount,
AmountRemaining = rOrder.remaining_amount
});
}
return(new TradeOrdersResponse(orders));
}
public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = context.HasMarket
? await api.GetOrdersHistoryAsync(context.Market.ToTicker(this).ToUpper()).ConfigureAwait(false)
: await api.GetOrdersHistoryAsync().ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
var orders = new List <TradeOrderStatus>();
foreach (var rOrder in r)
{
var order = ParseOrderResponse(rOrder);
if (context.HasMarket)
{
order.Market = context.Market;
}
orders.Add(order);
}
return(new TradeOrdersResponse(orders));
}
public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
var historyOrders = (await GetOrdersHistory((NetworkProviderPrivateContext)context).ConfigureAwait(false)).ToList();
var openOrders = (await GetOpenOrders(context).ConfigureAwait(false)).ToList();
return(new TradeOrdersResponse(historyOrders.Concat(openOrders))
{
ApiHitsCount = 2
});
}
public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = await api.GetOrderHistory().ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
var orders =
GetTradeOrderStatusFromResponse(r.result.Select(x => x as BittrexSchema.OrderCommonBase)
.ToList());
return(new TradeOrdersResponse(orders));
}
private void GetOrdersHistoryTest(IOrderLimitProvider provider, AssetPair market = null)
{
var context = new TradeOrdersContext(UserContext.Testing)
{
Market = market
};
OutputWriter.WriteLine("Orders history: \n");
var orders = AsyncContext.Run(() => provider.GetOrdersHistory(context)).Orders.ToArray();
if (orders.Length == 0)
{
OutputWriter.WriteLine("No trade orders returned");
}
else
{
orders.ForEach(DisplayOrderStatusInfo);
}
}
public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
var rAllOrders = await GetBuysAndSellsAsync(context).ConfigureAwait(false);
var orders = rAllOrders.Result.Where(x => !x.status.Equals("created", StringComparison.OrdinalIgnoreCase)).Select(x =>
{
var isBuy = x.resource.Equals("buy", StringComparison.OrdinalIgnoreCase);
var isCanceled = x.status.Equals("canceled", StringComparison.OrdinalIgnoreCase);
return(new TradeOrderStatus(Network, x.id, isBuy, false, isCanceled)
{
AmountInitial = x.amount.amount,
Market = new AssetPair(x.amount.currency, x.total.currency, this),
Rate = x.subtotal.amount / x.amount.amount
});
});
return(new TradeOrdersResponse(orders)
{
ApiHitsCount = rAllOrders.ApiHitsCount
});
}
public Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
throw new NotImplementedException();
}
public async Task <TradeOrdersResponse> GetOrdersHistory(TradeOrdersContext context)
{
var orders = await GetOrdersAsync(context, false).ConfigureAwait(false);
return(new TradeOrdersResponse(orders));
}
