mirror of
https://github.com/Kareadita/Kavita.git
synced 2025-05-24 00:52:23 -04:00
1449 lines
57 KiB
C#
1449 lines
57 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using API.Data;
|
|
using API.Data.Repositories;
|
|
using API.DTOs;
|
|
using API.DTOs.Collection;
|
|
using API.DTOs.KavitaPlus.ExternalMetadata;
|
|
using API.DTOs.KavitaPlus.Metadata;
|
|
using API.DTOs.Metadata.Matching;
|
|
using API.DTOs.Recommendation;
|
|
using API.DTOs.Scrobbling;
|
|
using API.DTOs.SeriesDetail;
|
|
using API.Entities;
|
|
using API.Entities.Enums;
|
|
using API.Entities.Metadata;
|
|
using API.Entities.MetadataMatching;
|
|
using API.Extensions;
|
|
using API.Helpers;
|
|
using API.Services.Tasks.Metadata;
|
|
using API.Services.Tasks.Scanner.Parser;
|
|
using API.SignalR;
|
|
using AutoMapper;
|
|
using Flurl.Http;
|
|
using Hangfire;
|
|
using Kavita.Common;
|
|
using Kavita.Common.Helpers;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace API.Services.Plus;
|
|
#nullable enable
|
|
|
|
|
|
|
|
public interface IExternalMetadataService
|
|
{
|
|
Task<ExternalSeriesDetailDto?> GetExternalSeriesDetail(int? aniListId, long? malId, int? seriesId);
|
|
Task<SeriesDetailPlusDto?> GetSeriesDetailPlus(int seriesId, LibraryType libraryType);
|
|
Task FetchExternalDataTask();
|
|
/// <summary>
|
|
/// This is an entry point and provides a level of protection against calling upstream API. Will only allow 100 new
|
|
/// series to fetch data within a day and enqueues background jobs at certain times to fetch that data.
|
|
/// </summary>
|
|
/// <param name="seriesId"></param>
|
|
/// <param name="libraryType"></param>
|
|
/// <returns>If the fetch was made</returns>
|
|
Task<bool> FetchSeriesMetadata(int seriesId, LibraryType libraryType);
|
|
|
|
Task<IList<MalStackDto>> GetStacksForUser(int userId);
|
|
Task<IList<ExternalSeriesMatchDto>> MatchSeries(MatchSeriesDto dto);
|
|
Task FixSeriesMatch(int seriesId, int anilistId, long? malId);
|
|
Task UpdateSeriesDontMatch(int seriesId, bool dontMatch);
|
|
Task<bool> WriteExternalMetadataToSeries(ExternalSeriesDetailDto externalMetadata, int seriesId);
|
|
}
|
|
|
|
public class ExternalMetadataService : IExternalMetadataService
|
|
{
|
|
private readonly IUnitOfWork _unitOfWork;
|
|
private readonly ILogger<ExternalMetadataService> _logger;
|
|
private readonly IMapper _mapper;
|
|
private readonly ILicenseService _licenseService;
|
|
private readonly IScrobblingService _scrobblingService;
|
|
private readonly IEventHub _eventHub;
|
|
private readonly ICoverDbService _coverDbService;
|
|
private readonly TimeSpan _externalSeriesMetadataCache = TimeSpan.FromDays(30);
|
|
public static readonly HashSet<LibraryType> NonEligibleLibraryTypes =
|
|
[LibraryType.Comic, LibraryType.Book, LibraryType.Image, LibraryType.ComicVine];
|
|
private readonly SeriesDetailPlusDto _defaultReturn = new()
|
|
{
|
|
Series = null,
|
|
Recommendations = null,
|
|
Ratings = [],
|
|
Reviews = []
|
|
};
|
|
// Allow 50 requests per 24 hours
|
|
private static readonly RateLimiter RateLimiter = new RateLimiter(50, TimeSpan.FromHours(24), false);
|
|
static bool IsRomanCharacters(string input) => Regex.IsMatch(input, @"^[\p{IsBasicLatin}\p{IsLatin-1Supplement}]+$");
|
|
|
|
public ExternalMetadataService(IUnitOfWork unitOfWork, ILogger<ExternalMetadataService> logger, IMapper mapper,
|
|
ILicenseService licenseService, IScrobblingService scrobblingService, IEventHub eventHub, ICoverDbService coverDbService)
|
|
{
|
|
_unitOfWork = unitOfWork;
|
|
_logger = logger;
|
|
_mapper = mapper;
|
|
_licenseService = licenseService;
|
|
_scrobblingService = scrobblingService;
|
|
_eventHub = eventHub;
|
|
_coverDbService = coverDbService;
|
|
|
|
FlurlConfiguration.ConfigureClientForUrl(Configuration.KavitaPlusApiUrl);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the library type is allowed to interact with Kavita+
|
|
/// </summary>
|
|
/// <param name="type"></param>
|
|
/// <returns></returns>
|
|
public static bool IsPlusEligible(LibraryType type)
|
|
{
|
|
return !NonEligibleLibraryTypes.Contains(type);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is a task that runs on a schedule and slowly fetches data from Kavita+ to keep
|
|
/// data in the DB non-stale and fetched.
|
|
/// </summary>
|
|
/// <remarks>To avoid blasting Kavita+ API, this only processes 25 records. The goal is to slowly build out/refresh the data</remarks>
|
|
/// <returns></returns>
|
|
[DisableConcurrentExecution(60 * 60 * 60)]
|
|
[AutomaticRetry(Attempts = 3, OnAttemptsExceeded = AttemptsExceededAction.Delete)]
|
|
public async Task FetchExternalDataTask()
|
|
{
|
|
// Find all Series that are eligible and limit
|
|
var ids = await _unitOfWork.ExternalSeriesMetadataRepository.GetSeriesThatNeedExternalMetadata(25, false);
|
|
if (ids.Count == 0) return;
|
|
|
|
_logger.LogInformation("[Kavita+ Data Refresh] Started Refreshing {Count} series data from Kavita+", ids.Count);
|
|
var count = 0;
|
|
var libTypes = await _unitOfWork.LibraryRepository.GetLibraryTypesBySeriesIdsAsync(ids);
|
|
foreach (var seriesId in ids)
|
|
{
|
|
var libraryType = libTypes[seriesId];
|
|
var success = await FetchSeriesMetadata(seriesId, libraryType);
|
|
if (success) count++;
|
|
await Task.Delay(6000); // Currently AL is degraded and has 30 requests/min, give a little padding since this is a background request
|
|
}
|
|
_logger.LogInformation("[Kavita+ Data Refresh] Finished Refreshing {Count} series data from Kavita+", count);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Fetches data from Kavita+
|
|
/// </summary>
|
|
/// <param name="seriesId"></param>
|
|
/// <param name="libraryType"></param>
|
|
/// <returns>If a successful match was made</returns>
|
|
public async Task<bool> FetchSeriesMetadata(int seriesId, LibraryType libraryType)
|
|
{
|
|
if (!IsPlusEligible(libraryType)) return false;
|
|
if (!await _licenseService.HasActiveLicense()) return false;
|
|
|
|
// Generate key based on seriesId and libraryType or any unique identifier for the request
|
|
// Check if the request is allowed based on the rate limit
|
|
if (!RateLimiter.TryAcquire(string.Empty))
|
|
{
|
|
// Request not allowed due to rate limit
|
|
_logger.LogDebug("Rate Limit hit for Kavita+ prefetch");
|
|
return false;
|
|
}
|
|
|
|
// Prefetch SeriesDetail data
|
|
return await GetSeriesDetailPlus(seriesId, libraryType) != null;
|
|
}
|
|
|
|
public async Task<IList<MalStackDto>> GetStacksForUser(int userId)
|
|
{
|
|
if (!await _licenseService.HasActiveLicense()) return ArraySegment<MalStackDto>.Empty;
|
|
|
|
// See if this user has Mal account on record
|
|
var user = await _unitOfWork.UserRepository.GetUserByIdAsync(userId);
|
|
if (user == null || string.IsNullOrEmpty(user.MalUserName) || string.IsNullOrEmpty(user.MalAccessToken))
|
|
{
|
|
_logger.LogInformation("User is attempting to fetch MAL Stacks, but missing information on their account");
|
|
return ArraySegment<MalStackDto>.Empty;
|
|
}
|
|
try
|
|
{
|
|
_logger.LogDebug("Fetching Kavita+ for MAL Stacks for user {UserName}", user.MalUserName);
|
|
|
|
var license = (await _unitOfWork.SettingsRepository.GetSettingAsync(ServerSettingKey.LicenseKey)).Value;
|
|
var result = await ($"{Configuration.KavitaPlusApiUrl}/api/metadata/v2/stacks?username={user.MalUserName}")
|
|
.WithKavitaPlusHeaders(license)
|
|
.GetJsonAsync<IList<MalStackDto>>();
|
|
|
|
if (result == null)
|
|
{
|
|
return ArraySegment<MalStackDto>.Empty;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogDebug(ex, "Fetching Kavita+ for MAL Stacks for user {UserName} failed", user.MalUserName);
|
|
return ArraySegment<MalStackDto>.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the match results for a Series from UI Flow
|
|
/// </summary>
|
|
/// <param name="dto"></param>
|
|
/// <returns></returns>
|
|
public async Task<IList<ExternalSeriesMatchDto>> MatchSeries(MatchSeriesDto dto)
|
|
{
|
|
var license = (await _unitOfWork.SettingsRepository.GetSettingAsync(ServerSettingKey.LicenseKey)).Value;
|
|
var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(dto.SeriesId,
|
|
SeriesIncludes.Metadata | SeriesIncludes.ExternalMetadata);
|
|
if (series == null) return [];
|
|
|
|
var potentialAnilistId = ScrobblingService.ExtractId<int?>(dto.Query, ScrobblingService.AniListWeblinkWebsite);
|
|
var potentialMalId = ScrobblingService.ExtractId<long?>(dto.Query, ScrobblingService.MalWeblinkWebsite);
|
|
|
|
List<string> altNames = [series.LocalizedName, series.OriginalName];
|
|
if (potentialAnilistId == null && potentialMalId == null && !string.IsNullOrEmpty(dto.Query))
|
|
{
|
|
altNames.Add(dto.Query);
|
|
}
|
|
|
|
var matchRequest = new MatchSeriesRequestDto()
|
|
{
|
|
Format = series.Format == MangaFormat.Epub ? PlusMediaFormat.LightNovel : PlusMediaFormat.Manga,
|
|
Query = dto.Query,
|
|
SeriesName = series.Name,
|
|
AlternativeNames = altNames.Where(s => !string.IsNullOrEmpty(s)).ToList(),
|
|
Year = series.Metadata.ReleaseYear,
|
|
AniListId = potentialAnilistId ?? ScrobblingService.GetAniListId(series),
|
|
MalId = potentialMalId ?? ScrobblingService.GetMalId(series),
|
|
};
|
|
|
|
var token = (await _unitOfWork.UserRepository.GetDefaultAdminUser()).AniListAccessToken;
|
|
|
|
try
|
|
{
|
|
var results = await (Configuration.KavitaPlusApiUrl + "/api/metadata/v2/match-series")
|
|
.WithKavitaPlusHeaders(license, token)
|
|
.PostJsonAsync(matchRequest)
|
|
.ReceiveJson<IList<ExternalSeriesMatchDto>>();
|
|
|
|
// Some summaries can contain multiple <br/>s, we need to ensure it's only 1
|
|
foreach (var result in results)
|
|
{
|
|
result.Series.Summary = StringHelper.RemoveSourceInDescription(StringHelper.SquashBreaklines(result.Series.Summary));
|
|
}
|
|
|
|
return results;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "An error happened during the request to Kavita+ API");
|
|
}
|
|
|
|
return ArraySegment<ExternalSeriesMatchDto>.Empty;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Retrieves Metadata about a Recommended External Series
|
|
/// </summary>
|
|
/// <param name="aniListId"></param>
|
|
/// <param name="malId"></param>
|
|
/// <param name="seriesId"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="KavitaException"></exception>
|
|
public async Task<ExternalSeriesDetailDto?> GetExternalSeriesDetail(int? aniListId, long? malId, int? seriesId)
|
|
{
|
|
if (!aniListId.HasValue && !malId.HasValue)
|
|
{
|
|
throw new KavitaException("Unable to find valid information from url for External Load");
|
|
}
|
|
|
|
// This is for the Series drawer. We can get this extra information during the initial SeriesDetail call so it's all coming from the DB
|
|
|
|
var license = (await _unitOfWork.SettingsRepository.GetSettingAsync(ServerSettingKey.LicenseKey)).Value;
|
|
var details = await GetSeriesDetail(license, aniListId, malId, seriesId);
|
|
|
|
return details;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns Series Detail data from Kavita+ - Review, Recs, Ratings
|
|
/// </summary>
|
|
/// <param name="seriesId"></param>
|
|
/// <param name="libraryType"></param>
|
|
/// <returns></returns>
|
|
public async Task<SeriesDetailPlusDto?> GetSeriesDetailPlus(int seriesId, LibraryType libraryType)
|
|
{
|
|
if (!IsPlusEligible(libraryType) || !await _licenseService.HasActiveLicense()) return _defaultReturn;
|
|
|
|
// Check blacklist (bad matches) or if there is a don't match
|
|
var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId);
|
|
if (series == null || !series.WillScrobble()) return _defaultReturn;
|
|
|
|
var needsRefresh =
|
|
await _unitOfWork.ExternalSeriesMetadataRepository.NeedsDataRefresh(seriesId);
|
|
|
|
if (!needsRefresh)
|
|
{
|
|
// Convert into DTOs and return
|
|
return await _unitOfWork.ExternalSeriesMetadataRepository.GetSeriesDetailPlusDto(seriesId);
|
|
}
|
|
|
|
var data = await _unitOfWork.SeriesRepository.GetPlusSeriesDto(seriesId);
|
|
if (data == null) return _defaultReturn;
|
|
|
|
// Get from Kavita+ API the Full Series metadata with rec/rev and cache to ExternalMetadata tables
|
|
try
|
|
{
|
|
return await FetchExternalMetadataForSeries(seriesId, libraryType, data);
|
|
}
|
|
catch (KavitaException ex)
|
|
{
|
|
_logger.LogError(ex, "Rate limit hit fetching metadata");
|
|
// This can happen when we hit rate limit
|
|
return _defaultReturn;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This will override any sort of matching that was done prior and force it to be what the user Selected
|
|
/// </summary>
|
|
/// <param name="seriesId"></param>
|
|
/// <param name="anilistId"></param>
|
|
public async Task FixSeriesMatch(int seriesId, int anilistId, long? malId)
|
|
{
|
|
var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId, SeriesIncludes.Library);
|
|
if (series == null) return;
|
|
|
|
// Remove from Blacklist
|
|
series.IsBlacklisted = false;
|
|
series.DontMatch = false;
|
|
_unitOfWork.SeriesRepository.Update(series);
|
|
|
|
// Refetch metadata with a Direct lookup
|
|
try
|
|
{
|
|
var metadata = await FetchExternalMetadataForSeries(seriesId, series.Library.Type,
|
|
new PlusSeriesRequestDto()
|
|
{
|
|
AniListId = anilistId,
|
|
MalId = malId,
|
|
SeriesName = series.Name // Required field, not used since AniList/Mal Id are passed
|
|
});
|
|
|
|
if (metadata.Series == null)
|
|
{
|
|
_logger.LogError("Unable to Match {SeriesName} with Kavita+ Series AniList Id: {AniListId}",
|
|
series.Name, anilistId);
|
|
return;
|
|
}
|
|
|
|
// Find all scrobble events and rewrite them to be the correct
|
|
var events = await _unitOfWork.ScrobbleRepository.GetAllEventsForSeries(seriesId);
|
|
_unitOfWork.ScrobbleRepository.Remove(events);
|
|
|
|
// Find all scrobble errors and remove them
|
|
var errors = await _unitOfWork.ScrobbleRepository.GetAllScrobbleErrorsForSeries(seriesId);
|
|
_unitOfWork.ScrobbleRepository.Remove(errors);
|
|
|
|
await _unitOfWork.CommitAsync();
|
|
|
|
// Regenerate all events for the series for all users
|
|
BackgroundJob.Enqueue(() => _scrobblingService.CreateEventsFromExistingHistoryForSeries(seriesId));
|
|
|
|
// Name can be null on Series even with a direct match
|
|
_logger.LogInformation("Matched {SeriesName} with Kavita+ Series {MatchSeriesName}", series.Name,
|
|
metadata.Series.Name);
|
|
}
|
|
catch (KavitaException ex)
|
|
{
|
|
// We can't rethrow because Fix match is done in a background thread and Hangfire will requeue multiple times
|
|
_logger.LogInformation(ex, "Rate limit hit for matching {SeriesName} with Kavita+", series.Name);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a series to Don't Match and removes all previously cached
|
|
/// </summary>
|
|
/// <param name="seriesId"></param>
|
|
public async Task UpdateSeriesDontMatch(int seriesId, bool dontMatch)
|
|
{
|
|
var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId, SeriesIncludes.ExternalMetadata);
|
|
if (series == null) return;
|
|
|
|
_logger.LogInformation("User has asked Kavita to stop matching/scrobbling on {SeriesName}", series.Name);
|
|
|
|
series.DontMatch = dontMatch;
|
|
|
|
if (dontMatch)
|
|
{
|
|
// When we set as DontMatch, we will clear existing External Metadata
|
|
var externalSeriesMetadata = await GetOrCreateExternalSeriesMetadataForSeries(seriesId, series);
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Remove(series.ExternalSeriesMetadata);
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Remove(externalSeriesMetadata.ExternalReviews);
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Remove(externalSeriesMetadata.ExternalRatings);
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Remove(externalSeriesMetadata.ExternalRecommendations);
|
|
}
|
|
|
|
_unitOfWork.SeriesRepository.Update(series);
|
|
|
|
await _unitOfWork.CommitAsync();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Requests the full SeriesDetail (rec, review, metadata) data for a Series. Will save to ExternalMetadata tables.
|
|
/// </summary>
|
|
/// <param name="seriesId"></param>
|
|
/// <param name="libraryType"></param>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
private async Task<SeriesDetailPlusDto> FetchExternalMetadataForSeries(int seriesId, LibraryType libraryType, PlusSeriesRequestDto data)
|
|
{
|
|
|
|
var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId, SeriesIncludes.Library);
|
|
if (series == null)
|
|
{
|
|
return _defaultReturn;
|
|
}
|
|
|
|
try
|
|
{
|
|
_logger.LogDebug("Fetching Kavita+ Series Detail data for {SeriesName}", string.IsNullOrEmpty(data.SeriesName) ? data.AniListId : data.SeriesName);
|
|
var license = (await _unitOfWork.SettingsRepository.GetSettingAsync(ServerSettingKey.LicenseKey)).Value;
|
|
var token = (await _unitOfWork.UserRepository.GetDefaultAdminUser()).AniListAccessToken;
|
|
SeriesDetailPlusApiDto? result = null;
|
|
|
|
try
|
|
{
|
|
result = await (Configuration.KavitaPlusApiUrl + "/api/metadata/v2/series-detail")
|
|
.WithKavitaPlusHeaders(license, token)
|
|
.PostJsonAsync(data)
|
|
.ReceiveJson<
|
|
SeriesDetailPlusApiDto>(); // This returns an AniListSeries and Match returns ExternalSeriesDto
|
|
}
|
|
catch (FlurlHttpException ex)
|
|
{
|
|
var errorMessage = await ex.GetResponseStringAsync();
|
|
// Trim quotes if the response is a JSON string
|
|
errorMessage = errorMessage.Trim('"');
|
|
|
|
if (ex.StatusCode == 400 && errorMessage.Contains("Too many Requests"))
|
|
{
|
|
_logger.LogInformation("Hit rate limit, will retry in 3 seconds");
|
|
await Task.Delay(3000);
|
|
|
|
result = await (Configuration.KavitaPlusApiUrl + "/api/metadata/v2/series-detail")
|
|
.WithKavitaPlusHeaders(license, token)
|
|
.PostJsonAsync(data)
|
|
.ReceiveJson<
|
|
SeriesDetailPlusApiDto>();
|
|
}
|
|
}
|
|
|
|
if (result == null)
|
|
{
|
|
_logger.LogInformation("Hit rate limit twice, try again later");
|
|
return _defaultReturn;
|
|
}
|
|
|
|
|
|
// Clear out existing results
|
|
var externalSeriesMetadata = await GetOrCreateExternalSeriesMetadataForSeries(seriesId, series);
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Remove(externalSeriesMetadata.ExternalReviews);
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Remove(externalSeriesMetadata.ExternalRatings);
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Remove(externalSeriesMetadata.ExternalRecommendations);
|
|
|
|
externalSeriesMetadata.ExternalReviews = result.Reviews.Select(r =>
|
|
{
|
|
var review = _mapper.Map<ExternalReview>(r);
|
|
review.SeriesId = externalSeriesMetadata.SeriesId;
|
|
return review;
|
|
}).ToList();
|
|
|
|
externalSeriesMetadata.ExternalRatings = result.Ratings.Select(r =>
|
|
{
|
|
var rating = _mapper.Map<ExternalRating>(r);
|
|
rating.SeriesId = externalSeriesMetadata.SeriesId;
|
|
return rating;
|
|
}).ToList();
|
|
|
|
|
|
// Recommendations
|
|
externalSeriesMetadata.ExternalRecommendations ??= [];
|
|
var recs = await ProcessRecommendations(libraryType, result.Recommendations, externalSeriesMetadata);
|
|
|
|
var extRatings = externalSeriesMetadata.ExternalRatings
|
|
.Where(r => r.AverageScore > 0)
|
|
.ToList();
|
|
|
|
externalSeriesMetadata.ValidUntilUtc = DateTime.UtcNow.Add(_externalSeriesMetadataCache);
|
|
externalSeriesMetadata.AverageExternalRating = extRatings.Count != 0 ? (int) extRatings
|
|
.Average(r => r.AverageScore) : 0;
|
|
|
|
if (result.MalId.HasValue) externalSeriesMetadata.MalId = result.MalId.Value;
|
|
if (result.AniListId.HasValue) externalSeriesMetadata.AniListId = result.AniListId.Value;
|
|
|
|
// If there is metadata and the user has metadata download turned on
|
|
var madeMetadataModification = false;
|
|
if (result.Series != null && series.Library.AllowMetadataMatching)
|
|
{
|
|
externalSeriesMetadata.Series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId);
|
|
|
|
try
|
|
{
|
|
madeMetadataModification = await WriteExternalMetadataToSeries(result.Series, seriesId);
|
|
if (madeMetadataModification)
|
|
{
|
|
_unitOfWork.SeriesRepository.Update(series);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "There was an exception when trying to write Series metadata from Kavita+");
|
|
}
|
|
|
|
}
|
|
|
|
// WriteExternalMetadataToSeries will commit but not always
|
|
if (_unitOfWork.HasChanges())
|
|
{
|
|
await _unitOfWork.CommitAsync();
|
|
}
|
|
|
|
if (madeMetadataModification)
|
|
{
|
|
// Inform the UI of the update
|
|
await _eventHub.SendMessageAsync(MessageFactory.ScanSeries, MessageFactory.ScanSeriesEvent(series.LibraryId, series.Id, series.Name), false);
|
|
}
|
|
|
|
return new SeriesDetailPlusDto()
|
|
{
|
|
Recommendations = recs,
|
|
Ratings = result.Ratings,
|
|
Reviews = externalSeriesMetadata.ExternalReviews.Select(r => _mapper.Map<UserReviewDto>(r)),
|
|
Series = result.Series
|
|
};
|
|
}
|
|
catch (FlurlHttpException ex)
|
|
{
|
|
var errorMessage = await ex.GetResponseStringAsync();
|
|
// Trim quotes if the response is a JSON string
|
|
errorMessage = errorMessage.Trim('"');
|
|
|
|
if (ex.StatusCode == 500)
|
|
{
|
|
return _defaultReturn;
|
|
}
|
|
|
|
if (ex.StatusCode == 400 && errorMessage.Contains("Too many Requests"))
|
|
{
|
|
throw new KavitaException("Too many requests, slow down");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (ex.Message.Contains("Too Many Requests"))
|
|
{
|
|
throw new KavitaException("Too many requests, slow down");
|
|
}
|
|
|
|
_logger.LogError(ex, "Unable to fetch external series metadata from Kavita+");
|
|
}
|
|
|
|
// Blacklist the series as it wasn't found in Kavita+
|
|
series.IsBlacklisted = true;
|
|
await _unitOfWork.CommitAsync();
|
|
|
|
return _defaultReturn;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Given external metadata from Kavita+, write as much as possible to the Kavita series as possible
|
|
/// </summary>
|
|
/// <param name="externalMetadata"></param>
|
|
/// <param name="seriesId"></param>
|
|
/// <returns></returns>
|
|
public async Task<bool> WriteExternalMetadataToSeries(ExternalSeriesDetailDto externalMetadata, int seriesId)
|
|
{
|
|
var settings = await _unitOfWork.SettingsRepository.GetMetadataSettingDto();
|
|
if (!settings.Enabled) return false;
|
|
|
|
var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId, SeriesIncludes.Metadata | SeriesIncludes.Related);
|
|
if (series == null) return false;
|
|
|
|
var defaultAdmin = await _unitOfWork.UserRepository.GetDefaultAdminUser();
|
|
|
|
_logger.LogInformation("Writing External metadata to Series {SeriesName}", series.Name);
|
|
|
|
var madeModification = false;
|
|
var processedGenres = new List<string>();
|
|
var processedTags = new List<string>();
|
|
|
|
madeModification = UpdateSummary(series, settings, externalMetadata) || madeModification;
|
|
madeModification = UpdateReleaseYear(series, settings, externalMetadata) || madeModification;
|
|
madeModification = UpdateLocalizedName(series, settings, externalMetadata) || madeModification;
|
|
madeModification = await UpdatePublicationStatus(series, settings, externalMetadata) || madeModification;
|
|
|
|
// Apply field mappings
|
|
GenerateGenreAndTagLists(externalMetadata, settings, ref processedTags, ref processedGenres);
|
|
|
|
madeModification = await UpdateGenres(series, settings, externalMetadata, processedGenres) || madeModification;
|
|
madeModification = await UpdateTags(series, settings, externalMetadata, processedTags) || madeModification;
|
|
madeModification = UpdateAgeRating(series, settings, processedGenres.Concat(processedTags)) || madeModification;
|
|
|
|
var staff = (externalMetadata.Staff ?? []).Select(s =>
|
|
{
|
|
s.Name = settings.FirstLastPeopleNaming ? $"{s.FirstName} {s.LastName}" : $"{s.LastName} {s.FirstName}";
|
|
|
|
return s;
|
|
}).ToList();
|
|
madeModification = await UpdateWriters(series, settings, staff) || madeModification;
|
|
madeModification = await UpdateArtists(series, settings, staff) || madeModification;
|
|
madeModification = await UpdateCharacters(series, settings, externalMetadata.Characters) || madeModification;
|
|
|
|
madeModification = await UpdateRelationships(series, settings, externalMetadata.Relations, defaultAdmin) || madeModification;
|
|
madeModification = await UpdateCoverImage(series, settings, externalMetadata) || madeModification;
|
|
|
|
return madeModification;
|
|
}
|
|
|
|
private static void GenerateGenreAndTagLists(ExternalSeriesDetailDto externalMetadata, MetadataSettingsDto settings,
|
|
ref List<string> processedTags, ref List<string> processedGenres)
|
|
{
|
|
externalMetadata.Tags ??= [];
|
|
externalMetadata.Genres ??= [];
|
|
|
|
var mappings = ApplyFieldMappings(externalMetadata.Tags.Select(t => t.Name), MetadataFieldType.Tag, settings.FieldMappings);
|
|
if (mappings.TryGetValue(MetadataFieldType.Tag, out var tagsToTags))
|
|
{
|
|
processedTags.AddRange(tagsToTags);
|
|
}
|
|
if (mappings.TryGetValue(MetadataFieldType.Genre, out var tagsToGenres))
|
|
{
|
|
processedGenres.AddRange(tagsToGenres);
|
|
}
|
|
|
|
mappings = ApplyFieldMappings(externalMetadata.Genres, MetadataFieldType.Genre, settings.FieldMappings);
|
|
if (mappings.TryGetValue(MetadataFieldType.Tag, out var genresToTags))
|
|
{
|
|
processedTags.AddRange(genresToTags);
|
|
}
|
|
if (mappings.TryGetValue(MetadataFieldType.Genre, out var genresToGenres))
|
|
{
|
|
processedGenres.AddRange(genresToGenres);
|
|
}
|
|
|
|
processedTags = ApplyBlackWhiteList(settings, MetadataFieldType.Tag, processedTags);
|
|
processedGenres = ApplyBlackWhiteList(settings, MetadataFieldType.Genre, processedGenres);
|
|
}
|
|
|
|
private async Task<bool> UpdateRelationships(Series series, MetadataSettingsDto settings, IList<SeriesRelationship>? externalMetadataRelations, AppUser defaultAdmin)
|
|
{
|
|
if (!settings.EnableRelationships) return false;
|
|
|
|
if (externalMetadataRelations == null || externalMetadataRelations.Count == 0 || defaultAdmin == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
foreach (var relation in externalMetadataRelations.Where(r => r.Relation != RelationKind.Parent))
|
|
{
|
|
var names = new [] {relation.SeriesName.PreferredTitle, relation.SeriesName.RomajiTitle, relation.SeriesName.EnglishTitle, relation.SeriesName.NativeTitle};
|
|
var relatedSeries = await _unitOfWork.SeriesRepository.GetSeriesByAnyName(
|
|
names,
|
|
relation.PlusMediaFormat.GetMangaFormats(),
|
|
defaultAdmin.Id,
|
|
relation.AniListId,
|
|
SeriesIncludes.Related);
|
|
|
|
// Skip if no related series found or series is the parent
|
|
if (relatedSeries == null || relatedSeries.Id == series.Id || relation.Relation == RelationKind.Parent) continue;
|
|
|
|
// Check if the relationship already exists
|
|
var relationshipExists = series.Relations.Any(r =>
|
|
r.TargetSeriesId == relatedSeries.Id && r.RelationKind == relation.Relation);
|
|
|
|
if (relationshipExists) continue;
|
|
|
|
// Add new relationship
|
|
var newRelation = new SeriesRelation
|
|
{
|
|
RelationKind = relation.Relation,
|
|
TargetSeriesId = relatedSeries.Id,
|
|
SeriesId = series.Id,
|
|
};
|
|
series.Relations.Add(newRelation);
|
|
|
|
// Handle sequel/prequel: add reverse relationship
|
|
if (relation.Relation is RelationKind.Prequel or RelationKind.Sequel)
|
|
{
|
|
var reverseExists = relatedSeries.Relations.Any(r =>
|
|
r.TargetSeriesId == series.Id && r.RelationKind == GetReverseRelation(relation.Relation));
|
|
|
|
if (!reverseExists)
|
|
{
|
|
var reverseRelation = new SeriesRelation
|
|
{
|
|
RelationKind = GetReverseRelation(relation.Relation),
|
|
TargetSeriesId = series.Id,
|
|
SeriesId = relatedSeries.Id,
|
|
};
|
|
relatedSeries.Relations.Add(reverseRelation);
|
|
_unitOfWork.SeriesRepository.Attach(reverseRelation);
|
|
}
|
|
}
|
|
|
|
_unitOfWork.SeriesRepository.Update(series);
|
|
}
|
|
|
|
if (_unitOfWork.HasChanges())
|
|
{
|
|
await _unitOfWork.CommitAsync();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private async Task<bool> UpdateCharacters(Series series, MetadataSettingsDto settings, IList<SeriesCharacter>? externalCharacters)
|
|
{
|
|
if (!settings.EnablePeople) return false;
|
|
|
|
if (externalCharacters == null || externalCharacters.Count == 0) return false;
|
|
|
|
if (series.Metadata.CharacterLocked && !settings.HasOverride(MetadataSettingField.People))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!settings.IsPersonAllowed(PersonRole.Character))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
series.Metadata.People ??= [];
|
|
|
|
var characters = externalCharacters
|
|
.Select(w => new PersonDto()
|
|
{
|
|
Name = w.Name,
|
|
AniListId = ScrobblingService.ExtractId<int>(w.Url, ScrobblingService.AniListCharacterWebsite),
|
|
Description = StringHelper.RemoveSourceInDescription(StringHelper.SquashBreaklines(w.Description)),
|
|
})
|
|
.Concat(series.Metadata.People
|
|
.Where(p => p.Role == PersonRole.Character)
|
|
// Need to ensure existing people are retained, but we overwrite anything from a bad match
|
|
.Where(p => !p.KavitaPlusConnection)
|
|
.Select(p => _mapper.Map<PersonDto>(p.Person))
|
|
)
|
|
.DistinctBy(p => Parser.Normalize(p.Name))
|
|
.ToList();
|
|
|
|
if (characters.Count == 0) return false;
|
|
await SeriesService.HandlePeopleUpdateAsync(series.Metadata, characters, PersonRole.Character, _unitOfWork);
|
|
foreach (var spPerson in series.Metadata.People.Where(p => p.Role == PersonRole.Character))
|
|
{
|
|
// Set a sort order based on their role
|
|
var characterMeta = externalCharacters.FirstOrDefault(c => c.Name == spPerson.Person.Name);
|
|
spPerson.OrderWeight = 0;
|
|
|
|
if (characterMeta != null)
|
|
{
|
|
spPerson.KavitaPlusConnection = true;
|
|
|
|
spPerson.OrderWeight = characterMeta.Role switch
|
|
{
|
|
CharacterRole.Main => 0,
|
|
CharacterRole.Supporting => 1,
|
|
CharacterRole.Background => 2,
|
|
_ => 99 // Default for unknown roles
|
|
};
|
|
}
|
|
}
|
|
|
|
// Download the image and save it
|
|
_unitOfWork.SeriesRepository.Update(series);
|
|
await _unitOfWork.CommitAsync();
|
|
|
|
foreach (var character in externalCharacters)
|
|
{
|
|
var aniListId = ScrobblingService.ExtractId<int>(character.Url, ScrobblingService.AniListCharacterWebsite);
|
|
if (aniListId <= 0) continue;
|
|
var person = await _unitOfWork.PersonRepository.GetPersonByAniListId(aniListId);
|
|
if (person != null && !string.IsNullOrEmpty(character.ImageUrl) && string.IsNullOrEmpty(person.CoverImage))
|
|
{
|
|
await _coverDbService.SetPersonCoverByUrl(person, character.ImageUrl, false);
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
private async Task<bool> UpdateArtists(Series series, MetadataSettingsDto settings, List<SeriesStaffDto> staff)
|
|
{
|
|
if (!settings.EnablePeople) return false;
|
|
|
|
|
|
var upstreamArtists = staff
|
|
.Where(s => s.Role is "Art" or "Story & Art")
|
|
.ToList();
|
|
|
|
if (upstreamArtists.Count == 0) return false;
|
|
|
|
if (series.Metadata.CoverArtistLocked && !settings.HasOverride(MetadataSettingField.People))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!settings.IsPersonAllowed(PersonRole.CoverArtist))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
series.Metadata.People ??= [];
|
|
var artists = upstreamArtists
|
|
.Select(w => new PersonDto()
|
|
{
|
|
Name = w.Name,
|
|
AniListId = ScrobblingService.ExtractId<int>(w.Url, ScrobblingService.AniListStaffWebsite),
|
|
Description = StringHelper.RemoveSourceInDescription(StringHelper.SquashBreaklines(w.Description)),
|
|
})
|
|
.Concat(series.Metadata.People
|
|
.Where(p => p.Role == PersonRole.CoverArtist)
|
|
.Where(p => !p.KavitaPlusConnection)
|
|
.Select(p => _mapper.Map<PersonDto>(p.Person))
|
|
)
|
|
.DistinctBy(p => Parser.Normalize(p.Name))
|
|
.ToList();
|
|
|
|
await SeriesService.HandlePeopleUpdateAsync(series.Metadata, artists, PersonRole.CoverArtist, _unitOfWork);
|
|
|
|
foreach (var person in series.Metadata.People.Where(p => p.Role == PersonRole.CoverArtist))
|
|
{
|
|
var meta = upstreamArtists.FirstOrDefault(c => c.Name == person.Person.Name);
|
|
person.OrderWeight = 0;
|
|
if (meta != null)
|
|
{
|
|
person.KavitaPlusConnection = true;
|
|
}
|
|
}
|
|
|
|
// Download the image and save it
|
|
_unitOfWork.SeriesRepository.Update(series);
|
|
await _unitOfWork.CommitAsync();
|
|
|
|
await DownloadAndSetPersonCovers(upstreamArtists);
|
|
|
|
return true;
|
|
}
|
|
|
|
private async Task<bool> UpdateWriters(Series series, MetadataSettingsDto settings, List<SeriesStaffDto> staff)
|
|
{
|
|
if (!settings.EnablePeople) return false;
|
|
|
|
var upstreamWriters = staff
|
|
.Where(s => s.Role is "Story" or "Story & Art")
|
|
.ToList();
|
|
|
|
if (upstreamWriters.Count == 0) return false;
|
|
|
|
if (series.Metadata.WriterLocked && !settings.HasOverride(MetadataSettingField.People))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!settings.IsPersonAllowed(PersonRole.Writer))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
series.Metadata.People ??= [];
|
|
var writers = upstreamWriters
|
|
.Select(w => new PersonDto()
|
|
{
|
|
Name = w.Name,
|
|
AniListId = ScrobblingService.ExtractId<int>(w.Url, ScrobblingService.AniListStaffWebsite),
|
|
Description = StringHelper.RemoveSourceInDescription(StringHelper.SquashBreaklines(w.Description)),
|
|
})
|
|
.Concat(series.Metadata.People
|
|
.Where(p => p.Role == PersonRole.Writer)
|
|
.Where(p => !p.KavitaPlusConnection)
|
|
.Select(p => _mapper.Map<PersonDto>(p.Person))
|
|
)
|
|
.DistinctBy(p => Parser.Normalize(p.Name))
|
|
.ToList();
|
|
|
|
|
|
await SeriesService.HandlePeopleUpdateAsync(series.Metadata, writers, PersonRole.Writer, _unitOfWork);
|
|
|
|
foreach (var person in series.Metadata.People.Where(p => p.Role == PersonRole.Writer))
|
|
{
|
|
var meta = upstreamWriters.FirstOrDefault(c => c.Name == person.Person.Name);
|
|
person.OrderWeight = 0;
|
|
if (meta != null)
|
|
{
|
|
person.KavitaPlusConnection = true;
|
|
}
|
|
}
|
|
|
|
_unitOfWork.SeriesRepository.Update(series);
|
|
await _unitOfWork.CommitAsync();
|
|
|
|
await DownloadAndSetPersonCovers(upstreamWriters);
|
|
|
|
return true;
|
|
}
|
|
|
|
private async Task<bool> UpdateTags(Series series, MetadataSettingsDto settings, ExternalSeriesDetailDto externalMetadata, List<string> processedTags)
|
|
{
|
|
externalMetadata.Tags ??= [];
|
|
|
|
if (!settings.EnableTags || processedTags.Count == 0) return false;
|
|
|
|
if (series.Metadata.TagsLocked && !settings.HasOverride(MetadataSettingField.Tags))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_logger.LogDebug("Found {TagCount} tags for {SeriesName}", processedTags.Count, series.Name);
|
|
var madeModification = false;
|
|
var allTags = (await _unitOfWork.TagRepository.GetAllTagsByNameAsync(processedTags.Select(Parser.Normalize)))
|
|
.ToList();
|
|
series.Metadata.Tags ??= [];
|
|
|
|
TagHelper.UpdateTagList(processedTags, series, allTags, tag =>
|
|
{
|
|
series.Metadata.Tags.Add(tag);
|
|
madeModification = true;
|
|
}, () => series.Metadata.TagsLocked = true);
|
|
|
|
return madeModification;
|
|
}
|
|
|
|
private static List<string> ApplyBlackWhiteList(MetadataSettingsDto settings, MetadataFieldType fieldType, List<string> processedStrings)
|
|
{
|
|
return fieldType switch
|
|
{
|
|
MetadataFieldType.Genre => processedStrings.Distinct()
|
|
.Where(g => settings.Blacklist.Count == 0 || !settings.Blacklist.Contains(g))
|
|
.ToList(),
|
|
MetadataFieldType.Tag => processedStrings.Distinct()
|
|
.Where(g => settings.Blacklist.Count == 0 || !settings.Blacklist.Contains(g))
|
|
.Where(g => settings.Whitelist.Count == 0 || settings.Whitelist.Contains(g))
|
|
.ToList(),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(fieldType), fieldType, null)
|
|
};
|
|
}
|
|
|
|
private async Task<bool> UpdateGenres(Series series, MetadataSettingsDto settings, ExternalSeriesDetailDto externalMetadata, List<string> processedGenres)
|
|
{
|
|
externalMetadata.Genres ??= [];
|
|
|
|
if (!settings.EnableGenres || processedGenres.Count == 0) return false;
|
|
|
|
if (series.Metadata.GenresLocked && !settings.HasOverride(MetadataSettingField.Genres))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_logger.LogDebug("Found {GenreCount} genres for {SeriesName}", processedGenres.Count, series.Name);
|
|
var madeModification = false;
|
|
var allGenres = (await _unitOfWork.GenreRepository.GetAllGenresByNamesAsync(processedGenres.Select(Parser.Normalize))).ToList();
|
|
series.Metadata.Genres ??= [];
|
|
var exisitingGenres = series.Metadata.Genres;
|
|
|
|
GenreHelper.UpdateGenreList(processedGenres, series, allGenres, genre =>
|
|
{
|
|
series.Metadata.Genres.Add(genre);
|
|
madeModification = true;
|
|
}, () => series.Metadata.GenresLocked = true);
|
|
|
|
foreach (var genre in exisitingGenres)
|
|
{
|
|
if (series.Metadata.Genres.FirstOrDefault(g => g.NormalizedTitle == genre.NormalizedTitle) != null) continue;
|
|
series.Metadata.Genres.Add(genre);
|
|
}
|
|
|
|
return madeModification;
|
|
}
|
|
|
|
private async Task<bool> UpdatePublicationStatus(Series series, MetadataSettingsDto settings, ExternalSeriesDetailDto externalMetadata)
|
|
{
|
|
if (!settings.EnablePublicationStatus) return false;
|
|
|
|
if (series.Metadata.PublicationStatusLocked && !settings.HasOverride(MetadataSettingField.PublicationStatus))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
var chapters =
|
|
(await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(series.Id, SeriesIncludes.Chapters))!.Volumes
|
|
.SelectMany(v => v.Chapters).ToList();
|
|
var status = DeterminePublicationStatus(series, chapters, externalMetadata);
|
|
|
|
series.Metadata.PublicationStatus = status;
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "There was an issue determining Publication Status for Series {SeriesName} ({SeriesId})", series.Name, series.Id);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool UpdateAgeRating(Series series, MetadataSettingsDto settings, IEnumerable<string> allExternalTags)
|
|
{
|
|
|
|
if (series.Metadata.AgeRatingLocked && !settings.HasOverride(MetadataSettingField.AgeRating))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Determine Age Rating
|
|
var totalTags = allExternalTags
|
|
.Concat(series.Metadata.Genres.Select(g => g.Title))
|
|
.Concat(series.Metadata.Tags.Select(g => g.Title));
|
|
|
|
var ageRating = DetermineAgeRating(totalTags, settings.AgeRatingMappings);
|
|
if (series.Metadata.AgeRating <= ageRating)
|
|
{
|
|
series.Metadata.AgeRating = ageRating;
|
|
return true;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "There was an issue determining Age Rating for Series {SeriesName} ({SeriesId})", series.Name, series.Id);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private async Task<bool> UpdateCoverImage(Series series, MetadataSettingsDto settings, ExternalSeriesDetailDto externalMetadata)
|
|
{
|
|
if (!settings.EnableCoverImage) return false;
|
|
|
|
if (string.IsNullOrEmpty(externalMetadata.CoverUrl)) return false;
|
|
|
|
if (series.CoverImageLocked && !settings.HasOverride(MetadataSettingField.Covers))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(externalMetadata.CoverUrl))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
await DownloadSeriesCovers(series, externalMetadata.CoverUrl);
|
|
return true;
|
|
}
|
|
|
|
|
|
private static bool UpdateReleaseYear(Series series, MetadataSettingsDto settings, ExternalSeriesDetailDto externalMetadata)
|
|
{
|
|
if (!settings.EnableStartDate) return false;
|
|
|
|
if (!externalMetadata.StartDate.HasValue) return false;
|
|
|
|
if (series.Metadata.ReleaseYearLocked && !settings.HasOverride(MetadataSettingField.StartDate))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (series.Metadata.ReleaseYear != 0 && !settings.HasOverride(MetadataSettingField.StartDate))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
series.Metadata.ReleaseYear = externalMetadata.StartDate.Value.Year;
|
|
return true;
|
|
}
|
|
|
|
private static bool UpdateLocalizedName(Series series, MetadataSettingsDto settings, ExternalSeriesDetailDto externalMetadata)
|
|
{
|
|
if (!settings.EnableLocalizedName) return false;
|
|
|
|
if (series.LocalizedNameLocked && !settings.HasOverride(MetadataSettingField.LocalizedName))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(series.LocalizedName) && !settings.HasOverride(MetadataSettingField.LocalizedName))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// We need to make the best appropriate guess
|
|
if (externalMetadata.Name == series.Name)
|
|
{
|
|
// Choose closest (usually last) synonym
|
|
var validSynonyms = externalMetadata.Synonyms
|
|
.Where(IsRomanCharacters)
|
|
.Where(s => s.ToNormalized() != series.Name.ToNormalized())
|
|
.ToList();
|
|
|
|
if (validSynonyms.Count == 0) return false;
|
|
|
|
series.LocalizedName = validSynonyms[^1];
|
|
series.LocalizedNameLocked = true;
|
|
}
|
|
else if (IsRomanCharacters(externalMetadata.Name))
|
|
{
|
|
series.LocalizedName = externalMetadata.Name;
|
|
series.LocalizedNameLocked = true;
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
private static bool UpdateSummary(Series series, MetadataSettingsDto settings, ExternalSeriesDetailDto externalMetadata)
|
|
{
|
|
if (!settings.EnableSummary) return false;
|
|
|
|
if (string.IsNullOrEmpty(externalMetadata.Summary)) return false;
|
|
|
|
if (series.Metadata.SummaryLocked && !settings.HasOverride(MetadataSettingField.Summary))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(series.Metadata.Summary) && !settings.HasOverride(MetadataSettingField.Summary))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
series.Metadata.Summary = StringHelper.RemoveSourceInDescription(StringHelper.SquashBreaklines(externalMetadata.Summary));
|
|
return true;
|
|
}
|
|
|
|
|
|
private static RelationKind GetReverseRelation(RelationKind relation)
|
|
{
|
|
return relation switch
|
|
{
|
|
RelationKind.Prequel => RelationKind.Sequel,
|
|
RelationKind.Sequel => RelationKind.Prequel,
|
|
_ => relation // For other relationships, no reverse needed
|
|
};
|
|
}
|
|
|
|
private async Task DownloadSeriesCovers(Series series, string coverUrl)
|
|
{
|
|
try
|
|
{
|
|
await _coverDbService.SetSeriesCoverByUrl(series, coverUrl, false, true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "There was an exception downloading cover image for Series {SeriesName} ({SeriesId})", series.Name, series.Id);
|
|
}
|
|
}
|
|
|
|
private async Task DownloadAndSetPersonCovers(List<SeriesStaffDto> people)
|
|
{
|
|
foreach (var staff in people)
|
|
{
|
|
var aniListId = ScrobblingService.ExtractId<int?>(staff.Url, ScrobblingService.AniListStaffWebsite);
|
|
if (aniListId is null or <= 0) continue;
|
|
var person = await _unitOfWork.PersonRepository.GetPersonByAniListId(aniListId.Value);
|
|
if (person == null || string.IsNullOrEmpty(staff.ImageUrl) ||
|
|
!string.IsNullOrEmpty(person.CoverImage) || staff.ImageUrl.EndsWith("default.jpg")) continue;
|
|
|
|
try
|
|
{
|
|
await _coverDbService.SetPersonCoverByUrl(person, staff.ImageUrl, false, true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "There was an exception saving cover image for Person {PersonName} ({PersonId})", person.Name, person.Id);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private PublicationStatus DeterminePublicationStatus(Series series, List<Chapter> chapters, ExternalSeriesDetailDto externalMetadata)
|
|
{
|
|
try
|
|
{
|
|
// Determine the expected total count based on local metadata
|
|
series.Metadata.TotalCount = Math.Max(
|
|
chapters.Max(chapter => chapter.TotalCount),
|
|
externalMetadata.Volumes > 0 ? externalMetadata.Volumes : externalMetadata.Chapters
|
|
);
|
|
|
|
// The actual number of count's defined across all chapter's metadata
|
|
series.Metadata.MaxCount = chapters.Max(chapter => chapter.Count);
|
|
|
|
var nonSpecialVolumes = series.Volumes
|
|
.Where(v => v.MaxNumber.IsNot(Parser.SpecialVolumeNumber))
|
|
.ToList();
|
|
|
|
var maxVolume = (int)(nonSpecialVolumes.Count != 0 ? nonSpecialVolumes.Max(v => v.MaxNumber) : 0);
|
|
var maxChapter = (int)chapters.Max(c => c.MaxNumber);
|
|
|
|
if (series.Format == MangaFormat.Epub || series.Format == MangaFormat.Pdf && chapters.Count == 1)
|
|
{
|
|
series.Metadata.MaxCount = 1;
|
|
}
|
|
else if (series.Metadata.TotalCount <= 1 && chapters.Count == 1 && chapters[0].IsSpecial)
|
|
{
|
|
series.Metadata.MaxCount = series.Metadata.TotalCount;
|
|
}
|
|
else if ((maxChapter == Parser.DefaultChapterNumber || maxChapter > series.Metadata.TotalCount) &&
|
|
maxVolume <= series.Metadata.TotalCount)
|
|
{
|
|
series.Metadata.MaxCount = maxVolume;
|
|
}
|
|
else if (maxVolume == series.Metadata.TotalCount)
|
|
{
|
|
series.Metadata.MaxCount = maxVolume;
|
|
}
|
|
else
|
|
{
|
|
series.Metadata.MaxCount = maxChapter;
|
|
}
|
|
|
|
var status = PublicationStatus.OnGoing;
|
|
|
|
var hasExternalCounts = externalMetadata.Volumes > 0 || externalMetadata.Chapters > 0;
|
|
|
|
if (hasExternalCounts)
|
|
{
|
|
status = PublicationStatus.Ended;
|
|
|
|
// Check if all volumes/chapters match the total count
|
|
if (series.Metadata.MaxCount == series.Metadata.TotalCount && series.Metadata.TotalCount > 0)
|
|
{
|
|
status = PublicationStatus.Completed;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogCritical(ex, "There was an issue determining Publication Status");
|
|
}
|
|
|
|
return PublicationStatus.OnGoing;
|
|
}
|
|
|
|
private static Dictionary<MetadataFieldType, List<string>> ApplyFieldMappings(IEnumerable<string> values, MetadataFieldType sourceType, List<MetadataFieldMappingDto> mappings)
|
|
{
|
|
var result = new Dictionary<MetadataFieldType, List<string>>();
|
|
|
|
foreach (var field in Enum.GetValues<MetadataFieldType>())
|
|
{
|
|
result[field] = [];
|
|
}
|
|
|
|
foreach (var value in values)
|
|
{
|
|
var mapping = mappings.FirstOrDefault(m =>
|
|
m.SourceType == sourceType &&
|
|
m.SourceValue.Equals(value, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (mapping != null && !string.IsNullOrWhiteSpace(mapping.DestinationValue))
|
|
{
|
|
var targetType = mapping.DestinationType;
|
|
|
|
if (!mapping.ExcludeFromSource)
|
|
{
|
|
result[sourceType].Add(mapping.SourceValue);
|
|
}
|
|
|
|
result[targetType].Add(mapping.DestinationValue);
|
|
}
|
|
else
|
|
{
|
|
// If no mapping, keep the original value
|
|
result[sourceType].Add(value);
|
|
}
|
|
}
|
|
|
|
// Ensure distinct
|
|
foreach (var key in result.Keys)
|
|
{
|
|
result[key] = result[key].Distinct().ToList();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns the highest age rating from all tags/genres based on user-supplied mappings
|
|
/// </summary>
|
|
/// <param name="values">A combo of all tags/genres</param>
|
|
/// <param name="mappings"></param>
|
|
/// <returns></returns>
|
|
public static AgeRating DetermineAgeRating(IEnumerable<string> values, Dictionary<string, AgeRating> mappings)
|
|
{
|
|
// Find highest age rating from mappings
|
|
mappings ??= new Dictionary<string, AgeRating>();
|
|
|
|
return values
|
|
.Select(v => mappings.TryGetValue(v, out var mapping) ? mapping : AgeRating.Unknown)
|
|
.DefaultIfEmpty(AgeRating.Unknown)
|
|
.Max();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Gets from DB or creates a new one with just SeriesId
|
|
/// </summary>
|
|
/// <param name="seriesId"></param>
|
|
/// <param name="series"></param>
|
|
/// <returns></returns>
|
|
private async Task<ExternalSeriesMetadata> GetOrCreateExternalSeriesMetadataForSeries(int seriesId, Series series)
|
|
{
|
|
var externalSeriesMetadata = await _unitOfWork.ExternalSeriesMetadataRepository.GetExternalSeriesMetadata(seriesId);
|
|
if (externalSeriesMetadata != null) return externalSeriesMetadata;
|
|
|
|
externalSeriesMetadata = new ExternalSeriesMetadata()
|
|
{
|
|
SeriesId = seriesId,
|
|
};
|
|
series.ExternalSeriesMetadata = externalSeriesMetadata;
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Attach(externalSeriesMetadata);
|
|
|
|
return externalSeriesMetadata;
|
|
}
|
|
|
|
private async Task<RecommendationDto> ProcessRecommendations(LibraryType libraryType, IEnumerable<MediaRecommendationDto> recs,
|
|
ExternalSeriesMetadata externalSeriesMetadata)
|
|
{
|
|
var recDto = new RecommendationDto()
|
|
{
|
|
ExternalSeries = new List<ExternalSeriesDto>(),
|
|
OwnedSeries = new List<SeriesDto>()
|
|
};
|
|
|
|
// NOTE: This can result in a series being recommended that shares the same name but different format
|
|
foreach (var rec in recs)
|
|
{
|
|
// Find the series based on name and type and that the user has access too
|
|
var seriesForRec = await _unitOfWork.SeriesRepository.GetSeriesDtoByNamesAndMetadataIds(rec.RecommendationNames,
|
|
libraryType, ScrobblingService.CreateUrl(ScrobblingService.AniListWeblinkWebsite, rec.AniListId),
|
|
ScrobblingService.CreateUrl(ScrobblingService.MalWeblinkWebsite, rec.MalId));
|
|
|
|
if (seriesForRec != null)
|
|
{
|
|
recDto.OwnedSeries.Add(seriesForRec);
|
|
externalSeriesMetadata.ExternalRecommendations.Add(new ExternalRecommendation()
|
|
{
|
|
SeriesId = seriesForRec.Id,
|
|
AniListId = rec.AniListId,
|
|
MalId = rec.MalId,
|
|
Name = seriesForRec.Name,
|
|
Url = rec.SiteUrl,
|
|
CoverUrl = rec.CoverUrl,
|
|
Summary = rec.Summary,
|
|
Provider = rec.Provider
|
|
});
|
|
continue;
|
|
}
|
|
|
|
// We can show this based on user permissions
|
|
if (string.IsNullOrEmpty(rec.Name) || string.IsNullOrEmpty(rec.SiteUrl) || string.IsNullOrEmpty(rec.CoverUrl)) continue;
|
|
recDto.ExternalSeries.Add(new ExternalSeriesDto()
|
|
{
|
|
Name = string.IsNullOrEmpty(rec.Name) ? rec.RecommendationNames.First() : rec.Name,
|
|
Url = rec.SiteUrl,
|
|
CoverUrl = rec.CoverUrl,
|
|
Summary = rec.Summary,
|
|
AniListId = rec.AniListId,
|
|
MalId = rec.MalId
|
|
});
|
|
externalSeriesMetadata.ExternalRecommendations.Add(new ExternalRecommendation()
|
|
{
|
|
SeriesId = null,
|
|
AniListId = rec.AniListId,
|
|
MalId = rec.MalId,
|
|
Name = rec.Name,
|
|
Url = rec.SiteUrl,
|
|
CoverUrl = rec.CoverUrl,
|
|
Summary = rec.Summary,
|
|
Provider = rec.Provider
|
|
});
|
|
}
|
|
|
|
recDto.OwnedSeries = recDto.OwnedSeries.DistinctBy(s => s.Id).OrderBy(r => r.Name).ToList();
|
|
recDto.ExternalSeries = recDto.ExternalSeries.DistinctBy(s => s.Name.ToNormalized()).OrderBy(r => r.Name).ToList();
|
|
|
|
return recDto;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// This is to get series information for the recommendation drawer on Kavita
|
|
/// </summary>
|
|
/// <remarks>This uses a different API that series detail</remarks>
|
|
/// <param name="license"></param>
|
|
/// <param name="aniListId"></param>
|
|
/// <param name="malId"></param>
|
|
/// <param name="seriesId"></param>
|
|
/// <returns></returns>
|
|
private async Task<ExternalSeriesDetailDto?> GetSeriesDetail(string license, int? aniListId, long? malId, int? seriesId)
|
|
{
|
|
var payload = new ExternalMetadataIdsDto()
|
|
{
|
|
AniListId = aniListId,
|
|
MalId = malId,
|
|
SeriesName = string.Empty,
|
|
LocalizedSeriesName = string.Empty
|
|
};
|
|
|
|
if (seriesId is > 0)
|
|
{
|
|
var series = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId.Value,
|
|
SeriesIncludes.Metadata | SeriesIncludes.Library | SeriesIncludes.ExternalReviews);
|
|
if (series != null)
|
|
{
|
|
if (payload.AniListId <= 0)
|
|
{
|
|
payload.AniListId = ScrobblingService.ExtractId<int>(series.Metadata.WebLinks, ScrobblingService.AniListWeblinkWebsite);
|
|
}
|
|
if (payload.MalId <= 0)
|
|
{
|
|
payload.MalId = ScrobblingService.ExtractId<long>(series.Metadata.WebLinks, ScrobblingService.MalWeblinkWebsite);
|
|
}
|
|
payload.SeriesName = series.Name;
|
|
payload.LocalizedSeriesName = series.LocalizedName;
|
|
payload.PlusMediaFormat = series.Library.Type.ConvertToPlusMediaFormat(series.Format);
|
|
}
|
|
|
|
}
|
|
try
|
|
{
|
|
var token = (await _unitOfWork.UserRepository.GetDefaultAdminUser()).AniListAccessToken;
|
|
var ret = await (Configuration.KavitaPlusApiUrl + "/api/metadata/v2/series-by-ids")
|
|
.WithKavitaPlusHeaders(license, token)
|
|
.PostJsonAsync(payload)
|
|
.ReceiveJson<ExternalSeriesDetailDto>();
|
|
|
|
ret.Summary = StringHelper.RemoveSourceInDescription(StringHelper.SquashBreaklines(ret.Summary));
|
|
|
|
return ret;
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_logger.LogError(e, "An error happened during the request to Kavita+ API");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|