Reading Lists & More (#564)

* Added continous reading to the book reader. Clicking on the max pages to right of progress bar will now go to last page.

* Forgot a file for continous book reading

* Fixed up some code regarding transitioning between chapters. Arrows now show to represent a chapter transition.

* Laid the foundation for reading lists

* All foundation is laid out. Actions are wired in the UI. Backend repository is setup. Redid the migration to have ReadingList track modification so we can order them for the user.

* Updated add modal to have basic skeleton

* Hooked up ability to fetch reading lists from backend

* Made a huge performance improvement to GetChapterIdsForSeriesAsync() by reducing a JOIN and an iteration loop. Improvement went from 2 seconds -> 200 ms.

* Implemented the ability to add all chapters in a series to a reading list.

* Fixed issue with adding new items to reading list not being in a logical order. Lots of work on getting all the information around the reading list view. Added some foreign keys back to chapter so delete should clean up after itself.

* Added ability to open directly the series

* Reading List Items now have progress attached

* Hooked up list deletion and added a case where if doesn't exist on load, then redirect to library.

* Lots of changes. Introduced a dashboard component for the main app. This will sit on libraries route for now and will have 3 tabs to show different sections.

Moved libraries reel down to bottom as people are more likely to access recently added or in progress than explore their whole library.

Note: Bundles are messed up, they need to be reoptimized and routes need to be updated.

* Added pagination to the reading lists api and implemented a page to show all lists

* Cleaned up old code from all-collections component so now it only handles all collections and doesn't have the old code for an individual collection

* Hooked in actions and navigation on reading lists

* When the user re-arranges items, they are now persisted

* Implemented remove read, but performance is pretty poor. Needs to be optimized.

* Lots of API fixes for adding items to a series, returning items, etc. Committing before fixing incorrect fetches of items for a readingListId.

* Rewrote the joins for GetReadingListItemDtosByIdAsync() to not return extra records.

* Remove bug marker now that it is fixed

* Refactor update-by-series to move more of the code to a re-usable function for update-by-volume/chapter APIs

* Implemented the ability to add via series, volume or chapter.

* Added OPDS support for reading lists. This included adding VolumeId to the ReadingListDto.

* Fixed a bug with deleting items

* After we create a library inform user that a scan has started

* Added some extra help information for users on directory picker, since linux users were getting confused.

* Setup for the reading functionality

* Fixed an issue where opening the edit series modal and pressing save without doing anything would empty collection tags. Would happen often when editing cover images.

* Fixed get-next-chapter for reading list. Refactored all methods to use the new GetUserIdByUsernameAsync(), which is much faster and uses less memory.

* Hooked in prev chapter for continuous reading with reading list

* Hooked up the read code for manga reader and book reader to have list id passed

* Manga reader now functions completely with reading lists

* Implemented reading list and incognito mode into book reader

* Refactored some common reading code into reader service

* Added support for "Series -  - Vol. 03 Ch. 023.5 - Volume 3 Extras.cbz" format that can occur with FMD2.

* Implemented continuous reading with a reading list between different readers. This incurs a 3x performance hit on the book info api.

* style changes. Don't emit an event if position of draggable item hasn't changed

* Styling and added the edit reading list flow.

* Cleaned up some extra spaces when actionables isn't shown. Lots of cleanup for promoted lists.

* Refactored some filter code to a common service

* Added an RBS check in getting Items for a given user.

* Code smells

* More smells

API/Data/Repositories/AppUserProgressRepository.cs

@@ -0,0 +1,57 @@
+using System.Linq;
+using System.Threading.Tasks;
+using API.Entities.Enums;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class AppUserProgressRepository : IAppUserProgressRepository
+    {
+        private readonly DataContext _context;
+
+        public AppUserProgressRepository(DataContext context)
+        {
+            _context = context;
+        }
+
+        /// <summary>
+        /// This will remove any entries that have chapterIds that no longer exists. This will execute the save as well.
+        /// </summary>
+        public async Task<int> CleanupAbandonedChapters()
+        {
+            var chapterIds = _context.Chapter.Select(c => c.Id);
+
+            var rowsToRemove = await _context.AppUserProgresses
+                .Where(progress => !chapterIds.Contains(progress.ChapterId))
+                .ToListAsync();
+
+            _context.RemoveRange(rowsToRemove);
+            return await _context.SaveChangesAsync() > 0 ? rowsToRemove.Count : 0;
+        }
+
+        /// <summary>
+        /// Checks if user has any progress against a library of passed type
+        /// </summary>
+        /// <param name="libraryType"></param>
+        /// <param name="userId"></param>
+        /// <returns></returns>
+        public async Task<bool> UserHasProgress(LibraryType libraryType, int userId)
+        {
+            var seriesIds = await _context.AppUserProgresses
+                .Where(aup => aup.PagesRead > 0 && aup.AppUserId == userId)
+                .AsNoTracking()
+                .Select(aup => aup.SeriesId)
+                .ToListAsync();
+
+            if (seriesIds.Count == 0) return false;
+
+            return await _context.Series
+                .Include(s => s.Library)
+                .Where(s => seriesIds.Contains(s.Id) && s.Library.Type == libraryType)
+                .AsNoTracking()
+                .AnyAsync();
+        }
+    }
+}

API/Data/Repositories/ChapterRepository.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.Entities;
+using API.Interfaces.Repositories;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class ChapterRepository : IChapterRepository
+    {
+        private readonly DataContext _context;
+
+        public ChapterRepository(DataContext context)
+        {
+            _context = context;
+        }
+
+        public void Update(Chapter chapter)
+        {
+            _context.Entry(chapter).State = EntityState.Modified;
+        }
+
+        public async Task<IEnumerable<Chapter>> GetChaptersByIdsAsync(IList<int> chapterIds)
+        {
+            return await _context.Chapter
+                .Where(c => chapterIds.Contains(c.Id))
+                .Include(c => c.Volume)
+                .ToListAsync();
+        }
+
+        // TODO: Move over Chapter based queries here
+    }
+}

