/// <summary> /// Authenticate an user and navigate to mainpage if success. /// </summary> public async void AuthenticateUser() { #if WINDOWS_APP var authenticationContext = new AuthenticationContext(AppSettings.AuthenticationUri); AuthenticationResult authResult = await authenticationContext.AcquireTokenAsync( AppSettings.ApiUri.ToString(), AppSettings.ClientId, new Uri(AppSettings.ReplyUri), PromptBehavior.Always, string.Empty); if (authResult.ExpiresOn < DateTime.UtcNow) { authResult = await authenticationContext.AcquireTokenByRefreshTokenAsync(authResult.RefreshToken, AppSettings.ClientId); } if (authResult.Status == AuthenticationStatus.Succeeded) { myCompanyClient.RefreshToken(authResult.AccessToken); AppSettings.SecurityToken = String.Format("Bearer {0}", authResult.AccessToken); AppSettings.SecurityTokenExpirationDateTime = authResult.ExpiresOn; this.navService.NavigateToMainPage(); } #endif }
private async Task<AuthenticationResult> GetAccessToken(string resource) { AuthenticationContext context = new AuthenticationContext(SettingsHelper.AzureADAuthority); var clientCredential = new ClientCredential(SettingsHelper.ClientId, SettingsHelper.ClientSecret); AuthenticationResult result = (AuthenticationResult)this.Session[SettingsHelper.UserTokenCacheKey]; return await context.AcquireTokenByRefreshTokenAsync(result.RefreshToken, clientCredential, resource); }
private async Task <AuthenticationResult> GetAccessToken(string resource, string refresh) { AuthenticationContext context = new AuthenticationContext(SettingsHelper.AzureADAuthority); var clientCredential = new ClientCredential(SettingsHelper.ClientId, SettingsHelper.ClientSecret); return(await context.AcquireTokenByRefreshTokenAsync(refresh, clientCredential, resource)); }
public override async Task <AuthenticationResult> AcquireTokenByRefreshToken(string resource) { await InitializeAuthentication(); var authResult = await authContext.AcquireTokenByRefreshTokenAsync(this.Result.RefreshToken, this.ClientId, resource); return(Convert(authResult)); }
private async Task <AuthenticationResult> GetAccessToken() { AuthenticationContext context = new AuthenticationContext(SettingsHelper.AzureADAuthority); var clientCredential = new ClientCredential(SettingsHelper.ClientId, SettingsHelper.ClientSecret); AuthenticationResult result = (AuthenticationResult)this.Session[SettingsHelper.UserTokenCacheKey]; //return await context.AcquireTokenAsync(SettingsHelper.UnifiedApiResource, clientCredential); //return await context.AcquireTokenByRefreshTokenAsync(result.RefreshToken, clientCredential, SettingsHelper.UnifiedApiResource); return(await context.AcquireTokenByRefreshTokenAsync(result.RefreshToken, clientCredential, "https://api.office.com/discovery/")); }
private async Task <AuthenticationResult> GetAccessToken() { AuthenticationContext context = new AuthenticationContext(SettingsHelper.AzureADAuthority); var clientCredential = new ClientCredential(SettingsHelper.ClientId, SettingsHelper.ClientSecret); // get the Session[User_Token] saved from 'Startup.Auth.cs' AuthenticationResult result = (AuthenticationResult)this.Session[SettingsHelper.UserTokenCacheKey]; return(await context.AcquireTokenByRefreshTokenAsync(result.RefreshToken, clientCredential, SettingsHelper.UnifiedApiResource)); }
public async Task <string> GetTokenForSecondResource(string authority, AuthenticationResult authResult1) { AuthenticationContext authContext = new AuthenticationContext(authority, new FileCache()); var resourceId2 = "https://enterprisedirectory.onmicrosoft.com/0e-d2dbcdb54f6e"; var result = await authContext.AcquireTokenByRefreshTokenAsync(authResult1.RefreshToken, this.authSettings.ClientId, resourceId2); //OfflineTokenValue(authContext); return(result.AccessToken); }
public static async Task <string> GetAccessTokenFromRefreshTokenAsync(string refreshToken) { string authority = string.Format(System.Globalization.CultureInfo.InvariantCulture, aadInstance, "common"); AuthenticationContext authContext = new AuthenticationContext(authority, false); AuthenticationResult authResult = await authContext.AcquireTokenByRefreshTokenAsync( refreshToken, credential, resourceId); return(authResult.AccessToken); }
public static void RefreshToken(SharePointCrawlJobData sharePointCrawlJobData) { string apiVersion = "9.1"; string webApiUrl = $"{sharePointCrawlJobData.Url}/api/data/v{apiVersion}/"; var userCredential = new UserCredential(sharePointCrawlJobData.UserName, sharePointCrawlJobData.Password); var authParameters = AuthenticationParameters.CreateFromResourceUrlAsync(new Uri(webApiUrl)).Result; var authContext = new AuthenticationContext(authParameters.Authority, false); var authResult = authContext.AcquireTokenAsync(authParameters.Resource, sharePointCrawlJobData.ClientId, userCredential).Result; var refreshToken = authContext.AcquireTokenByRefreshTokenAsync(authResult.RefreshToken, sharePointCrawlJobData.ClientId).Result; sharePointCrawlJobData.ApiKey = refreshToken.AccessToken; }
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (_authResult == null) { var authParams = await AuthenticationParameters.CreateFromResourceUrlAsync(_resourceUri); _authContext = new AuthenticationContext(authParams.Authority); _authResult = _authContext.AcquireToken(authParams.Resource, _clientId, _credential); } if (_authResult.ExpiresOn < DateTimeOffset.UtcNow) { _authResult = await _authContext.AcquireTokenByRefreshTokenAsync(_authResult.RefreshToken, _clientId); } request.Headers.Authorization = new AuthenticationHeaderValue(_authResult.AccessTokenType, _authResult.AccessToken); return(await base.SendAsync(request, cancellationToken)); }
static void Main(string[] args) { string authority = string.Format(CultureInfo.InvariantCulture, aadInstance, tenant); AuthenticationContext authContext = new AuthenticationContext(authority); UserCredential uc = new UserCredential("*****@*****.**", "Hqtumc2017"); var result = GetAccessToken(authContext, todoListResourceId, clientId, uc, authority); var token = result.AccessToken; Console.WriteLine(token); token = authContext.AcquireTokenByRefreshTokenAsync(result.RefreshToken, clientId).Result.AccessToken; Console.WriteLine(token); Console.Read(); }
protected async Task <TokenCacheInfo> GetAuthorizationResultByRefreshToken(CustomTokenCache tokenCache, TokenCacheInfo cacheInfo) { var authority = String.Format("{0}/{1}", ARMConfiguration.AADLoginUrl, cacheInfo.TenantId); var context = new AuthenticationContext( authority: authority, validateAuthority: true, tokenCache: tokenCache); AuthenticationResult result = await context.AcquireTokenByRefreshTokenAsync( refreshToken : cacheInfo.RefreshToken, clientId : !string.IsNullOrEmpty(cacheInfo.ClientId)?cacheInfo.ClientId : Constants.AADClientId, resource : cacheInfo.Resource); var ret = new TokenCacheInfo(cacheInfo.Resource, result); ret.TenantId = cacheInfo.TenantId; ret.DisplayableId = cacheInfo.DisplayableId; ret.ClientId = cacheInfo.ClientId; tokenCache.Add(ret); return(ret); }
protected async Task <TokenCacheInfo> GetAuthorizationResultByRefreshToken(CustomTokenCache tokenCache, TokenCacheInfo cacheInfo) { var azureEnvironment = this.AzureEnvironments; var authority = String.Format("{0}/{1}", Constants.AADLoginUrls[(int)azureEnvironment], cacheInfo.TenantId); var context = new AuthenticationContext( authority: authority, validateAuthority: true, tokenCache: tokenCache); AuthenticationResult result = await context.AcquireTokenByRefreshTokenAsync( refreshToken : cacheInfo.RefreshToken, clientId : Constants.AADClientId, resource : cacheInfo.Resource); var ret = new TokenCacheInfo(cacheInfo.Resource, result); ret.TenantId = cacheInfo.TenantId; ret.DisplayableId = cacheInfo.DisplayableId; tokenCache.Add(ret); return(ret); }
/// <summary> /// Gets an Azure access token that can be used to call into the Azure ARM apis. /// </summary> /// <returns>A user token to access Azure ARM</returns> static async Task <string> GetAzureAccessTokenAsync() { if (!string.IsNullOrWhiteSpace(azureToken)) { return(azureToken); } var commonToken = GetCommonAzureAccessToken(); var tenantId = (await GetTenantIdsAsync(commonToken.AccessToken)).FirstOrDefault(); if (string.IsNullOrWhiteSpace(tenantId)) { throw new InvalidOperationException("Unable to get tenant id for user accout"); } var authority = string.Format("https://login.windows.net/{0}/oauth2/authorize", tenantId); var authContext = new AuthenticationContext(authority); var result = await authContext.AcquireTokenByRefreshTokenAsync(commonToken.RefreshToken, clientId, armResource); return(azureToken = result.AccessToken); }
/// <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(TargetUri 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 static async Task <AuthenticationResult> GetAccessToken(this HttpContextBase context, string resource) { AuthenticationResult result = null; try { AuthenticationContext authContext = new AuthenticationContext("https://login.microsoftonline.com/common", false, null); ClientCredential creds = new ClientCredential(CLIENT_ID, CLIENT_SECRET); var refreshToken = context.Request.Cookies["RefreshToken"].Value; result = await authContext.AcquireTokenByRefreshTokenAsync(refreshToken, creds, resource); //save the NEW refresh token (rolling two week expiration) var cookie = new HttpCookie("RefreshToken", result.RefreshToken); cookie.Expires = DateTime.Now.AddDays(14); context.Response.SetCookie(cookie); } catch (Exception) { //swallow exception and allow null result to return } return(result); }
public override async Task <string> LoginAsync(bool clearCache, string authorityId, string redirectUri, string resourceId, string clientId) { var context = new AuthenticationContext(authorityId); var result = await context.AcquireTokenAsync(resourceId, clientId); // Build our token var token = JObject.FromObject(new { access_token = result.AccessToken, }); // Request access to Azure Mobile Services await MobileServiceClientProvider.MobileClient.LoginAsync(MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory, token); var authContext = new AuthenticationContext(ConfigurationHub.ReadConfigurationValue("AadAuthority"), false); // Get the sharepoint token var authenticationResult = await authContext.AcquireTokenByRefreshTokenAsync(result.RefreshToken, ConfigurationHub.ReadConfigurationValue("AadClientID"), ConfigurationHub.ReadConfigurationValue("SharePointResource")); State.SharePointToken = authenticationResult.AccessToken; return(result.AccessToken); }
private async Task <string> GetAzureAccessTokenAsync() { if (!string.IsNullOrWhiteSpace(GetAzureToken())) { return(GetAzureToken()); } var commonToken = GetCommonAzureAccessToken(); var tenantId = (await GetTenantIdsAsync(commonToken.AccessToken)).FirstOrDefault(); if (string.IsNullOrWhiteSpace(tenantId)) { throw new InvalidOperationException("Unable to get tenant id for user account"); } var authority = string.Format("{0}/{1}/oauth2/authorize", GetWindowsLoginUrl(), tenantId); var authContext = new AuthenticationContext(authority); var authenticationResult = await authContext.AcquireTokenByRefreshTokenAsync(commonToken.RefreshToken, clientId, ArmResource); SetAzureToken(authenticationResult); return(authenticationResult.AccessToken); }
/// <summary> /// Get a Microsoft Graph access token from Azure AD. /// </summary> /// <param name="appClientId">Azure AD application client ID</param> /// <returns>An oauth2 access token.</returns> internal async Task <string> GetUserTokenAsync(string appClientId) { // For the first use get an access token prompting the user, after one hour // refresh silently the token if (_tokenForUser == null) { AuthenticationResult userAuthnResult = await _azureAdContext.AcquireTokenAsync(MicrosoftGraphResource, appClientId, new Uri(DefaultRedirectUri), PromptBehavior.Always); _tokenForUser = userAuthnResult.AccessToken; _expiration = userAuthnResult.ExpiresOn; _refreshToken = userAuthnResult.RefreshToken; } if (_expiration <= DateTimeOffset.UtcNow.AddMinutes(5)) { AuthenticationResult userAuthnResult = await _azureAdContext.AcquireTokenByRefreshTokenAsync(_refreshToken, appClientId); _tokenForUser = userAuthnResult.AccessToken; _expiration = userAuthnResult.ExpiresOn; _refreshToken = userAuthnResult.RefreshToken; } return(_tokenForUser); }
internal async Task CheckToken() { if (PowerBIController.authorization == null) { PowerBIController.authorization = await ReadTokenFromStorage(); } if (PowerBIController.authorization == null) { return; } if (DateTime.UtcNow.CompareTo(PowerBIController.authorization.Expires) >= 0) { AuthenticationContext AC = new AuthenticationContext("https://login.windows.net/common/oauth2/authorize/"); ClientCredential cc = new ClientCredential(clientId, clientSecret); var ADALResult = await AC.AcquireTokenByRefreshTokenAsync(PowerBIController.authorization.RefreshToken, cc); PowerBIController.authorization = new AuthResult { Expires = ADALResult.ExpiresOn.UtcDateTime, AccessToken = ADALResult.AccessToken, RefreshToken = ADALResult.RefreshToken }; await WriteTokenToStorage(PowerBIController.authorization); } }
/// <summary> /// POST: api/Messages /// Receive a message from a user and reply to it /// </summary> public async Task <Message> Post([FromBody] Message message) { #region Check Authorization try { string d = (string)message.BotUserData; AuthenticationResult ar = AuthenticationResult.Deserialize(d); AuthenticationContext ac = new AuthenticationContext("https://login.windows.net/common/oauth2/authorize/"); ar = DateTimeOffset.Compare(DateTimeOffset.Now, ar.ExpiresOn) < 0 ? ar : await ac.AcquireTokenByRefreshTokenAsync(ar.RefreshToken, new ClientCredential(Constants.ADClientId, Constants.ADClientSecret)); } catch (Exception ex) { return(message.CreateReplyMessage($"You must authenticate to use bot: https://jehollanVSBot.azurewebsites.net/api/{message.From.Id}/login")); } #endregion if (message.Type == "Message") { #region bot /commands if (Regex.IsMatch(message.Text, Constants.regex_command)) { string command = Regex.Match(message.Text, Constants.regex_command).Groups[1].Value; switch (command.ToLower()) { case "create": return(createCommand(message)); case "topfeatures": return(logicAppCommand(message, "TopFeatures")); case "topbugs": return(logicAppCommand(message, "TopBugs")); case "topcri": return(logicAppCommand(message, "TopCRI")); case "currentsprint": return(logicAppCommand(message, "CurrentSprint")); case "start": return(message.CreateReplyMessage("Please welcome your bot overlord", "en")); case "logout": var getData = await client.Bots.GetUserDataAsync(Constants.botId, message.From.Id); getData.Data = null; await client.Bots.SetUserDataAsync(Constants.botId, message.From.Id, getData); return(message.CreateReplyMessage("You have been logged out")); default: return(message.CreateReplyMessage("Sorry, that's an invalid command", "en")); } } #endregion else { var reply = await Conversation.SendAsync(message, () => new VSTFDialog()); #region Check if I need to go start up a query or create var dialogQuery = reply.GetBotConversationData <QueryItem>("userQuery"); var dialogCreate = reply.GetBotConversationData <TFSItem>("userItem"); if (dialogQuery != null) { reply.SetBotConversationData("userQuery", null); Task.Factory.StartNew(async() => { await getQueryResults(message, dialogQuery); }); } else if (dialogCreate != null) { reply.SetBotConversationData("userItem", null); Task.Factory.StartNew(() => { createTFSItem(message, dialogCreate); }); } #endregion return(reply); } } else { return(HandleSystemMessage(message)); } }
public static async Task <AuthenticationResultProxy> ExecuteAsync(CommandProxy proxy) { AuthenticationResultProxy resultProxy = null; AuthenticationResult result = null; foreach (var command in proxy.Commands) { var arg = command.Arguments; switch (command.CommandType) { case CommandType.ClearDefaultTokenCache: { var dummyContext = new AuthenticationContext("https://dummy/dummy", false); dummyContext.TokenCache.Clear(); break; } case CommandType.SetEnvironmentVariable: { var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings; localSettings.Values[arg.EnvironmentVariable] = arg.EnvironmentVariableValue; break; } case CommandType.SetCorrelationId: { context.CorrelationId = arg.CorrelationId; break; } case CommandType.CreateContextA: { context = new AuthenticationContext(arg.Authority); break; } case CommandType.CreateContextAV: { context = new AuthenticationContext(arg.Authority, arg.ValidateAuthority); break; } case CommandType.CreateContextAVT: { TokenCache tokenCache = null; if (arg.TokenCacheType == TokenCacheType.InMemory) { tokenCache = new TokenCache() { // The default token cache in ADAL WinRT is persistent. This is how to make it in-memory only cache. BeforeAccess = delegate { }, AfterAccess = delegate { } }; } context = new AuthenticationContext(arg.Authority, arg.ValidateAuthority, tokenCache); break; } case CommandType.ClearUseCorporateNetwork: { //context.UseCorporateNetwork = false; break; } case CommandType.SetUseCorporateNetwork: { //context.UseCorporateNetwork = true; break; } case CommandType.AquireTokenAsyncRCUPa: { UserCredential credential = new UserCredential(arg.UserName); result = await context.AcquireTokenAsync(arg.Resource, arg.ClientId, credential); break; } case CommandType.AquireTokenAsyncRCRe: { result = await context.AcquireTokenAsync(arg.Resource, arg.ClientId, arg.RedirectUri); break; } case CommandType.AquireTokenAsyncRCRePUX: { result = await context.AcquireTokenAsync(arg.Resource, arg.ClientId, arg.RedirectUri, (arg.PromptBehavior == PromptBehaviorProxy.Always)?PromptBehavior.Always : (arg.PromptBehavior == PromptBehaviorProxy.Never)?PromptBehavior.Never : PromptBehavior.Auto, (arg.UserName != null)?new UserIdentifier(arg.UserName, UserIdentifierType.OptionalDisplayableId) : UserIdentifier.AnyUser, arg.Extra); break; } case CommandType.AquireTokenAsyncRCReP: { result = await context.AcquireTokenAsync(arg.Resource, arg.ClientId, arg.RedirectUri, (arg.PromptBehavior == PromptBehaviorProxy.Always)?PromptBehavior.Always : (arg.PromptBehavior == PromptBehaviorProxy.Never)?PromptBehavior.Never : PromptBehavior.Auto); break; } case CommandType.AquireTokenAsyncRCRePU: { result = await context.AcquireTokenAsync(arg.Resource, arg.ClientId, arg.RedirectUri, (arg.PromptBehavior == PromptBehaviorProxy.Always)?PromptBehavior.Always : (arg.PromptBehavior == PromptBehaviorProxy.Never)?PromptBehavior.Never : PromptBehavior.Auto, (arg.UserName != null)?new UserIdentifier(arg.UserName, UserIdentifierType.OptionalDisplayableId) : UserIdentifier.AnyUser); break; } case CommandType.AcquireTokenByRefreshTokenAsyncRC: { result = await context.AcquireTokenByRefreshTokenAsync(arg.RefreshToken, arg.ClientId); break; } case CommandType.AcquireTokenByRefreshTokenAsyncRCRe: { result = await context.AcquireTokenByRefreshTokenAsync(arg.RefreshToken, arg.ClientId, arg.Resource); break; } case CommandType.CreateFromResourceUrlAsync: { var parameters = await AuthenticationParameters.CreateFromResourceUrlAsync(new Uri(arg.Extra)); resultProxy = new AuthenticationResultProxy { AuthenticationParametersAuthority = parameters.Authority, AuthenticationParametersResource = parameters.Resource }; break; } case CommandType.CreateFromResponseAuthenticateHeader: { var parameters = AuthenticationParameters.CreateFromResponseAuthenticateHeader(arg.Extra); resultProxy = new AuthenticationResultProxy { AuthenticationParametersAuthority = parameters.Authority, AuthenticationParametersResource = parameters.Resource }; break; } /*case CommandType.AcquireTokenByRefreshTokenAsyncRCC: * { * result = await context.AcquireTokenByRefreshTokenAsync(arg.RefreshToken, arg.ClientId, * (arg.ClientId != null && arg.ClientSecret != null) ? new ClientCredential(arg.ClientId, arg.ClientSecret) : null); * break; * }*/ default: throw new Exception("Unknown command"); } } return(resultProxy ?? new AuthenticationResultProxy { AccessToken = result.AccessToken, AccessTokenType = result.AccessTokenType, ExpiresOn = result.ExpiresOn, IsMultipleResourceRefreshToken = result.IsMultipleResourceRefreshToken, RefreshToken = result.RefreshToken, IdToken = result.IdToken, TenantId = result.TenantId, UserInfo = result.UserInfo, Error = result.Error, ErrorDescription = result.ErrorDescription, Status = (result.Status == AuthenticationStatus.Success) ? AuthenticationStatusProxy.Success : ((result.Status == AuthenticationStatus.ClientError) ? AuthenticationStatusProxy.ClientError : AuthenticationStatusProxy.ServiceError) }); }
/// <summary> /// Initializes a new instance of the <see cref="TokenDetailsPage"/> class. /// </summary> public TokenDetailsPage(AuthenticationContext authCtx, TokenCacheItem token) { Button refresh, clear; Label time; this.Title = "Token Details"; this.Content = new StackLayout { Padding = 20, Spacing = 20, Children = { new Label { Text = token.DisplayableId }, new Label { Text = token.UniqueId }, (time = new Label { Text = token.ExpiresOn.ToLocalTime().ToString(), TextColor = token.ExpiresOn.ToUniversalTime() > DateTimeOffset.UtcNow ? Color.Green : Color.Red }), (refresh = new Button { Text = "Refresh", TextColor = Color.White, BackgroundColor = Color.FromHex("77D065"), }), (clear = new Button { Text = "Delete token", TextColor = Color.White, BackgroundColor = Color.FromHex("77D065"), }), }, }; refresh.Clicked += async(sender, args) => { this.IsBusy = true; try { var errorMessage = string.Empty; try { var accessToken = await authCtx.AcquireTokenSilentAsync(new UserIdentifier(token.UniqueId, UserIdentifierType.UniqueId)); accessToken = await authCtx.AcquireTokenByRefreshTokenAsync(accessToken); time.Text = accessToken.ExpiresOn.ToLocalTime().ToString(); time.TextColor = Color.Green; } catch (AuthenticationException e) { errorMessage = e.Message; } if (!string.IsNullOrEmpty(errorMessage)) { await this.DisplayAlert("Sign-in failed", errorMessage, "OK"); } } finally { this.IsBusy = false; } }; clear.Clicked += (sender, args) => { authCtx.TokenCache.DeleteItem(token); this.Navigation.PopAsync(); }; }