Report Media Issues (#1964)

* Started working on a report problems implementation.

* Started code

* Added logging to book and archive service.

* Removed an additional ComicInfo read when comicinfo is null when trying to load. But we've already done it once earlier, so there really isn't any point.

* Added basic implementation for media errors.

* MediaErrors will ignore duplicate errors when there are multiple issues on same file in a scan.

* Fixed unit tests

* Basic code in place to view and clear. Just UI Cleanup needed.

* Slight css upgrade

* Fixed up centering and simplified the code to use regular array instead of observables as it wasn't working.

* Fixed unit tests

* Fixed unit tests for real

API/Constants/ControllerConstants.cs

@@ -0,0 +1,6 @@
+namespace API.Constants;
+
+public abstract class ControllerConstants
+{
+    public const int MaxUploadSizeBytes = 8_000_000;
+}

API/Controllers/ServerController.cs

@@ -3,10 +3,13 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using API.Data;
 using API.DTOs.Jobs;
+using API.DTOs.MediaErrors;
 using API.DTOs.Stats;
 using API.DTOs.Update;
 using API.Extensions;
+using API.Helpers;
 using API.Services;
 using API.Services.Tasks;
 using Hangfire;
@@ -14,7 +17,6 @@ using Hangfire.Storage;
 using Kavita.Common;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using TaskScheduler = API.Services.TaskScheduler;
 
@@ -23,7 +25,6 @@ namespace API.Controllers;
 [Authorize(Policy = "RequireAdminRole")]
 public class ServerController : BaseApiController
 {
-    private readonly IHostApplicationLifetime _applicationLifetime;
     private readonly ILogger<ServerController> _logger;
     private readonly IBackupService _backupService;
     private readonly IArchiveService _archiveService;
@@ -34,13 +35,13 @@ public class ServerController : BaseApiController
     private readonly IScannerService _scannerService;
     private readonly IAccountService _accountService;
     private readonly ITaskScheduler _taskScheduler;
+    private readonly IUnitOfWork _unitOfWork;
 
-    public ServerController(IHostApplicationLifetime applicationLifetime, ILogger<ServerController> logger,
+    public ServerController(ILogger<ServerController> logger,
         IBackupService backupService, IArchiveService archiveService, IVersionUpdaterService versionUpdaterService, IStatsService statsService,
         ICleanupService cleanupService, IBookmarkService bookmarkService, IScannerService scannerService, IAccountService accountService,
-        ITaskScheduler taskScheduler)
+        ITaskScheduler taskScheduler, IUnitOfWork unitOfWork)
     {
-        _applicationLifetime = applicationLifetime;
         _logger = logger;
         _backupService = backupService;
         _archiveService = archiveService;
@@ -51,6 +52,7 @@ public class ServerController : BaseApiController
         _scannerService = scannerService;
         _accountService = accountService;
         _taskScheduler = taskScheduler;
+        _unitOfWork = unitOfWork;
     }
 
     /// <summary>
@@ -213,5 +215,28 @@ public class ServerController : BaseApiController
         return Ok(recurringJobs);
     }
 
+    /// <summary>
+    /// Returns a list of issues found during scanning or reading in which files may have corruption or bad metadata (structural metadata)
+    /// </summary>
+    /// <returns></returns>
+    [Authorize("RequireAdminRole")]
+    [HttpGet("media-errors")]
+    public ActionResult<PagedList<MediaErrorDto>> GetMediaErrors()
+    {
+        return Ok(_unitOfWork.MediaErrorRepository.GetAllErrorDtosAsync());
+    }
+
+    /// <summary>
+    /// Deletes all media errors
+    /// </summary>
+    /// <returns></returns>
+    [Authorize("RequireAdminRole")]
+    [HttpPost("clear-media-alerts")]
+    public async Task<ActionResult> ClearMediaErrors()
+    {
+        await _unitOfWork.MediaErrorRepository.DeleteAll();
+        return Ok();
+    }
+
 
 }

