public static async void ClearCookies(LoginOptions loginOptions)
{
var frame = Window.Current.Content as Frame;
if (frame != null)
{
await frame.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var loginUri = new Uri(ComputeAuthorizationUrl(loginOptions));
var myFilter = new HttpBaseProtocolFilter();
HttpCookieManager cookieManager = myFilter.CookieManager;
try
{
PlatformAdapter.SendToCustomLogger("OAuth.ClearCookies - attempting at clearing cookies", LoggingLevel.Verbose);
HttpCookieCollection cookies = cookieManager.GetCookies(loginUri);
foreach (HttpCookie cookie in cookies)
{
cookieManager.DeleteCookie(cookie);
}
PlatformAdapter.SendToCustomLogger("OAuth2.ClearCookies - done", LoggingLevel.Verbose);
}
catch (ArgumentException ex)
{
PlatformAdapter.SendToCustomLogger("OAuth2.ClearCookies - Exception occurred when clearing cookies:", LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Critical);
Debug.WriteLine("Error clearing cookies");
}
});
}
}
/// <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> RefreshAuthToken(Account account)
{
if (account != null)
{
try
{
AuthResponse response =
await RefreshAuthTokenRequest(account.GetLoginOptions(), account.RefreshToken);
account.AccessToken = response.AccessToken;
AuthStorageHelper.GetAuthStorageHelper().PersistCredentials(account);
}
catch (WebException ex)
{
PlatformAdapter.SendToCustomLogger(
"OAuth2.RefreshAuthToken - Exception occurred when refreshing token:", LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Critical);
Debug.WriteLine("Error refreshing token");
throw new OAuthException(ex.Message, ex.Status);
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(
"OAuth2.RefreshAuthToken - Exception occurred when refreshing token:", LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Critical);
Debug.WriteLine("Error refreshing token");
throw new OAuthException(ex.Message, ex.InnerException);
}
}
return(account);
}
/// <summary>
/// Called when bringing up page and user is authenticated but web view has not been loaded yet
/// </summary>
protected void OnResumeLoggedInNotLoaded()
{
PlatformAdapter.SendToCustomLogger("HybridMainPage.OnResumeLoggedInNotLoaded called", LoggingLevel.Verbose);
// Local
if (_bootConfig.IsLocal)
{
Log("Success:Loading local application");
LoadLocalStartPage();
}
// Remote
else
{
// Online
if (NetworkInterface.GetIsNetworkAvailable())
{
Log("Success:Loading remote application");
LoadRemoteStartPage();
}
// Offline
else
{
// Has cached version
if (false /* FIXME */)
{
Log("Success:Loading cached version of remote application because offline");
}
// No cached version
Log("Error:Can't load remote application offline without cached version");
LoadErrorPage();
}
}
}
public static void RefreshCookies()
{
PlatformAdapter.SendToCustomLogger("OAuth.RefreshCookies - attempting at refreshing cookies", LoggingLevel.Verbose);
Account account = AccountManager.GetAccount();
if (account != null)
{
var loginUri = new Uri(account.LoginUrl);
var instanceUri = new Uri(account.InstanceUrl);
var filter = new HttpBaseProtocolFilter();
var cookie = new HttpCookie("salesforce", loginUri.Host, "/");
cookie.Secure = true;
cookie.Value = account.AccessToken;
filter.CookieManager.SetCookie(cookie, false);
var instance = new HttpCookie("salesforceInstance", instanceUri.Host, "/");
instance.Secure = true;
instance.Value = account.AccessToken;
filter.CookieManager.SetCookie(instance, false);
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, instanceUri);
var web = new WebView();
web.NavigateWithHttpRequestMessage(httpRequestMessage);
}
PlatformAdapter.SendToCustomLogger("OAuth.RefreshCookies - done", LoggingLevel.Verbose);
}
public App()
{
// SfdcSDK
InitializeSfdcConfig();
SDKManager.CreateClientManager(false);
SDKManager.RootApplicationPage = typeof(VisualBrowserPage);
SDKManager.EndLoginCallBack = () => { Messenger.Default.Send(new UserLogInMessage()); };
PlatformAdapter.Resolve <ISFApplicationHelper>().Initialize();
// Set up the Logging Service and the custom log action function in the PlatformAdapter
var target = new LogFileTarget();
target.RetainDays = 10;
LoggingServices.DefaultConfiguration.AddTarget(LoggingLevel.Information, target);
PlatformAdapter.SetCustomLoggerAction(LoggingServices.LogAction);
// Continue App setup
InitializeComponent();
Suspending += OnSuspending;
Resuming += OnResuming;
// Setup the global crash handler
GlobalCrashHandler.Configure();
}
/// <summary>
/// Initialize Visual Browser
/// Load all necessary data
/// </summary>
protected override async Task Initialize()
{
try
{
_currentMobileConfiguration = await _mobileConfigurationDataService.GetCurrentMobileConfiguration();
Buttons = VisualBrowserViewModelBuilder.CreateButtonsViewModel(_currentMobileConfiguration, ShowCategory).ToList();
TopCategories = VisualBrowserViewModelBuilder.CreateCategoriesViewModel(_currentMobileConfiguration.TopCategories, _navigateToMediaCommand, IsInternalModeEnable, SubCategorySelectionAction);
ControlBarViewModel = new ControlBarViewModel(_dialogService, SettingsDataService, _mobileAppConfigDataService, _currentMobileConfiguration, _userSessionService, _contactsService, _presentationDataService, _syncLogService);
ExpandedCategories = new ObservableCollection <CategoryViewModel>();
SearchViewModel = new SearchControlViewModel(_documentInfoDataService, _searchContentDataService, _navigationService, _navigateToMediaCommand);
if (_orientation.HasValue)
{
RefreshButtons(_orientation.Value);
GetAllCategoryContent().ForEach(c => c.HandleOrientation(_orientation.Value));
}
await LoadBackgroundImage();
if (_orientation.HasValue)
{
BackgroundImage = ResolveBackgroundImage(_orientation.Value);
}
}
catch (Exception e)
{
PlatformAdapter.SendToCustomLogger(e, LoggingLevel.Error);
// Report error here
}
}
public AutomapperRegistry()
{
var platformSpecificRegistry = PlatformAdapter.Resolve <IPlatformSpecificMapperRegistry>();
platformSpecificRegistry.Initialize();
For <ConfigurationStore>().Singleton().Use <ConfigurationStore>()
.Ctor <IEnumerable <IObjectMapper> >().Is(MapperRegistry.Mappers);
For <IConfigurationProvider>().Use(ctx => ctx.GetInstance <ConfigurationStore>());
For <IConfiguration>().Use(ctx => ctx.GetInstance <ConfigurationStore>());
For <ITypeMapFactory>().Use <TypeMapFactory>();
For <IMappingEngine>().Singleton().Use <MappingEngine>()
.SelectConstructor(() => new MappingEngine(null));
this.Scan(scanner =>
{
scanner.AssemblyContainingType <PostProfile>();
scanner.AddAllTypesOf <Profile>().NameBy(item => item.Name);
//scanner.AssemblyContainingType<CommentProfile>();
//scanner.AddAllTypesOf<Profile>().NameBy(item => item.Name);
//scanner.AssembliesFromApplicationBaseDirectory();
scanner.ConnectImplementationsToTypesClosing(typeof(ITypeConverter <,>))
.OnAddedPluginTypes(t => t.HybridHttpOrThreadLocalScoped());
//scanner.ConnectImplementationsToTypesClosing(typeof(ValueResolver<,>))
// .OnAddedPluginTypes(t => t.HybridHttpOrThreadLocalScoped());
});
}
public async Task PushToStreamAsync(
Func <IOutputStream, IAsyncOperationWithProgress <ulong, ulong> > writeToStreamAsync,
IHttpContent content)
{
if (content == null)
{
throw new NullReferenceException("Parameter content is null");
}
if (writeToStreamAsync == null)
{
throw new NullReferenceException("Parameter writeToStreamAsync is null");
}
var attFolderMgr = AttachmentsFolder.Instance;
var attFolder = await attFolderMgr.CreateOrGetFolderForAttachmentId(_meta.Id, _syncId);
try
{
StorageFile newFile = await attFolder.CreateFileAsync(_meta.Name, CreationCollisionOption.ReplaceExisting);
using (var sfw = await newFile.OpenStreamForWriteAsync())
{
using (var outStream = sfw.AsOutputStream())
{
ulong x = await content.WriteToStreamAsync(outStream);
}
}
}
catch (UnauthorizedAccessException ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
Debug.WriteLine($"Exception Opening Attachment File For Write { _meta.Name } ");
}
}
private void RefreshSession(SalesforceOAuthPlugin plugin)
{
PlatformAdapter.SendToCustomLogger("HybridMainPage.RefreshSession - Making a REST call to refresh session", LoggingLevel.Verbose);
// Cheap REST call to refresh session
_client.SendAsync(RestRequest.GetRequestForResources(ApiVersion), response =>
{
if (plugin != null)
{
if (!response.Success)
{
PlatformAdapter.SendToCustomLogger(
string.Format("HybridMainPage.RefreshSession - Error = {0}", response.Error.ToString()), LoggingLevel.Verbose);
plugin.OnAuthenticateError(response.Error.Message);
}
else
{
PlatformAdapter.SendToCustomLogger("HybridMainPage.RefreshSession - refresh successful", LoggingLevel.Verbose);
plugin.OnAuthenticateSuccess(GetJSONCredentials());
}
}
});
}
private IEnumerable <PasswordCredential> SafeRetrieveResource(string resource)
{
try
{
PlatformAdapter.SendToCustomLogger(
string.Format(
"AuthStorageHelper.SafeRetrieveResource - Attempting to retrieve resource {0}",
resource), LoggingLevel.Verbose);
var list = _vault.RetrieveAll();
return(from item in list where resource.Equals(item.Resource) select item);
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(
string.Format(
"AuthStorageHelper.SafeRetrieveResource - Exception occured when retrieving vault data for resource {0}",
resource), LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Critical);
Debug.WriteLine("Failed to retrieve vault data for resource " + resource);
}
return(new List <PasswordCredential>());
}
public static async Task <bool> SwitchToAccount(Account account)
{
if (account != null && account.UserId != null)
{
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);
}
protected override async Task Initialize()
{
try
{
EditButtonDisabled = false;
var navigationCommand = new NavigateToMediaCommand(_navigationService, _historyDataService);
SearchViewModel = new SearchControlViewModel(_documentInfoDataService, _searchContentDataService, _navigationService, navigationCommand);
var data = await _playlistsDataService.GetPlayListsData();
_allPlaylists = PlaylistViewModelBuilder.Create(data, navigationCommand, _dialogService);
PopulateRemoveCommand(_allPlaylists);
SetInternalMode(_allPlaylists, IsInternalModeEnable);
PlayLists = _allPlaylists;
EditButtonText = ReadOnlyModeStateText;
var personalLibrarydata = await _playlistsDataService.GetPersonalLibrarData();
PersonalLibraryViewModel = PlaylistViewModelBuilder.Create(personalLibrarydata, navigationCommand, _dialogService);
PersonalLibraryViewModel.IsInternalMode = IsInternalModeEnable;
NewPlaylistViewModel = new NewPlaylistViewModel(this.PlayLists, new NavigateToMediaCommand(_navigationService, _historyDataService), _dialogService, (vm) => _allPlaylists.Remove(vm));
EditButtonDisabled = true;
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
}
}
public async void OnActivated(IActivatedEventArgs args)
{
CreateRootFrame();
await RestoreStatus(args.PreviousExecutionState);
if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
ContinuationManager.MarkAsStale();
}
PincodeManager.TriggerBackgroundedPinTimer();
if (args is IContinuationActivatedEventArgs)
{
var continueEvents = args as IContinuationActivatedEventArgs;
ContinuationManager.MarkAsStale();
try
{
PlatformAdapter.SendToCustomLogger("SFApplicationHelper.OnActivated - Calling ContinuationManager.Continue", LoggingLevel.Verbose);
ContinuationManager.Continue(continueEvents);
}
catch (InvalidOperationException e)
{
PlatformAdapter.SendToCustomLogger("SFApplicationHelper.OnActivated - Exception when calling ContinuationManager.Continue", LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(e, LoggingLevel.Critical);
Debug.WriteLine("Exception while continuing, " + e.StackTrace);
}
}
Window.Current.Activate();
}
private async Task <IInputStream> GetContent(string path)
{
if (path.ElementAt(0) == '/')
{
path = path.Remove(0, 1);
}
Stream zipStream = await _file.OpenStreamForReadAsync();
ZipArchive archive = new ZipArchive(zipStream, ZipArchiveMode.Read);
ZipArchiveEntry contentFile = archive.GetEntry(path);
if (contentFile == null)
{
throw new Exception("Invalid archive entry");
}
try
{
var zipASize = contentFile.Length;
IInputStream stream = await GetInputStreamFromIOStream(contentFile.Open(), zipASize);
return(stream);
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
return(null);
}
}
public static IStoreManager GetStoreManager(StoreConfiguration storeConfiguration = null)
{
if (storeConfiguration == null)
{
storeConfiguration = StoreConfiguration.DefaultStoreConfiguration;
}
if (storeConfiguration.StoreManagerType != null)
{
return
(Activator.CreateInstance(storeConfiguration.StoreManagerType, storeConfiguration) as IStoreManager);
}
#if BTREESTORE
#if SILVERLIGHT
return(new IsolatedStorageStoreManager(storeConfiguration));
#else
return(storeConfiguration.UseIsolatedStorage ? (IStoreManager) new IsolatedStorageStoreManager(storeConfiguration) : new FileStoreManager(storeConfiguration));
#endif
#else
#if WINDOWS_PHONE
return(new BPlusTreeStore.BPlusTreeStoreManager(storeConfiguration, new IsolatedStoragePersistanceManager()));
#elif PORTABLE
storeConfiguration.DisableBackgroundWrites = true;
return(new BPlusTreeStoreManager(storeConfiguration, PlatformAdapter.Resolve <IPersistenceManager>()));
#else
return(storeConfiguration.UseIsolatedStorage ? new BPlusTreeStore.BPlusTreeStoreManager(storeConfiguration, new IsolatedStoragePersistanceManager()) : new BPlusTreeStore.BPlusTreeStoreManager(storeConfiguration, new FilePersistenceManager()));
#endif
#endif
}
internal Account RetrieveCurrentAccount()
{
PasswordCredential creds = SafeRetrieveResource(PasswordVaultCurrentAccount).FirstOrDefault();
if (creds != null)
{
PasswordCredential account = _vault.Retrieve(creds.Resource, creds.UserName);
if (String.IsNullOrWhiteSpace(account.Password))
{
_vault.Remove(account);
}
else
{
try
{
PlatformAdapter.SendToCustomLogger(
"AuthStorageHelper.RetrieveCurrentAccount - getting current account", LoggingLevel.Verbose);
return(JsonConvert.DeserializeObject <Account>(Encryptor.Decrypt(account.Password)));
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(
"AuthStorageHelper.RetrieveCurrentAccount - Exception occured when decrypting account, removing account from vault",
LoggingLevel.Warning);
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Warning);
// if we can't decrypt remove the account
_vault.Remove(account);
}
}
}
return(null);
}
private PasswordCredential SafeRetrieveUser(string resource, string userName)
{
try
{
var list = SafeRetrieveResource(resource);
PlatformAdapter.SendToCustomLogger(
string.Format(
"AuthStorageHelper.SafeRetrieveUser - Attempting to retrieve user Resource={0} UserName={1}",
resource, userName), LoggingLevel.Verbose);
var passwordCredentials = list as IList <PasswordCredential> ?? list.ToList();
if (passwordCredentials.Any())
{
return(passwordCredentials.FirstOrDefault(n => userName.Equals(n.UserName)));
}
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(
string.Format(
"AuthStorageHelper.SafeRetrieveUser - Exception occured when retrieving vault data for resource {0}",
resource), LoggingLevel.Critical);
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Critical);
Debug.WriteLine("Failed to retrieve vault data for resource " + resource);
}
return(null);
}
/// <summary>
/// Persist account, and sets account as the current account.
/// </summary>
/// <param name="account"></param>
internal void PersistCredentials(Account account)
{
PasswordCredential creds = SafeRetrieveUser(PasswordVaultAccounts, account.UserName);
if (creds != null)
{
PlatformAdapter.SendToCustomLogger("AuthStorageHelper.PersistCredentials - removing existing credential", LoggingLevel.Verbose);
_vault.Remove(creds);
IReadOnlyList <PasswordCredential> current = _vault.FindAllByResource(PasswordVaultCurrentAccount);
if (current != null)
{
foreach (PasswordCredential user in current)
{
_vault.Remove(user);
}
}
}
string serialized = Encryptor.Encrypt(JsonConvert.SerializeObject(account));
_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;
PlatformAdapter.SendToCustomLogger("AuthStorageHelper.PersistCredentials - done adding info to vault", LoggingLevel.Verbose);
}
private static async Task SavePDFThumbnail(StorageFile file, StorageFolder folder)
{
PdfDocument pdfDocument;
try
{
pdfDocument = await PdfDocument.LoadFromFileAsync(file);
}
catch (Exception e)
{
PlatformAdapter.SendToCustomLogger(e, LoggingLevel.Error);
return;
}
if (pdfDocument == null)
{
return;
}
var currentPage = pdfDocument.GetPage(0);
var destinationFile = await folder.CreateFileAsync(ThumbnailName, CreationCollisionOption.GenerateUniqueName);
using (var strm = await destinationFile.OpenAsync(FileAccessMode.ReadWrite))
{
await currentPage.RenderToStreamAsync(strm, new PdfPageRenderOptions()
{
DestinationHeight = 300, DestinationWidth = 263
});
}
}
private async Task <IInputStream> GetInputStreamFromIOStream(Stream stream, long fileSize)
{
try
{
using (BinaryReader binReader = new BinaryReader(stream))
{
byte[] byteArr = binReader.ReadBytes((int)fileSize);
using (var iMS = new InMemoryRandomAccessStream())
{
var imsOutputStream = iMS.GetOutputStreamAt(0);
using (DataWriter dataWriter = new DataWriter(imsOutputStream))
{
dataWriter.WriteBytes(byteArr);
await dataWriter.StoreAsync();
await imsOutputStream.FlushAsync();
return(iMS.GetInputStreamAt(0));
}
}
}
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
return(null);
}
}
/// <summary>
/// This will return true if there is a master pincode set.
/// </summary>
/// <returns></returns>
public static bool IsPincodeSet()
{
bool result = AuthStorageHelper.GetAuthStorageHelper().RetrievePincode() != null;
PlatformAdapter.SendToCustomLogger(string.Format("AuthStorageHelper.IsPincodeSet - result = {0}", result), LoggingLevel.Verbose);
return(result);
}
/// <summary>
/// Configures the dialog to act as a confirmation for the entered pincode.
/// </summary>
private void SetupConfirm()
{
PlatformAdapter.SendToCustomLogger("PincodeDialog.SetupCreate - Configuring the dialog to act as a confirmation for the entered pincode", LoggingLevel.Information);
Title.Text = LocalizedStrings.GetString("passcode_reenter");
Description.Text = LocalizedStrings.GetString("passcode_confirm");
ContentFooter.Visibility = Visibility.Collapsed;
Passcode.KeyDown += ConfirmClicked;
}
public ControllerHelperI(string name, string[] args, MainPage page, PlatformAdapter platformAdapter)
{
_name = name;
_args = args;
_page = page;
_platformAdapter = platformAdapter;
_typename = name;
}
/// <summary>
/// This will wipe out the pincode and associated data.
/// </summary>
public static void WipePincode()
{
AuthStorageHelper auth = AuthStorageHelper.GetAuthStorageHelper();
auth.DeletePincode();
auth.DeleteData(PinBackgroundedTimeKey);
auth.DeleteData(PincodeRequired);
PlatformAdapter.SendToCustomLogger("PincodeManager.WipePincode - Pincode wiped", LoggingLevel.Verbose);
}
private static void RunExport(object jobData)
{
var exportJob = jobData as ExportJob;
if (exportJob == null)
{
return;
}
try
{
var storeDirectory = exportJob._storeWorker.WriteStore.DirectoryPath;
var exportDirectory = Path.Combine(Path.GetDirectoryName(storeDirectory), "import");
#if PORTABLE
var persistenceManager = PlatformAdapter.Resolve <IPersistenceManager>();
if (!persistenceManager.DirectoryExists(exportDirectory))
{
persistenceManager.CreateDirectory(exportDirectory);
}
var filePath = Path.Combine(exportDirectory, exportJob._outputFileName);
using (var stream = persistenceManager.GetOutputStream(filePath, FileMode.Create))
#else
if (!Directory.Exists(exportDirectory))
{
Directory.CreateDirectory(exportDirectory);
}
var filePath = Path.Combine(exportDirectory, exportJob._outputFileName);
Logging.LogDebug("Export file path calculated as '{0}'", filePath);
using (var stream = File.Open(filePath, FileMode.Create, FileAccess.Write))
#endif
{
string[] graphs = String.IsNullOrEmpty(exportJob._graphUri)
? null
: new[] { exportJob._graphUri };
var triples = exportJob._storeWorker.ReadStore.Match(null, null, null, graphs: graphs);
var sw = new StreamWriter(stream);
var sink = GetWriterSink(exportJob._exportFormat, sw);
var nw = new BrightstarTripleSinkAdapter(sink);
foreach (var triple in triples)
{
nw.Triple(triple);
}
sink.Close();
sw.Flush();
#if !PORTABLE
stream.Flush(true);
stream.Close();
#endif
}
exportJob._successCallback(exportJob._jobId);
}
catch (Exception ex)
{
Logging.LogError(BrightstarEventId.ExportDataError, "Error Exporting Data {0} {1}", ex.Message, ex.StackTrace);
exportJob._errorCallback(exportJob._jobId, ex);
}
}
/// <summary>
/// Returns a RestClient if user is already authenticated or otherwise kicks off a login flow
/// </summary>
/// <returns></returns>
public RestClient GetRestClient()
{
RestClient restClient = PeekRestClient();
if (restClient == null)
{
PlatformAdapter.Resolve <IAuthHelper>().StartLoginFlow();
}
return(restClient);
}
private static string GenerateEncryptedPincode(string pincode)
{
HashAlgorithmProvider alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
IBuffer buff = CryptographicBuffer.ConvertStringToBinary(pincode, BinaryStringEncoding.Utf8);
IBuffer hashed = alg.HashData(buff);
string res = CryptographicBuffer.EncodeToHexString(hashed);
PlatformAdapter.SendToCustomLogger("AuthStorageHelper.GenerateEncryptedPincode - Pincode generated, now encrypting and returning it", LoggingLevel.Verbose);
return(Encryptor.Encrypt(res));
}
public void PersistPincode(MobilePolicy policy)
{
DeletePincode();
var newPin = new PasswordCredential(PasswordVaultSecuredData, PasswordVaultPincode,
JsonConvert.SerializeObject(policy));
_vault.Add(newPin);
PlatformAdapter.SendToCustomLogger("AuthStorageHelper.PersistPincode - pincode added to vault",
LoggingLevel.Verbose);
}
public static IGraph LoadConfiguration(string configurationPath)
{
var pm = PlatformAdapter.Resolve <IPersistenceManager>();
ConfigurationLoader.PathResolver = new DotNetRdfConfigurationPathResolver(configurationPath);
using (var stream = pm.GetInputStream(configurationPath))
{
return(ConfigurationLoader.LoadConfiguration(configurationPath, new Uri(configurationPath), stream));
}
}
/// <summary>
/// Configures the dialog for creating a pincode.
/// </summary>
private void SetupCreate()
{
PlatformAdapter.SendToCustomLogger("PincodeDialog.SetupCreate - Configuring the dialog for creating a pincode", LoggingLevel.Information);
Title.Text = LocalizedStrings.GetString("passcode_create_title");
Description.Text = LocalizedStrings.GetString("passcode_create_security");
ContentFooter.Visibility = Visibility.Visible;
ContentFooter.Text = String.Format(LocalizedStrings.GetString("passcode_length"),
Options.User.Policy.PinLength);
Passcode.KeyDown += CreateClicked;
}
