Example #1
0
        /// <summary>
        /// Saves the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var builder = new StringBuilder();

            builder.Append("<Item>");

            var game = (Game)item;

            if (game.PlayersSupported.HasValue)
            {
                builder.Append("<Players>" + SecurityElement.Escape(game.PlayersSupported.Value.ToString(UsCulture)) + "</Players>");
            }

            if (!string.IsNullOrEmpty(game.GameSystem))
            {
                builder.Append("<GameSystem>" + SecurityElement.Escape(game.GameSystem) + "</GameSystem>");
            }

            XmlSaverHelpers.AddCommonNodes(game, _libraryManager, builder);

            builder.Append("</Item>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
                {
                    "Players",
                    "GameSystem",
                    "NesBox",
                    "NesBoxRom"
                }, _config, _fileSystem);
        }
Example #2
0
        /// <summary>
        /// Saves the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var playlist = (Playlist)item;

            var builder = new StringBuilder();

            builder.Append("<Item>");

            if (!string.IsNullOrEmpty(playlist.PlaylistMediaType))
            {
                builder.Append("<PlaylistMediaType>" + SecurityElement.Escape(playlist.PlaylistMediaType) + "</PlaylistMediaType>");
            }

            XmlSaverHelpers.AddCommonNodes(playlist, _libraryManager, builder);

            builder.Append("</Item>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
            {
                "OwnerUserId",
                "PlaylistMediaType"

            }, _config);
        }
Example #3
0
        protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
        {
            var imdb = item.GetProviderId(MetadataProviders.Imdb);

            if (!string.IsNullOrEmpty(imdb))
            {
                writer.WriteElementString("id", imdb);
            }

            var musicVideo = item as MusicVideo;

            if (musicVideo != null)
            {
                if (!string.IsNullOrEmpty(musicVideo.Artist))
                {
                    writer.WriteElementString("artist", musicVideo.Artist);
                }
                if (!string.IsNullOrEmpty(musicVideo.Album))
                {
                    writer.WriteElementString("album", musicVideo.Album);
                }
            }

            var movie = item as Movie;

            if (movie != null)
            {
                if (!string.IsNullOrEmpty(movie.TmdbCollectionName))
                {
                    writer.WriteElementString("set", movie.TmdbCollectionName);
                }
            }
        }
Example #4
0
        /// <summary>
        /// Saves the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var video = (Video)item;

            var builder = new StringBuilder();

            builder.Append("<Title>");

            XmlSaverHelpers.AddCommonNodes(video, builder);

            if (video.CommunityRating.HasValue)
            {
                builder.Append("<IMDBrating>" + SecurityElement.Escape(video.CommunityRating.Value.ToString(UsCulture)) + "</IMDBrating>");
            }

            if (!string.IsNullOrEmpty(video.Overview))
            {
                builder.Append("<Description><![CDATA[" + video.Overview + "]]></Description>");
            }

            var musicVideo = item as MusicVideo;

            if (musicVideo != null)
            {
                if (!string.IsNullOrEmpty(musicVideo.Artist))
                {
                    builder.Append("<Artist>" + SecurityElement.Escape(musicVideo.Artist) + "</Artist>");
                }
                if (!string.IsNullOrEmpty(musicVideo.Album))
                {
                    builder.Append("<Album>" + SecurityElement.Escape(musicVideo.Album) + "</Album>");
                }
            }

            var movie = item as Movie;

            if (movie != null)
            {
                if (!string.IsNullOrEmpty(movie.TmdbCollectionName))
                {
                    builder.Append("<TmdbCollectionName>" + SecurityElement.Escape(movie.TmdbCollectionName) + "</TmdbCollectionName>");
                }
            }
            
            XmlSaverHelpers.AddMediaInfo(video, builder, _itemRepository);

            builder.Append("</Title>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
                {
                    "IMDBrating",
                    "Description",
                    "Artist",
                    "Album",
                    "TmdbCollectionName"
                });
        }
Example #5
0
        /// <summary>
        /// Determines whether [is enabled for] [the specified item].
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="updateType">Type of the update.</param>
        /// <returns><c>true</c> if [is enabled for] [the specified item]; otherwise, <c>false</c>.</returns>
        public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            if (!item.SupportsLocalMetadata)
            {
                return false;
            }

            return item is MusicAlbum && updateType >= ItemUpdateType.MetadataDownload;
        }