API/Controllers/UploadController.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using API.Constants;
 using API.Data;
 using API.DTOs.Uploads;
 using API.Extensions;
@@ -78,7 +79,7 @@ public class UploadController : BaseApiController
     /// <param name="uploadFileDto"></param>
     /// <returns></returns>
     [Authorize(Policy = "RequireAdminRole")]
-    [RequestSizeLimit(8_000_000)]
+    [RequestSizeLimit(ControllerConstants.MaxUploadSizeBytes)]
     [HttpPost("series")]
     public async Task<ActionResult> UploadSeriesCoverImageFromUrl(UploadFileDto uploadFileDto)
     {
@@ -126,7 +127,7 @@ public class UploadController : BaseApiController
     /// <param name="uploadFileDto"></param>
     /// <returns></returns>
     [Authorize(Policy = "RequireAdminRole")]
-    [RequestSizeLimit(8_000_000)]
+    [RequestSizeLimit(ControllerConstants.MaxUploadSizeBytes)]
     [HttpPost("collection")]
     public async Task<ActionResult> UploadCollectionCoverImageFromUrl(UploadFileDto uploadFileDto)
     {
@@ -174,7 +175,7 @@ public class UploadController : BaseApiController
     /// <remarks>This is the only API that can be called by non-admins, but the authenticated user must have a readinglist permission</remarks>
     /// <param name="uploadFileDto"></param>
     /// <returns></returns>
-    [RequestSizeLimit(8_000_000)]
+    [RequestSizeLimit(ControllerConstants.MaxUploadSizeBytes)]
     [HttpPost("reading-list")]
     public async Task<ActionResult> UploadReadingListCoverImageFromUrl(UploadFileDto uploadFileDto)
     {
@@ -238,7 +239,7 @@ public class UploadController : BaseApiController
     /// <param name="uploadFileDto"></param>
     /// <returns></returns>
     [Authorize(Policy = "RequireAdminRole")]
-    [RequestSizeLimit(8_000_000)]
+    [RequestSizeLimit(ControllerConstants.MaxUploadSizeBytes)]
     [HttpPost("chapter")]
     public async Task<ActionResult> UploadChapterCoverImageFromUrl(UploadFileDto uploadFileDto)
     {
@@ -294,7 +295,7 @@ public class UploadController : BaseApiController
     /// <param name="uploadFileDto"></param>
     /// <returns></returns>
     [Authorize(Policy = "RequireAdminRole")]
-    [RequestSizeLimit(8_000_000)]
+    [RequestSizeLimit(ControllerConstants.MaxUploadSizeBytes)]
     [HttpPost("library")]
     public async Task<ActionResult> UploadLibraryCoverImageFromUrl(UploadFileDto uploadFileDto)
     {

API/DTOs/MediaErrors/MediaErrorDto.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace API.DTOs.MediaErrors;
+
+public class MediaErrorDto
+{
+    /// <summary>
+    /// Format Type (RAR, ZIP, 7Zip, Epub, PDF)
+    /// </summary>
+    public required string Extension { get; set; }
+    /// <summary>
+    /// Full Filepath to the file that has some issue
+    /// </summary>
+    public required string FilePath { get; set; }
+    /// <summary>
+    /// Developer defined string
+    /// </summary>
+    public string Comment { get; set; }
+    /// <summary>
+    /// Exception message
+    /// </summary>
+    public string Details { get; set; }
+    public DateTime Created { get; set; }
+    public DateTime CreatedUtc { get; set; }
+}

API/Data/DataContext.cs

@@ -47,6 +47,7 @@ public sealed class DataContext : IdentityDbContext<AppUser, AppRole, int,
     public DbSet<FolderPath> FolderPath { get; set; } = null!;
     public DbSet<Device> Device { get; set; } = null!;
     public DbSet<ServerStatistics> ServerStatistics { get; set; } = null!;
+    public DbSet<MediaError> MediaError { get; set; } = null!;
 
 
     protected override void OnModelCreating(ModelBuilder builder)

API/Data/Migrations/20230505124430_MediaError.cs

@@ -0,0 +1,42 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class MediaError : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "MediaError",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Extension = table.Column<string>(type: "TEXT", nullable: true),
+                    FilePath = table.Column<string>(type: "TEXT", nullable: true),
+                    Comment = table.Column<string>(type: "TEXT", nullable: true),
+                    Details = table.Column<string>(type: "TEXT", nullable: true),
+                    Created = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    LastModified = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    CreatedUtc = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    LastModifiedUtc = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MediaError", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "MediaError");
+        }
+    }
+}

API/Data/Migrations/DataContextModelSnapshot.cs

@@ -714,6 +714,41 @@ namespace API.Data.Migrations
                     b.ToTable("MangaFile");
                 });
 
