New PDF Reader (#1324)

* Refactored all the code that opens the reader to use a unified function. Added new library and setup basic pdf reader route.

* Progress saving is implemented. Targeting ES6 now.

* Customized the toolbar to remove things we don't want, made the download button download with correct filename. Adjusted zoom setting to work well on first load regardless of device.

* Stream the pdf file to the UI rather than handling the download ourselves.

* Started implementing a custom toolbar.

* Fixed up the jump bar calculations

* Fixed filtering being broken

* Pushing up for Robbie to cleanup the toolbar layout

* Added an additional button. Working on logic while robbie takes styling

* Tried to fix the code for robbie

* Tweaks for fonts

* Added button for book mode, but doesn't seem to work after renderer is built

* Removed book mode

* Removed the old image caching code for pdfs as it's not needed with new reader

* Removed the interfaces to extract images from pdf.

* Fixed original pagination area not scaling correctly

* Integrated series remove events to library detail

* Cleaned up the getter naming convention

* Cleaned up some of the manga reader code to reduce cluter and improve re-use

* Implemented Japanese parser support for volume and chapters.

* Fixed a bug where resetting scroll in manga reader wasn't working

* Fixed a bug where word count grew on each scan.

* Removed unused variable

* Ensure we calculate word count on files with their own cache timestamp

* Adjusted size of reel headers

* Put some code in for moving on original image with keyboard, but it's not in use.

* Cleaned up the css for the pdf reader

* Cleaned up the code

* Tweaked the list item so we show scrollbar now when fully read

API/Controllers/BookController.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using API.Data;
@@ -37,11 +38,34 @@ namespace API.Controllers
         {
             var dto = await _unitOfWork.ChapterRepository.GetChapterInfoDtoAsync(chapterId);
             var bookTitle = string.Empty;
-            if (dto.SeriesFormat == MangaFormat.Epub)
+            switch (dto.SeriesFormat)
             {
-                var mangaFile = (await _unitOfWork.ChapterRepository.GetFilesForChapterAsync(chapterId)).First();
-                using var book = await EpubReader.OpenBookAsync(mangaFile.FilePath, BookService.BookReaderOptions);
-                bookTitle = book.Title;
+                case MangaFormat.Epub:
+                {
+                    var mangaFile = (await _unitOfWork.ChapterRepository.GetFilesForChapterAsync(chapterId)).First();
+                    using var book = await EpubReader.OpenBookAsync(mangaFile.FilePath, BookService.BookReaderOptions);
+                    bookTitle = book.Title;
+                    break;
+                }
+                case MangaFormat.Pdf:
+                {
+                    var mangaFile = (await _unitOfWork.ChapterRepository.GetFilesForChapterAsync(chapterId)).First();
+                    if (string.IsNullOrEmpty(bookTitle))
+                    {
+                        // Override with filename
+                        bookTitle = Path.GetFileNameWithoutExtension(mangaFile.FilePath);
+                    }
+
+                    break;
+                }
+                case MangaFormat.Image:
+                    break;
+                case MangaFormat.Archive:
+                    break;
+                case MangaFormat.Unknown:
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
             }
 
             return Ok(new BookInfoDto()
@@ -209,7 +233,7 @@ namespace API.Controllers
         public async Task<ActionResult<string>> GetBookPage(int chapterId, [FromQuery] int page)
         {
             var chapter = await _cacheService.Ensure(chapterId);
-            var path = _cacheService.GetCachedEpubFile(chapter.Id, chapter);
+            var path = _cacheService.GetCachedFile(chapter);
 
             using var book = await EpubReader.OpenBookAsync(path, BookService.BookReaderOptions);
             var mappings = await _bookService.CreateKeyToPageMappingAsync(book);

API/Controllers/ReaderController.cs

@@ -11,7 +11,6 @@ using API.Entities;
 using API.Entities.Enums;
 using API.Extensions;
 using API.Services;
-using API.Services.Tasks;
 using API.SignalR;
 using Hangfire;
 using Microsoft.AspNetCore.Mvc;
@@ -45,6 +44,34 @@ namespace API.Controllers
             _eventHub = eventHub;
         }
 
+        /// <summary>
+        /// Returns the PDF for the chapterId.
+        /// </summary>
+        /// <param name="apiKey">API Key for user to validate they have access</param>
+        /// <param name="chapterId"></param>
+        /// <returns></returns>
+        [HttpGet("pdf")]
+        public async Task<ActionResult> GetPdf(int chapterId)
+        {
+
+            var chapter = await _cacheService.Ensure(chapterId);
+            if (chapter == null) return BadRequest("There was an issue finding pdf file for reading");
+
+            try
+            {
+                var path = _cacheService.GetCachedFile(chapter);
+                if (string.IsNullOrEmpty(path) || !System.IO.File.Exists(path)) return BadRequest($"Pdf doesn't exist when it should.");
+
+                Response.AddCacheHeader(path, TimeSpan.FromMinutes(60).Seconds);
+                return PhysicalFile(path, "application/pdf", Path.GetFileName(path), true);
+            }
+            catch (Exception)
+            {
+                _cacheService.CleanupChapters(new []{ chapterId });
+                throw;
+            }
+        }
+
         /// <summary>
         /// Returns an image for a given chapter. Side effect: This will cache the chapter images for reading.
         /// </summary>

API/Data/Migrations/20220615190640_LastFileAnalysis.cs

@@ -0,0 +1,27 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Data.Migrations
+{
+    public partial class LastFileAnalysis : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastFileAnalysis",
+                table: "MangaFile",
+                type: "TEXT",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastFileAnalysis",
+                table: "MangaFile");
+        }
+    }
+}

