/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/api/order_books", _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 <COrderBook>(_json_value.Content);
{
var _orderbook = new OrderBook {
asks = new List <OrderBookItem>(), bids = new List <OrderBookItem>()
};
foreach (var _ask in _json_data.asks.OrderBy(o => o.price).Take(limits).ToList())
{
_ask.amount = _ask.price * _ask.quantity;
_ask.count = 1;
_orderbook.asks.Add(_ask);
}
foreach (var _bid in _json_data.bids.OrderByDescending(o => o.price).Take(limits).ToList())
{
_bid.amount = _bid.price * _bid.quantity;
_bid.count = 1;
_orderbook.bids.Add(_bid);
}
_result.result = _orderbook;
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
var _limits = limits <= 1 ? 1
: limits <= 50 ? limits
: 50;
_params.Add("count", _limits);
_params.Add("group_orders", 1); // group_orders Int Value : 0 또는 1
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async($"/orderbook/{_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 <BOrderBooks>(_json_value.Content);
if (_json_data.success == true)
{
_result.result.asks = _json_data.result.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _json_data.result.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = _json_data.result.timestamp;
_result.result.nonce = _json_data.result.timestamp / 1000;
}
else
{
var _message = publicClient.GetErrorMessage(_json_data.statusCode);
_json_result.SetFailure(
_message,
ErrorCode.ResponseDataError
);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public Trade[] Execute(Order order)
{
if (!OrderBooks.TryGetValue(order.Instrument, out var orderBook))
{
orderBook = new OrderBook();
OrderBooks[order.Instrument] = orderBook;
}
return(orderBook.Execute(order));
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
_params.Add("currency_pair", _market.result.symbol);
_params.Add("category", "all");
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("/orderbook", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbook = publicClient.DeserializeObject <KOrderBook>(_json_value.Content);
{
_result.result.asks = _orderbook.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = _orderbook.timestamp;
_result.result.nonce = _orderbook.timestamp / 1000;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </summary>
/// <param name="symbol"></param>
/// <param name="count">maximum number of items (optional): default 25</param>
/// <returns></returns>
public async ValueTask <OrderBooks> GetOrderBooks(string symbol, int count = 25)
{
var _result = new OrderBooks();
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", symbol);
_params.Add("depth", count);
}
var _response = await publicClient.CallApiGet2Async("/api/v1/orderBook/L2", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _orderbooks = publicClient.DeserializeObject <List <BOrderBookItem> >(_response.Content);
if (_orderbooks != null)
{
_result.result.asks = new List <OrderBookItem>();
_result.result.bids = new List <OrderBookItem>();
foreach (var _o in _orderbooks)
{
_o.amount = _o.quantity * _o.price;
_o.count = 1;
if (_o.sideType == SideType.Ask)
{
_result.result.asks.Add(_o);
}
else
{
_result.result.bids.Add(_o);
}
}
_result.result.symbol = symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
_result.SetSuccess();
}
}
else
{
var _message = publicClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
var _limits = limits <= 5 ? 5
: limits <= 10 ? 10
: limits <= 20 ? 20
: limits <= 50 ? 50
: limits <= 100 ? 100
: limits <= 500 ? 500
: 1000;
_params.Add("symbol", _market.result.symbol);
_params.Add("limit", _limits);
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/depth", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbook = publicClient.DeserializeObject <BOrderBook>(_json_value.Content);
{
_result.result.asks = _orderbook.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = _orderbook.lastUpdateId;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooksAsync(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
_params.Add("markets", _market.result.symbol);
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/orderbook", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbooks = publicClient.DeserializeObject <List <UOrderBook> >(_json_value.Content);
{
var _orderbook = _orderbooks.FirstOrDefault();
if (_orderbook != null)
{
_orderbook.asks = _orderbook.asks.OrderBy(o => o.price).Take(limits).ToList();
_orderbook.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_orderbook.nonce = _orderbook.timestamp / 1000;
_result.result = _orderbook;
}
else
{
_json_result.SetFailure();
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
if (limits == 1) // 호가창의 상세정보 수준 (1 = 매수호가 및 매도호가, 2 = 매수 및 매도 주문 각 50개, 기타 = 호가창 전체)
{
_params.Add("level", 1);
}
else
{
_params.Add("level", 2);
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async($"/trading-pairs/{_market.result.symbol}/book", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbook = publicClient.DeserializeObject <GOrderBook>(_json_value.Content);
{
_result.result.asks = _orderbook.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limit = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
if (limit == 1)
{
_params.Add("level", 1); // Only the best bid and ask
}
else
{
_params.Add("level", 2); // Top 50 bids and asks (aggregated)
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async($"/products/{_market.result.symbol}/book", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbook = publicClient.DeserializeObject <GOrderBook>(_json_value.Content);
{
_result.result.asks = _orderbook.asks.OrderBy(o => o.price).Take(limit).ToList();
_result.result.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limit).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = _orderbook.sequence;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
_params.Add("market", _market.result.symbol);
_params.Add("type", "both"); // type required buy, sell or both to identify the type of orderbook to return
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/v1.1/public/getorderbook", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbook = publicClient.DeserializeObject <BOrderBooks>(_json_value.Content);
if (_orderbook.success == true)
{
_result.result.asks = _orderbook.result.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _orderbook.result.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
}
else
{
_json_result.SetFailure(_orderbook.message);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooksAsync(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
_params.Add("command", "returnOrderBook");
_params.Add("currencyPair", _market.result.symbol);
if (limits > 0)
{
_params.Add("depth", limits);
}
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 _orderbook = publicClient.DeserializeObject <POrderBook>(_json_value.Content);
{
_result.result.asks = _orderbook.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = _orderbook.seq;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
if (limits > 0)
{
_params.Add("limit_bids", limits);
_params.Add("limit_asks", limits);
}
_params.Add("group", 1); // group false [0/1] 1 If 1, orders are grouped by price in the orderbook. If 0, orders are not grouped and sorted individually
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async($"/v1/book/{_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 _orderbook = publicClient.DeserializeObject <BOrderBook>(_json_value.Content);
{
_result.result.asks = _orderbook.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async($"/1/orderBook/{_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 _orderbooks = publicClient.DeserializeObject <GOrderBook>(_json_value.Content);
{
if (_orderbooks.asks.Count > 0 || _orderbooks.bids.Count > 0)
{
_orderbooks.symbol = _market.result.symbol;
_orderbooks.asks = _orderbooks.asks.OrderBy(o => o.price).Take(limits).ToList();
_orderbooks.bids = _orderbooks.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_orderbooks.timestamp = CUnixTime.NowMilli;
_orderbooks.nonce = _orderbooks.timestamp / 1000;
_result.result = _orderbooks;
}
else
{
_json_result.SetFailure();
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
private void ClearOrderBooks(List <int> pertinentContracts)
{
OrderBooks.Clear();
ImpliedOrderBooks.Clear();
ConsolidatedOrderBooks.Clear();
int contractCount = pertinentContracts.Count;
for (int i = 0; i < contractCount; i++)
{
int instrument = pertinentContracts[i];
AddNewOrderBooksFor(instrument);
}
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
okexapiClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("size", $"{limits}");
okexapiClient.MergeParamsAndArgs(_params, args);
}
var _end_point = okexapiClient.CheckFuturesUrl(_market.result, "/depth.do", "/future_depth.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 _orderbook = okexapiClient.DeserializeObject <OOrderBook>(_json_value.Content);
{
_result.result.asks = _orderbook.asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _orderbook.bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public static List <OrderBooks> getOrderBooks(string token, int customerid)
{
List <OrderBooks> books = new List <OrderBooks>();
try
{
using (MySqlConnection con = new MySqlConnection(connString))
{
if (con.State == ConnectionState.Closed)
{
con.Open();
}
string query = " SELECT o.order_id,b.booksID,b.bookname,b.bookauthor,b.image1, b.rating, b.paperprice,o.quantity,os.added_on FROM orderr o JOIN orders os ON os.order_id = o.order_id JOIN books b ON b.booksID = o.book_id WHERE os.order_token = @order and os.user_id = @user";
MySqlCommand cmd = new MySqlCommand(query, con);
cmd.Parameters.Add(new MySqlParameter("@order", token));
cmd.Parameters.Add(new MySqlParameter("@user", customerid));
using (MySqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
OrderBooks book = new OrderBooks();
book.order_id = int.Parse(reader["order_id"].ToString());
book.booksID = int.Parse(reader["booksID"].ToString());
book.book_name = reader["bookname"].ToString();
book.book_author = reader["bookauthor"].ToString();
book.image = reader["image1"].ToString();
book.rating = double.Parse(reader["rating"].ToString());
book.price = double.Parse(reader["paperprice"].ToString());
book.quantity = int.Parse(reader["quantity"].ToString());
book.added_on = reader["added_on"].ToString();
books.Add(book);
}
}
con.Close();
}
}
catch (MySqlException e)
{
string message = e.Message;
}
return(books);
}
public List <OrderBooks> GetOrderBooks(List <JToken> result)
{
List <OrderBooks> list = new List <OrderBooks>();
OrderBooks or = new OrderBooks();
or.updated_at = result[0].First.ToString();
or.sequence = result[3].First.ToString();
//traemos nuevamente los elementos del asks
string jsonB = result[1].First.ToString();
JArray arr = JArray.Parse(jsonB) as JArray;
dynamic bids = arr;
List <AsksBids> asksBids = new List <AsksBids>();
foreach (dynamic el in arr)
{
AsksBids ab = new AsksBids();
ab.book = el.book;
ab.amount = el.amount;
ab.price = el.price;
ab.oid = null;
asksBids.Add(ab);
}
or.bids = asksBids;
string jsonA = result[1].First.ToString();
JArray arrA = JArray.Parse(result[1].First.ToString());
dynamic asks = arrA;
or.asks = new List <AsksBids>();
foreach (dynamic el in arrA)
{
AsksBids ab = new AsksBids();
ab.book = el.book;
ab.amount = el.amount;
ab.price = el.price;
ab.oid = null;
or.asks.Add(ab);
}
list.Add(or);
return(list);
}
/// <summary>
/// Fetch pending or registered order details
/// </summary>
/// <param name="symbol"></param>
/// <param name="count">maximum number of items (optional): default 25</param>
/// <returns></returns>
public async ValueTask <OrderBooks> GetOrderBooks(string symbol, int count = 25)
{
var _result = new OrderBooks();
var _params = new Dictionary <string, object>();
{
_params.Add("instrument_name", symbol);
_params.Add("depth", count);
}
var _response = await publicClient.CallApiGet2Async("/api/v2/public/get_order_book", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _orderbooks = publicClient.DeserializeObject <DRResults <DOrderBook> >(_response.Content);
if (_orderbooks != null)
{
_result.result.asks = _orderbooks.result.asks;
_result.result.bids = _orderbooks.result.bids;
_result.result.symbol = symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
_result.SetSuccess();
}
}
else
{
var _message = publicClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limit = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async($"{_market.result.symbol}/money/depth/full", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbook = publicClient.DeserializeObject <AOrderBooks>(_json_value.Content);
{
_result.result.asks = _orderbook.result.asks.OrderBy(o => o.price).Take(limit).ToList();
_result.result.bids = _orderbook.result.bids.OrderByDescending(o => o.price).Take(limit).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = _orderbook.result.dataUpdateTime / 1000;
_result.result.nonce = _orderbook.result.now / 1000000;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
private void ReconcileExpiredContracts()
{
for (int i = 0; i < ConsolidatedOrderBooks.Count; i++)
{
bool matchFound = false;
foreach (int pertinentContract in pertinentContracts)
{
if (ConsolidatedOrderBooks[i].InstrumentId == pertinentContract)
{
matchFound = true;
break;
}
}
if (!matchFound)
{
OrderBooks.RemoveAt(i);
ImpliedOrderBooks.RemoveAt(i);
ConsolidatedOrderBooks.RemoveAt(i);
}
}
}
public void CreateOrder(Order order)
{
order.OrderPlacedDate = DateTime.Now;
_appDbContext.Orders.Add(order);
var cartItems = _cart.StoreCartItems;
foreach (var cartItem in cartItems)
{
var orderDetail = new OrderBooks()
{
Quantity = cartItem.Quantity,
BookId = cartItem.Book.BookId,
OrderId = order.OrderId,
Price = cartItem.Book.Price
};
_appDbContext.OrderBooks.Add(orderDetail);
}
_appDbContext.SaveChanges();
}
public IActionResult CheckOut(int id, Customers c)
{
// var cid = (TempData["cid"]).ToString();
//context.Customers.Add(c);
//context.SaveChanges();
Orders ord = new Orders()
{
OrderAmount = Convert.ToSingle(TempData["total"]),
OrderDate = DateTime.Now,
CustomerId = id
};
_context.Orders.Add(ord);
_context.SaveChanges();
// return RedirectToAction("Payment");
//}
//return View(customers);
var cart = SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart");
List <OrderBooks> orderBooks = new List <OrderBooks>();
for (int i = 0; i < cart.Count; i++)
{
OrderBooks orderBook = new OrderBooks()
{
OrderId = ord.OrderId,
BookId = cart[i].Books.BookId,
Quantity = cart[i].Quantity
};
orderBooks.Add(orderBook);
}
orderBooks.ForEach(n => _context.OrderBooks.Add(n));
_context.SaveChanges();
TempData["cust"] = id;
return(RedirectToAction("Invoice", "Cart"));
}
public IActionResult CheckOut(int id, Customers c, string stripeEmail, string stripeToken)
{
// var cid = (TempData["cid"]).ToString();
//context.Customers.Add(c);
//context.SaveChanges();
Orders ord = new Orders()
{
OrderAmount = Convert.ToSingle(TempData["total"]),
OrderDate = DateTime.Now,
CustomerId = id
};
_context.Orders.Add(ord);
_context.SaveChanges();
// return RedirectToAction("Payment");
//}
//return View(customers);
var cart = SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart");
List <OrderBooks> orderBooks = new List <OrderBooks>();
for (int i = 0; i < cart.Count; i++)
{
OrderBooks orderBook = new OrderBooks()
{
OrderId = ord.OrderId,
BookId = cart[i].Books.BookId,
Quantity = cart[i].Quantity
};
orderBooks.Add(orderBook);
}
orderBooks.ForEach(n => _context.OrderBooks.Add(n));
_context.SaveChanges();
TempData["cust"] = id;
//return RedirectToAction("Index", "Payment");
var customers = new CustomerService();
var charges = new ChargeService();
var Amount = TempData["total"];
var order = ord.OrderId;
var custmr = TempData["cust"];
var customer = customers.Create(new CustomerCreateOptions
{
Email = stripeEmail,
SourceToken = stripeToken
});
var charge = charges.Create(new ChargeCreateOptions
{
Amount = 500,
Description = "Total Charge",
Currency = "usd",
CustomerId = customer.Id
});
Payments payment = new Payments();
{
payment.StripePaymentId = charge.PaymentMethodId;
payment.PaymentAmount = Convert.ToInt32(Amount);
payment.DateOfPayment = System.DateTime.Now;
payment.PaymentDescription = "Payment Initiated";
payment.CardLastDigit = Convert.ToInt32(charge.PaymentMethodDetails.Card.Last4);
payment.OrderId = Convert.ToInt32(order);
payment.CustomerId = Convert.ToInt32(custmr);
}
//_context.Add<Payments>(payment);
_context.Payments.Add(payment);
_context.SaveChanges();
return(RedirectToAction("Invoice", "Cart"));
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("size", limits); // type required buy, sell or both to identify the type of orderbook to return
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/api/v1/market/depth", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbooks = publicClient.DeserializeObject <BOrderBooks>(_json_value.Content);
if (_orderbooks.success == true)
{
var _ob_asks = _orderbooks.result.asks.OrderBy(o => o.price).Take(limits).ToList();
var _ob_bids = _orderbooks.result.bids.OrderByDescending(o => o.price).Take(limits).ToList();
var _orderbook = new OrderBook
{
asks = new List <IOrderBookItem>(),
bids = new List <IOrderBookItem>()
};
foreach (var _ask in _ob_asks)
{
_ask.amount = _ask.price * _ask.quantity;
_ask.count = 1;
_orderbook.asks.Add(_ask);
}
foreach (var _bid in _ob_bids)
{
_bid.amount = _bid.price * _bid.quantity;
_bid.count = 1;
_orderbook.bids.Add(_bid);
}
_result.result = _orderbook;
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
}
else
{
_json_result.SetFailure(_orderbooks.message);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Fetch pending or registered order details
/// </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="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 <OrderBooks> FetchOrderBooks(string base_name, string quote_name, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new OrderBooks(base_name, quote_name);
var _market = await this.LoadMarket(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("depth", limits);
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/api/v1/orderBook/L2", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _orderbooks = publicClient.DeserializeObject <List <BOrderBookItem> >(_json_value.Content);
{
var _asks = new List <OrderBookItem>();
var _bids = new List <OrderBookItem>();
foreach (var _o in _orderbooks)
{
_o.amount = _o.quantity * _o.price;
_o.count = 1;
if (_o.side.ToLower() == "sell")
{
_asks.Add(_o);
}
else
{
_bids.Add(_o);
}
}
_result.result.asks = _asks.OrderBy(o => o.price).Take(limits).ToList();
_result.result.bids = _bids.OrderByDescending(o => o.price).Take(limits).ToList();
_result.result.symbol = _market.result.symbol;
_result.result.timestamp = CUnixTime.NowMilli;
_result.result.nonce = CUnixTime.Now;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
private void AddNewOrderBooksFor(int instrumentId)
{
OrderBooks.Add(new OrderBook(OUTRIGHT_DEPTH, instrumentId));
ImpliedOrderBooks.Add(new OrderBook(IMPLIED_DEPTH, instrumentId));
ConsolidatedOrderBooks.Add(new OrderBook(OUTRIGHT_DEPTH, instrumentId));
}
/// <summary>
/// Processes the Spark update event provided in the EventFeedArgs and updates security properties based on the event type
/// </summary>
/// <param name="sender">Event sender</param>
/// <param name="eventFeedArgs">Event feed args</param>
internal void EventReceived(object sender, EventFeedArgs eventFeedArgs)
{
//Process event
Spark.Event eventItem = eventFeedArgs.Event;
switch (eventItem.Type)
{
//Depth update
case Spark.EVENT_NEW_DEPTH:
case Spark.EVENT_AMEND_DEPTH:
case Spark.EVENT_DELETE_DEPTH:
//Check if exchange order book exists and create if it doesn't
LimitOrderBook orderBook;
if (!OrderBooks.TryGetValue(eventFeedArgs.Exchange, out orderBook))
{
orderBook = new LimitOrderBook(eventFeedArgs.Symbol, eventFeedArgs.Exchange);
OrderBooks.Add(eventFeedArgs.Exchange, orderBook);
}
//Submit update to appropriate exchange order book
orderBook.SubmitEvent(eventItem);
if (OnDepthUpdate != null)
{
OnDepthUpdate(this, new GenericEventArgs <LimitOrderBook>(eventFeedArgs.TimeStamp, orderBook));
}
break;
//Trade update
case Spark.EVENT_TRADE:
//Create and store trade record
Trade trade = eventItem.ToTrade(eventFeedArgs.Symbol, eventFeedArgs.Exchange, eventFeedArgs.TimeStamp);
Trades.Add(trade);
if (OnTradeUpdate != null)
{
OnTradeUpdate(this, new GenericEventArgs <Trade>(eventFeedArgs.TimeStamp, trade));
}
break;
//Trade cancel
case Spark.EVENT_CANCEL_TRADE:
//Find original trade in trade record and delete
Trade cancelledTrade = eventItem.ToTrade(eventFeedArgs.TimeStamp);
Trade originalTrade = Trades.Find(x => (x.TimeStamp == cancelledTrade.TimeStamp && x.Price == cancelledTrade.Price && x.Volume == cancelledTrade.Volume));
if (originalTrade != null)
{
Trades.Remove(originalTrade);
}
break;
//Market state update
case Spark.EVENT_STATE_CHANGE:
State = ApiFunctions.ConvertToMarketState(eventItem.State);
if (OnMarketStateUpdate != null)
{
OnMarketStateUpdate(this, new GenericEventArgs <MarketState>(eventFeedArgs.TimeStamp, State));
}
break;
//Market quote update (change to best market bid-ask prices)
case Spark.EVENT_QUOTE:
if (OnQuoteUpdate != null)
{
LimitOrderBook depth = OrderBooks[eventFeedArgs.Exchange];
MarketQuote quote = new MarketQuote(eventFeedArgs.Symbol, eventFeedArgs.Exchange, depth.BidPrice, depth.AskPrice, eventFeedArgs.TimeStamp);
OnQuoteUpdate(this, new GenericEventArgs <MarketQuote>(eventFeedArgs.TimeStamp, quote));
}
break;
//IAP (Indicative Auction Price) Update
case Spark.EVENT_AUCTION_PRICE:
break;
default:
//Console.WriteLine(eventItem.ToOutputString());
break;
}
}