+            modelBuilder.Entity("API.Entities.MediaError", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedUtc")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Extension")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FilePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModifiedUtc")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaError");
+                });
+
             modelBuilder.Entity("API.Entities.Metadata.SeriesMetadata", b =>
                 {
                     b.Property<int>("Id")

API/Data/Repositories/MediaErrorRepository.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using API.DTOs.MediaErrors;
+using API.Entities;
+using API.Helpers;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data.Repositories;
+
+public interface IMediaErrorRepository
+{
+    void Attach(MediaError error);
+    void Remove(MediaError error);
+    Task<MediaError> Find(string filename);
+    Task<PagedList<MediaErrorDto>> GetAllErrorDtosAsync(UserParams userParams);
+    IEnumerable<MediaErrorDto> GetAllErrorDtosAsync();
+    Task<bool> ExistsAsync(MediaError error);
+    Task DeleteAll();
+}
+
+public class MediaErrorRepository : IMediaErrorRepository
+{
+    private readonly DataContext _context;
+    private readonly IMapper _mapper;
+
+    public MediaErrorRepository(DataContext context, IMapper mapper)
+    {
+        _context = context;
+        _mapper = mapper;
+    }
+
+    public void Attach(MediaError? error)
+    {
+        if (error == null) return;
+        _context.MediaError.Attach(error);
+    }
+
+    public void Remove(MediaError? error)
+    {
+        if (error == null) return;
+        _context.MediaError.Remove(error);
+    }
+
+    public Task<MediaError?> Find(string filename)
+    {
+        return _context.MediaError.Where(e => e.FilePath == filename).SingleOrDefaultAsync();
+    }
+
+    public Task<PagedList<MediaErrorDto>> GetAllErrorDtosAsync(UserParams userParams)
+    {
+        var query = _context.MediaError
+            .OrderByDescending(m => m.Created)
+            .ProjectTo<MediaErrorDto>(_mapper.ConfigurationProvider)
+            .AsNoTracking();
+        return PagedList<MediaErrorDto>.CreateAsync(query, userParams.PageNumber, userParams.PageSize);
+    }
+
+    public IEnumerable<MediaErrorDto> GetAllErrorDtosAsync()
+    {
+        var query = _context.MediaError
+            .OrderByDescending(m => m.Created)
+            .ProjectTo<MediaErrorDto>(_mapper.ConfigurationProvider)
+            .AsNoTracking();
+        return query.AsEnumerable();
+    }
+
+    public Task<bool> ExistsAsync(MediaError error)
+    {
+        return _context.MediaError.AnyAsync(m => m.FilePath.Equals(error.FilePath)
+                                                 && m.Comment.Equals(error.Comment)
+                                                 && m.Details.Equals(error.Details)
+        );
+    }
+
+    public async Task DeleteAll()
+    {
+        _context.MediaError.RemoveRange(await _context.MediaError.ToListAsync());
+        await _context.SaveChangesAsync();
+    }
+}

API/Data/UnitOfWork.cs

@@ -25,6 +25,7 @@ public interface IUnitOfWork
     ISiteThemeRepository SiteThemeRepository { get; }
     IMangaFileRepository MangaFileRepository { get; }
     IDeviceRepository DeviceRepository { get; }
+    IMediaErrorRepository MediaErrorRepository { get; }
     bool Commit();
     Task<bool> CommitAsync();
     bool HasChanges();
@@ -62,6 +63,7 @@ public class UnitOfWork : IUnitOfWork
     public ISiteThemeRepository SiteThemeRepository => new SiteThemeRepository(_context, _mapper);
     public IMangaFileRepository MangaFileRepository => new MangaFileRepository(_context);
     public IDeviceRepository DeviceRepository => new DeviceRepository(_context, _mapper);
+    public IMediaErrorRepository MediaErrorRepository => new MediaErrorRepository(_context, _mapper);
 
     /// <summary>
     /// Commits changes to the DB. Completes the open transaction.

API/Entities/MediaError.cs

@@ -0,0 +1,36 @@
+using System;
+using API.Entities.Interfaces;
+
+namespace API.Entities;
+
+/// <summary>
+/// Represents issues found during scanning or interacting with media. For example) Can't open file, corrupt media, missing content in epub.
+/// </summary>
+public class MediaError : IEntityDate
+{
+    public int Id { get; set; }
+    /// <summary>
+    /// Format Type (RAR, ZIP, 7Zip, Epub, PDF)
+    /// </summary>
+    public required string Extension { get; set; }
+    /// <summary>
+    /// Full Filepath to the file that has some issue
+    /// </summary>
+    public required string FilePath { get; set; }
+    /// <summary>
+    /// Developer defined string
+    /// </summary>
+    public string Comment { get; set; }
+    /// <summary>
+    /// Exception message
+    /// </summary>
+    public string Details { get; set; }
+    /// <summary>
+    /// Was the file imported or not
+    /// </summary>
+    //public bool Imported { get; set; }
+    public DateTime Created { get; set; }
+    public DateTime LastModified { get; set; }
+    public DateTime CreatedUtc { get; set; }
+    public DateTime LastModifiedUtc { get; set; }
+}

API/Extensions/ApplicationServiceExtensions.cs

@@ -49,6 +49,7 @@ public static class ApplicationServiceExtensions
         services.AddScoped<IReadingListService, ReadingListService>();
         services.AddScoped<IDeviceService, DeviceService>();
         services.AddScoped<IStatisticService, StatisticService>();
+        services.AddScoped<IMediaErrorService, MediaErrorService>();
 
         services.AddScoped<IScannerService, ScannerService>();
         services.AddScoped<IMetadataService, MetadataService>();

API/Helpers/AutoMapperProfiles.cs

@@ -4,6 +4,7 @@ using API.DTOs;
 using API.DTOs.Account;
 using API.DTOs.CollectionTags;
 using API.DTOs.Device;
+using API.DTOs.MediaErrors;
 using API.DTOs.Metadata;
 using API.DTOs.Reader;
 using API.DTOs.ReadingLists;
@@ -33,6 +34,7 @@ public class AutoMapperProfiles : Profile
         CreateMap<Tag, TagDto>();
         CreateMap<AgeRating, AgeRatingDto>();
         CreateMap<PublicationStatus, PublicationStatusDto>();
+        CreateMap<MediaError, MediaErrorDto>();
 
         CreateMap<AppUserProgress, ProgressDto>()
             .ForMember(dest => dest.PageNum,

API/Helpers/Builders/MediaErrorBuilder.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using API.Entities;
+
+namespace API.Helpers.Builders;
+
+public class MediaErrorBuilder : IEntityBuilder<MediaError>
+{
+    private readonly MediaError _mediaError;
+    public MediaError Build() => _mediaError;
+
+    public MediaErrorBuilder(string filePath)
+    {
+        _mediaError = new MediaError()
+        {
+            FilePath = filePath,
+            Extension = Path.GetExtension(filePath).Replace(".", string.Empty).ToUpperInvariant()
+        };
+    }
+
+    public MediaErrorBuilder WithComment(string comment)
+    {
+        _mediaError.Comment = comment.Trim();
+        return this;
+    }
+
+    public MediaErrorBuilder WithDetails(string details)
+    {
+        _mediaError.Details = details.Trim();
+        return this;
+    }
+}

API/Services/ArchiveService.cs

@@ -44,13 +44,16 @@ public class ArchiveService : IArchiveService
     private readonly ILogger<ArchiveService> _logger;
     private readonly IDirectoryService _directoryService;
     private readonly IImageService _imageService;
+    private readonly IMediaErrorService _mediaErrorService;
     private const string ComicInfoFilename = "ComicInfo.xml";
 
-    public ArchiveService(ILogger<ArchiveService> logger, IDirectoryService directoryService, IImageService imageService)
+    public ArchiveService(ILogger<ArchiveService> logger, IDirectoryService directoryService,
+        IImageService imageService, IMediaErrorService mediaErrorService)
     {
         _logger = logger;
         _directoryService = directoryService;
         _imageService = imageService;
+        _mediaErrorService = mediaErrorService;
     }
 
     /// <summary>
@@ -120,6 +123,8 @@ public class ArchiveService : IArchiveService
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "[GetNumberOfPagesFromArchive] There was an exception when reading archive stream: {ArchivePath}. Defaulting to 0 pages", archivePath);
+            _mediaErrorService.ReportMediaIssue(archivePath, MediaErrorProducer.ArchiveService,
+                "This archive cannot be read or not supported", ex);
             return 0;
         }
     }
