public void LiveAuthClient_GetLoginUrl_NoOptionalParameters()
        {
            LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
            Dictionary<string, string> options = new Dictionary<string, string>();
            string url = authClient.GetLoginUrl(new string[] { "wl.signin", "wl.basic" }, "https://www.foo.com", null);

            Assert.AreEqual("https://login.live.com/oauth20_authorize.srf?client_id=000000004802B729&redirect_uri=https%3A%2F%2Fwww.foo.com&scope=wl.signin%20wl.basic&response_type=code&display=page&locale=en-US&state=", url);
        }
        public void LiveAuthClient_GetLoginUrl_WithAllParams()
        {
            LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
            Dictionary<string, string> options = new Dictionary<string,string>();
            options[AuthConstants.ClientState] = "unit tests";
            options[AuthConstants.Locale] = "zh-hans";
            options[AuthConstants.Display] = "touch";
            options["random"] = "random";
            string url = authClient.GetLoginUrl(new string[] { "wl.signin", "wl.basic" }, "https://www.foo.com", options);

            Assert.AreEqual("https://login.live.com/oauth20_authorize.srf?client_id=000000004802B729&redirect_uri=https%3A%2F%2Fwww.foo.com&scope=wl.signin%20wl.basic&response_type=code&display=touch&locale=zh-hans&state=appstate%3Dunit%2520tests", url);
        }
 public async void TestLoginAsyncNullScopes()
 {
     var authClient = new LiveAuthClient("SomeClientId");
     try
     {
         LiveLoginResult result = await authClient.LoginAsync(null);
         Assert.Fail("Expected ArgumentNullException to be thrown.");
     }
     catch (ArgumentNullException)
     {
     }
 }
 public void TestInitializeAsyncNullScopes()
 {
     var authClient = new LiveAuthClient();
     try
     {
         authClient.InitializeAsync(null);
         Assert.Fail("Expected ArgumentNullException to be thrown.");
     }
     catch (ArgumentNullException)
     {
     }
 }
示例#5
0
        /// <summary>
        /// Checks if the access token is still valid.  If not, refreshes the token.
        /// </summary>
        protected bool RefreshTokenIfNeeded()
        {
            bool           needsRefresh = false;
            LiveAuthClient authClient   = this.LiveClient.Session.AuthClient;

            if (!this.refreshed && authClient != null)
            {
                this.refreshed = true;

                needsRefresh = authClient.RefreshToken(this.OnRefreshTokenOperationCompleted);
            }

            return(needsRefresh);
        }
示例#6
0
        public async void TestLoginAsyncNullScopes()
        {
            var authClient = new LiveAuthClient("SomeClientId");

            try
            {
                LiveLoginResult result = await authClient.LoginAsync(null);

                Assert.Fail("Expected ArgumentNullException to be thrown.");
            }
            catch (ArgumentNullException)
            {
            }
        }
示例#7
0
        public void Logout()
        {
            var liveAuthClient = new LiveAuthClient("000000004811DB42");

            string logoutUrl = liveAuthClient.GetLogoutUrl();

            var authForm = new LiveAuthWindow(
                logoutUrl,
                this.OnLiveAuthCompleted,
                "Logout"
                );

            authForm.LogOut(logoutUrl);
        }
        public async Task UnAuthenticateUserThroughLive()
        {
            try
            {
                LiveAuthClient  LCAuth        = new LiveAuthClient();
                LiveLoginResult LCLoginResult = await LCAuth.InitializeAsync();

                // LCAuth.Logout();
                LiveSession = null;
            }
            catch (LiveAuthException)
            {
                // Handle exceptions.
            }
        }
示例#9
0
        public void RegisterAccount(OAuthToken token, UserProfileInfo user)
        {
            LiveAuthClient auth = new LiveAuthClient(clientId, clientSecret, MogConstants.SKYDRIVE_REDIRECTURL);

            AuthCredential credential = new AuthCredential();

            credential.CloudService   = CloudStorageServices.Skydrive;
            credential.Token          = token.AccessToken;
            credential.Refresh        = token.RefreshToken;
            credential.Authentication = token.AuthenticationToken;
            credential.Status         = CredentialStatus.Approved;
            credential.UserId         = user.Id;
            credential.Login          = auth.GetUserId(token.AuthenticationToken);
            this.repoAuthCredential.Create(credential);
        }
