Release Polish (#1586)

* Fixed a scaling issue in the epub reader, where images could scale when they shouldn't.

* Removed some caching on library/ api and added more output for a foreign key constraint

* Hooked in Restricted Profile stat collection

* Added a new boolean on age restrictions to explicitly allow unknowns or not. Since unknown is the default state of metadata, if users are allowed access to Unknown, age restricted content could leak.

* Fixed a bug where sometimes series cover generation could fail under conditions where only specials existed.

* Fixed foreign constraint issue when cleaning up series not seen at end of scan loop

* Removed an additional epub parse when scanning and handled merging differently

* Code smell

API/Controllers/AccountController.cs

@@ -366,7 +366,9 @@ public class AccountController : BaseApiController
 
         var isAdmin = await _unitOfWork.UserRepository.IsUserAdminAsync(user);
 
-        user.AgeRestriction = isAdmin ? AgeRating.NotApplicable : dto.AgeRestriction;
+        user.AgeRestriction = isAdmin ? AgeRating.NotApplicable : dto.AgeRating;
+        user.AgeRestrictionIncludeUnknowns = isAdmin || dto.IncludeUnknowns;
+
         _unitOfWork.UserRepository.Update(user);
 
         if (!_unitOfWork.HasChanges()) return Ok();
@@ -455,7 +457,9 @@ public class AccountController : BaseApiController
             lib.AppUsers.Add(user);
         }
 
-        user.AgeRestriction = hasAdminRole ? AgeRating.NotApplicable : dto.AgeRestriction;
+        user.AgeRestriction = hasAdminRole ? AgeRating.NotApplicable : dto.AgeRestriction.AgeRating;
+        user.AgeRestrictionIncludeUnknowns = hasAdminRole || dto.AgeRestriction.IncludeUnknowns;
+
         _unitOfWork.UserRepository.Update(user);
 
         if (!_unitOfWork.HasChanges() || await _unitOfWork.CommitAsync())
@@ -570,7 +574,8 @@ public class AccountController : BaseApiController
                 lib.AppUsers.Add(user);
             }
 
-            user.AgeRestriction = hasAdminRole ? AgeRating.NotApplicable : dto.AgeRestriction;
+            user.AgeRestriction = hasAdminRole ? AgeRating.NotApplicable : dto.AgeRestriction.AgeRating;
+            user.AgeRestrictionIncludeUnknowns = hasAdminRole || dto.AgeRestriction.IncludeUnknowns;
 
             var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
             if (string.IsNullOrEmpty(token))

API/Controllers/LibraryController.cs

@@ -113,7 +113,6 @@ public class LibraryController : BaseApiController
     }
 
 
-    [ResponseCache(CacheProfileName = "10Minute")]
     [HttpGet]
     public async Task<ActionResult<IEnumerable<LibraryDto>>> GetLibraries()
     {

API/Controllers/ServerController.cs

@@ -72,7 +72,7 @@ public class ServerController : BaseApiController
     public ActionResult ClearCache()
     {
         _logger.LogInformation("{UserName} is clearing cache of server from admin dashboard", User.GetUsername());
-        _cleanupService.CleanupCacheDirectory();
+        _cleanupService.CleanupCacheAndTempDirectories();
 
         return Ok();
     }

API/DTOs/Account/AgeRestrictionDto.cs

@@ -0,0 +1,16 @@
+using API.Entities.Enums;
+
+namespace API.DTOs.Account;
+
+public class AgeRestrictionDto
+{
+    /// <summary>
+    /// The maximum age rating a user has access to. -1 if not applicable
+    /// </summary>
+    public AgeRating AgeRating { get; set; } = AgeRating.NotApplicable;
+    /// <summary>
+    /// Are Unknowns explicitly allowed against age rating
+    /// </summary>
+    /// <remarks>Unknown is always lowest and default age rating. Setting this to false will ensure Teen age rating applies and unknowns are still filtered</remarks>
+    public bool IncludeUnknowns { get; set; } = false;
+}

API/DTOs/Account/InviteUserDto.cs

@@ -20,5 +20,5 @@ public class InviteUserDto
     /// <summary>
     /// An Age Rating which will limit the account to seeing everything equal to or below said rating.
     /// </summary>
-    public AgeRating AgeRestriction { get; set; }
+    public AgeRestrictionDto AgeRestriction { get; set; }
 }

API/DTOs/Account/UpdateAgeRestrictionDto.cs