@@ -238,6 +243,8 @@ public class ArchiveService : IArchiveService
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "[GetCoverImage] There was an exception when reading archive stream: {ArchivePath}. Defaulting to no cover image", archivePath);
+            _mediaErrorService.ReportMediaIssue(archivePath, MediaErrorProducer.ArchiveService,
+                "This archive cannot be read or not supported", ex);
         }
 
         return string.Empty;
@@ -403,6 +410,8 @@ public class ArchiveService : IArchiveService
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "[GetComicInfo] There was an exception when reading archive stream: {Filepath}", archivePath);
+            _mediaErrorService.ReportMediaIssue(archivePath, MediaErrorProducer.ArchiveService,
+                "This archive cannot be read or not supported", ex);
         }
 
         return null;
@@ -485,9 +494,11 @@ public class ArchiveService : IArchiveService
             }
 
         }
-        catch (Exception e)
+        catch (Exception ex)
         {
-            _logger.LogWarning(e, "[ExtractArchive] There was a problem extracting {ArchivePath} to {ExtractPath}",archivePath, extractPath);
+            _logger.LogWarning(ex, "[ExtractArchive] There was a problem extracting {ArchivePath} to {ExtractPath}",archivePath, extractPath);
+            _mediaErrorService.ReportMediaIssue(archivePath, MediaErrorProducer.ArchiveService,
+                "This archive cannot be read or not supported", ex);
             throw new KavitaException(
                 $"There was an error when extracting {archivePath}. Check the file exists, has read permissions or the server OS can support all path characters.");
         }

