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