public async Task <NotePageModel> GetCurrentNotePageAsync(NotesListModel notesList)
 {
     // Check the settings for an active note page.
     return(_remoteFileStorage != null && _remoteSettingsStorage != null
         ? await GetCurrentNotePage(_remoteSettingsStorage, _remoteFileStorage, notesList)
         : await GetCurrentNotePage(_localStorage, _localStorage, notesList));
 }
        public async Task <NotesListModel> GetNotesListAsync()
        {
            var notesListItems     = new List <NotesListItemModel>();
            var notesListItemsDict = new Dictionary <string, int>();

            await InitRoamingSettingsHelperAsync();

            bool updateNotesList = false;

            // Get any remote notes.
            var remoteNotes = await GetNotesListAsync(_remoteFileStorage);

            if (remoteNotes != null)
            {
                for (var i = 0; i < remoteNotes.Items.Count; i++)
                {
                    var notesListItem = remoteNotes.Items[i];
                    notesListItems.Add(notesListItem);
                    notesListItemsDict.Add(notesListItem.NotePageId, i);
                }
            }

            // Get any local notes.
            var localNotes = await GetNotesListAsync(_localStorage);

            if (localNotes != null)
            {
                foreach (var notesListItem in localNotes.Items)
                {
                    if (!notesListItemsDict.ContainsKey(notesListItem.NotePageId))
                    {
                        notesListItems.Add(notesListItem);

                        // Sync these notes back to the remote, if available.
                        updateNotesList = true;
                    }
                }
            }

            NotesListModel notesList = null;

            if (notesListItems.Count > 0)
            {
                notesList = new NotesListModel(notesListItems);

                if (updateNotesList)
                {
                    await SaveNotesListAsync(notesList);
                }
            }

            return(notesList);
        }
        public async Task SaveNotesListAsync(NotesListModel notesList)
        {
            if (notesList != null && notesList.Items.Count > 0)
            {
                const string notesListFileName = "notesList.json";

                await _localStorage.SaveFileAsync(notesListFileName, notesList);

                if (_remoteFileStorage != null)
                {
                    await _remoteFileStorage.CreateFileAsync(notesListFileName, notesList);
                }
            }
        }
        private async Task <NotesListModel> GetNotesListAsync(IFileStorageHelper storageHelper)
        {
            if (storageHelper == null)
            {
                return(null);
            }

            // Get the list of stored notes.
            string notesListFileName = "notesList.json";

            try
            {
                NotesListModel notesList = await storageHelper.ReadFileAsync <NotesListModel>(notesListFileName);

                return(notesList);
            }
            catch (System.Exception e)
            {
                return(null);
            }
        }
        private async Task <NotePageModel> GetCurrentNotePage(ISettingsStorageHelper <string> settingsStorage, IFileStorageHelper fileStorage, NotesListModel notesList)
        {
            if (fileStorage == null || settingsStorage == null)
            {
                return(null);
            }

            if (settingsStorage.TryRead <string>("currentNotePageId", out string currentNotePageId) && currentNotePageId != null)
            {
                foreach (var notesListItem in notesList.Items)
                {
                    if (currentNotePageId == notesListItem.NotePageId)
                    {
                        string notePageFileName = GetNotePageFileName(notesListItem);
                        return(await fileStorage.ReadFileAsync <NotePageModel>(notePageFileName));
                    }
                }
            }

            return(null);
        }