Kavita+ Overhaul & New Changelog (#3507)

API/Extensions/ApplicationServiceExtensions.cs

@@ -24,8 +24,6 @@ public static class ApplicationServiceExtensions
     {
         services.AddAutoMapper(typeof(AutoMapperProfiles).Assembly);
 
-        //services.AddScoped<DataContext>();
-
         services.AddScoped<IUnitOfWork, UnitOfWork>();
         services.AddScoped<ITokenService, TokenService>();
         services.AddScoped<IFileService, FileService>();
@@ -52,7 +50,6 @@ public static class ApplicationServiceExtensions
         services.AddScoped<IStatisticService, StatisticService>();
         services.AddScoped<IMediaErrorService, MediaErrorService>();
         services.AddScoped<IMediaConversionService, MediaConversionService>();
-        services.AddScoped<IRecommendationService, RecommendationService>();
         services.AddScoped<IStreamService, StreamService>();
 
         services.AddScoped<IScannerService, ScannerService>();
@@ -77,6 +74,7 @@ public static class ApplicationServiceExtensions
         services.AddScoped<ILicenseService, LicenseService>();
         services.AddScoped<IExternalMetadataService, ExternalMetadataService>();
         services.AddScoped<ISmartCollectionSyncService, SmartCollectionSyncService>();
+        services.AddScoped<IWantToReadSyncService, WantToReadSyncService>();
 
         services.AddSqLite();
         services.AddSignalR(opt => opt.EnableDetailedErrors = true);
@@ -84,12 +82,13 @@ public static class ApplicationServiceExtensions
         services.AddEasyCaching(options =>
         {
             options.UseInMemory(EasyCacheProfiles.Favicon);
-            options.UseInMemory(EasyCacheProfiles.License);
             options.UseInMemory(EasyCacheProfiles.Library);
             options.UseInMemory(EasyCacheProfiles.RevokedJwt);
 
             // KavitaPlus stuff
             options.UseInMemory(EasyCacheProfiles.KavitaPlusExternalSeries);
+            options.UseInMemory(EasyCacheProfiles.License);
+            options.UseInMemory(EasyCacheProfiles.LicenseInfo);
         });
 
         services.AddMemoryCache(options =>

API/Extensions/FlurlExtensions.cs

@@ -0,0 +1,21 @@
+using System;
+using Flurl.Http;
+using Kavita.Common;
+using Kavita.Common.EnvironmentInfo;
+
+namespace API.Extensions;
+
+public static class FlurlExtensions
+{
+    public static IFlurlRequest WithKavitaPlusHeaders(this string request, string license)
+    {
+        return request
+            .WithHeader("Accept", "application/json")
+            .WithHeader("User-Agent", "Kavita")
+            .WithHeader("x-license-key", license)
+            .WithHeader("x-installId", HashUtil.ServerToken())
+            .WithHeader("x-kavita-version", BuildInfo.Version)
+            .WithHeader("Content-Type", "application/json")
+            .WithTimeout(TimeSpan.FromSeconds(Configuration.DefaultTimeOutSecs));
+    }
+}

API/Extensions/PlusMediaFormatExtensions.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using API.DTOs.Scrobbling;
+using API.Entities.Enums;
+
+namespace API.Extensions;
+
+public static class PlusMediaFormatExtensions
+{
+    public static PlusMediaFormat ConvertToPlusMediaFormat(this LibraryType libraryType, MangaFormat? seriesFormat = null)
+    {
+
+        return libraryType switch
+        {
+            LibraryType.Manga => seriesFormat is MangaFormat.Epub ? PlusMediaFormat.LightNovel : PlusMediaFormat.Manga,
+            LibraryType.Comic => PlusMediaFormat.Comic,
+            LibraryType.LightNovel => PlusMediaFormat.LightNovel,
+            LibraryType.Book => PlusMediaFormat.LightNovel,
+            LibraryType.Image => PlusMediaFormat.Manga,
+            LibraryType.ComicVine => PlusMediaFormat.Comic,
+            _ => throw new ArgumentOutOfRangeException(nameof(libraryType), libraryType, null)
+        };
+    }
+
+    public static IEnumerable<LibraryType> ConvertToLibraryTypes(this PlusMediaFormat plusMediaFormat)
+    {
+        return plusMediaFormat switch
+        {
+            PlusMediaFormat.Manga => new[] { LibraryType.Manga, LibraryType.Image },
+            PlusMediaFormat.Comic => new[] { LibraryType.Comic, LibraryType.ComicVine },
+            PlusMediaFormat.LightNovel => new[] { LibraryType.LightNovel, LibraryType.Book, LibraryType.Manga },
+            _ => throw new ArgumentOutOfRangeException(nameof(plusMediaFormat), plusMediaFormat, null)
+        };
+    }
+
+
+    public static IList<MangaFormat> GetMangaFormats(this PlusMediaFormat? mediaFormat)
+    {
+        if (mediaFormat == null) return [MangaFormat.Archive];
+        return mediaFormat switch
+        {
+            PlusMediaFormat.Manga => [MangaFormat.Archive, MangaFormat.Image],
+            PlusMediaFormat.Comic => [MangaFormat.Archive],
+            PlusMediaFormat.LightNovel => [MangaFormat.Epub, MangaFormat.Pdf],
+            PlusMediaFormat.Book => [MangaFormat.Epub, MangaFormat.Pdf],
+            PlusMediaFormat.Unknown => [MangaFormat.Archive],
+            _ => [MangaFormat.Archive]
+        };
+    }
+}

API/Extensions/QueryExtensions/QueryableExtensions.cs

@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using API.Data.Misc;
 using API.Data.Repositories;
 using API.DTOs.Filtering;
+using API.DTOs.KavitaPlus.Manage;
 using API.Entities;
 using API.Entities.Enums;
 using API.Entities.Scrobble;
@@ -281,4 +282,17 @@ public static class QueryableExtensions
     {
         return sortOptions.IsAscending ? query.OrderBy(keySelector) : query.OrderByDescending(keySelector);
     }
+
+    public static IQueryable<Series> FilterMatchState(this IQueryable<Series> query, MatchStateOption stateOption)
+    {
+        return stateOption switch
+        {
+            MatchStateOption.All => query,
+            MatchStateOption.Matched => query.Where(s => s.ExternalSeriesMetadata != null && s.ExternalSeriesMetadata.ValidUntilUtc > DateTime.MinValue && !s.IsBlacklisted),
+            MatchStateOption.NotMatched => query.Where(s => (s.ExternalSeriesMetadata == null || s.ExternalSeriesMetadata.ValidUntilUtc == DateTime.MinValue) && !s.IsBlacklisted),
+            MatchStateOption.Error => query.Where(s => s.IsBlacklisted),
+            MatchStateOption.DontMatch => query.Where(s => s.DontMatch),
+            _ => throw new ArgumentOutOfRangeException(nameof(stateOption), stateOption, null)
+        };
+    }
 }

API/Extensions/VersionExtensions.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace API.Extensions;
+
+public static class VersionExtensions
+{
+    public static bool CompareWithoutRevision(this Version v1, Version v2)
+    {
+        if (v1.Major != v2.Major)
+            return v1.Major == v2.Major;
+        if (v1.Minor != v2.Minor)
+            return v1.Minor == v2.Minor;
+        if (v1.Build != v2.Build)
+            return v1.Build == v2.Build;
+        return true;
+    }
+
+
+    /// <summary>
+    /// v0.8.2.3 is within v0.8.2 (v1). Essentially checks if this is a Nightly of a stable release
+    /// </summary>
+    /// <param name="v1"></param>
+    /// <param name="v2"></param>
+    /// <returns></returns>
+    public static bool IsWithinStableRelease(this Version v1, Version v2)
+    {
+        return v1.Major == v2.Major && v1.Minor != v2.Minor && v1.Build != v2.Build;
+    }
+
+
+}