/// <summary> /// Checks that a SharePoint client is available to the client. /// </summary> /// <returns>The SharePoint Online client.</returns> public static async Task <SharePointClient> EnsureSharePointClientCreatedAsync() { try { AuthenticationContext = new AuthenticationContext(CommonAuthority); if (AuthenticationContext.TokenCache.ReadItems().Count() > 0) { // Bind the AuthenticationContext to the authority that sourced the token in the cache // this is needed for the cache to work when asking for a token from that authority // (the common endpoint never triggers cache hits) string cachedAuthority = AuthenticationContext.TokenCache.ReadItems().First().Authority; AuthenticationContext = new AuthenticationContext(cachedAuthority); } // Create a DiscoveryClient using the discovery endpoint Uri. DiscoveryClient discovery = new DiscoveryClient(DiscoveryServiceEndpointUri, async() => await AcquireTokenAsync(AuthenticationContext, DiscoveryResourceId)); // Now get the capability that you are interested in. CapabilityDiscoveryResult result = await discovery.DiscoverCapabilityAsync("MyFiles"); var client = new SharePointClient( result.ServiceEndpointUri, async() => await AcquireTokenAsync(AuthenticationContext, result.ServiceResourceId)); return(client); } catch (DiscoveryFailedException dfe) { MessageDialogHelper.DisplayException(dfe as Exception); // Discovery failed. AuthenticationContext.TokenCache.Clear(); return(null); } catch (MissingConfigurationValueException mcve) { MessageDialogHelper.DisplayException(mcve); // Connected services not added correctly, or permissions not set correctly. AuthenticationContext.TokenCache.Clear(); return(null); } catch (AuthenticationFailedException afe) { MessageDialogHelper.DisplayException(afe); // Failed to authenticate the user AuthenticationContext.TokenCache.Clear(); return(null); } catch (ArgumentException ae) { MessageDialogHelper.DisplayException(ae as Exception); // Argument exception AuthenticationContext.TokenCache.Clear(); return(null); } }
private async void Button_Click(object sender, RoutedEventArgs e) { Uri spSiteUri; try { //Validate that the input is at least a well-formed URI spSiteUri = new Uri(spSite.Text); await AuthenticationHelper.EnsureAccessTokenAvailableAsync(spSiteUri.AbsoluteUri); this.Frame.Navigate(typeof(ItemsPage)); } catch (FormatException fe) { // Tell the user that the authentication failed MessageDialogHelper.DisplayException(fe); return; } catch (AuthenticationFailedException afe) { // Tell the user that the authentication failed MessageDialogHelper.DisplayException(afe); return; } }
/// <summary> /// Checks that an OutlookServicesClient object is available. /// </summary> /// <returns>The OutlookServicesClient object. </returns> public static async Task <OutlookServicesClient> EnsureOutlookClientCreatedAsync(string capability) { //Check to see if this client has already been created. If so, return it. Otherwise, create a new one. if (_outlookClient != null) { return(_outlookClient); } else { try { // Now get the capability that you are interested in. CapabilityDiscoveryResult result = await GetDiscoveryCapabilityResultAsync(capability); _outlookClient = new OutlookServicesClient( result.ServiceEndpointUri, async() => await GetTokenHelperAsync(_authenticationContext, result.ServiceResourceId)); return(_outlookClient); } // The following is a list of all exceptions you should consider handling in your app. // In the case of this sample, the exceptions are handled by returning null upstream. catch (DiscoveryFailedException dfe) { MessageDialogHelper.DisplayException(dfe as Exception); // Discovery failed. _authenticationContext.TokenCache.Clear(); return(null); } catch (MissingConfigurationValueException mcve) { MessageDialogHelper.DisplayException(mcve); // Connected services not added correctly, or permissions not set correctly. _authenticationContext.TokenCache.Clear(); return(null); } catch (AuthenticationFailedException afe) { MessageDialogHelper.DisplayException(afe); // Failed to authenticate the user _authenticationContext.TokenCache.Clear(); return(null); } catch (ArgumentException ae) { MessageDialogHelper.DisplayException(ae as Exception); // Argument exception _authenticationContext.TokenCache.Clear(); return(null); } } }
/// <summary> /// Checks that a SharePoint client is available to the client. /// </summary> /// <returns>The SharePoint Online client.</returns> public static async Task <SharePointClient> EnsureSharePointClientCreatedAsync() { //Check to see if this client has already been created. If so, return it. Otherwise, create a new one. if (_sharePointClient != null) { return(_sharePointClient); } else { try { // Now get the capability that you are interested in. CapabilityDiscoveryResult result = await GetDiscoveryCapabilityResultAsync("MyFiles"); _sharePointClient = new SharePointClient( result.ServiceEndpointUri, async() => await GetTokenHelperAsync(_authenticationContext, result.ServiceResourceId)); return(_sharePointClient); } catch (DiscoveryFailedException dfe) { MessageDialogHelper.DisplayException(dfe as Exception); // Discovery failed. _authenticationContext.TokenCache.Clear(); return(null); } catch (MissingConfigurationValueException mcve) { MessageDialogHelper.DisplayException(mcve); // Connected services not added correctly, or permissions not set correctly. _authenticationContext.TokenCache.Clear(); return(null); } catch (AuthenticationFailedException afe) { MessageDialogHelper.DisplayException(afe); // Failed to authenticate the user _authenticationContext.TokenCache.Clear(); return(null); } catch (ArgumentException ae) { MessageDialogHelper.DisplayException(ae as Exception); // Argument exception _authenticationContext.TokenCache.Clear(); return(null); } } }
private async void sendRequest_Click(object sender, RoutedEventArgs e) { // The access token may have expired. // By calling the EnsureAccessTokenAvailableAsync we ensure that it is still valid, // or we can get another one. await AuthenticationHelper.EnsureAccessTokenAvailableAsync(); try { // Update the headers data source BindingExpression headersBindingExpression = requestHeadersText.GetBindingExpression(TextBox.TextProperty); headersBindingExpression.UpdateSource(); } catch (Exception ex) { // The headers data is not a well-formed JSON string FormatException fe = new FormatException(ex.Message); MessageDialogHelper.DisplayException(fe); return; } try { // Update the body data source BindingExpression bodyBindingExpression = requestBodyText.GetBindingExpression(TextBox.TextProperty); bodyBindingExpression.UpdateSource(); } catch (Exception ex) { InvalidOperationException ioe = new InvalidOperationException(ex.Message); MessageDialogHelper.DisplayException(ioe); return; } // There are no errors that stop us from sending the request. // Create a new response item and assign it to the current item in the data source var selectedItem = (DataItem)itemsViewSource.View.CurrentItem; selectedItem.Response = await DataSource.GetResponseAsync(selectedItem.Request); // Show the Response UI VisualStateManager.GoToState(this, "ResponseView", true); }
/// <summary> /// Checks that a Graph client is available. /// </summary> /// <returns>The Graph client.</returns> public static async Task <ActiveDirectoryClient> EnsureGraphClientCreatedAsync() { // Active Directory service endpoints const string AadServiceResourceId = "https://graph.windows.net/"; Uri AadServiceEndpointUri = new Uri("https://graph.windows.net/"); try { AuthenticationContext = new AuthenticationContext(CommonAuthority); TokenCacheItem cacheItem = null; if (AuthenticationContext.TokenCache.ReadItems().Count() > 0) { // Bind the AuthenticationContext to the authority that sourced the token in the cache // this is needed for the cache to work when asking for a token from that authority // (the common endpoint never triggers cache hits) cacheItem = AuthenticationContext.TokenCache.ReadItems().First(); AuthenticationContext = new AuthenticationContext(cacheItem.Authority); } else { // Nothing was found in the cache, so let's acquire a token. var token = await AcquireTokenAsync(AuthenticationContext, AadServiceResourceId); // Check the token if (String.IsNullOrEmpty(token)) { // User cancelled sign-in return(null); } else { // If a token was acquired, the TokenCache will contain a TokenCacheItem containing // all the details of the authorization. cacheItem = AuthenticationContext.TokenCache.ReadItems().First(); } } // Store the Id of the logged-in user so that we can retrieve more user info later. _loggedInUser = cacheItem.UniqueId; // Create our ActiveDirectory client. var client = new ActiveDirectoryClient( new Uri(AadServiceEndpointUri, cacheItem.TenantId), async() => await AcquireTokenAsync(AuthenticationContext, AadServiceResourceId)); return(client); } // The following is a list of all exceptions you should consider handling in your app. // In the case of this sample, the exceptions are handled by returning null upstream. catch (DiscoveryFailedException dfe) { MessageDialogHelper.DisplayException(dfe as Exception); // Discovery failed. AuthenticationContext.TokenCache.Clear(); return(null); } catch (MissingConfigurationValueException mcve) { MessageDialogHelper.DisplayException(mcve); // Connected services not added correctly, or permissions not set correctly. AuthenticationContext.TokenCache.Clear(); return(null); } catch (AuthenticationFailedException afe) { MessageDialogHelper.DisplayException(afe); // Failed to authenticate the user AuthenticationContext.TokenCache.Clear(); return(null); } catch (ArgumentException ae) { MessageDialogHelper.DisplayException(ae as Exception); // Argument exception AuthenticationContext.TokenCache.Clear(); return(null); } }
/// <summary> /// Checks that a Graph client is available. /// </summary> /// <returns>The Graph client.</returns> public static async Task <ActiveDirectoryClient> EnsureGraphClientCreatedAsync() { //Check to see if this client has already been created. If so, return it. Otherwise, create a new one. if (_graphClient != null) { return(_graphClient); } else { // Active Directory service endpoints const string AadServiceResourceId = "https://graph.windows.net/"; Uri AadServiceEndpointUri = new Uri("https://graph.windows.net/"); try { //First, look for the authority used during the last authentication. //If that value is not populated, use CommonAuthority. string authority = null; if (String.IsNullOrEmpty(LastAuthority)) { authority = CommonAuthority; } else { authority = LastAuthority; } // Create an AuthenticationContext using this authority. _authenticationContext = new AuthenticationContext(authority); // Set the value of _authenticationContext.UseCorporateNetwork to true so that you // can use this app inside a corporate intranet. If the value of UseCorporateNetwork // is true, you also need to add the Enterprise Authentication, Private Networks, and // Shared User Certificates capabilities in the Package.appxmanifest file. _authenticationContext.UseCorporateNetwork = true; var token = await GetTokenHelperAsync(_authenticationContext, AadServiceResourceId); // Check the token if (String.IsNullOrEmpty(token)) { // User cancelled sign-in return(null); } else { // Create our ActiveDirectory client. _graphClient = new ActiveDirectoryClient( new Uri(AadServiceEndpointUri, TenantId), async() => await GetTokenHelperAsync(_authenticationContext, AadServiceResourceId)); return(_graphClient); } } catch (Exception e) { MessageDialogHelper.DisplayException(e as Exception); // Argument exception _authenticationContext.TokenCache.Clear(); return(null); } } }