/// <summary>
/// Requests data from uri, with error handling specific to the Eve Online API.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="uri"></param>
/// <returns></returns>
public async Task <T> RequestAsync <T>(Uri uri)
{
string data = null;
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.CacheOnly)
{
data = await Cache.LoadAsync(uri).ConfigureAwait(false);
}
var cached = data != null;
if (cached)
{
return(Serializer.Deserialize <T>(data));
}
if (CacheLevel == CacheLevel.CacheOnly)
{
return(default(T));
}
try {
var response = await HttpRequestHelper.GetResponseAsync(HttpRequestHelper.CreateRequest(uri)).ConfigureAwait(false);
// special handling for status code 000, because we cannot fetch the response body
if (response.StatusCode.ToString() == "0")
{
throw new EveXmlException("Kill log exhausted (You can only fetch kills that are less than a month old)", 119, new WebException("Unknown", null, WebExceptionStatus.UnknownError, response));
}
data = await HttpRequestHelper.GetResponseContentAsync(response);
}
catch (WebException e) {
_trace.TraceEvent(TraceEventType.Error, 0, "Http Request failed");
var response = (HttpWebResponse)e.Response;
if (response == null)
{
throw new EveXmlException("Unknown", 0, e);
}
var responseStream = response.GetResponseStream();
if (responseStream == null)
{
throw;
}
using (var reader = new StreamReader(responseStream)) {
data = reader.ReadToEnd();
var error = Serializer.Deserialize <EveXmlError>(data);
_trace.TraceEvent(TraceEventType.Verbose, 0, "Error: {0}, Code: {1}", error.Error.ErrorText,
error.Error.ErrorCode);
throw new EveXmlException(error.Error.ErrorText, error.Error.ErrorCode, e);
}
}
var xml = Serializer.Deserialize <T>(data);
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.Refresh)
{
await Cache.StoreAsync(uri, getCacheExpirationTime(xml), data).ConfigureAwait(false);
}
return(xml);
}
/// <summary>
/// head as an asynchronous operation.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="accessToken">The access token.</param>
/// <returns>Task.</returns>
public async Task <WebHeaderCollection> HeadAsync(Uri uri, string accessToken)
{
var request = HttpRequestHelper.CreateRequest(uri);
request.Method = WebRequestMethods.Http.Head;
var response = await requestAsync(request, accessToken).ConfigureAwait(false);
return(response.Headers);
//var content = await HttpRequestHelper.GetResponseContentAsync(response).ConfigureAwait(false);
//var result = Serializer.Deserialize<CrestOptions>(content);
}
/// <summary>
/// delete as an asynchronous operation.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="accessToken">The access token.</param>
/// <returns>Task<System.Boolean>.</returns>
public async Task <bool> DeleteAsync(Uri uri, string accessToken)
{
var request = HttpRequestHelper.CreateRequest(uri);
request.Method = "DELETE";
request.ContentType = "application/json";
var response = await requestAsync(request, accessToken);
var retval = response.StatusCode == HttpStatusCode.OK;
return(retval);
}
/// <summary>
/// Verifies the access token
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <returns>Task<VerifyResponse>.</returns>
public async Task <VerifyResponse> VerifyAsync(string accessToken)
{
HttpWebRequest request = HttpRequestHelper.CreateRequest(new Uri(BaseUri + "/oauth/verify"));
request.Host = "login.eveonline.com";
request.Headers.Add("Authorization", "Bearer " + accessToken);
request.Method = "GET";
string response = await requestAsync(request).ConfigureAwait(false);
var result = JsonConvert.DeserializeObject <VerifyResponse>(response);
return(result);
}
/// <summary>
/// put as an asynchronous operation.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="accessToken">The access token.</param>
/// <param name="postData">The post data.</param>
/// <returns>Task<System.Boolean>.</returns>
public async Task <bool> PutAsync(Uri uri, string accessToken, string postData)
{
var request = HttpRequestHelper.CreateRequest(uri);
request.Method = WebRequestMethods.Http.Put;
request.ContentType = "application/json";
request.Headers.Add(HttpRequestHeader.Authorization, TokenType + " " + accessToken);
HttpRequestHelper.AddPostData(request, postData);
var response = await requestAsync(request, accessToken);
var retval = response.StatusCode == HttpStatusCode.OK;
return(retval);
}
/// <summary>
/// Refreshes the specified encoded key.
/// </summary>
/// <param name="encodedKey">The encoded key.</param>
/// <param name="refreshToken">The refresh token.</param>
/// <returns>Task<AuthResponse>.</returns>
public async Task <AuthResponse> RefreshAsync(string encodedKey, string refreshToken)
{
HttpWebRequest request = HttpRequestHelper.CreateRequest(new Uri(BaseUri + "/oauth/token"));
request.Host = "login.eveonline.com";
request.Headers.Add("Authorization", "Basic " + encodedKey);
request.Method = "POST";
HttpRequestHelper.AddPostData(request, "grant_type=refresh_token&refresh_token=" + refreshToken);
string response = await requestAsync(request).ConfigureAwait(false);
var result = JsonConvert.DeserializeObject <AuthResponse>(response);
return(result);
}
/// <summary>
/// Authenticates the specified encoded key.
/// </summary>
/// <param name="encodedKey">The encoded key.</param>
/// <param name="authCode">The authentication code.</param>
/// <returns>Task<AuthResponse>.</returns>
public async Task <AuthResponse> AuthenticateAsync(string encodedKey, string authCode)
{
HttpWebRequest request = HttpRequestHelper.CreateRequest(new Uri(Protocol + Host + "/oauth/token"));
request.Host = Host;
request.Headers.Add("Authorization", "Basic " + encodedKey);
request.Method = "POST";
HttpRequestHelper.AddPostData(request, "grant_type=authorization_code&code=" + authCode);
string response = await requestAsync(request).ConfigureAwait(false);
var result = JsonConvert.DeserializeObject <AuthResponse>(response);
return(result);
}
/// <summary>
/// options as an asynchronous operation.
/// </summary>
/// <param name="uri">The URI.</param>
/// <returns>Task<CrestOptions>.</returns>
public async Task <CrestOptions> OptionsAsync(Uri uri)
{
var request = HttpRequestHelper.CreateRequest(uri);
request.Method = "OPTIONS";
var response = await requestAsync(request, null).ConfigureAwait(false);
var content = await HttpRequestHelper.GetResponseContentAsync(response).ConfigureAwait(false);
var result = Serializer.Deserialize <CrestOptions>(content);
result.ResponseHeaders = response.Headers;
result.Uri = uri;
return(result);
}
/// <summary>
/// Request as an asynchronous operation.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="uri">The URI.</param>
/// <returns>Task<T>.</returns>
public async Task <T> RequestAsync <T>(Uri uri)
{
_trace.TraceEvent(TraceEventType.Start, 0, "ZkbRequestHandler.RequestAsync(): {0}", uri);
string data = null;
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.CacheOnly)
{
data = await Cache.LoadAsync(uri).ConfigureAwait(false);
}
bool isCached = data != null;
if (isCached)
{
return(Serializer.Deserialize <T>(data));
}
if (CacheLevel == CacheLevel.CacheOnly)
{
return(default(T));
}
DateTime cacheTime;
int requestCount, maxRequests;
HttpWebRequest request = HttpRequestHelper.CreateRequest(uri);
using (
HttpWebResponse response = await HttpRequestHelper.GetResponseAsync(request).ConfigureAwait(false)) {
data = await HttpRequestHelper.GetResponseContentAsync(response).ConfigureAwait(false);
cacheTime = DateTime.Parse(response.GetResponseHeader("Expires"));
int.TryParse(response.GetResponseHeader("X-Bin-Request-Count"), out requestCount);
int.TryParse(response.GetResponseHeader("X-Bin-Max-Requests"), out maxRequests);
}
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.Refresh)
{
await Cache.StoreAsync(uri, cacheTime.ToUniversalTime(), data).ConfigureAwait(false);
}
_trace.TraceEvent(TraceEventType.Stop, 0, "ZkbRequestHandler.RequestAsync()", uri);
var result = Serializer.Deserialize <T>(data);
var zkbResponse = result as ZkbResponse;
if (zkbResponse != null)
{
zkbResponse.RequestCount = requestCount;
zkbResponse.MaxRequests = maxRequests;
}
return(result);
}
/// <summary>
/// get as an asynchronous operation.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="uri">The URI.</param>
/// <param name="accessToken">The access token.</param>
/// <returns>Task<T>.</returns>
public async Task <T> GetAsync <T>(Uri uri, string accessToken)
where T : class, ICrestResource <T>
{
string responseContent = null;
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.CacheOnly)
{
responseContent = await Cache.LoadAsync(uri).ConfigureAwait(false);
}
var cached = responseContent != null;
T result;
if (cached)
{
result = Serializer.Deserialize <T>(responseContent);
result.IsFromCache = true;
return(result);
}
if (CacheLevel == CacheLevel.CacheOnly)
{
return(default(T));
}
// set up request
var request = HttpRequestHelper.CreateRequest(uri);
request.Accept = ContentTypes.Get <T>(ThrowOnMissingContentType) + ";";
request.CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.Default);
request.Method = WebRequestMethods.Http.Get;
_trace.TraceEvent(TraceEventType.Error, 0, "Initiating Request: " + uri);
var response = await requestAsync(request, accessToken).ConfigureAwait(false);
// handle response
var header = response.Headers;
responseContent = await HttpRequestHelper.GetResponseContentAsync(response).ConfigureAwait(false);
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.Refresh)
{
await Cache.StoreAsync(uri, getCacheExpirationTime(header), responseContent).ConfigureAwait(false);
}
result = Serializer.Deserialize <T>(responseContent);
result.ResponseHeaders = header;
result.Uri = uri;
return(result);
}
/// <summary>
/// Performs a request to the specified URI and returns an EveApiResponse of specified type.
/// </summary>
/// <typeparam name="T">The type parameter for the xml response.</typeparam>
/// <param name="uri">The URI to request.</param>
/// <returns></returns>
public override T Request <T>(Uri uri)
{
DateTime cachedUntil;
bool fromCache = CacheExpirationRegister.TryGetValue(uri, out cachedUntil) && DateTime.UtcNow < cachedUntil;
string data = "";
HttpWebRequest request = HttpRequestHelper.CreateRequest(uri);
request.ContentType = ContentType;
request.CachePolicy = fromCache
? new HttpRequestCachePolicy(HttpRequestCacheLevel.CacheIfAvailable)
: new HttpRequestCachePolicy(HttpRequestCacheLevel.Reload);
request.Proxy = null;
try {
data = HttpRequestHelper.GetContent(request);
}
catch (WebException e) {
var response = (HttpWebResponse)e.Response;
Debug.WriteLine("From cache: " + response.IsFromCache);
if (response.StatusCode != HttpStatusCode.BadRequest)
{
throw new InvalidRequestException("Request caused a WebException.", e);
}
Stream responseStream = response.GetResponseStream();
if (responseStream == null)
{
throw new InvalidRequestException("Request caused a WebException.", e);
}
using (var reader = new StreamReader(responseStream)) {
data = reader.ReadToEnd();
var error = Serializer.Deserialize <EveApiError>(data);
throw new InvalidRequestException(error.Error.ErrorCode, error.Error.ErrorText, e);
}
}
var xml = Serializer.Deserialize <T>(data);
register(uri, xml);
SaveCacheState();
return(xml);
}
/// <summary>
/// Performs a request, and returns the response content.
/// </summary>
/// <typeparam name="T">Response type</typeparam>
/// <param name="uri">URI to request</param>
/// <param name="accessToken">CREST acces token</param>
/// <returns>T.</returns>
/// <exception cref="DeprecatedResourceException">The CREST resource is deprecated.</exception>
/// <exception cref="EveCrestException">
/// Undefined error
/// or
/// or
/// </exception>
public async Task <T> RequestAsync <T>(Uri uri, string accessToken) where T : class, ICrestResource <T>
{
string data = null;
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.CacheOnly)
{
data = await Cache.LoadAsync(uri).ConfigureAwait(false);
}
bool cached = data != null;
if (cached)
{
return(Serializer.Deserialize <T>(data));
}
if (CacheLevel == CacheLevel.CacheOnly)
{
return(default(T));
}
// set up request
CrestMode mode = (accessToken == null) ? CrestMode.Public : CrestMode.Authenticated;
HttpWebRequest request = HttpRequestHelper.CreateRequest(uri);
request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
request.Accept = ContentTypes.Get <T>(ThrowOnMissingContentType) + ";";
request.CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.Default);
if (!String.IsNullOrEmpty(Charset))
{
request.Accept = request.Accept + " " + Charset;
}
if (!String.IsNullOrEmpty(XRequestedWith))
{
request.Headers.Add("X-Requested-With", XRequestedWith);
}
if (!String.IsNullOrEmpty(UserAgent))
{
request.UserAgent = UserAgent;
}
if (mode == CrestMode.Authenticated)
{
request.Headers.Add(HttpRequestHeader.Authorization, TokenType + " " + accessToken);
_authedPool.WaitOne();
}
else
{
_publicPool.WaitOne();
}
_trace.TraceEvent(TraceEventType.Error, 0, "Initiating Request: " + uri);
WebHeaderCollection header;
try {
HttpWebResponse response = await HttpRequestHelper.GetResponseAsync(request).ConfigureAwait(false);
header = response.Headers;
string deprecated = response.GetResponseHeader("X-Deprecated");
if (!String.IsNullOrEmpty(deprecated))
{
_trace.TraceEvent(TraceEventType.Warning, 0,
"This CREST resource is deprecated. Please update to the newest EveLib version or notify the developers.");
if (ThrowOnDeprecated)
{
throw new DeprecatedResourceException("The CREST resource is deprecated.", response);
}
}
data = await HttpRequestHelper.GetResponseContentAsync(response).ConfigureAwait(false);
// release semaphores
if (mode == CrestMode.Authenticated)
{
_authedPool.Release();
}
else
{
_publicPool.Release();
}
}
catch (WebException e) {
// release semaphores
if (mode == CrestMode.Authenticated)
{
_authedPool.Release();
}
else
{
_publicPool.Release();
}
_trace.TraceEvent(TraceEventType.Error, 0, "CREST Request Failed.");
var response = (HttpWebResponse)e.Response;
Stream responseStream = response.GetResponseStream();
if (responseStream == null)
{
throw new EveCrestException("Undefined error", e);
}
using (var reader = new StreamReader(responseStream)) {
data = reader.ReadToEnd();
if (response.StatusCode == HttpStatusCode.InternalServerError ||
response.StatusCode == HttpStatusCode.BadGateway)
{
throw new EveCrestException(data, e);
}
var error = Serializer.Deserialize <CrestError>(data);
_trace.TraceEvent(TraceEventType.Verbose, 0, "Message: {0}, Key: {1}",
"Exception Type: {2}, Ref ID: {3}", error.Message, error.Key, error.ExceptionType,
error.RefId);
throw new EveCrestException(error.Message, e, error.Key, error.ExceptionType, error.RefId);
}
}
if (CacheLevel == CacheLevel.Default || CacheLevel == CacheLevel.Refresh)
{
await Cache.StoreAsync(uri, getCacheExpirationTime(header), data).ConfigureAwait(false);
}
var result = Serializer.Deserialize <T>(data);
result.ResponseHeaders = header;
return(result);
}