示例#10
0
        private void BeginLink(bool autoLogin)
        {
            // Returns if already linked.
            if (IsLinked)
            {
                Log("Already linked, ignored.");
                return;
            }

            // Stores auto-login setting.
            lock (_syncRoot)
            {
                _autoLoginOnInitFail = autoLogin;
            }

            // Makes sure the auth client exists.
            if (_authClient == null)
            {
                string clientId = null;
                try
                {
                    clientId = (string)App.Current.Resources["LiveConnectClientID"];
                }
                catch (Exception ex)
                {
                    Log("Unable to fetch LiveConnectClientID from App resources.");
                    throw new InvalidOperationException("Unable to fetch LiveConnectClientID from App resources.", ex);
                }

                _authClient = new LiveAuthClient(clientId);
            }

            // Starts initializing.
            try
            {
                Log("Starts InitializeAsync");
                StartTaskAndContinueWith(() => _authClient.InitializeAsync(_Scopes), OnAuthClientInitializeCompleted);
            }
            catch (LiveAuthException ex)
            {
                // Ignores but dumps the exception.
                Log("LiveAuthException: " + ex.Message);
                Geowigo.Utils.DebugUtils.DumpException(ex, dumpOnBugSenseToo: false);

                // Raises an event.
                RaiseLinkAbort(ex);
            }
        }
示例#11
0
        public async Task <bool> Init(string clientId)
        {
            clientId.NotNull("clientId");

            _authClient = new LiveAuthClient(clientId, this);

            var loginResult = await _authClient.InitializeAsync(_scopes);

            if (loginResult.Session != null)
            {
                _liveConnectClient = new LiveConnectClient(loginResult.Session);
            }

            SingInUrl = _authClient.GetLoginUrl(_scopes);
            return(true);
        }
        public LiveConnectSession LoadSession(LiveAuthClient authClient)
        {
            var appData = IsolatedStorageSettings.ApplicationSettings;
            LiveConnectSession session = null;
            if (appData.Values.Count > 0)
            {
                session = new LiveConnectSession(authClient);

                if (appData.Contains(AuthConstants.RefreshToken))
                {
                    session.RefreshToken = appData[AuthConstants.RefreshToken] as string;
                }
            }

            return session;
        }
示例#13
0
        public LiveConnectSession LoadSession(LiveAuthClient authClient)
        {
            var appData = IsolatedStorageSettings.ApplicationSettings;
            LiveConnectSession session = null;

            if (appData.Values.Count > 0)
            {
                session = new LiveConnectSession(authClient);

                if (appData.Contains(AuthConstants.RefreshToken))
                {
                    session.RefreshToken = appData[AuthConstants.RefreshToken] as string;
                }
            }

            return(session);
        }
示例#14
0
        public void SaveSession(LiveConnectSession session)
        {
            if (session != null)
            {
                ApplicationDataContainer appData = ApplicationData.Current.RoamingSettings;

                if (appData.Values.ContainsKey(AuthConstants.AccessToken))
                {
                    appData.Values.Remove(AuthConstants.AccessToken);
                }

                appData.Values.Add(AuthConstants.AccessToken, session.AccessToken);

                if (appData.Values.ContainsKey(AuthConstants.AuthenticationToken))
                {
                    appData.Values.Remove(AuthConstants.AuthenticationToken);
                }

                appData.Values.Add(AuthConstants.AuthenticationToken, session.AuthenticationToken);

                if (!string.IsNullOrEmpty(session.RefreshToken))
                {
                    if (appData.Values.ContainsKey(AuthConstants.RefreshToken))
                    {
                        appData.Values.Remove(AuthConstants.RefreshToken);
                    }

                    appData.Values.Add(AuthConstants.RefreshToken, session.RefreshToken);
                }

                if (appData.Values.ContainsKey(AuthConstants.Expires))
                {
                    appData.Values.Remove(AuthConstants.Expires);
                }

                appData.Values.Add(AuthConstants.Expires, session.Expires);

                if (appData.Values.ContainsKey(AuthConstants.Scope))
                {
                    appData.Values.Remove(AuthConstants.Scope);
                }

                appData.Values.Add(AuthConstants.Scope, LiveAuthClient.BuildScopeString(session.Scopes));
                TestAuthClient.Scopes = session.Scopes;
            }
        }
