private async Task <string> GetLatestSourceCodeVersionAsync(string name, string type)
{
using (var client = new CliHttpClient())
{
var response = await client.PostAsync(
$"{CliUrls.WwwAbpIo}api/download/{type}/get-version/",
new StringContent(
JsonSerializer.Serialize(
new GetLatestSourceCodeVersionDto {
Name = name
}
),
Encoding.UTF8,
MimeTypes.Application.Json
),
CancellationTokenProvider.Token
);
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response);
var result = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <GetLatestSourceCodeVersionResultDto>(result).Version);
}
}
private async Task <bool> CheckProLicenseAsync()
{
if (!AuthService.IsLoggedIn())
{
return(false);
}
try
{
var url = $"{CliUrls.WwwAbpIo}api/license/check-user";
using (var client = new CliHttpClient())
{
using (var response = await client.GetHttpResponseMessageWithRetryAsync(url, CancellationTokenProvider.Token, Logger))
{
if (!response.IsSuccessStatusCode)
{
throw new Exception($"ERROR: Remote server returns '{response.StatusCode}'");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response);
var responseContent = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <bool>(responseContent));
}
}
}
catch (Exception)
{
return(false);
}
}
public async Task <MyGetApiResponse> GetPackages()
{
if (_response != null)
{
return(_response);
}
try
{
using (var client = new CliHttpClient(TimeSpan.FromMinutes(10)))
{
var responseMessage = await client.GetAsync(
$"{CliUrls.WwwAbpIo}api/myget/packages/"
);
_response = JsonConvert.DeserializeObject <MyGetApiResponse>(Encoding.Default.GetString(await responseMessage.Content.ReadAsByteArrayAsync()));
}
}
catch (Exception)
{
Logger.LogError("Unable to get latest preview version.");
throw;
}
return(_response);
}
private async Task <byte[]> DownloadSourceCodeContentAsync(SourceCodeDownloadInputDto input)
{
var postData = JsonSerializer.Serialize(input);
using (var client = new CliHttpClient(TimeSpan.FromMinutes(10)))
{
HttpResponseMessage responseMessage;
if (input.TemplateSource.IsNullOrWhiteSpace())
{
responseMessage = await client.PostAsync(
$"{CliUrls.WwwAbpIo}api/download/{input.Type}/",
new StringContent(postData, Encoding.UTF8, MimeTypes.Application.Json),
CancellationTokenProvider.Token
);
}
else
{
responseMessage = await client.GetAsync(input.TemplateSource, CancellationTokenProvider.Token);
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(responseMessage);
return(await responseMessage.Content.ReadAsByteArrayAsync());
}
}
public async Task <SemanticVersion> GetLatestVersionOrNullAsync(string packageId, bool includePreviews = false, bool includeNightly = false)
{
using (var client = new CliHttpClient())
{
var url = includeNightly ?
$"https://www.myget.org/F/abp-nightly/api/v3/flatcontainer/{packageId.ToLowerInvariant()}/index.json" :
$"https://api.nuget.org/v3-flatcontainer/{packageId.ToLowerInvariant()}/index.json";
var responseMessage = await client.GetAsync(url, CancellationTokenProvider.Token);
if (!responseMessage.IsSuccessStatusCode)
{
throw new Exception("Remote server returns error! HTTP status code: " + responseMessage.StatusCode);
}
var result = await responseMessage.Content.ReadAsStringAsync();
var versions = JsonSerializer.Deserialize <NuGetVersionResultDto>(result).Versions.Select(x => SemanticVersion.Parse(x));
if (!includePreviews && !includeNightly)
{
versions = versions.Where(x => !x.IsPrerelease);
}
return(versions.Any() ? versions.Max() : null);
}
}
protected virtual async Task <ModuleWithMastersInfo> GetModuleInfoAsync(string moduleName, bool newTemplate,
bool newProTemplate = false)
{
if (newTemplate || newProTemplate)
{
return(await GetEmptyModuleProjectInfoAsync(moduleName, newProTemplate));
}
using (var client = new CliHttpClient())
{
var url = $"{CliUrls.WwwAbpIo}api/app/module/byNameWithDetails/?name=" + moduleName;
var response = await client.GetAsync(url);
if (!response.IsSuccessStatusCode)
{
if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new CliUsageException($"ERROR: '{moduleName}' module could not be found!");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response);
}
var responseContent = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <ModuleWithMastersInfo>(responseContent));
}
}
private async Task <List <string> > GetProPackageListAsync()
{
using var client = new CliHttpClient();
var url = $"{CliUrls.WwwRocketIo}api/app/nugetPackage/proPackageNames";
var responseMessage = await client.GetHttpResponseMessageWithRetryAsync(
url : url,
cancellationToken : CancellationTokenProvider.Token,
logger : Logger
);
if (responseMessage.IsSuccessStatusCode)
{
return(JsonSerializer.Deserialize <List <string> > (await responseMessage.Content.ReadAsStringAsync()));
}
var exceptionMessage = "Remote server returns '" + (int)responseMessage.StatusCode + "-" + responseMessage.ReasonPhrase + "'. ";
var remoteServiceErrorMessage = await RemoteServiceExceptionHandler.GetRocketRemoteServiceErrorAsync(responseMessage);
if (remoteServiceErrorMessage != null)
{
exceptionMessage += remoteServiceErrorMessage;
}
Logger.LogError(exceptionMessage);
return(null);
}
public async Task CollectAsync(CliAnalyticsCollectInputDto input)
{
var postData = _jsonSerializer.Serialize(input);
using (var client = new CliHttpClient())
{
var responseMessage = await client.PostAsync(
$"{CliUrls.WwwAbpIo}api/clianalytics/collect",
new StringContent(postData, Encoding.UTF8, MimeTypes.Application.Json),
_cancellationTokenProvider.Token
).ConfigureAwait(false);
if (!responseMessage.IsSuccessStatusCode)
{
var exceptionMessage = "Remote server returns '" + (int)responseMessage.StatusCode + "-" + responseMessage.ReasonPhrase + "'. ";
var remoteServiceErrorMessage = await _remoteServiceExceptionHandler.GetAbpRemoteServiceErrorAsync(responseMessage).ConfigureAwait(false);
if (remoteServiceErrorMessage != null)
{
exceptionMessage += remoteServiceErrorMessage;
}
_logger.LogInformation(exceptionMessage);
}
}
}
private async Task <string> GetTemplateNugetVersionAsync(string name, string type, string version)
{
var url = $"{CliUrls.WwwAbpIo}api/download/{type}/get-nuget-version/";
try
{
using (var client = new CliHttpClient(TimeSpan.FromMinutes(10)))
{
var response = await client.PostAsync(
url,
new StringContent(
JsonSerializer.Serialize(
new GetTemplateNugetVersionDto {
Name = name, Version = version
}
),
Encoding.UTF8,
MimeTypes.Application.Json
),
CancellationTokenProvider.Token
);
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response);
var result = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <GetVersionResultDto>(result).Version);
}
}
catch (Exception ex)
{
Console.WriteLine("Error occured while getting the NuGet version from {0} : {1}", url, ex.Message);
return(null);
}
}
private async Task <byte[]> DownloadSourceCodeContentAsync(SourceCodeDownloadInputDto input)
{
var url = $"{CliUrls.WwwAbpIo}api/download/{input.Type}/";
try
{
using (var client = new CliHttpClient(TimeSpan.FromMinutes(10)))
{
HttpResponseMessage responseMessage;
if (input.TemplateSource.IsNullOrWhiteSpace())
{
responseMessage = await client.PostAsync(
url,
new StringContent(JsonSerializer.Serialize(input), Encoding.UTF8, MimeTypes.Application.Json),
CancellationTokenProvider.Token
);
}
else
{
responseMessage = await client.GetAsync(input.TemplateSource, CancellationTokenProvider.Token);
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(responseMessage);
return(await responseMessage.Content.ReadAsByteArrayAsync());
}
}
catch (Exception ex)
{
Console.WriteLine("Error occured while downloading source-code from {0} : {1}", url, ex.Message);
throw;
}
}
private async Task <bool> CheckMultipleOrganizationsAsync(string username)
{
var url = $"{CliUrls.WwwAbpIo}api/license/check-multiple-organizations?username={username}";
using (var client = new CliHttpClient())
{
var response = await client.GetHttpResponseMessageWithRetryAsync(
url,
CancellationTokenProvider.Token,
Logger);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"ERROR: Remote server returns '{response.StatusCode}'");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response);
var responseContent = await response.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize <bool>(responseContent);
return(result);
}
}
public async Task <SemanticVersion> GetLatestVersionOrNullAsync(string packageId, bool includePreviews = false, bool includeNightly = false)
{
List <string> proPackageList = null;
if (AuthService.IsLoggedIn())
{
proPackageList = await GetProPackageListAsync();
}
string url;
if (includeNightly)
{
url =
$"https://www.myget.org/F/abp-nightly/api/v3/flatcontainer/{packageId.ToLowerInvariant()}/index.json";
}
else if (proPackageList?.Contains(packageId) ?? false)
{
url = await GetNuGetUrlForCommercialPackage(packageId);
}
else
{
url = $"https://api.nuget.org/v3-flatcontainer/{packageId.ToLowerInvariant()}/index.json";
}
using (var client = new CliHttpClient(setBearerToken: false))
{
var responseMessage = await GetHttpResponseMessageWithRetryAsync(client, url);
if (!responseMessage.IsSuccessStatusCode)
{
throw new Exception($"ERROR: Remote server returns '{responseMessage.StatusCode}'");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(responseMessage);
var responseContent = await responseMessage.Content.ReadAsStringAsync();
var versions = JsonSerializer
.Deserialize <NuGetVersionResultDto>(responseContent)
.Versions
.Select(SemanticVersion.Parse);
if (!includePreviews && !includeNightly)
{
versions = versions.Where(x => !x.IsPrerelease);
}
var semanticVersions = versions.ToList();
return(semanticVersions.Any() ? semanticVersions.Max() : null);
}
}
public async Task <SemanticVersion> GetLatestVersionOrNullAsync(string packageId, bool includeNightly = false, bool includeReleaseCandidates = false)
{
if (AuthService.IsLoggedIn())
{
if (_proPackageList == null)
{
_proPackageList = await GetProPackageListAsync();
}
}
string url;
if (includeNightly)
{
url = $"https://www.myget.org/F/abp-nightly/api/v3/flatcontainer/{packageId.ToLowerInvariant()}/index.json";
}
else if (_proPackageList?.Contains(packageId) ?? false)
{
url = await GetNuGetUrlForCommercialPackage(packageId);
}
else
{
url = $"https://api.nuget.org/v3-flatcontainer/{packageId.ToLowerInvariant()}/index.json";
}
using (var client = new CliHttpClient(setBearerToken: false))
{
var responseMessage = await client.GetHttpResponseMessageWithRetryAsync(
url,
cancellationToken : CancellationTokenProvider.Token,
logger : Logger
);
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(responseMessage);
var responseContent = await responseMessage.Content.ReadAsStringAsync();
var versions = JsonSerializer
.Deserialize <NuGetVersionResultDto>(responseContent)
.Versions
.Select(SemanticVersion.Parse)
.OrderByDescending(v => v, new VersionComparer()).ToList();
if (!includeNightly && !includeReleaseCandidates)
{
versions = versions.Where(x => !x.IsPrerelease).ToList();
}
var semanticVersions = versions.ToList();
return(semanticVersions.Any() ? semanticVersions.Max() : null);
}
}
private async Task <List <ModuleInfo> > GetModuleListAsync()
{
using (var client = new CliHttpClient())
{
var responseMessage = await client.GetAsync(
$"{CliUrls.WwwAbpIo}api/download/modules/",
CancellationTokenProvider.Token
).ConfigureAwait(false);
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(responseMessage).ConfigureAwait(false);
var result = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
return(JsonSerializer.Deserialize <List <ModuleInfo> >(result));
}
}
public async Task <DeveloperApiKeyResult> GetApiKeyOrNullAsync()
{
using (var client = new CliHttpClient())
{
var url = $"{CliUrls.WwwAbpIo}api/license/api-key";
var response = await client.GetAsync(url);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"ERROR: Remote server returns '{response.StatusCode}'");
}
var responseContent = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <DeveloperApiKeyResult>(responseContent));
}
}
public async Task <string> GetApiKeyAsync()
{
try
{
using (var client = new CliHttpClient(TimeSpan.FromMinutes(1)))
{
var responseMessage = await client.GetAsync(
$"{CliUrls.WwwAbpIo}api/myget/apikey/"
);
return(Encoding.Default.GetString(await responseMessage.Content.ReadAsByteArrayAsync()));
}
}
catch (Exception)
{
return("");
}
}
public async Task CollectAsync(CliAnalyticsCollectInputDto input)
{
var postData = _jsonSerializer.Serialize(input);
using (var client = new CliHttpClient())
{
var responseMessage = await client.PostAsync(
$"{CliUrls.WwwAbpIo}api/clianalytics/collect",
new StringContent(postData, Encoding.UTF8, MimeTypes.Application.Json),
_cancellationTokenProvider.Token
);
if (!responseMessage.IsSuccessStatusCode)
{
_logger.LogInformation("Remote server returns error! HTTP status code: " +
responseMessage.StatusCode);
}
}
}
public async Task <string> GetApiKeyAsync()
{
try
{
using (var client = new CliHttpClient(TimeSpan.FromMinutes(1)))
{
var response = await client.GetHttpResponseMessageWithRetryAsync(
url : $"{CliUrls.WwwAbpIo}api/myget/apikey/",
cancellationToken : CancellationTokenProvider.Token,
logger : Logger
);
return(Encoding.Default.GetString(await response.Content.ReadAsByteArrayAsync()));
}
}
catch (Exception)
{
return("");
}
}
private async Task <byte[]> DownloadTemplateFileContentAsync(TemplateDownloadInputDto input)
{
var postData = JsonSerializer.Serialize(input);
using (var client = new CliHttpClient())
{
var responseMessage = await client.PostAsync(
$"{CliUrls.WwwAbpIo}api/download/template/",
new StringContent(postData, Encoding.UTF8, MimeTypes.Application.Json),
CancellationTokenProvider.Token
);
if (!responseMessage.IsSuccessStatusCode)
{
throw new Exception("Remote server returns error! HTTP status code: " + responseMessage.StatusCode);
}
return(await responseMessage.Content.ReadAsByteArrayAsync());
}
}
public async Task <DeveloperApiKeyResult> GetApiKeyOrNullAsync(bool invalidateCache = false)
{
if (!AuthService.IsLoggedIn())
{
return(null);
}
if (invalidateCache)
{
_apiKeyResult = null;
}
if (_apiKeyResult != null)
{
return(_apiKeyResult);
}
var url = $"{CliUrls.WwwAbpIo}api/license/api-key";
using (var client = new CliHttpClient())
{
var response = await client.GetHttpResponseMessageWithRetryAsync(
url : url,
cancellationToken : CancellationTokenProvider.Token,
logger : _logger);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"ERROR: Remote server returns '{response.StatusCode}'");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response);
var responseContent = await response.Content.ReadAsStringAsync();
var apiKeyResult = JsonSerializer.Deserialize <DeveloperApiKeyResult>(responseContent);
return(apiKeyResult);
}
}
public async Task <List <string> > GetPackageVersionListAsync(string packageId, bool includeNightly = false,
bool includeReleaseCandidates = false)
{
if (AuthService.IsLoggedIn())
{
_proPackageList ??= await GetProPackageListAsync();
}
string url;
if (includeNightly)
{
url = $"https://www.myget.org/F/abp-nightly/api/v3/flatcontainer/{packageId.ToLowerInvariant()}/index.json";
}
else if (_proPackageList?.Contains(packageId) ?? false)
{
url = await GetNuGetUrlForCommercialPackage(packageId);
}
else
{
url = $"https://api.nuget.org/v3-flatcontainer/{packageId.ToLowerInvariant()}/index.json";
}
using (var client = new CliHttpClient(setBearerToken: false))
{
using (var responseMessage = await client.GetHttpResponseMessageWithRetryAsync(
url,
cancellationToken: CancellationTokenProvider.Token,
logger: Logger
))
{
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(responseMessage);
var responseContent = await responseMessage.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <NuGetVersionResultDto>(responseContent).Versions);
}
}
}
protected virtual async Task <ModuleInfo> FindModuleInfoAsync(string moduleName)
{
using (var client = new CliHttpClient())
{
var url = $"{CliUrls.WwwAbpIo}api/app/module/byName/?name=" + moduleName;
var response = await client.GetAsync(url).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new CliUsageException($"ERROR: '{moduleName}' module could not be found!");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response).ConfigureAwait(false);
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
return(JsonSerializer.Deserialize <ModuleInfo>(responseContent));
}
}
protected virtual async Task <NugetPackageInfo> FindNugetPackageInfoAsync(string packageName)
{
using (var client = new CliHttpClient())
{
var url = $"{CliUrls.WwwAbpIo}api/app/nugetPackage/byName/?name=" + packageName;
var response = await client.GetAsync(url);
if (!response.IsSuccessStatusCode)
{
if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new CliUsageException($"'{packageName}' nuget package could not be found!");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response);
}
var responseContent = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <NugetPackageInfo>(responseContent));
}
}
private async Task <string> GetLatestTemplateVersionAsync(string name)
{
var postData = JsonSerializer.Serialize(new GetLatestTemplateVersionDto {
Name = name
});
using (var client = new CliHttpClient())
{
var responseMessage = await client.PostAsync(
$"{CliUrls.WwwAbpIo}api/download/template/get-version/",
new StringContent(postData, Encoding.UTF8, MimeTypes.Application.Json),
CancellationTokenProvider.Token
);
if (!responseMessage.IsSuccessStatusCode)
{
throw new Exception("Remote server returns error! HTTP status code: " + responseMessage.StatusCode);
}
var result = await responseMessage.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <GetLatestTemplateVersionResultDto>(result).Version);
}
}
private async Task <List <string> > GetProPackageListAsync()
{
using var client = new CliHttpClient();
var responseMessage = await client.GetAsync(
$"{CliUrls.WwwAbpIo}api/app/nugetPackage/proPackageNames",
CancellationTokenProvider.Token
);
if (!responseMessage.IsSuccessStatusCode)
{
var exceptionMessage = "Remote server returns '" + (int)responseMessage.StatusCode + "-" + responseMessage.ReasonPhrase + "'. ";
var remoteServiceErrorMessage = await RemoteServiceExceptionHandler.GetAbpRemoteServiceErrorAsync(responseMessage);
if (remoteServiceErrorMessage != null)
{
exceptionMessage += remoteServiceErrorMessage;
}
Logger.LogInformation(exceptionMessage);
return(null);
}
return(JsonSerializer.Deserialize <List <string> >(await responseMessage.Content.ReadAsStringAsync()));
}
public async Task <DeveloperApiKeyResult> GetApiKeyOrNullAsync(bool invalidateCache = false)
{
if (invalidateCache)
{
_apiKeyResult = null;
}
if (_apiKeyResult != null)
{
return(_apiKeyResult);
}
var url = $"{CliUrls.WwwAbpIo}api/license/api-key";
using (var client = new CliHttpClient())
{
var response = await HttpPolicyExtensions
.HandleTransientHttpError()
.OrResult(msg => !msg.IsSuccessStatusCode)
.WaitAndRetryAsync(new[]
{
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(3),
TimeSpan.FromSeconds(7)
},
(responseMessage, timeSpan, retryCount, context) =>
{
if (responseMessage.Exception != null)
{
_logger.LogWarning(
$"{retryCount}. request attempt failed to {url} with an error: \"{responseMessage.Exception.Message}\". " +
$"Waiting {timeSpan.TotalSeconds} secs for the next try...");
}
else if (responseMessage.Result != null)
{
_logger.LogWarning(
$"{retryCount}. request attempt failed {url} with {(int)responseMessage.Result.StatusCode}-{responseMessage.Result.ReasonPhrase}. " +
$"Waiting {timeSpan.TotalSeconds} secs for the next try...");
}
})
.ExecuteAsync(async() => await client.GetAsync(url).ConfigureAwait(false)).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"ERROR: Remote server returns '{response.StatusCode}'");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response).ConfigureAwait(false);
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var apiKeyResult = JsonSerializer.Deserialize <DeveloperApiKeyResult>(responseContent);
if (apiKeyResult == null ||
string.IsNullOrEmpty(apiKeyResult.ApiKey))
{
_logger.LogError("Couldn't retrieve your NuGet API key!");
_logger.LogWarning(File.Exists(CliPaths.AccessToken)
? "Make sure you have an active session and license on commercial.abp.io. To re-sign in you can use the CLI command \"abp login <username>\"."
: "You are not signed in to commercial.abp.io. Use the CLI command \"abp login <username>\" to sign in.");
return(null);
}
return(apiKeyResult);
}
}
public async Task <DeveloperApiKeyResult> GetApiKeyOrNullAsync(bool invalidateCache = false)
{
if (!AuthService.IsLoggedIn())
{
return(null);
}
if (invalidateCache)
{
_apiKeyResult = null;
}
if (_apiKeyResult != null)
{
return(_apiKeyResult);
}
var url = $"{CliUrls.WwwAbpIo}api/license/api-key";
using (var client = new CliHttpClient())
{
var response = await HttpPolicyExtensions
.HandleTransientHttpError()
.OrResult(msg => !msg.IsSuccessStatusCode)
.WaitAndRetryAsync(new[]
{
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(3),
TimeSpan.FromSeconds(7)
},
(responseMessage, timeSpan, retryCount, context) =>
{
if (responseMessage.Exception != null)
{
_logger.LogWarning(
$"{retryCount}. request attempt failed to {url} with an error: \"{responseMessage.Exception.Message}\". " +
$"Waiting {timeSpan.TotalSeconds} secs for the next try...");
}
else if (responseMessage.Result != null)
{
_logger.LogWarning(
$"{retryCount}. request attempt failed {url} with {(int)responseMessage.Result.StatusCode}-{responseMessage.Result.ReasonPhrase}. " +
$"Waiting {timeSpan.TotalSeconds} secs for the next try...");
}
})
.ExecuteAsync(async() => await client.GetAsync(url).ConfigureAwait(false)).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"ERROR: Remote server returns '{response.StatusCode}'");
}
await RemoteServiceExceptionHandler.EnsureSuccessfulHttpResponseAsync(response).ConfigureAwait(false);
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var apiKeyResult = JsonSerializer.Deserialize <DeveloperApiKeyResult>(responseContent);
return(apiKeyResult);
}
}
