/// <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); }