API/Services/BookService.cs

@@ -60,6 +60,7 @@ public class BookService : IBookService
     private readonly ILogger<BookService> _logger;
     private readonly IDirectoryService _directoryService;
     private readonly IImageService _imageService;
+    private readonly IMediaErrorService _mediaErrorService;
     private readonly StylesheetParser _cssParser = new ();
     private static readonly RecyclableMemoryStreamManager StreamManager = new ();
     private const string CssScopeClass = ".book-content";
@@ -72,11 +73,12 @@ public class BookService : IBookService
         }
     };
 
-    public BookService(ILogger<BookService> logger, IDirectoryService directoryService, IImageService imageService)
+    public BookService(ILogger<BookService> logger, IDirectoryService directoryService, IImageService imageService, IMediaErrorService mediaErrorService)
     {
         _logger = logger;
         _directoryService = directoryService;
         _imageService = imageService;
+        _mediaErrorService = mediaErrorService;
     }
 
     private static bool HasClickableHrefPart(HtmlNode anchor)
@@ -394,6 +396,8 @@ public class BookService : IBookService
                 catch (Exception ex)
                 {
                     _logger.LogError(ex, "There was an error reading css file for inlining likely due to a key mismatch in metadata");
+                    await _mediaErrorService.ReportMediaIssueAsync(book.FilePath, MediaErrorProducer.BookService,
+                        "There was an error reading css file for inlining likely due to a key mismatch in metadata", ex);
                 }
             }
         }