API/Data/Repositories/CollectionTagRepository.cs

@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.DTOs;
+using API.Entities;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class CollectionTagRepository : ICollectionTagRepository
+    {
+        private readonly DataContext _context;
+        private readonly IMapper _mapper;
+
+        public CollectionTagRepository(DataContext context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public void Remove(CollectionTag tag)
+        {
+            _context.CollectionTag.Remove(tag);
+        }
+
+        public void Update(CollectionTag tag)
+        {
+            _context.Entry(tag).State = EntityState.Modified;
+        }
+
+        /// <summary>
+        /// Removes any collection tags without any series
+        /// </summary>
+        public async Task<int> RemoveTagsWithoutSeries()
+        {
+            var tagsToDelete = await _context.CollectionTag
+                .Include(c => c.SeriesMetadatas)
+                .Where(c => c.SeriesMetadatas.Count == 0)
+                .ToListAsync();
+            _context.RemoveRange(tagsToDelete);
+
+            return await _context.SaveChangesAsync();
+        }
+
+        public async Task<IEnumerable<CollectionTag>> GetAllTagsAsync()
+        {
+            return await _context.CollectionTag
+                .Select(c => c)
+                .OrderBy(c => c.NormalizedTitle)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<CollectionTagDto>> GetAllTagDtosAsync()
+        {
+            return await _context.CollectionTag
+                .Select(c => c)
+                .OrderBy(c => c.NormalizedTitle)
+                .AsNoTracking()
+                .ProjectTo<CollectionTagDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<CollectionTagDto>> GetAllPromotedTagDtosAsync()
+        {
+            return await _context.CollectionTag
+                .Where(c => c.Promoted)
+                .OrderBy(c => c.NormalizedTitle)
+                .AsNoTracking()
+                .ProjectTo<CollectionTagDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<CollectionTag> GetTagAsync(int tagId)
+        {
+            return await _context.CollectionTag
+                .Where(c => c.Id == tagId)
+                .SingleOrDefaultAsync();
+        }
+
+        public async Task<CollectionTag> GetFullTagAsync(int tagId)
+        {
+            return await _context.CollectionTag
+                .Where(c => c.Id == tagId)
+                .Include(c => c.SeriesMetadatas)
+                .SingleOrDefaultAsync();
+        }
+
+        public async Task<IEnumerable<CollectionTagDto>> SearchTagDtosAsync(string searchQuery)
+        {
+            return await _context.CollectionTag
+                .Where(s => EF.Functions.Like(s.Title, $"%{searchQuery}%")
+                            || EF.Functions.Like(s.NormalizedTitle, $"%{searchQuery}%"))
+                .OrderBy(s => s.Title)
+                .AsNoTracking()
+                .OrderBy(c => c.NormalizedTitle)
+                .ProjectTo<CollectionTagDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public Task<byte[]> GetCoverImageAsync(int collectionTagId)
+        {
+            return _context.CollectionTag
+                .Where(c => c.Id == collectionTagId)
+                .Select(c => c.CoverImage)
+                .AsNoTracking()
+                .SingleOrDefaultAsync();
+        }
+    }
+}

API/Data/Repositories/FileRepository.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class FileRepository : IFileRepository
+    {
+        private readonly DataContext _dbContext;
+
+        public FileRepository(DataContext context)
+        {
+            _dbContext = context;
+        }
+
+        public async Task<IEnumerable<string>> GetFileExtensions()
+        {
+            var fileExtensions = await _dbContext.MangaFile
+                .AsNoTracking()
+                .Select(x => x.FilePath.ToLower())
+                .Distinct()
+                .ToArrayAsync();
+
+            var uniqueFileTypes = fileExtensions
+                .Select(Path.GetExtension)
+                .Where(x => x is not null)
+                .Distinct();
+
+            return uniqueFileTypes;
+        }
+    }
+}

API/Data/Repositories/LibraryRepository.cs

@@ -0,0 +1,165 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.DTOs;
+using API.Entities;
+using API.Entities.Enums;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class LibraryRepository : ILibraryRepository
+    {
+        private readonly DataContext _context;
+        private readonly IMapper _mapper;
+
+        public LibraryRepository(DataContext context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public void Add(Library library)
+        {
+            _context.Library.Add(library);
+        }
+
+        public void Update(Library library)
+        {
+            _context.Entry(library).State = EntityState.Modified;
+        }
+
+        public void Delete(Library library)
+        {
+            _context.Library.Remove(library);
+        }
+
+        public async Task<IEnumerable<LibraryDto>> GetLibraryDtosForUsernameAsync(string userName)
+        {
+            return await _context.Library
+                .Include(l => l.AppUsers)
+                .Where(library => library.AppUsers.Any(x => x.UserName == userName))
+                .OrderBy(l => l.Name)
+                .ProjectTo<LibraryDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking()
+                .AsSingleQuery()
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<Library>> GetLibrariesAsync()
+        {
+            return await _context.Library
+                .Include(l => l.AppUsers)
+                .ToListAsync();
+        }
+
+        public async Task<bool> DeleteLibrary(int libraryId)
+        {
+            var library = await GetLibraryForIdAsync(libraryId);
+            _context.Library.Remove(library);
+            return await _context.SaveChangesAsync() > 0;
+        }
+
+        public async Task<IEnumerable<Library>> GetLibrariesForUserIdAsync(int userId)
+        {
+            return await _context.Library
+                .Include(l => l.AppUsers)
+                .Where(l => l.AppUsers.Select(ap => ap.Id).Contains(userId))
+                .AsNoTracking()
+                .ToListAsync();
+        }
+
+        public async Task<LibraryType> GetLibraryTypeAsync(int libraryId)
+        {
+            return await _context.Library
+                .Where(l => l.Id == libraryId)
+                .AsNoTracking()
+                .Select(l => l.Type)
+                .SingleAsync();
+        }
+
+        public async Task<IEnumerable<LibraryDto>> GetLibraryDtosAsync()
+        {
+            return await _context.Library
+                .Include(f => f.Folders)
+                .OrderBy(l => l.Name)
+                .ProjectTo<LibraryDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking()
+                .ToListAsync();
+        }
+
+        public async Task<Library> GetLibraryForIdAsync(int libraryId)
+        {
+            return await _context.Library
+                .Where(x => x.Id == libraryId)
+                .Include(f => f.Folders)
+                .Include(l => l.Series)
+                .SingleAsync();
+        }
+        /// <summary>
+        /// This returns a Library with all it's Series -> Volumes -> Chapters. This is expensive. Should only be called when needed.
+        /// </summary>
+        /// <param name="libraryId"></param>
+        /// <returns></returns>
+        public async Task<Library> GetFullLibraryForIdAsync(int libraryId)
+        {
+
+            return await _context.Library
+                .Where(x => x.Id == libraryId)
+                .Include(f => f.Folders)
+                .Include(l => l.Series)
+                .ThenInclude(s => s.Metadata)
+                .Include(l => l.Series)
+                .ThenInclude(s => s.Volumes)
+                .ThenInclude(v => v.Chapters)
+                .ThenInclude(c => c.Files)
+                .AsSplitQuery()
+                .SingleAsync();
+        }
+
+        /// <summary>
+        /// This is a heavy call, pulls all entities for a Library, except this version only grabs for one series id
+        /// </summary>
+        /// <param name="libraryId"></param>
+        /// <param name="seriesId"></param>
+        /// <returns></returns>
+        public async Task<Library> GetFullLibraryForIdAsync(int libraryId, int seriesId)
+        {
+
+            return await _context.Library
+                .Where(x => x.Id == libraryId)
+                .Include(f => f.Folders)
+                .Include(l => l.Series.Where(s => s.Id == seriesId))
+                .ThenInclude(s => s.Metadata)
+                .Include(l => l.Series.Where(s => s.Id == seriesId))
+                .ThenInclude(s => s.Volumes)
+                .ThenInclude(v => v.Chapters)
+                .ThenInclude(c => c.Files)
+                .AsSplitQuery()
+                .SingleAsync();
+        }
+
+        public async Task<bool> LibraryExists(string libraryName)
+        {
+            return await _context.Library
+                .AsNoTracking()
+                .AnyAsync(x => x.Name == libraryName);
+        }
+
+        public async Task<IEnumerable<LibraryDto>> GetLibrariesForUserAsync(AppUser user)
+        {
+            return await _context.Library
+                .Where(library => library.AppUsers.Contains(user))
+                .Include(l => l.Folders)
+                .AsNoTracking()
+                .ProjectTo<LibraryDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+
+    }
+}

API/Data/Repositories/ReadingListRepository.cs

@@ -0,0 +1,178 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.DTOs.ReadingLists;
+using API.Entities;
+using API.Helpers;
+using API.Interfaces.Repositories;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class ReadingListRepository : IReadingListRepository
+    {
+        private readonly DataContext _context;
+        private readonly IMapper _mapper;
+
+        public ReadingListRepository(DataContext context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public void Update(ReadingList list)
+        {
+            _context.Entry(list).State = EntityState.Modified;
+        }
+
+        public void Remove(ReadingListItem item)
+        {
+            _context.ReadingListItem.Remove(item);
+        }
+
+        public void BulkRemove(IEnumerable<ReadingListItem> items)
+        {
+            _context.ReadingListItem.RemoveRange(items);
+        }
+
+
+        public async Task<PagedList<ReadingListDto>> GetReadingListDtosForUserAsync(int userId, bool includePromoted, UserParams userParams)
+        {
+            var query = _context.ReadingList
+                .Where(l => l.AppUserId == userId || (includePromoted &&  l.Promoted ))
+                .OrderBy(l => l.LastModified)
+                .ProjectTo<ReadingListDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking();
+
+            return await PagedList<ReadingListDto>.CreateAsync(query, userParams.PageNumber, userParams.PageSize);
+        }
+
+        public async Task<ReadingList> GetReadingListByIdAsync(int readingListId)
+        {
+            return await _context.ReadingList
+                .Where(r => r.Id == readingListId)
+                .Include(r => r.Items)
+                .SingleOrDefaultAsync();
+        }
+
+        public async Task<IEnumerable<ReadingListItemDto>> GetReadingListItemDtosByIdAsync(int readingListId, int userId)
+        {
+            var userLibraries = _context.Library
+                .Include(l => l.AppUsers)
+                .Where(library => library.AppUsers.Any(user => user.Id == userId))
+                .AsNoTracking()
+                .Select(library => library.Id)
+                .ToList();
+
+            var items = await _context.ReadingListItem
+                .Where(s => s.ReadingListId == readingListId)
+                .Join(_context.Chapter, s => s.ChapterId, chapter => chapter.Id, (data, chapter) => new
+                {
+                    TotalPages = chapter.Pages,
+                    ChapterNumber = chapter.Range,
+                    readingListItem = data
+                })
+                .Join(_context.Volume, s => s.readingListItem.VolumeId, volume => volume.Id, (data, volume) => new
+                {
+                    data.readingListItem,
+                    data.TotalPages,
+                    data.ChapterNumber,
+                    VolumeId = volume.Id,
+                    VolumeNumber = volume.Name,
+                })
+                .Join(_context.Series, s => s.readingListItem.SeriesId, series => series.Id,
+                    (data, s) => new
+                    {
+                        SeriesName = s.Name,
+                        SeriesFormat = s.Format,
+                        s.LibraryId,
+                        data.readingListItem,
+                        data.TotalPages,
+                        data.ChapterNumber,
+                        data.VolumeNumber,
+                        data.VolumeId
+                    })
+                .Select(data => new ReadingListItemDto()
+                {
+                    Id = data.readingListItem.Id,
+                    ChapterId = data.readingListItem.ChapterId,
+                    Order = data.readingListItem.Order,
+                    SeriesId = data.readingListItem.SeriesId,
+                    SeriesName = data.SeriesName,
+                    SeriesFormat = data.SeriesFormat,
+                    PagesTotal = data.TotalPages,
+                    ChapterNumber = data.ChapterNumber,
+                    VolumeNumber = data.VolumeNumber,
+                    LibraryId = data.LibraryId,
+                    VolumeId = data.VolumeId,
+                    ReadingListId = data.readingListItem.ReadingListId
+                })
+                .Where(o => userLibraries.Contains(o.LibraryId))
+                .OrderBy(rli => rli.Order)
+                .AsNoTracking()
+                .ToListAsync();
+
+            // Attach progress information
+            var fetchedChapterIds = items.Select(i => i.ChapterId);
+            var progresses = await _context.AppUserProgresses
+                .Where(p => fetchedChapterIds.Contains(p.ChapterId))
+                .AsNoTracking()
+                .ToListAsync();
+
+            foreach (var progress in progresses)
+            {
+                var progressItem = items.SingleOrDefault(i => i.ChapterId == progress.ChapterId && i.ReadingListId == readingListId);
+                if (progressItem == null) continue;
+
+                progressItem.PagesRead = progress.PagesRead;
+            }
+
+            return items;
+        }
+
+        public async Task<ReadingListDto> GetReadingListDtoByIdAsync(int readingListId, int userId)
+        {
+            return await _context.ReadingList
+                .Where(r => r.Id == readingListId && (r.AppUserId == userId || r.Promoted))
+                .ProjectTo<ReadingListDto>(_mapper.ConfigurationProvider)
+                .SingleOrDefaultAsync();
+        }
+
+        public async Task<IEnumerable<ReadingListItemDto>> AddReadingProgressModifiers(int userId, IList<ReadingListItemDto> items)
+        {
+            var chapterIds = items.Select(i => i.ChapterId).Distinct().ToList();
+            var userProgress = await _context.AppUserProgresses
+                .Where(p => p.AppUserId == userId && chapterIds.Contains(p.ChapterId))
+                .AsNoTracking()
+                .ToListAsync();
+
+            foreach (var item in items)
+            {
+                var progress = userProgress.Where(p => p.ChapterId == item.ChapterId);
+                item.PagesRead = progress.Sum(p => p.PagesRead);
+            }
+
+            return items;
+        }
+
+        public async Task<ReadingListDto> GetReadingListDtoByTitleAsync(string title)
+        {
+            return await _context.ReadingList
+                .Where(r => r.Title.Equals(title))
+                .ProjectTo<ReadingListDto>(_mapper.ConfigurationProvider)
+                .SingleOrDefaultAsync();
+        }
+
+        public async Task<IEnumerable<ReadingListItem>> GetReadingListItemsByIdAsync(int readingListId)
+        {
+            return await _context.ReadingListItem
+                .Where(r => r.ReadingListId == readingListId)
+                .OrderBy(r => r.Order)
+                .ToListAsync();
+        }
+
+
+    }
+}

API/Data/Repositories/SeriesRepository.cs

@@ -0,0 +1,458 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.Comparators;
+using API.DTOs;
+using API.DTOs.Filtering;
+using API.Entities;
+using API.Extensions;
+using API.Helpers;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class SeriesRepository : ISeriesRepository
+    {
+        private readonly DataContext _context;
+        private readonly IMapper _mapper;
+        private readonly NaturalSortComparer _naturalSortComparer = new ();
+        public SeriesRepository(DataContext context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public void Add(Series series)
+        {
+            _context.Series.Add(series);
+        }
+
+        public void Update(Series series)
+        {
+            _context.Entry(series).State = EntityState.Modified;
+        }
+
+        public async Task<bool> SaveAllAsync()
+        {
+            return await _context.SaveChangesAsync() > 0;
+        }
+
+        public bool SaveAll()
+        {
+            return _context.SaveChanges() > 0;
+        }
+
+        public async Task<Series> GetSeriesByNameAsync(string name)
+        {
+            return await _context.Series.SingleOrDefaultAsync(x => x.Name == name);
+        }
+
+        public async Task<bool> DoesSeriesNameExistInLibrary(string name)
+        {
+            var libraries = _context.Series
+                .AsNoTracking()
+                .Where(x => x.Name == name)
+                .Select(s => s.LibraryId);
+
+            return await _context.Series
+                .AsNoTracking()
+                .Where(s => libraries.Contains(s.LibraryId) && s.Name == name)
+                .CountAsync() > 1;
+        }
+
+        public Series GetSeriesByName(string name)
+        {
+            return _context.Series.SingleOrDefault(x => x.Name == name);
+        }
+
+        public async Task<IEnumerable<Series>> GetSeriesForLibraryIdAsync(int libraryId)
+        {
+            return await _context.Series
+                .Where(s => s.LibraryId == libraryId)
+                .OrderBy(s => s.SortName)
+                .ToListAsync();
+        }
+
+        public async Task<PagedList<SeriesDto>> GetSeriesDtoForLibraryIdAsync(int libraryId, int userId, UserParams userParams, FilterDto filter)
+        {
+            var formats = filter.GetSqlFilter();
+            var query =  _context.Series
+                .Where(s => s.LibraryId == libraryId && formats.Contains(s.Format))
+                .OrderBy(s => s.SortName)
+                .ProjectTo<SeriesDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking();
+
+            return await PagedList<SeriesDto>.CreateAsync(query, userParams.PageNumber, userParams.PageSize);
+        }
+
+        public async Task<IEnumerable<SearchResultDto>> SearchSeries(int[] libraryIds, string searchQuery)
+        {
+            return await _context.Series
+                .Where(s => libraryIds.Contains(s.LibraryId))
+                .Where(s => EF.Functions.Like(s.Name, $"%{searchQuery}%")
+                            || EF.Functions.Like(s.OriginalName, $"%{searchQuery}%")
+                            || EF.Functions.Like(s.LocalizedName, $"%{searchQuery}%"))
+                .Include(s => s.Library)
+                .OrderBy(s => s.SortName)
+                .AsNoTracking()
+                .ProjectTo<SearchResultDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<VolumeDto>> GetVolumesDtoAsync(int seriesId, int userId)
+        {
+            var volumes =  await _context.Volume
+                .Where(vol => vol.SeriesId == seriesId)
+                .Include(vol => vol.Chapters)
+                .OrderBy(volume => volume.Number)
+                .ProjectTo<VolumeDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking()
+                .ToListAsync();
+
+            await AddVolumeModifiers(userId, volumes);
+            SortSpecialChapters(volumes);
+
+
+
+            return volumes;
+        }
+
+        private void SortSpecialChapters(IEnumerable<VolumeDto> volumes)
+        {
+            foreach (var v in volumes.Where(vDto => vDto.Number == 0))
+            {
+                v.Chapters = v.Chapters.OrderBy(x => x.Range, _naturalSortComparer).ToList();
+            }
+        }
+
+
+        public async Task<IEnumerable<Volume>> GetVolumes(int seriesId)
+        {
+            return await _context.Volume
+                .Where(vol => vol.SeriesId == seriesId)
+                .Include(vol => vol.Chapters)
+                .ThenInclude(c => c.Files)
+                .OrderBy(vol => vol.Number)
+                .ToListAsync();
+        }
+
+        public async Task<SeriesDto> GetSeriesDtoByIdAsync(int seriesId, int userId)
+        {
+            var series = await _context.Series.Where(x => x.Id == seriesId)
+                .ProjectTo<SeriesDto>(_mapper.ConfigurationProvider)
+                .SingleAsync();
+
+            var seriesList = new List<SeriesDto>() {series};
+            await AddSeriesModifiers(userId, seriesList);
+
+            return seriesList[0];
+        }
+
+        public async Task<Volume> GetVolumeAsync(int volumeId)
+        {
+            return await _context.Volume
+                .Include(vol => vol.Chapters)
+                .ThenInclude(c => c.Files)
+                .SingleOrDefaultAsync(vol => vol.Id == volumeId);
+        }
+
+        public async Task<VolumeDto> GetVolumeDtoAsync(int volumeId)
+        {
+            return await _context.Volume
+                .Where(vol => vol.Id == volumeId)
+                .AsNoTracking()
+                .ProjectTo<VolumeDto>(_mapper.ConfigurationProvider)
+                .SingleAsync();
+
+        }
+
+        public async Task<VolumeDto> GetVolumeDtoAsync(int volumeId, int userId)
+        {
+            var volume = await _context.Volume
+                .Where(vol => vol.Id == volumeId)
+                .Include(vol => vol.Chapters)
+                .ThenInclude(c => c.Files)
+                .ProjectTo<VolumeDto>(_mapper.ConfigurationProvider)
+                .SingleAsync(vol => vol.Id == volumeId);
+
+            var volumeList = new List<VolumeDto>() {volume};
+            await AddVolumeModifiers(userId, volumeList);
+
+            return volumeList[0];
+        }
+
+        /// <summary>
+        /// Returns all volumes that contain a seriesId in passed array.
+        /// </summary>
+        /// <param name="seriesIds"></param>
+        /// <returns></returns>
+        public async Task<IEnumerable<Volume>> GetVolumesForSeriesAsync(int[] seriesIds)
+        {
+            return await _context.Volume
+                .Where(v => seriesIds.Contains(v.SeriesId))
+                .ToListAsync();
+        }
+
+        public async Task<bool> DeleteSeriesAsync(int seriesId)
+        {
+            var series = await _context.Series.Where(s => s.Id == seriesId).SingleOrDefaultAsync();
+            _context.Series.Remove(series);
+
+            return await _context.SaveChangesAsync() > 0;
+        }
+
+        public async Task<Volume> GetVolumeByIdAsync(int volumeId)
+        {
+            return await _context.Volume.SingleOrDefaultAsync(x => x.Id == volumeId);
+        }
+
+        public async Task<Series> GetSeriesByIdAsync(int seriesId)
+        {
+            return await _context.Series
+                .Include(s => s.Volumes)
+                .Include(s => s.Metadata)
+                .ThenInclude(m => m.CollectionTags)
+                .Where(s => s.Id == seriesId)
+                .SingleOrDefaultAsync();
+        }
+
+        public async Task<int[]> GetChapterIdsForSeriesAsync(int[] seriesIds)
+        {
+            var volumes = await _context.Volume
+                .Where(v => seriesIds.Contains(v.SeriesId))
+                .Include(v => v.Chapters)
+                .ToListAsync();
+
+            IList<int> chapterIds = new List<int>();
+            foreach (var v in volumes)
+            {
+                foreach (var c in v.Chapters)
+                {
+                    chapterIds.Add(c.Id);
+                }
+            }
+
+            return chapterIds.ToArray();
+        }
+
+        public async Task AddSeriesModifiers(int userId, List<SeriesDto> series)
+        {
+            var userProgress = await _context.AppUserProgresses
+                .Where(p => p.AppUserId == userId && series.Select(s => s.Id).Contains(p.SeriesId))
+                .ToListAsync();
+
+            var userRatings = await _context.AppUserRating
+                .Where(r => r.AppUserId == userId && series.Select(s => s.Id).Contains(r.SeriesId))
+                .ToListAsync();
+
+            foreach (var s in series)
+            {
+                s.PagesRead = userProgress.Where(p => p.SeriesId == s.Id).Sum(p => p.PagesRead);
+                var rating = userRatings.SingleOrDefault(r => r.SeriesId == s.Id);
+                if (rating == null) continue;
+                s.UserRating = rating.Rating;
+                s.UserReview = rating.Review;
+            }
+        }
+
+        public async Task<byte[]> GetVolumeCoverImageAsync(int volumeId)
+        {
+            return await _context.Volume
+                .Where(v => v.Id == volumeId)
+                .Select(v => v.CoverImage)
+                .AsNoTracking()
+                .SingleOrDefaultAsync();
+        }
+
+        public async Task<byte[]> GetSeriesCoverImageAsync(int seriesId)
+        {
+            return await _context.Series
+                .Where(s => s.Id == seriesId)
+                .Select(s => s.CoverImage)
+                .AsNoTracking()
+                .SingleOrDefaultAsync();
+        }
+
+        private async Task AddVolumeModifiers(int userId, IReadOnlyCollection<VolumeDto> volumes)
+        {
+            var userProgress = await _context.AppUserProgresses
+                .Where(p => p.AppUserId == userId && volumes.Select(s => s.Id).Contains(p.VolumeId))
+                .AsNoTracking()
+                .ToListAsync();
+
+            foreach (var v in volumes)
+            {
+                foreach (var c in v.Chapters)
+                {
+                    c.PagesRead = userProgress.Where(p => p.ChapterId == c.Id).Sum(p => p.PagesRead);
+                }
+
+                v.PagesRead = userProgress.Where(p => p.VolumeId == v.Id).Sum(p => p.PagesRead);
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of Series that were added, ordered by Created desc
+        /// </summary>
+        /// <param name="userId"></param>
+        /// <param name="libraryId">Library to restrict to, if 0, will apply to all libraries</param>
+        /// <param name="userParams">Contains pagination information</param>
+        /// <param name="filter">Optional filter on query</param>
+        /// <returns></returns>
+        public async Task<PagedList<SeriesDto>> GetRecentlyAdded(int libraryId, int userId, UserParams userParams, FilterDto filter)
+        {
+            var formats = filter.GetSqlFilter();
+
+            if (libraryId == 0)
+            {
+                var userLibraries = _context.Library
+                    .Include(l => l.AppUsers)
+                    .Where(library => library.AppUsers.Any(user => user.Id == userId))
+                    .AsNoTracking()
+                    .Select(library => library.Id)
+                    .ToList();
+
+                var allQuery = _context.Series
+                    .Where(s => userLibraries.Contains(s.LibraryId) && formats.Contains(s.Format))
+                    .OrderByDescending(s => s.Created)
+                    .ProjectTo<SeriesDto>(_mapper.ConfigurationProvider)
+                    .AsNoTracking();
+
+                return await PagedList<SeriesDto>.CreateAsync(allQuery, userParams.PageNumber, userParams.PageSize);
+            }
+
+            var query = _context.Series
+                .Where(s => s.LibraryId == libraryId && formats.Contains(s.Format))
+                .OrderByDescending(s => s.Created)
+                .ProjectTo<SeriesDto>(_mapper.ConfigurationProvider)
+                .AsSplitQuery()
+                .AsNoTracking();
+
+            return await PagedList<SeriesDto>.CreateAsync(query, userParams.PageNumber, userParams.PageSize);
+        }
+
+        /// <summary>
+        /// Returns Series that the user has some partial progress on
+        /// </summary>
+        /// <param name="userId"></param>
+        /// <param name="libraryId">Library to restrict to, if 0, will apply to all libraries</param>
+        /// <param name="userParams">Pagination information</param>
+        /// <param name="filter">Optional (default null) filter on query</param>
+        /// <returns></returns>
+        public async Task<IEnumerable<SeriesDto>> GetInProgress(int userId, int libraryId, UserParams userParams, FilterDto filter)
+        {
+            var formats = filter.GetSqlFilter();
+            IList<int> userLibraries;
+            if (libraryId == 0)
+            {
+                userLibraries = _context.Library
+                    .Include(l => l.AppUsers)
+                    .Where(library => library.AppUsers.Any(user => user.Id == userId))
+                    .AsNoTracking()
+                    .Select(library => library.Id)
+                    .ToList();
+            }
+            else
+            {
+                userLibraries = new List<int>() {libraryId};
+            }
+
+            var series = _context.Series
+                .Where(s => formats.Contains(s.Format) && userLibraries.Contains(s.LibraryId))
+                .Join(_context.AppUserProgresses, s => s.Id, progress => progress.SeriesId, (s, progress) => new
+                {
+                    Series = s,
+                    PagesRead = _context.AppUserProgresses.Where(s1 => s1.SeriesId == s.Id && s1.AppUserId == userId).Sum(s1 => s1.PagesRead),
+                    progress.AppUserId,
+                    LastModified = _context.AppUserProgresses.Where(p => p.Id == progress.Id && p.AppUserId == userId).Max(p => p.LastModified)
+                })
+                .AsNoTracking();
+
+            var retSeries = series.Where(s => s.AppUserId == userId
+                                              && s.PagesRead > 0
+                                              && s.PagesRead < s.Series.Pages)
+                            .OrderByDescending(s => s.LastModified)
+                            .Select(s => s.Series)
+                            .ProjectTo<SeriesDto>(_mapper.ConfigurationProvider)
+                            .AsSplitQuery()
+                            .AsNoTracking();
+
+            // Pagination does not work for this query as when we pull the data back, we get multiple rows of the same series. See controller for pagination code
+            return await retSeries.ToListAsync();
+        }
+
+        public async Task<SeriesMetadataDto> GetSeriesMetadata(int seriesId)
+        {
+            var metadataDto = await _context.SeriesMetadata
+                .Where(metadata => metadata.SeriesId == seriesId)
+                .AsNoTracking()
+                .ProjectTo<SeriesMetadataDto>(_mapper.ConfigurationProvider)
+                .SingleOrDefaultAsync();
+
+            if (metadataDto != null)
+            {
+                metadataDto.Tags = await _context.CollectionTag
+                    .Include(t => t.SeriesMetadatas)
+                    .Where(t => t.SeriesMetadatas.Select(s => s.SeriesId).Contains(seriesId))
+                    .ProjectTo<CollectionTagDto>(_mapper.ConfigurationProvider)
+                    .AsNoTracking()
+                    .ToListAsync();
+            }
+
+            return metadataDto;
+        }
+
+        public async Task<PagedList<SeriesDto>> GetSeriesDtoForCollectionAsync(int collectionId, int userId, UserParams userParams)
+        {
+            var userLibraries = _context.Library
+                .Include(l => l.AppUsers)
+                .Where(library => library.AppUsers.Any(user => user.Id == userId))
+                .AsNoTracking()
+                .Select(library => library.Id)
+                .ToList();
+
+            var query =  _context.CollectionTag
+                .Where(s => s.Id == collectionId)
+                .Include(c => c.SeriesMetadatas)
+                .ThenInclude(m => m.Series)
+                .SelectMany(c => c.SeriesMetadatas.Select(sm => sm.Series).Where(s => userLibraries.Contains(s.LibraryId)))
+                .OrderBy(s => s.LibraryId)
+                .ThenBy(s => s.SortName)
+                .ProjectTo<SeriesDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking();
+
+            return await PagedList<SeriesDto>.CreateAsync(query, userParams.PageNumber, userParams.PageSize);
+        }
+
+        public async Task<IList<MangaFile>> GetFilesForSeries(int seriesId)
+        {
+            return await _context.Volume
+                .Where(v => v.SeriesId == seriesId)
+                .Include(v => v.Chapters)
+                .ThenInclude(c => c.Files)
+                .SelectMany(v => v.Chapters.SelectMany(c => c.Files))
+                .AsNoTracking()
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<SeriesDto>> GetSeriesDtoForIdsAsync(IEnumerable<int> seriesIds, int userId)
+        {
+            var allowedLibraries = _context.Library
+                .Include(l => l.AppUsers)
+                .Where(library => library.AppUsers.Any(x => x.Id == userId))
+                .Select(l => l.Id);
+
+            return await _context.Series
+                .Where(s => seriesIds.Contains(s.Id) && allowedLibraries.Contains(s.LibraryId))
+                .OrderBy(s => s.SortName)
+                .ProjectTo<SeriesDto>(_mapper.ConfigurationProvider)
+                .AsNoTracking()
+                .AsSplitQuery()
+                .ToListAsync();
+        }
+    }
+}

API/Data/Repositories/SettingsRepository.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.DTOs;
+using API.Entities;
+using API.Entities.Enums;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class SettingsRepository : ISettingsRepository
+    {
+        private readonly DataContext _context;
+        private readonly IMapper _mapper;
+
+        public SettingsRepository(DataContext context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public void Update(ServerSetting settings)
+        {
+            _context.Entry(settings).State = EntityState.Modified;
+        }
+
+        public async Task<ServerSettingDto> GetSettingsDtoAsync()
+        {
+            var settings = await _context.ServerSetting
+                .Select(x => x)
+                .AsNoTracking()
+                .ToListAsync();
+            return _mapper.Map<ServerSettingDto>(settings);
+        }
+
+        public Task<ServerSetting> GetSettingAsync(ServerSettingKey key)
+        {
+            return _context.ServerSetting.SingleOrDefaultAsync(x => x.Key == key);
+        }
+
+        public async Task<IEnumerable<ServerSetting>> GetSettingsAsync()
+        {
+            return await _context.ServerSetting.ToListAsync();
+        }
+    }
+}

API/Data/Repositories/UserRepository.cs

@@ -0,0 +1,192 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.Constants;
+using API.DTOs;
+using API.Entities;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class UserRepository : IUserRepository
+    {
+        private readonly DataContext _context;
+        private readonly UserManager<AppUser> _userManager;
+        private readonly IMapper _mapper;
+
+        public UserRepository(DataContext context, UserManager<AppUser> userManager, IMapper mapper)
+        {
+            _context = context;
+            _userManager = userManager;
+            _mapper = mapper;
+        }
+
+        public void Update(AppUser user)
+        {
+            _context.Entry(user).State = EntityState.Modified;
+        }
+
+        public void Update(AppUserPreferences preferences)
+        {
+            _context.Entry(preferences).State = EntityState.Modified;
+        }
+
+        public void Delete(AppUser user)
+        {
+            _context.AppUser.Remove(user);
+        }
+
+        /// <summary>
+        /// Gets an AppUser by username. Returns back Progress information.
+        /// </summary>
+        /// <param name="username"></param>
+        /// <returns></returns>
+        public async Task<AppUser> GetUserByUsernameAsync(string username)
+        {
+            return await _context.Users
+                .Include(u => u.Progresses)
+                .Include(u => u.Bookmarks)
+                .SingleOrDefaultAsync(x => x.UserName == username);
+        }
+
+        /// <summary>
+        /// This fetches the Id for a user. Use whenever you just need an ID.
+        /// </summary>
+        /// <param name="username"></param>
+        /// <returns></returns>
+        public async Task<int> GetUserIdByUsernameAsync(string username)
+        {
+            return await _context.Users
+                .Where(x => x.UserName == username)
+                .Select(u => u.Id)
+                .SingleOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets an AppUser by username. Returns back Reading List and their Items.
+        /// </summary>
+        /// <param name="username"></param>
+        /// <returns></returns>
+        public async Task<AppUser> GetUserWithReadingListsByUsernameAsync(string username)
+        {
+            return await _context.Users
+                .Include(u => u.ReadingLists)
+                .ThenInclude(l => l.Items)
+                .SingleOrDefaultAsync(x => x.UserName == username);
+        }
+
+        /// <summary>
+        /// Gets an AppUser by id. Returns back Progress information.
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public async Task<AppUser> GetUserByIdAsync(int id)
+        {
+            return await _context.Users
+                .Include(u => u.Progresses)
+                .Include(u => u.Bookmarks)
+                .SingleOrDefaultAsync(x => x.Id == id);
+        }
+
+        public async Task<IEnumerable<AppUser>> GetAdminUsersAsync()
+        {
+            return await _userManager.GetUsersInRoleAsync(PolicyConstants.AdminRole);
+        }
+
+        public async Task<AppUserRating> GetUserRating(int seriesId, int userId)
+        {
+            return await _context.AppUserRating.Where(r => r.SeriesId == seriesId && r.AppUserId == userId)
+                .SingleOrDefaultAsync();
+        }
+
+        public void AddRatingTracking(AppUserRating userRating)
+        {
+            _context.AppUserRating.Add(userRating);
+        }
+
+        public async Task<AppUserPreferences> GetPreferencesAsync(string username)
+        {
+            return await _context.AppUserPreferences
+                .Include(p => p.AppUser)
+                .SingleOrDefaultAsync(p => p.AppUser.UserName == username);
+        }
+
+        public async Task<IEnumerable<BookmarkDto>> GetBookmarkDtosForSeries(int userId, int seriesId)
+        {
+            return await _context.AppUserBookmark
+                .Where(x => x.AppUserId == userId && x.SeriesId == seriesId)
+                .OrderBy(x => x.Page)
+                .AsNoTracking()
+                .ProjectTo<BookmarkDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<BookmarkDto>> GetBookmarkDtosForVolume(int userId, int volumeId)
+        {
+            return await _context.AppUserBookmark
+                .Where(x => x.AppUserId == userId && x.VolumeId == volumeId)
+                .OrderBy(x => x.Page)
+                .AsNoTracking()
+                .ProjectTo<BookmarkDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<BookmarkDto>> GetBookmarkDtosForChapter(int userId, int chapterId)
+        {
+            return await _context.AppUserBookmark
+                .Where(x => x.AppUserId == userId && x.ChapterId == chapterId)
+                .OrderBy(x => x.Page)
+                .AsNoTracking()
+                .ProjectTo<BookmarkDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<BookmarkDto>> GetAllBookmarkDtos(int userId)
+        {
+            return await _context.AppUserBookmark
+                .Where(x => x.AppUserId == userId)
+                .OrderBy(x => x.Page)
+                .AsNoTracking()
+                .ProjectTo<BookmarkDto>(_mapper.ConfigurationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<AppUser> GetUserByApiKeyAsync(string apiKey)
+        {
+            return await _context.AppUser
+                .SingleOrDefaultAsync(u => u.ApiKey.Equals(apiKey));
+        }
+
+
+        public async Task<IEnumerable<MemberDto>> GetMembersAsync()
+        {
+            return await _context.Users
+                .Include(x => x.Libraries)
+                .Include(r => r.UserRoles)
+                .ThenInclude(r => r.Role)
+                .OrderBy(u => u.UserName)
+                .Select(u => new MemberDto
+                {
+                    Id = u.Id,
+                    Username = u.UserName,
+                    Created = u.Created,
+                    LastActive = u.LastActive,
+                    Roles = u.UserRoles.Select(r => r.Role.Name).ToList(),
+                    Libraries =  u.Libraries.Select(l => new LibraryDto
+                    {
+                        Name = l.Name,
+                        CoverImage = l.CoverImage,
+                        Type = l.Type,
+                        Folders = l.Folders.Select(x => x.Path).ToList()
+                    }).ToList()
+                })
+                .AsNoTracking()
+                .ToListAsync();
+        }
+    }
+}

API/Data/Repositories/VolumeRepository.cs

@@ -0,0 +1,117 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.DTOs;
+using API.Entities;
+using API.Interfaces;
+using API.Interfaces.Repositories;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories
+{
+    public class VolumeRepository : IVolumeRepository
+    {
+        private readonly DataContext _context;
+        private readonly IMapper _mapper;
+
+        public VolumeRepository(DataContext context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public void Update(Volume volume)
+        {
+            _context.Entry(volume).State = EntityState.Modified;
+        }
+
+        /// <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();
+        }
+
+
+
+
+        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 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();
+        }
+
+        public async Task<IList<MangaFile>> GetFilesForVolume(int volumeId)
+        {
+            return await _context.Chapter
+                .Where(c => volumeId == c.VolumeId)
+                .Include(c => c.Files)
+                .SelectMany(c => c.Files)
+                .AsNoTracking()
+                .ToListAsync();
+        }
+    }
+}