示例#15
0
        async private Task <bool> userIsLoggedToOneDrive()
        {
            if (liveConnect == null)
            {
                return(false);
            }

            var auth   = new LiveAuthClient(App.LSKEY_LIVE_CLIENT_ID);
            var result = await auth.InitializeAsync(new[] { "wl.signin", "wl.SkyDrive_update" });

            if (result.Status == LiveConnectSessionStatus.NotConnected)
            {
                return(false);
            }

            return(true);
        }
        private async Task <LiveConnectClient> GetLiveConnectClientAsync()
        {
            LiveAuthClient liveAuthClient = new LiveAuthClient();

            string[]        scopes          = new[] { "wl.basic", "wl.signin", "wl.offline_access", "wl.skydrive", "wl.skydrive_update", "wl.contacts_skydrive" };
            LiveLoginResult liveLoginResult = null;

            // Get Current live connection session
            // If session doesn't exist, get new one.
            liveLoginResult = await liveAuthClient.InitializeAsync(scopes);

            if (liveLoginResult.Status != LiveConnectSessionStatus.Connected)
            {
                liveLoginResult = await liveAuthClient.LoginAsync(scopes);
            }
            return(new LiveConnectClient(liveLoginResult.Session));
        }
示例#17
0
        public static async Task <string> upload(string filename)
        {
            string res = "";

            //diagLog("Uploading " + file);
            try
            {
                string[]       requiredScope = { "wl.offline_access", "wl.skydrive_update" };
                LiveAuthClient auth          = new LiveAuthClient(Secrets.ClientID);
                await auth.InitializeAsync(requiredScope);

                if (auth.Session == null)
                {
                    await auth.LoginAsync(requiredScope);
                }
                LiveConnectClient liveClient = new LiveConnectClient(auth.Session);

                string folderid = await GetSkyDriveFolderID(FOLDER, liveClient);

                if (folderid == null)
                {
                    folderid = await createSkyDriveFolder(FOLDER, liveClient);

                    res = "Created folder: " + FOLDER + "\n"; // , "ID:", folderid);
                }

                var store = IsolatedStorageFile.GetUserStoreForApplication();
                if (store.FileExists(filename))
                {
                    var file = store.OpenFile(filename, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                    LiveOperationResult operationResult = await liveClient.UploadAsync(folderid, filename, file, OverwriteOption.Overwrite);

                    dynamic result = operationResult.Result;
                    res += "Uploaded :" + result.name; //, "ID:", result.id);
                }
                else
                {
                    throw new Exception("file does not exist");
                }
            }
            catch (Exception exception)
            {
                res = "Error uploading file: " + exception.Message;
            }
            return(res);
        }
示例#18
0
        // TODO: REMOVE Login() / Logout() / OnLiveAuthCompleted() / etc. from this library, as they should not take a dependency
        //       specifically on the Desktop Live ID library
        public void Login()
        {
            var liveAuthClient = new LiveAuthClient("000000004811DB42");

            string startUrl = liveAuthClient.GetLoginUrl(new List <string>()
            {
                "service::prodkds.dns-cargo.com::MBI_SSL"
            });

            var authForm = new LiveAuthWindow(
                startUrl,
                this.OnLiveAuthCompleted,
                "Login to the Microsoft Account associated with your Band"
                );

            authForm.Login();
        }
        private async static Task <int> LogClient()
        {
            //  create OneDrive auth client
            var authClient = new LiveAuthClient("000000004814E746");

            //  ask for both read and write access to the OneDrive
            LiveLoginResult result = await authClient.LoginAsync(new string[] { "wl.skydrive", "wl.skydrive_update" });

            //  if login successful
            if (result.Status == LiveConnectSessionStatus.Connected)
            {
                //  create a OneDrive client
                LiveClient = new LiveConnectClient(result.Session);
                return(1);
            }
            return(0);
        }
示例#20
0
        private static ZumoTest CreateLiveSDKLoginTest()
        {
            return(new ZumoTest("Login via token with Live SDK", async delegate(ZumoTest test)
            {
                var client = ZumoTestGlobals.Instance.Client;
#if !WINDOWS_PHONE
                var uri = client.ApplicationUri.ToString();
                var liveIdClient = new LiveAuthClient(uri);
#else
                string clientId;
                testPropertyBag.TryGetValue(ClientIdKeyName, out clientId);
                if (clientId == null)
                {
                    test.AddLog("ClientId of Microsoft application not entered correctly.");
                    return false;
                }

                var liveIdClient = new LiveAuthClient(clientId);
#endif
                var liveLoginResult = await liveIdClient.LoginAsync(new string[] { "wl.basic" });
                if (liveLoginResult.Status == LiveConnectSessionStatus.Connected)
                {
                    var liveConnectClient = new LiveConnectClient(liveLoginResult.Session);
                    var me = await liveConnectClient.GetAsync("me");
                    test.AddLog("Logged in as {0}", me.RawResult);
                    if (liveLoginResult.Session.AuthenticationToken == null)
                    {
                        test.AddLog("Error, authentication token in the live login result is null");
                        return false;
                    }
                    else
                    {
                        var token = new JObject(new JProperty("authenticationToken", liveLoginResult.Session.AuthenticationToken));
                        var user = await client.LoginAsync(MobileServiceAuthenticationProvider.MicrosoftAccount, token);
                        test.AddLog("Logged in as {0}", user.UserId);
                        return true;
                    }
                }
                else
                {
                    test.AddLog("Login failed.");
                    return false;
                }
            }, ZumoTestGlobals.RuntimeFeatureNames.LIVE_LOGIN));
        }
        private LiveLoginResult GenerateLoginResultFrom(Stream responseStream)
        {
            IDictionary <string, object> jsonObj;

            try
            {
                using (var reader = new StreamReader(responseStream))
                {
                    var jsReader = new JsonReader(reader.ReadToEnd());
                    jsonObj = jsReader.ReadValue() as IDictionary <string, object>;
                }
            }
            catch (FormatException fe)
            {
                return(new LiveLoginResult(
                           new LiveAuthException(AuthErrorCodes.ServerError, fe.Message)));
            }

            if (jsonObj == null)
            {
                return(new LiveLoginResult(
                           new LiveAuthException(AuthErrorCodes.ServerError, ResourceHelper.GetString("ServerError"))));
            }

            if (jsonObj.ContainsKey(AuthConstants.Error))
            {
                var errorCode = jsonObj[AuthConstants.Error] as string;
                if (errorCode.Equals(AuthErrorCodes.InvalidGrant, StringComparison.Ordinal))
                {
                    return(new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null));
                }

                string errorDescription = string.Empty;
                if (jsonObj.ContainsKey(AuthConstants.ErrorDescription))
                {
                    errorDescription = jsonObj[AuthConstants.ErrorDescription] as string;
                }

                return(new LiveLoginResult(new LiveAuthException(errorCode, errorDescription)));
            }

            LiveConnectSession newSession = LiveAuthClient.CreateSession(this.AuthClient, jsonObj);

            return(new LiveLoginResult(LiveConnectSessionStatus.Connected, newSession));
        }