@@ -6,5 +6,7 @@ namespace API.DTOs.Account;
 public class UpdateAgeRestrictionDto
 {
     [Required]
-    public AgeRating AgeRestriction { get; set; }
+    public AgeRating AgeRating { get; set; }
+    [Required]
+    public bool IncludeUnknowns { get; set; }
 }

API/DTOs/Account/UpdateUserDto.cs

@@ -19,6 +19,6 @@ public record UpdateUserDto
     /// <summary>
     /// An Age Rating which will limit the account to seeing everything equal to or below said rating.
     /// </summary>
-    public AgeRating AgeRestriction { get; init; }
+    public AgeRestrictionDto AgeRestriction { get; init; }
 
 }

API/DTOs/MemberDto.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using API.Data.Misc;
+using API.DTOs.Account;
 using API.Entities.Enums;
 
 namespace API.DTOs;
@@ -12,11 +14,7 @@ public class MemberDto
     public int Id { get; init; }
     public string Username { get; init; }
     public string Email { get; init; }
-
-    /// <summary>
-    /// The maximum age rating a user has access to. -1 if not applicable
-    /// </summary>
-    public AgeRating AgeRestriction { get; init; } = AgeRating.NotApplicable;
+    public AgeRestrictionDto AgeRestriction { get; init; }
     public DateTime Created { get; init; }
     public DateTime LastActive { get; init; }
     public IEnumerable<LibraryDto> Libraries { get; init; }

API/DTOs/Stats/ServerInfoDto.cs

@@ -140,4 +140,9 @@ public class ServerInfoDto
     /// </summary>
     /// <remarks>Introduced in v0.6.0</remarks>
     public IEnumerable<FileFormatDto> FileFormats { get; set; }
+    /// <summary>
+    /// If there is at least one user that is using an age restricted profile on the instance
+    /// </summary>
+    /// <remarks>Introduced in v0.6.0</remarks>
+    public bool UsingRestrictedProfiles { get; set; }
 }

API/DTOs/UserDto.cs

@@ -1,4 +1,5 @@
 
+using API.DTOs.Account;
 using API.Entities.Enums;
 
 namespace API.DTOs;
@@ -11,8 +12,5 @@ public class UserDto
     public string RefreshToken { get; set; }
     public string ApiKey { get; init; }
     public UserPreferencesDto Preferences { get; set; }
-    /// <summary>
-    /// The highest age rating the user has access to. Not applicable for admins
-    /// </summary>
-    public AgeRating AgeRestriction { get; set; } = AgeRating.NotApplicable;
+    public AgeRestrictionDto AgeRestriction { get; init; }
 }

API/Data/Migrations/20221017131711_IncludeUnknowns.cs

@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace API.Data.Migrations
+{
+    public partial class IncludeUnknowns : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "AgeRestrictionIncludeUnknowns",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "AgeRestrictionIncludeUnknowns",
+                table: "AspNetUsers");
+        }
+    }
+}

API/Data/Migrations/DataContextModelSnapshot.cs

@@ -56,6 +56,9 @@ namespace API.Data.Migrations
                     b.Property<int>("AgeRestriction")
                         .HasColumnType("INTEGER");
 
+                    b.Property<bool>("AgeRestrictionIncludeUnknowns")
+                        .HasColumnType("INTEGER");
+
                     b.Property<string>("ApiKey")
                         .HasColumnType("TEXT");
 

API/Data/Misc/AgeRestriction.cs

@@ -0,0 +1,9 @@
+using API.Entities.Enums;
+
+namespace API.Data.Misc;
+
+public class AgeRestriction
+{
+    public AgeRating AgeRating { get; set; }
+    public bool IncludeUnknowns { get; set; }
+}

API/Data/Misc/RecentlyAddedSeries.cs

@@ -0,0 +1,22 @@
+using System;
+using API.Entities.Enums;
+
+namespace API.Data.Misc;
+
+public class RecentlyAddedSeries
+{
+    public int LibraryId { get; init; }
+    public LibraryType LibraryType { get; init; }
+    public DateTime Created { get; init; }
+    public int SeriesId { get; init; }
+    public string SeriesName { get; init; }
+    public MangaFormat Format { get; init; }
+    public int ChapterId { get; init; }
+    public int VolumeId { get; init; }
+    public string ChapterNumber { get; init; }
+    public string ChapterRange { get; init; }
+    public string ChapterTitle { get; init; }
+    public bool IsSpecial { get; init; }
+    public int VolumeNumber { get; init; }
+    public AgeRating AgeRating { get; init; }
+}

