Bookmarking Pages within the Reader (#469)

# Added
- Added: Added the ability to bookmark certain pages within the manga (image) reader and later download them from the series context menu. 

# Fixed
- Fixed: Fixed an issue where after adding a new folder to an existing library, a scan wouldn't be kicked off
- Fixed: In some cases, after clicking the background of a modal, the modal would close, but state wouldn't be handled as if cancel was pushed

# Changed
- Changed: Admin contextual actions on cards will now be separated by a line to help differentiate. 
- Changed: Performance enhancement on an API used before reading

# Dev
- Bumped dependencies to latest versions

=============================================
* Bumped versions of dependencies and refactored bookmark to progress.

* Refactored method names in UI from bookmark to progress to prepare for new bookmark entity

* Basic code is done, user can now bookmark a page (currently image reader only).

* Comments and pipes

* Some accessibility for new bookmark button

* Fixed up the APIs to work correctly, added a new modal to quickly explore bookmarks (not implemented, not final).

* Cleanup on the UI side to get the modal to look decent

* Added dismissed handlers for modals where appropriate

* Refactored UI to only show number of bookmarks across files to simplify delivery. Admin actionables are now separated by hr vs non-admin actions.

* Basic API implemented, now to implement the ability to actually extract files.

* Implemented the ability to download bookmarks.

* Fixed a bug where adding a new folder to an existing library would not trigger a scan library task.

* Fixed an issue that could cause bookmarked pages to get copied out of order.

* Added handler from series-card component

API/Controllers/DownloadController.cs

@@ -3,7 +3,11 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using API.Comparators;
+using API.DTOs;
+using API.DTOs.Downloads;
 using API.Entities;
+using API.Entities.Enums;
 using API.Extensions;
 using API.Interfaces;
 using API.Interfaces.Services;
@@ -21,12 +25,16 @@ namespace API.Controllers
         private readonly IUnitOfWork _unitOfWork;
         private readonly IArchiveService _archiveService;
         private readonly IDirectoryService _directoryService;
+        private readonly ICacheService _cacheService;
+        private readonly NumericComparer _numericComparer;
 
-        public DownloadController(IUnitOfWork unitOfWork, IArchiveService archiveService, IDirectoryService directoryService)
+        public DownloadController(IUnitOfWork unitOfWork, IArchiveService archiveService, IDirectoryService directoryService, ICacheService cacheService)
         {
             _unitOfWork = unitOfWork;
             _archiveService = archiveService;
             _directoryService = directoryService;
+            _cacheService = cacheService;
+            _numericComparer = new NumericComparer();
         }
 
         [HttpGet("volume-size")]
@@ -39,7 +47,7 @@ namespace API.Controllers
         [HttpGet("chapter-size")]
         public async Task<ActionResult<long>> GetChapterSize(int chapterId)
         {
-            var files = await _unitOfWork.VolumeRepository.GetFilesForChapter(chapterId);
+            var files = await _unitOfWork.VolumeRepository.GetFilesForChapterAsync(chapterId);
             return Ok(DirectoryService.GetTotalSize(files.Select(c => c.FilePath)));
         }
 
@@ -96,7 +104,7 @@ namespace API.Controllers
         [HttpGet("chapter")]
         public async Task<ActionResult> DownloadChapter(int chapterId)
         {
-            var files = await _unitOfWork.VolumeRepository.GetFilesForChapter(chapterId);
+            var files = await _unitOfWork.VolumeRepository.GetFilesForChapterAsync(chapterId);
             try
             {
                 if (files.Count == 1)
@@ -132,5 +140,62 @@ namespace API.Controllers
                 return BadRequest(ex.Message);
             }
         }
+
+        [HttpPost("bookmarks")]
+        public async Task<ActionResult> DownloadBookmarkPages(DownloadBookmarkDto downloadBookmarkDto)
+        {
+            // We know that all bookmarks will be for one single seriesId
+            var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(downloadBookmarkDto.Bookmarks.First().SeriesId);
+            var totalFilePaths = new List<string>();
+
+            var tempFolder = $"download_{series.Id}_bookmarks";
+            var fullExtractPath = Path.Join(DirectoryService.TempDirectory, tempFolder);
+            if (new DirectoryInfo(fullExtractPath).Exists)
+            {
+                return BadRequest(
+                    "Server is currently processing this exact download. Please try again in a few minutes.");
+            }
+            DirectoryService.ExistOrCreate(fullExtractPath);
+
+            var uniqueChapterIds = downloadBookmarkDto.Bookmarks.Select(b => b.ChapterId).Distinct().ToList();
+
+            foreach (var chapterId in uniqueChapterIds)
+            {
+                var chapterExtractPath = Path.Join(fullExtractPath, $"{series.Id}_bookmark_{chapterId}");
+                var chapterPages = downloadBookmarkDto.Bookmarks.Where(b => b.ChapterId == chapterId)
+                    .Select(b => b.Page).ToList();
+                var mangaFiles = await _unitOfWork.VolumeRepository.GetFilesForChapterAsync(chapterId);
+                switch (series.Format)
+                {
+                    case MangaFormat.Image:
+                        DirectoryService.ExistOrCreate(chapterExtractPath);
+                        _directoryService.CopyFilesToDirectory(mangaFiles.Select(f => f.FilePath), chapterExtractPath, $"{chapterId}_");
+                        break;
+                    case MangaFormat.Archive:
+                    case MangaFormat.Pdf:
+                        _cacheService.ExtractChapterFiles(chapterExtractPath, mangaFiles.ToList());
+                        var originalFiles = _directoryService.GetFilesWithExtension(chapterExtractPath,
+                            Parser.Parser.ImageFileExtensions);
+                        _directoryService.CopyFilesToDirectory(originalFiles, chapterExtractPath, $"{chapterId}_");
+                        DirectoryService.DeleteFiles(originalFiles);
+                        break;
+                    case MangaFormat.Epub:
+                        return BadRequest("Series is not in a valid format.");
+                    default:
+                        return BadRequest("Series is not in a valid format. Please rescan series and try again.");
+                }
+
+                var files = _directoryService.GetFilesWithExtension(chapterExtractPath, Parser.Parser.ImageFileExtensions);
+                // Filter out images that aren't in bookmarks
+                Array.Sort(files, _numericComparer);
+                totalFilePaths.AddRange(files.Where((t, i) => chapterPages.Contains(i)));
+            }
+
+
+            var (fileBytes, zipPath) = await _archiveService.CreateZipForDownload(totalFilePaths,
+                tempFolder);
+            DirectoryService.ClearAndDeleteDirectory(fullExtractPath);
+            return File(fileBytes, "application/zip", $"{series.Name} - Bookmarks.zip");
+        }
     }
 }