示例#22
0
        public async Task <LiveConnectClient> Login()
        {
            AuthClient = new LiveAuthClient("000000004015B444");

            LiveLoginResult result = await AuthClient.InitializeAsync(new string[] { "wl.signin", "wl.skydrive" });

            if (result.Status == LiveConnectSessionStatus.Connected)
            {
                return(new LiveConnectClient(result.Session));
            }
            result = await AuthClient.LoginAsync(new string[] { "wl.signin", "wl.skydrive" });

            if (result.Status == LiveConnectSessionStatus.Connected)
            {
                return(new LiveConnectClient(result.Session));
            }
            return(null);
        }
    public async Task <LiveConnectClient> Login()
    {
        _authClient = new LiveAuthClient("**your client id here**");

        LiveLoginResult result = await _authClient.InitializeAsync(Scopes);

        if (result.Status == LiveConnectSessionStatus.Connected)
        {
            return(new LiveConnectClient(result.Session));
        }
        result = await _authClient.LoginAsync(Scopes);

        if (result.Status == LiveConnectSessionStatus.Connected)
        {
            return(new LiveConnectClient(result.Session));
        }
        return(null);
    }
示例#24
0
        public async Task <UserInfo> Authenticate()
        {
            var authClient = new LiveAuthClient();
            var authResult = await authClient.LoginAsync(new List <string>() { "wl.signin", "wl.basic", "wl.skydrive" });

            if (authResult.Status == LiveConnectSessionStatus.Connected)
            {
                var session      = authResult.Session;
                var client       = new LiveConnectClient(session);
                var liveOpResult = await client.GetAsync("me");

                dynamic dynResult = liveOpResult.Result;
                return(new UserInfo {
                    Id = dynResult.id, UserName = dynResult.name, Name = dynResult.name
                });
            }
            return(null);
        }
        private async void btnDisplayProfile_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                LiveAuthClient auth = new LiveAuthClient();

                LiveConnectClient   liveClient      = new LiveConnectClient(auth.Session);
                LiveOperationResult operationResult = await liveClient.GetAsync("me/picture");

                dynamic     result = operationResult.Result;
                BitmapImage image  = new BitmapImage(new Uri(result.location, UriKind.Absolute));
                this.imgResult.Source = image;
            }
            catch (LiveConnectException exception)
            {
                this.infoTextBlock.Text = "Error getting user picture: " + exception.Message;
            }
        }