API/Data/Repositories/CollectionTagRepository.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using API.Data.Misc;
 using API.DTOs.CollectionTags;
 using API.Entities;
 using API.Extensions;
@@ -96,7 +97,7 @@ public class CollectionTagRepository : ICollectionTagRepository
 
     public async Task<IEnumerable<CollectionTagDto>> GetAllPromotedTagDtosAsync(int userId)
     {
-        var userRating = (await _context.AppUser.SingleAsync(u => u.Id == userId)).AgeRestriction;
+        var userRating = await GetUserAgeRestriction(userId);
         return await _context.CollectionTag
             .Where(c => c.Promoted)
             .RestrictAgainstAgeRestriction(userRating)
@@ -122,9 +123,22 @@ public class CollectionTagRepository : ICollectionTagRepository
             .SingleOrDefaultAsync();
     }
 
+    private async Task<AgeRestriction> GetUserAgeRestriction(int userId)
+    {
+        return await _context.AppUser
+            .AsNoTracking()
+            .Where(u => u.Id == userId)
+            .Select(u =>
+                new AgeRestriction(){
+                    AgeRating = u.AgeRestriction,
+                    IncludeUnknowns = u.AgeRestrictionIncludeUnknowns
+                })
+            .SingleAsync();
+    }
+
     public async Task<IEnumerable<CollectionTagDto>> SearchTagDtosAsync(string searchQuery, int userId)
     {
-        var userRating = (await _context.AppUser.SingleAsync(u => u.Id == userId)).AgeRestriction;
+        var userRating = await GetUserAgeRestriction(userId);
         return await _context.CollectionTag
             .Where(s => EF.Functions.Like(s.Title, $"%{searchQuery}%")
                         || EF.Functions.Like(s.NormalizedTitle, $"%{searchQuery}%"))

API/Data/Repositories/SeriesRepository.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using API.Data.Misc;
 using API.Data.Scanner;
 using API.DTOs;
 using API.DTOs.CollectionTags;
@@ -36,24 +37,6 @@ public enum SeriesIncludes
     Library = 16,
 }
 
-internal class RecentlyAddedSeries
-{
-    public int LibraryId { get; init; }
-    public LibraryType LibraryType { get; init; }
-    public DateTime Created { get; init; }
-    public int SeriesId { get; init; }
-    public string SeriesName { get; init; }
-    public MangaFormat Format { get; init; }
-    public int ChapterId { get; init; }
-    public int VolumeId { get; init; }
-    public string ChapterNumber { get; init; }
-    public string ChapterRange { get; init; }
-    public string ChapterTitle { get; init; }
-    public bool IsSpecial { get; init; }
-    public int VolumeNumber { get; init; }
-    public AgeRating AgeRating { get; init; }
-}
-
 public interface ISeriesRepository
 {
     void Add(Series series);
@@ -121,7 +104,7 @@ public interface ISeriesRepository
     Task<PagedList<SeriesDto>> GetWantToReadForUserAsync(int userId, UserParams userParams, FilterDto filter);
     Task<Series> GetSeriesByFolderPath(string folder, SeriesIncludes includes = SeriesIncludes.None);
     Task<Series> GetFullSeriesByAnyName(string seriesName, string localizedName, int libraryId, MangaFormat format, bool withFullIncludes = true);
-    Task<List<Series>> RemoveSeriesNotInList(IList<ParsedSeries> seenSeries, int libraryId);
+    Task<IList<Series>> RemoveSeriesNotInList(IList<ParsedSeries> seenSeries, int libraryId);
     Task<IDictionary<string, IList<SeriesModified>>> GetFolderPathMap(int libraryId);
     Task<AgeRating> GetMaxAgeRatingFromSeriesAsync(IEnumerable<int> seriesIds);
 }
@@ -767,7 +750,7 @@ public class SeriesRepository : ISeriesRepository
                         EF.Functions.Like(s.Name, $"%{filter.SeriesNameQuery}%")
                                              || EF.Functions.Like(s.OriginalName, $"%{filter.SeriesNameQuery}%")
                                              || EF.Functions.Like(s.LocalizedName, $"%{filter.SeriesNameQuery}%"));
