/// <summary>
/// Initializes the commands and sets <see cref="CredentialTokens"/> to an empty collection.
/// The ViewModel must be activated before use.
/// </summary>
/// <param name="accessList">A list used to look up candidates to get their underlying files.</param>
/// <param name="exportService">Used to export stored files.</param>
/// <param name="proxyProvider">Provider to use for accessing stored databases.</param>
/// <param name="deletePrompter">Service to use for prompting user consent/understanding.</param>
/// <param name="updatePrompter">Service to use for prompting user consent/understanding.</param>
/// <param name="fileService">Service to use for accessing the filesystem.</param>
public CachedFilesViewModel(
IDatabaseAccessList accessList,
IFileExportService exportService,
IFileProxyProvider proxyProvider,
IUserPromptingService deletePrompter,
IUserPromptingService updatePrompter,
IFileAccessService fileService
) : base(accessList, proxyProvider, exportService, deletePrompter, updatePrompter, fileService)
{
this.accessList = accessList;
this.proxyProvider = proxyProvider;
this.deleteAllCommand = new AsyncActionCommand(
async() =>
{
if (await this.proxyProvider.TryDeleteAllProxiesAsync()
.ConfigureAwait(false)
)
{
ClearAllFiles();
}
else
{
// If clearing wasn't successful we might need to add back some
// files.
await ResyncFiles();
}
}
);
}
/// <summary>
/// Initializes the ViewModel with the <see cref="IStorageItemAccessList"/> provided.
/// </summary>
/// <param name="accessList">The access list used to populate the RecentDatabases collection.</param>
/// <param name="motdProvider">Used to provide the message-of-the-day.</param>
/// <param name="proxyProvider">Used to generate database proxy files in the roaming directory.</param>
/// <param name="exportService">Used to export copies of cached files.</param>
/// <param name="deletePrompter">Used to prompt the user for consent/understanding.</param>
/// <param name="updatePrompter">Used to prompt the user for consent/understanding.</param>
/// <param name="fileService">Used to access the filesystem.</param>
public DashboardViewModel(
IDatabaseAccessList accessList,
IMotdProvider motdProvider,
IFileProxyProvider proxyProvider,
IFileExportService exportService,
IUserPromptingService deletePrompter,
IUserPromptingService updatePrompter,
IFileAccessService fileService
) : base(accessList, proxyProvider, exportService, deletePrompter, updatePrompter, fileService)
{
this.motdProvider = motdProvider ?? throw new ArgumentNullException(nameof(motdProvider));
this.proxyProvider = proxyProvider ?? throw new ArgumentNullException(nameof(proxyProvider));
}
public async Task Initialize()
{
this.accessList = new MockStorageItemAccessList();
this.accessList.Add(
new MockStorageFile {
Name = "Some Metadata"
},
"Some Metadata"
);
this.accessList.Add(
new MockStorageFile {
Name = "Some more metadata"
},
"Some more metadata"
);
this.badFileToken = this.accessList.Add(
null,
"Bad"
);
this.accessList.Add(
new MockStorageFile {
Name = "A test file"
},
"A test file"
);
this.proxyFileName = "temp.txt";
StorageFile proxy = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(this.proxyFileName, CreationCollisionOption.OpenIfExists);
this.accessList.Add(
proxy.AsWrapper(),
this.proxyFileName
);
this.proxyProvider = new FileProxyProvider(ApplicationData.Current.TemporaryFolder);
IFileAccessService fileService = new MockFileService();
this.promptingService = new MockUserPromptingService();
this.viewModel = new DashboardViewModel(
this.accessList,
new MockMotdProvider(),
this.proxyProvider,
new FileExportService(this.accessList, fileService),
this.promptingService,
this.promptingService,
fileService
);
}
public CachedFilesViewModelFactory(
IDatabaseAccessList accessList,
IFileExportService exportService,
IFileProxyProvider proxyProvider,
IUserPromptingService deletePrompter,
IUserPromptingService updatePrompter,
IFileAccessService fileService
)
{
this.accessList = accessList ?? throw new ArgumentNullException(nameof(accessList));
this.exportService = exportService ?? throw new ArgumentNullException(nameof(exportService));
this.proxyProvider = proxyProvider ?? throw new ArgumentNullException(nameof(proxyProvider));
this.deletePrompter = deletePrompter ?? throw new ArgumentNullException(nameof(deletePrompter));
this.updatePrompter = updatePrompter ?? throw new ArgumentNullException(nameof(updatePrompter));
this.fileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
}
/// <summary>
/// Initializes the instance with the services needed to export files.
/// </summary>
/// <param name="accessList">Used to retrieve files from stored tokens.</param>
/// <param name="proxyProvider">Used to manage underlying cached file proxies.</param>
/// <param name="exportService">The service used to export databases.</param>
/// <param name="deletePrompter">A service used to prompt the user for consent to delete a file.</param>
/// <param name="updatePrompter">A service used to prompt the user for consent to update a file.</param>
/// <param name="fileService">A service used to access the filesystem.</param>
protected CachedFileExportingViewModel(
IDatabaseAccessList accessList,
IFileProxyProvider proxyProvider,
IFileExportService exportService,
IUserPromptingService deletePrompter,
IUserPromptingService updatePrompter,
IFileAccessService fileService
)
{
this.accessList = accessList ?? throw new ArgumentNullException(nameof(accessList));
this.proxyProvider = proxyProvider ?? throw new ArgumentNullException(nameof(proxyProvider));
this.exportService = exportService ?? throw new ArgumentNullException(nameof(exportService));
this.deletePrompter = deletePrompter ?? throw new ArgumentNullException(nameof(deletePrompter));
this.updatePrompter = updatePrompter ?? throw new ArgumentNullException(nameof(updatePrompter));
this.fileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
this.data = new ObservableCollection <StoredFileDescriptor>(
this.accessList.Entries.Select(entry => new StoredFileDescriptor(entry))
);
this.readOnlyData = new ReadOnlyObservableCollection <StoredFileDescriptor>(this.data);
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
/// <param name="syncContext">Synchronization context used for marshalling to the UI thread.</param>
/// <param name="file">The candidate document file.</param>
/// <param name="isSampleFile">Whether the file is a PassKeep sample.</param>
/// <param name="futureAccessList">A database access list for persisting permission to the database.</param>
/// <param name="reader">The IKdbxReader implementation used for parsing document files.</param>
/// <param name="proxyProvider">Generates file proxies that the app controls.</param>
/// <param name="candidateFactory">Factory used to generate new candidate files as needed.</param>
/// <param name="keyChangeVmFactory">Factory used to generate the objects used to modify the master key of the database.</param>
/// <param name="taskNotificationService">A service used to notify the UI of blocking operations.</param>
/// <param name="identityService">The service used to verify the user's consent for saving credentials.</param>
/// <param name="credentialProvider">The provider used to store/load saved credentials.</param>
/// <param name="credentialViewModelFactory">A factory used to generate <see cref="ISavedCredentialsViewModel"/> instances.</param>
public DatabaseUnlockViewModel(
ISyncContext syncContext,
IDatabaseCandidate file,
bool isSampleFile,
IDatabaseAccessList futureAccessList,
IKdbxReader reader,
IFileProxyProvider proxyProvider,
IDatabaseCandidateFactory candidateFactory,
IMasterKeyChangeViewModelFactory keyChangeVmFactory,
ITaskNotificationService taskNotificationService,
IIdentityVerificationService identityService,
ICredentialStorageProvider credentialProvider,
ISavedCredentialsViewModelFactory credentialViewModelFactory
)
{
this.syncContext = syncContext ?? throw new ArgumentNullException(nameof(syncContext));
this.futureAccessList = futureAccessList;
this.kdbxReader = reader ?? throw new ArgumentNullException(nameof(reader));
this.proxyProvider = proxyProvider ?? throw new ArgumentNullException(nameof(proxyProvider));
this.candidateFactory = candidateFactory ?? throw new ArgumentNullException(nameof(candidateFactory));
this.keyChangeVmFactory = keyChangeVmFactory ?? throw new ArgumentNullException(nameof(keyChangeVmFactory));
this.taskNotificationService = taskNotificationService ?? throw new ArgumentNullException(nameof(taskNotificationService));
this.identityService = identityService ?? throw new ArgumentNullException(nameof(identityService));
this.credentialProvider = credentialProvider ?? throw new ArgumentNullException(nameof(credentialProvider));
this.credentialViewModelFactory = credentialViewModelFactory ?? throw new ArgumentNullException(nameof(credentialViewModelFactory));
SaveCredentials = false;
IdentityVerifiability = UserConsentVerifierAvailability.Available;
UnlockCommand = new AsyncActionCommand(CanUnlock, DoUnlockAsync);
UseSavedCredentialsCommand = new AsyncActionCommand(
() => UnlockCommand.CanExecute(null) && HasSavedCredentials,
DoUnlockWithSavedCredentials
);
IsSampleFile = isSampleFile;
RememberDatabase = true;
this.initialConstruction = UpdateCandidateFileAsync(file);
}
public async Task Init()
{
StorageFolder rootFolder = ApplicationData.Current.TemporaryFolder;
rootFolder = await rootFolder.CreateFolderAsync("Proxies", CreationCollisionOption.OpenIfExists);
this.proxyProvider = new FileProxyProvider(rootFolder);
Assert.AreEqual(0, (await rootFolder.GetFilesAsync()).Count, "Test should start with no proxies");
IDatabaseAccessList accessList = new MockStorageItemAccessList();
this.promptService = new MockUserPromptingService();
IFileAccessService fileService = new MockFileService();
this.viewModelFactory = new CachedFilesViewModelFactory(
accessList,
new FileExportService(accessList, fileService),
this.proxyProvider,
this.promptService,
this.promptService,
fileService
);
}
/// <summary>
/// Initializes the factory.
/// </summary>
/// <param name="proxyProvider">Provider to use for generating storage file proxies.</param>
public StorageFileDatabaseCandidateFactory(IFileProxyProvider proxyProvider)
{
this.proxyProvider = proxyProvider ?? throw new ArgumentNullException(nameof(proxyProvider));
}
public async Task Initialize()
{
TestDataAttribute dataAttr = GetTestAttribute <TestDataAttribute>();
if (dataAttr != null && dataAttr.SkipInitialization)
{
return;
}
this.testDatabaseInfo = null;
IDatabaseCandidate databaseValue = null;
bool sampleValue = false;
try
{
this.testDatabaseInfo = await Utils.GetDatabaseInfoForTest(TestContext);
}
catch (InvalidOperationException) { }
if (dataAttr?.UseRealProxyProvider != true)
{
this.proxyProvider = new MockFileProxyProvider
{
ScopeValue = (dataAttr?.InAppScope == true)
};
}
else
{
StorageFolder proxyFolder = ApplicationData.Current.TemporaryFolder;
proxyFolder = await proxyFolder.CreateFolderAsync("Proxies", CreationCollisionOption.OpenIfExists);
this.proxyProvider = new FileProxyProvider(proxyFolder);
}
IDatabaseCandidateFactory candidateFactory = new StorageFileDatabaseCandidateFactory(this.proxyProvider);
if (this.testDatabaseInfo != null)
{
databaseValue = await candidateFactory.AssembleAsync(this.testDatabaseInfo.Database);
sampleValue = (dataAttr != null && dataAttr.InitSample);
}
if (dataAttr != null && !dataAttr.InitDatabase)
{
databaseValue = null;
}
this.accessList = new MockStorageItemAccessList();
this.identityService = new MockIdentityVerifier()
{
CanVerify = dataAttr?.IdentityVerifierAvailable ?? UserConsentVerifierAvailability.NotConfiguredForUser,
Verified = dataAttr?.IdentityVerified ?? false
};
this.credentialProvider = new MockCredentialProvider();
if (dataAttr?.StoredCredentials == true && databaseValue != null && this.testDatabaseInfo != null)
{
Assert.IsTrue(
await this.credentialProvider.TryStoreRawKeyAsync(
databaseValue.File,
this.testDatabaseInfo.RawKey
)
);
}
Utils.DatabaseInfo backupDatabase = await Utils.DatabaseMap["StructureTesting"];
this.alwaysStoredCandidate = await candidateFactory.AssembleAsync(
backupDatabase.Database
);
Assert.IsTrue(
await this.credentialProvider.TryStoreRawKeyAsync(
this.alwaysStoredCandidate.File,
backupDatabase.RawKey
)
);
this.viewModel = new DatabaseUnlockViewModel(
new MockSyncContext(),
databaseValue,
sampleValue,
this.accessList,
new KdbxReader(),
this.proxyProvider,
candidateFactory,
new MasterKeyChangeViewModelFactory(new DatabaseCredentialProviderFactory(this.credentialProvider), new MockFileService()),
new TaskNotificationService(),
this.identityService,
this.credentialProvider,
new MockCredentialStorageViewModelFactory()
);
await this.viewModel.ActivateAsync();
// Set various ViewModel properties if desired
if (this.testDatabaseInfo != null && dataAttr != null)
{
if (dataAttr.SetPassword)
{
this.viewModel.Password = this.testDatabaseInfo.Password;
}
if (dataAttr.SetKeyFile)
{
this.viewModel.KeyFile = this.testDatabaseInfo.Keyfile;
}
}
if (databaseValue != null)
{
await ViewModelHeaderValidated();
}
}
