2019-01-13 21:03:10 +01:00
|
|
|
using System;
|
2020-02-23 10:53:51 +01:00
|
|
|
using System.Collections.Concurrent;
|
2018-12-31 00:28:23 +01:00
|
|
|
using System.Collections.Generic;
|
2020-02-23 10:53:51 +01:00
|
|
|
using System.Globalization;
|
2018-12-31 00:28:23 +01:00
|
|
|
using System.IO;
|
|
|
|
using System.Linq;
|
2020-08-06 23:43:19 +02:00
|
|
|
using System.Net;
|
2020-08-17 19:50:07 +02:00
|
|
|
using System.Net.Http;
|
2020-08-06 23:43:19 +02:00
|
|
|
using System.Net.Mime;
|
2018-12-31 00:28:23 +01:00
|
|
|
using System.Threading;
|
|
|
|
using System.Threading.Tasks;
|
2024-03-03 21:32:55 +01:00
|
|
|
using AsyncKeyedLock;
|
2021-12-12 03:31:30 +01:00
|
|
|
using Jellyfin.Data.Enums;
|
2020-08-14 02:48:28 +02:00
|
|
|
using Jellyfin.Data.Events;
|
2021-12-20 13:31:07 +01:00
|
|
|
using Jellyfin.Extensions;
|
2018-12-31 00:28:23 +01:00
|
|
|
using MediaBrowser.Common.Net;
|
2015-01-24 05:50:45 +01:00
|
|
|
using MediaBrowser.Controller;
|
2020-10-28 01:01:52 +01:00
|
|
|
using MediaBrowser.Controller.BaseItemManager;
|
2013-03-04 06:43:06 +01:00
|
|
|
using MediaBrowser.Controller.Configuration;
|
2018-12-31 00:28:23 +01:00
|
|
|
using MediaBrowser.Controller.Dto;
|
2013-02-21 02:33:05 +01:00
|
|
|
using MediaBrowser.Controller.Entities;
|
2014-02-02 14:36:31 +01:00
|
|
|
using MediaBrowser.Controller.Entities.Audio;
|
|
|
|
using MediaBrowser.Controller.Entities.Movies;
|
2013-06-23 19:48:30 +02:00
|
|
|
using MediaBrowser.Controller.Library;
|
2024-02-26 13:09:40 +01:00
|
|
|
using MediaBrowser.Controller.Lyrics;
|
2013-03-08 06:08:27 +01:00
|
|
|
using MediaBrowser.Controller.Providers;
|
2018-12-31 00:28:23 +01:00
|
|
|
using MediaBrowser.Controller.Subtitles;
|
2014-02-02 14:36:31 +01:00
|
|
|
using MediaBrowser.Model.Configuration;
|
2013-06-23 19:48:30 +02:00
|
|
|
using MediaBrowser.Model.Entities;
|
2021-09-08 23:20:11 +02:00
|
|
|
using MediaBrowser.Model.Extensions;
|
2018-12-31 00:28:23 +01:00
|
|
|
using MediaBrowser.Model.IO;
|
2022-04-09 16:46:06 +02:00
|
|
|
using MediaBrowser.Model.Net;
|
2018-12-31 00:28:23 +01:00
|
|
|
using MediaBrowser.Model.Providers;
|
2024-03-03 21:32:55 +01:00
|
|
|
using Microsoft.Extensions.Caching.Memory;
|
2018-12-31 00:28:23 +01:00
|
|
|
using Microsoft.Extensions.Logging;
|
2020-05-13 04:10:35 +02:00
|
|
|
using Book = MediaBrowser.Controller.Entities.Book;
|
|
|
|
using Episode = MediaBrowser.Controller.Entities.TV.Episode;
|
|
|
|
using Movie = MediaBrowser.Controller.Entities.Movies.Movie;
|
|
|
|
using MusicAlbum = MediaBrowser.Controller.Entities.Audio.MusicAlbum;
|
|
|
|
using Season = MediaBrowser.Controller.Entities.TV.Season;
|
|
|
|
using Series = MediaBrowser.Controller.Entities.TV.Series;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2014-01-28 19:37:01 +01:00
|
|
|
namespace MediaBrowser.Providers.Manager
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
/// <summary>
|
2020-06-16 00:37:52 +02:00
|
|
|
/// Class ProviderManager.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
2015-03-14 05:50:23 +01:00
|
|
|
public class ProviderManager : IProviderManager, IDisposable
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2022-01-01 00:22:46 +01:00
|
|
|
private readonly object _refreshQueueLock = new();
|
2020-06-06 02:15:56 +02:00
|
|
|
private readonly ILogger<ProviderManager> _logger;
|
2020-08-17 19:50:07 +02:00
|
|
|
private readonly IHttpClientFactory _httpClientFactory;
|
2014-01-28 22:25:10 +01:00
|
|
|
private readonly ILibraryMonitor _libraryMonitor;
|
2020-04-04 20:56:50 +02:00
|
|
|
private readonly IFileSystem _fileSystem;
|
|
|
|
private readonly IServerApplicationPaths _appPaths;
|
|
|
|
private readonly ILibraryManager _libraryManager;
|
|
|
|
private readonly ISubtitleManager _subtitleManager;
|
2024-02-26 13:09:40 +01:00
|
|
|
private readonly ILyricManager _lyricManager;
|
2020-04-04 20:56:50 +02:00
|
|
|
private readonly IServerConfigurationManager _configurationManager;
|
2020-10-28 01:01:52 +01:00
|
|
|
private readonly IBaseItemManager _baseItemManager;
|
2022-01-01 00:22:46 +01:00
|
|
|
private readonly ConcurrentDictionary<Guid, double> _activeRefreshes = new();
|
|
|
|
private readonly CancellationTokenSource _disposeCancellationTokenSource = new();
|
2022-12-07 18:02:12 +01:00
|
|
|
private readonly PriorityQueue<(Guid ItemId, MetadataRefreshOptions RefreshOptions), RefreshPriority> _refreshQueue = new();
|
2024-03-03 21:32:55 +01:00
|
|
|
private readonly IMemoryCache _memoryCache;
|
|
|
|
|
|
|
|
private readonly AsyncKeyedLocker<string> _imageSaveLock = new(o =>
|
|
|
|
{
|
|
|
|
o.PoolSize = 20;
|
|
|
|
o.PoolInitialFill = 1;
|
|
|
|
});
|
2013-03-07 06:34:00 +01:00
|
|
|
|
2021-12-05 21:43:59 +01:00
|
|
|
private IImageProvider[] _imageProviders = Array.Empty<IImageProvider>();
|
2020-07-03 20:02:04 +02:00
|
|
|
private IMetadataService[] _metadataServices = Array.Empty<IMetadataService>();
|
|
|
|
private IMetadataProvider[] _metadataProviders = Array.Empty<IMetadataProvider>();
|
Fix possible nullref
when `ProviderManager.SaveMetadata` gets called before
`ProviderManager.AddParts`
```
Error Message:
System.ArgumentNullException : Value cannot be null. (Parameter 'source')
Stack Trace:
at System.Linq.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
at System.Linq.Enumerable.Where[TSource](IEnumerable`1 source, Func`2 predicate)
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType, IEnumerable`1 savers) in D:\a\1\s\MediaBrowser.Providers\Manager\ProviderManager.cs:line 674
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType) in D:\a\1\s\MediaBrowser.Providers\Manager\ProviderManager.cs:line 655
at Emby.Server.Implementations.Library.LibraryManager.RunMetadataSavers(BaseItem item, ItemUpdateType updateReason) in D:\a\1\s\Emby.Server.Implementations\Library\LibraryManager.cs:line 2012
at Emby.Server.Implementations.Library.LibraryManager.UpdateItemsAsync(IReadOnlyList`1 items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken) in D:\a\1\s\Emby.Server.Implementations\Library\LibraryManager.cs:line 1970
at Emby.Server.Implementations.Library.LibraryManager.CreateRootFolder() in D:\a\1\s\Emby.Server.Implementations\Library\LibraryManager.cs:line 775
at Emby.Server.Implementations.Library.LibraryManager.get_RootFolder() in D:\a\1\s\Emby.Server.Implementations\Library\LibraryManager.cs:line 180
at Emby.Server.Implementations.IO.LibraryMonitor.Start() in D:\a\1\s\Emby.Server.Implementations\IO\LibraryMonitor.cs:line 135
at Emby.Server.Implementations.IO.LibraryMonitorStartup.RunAsync() in D:\a\1\s\Emby.Server.Implementations\IO\LibraryMonitorStartup.cs:line 26
at Emby.Server.Implementations.ApplicationHost.StartEntryPoints(IEnumerable`1 entryPoints, Boolean isBeforeStartup)+MoveNext() in D:\a\1\s\Emby.Server.Implementations\ApplicationHost.cs:line 541
at System.Threading.Tasks.Task.WhenAll(IEnumerable`1 tasks)
at Emby.Server.Implementations.ApplicationHost.RunStartupTasksAsync(CancellationToken cancellationToken) in D:\a\1\s\Emby.Server.Implementations\ApplicationHost.cs:line 525
at Jellyfin.Server.Integration.Tests.JellyfinApplicationFactory.CreateServer(IWebHostBuilder builder) in D:\a\1\s\tests\Jellyfin.Server.Integration.Tests\JellyfinApplicationFactory.cs:line 101
at Microsoft.AspNetCore.Mvc.Testing.WebApplicationFactory`1.EnsureServer()
at Microsoft.AspNetCore.Mvc.Testing.WebApplicationFactory`1.CreateDefaultClient(DelegatingHandler[] handlers)
at Microsoft.AspNetCore.Mvc.Testing.WebApplicationFactory`1.CreateDefaultClient(Uri baseAddress, DelegatingHandler[] handlers)
at Microsoft.AspNetCore.Mvc.Testing.WebApplicationFactory`1.CreateClient(WebApplicationFactoryClientOptions options)
at Microsoft.AspNetCore.Mvc.Testing.WebApplicationFactory`1.CreateClient()
at Jellyfin.Server.Integration.Tests.OpenApiSpecTests.GetSpec_ReturnsCorrectResponse() in D:\a\1\s\tests\Jellyfin.Server.Integration.Tests\OpenApiSpecTests.cs:line 26
--- End of stack trace from previous location ---
```
2021-04-04 01:45:15 +02:00
|
|
|
private IMetadataSaver[] _savers = Array.Empty<IMetadataSaver>();
|
|
|
|
private IExternalId[] _externalIds = Array.Empty<IExternalId>();
|
2020-07-03 20:02:04 +02:00
|
|
|
private bool _isProcessingRefreshQueue;
|
|
|
|
private bool _disposed;
|
2017-06-23 18:04:45 +02:00
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
2020-07-03 20:02:04 +02:00
|
|
|
/// Initializes a new instance of the <see cref="ProviderManager"/> class.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
2020-08-17 19:50:07 +02:00
|
|
|
/// <param name="httpClientFactory">The Http client factory.</param>
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <param name="subtitleManager">The subtitle manager.</param>
|
|
|
|
/// <param name="configurationManager">The configuration manager.</param>
|
|
|
|
/// <param name="libraryMonitor">The library monitor.</param>
|
|
|
|
/// <param name="logger">The logger.</param>
|
|
|
|
/// <param name="fileSystem">The filesystem.</param>
|
|
|
|
/// <param name="appPaths">The server application paths.</param>
|
|
|
|
/// <param name="libraryManager">The library manager.</param>
|
2020-10-28 01:01:52 +01:00
|
|
|
/// <param name="baseItemManager">The BaseItem manager.</param>
|
2024-02-26 13:09:40 +01:00
|
|
|
/// <param name="lyricManager">The lyric manager.</param>
|
2024-03-03 21:32:55 +01:00
|
|
|
/// <param name="memoryCache">The memory cache.</param>
|
2020-04-04 20:56:50 +02:00
|
|
|
public ProviderManager(
|
2020-08-17 19:50:07 +02:00
|
|
|
IHttpClientFactory httpClientFactory,
|
2020-04-04 20:56:50 +02:00
|
|
|
ISubtitleManager subtitleManager,
|
|
|
|
IServerConfigurationManager configurationManager,
|
|
|
|
ILibraryMonitor libraryMonitor,
|
|
|
|
ILogger<ProviderManager> logger,
|
|
|
|
IFileSystem fileSystem,
|
|
|
|
IServerApplicationPaths appPaths,
|
2020-10-28 01:01:52 +01:00
|
|
|
ILibraryManager libraryManager,
|
2024-02-26 13:09:40 +01:00
|
|
|
IBaseItemManager baseItemManager,
|
2024-03-03 21:32:55 +01:00
|
|
|
ILyricManager lyricManager,
|
|
|
|
IMemoryCache memoryCache)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
_logger = logger;
|
2020-08-17 19:50:07 +02:00
|
|
|
_httpClientFactory = httpClientFactory;
|
2020-04-04 20:56:50 +02:00
|
|
|
_configurationManager = configurationManager;
|
2014-01-28 22:25:10 +01:00
|
|
|
_libraryMonitor = libraryMonitor;
|
2013-10-31 15:03:23 +01:00
|
|
|
_fileSystem = fileSystem;
|
2015-01-24 05:50:45 +01:00
|
|
|
_appPaths = appPaths;
|
2020-04-04 20:56:50 +02:00
|
|
|
_libraryManager = libraryManager;
|
2018-09-12 19:26:21 +02:00
|
|
|
_subtitleManager = subtitleManager;
|
2020-10-28 01:01:52 +01:00
|
|
|
_baseItemManager = baseItemManager;
|
2024-02-26 13:09:40 +01:00
|
|
|
_lyricManager = lyricManager;
|
2024-03-03 21:32:55 +01:00
|
|
|
_memoryCache = memoryCache;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2021-12-05 21:43:59 +01:00
|
|
|
public event EventHandler<GenericEventArgs<BaseItem>>? RefreshStarted;
|
2020-07-03 20:02:04 +02:00
|
|
|
|
|
|
|
/// <inheritdoc/>
|
2021-12-05 21:43:59 +01:00
|
|
|
public event EventHandler<GenericEventArgs<BaseItem>>? RefreshCompleted;
|
2020-07-03 20:02:04 +02:00
|
|
|
|
|
|
|
/// <inheritdoc/>
|
2021-12-05 21:43:59 +01:00
|
|
|
public event EventHandler<GenericEventArgs<Tuple<BaseItem, double>>>? RefreshProgress;
|
2020-07-03 20:02:04 +02:00
|
|
|
|
|
|
|
/// <inheritdoc/>
|
|
|
|
public void AddParts(
|
|
|
|
IEnumerable<IImageProvider> imageProviders,
|
|
|
|
IEnumerable<IMetadataService> metadataServices,
|
|
|
|
IEnumerable<IMetadataProvider> metadataProviders,
|
|
|
|
IEnumerable<IMetadataSaver> metadataSavers,
|
|
|
|
IEnumerable<IExternalId> externalIds)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2021-12-05 21:43:59 +01:00
|
|
|
_imageProviders = imageProviders.ToArray();
|
2014-01-28 19:37:01 +01:00
|
|
|
_metadataServices = metadataServices.OrderBy(i => i.Order).ToArray();
|
2014-01-31 20:55:21 +01:00
|
|
|
_metadataProviders = metadataProviders.ToArray();
|
2020-05-17 23:35:43 +02:00
|
|
|
_externalIds = externalIds.OrderBy(i => i.ProviderName).ToArray();
|
2015-08-02 21:08:55 +02:00
|
|
|
|
2022-01-22 23:36:42 +01:00
|
|
|
_savers = metadataSavers.ToArray();
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public Task<ItemUpdateType> RefreshSingleItem(BaseItem item, MetadataRefreshOptions options, CancellationToken cancellationToken)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2017-10-06 17:49:22 +02:00
|
|
|
var type = item.GetType();
|
|
|
|
|
2023-06-22 05:01:47 +02:00
|
|
|
var service = _metadataServices.FirstOrDefault(current => current.CanRefreshPrimary(type))
|
|
|
|
?? _metadataServices.FirstOrDefault(current => current.CanRefresh(item));
|
2017-10-06 17:49:22 +02:00
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (service is null)
|
2017-10-06 17:49:22 +02:00
|
|
|
{
|
2023-06-22 05:01:47 +02:00
|
|
|
_logger.LogError("Unable to find a metadata service for item of type {TypeName}", type.Name);
|
2021-12-21 00:25:35 +01:00
|
|
|
return Task.FromResult(ItemUpdateType.None);
|
2017-10-06 17:49:22 +02:00
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2021-12-21 00:25:35 +01:00
|
|
|
return service.RefreshMetadata(item, options, cancellationToken);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public async Task SaveImage(BaseItem item, string url, ImageType type, int? imageIndex, CancellationToken cancellationToken)
|
2013-06-28 22:25:58 +02:00
|
|
|
{
|
2024-03-03 21:32:55 +01:00
|
|
|
using (await _imageSaveLock.LockAsync(url, cancellationToken).ConfigureAwait(false))
|
2020-09-29 10:19:12 +02:00
|
|
|
{
|
2024-03-03 21:32:55 +01:00
|
|
|
if (_memoryCache.TryGetValue(url, out (string ContentType, byte[] ImageContents)? cachedValue)
|
|
|
|
&& cachedValue is not null)
|
|
|
|
{
|
|
|
|
var imageContents = cachedValue.Value.ImageContents;
|
|
|
|
var cacheStream = new MemoryStream(imageContents, 0, imageContents.Length, false);
|
|
|
|
await using (cacheStream.ConfigureAwait(false))
|
|
|
|
{
|
|
|
|
await SaveImage(
|
|
|
|
item,
|
|
|
|
cacheStream,
|
|
|
|
cachedValue.Value.ContentType,
|
|
|
|
type,
|
|
|
|
imageIndex,
|
|
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2020-09-28 06:47:30 +02:00
|
|
|
|
2024-03-03 21:32:55 +01:00
|
|
|
var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
|
|
|
|
using var response = await httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
|
2013-06-28 22:25:58 +02:00
|
|
|
|
2024-03-03 21:32:55 +01:00
|
|
|
response.EnsureSuccessStatusCode();
|
|
|
|
|
|
|
|
var contentType = response.Content.Headers.ContentType?.MediaType;
|
|
|
|
|
|
|
|
// Workaround for tvheadend channel icons
|
|
|
|
// TODO: Isolate this hack into the tvh plugin
|
|
|
|
if (string.IsNullOrEmpty(contentType))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
2024-03-03 21:32:55 +01:00
|
|
|
if (url.Contains("/imagecache/", StringComparison.OrdinalIgnoreCase))
|
|
|
|
{
|
|
|
|
contentType = MediaTypeNames.Image.Png;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw new HttpRequestException("Invalid image received: contentType not set.", null, response.StatusCode);
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2024-03-03 21:32:55 +01:00
|
|
|
|
|
|
|
// TVDb will sometimes serve a rubbish 404 html page with a 200 OK code, because reasons...
|
|
|
|
if (contentType.Equals(MediaTypeNames.Text.Html, StringComparison.OrdinalIgnoreCase))
|
2022-01-01 00:22:46 +01:00
|
|
|
{
|
2024-03-03 21:32:55 +01:00
|
|
|
throw new HttpRequestException("Invalid image received.", null, HttpStatusCode.NotFound);
|
2022-01-01 00:22:46 +01:00
|
|
|
}
|
2020-07-03 20:02:04 +02:00
|
|
|
|
2024-03-03 21:32:55 +01:00
|
|
|
// some iptv/epg providers don't correctly report media type, extract from url if no extension found
|
|
|
|
if (string.IsNullOrWhiteSpace(MimeTypes.ToExtension(contentType)))
|
|
|
|
{
|
|
|
|
// Strip query parameters from url to get actual path.
|
|
|
|
contentType = MimeTypes.GetMimeType(new Uri(url).GetLeftPart(UriPartial.Path));
|
|
|
|
}
|
2020-08-06 23:43:19 +02:00
|
|
|
|
2024-03-03 21:32:55 +01:00
|
|
|
if (!contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
|
|
|
|
{
|
|
|
|
throw new HttpRequestException($"Request returned {contentType} instead of an image type", null, HttpStatusCode.NotFound);
|
|
|
|
}
|
2022-04-09 16:46:06 +02:00
|
|
|
|
2024-03-03 21:32:55 +01:00
|
|
|
var responseBytes = await response.Content.ReadAsByteArrayAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
var stream = new MemoryStream(responseBytes, 0, responseBytes.Length, false);
|
|
|
|
await using (stream.ConfigureAwait(false))
|
|
|
|
{
|
|
|
|
_memoryCache.Set(url, (contentType, responseBytes), TimeSpan.FromSeconds(10));
|
|
|
|
|
|
|
|
await SaveImage(
|
|
|
|
item,
|
|
|
|
stream,
|
|
|
|
contentType,
|
|
|
|
type,
|
|
|
|
imageIndex,
|
|
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
}
|
2023-01-11 10:36:18 +01:00
|
|
|
}
|
2013-06-28 22:25:58 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public Task SaveImage(BaseItem item, Stream source, string mimeType, ImageType type, int? imageIndex, CancellationToken cancellationToken)
|
2013-06-28 22:25:58 +02:00
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
return new ImageSaver(_configurationManager, _libraryMonitor, _fileSystem, _logger).SaveImage(item, source, mimeType, type, imageIndex, cancellationToken);
|
2013-06-28 22:25:58 +02:00
|
|
|
}
|
2013-10-30 22:33:27 +01:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public Task SaveImage(BaseItem item, string source, string mimeType, ImageType type, int? imageIndex, bool? saveLocallyWithMedia, CancellationToken cancellationToken)
|
2015-04-08 17:45:30 +02:00
|
|
|
{
|
2015-06-21 23:31:21 +02:00
|
|
|
if (string.IsNullOrWhiteSpace(source))
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
throw new ArgumentNullException(nameof(source));
|
2015-06-21 23:31:21 +02:00
|
|
|
}
|
|
|
|
|
2021-10-03 19:52:38 +02:00
|
|
|
var fileStream = AsyncFile.OpenRead(source);
|
2020-04-04 20:56:50 +02:00
|
|
|
return new ImageSaver(_configurationManager, _libraryMonitor, _fileSystem, _logger).SaveImage(item, fileStream, mimeType, type, imageIndex, saveLocallyWithMedia, cancellationToken);
|
2015-04-08 17:45:30 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2020-08-07 19:26:28 +02:00
|
|
|
public Task SaveImage(Stream source, string mimeType, string path)
|
2020-05-13 04:10:35 +02:00
|
|
|
{
|
|
|
|
return new ImageSaver(_configurationManager, _libraryMonitor, _fileSystem, _logger)
|
2020-08-07 19:26:28 +02:00
|
|
|
.SaveImage(source, path);
|
2020-05-13 04:10:35 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public async Task<IEnumerable<RemoteImageInfo>> GetAvailableRemoteImages(BaseItem item, RemoteImageQuery query, CancellationToken cancellationToken)
|
2013-10-30 22:33:27 +01:00
|
|
|
{
|
2014-02-12 04:46:27 +01:00
|
|
|
var providers = GetRemoteImageProviders(item, query.IncludeDisabledProviders);
|
2013-11-01 02:48:14 +01:00
|
|
|
|
2014-02-12 04:46:27 +01:00
|
|
|
if (!string.IsNullOrEmpty(query.ProviderName))
|
2013-11-01 02:48:14 +01:00
|
|
|
{
|
2014-02-12 04:46:27 +01:00
|
|
|
var providerName = query.ProviderName;
|
|
|
|
|
2013-11-01 02:48:14 +01:00
|
|
|
providers = providers.Where(i => string.Equals(i.Name, providerName, StringComparison.OrdinalIgnoreCase));
|
|
|
|
}
|
|
|
|
|
2023-06-22 05:01:47 +02:00
|
|
|
if (query.ImageType is not null)
|
|
|
|
{
|
|
|
|
providers = providers.Where(i => i.GetSupportedImages(item).Contains(query.ImageType.Value));
|
|
|
|
}
|
|
|
|
|
2013-12-27 01:23:58 +01:00
|
|
|
var preferredLanguage = item.GetPreferredMetadataLanguage();
|
2013-10-30 22:33:27 +01:00
|
|
|
|
2021-09-08 23:20:11 +02:00
|
|
|
var tasks = providers.Select(i => GetImages(item, i, preferredLanguage, query.IncludeAllLanguages, cancellationToken, query.ImageType));
|
2013-12-30 03:41:22 +01:00
|
|
|
|
|
|
|
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
|
|
|
|
|
2017-08-09 21:56:38 +02:00
|
|
|
return results.SelectMany(i => i.ToList());
|
2013-12-30 03:41:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the images.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The item.</param>
|
2014-02-13 06:11:54 +01:00
|
|
|
/// <param name="provider">The provider.</param>
|
2021-09-08 23:20:11 +02:00
|
|
|
/// <param name="preferredLanguage">The preferred language.</param>
|
|
|
|
/// <param name="includeAllLanguages">Whether to include all languages in results.</param>
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
2013-12-30 03:41:22 +01:00
|
|
|
/// <param name="type">The type.</param>
|
|
|
|
/// <returns>Task{IEnumerable{RemoteImageInfo}}.</returns>
|
2020-07-03 20:02:04 +02:00
|
|
|
private async Task<IEnumerable<RemoteImageInfo>> GetImages(
|
|
|
|
BaseItem item,
|
|
|
|
IRemoteImageProvider provider,
|
2021-09-08 23:20:11 +02:00
|
|
|
string preferredLanguage,
|
|
|
|
bool includeAllLanguages,
|
2020-07-03 20:02:04 +02:00
|
|
|
CancellationToken cancellationToken,
|
|
|
|
ImageType? type = null)
|
2013-12-30 03:41:22 +01:00
|
|
|
{
|
2021-09-08 23:20:11 +02:00
|
|
|
bool hasPreferredLanguage = !string.IsNullOrWhiteSpace(preferredLanguage);
|
|
|
|
|
2013-12-30 03:41:22 +01:00
|
|
|
try
|
2013-10-30 22:33:27 +01:00
|
|
|
{
|
2014-02-13 06:11:54 +01:00
|
|
|
var result = await provider.GetImages(item, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
2013-12-30 03:41:22 +01:00
|
|
|
if (type.HasValue)
|
2013-10-30 22:33:27 +01:00
|
|
|
{
|
2014-02-13 06:11:54 +01:00
|
|
|
result = result.Where(i => i.Type == type.Value);
|
2013-10-30 22:33:27 +01:00
|
|
|
}
|
2014-02-12 04:46:27 +01:00
|
|
|
|
2021-09-08 23:20:11 +02:00
|
|
|
if (!includeAllLanguages && hasPreferredLanguage)
|
2014-02-19 06:21:03 +01:00
|
|
|
{
|
2021-09-08 23:20:11 +02:00
|
|
|
// Filter out languages that do not match the preferred languages.
|
|
|
|
//
|
|
|
|
// TODO: should exception case of "en" (English) eventually be removed?
|
|
|
|
result = result.Where(i => string.IsNullOrWhiteSpace(i.Language) ||
|
|
|
|
string.Equals(preferredLanguage, i.Language, StringComparison.OrdinalIgnoreCase) ||
|
2014-07-05 06:01:30 +02:00
|
|
|
string.Equals(i.Language, "en", StringComparison.OrdinalIgnoreCase));
|
2014-02-19 06:21:03 +01:00
|
|
|
}
|
|
|
|
|
2021-09-08 23:20:11 +02:00
|
|
|
return result.OrderByLanguageDescending(preferredLanguage);
|
2013-12-30 03:41:22 +01:00
|
|
|
}
|
2014-02-26 05:38:21 +01:00
|
|
|
catch (OperationCanceledException)
|
|
|
|
{
|
2023-03-01 00:44:57 +01:00
|
|
|
return Enumerable.Empty<RemoteImageInfo>();
|
2014-02-26 05:38:21 +01:00
|
|
|
}
|
2013-12-30 03:41:22 +01:00
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2020-07-19 13:59:28 +02:00
|
|
|
_logger.LogError(ex, "{ProviderName} failed in GetImageInfos for type {ItemType} at {ItemPath}", provider.GetType().Name, item.GetType().Name, item.Path);
|
2023-03-01 00:44:57 +01:00
|
|
|
return Enumerable.Empty<RemoteImageInfo>();
|
2013-12-30 03:41:22 +01:00
|
|
|
}
|
2013-10-30 22:33:27 +01:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public IEnumerable<ImageProviderInfo> GetRemoteImageProviderInfo(BaseItem item)
|
2014-01-31 20:55:21 +01:00
|
|
|
{
|
2020-04-05 18:10:56 +02:00
|
|
|
return GetRemoteImageProviders(item, true).Select(i => new ImageProviderInfo(i.Name, i.GetSupportedImages(item).ToArray()));
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
|
2021-12-06 22:31:16 +01:00
|
|
|
private IEnumerable<IRemoteImageProvider> GetRemoteImageProviders(BaseItem item, bool includeDisabled)
|
2013-10-30 22:33:27 +01:00
|
|
|
{
|
2021-12-06 22:31:16 +01:00
|
|
|
var options = GetMetadataOptions(item);
|
|
|
|
var libraryOptions = _libraryManager.GetLibraryOptions(item);
|
|
|
|
|
|
|
|
return GetImageProvidersInternal(
|
|
|
|
item,
|
|
|
|
libraryOptions,
|
|
|
|
options,
|
|
|
|
new ImageRefreshOptions(new DirectoryService(_fileSystem)),
|
|
|
|
includeDisabled).OfType<IRemoteImageProvider>();
|
2014-02-11 05:55:01 +01:00
|
|
|
}
|
|
|
|
|
2021-11-30 23:53:34 +01:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public IEnumerable<IImageProvider> GetImageProviders(BaseItem item, ImageRefreshOptions refreshOptions)
|
2014-02-11 05:55:01 +01:00
|
|
|
{
|
2021-12-06 22:31:16 +01:00
|
|
|
return GetImageProvidersInternal(item, _libraryManager.GetLibraryOptions(item), GetMetadataOptions(item), refreshOptions, false);
|
2014-02-11 05:55:01 +01:00
|
|
|
}
|
2014-02-19 06:21:03 +01:00
|
|
|
|
2021-12-06 22:31:16 +01:00
|
|
|
private IEnumerable<IImageProvider> GetImageProvidersInternal(BaseItem item, LibraryOptions libraryOptions, MetadataOptions options, ImageRefreshOptions refreshOptions, bool includeDisabled)
|
2014-02-11 05:55:01 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var typeOptions = libraryOptions.GetTypeOptions(item.GetType().Name);
|
2021-12-05 21:33:31 +01:00
|
|
|
var fetcherOrder = typeOptions?.ImageFetcherOrder ?? options.ImageFetcherOrder;
|
2014-02-11 05:55:01 +01:00
|
|
|
|
2021-12-18 21:40:27 +01:00
|
|
|
return _imageProviders.Where(i => CanRefreshImages(i, item, typeOptions, refreshOptions, includeDisabled))
|
2021-12-05 21:33:31 +01:00
|
|
|
.OrderBy(i => GetConfiguredOrder(fetcherOrder, i.Name))
|
2021-12-08 16:49:09 +01:00
|
|
|
.ThenBy(GetDefaultOrder);
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
|
2021-12-18 22:30:06 +01:00
|
|
|
private bool CanRefreshImages(
|
|
|
|
IImageProvider provider,
|
|
|
|
BaseItem item,
|
|
|
|
TypeOptions? libraryTypeOptions,
|
|
|
|
ImageRefreshOptions refreshOptions,
|
|
|
|
bool includeDisabled)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
if (!provider.Supports(item))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
2021-12-18 22:30:06 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2021-12-18 22:30:06 +01:00
|
|
|
if (includeDisabled || provider is ILocalImageProvider)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (item.IsLocked && refreshOptions.ImageRefreshMode != MetadataRefreshMode.FullRefresh)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2021-12-18 22:30:06 +01:00
|
|
|
return _baseItemManager.IsImageFetcherEnabled(item, libraryTypeOptions, provider.Name);
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
|
2021-11-30 23:53:34 +01:00
|
|
|
/// <inheritdoc />
|
2018-09-12 19:26:21 +02:00
|
|
|
public IEnumerable<IMetadataProvider<T>> GetMetadataProviders<T>(BaseItem item, LibraryOptions libraryOptions)
|
|
|
|
where T : BaseItem
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var globalMetadataOptions = GetMetadataOptions(item);
|
2014-02-10 19:39:41 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetMetadataProvidersInternal<T>(item, libraryOptions, globalMetadataOptions, false, false);
|
2014-02-02 14:36:31 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private IEnumerable<IMetadataProvider<T>> GetMetadataProvidersInternal<T>(BaseItem item, LibraryOptions libraryOptions, MetadataOptions globalMetadataOptions, bool includeDisabled, bool forceEnableInternetMetadata)
|
|
|
|
where T : BaseItem
|
2014-01-31 20:55:21 +01:00
|
|
|
{
|
2021-12-08 16:49:09 +01:00
|
|
|
var localMetadataReaderOrder = libraryOptions.LocalMetadataReaderOrder ?? globalMetadataOptions.LocalMetadataReaderOrder;
|
|
|
|
var typeOptions = libraryOptions.GetTypeOptions(item.GetType().Name);
|
|
|
|
var metadataFetcherOrder = typeOptions?.MetadataFetcherOrder ?? globalMetadataOptions.MetadataFetcherOrder;
|
2014-02-12 04:46:27 +01:00
|
|
|
|
2014-02-19 06:21:03 +01:00
|
|
|
return _metadataProviders.OfType<IMetadataProvider<T>>()
|
2021-12-18 21:40:27 +01:00
|
|
|
.Where(i => CanRefreshMetadata(i, item, typeOptions, includeDisabled, forceEnableInternetMetadata))
|
2021-12-08 16:49:09 +01:00
|
|
|
.OrderBy(i =>
|
|
|
|
// local and remote providers will be interleaved in the final order
|
|
|
|
// only relative order within a type matters: consumers of the list filter to one or the other
|
2021-12-24 09:50:58 +01:00
|
|
|
i switch
|
2021-12-08 16:49:09 +01:00
|
|
|
{
|
2021-12-24 09:50:58 +01:00
|
|
|
ILocalMetadataProvider => GetConfiguredOrder(localMetadataReaderOrder, i.Name),
|
|
|
|
IRemoteMetadataProvider => GetConfiguredOrder(metadataFetcherOrder, i.Name),
|
|
|
|
// Default to end
|
|
|
|
_ => int.MaxValue
|
|
|
|
})
|
2014-02-19 06:21:03 +01:00
|
|
|
.ThenBy(GetDefaultOrder);
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
|
2021-12-06 22:31:16 +01:00
|
|
|
private bool CanRefreshMetadata(
|
2020-07-03 20:02:04 +02:00
|
|
|
IMetadataProvider provider,
|
|
|
|
BaseItem item,
|
2021-12-18 21:40:27 +01:00
|
|
|
TypeOptions? libraryTypeOptions,
|
2020-07-03 20:02:04 +02:00
|
|
|
bool includeDisabled,
|
|
|
|
bool forceEnableInternetMetadata)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2014-02-10 21:11:46 +01:00
|
|
|
if (!item.SupportsLocalMetadata && provider is ILocalMetadataProvider)
|
2014-01-31 20:55:21 +01:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-12-18 22:30:06 +01:00
|
|
|
if (includeDisabled)
|
2014-02-11 05:55:01 +01:00
|
|
|
{
|
2021-12-18 22:30:06 +01:00
|
|
|
return true;
|
2014-02-11 05:55:01 +01:00
|
|
|
}
|
|
|
|
|
2021-12-18 22:30:06 +01:00
|
|
|
// If locked only allow local providers
|
|
|
|
if (item.IsLocked && provider is not ILocalMetadataProvider && provider is not IForcedProvider)
|
2014-02-11 05:55:01 +01:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-12-18 22:30:06 +01:00
|
|
|
if (forceEnableInternetMetadata || provider is not IRemoteMetadataProvider)
|
2014-01-31 20:55:21 +01:00
|
|
|
{
|
2021-12-18 22:30:06 +01:00
|
|
|
return true;
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
|
2021-12-18 22:30:06 +01:00
|
|
|
return _baseItemManager.IsMetadataFetcherEnabled(item, libraryTypeOptions, provider.Name);
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
|
2021-12-08 16:49:09 +01:00
|
|
|
private static int GetConfiguredOrder(string[] order, string providerName)
|
2014-02-19 06:21:03 +01:00
|
|
|
{
|
2021-12-08 16:49:09 +01:00
|
|
|
var index = Array.IndexOf(order, providerName);
|
2014-02-19 06:21:03 +01:00
|
|
|
|
2021-12-08 16:49:09 +01:00
|
|
|
if (index != -1)
|
2014-02-19 06:21:03 +01:00
|
|
|
{
|
2021-12-08 16:49:09 +01:00
|
|
|
return index;
|
2014-02-19 06:21:03 +01:00
|
|
|
}
|
|
|
|
|
2021-12-08 16:49:09 +01:00
|
|
|
// default to end
|
|
|
|
return int.MaxValue;
|
2014-02-19 06:21:03 +01:00
|
|
|
}
|
2014-02-19 17:24:06 +01:00
|
|
|
|
2021-12-08 16:49:09 +01:00
|
|
|
private static int GetDefaultOrder(object provider)
|
2014-01-31 20:55:21 +01:00
|
|
|
{
|
2020-07-03 20:02:04 +02:00
|
|
|
if (provider is IHasOrder hasOrder)
|
2014-01-31 20:55:21 +01:00
|
|
|
{
|
2014-02-10 19:39:41 +01:00
|
|
|
return hasOrder.Order;
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
|
2021-12-05 21:33:31 +01:00
|
|
|
// after items that want to be first (~0) but before items that want to be last (~100)
|
|
|
|
return 50;
|
2013-10-30 22:33:27 +01:00
|
|
|
}
|
2014-02-02 14:36:31 +01:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2017-08-19 21:43:35 +02:00
|
|
|
public MetadataPluginSummary[] GetAllMetadataPlugins()
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2020-07-03 20:02:04 +02:00
|
|
|
return new[]
|
2014-02-07 21:30:41 +01:00
|
|
|
{
|
|
|
|
GetPluginSummary<Movie>(),
|
|
|
|
GetPluginSummary<BoxSet>(),
|
|
|
|
GetPluginSummary<Book>(),
|
|
|
|
GetPluginSummary<Series>(),
|
|
|
|
GetPluginSummary<Season>(),
|
|
|
|
GetPluginSummary<Episode>(),
|
|
|
|
GetPluginSummary<MusicAlbum>(),
|
|
|
|
GetPluginSummary<MusicArtist>(),
|
|
|
|
GetPluginSummary<Audio>(),
|
2017-10-06 17:49:22 +02:00
|
|
|
GetPluginSummary<AudioBook>(),
|
2014-02-07 21:30:41 +01:00
|
|
|
GetPluginSummary<Studio>(),
|
|
|
|
GetPluginSummary<MusicVideo>(),
|
2018-09-12 19:26:21 +02:00
|
|
|
GetPluginSummary<Video>()
|
2014-02-07 21:30:41 +01:00
|
|
|
};
|
2014-02-02 14:36:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private MetadataPluginSummary GetPluginSummary<T>()
|
|
|
|
where T : BaseItem, new()
|
|
|
|
{
|
|
|
|
// Give it a dummy path just so that it looks like a file system item
|
2020-07-03 20:02:04 +02:00
|
|
|
var dummy = new T
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2015-09-06 18:02:41 +02:00
|
|
|
Path = Path.Combine(_appPaths.InternalMetadataPath, "dummy"),
|
|
|
|
ParentId = Guid.NewGuid()
|
2014-02-02 14:36:31 +01:00
|
|
|
};
|
|
|
|
|
2014-02-10 19:39:41 +01:00
|
|
|
var options = GetMetadataOptions(dummy);
|
|
|
|
|
2014-02-02 14:36:31 +01:00
|
|
|
var summary = new MetadataPluginSummary
|
|
|
|
{
|
|
|
|
ItemType = typeof(T).Name
|
|
|
|
};
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var libraryOptions = new LibraryOptions();
|
|
|
|
|
2021-12-06 22:31:16 +01:00
|
|
|
var imageProviders = GetImageProvidersInternal(
|
2020-07-03 20:02:04 +02:00
|
|
|
dummy,
|
|
|
|
libraryOptions,
|
|
|
|
options,
|
|
|
|
new ImageRefreshOptions(new DirectoryService(_fileSystem)),
|
|
|
|
true).ToList();
|
2014-02-02 14:36:31 +01:00
|
|
|
|
2017-08-19 21:43:35 +02:00
|
|
|
var pluginList = summary.Plugins.ToList();
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
AddMetadataPlugins(pluginList, dummy, libraryOptions, options);
|
2020-08-07 19:26:28 +02:00
|
|
|
AddImagePlugins(pluginList, imageProviders);
|
2017-08-19 21:43:35 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
// Subtitle fetchers
|
2024-02-26 13:09:40 +01:00
|
|
|
var subtitleProviders = _subtitleManager.GetSupportedProviders(dummy);
|
2018-09-12 19:26:21 +02:00
|
|
|
pluginList.AddRange(subtitleProviders.Select(i => new MetadataPlugin
|
|
|
|
{
|
|
|
|
Name = i.Name,
|
|
|
|
Type = MetadataPluginType.SubtitleFetcher
|
|
|
|
}));
|
|
|
|
|
2024-02-26 13:09:40 +01:00
|
|
|
// Lyric fetchers
|
|
|
|
var lyricProviders = _lyricManager.GetSupportedProviders(dummy);
|
|
|
|
pluginList.AddRange(lyricProviders.Select(i => new MetadataPlugin
|
|
|
|
{
|
|
|
|
Name = i.Name,
|
|
|
|
Type = MetadataPluginType.LyricFetcher
|
|
|
|
}));
|
|
|
|
|
2018-12-28 16:48:26 +01:00
|
|
|
summary.Plugins = pluginList.ToArray();
|
2014-02-02 14:36:31 +01:00
|
|
|
|
2014-02-24 04:27:13 +01:00
|
|
|
var supportedImageTypes = imageProviders.OfType<IRemoteImageProvider>()
|
2014-02-02 14:36:31 +01:00
|
|
|
.SelectMany(i => i.GetSupportedImages(dummy))
|
|
|
|
.ToList();
|
2014-02-24 04:27:13 +01:00
|
|
|
|
|
|
|
supportedImageTypes.AddRange(imageProviders.OfType<IDynamicImageProvider>()
|
|
|
|
.SelectMany(i => i.GetSupportedImages(dummy)));
|
|
|
|
|
2017-08-19 21:43:35 +02:00
|
|
|
summary.SupportedImageTypes = supportedImageTypes.Distinct().ToArray();
|
2014-02-02 14:36:31 +01:00
|
|
|
|
|
|
|
return summary;
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private void AddMetadataPlugins<T>(List<MetadataPlugin> list, T item, LibraryOptions libraryOptions, MetadataOptions options)
|
|
|
|
where T : BaseItem
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var providers = GetMetadataProvidersInternal<T>(item, libraryOptions, options, true, true).ToList();
|
2014-02-02 14:36:31 +01:00
|
|
|
|
|
|
|
// Locals
|
2020-08-07 19:26:28 +02:00
|
|
|
list.AddRange(providers.Where(i => i is ILocalMetadataProvider).Select(i => new MetadataPlugin
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
|
|
|
Name = i.Name,
|
|
|
|
Type = MetadataPluginType.LocalMetadataProvider
|
|
|
|
}));
|
|
|
|
|
2016-12-29 08:14:59 +01:00
|
|
|
// Fetchers
|
2020-08-07 19:26:28 +02:00
|
|
|
list.AddRange(providers.Where(i => i is IRemoteMetadataProvider).Select(i => new MetadataPlugin
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2016-12-29 08:14:59 +01:00
|
|
|
Name = i.Name,
|
|
|
|
Type = MetadataPluginType.MetadataFetcher
|
|
|
|
}));
|
2014-03-02 16:42:21 +01:00
|
|
|
|
2016-12-29 08:14:59 +01:00
|
|
|
// Savers
|
2018-09-12 19:26:21 +02:00
|
|
|
list.AddRange(_savers.Where(i => IsSaverEnabledForItem(i, item, libraryOptions, ItemUpdateType.MetadataEdit, true)).OrderBy(i => i.Name).Select(i => new MetadataPlugin
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2016-12-29 08:14:59 +01:00
|
|
|
Name = i.Name,
|
|
|
|
Type = MetadataPluginType.MetadataSaver
|
|
|
|
}));
|
2014-02-02 14:36:31 +01:00
|
|
|
}
|
|
|
|
|
2020-08-07 19:26:28 +02:00
|
|
|
private void AddImagePlugins(List<MetadataPlugin> list, List<IImageProvider> imageProviders)
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
|
|
|
// Locals
|
2020-08-07 19:26:28 +02:00
|
|
|
list.AddRange(imageProviders.Where(i => i is ILocalImageProvider).Select(i => new MetadataPlugin
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
|
|
|
Name = i.Name,
|
|
|
|
Type = MetadataPluginType.LocalImageProvider
|
|
|
|
}));
|
|
|
|
|
|
|
|
// Fetchers
|
2018-09-12 19:26:21 +02:00
|
|
|
list.AddRange(imageProviders.Where(i => i is IDynamicImageProvider || (i is IRemoteImageProvider)).Select(i => new MetadataPlugin
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
|
|
|
Name = i.Name,
|
|
|
|
Type = MetadataPluginType.ImageFetcher
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public MetadataOptions GetMetadataOptions(BaseItem item)
|
2023-06-22 05:01:47 +02:00
|
|
|
=> _configurationManager.GetMetadataOptionsForType(item.GetType().Name) ?? new MetadataOptions();
|
2014-02-10 19:39:41 +01:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2022-01-22 23:36:42 +01:00
|
|
|
public Task SaveMetadataAsync(BaseItem item, ItemUpdateType updateType)
|
|
|
|
=> SaveMetadataAsync(item, updateType, _savers);
|
2014-09-27 04:28:13 +02:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2022-01-22 23:36:42 +01:00
|
|
|
public Task SaveMetadataAsync(BaseItem item, ItemUpdateType updateType, IEnumerable<string> savers)
|
|
|
|
=> SaveMetadataAsync(item, updateType, _savers.Where(i => savers.Contains(i.Name, StringComparison.OrdinalIgnoreCase)));
|
2014-09-27 04:28:13 +02:00
|
|
|
|
|
|
|
/// <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>
|
2022-01-22 23:36:42 +01:00
|
|
|
private async Task SaveMetadataAsync(BaseItem item, ItemUpdateType updateType, IEnumerable<IMetadataSaver> savers)
|
2014-09-27 04:28:13 +02:00
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
var libraryOptions = _libraryManager.GetLibraryOptions(item);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
foreach (var saver in savers.Where(i => IsSaverEnabledForItem(i, item, libraryOptions, updateType, false)))
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2022-01-01 00:22:46 +01:00
|
|
|
_logger.LogDebug("Saving {Item} to {Saver}", item.Path ?? item.Name, saver.Name);
|
2014-02-10 19:39:41 +01:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
if (saver is IMetadataFileSaver fileSaver)
|
2014-02-02 17:59:14 +01:00
|
|
|
{
|
2020-07-03 20:02:04 +02:00
|
|
|
string path;
|
2014-02-08 21:02:35 +01:00
|
|
|
|
|
|
|
try
|
2014-02-02 17:59:14 +01:00
|
|
|
{
|
2014-02-08 21:02:35 +01:00
|
|
|
path = fileSaver.GetSavePath(item);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2022-01-01 00:22:46 +01:00
|
|
|
_logger.LogError(ex, "Error in {Saver} GetSavePath", saver.Name);
|
2014-02-08 21:02:35 +01:00
|
|
|
continue;
|
2014-02-02 17:59:14 +01:00
|
|
|
}
|
2014-02-02 14:36:31 +01:00
|
|
|
|
2014-02-02 17:59:14 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
_libraryMonitor.ReportFileSystemChangeBeginning(path);
|
2022-01-22 23:36:42 +01:00
|
|
|
await saver.SaveAsync(item, CancellationToken.None).ConfigureAwait(false);
|
2014-02-02 17:59:14 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error in metadata saver");
|
2014-02-02 17:59:14 +01:00
|
|
|
}
|
|
|
|
finally
|
|
|
|
{
|
|
|
|
_libraryMonitor.ReportFileSystemChangeComplete(path, false);
|
|
|
|
}
|
2014-02-02 14:36:31 +01:00
|
|
|
}
|
2014-02-02 17:59:14 +01:00
|
|
|
else
|
2014-02-02 14:36:31 +01:00
|
|
|
{
|
2014-02-02 17:59:14 +01:00
|
|
|
try
|
|
|
|
{
|
2022-01-22 23:36:42 +01:00
|
|
|
await saver.SaveAsync(item, CancellationToken.None).ConfigureAwait(false);
|
2014-02-02 17:59:14 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error in metadata saver");
|
2014-02-02 17:59:14 +01:00
|
|
|
}
|
2014-02-02 14:36:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-02-08 21:02:35 +01:00
|
|
|
|
2014-09-27 04:28:13 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Determines whether [is saver enabled for item] [the specified saver].
|
|
|
|
/// </summary>
|
2018-09-12 19:26:21 +02:00
|
|
|
private bool IsSaverEnabledForItem(IMetadataSaver saver, BaseItem item, LibraryOptions libraryOptions, ItemUpdateType updateType, bool includeDisabled)
|
2014-02-08 21:02:35 +01:00
|
|
|
{
|
2014-02-10 00:08:01 +01:00
|
|
|
var options = GetMetadataOptions(item);
|
|
|
|
|
2014-02-08 21:02:35 +01:00
|
|
|
try
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!saver.IsEnabledFor(item, updateType))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-06-04 05:34:36 +02:00
|
|
|
|
2014-02-27 04:57:37 +01:00
|
|
|
if (!includeDisabled)
|
2014-02-10 00:08:01 +01:00
|
|
|
{
|
2022-12-05 15:00:20 +01:00
|
|
|
if (libraryOptions.MetadataSavers is null)
|
2014-02-27 04:57:37 +01:00
|
|
|
{
|
2021-12-20 13:31:07 +01:00
|
|
|
if (options.DisabledMetadataSavers.Contains(saver.Name, StringComparison.OrdinalIgnoreCase))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-06-04 05:34:36 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!item.IsSaveLocalMetadataEnabled())
|
2014-04-08 06:17:18 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (updateType >= ItemUpdateType.MetadataEdit)
|
|
|
|
{
|
|
|
|
// Manual edit occurred
|
|
|
|
// Even if save local is off, save locally anyway if the metadata file already exists
|
2021-08-29 00:32:50 +02:00
|
|
|
if (saver is not IMetadataFileSaver fileSaver || !File.Exists(fileSaver.GetSavePath(item)))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2014-04-08 06:17:18 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
// Manual edit did not occur
|
|
|
|
// Since local metadata saving is disabled, consider it disabled
|
2014-04-08 06:17:18 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-20 13:31:07 +01:00
|
|
|
if (!libraryOptions.MetadataSavers.Contains(saver.Name, StringComparison.OrdinalIgnoreCase))
|
2014-04-08 06:17:18 +02:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-02-27 04:57:37 +01:00
|
|
|
}
|
2014-02-10 00:08:01 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return true;
|
2014-02-08 21:02:35 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2022-01-01 00:22:46 +01:00
|
|
|
_logger.LogError(ex, "Error in {Saver}.IsEnabledFor", saver.Name);
|
2014-02-08 21:02:35 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2014-02-19 06:21:03 +01:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2018-09-12 19:26:21 +02:00
|
|
|
public Task<IEnumerable<RemoteSearchResult>> GetRemoteSearchResults<TItemType, TLookupType>(RemoteSearchQuery<TLookupType> searchInfo, CancellationToken cancellationToken)
|
2014-02-19 17:24:06 +01:00
|
|
|
where TItemType : BaseItem, new()
|
|
|
|
where TLookupType : ItemLookupInfo
|
|
|
|
{
|
2021-12-05 21:43:59 +01:00
|
|
|
BaseItem? referenceItem = null;
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2024-01-17 16:51:39 +01:00
|
|
|
if (!searchInfo.ItemId.IsEmpty())
|
2014-02-19 17:24:06 +01:00
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
referenceItem = _libraryManager.GetItemById(searchInfo.ItemId);
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2014-02-19 17:24:06 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetRemoteSearchResults<TItemType, TLookupType>(searchInfo, referenceItem, cancellationToken);
|
|
|
|
}
|
2015-07-09 07:52:25 +02:00
|
|
|
|
2021-12-05 21:43:59 +01:00
|
|
|
private async Task<IEnumerable<RemoteSearchResult>> GetRemoteSearchResults<TItemType, TLookupType>(RemoteSearchQuery<TLookupType> searchInfo, BaseItem? referenceItem, CancellationToken cancellationToken)
|
2018-09-12 19:26:21 +02:00
|
|
|
where TItemType : BaseItem, new()
|
|
|
|
where TLookupType : ItemLookupInfo
|
|
|
|
{
|
|
|
|
LibraryOptions libraryOptions;
|
2014-02-19 17:24:06 +01:00
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (referenceItem is null)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
// 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
|
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
libraryOptions = _libraryManager.GetLibraryOptions(referenceItem);
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
var options = GetMetadataOptions(referenceItem);
|
|
|
|
|
|
|
|
var providers = GetMetadataProvidersInternal<TItemType>(referenceItem, libraryOptions, options, searchInfo.IncludeDisabledProviders, false)
|
2014-02-19 17:24:06 +01:00
|
|
|
.OfType<IRemoteSearchProvider<TLookupType>>();
|
2014-02-19 06:21:03 +01:00
|
|
|
|
2014-02-19 17:24:06 +01:00
|
|
|
if (!string.IsNullOrEmpty(searchInfo.SearchProviderName))
|
|
|
|
{
|
|
|
|
providers = providers.Where(i => string.Equals(i.Name, searchInfo.SearchProviderName, StringComparison.OrdinalIgnoreCase));
|
|
|
|
}
|
|
|
|
|
2014-03-01 23:34:27 +01:00
|
|
|
if (string.IsNullOrWhiteSpace(searchInfo.SearchInfo.MetadataLanguage))
|
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
searchInfo.SearchInfo.MetadataLanguage = _configurationManager.Configuration.PreferredMetadataLanguage;
|
2014-03-01 23:34:27 +01:00
|
|
|
}
|
2020-06-15 23:43:52 +02:00
|
|
|
|
2014-03-01 23:34:27 +01:00
|
|
|
if (string.IsNullOrWhiteSpace(searchInfo.SearchInfo.MetadataCountryCode))
|
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
searchInfo.SearchInfo.MetadataCountryCode = _configurationManager.Configuration.MetadataCountryCode;
|
2014-03-01 23:34:27 +01:00
|
|
|
}
|
|
|
|
|
2015-10-01 02:36:46 +02:00
|
|
|
var resultList = new List<RemoteSearchResult>();
|
|
|
|
|
2014-02-19 17:24:06 +01:00
|
|
|
foreach (var provider in providers)
|
|
|
|
{
|
2014-11-05 04:41:14 +01:00
|
|
|
try
|
|
|
|
{
|
2023-08-26 17:29:00 +02:00
|
|
|
var results = await provider.GetSearchResults(searchInfo.SearchInfo, cancellationToken).ConfigureAwait(false);
|
2014-02-19 17:24:06 +01:00
|
|
|
|
2015-10-06 00:03:58 +02:00
|
|
|
foreach (var result in results)
|
2014-11-05 04:41:14 +01:00
|
|
|
{
|
2023-08-26 17:29:00 +02:00
|
|
|
result.SearchProviderName = provider.Name;
|
|
|
|
|
2016-04-25 02:36:10 +02:00
|
|
|
var existingMatch = resultList.FirstOrDefault(i => i.ProviderIds.Any(p => string.Equals(result.GetProviderId(p.Key), p.Value, StringComparison.OrdinalIgnoreCase)));
|
2015-10-01 02:36:46 +02:00
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (existingMatch is null)
|
2015-10-06 00:03:58 +02:00
|
|
|
{
|
2016-04-25 02:36:10 +02:00
|
|
|
resultList.Add(result);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
foreach (var providerId in result.ProviderIds)
|
2015-10-06 00:03:58 +02:00
|
|
|
{
|
2023-04-06 19:16:12 +02:00
|
|
|
existingMatch.ProviderIds.TryAdd(providerId.Key, providerId.Value);
|
2015-10-06 00:03:58 +02:00
|
|
|
}
|
|
|
|
|
2016-04-25 02:36:10 +02:00
|
|
|
if (string.IsNullOrWhiteSpace(existingMatch.ImageUrl))
|
|
|
|
{
|
|
|
|
existingMatch.ImageUrl = result.ImageUrl;
|
|
|
|
}
|
2015-10-06 00:03:58 +02:00
|
|
|
}
|
2014-11-05 04:41:14 +01:00
|
|
|
}
|
|
|
|
}
|
2021-03-03 09:09:57 +01:00
|
|
|
#pragma warning disable CA1031 // do not catch general exception types
|
|
|
|
catch (Exception ex)
|
|
|
|
#pragma warning restore CA1031 // do not catch general exception types
|
2014-02-19 17:24:06 +01:00
|
|
|
{
|
2021-03-03 09:09:57 +01:00
|
|
|
_logger.LogError(ex, "Provider {ProviderName} failed to retrieve search results", provider.Name);
|
2014-02-19 17:24:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-01 02:36:46 +02:00
|
|
|
return resultList;
|
2014-02-19 17:24:06 +01:00
|
|
|
}
|
2014-02-21 19:48:15 +01:00
|
|
|
|
2020-09-07 13:20:39 +02:00
|
|
|
private IEnumerable<IExternalId> GetExternalIds(IHasProviderIds item)
|
2014-02-21 19:48:15 +01:00
|
|
|
{
|
|
|
|
return _externalIds.Where(i =>
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
return i.Supports(item);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2022-01-01 00:22:46 +01:00
|
|
|
_logger.LogError(ex, "Error in {Type}.Supports", i.GetType().Name);
|
2014-02-21 19:48:15 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2016-05-29 08:03:09 +02:00
|
|
|
public IEnumerable<ExternalUrl> GetExternalUrls(BaseItem item)
|
2014-02-21 19:48:15 +01:00
|
|
|
{
|
|
|
|
return GetExternalIds(item)
|
|
|
|
.Select(i =>
|
|
|
|
{
|
|
|
|
if (string.IsNullOrEmpty(i.UrlFormatString))
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
2014-02-21 22:44:10 +01:00
|
|
|
|
2014-02-21 19:48:15 +01:00
|
|
|
var value = item.GetProviderId(i.Key);
|
|
|
|
|
|
|
|
if (string.IsNullOrEmpty(value))
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return new ExternalUrl
|
|
|
|
{
|
2020-05-17 23:35:43 +02:00
|
|
|
Name = i.ProviderName,
|
2020-02-23 10:53:51 +01:00
|
|
|
Url = string.Format(
|
|
|
|
CultureInfo.InvariantCulture,
|
|
|
|
i.UrlFormatString,
|
|
|
|
value)
|
2014-02-21 19:48:15 +01:00
|
|
|
};
|
2022-12-05 15:01:13 +01:00
|
|
|
}).Where(i => i is not null)
|
2021-12-05 21:43:59 +01:00
|
|
|
.Concat(item.GetRelatedUrls())!; // We just filtered out all the nulls
|
2014-02-21 19:48:15 +01:00
|
|
|
}
|
2014-02-21 22:44:10 +01:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2014-02-21 22:44:10 +01:00
|
|
|
public IEnumerable<ExternalIdInfo> GetExternalIdInfos(IHasProviderIds item)
|
|
|
|
{
|
|
|
|
return GetExternalIds(item)
|
2020-12-31 12:09:25 +01:00
|
|
|
.Select(i => new ExternalIdInfo(
|
|
|
|
name: i.ProviderName,
|
|
|
|
key: i.Key,
|
|
|
|
type: i.Type,
|
|
|
|
urlFormatString: i.UrlFormatString));
|
2014-02-21 22:44:10 +01:00
|
|
|
}
|
2015-03-14 05:50:23 +01:00
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2022-12-07 18:02:12 +01:00
|
|
|
public HashSet<Guid> GetRefreshQueue()
|
2017-06-23 18:04:45 +02:00
|
|
|
{
|
|
|
|
lock (_refreshQueueLock)
|
|
|
|
{
|
2022-12-07 18:02:12 +01:00
|
|
|
return _refreshQueue.UnorderedItems.Select(x => x.Element.ItemId).ToHashSet();
|
2017-06-23 18:04:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2017-06-23 18:04:45 +02:00
|
|
|
public void OnRefreshStart(BaseItem item)
|
|
|
|
{
|
2023-02-02 14:02:57 +01:00
|
|
|
_logger.LogDebug("OnRefreshStart {Item:N}", item.Id);
|
2020-02-23 10:53:51 +01:00
|
|
|
_activeRefreshes[item.Id] = 0;
|
2023-02-02 14:02:57 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
RefreshStarted?.Invoke(this, new GenericEventArgs<BaseItem>(item));
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
// EventHandlers should never propagate exceptions, but we have little control over plugins...
|
|
|
|
_logger.LogError(ex, "Invoking {RefreshEvent} event handlers failed", nameof(RefreshStarted));
|
|
|
|
}
|
2017-06-23 18:04:45 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2017-06-23 18:04:45 +02:00
|
|
|
public void OnRefreshComplete(BaseItem item)
|
|
|
|
{
|
2023-02-02 14:02:57 +01:00
|
|
|
_logger.LogDebug("OnRefreshComplete {Item:N}", item.Id);
|
|
|
|
_activeRefreshes.TryRemove(item.Id, out _);
|
2017-06-23 18:04:45 +02:00
|
|
|
|
2023-02-02 14:02:57 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
RefreshCompleted?.Invoke(this, new GenericEventArgs<BaseItem>(item));
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
// EventHandlers should never propagate exceptions, but we have little control over plugins...
|
|
|
|
_logger.LogError(ex, "Invoking {RefreshEvent} event handlers failed", nameof(RefreshCompleted));
|
|
|
|
}
|
2017-06-23 18:04:45 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2017-06-23 18:04:45 +02:00
|
|
|
public double? GetRefreshProgress(Guid id)
|
|
|
|
{
|
2020-02-23 10:53:51 +01:00
|
|
|
if (_activeRefreshes.TryGetValue(id, out double value))
|
2017-06-23 18:04:45 +02:00
|
|
|
{
|
2020-02-23 10:53:51 +01:00
|
|
|
return value;
|
2017-06-23 18:04:45 +02:00
|
|
|
}
|
2020-02-23 10:53:51 +01:00
|
|
|
|
|
|
|
return null;
|
2017-06-23 18:04:45 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2017-06-23 18:04:45 +02:00
|
|
|
public void OnRefreshProgress(BaseItem item, double progress)
|
|
|
|
{
|
|
|
|
var id = item.Id;
|
2023-02-02 14:02:57 +01:00
|
|
|
_logger.LogDebug("OnRefreshProgress {Id:N} {Progress}", id, progress);
|
2017-06-23 18:04:45 +02:00
|
|
|
|
2024-04-13 01:45:15 +02:00
|
|
|
if (!_activeRefreshes.TryGetValue(id, out var current)
|
|
|
|
|| progress <= current
|
|
|
|
|| !_activeRefreshes.TryUpdate(id, progress, current))
|
|
|
|
{
|
|
|
|
// Item isn't currently refreshing, or update was received out-of-order, so don't trigger event.
|
|
|
|
return;
|
|
|
|
}
|
2020-02-28 20:34:10 +01:00
|
|
|
|
2023-02-02 14:02:57 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
RefreshProgress?.Invoke(this, new GenericEventArgs<Tuple<BaseItem, double>>(new Tuple<BaseItem, double>(item, progress)));
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
// EventHandlers should never propagate exceptions, but we have little control over plugins...
|
|
|
|
_logger.LogError(ex, "Invoking {RefreshEvent} event handlers failed", nameof(RefreshProgress));
|
|
|
|
}
|
2017-06-23 18:04:45 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2021-04-19 23:52:58 +02:00
|
|
|
public void QueueRefresh(Guid itemId, MetadataRefreshOptions options, RefreshPriority priority)
|
2015-03-14 05:50:23 +01:00
|
|
|
{
|
2023-10-10 13:29:16 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(itemId);
|
2024-01-17 16:51:39 +01:00
|
|
|
if (itemId.IsEmpty())
|
2023-10-10 13:29:16 +02:00
|
|
|
{
|
|
|
|
throw new ArgumentException("Guid can't be empty", nameof(itemId));
|
|
|
|
}
|
|
|
|
|
2015-03-14 05:50:23 +01:00
|
|
|
if (_disposed)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-12-07 18:02:12 +01:00
|
|
|
_refreshQueue.Enqueue((itemId, options), priority);
|
2015-03-14 05:50:23 +01:00
|
|
|
|
2016-10-27 09:58:33 +02:00
|
|
|
lock (_refreshQueueLock)
|
2015-03-14 05:50:23 +01:00
|
|
|
{
|
2016-10-27 09:58:33 +02:00
|
|
|
if (!_isProcessingRefreshQueue)
|
2015-03-14 05:50:23 +01:00
|
|
|
{
|
2016-10-27 09:58:33 +02:00
|
|
|
_isProcessingRefreshQueue = true;
|
2017-05-27 09:19:09 +02:00
|
|
|
Task.Run(StartProcessingRefreshQueue);
|
2015-03-14 05:50:23 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-27 09:58:33 +02:00
|
|
|
private async Task StartProcessingRefreshQueue()
|
2015-03-14 05:50:23 +01:00
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
var libraryManager = _libraryManager;
|
2015-03-14 05:50:23 +01:00
|
|
|
|
2017-06-06 08:13:49 +02:00
|
|
|
if (_disposed)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
var cancellationToken = _disposeCancellationTokenSource.Token;
|
|
|
|
|
2022-12-07 18:02:12 +01:00
|
|
|
while (_refreshQueue.TryDequeue(out var refreshItem, out _))
|
2015-03-14 05:50:23 +01:00
|
|
|
{
|
|
|
|
if (_disposed)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-10-04 20:10:50 +02:00
|
|
|
try
|
2015-03-14 05:50:23 +01:00
|
|
|
{
|
2022-12-07 18:02:12 +01:00
|
|
|
var item = libraryManager.GetItemById(refreshItem.ItemId);
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null)
|
2015-03-14 16:38:16 +01:00
|
|
|
{
|
2021-04-13 20:09:50 +02:00
|
|
|
continue;
|
|
|
|
}
|
2015-07-18 04:52:27 +02:00
|
|
|
|
2021-04-13 20:09:50 +02:00
|
|
|
var task = item is MusicArtist artist
|
2022-12-07 18:02:12 +01:00
|
|
|
? RefreshArtist(artist, refreshItem.RefreshOptions, cancellationToken)
|
|
|
|
: RefreshItem(item, refreshItem.RefreshOptions, cancellationToken);
|
2015-03-14 16:38:16 +01:00
|
|
|
|
2021-04-13 20:09:50 +02:00
|
|
|
await task.ConfigureAwait(false);
|
2015-10-04 20:10:50 +02:00
|
|
|
}
|
2017-06-06 08:13:49 +02:00
|
|
|
catch (OperationCanceledException)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2015-10-04 20:10:50 +02:00
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error refreshing item");
|
2015-03-14 05:50:23 +01:00
|
|
|
}
|
2015-03-14 16:38:16 +01:00
|
|
|
}
|
|
|
|
|
2016-10-27 09:58:33 +02:00
|
|
|
lock (_refreshQueueLock)
|
|
|
|
{
|
|
|
|
_isProcessingRefreshQueue = false;
|
|
|
|
}
|
2015-03-14 16:38:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private async Task RefreshItem(BaseItem item, MetadataRefreshOptions options, CancellationToken cancellationToken)
|
|
|
|
{
|
2017-06-06 08:13:49 +02:00
|
|
|
await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
|
2015-03-14 16:38:16 +01:00
|
|
|
|
2017-01-06 05:38:03 +01:00
|
|
|
// Collection folders don't validate their children so we'll have to simulate that here
|
2020-07-03 20:02:04 +02:00
|
|
|
switch (item)
|
2017-01-06 05:38:03 +01:00
|
|
|
{
|
2020-07-03 20:02:04 +02:00
|
|
|
case CollectionFolder collectionFolder:
|
|
|
|
await RefreshCollectionFolderChildren(options, collectionFolder, cancellationToken).ConfigureAwait(false);
|
|
|
|
break;
|
|
|
|
case Folder folder:
|
2024-02-06 15:50:46 +01:00
|
|
|
await folder.ValidateChildren(new Progress<double>(), options, cancellationToken: cancellationToken).ConfigureAwait(false);
|
2020-07-03 20:02:04 +02:00
|
|
|
break;
|
2015-03-14 05:50:23 +01:00
|
|
|
}
|
2015-03-14 16:38:16 +01:00
|
|
|
}
|
2015-03-14 05:50:23 +01:00
|
|
|
|
2017-06-06 08:13:49 +02:00
|
|
|
private async Task RefreshCollectionFolderChildren(MetadataRefreshOptions options, CollectionFolder collectionFolder, CancellationToken cancellationToken)
|
2015-03-14 16:38:16 +01:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
foreach (var child in collectionFolder.GetPhysicalFolders())
|
2015-03-14 16:38:16 +01:00
|
|
|
{
|
2017-06-06 08:13:49 +02:00
|
|
|
await child.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
|
2015-03-14 16:38:16 +01:00
|
|
|
|
2024-02-06 15:50:46 +01:00
|
|
|
await child.ValidateChildren(new Progress<double>(), options, cancellationToken: cancellationToken).ConfigureAwait(false);
|
2015-03-14 16:38:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-06 08:13:49 +02:00
|
|
|
private async Task RefreshArtist(MusicArtist item, MetadataRefreshOptions options, CancellationToken cancellationToken)
|
2015-03-14 16:38:16 +01:00
|
|
|
{
|
2020-04-04 20:56:50 +02:00
|
|
|
var albums = _libraryManager
|
2017-01-21 21:27:07 +01:00
|
|
|
.GetItemList(new InternalItemsQuery
|
|
|
|
{
|
2021-12-12 03:31:30 +01:00
|
|
|
IncludeItemTypes = new[] { BaseItemKind.MusicAlbum },
|
2018-09-12 19:26:21 +02:00
|
|
|
ArtistIds = new[] { item.Id },
|
2017-05-21 09:25:49 +02:00
|
|
|
DtoOptions = new DtoOptions(false)
|
|
|
|
{
|
|
|
|
EnableImages = false
|
|
|
|
}
|
2017-01-21 21:27:07 +01:00
|
|
|
})
|
2019-03-13 22:32:52 +01:00
|
|
|
.OfType<MusicAlbum>();
|
2015-03-14 16:38:16 +01:00
|
|
|
|
|
|
|
var musicArtists = albums
|
2016-03-14 02:34:24 +01:00
|
|
|
.Select(i => i.MusicArtist)
|
2024-03-30 17:40:27 +01:00
|
|
|
.Where(i => i is not null)
|
|
|
|
.Distinct();
|
2015-03-14 16:38:16 +01:00
|
|
|
|
2024-04-17 08:41:19 +02:00
|
|
|
var musicArtistRefreshTasks = musicArtists.Select(i => i.ValidateChildren(new Progress<double>(), options, true, false, cancellationToken));
|
2015-03-14 16:38:16 +01:00
|
|
|
|
|
|
|
await Task.WhenAll(musicArtistRefreshTasks).ConfigureAwait(false);
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2017-06-06 08:13:49 +02:00
|
|
|
await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
|
2015-03-14 16:38:16 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error refreshing library");
|
2015-03-14 16:38:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2020-02-23 10:53:51 +01:00
|
|
|
public Task RefreshFullItem(BaseItem item, MetadataRefreshOptions options, CancellationToken cancellationToken)
|
2015-03-14 16:38:16 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
return RefreshItem(item, options, cancellationToken);
|
2015-03-14 05:50:23 +01:00
|
|
|
}
|
|
|
|
|
2020-07-03 20:02:04 +02:00
|
|
|
/// <inheritdoc/>
|
2015-03-14 05:50:23 +01:00
|
|
|
public void Dispose()
|
|
|
|
{
|
2020-08-07 19:26:28 +02:00
|
|
|
Dispose(true);
|
|
|
|
GC.SuppressFinalize(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Releases unmanaged and optionally managed resources.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
|
|
{
|
|
|
|
if (_disposed)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2017-06-06 08:13:49 +02:00
|
|
|
|
2020-08-07 19:26:28 +02:00
|
|
|
if (disposing)
|
|
|
|
{
|
2023-11-05 02:01:14 +01:00
|
|
|
if (!_disposeCancellationTokenSource.IsCancellationRequested)
|
|
|
|
{
|
|
|
|
_disposeCancellationTokenSource.Cancel();
|
|
|
|
}
|
|
|
|
|
2020-08-07 19:26:28 +02:00
|
|
|
_disposeCancellationTokenSource.Dispose();
|
2024-03-03 21:32:55 +01:00
|
|
|
_imageSaveLock.Dispose();
|
2020-08-07 19:26:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
_disposed = true;
|
2015-03-14 05:50:23 +01:00
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
2018-12-28 16:48:26 +01:00
|
|
|
}
|