private async Task <bool> DownloadImage(BaseItem item, LibraryOptions libraryOptions, IRemoteImageProvider provider, RefreshResult result, IEnumerable <RemoteImageInfo> images, int minWidth, ImageType type, CancellationToken cancellationToken) { var eligibleImages = images .Where(i => i.Type == type && !(i.Width.HasValue && i.Width.Value < minWidth)) .ToList(); if (EnableImageStub(item, type, libraryOptions) && eligibleImages.Count > 0) { SaveImageStub(item, type, eligibleImages.Select(i => i.Url)); result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate; return(true); } foreach (var image in eligibleImages) { var url = image.Url; try { var response = await provider.GetImageResponse(url, cancellationToken).ConfigureAwait(false); await _providerManager.SaveImage(item, response.Content, response.ContentType, type, null, cancellationToken).ConfigureAwait(false); result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate; return(true); } catch (HttpException ex) { // Sometimes providers send back bad url's. Just move to the next image if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound) { continue; } break; } } return(false); }
public Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { var infos = new List <RemoteImageInfo>(); var person = AniDbSeriesProvider.GetPersonInfo(_paths.CachePath, item.Name); if (person != null) { infos.Add(new RemoteImageInfo { Url = person.Image, Type = ImageType.Primary, ProviderName = Name }); } return(Task.FromResult <IEnumerable <RemoteImageInfo> >(infos)); }
public static void SaveLibraryOptions(string path, LibraryOptions options) { lock (LibraryOptions) { LibraryOptions[path] = options; var clone = JsonSerializer.Deserialize <LibraryOptions>(JsonSerializer.SerializeToUtf8Bytes(options, _jsonOptions), _jsonOptions); foreach (var mediaPath in clone.PathInfos) { if (!string.IsNullOrEmpty(mediaPath.Path)) { mediaPath.Path = ApplicationHost.ReverseVirtualPath(mediaPath.Path); } } XmlSerializer.SerializeToFile(clone, GetLibraryOptionsPath(path)); } }
public Task Save(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { var path = GetSavePath(item); var serializeditem = SerializeItem(item, ConfigurationManager, LibraryManager); var options = new JsonSerializerOptions { WriteIndented = true, Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping, }; options.Converters.Add(new DateTimeConverter("yyyy-MM-dd")); var json = JsonSerializer.Serialize(serializeditem, serializeditem.GetType(), options); FileSystem.CreateDirectory(FileSystem.GetDirectoryName(path)); FileSystem.SetAttributes(path, false, false); File.WriteAllText(path, json); return(Task.CompletedTask); }
public async Task<RefreshResult> RefreshImages(BaseItem item, LibraryOptions libraryOptions, List<IImageProvider> providers, ImageRefreshOptions refreshOptions, MetadataOptions savedOptions, CancellationToken cancellationToken) { if (refreshOptions.IsReplacingImage(ImageType.Backdrop)) { ClearImages(item, ImageType.Backdrop); } if (refreshOptions.IsReplacingImage(ImageType.Screenshot)) { ClearImages(item, ImageType.Screenshot); } var result = new RefreshResult { UpdateType = ItemUpdateType.None }; var providerIds = new List<Guid>(); // In order to avoid duplicates, only download these if there are none already var backdropLimit = savedOptions.GetLimit(ImageType.Backdrop); var screenshotLimit = savedOptions.GetLimit(ImageType.Screenshot); var downloadedImages = new List<ImageType>(); foreach (var provider in providers) { var remoteProvider = provider as IRemoteImageProvider; if (remoteProvider != null) { await RefreshFromProvider(item, libraryOptions, remoteProvider, refreshOptions, savedOptions, backdropLimit, screenshotLimit, downloadedImages, result, cancellationToken).ConfigureAwait(false); providerIds.Add(provider.GetType().FullName.GetMD5()); continue; } var dynamicImageProvider = provider as IDynamicImageProvider; if (dynamicImageProvider != null) { await RefreshFromProvider(item, dynamicImageProvider, refreshOptions, savedOptions, downloadedImages, result, cancellationToken).ConfigureAwait(false); providerIds.Add(provider.GetType().FullName.GetMD5()); } } result.Providers = providerIds; return result; }
private bool EnableImageStub(IHasImages item, ImageType type, LibraryOptions libraryOptions) { if (item is LiveTvProgram) { return(true); } if (libraryOptions.DownloadImagesInAdvance) { return(false); } if (item.LocationType == LocationType.Remote || item.LocationType == LocationType.Virtual) { return(true); } if (!item.IsSaveLocalMetadataEnabled()) { return(true); } if (item is IItemByName && !(item is MusicArtist)) { var hasDualAccess = item as IHasDualAccess; if (hasDualAccess == null || hasDualAccess.IsAccessedByName) { return(true); } } switch (type) { case ImageType.Primary: return(false); case ImageType.Thumb: return(false); default: return(true); } }
public List <LocalImageInfo> GetImages(BaseItem item, LibraryOptions libraryOptions, IDirectoryService directoryService) { var parentPath = _fileSystem.GetDirectoryName(item.Path); var parentPathFiles = directoryService.GetFileSystemEntries(parentPath) .ToList(); var nameWithoutExtension = _fileSystem.GetFileNameWithoutExtension(item.Path); var metadataPath = Path.Combine(parentPath, "metadata"); if (parentPathFiles.Any(i => string.Equals(i.FullName, metadataPath, StringComparison.OrdinalIgnoreCase))) { var filesInMetadataFolder = _fileSystem.GetFiles(metadataPath, BaseItem.SupportedImageExtensions, false, false); return(GetFilesFromParentFolder(nameWithoutExtension, filesInMetadataFolder)); } return(new List <LocalImageInfo>()); }
private async Task SavePeopleMetadataAsync(List <PersonInfo> people, LibraryOptions libraryOptions, CancellationToken cancellationToken) { foreach (var person in people) { cancellationToken.ThrowIfCancellationRequested(); if (person.ProviderIds.Count > 0 || !string.IsNullOrWhiteSpace(person.ImageUrl)) { var updateType = ItemUpdateType.MetadataDownload; var saveEntity = false; var personEntity = LibraryManager.GetPerson(person.Name); foreach (var id in person.ProviderIds) { if (!string.Equals(personEntity.GetProviderId(id.Key), id.Value, StringComparison.OrdinalIgnoreCase)) { personEntity.SetProviderId(id.Key, id.Value); saveEntity = true; } } if (!string.IsNullOrWhiteSpace(person.ImageUrl) && !personEntity.HasImage(ImageType.Primary)) { personEntity.SetImage( new ItemImageInfo { Path = person.ImageUrl, Type = ImageType.Primary }, 0); saveEntity = true; updateType |= ItemUpdateType.ImageUpdate; } if (saveEntity) { await personEntity.UpdateToRepositoryAsync(updateType, cancellationToken).ConfigureAwait(false); } } } }
public Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { var list = new List <RemoteImageInfo>(); if (!string.IsNullOrEmpty(item.GetProviderId(Name))) { var cachePath = Path.Combine(_appPaths.CachePath, "douban", item.GetProviderId(Name), "image.txt"); if (File.Exists(cachePath)) { var image = new RemoteImageInfo { ProviderName = Name, Url = File.ReadAllText(cachePath), Type = ImageType.Primary }; list.Add(image); } } return(Task.FromResult <IEnumerable <RemoteImageInfo> >(list)); }
public async Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { var list = new List <RemoteImageInfo>(); var series = (Series)item; var id = series.GetProviderId(MetadataProviders.Tvdb); if (!string.IsNullOrEmpty(id)) { // Bad id entered try { await EnsureSeriesJson(id, cancellationToken).ConfigureAwait(false); } catch (HttpException ex) { if (!ex.StatusCode.HasValue || ex.StatusCode.Value != HttpStatusCode.NotFound) { throw; } } var path = GetFanartJsonPath(id); try { AddImages(list, path, cancellationToken); } catch (FileNotFoundException) { // No biggie. Don't blow up } catch (IOException) { // No biggie. Don't blow up } } return(list); }
private void AddPersonImage(Person personEntity, LibraryOptions libraryOptions, string imageUrl, CancellationToken cancellationToken) { //if (libraryOptions.DownloadImagesInAdvance) //{ // try // { // await ProviderManager.SaveImage(personEntity, imageUrl, ImageType.Primary, null, cancellationToken).ConfigureAwait(false); // return; // } // catch (Exception ex) // { // Logger.LogError(ex, "Error in AddPersonImage"); // } //} personEntity.SetImage(new ItemImageInfo { Path = imageUrl, Type = ImageType.Primary }, 0); }
private bool CanRefresh( IMetadataProvider provider, BaseItem item, LibraryOptions libraryOptions, bool includeDisabled, bool forceEnableInternetMetadata) { if (!includeDisabled) { // If locked only allow local providers if (item.IsLocked && !(provider is ILocalMetadataProvider) && !(provider is IForcedProvider)) { return(false); } if (provider is IRemoteMetadataProvider) { if (!forceEnableInternetMetadata && !_baseItemManager.IsMetadataFetcherEnabled(item, libraryOptions, provider.Name)) { return(false); } } } if (!item.SupportsLocalMetadata && provider is ILocalMetadataProvider) { return(false); } // If this restriction is ever lifted, movie xml providers will have to be updated to prevent owned items like trailers from reading those files if (!item.OwnerId.Equals(Guid.Empty)) { if (provider is ILocalMetadataProvider || provider is IRemoteMetadataProvider) { return(false); } } return(true); }
private async Task AddPersonImage(Person personEntity, LibraryOptions libraryOptions, string imageUrl, CancellationToken cancellationToken) { if (libraryOptions.DownloadImagesInAdvance) { try { await ProviderManager.SaveImage(personEntity, imageUrl, ImageType.Primary, null, cancellationToken).ConfigureAwait(false); return; } catch (Exception ex) { Logger.ErrorException("Error in AddPersonImage", ex); } } personEntity.SetImage(new ItemImageInfo { Path = imageUrl, Type = ImageType.Primary }, 0); }
public async Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { var list = new List <RemoteImageInfo>(); var series = (Series)item; var idType = "imdb"; var seriesId = series.GetProviderId(MetadataProviders.Imdb); if (string.IsNullOrEmpty(seriesId)) { idType = "tmdb"; seriesId = string.Format(BaseTmdbId, series.GetProviderId(MetadataProviders.Tmdb)); } if (string.IsNullOrEmpty(seriesId)) { idType = "tvdb"; seriesId = series.GetProviderId(MetadataProviders.Tvdb); } if (!string.IsNullOrEmpty(seriesId)) { try { await AddImages(list, idType, seriesId, cancellationToken).ConfigureAwait(false); } catch (FileNotFoundException) { // No biggie. Don't blow up } catch (IOException) { // No biggie. Don't blow up } } return(list); }
private bool EnableImageStub(BaseItem item, LibraryOptions libraryOptions) { if (item is LiveTvProgram) { return(true); } if (!item.IsFileProtocol) { return(true); } if (item is IItemByName && !(item is MusicArtist)) { var hasDualAccess = item as IHasDualAccess; if (hasDualAccess == null || hasDualAccess.IsAccessedByName) { return(true); } } // We always want to use prefetched images return(false); }
public async Task <MetadataResult <T> > GetMetadata(ItemInfo info, LibraryOptions libraryOptions, IDirectoryService directoryService, CancellationToken cancellationToken) { var result = new MetadataResult <T>(); var file = GetXmlFile(info, directoryService); if (file == null) { return(result); } var path = file.FullName; Logger.Debug("{0} will fetch xml from {1}", GetType().Name, path); try { result.Item = new T(); await Fetch(result, path, cancellationToken).ConfigureAwait(false); result.HasMetadata = true; } catch (FileNotFoundException) { result.HasMetadata = false; } catch (IOException) { result.HasMetadata = false; } return(result); }
private bool CanRefresh( IImageProvider provider, BaseItem item, LibraryOptions libraryOptions, ImageRefreshOptions refreshOptions, bool includeDisabled) { if (!includeDisabled) { // If locked only allow local providers if (item.IsLocked && !(provider is ILocalImageProvider)) { if (refreshOptions.ImageRefreshMode != MetadataRefreshMode.FullRefresh) { return(false); } } if (provider is IRemoteImageProvider || provider is IDynamicImageProvider) { if (!_baseItemManager.IsImageFetcherEnabled(item, libraryOptions, provider.Name)) { return(false); } } } try { return(provider.Supports(item)); } catch (Exception ex) { _logger.LogError(ex, "{ProviderName} failed in Supports for type {ItemType} at {ItemPath}", provider.GetType().Name, item.GetType().Name, item.Path); return(false); } }
public async Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { _logger.LogCallerInfo($"[DOUBAN] GetImages for item: {item.Name}"); var list = new List <RemoteImageInfo>(); var sid = item.GetProviderId(ProviderID); if (string.IsNullOrWhiteSpace(sid)) { _logger.LogCallerInfo($"[DOUBAN] Got images failed because the sid of \"{item.Name}\" is empty!"); return(list); } var primaryList = await GetPrimary(sid, item is Movie? "movie" : "tv", cancellationToken); list.AddRange(primaryList); // TODO(Libitum): Add backdrop back. var backdropList = await GetBackdrop(sid, cancellationToken); list.AddRange(backdropList); return(list); }
private void SavePeopleMetadata(List <PersonInfo> people, LibraryOptions libraryOptions, CancellationToken cancellationToken) { foreach (var person in people) { cancellationToken.ThrowIfCancellationRequested(); if (person.ProviderIds.Any() || !string.IsNullOrWhiteSpace(person.ImageUrl)) { var updateType = ItemUpdateType.MetadataDownload; var saveEntity = false; var personEntity = LibraryManager.GetPerson(person.Name); foreach (var id in person.ProviderIds) { if (!string.Equals(personEntity.GetProviderId(id.Key), id.Value, StringComparison.OrdinalIgnoreCase)) { personEntity.SetProviderId(id.Key, id.Value); saveEntity = true; } } if (!string.IsNullOrWhiteSpace(person.ImageUrl) && !personEntity.HasImage(ImageType.Primary)) { AddPersonImage(personEntity, libraryOptions, person.ImageUrl, cancellationToken); saveEntity = true; updateType = updateType | ItemUpdateType.ImageUpdate; } if (saveEntity) { personEntity.UpdateToRepository(updateType, cancellationToken); } } } }
public Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { var seriesId = item.GetProviderId(ProviderNames.AniList); return(GetImages(seriesId, cancellationToken)); }
private IEnumerable <IMetadataProvider <T> > GetMetadataProvidersInternal <T>(BaseItem item, LibraryOptions libraryOptions, MetadataOptions globalMetadataOptions, bool includeDisabled, bool forceEnableInternetMetadata) where T : BaseItem { // Avoid implicitly captured closure var currentOptions = globalMetadataOptions; return(_metadataProviders.OfType <IMetadataProvider <T> >() .Where(i => CanRefresh(i, item, libraryOptions, includeDisabled, forceEnableInternetMetadata)) .OrderBy(i => GetConfiguredOrder(item, i, libraryOptions, globalMetadataOptions)) .ThenBy(GetDefaultOrder)); }
/// <summary> /// Gets the metadata providers for the provided item. /// </summary> /// <param name="item">The item.</param> /// <param name="libraryOptions">The library options.</param> /// <typeparam name="T">The type of metadata provider.</typeparam> /// <returns>The metadata providers.</returns> public IEnumerable <IMetadataProvider <T> > GetMetadataProviders <T>(BaseItem item, LibraryOptions libraryOptions) where T : BaseItem { var globalMetadataOptions = GetMetadataOptions(item); return(GetMetadataProvidersInternal <T>(item, libraryOptions, globalMetadataOptions, false, false)); }
public async Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken) { var list = new List <RemoteImageInfo>(); var httpRequestOptions = new HttpRequestOptions { CancellationToken = cancellationToken, }; if (item is MusicAlbum || item is Book) { if (item.ProviderIds.TryGetValue("isbn", out string isbn)) { httpRequestOptions.Url = $"{baseUrl}ISBN:{isbn}"; using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false)) { var openLibrarySearch = await _json.DeserializeFromStreamAsync <Dictionary <string, OpenLibraryResp> >(resp.Content).ConfigureAwait(false); foreach (var book in openLibrarySearch) { list.Add(new RemoteImageInfo { Url = book.Value.cover.large, ThumbnailUrl = book.Value.cover.medium, ProviderName = Name }); } } } else { httpRequestOptions.Url = $"{searchUrl}\"{HttpUtility.UrlEncode(item.Name)}\""; using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false)) { var openLibrarySearch = await _json.DeserializeFromStreamAsync <OpenLibrarySearch>(resp.Content).ConfigureAwait(false); foreach (var book in openLibrarySearch.docs) { list.Add(new RemoteImageInfo { Url = $"https://covers.openlibrary.org/b/id/{book.cover_i}-L.jpg", ThumbnailUrl = $"https://covers.openlibrary.org/b/id/{book.cover_i}-M.jpg", ProviderName = Name }); } } } } if (item is MusicArtist) { httpRequestOptions.Url = $"{authorUrl}\"{HttpUtility.UrlEncode(item.Name)}\""; using (var resp = await _httpClient.GetResponse(httpRequestOptions).ConfigureAwait(false)) { var openLibrarySearch = await _json.DeserializeFromStreamAsync <OpenLibrarySearch>(resp.Content).ConfigureAwait(false); foreach (var book in openLibrarySearch.docs) { list.Add(new RemoteImageInfo { Url = $"https://covers.openlibrary.org/a/olid/{book.key}-L.jpg", ThumbnailUrl = $"https://covers.openlibrary.org/a/olid/{book.key}-M.jpg", ProviderName = Name }); } } } return(list); }
private void FetchEmbeddedInfo(Video video, Model.MediaInfo.MediaInfo data, MetadataRefreshOptions refreshOptions, LibraryOptions libraryOptions) { var isFullRefresh = refreshOptions.MetadataRefreshMode == MetadataRefreshMode.FullRefresh; if (!video.IsLocked && !video.LockedFields.Contains(MetadataFields.OfficialRating)) { if (!string.IsNullOrWhiteSpace(data.OfficialRating) || isFullRefresh) { video.OfficialRating = data.OfficialRating; } } if (!video.IsLocked && !video.LockedFields.Contains(MetadataFields.Genres)) { if (video.Genres.Length == 0 || isFullRefresh) { video.Genres = Array.Empty <string>(); foreach (var genre in data.Genres) { video.AddGenre(genre); } } } if (!video.IsLocked && !video.LockedFields.Contains(MetadataFields.Studios)) { if (video.Studios.Length == 0 || isFullRefresh) { video.SetStudios(data.Studios); } } if (data.ProductionYear.HasValue) { if (!video.ProductionYear.HasValue || isFullRefresh) { video.ProductionYear = data.ProductionYear; } } if (data.PremiereDate.HasValue) { if (!video.PremiereDate.HasValue || isFullRefresh) { video.PremiereDate = data.PremiereDate; } } if (data.IndexNumber.HasValue) { if (!video.IndexNumber.HasValue || isFullRefresh) { video.IndexNumber = data.IndexNumber; } } if (data.ParentIndexNumber.HasValue) { if (!video.ParentIndexNumber.HasValue || isFullRefresh) { video.ParentIndexNumber = data.ParentIndexNumber; } } if (!video.IsLocked && !video.LockedFields.Contains(MetadataFields.Name)) { if (!string.IsNullOrWhiteSpace(data.Name) && libraryOptions.EnableEmbeddedTitles) { // Don't use the embedded name for extras because it will often be the same name as the movie if (!video.ExtraType.HasValue) { video.Name = data.Name; } } } // If we don't have a ProductionYear try and get it from PremiereDate if (video.PremiereDate.HasValue && !video.ProductionYear.HasValue) { video.ProductionYear = video.PremiereDate.Value.ToLocalTime().Year; } if (!video.IsLocked && !video.LockedFields.Contains(MetadataFields.Overview)) { if (string.IsNullOrWhiteSpace(video.Overview) || isFullRefresh) { video.Overview = data.Overview; } } }
private void CheckForMetadata(object sender, ElapsedEventArgs eventArgs) { try { queuedUpdateCheck.ToList().ForEach(async updateCheck => { Guid itemId = updateCheck.Key; _logger.Debug("{0} queued for recheck", itemId.ToString()); BaseItem item = _libraryManager.GetItemById(itemId); LibraryOptions itemLibraryOptions = _libraryManager.GetLibraryOptions(item); DiscordOptions options = Plugin.Instance.Configuration.Options.FirstOrDefault(opt => opt.MediaAddedOverride == true); PublicSystemInfo sysInfo = await _applicationHost.GetPublicSystemInfo(CancellationToken.None); ServerConfiguration serverConfig = _serverConfiguration.Configuration; if (!isInVisibleLibrary(options.MediaBrowserUserId, item)) { queuedUpdateCheck.Remove(itemId); _logger.Debug("User does not have access to library, skipping..."); return; } // for whatever reason if you have extraction on during library scans then it waits for the extraction to finish before populating the metadata.... I don't get why the f**k it goes in that order // its basically impossible to make a prediction on how long it could take as its dependent on the bitrate, duration, codec, and processing power of the system Boolean localMetadataFallback = queuedUpdateCheck[itemId] >= (itemLibraryOptions.ExtractChapterImagesDuringLibraryScan ? Constants.MaxRetriesBeforeFallback * 5.5 : Constants.MaxRetriesBeforeFallback); if (item.ProviderIds.Count > 0 || localMetadataFallback) { _logger.Debug("{0}[{1}] has metadata, sending notification", item.Id, item.Name); string serverName = options.ServerNameOverride ? serverConfig.ServerName : "Emby Server"; string LibraryType = item.GetType().Name; // build primary info DiscordMessage mediaAddedEmbed = new DiscordMessage { username = options.Username, avatar_url = options.AvatarUrl, embeds = new List <DiscordEmbed>() { new DiscordEmbed() { color = DiscordWebhookHelper.FormatColorCode(options.EmbedColor), footer = new Footer { text = $"From {serverName}", icon_url = options.AvatarUrl }, timestamp = DateTime.Now } }, }; // populate title string titleText; if (LibraryType == "Episode") { titleText = $"{item.Parent.Parent.Name} {(item.ParentIndexNumber != null ? $"S{formatIndex(item.ParentIndexNumber)}" : "")}{(item.IndexNumber != null ? $"E{formatIndex(item.IndexNumber)}" : "")} {item.Name}"; } else { titleText = $"{item.Name} {(!String.IsNullOrEmpty(item.ProductionYear.ToString()) ? $"({item.ProductionYear.ToString()})" : "")}"; } mediaAddedEmbed.embeds.First().title = _localizationManager.GetLocalizedString("ValueHasBeenAddedToLibrary").Replace("{0}", titleText).Replace("{1}", serverName); // populate description if (LibraryType == "Audio") { List <BaseItem> artists = _libraryManager.GetAllArtists(item); IEnumerable <string> artistsFormat = artists.Select(artist => { if (artist.ProviderIds.Count() > 0) { KeyValuePair <string, string> firstProvider = artist.ProviderIds.FirstOrDefault(); string providerUrl = firstProvider.Key == "MusicBrainzArtist" ? $"https://musicbrainz.org/artist/{firstProvider.Value}" : $"https://theaudiodb.com/artist/{firstProvider.Value}"; return($"[{artist.Name}]({providerUrl})"); } else { return(artist.Name); } }); if (artists.Count() > 0) { mediaAddedEmbed.embeds.First().description = $"By {string.Join(", ", artistsFormat)}"; } } else { if (!String.IsNullOrEmpty(item.Overview)) { mediaAddedEmbed.embeds.First().description = item.Overview; } } // populate title URL if (!String.IsNullOrEmpty(sysInfo.WanAddress) && !options.ExcludeExternalServerLinks) { mediaAddedEmbed.embeds.First().url = $"{sysInfo.WanAddress}/web/index.html#!/item?id={itemId}&serverId={sysInfo.Id}"; } // populate images if (item.HasImage(ImageType.Primary)) { string imageUrl = ""; if (!item.GetImageInfo(ImageType.Primary, 0).IsLocalFile) { imageUrl = item.GetImagePath(ImageType.Primary); } else if (serverConfig.EnableRemoteAccess == true && !options.ExcludeExternalServerLinks) // in the future we can proxy images through memester server if people want to hide their server address { imageUrl = $"{sysInfo.WanAddress}/emby/Items/{itemId}/Images/Primary"; } else { string localPath = item.GetImagePath(ImageType.Primary); Stream imageData = _fileSystem.OpenRead(localPath); try { imageUrl = await MemesterServiceHelper.UploadImage(imageData, _jsonSerializer, _httpClient); } catch (Exception e) { _logger.ErrorException("Failed to proxy image", e); } } mediaAddedEmbed.embeds.First().thumbnail = new Thumbnail { url = imageUrl }; } if (options.MentionType == MentionTypes.Everyone) { mediaAddedEmbed.content = "@everyone"; } else if (options.MentionType == MentionTypes.Here) { mediaAddedEmbed.content = "@here"; } // populate external URLs List <Field> providerFields = new List <Field>(); if (!localMetadataFallback) { item.ProviderIds.ToList().ForEach(provider => { Field field = new Field { name = "External Details" }; Boolean didPopulate = true; switch (provider.Key.ToLower()) { case "imdb": field.value = $"[IMDb](https://www.imdb.com/title/{provider.Value}/)"; break; case "tmdb": field.value = $"[TMDb](https://www.themoviedb.org/{(LibraryType == "Movie" ? "movie" : "tv")}/{provider.Value})"; break; case "musicbrainztrack": field.value = $"[MusicBrainz Track](https://musicbrainz.org/track/{provider.Value})"; break; case "musicbrainzalbum": field.value = $"[MusicBrainz Album](https://musicbrainz.org/release/{provider.Value})"; break; case "theaudiodbalbum": field.value = $"[TADb Album](https://theaudiodb.com/album/{provider.Value})"; break; default: didPopulate = false; break; } if (didPopulate == true) { providerFields.Add(field); } }); if (providerFields.Count() > 0) { mediaAddedEmbed.embeds.First().fields = providerFields; } } pendingSendQueue.Add(mediaAddedEmbed, options); queuedUpdateCheck.Remove(itemId); } else { queuedUpdateCheck[itemId]++; _logger.Debug("Attempt: {0}", queuedUpdateCheck[itemId]); } }); } catch (Exception e) { _logger.ErrorException("Something unexpected happened in the update checker", e); } }
protected IEnumerable <IMetadataProvider> GetProviders(BaseItem item, LibraryOptions libraryOptions, MetadataRefreshOptions options, bool isFirstRefresh, bool requiresRefresh) { // Get providers to refresh var providers = ((ProviderManager)ProviderManager).GetMetadataProviders <TItemType>(item, libraryOptions).ToList(); var metadataRefreshMode = options.MetadataRefreshMode; // Run all if either of these flags are true var runAllProviders = options.ReplaceAllMetadata || metadataRefreshMode == MetadataRefreshMode.FullRefresh || (isFirstRefresh && metadataRefreshMode >= MetadataRefreshMode.Default) || (requiresRefresh && metadataRefreshMode >= MetadataRefreshMode.Default); if (!runAllProviders) { var providersWithChanges = providers .Where(i => { if (i is IHasItemChangeMonitor hasFileChangeMonitor) { return(HasChanged(item, hasFileChangeMonitor, options.DirectoryService)); } return(false); }) .ToList(); if (providersWithChanges.Count == 0) { providers = new List <IMetadataProvider <TItemType> >(); } else { var anyRemoteProvidersChanged = providersWithChanges.OfType <IRemoteMetadataProvider>() .Any(); var anyLocalProvidersChanged = providersWithChanges.OfType <ILocalMetadataProvider>() .Any(); var anyLocalPreRefreshProvidersChanged = providersWithChanges.OfType <IPreRefreshProvider>() .Any(); providers = providers.Where(i => { // If any provider reports a change, always run local ones as well if (i is ILocalMetadataProvider) { return(anyRemoteProvidersChanged || anyLocalProvidersChanged || anyLocalPreRefreshProvidersChanged); } // If any remote providers changed, run them all so that priorities can be honored if (i is IRemoteMetadataProvider) { if (options.MetadataRefreshMode == MetadataRefreshMode.ValidationOnly) { return(false); } return(anyRemoteProvidersChanged); } // Run custom refresh providers if they report a change or any remote providers change return(anyRemoteProvidersChanged || providersWithChanges.Contains(i)); }).ToList(); } } return(providers); }
public async Task <IEnumerable <RemoteImageInfo> > GetImages(BaseItem item, LibraryOptions libraryOptions, CancellationToken cancellationToken)
public void UpdateLibraryOptions(LibraryOptions options) { SaveLibraryOptions(Path, options); }
private async Task <IEnumerable <RemoteSearchResult> > GetRemoteSearchResults <TItemType, TLookupType>(RemoteSearchQuery <TLookupType> searchInfo, BaseItem referenceItem, CancellationToken cancellationToken) where TItemType : BaseItem, new() where TLookupType : ItemLookupInfo { LibraryOptions libraryOptions; if (referenceItem == null) { // Give it a dummy path just so that it looks like a file system item var dummy = new TItemType { Path = Path.Combine(_appPaths.InternalMetadataPath, "dummy"), ParentId = Guid.NewGuid() }; dummy.SetParent(new Folder()); referenceItem = dummy; libraryOptions = new LibraryOptions(); } else { libraryOptions = _libraryManager.GetLibraryOptions(referenceItem); } var options = GetMetadataOptions(referenceItem); var providers = GetMetadataProvidersInternal <TItemType>(referenceItem, libraryOptions, options, searchInfo.IncludeDisabledProviders, false) .OfType <IRemoteSearchProvider <TLookupType> >(); if (!string.IsNullOrEmpty(searchInfo.SearchProviderName)) { providers = providers.Where(i => string.Equals(i.Name, searchInfo.SearchProviderName, StringComparison.OrdinalIgnoreCase)); } if (string.IsNullOrWhiteSpace(searchInfo.SearchInfo.MetadataLanguage)) { searchInfo.SearchInfo.MetadataLanguage = _configurationManager.Configuration.PreferredMetadataLanguage; } if (string.IsNullOrWhiteSpace(searchInfo.SearchInfo.MetadataCountryCode)) { searchInfo.SearchInfo.MetadataCountryCode = _configurationManager.Configuration.MetadataCountryCode; } var resultList = new List <RemoteSearchResult>(); foreach (var provider in providers) { try { var results = await GetSearchResults(provider, searchInfo.SearchInfo, cancellationToken).ConfigureAwait(false); foreach (var result in results) { var existingMatch = resultList.FirstOrDefault(i => i.ProviderIds.Any(p => string.Equals(result.GetProviderId(p.Key), p.Value, StringComparison.OrdinalIgnoreCase))); if (existingMatch == null) { resultList.Add(result); } else { foreach (var providerId in result.ProviderIds) { if (!existingMatch.ProviderIds.ContainsKey(providerId.Key)) { existingMatch.ProviderIds.Add(providerId.Key, providerId.Value); } } if (string.IsNullOrWhiteSpace(existingMatch.ImageUrl)) { existingMatch.ImageUrl = result.ImageUrl; } } } } #pragma warning disable CA1031 // do not catch general exception types catch (Exception ex) #pragma warning restore CA1031 // do not catch general exception types { _logger.LogError(ex, "Provider {ProviderName} failed to retrieve search results", provider.Name); } } return(resultList); }
public LibraryOptions GetLibraryOptions() { return(LibraryOptions ?? (LibraryOptions = Parent == null ? new LibraryOptions() : BaseItem.LibraryManager.GetLibraryOptions(Parent))); }