Example #6
0
        public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            if (!item.SupportsLocalMetadata)
            {
                return false;
            }

            return item is Episode && updateType >= MinimumUpdateType;
        }
Example #7
0
        /// <summary>
        /// Determines whether [is enabled for] [the specified item].
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="updateType">Type of the update.</param>
        /// <returns><c>true</c> if [is enabled for] [the specified item]; otherwise, <c>false</c>.</returns>
        public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            if (!item.SupportsLocalMetadata)
            {
                return false;
            }

            return item is Playlist && updateType >= ItemUpdateType.MetadataImport;
        }
Example #8
0
        protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
        {
            var season = (Season)item;

            if (season.IndexNumber.HasValue)
            {
                writer.WriteElementString("seasonnumber", season.IndexNumber.Value.ToString(CultureInfo.InvariantCulture));
            }
        }
Example #9
0
        public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            if (!item.SupportsLocalMetadata)
            {
                return false;
            }

            return item is Series && updateType >= ItemUpdateType.ImageUpdate;
        }
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var video = (Video)item;

            var builder = new StringBuilder();

            var tag = item is MusicVideo ? "musicvideo" : "movie";

            builder.Append("<" + tag + ">");

            XmlSaverHelpers.AddCommonNodes(video, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);

            var imdb = item.GetProviderId(MetadataProviders.Imdb);

            if (!string.IsNullOrEmpty(imdb))
            {
                builder.Append("<id>" + SecurityElement.Escape(imdb) + "</id>");
            }

            var musicVideo = item as MusicVideo;

            if (musicVideo != null)
            {
                if (!string.IsNullOrEmpty(musicVideo.Artist))
                {
                    builder.Append("<artist>" + SecurityElement.Escape(musicVideo.Artist) + "</artist>");
                }
                if (!string.IsNullOrEmpty(musicVideo.Album))
                {
                    builder.Append("<album>" + SecurityElement.Escape(musicVideo.Album) + "</album>");
                }
            }

            var movie = item as Movie;

            if (movie != null)
            {
                if (!string.IsNullOrEmpty(movie.TmdbCollectionName))
                {
                    builder.Append("<set>" + SecurityElement.Escape(movie.TmdbCollectionName) + "</set>");
                }
            }

            XmlSaverHelpers.AddMediaInfo((Video)item, _itemRepo, builder);

            builder.Append("</" + tag + ">");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
                {
                    "album",
                    "artist",
                    "set"
                });
        }
Example #11
0
        public bool HasChanged(IHasMetadata item, IDirectoryService directoryService)
        {
            var liveTvItem = item as ILiveTvRecording;

            if (liveTvItem != null)
            {
                return !liveTvItem.HasImage(ImageType.Primary);
            }
            return false;
        }
        public bool HasChanged(IHasMetadata item, MetadataStatus status, IDirectoryService directoryService)
        {
            var liveTvItem = item as LiveTvProgram;

            if (liveTvItem != null)
            {
                return !liveTvItem.HasImage(ImageType.Primary);
            }
            return false;
        }
        public bool HasChanged(IHasMetadata item, IDirectoryService directoryService, DateTime date)
        {
            var channelItem = item as IChannelItem;

            if (channelItem != null)
            {
                return !channelItem.HasImage(ImageType.Primary) && !string.IsNullOrWhiteSpace(channelItem.OriginalImageUrl);
            }
            return false;
        }