API/Controllers/LibraryController.cs

@@ -203,8 +203,7 @@ namespace API.Controllers
         {
             var library = await _unitOfWork.LibraryRepository.GetLibraryForIdAsync(libraryForUserDto.Id);
 
-            var originalFolders = library.Folders.Select(x => x.Path);
-            var differenceBetweenFolders = originalFolders.Except(libraryForUserDto.Folders);
+            var originalFolders = library.Folders.Select(x => x.Path).ToList();
 
             library.Name = libraryForUserDto.Name;
             library.Folders = libraryForUserDto.Folders.Select(s => new FolderPath() {Path = s}).ToList();
@@ -212,9 +211,9 @@ namespace API.Controllers
             _unitOfWork.LibraryRepository.Update(library);
 
             if (!await _unitOfWork.CommitAsync()) return BadRequest("There was a critical issue updating the library.");
-            if (differenceBetweenFolders.Any())
+            if (originalFolders.Count != libraryForUserDto.Folders.Count())
             {
-                _taskScheduler.ScanLibrary(library.Id, true);
+                _taskScheduler.ScanLibrary(library.Id);
             }
 
             return Ok();

API/Controllers/ReaderController.cs

@@ -50,15 +50,16 @@ namespace API.Controllers
         }
 
         [HttpGet("chapter-info")]
-        public async Task<ActionResult<ChapterInfoDto>> GetChapterInfo(int chapterId)
+        public async Task<ActionResult<ChapterInfoDto>> GetChapterInfo(int seriesId, int chapterId)
         {
             // PERF: Write this in one DB call
             var chapter = await _cacheService.Ensure(chapterId);
             if (chapter == null) return BadRequest("Could not find Chapter");
-            var volume = await _unitOfWork.SeriesRepository.GetVolumeAsync(chapter.VolumeId);
+
+            var volume = await _unitOfWork.SeriesRepository.GetVolumeDtoAsync(chapter.VolumeId);
             if (volume == null) return BadRequest("Could not find Volume");
-            var (_, mangaFile) = await _cacheService.GetCachedPagePath(chapter, 0);
-            var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(volume.SeriesId);
+            var mangaFile = (await _unitOfWork.VolumeRepository.GetFilesForChapterAsync(chapterId)).First();
+            var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId);
 
             return Ok(new ChapterInfoDto()
             {
@@ -72,29 +73,6 @@ namespace API.Controllers
             });
         }
 
