/// <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); }
/// <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); }
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); } } }
/// <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" }); }
/// <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; }
public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType) { if (!item.SupportsLocalMetadata) { return false; } return item is Episode && updateType >= MinimumUpdateType; }
/// <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; }
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)); } }
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" }); }
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; }
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)); } }
/// <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); }
public ItemInfo(IHasMetadata item) { Path = item.Path; ContainingFolderPath = item.ContainingFolderPath; IsInMixedFolder = item.IsInMixedFolder; var video = item as Video; if (video != null) { VideoType = video.VideoType; } }
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"); }
/// <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> { }); }
/// <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> { }); }
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))); }
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(); }
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; }
/// <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" }); }
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); }
/// <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))); }
public bool Supports(IHasMetadata item) { var audio = item as Audio; return(item.LocationType == LocationType.FileSystem && audio != null); }
public string GetSavePath(IHasMetadata item) { return(GetLocalSavePath(item)); }
/// <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); }
public bool CanRefresh(IHasMetadata item) { return(item is TItemType); }
protected override string GetLocalSavePath(IHasMetadata item) { return(Path.Combine(item.Path, "album.nfo")); }
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)); } }
public bool Supports(IHasMetadata item) { return(item is Person); }
public static bool HasImage(this IHasMetadata item, ImageType imageType) { return(item.HasImage(imageType, 0)); }
protected abstract void WriteCustomElements(IHasMetadata item, XmlWriter writer);
/// <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);
/// <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);
/// <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); }
protected override string GetRootElementName(IHasMetadata item) { return("album"); }
/// <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)))); }
protected override string GetLocalSavePath(IHasMetadata item) { return(Path.ChangeExtension(item.Path, ".nfo")); }
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); }
/// <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)); }
/// <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)); }
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)); }
public IEnumerable <ImageType> GetSupportedImages(IHasMetadata item) { return(new List <ImageType> { ImageType.Primary }); }
/// <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")); }
public override string GetSavePath(IHasMetadata item) { return(Path.Combine(item.Path, "artist.nfo")); }
/// <summary> /// Gets the save path. /// </summary> /// <param name="item">The item.</param> /// <returns>System.String.</returns> public abstract string GetSavePath(IHasMetadata item);
protected override string GetRootElementName(IHasMetadata item) { return("episodedetails"); }
public string GetSavePath(IHasMetadata item) { return(GetGameSavePath((Game)item)); }
public static string GetImageCacheTag(this IImageProcessor processor, IHasMetadata item, ImageType imageType) { return(processor.GetImageCacheTag(item, imageType, 0)); }
public string GetSavePath(IHasMetadata item) { return(GetMovieSavePath((Video)item)); }
/// <summary> /// Gets the save path. /// </summary> /// <param name="item">The item.</param> /// <returns>System.String.</returns> protected abstract string GetLocalSavePath(IHasMetadata item);
public Task RefreshFullItem(IHasMetadata item, MetadataRefreshOptions options, CancellationToken cancellationToken) { return(RefreshItem((BaseItem)item, options, cancellationToken)); }