private void WireMessages() { Messenger.Default.Register<NotificationMessage>(this, async m => { if (m.Notification.Equals("AccountViewLoaded") || m.Notification.Equals("AppLoaded")) { try { if (_navigationService.IsNetworkAvailable) { _liveLoginResult = await _authClient.InitializeAsync(LiveSDKClientHelper.GetScopesStringList(_scopes)); IsLoggedIn = _liveLoginResult.Status == LiveConnectSessionStatus.Connected; await GetLoginDetails(); } } catch{} } if (m.Notification.Equals("Logout")) { if (_authClient.CanLogout) { _authClient.Logout(); IsLoggedIn = false; LoggedInAs = "Not logged in"; } else { await MessageBox.ShowAsync("We were unable to sign you out at this time", "Unable to sign out", MessageBoxButton.OK); } } }); }
/// <summary> /// Initializes the LiveAuthClient instance by trying to retrieve an access token using refresh token /// provided by the app via the IRefreshTokenHandler instance. /// </summary> public Task<LiveLoginResult> InitializeAsync(IEnumerable<string> scopes) { // We don't allow InitializeAsync or ExchangeAuthCodeAsync to be invoked concurrently. if (this.initTask != null) { throw new InvalidOperationException(ErrorText.ExistingAuthTaskRunning); } var task = new TaskCompletionSource<LiveLoginResult>(); this.initTask = task; this.initScopes = scopes; if (this.loginStatus != null) { // We have a result already, then return this one. this.OnInitCompleted(null); } else { this.loginStatus = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); this.TryRefreshToken(); } return task.Task; }
//인스턴스 생성용 method private async void login_Client() { try { //Client 생성 authClient = new LiveAuthClient(); //초기화 result = await authClient.InitializeAsync(); //로그인 loginResult = await authClient.LoginAsync(scope); //로그인 할 떄 cancel을 누르면 뒤로 돌아가기 } catch (NullReferenceException ex) { //로그인 할 때 cancel을 누르면 nullreferenceException 발생 //뒤로가기 ex.Message.ToString(); messagePrint(false); if (Frame.CanGoBack) { Frame.GoBack(); } } catch (Exception ex) { //기타 Exception을 위한 catch ex.Message.ToString(); messagePrint(false); if(Frame.CanGoBack) { Frame.GoBack(); } } }
/// <summary> /// Authenticate the user. Ask user for consent if neccessary. /// </summary> public async Task<LiveLoginResult> AuthenticateAsync(string scopes, bool? silent) { Exception error = null; string accessToken = null; string authenticationToken = null; LiveLoginResult result = null; try { accessToken = await this.GetAccessToken(scopes, silent); LiveConnectSession session = new LiveConnectSession(this.authClient); session.AccessToken = accessToken; if (!string.IsNullOrEmpty(this.authClient.RedirectUrl) && !this.authClient.RedirectUrl.Equals(Win8ReturnUriScheme, StringComparison.OrdinalIgnoreCase)) { authenticationToken = await this.GetAuthenticationToken(this.authClient.RedirectUrl, silent); session.AuthenticationToken = authenticationToken; } result = new LiveLoginResult(LiveConnectSessionStatus.Connected, session); } catch (TaskCanceledException) { result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); } catch (Exception comExp) { switch (comExp.HResult) { case TailoredAuthClient.UserNotFoundLoginExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); break; case TailoredAuthClient.ConsentNotGrantedExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); break; case TailoredAuthClient.InvalidClientExceptionHResult: case TailoredAuthClient.InvalidAuthTargetExceptionHResult: error = new LiveAuthException(AuthErrorCodes.InvalidRequest, ResourceHelper.GetString("InvalidAuthClient"), comExp); break; default: error = new LiveAuthException(AuthErrorCodes.ServerError, ResourceHelper.GetString("ServerError"), comExp); break; } } if (result == null) { Debug.Assert(error != null); result = new LiveLoginResult(error); } return result; }
//private static Task<LiveLoginResult> RequestAccessTokenAsync(string postContent) //{ // Task<LiveLoginResult> task = Task.Factory.StartNew(() => // { // return RequestAccessToken(postContent); // }); // return task; //} private static async Task<LiveLoginResult> RequestAccessTokenAsync(string postContent) { string url = LiveAuthUtility.BuildTokenUrl(); HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest; HttpWebResponse response = null; LiveLoginResult loginResult = null; request.Method = ApiMethod.Post.ToString().ToUpperInvariant(); request.ContentType = TokenRequestContentType; try { var requestStream = await request.GetRequestStreamAsync(); using (StreamWriter writer = new StreamWriter(requestStream)) { writer.Write(postContent); } response = await request.GetResponseAsync() as HttpWebResponse; loginResult = ReadResponse(response); } catch (WebException e) { response = e.Response as HttpWebResponse; loginResult = ReadResponse(response); } catch (IOException ioe) { loginResult = new LiveLoginResult(new LiveAuthException(AuthErrorCodes.ClientError, ioe.Message)); } finally { if (response != null) { //response.Close(); response.Dispose(); } } if (loginResult == null) { loginResult = new LiveLoginResult(new LiveAuthException(AuthErrorCodes.ClientError, ErrorText.RetrieveTokenError)); } return loginResult; }
private static LiveLoginResult RequestAccessToken(string postContent) { string url = LiveAuthUtility.BuildTokenUrl(); HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest; HttpWebResponse response = null; LiveLoginResult loginResult = null; request.Method = ApiMethod.Post.ToString().ToUpperInvariant(); request.ContentType = TokenRequestContentType; try { using (StreamWriter writer = new StreamWriter(request.GetRequestStream())) { writer.Write(postContent); } response = request.GetResponse() as HttpWebResponse; loginResult = ReadResponse(response); } catch (WebException e) { response = e.Response as HttpWebResponse; loginResult = ReadResponse(response); } catch (IOException ioe) { loginResult = new LiveLoginResult(new LiveAuthException(AuthErrorCodes.ClientError, ioe.Message)); } finally { if (response != null) { response.Close(); } } if (loginResult == null) { loginResult = new LiveLoginResult(new LiveAuthException(AuthErrorCodes.ClientError, ErrorText.RetrieveTokenError)); } return(loginResult); }
public override async Task<AuthenticationResult> AuthenticateAsync() { var result = await _authClient.LoginAsync(this.AuthorizationScopesList.ToArray()); if (result != null && result.Status == LiveConnectSessionStatus.Connected) { _result = result; return AuthenticationResult.Success; } if (result.Status == LiveConnectSessionStatus.Unknown) return AuthenticationResult.Unknown; else if (result.Status == LiveConnectSessionStatus.NotConnected) return AuthenticationResult.Failed; return AuthenticationResult.Unknown; //A really bad status to talk about! //var client = new LiveConnectClient(result.Session); //dynamic result2 = await client.GetAsync("me/skydrive/files"); }
protected async override Task OnActivate() { if (authClient == null) { authClient = new LiveAuthClient(ApiKeys.SkyDriveClientId); IEnumerable<string> scopes = ParseScopeString(Scopes); try { Task<LiveLoginResult> result = authClient.InitializeAsync(scopes); LiveLoginResult = await result; } catch (Exception exception) { //this.RaiseSessionChangedEvent(new LiveConnectSessionChangedEventArgs(exception)); } } }
/// <summary> /// Parse the response data. /// </summary> private LiveLoginResult ParseResponseFragment(string fragment) { Debug.Assert(!string.IsNullOrEmpty(fragment)); LiveLoginResult loginResult = null; IDictionary <string, object> result = LiveAuthClient.ParseQueryString(fragment); if (result.ContainsKey(AuthConstants.AccessToken)) { LiveConnectSession sessionData = CreateSession(this, result); loginResult = new LiveLoginResult(LiveConnectSessionStatus.Connected, sessionData); } else if (result.ContainsKey(AuthConstants.Error)) { loginResult = GetErrorResult(result); } return(loginResult); }
private void OnInitCompleted(LiveLoginResult authResult) { authResult = this.ValidateSessionInitScopes(authResult); this.UpdateSession(authResult); Debug.Assert(this.loginStatus != null); this.publicAuthClient.FirePendingPropertyChangedEvents(); if (authResult != null && authResult.Error != null) { this.initTask.SetException(authResult.Error); } else { this.initTask.SetResult(this.loginStatus); } this.initTask = null; }
private void RefreshToken(Action <LiveLoginResult> completionCallback) { if (this.refreshTokenInfo != null) { LiveAuthRequestUtility.RefreshTokenAsync( this.clientId, null, LiveAuthUtility.BuildDesktopRedirectUrl(), this.refreshTokenInfo.RefreshToken, null /*scopes*/ ).ContinueWith(t => { this.OnRefreshTokenCompleted(t.Result, completionCallback); }); } else { LiveLoginResult result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); this.OnRefreshTokenCompleted(result, completionCallback); } }
internal void TryRefreshToken(Action <LiveLoginResult> completionCallback) { LiveLoginResult result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); if (this.refreshTokenHandler != null) { if (this.refreshTokenInfo == null) { this.refreshTokenHandler.RetrieveRefreshTokenAsync().ContinueWith(t => { this.refreshTokenInfo = t.Result; this.RefreshToken(completionCallback); }); return; } this.RefreshToken(completionCallback); return; } this.OnRefreshTokenCompleted(result, completionCallback); }
private void CompleteAuthTask(LiveLoginResult loginResult) { Debug.Assert(loginResult != null); loginResult = this.ValidateSessionInitScopes(loginResult); HttpContextUtility.UpdateUserSession(this.webContext, loginResult, this.appRequestTs); if (loginResult.Session != null) { // Only update Session property if there is a new session. this.publicAuthClient.Session = loginResult.Session; } this.publicAuthClient.FirePendingPropertyChangedEvents(); TaskCompletionSource <LiveLoginResult> taskSource = this.currentTask; if (taskSource != null) { this.currentTask = null; if (loginResult.Error != null) { var error = loginResult.Error as LiveAuthException; if (error == null) { error = new LiveAuthException(AuthErrorCodes.ClientError, error.Message, loginResult.Error); } error.State = this.appRequestState; taskSource.SetException(loginResult.Error); } else { loginResult.State = this.appRequestState; taskSource.SetResult(loginResult); } } }
private async void TryRefreshToken(Action <LiveLoginResult> completionCallback) { LiveLoginResult result = await this.AuthClient.AuthenticateAsync( LiveAuthClient.BuildScopeString(this.currentScopes), true); if (result.Status == LiveConnectSessionStatus.NotConnected && this.currentScopes.Count > 1) { // The user might have revoked one of the scopes while the app is running. Try getting a token for the remaining scopes // by passing in only the "wl.signin" scope. The server should return a token that contains all remaining scopes. this.currentScopes = new List <string>(new string[] { LiveAuthClient.SignInOfferName }); result = await this.AuthClient.AuthenticateAsync( LiveAuthClient.BuildScopeString(this.currentScopes), true); } if (result.Session != null && !AreSessionsSame(this.Session, result.Session)) { this.Session = result.Session; } completionCallback(result); }
/// <summary> /// Authenticate the user. Ask user for consent if neccessary. /// </summary> public async Task <LiveLoginResult> AuthenticateAsync(string scopes, bool silent) { Exception error = null; string accessToken = null; string authenticationToken = null; LiveLoginResult result = null; try { accessToken = await this.GetAccessToken(scopes, silent); LiveConnectSession session = new LiveConnectSession(this.authClient); session.AccessToken = accessToken; if (!string.IsNullOrEmpty(this.authClient.RedirectUrl) && !this.authClient.RedirectUrl.StartsWith(Win8AppIdPrefix, StringComparison.OrdinalIgnoreCase)) { authenticationToken = await this.GetAuthenticationToken(this.authClient.RedirectUrl, silent); session.AuthenticationToken = authenticationToken; } result = new LiveLoginResult(LiveConnectSessionStatus.Connected, session); } catch (TaskCanceledException) { result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); } catch (Exception comExp) { switch (comExp.HResult) { case TailoredAuthClient.UserNotFoundLoginExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); break; case TailoredAuthClient.ConsentNotGrantedExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); break; case TailoredAuthClient.InvalidClientExceptionHResult: case TailoredAuthClient.InvalidAuthTargetExceptionHResult: error = new LiveAuthException(AuthErrorCodes.InvalidRequest, ResourceHelper.GetString("InvalidAuthClient"), comExp); break; default: error = new LiveAuthException(AuthErrorCodes.ServerError, ResourceHelper.GetString("ServerError"), comExp); break; } } if (result == null) { Debug.Assert(error != null); result = new LiveLoginResult(error); } return(result); }
/// <summary> /// Writes the user current session. /// </summary> public static void UpdateUserSession(HttpContextBase context, LiveLoginResult loginResult, string requestTs) { if (context == null) { return; } Debug.Assert(loginResult != null); Dictionary<string, string> cookieValues = new Dictionary<string, string>(); HttpCookie cookie = context.Request.Cookies[AuthCookie]; HttpCookie newCookie = new HttpCookie(AuthCookie); newCookie.Path = "/"; string host = context.Request.Headers["Host"]; newCookie.Domain = host.Split(':')[0]; if (cookie != null && cookie.Values != null) { foreach (string key in cookie.Values.AllKeys) { newCookie.Values[key] = cookie[key]; } } LiveConnectSession session = loginResult.Session; if (session != null) { newCookie.Values[AuthConstants.AccessToken] = Uri.EscapeDataString(session.AccessToken); newCookie.Values[AuthConstants.AuthenticationToken] = Uri.EscapeDataString(session.AuthenticationToken); newCookie.Values[AuthConstants.Scope] = Uri.EscapeDataString(LiveAuthUtility.BuildScopeString(session.Scopes)); newCookie.Values[AuthConstants.ExpiresIn] = Uri.EscapeDataString(LiveAuthWebUtility.GetExpiresInString(session.Expires)); newCookie.Values[AuthConstants.Expires] = Uri.EscapeDataString(LiveAuthWebUtility.GetExpiresString(session.Expires)); } LiveConnectSessionStatus status; if (!string.IsNullOrEmpty(newCookie[AuthConstants.AccessToken])) { // We have an access token, so it is connected, regardless expired or not // since it is handled after loading the session in both Asp.Net and JS library. status = LiveConnectSessionStatus.Connected; } else { status = loginResult.Status; if (loginResult.Status == LiveConnectSessionStatus.Unknown) { // If we recorded NotConnected previously, keep it. LiveConnectSessionStatus statusFromCookie; if (Enum.TryParse<LiveConnectSessionStatus>( newCookie[AuthConstants.Status], true/*ignore case*/, out statusFromCookie)) { if (statusFromCookie == LiveConnectSessionStatus.NotConnected) { status = statusFromCookie; } } } } newCookie.Values[AuthConstants.Status] = GetStatusString(status); // Needs to write error to inform the JS library. LiveAuthException authError = loginResult.Error as LiveAuthException; if (authError != null) { newCookie.Values[AuthConstants.Error] = Uri.EscapeDataString(authError.ErrorCode); newCookie.Values[AuthConstants.ErrorDescription] = HttpUtility.UrlPathEncode(authError.Message); } else if (status != LiveConnectSessionStatus.Connected) { newCookie.Values[AuthConstants.Error] = Uri.EscapeDataString(AuthErrorCodes.AccessDenied); newCookie.Values[AuthConstants.ErrorDescription] = HttpUtility.UrlPathEncode("Cannot retrieve access token."); } if (!string.IsNullOrEmpty(requestTs)) { newCookie.Values[AuthConstants.ClientRequestTs] = requestTs; } context.Response.Cookies.Add(newCookie); }
private void TryRefreshToken(string redirectUrl) { Debug.Assert(this.loginStatus != null); IEnumerable<string> scopes; LiveAuthException error; bool isTokenRequest = this.CheckRefreshTokenRequest(out scopes, out error); if (error != null) { this.OnAuthTaskCompleted(new LiveLoginResult(error)); return; } // Try to refresh a token if // i) there is a token request or // ii) we don't have a token or // iii) the current token is expired. LiveLoginResult result = null; LiveConnectSession session = this.loginStatus.Session; bool hasValidToken = session != null && session.IsValid; bool shouldRefresh = (this.refreshTokenHandler != null) && (isTokenRequest || !hasValidToken); if (!shouldRefresh) { this.OnAuthTaskCompleted(null); return; } if (this.initScopes == null) { // We don't have initScopes, then use the scopes received from Url. this.initScopes = scopes; } this.refreshTokenHandler.RetrieveRefreshTokenAsync().ContinueWith(t => { try { this.refreshTokenInfo = t.Result; if (this.refreshTokenInfo != null) { string currentUserId = this.publicAuthClient.CurrentUserId; if (currentUserId != null && this.refreshTokenInfo.UserId != currentUserId) { // There is a user Id available in current session. We need to ensure the token provided matches it. result = new LiveLoginResult(new LiveAuthException( AuthErrorCodes.InvalidRequest, ErrorText.RefereshTokenNotMatchUserId)); } else { LiveAuthRequestUtility.RefreshTokenAsync( this.clientId, this.clientSecret, redirectUrl, this.refreshTokenInfo.RefreshToken, null/*scopes - We intentially specify null scopes and validate the initScopes after we have the session * result. With this approach, we can return notConnected if initScopes is not satisfied, and surface * the error if there is one. */ ).ContinueWith((Task<LiveLoginResult> rt) => { result = rt.Result; this.OnAuthTaskCompleted(result); }); return; } } } catch (Exception ex) { error = new LiveAuthException(AuthErrorCodes.ClientError, ErrorText.RetrieveRefreshTokenError, ex); result = new LiveLoginResult(error); } this.OnAuthTaskCompleted(result); }); }
/// <summary> /// Writes the user current session. /// </summary> public static void UpdateUserSession(HttpContextBase context, LiveLoginResult loginResult, string requestTs) { if (context == null) { return; } Debug.Assert(loginResult != null); Dictionary <string, string> cookieValues = new Dictionary <string, string>(); HttpCookie cookie = context.Request.Cookies[AuthCookie]; HttpCookie newCookie = new HttpCookie(AuthCookie); newCookie.Path = "/"; string host = context.Request.Headers["Host"]; newCookie.Domain = host.Split(':')[0]; if (cookie != null && cookie.Values != null) { foreach (string key in cookie.Values.AllKeys) { newCookie.Values[key] = cookie[key]; } } LiveConnectSession session = loginResult.Session; if (session != null) { newCookie.Values[AuthConstants.AccessToken] = Uri.EscapeDataString(session.AccessToken); newCookie.Values[AuthConstants.AuthenticationToken] = Uri.EscapeDataString(session.AuthenticationToken); newCookie.Values[AuthConstants.Scope] = Uri.EscapeDataString(LiveAuthUtility.BuildScopeString(session.Scopes)); newCookie.Values[AuthConstants.ExpiresIn] = Uri.EscapeDataString(LiveAuthWebUtility.GetExpiresInString(session.Expires)); newCookie.Values[AuthConstants.Expires] = Uri.EscapeDataString(LiveAuthWebUtility.GetExpiresString(session.Expires)); } LiveConnectSessionStatus status; if (!string.IsNullOrEmpty(newCookie[AuthConstants.AccessToken])) { // We have an access token, so it is connected, regardless expired or not // since it is handled after loading the session in both Asp.Net and JS library. status = LiveConnectSessionStatus.Connected; } else { status = loginResult.Status; if (loginResult.Status == LiveConnectSessionStatus.Unknown) { // If we recorded NotConnected previously, keep it. LiveConnectSessionStatus statusFromCookie; if (Enum.TryParse <LiveConnectSessionStatus>( newCookie[AuthConstants.Status], true /*ignore case*/, out statusFromCookie)) { if (statusFromCookie == LiveConnectSessionStatus.NotConnected) { status = statusFromCookie; } } } } newCookie.Values[AuthConstants.Status] = GetStatusString(status); // Needs to write error to inform the JS library. LiveAuthException authError = loginResult.Error as LiveAuthException; if (authError != null) { newCookie.Values[AuthConstants.Error] = Uri.EscapeDataString(authError.ErrorCode); newCookie.Values[AuthConstants.ErrorDescription] = HttpUtility.UrlPathEncode(authError.Message); } else if (status != LiveConnectSessionStatus.Connected) { newCookie.Values[AuthConstants.Error] = Uri.EscapeDataString(AuthErrorCodes.AccessDenied); newCookie.Values[AuthConstants.ErrorDescription] = HttpUtility.UrlPathEncode("Cannot retrieve access token."); } if (!string.IsNullOrEmpty(requestTs)) { newCookie.Values[AuthConstants.ClientRequestTs] = requestTs; } context.Response.Cookies.Add(newCookie); }
/// <summary> /// Downloads the resource with the given path to the downloadLocation using the Windows Phone /// BackgroundTransferService. /// </summary> /// <param name="path">Path to the resource to download</param> /// <param name="downloadLocation"> /// The path to the file that will contain the download resource. /// The downloadLocation must exist in /shared/transfers. /// </param> /// <param name="ct">a token that is used to cancel the background download operation.</param> /// <param name="progress">an object that is called to report the background download's progress.</param> /// <returns>A Task object representing the asynchronous operation.</returns> public async Task <LiveOperationResult> BackgroundDownloadAsync( string path, Uri downloadLocation, CancellationToken ct, IProgress <LiveOperationProgress> progress) { if (string.IsNullOrWhiteSpace(path)) { string message = String.Format(CultureInfo.CurrentUICulture, ResourceHelper.GetString("UrlInvalid"), "path"); if (path == null) { throw new ArgumentNullException("path", message); } throw new ArgumentException(message, "path"); } if (downloadLocation == null) { throw new ArgumentNullException("downloadLocation"); } string filename = Path.GetFileName(downloadLocation.OriginalString); if (string.IsNullOrEmpty(filename)) { string message = String.Format(CultureInfo.CurrentUICulture, ResourceHelper.GetString("UriMissingFileName"), "downloadLocation"); throw new ArgumentException(message, "downloadLocation"); } if (!BackgroundTransferHelper.IsRootedInSharedTransfers(downloadLocation)) { string message = String.Format(CultureInfo.CurrentUICulture, ResourceHelper.GetString("UriMustBeRootedInSharedTransfers"), "downloadLocation"); throw new ArgumentException(message, "downloadLocation"); } if (this.Session == null) { throw new LiveConnectException(ApiOperation.ApiClientErrorCode, ResourceHelper.GetString("UserNotLoggedIn")); } Uri requestUri = this.GetResourceUri(path, ApiMethod.Download); var builder = new BackgroundDownloadOperation.Builder { RequestUri = requestUri, DownloadLocationOnDevice = downloadLocation, BackgroundTransferService = this.BackgroundTransferService, Progress = progress, BackgroundTransferPreferences = this.BackgroundTransferPreferences }; if (!this.Session.IsValid) { LiveLoginResult result = await this.Session.AuthClient.RefreshTokenAsync(); if (result.Status == LiveConnectSessionStatus.Connected) { this.Session = result.Session; } } builder.AccessToken = this.Session.AccessToken; BackgroundDownloadOperation operation = builder.Build(); ct.Register(operation.Cancel); return(await operation.ExecuteAsync()); }
private LiveLoginResult ValidateSessionInitScopes(LiveLoginResult loginResult) { if (loginResult.Session != null && this.initScopes != null) { if (!LiveAuthUtility.IsSubsetOfScopeRange(this.initScopes, loginResult.Session.Scopes)) { loginResult = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); } this.initScopes = null; } return loginResult; }
private void RefreshToken(Action<LiveLoginResult> completionCallback) { if (this.refreshTokenInfo != null) { LiveAuthRequestUtility.RefreshTokenAsync( this.clientId, null, LiveAuthUtility.BuildDesktopRedirectUrl(), this.refreshTokenInfo.RefreshToken, null /*scopes*/ ).ContinueWith(t => { this.OnRefreshTokenCompleted(t.Result, completionCallback); }); } else { LiveLoginResult result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); this.OnRefreshTokenCompleted(result, completionCallback); } }
private void OnInitCompleted(LiveLoginResult authResult) { authResult = this.ValidateSessionInitScopes(authResult); this.UpdateSession(authResult); Debug.Assert(this.loginStatus != null); this.publicAuthClient.FirePendingPropertyChangedEvents(); if (authResult != null && authResult.Error != null) { this.initTask.SetException(authResult.Error); } else { this.initTask.SetResult(this.loginStatus); } this.initTask = null; }
internal void TryRefreshToken(Action<LiveLoginResult> completionCallback) { LiveLoginResult result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); if (this.refreshTokenHandler != null) { if (this.refreshTokenInfo == null) { this.refreshTokenHandler.RetrieveRefreshTokenAsync().ContinueWith(t => { this.refreshTokenInfo = t.Result; this.RefreshToken(completionCallback); }); return; } this.RefreshToken(completionCallback); return; } this.OnRefreshTokenCompleted(result, completionCallback); }
private void TryRefreshToken(string redirectUrl) { Debug.Assert(this.loginStatus != null); IEnumerable <string> scopes; LiveAuthException error; bool isTokenRequest = this.CheckRefreshTokenRequest(out scopes, out error); if (error != null) { this.OnAuthTaskCompleted(new LiveLoginResult(error)); return; } // Try to refresh a token if // i) there is a token request or // ii) we don't have a token or // iii) the current token is expired. LiveLoginResult result = null; LiveConnectSession session = this.loginStatus.Session; bool hasValidToken = session != null && session.IsValid; bool shouldRefresh = (this.refreshTokenHandler != null) && (isTokenRequest || !hasValidToken); if (!shouldRefresh) { this.OnAuthTaskCompleted(null); return; } if (this.initScopes == null) { // We don't have initScopes, then use the scopes received from Url. this.initScopes = scopes; } this.refreshTokenHandler.RetrieveRefreshTokenAsync().ContinueWith(t => { try { this.refreshTokenInfo = t.Result; if (this.refreshTokenInfo != null) { string currentUserId = this.publicAuthClient.CurrentUserId; if (currentUserId != null && this.refreshTokenInfo.UserId != currentUserId) { // There is a user Id available in current session. We need to ensure the token provided matches it. result = new LiveLoginResult(new LiveAuthException( AuthErrorCodes.InvalidRequest, ErrorText.RefereshTokenNotMatchUserId)); } else { LiveAuthRequestUtility.RefreshTokenAsync( this.clientId, this.clientSecret, redirectUrl, this.refreshTokenInfo.RefreshToken, null/*scopes - We intentially specify null scopes and validate the initScopes after we have the session * result. With this approach, we can return notConnected if initScopes is not satisfied, and surface * the error if there is one. */ ).ContinueWith((Task <LiveLoginResult> rt) => { result = rt.Result; this.OnAuthTaskCompleted(result); }); return; } } } catch (Exception ex) { error = new LiveAuthException(AuthErrorCodes.ClientError, ErrorText.RetrieveRefreshTokenError, ex); result = new LiveLoginResult(error); } this.OnAuthTaskCompleted(result); }); }
private void OnLogin(LiveLoginResult loginResult) { Session = loginResult.Session; if (loginResult.Status == LiveConnectSessionStatus.Connected) { _cache.SkydriveSession = loginResult.Session; _navigationService.UriFor<BrowseCloudFilesViewModel>() .WithParam(vm => vm.CloudProvider, CloudProvider.SkyDrive) .WithParam(vm => vm.NavigationUrl, "/me/skydrive") .Navigate(); } else { _cache.SkydriveSession = null; SignInIsEnabled = true; } }
private void OnExchangeCodeCompleted(LiveLoginResult authResult) { this.UpdateSession(authResult); Debug.Assert(this.loginStatus != null); this.publicAuthClient.FirePendingPropertyChangedEvents(); if (authResult != null && authResult.Error != null) { this.codeExchangeTask.SetException(authResult.Error); } else { this.codeExchangeTask.SetResult(authResult.Session); } this.codeExchangeTask = null; }
/// <summary> /// Initializes the LiveAuthClient instance for the current user. /// If an authorization code is present, it will send a request to the auth server to exchange the token. /// If there is an auth session in current context, it will retrieve the current auth session. /// If the current session is expired or the current request url indicates (refresh=1) to get a new token, /// it will try to request a new access token using refresh token that will need to be provided through /// IRefreshTokenHandler.RetrieveRefreshTokenAsync() method. /// Any updated session state will be saved in the auth session cookie. /// </summary> public Task<LiveLoginResult> ExchangeAuthCodeAsync(string redirectUrl, HttpContextBase webContext) { Debug.Assert(webContext != null); Debug.Assert(!string.IsNullOrEmpty(redirectUrl)); this.ValidateConflictAuthTask(); this.webContext = webContext; var taskSource = new TaskCompletionSource<LiveLoginResult>(); this.currentTask = taskSource; string authorizationCode; LiveAuthException error; this.LoadSession(out authorizationCode, out error); // If this page receives an authorization code, then exchange the code // with the auth server to get the tokens. if (!string.IsNullOrEmpty(authorizationCode)) { // We intentionally move auth actions into a wrapping asynchronous process to work around an issue where // invoking Task Async methods will trigger an error to be thrown on an Async Asp.Net page (.aspx) code. Task.Factory.StartNew(() => { this.ExchangeCodeForToken( redirectUrl, authorizationCode); }); } else if (error != null) { // We received error from the auth server response. if (error.ErrorCode == AuthErrorCodes.AccessDenied) { // Access_denied should be treated as NotConnected. LiveLoginResult result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); this.OnAuthTaskCompleted(result); } else { // We received some other error, then throw it. this.OnAuthTaskCompleted(new LiveLoginResult(error)); } } else { // This is exchange auth code only action, but there is neither code nor error return. // The app developer may invoke this at wrong location. error = new LiveAuthException(AuthErrorCodes.ClientError, ErrorText.AuthServerResponseNotAvailable); this.OnAuthTaskCompleted(new LiveLoginResult(error)); } return taskSource.Task; }
private void OnRefreshTokenCompleted(LiveLoginResult result, Action<LiveLoginResult> completionCallback) { if (completionCallback != null) { this.UpdateSession(result); completionCallback(result); } else { this.OnInitCompleted(result); } }
private async void Login(object arg) { LiveLoginResult = await authClient.LoginAsync(ParseScopeString(this.Scopes)); }
private void UpdateSession(LiveLoginResult result) { Debug.Assert(result != null); if (result.Session != null) { // Set the AuthClient that is needed when refreshing a token. result.Session.AuthClient = this.publicAuthClient; // We have a new session, update the public property this.loginStatus = result; this.publicAuthClient.Session = result.Session; if (this.refreshTokenHandler != null && !string.IsNullOrEmpty(result.Session.RefreshToken)) { RefreshTokenInfo refreshInfo = new RefreshTokenInfo(result.Session.RefreshToken); this.refreshTokenHandler.SaveRefreshTokenAsync(refreshInfo); } } else if (this.loginStatus.Status == LiveConnectSessionStatus.Unknown && result.Status == LiveConnectSessionStatus.NotConnected) { this.loginStatus = result; } }
private void LoadSession(out string authCode, out LiveAuthException error) { authCode = null; error = null; // only load session once. if (this.loginStatus == null) { if (this.webContext != null) { // Reads current login status from session cookie. this.loginStatus = HttpContextUtility.GetUserLoginStatus(this.webContext); HttpContextUtility.ReadAuthCodeRequest( webContext, out authCode, out this.appRequestState, out this.appRequestTs, out error); if (this.loginStatus.Status == LiveConnectSessionStatus.Unknown && error != null && error.ErrorCode == AuthErrorCodes.AccessDenied) { this.loginStatus = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); } } else { this.loginStatus = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); } this.publicAuthClient.Session = this.loginStatus.Session; } }
/// <summary> /// Parse the response data. /// </summary> private LiveLoginResult ParseResponseFragment(string fragment) { Debug.Assert(!string.IsNullOrEmpty(fragment)); LiveLoginResult loginResult = null; IDictionary<string, object> result = LiveAuthClient.ParseQueryString(fragment); if (result.ContainsKey(AuthConstants.AccessToken)) { LiveConnectSession sessionData = CreateSession(this, result); loginResult = new LiveLoginResult(LiveConnectSessionStatus.Connected, sessionData); } else if (result.ContainsKey(AuthConstants.Error)) { loginResult = GetErrorResult(result); } return loginResult; }
private void OnAuthTaskCompleted( LiveLoginResult loginResult) { if (loginResult != null) { if (loginResult.Session != null) { LiveAuthException error = this.ValidateSession(loginResult.Session); if (error != null) { loginResult = new LiveLoginResult(error); } else { // We have a new session, update the LiveAuthClient.Session this.loginStatus = loginResult; if (this.refreshTokenHandler != null && !string.IsNullOrEmpty(loginResult.Session.RefreshToken)) { string userId; if (this.GetUserId(loginResult.Session.AuthenticationToken, out userId, out error)) { RefreshTokenInfo refreshInfo = new RefreshTokenInfo(loginResult.Session.RefreshToken, userId); Task saveTokenTask = this.refreshTokenHandler.SaveRefreshTokenAsync(refreshInfo); saveTokenTask.ContinueWith((tk) => { this.CompleteAuthTask(loginResult); }); return; } else { loginResult = new LiveLoginResult(error); } } } } } else { // We should return the existing status for cases like already initialized or can't refresh ticket. loginResult = this.loginStatus; } this.CompleteAuthTask(loginResult); }
/// <summary> /// Clear the auth state in the current session /// </summary> public void ClearSession(HttpContextBase context) { LiveUtility.ValidateNotNullParameter(context, "context"); HttpContextUtility.ClearUserSession(context); this.loginStatus = null; this.publicAuthClient.Session = null; this.publicAuthClient.FirePendingPropertyChangedEvents(); }
private void CompleteAuthTask(LiveLoginResult loginResult) { Debug.Assert(loginResult != null); loginResult = this.ValidateSessionInitScopes(loginResult); HttpContextUtility.UpdateUserSession(this.webContext, loginResult, this.appRequestTs); if (loginResult.Session != null) { // Only update Session property if there is a new session. this.publicAuthClient.Session = loginResult.Session; } this.publicAuthClient.FirePendingPropertyChangedEvents(); TaskCompletionSource<LiveLoginResult> taskSource = this.currentTask; if (taskSource != null) { this.currentTask = null; if (loginResult.Error != null) { var error = loginResult.Error as LiveAuthException; if (error == null) { error = new LiveAuthException(AuthErrorCodes.ClientError, error.Message, loginResult.Error); } error.State = this.appRequestState; taskSource.SetException(loginResult.Error); } else { loginResult.State = this.appRequestState; taskSource.SetResult(loginResult); } } }