/// <inheritdoc/>
public async Task <RequestTokenResponse> RefreshTokenAsync(string clientId, string clientSecret, string refreshTokenUrl, string refreshToken)
{
Validate.RejectNullOrEmpty(clientId, "clientId");
Validate.RejectNullOrEmpty(clientSecret, "clientSecret");
Validate.RejectNullOrEmpty(refreshTokenUrl, "refreshTokenUrl");
Validate.RejectNullOrEmpty(refreshToken, "refreshToken");
var formData = new List <BasicKeyValuePair>()
{
new BasicKeyValuePair(Constants.Parameters.REFRESH_TOKEN, refreshToken),
new BasicKeyValuePair(Constants.Parameters.GRANT_TYPE, Constants.GrantTypes.REFRESH_TOKEN),
};
var authentication = RestAuthentication.Basic(clientId, clientSecret);
RestResponse restResponse;
try
{
restResponse = await _client.PostAsync(refreshTokenUrl, authentication, formData, null, null);
}
catch (Exception e) when(e is HttpRequestException || e is System.Net.WebException || e is TaskCanceledException)
{
Log.Error(() => $"Error occurred while refreshing token url={refreshTokenUrl}", e);
throw new MobileConnectEndpointHttpException(e.Message, e);
}
return(new RequestTokenResponse(restResponse));
}
public bool Confidentials()
{
RestAuthentication restAuthentication = new RestAuthentication(new UserRepository(),
new CanonicalRequest(), new CalculateSignature());
return(restAuthentication.IsAuthenticated(this.Request));
}
/// <inheritdoc/>
public async Task <RequestTokenResponse> RequestTokenAsync(string clientId, string clientSecret, string requestTokenUrl, string redirectUrl, string code)
{
Validate.RejectNullOrEmpty(clientId, "clientId");
Validate.RejectNullOrEmpty(clientSecret, "clientSecret");
Validate.RejectNullOrEmpty(requestTokenUrl, "requestTokenUrl");
Validate.RejectNullOrEmpty(redirectUrl, "redirectUrl");
Validate.RejectNullOrEmpty(code, "code");
try
{
var formData = new List <BasicKeyValuePair>()
{
new BasicKeyValuePair(Constants.Parameters.AUTHENTICATION_REDIRECT_URI, redirectUrl),
new BasicKeyValuePair(Constants.Parameters.CODE, code),
new BasicKeyValuePair(Constants.Parameters.GRANT_TYPE, Constants.DefaultOptions.GRANT_TYPE)
};
RestResponse response = await _client.PostAsync(requestTokenUrl, RestAuthentication.Basic(clientId, clientSecret), formData, null, null);
var tokenResponse = new RequestTokenResponse(response);
return(tokenResponse);
}
catch (Exception e) when(e is HttpRequestException || e is System.Net.WebException || e is TaskCanceledException)
{
Log.Error(() => $"Error occurred while requesting token url={requestTokenUrl}", e);
throw new MobileConnectEndpointHttpException(e.Message, e);
}
}
private async Task <DiscoveryResponse> CallDiscoveryEndpoint(
string clientId,
string clientSecret,
string discoveryUrl,
DiscoveryOptions options,
IEnumerable <BasicKeyValuePair> currentCookies,
bool cacheDiscoveryResponse)
{
Validate.RejectNullOrEmpty(clientId, "clientId");
Validate.RejectNullOrEmpty(clientSecret, "clientSecret");
Validate.RejectNullOrEmpty(discoveryUrl, "discoveryUrl");
Validate.RejectNullOrEmpty(options.RedirectUrl, "redirectUrl");
if (cacheDiscoveryResponse)
{
var cachedValue = await GetCachedValueAsync(options);
if (cachedValue != null)
{
return(cachedValue);
}
}
try
{
var cookies = GetCookiesToProxy(currentCookies);
var authentication = RestAuthentication.Basic(clientId, clientSecret);
var queryParams = GetDiscoveryQueryParams(options);
RestResponse response;
if (string.IsNullOrEmpty(options.MSISDN))
{
response = await _client.GetDiscoveryAsync(discoveryUrl, authentication, options.XRedirect, options.ClientIP, queryParams, cookies);
}
else
{
response = await _client.PostDiscoveryAsync(discoveryUrl, authentication, queryParams, options.ClientIP, options.XRedirect, cookies);
}
var discoveryResponse = new DiscoveryResponse(response);
discoveryResponse.ProviderMetadata = await RetrieveProviderMetada(discoveryResponse.OperatorUrls?.ProviderMetadataUrl);
if (cacheDiscoveryResponse)
{
await AddCachedValueAsync(options, discoveryResponse).ConfigureAwait(false);
}
return(discoveryResponse);
}
catch (Exception e) when(e is HttpRequestException || e is System.Net.WebException || e is TaskCanceledException)
{
Log.Error("Error occured while calling discovery endpoint", e);
throw new MobileConnectEndpointHttpException(e.Message, e);
}
}
/// <inheritdoc/>
private async Task <IdentityResponse> RequestInfoInternal(string infoUrl, string accessToken, InfoType infoType)
{
try
{
RestResponse response;
var auth = RestAuthentication.Bearer(accessToken);
response = await _client.GetAsync(infoUrl, auth, null, null, null);
return(new IdentityResponse(response, infoType));
}
catch (Exception e) when(e is HttpRequestException || e is WebException || e is TaskCanceledException)
{
Log.Error(() => $"Error occurred while requesting identity url={infoUrl}", e);
throw new MobileConnectEndpointHttpException(e.Message, e);
}
}
/// <inheritdoc/>
public async Task <RevokeTokenResponse> RevokeTokenAsync(string clientId, string clientSecret, string revokeTokenUrl, string token, string tokenTypeHint)
{
Validate.RejectNullOrEmpty(clientId, "clientId");
Validate.RejectNullOrEmpty(clientSecret, "clientSecret");
Validate.RejectNullOrEmpty(revokeTokenUrl, "revokeTokenUrl");
Validate.RejectNullOrEmpty(token, "token");
var formData = new List <BasicKeyValuePair>()
{
new BasicKeyValuePair(Constants.Parameters.TOKEN, token)
};
if (tokenTypeHint != null)
{
formData.Add(new BasicKeyValuePair(Constants.Parameters.TOKEN_TYPE_HINT, tokenTypeHint));
}
var authentication = RestAuthentication.Basic(clientId, clientSecret);
var restResponse = await _client.PostAsync(revokeTokenUrl, authentication, formData, null, null);
return(new RevokeTokenResponse(restResponse));
}
protected override Task <RestResponse> PostAsync(string uri, RestAuthentication authentication, HttpContent content, string xRedirect, string sourceIp, IEnumerable <BasicKeyValuePair> cookies = null)
{
return(Task.Run(() => HandleResponse(uri)));
}
public override Task <RestResponse> GetAsync(string uri, RestAuthentication authentication, string xRedirect, string sourceIp, IEnumerable <BasicKeyValuePair> queryParams = null, IEnumerable <BasicKeyValuePair> cookies = null)
{
return(Task.Run(() => HandleResponse(uri)));
}
