private void btnLogin_Click(object sender, RoutedEventArgs e)
{
// for reference: if you ever need to get the correct callbackUri
// for your app
// var callbackUri = WebAuthenticationBroker.GetCurrentApplicationCallbackUri();
var client = new OAuth2Client(
new Uri(ExpenseTrackerConstants.IdSrvAuthorize));
string nonce = Guid.NewGuid().ToString() + DateTime.Now.Ticks.ToString();
var startUrl = client.CreateAuthorizeUrl(
"native",
"id_token token",
"openid roles expensetrackerapi",
ExpenseTrackerConstants.ExpenseTrackerMobile,
"state", nonce);
WebAuthenticationBroker.AuthenticateAndContinue
(
new Uri(startUrl),
new Uri(ExpenseTrackerConstants.ExpenseTrackerMobile),
null,
WebAuthenticationOptions.None);
}
/// <summary>
/// Begins a server-side authentication flow by navigating the
/// <see cref="WebAuthenticationBroker"/> to the <paramref name="startUrl"/>.
/// Considers if the <paramref name="useSingleSignOn"/> is being used and calls the
/// correct overload of the <see cref="WebAuthenticationBroker"/>.
/// </summary>
/// <param name="startUrl">The URL that the browser-based control should
/// first navigate to in order to start the authenication flow.
/// </param>
/// <param name="endUrl">The URL that indicates the authentication flow has
/// completed. Upon being redirected to any URL that starts with the
/// <paramref name="endUrl"/>, the browser-based control must stop navigating and
/// return the response data to the <see cref="AuthenticationBroker"/>.
/// </param>
/// <param name="useSingleSignOn">Indicates if single sign-on should be used so
/// that users do not have to re-enter his/her credentials every time.
/// </param>
/// <returns>
/// The <see cref="WebAuthenticationResult"/> returned by the
/// <see cref="WebAuthenticationBroker"/>.
/// </returns>
private Task <string> AuthenticateWithBroker(Uri startUrl, Uri endUrl, bool useSingleSignOn)
{
Debug.Assert(startUrl != null);
Debug.Assert(endUrl != null);
if (pendingLoginTask != null)
{
throw new InvalidOperationException(Resources.IAuthenticationBroker_LoginInProgress);
}
pendingLoginTask = new TaskCompletionSource <string>();
if (useSingleSignOn)
{
Uri ssoEndUri = WebAuthenticationBroker.GetCurrentApplicationCallbackUri();
Uri ssoStartUrl = GetUrlWithQueryStringParameter(startUrl, "sso_end_uri", ssoEndUri.AbsoluteUri);
WebAuthenticationBroker.AuthenticateAndContinue(ssoStartUrl, null, null, WebAuthenticationOptions.None);
}
else
{
WebAuthenticationBroker.AuthenticateAndContinue(startUrl, endUrl, null, WebAuthenticationOptions.None);
}
return(pendingLoginTask.Task);
}
private async Task Login()
{
//Client ID of the Facebook App (retrieved from the Facebook Developers portal)
//Required permissions
var scope = "public_profile, email";
var redirectUri = WebAuthenticationBroker.GetCurrentApplicationCallbackUri().ToString();
var fb = new FacebookClient();
var loginUrl = fb.GetLoginUrl(new
{
client_id = ClientId,
redirect_uri = redirectUri,
response_type = "token",
scope = scope
});
Uri startUri = loginUrl;
Uri endUri = new Uri(redirectUri, UriKind.Absolute);
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(startUri, endUri, null, WebAuthenticationOptions.None);
#endif
#if WINDOWS_APP
WebAuthenticationResult result = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, startUri, endUri);
await ParseAuthenticationResult(result);
#endif
}
/// <summary>
/// Authenticates a user to enable the user data APIs.
/// </summary>
/// <param name="client">The MixRadio client.</param>
/// <param name="clientSecret">The client secret obtained during app registration</param>
/// <param name="scopes">The scopes requested.</param>
/// <param name="oauthRedirectUri">The OAuth completed URI.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation</param>
/// <returns>
/// An AuthResultCode value indicating the result
/// </returns>
/// <remarks>
/// Sorry, this method is messy due to the platform differences!
/// </remarks>
public static async Task <AuthResultCode> AuthenticateUserAsync(this MusicClient client, string clientSecret, Scope scopes, string oauthRedirectUri = MusicClient.DefaultOAuthRedirectUri, CancellationToken?cancellationToken = null)
{
if (string.IsNullOrEmpty(oauthRedirectUri))
{
throw new ArgumentNullException("oauthRedirectUri", "You must supply your OAuth Redirect URI to allow user interaction");
}
if (string.IsNullOrEmpty(clientSecret))
{
throw new ArgumentNullException("clientSecret", "You must supply your app client secret obtained during app registration");
}
// See if we have a cached token...
AuthResultCode cachedResult = await AuthenticateUserAsync(client, clientSecret, cancellationToken).ConfigureAwait(false);
if (cachedResult == AuthResultCode.Success)
{
return(cachedResult);
}
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(client.GetAuthenticationUri(scopes), new Uri(oauthRedirectUri));
return(AuthResultCode.InProgress);
#elif WINDOWS_APP
var authResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, client.GetAuthenticationUri(scopes), new Uri(oauthRedirectUri));
return(await CompleteAuthenticateUserAsync(client, clientSecret, authResult, cancellationToken));
#endif
}
/// <summary>
/// Execute login process through OAuth2 authentication mechanism
/// (https://developer.gitter.im/docs/authentication)
/// </summary>
/// <returns>true: login success / false: login failed / null: exception occured</returns>
public async Task <bool?> LoginAsync(string oauthKey, string oauthSecret)
{
try
{
#if WINDOWS_PHONE_APP
_oauthKey = oauthKey;
_oauthSecret = oauthSecret;
#endif
string startUrl = $"https://gitter.im/login/oauth/authorize?client_id={oauthKey}&response_type=code&redirect_uri={AuthHelper.RedirectUrl}";
var startUri = new Uri(startUrl);
var endUri = new Uri(AuthHelper.RedirectUrl);
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(startUri, endUri, null, WebAuthenticationOptions.None);
return(await Task.FromResult <bool?>(null));
#endif
#if WINDOWS_APP
var webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, startUri, endUri);
_token = await AuthHelper.RetrieveToken(webAuthenticationResult, oauthKey, oauthSecret);
return(!string.IsNullOrWhiteSpace(_token));
#endif
}
catch
{
return(null);
}
}
private void btnLogin_Click(object sender, RoutedEventArgs e)
{
// for reference: if you ever need to get the correct callbackUri
// for your app
// var callbackUri = WebAuthenticationBroker.GetCurrentApplicationCallbackUri();
var client = new OAuth2Client(
new Uri(ExpenseTrackerConstants.IdSrvAuthorizeWp));
string nonce = Guid.NewGuid().ToString() + DateTime.Now.Ticks.ToString();
var startUrl = client.CreateAuthorizeUrl(
"native", //this client corresponds to client config on id srv level
"id_token token", //Request an id token + access token
"openid roles expensetrackerapi", //the access token should contain the id and roles scope
//will call the user info end point for this
//We no longer use the authorization code as this does not belong to the implicit flow
//The WP client isn't a confidential client...
//If you do ask for the authorization code, this flow will fail.
//Ask for the expensetrackerapi scope to get it included in the access token
ExpenseTrackerConstants.ExpenseTrackerMobile,
"state", //With state you can pass through values
nonce); //Number only used once, this is used by the STS to prevent replay attacks
WebAuthenticationBroker.AuthenticateAndContinue
(
new Uri(startUrl),
new Uri(ExpenseTrackerConstants.ExpenseTrackerMobile),
null,
WebAuthenticationOptions.None);
}
protected override void OnElementChanged(ElementChangedEventArgs <Page> e)
{
base.OnElementChanged(e);
var app = (MixRadioActivity.App.Current as MixRadioActivity.App);
WebAuthenticationBroker.AuthenticateAndContinue(app.ActivityViewModel.GetAuthUri(), new Uri(ApiKeys.OAuthRedirectUrl));
}
public void StartLoginFlow(LoginOptions loginOptions)
{
Uri loginUri = new Uri(OAuth2.ComputeAuthorizationUrl(loginOptions));
Uri callbackUri = new Uri(loginOptions.CallbackUrl);
OAuth2.ClearCookies(loginOptions);
WebAuthenticationBroker.AuthenticateAndContinue(loginUri, callbackUri, null, WebAuthenticationOptions.None);
}
private void LaunchAuthentication()
{
var url = _vidMeClient.GetAuthUrl(Constants.ClientId, Constants.CallBackUrl, new List <Scope> {
Scope.Videos, Scope.VideoUpload, Scope.Channels, Scope.Comments, Scope.Votes, Scope.Account, Scope.AuthManagement, Scope.ClientManagement
});
WebAuthenticationBroker.AuthenticateAndContinue(new Uri(url), new Uri(Constants.CallBackUrl), new ValueSet(), WebAuthenticationOptions.None);
}
private async void Launch_Click(object sender, RoutedEventArgs e)
#endif
{
if (TwitterClientID.Text == "")
{
rootPage.NotifyUser("Please enter an Client ID.", NotifyType.StatusMessage);
}
else if (TwitterCallbackUrl.Text == "")
{
rootPage.NotifyUser("Please enter an Callback URL.", NotifyType.StatusMessage);
}
else if (TwitterClientSecret.Text == "")
{
rootPage.NotifyUser("Please enter an Client Secret.", NotifyType.StatusMessage);
}
try
{
string oauth_token = await GetTwitterRequestTokenAsync(TwitterCallbackUrl.Text, TwitterClientID.Text);
string TwitterUrl = "https://api.twitter.com/oauth/authorize?oauth_token=" + oauth_token;
System.Uri StartUri = new Uri(TwitterUrl);
System.Uri EndUri = new Uri(TwitterCallbackUrl.Text);
// DebugPrint("Navigating to: " + TwitterUrl);
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(StartUri, EndUri, null, WebAuthenticationOptions.None);
#else
WebAuthenticationResult WebAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(
WebAuthenticationOptions.None,
StartUri,
EndUri);
if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
{
OutputToken(WebAuthenticationResult.ResponseData.ToString());
await GetTwitterUserNameAsync(WebAuthenticationResult.ResponseData.ToString());
}
else if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.ErrorHttp)
{
OutputToken("HTTP Error returned by AuthenticateAsync() : " + WebAuthenticationResult.ResponseErrorDetail.ToString());
}
else
{
OutputToken("Error returned by AuthenticateAsync() : " + WebAuthenticationResult.ResponseStatus.ToString());
}
#endif
}
catch (Exception Error)
{
//
// Bad Parameter, SSL/TLS Errors and Network Unavailable errors are to be handled here.
//
DebugPrint(Error.ToString());
}
}
/// <summary>
/// This method will be for logout from facebook
/// </summary>
public void FacebookLogout()
{
var _logoutUrl = GlobalVariable.fbclient.GetLogoutUrl(new
{
next = "https://www.facebook.com/connect/login_success.html",
access_token = GlobalVariable.FbAccessToken
});
WebAuthenticationBroker.AuthenticateAndContinue(_logoutUrl);
}
private async void BtnFaceBookLogout_Click(object sender, RoutedEventArgs e)
{
_logoutUrl = fbclient.GetLogoutUrl(new
{
next = "https://www.facebook.com/connect/login_success.html",
access_token = ObjFBHelper.AccessToken
});
WebAuthenticationBroker.AuthenticateAndContinue(_logoutUrl);
BtnLogin.Visibility = Visibility.Visible;
BtnLogout.Visibility = Visibility.Collapsed;
}
/// <summary>
/// Startes the authorization process which will continue through an app
/// activation.
/// </summary>
public static void AuthorizeAndContinue()
{
var authUri = DropboxOAuth2Helper.GetAuthorizeUri(
OAuthResponseType.Token,
App.AppKey,
App.RedirectUri);
WebAuthenticationBroker.AuthenticateAndContinue(
authUri,
App.RedirectUri);
}
public virtual void RequestAuthorizationCode()
{
var param = string.Format(PARAM_TEMPLATE, config.scope, Uri.EscapeDataString(config.redirectURL), Uri.EscapeDataString(config.clientId));
var uri = new Uri(config.baseURL + config.authzEndpoint).AbsoluteUri + param;
var values = new ValueSet()
{
{ "name", config.accountId }
};
WebAuthenticationBroker.AuthenticateAndContinue(new Uri(uri), new Uri(config.redirectURL), values, WebAuthenticationOptions.None);
}
private async void Launch_Click(object sender, RoutedEventArgs e)
#endif
{
if (GoogleClientID.Text == "")
{
rootPage.NotifyUser("Please enter an Client ID.", NotifyType.StatusMessage);
}
else if (GoogleCallbackUrl.Text == "")
{
rootPage.NotifyUser("Please enter an Callback URL.", NotifyType.StatusMessage);
}
try
{
String GoogleURL = "https://accounts.google.com/o/oauth2/auth?client_id=" + Uri.EscapeDataString(GoogleClientID.Text) + "&redirect_uri=" + Uri.EscapeDataString(GoogleCallbackUrl.Text) + "&response_type=code&scope=" + Uri.EscapeDataString("http://picasaweb.google.com/data");
System.Uri StartUri = new Uri(GoogleURL);
// When using the desktop flow, the success code is displayed in the html title of this end uri
System.Uri EndUri = new Uri("https://accounts.google.com/o/oauth2/approval?");
DebugPrint("Navigating to: " + GoogleURL);
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(StartUri, EndUri, null, WebAuthenticationOptions.None);
#else
WebAuthenticationResult WebAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(
WebAuthenticationOptions.UseTitle,
StartUri,
EndUri);
if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
{
OutputToken(WebAuthenticationResult.ResponseData.ToString());
}
else if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.ErrorHttp)
{
OutputToken("HTTP Error returned by AuthenticateAsync() : " + WebAuthenticationResult.ResponseErrorDetail.ToString());
}
else
{
OutputToken("Error returned by AuthenticateAsync() : " + WebAuthenticationResult.ResponseStatus.ToString());
}
#endif
}
catch (Exception Error)
{
//
// Bad Parameter, SSL/TLS Errors and Network Unavailable errors are to be handled here.
//
DebugPrint(Error.ToString());
}
}
public async Task LoginAndContinue()
{
if (DeviceTypeHelper.GetDeviceFormFactorType() == DeviceFormFactorType.Desktop)
{
WebAuthenticationResult result = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, _loginUrl);
ValidateAndProccessResult(result);
}
else
{
WebAuthenticationBroker.AuthenticateAndContinue(_loginUrl);
}
}
private async void Launch_Click(object sender, RoutedEventArgs e)
#endif
{
if (FacebookClientID.Text == "")
{
rootPage.NotifyUser("Please enter an Client ID.", NotifyType.StatusMessage);
}
else if (FacebookCallbackUrl.Text == "")
{
rootPage.NotifyUser("Please enter an Callback URL.", NotifyType.StatusMessage);
}
try
{
String FacebookURL = "https://www.facebook.com/dialog/oauth?client_id=" + Uri.EscapeDataString(FacebookClientID.Text) + "&redirect_uri=" + Uri.EscapeDataString(FacebookCallbackUrl.Text) + "&scope=read_stream&display=popup&response_type=token";
System.Uri StartUri = new Uri(FacebookURL);
System.Uri EndUri = new Uri(FacebookCallbackUrl.Text);
DebugPrint("Navigating to: " + FacebookURL);
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(StartUri, EndUri, null, WebAuthenticationOptions.None);
#else
WebAuthenticationResult WebAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(
WebAuthenticationOptions.None,
StartUri,
EndUri);
if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
{
OutputToken(WebAuthenticationResult.ResponseData.ToString());
await GetFacebookUserNameAsync(WebAuthenticationResult.ResponseData.ToString());
}
else if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.ErrorHttp)
{
OutputToken("HTTP Error returned by AuthenticateAsync() : " + WebAuthenticationResult.ResponseErrorDetail.ToString());
}
else
{
OutputToken("Error returned by AuthenticateAsync() : " + WebAuthenticationResult.ResponseStatus.ToString());
}
#endif
}
catch (Exception Error)
{
//
// Bad Parameter, SSL/TLS Errors and Network Unavailable errors are to be handled here.
//
DebugPrint(Error.ToString());
}
}
// http://msdn.microsoft.com/ja-jp/library/dn631755.aspx
// http://dotnet.dzone.com/articles/how-use
// http://www.cloudidentity.com/blog/2014/04/16/calling-office365-api-from-a-windows-phone-8-1-app/
// http://msicc.net/?p=4054
private void RedirectToAuthButton_Click(object sender, RoutedEventArgs e)
{
if (this.requestToken != null)
{
var redirectUrl = this.twitterOAuth.GetRedirectAuthUrl(this.requestToken);
this.WriteLog(String.Format("Redirect URI:{0}", redirectUrl));
Uri StartUri = new Uri(redirectUrl);
Uri EndUri = new Uri(TwitterOAuthConstants.OAuthCallbackUrl);
//WebAuthenticationBroker.AuthenticateAndContinue(StartUri, EndUri, null, WebAuthenticationOptions.None);
WebAuthenticationBroker.AuthenticateAndContinue(StartUri, EndUri);
}
}
private async Task ReadabilityAuthentication()
{
try
{
await _readabilityClient.GetRequestTokenAsync(Constants.Readability.CallBackUri);
}
catch (Exception ex)
{
Log.ErrorException("ReadabilityAuthentication()", ex);
return;
}
var authUri = _readabilityClient.GenerateAuthenticationUri();
WebAuthenticationBroker.AuthenticateAndContinue(authUri, new Uri(Constants.Readability.CallBackUri), new ValueSet(), WebAuthenticationOptions.None);
}
public async Task <Session> LoginAsync()
{
const string FacebookCallbackUrl = "https://m.facebook.com/connect/login_success.html";
var facebookUrl = "https://www.facebook.com/dialog/oauth?client_id=" + Uri.EscapeDataString(Constants.FacebookAppId) + "&redirect_uri=" + Uri.EscapeDataString(FacebookCallbackUrl) + "&scope=public_profile,email&display=popup&response_type=token";
var startUri = new Uri(facebookUrl);
var endUri = new Uri(FacebookCallbackUrl);
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(startUri, endUri, null, WebAuthenticationOptions.None);
return(null);
#else
var webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, startUri, endUri);
return(GetSession(webAuthenticationResult));
#endif
}
public void Authenticate(Uri authorizationUri, Uri redirectUri, IDictionary <string, object> headersMap, CallState callState)
{
ValueSet set = new ValueSet();
foreach (string key in headersMap.Keys)
{
set[key] = headersMap[key];
}
try
{
WebAuthenticationBroker.AuthenticateAndContinue(authorizationUri, ReferenceEquals(redirectUri, Constant.SsoPlaceHolderUri) ? null : redirectUri, set, WebAuthenticationOptions.None);
}
catch (Exception ex)
{
throw new AdalException(AdalError.AuthenticationUiFailed, ex);
}
}
private void ProfileImage_Tapped(object sender, TappedRoutedEventArgs e)
{
FacebookClient fbclient = new FacebookClient();
_logoutUrl = fbclient.GetLogoutUrl(new
{
next = "https://www.facebook.com/connect/login_success.html",
access_token = App.ObjFBHelper.AccessToken,
// redirect_uri = App.ObjFBHelper._callbackUri.AbsoluteUri,
});
ProfileHelpers.IsLogin = false;
ProfileHelpers.ProfileImage = "";
WebAuthenticationBroker.AuthenticateAndContinue(_logoutUrl);
// Frame.Navigate(typeof(Login));
//BtnLogin.Visibility = Visibility.Visible;
//BtnLogout.Visibility = Visibility.Collapsed;
}
/// <summary>
/// The dispatcher tick.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The event args</param>
/// <remarks>http://stackoverflow.com/questions/23267918</remarks>
private async void DispatcherTick(object sender, object e)
{
_dispatcherTimer.Stop();
var token = await IsolatedStorage.GetToken();
if (!string.IsNullOrEmpty(token))
{
((Frame)Window.Current.Content).Navigate(typeof(RoomsPage));
return;
}
var gitterUrl = string.Format("{0}{1}?response_type=code&redirect_uri={2}&client_id={3}", Constants.GitterBaseAddress, Constants.AuthEndPoint, Constants.RedirectUrl, Constants.ClientKey);
var startUri = new Uri(gitterUrl);
var endUri = new Uri(Constants.RedirectUrl);
WebAuthenticationBroker.AuthenticateAndContinue(startUri, endUri, null, WebAuthenticationOptions.None);
}
public static void DoImplicitFlowAsync(
Uri endpoint,
string clientId,
string responseType,
string scope,
Uri redirectUri)
{
var client = new OAuth2Client(endpoint);
var state = Guid.NewGuid().ToString("N");
var nonce = Guid.NewGuid().ToString("N");
var startUri = client.CreateAuthorizeUrl(
clientId: clientId,
responseType: responseType,
scope: scope,
redirectUri: redirectUri.AbsoluteUri,
state: state,
nonce: nonce);
try
{
// On Windows Phone 8.1, the AuthenticateAsync method isn't implemented on
// the WebAuthenticationBroker. Therefor, AuthenticateAndContinue is used.
//
// Callback = ContinueWebAuthentication in MainPage.xaml.cs
WebAuthenticationBroker.AuthenticateAndContinue(
new Uri(startUri),
redirectUri,
null,
WebAuthenticationOptions.None
);
}
catch
{
// Bad Parameter, SSL/TLS Errors and Network Unavailable errors are to be handled here.
throw;
}
}
public void StartLoginFlow(LoginOptions loginOptions)
{
if (loginOptions == null || String.IsNullOrWhiteSpace(loginOptions.CallbackUrl) ||
String.IsNullOrWhiteSpace(loginOptions.LoginUrl))
{
return;
}
try
{
var loginUri = new Uri(OAuth2.ComputeAuthorizationUrl(loginOptions));
var callbackUri = new Uri(loginOptions.CallbackUrl);
WebAuthenticationBroker.AuthenticateAndContinue(loginUri, callbackUri, null,
WebAuthenticationOptions.None);
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger("AccountPage.StartLoginFlow - Exception occured", LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Critical);
PlatformAdapter.Resolve <IAuthHelper>().StartLoginFlow();
}
}
private async Task PocketAuthentication()
{
try
{
var code = await _pocketClient.GetRequestCode();
}
catch (Exception ex)
{
Log.ErrorException("PocketAuthentication", ex);
return;
}
var authUri = _pocketClient.GenerateAuthenticationUri();
#if WINDOWS_PHONE_APP
WebAuthenticationBroker.AuthenticateAndContinue(authUri, new Uri(Constants.Pocket.CallBackUri), new ValueSet(), WebAuthenticationOptions.None);
#else
var result = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, authUri);
await GetAuthenticationToken();
#endif
}
public void Authenticate(Uri authorizationUri, Uri redirectUri, IDictionary <string, object> headersMap, CallState callState)
{
ValueSet set = new ValueSet();
foreach (string key in headersMap.Keys)
{
set[key] = headersMap[key];
}
if (redirectUri.AbsoluteUri == WebAuthenticationBroker.GetCurrentApplicationCallbackUri().AbsoluteUri)
{
// SSO Mode
try
{
WebAuthenticationBroker.AuthenticateAndContinue(authorizationUri, null, set, WebAuthenticationOptions.None);
}
catch (FileNotFoundException ex)
{
throw new AdalException(AdalError.AuthenticationUiFailed, ex);
}
}
else if (redirectUri.Scheme == "ms-app")
{
throw new ArgumentException(AdalErrorMessage.RedirectUriAppIdMismatch, "redirectUri");
}
else
{
try
{
// Non-SSO Mode
WebAuthenticationBroker.AuthenticateAndContinue(authorizationUri, redirectUri, set, WebAuthenticationOptions.None);
}
catch (FileNotFoundException ex)
{
throw new AdalException(AdalError.AuthenticationUiFailed, ex);
}
}
}
public async Task StartOAuthFlow()
{
Exception exIfAny = null;
try
{
string state = Guid.NewGuid().ToString("N");
VaultManager.Save(VaultStateResourceKey, VaultDefaultUnusedUserName, state);
// Delete the now "old" code and access token info record from the vault before proceeding
VaultManager.Delete(VaultTokenCodeResourceKey, VaultDefaultUnusedUserName);
VaultManager.Delete(VaultTokenInfoResourceKey, VaultDefaultUnusedUserName);
_gitHubClient.Credentials = Credentials.Anonymous;
var uri = FormatGitHubLoginUrl(GhOAuthConfiguration.ClientId,
GhOAuthConfiguration.RedirectUri,
DeclareScopes(),
state);
Uri requestUri = new Uri(uri);
Uri callbackUri = new Uri(GhOAuthConfiguration.RedirectUri);
WebAuthenticationBroker.AuthenticateAndContinue(requestUri,
callbackUri,
null,
WebAuthenticationOptions.None);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
exIfAny = ex;
}
if (null != exIfAny)
{
await _messageService.ShowAsync(exIfAny.Message);
}
}
/// <summary>Asynchronously receives the authorization code.</summary>
/// <param name="url">The authorization code request URL.</param>
/// <param name="tcs">Task completion source whose result will be set to the authorization code.</param>
private async Task ReceiveCodeAsync(AuthorizationCodeRequestUrl url,
TaskCompletionSource <AuthorizationCodeResponseUrl> tcs)
{
var result = await PasswordVaultDataStore.Default.GetAsync <SerializableWebAuthResult>(
SerializableWebAuthResult.Name);
if (result == null)
{
// We should run WebAuthenticationBroker.AuthenticateAndContinue from the UI thread ONLY.
await InvokeFromUIThread(() => WebAuthenticationBroker.AuthenticateAndContinue(url.Build(),
new Uri(GoogleAuthConsts.LocalhostRedirectUri), null, WebAuthenticationOptions.None));
// No need to return anything, cause the application is going to be suspended now.
return;
}
const string Code = "code=";
const string Error = "error=";
// Get the index of the error or the code.
var index = result.ResponseData.IndexOf(Code);
index = index != -1 ? index : result.ResponseData.IndexOf(Error);
if (index != -1)
{
tcs.SetResult(new AuthorizationCodeResponseUrl(result.ResponseData.Substring(index)));
return;
}
tcs.SetException(new TokenResponseException(
new TokenErrorResponse
{
Error = result.ResponseStatus.ToString(),
ErrorDescription = "The WebAuthenticationBroker didn't return a code or an error. Details: " +
result.ResponseErrorDetail,
}));
}
public async Task <Session> LoginAsync()
{
var googleUrl = new StringBuilder();
googleUrl.Append("https://accounts.google.com/o/oauth2/auth?client_id=");
googleUrl.Append(Uri.EscapeDataString(Constants.GoogleClientId));
googleUrl.Append("&scope=openid%20email%20profile");
googleUrl.Append("&redirect_uri=");
googleUrl.Append(Uri.EscapeDataString(Constants.GoogleCallbackUrl));
googleUrl.Append("&state=foobar");
googleUrl.Append("&response_type=code");
var startUri = new Uri(googleUrl.ToString());
#if WINDOWS_APP
var endUri = new Uri("https://accounts.google.com/o/oauth2/approval?");
var webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.UseTitle, startUri, endUri);
return(await GetSessionAsync(webAuthenticationResult));
#else
WebAuthenticationBroker.AuthenticateAndContinue(startUri, new Uri(Constants.GoogleCallbackUrl), null, WebAuthenticationOptions.None);
return(null);
#endif
}