public async Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return(false);
}
SeriesInfo seriesInfo = RelationshipExtractorUtils.TryCreateInfoFromLinkedAspects(extractedLinkedAspects, out List <SeriesInfo> series) ?
series[0] : episodeInfo.CloneBasicInstance <SeriesInfo>();
if (!SeriesMetadataExtractor.SkipOnlineSearches)
{
await OnlineMatcherService.Instance.UpdateSeriesAsync(seriesInfo, false, _category).ConfigureAwait(false);
}
if (seriesInfo.Genres.Count > 0)
{
IGenreConverter converter = ServiceRegistration.Get <IGenreConverter>();
foreach (var genre in seriesInfo.Genres)
{
if (!genre.Id.HasValue && converter.GetGenreId(genre.Name, GenreCategory.Series, null, out int genreId))
{
genre.Id = genreId;
seriesInfo.HasChanged = true;
}
}
}
IDictionary <Guid, IList <MediaItemAspect> > seriesAspects = seriesInfo.LinkedAspects != null ?
seriesInfo.LinkedAspects : new Dictionary <Guid, IList <MediaItemAspect> >();
seriesInfo.SetMetadata(seriesAspects);
if (aspects.ContainsKey(EpisodeAspect.ASPECT_ID))
{
bool episodeVirtual = true;
if (MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_ISVIRTUAL, false, out episodeVirtual))
{
MediaItemAspect.SetAttribute(seriesAspects, MediaAspect.ATTR_ISVIRTUAL, episodeVirtual);
}
}
if (!seriesAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
return(false);
}
if (seriesInfo.LinkedAspects == null)
{
extractedLinkedAspects.Add(seriesAspects);
}
return(true);
}
public bool TryExtractRelationships(IDictionary <Guid, IList <MediaItemAspect> > aspects, bool importOnly, out IList <RelationshipItem> extractedLinkedAspects)
{
extractedLinkedAspects = null;
//Only run during import
if (!importOnly)
{
return(false);
}
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return(false);
}
SeriesInfo seriesInfo = episodeInfo.CloneBasicInstance <SeriesInfo>();
UpdatePersons(aspects, seriesInfo.Actors, true);
UpdateCharacters(aspects, seriesInfo.Characters, true);
if (!UpdateSeries(aspects, seriesInfo))
{
return(false);
}
OnlineMatcherService.Instance.AssignMissingSeriesGenreIds(seriesInfo.Genres);
extractedLinkedAspects = new List <RelationshipItem>();
IDictionary <Guid, IList <MediaItemAspect> > seriesAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
seriesInfo.SetMetadata(seriesAspects);
if (aspects.ContainsKey(EpisodeAspect.ASPECT_ID))
{
bool episodeVirtual = true;
if (MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_ISVIRTUAL, false, out episodeVirtual))
{
MediaItemAspect.SetAttribute(seriesAspects, MediaAspect.ATTR_ISVIRTUAL, episodeVirtual);
}
}
if (!seriesAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
return(false);
}
StorePersons(seriesAspects, seriesInfo.Actors, true);
StoreCharacters(seriesAspects, seriesInfo.Characters, true);
extractedLinkedAspects.Add(new RelationshipItem(seriesAspects, Guid.Empty));
return(true);
}
public async Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
SeriesInfo reimport = null;
if (aspects.ContainsKey(ReimportAspect.ASPECT_ID))
{
EpisodeInfo episode = new EpisodeInfo();
episode.FromMetadata(aspects);
reimport = episode.CloneBasicInstance <SeriesInfo>();
}
IDictionary <Guid, IList <MediaItemAspect> > extractedAspectData = extractedLinkedAspects.Count > 0 ?
extractedLinkedAspects[0] : new Dictionary <Guid, IList <MediaItemAspect> >();
if (!await TryExtractSeriesMetadataAsync(mediaItemAccessor, extractedAspectData, reimport).ConfigureAwait(false))
{
return(false);
}
SeriesInfo seriesInfo = new SeriesInfo();
if (!seriesInfo.FromMetadata(extractedAspectData))
{
return(false);
}
IGenreConverter converter = ServiceRegistration.Get <IGenreConverter>();
foreach (var genre in seriesInfo.Genres)
{
if (!genre.Id.HasValue && converter.GetGenreId(genre.Name, GenreCategory.Series, null, out int genreId))
{
genre.Id = genreId;
}
}
seriesInfo.SetMetadata(extractedAspectData);
if (!extractedAspectData.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
return(false);
}
bool episodeVirtual;
if (MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_ISVIRTUAL, false, out episodeVirtual))
{
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_ISVIRTUAL, episodeVirtual);
}
extractedLinkedAspects.Clear();
extractedLinkedAspects.Add(extractedAspectData);
return(true);
}
public static SeasonInfo AsSeason(this BaseInfo info)
{
SeasonInfo season = info as SeasonInfo;
if (season != null)
{
return(season);
}
EpisodeInfo episode = info as EpisodeInfo;
if (episode != null)
{
return(episode.CloneBasicInstance <SeasonInfo>());
}
return(null);
}
public async Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return(false);
}
SeasonInfo seasonInfo = episodeInfo.CloneBasicInstance <SeasonInfo>();
if (!SeriesMetadataExtractor.SkipOnlineSearches)
{
await OnlineMatcherService.Instance.UpdateSeasonAsync(seasonInfo).ConfigureAwait(false);
}
if (seasonInfo.SeriesName.IsEmpty)
{
return(false);
}
IDictionary <Guid, IList <MediaItemAspect> > seasonAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
seasonInfo.SetMetadata(seasonAspects);
bool episodeVirtual = true;
if (MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_ISVIRTUAL, false, out episodeVirtual))
{
MediaItemAspect.SetAttribute(seasonAspects, MediaAspect.ATTR_ISVIRTUAL, episodeVirtual);
}
if (!seasonAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
return(false);
}
extractedLinkedAspects.Add(seasonAspects);
return(true);
}
public override bool SearchSeriesEpisode(EpisodeInfo episodeSearch, string language, out List <EpisodeInfo> episodes)
{
episodes = null;
SeriesInfo seriesSearch = null;
if (string.IsNullOrEmpty(episodeSearch.SeriesImdbId))
{
seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>();
if (!SearchSeriesUniqueAndUpdate(seriesSearch, language))
{
return(false);
}
episodeSearch.CopyIdsFrom(seriesSearch);
}
if (!string.IsNullOrEmpty(episodeSearch.SeriesImdbId) && episodeSearch.SeasonNumber.HasValue)
{
OmDbSeason season = _omDbHandler.GetSeriesSeason(episodeSearch.SeriesImdbId, episodeSearch.SeasonNumber.Value, false);
if (season != null && season.Episodes != null)
{
foreach (OmDbSeasonEpisode episode in season.Episodes)
{
if ((episode.EpisodeNumber.HasValue && episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber.Value)) || episodeSearch.EpisodeNumbers.Count == 0)
{
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
}
EpisodeInfo info = new EpisodeInfo()
{
ImdbId = episode.ImdbID,
SeriesName = new SimpleTitle(season.Title, true),
SeasonNumber = episodeSearch.SeasonNumber.Value,
EpisodeName = new SimpleTitle(episode.Title, false),
};
if (episode.EpisodeNumber.HasValue)
{
info.EpisodeNumbers.Add(episode.EpisodeNumber.Value);
}
info.CopyIdsFrom(episodeSearch.CloneBasicInstance <SeriesInfo>());
episodes.Add(info);
}
}
}
}
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
EpisodeInfo info = new EpisodeInfo()
{
SeriesName = seriesSearch == null ? episodeSearch.SeriesName : seriesSearch.SeriesName,
SeasonNumber = episodeSearch.SeasonNumber,
EpisodeName = episodeSearch.EpisodeName,
};
info.CopyIdsFrom(seriesSearch);
CollectionUtils.AddAll(info.EpisodeNumbers, episodeSearch.EpisodeNumbers);
episodes.Add(info);
return(true);
}
return(episodes != null);
}
public override bool SearchSeriesEpisode(EpisodeInfo episodeSearch, string language, out List <EpisodeInfo> episodes)
{
episodes = null;
SeriesInfo seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>();
if (episodeSearch.SeriesTvMazeId <= 0)
{
if (!SearchSeriesUniqueAndUpdate(seriesSearch, language))
{
return(false);
}
episodeSearch.CopyIdsFrom(seriesSearch);
}
if (episodeSearch.SeriesTvMazeId > 0 && episodeSearch.SeasonNumber.HasValue)
{
TvMazeSeries seriesDetail = _tvMazeHandler.GetSeries(episodeSearch.SeriesTvMazeId, false);
List <TvMazeEpisode> seasonEpisodes = null;
if (seriesDetail.Embedded != null && seriesDetail.Embedded.Episodes != null)
{
seasonEpisodes = seriesDetail.Embedded.Episodes.Where(s => s.SeasonNumber == episodeSearch.SeasonNumber.Value).ToList();
}
foreach (TvMazeEpisode episode in seasonEpisodes)
{
if (episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber) || episodeSearch.EpisodeNumbers.Count == 0)
{
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
}
EpisodeInfo info = new EpisodeInfo()
{
TvMazeId = episode.Id,
SeriesName = seriesSearch.SeriesName,
SeasonNumber = episode.SeasonNumber,
EpisodeName = new SimpleTitle(episode.Name, true),
};
info.EpisodeNumbers.Add(episode.EpisodeNumber);
info.CopyIdsFrom(seriesSearch);
episodes.Add(info);
}
}
}
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
EpisodeInfo info = new EpisodeInfo()
{
SeriesName = seriesSearch.SeriesName,
SeasonNumber = episodeSearch.SeasonNumber,
EpisodeName = episodeSearch.EpisodeName,
};
info.CopyIdsFrom(seriesSearch);
CollectionUtils.AddAll(info.EpisodeNumbers, episodeSearch.EpisodeNumbers);
episodes.Add(info);
return(true);
}
return(episodes != null);
}
public override bool GetFanArt <T>(T infoObject, string language, string fanartMediaType, out ApiWrapperImageCollection <TvMazeImageCollection> images)
{
images = new ApiWrapperImageCollection <TvMazeImageCollection>();
try
{
if (fanartMediaType == FanArtMediaTypes.Series)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
SeasonInfo season = infoObject as SeasonInfo;
SeriesInfo series = infoObject as SeriesInfo;
if (series == null && season != null)
{
series = season.CloneBasicInstance <SeriesInfo>();
}
if (series == null && episode != null)
{
series = episode.CloneBasicInstance <SeriesInfo>();
}
if (series != null && series.TvMazeId > 0)
{
// Download all image information, filter later!
TvMazeSeries seriesDetail = _tvMazeHandler.GetSeries(series.TvMazeId, false);
if (seriesDetail != null)
{
images.Id = series.TvMazeId.ToString();
images.Posters.Add(seriesDetail.Images);
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.Episode)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
if (episode != null && episode.SeriesTvMazeId > 0 && episode.SeasonNumber.HasValue && episode.EpisodeNumbers.Count > 0)
{
// Download all image information, filter later!
TvMazeEpisode episodeDetail = _tvMazeHandler.GetSeriesEpisode(episode.SeriesTvMazeId, episode.SeasonNumber.Value, episode.FirstEpisodeNumber, false);
if (episodeDetail != null)
{
images.Id = episode.SeriesTvMazeId.ToString();
images.Thumbnails.Add(episodeDetail.Images);
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.Actor)
{
PersonInfo person = infoObject as PersonInfo;
if (person != null && person.TvMazeId > 0)
{
// Download all image information, filter later!
TvMazePerson personDetail = _tvMazeHandler.GetPerson(person.TvMazeId, false);
if (personDetail != null)
{
images.Id = person.TvMazeId.ToString();
images.Thumbnails.Add(personDetail.Images);
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.Character)
{
CharacterInfo character = infoObject as CharacterInfo;
if (character != null && character.TvMazeId > 0)
{
// Download all image information, filter later!
TvMazePerson personDetail = _tvMazeHandler.GetCharacter(character.TvMazeId, false);
if (personDetail != null)
{
images.Id = character.TvMazeId.ToString();
images.Thumbnails.Add(personDetail.Images);
return(true);
}
}
}
else
{
return(true);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug(GetType().Name + ": Exception downloading images", ex);
}
return(false);
}
public override bool UpdateFromOnlineSeriesEpisodeCharacter(EpisodeInfo episodeInfo, CharacterInfo character, TvdbLanguage language, bool cacheOnly)
{
return(UpdateFromOnlineSeriesCharacter(episodeInfo.CloneBasicInstance <SeriesInfo>(), character, language, cacheOnly));
}
public override async Task <List <EpisodeInfo> > SearchSeriesEpisodeAsync(EpisodeInfo episodeSearch, string language)
{
SeriesInfo seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>();
if (episodeSearch.SeriesTvMazeId <= 0)
{
if (!await SearchSeriesUniqueAndUpdateAsync(seriesSearch, language).ConfigureAwait(false))
{
return(null);
}
episodeSearch.CopyIdsFrom(seriesSearch);
}
List <EpisodeInfo> episodes = null;
if (episodeSearch.SeriesTvMazeId > 0 && episodeSearch.SeasonNumber.HasValue)
{
TvMazeSeries seriesDetail = await _tvMazeHandler.GetSeriesAsync(episodeSearch.SeriesTvMazeId, false).ConfigureAwait(false);
List <TvMazeEpisode> seasonEpisodes = null;
if (seriesDetail.Embedded != null && seriesDetail.Embedded.Episodes != null)
{
seasonEpisodes = seriesDetail.Embedded.Episodes.Where(s => s.SeasonNumber == episodeSearch.SeasonNumber.Value).ToList();
}
foreach (TvMazeEpisode episode in seasonEpisodes)
{
if (episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber) || episodeSearch.EpisodeNumbers.Count == 0)
{
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
}
EpisodeInfo info = new EpisodeInfo()
{
TvMazeId = episode.Id,
SeriesName = seriesSearch.SeriesName,
SeasonNumber = episode.SeasonNumber,
EpisodeName = new SimpleTitle(episode.Name, true),
DataProviders = new List <string>()
{
_name
}
};
info.EpisodeNumbers.Add(episode.EpisodeNumber);
info.CopyIdsFrom(seriesSearch);
episodes.Add(info);
}
}
}
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
EpisodeInfo info = new EpisodeInfo()
{
SeriesName = seriesSearch.SeriesName,
SeasonNumber = episodeSearch.SeasonNumber,
EpisodeName = episodeSearch.EpisodeName,
DataProviders = new List <string>()
{
_name
}
};
info.CopyIdsFrom(seriesSearch);
info.EpisodeNumbers = info.EpisodeNumbers.Union(episodeSearch.EpisodeNumbers).ToList();
episodes.Add(info);
}
return(episodes);
}
public bool TryExtractRelationships(IDictionary <Guid, IList <MediaItemAspect> > aspects, bool importOnly, out IList <RelationshipItem> extractedLinkedAspects)
{
extractedLinkedAspects = null;
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return(false);
}
if (CheckCacheContains(episodeInfo))
{
return(false);
}
SeriesInfo cachedSeries;
Guid seriesId;
SeriesInfo seriesInfo = episodeInfo.CloneBasicInstance <SeriesInfo>();
if (TryGetInfoFromCache(seriesInfo, out cachedSeries, out seriesId))
{
seriesInfo = cachedSeries;
}
else if (!SeriesMetadataExtractor.SkipOnlineSearches)
{
OnlineMatcherService.Instance.UpdateSeries(seriesInfo, false, importOnly);
}
if (!BaseInfo.HasRelationship(aspects, LinkedRole))
{
seriesInfo.HasChanged = true; //Force save if no relationship exists
}
if (!seriesInfo.HasChanged && !importOnly)
{
return(false);
}
AddToCheckCache(episodeInfo);
extractedLinkedAspects = new List <RelationshipItem>();
IDictionary <Guid, IList <MediaItemAspect> > seriesAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
seriesInfo.SetMetadata(seriesAspects);
if (aspects.ContainsKey(EpisodeAspect.ASPECT_ID))
{
bool episodeVirtual = true;
if (MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_ISVIRTUAL, false, out episodeVirtual))
{
MediaItemAspect.SetAttribute(seriesAspects, MediaAspect.ATTR_ISVIRTUAL, episodeVirtual);
}
}
if (!seriesAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
return(false);
}
if (seriesId != Guid.Empty)
{
extractedLinkedAspects.Add(new RelationshipItem(seriesAspects, seriesId));
}
else
{
extractedLinkedAspects.Add(new RelationshipItem(seriesAspects, Guid.Empty));
}
return(true);
}
private void ExtractFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?seriesMediaItemId, Guid?seasonMediaItemId, IDictionary <Guid, string> actorMediaItems)
{
if (aspects.ContainsKey(EpisodeAspect.ASPECT_ID))
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
EpisodeInfo episodeInfo = new EpisodeInfo();
episodeInfo.FromMetadata(aspects);
bool forceFanart = !episodeInfo.IsRefreshed;
SeasonInfo seasonInfo = episodeInfo.CloneBasicInstance <SeasonInfo>();
SeriesInfo seriesInfo = episodeInfo.CloneBasicInstance <SeriesInfo>();
ExtractLocalImages(aspects, mediaItemId, seriesMediaItemId, seasonMediaItemId, episodeInfo, seriesInfo, seasonInfo, actorMediaItems);
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadSeriesFanArt(mediaItemId, episodeInfo, forceFanart);
}
//Take advantage of the audio language being known and download season and series too
if (seasonMediaItemId.HasValue && !_checkCache.Contains(seasonMediaItemId.Value))
{
_checkCache.Add(seasonMediaItemId.Value);
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadSeriesFanArt(seasonMediaItemId.Value, seasonInfo, forceFanart);
}
}
if (seriesMediaItemId.HasValue && !_checkCache.Contains(seriesMediaItemId.Value))
{
_checkCache.Add(seriesMediaItemId.Value);
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadSeriesFanArt(seriesMediaItemId.Value, seriesInfo, forceFanart);
}
}
}
else if (aspects.ContainsKey(PersonAspect.ASPECT_ID))
{
PersonInfo personInfo = new PersonInfo();
personInfo.FromMetadata(aspects);
if (personInfo.Occupation == PersonAspect.OCCUPATION_ACTOR || personInfo.Occupation == PersonAspect.OCCUPATION_DIRECTOR ||
personInfo.Occupation == PersonAspect.OCCUPATION_WRITER)
{
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadSeriesFanArt(mediaItemId, personInfo, !personInfo.IsRefreshed);
}
}
}
else if (aspects.ContainsKey(CharacterAspect.ASPECT_ID))
{
CharacterInfo characterInfo = new CharacterInfo();
characterInfo.FromMetadata(aspects);
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadSeriesFanArt(mediaItemId, characterInfo, !characterInfo.IsRefreshed);
}
}
else if (aspects.ContainsKey(CompanyAspect.ASPECT_ID))
{
CompanyInfo companyInfo = new CompanyInfo();
companyInfo.FromMetadata(aspects);
if (companyInfo.Type == CompanyAspect.COMPANY_PRODUCTION || companyInfo.Type == CompanyAspect.COMPANY_TV_NETWORK)
{
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadSeriesFanArt(mediaItemId, companyInfo, !companyInfo.IsRefreshed);
}
}
}
}
protected async Task ExtractEpisodeFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
bool shouldCacheLocal = false;
IResourceLocator mediaItemLocator = null;
if (!BaseInfo.IsVirtualResource(aspects))
{
mediaItemLocator = GetResourceLocator(aspects);
//Whether local fanart should be stored in the fanart cache
shouldCacheLocal = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath,
SeriesMetadataExtractor.CacheLocalFanArt, SeriesMetadataExtractor.CacheOfflineFanArt);
}
if (mediaItemLocator == null)
{
return;
}
if (!shouldCacheLocal && SeriesMetadataExtractor.SkipFanArtDownload)
{
return; //Nothing to do
}
EpisodeInfo episodeInfo = new EpisodeInfo();
episodeInfo.FromMetadata(aspects);
//Episode fanart
if (AddToCache(mediaItemId))
{
if (shouldCacheLocal)
{
await ExtractEpisodeFolderFanArt(mediaItemLocator, mediaItemId, episodeInfo.ToString()).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(mediaItemId, episodeInfo).ConfigureAwait(false);
}
}
//Actor fanart may be stored in the season or series directory, so get the actors now
IList <Tuple <Guid, string> > actors = null;
if (MediaItemAspect.TryGetAspect(aspects, VideoAspect.Metadata, out SingleMediaItemAspect videoAspect))
{
var actorNames = videoAspect.GetCollectionAttribute <string>(VideoAspect.ATTR_ACTORS);
if (actorNames != null)
{
RelationshipExtractorUtils.TryGetMappedLinkedIds(PersonAspect.ROLE_ACTOR, aspects, actorNames.ToList(), out actors);
}
}
//Take advantage of the audio language being known and download season and series too
//Season fanart
if (RelationshipExtractorUtils.TryGetLinkedId(SeasonAspect.ROLE_SEASON, aspects, out Guid seasonMediaItemId) &&
AddToCache(seasonMediaItemId))
{
SeasonInfo seasonInfo = episodeInfo.CloneBasicInstance <SeasonInfo>();
if (shouldCacheLocal)
{
await ExtractSeasonFolderFanArt(mediaItemLocator, seasonMediaItemId, seasonInfo.ToString(), seasonInfo.SeasonNumber, actors).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(seasonMediaItemId, seasonInfo).ConfigureAwait(false);
}
}
//Series fanart
if (RelationshipExtractorUtils.TryGetLinkedId(SeriesAspect.ROLE_SERIES, aspects, out Guid seriesMediaItemId) &&
AddToCache(seriesMediaItemId))
{
SeriesInfo seriesInfo = episodeInfo.CloneBasicInstance <SeriesInfo>();
if (shouldCacheLocal)
{
await ExtractSeriesFolderFanArt(mediaItemLocator, seriesMediaItemId, seriesInfo.ToString(), episodeInfo.SeasonNumber, actors).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(seriesMediaItemId, seriesInfo).ConfigureAwait(false);
}
}
//Find central actor information folder
var seriesDirectory = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../../");
ResourcePath centralActorFolderPath = LocalFanartHelper.GetCentralPersonFolder(seriesDirectory, CentralPersonFolderType.SeriesActors);
if (shouldCacheLocal && centralActorFolderPath != null && actors != null)
{
foreach (var actor in actors)
{
// Check if we already processed this actor
if (!AddToCache(actor.Item1))
{
continue;
}
// First get the ResourcePath of the central directory
var artistFolderPath = ResourcePathHelper.Combine(centralActorFolderPath, $"{LocalFanartHelper.GetSafePersonFolderName(actor.Item2)}/");
using (IResourceAccessor accessor = new ResourceLocator(mediaItemLocator.NativeSystemId, artistFolderPath).CreateAccessor())
{
if (accessor is IFileSystemResourceAccessor directoryAccessor)
{
FanArtPathCollection paths = new FanArtPathCollection();
List <ResourcePath> potentialFanArtFiles = LocalFanartHelper.GetPotentialFanArtFiles(directoryAccessor);
ExtractAllFanArtImages(potentialFanArtFiles, paths);
await SaveFolderImagesToCache(mediaItemLocator.NativeSystemId, paths, actor.Item1, actor.Item2).ConfigureAwait(false);
}
}
}
}
}
public override bool GetFanArt <T>(T infoObject, string language, string fanartMediaType, out ApiWrapperImageCollection <FanArtMovieThumb> images)
{
images = new ApiWrapperImageCollection <FanArtMovieThumb>();
try
{
if (fanartMediaType == FanArtMediaTypes.Movie)
{
FanArtMovieThumbs imgs = null;
MovieInfo movie = infoObject as MovieInfo;
if (movie != null && movie.MovieDbId > 0)
{
// Download all image information, filter later!
imgs = _fanArtTvHandler.GetMovieThumbs(movie.MovieDbId.ToString());
}
if (imgs != null)
{
images.Id = movie.MovieDbId.ToString();
if (imgs.MovieFanArt != null)
{
images.Backdrops.AddRange(imgs.MovieFanArt.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.MovieBanners != null)
{
images.Banners.AddRange(imgs.MovieBanners.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.MoviePosters != null)
{
images.Posters.AddRange(imgs.MoviePosters.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.MovieCDArt != null)
{
images.DiscArt.AddRange(imgs.MovieCDArt.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.HDMovieClearArt != null)
{
images.ClearArt.AddRange(imgs.HDMovieClearArt.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.HDMovieLogos != null)
{
images.Logos.AddRange(imgs.HDMovieLogos.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.MovieThumbnails != null)
{
images.Thumbnails.AddRange(imgs.MovieThumbnails.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
return(true);
}
}
else if (fanartMediaType == FanArtMediaTypes.Series)
{
FanArtTVThumbs imgs = null;
EpisodeInfo episode = infoObject as EpisodeInfo;
SeasonInfo season = infoObject as SeasonInfo;
SeriesInfo series = infoObject as SeriesInfo;
if (series == null && season != null)
{
series = season.CloneBasicInstance <SeriesInfo>();
}
if (series == null && episode != null)
{
series = episode.CloneBasicInstance <SeriesInfo>();
}
if (series != null && series.TvdbId > 0)
{
// Download all image information, filter later!
imgs = _fanArtTvHandler.GetSeriesThumbs(series.TvdbId.ToString());
}
if (imgs != null)
{
images.Id = series.TvdbId.ToString();
if (imgs.SeriesFanArt != null)
{
images.Backdrops.AddRange(imgs.SeriesFanArt.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.SeriesBanners != null)
{
images.Banners.AddRange(imgs.SeriesBanners.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.SeriesPosters != null)
{
images.Posters.AddRange(imgs.SeriesPosters.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.HDSeriesClearArt != null)
{
images.ClearArt.AddRange(imgs.HDSeriesClearArt.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.HDSeriesLogos != null)
{
images.Logos.AddRange(imgs.HDSeriesLogos.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.SeriesThumbnails != null)
{
images.Thumbnails.AddRange(imgs.SeriesThumbnails.OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
return(true);
}
}
else if (fanartMediaType == FanArtMediaTypes.SeriesSeason)
{
FanArtTVThumbs imgs = null;
int seasonNo = 0;
EpisodeInfo episode = infoObject as EpisodeInfo;
SeasonInfo season = infoObject as SeasonInfo;
if (season == null && episode != null)
{
season = episode.CloneBasicInstance <SeasonInfo>();
}
if (season != null && season.SeriesTvdbId > 0 && season.SeasonNumber.HasValue)
{
// Download all image information, filter later!
imgs = _fanArtTvHandler.GetSeriesThumbs(season.SeriesTvdbId.ToString());
seasonNo = season.SeasonNumber.Value;
}
if (imgs != null)
{
images.Id = season.SeriesTvdbId.ToString();
if (imgs.SeasonBanners != null)
{
images.Banners.AddRange(imgs.SeasonBanners.FindAll(b => !b.Season.HasValue || b.Season == seasonNo).
OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.SeasonPosters != null)
{
images.Posters.AddRange(imgs.SeasonPosters.FindAll(b => !b.Season.HasValue || b.Season == seasonNo).
OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
if (imgs.SeasonThumbnails != null)
{
images.Thumbnails.AddRange(imgs.SeasonThumbnails.FindAll(b => !b.Season.HasValue || b.Season == seasonNo).
OrderBy(b => string.IsNullOrEmpty(b.Language)).ThenByDescending(b => b.Likes).ToList());
}
return(true);
}
}
else if (fanartMediaType == FanArtMediaTypes.Artist)
{
FanArtArtistThumbs imgs = null;
PersonInfo person = infoObject as PersonInfo;
if (person != null && !string.IsNullOrEmpty(person.MusicBrainzId))
{
// Download all image information, filter later!
imgs = _fanArtTvHandler.GetArtistThumbs(person.MusicBrainzId);
}
if (imgs != null)
{
images.Id = person.MusicBrainzId;
if (imgs.ArtistFanart != null)
{
images.Backdrops.AddRange(imgs.ArtistFanart.OrderByDescending(b => b.Likes).Select(b => new FanArtMovieThumb(b)).ToList());
}
if (imgs.ArtistBanners != null)
{
images.Banners.AddRange(imgs.ArtistBanners.OrderByDescending(b => b.Likes).Select(b => new FanArtMovieThumb(b)).ToList());
}
if (imgs.HDArtistLogos != null)
{
images.Logos.AddRange(imgs.HDArtistLogos.OrderByDescending(b => b.Likes).Select(b => new FanArtMovieThumb(b)).ToList());
}
if (imgs.ArtistThumbnails != null)
{
images.Thumbnails.AddRange(imgs.ArtistThumbnails.OrderByDescending(b => b.Likes).Select(b => new FanArtMovieThumb(b)).ToList());
}
return(true);
}
}
else if (fanartMediaType == FanArtMediaTypes.MusicLabel)
{
FanArtLabelThumbs imgs = null;
CompanyInfo company = infoObject as CompanyInfo;
if (company != null && !string.IsNullOrEmpty(company.MusicBrainzId))
{
// Download all image information, filter later!
imgs = _fanArtTvHandler.GetLabelThumbs(company.MusicBrainzId);
}
if (imgs != null)
{
images.Id = company.MusicBrainzId;
if (imgs.LabelLogos != null)
{
images.Logos.AddRange(imgs.LabelLogos.OrderByDescending(b => b.Likes).Select(b => new FanArtMovieThumb(b)).ToList());
}
return(true);
}
}
else if (fanartMediaType == FanArtMediaTypes.Album)
{
FanArtAlbumDetails imgs = null;
string albumId = null;
TrackInfo track = infoObject as TrackInfo;
AlbumInfo album = infoObject as AlbumInfo;
if (album == null && track != null)
{
album = track.CloneBasicInstance <AlbumInfo>();
}
if (album != null && !string.IsNullOrEmpty(album.MusicBrainzGroupId))
{
// Download all image information, filter later!
imgs = _fanArtTvHandler.GetAlbumThumbs(album.MusicBrainzGroupId);
albumId = album.MusicBrainzGroupId;
}
if (imgs != null)
{
images.Id = albumId;
if (imgs.Albums != null && imgs.Albums.ContainsKey(albumId) && imgs.Albums[albumId].AlbumCovers != null)
{
images.Covers.AddRange(imgs.Albums[albumId].AlbumCovers.OrderByDescending(b => b.Likes).Select(b => new FanArtMovieThumb(b)).ToList());
}
if (imgs.Albums != null && imgs.Albums.ContainsKey(albumId) && imgs.Albums[albumId].CDArts != null)
{
images.DiscArt.AddRange(imgs.Albums[albumId].CDArts.OrderByDescending(b => b.Likes).Select(b => new FanArtMovieThumb(b)).ToList());
}
return(true);
}
}
else
{
return(true);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug(GetType().Name + ": Exception downloading images", ex);
}
return(false);
}
public override bool GetFanArt <T>(T infoObject, TvdbLanguage language, string fanartMediaType, out ApiWrapperImageCollection <TvdbBanner> images)
{
images = new ApiWrapperImageCollection <TvdbBanner>();
try
{
try
{
TvdbSeries seriesDetail = null;
language = language ?? PreferredLanguage;
if (fanartMediaType == FanArtMediaTypes.Series)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
SeasonInfo season = infoObject as SeasonInfo;
SeriesInfo series = infoObject as SeriesInfo;
if (series == null && season != null)
{
series = season.CloneBasicInstance <SeriesInfo>();
}
if (series == null && episode != null)
{
series = episode.CloneBasicInstance <SeriesInfo>();
}
if (series != null && series.TvdbId > 0)
{
seriesDetail = _tvdbHandler.GetSeries(series.TvdbId, language, false, true, true);
if (seriesDetail != null)
{
images.Id = series.TvdbId.ToString();
images.Posters.AddRange(seriesDetail.PosterBanners.OrderBy(b => b.Language != language));
images.Banners.AddRange(seriesDetail.SeriesBanners.OrderBy(b => b.Language != language));
images.Backdrops.AddRange(seriesDetail.FanartBanners.OrderBy(b => b.Language != language));
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.SeriesSeason)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
SeasonInfo season = infoObject as SeasonInfo;
if (season == null && episode != null)
{
season = episode.CloneBasicInstance <SeasonInfo>();
}
if (season != null && season.SeriesTvdbId > 0 && season.SeasonNumber.HasValue)
{
seriesDetail = _tvdbHandler.GetSeries(season.SeriesTvdbId, language, false, false, true);
if (seriesDetail != null)
{
images.Id = season.TvdbId.ToString();
var seasonLookup = seriesDetail.SeasonBanners.Where(s => s.Season == season.SeasonNumber).ToLookup(s => string.Format("{0}_{1}", s.Season, s.BannerType), v => v);
foreach (IGrouping <string, TvdbSeasonBanner> tvdbSeasonBanners in seasonLookup)
{
images.Banners.AddRange(seasonLookup[tvdbSeasonBanners.Key].Where(b => b.BannerPath.Contains("wide")).OrderBy(b => b.Language != language));
images.Posters.AddRange(seasonLookup[tvdbSeasonBanners.Key].Where(b => !b.BannerPath.Contains("wide")).OrderBy(b => b.Language != language));
}
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.Episode)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
if (episode != null && episode.SeriesTvdbId > 0 && episode.SeasonNumber.HasValue && episode.EpisodeNumbers.Count > 0)
{
seriesDetail = _tvdbHandler.GetSeries(episode.SeriesTvdbId, language, true, false, true);
if (seriesDetail != null)
{
images.Id = episode.TvdbId.ToString();
TvdbEpisode episodeDetail = seriesDetail.Episodes.Find(e => e.SeasonNumber == episode.SeasonNumber.Value && e.EpisodeNumber == episode.FirstEpisodeNumber);
if (episodeDetail != null)
{
images.Thumbnails.AddRange(new TvdbBanner[] { episodeDetail.Banner });
}
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.Actor)
{
PersonInfo person = infoObject as PersonInfo;
string seriesId = null;
_seriesToActorMap.GetMappedId(person.TvdbId.ToString(), out seriesId);
int seriesTvdbId = 0;
if (int.TryParse(seriesId, out seriesTvdbId))
{
seriesDetail = _tvdbHandler.GetSeries(seriesTvdbId, language, false, true, true);
if (seriesDetail != null)
{
foreach (TvdbActor actor in seriesDetail.TvdbActors)
{
if (actor.Id == person.TvdbId)
{
images.Id = actor.Id.ToString();
images.Thumbnails.AddRange(new TvdbBanner[] { actor.ActorImage });
return(true);
}
}
}
}
}
else
{
return(true);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("TvDbWrapper: Error getting fan art for scope {0}", ex, fanartMediaType);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug(GetType().Name + ": Exception downloading images", ex);
}
return(false);
}
public override bool UpdateFromOnlineSeriesEpisodePerson(EpisodeInfo episodeInfo, PersonInfo person, TvdbLanguage language, bool cacheOnly)
{
return(UpdateFromOnlineSeriesPerson(episodeInfo.CloneBasicInstance <SeriesInfo>(), person, language, cacheOnly));
}
public override Task <bool> UpdateFromOnlineSeriesEpisodePersonAsync(EpisodeInfo episodeInfo, PersonInfo person, string language, bool cacheOnly)
{
return(UpdateFromOnlineSeriesPersonAsync(episodeInfo.CloneBasicInstance <SeriesInfo>(), person, language, cacheOnly));
}
public override Task <bool> UpdateFromOnlineSeriesEpisodeCharacterAsync(EpisodeInfo episodeInfo, CharacterInfo character, string language, bool cacheOnly)
{
return(UpdateFromOnlineSeriesCharacterAsync(episodeInfo.CloneBasicInstance <SeriesInfo>(), character, language, cacheOnly));
}
protected async Task ExtractEpisodeFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
IResourceLocator mediaItemLocator = GetResourceLocator(aspects);
if (mediaItemLocator == null)
{
return;
}
//Whether local fanart should be stored in the fanart cache
bool shouldCacheLocal = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath,
SeriesMetadataExtractor.CacheLocalFanArt, SeriesMetadataExtractor.CacheOfflineFanArt);
if (!shouldCacheLocal && SeriesMetadataExtractor.SkipFanArtDownload)
{
return; //Nothing to do
}
EpisodeInfo episodeInfo = new EpisodeInfo();
episodeInfo.FromMetadata(aspects);
//Episode fanart
if (AddToCache(mediaItemId))
{
if (shouldCacheLocal)
{
await ExtractEpisodeFolderFanArt(mediaItemLocator, mediaItemId, episodeInfo.ToString()).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(mediaItemId, episodeInfo).ConfigureAwait(false);
}
}
//Actor fanart may be stored in the season or series directory, so get the actors now
IList <Tuple <Guid, string> > actors = null;
if (MediaItemAspect.TryGetAspect(aspects, VideoAspect.Metadata, out SingleMediaItemAspect videoAspect))
{
var actorNames = videoAspect.GetCollectionAttribute <string>(VideoAspect.ATTR_ACTORS);
if (actorNames != null)
{
RelationshipExtractorUtils.TryGetMappedLinkedIds(PersonAspect.ROLE_ACTOR, aspects, actorNames.ToList(), out actors);
}
}
//Take advantage of the audio language being known and download season and series too
//Season fanart
if (RelationshipExtractorUtils.TryGetLinkedId(SeasonAspect.ROLE_SEASON, aspects, out Guid seasonMediaItemId) &&
AddToCache(seasonMediaItemId))
{
SeasonInfo seasonInfo = episodeInfo.CloneBasicInstance <SeasonInfo>();
if (shouldCacheLocal)
{
await ExtractSeasonFolderFanArt(mediaItemLocator, seasonMediaItemId, seasonInfo.ToString(), seasonInfo.SeasonNumber, actors).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(seasonMediaItemId, seasonInfo).ConfigureAwait(false);
}
}
//Series fanart
if (RelationshipExtractorUtils.TryGetLinkedId(SeriesAspect.ROLE_SERIES, aspects, out Guid seriesMediaItemId) &&
AddToCache(seriesMediaItemId))
{
SeriesInfo seriesInfo = episodeInfo.CloneBasicInstance <SeriesInfo>();
if (shouldCacheLocal)
{
await ExtractSeriesFolderFanArt(mediaItemLocator, seriesMediaItemId, seriesInfo.ToString(), actors).ConfigureAwait(false);
}
if (!SeriesMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadSeriesFanArtAsync(seriesMediaItemId, seriesInfo).ConfigureAwait(false);
}
}
}
public override async Task <List <EpisodeInfo> > SearchSeriesEpisodeAsync(EpisodeInfo episodeSearch, string language)
{
SeriesInfo seriesSearch = null;
if (string.IsNullOrEmpty(episodeSearch.SeriesImdbId))
{
seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>();
if (!await SearchSeriesUniqueAndUpdateAsync(seriesSearch, language))
{
return(null);
}
episodeSearch.CopyIdsFrom(seriesSearch);
}
List <EpisodeInfo> episodes = null;
if (!string.IsNullOrEmpty(episodeSearch.SeriesImdbId) && episodeSearch.SeasonNumber.HasValue)
{
OmDbSeason season = await _omDbHandler.GetSeriesSeasonAsync(episodeSearch.SeriesImdbId, episodeSearch.SeasonNumber.Value, false).ConfigureAwait(false);
if (season != null && season.Episodes != null)
{
foreach (OmDbSeasonEpisode episode in season.Episodes)
{
if ((episode.EpisodeNumber.HasValue && episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber.Value)) || episodeSearch.EpisodeNumbers.Count == 0)
{
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
}
EpisodeInfo info = new EpisodeInfo()
{
ImdbId = episode.ImdbID,
SeriesName = new SimpleTitle(season.Title, true),
SeasonNumber = episodeSearch.SeasonNumber.Value,
EpisodeName = new SimpleTitle(episode.Title, false),
};
if (episode.EpisodeNumber.HasValue)
{
info.EpisodeNumbers.Add(episode.EpisodeNumber.Value);
}
info.CopyIdsFrom(episodeSearch.CloneBasicInstance <SeriesInfo>());
episodes.Add(info);
}
}
}
}
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
EpisodeInfo info = new EpisodeInfo()
{
SeriesName = seriesSearch == null ? episodeSearch.SeriesName : seriesSearch.SeriesName,
SeasonNumber = episodeSearch.SeasonNumber,
EpisodeName = episodeSearch.EpisodeName,
};
info.CopyIdsFrom(seriesSearch);
info.EpisodeNumbers = info.EpisodeNumbers.Union(episodeSearch.EpisodeNumbers).ToList();
episodes.Add(info);
}
return(episodes);
}
public override bool SearchSeriesEpisode(EpisodeInfo episodeSearch, TvdbLanguage language, out List <EpisodeInfo> episodes)
{
language = language ?? PreferredLanguage;
episodes = null;
SeriesInfo seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>();
if (episodeSearch.SeriesTvdbId <= 0)
{
if (!SearchSeriesUniqueAndUpdate(seriesSearch, language))
{
return(false);
}
episodeSearch.CopyIdsFrom(seriesSearch);
}
if (episodeSearch.SeriesTvdbId > 0 && episodeSearch.SeasonNumber.HasValue)
{
TvdbSeries seriesDetail = _tvdbHandler.GetSeries(episodeSearch.SeriesTvdbId, language, true, false, false);
foreach (TvdbEpisode episode in seriesDetail.Episodes.OrderByDescending(e => e.Id))
{
if ((episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber) || episodeSearch.EpisodeNumbers.Count == 0) &&
(episodeSearch.SeasonNumber == episode.SeasonNumber || episodeSearch.SeasonNumber.HasValue == false))
{
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
}
EpisodeInfo info = new EpisodeInfo
{
TvdbId = episode.Id,
SeriesName = new SimpleTitle(seriesDetail.SeriesName, false),
SeasonNumber = episode.SeasonNumber,
EpisodeName = new SimpleTitle(episode.EpisodeName, false),
};
info.EpisodeNumbers.Add(episode.EpisodeNumber);
info.CopyIdsFrom(seriesSearch);
info.Languages.Add(episode.Language.Abbriviation);
if (!episodes.Contains(info))
{
episodes.Add(info);
}
}
}
if (episodes != null)
{
episodes.Sort();
}
}
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
EpisodeInfo info = new EpisodeInfo
{
SeriesName = seriesSearch.SeriesName,
SeasonNumber = episodeSearch.SeasonNumber,
EpisodeName = episodeSearch.EpisodeName,
};
info.CopyIdsFrom(seriesSearch);
CollectionUtils.AddAll(info.EpisodeNumbers, episodeSearch.EpisodeNumbers);
info.Languages = seriesSearch.Languages;
episodes.Add(info);
return(true);
}
return(episodes != null);
}
public override async Task CollectFanArtAsync(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
IResourceLocator mediaItemLocator = null;
if (!BaseInfo.IsVirtualResource(aspects))
{
mediaItemLocator = GetResourceLocator(aspects);
}
if (!aspects.ContainsKey(EpisodeAspect.ASPECT_ID) || mediaItemLocator == null)
{
return;
}
IFanArtCache fanArtCache = ServiceRegistration.Get <IFanArtCache>();
using (IResourceAccessor mediaItemAccessor = mediaItemLocator.CreateAccessor())
{
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return;
}
//Episode fanart
if (AddToCache(mediaItemId))
{
var existingThumbs = fanArtCache.GetFanArtFiles(mediaItemId, FanArtTypes.Thumbnail);
int?season = episodeInfo.SeasonNumber;
int?episode = episodeInfo.EpisodeNumbers != null && episodeInfo.EpisodeNumbers.Any() ? episodeInfo.EpisodeNumbers.First() : (int?)null;
if (!existingThumbs.Any()) //Only get thumb if needed for better performance
{
NfoSeriesEpisodeReader episodeReader = await SERIES_EXTRACTOR.TryGetNfoSeriesEpisodeReaderAsync(mediaItemAccessor, season, episode, true).ConfigureAwait(false);
if (episodeReader != null)
{
var stubs = episodeReader.GetEpisodeStubs();
var mainStub = stubs?.FirstOrDefault();
if (mainStub?.Thumb != null)
{
await fanArtCache.TrySaveFanArt(mediaItemId, episodeInfo.ToString(), FanArtTypes.Thumbnail, p => TrySaveFileImage(mainStub.Thumb, p, "Thumb", "Nfo.")).ConfigureAwait(false);
}
}
}
}
//Series fanart
if (RelationshipExtractorUtils.TryGetLinkedId(SeriesAspect.ROLE_SERIES, aspects, out Guid seriesMediaItemId))
{
IList <Tuple <Guid, string> > actors = GetActors(aspects);
RelationshipExtractorUtils.TryGetLinkedId(SeasonAspect.ROLE_SEASON, aspects, out Guid seasonMediaItemId);
//Check if loading nfo is needed
if ((actors?.All(a => IsInCache(a.Item1)) ?? true) && IsInCache(seriesMediaItemId) && (seasonMediaItemId == Guid.Empty || IsInCache(seasonMediaItemId)))
{
return; //Everything was already saved
}
NfoSeriesReader seriesNfoReader = await SERIES_EXTRACTOR.TryGetNfoSeriesReaderAsync(mediaItemAccessor, true).ConfigureAwait(false);
if (seriesNfoReader != null)
{
var stubs = seriesNfoReader.GetSeriesStubs();
var mainStub = stubs?.FirstOrDefault();
if (AddToCache(seriesMediaItemId))
{
var series = episodeInfo.CloneBasicInstance <SeriesInfo>();
if (mainStub?.Thumbs?.Count > 0)
{
await TrySaveThumbStubs(fanArtCache, mainStub.Thumbs, null, seriesMediaItemId, series.ToString());
}
}
if (seasonMediaItemId != Guid.Empty && episodeInfo.SeasonNumber.HasValue && AddToCache(seasonMediaItemId))
{
var season = episodeInfo.CloneBasicInstance <SeasonInfo>();
if (mainStub?.Thumbs?.Count > 0)
{
await TrySaveThumbStubs(fanArtCache, mainStub.Thumbs, episodeInfo.SeasonNumber, seasonMediaItemId, season.ToString());
}
}
//Actor fanart
//We only want the series actors because thumb loading is disabled on episode actors for performance reasons, so we might need to
//load the series nfo multiple time before we have all actors depending on what actors are in the episode
foreach (var actor in actors)
{
if (!IsInCache(actor.Item1))
{
var existingThumbs = fanArtCache.GetFanArtFiles(actor.Item1, FanArtTypes.Thumbnail);
var actorStub = mainStub?.Actors?.FirstOrDefault(a => string.Equals(a?.Name, actor.Item2, StringComparison.InvariantCultureIgnoreCase));
if (actorStub != null || existingThumbs.Any()) //We have a thumb already or no thumb is available, so no need to check again
{
AddToCache(actor.Item1);
}
if (actorStub?.Thumb != null)
{
await fanArtCache.TrySaveFanArt(actor.Item1, actor.Item2, FanArtTypes.Thumbnail, p => TrySaveFileImage(actorStub.Thumb, p, "Thumb", "Nfo.")).ConfigureAwait(false);
}
}
}
}
}
}
}
public override async Task <List <EpisodeInfo> > SearchSeriesEpisodeAsync(EpisodeInfo episodeSearch, TvdbLanguage language)
{
language = language ?? PreferredLanguage;
SeriesInfo seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>();
if (episodeSearch.SeriesTvdbId <= 0 && string.IsNullOrEmpty(episodeSearch.SeriesImdbId))
{
if (!await SearchSeriesUniqueAndUpdateAsync(seriesSearch, language).ConfigureAwait(false))
{
return(null);
}
episodeSearch.CopyIdsFrom(seriesSearch);
}
List <EpisodeInfo> episodes = null;
if ((episodeSearch.SeriesTvdbId > 0 || !string.IsNullOrEmpty(episodeSearch.SeriesImdbId)) && episodeSearch.SeasonNumber.HasValue)
{
int seriesId = 0;
if (episodeSearch.SeriesTvdbId > 0)
{
seriesId = episodeSearch.SeriesTvdbId;
}
else if (!string.IsNullOrEmpty(episodeSearch.SeriesImdbId))
{
TvdbSearchResult searchResult = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, episodeSearch.SeriesImdbId);
if (searchResult?.Id > 0)
{
seriesId = searchResult.Id;
}
}
TvdbSeries seriesDetail = await _tvdbHandler.GetSeriesAsync(seriesId, language, true, false, false).ConfigureAwait(false);
if (seriesDetail == null)
{
return(null);
}
foreach (TvdbEpisode episode in seriesDetail.Episodes.OrderByDescending(e => e.Id))
{
if ((episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber) || episodeSearch.EpisodeNumbers.Count == 0) &&
(episodeSearch.SeasonNumber == episode.SeasonNumber || episodeSearch.SeasonNumber.HasValue == false))
{
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
}
EpisodeInfo info = new EpisodeInfo
{
TvdbId = episode.Id,
SeriesName = new SimpleTitle(seriesDetail.SeriesName, false),
SeasonNumber = episode.SeasonNumber,
EpisodeName = new SimpleTitle(episode.EpisodeName, false),
};
info.EpisodeNumbers.Add(episode.EpisodeNumber);
info.CopyIdsFrom(seriesSearch);
info.Languages.Add(episode.Language.Abbriviation);
if (!episodes.Contains(info))
{
episodes.Add(info);
}
}
}
if (episodes != null)
{
episodes.Sort();
}
}
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
EpisodeInfo info = new EpisodeInfo
{
SeriesName = seriesSearch.SeriesName,
SeasonNumber = episodeSearch.SeasonNumber,
EpisodeName = episodeSearch.EpisodeName,
};
info.CopyIdsFrom(seriesSearch);
info.EpisodeNumbers = info.EpisodeNumbers.Union(episodeSearch.EpisodeNumbers).ToList();
info.Languages = seriesSearch.Languages;
episodes.Add(info);
}
return(episodes);
}
