/// <summary>
/// Gets the folders in the current folder.
/// </summary>
/// <returns></returns>
public Task <IReadOnlyList <StorageFolder> > GetFoldersAsync()
{
List <StorageFolder> folders = new List <StorageFolder>();
#if WINDOWS_UWP || WINDOWS_APP || WINDOWS_PHONE_APP || WINDOWS_PHONE
return(Task.Run <IReadOnlyList <StorageFolder> >(async() =>
{
var found = await _folder.GetFoldersAsync();
foreach (var folder in found)
{
folders.Add(new StorageFolder(folder));
}
return folders.AsReadOnly();
}));
#elif __ANDROID__ || __UNIFIED__ || WIN32 || TIZEN
return(Task.Run <IReadOnlyList <StorageFolder> >(() =>
{
foreach (string foldername in global::System.IO.Directory.GetDirectories(Path))
{
folders.Add(new StorageFolder(global::System.IO.Path.Combine(Path, foldername)));
}
return folders.AsReadOnly();
}));
#else
throw new PlatformNotSupportedException();
#endif
}
public async Task When_GetItems()
{
var realFileList = await _folderForTestFiles.GetFilesAsync();
if (realFileList.Count != _filenames.Length)
{
Assert.Fail("Number of files mismatch");
}
foreach (string requestedFilename in _filenames)
{
bool fileOK = realFileList.Any(r => r.Name.Equals(requestedFilename, StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(fileOK, "Required file is missing - error in tested method");
}
var realFolderList = await _folderForTestFiles.GetFoldersAsync();
if (realFolderList.Count != _foldernames.Length)
{
Assert.Fail("Number of folders mismatch");
}
foreach (var requestedFoldername in _foldernames)
{
bool fileOK = realFolderList.Any(r => r.Name.Equals(requestedFoldername, StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(fileOK, "Required folder is missing - error in tested method");
}
}
protected async static Task <string []> GetDirectoryNamesAsync(Windows.Storage.StorageFolder fldr, string wildcard)
{
IReadOnlyList <Windows.Storage.StorageFolder> subfolders =
await fldr.GetFoldersAsync();
RscWildCard wc = new RscWildCard(wildcard);
string [] astr = new String[subfolders.Count];
int iLenSave = astr.Length;
int i = 0;
foreach (Windows.Storage.StorageFolder folder in subfolders)
{
if (wc.Wanted(folder.Name))
{
astr[i] = folder.Name;
i++;
}
}
if (i == 0)
{
return new String [] {}
}
; //All filtered out...
if (i == iLenSave)
{
return(astr); //All wanted...
}
//Not so nice... :(
string [] astr2 = new String[i];
for (int j = 0; j < i; j++)
{
astr2[j] = astr[j];
}
return(astr2);
}
public static async Task <BookContainer> GetFromStorageFolder(Windows.Storage.StorageFolder folder, string Token = null, string[] Path = null)
{
var result = new BookContainer();
result.Title = folder.DisplayName;
List <string> path = (Path ?? new string[0]).ToList();
if (Token == null)
{
Token = Books.BookManager.StorageItemRegister(folder);
}
else
{
path.Add(folder.Name);
}
foreach (var item in await folder.GetFoldersAsync())
{
var f = await GetFromStorageFolder(item, Token, path.ToArray());
if (!f.IsEmpty())
{
result.Folders.Add(f);
}
}
foreach (var item in await folder.GetFilesAsync())
{
var f = await GetFromStorageFile(item, Token, path.ToArray());
if (f != null)
{
result.Files.Add(f);
}
}
return(result);
}
private async Task <NetworkStatus> VerifyFolder()
{
Status = NetworkStatus.Networking;
long currentProgress = 0, totalProgress = 1;
OnProgressChanged(currentProgress, totalProgress);
if (cloudFolder.Name != windowsFolder.Name)
{
OnMessageAppended($"Name not consistent, Cloud: {cloudFolder.Name}, Local: {windowsFolder.Name}");
return(NetworkStatus.ErrorNeedRestart);
}
var folderVerifiers = new List <Tuple <CloudFile, Windows.Storage.StorageFolder> >();
{
if (!await GetCloudSubFolders())
{
return(NetworkStatus.ErrorNeedRestart);
}
Dictionary <string, Windows.Storage.StorageFolder> localSubFolders = new Dictionary <string, Windows.Storage.StorageFolder>();
foreach (var f in await windowsFolder.GetFoldersAsync())
{
if (!cloudSubFolders.ContainsKey(f.Name))
{
OnMessageAppended($"Cloud Folder doesn't exist: {f.Name}");
return(NetworkStatus.ErrorNeedRestart);
}
localSubFolders.Add(f.Name, f);
}
foreach (var p in cloudSubFolders)
{
if (!localSubFolders.ContainsKey(p.Key))
{
OnMessageAppended($"Local Folder doesn't exist: {p.Key}");
return(NetworkStatus.ErrorNeedRestart);
}
folderVerifiers.Add(new Tuple <CloudFile, Windows.Storage.StorageFolder>(p.Value, localSubFolders[p.Key]));
localSubFolders.Remove(p.Key);
}
MyLogger.Assert(localSubFolders.Count == 0);
}
{
if (!await GetCloudSubFiles())
{
return(NetworkStatus.ErrorNeedRestart);
}
Dictionary <string, Windows.Storage.StorageFile> localSubFiles = new Dictionary <string, Windows.Storage.StorageFile>();
foreach (var f in await windowsFolder.GetFilesAsync())
{
if (!cloudSubFiles.ContainsKey(f.Name))
{
OnMessageAppended($"Cloud File doesn't exist: {f.Name}");
return(NetworkStatus.ErrorNeedRestart);
}
localSubFiles.Add(f.Name, f);
}
foreach (var p in cloudSubFiles)
{
if (!localSubFiles.ContainsKey(p.Key))
{
OnMessageAppended($"Local File doesn't exist: {p.Key}");
return(NetworkStatus.ErrorNeedRestart);
}
}
OnProgressChanged(++currentProgress, totalProgress += cloudSubFiles.Count);
CurrentProgressChanged?.Invoke(1);
TotalProgressChanged?.Invoke(cloudSubFiles.Count);
OnMessageAppended("Verifying subfiles...");
int filesVerified = 0;
foreach (var p in cloudSubFiles)
{
var localFile = localSubFiles[p.Key];
var stream = await localFile.OpenStreamForReadAsync();
var localMd5 = await Libraries.GetSha256ForWindowsStorageFile(stream);
stream.Dispose();
if (localMd5 != p.Value || p.Value == null)
{
OnMessageAppended($"{p.Key} content not consistent, Cloud: {p.Value}, Local: {localMd5}");
CurrentProgressChanged?.Invoke(-filesVerified - 1);
TotalProgressChanged?.Invoke(-cloudSubFiles.Count);
return(NetworkStatus.ErrorNeedRestart);
}
OnProgressChanged(++currentProgress, totalProgress);
CurrentProgressChanged?.Invoke(1);
++filesVerified;
localSubFiles.Remove(p.Key);
}
OnMessageAppended("Subfiles verified.");
MyLogger.Assert(localSubFiles.Count == 0);
}
OnProgressChanged(currentProgress, totalProgress += folderVerifiers.Count);
TotalProgressChanged?.Invoke(folderVerifiers.Count);
ReleaseSemaphoreSlim();
OnMessageAppended("Waiting for subfolders to be verified...");
try
{
await Task.WhenAll(folderVerifiers.Select(async(tuple) =>
{
var totalProgressChangedEventHandler = new TotalProgressChangedEventHandler((difference) =>
{
OnProgressChanged(currentProgress, totalProgress += difference);
TotalProgressChanged?.Invoke(difference);
});
var currentProgressChangedEventHandler = new TotalProgressChangedEventHandler((difference) =>
{
//MyLogger.Assert(difference == 1);
OnProgressChanged(currentProgress += difference, totalProgress);
CurrentProgressChanged?.Invoke(difference);
});
var verifier = new Verifiers.FolderVerifier(tuple.Item1, tuple.Item2);
verifier.TotalProgressChanged += totalProgressChangedEventHandler;
verifier.CurrentProgressChanged += currentProgressChangedEventHandler;
await verifier.StartUntilCompletedAsync();
verifier.TotalProgressChanged -= totalProgressChangedEventHandler;
verifier.CurrentProgressChanged -= currentProgressChangedEventHandler;
}));
return(NetworkStatus.Completed);
}
finally
{
await WaitSemaphoreSlimAsync();
}
}