-        if (userRating != AgeRating.NotApplicable)
+        if (userRating.AgeRating != AgeRating.NotApplicable)
         {
             query = query.RestrictAgainstAgeRestriction(userRating);
         }
@@ -1048,9 +1031,9 @@ public class SeriesRepository : ISeriesRepository
          var userRating = await GetUserAgeRestriction(userId);
 
          var items = (await GetRecentlyAddedChaptersQuery(userId));
-         if (userRating != AgeRating.NotApplicable)
+         if (userRating.AgeRating != AgeRating.NotApplicable)
          {
-             items = items.Where(c => c.AgeRating <= userRating);
+             items = items.RestrictAgainstAgeRestriction(userRating);
          }
          foreach (var item in items)
          {
@@ -1080,9 +1063,17 @@ public class SeriesRepository : ISeriesRepository
          return seriesMap.Values.AsEnumerable();
     }
 
-    private async Task<AgeRating> GetUserAgeRestriction(int userId)
+    private async Task<AgeRestriction> GetUserAgeRestriction(int userId)
     {
-        return (await _context.AppUser.SingleAsync(u => u.Id == userId)).AgeRestriction;
+        return await _context.AppUser
+            .AsNoTracking()
+            .Where(u => u.Id == userId)
+            .Select(u =>
+            new AgeRestriction(){
+                AgeRating = u.AgeRestriction,
+                IncludeUnknowns = u.AgeRestrictionIncludeUnknowns
+            })
+            .SingleAsync();
     }
 
     public async Task<IEnumerable<SeriesDto>> GetSeriesForRelationKind(int userId, int seriesId, RelationKind kind)
@@ -1267,20 +1258,39 @@ public class SeriesRepository : ISeriesRepository
     /// </summary>
     /// <param name="seenSeries"></param>
     /// <param name="libraryId"></param>
-    public async Task<List<Series>> RemoveSeriesNotInList(IList<ParsedSeries> seenSeries, int libraryId)
+    public async Task<IList<Series>> RemoveSeriesNotInList(IList<ParsedSeries> seenSeries, int libraryId)
     {
-        if (seenSeries.Count == 0) return new List<Series>();
+        if (seenSeries.Count == 0) return Array.Empty<Series>();
+
         var ids = new List<int>();
         foreach (var parsedSeries in seenSeries)
         {
-            var series = await _context.Series
-                .Where(s => s.Format == parsedSeries.Format && s.NormalizedName == parsedSeries.NormalizedName &&
-                            s.LibraryId == libraryId)
-                .Select(s => s.Id)
-                .SingleOrDefaultAsync();
-            if (series > 0)
+            try
             {
-                ids.Add(series);
+                var seriesId = await _context.Series
+                    .Where(s => s.Format == parsedSeries.Format && s.NormalizedName == parsedSeries.NormalizedName &&
+                                s.LibraryId == libraryId)
+                    .Select(s => s.Id)
+                    .SingleOrDefaultAsync();
+                if (seriesId > 0)
+                {
+                    ids.Add(seriesId);
+                }
+            }
+            catch (Exception)
+            {
+                // This is due to v0.5.6 introducing bugs where we could have multiple series get duplicated and no way to delete them
+                // This here will delete the 2nd one as the first is the one to likely be used.
+                var sId = _context.Series
+                    .Where(s => s.Format == parsedSeries.Format && s.NormalizedName == parsedSeries.NormalizedName &&
+                                s.LibraryId == libraryId)
+                    .Select(s => s.Id)
+                    .OrderBy(s => s)
+                    .Last();
+                if (sId > 0)
+                {
+                    ids.Add(sId);
+                }
             }
         }
 
@@ -1289,6 +1299,15 @@ public class SeriesRepository : ISeriesRepository
             .Where(s => !ids.Contains(s.Id))
             .ToListAsync();
 
+        // If the series to remove has Relation (related series), we must manually unlink due to the DB not being
+        // setup correctly (if this is not done, a foreign key constraint will be thrown)
+
+        foreach (var sr in seriesToRemove)
+        {
+            sr.Relations = new List<SeriesRelation>();
+            Update(sr);
+        }
+
         _context.Series.RemoveRange(seriesToRemove);
 
         return seriesToRemove;
@@ -1427,7 +1446,7 @@ public class SeriesRepository : ISeriesRepository
             .Select(s => s.Id);
     }
 
