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();
}