API/Data/Migrations/DataContextModelSnapshot.cs

@@ -516,6 +516,9 @@ namespace API.Data.Migrations
                     b.Property<int>("Format")
                         .HasColumnType("INTEGER");
 
+                    b.Property<DateTime>("LastFileAnalysis")
+                        .HasColumnType("TEXT");
+
                     b.Property<DateTime>("LastModified")
                         .HasColumnType("TEXT");
 

API/Data/Repositories/MangaFileRepository.cs

@@ -0,0 +1,27 @@
+using API.Entities;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories;
+
+public interface IMangaFileRepository
+{
+    void Update(MangaFile file);
+}
+
+public class MangaFileRepository : IMangaFileRepository
+{
+    private readonly DataContext _context;
+    private readonly IMapper _mapper;
+
+    public MangaFileRepository(DataContext context, IMapper mapper)
+    {
+        _context = context;
+        _mapper = mapper;
+    }
+
+    public void Update(MangaFile file)
+    {
+        _context.Entry(file).State = EntityState.Modified;
+    }
+}

API/Data/UnitOfWork.cs

@@ -22,6 +22,7 @@ public interface IUnitOfWork
     IGenreRepository GenreRepository { get; }
     ITagRepository TagRepository { get; }
     ISiteThemeRepository SiteThemeRepository { get; }
+    IMangaFileRepository MangaFileRepository { get; }
     bool Commit();
     Task<bool> CommitAsync();
     bool HasChanges();
@@ -58,6 +59,7 @@ public class UnitOfWork : IUnitOfWork
     public IGenreRepository GenreRepository => new GenreRepository(_context, _mapper);
     public ITagRepository TagRepository => new TagRepository(_context, _mapper);
     public ISiteThemeRepository SiteThemeRepository => new SiteThemeRepository(_context, _mapper);
+    public IMangaFileRepository MangaFileRepository => new MangaFileRepository(_context, _mapper);
 
     /// <summary>
     /// Commits changes to the DB. Completes the open transaction.

API/Entities/MangaFile.cs

@@ -25,6 +25,10 @@ namespace API.Entities
         /// </summary>
         /// <remarks>This gets updated anytime the file is scanned</remarks>
         public DateTime LastModified { get; set; }