-    private async Task<IEnumerable<SeriesDto>> GetRelatedSeriesQuery(int seriesId, IEnumerable<int> usersSeriesIds, RelationKind kind, AgeRating userRating)
+    private async Task<IEnumerable<SeriesDto>> GetRelatedSeriesQuery(int seriesId, IEnumerable<int> usersSeriesIds, RelationKind kind, AgeRestriction userRating)
     {
         return await _context.Series.SelectMany(s =>
             s.Relations.Where(sr => sr.RelationKind == kind && sr.SeriesId == seriesId && usersSeriesIds.Contains(sr.TargetSeriesId))

API/Data/Repositories/UserRepository.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using API.Constants;
 using API.DTOs;
+using API.DTOs.Account;
 using API.DTOs.Filtering;
 using API.DTOs.Reader;
 using API.Entities;
@@ -396,7 +397,11 @@ public class UserRepository : IUserRepository
                 Created = u.Created,
                 LastActive = u.LastActive,
                 Roles = u.UserRoles.Select(r => r.Role.Name).ToList(),
-                AgeRestriction = u.AgeRestriction,
+                AgeRestriction = new AgeRestrictionDto()
+                {
+                    AgeRating = u.AgeRestriction,
+                    IncludeUnknowns = u.AgeRestrictionIncludeUnknowns
+                },
                 Libraries =  u.Libraries.Select(l => new LibraryDto
                 {
                     Name = l.Name,
@@ -430,7 +435,11 @@ public class UserRepository : IUserRepository
                 Created = u.Created,
                 LastActive = u.LastActive,
                 Roles = u.UserRoles.Select(r => r.Role.Name).ToList(),
-                AgeRestriction = u.AgeRestriction,
+                AgeRestriction = new AgeRestrictionDto()
+                {
+                    AgeRating = u.AgeRestriction,
+                    IncludeUnknowns = u.AgeRestrictionIncludeUnknowns
+                },
                 Libraries =  u.Libraries.Select(l => new LibraryDto
                 {
                     Name = l.Name,

API/Entities/AppUser.cs

@@ -45,6 +45,10 @@ public class AppUser : IdentityUser<int>, IHasConcurrencyToken
     /// The highest age rating the user has access to. Not applicable for admins
     /// </summary>
     public AgeRating AgeRestriction { get; set; } = AgeRating.NotApplicable;
+    /// <summary>
+    /// If an age rating restriction is applied to the account, if Unknowns should be allowed for the user. Defaults to false.
+    /// </summary>
+    public bool AgeRestrictionIncludeUnknowns { get; set; } = false;
 
     /// <inheritdoc />
     [ConcurrencyCheck]

API/Extensions/EnumerableExtensions.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
+using API.Data.Misc;
+using API.Entities.Enums;
 
 namespace API.Extensions;
 
@@ -27,4 +29,16 @@ public static class EnumerableExtensions
 
         return list.OrderBy(i => Regex.Replace(selector(i), match => match.Value.PadLeft(maxDigits, '0')), stringComparer ?? StringComparer.CurrentCulture);
     }
+
+    public static IEnumerable<RecentlyAddedSeries> RestrictAgainstAgeRestriction(this IEnumerable<RecentlyAddedSeries> items, AgeRestriction restriction)
+    {
+        if (restriction.AgeRating == AgeRating.NotApplicable) return items;
+        var q = items.Where(s => s.AgeRating <= restriction.AgeRating);
+        if (!restriction.IncludeUnknowns)
+        {
+            return q.Where(s => s.AgeRating != AgeRating.Unknown);
+        }
+
+        return q;
+    }
 }

API/Extensions/QueryableExtensions.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using API.Data.Misc;
 using API.Entities;
 using API.Entities.Enums;
 
@@ -6,18 +7,42 @@ namespace API.Extensions;
 
 public static class QueryableExtensions
 {
-    public static IQueryable<Series> RestrictAgainstAgeRestriction(this IQueryable<Series> queryable, AgeRating rating)
+    public static IQueryable<Series> RestrictAgainstAgeRestriction(this IQueryable<Series> queryable, AgeRestriction restriction)
     {
-        return queryable.Where(s => rating == AgeRating.NotApplicable || s.Metadata.AgeRating <= rating);
+        if (restriction.AgeRating == AgeRating.NotApplicable) return queryable;
+        var q = queryable.Where(s => s.Metadata.AgeRating <= restriction.AgeRating);
+        if (!restriction.IncludeUnknowns)
+        {
+            return q.Where(s => s.Metadata.AgeRating != AgeRating.Unknown);
+        }
+
+        return q;
     }
 
-    public static IQueryable<CollectionTag> RestrictAgainstAgeRestriction(this IQueryable<CollectionTag> queryable, AgeRating rating)
+    public static IQueryable<CollectionTag> RestrictAgainstAgeRestriction(this IQueryable<CollectionTag> queryable, AgeRestriction restriction)
     {
-        return queryable.Where(c => c.SeriesMetadatas.All(sm => sm.AgeRating <= rating));
+        if (restriction.AgeRating == AgeRating.NotApplicable) return queryable;
+
+        if (restriction.IncludeUnknowns)
+        {
+            return queryable.Where(c => c.SeriesMetadatas.All(sm =>
+                sm.AgeRating <= restriction.AgeRating));
+        }
+
+        return queryable.Where(c => c.SeriesMetadatas.All(sm =>
+            sm.AgeRating <= restriction.AgeRating && sm.AgeRating > AgeRating.Unknown));
     }
 
-    public static IQueryable<ReadingList> RestrictAgainstAgeRestriction(this IQueryable<ReadingList> queryable, AgeRating rating)
+    public static IQueryable<ReadingList> RestrictAgainstAgeRestriction(this IQueryable<ReadingList> queryable, AgeRestriction restriction)
     {
-        return queryable.Where(rl => rl.AgeRating <= rating);
+        if (restriction.AgeRating == AgeRating.NotApplicable) return queryable;
+        var q = queryable.Where(rl => rl.AgeRating <= restriction.AgeRating);
+
+        if (!restriction.IncludeUnknowns)
+        {
+            return q.Where(rl => rl.AgeRating != AgeRating.Unknown);
+        }
+
+        return q;
     }
 }

API/Extensions/SeriesExtensions.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using API.Comparators;
 using API.Entities;
 using API.Parser;
 using API.Services.Tasks.Scanner;
@@ -45,4 +46,26 @@ public static class SeriesExtensions
             || info.Series == series.Name || info.Series == series.LocalizedName || info.Series == series.OriginalName
             || Services.Tasks.Scanner.Parser.Parser.Normalize(info.Series) == Services.Tasks.Scanner.Parser.Parser.Normalize(series.OriginalName);
     }
+
+    /// <summary>
+    /// Calculates the Cover Image for the Series
+    /// </summary>
+    /// <param name="series"></param>
+    /// <returns></returns>
+    /// <remarks>This is under the assumption that the Volume already has a Cover Image calculated and set</remarks>
+    public static string GetCoverImage(this Series series)
+    {
+        var volumes = series.Volumes ?? new List<Volume>();
+        var firstVolume = volumes.GetCoverImage(series.Format);
+        string coverImage = null;
+
+        var chapters = firstVolume.Chapters.OrderBy(c => double.Parse(c.Number), ChapterSortComparerZeroFirst.Default).ToList();
+        if (chapters.Count > 1 && chapters.Any(c => c.IsSpecial))
+        {
+            coverImage = chapters.FirstOrDefault(c => !c.IsSpecial)?.CoverImage ?? chapters.First().CoverImage;
+            firstVolume = null;
+        }
+
+        return firstVolume?.CoverImage ?? coverImage;
+    }
 }

API/Helpers/AutoMapperProfiles.cs

@@ -1,13 +1,13 @@
 using System.Collections.Generic;
 using System.Linq;
 using API.DTOs;
+using API.DTOs.Account;
 using API.DTOs.CollectionTags;
 using API.DTOs.Device;
 using API.DTOs.Metadata;
 using API.DTOs.Reader;
 using API.DTOs.ReadingLists;
 using API.DTOs.Search;
-using API.DTOs.SeriesDetail;
 using API.DTOs.Settings;
 using API.DTOs.Theme;
 using API.Entities;
@@ -98,7 +98,14 @@ public class AutoMapperProfiles : Profile
                 opt =>
                     opt.MapFrom(src => src.People.Where(p => p.Role == PersonRole.Editor)));
 
-        CreateMap<AppUser, UserDto>();
+        CreateMap<AppUser, UserDto>()
+            .ForMember(dest => dest.AgeRestriction,
+            opt =>
+                opt.MapFrom(src => new AgeRestrictionDto()
+                {
+                    AgeRating = src.AgeRestriction,
+                    IncludeUnknowns = src.AgeRestrictionIncludeUnknowns
+                }));
         CreateMap<SiteTheme, SiteThemeDto>();
         CreateMap<AppUserPreferences, UserPreferencesDto>()
             .ForMember(dest => dest.Theme,
@@ -130,6 +137,13 @@ public class AutoMapperProfiles : Profile
                     opt.MapFrom(src => src.Folders.Select(x => x.Path).ToList()));
 
         CreateMap<AppUser, MemberDto>()
+            .ForMember(dest => dest.AgeRestriction,
+                opt =>
+                    opt.MapFrom(src => new AgeRestrictionDto()
+                    {
+                        AgeRating = src.AgeRestriction,
+                        IncludeUnknowns = src.AgeRestrictionIncludeUnknowns
+                    }))
             .AfterMap((ps, pst, context) => context.Mapper.Map(ps.Libraries, pst.Libraries));
 
         CreateMap<RegisterDto, AppUser>();

API/Services/MetadataService.cs

@@ -130,17 +130,8 @@ public class MetadataService : IMetadataService
             return Task.CompletedTask;
 
         series.Volumes ??= new List<Volume>();
-        var firstCover = series.Volumes.GetCoverImage(series.Format);
-        string coverImage = null;
+        series.CoverImage = series.GetCoverImage();
 
-        var chapters = firstCover.Chapters.OrderBy(c => double.Parse(c.Number), ChapterSortComparerZeroFirst.Default).ToList();
-        if (chapters.Count > 1 && chapters.Any(c => c.IsSpecial))
-        {
-            coverImage = chapters.First(c => !c.IsSpecial).CoverImage ?? chapters.First().CoverImage;
-            firstCover = null;
-        }
-
-        series.CoverImage = firstCover?.CoverImage ?? coverImage;
         _updateEvents.Add(MessageFactory.CoverUpdateEvent(series.Id, MessageFactoryEntityTypes.Series));
         return Task.CompletedTask;
     }