@@ -480,7 +484,9 @@ public class BookService : IBookService
         }
         catch (Exception ex)
         {
-            _logger.LogWarning(ex, "[GetComicInfo] There was an exception getting metadata");
+            _logger.LogWarning(ex, "[GetComicInfo] There was an exception parsing metadata");
+            _mediaErrorService.ReportMediaIssue(filePath, MediaErrorProducer.BookService,
+                "There was an exception parsing metadata", ex);
         }
 
         return null;
@@ -553,6 +559,8 @@ public class BookService : IBookService
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "[BookService] There was an exception getting number of pages, defaulting to 0");
+            _mediaErrorService.ReportMediaIssue(filePath, MediaErrorProducer.BookService,
+                "There was an exception getting number of pages, defaulting to 0", ex);
         }
 
         return 0;
@@ -697,6 +705,8 @@ public class BookService : IBookService
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "[BookService] There was an exception when opening epub book: {FileName}", filePath);
+            _mediaErrorService.ReportMediaIssue(filePath, MediaErrorProducer.BookService,
+                "There was an exception when opening epub book", ex);
         }
 
         return null;
@@ -916,8 +926,9 @@ public class BookService : IBookService
             }
         } catch (Exception ex)
         {
-            // NOTE: We can log this to media analysis service
             _logger.LogError(ex, "There was an issue reading one of the pages for {Book}", book.FilePath);
+            await _mediaErrorService.ReportMediaIssueAsync(book.FilePath, MediaErrorProducer.BookService,
+                "There was an issue reading one of the pages for", ex);
         }
 
         throw new KavitaException("Could not find the appropriate html for that page");
@@ -990,6 +1001,8 @@ public class BookService : IBookService
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "[BookService] There was a critical error and prevented thumbnail generation on {BookFile}. Defaulting to no cover image", fileFilePath);
+            _mediaErrorService.ReportMediaIssue(fileFilePath, MediaErrorProducer.BookService,
+                "There was a critical error and prevented thumbnail generation", ex);
         }
 
         return string.Empty;
@@ -1014,6 +1027,8 @@ public class BookService : IBookService
             _logger.LogWarning(ex,
                 "[BookService] There was a critical error and prevented thumbnail generation on {BookFile}. Defaulting to no cover image",
                 fileFilePath);
+            _mediaErrorService.ReportMediaIssue(fileFilePath, MediaErrorProducer.BookService,
+                "There was a critical error and prevented thumbnail generation", ex);
         }
 
         return string.Empty;

