mirror of
https://github.com/zoriya/Kyoo.git
synced 2025-06-23 15:30:34 -04:00
281 lines
9.1 KiB
C#
281 lines
9.1 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Kyoo.Abstractions.Controllers;
|
|
using Kyoo.Abstractions.Models;
|
|
using Kyoo.TheMovieDb.Models;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Options;
|
|
using TMDbLib.Client;
|
|
using TMDbLib.Objects.Movies;
|
|
using TMDbLib.Objects.Search;
|
|
using TMDbLib.Objects.TvShows;
|
|
|
|
namespace Kyoo.TheMovieDb
|
|
{
|
|
/// <summary>
|
|
/// A metadata provider for TheMovieDb.
|
|
/// </summary>
|
|
public class TheMovieDbProvider : IMetadataProvider
|
|
{
|
|
/// <summary>
|
|
/// The API key used to authenticate with TheMovieDb API.
|
|
/// </summary>
|
|
private readonly IOptions<TheMovieDbOptions> _apiKey;
|
|
|
|
/// <summary>
|
|
/// The logger to use in ase of issue.
|
|
/// </summary>
|
|
private readonly ILogger<TheMovieDbProvider> _logger;
|
|
|
|
/// <inheritdoc />
|
|
public Provider Provider => new()
|
|
{
|
|
Slug = "the-moviedb",
|
|
Name = "TheMovieDB",
|
|
Images = new Dictionary<int, string>
|
|
{
|
|
[Images.Logo] = "https://www.themoviedb.org/assets/2/v4/logos/v2/" +
|
|
"blue_short-8e7b30f73a4020692ccca9c88bafe5dcb6f8a62a4c6bc55cd9ba82bb2cd95f6c.svg"
|
|
}
|
|
};
|
|
|
|
/// <summary>
|
|
/// Create a new <see cref="TheMovieDbProvider"/> using the given api key.
|
|
/// </summary>
|
|
/// <param name="apiKey">The api key.</param>
|
|
/// <param name="logger">The logger to use in case of issue.</param>
|
|
public TheMovieDbProvider(IOptions<TheMovieDbOptions> apiKey, ILogger<TheMovieDbProvider> logger)
|
|
{
|
|
_apiKey = apiKey;
|
|
_logger = logger;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task<T> Get<T>(T item)
|
|
where T : class, IResource
|
|
{
|
|
return item switch
|
|
{
|
|
Collection collection => _GetCollection(collection) as Task<T>,
|
|
Show show => _GetShow(show) as Task<T>,
|
|
Season season => _GetSeason(season) as Task<T>,
|
|
Episode episode => _GetEpisode(episode) as Task<T>,
|
|
People person => _GetPerson(person) as Task<T>,
|
|
Studio studio => _GetStudio(studio) as Task<T>,
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a collection using it's id, if the id is not present in the collection, fallback to a name search.
|
|
/// </summary>
|
|
/// <param name="collection">The collection to search for.</param>
|
|
/// <returns>A collection containing metadata from TheMovieDb.</returns>
|
|
private async Task<Collection> _GetCollection(Collection collection)
|
|
{
|
|
if (!collection.TryGetID(Provider.Slug, out int id))
|
|
{
|
|
Collection found = (await _SearchCollections(collection.Name ?? collection.Slug)).FirstOrDefault();
|
|
if (found?.TryGetID(Provider.Slug, out id) != true)
|
|
return found;
|
|
}
|
|
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.GetCollectionAsync(id)).ToCollection(Provider);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a show using it's id, if the id is not present in the show, fallback to a title search.
|
|
/// </summary>
|
|
/// <param name="show">The show to search for.</param>
|
|
/// <returns>A show containing metadata from TheMovieDb.</returns>
|
|
private async Task<Show> _GetShow(Show show)
|
|
{
|
|
if (!show.TryGetID(Provider.Slug, out int id))
|
|
{
|
|
Show found = (await _SearchShows(show.Title ?? show.Slug, show.StartAir?.Year))
|
|
.FirstOrDefault(x => x.IsMovie == show.IsMovie);
|
|
if (found?.TryGetID(Provider.Slug, out id) != true)
|
|
return found;
|
|
}
|
|
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
|
|
if (show.IsMovie)
|
|
{
|
|
return (await client
|
|
.GetMovieAsync(id, MovieMethods.AlternativeTitles | MovieMethods.Videos | MovieMethods.Credits))
|
|
?.ToShow(Provider);
|
|
}
|
|
|
|
return (await client
|
|
.GetTvShowAsync(id, TvShowMethods.AlternativeTitles | TvShowMethods.Videos | TvShowMethods.Credits))
|
|
?.ToShow(Provider);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a season using it's show and it's season number.
|
|
/// </summary>
|
|
/// <param name="season">The season to retrieve metadata for.</param>
|
|
/// <returns>A season containing metadata from TheMovieDb.</returns>
|
|
private async Task<Season> _GetSeason(Season season)
|
|
{
|
|
if (season.Show == null)
|
|
{
|
|
_logger.LogWarning("Metadata for a season was requested but it's show is not loaded. " +
|
|
"This is unsupported");
|
|
return null;
|
|
}
|
|
|
|
if (!season.Show.TryGetID(Provider.Slug, out int id))
|
|
return null;
|
|
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.GetTvSeasonAsync(id, season.SeasonNumber))
|
|
.ToSeason(id, Provider);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get an episode using it's show, it's season number and it's episode number.
|
|
/// Absolute numbering is not supported.
|
|
/// </summary>
|
|
/// <param name="episode">The episode to retrieve metadata for.</param>
|
|
/// <returns>An episode containing metadata from TheMovieDb.</returns>
|
|
private async Task<Episode> _GetEpisode(Episode episode)
|
|
{
|
|
if (episode.Show == null)
|
|
{
|
|
_logger.LogWarning("Metadata for an episode was requested but it's show is not loaded. " +
|
|
"This is unsupported");
|
|
return null;
|
|
}
|
|
if (!episode.Show.TryGetID(Provider.Slug, out int id)
|
|
|| episode.SeasonNumber == null || episode.EpisodeNumber == null)
|
|
return null;
|
|
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.GetTvEpisodeAsync(id, episode.SeasonNumber.Value, episode.EpisodeNumber.Value))
|
|
?.ToEpisode(id, Provider);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a person using it's id, if the id is not present in the person, fallback to a name search.
|
|
/// </summary>
|
|
/// <param name="person">The person to search for.</param>
|
|
/// <returns>A person containing metadata from TheMovieDb.</returns>
|
|
private async Task<People> _GetPerson(People person)
|
|
{
|
|
if (!person.TryGetID(Provider.Slug, out int id))
|
|
{
|
|
People found = (await _SearchPeople(person.Name ?? person.Slug)).FirstOrDefault();
|
|
if (found?.TryGetID(Provider.Slug, out id) != true)
|
|
return found;
|
|
}
|
|
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.GetPersonAsync(id)).ToPeople(Provider);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a studio using it's id, if the id is not present in the studio, fallback to a name search.
|
|
/// </summary>
|
|
/// <param name="studio">The studio to search for.</param>
|
|
/// <returns>A studio containing metadata from TheMovieDb.</returns>
|
|
private async Task<Studio> _GetStudio(Studio studio)
|
|
{
|
|
if (!studio.TryGetID(Provider.Slug, out int id))
|
|
{
|
|
Studio found = (await _SearchStudios(studio.Name ?? studio.Slug)).FirstOrDefault();
|
|
if (found?.TryGetID(Provider.Slug, out id) != true)
|
|
return found;
|
|
}
|
|
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.GetCompanyAsync(id)).ToStudio(Provider);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task<ICollection<T>> Search<T>(string query)
|
|
where T : class, IResource
|
|
{
|
|
if (typeof(T) == typeof(Collection))
|
|
return (await _SearchCollections(query) as ICollection<T>)!;
|
|
if (typeof(T) == typeof(Show))
|
|
return (await _SearchShows(query) as ICollection<T>)!;
|
|
if (typeof(T) == typeof(People))
|
|
return (await _SearchPeople(query) as ICollection<T>)!;
|
|
if (typeof(T) == typeof(Studio))
|
|
return (await _SearchStudios(query) as ICollection<T>)!;
|
|
return ArraySegment<T>.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search for a collection using it's name as a query.
|
|
/// </summary>
|
|
/// <param name="query">The query to search for</param>
|
|
/// <returns>A list of collections containing metadata from TheMovieDb</returns>
|
|
private async Task<ICollection<Collection>> _SearchCollections(string query)
|
|
{
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.SearchCollectionAsync(query))
|
|
.Results
|
|
.Select(x => x.ToCollection(Provider))
|
|
.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search for a show using it's name as a query.
|
|
/// </summary>
|
|
/// <param name="query">The query to search for</param>
|
|
/// <param name="year">The year in witch the show has aired.</param>
|
|
/// <returns>A list of shows containing metadata from TheMovieDb</returns>
|
|
private async Task<ICollection<Show>> _SearchShows(string query, int? year = null)
|
|
{
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.SearchMultiAsync(query, year: year ?? 0))
|
|
.Results
|
|
.Select(x =>
|
|
{
|
|
return x switch
|
|
{
|
|
SearchTv tv => tv.ToShow(Provider),
|
|
SearchMovie movie => movie.ToShow(Provider),
|
|
_ => null
|
|
};
|
|
})
|
|
.Where(x => x != null)
|
|
.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search for people using there name as a query.
|
|
/// </summary>
|
|
/// <param name="query">The query to search for</param>
|
|
/// <returns>A list of people containing metadata from TheMovieDb</returns>
|
|
private async Task<ICollection<People>> _SearchPeople(string query)
|
|
{
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.SearchPersonAsync(query))
|
|
.Results
|
|
.Select(x => x.ToPeople(Provider))
|
|
.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search for studios using there name as a query.
|
|
/// </summary>
|
|
/// <param name="query">The query to search for</param>
|
|
/// <returns>A list of studios containing metadata from TheMovieDb</returns>
|
|
private async Task<ICollection<Studio>> _SearchStudios(string query)
|
|
{
|
|
TMDbClient client = new(_apiKey.Value.ApiKey);
|
|
return (await client.SearchCompanyAsync(query))
|
|
.Results
|
|
.Select(x => x.ToStudio(Provider))
|
|
.ToArray();
|
|
}
|
|
}
|
|
}
|