API/Services/ReadingItemService.cs

@@ -72,8 +72,7 @@ public class ReadingItemService : IReadingItemService
         // This catches when original library type is Manga/Comic and when parsing with non
         if (Tasks.Scanner.Parser.Parser.IsEpub(path) && Tasks.Scanner.Parser.Parser.ParseVolume(info.Series) != Tasks.Scanner.Parser.Parser.DefaultVolume) // Shouldn't this be info.Volume != DefaultVolume?
         {
-            info = _defaultParser.Parse(path, rootPath, LibraryType.Book);
-            var info2 = Parse(path, rootPath, type);
+            var info2 = _defaultParser.Parse(path, rootPath, LibraryType.Book);
             info.Merge(info2);
         }
 

API/Services/TaskScheduler.cs

@@ -239,7 +239,7 @@ public class TaskScheduler : ITaskScheduler
         _logger.LogInformation("Enqueuing library scan for: {LibraryId}", libraryId);
         BackgroundJob.Enqueue(() => _scannerService.ScanLibrary(libraryId, force));
         // When we do a scan, force cache to re-unpack in case page numbers change
-        BackgroundJob.Enqueue(() => _cleanupService.CleanupCacheDirectory());
+        BackgroundJob.Enqueue(() => _cleanupService.CleanupCacheAndTempDirectories());
     }
 
     public void CleanupChapters(int[] chapterIds)