API/Services/MediaErrorService.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Threading.Tasks;
+using API.Data;
+using API.Helpers.Builders;
+using Hangfire;
+
+namespace API.Services;
+
+public enum MediaErrorProducer
+{
+    BookService = 0,
+    ArchiveService = 1
+
+}
+
+public interface IMediaErrorService
+{
+    Task ReportMediaIssueAsync(string filename, MediaErrorProducer producer, string errorMessage, string details);
+    void ReportMediaIssue(string filename, MediaErrorProducer producer, string errorMessage, string details);
+    Task ReportMediaIssueAsync(string filename, MediaErrorProducer producer, string errorMessage, Exception ex);
+    void ReportMediaIssue(string filename, MediaErrorProducer producer, string errorMessage, Exception ex);
+}
+
+public class MediaErrorService : IMediaErrorService
+{
+    private readonly IUnitOfWork _unitOfWork;
+
+    public MediaErrorService(IUnitOfWork unitOfWork)
+    {
+        _unitOfWork = unitOfWork;
+    }
+
+    public async Task ReportMediaIssueAsync(string filename, MediaErrorProducer producer, string errorMessage, Exception ex)
+    {
+        await ReportMediaIssueAsync(filename, producer, errorMessage, ex.Message);
+    }
+
+    public void ReportMediaIssue(string filename, MediaErrorProducer producer, string errorMessage, Exception ex)
+    {
+        // To avoid overhead on commits, do async. We don't need to wait.
+        BackgroundJob.Enqueue(() => ReportMediaIssueAsync(filename, producer, errorMessage, ex.Message));
+    }
+
+    public void ReportMediaIssue(string filename, MediaErrorProducer producer, string errorMessage, string details)
+    {
+        // To avoid overhead on commits, do async. We don't need to wait.
+        BackgroundJob.Enqueue(() => ReportMediaIssueAsync(filename, producer, errorMessage, details));
+    }
+
+    public async Task ReportMediaIssueAsync(string filename, MediaErrorProducer producer, string errorMessage, string details)
+    {
+        var error = new MediaErrorBuilder(filename)
+            .WithComment(errorMessage)
+            .WithDetails(details)
+            .Build();
+
+        if (await _unitOfWork.MediaErrorRepository.ExistsAsync(error))
+        {
+            return;
+        }
+
+
+        _unitOfWork.MediaErrorRepository.Attach(error);
+        await _unitOfWork.CommitAsync();
+    }
+
+}

API/Services/TaskScheduler.cs

@@ -399,6 +399,7 @@ public class TaskScheduler : ITaskScheduler
 
         var scheduledJobs = JobStorage.Current.GetMonitoringApi().ScheduledJobs(0, int.MaxValue);
         ret = scheduledJobs.Any(j =>
+            j.Value.Job != null &&
             j.Value.Job.Method.DeclaringType != null && j.Value.Job.Args.SequenceEqual(args) &&
             j.Value.Job.Method.Name.Equals(methodName) &&
             j.Value.Job.Method.DeclaringType.Name.Equals(className));

API/Services/Tasks/Scanner/ProcessSeries.cs

@@ -657,19 +657,13 @@ public class ProcessSeries : IProcessSeries
         }
     }
 
-    public void UpdateChapterFromComicInfo(Chapter chapter, ComicInfo? info)
+    public void UpdateChapterFromComicInfo(Chapter chapter, ComicInfo? comicInfo)
     {
+        if (comicInfo == null) return;
         var firstFile = chapter.Files.MinBy(x => x.Chapter);
         if (firstFile == null ||
             _cacheHelper.IsFileUnmodifiedSinceCreationOrLastScan(chapter, false, firstFile)) return;
 
-        var comicInfo = info;
-        if (info == null)
-        {
-            comicInfo = _readingItemService.GetComicInfo(firstFile.FilePath);
-        }
-
-        if (comicInfo == null) return;
         _logger.LogTrace("[ScannerService] Read ComicInfo for {File}", firstFile.FilePath);
 
         chapter.AgeRating = ComicInfo.ConvertAgeRatingToEnum(comicInfo.AgeRating);
@@ -807,11 +801,15 @@ public class ProcessSeries : IProcessSeries
     private static IList<string> GetTagValues(string comicInfoTagSeparatedByComma)
     {
         // TODO: Move this to an extension and test it
-        if (!string.IsNullOrEmpty(comicInfoTagSeparatedByComma))
+        if (string.IsNullOrEmpty(comicInfoTagSeparatedByComma))
         {
-            return comicInfoTagSeparatedByComma.Split(",").Select(s => s.Trim()).DistinctBy(Parser.Parser.Normalize).ToList();
+            return ImmutableList<string>.Empty;
         }
-        return ImmutableList<string>.Empty;
+
+        return comicInfoTagSeparatedByComma.Split(",")
+            .Select(s => s.Trim())
+            .DistinctBy(Parser.Parser.Normalize)
+            .ToList();
     }
 
     /// <summary>