jellyfin/MediaBrowser.Providers/Movies/GenericMovieDbInfo.cs

340 lines
13 KiB
C#
Raw Normal View History

using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
2014-11-18 02:48:22 +00:00
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.IO;
using MediaBrowser.Model.IO;
2016-09-18 05:52:10 +00:00
using MediaBrowser.Model.Extensions;
namespace MediaBrowser.Providers.Movies
{
public class GenericMovieDbInfo<T>
2015-03-14 20:00:32 +00:00
where T : BaseItem, new()
{
private readonly ILogger _logger;
private readonly IJsonSerializer _jsonSerializer;
2014-11-18 02:48:22 +00:00
private readonly ILibraryManager _libraryManager;
2016-11-01 18:28:36 +00:00
private readonly IFileSystem _fileSystem;
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
2016-11-01 18:28:36 +00:00
public GenericMovieDbInfo(ILogger logger, IJsonSerializer jsonSerializer, ILibraryManager libraryManager, IFileSystem fileSystem)
{
_logger = logger;
_jsonSerializer = jsonSerializer;
2014-11-18 02:48:22 +00:00
_libraryManager = libraryManager;
2016-11-01 18:28:36 +00:00
_fileSystem = fileSystem;
}
2014-02-07 03:10:13 +00:00
public async Task<MetadataResult<T>> GetMetadata(ItemLookupInfo itemId, CancellationToken cancellationToken)
{
var tmdbId = itemId.GetProviderId(MetadataProviders.Tmdb);
var imdbId = itemId.GetProviderId(MetadataProviders.Imdb);
// Don't search for music video id's because it is very easy to misidentify.
if (string.IsNullOrEmpty(tmdbId) && string.IsNullOrEmpty(imdbId) && typeof(T) != typeof(MusicVideo))
{
2014-11-18 02:48:22 +00:00
var searchResults = await new MovieDbSearch(_logger, _jsonSerializer, _libraryManager).GetMovieSearchResults(itemId, cancellationToken).ConfigureAwait(false);
2014-03-01 22:34:27 +00:00
var searchResult = searchResults.FirstOrDefault();
2014-02-15 16:36:09 +00:00
if (searchResult != null)
{
2014-03-02 17:09:35 +00:00
tmdbId = searchResult.GetProviderId(MetadataProviders.Tmdb);
2014-02-15 16:36:09 +00:00
}
}
if (!string.IsNullOrEmpty(tmdbId) || !string.IsNullOrEmpty(imdbId))
{
cancellationToken.ThrowIfCancellationRequested();
2015-06-29 01:10:45 +00:00
return await FetchMovieData(tmdbId, imdbId, itemId.MetadataLanguage, itemId.MetadataCountryCode, cancellationToken).ConfigureAwait(false);
}
2015-06-29 01:10:45 +00:00
return new MetadataResult<T>();
}
/// <summary>
/// Fetches the movie data.
/// </summary>
/// <param name="tmdbId">The TMDB identifier.</param>
/// <param name="imdbId">The imdb identifier.</param>
/// <param name="language">The language.</param>
/// <param name="preferredCountryCode">The preferred country code.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{`0}.</returns>
2015-06-29 01:10:45 +00:00
private async Task<MetadataResult<T>> FetchMovieData(string tmdbId, string imdbId, string language, string preferredCountryCode, CancellationToken cancellationToken)
{
2015-06-29 01:10:45 +00:00
var item = new MetadataResult<T>
{
Item = new T()
};
string dataFilePath = null;
MovieDbProvider.CompleteMovieData movieInfo = null;
// Id could be ImdbId or TmdbId
if (string.IsNullOrEmpty(tmdbId))
{
2014-09-28 20:49:43 +00:00
movieInfo = await MovieDbProvider.Current.FetchMainResult(imdbId, false, language, cancellationToken).ConfigureAwait(false);
2015-10-26 05:29:32 +00:00
if (movieInfo != null)
{
tmdbId = movieInfo.id.ToString(_usCulture);
2015-10-26 05:29:32 +00:00
dataFilePath = MovieDbProvider.Current.GetDataFilePath(tmdbId, language);
_fileSystem.CreateDirectory(Path.GetDirectoryName(dataFilePath));
_jsonSerializer.SerializeToFile(movieInfo, dataFilePath);
}
}
2015-10-26 05:29:32 +00:00
if (!string.IsNullOrWhiteSpace(tmdbId))
{
await MovieDbProvider.Current.EnsureMovieInfo(tmdbId, language, cancellationToken).ConfigureAwait(false);
2015-10-26 05:29:32 +00:00
dataFilePath = dataFilePath ?? MovieDbProvider.Current.GetDataFilePath(tmdbId, language);
movieInfo = movieInfo ?? _jsonSerializer.DeserializeFromFile<MovieDbProvider.CompleteMovieData>(dataFilePath);
2016-01-21 18:50:43 +00:00
var settings = await MovieDbProvider.Current.GetTmdbSettings(cancellationToken).ConfigureAwait(false);
ProcessMainInfo(item, settings, preferredCountryCode, movieInfo);
2015-10-26 05:29:32 +00:00
item.HasMetadata = true;
}
return item;
}
/// <summary>
/// Processes the main info.
/// </summary>
2015-06-29 01:10:45 +00:00
/// <param name="resultItem">The result item.</param>
2016-01-21 18:50:43 +00:00
/// <param name="settings">The settings.</param>
/// <param name="preferredCountryCode">The preferred country code.</param>
/// <param name="movieData">The movie data.</param>
2016-01-21 18:50:43 +00:00
private void ProcessMainInfo(MetadataResult<T> resultItem, TmdbSettingsResult settings, string preferredCountryCode, MovieDbProvider.CompleteMovieData movieData)
{
2015-06-29 01:10:45 +00:00
var movie = resultItem.Item;
2015-03-10 01:30:20 +00:00
movie.Name = movieData.GetTitle() ?? movie.Name;
movie.OriginalTitle = movieData.GetOriginalTitle();
// Bug in Mono: WebUtility.HtmlDecode should return null if the string is null but in Mono it generate an System.ArgumentNullException.
movie.Overview = movieData.overview != null ? WebUtility.HtmlDecode(movieData.overview) : null;
movie.Overview = movie.Overview != null ? movie.Overview.Replace("\n\n", "\n") : null;
movie.HomePageUrl = movieData.homepage;
var hasBudget = movie as IHasBudget;
if (hasBudget != null)
{
hasBudget.Budget = movieData.budget;
hasBudget.Revenue = movieData.revenue;
}
if (!string.IsNullOrEmpty(movieData.tagline))
{
2016-10-08 05:57:38 +00:00
movie.Tagline = movieData.tagline;
}
2014-05-16 19:16:29 +00:00
if (movieData.production_countries != null)
{
2016-10-09 07:18:43 +00:00
movie.ProductionLocations = movieData
.production_countries
.Select(i => i.name)
.ToList();
2014-05-16 19:16:29 +00:00
}
movie.SetProviderId(MetadataProviders.Tmdb, movieData.id.ToString(_usCulture));
movie.SetProviderId(MetadataProviders.Imdb, movieData.imdb_id);
if (movieData.belongs_to_collection != null)
{
movie.SetProviderId(MetadataProviders.TmdbCollection,
movieData.belongs_to_collection.id.ToString(CultureInfo.InvariantCulture));
var movieItem = movie as Movie;
if (movieItem != null)
{
2016-03-14 01:34:24 +00:00
movieItem.CollectionName = movieData.belongs_to_collection.name;
}
}
float rating;
string voteAvg = movieData.vote_average.ToString(CultureInfo.InvariantCulture);
if (float.TryParse(voteAvg, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out rating))
{
movie.CommunityRating = rating;
}
movie.VoteCount = movieData.vote_count;
//release date and certification are retrieved based on configured country and we fall back on US if not there and to minimun release date if still no match
if (movieData.releases != null && movieData.releases.countries != null)
{
2015-08-19 16:43:23 +00:00
var releases = movieData.releases.countries.Where(i => !string.IsNullOrWhiteSpace(i.certification)).ToList();
2016-10-02 02:10:53 +00:00
var ourRelease = releases.FirstOrDefault(c => string.Equals(c.iso_3166_1, preferredCountryCode, StringComparison.OrdinalIgnoreCase));
var usRelease = releases.FirstOrDefault(c => string.Equals(c.iso_3166_1, "US", StringComparison.OrdinalIgnoreCase));
2015-08-19 16:43:23 +00:00
if (ourRelease != null)
{
var ratingPrefix = string.Equals(preferredCountryCode, "us", StringComparison.OrdinalIgnoreCase) ? "" : preferredCountryCode + "-";
2016-09-18 05:52:10 +00:00
var newRating = ratingPrefix + ourRelease.certification;
newRating = newRating.Replace("de-", "FSK-", StringComparison.OrdinalIgnoreCase);
movie.OfficialRating = newRating;
2015-08-19 16:43:23 +00:00
}
else if (usRelease != null)
{
movie.OfficialRating = usRelease.certification;
}
}
2014-03-02 18:01:46 +00:00
if (!string.IsNullOrWhiteSpace(movieData.release_date))
{
2014-03-02 18:01:46 +00:00
DateTime r;
// These dates are always in this exact format
if (DateTime.TryParse(movieData.release_date, _usCulture, DateTimeStyles.None, out r))
{
movie.PremiereDate = r.ToUniversalTime();
movie.ProductionYear = movie.PremiereDate.Value.Year;
}
}
//studios
if (movieData.production_companies != null)
{
movie.Studios.Clear();
foreach (var studio in movieData.production_companies.Select(c => c.name))
{
movie.AddStudio(studio);
}
}
// genres
// Movies get this from imdb
var genres = movieData.genres ?? new List<MovieDbProvider.GenreItem>();
foreach (var genre in genres.Select(g => g.name))
{
movie.AddGenre(genre);
}
2015-07-24 02:48:10 +00:00
resultItem.ResetPeople();
var tmdbImageUrl = settings.images.secure_base_url + "original";
2015-08-19 16:43:23 +00:00
//Actors, Directors, Writers - all in People
//actors come from cast
if (movieData.casts != null && movieData.casts.cast != null)
{
2015-06-28 16:36:25 +00:00
foreach (var actor in movieData.casts.cast.OrderBy(a => a.order))
{
2016-01-21 18:50:43 +00:00
var personInfo = new PersonInfo
{
Name = actor.name.Trim(),
Role = actor.character,
Type = PersonType.Actor,
SortOrder = actor.order
};
if (!string.IsNullOrWhiteSpace(actor.profile_path))
{
personInfo.ImageUrl = tmdbImageUrl + actor.profile_path;
}
if (actor.id > 0)
{
personInfo.SetProviderId(MetadataProviders.Tmdb, actor.id.ToString(CultureInfo.InvariantCulture));
}
resultItem.AddPerson(personInfo);
2015-06-28 16:36:25 +00:00
}
}
//and the rest from crew
if (movieData.casts != null && movieData.casts.crew != null)
{
2017-01-31 21:20:01 +00:00
var keepTypes = new[]
{
PersonType.Director,
PersonType.Writer,
//PersonType.Producer
};
2016-11-01 18:28:36 +00:00
2015-06-28 16:36:25 +00:00
foreach (var person in movieData.casts.crew)
{
2015-09-25 12:53:38 +00:00
// Normalize this
var type = person.department;
if (string.Equals(type, "writing", StringComparison.OrdinalIgnoreCase))
{
type = PersonType.Writer;
}
2016-11-01 18:28:36 +00:00
if (!keepTypes.Contains(type ?? string.Empty, StringComparer.OrdinalIgnoreCase) &&
!keepTypes.Contains(person.job ?? string.Empty, StringComparer.OrdinalIgnoreCase))
{
continue;
}
2016-01-21 18:50:43 +00:00
var personInfo = new PersonInfo
{
Name = person.name.Trim(),
Role = person.job,
Type = type
};
if (!string.IsNullOrWhiteSpace(person.profile_path))
{
personInfo.ImageUrl = tmdbImageUrl + person.profile_path;
}
if (person.id > 0)
{
personInfo.SetProviderId(MetadataProviders.Tmdb, person.id.ToString(CultureInfo.InvariantCulture));
}
resultItem.AddPerson(personInfo);
2015-06-28 16:36:25 +00:00
}
}
if (movieData.keywords != null && movieData.keywords.keywords != null)
{
movie.Keywords = movieData.keywords.keywords.Select(i => i.name).ToList();
}
if (movieData.trailers != null && movieData.trailers.youtube != null &&
movieData.trailers.youtube.Count > 0)
{
var hasTrailers = movie as IHasTrailers;
if (hasTrailers != null)
{
hasTrailers.RemoteTrailers = movieData.trailers.youtube.Select(i => new MediaUrl
{
2016-04-21 05:13:33 +00:00
Url = string.Format("https://www.youtube.com/watch?v={0}", i.source),
2016-06-17 13:06:13 +00:00
Name = i.name
}).ToList();
}
}
}
}
}