public async Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return(false);
}
TrackInfo trackInfo = new TrackInfo();
if (!trackInfo.FromMetadata(aspects))
{
return(false);
}
if (AudioMetadataExtractor.IncludeComposerDetails && !AudioMetadataExtractor.SkipOnlineSearches)
{
await OnlineMatcherService.Instance.UpdateTrackPersonsAsync(trackInfo, PersonAspect.OCCUPATION_COMPOSER, false).ConfigureAwait(false);
}
foreach (PersonInfo person in trackInfo.Composers)
{
IDictionary <Guid, IList <MediaItemAspect> > personAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
if (person.SetMetadata(personAspects) && personAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
extractedLinkedAspects.Add(personAspects);
}
}
return(extractedLinkedAspects.Count > 0);
}
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?episodeMediaItemId, Guid?seriesMediaItemId, Guid?seasonMediaItemId, EpisodeInfo episode, SeriesInfo series, SeasonInfo season, IDictionary <Guid, string> actorMediaItems)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
IResourceLocator mediaItemLocater = GetResourceLocator(aspects);
if (mediaItemLocater == null)
{
return;
}
ExtractFolderImages(mediaItemLocater, episodeMediaItemId, seriesMediaItemId, seasonMediaItemId, episode, series, season, actorMediaItems);
using (IResourceAccessor mediaItemAccessor = mediaItemLocater.CreateAccessor())
{
using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor))
{
using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess())
{
ExtractMkvImages(rah.LocalFsResourceAccessor, seriesMediaItemId, series);
}
}
}
}
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?albumMediaItemId, IDictionary <Guid, string> artistMediaItems, string albumTitle)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
IResourceLocator mediaItemLocater = GetResourceLocator(aspects);
if (mediaItemLocater == null)
{
return;
}
ExtractFolderImages(mediaItemLocater, albumMediaItemId, artistMediaItems, albumTitle);
using (IResourceAccessor mediaItemAccessor = mediaItemLocater.CreateAccessor())
{
using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor))
{
using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess())
{
ExtractFileImages(rah.LocalFsResourceAccessor, albumMediaItemId, albumTitle);
}
}
}
}
public async Task<bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary<Guid, IList<MediaItemAspect>> aspects, IList<IDictionary<Guid, IList<MediaItemAspect>>> extractedLinkedAspects)
{
if (BaseInfo.IsVirtualResource(aspects))
return false;
MovieInfo movieInfo = new MovieInfo();
if (!movieInfo.FromMetadata(aspects))
return false;
if (RelationshipExtractorUtils.TryCreateInfoFromLinkedAspects(extractedLinkedAspects, out List<PersonInfo> writers))
movieInfo.Writers = writers;
if (MovieMetadataExtractor.IncludeWriterDetails && !MovieMetadataExtractor.SkipOnlineSearches)
await OnlineMatcherService.Instance.UpdatePersonsAsync(movieInfo, PersonAspect.OCCUPATION_WRITER).ConfigureAwait(false);
foreach (PersonInfo person in movieInfo.Writers)
{
if (person.LinkedAspects != null)
person.SetLinkedMetadata();
else
{
IDictionary<Guid, IList<MediaItemAspect>> personAspects = new Dictionary<Guid, IList<MediaItemAspect>>();
if (person.SetMetadata(personAspects) && personAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
extractedLinkedAspects.Add(personAspects);
}
}
return extractedLinkedAspects.Count > 0;
}
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?movieMediaItemId, Guid?collectionMediaItemId, string movieName, string collectionName, IDictionary <Guid, string> actorMediaItems)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
IResourceLocator mediaItemLocater = GetResourceLocator(aspects);
if (mediaItemLocater == null)
{
return;
}
ExtractFolderImages(mediaItemLocater, movieMediaItemId, collectionMediaItemId, movieName, collectionName, actorMediaItems);
using (IResourceAccessor mediaItemAccessor = mediaItemLocater.CreateAccessor())
{
using (LocalFsResourceAccessorHelper rah = new LocalFsResourceAccessorHelper(mediaItemAccessor))
{
using (rah.LocalFsResourceAccessor.EnsureLocalFileSystemAccess())
{
ExtractMkvImages(rah.LocalFsResourceAccessor, movieMediaItemId, movieName);
}
}
}
}
private void ExtractFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?albumMediaItemId, IDictionary <Guid, string> artistMediaItems)
{
if (aspects.ContainsKey(AudioAspect.ASPECT_ID))
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
TrackInfo trackInfo = new TrackInfo();
trackInfo.FromMetadata(aspects);
bool forceFanart = !trackInfo.IsRefreshed;
AlbumInfo albumInfo = trackInfo.CloneBasicInstance <AlbumInfo>();
ExtractLocalImages(aspects, albumMediaItemId, artistMediaItems, albumInfo.ToString());
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(mediaItemId, trackInfo, forceFanart);
}
if (albumMediaItemId.HasValue && !_checkCache.Contains(albumMediaItemId.Value))
{
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(albumMediaItemId.Value, albumInfo, forceFanart);
}
_checkCache.Add(albumMediaItemId.Value);
}
}
else if (aspects.ContainsKey(PersonAspect.ASPECT_ID))
{
PersonInfo personInfo = new PersonInfo();
personInfo.FromMetadata(aspects);
if (personInfo.Occupation == PersonAspect.OCCUPATION_ARTIST || personInfo.Occupation == PersonAspect.OCCUPATION_COMPOSER)
{
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(mediaItemId, personInfo, !personInfo.IsRefreshed);
}
}
}
else if (aspects.ContainsKey(CompanyAspect.ASPECT_ID))
{
CompanyInfo companyInfo = new CompanyInfo();
companyInfo.FromMetadata(aspects);
if (companyInfo.Type == CompanyAspect.COMPANY_MUSIC_LABEL)
{
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(mediaItemId, companyInfo, !companyInfo.IsRefreshed);
}
}
}
}
private void ExtractFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
if (aspects.ContainsKey(VideoAspect.ASPECT_ID))
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
MovieInfo movieInfo = new MovieInfo();
movieInfo.FromMetadata(aspects);
bool forceFanart = !movieInfo.IsRefreshed;
ExtractLocalImages(aspects, mediaItemId, movieInfo.ToString());
}
}
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?episodeMediaItemId, Guid?seriesMediaItemId, Guid?seasonMediaItemId, EpisodeInfo episode, SeriesInfo series, SeasonInfo season, IDictionary <Guid, string> actorMediaItems)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
IResourceLocator mediaItemLocater = GetResourceLocator(aspects);
if (mediaItemLocater == null)
{
return;
}
ExtractFolderImages(mediaItemLocater, episodeMediaItemId, seriesMediaItemId, seasonMediaItemId, episode, series, season, actorMediaItems);
}
private void ExtractLocalImages(IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?movieMediaItemId, Guid?collectionMediaItemId, string movieName, string collectionName, IDictionary <Guid, string> actorMediaItems)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
IResourceLocator mediaItemLocater = GetResourceLocator(aspects);
if (mediaItemLocater == null)
{
return;
}
ExtractFolderImages(mediaItemLocater, movieMediaItemId, collectionMediaItemId, movieName, collectionName, actorMediaItems);
}
public async Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return(false);
}
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return(false);
}
if (RelationshipExtractorUtils.TryCreateInfoFromLinkedAspects(extractedLinkedAspects, out List <PersonInfo> directors))
{
episodeInfo.Directors = directors;
}
if (SeriesMetadataExtractor.IncludeDirectorDetails && !SeriesMetadataExtractor.SkipOnlineSearches)
{
await OnlineMatcherService.Instance.UpdateEpisodePersonsAsync(episodeInfo, PersonAspect.OCCUPATION_DIRECTOR).ConfigureAwait(false);
}
foreach (PersonInfo person in episodeInfo.Directors)
{
if (person.LinkedAspects != null)
{
person.SetLinkedMetadata();
}
else
{
IDictionary <Guid, IList <MediaItemAspect> > personAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
if (person.SetMetadata(personAspects) && personAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
extractedLinkedAspects.Add(personAspects);
}
}
}
return(extractedLinkedAspects.Count > 0);
}
public async Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return(false);
}
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return(false);
}
if (RelationshipExtractorUtils.TryCreateInfoFromLinkedAspects(extractedLinkedAspects, out List <CharacterInfo> characters))
{
episodeInfo.Characters = characters;
}
if (SeriesMetadataExtractor.IncludeCharacterDetails && !SeriesMetadataExtractor.SkipOnlineSearches)
{
await OnlineMatcherService.Instance.UpdateEpisodeCharactersAsync(episodeInfo, _category).ConfigureAwait(false);
}
foreach (CharacterInfo character in episodeInfo.Characters.Take(SeriesMetadataExtractor.MaximumCharacterCount))
{
if (character.LinkedAspects != null)
{
character.SetLinkedMetadata();
}
else
{
IDictionary <Guid, IList <MediaItemAspect> > characterAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
if (character.SetMetadata(characterAspects) && characterAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
extractedLinkedAspects.Add(characterAspects);
}
}
}
return(extractedLinkedAspects.Count > 0);
}
public override async Task CollectFanArtAsync(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
//Virtual resources won't have local fanart
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
//Don't process the same item again
if (!AddToCache(mediaItemId))
{
return;
}
IResourceLocator mediaItemLocator = GetResourceLocator(aspects);
if (mediaItemLocator == null)
{
return;
}
//Only needed for the name used in the fanart cache
MovieInfo movieInfo = new MovieInfo();
movieInfo.FromMetadata(aspects);
string title = movieInfo.ToString();
//Fanart files in the local directory
if (ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath, VideoMetadataExtractor.CacheLocalFanArt, VideoMetadataExtractor.CacheOfflineFanArt))
{
await ExtractFolderFanArt(mediaItemLocator, mediaItemId, title).ConfigureAwait(false);
}
//Fanart in MKV tags
if (MKV_EXTENSIONS.Contains(ResourcePathHelper.GetExtension(mediaItemLocator.NativeResourcePath.FileName)))
{
await ExtractMkvFanArt(mediaItemLocator, mediaItemId, title).ConfigureAwait(false);
}
}
public async Task<bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary<Guid, IList<MediaItemAspect>> aspects, IList<IDictionary<Guid, IList<MediaItemAspect>>> extractedLinkedAspects)
{
if (BaseInfo.IsVirtualResource(aspects))
return false;
TrackInfo trackInfo = new TrackInfo();
if (!trackInfo.FromMetadata(aspects))
return false;
AudioMetadataExtractor.TryUpdateArtists(mediaItemAccessor, trackInfo.Artists, false);
if (AudioMetadataExtractor.IncludeArtistDetails && !AudioMetadataExtractor.SkipOnlineSearches)
await OnlineMatcherService.Instance.UpdateTrackPersonsAsync(trackInfo, PersonAspect.OCCUPATION_ARTIST, false, _category).ConfigureAwait(false);
foreach (PersonInfo person in trackInfo.Artists)
{
IDictionary<Guid, IList<MediaItemAspect>> personAspects = new Dictionary<Guid, IList<MediaItemAspect>>();
if (person.SetMetadata(personAspects) && personAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
extractedLinkedAspects.Add(personAspects);
}
return extractedLinkedAspects.Count > 0;
}
public Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return(Task.FromResult(false));
}
TrackInfo trackInfo = new TrackInfo();
if (!trackInfo.FromMetadata(aspects))
{
return(Task.FromResult(false));
}
foreach (PersonInfo person in trackInfo.Conductors)
{
IDictionary <Guid, IList <MediaItemAspect> > personAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
if (person.SetMetadata(personAspects) && personAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
extractedLinkedAspects.Add(personAspects);
}
}
return(Task.FromResult(extractedLinkedAspects.Count > 0));
}
public async Task <bool> TryExtractRelationshipsAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > aspects, IList <IDictionary <Guid, IList <MediaItemAspect> > > extractedLinkedAspects)
{
if (BaseInfo.IsVirtualResource(aspects))
{
return(false);
}
MovieInfo movieInfo = new MovieInfo();
if (!movieInfo.FromMetadata(aspects))
{
return(false);
}
if (MovieMetadataExtractor.IncludeProductionCompanyDetails && !MovieMetadataExtractor.SkipOnlineSearches)
{
await OnlineMatcherService.Instance.UpdateCompaniesAsync(movieInfo, CompanyAspect.COMPANY_PRODUCTION, _category).ConfigureAwait(false);
}
foreach (CompanyInfo company in movieInfo.ProductionCompanies)
{
if (company.LinkedAspects != null)
{
company.SetLinkedMetadata();
}
else
{
IDictionary <Guid, IList <MediaItemAspect> > companyAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
if (company.SetMetadata(companyAspects) && companyAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
extractedLinkedAspects.Add(companyAspects);
}
}
}
return(extractedLinkedAspects.Count > 0);
}
protected async Task ExtractAlbumAndArtistFanArt(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,
AudioMetadataExtractor.CacheLocalFanArt, AudioMetadataExtractor.CacheOfflineFanArt);
}
if (mediaItemLocator == null)
{
return;
}
if (!shouldCacheLocal && AudioMetadataExtractor.SkipFanArtDownload)
{
return; //Nothing to do
}
TrackInfo trackInfo = new TrackInfo();
trackInfo.FromMetadata(aspects);
AlbumInfo albumInfo = trackInfo.CloneBasicInstance <AlbumInfo>();
string albumTitle = albumInfo.ToString();
ResourcePath albumDirectory = null;
if (shouldCacheLocal)
{
albumDirectory = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../");
if (AudioMetadataExtractor.IsDiscFolder(albumTitle, albumDirectory.FileName))
{
//Probably a CD folder so try next parent
albumDirectory = ResourcePathHelper.Combine(albumDirectory, "../");
}
}
//Artist fanart may be stored in the album directory, so get the artists now
IList <Tuple <Guid, string> > artists = GetArtists(aspects);
//Album fanart
if (RelationshipExtractorUtils.TryGetLinkedId(AudioAlbumAspect.ROLE_ALBUM, aspects, out Guid albumMediaItemId) &&
AddToCache(albumMediaItemId))
{
if (shouldCacheLocal)
{
//If the track is not a stub, Store track tag images in the album
if (!aspects.ContainsKey(ReimportAspect.ASPECT_ID) && MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_ISSTUB, out bool isStub) && isStub == false)
{
await ExtractTagFanArt(mediaItemLocator, albumMediaItemId, albumTitle);
}
await ExtractAlbumFolderFanArt(mediaItemLocator.NativeSystemId, albumDirectory, albumMediaItemId, albumTitle, artists).ConfigureAwait(false);
}
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadAudioFanArtAsync(albumMediaItemId, albumInfo).ConfigureAwait(false);
}
}
if (shouldCacheLocal && artists != null)
{
await ExtractArtistFolderFanArt(mediaItemLocator.NativeSystemId, albumDirectory, artists).ConfigureAwait(false);
}
}
protected async Task ExtractMovieFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
bool shouldCacheLocal = false;
IResourceLocator mediaItemLocator = null;
if (!BaseInfo.IsVirtualResource(aspects))
{
mediaItemLocator = GetResourceLocator(aspects);
if (mediaItemLocator == null)
{
return;
}
//Whether local fanart should be stored in the fanart cache
shouldCacheLocal = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath,
MovieMetadataExtractor.CacheLocalFanArt, MovieMetadataExtractor.CacheOfflineFanArt);
}
if (!shouldCacheLocal && MovieMetadataExtractor.SkipFanArtDownload)
{
return; //Nothing to do
}
MovieInfo movieInfo = new MovieInfo();
movieInfo.FromMetadata(aspects);
//Movie fanart
if (AddToCache(mediaItemId))
{
//Actor fanart may be stored in the movie 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);
}
}
if (shouldCacheLocal)
{
await ExtractMovieFolderFanArt(mediaItemLocator, mediaItemId, movieInfo.ToString(), actors).ConfigureAwait(false);
}
if (!MovieMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadMovieFanArtAsync(mediaItemId, movieInfo).ConfigureAwait(false);
}
}
//Collection fanart
if (RelationshipExtractorUtils.TryGetLinkedId(MovieCollectionAspect.ROLE_MOVIE_COLLECTION, aspects, out Guid collectionMediaItemId) &&
AddToCache(collectionMediaItemId))
{
MovieCollectionInfo collectionInfo = movieInfo.CloneBasicInstance <MovieCollectionInfo>();
if (shouldCacheLocal)
{
await ExtractCollectionFolderFanArt(mediaItemLocator, collectionMediaItemId, collectionInfo.ToString()).ConfigureAwait(false);
}
if (!MovieMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadMovieFanArtAsync(collectionMediaItemId, collectionInfo).ConfigureAwait(false);
}
}
}
public bool TryExtractRelationships(IDictionary <Guid, IList <MediaItemAspect> > aspects, bool importOnly, out IList <RelationshipItem> extractedLinkedAspects)
{
extractedLinkedAspects = null;
if (!MovieMetadataExtractor.IncludeWriterDetails)
{
return(false);
}
if (importOnly)
{
return(false);
}
if (BaseInfo.IsVirtualResource(aspects))
{
return(false);
}
MovieInfo movieInfo = new MovieInfo();
if (!movieInfo.FromMetadata(aspects))
{
return(false);
}
if (CheckCacheContains(movieInfo))
{
return(false);
}
int count = 0;
if (!MovieMetadataExtractor.SkipOnlineSearches)
{
OnlineMatcherService.Instance.UpdatePersons(movieInfo, PersonAspect.OCCUPATION_WRITER, importOnly);
count = movieInfo.Writers.Where(p => p.HasExternalId).Count();
if (!movieInfo.IsRefreshed)
{
movieInfo.HasChanged = true; //Force save to update external Ids for metadata found by other MDEs
}
}
else
{
count = movieInfo.Writers.Where(p => !string.IsNullOrEmpty(p.Name)).Count();
}
if (movieInfo.Writers.Count == 0)
{
return(false);
}
if (BaseInfo.CountRelationships(aspects, LinkedRole) < count || (BaseInfo.CountRelationships(aspects, LinkedRole) == 0 && movieInfo.Writers.Count > 0))
{
movieInfo.HasChanged = true; //Force save if no relationship exists
}
if (!movieInfo.HasChanged)
{
return(false);
}
AddToCheckCache(movieInfo);
extractedLinkedAspects = new List <RelationshipItem>();
foreach (PersonInfo person in movieInfo.Writers)
{
person.AssignNameId();
person.HasChanged = movieInfo.HasChanged;
IDictionary <Guid, IList <MediaItemAspect> > personAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
person.SetMetadata(personAspects);
if (personAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
Guid existingId;
if (TryGetIdFromCache(person, out existingId))
{
extractedLinkedAspects.Add(new RelationshipItem(personAspects, existingId));
}
else
{
extractedLinkedAspects.Add(new RelationshipItem(personAspects, Guid.Empty));
}
}
}
return(extractedLinkedAspects.Count > 0);
}
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 CollectFanArtAsync(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
IResourceLocator mediaItemLocator = null;
if (!BaseInfo.IsVirtualResource(aspects))
{
mediaItemLocator = GetResourceLocator(aspects);
}
if (!aspects.ContainsKey(AudioAspect.ASPECT_ID) || mediaItemLocator == null)
{
return;
}
IFanArtCache fanArtCache = ServiceRegistration.Get <IFanArtCache>();
using (IResourceAccessor mediaItemAccessor = mediaItemLocator.CreateAccessor())
{
//Album fanart
if (RelationshipExtractorUtils.TryGetLinkedId(AudioAlbumAspect.ROLE_ALBUM, aspects, out Guid albumMediaItemId) && AddToCache(albumMediaItemId))
{
var existingCovers = fanArtCache.GetFanArtFiles(albumMediaItemId, FanArtTypes.Cover);
if (!existingCovers.Any()) //Only get album cover if needed for better performance
{
NfoAlbumReader albumNfoReader = await AUDIO_EXTRACTOR.TryGetNfoAlbumReaderAsync(mediaItemAccessor, true).ConfigureAwait(false);
if (albumNfoReader != null)
{
var stubs = albumNfoReader.GetAlbumStubs();
var mainStub = stubs?.FirstOrDefault();
if (mainStub?.Thumb != null)
{
await fanArtCache.TrySaveFanArt(albumMediaItemId, mainStub.Title, FanArtTypes.Cover, p => TrySaveFileImage(mainStub.Thumb, p, "Thumb", "Nfo.")).ConfigureAwait(false);
}
}
}
}
//Artist fanart
IList <Tuple <Guid, string> > artists = GetArtists(aspects);
if (artists?.Count > 0)
{
foreach (var artist in artists)
{
var existingThumbs = fanArtCache.GetFanArtFiles(artist.Item1, FanArtTypes.Thumbnail);
if (!existingThumbs.Any() && AddToCache(artist.Item1)) //Only get artist thumbnail if needed for better performance
{
NfoArtistReader artistReader = await AUDIO_EXTRACTOR.TryGetNfoArtistReaderAsync(mediaItemAccessor, artist.Item2, true).ConfigureAwait(false);
if (artistReader != null)
{
var stubs = artistReader.GetArtistStubs();
var mainStub = stubs?.FirstOrDefault();
if (string.Equals(mainStub?.Name, artist.Item2, StringComparison.InvariantCultureIgnoreCase))
{
if (mainStub?.Thumb != null)
{
await fanArtCache.TrySaveFanArt(artist.Item1, artist.Item2, FanArtTypes.Thumbnail, p => TrySaveFileImage(mainStub.Thumb, p, "Thumb", "Nfo.")).ConfigureAwait(false);
}
}
}
}
}
}
}
}
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(MovieAspect.ASPECT_ID) || mediaItemLocator == null)
{
return;
}
IFanArtCache fanArtCache = ServiceRegistration.Get <IFanArtCache>();
using (IResourceAccessor mediaItemAccessor = mediaItemLocator.CreateAccessor())
{
IList <Tuple <Guid, string> > actors = GetActors(aspects);
//Check if loading nfo is needed
if ((actors?.All(a => IsInCache(a.Item1)) ?? true) && IsInCache(mediaItemId))
{
return; //Everything was already saved
}
NfoMovieReader movieNfoReader = await MOVIE_EXTRACTOR.TryGetNfoMovieReaderAsync(mediaItemAccessor, true).ConfigureAwait(false);
if (movieNfoReader != null)
{
//Movie fanart
var stubs = movieNfoReader.GetMovieStubs();
var mainStub = stubs?.FirstOrDefault();
if (AddToCache(mediaItemId))
{
if (mainStub?.Thumb != null)
{
await fanArtCache.TrySaveFanArt(mediaItemId, mainStub.Title, FanArtTypes.Poster, p => TrySaveFileImage(mainStub.Thumb, p, "Thumb", "Nfo.")).ConfigureAwait(false);
}
await TrySaveFanArt(fanArtCache, FanArtTypes.FanArt, "FanArt", mainStub?.FanArt, mediaItemId, mainStub?.Title).ConfigureAwait(false);
await TrySaveFanArt(fanArtCache, FanArtTypes.DiscArt, "DiscArt", mainStub?.DiscArt, mediaItemId, mainStub?.Title).ConfigureAwait(false);
await TrySaveFanArt(fanArtCache, FanArtTypes.Logo, "Logo", mainStub?.Logos, mediaItemId, mainStub?.Title).ConfigureAwait(false);
await TrySaveFanArt(fanArtCache, FanArtTypes.ClearArt, "ClearArt", mainStub?.ClearArt, mediaItemId, mainStub?.Title).ConfigureAwait(false);
await TrySaveFanArt(fanArtCache, FanArtTypes.Banner, "Banner", mainStub?.Banners, mediaItemId, mainStub?.Title).ConfigureAwait(false);
await TrySaveFanArt(fanArtCache, FanArtTypes.Thumbnail, "Landscape", mainStub?.Landscape, mediaItemId, mainStub?.Title).ConfigureAwait(false);
}
//Actor fanart
if (actors != null)
{
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);
}
}
}
}
}
}
}
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);
}
}
}
}
}
private void ExtractFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?collectionMediaItemId, IDictionary <Guid, string> actorMediaItems)
{
if (aspects.ContainsKey(MovieAspect.ASPECT_ID))
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
MovieInfo movieInfo = new MovieInfo();
movieInfo.FromMetadata(aspects);
bool forceFanart = !movieInfo.IsRefreshed;
MovieCollectionInfo collectionInfo = movieInfo.CloneBasicInstance <MovieCollectionInfo>();
ExtractLocalImages(aspects, mediaItemId, collectionMediaItemId, movieInfo.ToString(), collectionInfo.ToString(), actorMediaItems);
if (!MovieMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadMovieFanArt(mediaItemId, movieInfo, forceFanart);
}
//Take advantage of the movie language being known and download collection too
if (collectionMediaItemId.HasValue && !_checkCache.Contains(collectionMediaItemId.Value))
{
if (!MovieMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadMovieFanArt(collectionMediaItemId.Value, collectionInfo, forceFanart);
}
_checkCache.Add(collectionMediaItemId.Value);
}
}
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 (!MovieMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadMovieFanArt(mediaItemId, personInfo, !personInfo.IsRefreshed);
}
}
}
else if (aspects.ContainsKey(CharacterAspect.ASPECT_ID))
{
CharacterInfo characterInfo = new CharacterInfo();
characterInfo.FromMetadata(aspects);
if (!MovieMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadMovieFanArt(mediaItemId, characterInfo, !characterInfo.IsRefreshed);
}
}
else if (aspects.ContainsKey(CompanyAspect.ASPECT_ID))
{
CompanyInfo companyInfo = new CompanyInfo();
companyInfo.FromMetadata(aspects);
if (companyInfo.Type == CompanyAspect.COMPANY_PRODUCTION)
{
if (!MovieMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadMovieFanArt(mediaItemId, companyInfo, !companyInfo.IsRefreshed);
}
}
}
}
public override async Task CollectFanArtAsync(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
//Virtual resources won't have local fanart
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
//Don't process the same item again
if (!AddToCache(mediaItemId))
{
return;
}
IResourceLocator mediaItemLocator = GetResourceLocator(aspects);
if (mediaItemLocator == null)
{
return;
}
//Only needed for the name used in the fanart cache
string title = "";
if (aspects.ContainsKey(MovieAspect.ASPECT_ID))
{
MediaItemAspect.TryGetAttribute(aspects, MovieAspect.ATTR_MOVIE_NAME, out title);
}
else if (aspects.ContainsKey(VideoAspect.ASPECT_ID))
{
MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_TITLE, out title);
}
else if (aspects.ContainsKey(MediaAspect.ASPECT_ID))
{
MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_TITLE, out title);
}
bool shouldCacheFanart = false;
if (aspects.ContainsKey(MovieAspect.ASPECT_ID))
{
shouldCacheFanart = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath, VideoMetadataExtractor.CacheLocalMovieFanArt, VideoMetadataExtractor.CacheOfflineMovieFanArt);
}
else if (aspects.ContainsKey(EpisodeAspect.ASPECT_ID))
{
shouldCacheFanart = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath, VideoMetadataExtractor.CacheLocalSeriesFanArt, VideoMetadataExtractor.CacheOfflineSeriesFanArt);
}
else if (aspects.ContainsKey(VideoAspect.ASPECT_ID))
{
shouldCacheFanart = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath, VideoMetadataExtractor.CacheLocalFanArt, VideoMetadataExtractor.CacheOfflineFanArt);
}
if (shouldCacheFanart)
{
//Fanart files in the local directory
//Fanart for movies and episodes is handled in other MDE's
if (!aspects.ContainsKey(EpisodeAspect.ASPECT_ID) && !aspects.ContainsKey(MovieAspect.ASPECT_ID))
{
await ExtractFolderFanArt(mediaItemLocator, mediaItemId, title, aspects).ConfigureAwait(false);
}
//Fanart in tags and media
await ExtractFanArt(mediaItemLocator, mediaItemId, title, aspects).ConfigureAwait(false);
}
}
public bool TryExtractRelationships(IDictionary <Guid, IList <MediaItemAspect> > aspects, bool importOnly, out IList <RelationshipItem> extractedLinkedAspects)
{
extractedLinkedAspects = null;
if (!SeriesMetadataExtractor.IncludeCharacterDetails)
{
return(false);
}
if (importOnly)
{
return(false);
}
if (BaseInfo.IsVirtualResource(aspects))
{
return(false);
}
EpisodeInfo episodeInfo = new EpisodeInfo();
if (!episodeInfo.FromMetadata(aspects))
{
return(false);
}
if (CheckCacheContains(episodeInfo))
{
return(false);
}
int count = 0;
if (!SeriesMetadataExtractor.SkipOnlineSearches)
{
OnlineMatcherService.Instance.UpdateEpisodeCharacters(episodeInfo, importOnly);
count = episodeInfo.Characters.Where(p => p.HasExternalId).Count();
if (!episodeInfo.IsRefreshed)
{
episodeInfo.HasChanged = true; //Force save to update external Ids for metadata found by other MDEs
}
}
else
{
count = episodeInfo.Characters.Where(p => !string.IsNullOrEmpty(p.Name)).Count();
}
if (episodeInfo.Characters.Count == 0)
{
return(false);
}
if (BaseInfo.CountRelationships(aspects, LinkedRole) < count || (BaseInfo.CountRelationships(aspects, LinkedRole) == 0 && episodeInfo.Characters.Count > 0))
{
episodeInfo.HasChanged = true; //Force save if no relationship exists
}
if (!episodeInfo.HasChanged)
{
return(false);
}
AddToCheckCache(episodeInfo);
extractedLinkedAspects = new List <RelationshipItem>();
foreach (CharacterInfo character in episodeInfo.Characters)
{
character.AssignNameId();
character.HasChanged = episodeInfo.HasChanged;
IDictionary <Guid, IList <MediaItemAspect> > characterAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
character.SetMetadata(characterAspects);
if (characterAspects.ContainsKey(ExternalIdentifierAspect.ASPECT_ID))
{
Guid existingId;
if (TryGetIdFromCache(character, out existingId))
{
extractedLinkedAspects.Add(new RelationshipItem(characterAspects, existingId));
}
else
{
extractedLinkedAspects.Add(new RelationshipItem(characterAspects, Guid.Empty));
}
}
}
return(extractedLinkedAspects.Count > 0);
}
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);
}
}
}