Example #14
0
        protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
        {
            var episode = (Episode)item;

            if (episode.IndexNumber.HasValue)
            {
                writer.WriteElementString("episode", episode.IndexNumber.Value.ToString(UsCulture));
            }

            if (episode.IndexNumberEnd.HasValue)
            {
                writer.WriteElementString("episodenumberend", episode.IndexNumberEnd.Value.ToString(UsCulture));
            }

            if (episode.ParentIndexNumber.HasValue)
            {
                writer.WriteElementString("season", episode.ParentIndexNumber.Value.ToString(UsCulture));
            }

            if (episode.PremiereDate.HasValue)
            {
                var formatString = ConfigurationManager.GetNfoConfiguration().ReleaseDateFormat;

                writer.WriteElementString("aired", episode.PremiereDate.Value.ToLocalTime().ToString(formatString));
            }

            if (episode.AirsAfterSeasonNumber.HasValue)
            {
                writer.WriteElementString("airsafter_season", episode.AirsAfterSeasonNumber.Value.ToString(UsCulture));
            }
            if (episode.AirsBeforeEpisodeNumber.HasValue)
            {
                writer.WriteElementString("airsbefore_episode", episode.AirsBeforeEpisodeNumber.Value.ToString(UsCulture));
            }
            if (episode.AirsBeforeSeasonNumber.HasValue)
            {
                writer.WriteElementString("airsbefore_season", episode.AirsBeforeSeasonNumber.Value.ToString(UsCulture));
            }

            if (episode.DvdEpisodeNumber.HasValue)
            {
                writer.WriteElementString("DVD_episodenumber", episode.DvdEpisodeNumber.Value.ToString(UsCulture));
            }

            if (episode.DvdSeasonNumber.HasValue)
            {
                writer.WriteElementString("DVD_season", episode.DvdSeasonNumber.Value.ToString(UsCulture));
            }

            if (episode.AbsoluteEpisodeNumber.HasValue)
            {
                writer.WriteElementString("absolute_number", episode.AbsoluteEpisodeNumber.Value.ToString(UsCulture));
            }
        }
Example #15
0
        /// <summary>
        /// Saves the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var video = (Video)item;

            var builder = new StringBuilder();

            builder.Append("<Title>");

            XmlSaverHelpers.AddCommonNodes(video, _libraryManager, builder);

            var musicVideo = item as MusicVideo;

            if (musicVideo != null)
            {
                if (musicVideo.Artists.Count > 0)
                {
                    builder.Append("<Artist>" + SecurityElement.Escape(string.Join(";", musicVideo.Artists.ToArray())) + "</Artist>");
                }
                if (!string.IsNullOrEmpty(musicVideo.Album))
                {
                    builder.Append("<Album>" + SecurityElement.Escape(musicVideo.Album) + "</Album>");
                }
            }

            var movie = item as Movie;

            if (movie != null)
            {
                if (!string.IsNullOrEmpty(movie.TmdbCollectionName))
                {
                    builder.Append("<TmdbCollectionName>" + SecurityElement.Escape(movie.TmdbCollectionName) + "</TmdbCollectionName>");
                }
            }

            XmlSaverHelpers.AddMediaInfo(video, builder, _itemRepository);

            builder.Append("</Title>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
                {
                    // Deprecated. No longer saving in this field.
                    "IMDBrating",
                    
                    // Deprecated. No longer saving in this field.
                    "Description",

                    "Artist",
                    "Album",
                    "TmdbCollectionName"
                }, _config, _fileSystem);
        }
Example #16
0
        public ItemInfo(IHasMetadata item)
        {
            Path = item.Path;
            ContainingFolderPath = item.ContainingFolderPath;
            IsInMixedFolder = item.IsInMixedFolder;

            var video = item as Video;
            if (video != null)
            {
                VideoType = video.VideoType;
            }
        }
Example #17
0
        protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
        {
            var series = (Series)item;

            var tvdb = item.GetProviderId(MetadataProviders.Tvdb);

            if (!string.IsNullOrEmpty(tvdb))
            {
                writer.WriteElementString("id", tvdb);

                writer.WriteStartElement("episodeguide");

                var language = item.GetPreferredMetadataLanguage();
                language = string.IsNullOrEmpty(language)
                    ? "en"
                    : language;

                writer.WriteStartElement("url");
                writer.WriteAttributeString("cache", string.Format("{0}.xml", tvdb));
                writer.WriteString(string.Format("http://www.thetvdb.com/api/1D62F2F90030C444/series/{0}/all/{1}.zip", tvdb, language));
                writer.WriteEndElement();
                
                writer.WriteEndElement();
            }

            writer.WriteElementString("season", "-1");
            writer.WriteElementString("episode", "-1");

            if (series.Status.HasValue)
            {
                writer.WriteElementString("status", series.Status.Value.ToString());
            }

            if (!string.IsNullOrEmpty(series.AirTime))
            {
                writer.WriteElementString("airs_time", series.AirTime);
            }

            if (series.AirDays.Count == 7)
            {
                writer.WriteElementString("airs_dayofweek", "Daily");
            }
            else if (series.AirDays.Count > 0)
            {
                writer.WriteElementString("airs_dayofweek", series.AirDays[0].ToString());
            }

            if (series.AnimeSeriesIndex.HasValue)
            {
                writer.WriteElementString("animeseriesindex", series.AnimeSeriesIndex.Value.ToString(CultureInfo.InvariantCulture));
            }
        }
        public string GetSavePath(IHasMetadata item)
        {
            var video = (Video)item;

            if (video.VideoType == VideoType.Dvd || video.VideoType == VideoType.BluRay || video.VideoType == VideoType.HdDvd)
            {
                var path = item.ContainingFolderPath;

                return Path.Combine(path, Path.GetFileNameWithoutExtension(path) + ".nfo");
            }

            return Path.ChangeExtension(item.Path, ".nfo");
        }