+        /// <summary>
+        /// Last time file analysis ran on this file
+        /// </summary>
+        public DateTime LastFileAnalysis { get; set; }
 
 
         // Relationship Mapping

API/Helpers/CacheHelper.cs

@@ -14,6 +14,7 @@ public interface ICacheHelper
     bool CoverImageExists(string path);
 
     bool HasFileNotChangedSinceCreationOrLastScan(IEntityDate chapter, bool forceUpdate, MangaFile firstFile);
+    bool HasFileChangedSinceLastScan(DateTime lastScan, bool forceUpdate, MangaFile firstFile);
 
 }
 
@@ -62,6 +63,25 @@ public class CacheHelper : ICacheHelper
                   || _fileService.HasFileBeenModifiedSince(firstFile.FilePath, firstFile.LastModified)));
     }
 
+    /// <summary>
+    /// Has the file been modified since last scan or is user forcing an update
+    /// </summary>
+    /// <param name="lastScan"></param>
+    /// <param name="forceUpdate"></param>
+    /// <param name="firstFile"></param>
+    /// <returns></returns>
+    public bool HasFileChangedSinceLastScan(DateTime lastScan, bool forceUpdate, MangaFile firstFile)
+    {
+        if (firstFile == null) return false;
+        if (forceUpdate) return true;
+        return _fileService.HasFileBeenModifiedSince(firstFile.FilePath, lastScan)
+               || _fileService.HasFileBeenModifiedSince(firstFile.FilePath, firstFile.LastModified);
+        // return firstFile != null &&
+        //        (!forceUpdate &&
+        //         !(_fileService.HasFileBeenModifiedSince(firstFile.FilePath, lastScan)
+        //           || _fileService.HasFileBeenModifiedSince(firstFile.FilePath, firstFile.LastModified)));
+    }
+
     /// <summary>
     /// Determines if a given coverImage path exists
     /// </summary>

API/Parser/Parser.cs

@@ -126,6 +126,10 @@ namespace API.Parser
             new Regex(
                 @"시즌(?<Volume>\d+(\-|~)?\d+?)",
                 MatchOptions, RegexTimeout),
+            // Japanese Volume: n巻 -> Volume n
+            new Regex(
+                @"(?<Volume>\d+(?:(\-)\d+)?)巻",
+                MatchOptions, RegexTimeout),
         };
 
         private static readonly Regex[] MangaSeriesRegex = new[]
@@ -368,6 +372,10 @@ namespace API.Parser
             new Regex(
                 @"제?(?<Volume>\d+)권",
                 MatchOptions, RegexTimeout),
+            // Japanese Volume: n巻 -> Volume n
+            new Regex(
+                @"(?<Volume>\d+(?:(\-)\d+)?)巻",
+                MatchOptions, RegexTimeout),
         };
 
         private static readonly Regex[] ComicChapterRegex = new[]
@@ -489,6 +497,10 @@ namespace API.Parser
             new Regex(
                 @"제?(?<Chapter>\d+\.?\d+)(화|장)",
                 MatchOptions, RegexTimeout),
+            // Korean Chapter: 第10話 -> Chapter n, [ハレム]ナナとカオル ～高校生のSMごっこ～　第1話
+            new Regex(
+                @"第?(?<Chapter>\d+(?:.\d+|-\d+)?)話",
+                MatchOptions, RegexTimeout),
         };
         private static readonly Regex[] MangaEditionRegex = {
             // Tenjo Tenge {Full Contact Edition} v01 (2011) (Digital) (ASTC).cbz

API/Services/BookService.cs

@@ -47,6 +47,7 @@ namespace API.Services
         /// </summary>
         /// <param name="fileFilePath"></param>
         /// <param name="targetDirectory">Where the files will be extracted to. If doesn't exist, will be created.</param>
+        [Obsolete("This method of reading is no longer supported. Please use native pdf reader")]
         void ExtractPdfImages(string fileFilePath, string targetDirectory);
 
         Task<string> ScopePage(HtmlDocument doc, EpubBookRef book, string apiBase, HtmlNode body, Dictionary<string, int> mappings, int page);

API/Services/CacheService.cs

@@ -29,7 +29,7 @@ namespace API.Services
         void CleanupBookmarks(IEnumerable<int> seriesIds);
         string GetCachedPagePath(Chapter chapter, int page);
         string GetCachedBookmarkPagePath(int seriesId, int page);
-        string GetCachedEpubFile(int chapterId, Chapter chapter);
+        string GetCachedFile(Chapter chapter);
         public void ExtractChapterFiles(string extractPath, IReadOnlyList<MangaFile> files);
         Task<int> CacheBookmarkForSeries(int userId, int seriesId);
         void CleanupBookmarkCache(int seriesId);
@@ -73,14 +73,13 @@ namespace API.Services
         }
 
         /// <summary>
