/// <summary> /// Share data to LinkedIn. /// </summary> /// <typeparam name="T">Schema of data to share.</typeparam> /// <typeparam name="U">Type of response object.</typeparam> /// <param name="dataToShare">Share request content.</param> /// <returns>Boolean indicating success or failure.</returns> public async Task <U> ShareDataAsync <T, U>(T dataToShare) { var shareRequest = dataToShare as LinkedInShareRequest; if (shareRequest != null) { LinkedInVisibility.ParseVisibilityStringToEnum(shareRequest.Visibility.Code); var requestParser = new LinkedInParser <LinkedInShareRequest>(); var url = $"{_baseUrl}/people/~/shares?oauth2_access_token={Tokens.AccessToken}&format=json"; using (HttpHelperRequest request = new HttpHelperRequest(new Uri(url), HttpMethod.Post)) { request.Headers["x-li-format"] = "json"; var stringContent = requestParser.Parse(shareRequest); request.Content = new HttpStringContent(stringContent, Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json"); using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { var data = await response.GetTextResultAsync().ConfigureAwait(false); var responseParser = new LinkedInParser <U>(); var listResults = responseParser.Parse(data) as List <U>; return(listResults[0]); } } } return(default(U)); }
protected override async void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); Shell.Current.DisplayWaitRing = true; try { using (var request = new HttpHelperRequest(new Uri("https://raw.githubusercontent.com/Microsoft/UWPCommunityToolkit/dev/githubresources/content/analytics.md"))) { using (var response = await HttpHelper.Instance.SendRequestAsync(request)) { if (response.Success) { MarkdownTextBlockTextblock.Text = await response.Content.ReadAsStringAsync(); } } } } catch (Exception exception) { MarkdownTextBlockTextblock.Text = "Unable to download content: " + exception.Message; TrackingManager.TrackException(exception); } Shell.Current.DisplayWaitRing = false; }
/// <summary> /// Gets a token for the specified subscription. /// </summary> /// <returns>The encoded JWT token prefixed with the string "Bearer ".</returns> /// <remarks> /// This method uses a cache to limit the number of request to the token service. /// A fresh token can be re-used during its lifetime of 10 minutes. After a successful /// request to the token service, this method caches the access token. Subsequent /// invocations of the method return the cached token for the next 5 minutes. After /// 5 minutes, a new token is fetched from the token service and the cache is updated. /// </remarks> public async Task <string> GetAccessTokenAsync() { if (string.IsNullOrEmpty(SubscriptionKey)) { throw new ArgumentNullException(nameof(SubscriptionKey), "A subscription key is required"); } // Re-use the cached token if there is one. if ((DateTime.Now - _storedTokenTime) < TokenCacheDuration && !string.IsNullOrWhiteSpace(_storedTokenValue)) { return(_storedTokenValue); } using (var request = new HttpHelperRequest(ServiceUrl, HttpMethod.Post)) { request.Headers.Add(OcpApimSubscriptionKeyHeader, SubscriptionKey); var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false); var token = await response.GetTextResultAsync().ConfigureAwait(false); _storedTokenTime = DateTime.Now; _storedTokenValue = $"Bearer {token}"; return(_storedTokenValue); } }
/// <summary> /// Gets a token for the specified subscription. /// </summary> /// <returns>The encoded JWT token prefixed with the string "Bearer ".</returns> /// <remarks> /// This method uses a cache to limit the number of request to the token service. /// A fresh token can be re-used during its lifetime of 10 minutes. After a successful /// request to the token service, this method caches the access token. Subsequent /// invocations of the method return the cached token for the next 8 minutes. After /// 8 minutes, a new token is fetched from the token service and the cache is updated. /// </remarks> public async Task <string> GetAccessTokenAsync() { if (string.IsNullOrEmpty(_subscriptionKey)) { throw new ArgumentNullException(nameof(SubscriptionKey), "A subscription key is required. Go to Azure Portal and sign up for Microsoft Translator: https://portal.azure.com/#create/Microsoft.CognitiveServices/apitype/TextTranslation"); } // Re-use the cached token if there is one. if ((DateTime.Now - _storedTokenTime) < TokenCacheDuration && !string.IsNullOrWhiteSpace(_storedTokenValue)) { return(_storedTokenValue); } using (var request = new HttpHelperRequest(ServiceUrl, HttpMethod.Post)) { request.Headers.Add(OcpApimSubscriptionKeyHeader, SubscriptionKey); var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false); var content = await response.GetTextResultAsync().ConfigureAwait(false); if (!response.Success) { var error = JsonConvert.DeserializeObject <ErrorResponse>(content); throw new TranslatorServiceException(error.Message); } _storedTokenTime = DateTime.Now; _storedTokenValue = $"Bearer {content}"; return(_storedTokenValue); } }
/// <summary> /// HTTP Get request for stream service. /// </summary> /// <param name="requestUri">Uri to make OAuth request.</param> /// <param name="tokens">Tokens to pass in request.</param> /// <param name="callback">Function invoked when stream available.</param> /// <returns>awaitable task</returns> public async Task ExecuteGetStreamAsync(Uri requestUri, TwitterOAuthTokens tokens, TwitterStreamCallbacks.RawJsonCallback callback) { using (var request = new HttpHelperRequest(requestUri, HttpMethod.Get)) { var requestBuilder = new TwitterOAuthRequestBuilder(requestUri, tokens); request.Headers.Authorization = HttpCredentialsHeaderValue.Parse(requestBuilder.AuthorizationHeader); using (var response = await HttpHelper.Instance.GetInputStreamAsync(request).ConfigureAwait(false)) { var responseStream = await response.GetStreamResultAsync().ConfigureAwait(false); using (var reader = new StreamReader(responseStream.AsStreamForRead())) { while (!_abort && !reader.EndOfStream) { var result = reader.ReadLine(); if (!string.IsNullOrEmpty(result)) { callback?.Invoke(result); } } } } } }
private HttpHelperRequest CreateHttpRequest(string uriString, HttpMethod method) { var request = new HttpHelperRequest(new Uri(uriString), method); request.Headers.Add(AuthorizationUri, _authorizationHeaderValue); return(request); }
/// <summary> /// Logout the user /// </summary> /// <returns>Success or failure</returns> internal async Task <bool> LogoutAsync() { using (var request = new HttpHelperRequest(new Uri(LogoutUrl), HttpMethod.Get)) { using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { return(response.Success); } } }
/// <summary> /// Extract and initialize access tokens. /// 第三次网络请求,获取oauth_token即最终的access_tokens,并保存于本地 /// </summary> /// <param name="webAuthResultResponseData">WAB data containing appropriate tokens.</param> /// <returns>Success or failure.</returns> private async Task <bool> ExchangeRequestTokenForAccessTokenAsync(string webAuthResultResponseData) { string responseData = webAuthResultResponseData.Substring(webAuthResultResponseData.IndexOf("oauth_token")); string requestToken = ExtractTokenFromResponse(responseData, TwitterOAuthTokenType.OAuthRequestOrAccessToken); // Ensure requestToken matches accessToken per Twitter documentation. if (requestToken != _tokens.RequestToken) { return(false); } string oAuthVerifier = ExtractTokenFromResponse(responseData, TwitterOAuthTokenType.OAuthVerifier); string twitterUrl = $"{OAuthBaseUrl}/access_token"; string timeStamp = GetTimeStamp(); string nonce = GetNonce(); string sigBaseStringParams = GetSignatureBaseStringParams2(_tokens.ConsumerKey, nonce, timeStamp, "oauth_token=" + requestToken); string sigBaseString = "POST&"; sigBaseString += Uri.EscapeDataString(twitterUrl) + "&" + Uri.EscapeDataString(sigBaseStringParams); // 第二次签名 string signature = GetSignature(sigBaseString, _tokens.ConsumerSecret); string data = null; string authorizationHeaderParams = "oauth_consumer_key=\"" + _tokens.ConsumerKey + "\", oauth_nonce=\"" + nonce + "\", oauth_signature_method=\"HMAC-SHA1\", oauth_signature=\"" + Uri.EscapeDataString(signature) + "\", oauth_timestamp=\"" + timeStamp + "\", oauth_token=\"" + Uri.EscapeDataString(requestToken) + "\", oauth_verifier=\"" + Uri.EscapeUriString(oAuthVerifier) + "\" , oauth_version=\"1.0\""; using (var request = new HttpHelperRequest(new Uri(twitterUrl), Windows.Web.Http.HttpMethod.Post)) { request.Headers.Authorization = new Windows.Web.Http.Headers.HttpCredentialsHeaderValue("OAuth", authorizationHeaderParams); using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { data = await response.GetTextResultAsync().ConfigureAwait(false); } } var screenName = ExtractTokenFromResponse(data, TwitterOAuthTokenType.ScreenName); var accessToken = ExtractTokenFromResponse(data, TwitterOAuthTokenType.OAuthRequestOrAccessToken); var accessTokenSecret = ExtractTokenFromResponse(data, TwitterOAuthTokenType.OAuthRequestOrAccessTokenSecret); UserScreenName = screenName; _tokens.AccessToken = accessToken; _tokens.AccessTokenSecret = accessTokenSecret; var passwordCredential = new PasswordCredential("TwitterAccessToken", accessToken, accessTokenSecret); ApplicationData.Current.LocalSettings.Values["TwitterScreenName"] = screenName; _vault.Add(passwordCredential); return(true); }
public async Task Test_HttpHelper_SendRequestAsync() { using (var request = new HttpHelperRequest(new Uri("http://dev.windows.com"))) { using (var response = await HttpHelper.Instance.SendRequestAsync(request)) { Assert.IsTrue(response.Success); Assert.IsNotNull(response.Content); } } }
/// <summary> /// Package up token request.封装的token请求。 /// 第一次网络请求,第一次获取oauth_token是未被认证的Request_token。 /// 按照Twitter Api接入要求,实际是按照OAuth1.0A的步骤进行配置请求参数,获取OAuth_token. /// 就是确认设置的输入的CallbackUrl是否与应用设置的CallbackUrl一致,一致则可以获取第一个OAuth_token即OAuth1中的Request_token /// </summary> /// <param name="twitterCallbackUrl">Callback Uri.</param> /// <returns>Success or failure.</returns> private async Task <bool> InitializeRequestAccessTokensAsync(string twitterCallbackUrl) { // 设置url var twitterUrl = $"{OAuthBaseUrl}/request_token"; // 设置参数 string nonce = GetNonce(); string timeStamp = GetTimeStamp(); string sigBaseStringParams = GetSignatureBaseStringParams(_tokens.ConsumerKey, nonce, timeStamp, "oauth_callback=" + Uri.EscapeDataString(twitterCallbackUrl)); // Uri.EscapeDataString(twitterUrl) Converts a string to its escaped representation. string sigBaseString = "GET&" + Uri.EscapeDataString(twitterUrl) + "&" + Uri.EscapeDataString(sigBaseStringParams); // 第一次签名,调用该方法获取签名 string signature = GetSignature(sigBaseString, _tokens.ConsumerSecret); twitterUrl += "?" + sigBaseStringParams + "&oauth_signature=" + Uri.EscapeDataString(signature); string getResponse; // 可以从getResponse中获取OAuth_token using (var request = new HttpHelperRequest(new Uri(twitterUrl), Windows.Web.Http.HttpMethod.Get)) { using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { var data = await response.GetTextResultAsync().ConfigureAwait(false); if (response.Success) { getResponse = data; } else { Debug.WriteLine("HttpHelper call failed trying to retrieve Twitter Request Tokens. Message: {0}", data); return(false); } } } // 获取callbackConfirmed确认的结果 var callbackConfirmed = ExtractTokenFromResponse(getResponse, TwitterOAuthTokenType.OAuthCallbackConfirmed); if (Convert.ToBoolean(callbackConfirmed) != true) { return(false); } // 截取返回结果中的对应数据,并将获取的数据保存到_tokens实例中 _tokens.RequestToken = ExtractTokenFromResponse(getResponse, TwitterOAuthTokenType.OAuthRequestOrAccessToken); _tokens.RequestTokenSecret = ExtractTokenFromResponse(getResponse, TwitterOAuthTokenType.OAuthRequestOrAccessTokenSecret); return(true); }
public async Task Test_HttpHelper_SendRequestAsync() { #pragma warning disable CS0612 // Type or member is obsolete using (var request = new HttpHelperRequest(new Uri("http://dev.windows.com"))) { using (var response = await HttpHelper.Instance.SendRequestAsync(request)) { Assert.IsTrue(response.Success); Assert.IsNotNull(response.Content); } } #pragma warning restore CS0612 // Type or member is obsolete }
/// <summary> /// HTTP Get request to specified Uri. /// </summary> /// <param name="requestUri">Uri to make OAuth request.</param> /// <param name="tokens">Tokens to pass in request.</param> /// <returns>String result.</returns> public async Task <string> ExecuteGetAsync(Uri requestUri, TwitterOAuthTokens tokens) { using (var request = new HttpHelperRequest(requestUri, HttpMethod.Get)) { var requestBuilder = new TwitterOAuthRequestBuilder(requestUri, tokens, "GET"); request.Headers.Authorization = HttpCredentialsHeaderValue.Parse(requestBuilder.AuthorizationHeader); using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { return(ProcessErrors(await response.GetTextResultAsync().ConfigureAwait(false))); } } }
/// <summary> /// Wrapper around REST API for making data request. /// </summary> /// <typeparam name="TSchema">Schema to use</typeparam> /// <param name="config">Query configuration.</param> /// <param name="maxRecords">Upper limit for records returned.</param> /// <param name="parser">IParser implementation for interpreting results.</param> /// <returns>Strongly typed list of results.</returns> protected override async Task <IEnumerable <TSchema> > GetDataAsync <TSchema>(BingSearchConfig config, int maxRecords, IParser <TSchema> parser) { var countryValue = config.Country.GetStringValue(); var languageValue = config.Language.GetStringValue(); var languageParameter = string.IsNullOrEmpty(languageValue) ? string.Empty : $"language:{languageValue}+"; if (string.IsNullOrEmpty(countryValue)) { if (CultureInfo.CurrentCulture.IsNeutralCulture) { countryValue = BingCountry.None.GetStringValue(); } else { countryValue = CultureInfo.CurrentCulture.Name.Split('-')[1].ToLower(); } } var locParameter = $"loc:{countryValue}+"; var queryTypeParameter = string.Empty; switch (config.QueryType) { case BingQueryType.Search: queryTypeParameter = string.Empty; break; case BingQueryType.News: queryTypeParameter = "/news"; break; } var uri = new Uri($"{BaseUrl}{queryTypeParameter}/search?q={locParameter}{languageParameter}{WebUtility.UrlEncode(config.Query)}&format=rss&count={maxRecords}"); using (HttpHelperRequest request = new HttpHelperRequest(uri, HttpMethod.Get)) { using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { var data = await response.GetTextResultAsync().ConfigureAwait(false); if (response.Success && !string.IsNullOrEmpty(data)) { return(parser.Parse(data)); } throw new RequestFailedException(response.StatusCode, data); } } }
public async Task <string> GetDocumentationAsync() { try { using (var request = new HttpHelperRequest(new Uri(DocumentationUrl), HttpMethod.Get)) { using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { if (response.Success) { var result = await response.Content.ReadAsStringAsync(); // Need to do some cleaning // Rework code tags var regex = new Regex("```(xaml|xml|csharp)(?<code>.+?)```", RegexOptions.Singleline); foreach (Match match in regex.Matches(result)) { var code = match.Groups["code"].Value; var lines = code.Split('\n'); var newCode = new StringBuilder(); foreach (var line in lines) { newCode.AppendLine(" " + line); } result = result.Replace(match.Value, newCode.ToString()); } // Images regex = new Regex("## Example Image.+?##", RegexOptions.Singleline); result = regex.Replace(result, "##"); return(result); } } } } catch (Exception ex) { return(ex.Message); } return(string.Empty); }
/// <summary> /// Get the response stream returned by a HTTP get request and save it to a local file. /// </summary> /// <param name="uri">Uri to request.</param> /// <param name="targetFile">StorageFile to save the stream to.</param> /// <returns>True if success.</returns> public static async Task GetHttpStreamToStorageFileAsync( this Uri uri, StorageFile targetFile) { using (var fileStream = await targetFile.OpenAsync(FileAccessMode.ReadWrite).AsTask().ConfigureAwait(false)) { using (var request = new HttpHelperRequest(uri, HttpMethod.Get)) { using (var response = await HttpHelper.HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { if (response.Success) { await response.Content.WriteToStreamAsync(fileStream).AsTask().ConfigureAwait(false); } } } } }
/// <summary> /// Get the response stream returned by a HTTP get request. /// </summary> /// <param name="uri">Uri to request.</param> /// <param name="cancellationToken">instance of <see cref="CancellationToken"/></param> /// <returns>Response stream</returns> public static async Task <IRandomAccessStream> GetHttpStreamAsync(this Uri uri, CancellationToken cancellationToken = default(CancellationToken)) { var outputStream = new InMemoryRandomAccessStream(); using (var request = new HttpHelperRequest(uri, HttpMethod.Get)) { using (var response = await HttpHelper.HttpHelper.Instance.SendRequestAsync(request, cancellationToken).ConfigureAwait(false)) { if (response.Success) { await response.Content.WriteToStreamAsync(outputStream).AsTask().ConfigureAwait(false); outputStream.Seek(0); } } } return(outputStream); }
private async Task <string> GetAccessTokenAsync(LinkedInOAuthTokens tokens, string authorizeCode) { var url = $"{_oAuthBaseUrl}accessToken?grant_type=authorization_code" + "&code=" + authorizeCode + "&redirect_uri=" + Uri.EscapeDataString(tokens.CallbackUri) + "&client_id=" + tokens.ClientId + "&client_secret=" + tokens.ClientSecret; using (var request = new HttpHelperRequest(new Uri(url), HttpMethod.Post)) { using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { var jsonString = await response.GetTextResultAsync().ConfigureAwait(false); var json = JsonObject.Parse(jsonString); return(json.GetNamedString("access_token")); } } }
/// <summary> /// HTTP Post request to specified Uri. /// </summary> /// <param name="requestUri">Uri to make OAuth request.</param> /// <param name="tokens">Tokens to pass in request.</param> /// <param name="boundary">Boundary used to separate data.</param> /// <param name="content">Data to post to server.</param> /// <returns>String result.</returns> public async Task <string> ExecutePostMultipartAsync(Uri requestUri, TwitterOAuthTokens tokens, string boundary, byte[] content) { JToken mediaId = null; try { using (var multipartFormDataContent = new HttpMultipartFormDataContent(boundary)) { using (var byteContent = new HttpBufferContent(content.AsBuffer())) { multipartFormDataContent.Add(byteContent, "media"); using (var request = new HttpHelperRequest(requestUri, HttpMethod.Post)) { var requestBuilder = new TwitterOAuthRequestBuilder(requestUri, tokens, "POST"); request.Headers.Authorization = HttpCredentialsHeaderValue.Parse(requestBuilder.AuthorizationHeader); request.Content = multipartFormDataContent; using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { string jsonResult = await response.GetTextResultAsync().ConfigureAwait(false); JObject jObj = JObject.Parse(jsonResult); mediaId = jObj["media_id_string"]; } } } } } catch (ObjectDisposedException) { // known issue // http://stackoverflow.com/questions/39109060/httpmultipartformdatacontent-dispose-throws-objectdisposedexception } return(mediaId.ToString()); }
/// <summary> /// Wrapper around REST API for making data request. /// </summary> /// <typeparam name="TSchema">Schema to use</typeparam> /// <param name="config">Query configuration.</param> /// <param name="maxRecords">Upper limit for records returned.</param> /// <param name="startRecord">Index of paged results.</param> /// <param name="fields">A comma seperated string of required fields, which will have strongly typed representation in the model passed in.</param> /// <returns>Strongly typed list of results.</returns> public async Task <IEnumerable <TSchema> > GetDataAsync <TSchema>(LinkedInDataConfig config, int maxRecords, int startRecord = 0, string fields = "id") { var parser = new LinkedInParser <TSchema>(); var url = $"{_baseUrl}{config.Query}/~:({fields})?oauth2_access_token={Tokens.AccessToken}&format=json&count={maxRecords}&start={startRecord}"; using (HttpHelperRequest request = new HttpHelperRequest(new Uri(url), HttpMethod.Get)) { request.Headers.Connection.TryParseAdd("Keep-Alive"); using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { var data = await response.GetTextResultAsync().ConfigureAwait(false); if (response.Success && !string.IsNullOrEmpty(data)) { return(parser.Parse(data)); } throw new RequestFailedException(response.StatusCode, data); } } }
/// <summary> /// Wrapper around REST API for making data request. /// </summary> /// <typeparam name="TSchema">Schema to use</typeparam> /// <param name="config">Query configuration.</param> /// <param name="maxRecords">Upper limit for records returned.</param> /// <param name="parser">IParser implementation for interpreting results.</param> /// <returns>Strongly typed list of results.</returns> protected override async Task <IEnumerable <TSchema> > GetDataAsync <TSchema>(FlickrDataConfig config, int pageIndex, int maxRecords, IParser <TSchema> parser) { var queryMethod = string.Empty; var searchText = string.Empty; switch (config.QueryType) { case FlickrQueryType.Recent: queryMethod = "flickr.photos.getRecent"; break; case FlickrQueryType.Search: queryMethod = "flickr.photos.search"; searchText = config.Query; break; default: break; } var uri = new Uri($"{BaseUrl}method={queryMethod}&extras=geo&description&per_page={maxRecords}&page={pageIndex}&text={searchText}&api_key={ApiKey}&format=json&nojsoncallback=1"); using (HttpHelperRequest request = new HttpHelperRequest(uri, HttpMethod.Get)) { using (var response = await HttpHelper.Instance.SendRequestAsync(request).ConfigureAwait(false)) { var data = await response.GetTextResultAsync().ConfigureAwait(false); if (response.Success && !string.IsNullOrEmpty(data)) { return(parser.Parse(data)); } throw new RequestFailedException(response.StatusCode, data); } } }
public async Task <ResponseModel> SendRequest(RequestModel request) { var address = string.Empty; switch (request.Type) { case RequestType.Train: address = _settings.TrainServiceAddress; break; case RequestType.Request: address = _settings.RequestServiceAddress; break; } try { using (var httpRequest = new HttpHelperRequest(new Uri(address), HttpMethod.Post)) { httpRequest.Content = new HttpStringContent(JsonConvert.SerializeObject(request), UnicodeEncoding.Utf8, "application/json"); using (var response = await HttpHelper.Instance.SendRequestAsync(httpRequest)) { return(new ResponseModel { Data = await response.GetTextResultAsync() }); } } } catch (Exception exception) { return(new ResponseModel { Data = exception.Message }); } }