Example #19
0
        /// <summary>
        /// Saves the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var builder = new StringBuilder();

            builder.Append("<Item>");

            XmlSaverHelpers.AddCommonNodes((Folder)item, builder);

            builder.Append("</Item>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string> { });
        }
Example #20
0
        /// <summary>
        /// Saves the specified item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var builder = new StringBuilder();

            builder.Append("<Item>");

            XmlSaverHelpers.AddCommonNodes((BoxSet)item, _libraryManager, builder);

            builder.Append("</Item>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string> { }, _config, _fileSystem);
        }
        public Task<MetadataRawTable> GetMetadataRaw(IHasMetadata item, string language, CancellationToken cancellationToken)
        {
            var table = new MetadataRawTable();

            var service = _metadataServices.FirstOrDefault(i => i.CanRefresh(item));

            if (service == null)
            {
                _logger.Error("Unable to find a metadata service for item of type " + item.GetType().Name);
                return null;
            }

            return this.GetMetadataRaw(item, service, language, cancellationToken);
        }
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var builder = new StringBuilder();

            builder.Append("<season>");

            XmlSaverHelpers.AddCommonNodes((Season)item, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);

            builder.Append("</season>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string> { });
        }
Example #23
0
        public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            if (!item.SupportsLocalMetadata)
            {
                return false;
            }

            if (!(item is Season))
            {
                return false;
            }

            return updateType >= ItemUpdateType.ImageUpdate || (updateType >= ItemUpdateType.MetadataImport && File.Exists(GetSavePath(item)));
        }
Example #24
0
        public ItemInfo(IHasMetadata item)
        {
            Path = item.Path;
            ContainingFolderPath = item.ContainingFolderPath;
            IsInMixedFolder = item.DetectIsInMixedFolder();

            var video = item as Video;
            if (video != null)
            {
                VideoType = video.VideoType;
                IsPlaceHolder = video.IsPlaceHolder;
            }

            ItemType = item.GetType();
        }
Example #25
0
        protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
        {
            var album = (MusicAlbum)item;
            
            foreach (var artist in album.Artists)
            {
                writer.WriteElementString("artist", artist);
            }

            foreach (var artist in album.AlbumArtists)
            {
                writer.WriteElementString("albumartist", artist);
            }

            AddTracks(album.Tracks, writer);
        }        
        public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            var locationType = item.LocationType;
            if (locationType == LocationType.Remote || locationType == LocationType.Virtual)
            {
                return false;
            }

            // If new metadata has been downloaded or metadata was manually edited, proceed
            if ((updateType & ItemUpdateType.MetadataDownload) == ItemUpdateType.MetadataDownload
                || (updateType & ItemUpdateType.MetadataEdit) == ItemUpdateType.MetadataEdit)
            {
                return item is Season;
            }

            return false;
        }