示例#26
0
        public override async Task LoginAsync(IList <string> scopes)
        {
            if (string.IsNullOrEmpty(ClientId))
            {
                EtcUtility.Instance.MsgBox("ClientId Required");
                return;
            }

            if (AuthClient == null)
            {
                AuthClient = authClient = new LiveAuthClient(ClientId);
            }
            else
            {
                authClient = (LiveAuthClient)AuthClient;
            }

            try
            {
                IsBusy = true;
                await TaskEx.Run(() =>
                {
                    StaticFunctions.InvokeIfRequiredAsync(StaticFunctions.BaseContext,
                                                          para =>
                    {
                        //authClient.LoginCompleted +=
                        //    (s, e) =>
                        //    {
                        //        if (e.Status == LiveConnectSessionStatus.Connected)
                        //        {
                        //            LoadUser();
                        //        }
                        //    };
                        //두번째 접속 시도
                        authClient.LoginAsync(scopes);
                    }, null);
                });
            }
            catch (Exception ex)
            {
                EtcUtility.Instance.MsgBox("NotConnectLiveID " + ex.Message);
            }
        }
示例#27
0
        public async Task <bool> SignInSkydrive()
        {
            try
            {
                _authClient = new LiveAuthClient();
                LiveLoginResult loginResult = await this._authClient.LoginAsync(scopes);

                if (loginResult.Status == LiveConnectSessionStatus.Connected)
                {
                    _liveClient = new LiveConnectClient(loginResult.Session);
                    _session    = loginResult.Session;
                    return(true);
                }
            }
            catch (LiveAuthException authExp)
            {
            }
            return(false);
        }
