public async Task GetFoldersMultiple() { // Arrange IFolder folder = await TestFileSystem.LocalStorage.CreateFolderAsync("GetFoldersMultiple_Folder", CreationCollisionOption.FailIfExists); var folderNames = new[] { "One", "2", "Hello" }; foreach (var fn in folderNames) { await folder.CreateFolderAsync(fn, CreationCollisionOption.FailIfExists); } // Act IList <IFolder> folders = await folder.GetFoldersAsync(); // Assert Assert.AreEqual(folderNames.Length, folders.Count, "Folder count"); foreach (var fn in folderNames) { Assert.IsTrue(folders.Count(f => f.Name == fn) == 1, "Folder " + fn + " in results"); } // Cleanup await folder.DeleteAsync(); }
public async Task MoveFile_AcrossDirectories() { // Arrange IFolder folder = TestFileSystem.LocalStorage; string originalFileName = "fileToMove.txt"; IFile file = await folder.CreateFileAsync(originalFileName, CreationCollisionOption.FailIfExists); IFolder subfolder = await folder.CreateFolderAsync("subfolder", CreationCollisionOption.FailIfExists); // Act string movedFile = "movedFile.txt"; await file.MoveAsync(Path.Combine(subfolder.Path, movedFile)); // Assert Assert.AreEqual(movedFile, file.Name); Assert.AreEqual(Path.Combine(subfolder.Path, file.Name), file.Path); IList <IFile> files = await folder.GetFilesAsync(); Assert.IsFalse(files.Any(f => f.Name == originalFileName)); Assert.IsFalse(files.Any(f => f.Name == movedFile)); files = await subfolder.GetFilesAsync(); Assert.IsFalse(files.Any(f => f.Name == originalFileName)); Assert.IsTrue(files.Any(f => f.Name == movedFile)); // Cleanup await subfolder.DeleteAsync(); }
/// <summary> /// Recursively deletes directory and all files. See /// http://stackoverflow.com/questions/3775694/deleting-folder-from-java/3775723#3775723 /// </summary> /// <param name="folder"> /// the directory to delete with all its content </param> /// <returns> true if directory and all content has been deleted, false if not </returns> private static bool DeleteDirectory(IFolder folder) { if (folder == null) { return(false); } var files = folder.GetFilesAsync().Result; foreach (var file in files) { file.DeleteAsync().RunSynchronously(); } var subFolders = folder.GetFoldersAsync().Result; foreach (var subFolder in subFolders) { var success = DeleteDirectory(subFolder); if (!success) { return(false); } } // The directory is now empty so delete it folder.DeleteAsync().RunSynchronously(); return(true); }
private async void btnLogout_Clicked(object sender, EventArgs e) { if (await this.DisplayYesNoAlert("Are you sure you want to logout? Any work not syched will be lost?")) { App.DB.DropAndCreateDatabase(); Settings.LoggedIn = false; Settings.OfficerCode = string.Empty; Settings.Password = string.Empty; Settings.AuthToken = string.Empty; Settings.FullName = string.Empty; Settings.ClearUsername = string.Empty; Settings.EmailAddress = string.Empty; Settings.UserSites = string.Empty; Settings.LastBaseDataSync = DateTime.MinValue; Settings.WifiOnly = false; Settings.IsNewLogin = true; IFolder localStorage = FileSystem.Current.LocalStorage; ExistenceCheckResult exists = await localStorage.CheckExistsAsync(SyncHelper.FormsFolder); if (exists == ExistenceCheckResult.FolderExists) { IFolder formsFolder = await localStorage.GetFolderAsync(SyncHelper.FormsFolder); if (formsFolder != null) { await formsFolder.DeleteAsync(); } } App.Current.ShowLoginPage(); } }
// Get plants from MobileApi server and save locally public async Task StartDownload(CancellationToken token) { try { if (resyncPlants) { ClearLocalRepositories(); } ClearRepositories(); try { IFolder folder = await rootFolder.GetFolderAsync("Images"); await folder.DeleteAsync(); } catch (Exception e) { } await UpdatePlants(token); //App.WoodyPlantImageRepoLocal = new WoodyPlantImageRepositoryLocal(App.WoodyPlantImageRepo.GetAllWoodyPlantImages()); } catch (OperationCanceledException e) { downloadLabel.Text = "Download Canceled!"; Debug.WriteLine("Canceled UpdatePlants {0}", e.Message); } catch (Exception e) { downloadLabel.Text = "Error While Downloading Database!"; Debug.WriteLine("ex {0}", e.Message); } }
//Delete Folder async void DeleteFolder(object sender, EventArgs e) { var Entry = EntDeleteFolder; // Alert, if SubFolder Name was not entered if (Entry.Text == null) { await DisplayAlert("Delete Folder Result", "Input Folder Name!", "OK"); return; } // Delete Folder entered in EntDeleteSubFolder var subfolderExists = await rootFolder.CheckExistsAsync(Entry.Text); if (subfolderExists != ExistenceCheckResult.FolderExists) { await DisplayAlert("Delete Folder Result", Entry.Text + " doesn't exist", "OK"); return; } IFolder subfolder = await rootFolder.GetFolderAsync(Entry.Text); await subfolder.DeleteAsync(); await DisplayAlert("Delete Folder Result", Entry.Text + " has been deleted!", "OK"); }
public static async Task Export(Book book) { await CheckInitialized(); string json = BookToJson(book); IFolder folder = await RootDir.CreateFolderAsync(book.Title, CreationCollisionOption.ReplaceExisting); foreach (Entry e in book.Entries) { IFile image = await ImageDir.GetFileAsync(e.ImagePath); IFile target = await folder.CreateFileAsync(e.ImagePath, CreationCollisionOption.ReplaceExisting); using (var targetStream = await target.OpenAsync(FileAccess.ReadAndWrite)) using (var imageStream = await image.OpenAsync(FileAccess.Read)) await imageStream.CopyToAsync(targetStream); } IFile jsonFile = await folder.CreateFileAsync("content.json", CreationCollisionOption.ReplaceExisting); await jsonFile.WriteAllTextAsync(json); string exportPath = await Zip(folder.Path, book.Title); await folder.DeleteAsync(); AlertManager.ExportPath(exportPath); }
public async Task GetFileFromPath() { // Arrange IFolder folder = await TestFileSystem.LocalStorage.CreateFolderAsync("GetFileFromPath_Folder", CreationCollisionOption.FailIfExists); string fileName = "file.txt"; string fileContents = "Do you like green eggs and ham?"; IFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.FailIfExists); await file.WriteAllTextAsync(fileContents); string expectedPath = PortablePath.Combine(folder.Path, fileName); // Act IFile gottenFile = await TestFileSystem.GetFileFromPathAsync(expectedPath); string gottenContents = await gottenFile.ReadAllTextAsync(); // Assert Assert.AreEqual(expectedPath, file.Path, "file.Path"); Assert.AreEqual(expectedPath, gottenFile.Path, "gottenFile.Path"); Assert.AreEqual(fileContents, gottenContents); // Cleanup await folder.DeleteAsync(); }
public async Task GetFolderFromPath() { // Arrange IFolder folder = await TestFileSystem.LocalStorage.CreateFolderAsync("GetFolderFromPath_Folder", CreationCollisionOption.FailIfExists); string fileName1 = "file1.txt"; string fileName2 = "file2.txt"; await folder.CreateFileAsync(fileName1, CreationCollisionOption.FailIfExists); IFile file2 = await folder.CreateFileAsync(fileName2, CreationCollisionOption.FailIfExists); await file2.WriteAllTextAsync("File 2 contents"); string expectedPath = folder.Path; // Act IFolder gottenFolder = await TestFileSystem.GetFolderFromPathAsync(expectedPath); var files = await gottenFolder.GetFilesAsync(); var fileNames = files.Select(f => f.Name); // Assert Assert.AreEqual(expectedPath, gottenFolder.Path, "gottenFolder.Path"); Assert.AreEqual(2, files.Count, "file count"); Assert.IsTrue(fileNames.Contains("file1.txt")); Assert.IsTrue(fileNames.Contains("file2.txt")); // Cleanup await gottenFolder.DeleteAsync(); }
public async Task GetFilesMultiple() { // Arrange IFolder folder = await TestFileSystem.LocalStorage.CreateFolderAsync("GetFilesMultiple_Folder", CreationCollisionOption.FailIfExists); var fileNames = new[] { "hello.txt", "file.zzz", "anotherone", "42" }; foreach (var fn in fileNames) { await folder.CreateFileAsync(fn, CreationCollisionOption.FailIfExists); } // Act IList <IFile> files = await folder.GetFilesAsync(); // Assert Assert.AreEqual(fileNames.Length, files.Count, "File count"); foreach (var fn in fileNames) { Assert.IsTrue(files.Count(f => f.Name == fn) == 1, "File " + fn + " in results"); } // Cleanup await folder.DeleteAsync(); }
/// <summary> /// Deletes all the saved XML files found in the specified folder. /// </summary> /// <param name="path">The path of the XML files.</param> public void DeleteAll() { IFolder folder = GetFolder(); folder.DeleteAsync().Wait(); _listGames.Clear(); }
public async Task DeleteAppLocalStorageThrows() { // Arrange IFolder folder = TestFileSystem.LocalStorage; // Act & Assert await Assert.ThrowsExceptionAsync <IOException>(async() => await folder.DeleteAsync()); }
async void deletefile() { IFolder folder = await rootFolder.CreateFolderAsync("Library", CreationCollisionOption.OpenIfExists); // create a file, overwriting any existing fileMySubFolder IFile Calendarfile = await folder.CreateFileAsync("Calendar.json", CreationCollisionOption.OpenIfExists); await folder.DeleteAsync(); }
/// <summary> /// Deletes the folder where all the default databases should be located /// </summary> public async static Task DestroyAllDatabases() { IFolder databaseFolder = await FileSystem.Current.GetFolderFromPathAsync(DatabasesFolder); if (databaseFolder != null) { await databaseFolder.DeleteAsync(); } }
/// <summary> /// Thread safe, but will lock the thread /// </summary> /// <param name="localAccountId"></param> /// <returns></returns> public static async Task Delete(Guid localAccountId) { await Task.Run(async delegate { using (await Locks.LockAccounts()) { using (await Locks.LockDataForWriteAsync("AccountsManager.Delete")) { IFolder accountFolder = await FileHelper.GetAccountFolder(localAccountId); if (accountFolder != null) { AccountDataStore.Dispose(localAccountId); try { await accountFolder.DeleteAsync(); } catch { } } } _cachedAccounts.Remove(localAccountId); } }); if (OnAccountDeleted != null) { OnAccountDeleted(null, localAccountId); } // Clear reminders try { RemindersExtension.Current?.ClearReminders(localAccountId); } catch { } // Clear calendar integration try { if (AppointmentsExtension.Current != null) { await AppointmentsExtension.Current.DeleteAsync(localAccountId); } } catch { } // Unpin tiles try { TilesExtension.Current?.UnpinAllTilesForAccount(localAccountId); } catch { } }
private static async Task ClearTempFolderAsync() { try { IFolder folder = await FileSystem.Current.LocalStorage.GetFolderAsync(FolderName); await folder.DeleteAsync(); } catch { } }
public async Task DeleteFolderTwice() { // Arrange IFolder rootFolder = TestFileSystem.LocalStorage; IFolder folder = await rootFolder.CreateFolderAsync("FolderToDeleteTwice", CreationCollisionOption.FailIfExists); await folder.DeleteAsync(); // Act & Asserth await Assert.ThrowsExceptionAsync <DirectoryNotFoundException>(async() => await folder.DeleteAsync()); }
public async Task CreateFileInDeletedFolder() { // Arrange IFolder rootFolder = TestFileSystem.LocalStorage; IFolder folder = await rootFolder.CreateFolderAsync("FolderToDeleteAndThenCreateFileIn", CreationCollisionOption.FailIfExists); await folder.DeleteAsync(); // Act & Assert await Assert.ThrowsExceptionAsync <DirectoryNotFoundException>(async() => await folder.CreateFileAsync("Foo.txt", CreationCollisionOption.GenerateUniqueName)); }
public static async Task Move(IFolder source, IFolder target) { foreach (IFolder f in await source.GetFoldersAsync()) { await Move(f, await target.CreateFolderAsync(f.Name, CreationCollisionOption.GenerateUniqueName).ConfigureAwait(false)).ConfigureAwait(false); } foreach (IFile f in await source.GetFilesAsync()) { await f.MoveAsync(PortablePath.Combine(target.Path, f.Name), NameCollisionOption.GenerateUniqueName).ConfigureAwait(false); } await source.DeleteAsync(); }
public async Task GetFilesEmpty() { // Arrange IFolder folder = await TestFileSystem.LocalStorage.CreateFolderAsync("GetFilesEmpty_Folder", CreationCollisionOption.FailIfExists); // Act IList <IFile> files = await folder.GetFilesAsync(); // Assert Assert.AreEqual(0, files.Count, "File count"); // Cleanup await folder.DeleteAsync(); }
public async Task Cleanup() { await _compiledResourceFolder.DeleteAsync(); _compiledResourceFolder = null; await _localResourceFolder.DeleteAsync(); _localResourceFolder = null; await _remoteResourceFolder.DeleteAsync(); _remoteResourceFolder = null; await DisableInternetAsync(); }
// Delete the IFolder "ifolder" in the IFolder "iparent" async Task IDeleteFolder(IFolder ifolder, IFolder iparent) { // Check the existence of the IFolder corresponding to the Object "folder" bool IsExist = await ICheckFolderExist(ifolder.Name, iparent); if (!IsExist) { await DisplayAlert("", ifolder.Name.ToString() + " doesn't exist", "OK"); return; } await ifolder.DeleteAsync(); }
private async void DownloadImagesPressed(object sender, EventArgs e) { if (clearDatabase) { var answer = await DisplayAlert("Warning", "Are you sure you want to clear your offline plant data and stream plants?", "Yes", "No"); if (answer) { DownloadButtonText = "Plant DB Up To Date"; downloadImagesButton.Text = "Clearing Offline Plant Data..."; try { IFolder folder = await rootFolder.GetFolderAsync("Images"); await folder.DeleteAsync(); } catch (Exception exception) { } ClearRepositories(); ClearLocalRepositories(); updatePlants = false; resyncPlants = false; clearDatabase = false; datePlantDataUpdatedLocally.valuetimestamp = null; await App.WoodySettingsRepo.AddOrUpdateSettingAsync(datePlantDataUpdatedLocally); DownloadButtonText = "Download Plant DB"; downloadImagesButton.Text = "Download Offline Plant Data"; streamingLabel.Text = "You Are Streaming Plants"; downloadImagesLabel.TextColor = Color.Red; downloadImagesSetting.valuebool = true; downloadImages = true; } } // If valid date comparison and date on server is more recent than local date, show download button else if (datePlantDataUpdatedOnServer.valuetimestamp != null) { if ((datePlantDataUpdatedLocally.valuetimestamp < datePlantDataUpdatedOnServer.valuetimestamp) || numberOfPlants == 0 || datePlantDataUpdatedLocally.valuetimestamp == null) { updatePlants = true; ToDownloadPage(); downloadImagesSetting.valuebool = false; downloadImages = false; } } await App.WoodySettingsRepo.AddOrUpdateSettingAsync(downloadImagesSetting); }
private async void HandleCancelDownload(object sender, EventArgs e) { canceledDownload = true; //ClearRepositories(); //ClearLocalRepositories(); try { IFolder folder = await rootFolder.GetFolderAsync("Images"); await folder.DeleteAsync(); } catch (Exception exception) { } await App.Current.MainPage.Navigation.PopModalAsync(); }
public async static void RemoveAllData() { IFolder rootFolder = FileSystem.Current.LocalStorage; ExistenceCheckResult kuchaFolderExists = await rootFolder.CheckExistsAsync("Kucha"); if (kuchaFolderExists == ExistenceCheckResult.FolderExists) { IFolder kuchaFolder = await rootFolder.GetFolderAsync("Kucha"); await kuchaFolder.DeleteAsync(); kuchaContainer = null; App.Current.MainPage = new UI.LoginPage(); } }
public async Task DeleteFolder() { // Arrange IFolder rootFolder = TestFileSystem.LocalStorage; string subFolderName = "FolderToDelete"; IFolder folder = await rootFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.FailIfExists); // Act await folder.DeleteAsync(); // Assert IList <IFolder> folders = await rootFolder.GetFoldersAsync(); Assert.IsFalse(folders.Any(f => f.Name == subFolderName)); }
public static async Task Import(int parentId) { await CheckInitialized(); string[] types = { ".zip" }; FileData zipFile = await CrossFilePicker.Current.PickFile(types); if (zipFile == null) { return; } IFile newZip = await CopyZip(zipFile.FileName, zipFile.DataArray); Tuple <string, string> values = await Unzip(newZip.Path); IFolder import = await RootDir.GetFolderAsync(values.Item1); IFile json = await import.GetFileAsync("content.json"); string jsonText = await json.ReadAllTextAsync(); Book b = JsonToBook(jsonText); Debug.WriteLine($"NewBook: {b.ToString()}"); RealmManager.ImportBook(b, parentId); IFile old; foreach (Entry e in b.Entries) { string[] splits = e.ImagePath.Split('_'); string oldPath = $"{b.Id}_{splits[1]}"; ExistenceCheckResult exists = await import.CheckExistsAsync(oldPath); if (exists == ExistenceCheckResult.NotFound) { Debug.WriteLine($"Image not Found at: {e.ImagePath}"); continue; } old = await import.GetFileAsync(oldPath); await old.MoveAsync($"{ImageDir.Path}\\{old.Name}", NameCollisionOption.ReplaceExisting); } await import.DeleteAsync(); await newZip.DeleteAsync(); }
public async Task CreateFolderCollision_FailIfExists() { // Arrange IFolder rootFolder = TestFileSystem.LocalStorage; string subFolderName = "Collision_Fail"; IFolder existingFolder = await rootFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.FailIfExists); // Act & Assert await Assert.ThrowsExceptionAsync <IOException>(async() => { await rootFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.FailIfExists); }); // Cleanup await existingFolder.DeleteAsync(); }
public async Task GetFileFromPath_WhenFileDoesNotExist() { // Arrange IFolder folder = await TestFileSystem.LocalStorage.CreateFolderAsync("GetFileFromPath_WhenFileDoesNotExist_Folder", CreationCollisionOption.FailIfExists); string pathForFile = PortablePath.Combine(folder.Path, "filethatdoesnotexist.txt"); // Act IFile file = await TestFileSystem.GetFileFromPathAsync(pathForFile); // Assert Assert.AreEqual(null, file); // Cleanup await folder.DeleteAsync(); }
public async Task CreateFolder() { // Arrange IFolder rootFolder = TestFileSystem.LocalStorage; string folderName = "FolderToCreate"; // Act IFolder folder = await rootFolder.CreateFolderAsync(folderName, CreationCollisionOption.FailIfExists); // Assert Assert.AreEqual(folderName, folder.Name); Assert.AreEqual(Path.Combine(rootFolder.Path, folderName), folder.Path, "Folder path"); // Cleanup await folder.DeleteAsync(); }