protected void LogTokenPair(TokenPair tokenPair, string text, LogEventLevel level)
{
if (_logger == null)
{
return;
}
_logger.Write <string, LexicalType, string>(level,
"{0} *undefined* => {1} ('{2}')",
text,
tokenPair.Current.Type,
tokenPair.Current.Text);
//else
// _logger.Write( level,
// "{0} {1} ('{2}') => {3} ('{4}')",
// new object[]
// {
// text,
// tokenPair.Previous.Type,
// tokenPair.Previous.Text,
// tokenPair.Current.Type,
// tokenPair.Current.Text
// } );
}
public async Task <ActionResult <User> > Login(LoginViewModel user)
{
if (!ModelState.IsValid)
{
return(Ok(new { error_message = "Tai khoan hoac mat khau khong hop le" }));
}
User fromDb = await _userServices.DoLogin(user);
if (fromDb is null)
{
return(Ok(new { error_message = "Đăng nhập thất bại, vui lòng thử lại!" }));
}
if (!fromDb.IsAccess)
{
return(Ok(new { error_message = "Tai khoan cua ban bi khoa. Vui long lien he quan tri vien" }));
}
TokenPair tokenPair = new TokenPair()
{
Access = _accessToken.GenerateToken(fromDb),
Refresh = _refreshToken.GenerateToken()
};
await _userServices.createUserTokenAsync(fromDb, tokenPair.Refresh);
return(Ok(new
{
data = tokenPair,
success = true,
}));
}
/// <summary>
/// acquires a <see cref="TokenPair"/> from the authority via an interactive user logon
/// prompt.
/// </summary>
/// <param name="targetUri">
/// The uniform resource indicator of the resource access tokens are being requested for.
/// </param>
/// <param name="clientId">Identifier of the client requesting the token.</param>
/// <param name="resource">
/// Identifier of the target resource that is the recipient of the requested token.
/// </param>
/// <param name="redirectUri">
/// Address to return to upon receiving a response from the authority.
/// </param>
/// <param name="queryParameters">
/// Optional: appended as-is to the query string in the HTTP authentication request to the
/// authority.
/// </param>
/// <returns>If successful a <see cref="TokenPair"/>; otherwise <see langword="null"/>.</returns>
public TokenPair AcquireToken(Uri targetUri, string clientId, string resource, Uri redirectUri, string queryParameters = null)
{
Debug.Assert(targetUri != null && targetUri.IsAbsoluteUri, "The targetUri parameter is null or invalid");
Debug.Assert(!String.IsNullOrWhiteSpace(clientId), "The clientId parameter is null or empty");
Debug.Assert(!String.IsNullOrWhiteSpace(resource), "The resource parameter is null or empty");
Debug.Assert(redirectUri != null, "The redirectUri parameter is null");
Debug.Assert(redirectUri.IsAbsoluteUri, "The redirectUri parameter is not an absolute Uri");
Trace.WriteLine("AzureAuthority::AcquireToken");
TokenPair tokens = null;
queryParameters = queryParameters ?? String.Empty;
try
{
Trace.WriteLine(String.Format(" authority host url = '{0}'.", AuthorityHostUrl));
AuthenticationContext authCtx = new AuthenticationContext(AuthorityHostUrl, _adalTokenCache);
AuthenticationResult authResult = authCtx.AcquireToken(resource, clientId, redirectUri, PromptBehavior.Always, UserIdentifier.AnyUser, queryParameters);
tokens = new TokenPair(authResult);
Trace.WriteLine(" token acquisition succeeded.");
}
catch (AdalException)
{
Trace.WriteLine(" token acquisition failed.");
}
return tokens;
}
public TokenPair RequestToken()
{
try
{
WebRequest req = MakeRequest("POST", "https://api.twitter.com/oauth/request_token");
Stream resStream = req.GetResponse().GetResponseStream();
if (resStream != null)
{
using (StreamReader reader = new StreamReader(resStream))
{
string str = reader.ReadToEnd();
TokenPair token = new TokenPair
{
Token = Regex.Match(str, @"oauth_token=([^&]+)").Groups[1].Value,
Secret = Regex.Match(str, @"oauth_token_secret=([^&]+)").Groups[1].Value
};
return(token);
}
}
return(null);
}
catch (WebException ex)
{
Stream resStream = ex.Response?.GetResponseStream();
if (resStream == null)
{
return(null);
}
using (StreamReader reader = new StreamReader(resStream))
Console.WriteLine(reader.ReadToEnd());
return(null);
}
}
public async void SavesRefreshTokenReturnsTokenPair(string uid, bool shouldPersist)
{
var user = new User {
Id = uid, UserName = "******"
};
var expected = new TokenPair
{
AccessToken = "axessToken" + uid,
RefreshToken = "refreshToken" + uid,
User = user,
Persistent = shouldPersist
};
var refreshToken = new RefreshToken
{
Token = expected.RefreshToken,
UID = uid,
ExpiresAt = Now.AddDays(30),
Persistent = shouldPersist
};
tokenService.Setup(x => x.CreateAccessToken(uid)).Returns(expected.AccessToken);
tokenService.Setup(x => x.CreateRefreshToken()).Returns(expected.RefreshToken);
refreshTokenRepo.Setup(x => x.Create(refreshToken)).ReturnsAsync(refreshToken);
var actual = await userService.CreateAuthTokens(user, shouldPersist);
Assert.Equal(expected, actual);
refreshTokenRepo.Verify(x => x.Create(It.IsAny <RefreshToken>()), Times.Once);
}
public async Task <string> GetTokenAsync()
{
TokenPair tokenPair = new TokenPair("", "");
if (tokens != null)
{
tokenPair = tokens;
}
else if (tokens == null)
{
string accessToken = await _localStorageService.GetItemAsync <string>(_options.Value.AccessTokenName).ConfigureAwait(true);
string refreshToken = await _localStorageService.GetItemAsync <string>(_options.Value.RefreshTokenName).ConfigureAwait(false);
tokenPair = new TokenPair(accessToken, refreshToken);
}
if (String.IsNullOrWhiteSpace(tokenPair.AccessToken) || String.IsNullOrWhiteSpace(tokenPair.RefreshToken))
{
throw new Exception("Invalid token");
}
if (!await _tokenProvider.ValidateTokenAsync(tokenPair.AccessToken))
{
tokenPair = await _tokenProvider.RenewTokensAsync(tokenPair.RefreshToken);
await SetTokensAsync(tokenPair);
}
tokens = tokenPair;
return(tokenPair.AccessToken);
}
public TokenPair AccessToken(string verifier)
{
try
{
var obj = new { oauth_verifier = verifier };
var buff = Encoding.UTF8.GetBytes(OAuth.ToString(obj));
var req = MakeRequest("POST", "https://api.twitter.com/oauth/access_token", obj);
req.GetRequestStream().Write(buff, 0, buff.Length);
using (var res = req.GetResponse())
using (var reader = new StreamReader(res.GetResponseStream()))
{
var str = reader.ReadToEnd();
var token = new TokenPair();
token.Token = Regex.Match(str, @"oauth_token=([^&]+)").Groups[1].Value;
token.Secret = Regex.Match(str, @"oauth_token_secret=([^&]+)").Groups[1].Value;
return(token);
}
}
catch
{
return(null);
}
}
public async Task SetTokensAsync(TokenPair tokenPair)
{
await _localStorageService.SetItemAsync <string>(_options.Value.AccessTokenName, tokenPair.AccessToken);
await _localStorageService.SetItemAsync <string>(_options.Value.RefreshTokenName, tokenPair.RefreshToken);
tokens = new TokenPair(tokenPair.AccessToken, tokenPair.RefreshToken);
}
/// <inheritdoc />
public override IDocumentItem Parse(TokenPair token, ParserOptions options, Stack <DocumentScope> buildStack,
Func <int> getScope, IEnumerable <ITokenOption> tokenOptions)
{
var tagKeyword = _tagRegex.Match(token.Value).Value;
var value = token.Value?.Trim('{', '}').Remove(0, tagKeyword.Length).Trim();
return(CreateDocumentItem(tagKeyword, value, token, options, tokenOptions));
}
public bool TerminateWithPrejudice(TokenPair tokenPair)
{
_current = null;
LogTokenPair(tokenPair, "terminated with prejudice", LogEventLevel.Error);
return(false);
}
/// <inheritdoc />
public override bool ShouldParse(TokenPair token, ParserOptions options, IEnumerable <ITokenOption> tagCreationOptions)
{
if (!(token.Type is string blockType))
{
return(false);
}
return(TagOpen.IsMatch(blockType) || TagClose.IsMatch(blockType));
}
public async Task <IActionResult> Login(LoginModel model)
{
var jwt = await accountService.AuthAsync(model.Email, model.Password);
var tokenPair = new TokenPair
{
Token = jwt.Token,
ExpiredAt = jwt.ExpiredAt
};
return(Ok(tokenPair));
}
private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
{
if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true)
{
return;
}
var declaration = (MemberDeclarationSyntax)context.Node;
if (declaration.Parent?.IsKind(SyntaxKind.CompilationUnit) == false)
{
TokenPair tokenPair = GetTokenPair(declaration);
if (!tokenPair.OpenToken.IsKind(SyntaxKind.None) &&
!tokenPair.OpenToken.IsMissing &&
!tokenPair.CloseToken.IsKind(SyntaxKind.None) &&
!tokenPair.CloseToken.IsMissing)
{
int closeTokenLine = tokenPair.CloseToken.GetSpanEndLine();
if (tokenPair.OpenToken.GetSpanEndLine() != closeTokenLine)
{
MemberDeclarationSyntax nextDeclaration = GetNextDeclaration(declaration);
if (nextDeclaration != null)
{
int diff = nextDeclaration.GetSpanStartLine() - closeTokenLine;
if (diff < 2)
{
SyntaxTrivia trivia = declaration.GetTrailingTrivia().LastOrDefault();
if (trivia.IsKind(SyntaxKind.EndOfLineTrivia))
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddEmptyLineBetweenDeclarations,
trivia.GetLocation());
}
else
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddEmptyLineBetweenDeclarations,
tokenPair.CloseToken.GetLocation());
}
}
}
}
}
}
}
public void HandlesNullCorrectly()
{
var tokenPair = new TokenPair();
Assert.False(tokenPair == null);
Assert.False(null == tokenPair);
Assert.True(tokenPair != null);
Assert.True(null != tokenPair);
tokenPair = null;
Assert.True(tokenPair == null);
Assert.True(null == tokenPair);
Assert.False(tokenPair != null);
Assert.False(null != tokenPair);
}
public static void AnalyzeMemberDeclaration(SyntaxNodeAnalysisContext context)
{
var declaration = (MemberDeclarationSyntax)context.Node;
if (!declaration.IsParentKind(SyntaxKind.CompilationUnit))
{
TokenPair tokenPair = GetTokenPair(declaration);
SyntaxToken openToken = tokenPair.OpenToken;
SyntaxToken closeToken = tokenPair.CloseToken;
if (!openToken.IsKind(SyntaxKind.None) &&
!openToken.IsMissing &&
!closeToken.IsKind(SyntaxKind.None) &&
!closeToken.IsMissing)
{
int closeTokenLine = closeToken.GetSpanEndLine();
if (openToken.GetSpanEndLine() != closeTokenLine)
{
MemberDeclarationSyntax nextDeclaration = GetNextDeclaration(declaration);
if (nextDeclaration != null)
{
int diff = nextDeclaration.GetSpanStartLine() - closeTokenLine;
if (diff < 2)
{
SyntaxTrivia trivia = declaration.GetTrailingTrivia().LastOrDefault();
if (trivia.IsEndOfLineTrivia())
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddEmptyLineBetweenDeclarations,
trivia);
}
else
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddEmptyLineBetweenDeclarations,
closeToken);
}
}
}
}
}
}
}
/// <inheritdoc />
public override IDocumentItem Parse(TokenPair token, ParserOptions options, Stack <DocumentScope> buildStack,
Func <int> getScope, IEnumerable <ITokenOption> tagCreationOptions)
{
if (Equals(token.Type, TagOpen.Trim()))
{
var tagDocumentItem = CreateDocumentItem(TagOpen,
token.Value?.Remove(0, TagOpen.Length).Trim(),
token, options, tagCreationOptions);
buildStack.Push(new DocumentScope(tagDocumentItem, getScope));
return(tagDocumentItem);
}
else if (Equals(token.Type, TagClose))
{
buildStack.Pop();
}
return(null);
}
public bool EndParsing(TokenPair tokenPair)
{
if (tokenPair.Current.Type != LexicalType.EndOfInput)
{
LogTokenPair(tokenPair,
$"{nameof( EndParsing )} called before end of command line text",
LogEventLevel.Error);
return(false);
}
if (_current == null)
{
_options !.SpuriousValues.Add(tokenPair.Previous.Text);
return(true);
}
return(AssignToOption(tokenPair));
}
public async Task <ActionResult <User> > Refresh(TokenPair token)
{
bool isValidToken;
//Validate from client
if (token.Refresh is null)
{
return(Unauthorized(new { error_message = "Refresh token invalid" }));
}
isValidToken = _refreshToken.Validate(token.Refresh);
if (!isValidToken)
{
return(Unauthorized(new { error_message = "Refresh token invalid" }));
}
//Validate from server
User user = await _userServices.GetByRefreshToken(token.Refresh);
if (user is null)
{
return(Unauthorized(new { error_message = "Refresh token invalid" }));
}
isValidToken = _refreshToken.Validate(user.RefreshToken);
if (!isValidToken)
{
return(Unauthorized(new { error_message = "Refresh token invalid" }));
}
//Create new token pair
TokenPair tokenPair = new TokenPair
{
Access = _accessToken.GenerateToken(user),
Refresh = _refreshToken.GenerateToken()
};
await _userServices.createUserTokenAsync(user, tokenPair.Refresh);
return(Ok(new
{
data = tokenPair,
success = true,
}));
}
public async void RetriesOnDocumentConflictError(string uid, bool shouldPersist)
{
var user = new User {
Id = uid, UserName = "******"
};
var expected = new TokenPair
{
AccessToken = "axessToken" + uid,
RefreshToken = "refreshToken" + uid,
User = user,
Persistent = shouldPersist
};
var refreshToken = new RefreshToken
{
Token = expected.RefreshToken,
UID = uid,
ExpiresAt = Now.AddDays(30),
Persistent = shouldPersist
};
var duplicateToken = new RefreshToken
{
UID = uid,
Token = "tokenthatsalreadyinuse",
ExpiresAt = Now.AddDays(30),
Persistent = shouldPersist
};
tokenService.Setup(x => x.CreateAccessToken(uid)).Returns(expected.AccessToken);
tokenService.SetupSequence(x => x.CreateRefreshToken())
.Returns(duplicateToken.Token)
.Returns(expected.RefreshToken);
refreshTokenRepo.SetupSequence(x => x.Create(duplicateToken))
.ThrowsAsync(new DocumentConflictException());
refreshTokenRepo.SetupSequence(x => x.Create(refreshToken))
.ReturnsAsync(refreshToken);
var actual = await userService.CreateAuthTokens(user, shouldPersist);
Assert.Equal(expected, actual);
refreshTokenRepo.Verify(x => x.Create(It.IsNotNull <RefreshToken>()), Times.Exactly(2));
}
public static TokenPair Oauth_AccessToken(this OAuth oauth, string verifier)
{
try
{
var obj = new { oauth_verifier = verifier };
var str = oauth.GetResponse("POST", new Uri("https://api.twitter.com/oauth/access_token"), obj);
var token = new TokenPair
{
Token = Regex.Match(str, @"oauth_token=([^&]+)").Groups[1].Value,
Secret = Regex.Match(str, @"oauth_token_secret=([^&]+)").Groups[1].Value
};
return(token);
}
catch
{
return(null);
}
}
public bool ProcessText(TokenPair tokenPair)
{
if (_current == null)
{
_options !.SpuriousValues.Add(tokenPair.Current.Text);
}
else
{
if (_current.Key == null)
{
_current.Key = tokenPair.Current.Text;
}
else
{
_current.Values.Add(tokenPair.Current.Text);
}
}
return(true);
}
public TokenPair AccessToken(string verifier)
{
try
{
var obj = new { oauth_verifier = verifier };
byte[] buff = Encoding.UTF8.GetBytes(ToString(obj));
WebRequest req = MakeRequest("POST", "https://api.twitter.com/oauth/access_token", obj);
req.GetRequestStream().Write(buff, 0, buff.Length);
Stream resStream = req.GetResponse().GetResponseStream();
if (resStream != null)
{
using (StreamReader reader = new StreamReader(resStream))
{
string str = reader.ReadToEnd();
TokenPair token = new TokenPair
{
Token = Regex.Match(str, @"oauth_token=([^&]+)").Groups[1].Value,
Secret = Regex.Match(str, @"oauth_token_secret=([^&]+)").Groups[1].Value
};
return(token);
}
}
return(null);
}
catch (WebException ex)
{
Stream resStream = ex.Response?.GetResponseStream();
if (resStream == null)
{
return(null);
}
using (StreamReader reader = new StreamReader(resStream))
Console.WriteLine(reader.ReadToEnd());
return(null);
}
}
public TokenPair RequestToken()
{
try
{
var req = MakeRequest("POST", "https://api.twitter.com/oauth/request_token");
using (var res = req.GetResponse())
using (var reader = new StreamReader(res.GetResponseStream()))
{
var str = reader.ReadToEnd();
var token = new TokenPair();
token.Token = Regex.Match(str, @"oauth_token=([^&]+)").Groups[1].Value;
token.Secret = Regex.Match(str, @"oauth_token_secret=([^&]+)").Groups[1].Value;
return(token);
}
}
catch
{
return(null);
}
}
public bool Commit(TokenPair tokenPair)
{
if (_current == null)
{
switch (tokenPair.Current.Type)
{
// if we're not yet building an entry but we received a KeyPrefix token we must be
// about to start building one
case LexicalType.Separator
when tokenPair.Previous.Type == LexicalType.Separator:
return(true);
case LexicalType.KeyPrefix:
return(Create(tokenPair));
default:
LogTokenPair(tokenPair, "invalid token sequence", LogEventLevel.Error);
return(false);
}
}
return(AssignToOption(tokenPair) && Create(tokenPair));
}
private bool AssignToOption(TokenPair tokenPair)
{
if (_current == null)
{
return(false);
}
// where we add values depends on how many are expected/required
// by the option and what kind of option it is
// Switch options should've been committed by this point -- so
// the "switch" branch should never run -- but just to be safe...
if (_current.Option != null)
{
return(_current.Option.Style == OptionStyle.Switch
? CommitSwitch()
: CommitNonSwitch());
}
_options !.UnknownKeys.Add(_current);
LogTokenPair(tokenPair, $"unexpected key '{_current.Key}'", LogEventLevel.Error);
return(true);
}
public void HandlesNullCorrectly()
{
var tokenPair = new TokenPair();
Assert.False(tokenPair.Equals(null));
}
GetStringToken(string text, TokenPair[] tokenList)
{
string s = text.ToLower();
foreach (TokenPair tp in tokenList)
{
if (tp.Text.Equals(s) == true)
return (tp.Token);
}
return (FToken.BadToken);
}
/// <inheritdoc />
public override IDocumentItem CreateDocumentItem(string tag, string value, TokenPair token, ParserOptions options)
{
return(new MorestachioLocalizationDocumentItem(token.MorestachioExpression));
}
/// <inheritdoc />
public override IDocumentItem CreateDocumentItem(string tag, string value, TokenPair token, ParserOptions options)
{
return(new CompileLessDocumentItem());
}
/// <summary>
/// Acquires an access token from the authority using a previously acquired refresh token.
/// </summary>
/// <param name="targetUri">
/// The uniform resource indicator of the resource access tokens are being requested for.
/// </param>
/// <param name="clientId">Identifier of the client requesting the token.</param>
/// <param name="resource">
/// Identifier of the target resource that is the recipient of the requested token.
/// </param>
/// <param name="refreshToken">The <see cref="Token"/> of type <see cref="TokenType.Refresh"/>
/// to be used to acquire the access token.</param>
/// <returns>If successful a <see cref="TokenPair"/>; otherwise <see langword="null"/>.</returns>
public async Task<TokenPair> AcquireTokenByRefreshTokenAsync(Uri targetUri, string clientId, string resource, Token refreshToken)
{
Debug.Assert(targetUri != null && targetUri.IsAbsoluteUri, "The targetUri parameter is null or invalid");
Debug.Assert(!String.IsNullOrWhiteSpace(clientId), "The clientId parameter is null or empty");
Debug.Assert(!String.IsNullOrWhiteSpace(resource), "The resource parameter is null or empty");
Debug.Assert(refreshToken != null, "The refreshToken parameter is null");
Debug.Assert(refreshToken.Type == TokenType.Refresh, "The value of refreshToken parameter is not a refresh token");
Debug.Assert(!String.IsNullOrWhiteSpace(refreshToken.Value), "The value of refreshToken parameter is null or empty");
TokenPair tokens = null;
try
{
string authorityHostUrl = AuthorityHostUrl;
if (refreshToken.TargetIdentity != Guid.Empty)
{
authorityHostUrl = GetAuthorityUrl(refreshToken.TargetIdentity);
Trace.WriteLine(" authority host url set by refresh token.");
}
Trace.WriteLine(String.Format(" authority host url = '{0}'.", authorityHostUrl));
AuthenticationContext authCtx = new AuthenticationContext(authorityHostUrl, _adalTokenCache);
AuthenticationResult authResult = await authCtx.AcquireTokenByRefreshTokenAsync(refreshToken.Value, clientId, resource);
tokens = new TokenPair(authResult);
Trace.WriteLine(" token acquisition succeeded.");
}
catch (AdalException)
{
Trace.WriteLine(" token acquisition failed.");
}
return tokens;
}
public TokenPair RequestToken()
{
try
{
var req = MakeRequest("POST", "https://api.twitter.com/oauth/request_token");
using (var res = req.GetResponse())
using (var reader = new StreamReader(res.GetResponseStream()))
{
var str = reader.ReadToEnd();
var token = new TokenPair();
token.Token = Regex.Match(str, @"oauth_token=([^&]+)").Groups[1].Value;
token.Secret = Regex.Match(str, @"oauth_token_secret=([^&]+)").Groups[1].Value;
return token;
}
}
catch
{
return null;
}
}
public TokenPair AccessToken(string verifier)
{
try
{
var obj = new { oauth_verifier = verifier };
var buff = Encoding.UTF8.GetBytes(OAuth.ToString(obj));
var req = MakeRequest("POST", "https://api.twitter.com/oauth/access_token", obj);
req.GetRequestStream().Write(buff, 0, buff.Length);
using (var res = req.GetResponse())
using (var reader = new StreamReader(res.GetResponseStream()))
{
var str = reader.ReadToEnd();
var token = new TokenPair();
token.Token = Regex.Match(str, @"oauth_token=([^&]+)").Groups[1].Value;
token.Secret = Regex.Match(str, @"oauth_token_secret=([^&]+)").Groups[1].Value;
return token;
}
}
catch
{
return null;
}
}
/// <inheritdoc />
public override IDocumentItem CreateDocumentItem(string tag, string value, TokenPair token, ParserOptions options,
IEnumerable <ITokenOption> tagCreationOptions)
{
return(new BlockDocumentItemProvider.BlockDocumentItem(token.TokenLocation, _action, value,
tagCreationOptions));
}
public TwitterOAuth(string appToken, string appSecret, string userToken, string userSecret)
{
App = new TokenPair(appToken, appSecret);
User = new TokenPair(userToken, userSecret);
}
/// <inheritdoc />
public override IDocumentItem CreateDocumentItem(string tag, string value, TokenPair token,
ParserOptions options, IEnumerable <ITokenOption> tagCreationOptions)
{
return(new MorestachioCustomCultureLocalizationDocumentItem(token.TokenLocation, token.MorestachioExpression, tagCreationOptions));
}
/// <summary>
/// acquires a <see cref="TokenPair"/> from the authority using optionally provided
/// credentials or via the current identity.
/// </summary>
/// <param name="targetUri">
/// The uniform resource indicator of the resource access tokens are being requested for.
/// </param>
/// <param name="clientId">Identifier of the client requesting the token.</param>
/// <param name="resource">
/// Identifier of the target resource that is the recipient of the requested token.
/// </param>
/// <param name="credentials">Optional: user credential to use for token acquisition.</param>
/// <returns>If successful a <see cref="TokenPair"/>; otherwise <see langword="null"/>.</returns>
public async Task<TokenPair> AcquireTokenAsync(Uri targetUri, string clientId, string resource, Credential credentials = null)
{
Debug.Assert(targetUri != null && targetUri.IsAbsoluteUri, "The targetUri parameter is null or invalid");
Debug.Assert(!String.IsNullOrWhiteSpace(clientId), "The clientId parameter is null or empty");
Debug.Assert(!String.IsNullOrWhiteSpace(resource), "The resource parameter is null or empty");
Trace.WriteLine("AzureAuthority::AcquireTokenAsync");
TokenPair tokens = null;
try
{
Trace.WriteLine(String.Format(" authority host url = '{0}'.", AuthorityHostUrl));
UserCredential userCredential = credentials == null ? new UserCredential() : new UserCredential(credentials.Username, credentials.Password);
AuthenticationContext authCtx = new AuthenticationContext(AuthorityHostUrl, _adalTokenCache);
AuthenticationResult authResult = await authCtx.AcquireTokenAsync(resource, clientId, userCredential);
tokens = new TokenPair(authResult);
Trace.WriteLine(" token acquisition succeeded.");
}
catch (AdalException)
{
Trace.WriteLine(" token acquisition failed.");
}
return tokens;
}