private async Task <IList <IList <T> > > GetAllSubsequentPages <T>(
string uri,
string firstPageAfterCursorId,
int numberOfPages)
{
var pagedList = new List <IList <T> >();
var subsequentPageAfterHeaderId = firstPageAfterCursorId;
var runCount = numberOfPages == 0
? int.MaxValue
: numberOfPages;
while (runCount > 1)
{
var subsequentHttpResponseMessage = await SendHttpRequestMessageAsync(HttpMethod.Get, uri + $"&after={subsequentPageAfterHeaderId}").ConfigureAwait(false);
if (!subsequentHttpResponseMessage.Headers.TryGetValues("cb-after", out var cursorHeaders))
{
break;
}
subsequentPageAfterHeaderId = cursorHeaders.First();
var subsequentContentBody = await httpClient.ReadAsStringAsync(subsequentHttpResponseMessage).ConfigureAwait(false);
var page = JsonConfig.DeserializeObject <IList <T> >(subsequentContentBody);
pagedList.Add(page);
runCount--;
}
return(pagedList);
}
protected async Task <IList <IList <T> > > SendHttpRequestMessagePagedAsync <T>(
HttpMethod httpMethod,
string uri,
string content = null,
int numberOfPages = 0)
{
Log.Debug("REST {HttpMethod} {Uri} {Content} {NumberOfPages}", httpMethod, uri, content, numberOfPages);
var pagedList = new List <IList <T> >();
var httpResponseMessage = await SendHttpRequestMessageAsync(httpMethod, uri, content);
var contentBody = await httpClient.ReadAsStringAsync(httpResponseMessage).ConfigureAwait(false);
var firstPage = JsonConfig.DeserializeObject <IList <T> >(contentBody);
pagedList.Add(firstPage);
if (!httpResponseMessage.Headers.TryGetValues("cb-after", out var firstPageAfterCursorId))
{
return(pagedList);
}
var subsequentPages = await GetAllSubsequentPages <T>(uri, firstPageAfterCursorId.First(), numberOfPages);
pagedList.AddRange(subsequentPages);
return(pagedList);
}
protected async Task <T> SendServiceCall <T>(
HttpMethod httpMethod,
string uri,
string content = null)
{
var httpResponseMessage = await SendHttpRequestMessageAsync(httpMethod, uri, content);
var contentBody = await httpClient.ReadAsStringAsync(httpResponseMessage).ConfigureAwait(false);
return(JsonConfig.DeserializeObject <T>(contentBody));
}
public static bool TryDeserializeObject <T>(this string json, out T result)
{
try
{
result = JsonConfig.DeserializeObject <T>(json);
return(true);
}
catch
{
result = default;
return(false);
}
}
protected async Task <T> SendServiceCall <T>(
HttpMethod httpMethod,
string uri,
string content = null)
{
Log.Debug("REST {HttpMethod} {Uri} {Content}", httpMethod, uri, content);
var httpResponseMessage = await SendHttpRequestMessageAsync(httpMethod, uri, content);
var contentBody = await httpClient.ReadAsStringAsync(httpResponseMessage).ConfigureAwait(false);
if (typeof(T) == typeof(string))
{
return((T)(object)contentBody);
}
return(JsonConfig.DeserializeObject <T>(contentBody));
}
private async Task <HttpResponseMessage> SendHttpRequestMessageAsync(
HttpMethod httpMethod,
string uri,
string content = null)
{
var httpRequestMessage = content == null
? httpRequestMessageService.CreateHttpRequestMessage(httpMethod, uri)
: httpRequestMessageService.CreateHttpRequestMessage(httpMethod, uri, content);
var httpResponseMessage = await httpClient.SendAsync(httpRequestMessage).ConfigureAwait(false);
if (httpResponseMessage.IsSuccessStatusCode)
{
Log.Verbose("@httpResponseMessage", httpResponseMessage);
return(httpResponseMessage);
}
var contentBody = await httpClient.ReadAsStringAsync(httpResponseMessage).ConfigureAwait(false);
string errorMessage;
try
{
var jsonMsg = JsonConfig.DeserializeObject <CoinbaseProErrorMessage>(contentBody);
errorMessage = jsonMsg.Message;
}
catch
{
errorMessage = contentBody;
}
var ex = new CoinbaseProHttpException(errorMessage)
{
StatusCode = httpResponseMessage.StatusCode,
RequestMessage = httpRequestMessage,
ResponseMessage = httpResponseMessage,
EndPoint = new EndPoint(httpMethod, uri, content)
};
Log.Error("REST request about to throw {@CoinbaseProHttpException}", ex);
throw ex;
}
private async Task <HttpResponseMessage> SendHttpRequestMessageAsync(
HttpMethod httpMethod,
string uri,
string content = null)
{
var httpRequestMessage = content == null
? httpRequestMessageService.CreateHttpRequestMessage(httpMethod, uri)
: httpRequestMessageService.CreateHttpRequestMessage(httpMethod, uri, content);
var httpResponseMessage = await httpClient.SendAsync(httpRequestMessage).ConfigureAwait(false);
if (httpResponseMessage.IsSuccessStatusCode)
{
return(httpResponseMessage);
}
var contentBody = await httpClient.ReadAsStringAsync(httpResponseMessage).ConfigureAwait(false);
string errorMessage;
try
{
var jsonMsg = JsonConfig.DeserializeObject <GDAXErrorMessage>(contentBody);
errorMessage = jsonMsg.Message;
}
catch
{
errorMessage = contentBody;
}
throw new GDAXSharpHttpException(errorMessage)
{
StatusCode = httpResponseMessage.StatusCode,
RequestMessage = httpRequestMessage,
ResponseMessage = httpResponseMessage,
EndPoint = new EndPoint(httpMethod, uri, content)
};
}
public void WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (stopWebSocket)
{
return;
}
var json = e.Message;
if (!json.TryDeserializeObject <BaseMessage>(out var response))
{
Log.Error("Could not deserialize response because the type doesn't exist {@ResponseJson}.", json);
}
switch (response?.Type)
{
case ResponseType.Subscriptions:
var subscription = JsonConfig.DeserializeObject <Subscription>(json);
if (subscription.Channels == null || !subscription.Channels.Any())
{
Subscribe();
}
else
{
webSocketFeed.Invoke(OnSubscriptionReceived, sender, new WebfeedEventArgs <Subscription>(subscription));
}
break;
case ResponseType.Ticker:
var ticker = JsonConfig.DeserializeObject <Ticker>(json);
webSocketFeed.Invoke(OnTickerReceived, sender, new WebfeedEventArgs <Ticker>(ticker));
break;
case ResponseType.Snapshot:
var snapshot = JsonConfig.DeserializeObject <Snapshot>(json);
webSocketFeed.Invoke(OnSnapShotReceived, sender, new WebfeedEventArgs <Snapshot>(snapshot));
break;
case ResponseType.L2Update:
var level2 = JsonConfig.DeserializeObject <Level2>(json);
webSocketFeed.Invoke(OnLevel2UpdateReceived, sender, new WebfeedEventArgs <Level2>(level2));
break;
case ResponseType.Heartbeat:
var heartbeat = JsonConfig.DeserializeObject <Heartbeat>(json);
webSocketFeed.Invoke(OnHeartbeatReceived, sender, new WebfeedEventArgs <Heartbeat>(heartbeat));
break;
case ResponseType.Received:
var received = JsonConfig.DeserializeObject <Received>(json);
webSocketFeed.Invoke(OnReceivedReceived, sender, new WebfeedEventArgs <Received>(received));
break;
case ResponseType.Open:
var open = JsonConfig.DeserializeObject <Open>(json);
webSocketFeed.Invoke(OnOpenReceived, sender, new WebfeedEventArgs <Open>(open));
break;
case ResponseType.Done:
var done = JsonConfig.DeserializeObject <Done>(json);
webSocketFeed.Invoke(OnDoneReceived, sender, new WebfeedEventArgs <Done>(done));
break;
case ResponseType.Match:
var match = JsonConfig.DeserializeObject <Match>(json);
webSocketFeed.Invoke(OnMatchReceived, sender, new WebfeedEventArgs <Match>(match));
break;
case ResponseType.LastMatch:
var lastMatch = JsonConfig.DeserializeObject <LastMatch>(json);
webSocketFeed.Invoke(OnLastMatchReceived, sender, new WebfeedEventArgs <LastMatch>(lastMatch));
break;
case ResponseType.Error:
var error = JsonConfig.DeserializeObject <Error>(json);
webSocketFeed.Invoke(OnErrorReceived, sender, new WebfeedEventArgs <Error>(error));
break;
case ResponseType.Change:
var change = JsonConfig.DeserializeObject <Change>(json);
webSocketFeed.Invoke(OnChangeReceived, sender, new WebfeedEventArgs <Change>(change));
break;
case ResponseType.Activate:
var activate = JsonConfig.DeserializeObject <Activate>(json);
webSocketFeed.Invoke(OnActivateReceived, sender, new WebfeedEventArgs <Activate>(activate));
break;
default:
Log.Error("Unknown ResponseType {@ResponseJson}. Ignoring message received.", json);
break;
}
}
public void WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (stopWebSocket)
{
webSocketFeed.Close();
return;
}
var json = e.Message;
var response = JsonConfig.DeserializeObject <BaseMessage>(json);
switch (response.Type)
{
case ResponseType.Subscriptions:
var subscription = JsonConfig.DeserializeObject <Subscription>(json);
webSocketFeed.Invoke(OnSubscriptionReceived, sender, new WebfeedEventArgs <Subscription>(subscription));
break;
case ResponseType.Ticker:
var ticker = JsonConfig.DeserializeObject <Ticker>(json);
webSocketFeed.Invoke(OnTickerReceived, sender, new WebfeedEventArgs <Ticker>(ticker));
break;
case ResponseType.Snapshot:
var snapshot = JsonConfig.DeserializeObject <Snapshot>(json);
webSocketFeed.Invoke(OnSnapShotReceived, sender, new WebfeedEventArgs <Snapshot>(snapshot));
break;
case ResponseType.L2Update:
var level2 = JsonConfig.DeserializeObject <Level2>(json);
webSocketFeed.Invoke(OnLevel2UpdateReceived, sender, new WebfeedEventArgs <Level2>(level2));
break;
case ResponseType.Heartbeat:
var heartbeat = JsonConfig.DeserializeObject <Heartbeat>(json);
webSocketFeed.Invoke(OnHeartbeatReceived, sender, new WebfeedEventArgs <Heartbeat>(heartbeat));
break;
case ResponseType.Received:
var received = JsonConfig.DeserializeObject <Received>(json);
webSocketFeed.Invoke(OnReceivedReceived, sender, new WebfeedEventArgs <Received>(received));
break;
case ResponseType.Open:
var open = JsonConfig.DeserializeObject <Open>(json);
webSocketFeed.Invoke(OnOpenReceived, sender, new WebfeedEventArgs <Open>(open));
break;
case ResponseType.Done:
var done = JsonConfig.DeserializeObject <Done>(json);
webSocketFeed.Invoke(OnDoneReceived, sender, new WebfeedEventArgs <Done>(done));
break;
case ResponseType.Match:
var match = JsonConfig.DeserializeObject <Match>(json);
webSocketFeed.Invoke(OnMatchReceived, sender, new WebfeedEventArgs <Match>(match));
break;
case ResponseType.LastMatch:
var lastMatch = JsonConfig.DeserializeObject <LastMatch>(json);
webSocketFeed.Invoke(OnLastMatchReceived, sender, new WebfeedEventArgs <LastMatch>(lastMatch));
break;
case ResponseType.Error:
var error = JsonConfig.DeserializeObject <Error>(json);
webSocketFeed.Invoke(OnErrorReceived, sender, new WebfeedEventArgs <Error>(error));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
