Continuous Reading for Webtoons & I Just Couldn't Stop Coding (#574)

* Fixed an issue from perf tuning where I forgot to send Pages to frontend, breaking reader.

* Built out continuous reading for webtoon reader. Still has some issues with triggering.

* Refactored GetUserByUsernameAsync to have a new flavor and allow the caller to pass in bitwise flags for what to include. This has a get by username or id variant. Code is much cleaner and snappier as we avoid many extra joins when not needed.

* Cleanup old code from UserRepository.cs

* Refactored OPDS to use faster API lookups for User

* Refactored more code to be cleaner and faster.

* Refactored GetNext/Prev ChapterIds to ReaderService.

* Refactored Repository methods to their correct entity repos.

* Refactored DTOs and overall cleanup of the code.

* Added ability to press 'b' to bookmark a page

* On hitting last page, save progress forcing last page to be read. Adjusted logic for the top and bottom spacers for triggering next/prev chapter load

* When at top or moving between chapters, scrolling down then up will now trigger page load. Show a toastr to inform the user of a change in chapter (it can be really fast to switch)

* Cleaned up scroll code

* Fixed an issue where loading a chapter with last page bookmarked, we'd load lastpage - 1

* Fixed last page of webtoon reader not being resumed on loading said chapter due to a difference in how max page is handled between infinite scroller and manga reader.

* Removed some comments

* Book reader shouldn't look at left/right tap to paginate elems for position bookmarking. Missed a few areas for saving while in incognito mode

* Added a benchmark to test out a sort code

* Updated the read status on reading list to use same style as other places

* Refactored GetNextChapterId to bring the average response time from 1.2 seconds to 400ms.

* Added a filter to add to list when there are more than 5 reading lists

* Added download reading list (will be removed, just saving for later). Fixes around styling on reading lists

* Removed ability to download reading lists

* Tweaked the logic for infinite scroller to be much smoother loading next/prev chapter. Added a bug marker for a concurrency bug.

* Updated the top spacer so that when you hit the top, you stay at the page height and can now just scroll up.

* Got the logic for scrolling up. Now just need the CSS then cont infinite scroller will be working

* More polishing on infinite scroller

* Removed IsSpecial on volumeDto, which is not used anywhere.

* Cont Reading inf scroller edition is done.

* Code smells and fixed package.json explore script

API/Data/Repositories/ChapterRepository.cs

@@ -1,9 +1,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using API.DTOs;
 using API.DTOs.Reader;
 using API.Entities;
 using API.Interfaces.Repositories;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace API.Data.Repositories
@@ -11,10 +14,12 @@ namespace API.Data.Repositories
     public class ChapterRepository : IChapterRepository
     {
         private readonly DataContext _context;
+        private readonly IMapper _mapper;
 
-        public ChapterRepository(DataContext context)
+        public ChapterRepository(DataContext context, IMapper mapper)
         {
             _context = context;
+            _mapper = mapper;
         }
 
         public void Update(Chapter chapter)
@@ -30,8 +35,6 @@ namespace API.Data.Repositories
                 .ToListAsync();
         }
 
-        // TODO: Move over Chapter based queries here
-
         /// <summary>
         /// Populates a partial IChapterInfoDto
         /// </summary>
@@ -76,5 +79,87 @@ namespace API.Data.Repositories
                 .AsNoTracking()
                 .SingleAsync();
         }
+
+        public Task<int> GetChapterTotalPagesAsync(int chapterId)
+        {
+            return _context.Chapter
+                .Where(c => c.Id == chapterId)
+                .Select(c => c.Pages)
+                .SingleOrDefaultAsync();
+        }
+        public async Task<ChapterDto> GetChapterDtoAsync(int chapterId)
+        {
+            var chapter = await _context.Chapter
+                .Include(c => c.Files)
+                .ProjectTo<ChapterDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking()
+                .SingleOrDefaultAsync(c => c.Id == chapterId);
+
+            return chapter;
+        }
+
+        /// <summary>
+        /// Returns non-tracked files for a given chapterId
+        /// </summary>
+        /// <param name="chapterId"></param>
+        /// <returns></returns>
+        public async Task<IList<MangaFile>> GetFilesForChapterAsync(int chapterId)
+        {
+            return await _context.MangaFile
+                .Where(c => chapterId == c.ChapterId)
+                .AsNoTracking()
+                .ToListAsync();
+        }
+
+        /// <summary>
+        /// Returns a Chapter for an Id. Includes linked <see cref="MangaFile"/>s.
+        /// </summary>
+        /// <param name="chapterId"></param>
+        /// <returns></returns>
+        public async Task<Chapter> GetChapterAsync(int chapterId)
+        {
+            return await _context.Chapter
+                .Include(c => c.Files)
+                .SingleOrDefaultAsync(c => c.Id == chapterId);
+        }
+
+        /// <summary>
+        /// Returns Chapters for a volume id.
+        /// </summary>
+        /// <param name="volumeId"></param>
+        /// <returns></returns>
+        public async Task<IList<Chapter>> GetChaptersAsync(int volumeId)
+        {
+            return await _context.Chapter
+                .Where(c => c.VolumeId == volumeId)
+                .ToListAsync();
+        }
+
+        /// <summary>
+        /// Returns the cover image for a chapter id.
+        /// </summary>
+        /// <param name="chapterId"></param>
+        /// <returns></returns>
+        public async Task<byte[]> GetChapterCoverImageAsync(int chapterId)
+        {
+            return await _context.Chapter
+                .Where(c => c.Id == chapterId)
+                .Select(c => c.CoverImage)
+                .AsNoTracking()
+                .SingleOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Returns non-tracked files for a set of chapterIds
+        /// </summary>
+        /// <param name="chapterIds"></param>
+        /// <returns></returns>
+        public async Task<IList<MangaFile>> GetFilesForChaptersAsync(IReadOnlyList<int> chapterIds)
+        {
+            return await _context.MangaFile
+                .Where(c => chapterIds.Contains(c.ChapterId))
+                .AsNoTracking()
+                .ToListAsync();
+        }
     }
 }