-        [HttpGet("get-bookmark")]
-        public async Task<ActionResult<BookmarkDto>> GetBookmark(int chapterId)
-        {
-            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
-            var bookmark = new BookmarkDto()
-            {
-                PageNum = 0,
-                ChapterId = chapterId,
-                VolumeId = 0,
-                SeriesId = 0
-            };
-            if (user.Progresses == null) return Ok(bookmark);
-            var progress = user.Progresses.SingleOrDefault(x => x.AppUserId == user.Id && x.ChapterId == chapterId);
-
-            if (progress != null)
-            {
-                bookmark.SeriesId = progress.SeriesId;
-                bookmark.VolumeId = progress.VolumeId;
-                bookmark.PageNum = progress.PagesRead;
-                bookmark.BookScrollId = progress.BookScrollId;
-            }
-            return Ok(bookmark);
-        }
 
         [HttpPost("mark-read")]
         public async Task<ActionResult> MarkRead(MarkReadDto markReadDto)
@@ -232,21 +210,45 @@ namespace API.Controllers
             return BadRequest("Could not save progress");
         }
 
-        [HttpPost("bookmark")]
-        public async Task<ActionResult> Bookmark(BookmarkDto bookmarkDto)
+        [HttpGet("get-progress")]
+        public async Task<ActionResult<ProgressDto>> GetProgress(int chapterId)
+        {
+            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
+            var progressBookmark = new ProgressDto()
+            {
+                PageNum = 0,
+                ChapterId = chapterId,
+                VolumeId = 0,
+                SeriesId = 0
+            };
+            if (user.Progresses == null) return Ok(progressBookmark);
+            var progress = user.Progresses.SingleOrDefault(x => x.AppUserId == user.Id && x.ChapterId == chapterId);
+
+            if (progress != null)
+            {
+                progressBookmark.SeriesId = progress.SeriesId;
+                progressBookmark.VolumeId = progress.VolumeId;
+                progressBookmark.PageNum = progress.PagesRead;
+                progressBookmark.BookScrollId = progress.BookScrollId;
+            }
+            return Ok(progressBookmark);
+        }
+
+        [HttpPost("progress")]
+        public async Task<ActionResult> BookmarkProgress(ProgressDto progressDto)
         {
             var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
 
-            // Don't let user bookmark past total pages.
-            var chapter = await _unitOfWork.VolumeRepository.GetChapterAsync(bookmarkDto.ChapterId);
-            if (bookmarkDto.PageNum > chapter.Pages)
+            // Don't let user save past total pages.
+            var chapter = await _unitOfWork.VolumeRepository.GetChapterAsync(progressDto.ChapterId);
+            if (progressDto.PageNum > chapter.Pages)
             {
-                bookmarkDto.PageNum = chapter.Pages;
+                progressDto.PageNum = chapter.Pages;
             }
 
-            if (bookmarkDto.PageNum < 0)
+            if (progressDto.PageNum < 0)
             {
-                bookmarkDto.PageNum = 0;
+                progressDto.PageNum = 0;
             }
 
 
@@ -255,26 +257,26 @@ namespace API.Controllers
                 // TODO: Look into creating a progress entry when a new item is added to the DB so we can just look it up and modify it
                user.Progresses ??= new List<AppUserProgress>();
                var userProgress =
-                  user.Progresses.SingleOrDefault(x => x.ChapterId == bookmarkDto.ChapterId && x.AppUserId == user.Id);
+                  user.Progresses.SingleOrDefault(x => x.ChapterId == progressDto.ChapterId && x.AppUserId == user.Id);
 
                if (userProgress == null)
                {
                   user.Progresses.Add(new AppUserProgress
                   {
-                     PagesRead = bookmarkDto.PageNum,
-                     VolumeId = bookmarkDto.VolumeId,
-                     SeriesId = bookmarkDto.SeriesId,
-                     ChapterId = bookmarkDto.ChapterId,
-                     BookScrollId = bookmarkDto.BookScrollId,
+                     PagesRead = progressDto.PageNum,
+                     VolumeId = progressDto.VolumeId,
+                     SeriesId = progressDto.SeriesId,
+                     ChapterId = progressDto.ChapterId,
+                     BookScrollId = progressDto.BookScrollId,
                      LastModified = DateTime.Now
                   });
                }
                else
                {
-                  userProgress.PagesRead = bookmarkDto.PageNum;
-                  userProgress.SeriesId = bookmarkDto.SeriesId;
-                  userProgress.VolumeId = bookmarkDto.VolumeId;
-                  userProgress.BookScrollId = bookmarkDto.BookScrollId;
+                  userProgress.PagesRead = progressDto.PageNum;
+                  userProgress.SeriesId = progressDto.SeriesId;
+                  userProgress.VolumeId = progressDto.VolumeId;
+                  userProgress.BookScrollId = progressDto.BookScrollId;
                   userProgress.LastModified = DateTime.Now;
                }
 
@@ -293,6 +295,139 @@ namespace API.Controllers
             return BadRequest("Could not save progress");
         }
 