Example #27
0
        /// <summary>
        /// Determines whether [is enabled for] [the specified item].
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="updateType">Type of the update.</param>
        /// <returns><c>true</c> if [is enabled for] [the specified item]; otherwise, <c>false</c>.</returns>
        public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            if (!item.SupportsLocalMetadata)
            {
                return false;
            }

            var video = item as Video;

            // Check parent for null to avoid running this against things like video backdrops
            if (video != null && !(item is Episode) && !video.IsOwnedItem)
            {
                return updateType >= ItemUpdateType.MetadataDownload;
            }

            return false;
        }
        public void Save(IHasMetadata item, CancellationToken cancellationToken)
        {
            var album = (MusicAlbum)item;

            var builder = new StringBuilder();

            builder.Append("<album>");

            XmlSaverHelpers.AddCommonNodes(album, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);

            var tracks = album.RecursiveChildren
                .OfType<Audio>()
                .ToList();

            var artists = tracks
                .SelectMany(i =>
                {
                    var list = new List<string>();

                    if (!string.IsNullOrEmpty(i.AlbumArtist))
                    {
                        list.Add(i.AlbumArtist);
                    }
                    list.AddRange(i.Artists);

                    return list;
                })
                .Distinct(StringComparer.OrdinalIgnoreCase);

            foreach (var artist in artists)
            {
                builder.Append("<artist>" + SecurityElement.Escape(artist) + "</artist>");
            }

            AddTracks(tracks, builder);

            builder.Append("</album>");

            var xmlFilePath = GetSavePath(item);

            XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
                {
                    "track"
                });
        }
Example #29
0
        protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
        {
            var artist = (MusicArtist)item;

            if (artist.EndDate.HasValue)
            {
                var formatString = ConfigurationManager.GetNfoConfiguration().ReleaseDateFormat;

                writer.WriteElementString("disbanded", artist.EndDate.Value.ToString(formatString));
            }
            
            var albums = artist
                .RecursiveChildren
                .OfType<MusicAlbum>()
                .ToList();

            AddAlbums(albums, writer);
        }
Example #30
0
        /// <summary>
        /// Determines whether [is enabled for] [the specified item].
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="updateType">Type of the update.</param>
        /// <returns><c>true</c> if [is enabled for] [the specified item]; otherwise, <c>false</c>.</returns>
        public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
        {
            if (!item.SupportsLocalMetadata)
            {
                return false;
            }

            if (item is Folder)
            {
                if (!(item is Series) && !(item is BoxSet) && !(item is MusicArtist) && !(item is MusicAlbum) &&
                    !(item is Season) &&
                    !(item is GameSystem))
                {
                    return updateType >= ItemUpdateType.MetadataDownload;
                }
            }

            return false;
        }
 public bool HasChanged(IHasMetadata item, IDirectoryService directoryService)
 {
     return(GetSupportedImages(item).Any(i => !item.HasImage(i)));
 }
Example #32
0
        public bool Supports(IHasMetadata item)
        {
            var audio = item as Audio;

            return(item.LocationType == LocationType.FileSystem && audio != null);
        }
Example #33
0
 public string GetSavePath(IHasMetadata item)
 {
     return(GetLocalSavePath(item));
 }
Example #34
0
        /// <summary>
        /// Gets the providers.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="status">The status.</param>
        /// <param name="options">The options.</param>
        /// <returns>IEnumerable{`0}.</returns>
        protected IEnumerable <IMetadataProvider> GetProviders(IHasMetadata item, MetadataStatus status, MetadataRefreshOptions options)
        {
            // Get providers to refresh
            var providers = ((ProviderManager)ProviderManager).GetMetadataProviders <TItemType>(item).ToList();

            // Run all if either of these flags are true
            var runAllProviders = options.ReplaceAllMetadata || options.MetadataRefreshMode == MetadataRefreshMode.FullRefresh || !status.DateLastMetadataRefresh.HasValue;

            if (!runAllProviders)
            {
                // Avoid implicitly captured closure
                var currentItem = item;

                var providersWithChanges = providers
                                           .Where(i =>
                {
                    var hasChangeMonitor = i as IHasChangeMonitor;
                    if (hasChangeMonitor != null)
                    {
                        return(HasChanged(item, hasChangeMonitor, currentItem.DateLastSaved, options.DirectoryService));
                    }

                    var hasFileChangeMonitor = i as IHasItemChangeMonitor;
                    if (hasFileChangeMonitor != null)
                    {
                        return(HasChanged(item, hasFileChangeMonitor, status, options.DirectoryService));
                    }

                    return(false);
                })
                                           .ToList();

                if (providersWithChanges.Count == 0)
                {
                    providers = new List <IMetadataProvider <TItemType> >();
                }
                else
                {
                    providers = providers.Where(i =>
                    {
                        // If any provider reports a change, always run local ones as well
                        if (i is ILocalMetadataProvider)
                        {
                            return(true);
                        }

                        var anyRemoteProvidersChanged = providersWithChanges.OfType <IRemoteMetadataProvider>()
                                                        .Any();

                        // If any remote providers changed, run them all so that priorities can be honored
                        if (i is IRemoteMetadataProvider)
                        {
                            return(anyRemoteProvidersChanged);
                        }

                        // Run custom providers if they report a change or any remote providers change
                        return(anyRemoteProvidersChanged || providersWithChanges.Contains(i));
                    }).ToList();
                }
            }

            return(providers);
        }