示例#28
0
        public async Task <ConnectionResult> UpdateConnectionAsync()
        {
            var authClient             = new LiveAuthClient();
            var sessionStatus          = LiveConnectSessionStatus.Unknown;
            LiveConnectSession session = null;

            try
            {
                // IMPORTANT!  The app MUST be associated with the store, or a (otherwise unhelpful) NullReferenceException
                // will be raised when calling the AuthClient methods.
                var loginResult = await authClient.InitializeAsync(_scopes);

                sessionStatus = loginResult.Status;
                session       = loginResult.Session;
            }
            catch (NullReferenceException)
            {
                // This is basically for the sake of example only, since an actual app obtained through the store will not have
                // the problem of not having been associated with the Windows Store.
                AppNotAssociatedWithStoreError(this, EventArgs.Empty);
                return(new ConnectionResult {
                    SessionStatus = LiveConnectSessionStatus.NotConnected, CanLogout = false
                });
            }
            catch (LiveAuthException ex)
            {
                // TODO - handle notification/display of error information
                //throw new InvalidOperationException("An error occurred during initialization.", ex);
            }

            // Set the current instance session based on the login
            var currentSession = sessionStatus == LiveConnectSessionStatus.Connected ? session : null;

            UpdateSession(currentSession);

            var result = new ConnectionResult
            {
                SessionStatus = sessionStatus,
                CanLogout     = authClient.CanLogout,
            };

            return(result);
        }
示例#29
0
        public override bool Logout()
        {
            LiveAuthClient authClient;

            if (AuthClient == null)
            {
                AuthClient = authClient = new LiveAuthClient();
            }
            else
            {
                authClient = (LiveAuthClient)AuthClient;
            }

            authClient.Logout();
            IsSignIn = false;
            User     = null;

            return(true);
        }
        private async void SignIn(object sender, RoutedEventArgs e)
        {
            try
            {
                LiveAuthClient  auth        = new LiveAuthClient();
                LiveLoginResult loginResult =
                    await auth.LoginAsync(new string[] { "wl.basic" });

                if (loginResult.Status == LiveConnectSessionStatus.Connected)
                {
                    this.infoTextBlock.Text = "Signed in.";
                }
            }
            catch (LiveAuthException exception)
            {
                this.infoTextBlock.Text = "Error signing in: "
                                          + exception.Message;
            }
        }
示例#31
0
        /// <summary>
        /// Upload a file to OneDrive
        /// </summary>
        /// <param name="Filename"></param>
        /// <param name="Content"></param>
        /// <returns></returns>
        public static async Task <int> UploadFileAsync(String Foldername, String Filename)
        {
            try
            {
                //  create OneDrive auth client
                var authClient = new LiveAuthClient();

                //  ask for both read and write access to the OneDrive
                LiveLoginResult result = await authClient.LoginAsync(new string[] { "wl.signin", "wl.skydrive", "wl.skydrive_update" });

                //  if login successful
                if (result.Status == LiveConnectSessionStatus.Connected)
                {
                    //  create a OneDrive client
                    liveClient = new LiveConnectClient(result.Session);

                    //  create a local file
                    StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(Filename);

                    //  create a folder
                    string folderID = await GetFolderIDAsync(Foldername, true);

                    if (string.IsNullOrEmpty(folderID))
                    {
                        //  return error
                        return(0);
                    }

                    //  upload local file to OneDrive
                    await liveClient.BackgroundUploadAsync(folderID, file.Name, file, OverwriteOption.Overwrite);

                    return(1);
                }
            }
            catch (Exception e)
            {
                return(e.Message.Length);
            }

            //  return error
            return(0);
        }
示例#32
0
        /// <summary>
        ///     Calls LiveAuthClient.Initialize to get the user login status.
        ///     Retrieves user profile information if user is already signed in.
        /// </summary>
        private async void InitializePage()
        {
            try
            {
                this.authClient = new LiveAuthClient("0000000048087CFD");
                LiveLoginResult loginResult = await this.authClient.InitializeAsync(scopes);

                if (loginResult.Status == LiveConnectSessionStatus.Connected)
                {
                    this.btnLogin.Content = "Sign Out";

                    this.liveClient = new LiveConnectClient(loginResult.Session);
                    this.GetMe();
                }
            }
            catch (LiveAuthException authExp)
            {
                this.tbResponse.Text = authExp.ToString();
            }
        }
        public void TestExecute()
        {
            WebRequestFactory.Current = new TestWebRequestFactory();

#if NETFX_CORE
            LiveAuthClient authClient = new LiveAuthClient();
#elif WINDOWS_PHONE
            LiveAuthClient authClient = new LiveAuthClient("clientId");
#else
#error This platform needs to be handled.
#endif

            string clientId = "clientId";
            string refreshToken = "refreshToken";
            IEnumerable<string> scopes = new string[]{ "wl.basic" };
            SynchronizationContextWrapper syncContext = SynchronizationContextWrapper.Current;

            var refreshOperation =
                new RefreshTokenOperation(authClient, clientId, refreshToken, scopes, syncContext);
        }
