public Task <bool> SaveAsync(IEnumerable <DocumentFile> newFiles) { Guard.NotNull(newFiles, nameof(newFiles)); if (!PlattformDetector.IsDesktop) { return(Task.FromResult(true)); } return(FileQueue.EnqueueAsync(() => { try { var errors = 0; var handledPaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach ( var file in newFiles.Where(x => !x.IsInLocalFolder && x.File != null).Select(x => x.File)) { try { if (!handledPaths.Add(file.Path)) { continue; } if (!tokenMapping.Remove(file.Path)) { recentList.Add(file); } } catch { errors++; } } foreach (var token in tokenMapping.Values) { try { recentList.Remove(token); } catch { errors++; } } return Task.FromResult(errors == 0); } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies("SaveRecentList")); throw; } })); }
public Task <IReadOnlyList <DocumentFile> > LoadAsync() { return(FileQueue.EnqueueAsync <IReadOnlyList <DocumentFile> >(async() => { try { var unsortedFiles = new Dictionary <string, DocumentFile>(StringComparer.OrdinalIgnoreCase); await LoadFilesFromLocalStoreAsync(unsortedFiles); await LoadFilesFromRecentListAsync(unsortedFiles); files.Clear(); foreach (var sortedFile in unsortedFiles.Values.OrderByDescending(x => x.ModifiedUtc)) { files.Add(sortedFile); } return files; } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies("LoadRecentList")); throw; } })); }
public static Task DeleteQueuedAsync(this StorageFile file) { return(FileQueue.EnqueueAsync(async() => { try { await file.DeleteAsync(StorageDeleteOption.Default); } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies(file, "Delete")); throw; } })); }
public static Task RenameQueuedAsync(this StorageFile file, string name, string extension) { Guard.ValidFileName(name, nameof(name)); return(FileQueue.EnqueueAsync(async() => { try { await file.RenameAsync(name + extension, NameCollisionOption.GenerateUniqueName); } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies(file, "Rename")); throw; } })); }
public static Task <List <StorageFile> > GetFilesQueuedAsync() { return(FileQueue.EnqueueAsync(async() => { try { var folder = await GetStorageFolderAsync(); return (await folder.GetFilesAsync()).ToList(); } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies("GetFiles")); throw; } })); }
public static Task <Document> OpenDocumentQueuedAsync(this StorageFile file) { return(FileQueue.EnqueueAsync(async() => { try { using (IRandomAccessStream stream = await file.OpenReadAsync()) { return stream.Size > 0 ? JsonDocumentSerializer.Deserialize(stream.AsStreamForRead()) : Document.CreateNew(file.DisplayName); } } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies(file, "Open")); throw; } })); }
public static Task <StorageFile> CreateOrOpenFileQueuedAsync(string name) { Guard.ValidFileName(name, nameof(name)); return(FileQueue.EnqueueAsync(async() => { try { var folder = await GetStorageFolderAsync(); return await folder.CreateFileAsync(name, CreationCollisionOption.OpenIfExists); } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies("CreateOrOpen", name)); throw; } })); }
public static async Task MakeBackupAsync(IEnumerable <DocumentFile> files) { var backupFile = await LocalStore.CreateOrOpenFileQueuedAsync("Backup.zip"); var histories = new Dictionary <string, JsonHistory>(); foreach (var file in files.Where(x => x.Document != null)) { var name = file.Name + ".mmd"; if (file.Path != null) { name = file.Path; name = name.Replace('/', '_'); name = name.Replace(':', '_'); name = name.Replace('\\', '_'); } histories.Add(name, new JsonHistory(file.Document)); } await FileQueue.EnqueueAsync(async() => { using (var transaction = await backupFile.OpenTransactedWriteAsync()) { using (var archive = new ZipArchive(transaction.Stream.AsStream(), ZipArchiveMode.Update)) { foreach (var kvp in histories) { var entry = archive.GetEntry(kvp.Key) ?? archive.CreateEntry(kvp.Key); using (var entrySteam = entry.Open()) { JsonDocumentSerializer.Serialize(kvp.Value, entrySteam); } } } await transaction.CommitAsync(); } }); }
public static async Task SaveDocumentQueuedAsync(this StorageFile file, Document document) { var history = new JsonHistory(document); await FileQueue.EnqueueAsync(async() => { try { using (var transaction = await file.OpenTransactedWriteAsync()) { JsonDocumentSerializer.Serialize(history, transaction.Stream.AsStreamForWrite()); await transaction.CommitAsync(); } } catch (Exception e) { HockeyClient.Current.TrackException(e, GetExceptionProperies(file, "Open")); throw; } }); }