Example #35
0
 public bool CanRefresh(IHasMetadata item)
 {
     return(item is TItemType);
 }
Example #36
0
 protected override string GetLocalSavePath(IHasMetadata item)
 {
     return(Path.Combine(item.Path, "album.nfo"));
 }
Example #37
0
        protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
        {
            var episode = (Episode)item;

            if (episode.IndexNumber.HasValue)
            {
                writer.WriteElementString("episode", episode.IndexNumber.Value.ToString(UsCulture));
            }

            if (episode.IndexNumberEnd.HasValue)
            {
                writer.WriteElementString("episodenumberend", episode.IndexNumberEnd.Value.ToString(UsCulture));
            }

            if (episode.ParentIndexNumber.HasValue)
            {
                writer.WriteElementString("season", episode.ParentIndexNumber.Value.ToString(UsCulture));
            }

            if (episode.PremiereDate.HasValue)
            {
                var formatString = ConfigurationManager.GetNfoConfiguration().ReleaseDateFormat;

                writer.WriteElementString("aired", episode.PremiereDate.Value.ToLocalTime().ToString(formatString));
            }

            if (episode.AirsAfterSeasonNumber.HasValue)
            {
                writer.WriteElementString("airsafter_season", episode.AirsAfterSeasonNumber.Value.ToString(UsCulture));
            }
            if (episode.AirsBeforeEpisodeNumber.HasValue)
            {
                writer.WriteElementString("airsbefore_episode", episode.AirsBeforeEpisodeNumber.Value.ToString(UsCulture));
            }
            if (episode.AirsBeforeEpisodeNumber.HasValue)
            {
                writer.WriteElementString("displayepisode", episode.AirsBeforeEpisodeNumber.Value.ToString(UsCulture));
            }
            if (episode.AirsBeforeSeasonNumber.HasValue)
            {
                writer.WriteElementString("airsbefore_season", episode.AirsBeforeSeasonNumber.Value.ToString(UsCulture));
            }

            var season = episode.AiredSeasonNumber;

            if (season.HasValue)
            {
                writer.WriteElementString("displayseason", season.Value.ToString(UsCulture));
            }

            if (episode.DvdEpisodeNumber.HasValue)
            {
                writer.WriteElementString("DVD_episodenumber", episode.DvdEpisodeNumber.Value.ToString(UsCulture));
            }

            if (episode.DvdSeasonNumber.HasValue)
            {
                writer.WriteElementString("DVD_season", episode.DvdSeasonNumber.Value.ToString(UsCulture));
            }

            if (episode.AbsoluteEpisodeNumber.HasValue)
            {
                writer.WriteElementString("absolute_number", episode.AbsoluteEpisodeNumber.Value.ToString(UsCulture));
            }
        }
Example #38
0
 public bool Supports(IHasMetadata item)
 {
     return(item is Person);
 }
Example #39
0
 public static bool HasImage(this IHasMetadata item, ImageType imageType)
 {
     return(item.HasImage(imageType, 0));
 }
Example #40
0
 protected abstract void WriteCustomElements(IHasMetadata item, XmlWriter writer);
Example #41
0
 /// <summary>
 /// Determines whether [is enabled for] [the specified item].
 /// </summary>
 /// <param name="item">The item.</param>
 /// <param name="updateType">Type of the update.</param>
 /// <returns><c>true</c> if [is enabled for] [the specified item]; otherwise, <c>false</c>.</returns>
 public abstract bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType);
Example #42
0
 /// <summary>
 /// Gets the name of the root element.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <returns>System.String.</returns>
 protected abstract string GetRootElementName(IHasMetadata item);
