692 lines
27 KiB
C#
692 lines
27 KiB
C#
using Jellyfin.Plugin.MetaShark.Configuration;
|
|
using Microsoft.Extensions.Caching.Memory;
|
|
using Microsoft.Extensions.Logging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using TMDbLib.Client;
|
|
using TMDbLib.Objects.Collections;
|
|
using TMDbLib.Objects.Find;
|
|
using TMDbLib.Objects.General;
|
|
using TMDbLib.Objects.Movies;
|
|
using TMDbLib.Objects.People;
|
|
using TMDbLib.Objects.Search;
|
|
using TMDbLib.Objects.TvShows;
|
|
|
|
namespace Jellyfin.Plugin.MetaShark.Api
|
|
{
|
|
public class TmdbApi : IDisposable
|
|
{
|
|
public const string DEFAULT_API_KEY = "4219e299c89411838049ab0dab19ebd5";
|
|
public const string DEFAULT_API_HOST = "api.tmdb.org";
|
|
private const int CacheDurationInHours = 1;
|
|
private readonly ILogger<TmdbApi> _logger;
|
|
private readonly IMemoryCache _memoryCache;
|
|
private readonly TMDbClient _tmDbClient;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="TmdbApi"/> class.
|
|
/// </summary>
|
|
public TmdbApi(ILoggerFactory loggerFactory)
|
|
{
|
|
_logger = loggerFactory.CreateLogger<TmdbApi>();
|
|
_memoryCache = new MemoryCache(new MemoryCacheOptions());
|
|
var config = Plugin.Instance?.Configuration;
|
|
var apiKey = string.IsNullOrEmpty(config?.TmdbApiKey) ? DEFAULT_API_KEY : config.TmdbApiKey;
|
|
var host = string.IsNullOrEmpty(config?.TmdbHost) ? DEFAULT_API_HOST : config.TmdbHost;
|
|
_tmDbClient = new TMDbClient(apiKey, true, host);
|
|
_tmDbClient.Timeout = TimeSpan.FromSeconds(10);
|
|
// Not really interested in NotFoundException
|
|
_tmDbClient.ThrowApiExceptions = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a movie from the TMDb API based on its TMDb id.
|
|
/// </summary>
|
|
/// <param name="tmdbId">The movie's TMDb id.</param>
|
|
/// <param name="language">The movie's language.</param>
|
|
/// <param name="imageLanguages">A comma-separated list of image languages.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb movie or null if not found.</returns>
|
|
public async Task<Movie?> GetMovieAsync(int tmdbId, string language, string imageLanguages, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var key = $"movie-{tmdbId.ToString(CultureInfo.InvariantCulture)}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out Movie movie))
|
|
{
|
|
return movie;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
movie = await _tmDbClient.GetMovieAsync(
|
|
tmdbId,
|
|
NormalizeLanguage(language),
|
|
GetImageLanguagesParam(imageLanguages),
|
|
MovieMethods.Credits | MovieMethods.Releases | MovieMethods.Images | MovieMethods.Keywords | MovieMethods.Videos,
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
if (movie != null)
|
|
{
|
|
_memoryCache.Set(key, movie, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return movie;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection from the TMDb API based on its TMDb id.
|
|
/// </summary>
|
|
/// <param name="tmdbId">The collection's TMDb id.</param>
|
|
/// <param name="language">The collection's language.</param>
|
|
/// <param name="imageLanguages">A comma-separated list of image languages.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb collection or null if not found.</returns>
|
|
public async Task<Collection?> GetCollectionAsync(int tmdbId, string language, string imageLanguages, CancellationToken cancellationToken)
|
|
{
|
|
var key = $"collection-{tmdbId.ToString(CultureInfo.InvariantCulture)}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out Collection collection))
|
|
{
|
|
return collection;
|
|
}
|
|
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
collection = await _tmDbClient.GetCollectionAsync(
|
|
tmdbId,
|
|
NormalizeLanguage(language),
|
|
imageLanguages,
|
|
CollectionMethods.Images,
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
if (collection != null)
|
|
{
|
|
_memoryCache.Set(key, collection, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return collection;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a tv show from the TMDb API based on its TMDb id.
|
|
/// </summary>
|
|
/// <param name="tmdbId">The tv show's TMDb id.</param>
|
|
/// <param name="language">The tv show's language.</param>
|
|
/// <param name="imageLanguages">A comma-separated list of image languages.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb tv show information or null if not found.</returns>
|
|
public async Task<TvShow?> GetSeriesAsync(int tmdbId, string language, string imageLanguages, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var key = $"series-{tmdbId.ToString(CultureInfo.InvariantCulture)}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out TvShow series))
|
|
{
|
|
return series;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
series = await _tmDbClient.GetTvShowAsync(
|
|
tmdbId,
|
|
language: NormalizeLanguage(language),
|
|
includeImageLanguage: GetImageLanguagesParam(imageLanguages),
|
|
extraMethods: TvShowMethods.Credits | TvShowMethods.Images | TvShowMethods.Keywords | TvShowMethods.ExternalIds | TvShowMethods.Videos | TvShowMethods.ContentRatings,
|
|
cancellationToken: cancellationToken).ConfigureAwait(false);
|
|
|
|
if (series != null)
|
|
{
|
|
_memoryCache.Set(key, series, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return series;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a tv season from the TMDb API based on the tv show's TMDb id.
|
|
/// </summary>
|
|
/// <param name="tvShowId">The tv season's TMDb id.</param>
|
|
/// <param name="seasonNumber">The season number.</param>
|
|
/// <param name="language">The tv season's language.</param>
|
|
/// <param name="imageLanguages">A comma-separated list of image languages.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb tv season information or null if not found.</returns>
|
|
public async Task<TvSeason?> GetSeasonAsync(int tvShowId, int seasonNumber, string language, string imageLanguages, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var key = $"season-{tvShowId.ToString(CultureInfo.InvariantCulture)}-s{seasonNumber.ToString(CultureInfo.InvariantCulture)}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out TvSeason season))
|
|
{
|
|
return season;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
season = await _tmDbClient.GetTvSeasonAsync(
|
|
tvShowId,
|
|
seasonNumber,
|
|
language: NormalizeLanguage(language),
|
|
includeImageLanguage: GetImageLanguagesParam(imageLanguages),
|
|
extraMethods: TvSeasonMethods.Credits | TvSeasonMethods.Images | TvSeasonMethods.ExternalIds | TvSeasonMethods.Videos,
|
|
cancellationToken: cancellationToken).ConfigureAwait(false);
|
|
|
|
_memoryCache.Set(key, season, TimeSpan.FromHours(CacheDurationInHours));
|
|
return season;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// 可能网络有问题，缓存一下避免频繁请求
|
|
_memoryCache.Set(key, season, TimeSpan.FromSeconds(30));
|
|
this._logger.LogError(ex, ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a movie from the TMDb API based on the tv show's TMDb id.
|
|
/// </summary>
|
|
/// <param name="tvShowId">The tv show's TMDb id.</param>
|
|
/// <param name="seasonNumber">The season number.</param>
|
|
/// <param name="episodeNumber">The episode number.</param>
|
|
/// <param name="language">The episode's language.</param>
|
|
/// <param name="imageLanguages">A comma-separated list of image languages.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb tv episode information or null if not found.</returns>
|
|
public async Task<TvEpisode?> GetEpisodeAsync(int tvShowId, int seasonNumber, int episodeNumber, string language, string imageLanguages, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var key = $"episode-{tvShowId.ToString(CultureInfo.InvariantCulture)}-s{seasonNumber.ToString(CultureInfo.InvariantCulture)}e{episodeNumber.ToString(CultureInfo.InvariantCulture)}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out TvEpisode episode))
|
|
{
|
|
return episode;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
episode = await _tmDbClient.GetTvEpisodeAsync(
|
|
tvShowId,
|
|
seasonNumber,
|
|
episodeNumber,
|
|
language: NormalizeLanguage(language),
|
|
includeImageLanguage: GetImageLanguagesParam(imageLanguages),
|
|
extraMethods: TvEpisodeMethods.Credits | TvEpisodeMethods.Images | TvEpisodeMethods.ExternalIds | TvEpisodeMethods.Videos,
|
|
cancellationToken: cancellationToken).ConfigureAwait(false);
|
|
|
|
if (episode != null)
|
|
{
|
|
_memoryCache.Set(key, episode, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return episode;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a person eg. cast or crew member from the TMDb API based on its TMDb id.
|
|
/// </summary>
|
|
/// <param name="personTmdbId">The person's TMDb id.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb person information or null if not found.</returns>
|
|
public async Task<Person?> GetPersonAsync(int personTmdbId, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var key = $"person-{personTmdbId.ToString(CultureInfo.InvariantCulture)}";
|
|
if (_memoryCache.TryGetValue(key, out Person person))
|
|
{
|
|
return person;
|
|
}
|
|
|
|
try
|
|
{
|
|
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
person = await _tmDbClient.GetPersonAsync(
|
|
personTmdbId,
|
|
PersonMethods.TvCredits | PersonMethods.MovieCredits | PersonMethods.Images | PersonMethods.ExternalIds,
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
if (person != null)
|
|
{
|
|
_memoryCache.Set(key, person, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return person;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an item from the TMDb API based on its id from an external service eg. IMDb id, TvDb id.
|
|
/// </summary>
|
|
/// <param name="externalId">The item's external id.</param>
|
|
/// <param name="source">The source of the id eg. IMDb.</param>
|
|
/// <param name="language">The item's language.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb item or null if not found.</returns>
|
|
public async Task<FindContainer?> FindByExternalIdAsync(
|
|
string externalId,
|
|
FindExternalSource source,
|
|
string language,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var key = $"find-{source.ToString()}-{externalId.ToString(CultureInfo.InvariantCulture)}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out FindContainer result))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
result = await _tmDbClient.FindAsync(
|
|
source,
|
|
externalId,
|
|
NormalizeLanguage(language),
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
if (result != null)
|
|
{
|
|
_memoryCache.Set(key, result, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Searches for a tv show using the TMDb API based on its name.
|
|
/// </summary>
|
|
/// <param name="name">The name of the tv show.</param>
|
|
/// <param name="language">The tv show's language.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb tv show information.</returns>
|
|
public async Task<IReadOnlyList<SearchTv>> SearchSeriesAsync(string name, string language, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return new List<SearchTv>();
|
|
}
|
|
|
|
var key = $"searchseries-{name}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out SearchContainer<SearchTv> series))
|
|
{
|
|
return series.Results;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
var searchResults = await _tmDbClient
|
|
.SearchTvShowAsync(name, NormalizeLanguage(language), cancellationToken: cancellationToken)
|
|
.ConfigureAwait(false);
|
|
|
|
if (searchResults.Results.Count > 0)
|
|
{
|
|
_memoryCache.Set(key, searchResults, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return searchResults.Results;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new List<SearchTv>();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Searches for a person based on their name using the TMDb API.
|
|
/// </summary>
|
|
/// <param name="name">The name of the person.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb person information.</returns>
|
|
public async Task<IReadOnlyList<SearchPerson>> SearchPersonAsync(string name, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return new List<SearchPerson>();
|
|
}
|
|
|
|
var key = $"searchperson-{name}";
|
|
if (_memoryCache.TryGetValue(key, out SearchContainer<SearchPerson> person))
|
|
{
|
|
return person.Results;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
var searchResults = await _tmDbClient
|
|
.SearchPersonAsync(name, cancellationToken: cancellationToken)
|
|
.ConfigureAwait(false);
|
|
|
|
if (searchResults.Results.Count > 0)
|
|
{
|
|
_memoryCache.Set(key, searchResults, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return searchResults.Results;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return new List<SearchPerson>();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Searches for a movie based on its name using the TMDb API.
|
|
/// </summary>
|
|
/// <param name="name">The name of the movie.</param>
|
|
/// <param name="language">The movie's language.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb movie information.</returns>
|
|
public Task<IReadOnlyList<SearchMovie>> SearchMovieAsync(string name, string language, CancellationToken cancellationToken)
|
|
{
|
|
return SearchMovieAsync(name, 0, language, cancellationToken);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Searches for a movie based on its name using the TMDb API.
|
|
/// </summary>
|
|
/// <param name="name">The name of the movie.</param>
|
|
/// <param name="year">The release year of the movie.</param>
|
|
/// <param name="language">The movie's language.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb movie information.</returns>
|
|
public async Task<IReadOnlyList<SearchMovie>> SearchMovieAsync(string name, int year, string language, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return new List<SearchMovie>();
|
|
}
|
|
|
|
var key = $"moviesearch-{name}-{year.ToString(CultureInfo.InvariantCulture)}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out SearchContainer<SearchMovie> movies))
|
|
{
|
|
return movies.Results;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
var searchResults = await _tmDbClient
|
|
.SearchMovieAsync(name, NormalizeLanguage(language), year: year, cancellationToken: cancellationToken)
|
|
.ConfigureAwait(false);
|
|
|
|
if (searchResults.Results.Count > 0)
|
|
{
|
|
_memoryCache.Set(key, searchResults, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return searchResults.Results;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return new List<SearchMovie>();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Searches for a collection based on its name using the TMDb API.
|
|
/// </summary>
|
|
/// <param name="name">The name of the collection.</param>
|
|
/// <param name="language">The collection's language.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>The TMDb collection information.</returns>
|
|
public async Task<IReadOnlyList<SearchCollection>> SearchCollectionAsync(string name, string language, CancellationToken cancellationToken)
|
|
{
|
|
if (!this.IsEnable())
|
|
{
|
|
return new List<SearchCollection>();
|
|
}
|
|
|
|
var key = $"collectionsearch-{name}-{language}";
|
|
if (_memoryCache.TryGetValue(key, out SearchContainer<SearchCollection> collections))
|
|
{
|
|
return collections.Results;
|
|
}
|
|
|
|
try
|
|
{
|
|
await EnsureClientConfigAsync().ConfigureAwait(false);
|
|
|
|
var searchResults = await _tmDbClient
|
|
.SearchCollectionAsync(name, NormalizeLanguage(language), cancellationToken: cancellationToken)
|
|
.ConfigureAwait(false);
|
|
|
|
if (searchResults.Results.Count > 0)
|
|
{
|
|
_memoryCache.Set(key, searchResults, TimeSpan.FromHours(CacheDurationInHours));
|
|
}
|
|
|
|
return searchResults.Results;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this._logger.LogError(ex, ex.Message);
|
|
return new List<SearchCollection>();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the absolute URL of the poster.
|
|
/// </summary>
|
|
/// <param name="posterPath">The relative URL of the poster.</param>
|
|
/// <returns>The absolute URL.</returns>
|
|
public string? GetPosterUrl(string posterPath)
|
|
{
|
|
if (string.IsNullOrEmpty(posterPath))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return _tmDbClient.GetImageUrl(_tmDbClient.Config.Images.PosterSizes[^1], posterPath).ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the absolute URL of the backdrop image.
|
|
/// </summary>
|
|
/// <param name="posterPath">The relative URL of the backdrop image.</param>
|
|
/// <returns>The absolute URL.</returns>
|
|
public string? GetBackdropUrl(string posterPath)
|
|
{
|
|
if (string.IsNullOrEmpty(posterPath))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return _tmDbClient.GetImageUrl(_tmDbClient.Config.Images.BackdropSizes[^1], posterPath).ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the absolute URL of the profile image.
|
|
/// </summary>
|
|
/// <param name="actorProfilePath">The relative URL of the profile image.</param>
|
|
/// <returns>The absolute URL.</returns>
|
|
public string? GetProfileUrl(string actorProfilePath)
|
|
{
|
|
if (string.IsNullOrEmpty(actorProfilePath))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return _tmDbClient.GetImageUrl(_tmDbClient.Config.Images.ProfileSizes[^1], actorProfilePath).ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the absolute URL of the still image.
|
|
/// </summary>
|
|
/// <param name="filePath">The relative URL of the still image.</param>
|
|
/// <returns>The absolute URL.</returns>
|
|
public string? GetStillUrl(string filePath)
|
|
{
|
|
if (string.IsNullOrEmpty(filePath))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return _tmDbClient.GetImageUrl(_tmDbClient.Config.Images.StillSizes[^1], filePath).ToString();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dispose.
|
|
/// </summary>
|
|
/// <param name="disposing">Dispose all members.</param>
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
_memoryCache.Dispose();
|
|
_tmDbClient.Dispose();
|
|
}
|
|
}
|
|
|
|
private Task EnsureClientConfigAsync()
|
|
{
|
|
return !_tmDbClient.HasConfig ? _tmDbClient.GetConfigAsync() : Task.CompletedTask;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Normalizes a language string for use with TMDb's language parameter.
|
|
/// </summary>
|
|
/// <param name="language">The language code.</param>
|
|
/// <returns>The normalized language code.</returns>
|
|
public string NormalizeLanguage(string language)
|
|
{
|
|
if (string.IsNullOrEmpty(language))
|
|
{
|
|
return language;
|
|
}
|
|
|
|
// They require this to be uppercase
|
|
// Everything after the hyphen must be written in uppercase due to a way TMDB wrote their api.
|
|
// See here: https://www.themoviedb.org/talk/5119221d760ee36c642af4ad?page=3#56e372a0c3a3685a9e0019ab
|
|
var parts = language.Split('-');
|
|
|
|
if (parts.Length == 2)
|
|
{
|
|
language = parts[0] + "-" + parts[1].ToUpperInvariant();
|
|
}
|
|
|
|
return language;
|
|
}
|
|
|
|
|
|
public string GetImageLanguagesParam(string preferredLanguage)
|
|
{
|
|
if (string.IsNullOrEmpty(preferredLanguage))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var languages = new List<string>();
|
|
|
|
if (!string.IsNullOrEmpty(preferredLanguage))
|
|
{
|
|
preferredLanguage = NormalizeLanguage(preferredLanguage);
|
|
|
|
languages.Add(preferredLanguage);
|
|
|
|
if (preferredLanguage.Length == 5) // like en-US
|
|
{
|
|
// Currently, TMDB supports 2-letter language codes only
|
|
// They are planning to change this in the future, thus we're
|
|
// supplying both codes if we're having a 5-letter code.
|
|
languages.Add(preferredLanguage.Substring(0, 2));
|
|
}
|
|
}
|
|
|
|
languages.Add("null");
|
|
|
|
if (!string.Equals(preferredLanguage, "en", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
languages.Add("en");
|
|
}
|
|
|
|
return string.Join(',', languages);
|
|
}
|
|
|
|
private bool IsEnable()
|
|
{
|
|
return Plugin.Instance?.Configuration.EnableTmdb ?? true;
|
|
}
|
|
|
|
}
|
|
}
|