示例#34
0
        public async static Task <bool> SilentLoginAsync()
        {
            try
            {
                _auth = new LiveAuthClient(ClientId);
                LiveLoginResult result = await _auth.InitializeAsync(Scopes);

                if (result.Status == LiveConnectSessionStatus.Connected)
                {
                    _client         = new LiveConnectClient(result.Session);
                    CurrentUserName = await GetUserNameAsync();

                    return(true);
                }
            }
            catch (Exception) { }
            _client = null;
            _auth   = null;
            return(false);
        }
        public void TestExecute()
        {
            WebRequestFactory.Current = new TestWebRequestFactory();

#if NETFX_CORE
            LiveAuthClient authClient = new LiveAuthClient();
#elif WINDOWS_PHONE
            LiveAuthClient authClient = new LiveAuthClient("clientId");
#else
#error This platform needs to be handled.
#endif

            string clientId     = "clientId";
            string refreshToken = "refreshToken";
            IEnumerable <string>          scopes      = new string[] { "wl.basic" };
            SynchronizationContextWrapper syncContext = SynchronizationContextWrapper.Current;

            var refreshOperation =
                new RefreshTokenOperation(authClient, clientId, refreshToken, scopes, syncContext);
        }
        private async Task Authenticate()
        {
            try
            {
                var liveIdClient = new LiveAuthClient("000000004810306D");
                var initResult   = await liveIdClient.InitializeAsync(scopes);

                _session = initResult.Session;

                if (null == _session)
                {
                    LiveLoginResult result = await liveIdClient.LoginAsync(scopes);

                    if (result.Status == LiveConnectSessionStatus.Connected)
                    {
                        _session = result.Session;
                        if (AuthenticationSuccessful != null)
                        {
                            AuthenticationSuccessful();
                        }
                    }
                    else
                    {
                        _session = null;
                        if (AuthenticationFailed != null)
                        {
                            AuthenticationFailed();
                        }
                        //MessageBox.Show("Unable to authenticate with Windows Live.", "Login failed :(", MessageBoxButton.OK);
                    }
                }

                if (AuthenticationSuccessful != null)
                {
                    AuthenticationSuccessful();
                }
            }
            catch (Exception)
            {
            }
        }
        /// <summary>
        /// Create a new RefreshTokenOperation object.
        /// </summary>
        /// <remarks>This constructor is used when exchanging the refresh token for the access token.</remarks>
        public RefreshTokenOperation(
            LiveAuthClient authClient, 
            string clientId, 
            string refreshToken, 
            IEnumerable<string> scopes,
            SynchronizationContextWrapper syncContext)
            : base(new Uri(authClient.ConsentEndpoint + LiveAuthClient.TokenEndpoint), 
                   null,   
                   syncContext)
        {
            Debug.Assert(authClient != null, "authClient must not be null.");
            Debug.Assert(!string.IsNullOrEmpty(clientId));
            Debug.Assert(!string.IsNullOrEmpty(refreshToken));

            this.AuthClient = authClient;

            this.Body = String.Format(
                RefreshTokenOperation.RefreshTokenPostBodyTemplate,
                HttpUtility.UrlEncode(clientId),
                refreshToken,
                HttpUtility.UrlEncode(LiveAuthClient.BuildScopeString(scopes)));
        }
        /// <summary>
        /// Create a new RefreshTokenOperation object.
        /// </summary>
        /// <remarks>This constructor is used when exchanging the verification code for the access token.</remarks>
        public RefreshTokenOperation(
            LiveAuthClient authClient,
            string clientId,
            string verificationCode,
            string redirectUri,
            SynchronizationContextWrapper syncContext)
            : base(new Uri(authClient.ConsentEndpoint + LiveAuthClient.TokenEndpoint), 
                   null, 
                   syncContext)
        {
            Debug.Assert(authClient != null, "authClient must not be null.");
            Debug.Assert(!string.IsNullOrEmpty(clientId));
            Debug.Assert(!string.IsNullOrEmpty(verificationCode));

            this.AuthClient = authClient;

            this.Body = String.Format(
                        RefreshTokenOperation.AuthCodePostBodyTemplate,
                        HttpUtility.UrlEncode(clientId),
                        HttpUtility.UrlEncode(verificationCode),
                        HttpUtility.UrlEncode(redirectUri));
        }
        public LiveConnectSession LoadSession(LiveAuthClient authClient)
        {
            ApplicationDataContainer appData = ApplicationData.Current.RoamingSettings;
            LiveConnectSession session = null;
            if (appData.Values.Count > 0)
            {
                session = new LiveConnectSession(authClient);

                if (appData.Values.ContainsKey(AuthConstants.AccessToken))
                {
                    session.AccessToken = appData.Values[AuthConstants.AccessToken] as string;
                }

                if (appData.Values.ContainsKey(AuthConstants.AuthenticationToken))
                {
                    session.AuthenticationToken = appData.Values[AuthConstants.AuthenticationToken] as string;
                }

                if (appData.Values.ContainsKey(AuthConstants.RefreshToken))
                {
                    session.RefreshToken = appData.Values[AuthConstants.RefreshToken] as string;
                }

                if (appData.Values.ContainsKey(AuthConstants.Expires))
                {
                    session.Expires = (DateTimeOffset)appData.Values[AuthConstants.Expires];
                }

                if (appData.Values.ContainsKey(AuthConstants.Scope))
                {
                    session.Scopes = LiveAuthClient.ParseScopeString(appData.Values[AuthConstants.Scope] as string);
                    TestAuthClient.Scopes = session.Scopes;
                }
            }

            return session;
        }
 public TestAuthClient(LiveAuthClient liveAuthClient)
 {
     this.liveAuthClient = liveAuthClient;
 }
 public void TestCanLogout()
 {
     var authClient = new LiveAuthClient(string.Empty);
     Assert.IsFalse(authClient.CanLogout);
 }
 public void LiveAuthClient_GetUserId_Empty()
 {
     LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
     string uid = authClient.GetUserId("");            
 }
 public void LiveAuthClient_GetUserId_Invalid()
 {
     LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
     string uid = authClient.GetUserId("etaeetwetw");
 }
 public void LiveAuthClient_GetLogoutUrl_Normal()
 {
     LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
     string url = authClient.GetLogoutUrl("http://www.foo.com/callback");
     Assert.AreEqual("https://login.live.com/oauth20_logout.srf?client_id=000000004802B729&redirect_uri=http%3A%2F%2Fwww.foo.com%2Fcallback", url);
  }
 public void LiveAuthClient_GetLoginUrl_InvalidSchemeRedirectUrl()
 {
     LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
     string url = authClient.GetLoginUrl(new string[] { "wl.signin" }, "ftp://www.foo.com/callback", null);
 }
 public void LiveAuthClient_GetLoginUrl_WhiteSpaceRedirectUrl()
 {
     LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
     string url = authClient.GetLoginUrl(new string[] { "wl.signin" }, " ", null);
 }
 public void LiveAuthClient_GetLoginUrl_WithEmptyScopes()
 {
     LiveAuthClient authClient = new LiveAuthClient("000000004802B729", "password", null);
     string url = authClient.GetLoginUrl(new string[] { }, "https://www.foo.com", null);
 }
 public LiveConnectSession LoadSession(LiveAuthClient authClient)
 {
     return null;
 }