Example #43
0
 /// <summary>
 /// Sets the image path.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <param name="imageType">Type of the image.</param>
 /// <param name="file">The file.</param>
 public static void SetImagePath(this IHasMetadata item, ImageType imageType, FileSystemMetadata file)
 {
     item.SetImagePath(imageType, 0, file);
 }
Example #44
0
 protected override string GetRootElementName(IHasMetadata item)
 {
     return("album");
 }
Example #45
0
 /// <summary>
 /// Saves the metadata.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <param name="updateType">Type of the update.</param>
 /// <param name="savers">The savers.</param>
 /// <returns>Task.</returns>
 public Task SaveMetadata(IHasMetadata item, ItemUpdateType updateType, IEnumerable <string> savers)
 {
     return(SaveMetadata(item, updateType, _savers.Where(i => savers.Contains(i.Name, StringComparer.OrdinalIgnoreCase))));
 }
Example #46
0
 protected override string GetLocalSavePath(IHasMetadata item)
 {
     return(Path.ChangeExtension(item.Path, ".nfo"));
 }
Example #47
0
        public async Task <ItemUpdateType> RefreshMetadata(IHasMetadata item, MetadataRefreshOptions refreshOptions, CancellationToken cancellationToken)
        {
            var itemOfType = (TItemType)item;
            var config     = ProviderManager.GetMetadataOptions(item);

            var updateType    = ItemUpdateType.None;
            var refreshResult = GetLastResult(item);

            refreshResult.LastErrorMessage = string.Empty;
            refreshResult.LastStatus       = ProviderRefreshStatus.Success;

            var itemImageProvider = new ItemImageProvider(Logger, ProviderManager, ServerConfigurationManager, FileSystem);
            var localImagesFailed = false;

            var allImageProviders = ((ProviderManager)ProviderManager).GetImageProviders(item).ToList();

            // Start by validating images
            try
            {
                // Always validate images and check for new locally stored ones.
                if (itemImageProvider.ValidateImages(item, allImageProviders.OfType <ILocalImageProvider>(), refreshOptions.DirectoryService))
                {
                    updateType = updateType | ItemUpdateType.ImageUpdate;
                }
            }
            catch (Exception ex)
            {
                localImagesFailed = true;
                Logger.ErrorException("Error validating images for {0}", ex, item.Path ?? item.Name ?? "Unknown name");
                refreshResult.AddStatus(ProviderRefreshStatus.Failure, ex.Message);
            }

            var metadataResult = new MetadataResult <TItemType>
            {
                Item = itemOfType
            };

            // Next run metadata providers
            if (refreshOptions.MetadataRefreshMode != MetadataRefreshMode.None)
            {
                var providers = GetProviders(item, refreshResult, refreshOptions)
                                .ToList();

                if (providers.Count > 0 || !refreshResult.DateLastMetadataRefresh.HasValue)
                {
                    if (item.BeforeMetadataRefresh())
                    {
                        updateType = updateType | ItemUpdateType.MetadataImport;
                    }
                }

                if (providers.Count > 0)
                {
                    var id = await CreateInitialLookupInfo(itemOfType, cancellationToken).ConfigureAwait(false);

                    var result = await RefreshWithProviders(metadataResult, id, refreshOptions, providers, itemImageProvider, cancellationToken).ConfigureAwait(false);

                    updateType = updateType | result.UpdateType;
                    refreshResult.AddStatus(result.Status, result.ErrorMessage);
                    refreshResult.SetDateLastMetadataRefresh(DateTime.UtcNow);

                    MergeIdentities(itemOfType, id);
                }
            }

            // Next run remote image providers, but only if local image providers didn't throw an exception
            if (!localImagesFailed && refreshOptions.ImageRefreshMode != ImageRefreshMode.ValidationOnly)
            {
                var providers = GetNonLocalImageProviders(item, allImageProviders, refreshResult, refreshOptions).ToList();

                if (providers.Count > 0)
                {
                    var result = await itemImageProvider.RefreshImages(itemOfType, providers, refreshOptions, config, cancellationToken).ConfigureAwait(false);

                    updateType = updateType | result.UpdateType;
                    refreshResult.AddStatus(result.Status, result.ErrorMessage);
                    refreshResult.SetDateLastImagesRefresh(DateTime.UtcNow);
                }
            }

            var beforeSaveResult = await BeforeSave(itemOfType, item.DateLastSaved == default(DateTime) || refreshOptions.ReplaceAllMetadata || refreshOptions.MetadataRefreshMode == MetadataRefreshMode.FullRefresh, updateType).ConfigureAwait(false);

            updateType = updateType | beforeSaveResult;

            // Save if changes were made, or it's never been saved before
            if (refreshOptions.ForceSave || updateType > ItemUpdateType.None || item.DateLastSaved == default(DateTime) || refreshOptions.ReplaceAllMetadata)
            {
                // If any of these properties are set then make sure the updateType is not None, just to force everything to save
                if (refreshOptions.ForceSave || refreshOptions.ReplaceAllMetadata)
                {
                    updateType = updateType | ItemUpdateType.MetadataDownload;
                }

                // Save to database
                await SaveItem(metadataResult, updateType, cancellationToken).ConfigureAwait(false);
            }

            if (updateType > ItemUpdateType.None || refreshResult.IsDirty)
            {
                await SaveProviderResult(itemOfType, refreshResult, refreshOptions.DirectoryService).ConfigureAwait(false);
            }

            await AfterMetadataRefresh(itemOfType, refreshOptions, cancellationToken).ConfigureAwait(false);

            return(updateType);
        }