-        /// Returns the full path to the cached epub file. If the file does not exist, will fallback to the original.
+        /// Returns the full path to the cached file. If the file does not exist, will fallback to the original.
         /// </summary>
-        /// <param name="chapterId"></param>
         /// <param name="chapter"></param>
         /// <returns></returns>
-        public string GetCachedEpubFile(int chapterId, Chapter chapter)
+        public string GetCachedFile(Chapter chapter)
         {
-            var extractPath = GetCachePath(chapterId);
+            var extractPath = GetCachePath(chapter.Id);
             var path = Path.Join(extractPath, _directoryService.FileSystem.Path.GetFileName(chapter.Files.First().FilePath));
             if (!(_directoryService.FileSystem.FileInfo.FromFileName(path).Exists))
             {
@@ -89,6 +88,7 @@ namespace API.Services
             return path;
         }
 
+
         /// <summary>
         /// Caches the files for the given chapter to CacheDirectory
         /// </summary>
@@ -136,25 +136,25 @@ namespace API.Services
                     extraPath = file.Id + string.Empty;
                 }
 
-                if (file.Format == MangaFormat.Archive)
+                switch (file.Format)
                 {
-                    _readingItemService.Extract(file.FilePath, Path.Join(extractPath, extraPath), file.Format);
-                }
-                else if (file.Format == MangaFormat.Pdf)
-                {
-                    _readingItemService.Extract(file.FilePath, Path.Join(extractPath, extraPath), file.Format);
-                }
-                else if (file.Format == MangaFormat.Epub)
-                {
-                    removeNonImages = false;
-                    if (!_directoryService.FileSystem.File.Exists(files[0].FilePath))
+                    case MangaFormat.Archive:
+                        _readingItemService.Extract(file.FilePath, Path.Join(extractPath, extraPath), file.Format);
+                        break;
+                    case MangaFormat.Epub:
+                    case MangaFormat.Pdf:
                     {
-                        _logger.LogError("{Archive} does not exist on disk", files[0].FilePath);
-                        throw new KavitaException($"{files[0].FilePath} does not exist on disk");
-                    }
+                        removeNonImages = false;
+                        if (!_directoryService.FileSystem.File.Exists(files[0].FilePath))
+                        {
+                            _logger.LogError("{File} does not exist on disk", files[0].FilePath);
+                            throw new KavitaException($"{files[0].FilePath} does not exist on disk");
+                        }
 
-                    _directoryService.ExistOrCreate(extractPath);
-                    _directoryService.CopyFileToDirectory(files[0].FilePath, extractPath);
+                        _directoryService.ExistOrCreate(extractPath);
+                        _directoryService.CopyFileToDirectory(files[0].FilePath, extractPath);
+                        break;
+                    }
                 }
             }
 

API/Services/ReadingItemService.cs

