mirror of
https://github.com/Kareadita/Kavita.git
synced 2025-05-31 20:24:27 -04:00
332 lines
13 KiB
C#
332 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using API.Data;
|
|
using API.Data.Repositories;
|
|
using API.DTOs;
|
|
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.Extensions;
|
|
using API.Helpers.Builders;
|
|
using AutoMapper;
|
|
using Flurl.Http;
|
|
using Kavita.Common;
|
|
using Kavita.Common.EnvironmentInfo;
|
|
using Kavita.Common.Helpers;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace API.Services.Plus;
|
|
#nullable enable
|
|
|
|
/// <summary>
|
|
/// Used for matching and fetching metadata on a series
|
|
/// </summary>
|
|
internal class ExternalMetadataIdsDto
|
|
{
|
|
public long? MalId { get; set; }
|
|
public int? AniListId { get; set; }
|
|
|
|
public string? SeriesName { get; set; }
|
|
public string? LocalizedSeriesName { get; set; }
|
|
public MediaFormat? PlusMediaFormat { get; set; } = MediaFormat.Unknown;
|
|
}
|
|
|
|
internal class SeriesDetailPlusApiDto
|
|
{
|
|
public IEnumerable<MediaRecommendationDto> Recommendations { get; set; }
|
|
public IEnumerable<UserReviewDto> Reviews { get; set; }
|
|
public IEnumerable<RatingDto> Ratings { get; set; }
|
|
public int? AniListId { get; set; }
|
|
public long? MalId { get; set; }
|
|
}
|
|
|
|
public interface IExternalMetadataService
|
|
{
|
|
Task<ExternalSeriesDetailDto?> GetExternalSeriesDetail(int? aniListId, long? malId, int? seriesId);
|
|
Task<SeriesDetailPlusDto?> GetSeriesDetail(int userId, int seriesId);
|
|
}
|
|
|
|
public class ExternalMetadataService : IExternalMetadataService
|
|
{
|
|
private readonly IUnitOfWork _unitOfWork;
|
|
private readonly ILogger<ExternalMetadataService> _logger;
|
|
private readonly IMapper _mapper;
|
|
private readonly TimeSpan _externalSeriesMetadataCache = TimeSpan.FromDays(14);
|
|
|
|
public ExternalMetadataService(IUnitOfWork unitOfWork, ILogger<ExternalMetadataService> logger, IMapper mapper)
|
|
{
|
|
_unitOfWork = unitOfWork;
|
|
_logger = logger;
|
|
_mapper = mapper;
|
|
|
|
FlurlHttp.ConfigureClient(Configuration.KavitaPlusApiUrl, cli =>
|
|
cli.Settings.HttpClientFactory = new UntrustedCertClientFactory());
|
|
}
|
|
|
|
/// <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;
|
|
|
|
}
|
|
|
|
public async Task<SeriesDetailPlusDto?> GetSeriesDetail(int userId, int seriesId)
|
|
{
|
|
var series =
|
|
await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(seriesId,
|
|
SeriesIncludes.Metadata | SeriesIncludes.Library | SeriesIncludes.Volumes | SeriesIncludes.Chapters);
|
|
if (series == null || series.Library.Type == LibraryType.Comic) return null;
|
|
var user = await _unitOfWork.UserRepository.GetUserByIdAsync(userId);
|
|
if (user == null) return null;
|
|
|
|
var needsRefresh =
|
|
await _unitOfWork.ExternalSeriesMetadataRepository.ExternalSeriesMetadataNeedsRefresh(seriesId,
|
|
DateTime.UtcNow.Subtract(_externalSeriesMetadataCache));
|
|
|
|
if (!needsRefresh)
|
|
{
|
|
// Convert into DTOs and return
|
|
return await _unitOfWork.ExternalSeriesMetadataRepository.GetSeriesDetailPlusDto(seriesId, series.LibraryId, user);
|
|
}
|
|
|
|
try
|
|
{
|
|
var license = (await _unitOfWork.SettingsRepository.GetSettingAsync(ServerSettingKey.LicenseKey)).Value;
|
|
var result = await (Configuration.KavitaPlusApiUrl + "/api/metadata/v2/series-detail")
|
|
.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))
|
|
.PostJsonAsync(new PlusSeriesDtoBuilder(series).Build())
|
|
.ReceiveJson<SeriesDetailPlusApiDto>();
|
|
|
|
|
|
// Clear out existing results
|
|
var externalSeriesMetadata = await GetExternalSeriesMetadataForSeries(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 ??= new List<ExternalRecommendation>();
|
|
var recs = await ProcessRecommendations(series, user, result.Recommendations, externalSeriesMetadata);
|
|
|
|
var extRatings = externalSeriesMetadata.ExternalRatings
|
|
.Where(r => r.AverageScore > 0)
|
|
.ToList();
|
|
|
|
externalSeriesMetadata.LastUpdatedUtc = DateTime.UtcNow;
|
|
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;
|
|
|
|
await _unitOfWork.CommitAsync();
|
|
|
|
return new SeriesDetailPlusDto()
|
|
{
|
|
Recommendations = recs,
|
|
Ratings = result.Ratings,
|
|
Reviews = externalSeriesMetadata.ExternalReviews.Select(r => _mapper.Map<UserReviewDto>(r))
|
|
};
|
|
}
|
|
catch (FlurlHttpException ex)
|
|
{
|
|
if (ex.StatusCode == 404)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "An error happened during the request to Kavita+ API");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
private async Task<ExternalSeriesMetadata> GetExternalSeriesMetadataForSeries(int seriesId, Series series)
|
|
{
|
|
var externalSeriesMetadata = await _unitOfWork.ExternalSeriesMetadataRepository.GetExternalSeriesMetadata(seriesId);
|
|
if (externalSeriesMetadata == null)
|
|
{
|
|
externalSeriesMetadata = new ExternalSeriesMetadata();
|
|
series.ExternalSeriesMetadata = externalSeriesMetadata;
|
|
externalSeriesMetadata.SeriesId = series.Id;
|
|
_unitOfWork.ExternalSeriesMetadataRepository.Attach(externalSeriesMetadata);
|
|
}
|
|
|
|
return externalSeriesMetadata;
|
|
}
|
|
|
|
private async Task<RecommendationDto> ProcessRecommendations(Series series, AppUser user, 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.GetSeriesDtoByNamesAndMetadataIdsForUser(user.Id, rec.RecommendationNames,
|
|
series.Library.Type, 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
|
|
});
|
|
}
|
|
|
|
await _unitOfWork.SeriesRepository.AddSeriesModifiers(user.Id, recDto.OwnedSeries);
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
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 = ConvertToMediaFormat(series.Library.Type, series.Format);
|
|
}
|
|
|
|
}
|
|
try
|
|
{
|
|
return await (Configuration.KavitaPlusApiUrl + "/api/metadata/v2/series-by-ids")
|
|
.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))
|
|
.PostJsonAsync(payload)
|
|
.ReceiveJson<ExternalSeriesDetailDto>();
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_logger.LogError(e, "An error happened during the request to Kavita+ API");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static MediaFormat ConvertToMediaFormat(LibraryType libraryType, MangaFormat seriesFormat)
|
|
{
|
|
return libraryType switch
|
|
{
|
|
LibraryType.Manga => seriesFormat == MangaFormat.Epub ? MediaFormat.LightNovel : MediaFormat.Manga,
|
|
LibraryType.Comic => MediaFormat.Comic,
|
|
LibraryType.Book => MediaFormat.Book,
|
|
_ => MediaFormat.Unknown
|
|
};
|
|
}
|
|
}
|