Example #48
0
 /// <summary>
 /// Gets the image path.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <param name="imageType">Type of the image.</param>
 /// <returns>System.String.</returns>
 public static string GetImagePath(this IHasMetadata item, ImageType imageType)
 {
     return(item.GetImagePath(imageType, 0));
 }
Example #49
0
 /// <summary>
 /// Saves the metadata.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <param name="updateType">Type of the update.</param>
 /// <returns>Task.</returns>
 public Task SaveMetadata(IHasMetadata item, ItemUpdateType updateType)
 {
     return(SaveMetadata(item, updateType, _savers));
 }
Example #50
0
        private IEnumerable <IMetadataProvider <T> > GetMetadataProvidersInternal <T>(IHasMetadata item, MetadataOptions options, bool includeDisabled, bool checkIsOwnedItem)
            where T : IHasMetadata
        {
            // Avoid implicitly captured closure
            var currentOptions = options;

            return(_metadataProviders.OfType <IMetadataProvider <T> >()
                   .Where(i => CanRefresh(i, item, currentOptions, includeDisabled, checkIsOwnedItem))
                   .OrderBy(i => GetConfiguredOrder(i, options))
                   .ThenBy(GetDefaultOrder));
        }
Example #51
0
 public IEnumerable <ImageType> GetSupportedImages(IHasMetadata item)
 {
     return(new List <ImageType> {
         ImageType.Primary
     });
 }
Example #52
0
 /// <summary>
 /// Gets the save path.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <returns>System.String.</returns>
 public string GetSavePath(IHasMetadata item)
 {
     return(Path.Combine(item.Path, "person.xml"));
 }
Example #53
0
 public override string GetSavePath(IHasMetadata item)
 {
     return(Path.Combine(item.Path, "artist.nfo"));
 }
Example #54
0
 /// <summary>
 /// Gets the save path.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <returns>System.String.</returns>
 public abstract string GetSavePath(IHasMetadata item);
Example #55
0
 protected override string GetRootElementName(IHasMetadata item)
 {
     return("episodedetails");
 }
 public string GetSavePath(IHasMetadata item)
 {
     return(GetGameSavePath((Game)item));
 }
Example #57
0
 public static string GetImageCacheTag(this IImageProcessor processor, IHasMetadata item, ImageType imageType)
 {
     return(processor.GetImageCacheTag(item, imageType, 0));
 }
Example #58
0
 public string GetSavePath(IHasMetadata item)
 {
     return(GetMovieSavePath((Video)item));
 }
Example #59
0
 /// <summary>
 /// Gets the save path.
 /// </summary>
 /// <param name="item">The item.</param>
 /// <returns>System.String.</returns>
 protected abstract string GetLocalSavePath(IHasMetadata item);
Example #60
0
 public Task RefreshFullItem(IHasMetadata item, MetadataRefreshOptions options,
                             CancellationToken cancellationToken)
 {
     return(RefreshItem((BaseItem)item, options, cancellationToken));
 }