@@ -110,15 +110,13 @@ public class ReadingItemService : IReadingItemService
     {
         switch (format)
         {
-            case MangaFormat.Pdf:
-                _bookService.ExtractPdfImages(fileFilePath, targetDirectory);
-                break;
             case MangaFormat.Archive:
                 _archiveService.ExtractArchive(fileFilePath, targetDirectory);
                 break;
             case MangaFormat.Image:
                 _imageService.ExtractImages(fileFilePath, targetDirectory, imageCount);
                 break;
+            case MangaFormat.Pdf:
             case MangaFormat.Unknown:
             case MangaFormat.Epub:
                 break;

API/Services/Tasks/Metadata/WordCountAnalyzerService.cs

@@ -55,7 +55,6 @@ public class WordCountAnalyzerService : IWordCountAnalyzerService
 
         var chunkInfo = await _unitOfWork.SeriesRepository.GetChunkInfo(library.Id);
         var stopwatch = Stopwatch.StartNew();
-        var totalTime = 0L;
         _logger.LogInformation("[MetadataService] Refreshing Library {LibraryName}. Total Items: {TotalSize}. Total Chunks: {TotalChunks} with {ChunkSize} size", library.Name, chunkInfo.TotalSize, chunkInfo.TotalChunks, chunkInfo.ChunkSize);
 
         await _eventHub.SendMessageAsync(MessageFactory.NotificationProgress,
@@ -64,7 +63,6 @@ public class WordCountAnalyzerService : IWordCountAnalyzerService
         for (var chunk = 1; chunk <= chunkInfo.TotalChunks; chunk++)
         {
             if (chunkInfo.TotalChunks == 0) continue;
-            totalTime += stopwatch.ElapsedMilliseconds;
             stopwatch.Restart();
 
             _logger.LogInformation("[MetadataService] Processing chunk {ChunkNumber} / {TotalChunks} with size {ChunkSize}. Series ({SeriesStart} - {SeriesEnd}",
@@ -145,26 +143,30 @@ public class WordCountAnalyzerService : IWordCountAnalyzerService
     private async Task ProcessSeries(Series series, bool forceUpdate = false, bool useFileName = true)
     {
         var isEpub = series.Format == MangaFormat.Epub;
-
+        series.WordCount = 0;
         foreach (var volume in series.Volumes)
         {
+            volume.WordCount = 0;
             foreach (var chapter in volume.Chapters)
             {
                 // This compares if it's changed since a file scan only
-                if (!_cacheHelper.HasFileNotChangedSinceCreationOrLastScan(chapter, forceUpdate,
-                        chapter.Files.FirstOrDefault()) && chapter.WordCount != 0)
+                var firstFile = chapter.Files.FirstOrDefault();
+                if (firstFile == null) return;
+                if (!_cacheHelper.HasFileChangedSinceLastScan(firstFile.LastFileAnalysis, forceUpdate,
+                        firstFile))
                     continue;
 
                 if (series.Format == MangaFormat.Epub)
                 {
                     long sum = 0;
                     var fileCounter = 1;
-                    foreach (var file in chapter.Files.Select(file => file.FilePath))
+                    foreach (var file in chapter.Files)
                     {
+                        var filePath = file.FilePath;
                         var pageCounter = 1;
                         try
                         {
-                            using var book = await EpubReader.OpenBookAsync(file, BookService.BookReaderOptions);
+                            using var book = await EpubReader.OpenBookAsync(filePath, BookService.BookReaderOptions);
 
                             var totalPages = book.Content.Html.Values;
                             foreach (var bookPage in totalPages)
@@ -174,7 +176,7 @@ public class WordCountAnalyzerService : IWordCountAnalyzerService
 
                                 await _eventHub.SendMessageAsync(MessageFactory.NotificationProgress,
                                     MessageFactory.WordCountAnalyzerProgressEvent(series.LibraryId, progress,
-                                        ProgressEventType.Updated, useFileName ? file : series.Name));
+                                        ProgressEventType.Updated, useFileName ? filePath : series.Name));
                                 sum += await GetWordCountFromHtml(bookPage);
                                 pageCounter++;
                             }
@@ -190,6 +192,8 @@ public class WordCountAnalyzerService : IWordCountAnalyzerService
                             return;
                         }
 
+                        file.LastFileAnalysis = DateTime.Now;
+                        _unitOfWork.MangaFileRepository.Update(file);
                     }
 
                     chapter.WordCount = sum;