/// <inheritdoc />
public async Task <TokenExchangeResult> ExchangeBankTokenAsync(string publicToken, string accountId)
{
Condition.Requires(publicToken).IsNotNullOrWhiteSpace();
ExchangeTokenRequest exchangeRequest = new ExchangeTokenRequest(this.clientId, this.clientSecret, publicToken, accountId);
HttpResponseMessage response = await this.httpClient.PostAsJsonAsync("exchange_token", exchangeRequest);
string responseJson = await response.Content.ReadAsStringAsync();
TokenExchangeResult result = new TokenExchangeResult();
if (response.StatusCode == HttpStatusCode.OK)
{
ExchangeTokenResponse tokenResponse = JsonConvert.DeserializeObject <ExchangeTokenResponse>(responseJson);
result.AccessToken = new AccessToken(tokenResponse.AccessToken);
result.BankAccountToken = tokenResponse.BankToken;
return(result);
}
result.Exception = await this.ParseException(response, responseJson);
return(result);
}
public async Task <IActionResult> RefreshJwtToken([FromBody] ExchangeTokenRequest exchangeTokenRequest)
{
string refreshToken = _facebookService.RefreshFacebookToken(exchangeTokenRequest.Token);
if (refreshToken == null)
{
return(Unauthorized("Invalid token1"));
}
exchangeTokenRequest.Token = refreshToken;
return(GenerateToken(exchangeTokenRequest, refreshToken));
}
public async Task ExchangePublicTokenAsync_should_retrieve_a_response_from_the_api_server()
{
// Arrange
using PlaidClient client = new PlaidClient { Environment = Environment.Sandbox };
// Act
ExchangeTokenRequest request = new ExchangeTokenRequest {
};
ExchangeTokenResponse result = await client.ExchangeTokenAsync(request);
// Assert
result.Exception.ShouldBeNull();
result.SuccessfulOutcome.ShouldBeTrue();
result.AccessToken.ShouldNotBeNull();
}
private IActionResult GenerateToken(ExchangeTokenRequest exchangeTokenRequest, string refreshToken)
{
var validTokenInfo = GetValidTokenInfo(exchangeTokenRequest);
if (validTokenInfo == null)
{
return(Unauthorized("Invalid token"));
}
long unixTime = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds();
int lifeTime = (int)(validTokenInfo.expires_at - unixTime);
return(Ok(new ExchangeTokenResponse
{
expires_in = lifeTime,
access_token = _jwtTokenGenerator.GenerateJwtToken(validTokenInfo, lifeTime),
token_type = "Bearer",
refresh_token = refreshToken,
source = exchangeTokenRequest.Source
}));
}
public async Task <ApiResponse <AuthResponse> > ExchangeRefreshToken(ExchangeTokenRequest tokenRequest)
{
var refreshToken = _hostRepository.GetFirst <RefreshToken>(r => r.Token == tokenRequest.RefreshToken);
ClaimsPrincipal principal = GetPrincipalFromToken(tokenRequest.AccessToken);
if (principal == null)
{
return(ApiResponse <AuthResponse> .Error()); //ErrorProvider.GetError("no_valid_token")
}
var expiryDate = long.Parse(principal.Claims.Single(x => x.Type == JwtRegisteredClaimNames.Exp).Value);
var expiryDateTimeLocal = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(expiryDate).ToLocalTime();
var jti = principal.Claims.Single(x => x.Type == JwtRegisteredClaimNames.Jti).Value;
if (expiryDateTimeLocal > DateTime.Now)
{
return(ApiResponse <AuthResponse> .Error()); //ErrorProvider.GetError("token_not_expired") });
}
if (refreshToken == null)
{
return(ApiResponse <AuthResponse> .Error()); //ErrorProvider.GetError("token_not_found") });
}
if (refreshToken.Invalidated)
{
return(ApiResponse <AuthResponse> .Error()); //ErrorProvider.GetError("no_valid_token") });
}
if (refreshToken.ExpiresOn < DateTime.Now)
{
refreshToken.Invalidated = true;
_hostRepository.Update(refreshToken);
await _hostRepository.SaveAsync();
return(ApiResponse <AuthResponse> .Error()); //ErrorProvider.GetError("token_expired") });
}
if (refreshToken.JwtId != jti)
{
return(ApiResponse <AuthResponse> .Error()); //ErrorProvider.GetError("token_mismatch") });
}
var user = await _userManager.FindByIdAsync(refreshToken.ApplicationUserId.ToString());
if (user != null)
{
var tokens = await _jwtTokenFactory.GenerateAuthResponseForUser(user);
refreshToken.Invalidated = true;
_hostRepository.Update(refreshToken);
await _hostRepository.SaveAsync();
return(ApiResponse <AuthResponse> .Success(tokens));
}
else
{
return(ApiResponse <AuthResponse> .Error()); //ErrorProvider.GetError("auth_user_not_found") });
}
}
private UserInfo GetValidTokenInfo(ExchangeTokenRequest exchangeTokenRequest)
{
return("facebook".Equals(exchangeTokenRequest.Source.ToLower())
? _facebookService.GetUserInfoByToken(exchangeTokenRequest.Token)
: null);
}
public async Task <IActionResult> GetJwtToken([FromBody] ExchangeTokenRequest exchangeTokenRequest)
{
return(GenerateToken(exchangeTokenRequest, exchangeTokenRequest.Token));
}
public async Task <ActionResult <AuthResponse> > RefreshToken([FromBody] ExchangeTokenRequest tokenRequest)
{
var response = await _authService.ExchangeRefreshToken(tokenRequest);
return(response.ToActionResult(this));
}