API/Services/Tasks/CleanupService.cs

@@ -20,7 +20,7 @@ public interface ICleanupService
 {
     Task Cleanup();
     Task CleanupDbEntries();
-    void CleanupCacheDirectory();
+    void CleanupCacheAndTempDirectories();
     Task DeleteSeriesCoverImages();
     Task DeleteChapterCoverImages();
     Task DeleteTagCoverImages();
@@ -65,7 +65,7 @@ public class CleanupService : ICleanupService
         _logger.LogInformation("Cleaning temp directory");
         _directoryService.ClearDirectory(_directoryService.TempDirectory);
         await SendProgress(0.1F, "Cleaning temp directory");
-        CleanupCacheDirectory();
+        CleanupCacheAndTempDirectories();
         await SendProgress(0.25F, "Cleaning old database backups");
         _logger.LogInformation("Cleaning old database backups");
         await CleanupBackups();
@@ -143,9 +143,9 @@ public class CleanupService : ICleanupService
     /// <summary>
     /// Removes all files and directories in the cache and temp directory
     /// </summary>
-    public void CleanupCacheDirectory()
+    public void CleanupCacheAndTempDirectories()
     {
-        _logger.LogInformation("Performing cleanup of Cache directory");
+        _logger.LogInformation("Performing cleanup of Cache & Temp directories");
         _directoryService.ExistOrCreate(_directoryService.CacheDirectory);
         _directoryService.ExistOrCreate(_directoryService.TempDirectory);
 
@@ -159,7 +159,7 @@ public class CleanupService : ICleanupService
             _logger.LogError(ex, "There was an issue deleting one or more folders/files during cleanup");
         }
 
-        _logger.LogInformation("Cache directory purged");
+        _logger.LogInformation("Cache and temp directory purged");
     }
 
     /// <summary>

