public PincodeOptions(PincodeScreen screen, Account user, string passcode) { Screen = screen; User = user; Passcode = passcode; Policy = User.Policy; }
public static DBOpenHelper GetOpenHelper(string dbNamePrefix, Account account, string communityId) { var dbName = new StringBuilder(dbNamePrefix); // If we have account information, we will use it to create a database suffix for the user. if (account != null) { // Default user path for a user is 'internal', if community ID is null. if (String.IsNullOrWhiteSpace(communityId)) { dbName.Append(communityId); } } dbName.Append(DBNameSuffix); DBOpenHelper helper = null; if (_openHelpers == null) { _openHelpers = new Dictionary<string, DBOpenHelper>(); helper = new DBOpenHelper(dbName.ToString()); _openHelpers.Add(dbName.ToString(), helper); } else { if (!_openHelpers.TryGetValue(dbName.ToString(), out helper)) { helper = new DBOpenHelper(dbName.ToString()); } } return helper; }
/// <summary> /// Returns the instance of this class associated with this user and community. /// </summary> /// <param name="account"></param> /// <param name="communityId"></param> /// <returns></returns> public static MetadataManager GetInstance(Account account, string communityId = null) { if (account == null) { account = AccountManager.GetAccount(); } if (account == null) { return null; } string uniqueId = Constants.GenerateAccountCommunityId(account, communityId); lock (Synclock) { MetadataManager instance = null; if (_instances != null) { if (_instances.TryGetValue(uniqueId, out instance)) { return instance; } instance = new MetadataManager(account, communityId); _instances.Add(uniqueId, instance); } else { _instances = new Dictionary<string, MetadataManager>(); instance = new MetadataManager(account, communityId); _instances.Add(uniqueId, instance); } return instance; } }
/// <summary> /// Persist account /// </summary> /// <param name="account"></param> public void PersistCredentials(Account account) { // TODO use PasswordVault ApplicationDataContainer settings = ApplicationData.Current.RoamingSettings; string accountJson = Account.ToJson(account); settings.Values[ACCOUNT_SETTING] = accountJson; }
public static DBOpenHelper GetOpenHelper(Account account) { lock (Dbopenlock) { return GetOpenHelper(account, null); } }
public static async Task<bool> SwitchToAccount(Account account) { if (account != null && account.UserId != null) { AuthStorageHelper.SavePinTimer(); AuthStorageHelper.GetAuthStorageHelper().PersistCredentials(account); RestClient client = SDKManager.GlobalClientManager.PeekRestClient(); if (client != null) { OAuth2.ClearCookies(account.GetLoginOptions()); IdentityResponse identity = await OAuth2.CallIdentityService(account.IdentityUrl, client); if (identity != null) { account.UserId = identity.UserId; account.UserName = identity.UserName; account.Policy = identity.MobilePolicy; AuthStorageHelper.GetAuthStorageHelper().PersistCredentials(account); } OAuth2.RefreshCookies(); PlatformAdapter.SendToCustomLogger("AccountManager.SwitchToAccount - done, result = true", LoggingLevel.Verbose); return true; } } PlatformAdapter.SendToCustomLogger("AccountManager.SwitchToAccount - done, result = false", LoggingLevel.Verbose); return false; }
public static bool SwitchToAccount(Account account) { if (account != null && account.UserId != null) { AuthStorage.PersistCredentials(account); } return false; }
public void TestPersistRetrieveDeleteCredentials() { Account account = new Account("loginUrl", "clientId", "callbackUrl", new string[] { "scopeA", "scopeB" }, "instanceUrl", "accessToken", "refreshToken"); IAuthStorageHelper authStorageHelper = PlatformAdapter.Resolve<IAuthStorageHelper>(); CheckAccount(null); authStorageHelper.PersistCredentials(account); CheckAccount(account); authStorageHelper.DeletePersistedCredentials(); CheckAccount(null); }
/// <summary> /// Persist account /// </summary> /// <param name="account"></param> public void PersistCredentials(Account account) { // TODO store encrypted credentials IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings; string accountJson = Account.ToJson(account); if (settings.Contains(ACCOUNT_SETTING)) { settings[ACCOUNT_SETTING] = accountJson; } else { settings.Add(ACCOUNT_SETTING, accountJson); } settings.Save(); }
public void TestPersistRetrieveDeleteCredentials() { Account account = new Account("loginUrl", "clientId", "callbackUrl", new string[] { "scopeA", "scopeB" }, "instanceUrl", "identityUrl", "accessToken", "refreshToken"); account.UserId = "userId"; account.UserName = "******"; AuthStorageHelper authStorageHelper = new AuthStorageHelper(); CheckAccount(account, false); TypeInfo auth = authStorageHelper.GetType().GetTypeInfo(); MethodInfo persist = auth.GetDeclaredMethod("PersistCredentials"); MethodInfo delete = auth.GetDeclaredMethods("DeletePersistedCredentials").First(method => method.GetParameters().Count() == 1); persist.Invoke(authStorageHelper, new object[] { account }); CheckAccount(account, true); delete.Invoke(authStorageHelper, new object[] { account.UserId }); CheckAccount(account, false); }
/// <summary> /// Resets the Sync manager associated with this user and community. /// </summary> /// <param name="account"></param> /// <param name="communityId"></param> public static void Reset(Account account, string communityId = null) { if (account == null) { account = AccountManager.GetAccount(); } if (account != null) { lock (Synclock) { MetadataManager instance = GetInstance(account, communityId); if (instance == null) return; _instances.Remove(Constants.GenerateAccountCommunityId(account, communityId)); } } }
/// <summary> /// Persist account, and sets account as the current account. /// </summary> /// <param name="account"></param> internal void PersistCredentials(Account account) { // TODO use PasswordVault ApplicationDataContainer settings = ApplicationData.Current.LocalSettings; Dictionary<string, Account> accounts = RetrievePersistedCredentials(); if (accounts.ContainsKey(account.UserId)) { accounts[account.UserId] = account; } else { accounts.Add(account.UserId, account); } String accountJson = JsonConvert.SerializeObject(accounts); settings.Values[ACCOUNT_SETTING] = Encryptor.Encrypt(accountJson); settings.Values[CURRENT_ACCOUNT] = Encryptor.Encrypt(account.UserId); LoginOptions options = new LoginOptions(account.LoginUrl, account.ClientId, account.CallbackUrl, account.Scopes); SalesforceConfig.LoginOptions = options; }
private void CheckAccount(Account expectedAccount) { IAuthStorageHelper authStorageHelper = PlatformAdapter.Resolve<IAuthStorageHelper>(); Account account = authStorageHelper.RetrievePersistedCredentials(); if (expectedAccount == null) { Assert.IsNull(account, "No account should have been found"); } else { Assert.AreEqual(expectedAccount.LoginUrl, account.LoginUrl); Assert.AreEqual(expectedAccount.ClientId, account.ClientId); Assert.AreEqual(expectedAccount.CallbackUrl, account.CallbackUrl); Assert.AreEqual(expectedAccount.Scopes.Length, account.Scopes.Length); Assert.AreEqual(expectedAccount.InstanceUrl, account.InstanceUrl); Assert.AreEqual(expectedAccount.AccessToken, expectedAccount.AccessToken); Assert.AreEqual(expectedAccount.RefreshToken, expectedAccount.RefreshToken); } }
public static DBOpenHelper GetOpenHelper(Account account, string communityId) { string dbName = String.Format(DBName, ""); if (account == null) return _defaultHelper ?? (_defaultHelper = new DBOpenHelper(dbName)); var uniqueId = account.UserId; DBOpenHelper helper = null; if (_openHelpers == null) { _openHelpers = new Dictionary<string, DBOpenHelper>(); helper = new DBOpenHelper(String.Format(DBName, uniqueId)); _openHelpers.Add(uniqueId, helper); } else { if (!_openHelpers.TryGetValue(uniqueId, out helper)) { helper = new DBOpenHelper(dbName); } } return helper; }
private void CheckAccount(Account expectedAccount, bool exists) { AuthStorageHelper authStorageHelper = new AuthStorageHelper(); TypeInfo auth = authStorageHelper.GetType().GetTypeInfo(); MethodInfo retrieve = auth.GetDeclaredMethod("RetrievePersistedCredentials"); var accounts = (Dictionary<string, Account>) retrieve.Invoke(authStorageHelper, null); if (!exists) { Assert.IsFalse(accounts.ContainsKey(expectedAccount.UserId), "Account " + expectedAccount.UserId + " should not have been found"); } else { Assert.IsTrue(accounts.ContainsKey(expectedAccount.UserId), "Account " + expectedAccount.UserId + " should exist"); Account account = accounts[expectedAccount.UserId]; Assert.AreEqual(expectedAccount.LoginUrl, account.LoginUrl); Assert.AreEqual(expectedAccount.ClientId, account.ClientId); Assert.AreEqual(expectedAccount.CallbackUrl, account.CallbackUrl); Assert.AreEqual(expectedAccount.Scopes.Length, account.Scopes.Length); Assert.AreEqual(expectedAccount.InstanceUrl, account.InstanceUrl); Assert.AreEqual(expectedAccount.AccessToken, expectedAccount.AccessToken); Assert.AreEqual(expectedAccount.RefreshToken, expectedAccount.RefreshToken); } }
private MetadataManager(Account account, string communityId) { _apiVersion = ApiVersionStrings.VersionNumber; _communityId = communityId; _cacheManager = CacheManager.GetInstance(account, communityId); }
public Task PersistCurrentAccountAsync(Account account) { AuthStorageHelper.GetAuthStorageHelper().PersistCurrentCredentials(account); return Task.FromResult(0); }
public static async Task<bool> HasSmartStore(Account account) { var path = DBOpenHelper.GetOpenHelper(account).DatabaseFile; return await AppInfoService.DoesFileExistAsync(path); }
public static string GenerateDatabasePath(Account account) { DBOpenHelper open = DBOpenHelper.GetOpenHelper(account); var localPath = AppInfoService.GetApplicationLocalFolderPath(); return Path.Combine(localPath, open.DatabaseFile); }
private SmartStore(Account account) { _databasePath = GenerateDatabasePath(account); CreateMetaTables(); }
/// <summary> /// Persist account, and sets account as the current account. /// </summary> /// <param name="account"></param> internal void PersistCurrentCredentials(Account account) { var userCredentials = SafeRetrieveUser(PasswordVaultAccounts, account.UserName); if (userCredentials != null) { LoggingService.Log("removing existing credential", LoggingLevel.Verbose); _vault.Remove(userCredentials); // clear the current account from the password vault try { var current = _vault.FindAllByResource(PasswordVaultCurrentAccount); if (current != null) { foreach (var user in current) { _vault.Remove(user); } } } catch (Exception) { LoggingService.Log("did not find existing logged in user while persisting", LoggingLevel.Verbose); } } var serialized = EncryptionService.Encrypt(JsonConvert.SerializeObject(account)); if (account.UserName != null) { _vault.Add(new PasswordCredential(PasswordVaultAccounts, account.UserName, serialized)); _vault.Add(new PasswordCredential(PasswordVaultCurrentAccount, account.UserName, serialized)); } var options = new LoginOptions(account.LoginUrl, account.ClientId, account.CallbackUrl, LoginOptions.DefaultDisplayType, account.Scopes); SalesforceConfig.LoginOptions = options; LoggingService.Log("done adding info to vault", LoggingLevel.Verbose); }
/// <summary> /// Serialize Account object as a JSON string /// </summary> /// <param name="account"></param> /// <returns></returns> public static string ToJson(Account account) { return JsonConvert.SerializeObject(account); }
/// <summary> /// Create and persist Account for newly authenticated user /// </summary> /// <param name="loginOptions"></param> /// <param name="authResponse"></param> public static async Task<Account> CreateNewAccount(LoginOptions loginOptions, AuthResponse authResponse) { LoggingService.Log("Create account object", LoggingLevel.Verbose); var account = new Account( loginOptions.LoginUrl, loginOptions.ClientId, loginOptions.CallbackUrl, loginOptions.Scopes, authResponse.InstanceUrl, authResponse.IdentityUrl, authResponse.AccessToken, authResponse.RefreshToken) { CommunityId = authResponse.CommunityId, CommunityUrl = authResponse.CommunityUrl }; var cm = new ClientManager(); cm.PeekRestClient(); IdentityResponse identity = null; try { identity = await OAuth2.CallIdentityServiceAsync(authResponse.IdentityUrl, authResponse.AccessToken); } catch (JsonException ex) { LoggingService.Log("Exception occurred when retrieving account identity:", LoggingLevel.Critical); LoggingService.Log(ex, LoggingLevel.Critical); Debug.WriteLine("Error retrieving account identity"); } if (identity != null) { account.UserId = identity.UserId; account.UserName = identity.UserName; account.Policy = identity.MobilePolicy; account.OrganizationId = identity.OrganizationId; await AuthStorageHelper.PersistCurrentAccountAsync(account); LoggedInAccount = account; } LoggingService.Log("Finished creating account", LoggingLevel.Verbose); return account; }
/// <summary> /// Create and persist Account for newly authenticated user /// </summary> /// <param name="loginOptions"></param> /// <param name="authResponse"></param> public static async Task<Account> CreateNewAccount(LoginOptions loginOptions, AuthResponse authResponse) { PlatformAdapter.SendToCustomLogger("AccountManager.CreateNewAccount - create account object", LoggingLevel.Verbose); var account = new Account(loginOptions.LoginUrl, loginOptions.ClientId, loginOptions.CallbackUrl, loginOptions.Scopes, authResponse.InstanceUrl, authResponse.IdentityUrl, authResponse.AccessToken, authResponse.RefreshToken); account.CommunityId = authResponse.CommunityId; account.CommunityUrl = authResponse.CommunityUrl; var cm = new ClientManager(); cm.PeekRestClient(); IdentityResponse identity = null; try { identity = await OAuth2.CallIdentityService(authResponse.IdentityUrl, authResponse.AccessToken); } catch (JsonException ex) { PlatformAdapter.SendToCustomLogger( "AccountManager.CreateNewAccount - Exception occurred when retrieving account identity:", LoggingLevel.Critical); PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Critical); Debug.WriteLine("Error retrieving account identity"); } if (identity != null) { account.UserId = identity.UserId; account.UserName = identity.UserName; account.Policy = identity.MobilePolicy; AuthStorageHelper.GetAuthStorageHelper().PersistCredentials(account); } PlatformAdapter.SendToCustomLogger("AccountManager.CreateNewAccount - done", LoggingLevel.Verbose); return account; }
/// <summary> /// Raises the account changed event. This method exists because AuthStorageHelper truly knows when /// an account changes but the event belongs in the AccountManager class, so this method is necessary /// to enable AuthStorageHelper to raise that event. /// </summary> private static void RaiseAuthenticatedAccountChangedEvent(Account oldAccount, Account newAccount) { AuthenticatedAccountChanged?.Invoke(new AuthenticatedAccountChangedEventArgs(oldAccount, newAccount)); }
public static SmartStore GetSmartStore(Account account) { var store = new SmartStore(account); return store; }
/// <summary> /// Create and persist Account for newly authenticated user /// </summary> /// <param name="loginOptions"></param> /// <param name="authResponse"></param> public static void CreateNewAccount(LoginOptions loginOptions, AuthResponse authResponse) { Account account = new Account(loginOptions.LoginUrl, loginOptions.ClientId, loginOptions.CallbackUrl, loginOptions.Scopes, authResponse.InstanceUrl, authResponse.AccessToken, authResponse.RefreshToken); PlatformAdapter.Resolve<IAuthStorageHelper>().PersistCredentials(account); }
/// <summary> /// Delete Account (log out) for currently authenticated user /// </summary> public static void DeleteAccount() { var account = GetAccount(); if (account == null) { return; } AuthStorageHelper.DeletePersistedAccount(account.UserName, account.UserId); LoggedInAccount = null; }
/// <summary> /// Async method for refreshing the token, persisting the data in the encrypted settings and returning the updated /// account /// with the new access token. /// </summary> /// <param name="account"></param> /// <returns>Boolean based on if the refresh auth token succeeded or not</returns> public static async Task<Account> RefreshAuthTokenAsync(Account account) { LoggingService.Log("Atempting to refresh auth token", LoggingLevel.Verbose); if (account == null) { return null; } try { var loginOptions = account.GetLoginOptions(); // args var argsStr = string.Format(OauthRefreshQueryString, loginOptions.ClientId, account.RefreshToken); // Refresh url var refreshUrl = loginOptions.LoginUrl + OauthRefreshPath; // Post var call = HttpCall.CreatePost(refreshUrl, argsStr); var response = await call.ExecuteAndDeserializeAsync<AuthResponse>(); account.AccessToken = response.AccessToken; account.IdentityUrl = response.IdentityUrl; await SDKServiceLocator.Get<IAuthHelper>().PersistCurrentAccountAsync(account); } catch (DeviceOfflineException ex) { LoggingService.Log("Failed to refresh the token because we were offline", LoggingLevel.Warning); LoggingService.Log(ex, LoggingLevel.Warning); throw; } catch (WebException ex) { LoggingService.Log("Exception occurred when refreshing token:", LoggingLevel.Critical); LoggingService.Log(ex, LoggingLevel.Critical); Debug.WriteLine("Error refreshing token"); throw new OAuthException(ex.Message, ex); } catch (Exception ex) { LoggingService.Log("Exception occurred when refreshing token:", LoggingLevel.Critical); LoggingService.Log(ex, LoggingLevel.Critical); Debug.WriteLine("Error refreshing token"); throw new OAuthException(ex.Message, ex); } return account; }
public JSONCredentials(Account account, RestClient client) { AccessToken = client.AccessToken; LoginUrl = account.LoginUrl; InstanceUrl = account.InstanceUrl; ClientId = account.ClientId; RefreshToken = account.RefreshToken; UserAgent = "SalesforceMobileSDK/2.0 windows phone"; // FIXME // TODO wire through the other fields }