+        [HttpGet("get-bookmarks")]
+        public async Task<ActionResult<IEnumerable<BookmarkDto>>> GetBookmarks(int chapterId)
+        {
+            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
+            if (user.Bookmarks == null) return Ok(Array.Empty<BookmarkDto>());
+            return Ok(await _unitOfWork.UserRepository.GetBookmarkDtosForChapter(user.Id, chapterId));
+        }
+
+        [HttpPost("remove-bookmarks")]
+        public async Task<ActionResult> RemoveBookmarks(int seriesId)
+        {
+            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
+            if (user.Bookmarks == null) return Ok("Nothing to remove");
+            try
+            {
+                user.Bookmarks = user.Bookmarks.Where(bmk => bmk.SeriesId == seriesId).ToList();
+                _unitOfWork.UserRepository.Update(user);
+
+                if (await _unitOfWork.CommitAsync())
+                {
+                    return Ok();
+                }
+            }
+            catch (Exception)
+            {
+                await _unitOfWork.RollbackAsync();
+            }
+
+            return BadRequest("Could not clear bookmarks");
+
+        }
+
+        [HttpGet("get-volume-bookmarks")]
+        public async Task<ActionResult<IEnumerable<BookmarkDto>>> GetBookmarksForVolume(int volumeId)
+        {
+            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
+            if (user.Bookmarks == null) return Ok(Array.Empty<BookmarkDto>());
+            return Ok(await _unitOfWork.UserRepository.GetBookmarkDtosForVolume(user.Id, volumeId));
+        }
+
+        [HttpGet("get-series-bookmarks")]
+        public async Task<ActionResult<IEnumerable<BookmarkDto>>> GetBookmarksForSeries(int seriesId)
+        {
+            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
+            if (user.Bookmarks == null) return Ok(Array.Empty<BookmarkDto>());
+
+            return Ok(await _unitOfWork.UserRepository.GetBookmarkDtosForSeries(user.Id, seriesId));
+        }
+
+        [HttpPost("bookmark")]
+        public async Task<ActionResult> BookmarkPage(BookmarkDto bookmarkDto)
+        {
+            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
+
+            // Don't let user save past total pages.
+            var chapter = await _unitOfWork.VolumeRepository.GetChapterAsync(bookmarkDto.ChapterId);
+            if (bookmarkDto.Page > chapter.Pages)
+            {
+                bookmarkDto.Page = chapter.Pages;
+            }
+
+            if (bookmarkDto.Page < 0)
+            {
+                bookmarkDto.Page = 0;
+            }
+
+
+            try
+            {
+                user.Bookmarks ??= new List<AppUserBookmark>();
+               var userBookmark =
+                  user.Bookmarks.SingleOrDefault(x => x.ChapterId == bookmarkDto.ChapterId && x.AppUserId == user.Id && x.Page == bookmarkDto.Page);
+
+               if (userBookmark == null)
+               {
+                  user.Bookmarks.Add(new AppUserBookmark()
+                  {
+                     Page = bookmarkDto.Page,
+                     VolumeId = bookmarkDto.VolumeId,
+                     SeriesId = bookmarkDto.SeriesId,
+                     ChapterId = bookmarkDto.ChapterId,
+                  });
+               }
+               else
+               {
+                   userBookmark.Page = bookmarkDto.Page;
+                   userBookmark.SeriesId = bookmarkDto.SeriesId;
+                   userBookmark.VolumeId = bookmarkDto.VolumeId;
+               }
+
+               _unitOfWork.UserRepository.Update(user);
+
+               if (await _unitOfWork.CommitAsync())
+               {
+                  return Ok();
+               }
+            }
+            catch (Exception)
+            {
+               await _unitOfWork.RollbackAsync();
+            }
+
+            return BadRequest("Could not save bookmark");
+        }
+
+        [HttpPost("unbookmark")]
+        public async Task<ActionResult> UnBookmarkPage(BookmarkDto bookmarkDto)
+        {
+            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
+
+            if (user.Bookmarks == null) return Ok();
+            try {
+                user.Bookmarks = user.Bookmarks.Where(x =>
+                    x.ChapterId == bookmarkDto.ChapterId
+                    && x.AppUserId == user.Id
+                    && x.Page != bookmarkDto.Page).ToList();
+
+
+                _unitOfWork.UserRepository.Update(user);
+
+                if (await _unitOfWork.CommitAsync())
+                {
+                    return Ok();
+                }
+            }
+            catch (Exception)
+            {
+                await _unitOfWork.RollbackAsync();
+            }
+
+            return BadRequest("Could not remove bookmark");
+        }
+
         /// <summary>
         /// Returns the next logical chapter from the series.
         /// </summary>