API/Services/Tasks/Scanner/ParseScannedFiles.cs

@@ -29,12 +29,6 @@ public class ParsedSeries
     public MangaFormat Format { get; init; }
 }
 
-public enum Modified
-{
-    Modified = 1,
-    NotModified = 2
-}
-
 public class SeriesModified
 {
     public string FolderPath { get; set; }

API/Services/Tasks/ScannerService.cs

@@ -506,11 +506,6 @@ public class ScannerService : IScannerService
 
         library.LastScanned = time;
 
-        // Could I delete anything in a Library's Series where the LastScan date is before scanStart?
-        // NOTE: This implementation is expensive
-        _logger.LogDebug("Removing Series that were not found during the scan");
-        var removedSeries = await _unitOfWork.SeriesRepository.RemoveSeriesNotInList(seenSeries, library.Id);
-        _logger.LogDebug("Removing Series that were not found during the scan - complete");
 
         _unitOfWork.LibraryRepository.Update(library);
         if (await _unitOfWork.CommitAsync())
@@ -528,10 +523,27 @@ public class ScannerService : IScannerService
                     totalFiles, seenSeries.Count, sw.ElapsedMilliseconds, library.Name);
             }
 
-            foreach (var s in removedSeries)
+            try
             {
-                await _eventHub.SendMessageAsync(MessageFactory.SeriesRemoved,
-                    MessageFactory.SeriesRemovedEvent(s.Id, s.Name, s.LibraryId), false);
+                // Could I delete anything in a Library's Series where the LastScan date is before scanStart?
+                // NOTE: This implementation is expensive
+                _logger.LogDebug("[ScannerService] Removing Series that were not found during the scan");
+                var removedSeries = await _unitOfWork.SeriesRepository.RemoveSeriesNotInList(seenSeries, library.Id);
+                _logger.LogDebug("[ScannerService] Found {Count} series that needs to be removed: {SeriesList}",
+                    removedSeries.Count, removedSeries.Select(s => s.Name));
+                _logger.LogDebug("[ScannerService] Removing Series that were not found during the scan - complete");
+
+                await _unitOfWork.CommitAsync();
+
+                foreach (var s in removedSeries)
+                {
+                    await _eventHub.SendMessageAsync(MessageFactory.SeriesRemoved,
+                        MessageFactory.SeriesRemovedEvent(s.Id, s.Name, s.LibraryId), false);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogCritical(ex, "[ScannerService] There was an issue deleting series for cleanup. Please check logs and rescan");
             }
         }
         else
@@ -584,4 +596,5 @@ public class ScannerService : IScannerService
     {
         return existingSeries.Where(es => !ParserInfoHelpers.SeriesHasMatchingParserInfoFormat(es, parsedSeries));
     }
+
 }

API/Services/Tasks/StatsService.cs

@@ -134,6 +134,7 @@ public class StatsService : IStatsService
             MangaReaderPageSplittingModes = await AllMangaReaderPageSplitting(),
             MangaReaderLayoutModes = await AllMangaReaderLayoutModes(),
             FileFormats = AllFormats(),
+            UsingRestrictedProfiles = await GetUsingRestrictedProfiles(),
         };
 
         var usersWithPref = (await _unitOfWork.UserRepository.GetAllUsersAsync(AppUserIncludes.UserPreferences)).ToList();
@@ -261,4 +262,9 @@ public class StatsService : IStatsService
 
         return results;
     }
+
+    private Task<bool> GetUsingRestrictedProfiles()
+    {
+        return _context.Users.AnyAsync(u => u.AgeRestriction > AgeRating.NotApplicable);
+    }
 }