2021-05-20 21:28:18 +02:00
|
|
|
#nullable disable
|
|
|
|
|
2019-11-01 18:38:54 +01:00
|
|
|
#pragma warning disable CS1591
|
|
|
|
|
2019-01-13 20:21:32 +01:00
|
|
|
using System;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Globalization;
|
|
|
|
using System.IO;
|
|
|
|
using System.Linq;
|
|
|
|
using System.Net;
|
2020-11-14 22:30:34 +01:00
|
|
|
using System.Net.Http;
|
2019-01-13 20:21:32 +01:00
|
|
|
using System.Threading;
|
|
|
|
using System.Threading.Tasks;
|
|
|
|
using Emby.Naming.Common;
|
|
|
|
using Emby.Naming.TV;
|
2021-12-28 00:37:40 +01:00
|
|
|
using Emby.Server.Implementations.Library.Resolvers;
|
2019-01-13 20:21:32 +01:00
|
|
|
using Emby.Server.Implementations.Library.Validators;
|
|
|
|
using Emby.Server.Implementations.Playlists;
|
2021-12-15 18:25:36 +01:00
|
|
|
using Emby.Server.Implementations.ScheduledTasks.Tasks;
|
2020-05-20 19:07:53 +02:00
|
|
|
using Jellyfin.Data.Entities;
|
2020-05-13 04:10:35 +02:00
|
|
|
using Jellyfin.Data.Enums;
|
2021-06-19 18:02:33 +02:00
|
|
|
using Jellyfin.Extensions;
|
2019-01-06 21:50:43 +01:00
|
|
|
using MediaBrowser.Common.Extensions;
|
2013-04-22 06:38:03 +02:00
|
|
|
using MediaBrowser.Common.Progress;
|
2019-01-13 20:21:32 +01:00
|
|
|
using MediaBrowser.Controller;
|
2013-03-04 06:43:06 +01:00
|
|
|
using MediaBrowser.Controller.Configuration;
|
2020-03-23 20:05:49 +01:00
|
|
|
using MediaBrowser.Controller.Drawing;
|
2019-01-13 20:21:32 +01:00
|
|
|
using MediaBrowser.Controller.Dto;
|
2013-02-21 02:33:05 +01:00
|
|
|
using MediaBrowser.Controller.Entities;
|
2013-04-21 03:02:16 +02:00
|
|
|
using MediaBrowser.Controller.Entities.Audio;
|
2013-02-21 02:33:05 +01:00
|
|
|
using MediaBrowser.Controller.IO;
|
2013-02-28 20:32:41 +01:00
|
|
|
using MediaBrowser.Controller.Library;
|
2019-01-13 20:21:32 +01:00
|
|
|
using MediaBrowser.Controller.LiveTv;
|
2020-02-17 14:56:31 +01:00
|
|
|
using MediaBrowser.Controller.MediaEncoding;
|
2013-04-08 17:55:53 +02:00
|
|
|
using MediaBrowser.Controller.Persistence;
|
2014-02-02 14:36:31 +01:00
|
|
|
using MediaBrowser.Controller.Providers;
|
2013-03-03 17:53:58 +01:00
|
|
|
using MediaBrowser.Controller.Resolvers;
|
2013-03-10 05:22:36 +01:00
|
|
|
using MediaBrowser.Controller.Sorting;
|
2013-03-12 06:40:24 +01:00
|
|
|
using MediaBrowser.Model.Configuration;
|
2020-02-17 14:56:31 +01:00
|
|
|
using MediaBrowser.Model.Dlna;
|
2020-03-23 20:05:49 +01:00
|
|
|
using MediaBrowser.Model.Drawing;
|
2016-06-17 15:06:13 +02:00
|
|
|
using MediaBrowser.Model.Dto;
|
2019-01-13 20:21:32 +01:00
|
|
|
using MediaBrowser.Model.Entities;
|
|
|
|
using MediaBrowser.Model.IO;
|
2015-11-13 21:53:29 +01:00
|
|
|
using MediaBrowser.Model.Library;
|
2019-01-13 20:21:32 +01:00
|
|
|
using MediaBrowser.Model.Querying;
|
2016-10-23 21:47:34 +02:00
|
|
|
using MediaBrowser.Model.Tasks;
|
2020-07-29 23:28:15 +02:00
|
|
|
using Microsoft.Extensions.Caching.Memory;
|
2019-01-13 20:21:32 +01:00
|
|
|
using Microsoft.Extensions.Logging;
|
2020-05-20 19:07:53 +02:00
|
|
|
using Episode = MediaBrowser.Controller.Entities.TV.Episode;
|
2021-04-09 13:20:12 +02:00
|
|
|
using EpisodeInfo = Emby.Naming.TV.EpisodeInfo;
|
2020-05-20 19:07:53 +02:00
|
|
|
using Genre = MediaBrowser.Controller.Entities.Genre;
|
|
|
|
using Person = MediaBrowser.Controller.Entities.Person;
|
2019-01-13 20:21:32 +01:00
|
|
|
using VideoResolver = Emby.Naming.Video.VideoResolver;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2016-11-03 07:37:52 +01:00
|
|
|
namespace Emby.Server.Implementations.Library
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
/// <summary>
|
2020-05-29 11:28:19 +02:00
|
|
|
/// Class LibraryManager.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
2013-02-28 20:32:41 +01:00
|
|
|
public class LibraryManager : ILibraryManager
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-07-20 11:01:37 +02:00
|
|
|
private const string ShortcutFileExtension = ".mblink";
|
|
|
|
|
2020-06-06 02:15:56 +02:00
|
|
|
private readonly ILogger<LibraryManager> _logger;
|
2020-07-29 23:28:15 +02:00
|
|
|
private readonly IMemoryCache _memoryCache;
|
2020-04-05 00:28:46 +02:00
|
|
|
private readonly ITaskManager _taskManager;
|
|
|
|
private readonly IUserManager _userManager;
|
|
|
|
private readonly IUserDataManager _userDataRepository;
|
|
|
|
private readonly IServerConfigurationManager _configurationManager;
|
|
|
|
private readonly Lazy<ILibraryMonitor> _libraryMonitorFactory;
|
|
|
|
private readonly Lazy<IProviderManager> _providerManagerFactory;
|
|
|
|
private readonly Lazy<IUserViewManager> _userviewManagerFactory;
|
|
|
|
private readonly IServerApplicationHost _appHost;
|
|
|
|
private readonly IMediaEncoder _mediaEncoder;
|
|
|
|
private readonly IFileSystem _fileSystem;
|
|
|
|
private readonly IItemRepository _itemRepository;
|
2020-05-20 23:03:22 +02:00
|
|
|
private readonly IImageProcessor _imageProcessor;
|
2021-11-15 15:56:02 +01:00
|
|
|
private readonly NamingOptions _namingOptions;
|
2021-12-28 00:37:40 +01:00
|
|
|
private readonly ExtraResolver _extraResolver;
|
2020-04-05 00:28:46 +02:00
|
|
|
|
2013-03-10 05:22:36 +01:00
|
|
|
/// <summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
/// The _root folder sync lock.
|
2013-03-10 05:22:36 +01:00
|
|
|
/// </summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
private readonly object _rootFolderSyncLock = new object();
|
|
|
|
private readonly object _userRootFolderSyncLock = new object();
|
2013-03-10 05:22:36 +01:00
|
|
|
|
2020-07-20 11:01:37 +02:00
|
|
|
private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromHours(24);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2013-05-03 06:10:11 +02:00
|
|
|
/// <summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
/// The _root folder.
|
2013-05-03 06:10:11 +02:00
|
|
|
/// </summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
private volatile AggregateFolder _rootFolder;
|
|
|
|
private volatile UserRootFolder _userRootFolder;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2020-07-20 11:01:37 +02:00
|
|
|
private bool _wizardCompleted;
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Initializes a new instance of the <see cref="LibraryManager" /> class.
|
|
|
|
/// </summary>
|
2020-06-19 12:21:49 +02:00
|
|
|
/// <param name="appHost">The application host.</param>
|
2022-01-04 22:52:52 +01:00
|
|
|
/// <param name="loggerFactory">The logger factory.</param>
|
2013-02-26 17:10:55 +01:00
|
|
|
/// <param name="taskManager">The task manager.</param>
|
2013-02-28 20:32:41 +01:00
|
|
|
/// <param name="userManager">The user manager.</param>
|
2013-03-04 06:43:06 +01:00
|
|
|
/// <param name="configurationManager">The configuration manager.</param>
|
2013-04-13 20:02:30 +02:00
|
|
|
/// <param name="userDataRepository">The user data repository.</param>
|
2020-05-29 11:28:19 +02:00
|
|
|
/// <param name="libraryMonitorFactory">The library monitor.</param>
|
|
|
|
/// <param name="fileSystem">The file system.</param>
|
|
|
|
/// <param name="providerManagerFactory">The provider manager.</param>
|
|
|
|
/// <param name="userviewManagerFactory">The userview manager.</param>
|
|
|
|
/// <param name="mediaEncoder">The media encoder.</param>
|
|
|
|
/// <param name="itemRepository">The item repository.</param>
|
2020-06-03 11:54:01 +02:00
|
|
|
/// <param name="imageProcessor">The image processor.</param>
|
2020-07-29 23:28:15 +02:00
|
|
|
/// <param name="memoryCache">The memory cache.</param>
|
2021-11-15 15:56:02 +01:00
|
|
|
/// <param name="namingOptions">The naming options.</param>
|
2019-01-17 23:55:05 +01:00
|
|
|
public LibraryManager(
|
|
|
|
IServerApplicationHost appHost,
|
2022-01-04 22:52:52 +01:00
|
|
|
ILoggerFactory loggerFactory,
|
2019-01-17 23:55:05 +01:00
|
|
|
ITaskManager taskManager,
|
|
|
|
IUserManager userManager,
|
|
|
|
IServerConfigurationManager configurationManager,
|
|
|
|
IUserDataManager userDataRepository,
|
2020-04-05 00:28:46 +02:00
|
|
|
Lazy<ILibraryMonitor> libraryMonitorFactory,
|
2019-01-17 23:55:05 +01:00
|
|
|
IFileSystem fileSystem,
|
2020-04-05 00:28:46 +02:00
|
|
|
Lazy<IProviderManager> providerManagerFactory,
|
|
|
|
Lazy<IUserViewManager> userviewManagerFactory,
|
|
|
|
IMediaEncoder mediaEncoder,
|
2020-05-20 23:03:22 +02:00
|
|
|
IItemRepository itemRepository,
|
2020-07-29 23:28:15 +02:00
|
|
|
IImageProcessor imageProcessor,
|
2021-11-15 15:56:02 +01:00
|
|
|
IMemoryCache memoryCache,
|
|
|
|
NamingOptions namingOptions)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
_appHost = appHost;
|
2022-01-04 22:52:52 +01:00
|
|
|
_logger = loggerFactory.CreateLogger<LibraryManager>();
|
2013-02-26 17:10:55 +01:00
|
|
|
_taskManager = taskManager;
|
2013-02-27 21:25:45 +01:00
|
|
|
_userManager = userManager;
|
2020-04-05 00:28:46 +02:00
|
|
|
_configurationManager = configurationManager;
|
2013-04-13 20:02:30 +02:00
|
|
|
_userDataRepository = userDataRepository;
|
2014-01-28 22:25:10 +01:00
|
|
|
_libraryMonitorFactory = libraryMonitorFactory;
|
2013-10-30 15:40:14 +01:00
|
|
|
_fileSystem = fileSystem;
|
2014-02-02 14:36:31 +01:00
|
|
|
_providerManagerFactory = providerManagerFactory;
|
2020-04-05 00:28:46 +02:00
|
|
|
_userviewManagerFactory = userviewManagerFactory;
|
2020-02-19 16:06:30 +01:00
|
|
|
_mediaEncoder = mediaEncoder;
|
2020-04-05 00:28:46 +02:00
|
|
|
_itemRepository = itemRepository;
|
2020-05-20 23:03:22 +02:00
|
|
|
_imageProcessor = imageProcessor;
|
2020-07-29 23:28:15 +02:00
|
|
|
_memoryCache = memoryCache;
|
2021-11-15 15:56:02 +01:00
|
|
|
_namingOptions = namingOptions;
|
2013-02-26 17:10:55 +01:00
|
|
|
|
2022-01-04 22:52:52 +01:00
|
|
|
_extraResolver = new ExtraResolver(loggerFactory.CreateLogger<ExtraResolver>(), namingOptions);
|
2021-12-28 00:37:40 +01:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
_configurationManager.ConfigurationUpdated += ConfigurationUpdated;
|
2013-03-12 06:40:24 +01:00
|
|
|
|
|
|
|
RecordConfigurationValues(configurationManager.Configuration);
|
2013-02-26 17:10:55 +01:00
|
|
|
}
|
|
|
|
|
2013-03-01 22:22:34 +01:00
|
|
|
/// <summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
/// Occurs when [item added].
|
2013-03-01 22:22:34 +01:00
|
|
|
/// </summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
public event EventHandler<ItemChangeEventArgs> ItemAdded;
|
2013-03-01 22:22:34 +01:00
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
/// <summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
/// Occurs when [item updated].
|
2013-02-28 20:32:41 +01:00
|
|
|
/// </summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
public event EventHandler<ItemChangeEventArgs> ItemUpdated;
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
/// <summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
/// Occurs when [item removed].
|
2013-02-28 20:32:41 +01:00
|
|
|
/// </summary>
|
2020-07-20 11:01:37 +02:00
|
|
|
public event EventHandler<ItemChangeEventArgs> ItemRemoved;
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the root folder.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>The root folder.</value>
|
|
|
|
public AggregateFolder RootFolder
|
|
|
|
{
|
|
|
|
get
|
|
|
|
{
|
2022-12-05 15:00:20 +01:00
|
|
|
if (_rootFolder is null)
|
2013-02-28 20:32:41 +01:00
|
|
|
{
|
2015-01-26 17:47:15 +01:00
|
|
|
lock (_rootFolderSyncLock)
|
|
|
|
{
|
2021-05-05 13:51:14 +02:00
|
|
|
_rootFolder ??= CreateRootFolder();
|
2015-01-26 17:47:15 +01:00
|
|
|
}
|
2013-02-28 20:32:41 +01:00
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2015-01-26 17:47:15 +01:00
|
|
|
return _rootFolder;
|
2013-02-28 20:32:41 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-20 11:01:37 +02:00
|
|
|
private ILibraryMonitor LibraryMonitor => _libraryMonitorFactory.Value;
|
|
|
|
|
|
|
|
private IProviderManager ProviderManager => _providerManagerFactory.Value;
|
|
|
|
|
|
|
|
private IUserViewManager UserViewManager => _userviewManagerFactory.Value;
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets or sets the postscan tasks.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>The postscan tasks.</value>
|
Fix possible ArgumentNullException
```
Error Message:
System.ArgumentNullException : Value cannot be null. (Parameter 'source')
Stack Trace:
at System.Linq.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
at System.Linq.Enumerable.Select[TSource,TResult](IEnumerable`1 source, Func`2 selector)
at Emby.Server.Implementations.Library.LibraryManager.ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 475
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, IDirectoryService directoryService, IItemResolver[] resolvers, Folder parent, String collectionType, LibraryOptions libraryOptions) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 618
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, Folder parent) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 536
at Emby.Server.Implementations.Library.LibraryManager.GetUserRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 812
at Emby.Server.Implementations.Library.LibraryManager.GetCollectionFolders(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2080
at Emby.Server.Implementations.Library.LibraryManager.GetLibraryOptions(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2116
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType, IEnumerable`1 savers) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 672
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 655
at Emby.Server.Implementations.Library.LibraryManager.RunMetadataSavers(BaseItem item, ItemUpdateType updateReason) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2017
at Emby.Server.Implementations.Library.LibraryManager.UpdateItemsAsync(IReadOnlyList`1 items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 1975
at Emby.Server.Implementations.Library.LibraryManager.CreateRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 775
at Emby.Server.Implementations.Library.LibraryManager.get_RootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 180
at Emby.Server.Implementations.IO.LibraryMonitor.Start() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitor.cs:line 135
at Emby.Server.Implementations.IO.LibraryMonitorStartup.RunAsync() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitorStartup.cs:line 26
at Emby.Server.Implementations.ApplicationHost.StartEntryPoints(IEnumerable`1 entryPoints, Boolean isBeforeStartup)+MoveNext() in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 518
at System.Threading.Tasks.Task.WhenAll(IEnumerable`1 tasks)
at Emby.Server.Implementations.ApplicationHost.RunStartupTasksAsync(CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 502
at Jellyfin.Server.Integration.Tests.JellyfinApplicationFactory.CreateServer(IWebHostBuilder builder) in /home/vsts/work/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.Controllers.ActivityLogControllerTests.ActivityLog_GetEntries_Ok() in /home/vsts/work/1/s/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs:line 21
--- End of stack trace from previous location ---
```
2021-04-12 22:01:35 +02:00
|
|
|
private ILibraryPostScanTask[] PostscanTasks { get; set; } = Array.Empty<ILibraryPostScanTask>();
|
2020-07-20 11:01:37 +02:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets or sets the intro providers.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>The intro providers.</value>
|
Fix possible ArgumentNullException
```
Error Message:
System.ArgumentNullException : Value cannot be null. (Parameter 'source')
Stack Trace:
at System.Linq.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
at System.Linq.Enumerable.Select[TSource,TResult](IEnumerable`1 source, Func`2 selector)
at Emby.Server.Implementations.Library.LibraryManager.ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 475
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, IDirectoryService directoryService, IItemResolver[] resolvers, Folder parent, String collectionType, LibraryOptions libraryOptions) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 618
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, Folder parent) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 536
at Emby.Server.Implementations.Library.LibraryManager.GetUserRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 812
at Emby.Server.Implementations.Library.LibraryManager.GetCollectionFolders(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2080
at Emby.Server.Implementations.Library.LibraryManager.GetLibraryOptions(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2116
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType, IEnumerable`1 savers) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 672
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 655
at Emby.Server.Implementations.Library.LibraryManager.RunMetadataSavers(BaseItem item, ItemUpdateType updateReason) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2017
at Emby.Server.Implementations.Library.LibraryManager.UpdateItemsAsync(IReadOnlyList`1 items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 1975
at Emby.Server.Implementations.Library.LibraryManager.CreateRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 775
at Emby.Server.Implementations.Library.LibraryManager.get_RootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 180
at Emby.Server.Implementations.IO.LibraryMonitor.Start() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitor.cs:line 135
at Emby.Server.Implementations.IO.LibraryMonitorStartup.RunAsync() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitorStartup.cs:line 26
at Emby.Server.Implementations.ApplicationHost.StartEntryPoints(IEnumerable`1 entryPoints, Boolean isBeforeStartup)+MoveNext() in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 518
at System.Threading.Tasks.Task.WhenAll(IEnumerable`1 tasks)
at Emby.Server.Implementations.ApplicationHost.RunStartupTasksAsync(CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 502
at Jellyfin.Server.Integration.Tests.JellyfinApplicationFactory.CreateServer(IWebHostBuilder builder) in /home/vsts/work/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.Controllers.ActivityLogControllerTests.ActivityLog_GetEntries_Ok() in /home/vsts/work/1/s/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs:line 21
--- End of stack trace from previous location ---
```
2021-04-12 22:01:35 +02:00
|
|
|
private IIntroProvider[] IntroProviders { get; set; } = Array.Empty<IIntroProvider>();
|
2020-07-20 11:01:37 +02:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets or sets the list of entity resolution ignore rules.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>The entity resolution ignore rules.</value>
|
2021-03-24 21:06:03 +01:00
|
|
|
private IResolverIgnoreRule[] EntityResolutionIgnoreRules { get; set; } = Array.Empty<IResolverIgnoreRule>();
|
2020-07-20 11:01:37 +02:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets or sets the list of currently registered entity resolvers.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>The entity resolvers enumerable.</value>
|
Fix possible ArgumentNullException
```
Error Message:
System.ArgumentNullException : Value cannot be null. (Parameter 'source')
Stack Trace:
at System.Linq.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
at System.Linq.Enumerable.Select[TSource,TResult](IEnumerable`1 source, Func`2 selector)
at Emby.Server.Implementations.Library.LibraryManager.ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 475
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, IDirectoryService directoryService, IItemResolver[] resolvers, Folder parent, String collectionType, LibraryOptions libraryOptions) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 618
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, Folder parent) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 536
at Emby.Server.Implementations.Library.LibraryManager.GetUserRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 812
at Emby.Server.Implementations.Library.LibraryManager.GetCollectionFolders(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2080
at Emby.Server.Implementations.Library.LibraryManager.GetLibraryOptions(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2116
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType, IEnumerable`1 savers) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 672
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 655
at Emby.Server.Implementations.Library.LibraryManager.RunMetadataSavers(BaseItem item, ItemUpdateType updateReason) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2017
at Emby.Server.Implementations.Library.LibraryManager.UpdateItemsAsync(IReadOnlyList`1 items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 1975
at Emby.Server.Implementations.Library.LibraryManager.CreateRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 775
at Emby.Server.Implementations.Library.LibraryManager.get_RootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 180
at Emby.Server.Implementations.IO.LibraryMonitor.Start() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitor.cs:line 135
at Emby.Server.Implementations.IO.LibraryMonitorStartup.RunAsync() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitorStartup.cs:line 26
at Emby.Server.Implementations.ApplicationHost.StartEntryPoints(IEnumerable`1 entryPoints, Boolean isBeforeStartup)+MoveNext() in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 518
at System.Threading.Tasks.Task.WhenAll(IEnumerable`1 tasks)
at Emby.Server.Implementations.ApplicationHost.RunStartupTasksAsync(CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 502
at Jellyfin.Server.Integration.Tests.JellyfinApplicationFactory.CreateServer(IWebHostBuilder builder) in /home/vsts/work/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.Controllers.ActivityLogControllerTests.ActivityLog_GetEntries_Ok() in /home/vsts/work/1/s/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs:line 21
--- End of stack trace from previous location ---
```
2021-04-12 22:01:35 +02:00
|
|
|
private IItemResolver[] EntityResolvers { get; set; } = Array.Empty<IItemResolver>();
|
2020-07-20 11:01:37 +02:00
|
|
|
|
Fix possible ArgumentNullException
```
Error Message:
System.ArgumentNullException : Value cannot be null. (Parameter 'source')
Stack Trace:
at System.Linq.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
at System.Linq.Enumerable.Select[TSource,TResult](IEnumerable`1 source, Func`2 selector)
at Emby.Server.Implementations.Library.LibraryManager.ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 475
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, IDirectoryService directoryService, IItemResolver[] resolvers, Folder parent, String collectionType, LibraryOptions libraryOptions) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 618
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, Folder parent) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 536
at Emby.Server.Implementations.Library.LibraryManager.GetUserRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 812
at Emby.Server.Implementations.Library.LibraryManager.GetCollectionFolders(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2080
at Emby.Server.Implementations.Library.LibraryManager.GetLibraryOptions(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2116
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType, IEnumerable`1 savers) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 672
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 655
at Emby.Server.Implementations.Library.LibraryManager.RunMetadataSavers(BaseItem item, ItemUpdateType updateReason) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2017
at Emby.Server.Implementations.Library.LibraryManager.UpdateItemsAsync(IReadOnlyList`1 items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 1975
at Emby.Server.Implementations.Library.LibraryManager.CreateRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 775
at Emby.Server.Implementations.Library.LibraryManager.get_RootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 180
at Emby.Server.Implementations.IO.LibraryMonitor.Start() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitor.cs:line 135
at Emby.Server.Implementations.IO.LibraryMonitorStartup.RunAsync() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitorStartup.cs:line 26
at Emby.Server.Implementations.ApplicationHost.StartEntryPoints(IEnumerable`1 entryPoints, Boolean isBeforeStartup)+MoveNext() in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 518
at System.Threading.Tasks.Task.WhenAll(IEnumerable`1 tasks)
at Emby.Server.Implementations.ApplicationHost.RunStartupTasksAsync(CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 502
at Jellyfin.Server.Integration.Tests.JellyfinApplicationFactory.CreateServer(IWebHostBuilder builder) in /home/vsts/work/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.Controllers.ActivityLogControllerTests.ActivityLog_GetEntries_Ok() in /home/vsts/work/1/s/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs:line 21
--- End of stack trace from previous location ---
```
2021-04-12 22:01:35 +02:00
|
|
|
private IMultiItemResolver[] MultiItemResolvers { get; set; } = Array.Empty<IMultiItemResolver>();
|
2020-07-20 11:01:37 +02:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets or sets the comparers.
|
|
|
|
/// </summary>
|
|
|
|
/// <value>The comparers.</value>
|
Fix possible ArgumentNullException
```
Error Message:
System.ArgumentNullException : Value cannot be null. (Parameter 'source')
Stack Trace:
at System.Linq.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
at System.Linq.Enumerable.Select[TSource,TResult](IEnumerable`1 source, Func`2 selector)
at Emby.Server.Implementations.Library.LibraryManager.ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 475
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, IDirectoryService directoryService, IItemResolver[] resolvers, Folder parent, String collectionType, LibraryOptions libraryOptions) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 618
at Emby.Server.Implementations.Library.LibraryManager.ResolvePath(FileSystemMetadata fileInfo, Folder parent) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 536
at Emby.Server.Implementations.Library.LibraryManager.GetUserRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 812
at Emby.Server.Implementations.Library.LibraryManager.GetCollectionFolders(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2080
at Emby.Server.Implementations.Library.LibraryManager.GetLibraryOptions(BaseItem item) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2116
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType, IEnumerable`1 savers) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 672
at MediaBrowser.Providers.Manager.ProviderManager.SaveMetadata(BaseItem item, ItemUpdateType updateType) in /home/vsts/work/1/s/MediaBrowser.Providers/Manager/ProviderManager.cs:line 655
at Emby.Server.Implementations.Library.LibraryManager.RunMetadataSavers(BaseItem item, ItemUpdateType updateReason) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 2017
at Emby.Server.Implementations.Library.LibraryManager.UpdateItemsAsync(IReadOnlyList`1 items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 1975
at Emby.Server.Implementations.Library.LibraryManager.CreateRootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 775
at Emby.Server.Implementations.Library.LibraryManager.get_RootFolder() in /home/vsts/work/1/s/Emby.Server.Implementations/Library/LibraryManager.cs:line 180
at Emby.Server.Implementations.IO.LibraryMonitor.Start() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitor.cs:line 135
at Emby.Server.Implementations.IO.LibraryMonitorStartup.RunAsync() in /home/vsts/work/1/s/Emby.Server.Implementations/IO/LibraryMonitorStartup.cs:line 26
at Emby.Server.Implementations.ApplicationHost.StartEntryPoints(IEnumerable`1 entryPoints, Boolean isBeforeStartup)+MoveNext() in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 518
at System.Threading.Tasks.Task.WhenAll(IEnumerable`1 tasks)
at Emby.Server.Implementations.ApplicationHost.RunStartupTasksAsync(CancellationToken cancellationToken) in /home/vsts/work/1/s/Emby.Server.Implementations/ApplicationHost.cs:line 502
at Jellyfin.Server.Integration.Tests.JellyfinApplicationFactory.CreateServer(IWebHostBuilder builder) in /home/vsts/work/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.Controllers.ActivityLogControllerTests.ActivityLog_GetEntries_Ok() in /home/vsts/work/1/s/tests/Jellyfin.Server.Integration.Tests/Controllers/ActivityLogControllerTests.cs:line 21
--- End of stack trace from previous location ---
```
2021-04-12 22:01:35 +02:00
|
|
|
private IBaseItemComparer[] Comparers { get; set; } = Array.Empty<IBaseItemComparer>();
|
2020-07-20 11:01:37 +02:00
|
|
|
|
|
|
|
public bool IsScanRunning { get; private set; }
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Adds the parts.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="rules">The rules.</param>
|
|
|
|
/// <param name="resolvers">The resolvers.</param>
|
|
|
|
/// <param name="introProviders">The intro providers.</param>
|
|
|
|
/// <param name="itemComparers">The item comparers.</param>
|
|
|
|
/// <param name="postscanTasks">The post scan tasks.</param>
|
|
|
|
public void AddParts(
|
|
|
|
IEnumerable<IResolverIgnoreRule> rules,
|
|
|
|
IEnumerable<IItemResolver> resolvers,
|
|
|
|
IEnumerable<IIntroProvider> introProviders,
|
|
|
|
IEnumerable<IBaseItemComparer> itemComparers,
|
|
|
|
IEnumerable<ILibraryPostScanTask> postscanTasks)
|
|
|
|
{
|
|
|
|
EntityResolutionIgnoreRules = rules.ToArray();
|
|
|
|
EntityResolvers = resolvers.OrderBy(i => i.Priority).ToArray();
|
|
|
|
MultiItemResolvers = EntityResolvers.OfType<IMultiItemResolver>().ToArray();
|
|
|
|
IntroProviders = introProviders.ToArray();
|
|
|
|
Comparers = itemComparers.ToArray();
|
|
|
|
PostscanTasks = postscanTasks.ToArray();
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Records the configuration values.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="configuration">The configuration.</param>
|
2013-03-12 06:40:24 +01:00
|
|
|
private void RecordConfigurationValues(ServerConfiguration configuration)
|
|
|
|
{
|
2014-02-04 05:04:19 +01:00
|
|
|
_wizardCompleted = configuration.IsStartupWizardCompleted;
|
2013-03-12 06:40:24 +01:00
|
|
|
}
|
|
|
|
|
2013-02-26 17:10:55 +01:00
|
|
|
/// <summary>
|
2013-04-08 17:55:53 +02:00
|
|
|
/// Configurations the updated.
|
2013-02-26 17:10:55 +01:00
|
|
|
/// </summary>
|
2013-04-08 17:55:53 +02:00
|
|
|
/// <param name="sender">The sender.</param>
|
2013-05-27 18:53:10 +02:00
|
|
|
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
|
2019-03-13 22:32:52 +01:00
|
|
|
private void ConfigurationUpdated(object sender, EventArgs e)
|
2013-02-26 17:10:55 +01:00
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
var config = _configurationManager.Configuration;
|
2013-03-12 06:40:24 +01:00
|
|
|
|
2014-02-04 05:04:19 +01:00
|
|
|
var wizardChanged = config.IsStartupWizardCompleted != _wizardCompleted;
|
2013-05-25 17:16:50 +02:00
|
|
|
|
2013-03-12 06:40:24 +01:00
|
|
|
RecordConfigurationValues(config);
|
2013-02-26 17:10:55 +01:00
|
|
|
|
2017-09-24 22:23:56 +02:00
|
|
|
if (wizardChanged)
|
2013-02-26 17:10:55 +01:00
|
|
|
{
|
2015-08-20 01:57:27 +02:00
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
|
|
|
|
}
|
2013-05-24 17:01:53 +02:00
|
|
|
}
|
|
|
|
|
2014-01-11 06:49:18 +01:00
|
|
|
public void RegisterItem(BaseItem item)
|
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(item);
|
2019-02-24 15:47:59 +01:00
|
|
|
|
2015-08-20 01:57:27 +02:00
|
|
|
if (item is IItemByName)
|
|
|
|
{
|
2021-08-29 00:32:50 +02:00
|
|
|
if (item is not MusicArtist)
|
2015-08-20 01:57:27 +02:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2019-02-24 15:47:59 +01:00
|
|
|
else if (!item.IsFolder)
|
2016-07-05 07:40:18 +02:00
|
|
|
{
|
2021-08-29 00:32:50 +02:00
|
|
|
if (item is not Video && item is not LiveTvChannel)
|
2016-07-09 19:39:04 +02:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2016-07-05 07:40:18 +02:00
|
|
|
}
|
2016-07-09 19:39:04 +02:00
|
|
|
|
2020-08-07 11:55:22 +02:00
|
|
|
_memoryCache.Set(item.Id, item);
|
2013-03-31 19:39:28 +02:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
public void DeleteItem(BaseItem item, DeleteOptions options)
|
|
|
|
{
|
|
|
|
DeleteItem(item, options, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void DeleteItem(BaseItem item, DeleteOptions options, bool notifyParentItem)
|
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(item);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
var parent = item.GetOwner() ?? item.GetParent();
|
|
|
|
|
|
|
|
DeleteItem(item, options, parent, notifyParentItem);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void DeleteItem(BaseItem item, DeleteOptions options, BaseItem parent, bool notifyParentItem)
|
2014-02-19 19:50:37 +01:00
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(item);
|
2016-03-20 22:32:26 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (item.SourceType == SourceType.Channel)
|
|
|
|
{
|
|
|
|
if (options.DeleteFromExternalProvider)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2021-11-09 22:29:33 +01:00
|
|
|
BaseItem.ChannelManager.DeleteItem(item).GetAwaiter().GetResult();
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
catch (ArgumentException)
|
|
|
|
{
|
|
|
|
// channel no longer installed
|
|
|
|
}
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
options.DeleteFileLocation = false;
|
|
|
|
}
|
|
|
|
|
2017-04-13 20:57:24 +02:00
|
|
|
if (item is LiveTvProgram)
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
_logger.LogDebug(
|
2020-07-17 23:53:10 +02:00
|
|
|
"Removing item, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
|
2017-04-13 20:57:24 +02:00
|
|
|
item.GetType().Name,
|
|
|
|
item.Name ?? "Unknown name",
|
|
|
|
item.Path ?? string.Empty,
|
|
|
|
item.Id);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
_logger.LogInformation(
|
2020-07-17 23:53:10 +02:00
|
|
|
"Removing item, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
|
2017-04-13 20:57:24 +02:00
|
|
|
item.GetType().Name,
|
|
|
|
item.Name ?? "Unknown name",
|
|
|
|
item.Path ?? string.Empty,
|
|
|
|
item.Id);
|
|
|
|
}
|
2014-02-20 05:53:15 +01:00
|
|
|
|
2014-02-19 19:50:37 +01:00
|
|
|
var children = item.IsFolder
|
2016-09-07 19:17:26 +02:00
|
|
|
? ((Folder)item).GetRecursiveChildren(false).ToList()
|
2014-02-19 19:50:37 +01:00
|
|
|
: new List<BaseItem>();
|
|
|
|
|
|
|
|
foreach (var metadataPath in GetMetadataPaths(item, children))
|
|
|
|
{
|
2019-02-24 15:47:59 +01:00
|
|
|
if (!Directory.Exists(metadataPath))
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-07-17 23:53:10 +02:00
|
|
|
_logger.LogDebug(
|
|
|
|
"Deleting metadata path, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
|
|
|
|
item.GetType().Name,
|
|
|
|
item.Name ?? "Unknown name",
|
|
|
|
metadataPath,
|
|
|
|
item.Id);
|
2014-02-19 19:50:37 +01:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.Delete(metadataPath, true);
|
2014-02-19 19:50:37 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2019-02-24 15:47:59 +01:00
|
|
|
_logger.LogError(ex, "Error deleting {MetadataPath}", metadataPath);
|
2014-02-19 19:50:37 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (options.DeleteFileLocation && item.IsFileProtocol)
|
2014-02-19 19:50:37 +01:00
|
|
|
{
|
2017-03-07 19:27:56 +01:00
|
|
|
// Assume only the first is required
|
|
|
|
// Add this flag to GetDeletePaths if required in the future
|
|
|
|
var isRequiredForDelete = true;
|
|
|
|
|
2019-12-15 05:38:59 +01:00
|
|
|
foreach (var fileSystemInfo in item.GetDeletePaths())
|
2014-02-19 19:50:37 +01:00
|
|
|
{
|
2020-01-01 06:45:09 +01:00
|
|
|
if (Directory.Exists(fileSystemInfo.FullName) || File.Exists(fileSystemInfo.FullName))
|
2017-03-07 19:27:56 +01:00
|
|
|
{
|
2019-01-27 17:00:17 +01:00
|
|
|
try
|
2017-03-07 19:27:56 +01:00
|
|
|
{
|
2020-07-17 23:53:10 +02:00
|
|
|
_logger.LogInformation(
|
|
|
|
"Deleting item path, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
|
|
|
|
item.GetType().Name,
|
|
|
|
item.Name ?? "Unknown name",
|
|
|
|
fileSystemInfo.FullName,
|
|
|
|
item.Id);
|
|
|
|
|
2019-01-27 17:00:17 +01:00
|
|
|
if (fileSystemInfo.IsDirectory)
|
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.Delete(fileSystemInfo.FullName, true);
|
2019-01-27 17:00:17 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
File.Delete(fileSystemInfo.FullName);
|
2019-01-27 17:00:17 +01:00
|
|
|
}
|
2017-03-07 19:27:56 +01:00
|
|
|
}
|
2019-01-27 17:00:17 +01:00
|
|
|
catch (IOException)
|
2017-03-07 19:27:56 +01:00
|
|
|
{
|
2019-01-27 17:00:17 +01:00
|
|
|
if (isRequiredForDelete)
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
2017-03-07 19:27:56 +01:00
|
|
|
}
|
2019-01-27 17:00:17 +01:00
|
|
|
catch (UnauthorizedAccessException)
|
2017-03-07 19:27:56 +01:00
|
|
|
{
|
2019-01-27 17:00:17 +01:00
|
|
|
if (isRequiredForDelete)
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
2017-03-07 19:27:56 +01:00
|
|
|
}
|
2014-02-19 19:50:37 +01:00
|
|
|
}
|
2017-03-07 19:27:56 +01:00
|
|
|
|
|
|
|
isRequiredForDelete = false;
|
2014-02-19 19:50:37 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
item.SetParent(null);
|
|
|
|
|
2020-04-11 16:00:39 +02:00
|
|
|
_itemRepository.DeleteItem(item.Id);
|
2014-02-19 19:50:37 +01:00
|
|
|
foreach (var child in children)
|
|
|
|
{
|
2020-04-11 16:00:39 +02:00
|
|
|
_itemRepository.DeleteItem(child.Id);
|
2014-02-19 19:50:37 +01:00
|
|
|
}
|
2014-02-20 05:53:15 +01:00
|
|
|
|
2020-07-29 23:28:15 +02:00
|
|
|
_memoryCache.Remove(item.Id);
|
2014-03-09 23:14:44 +01:00
|
|
|
|
2017-11-26 05:48:12 +01:00
|
|
|
ReportItemRemoved(item, parent);
|
2014-02-19 19:50:37 +01:00
|
|
|
}
|
|
|
|
|
2019-01-06 21:50:43 +01:00
|
|
|
private static IEnumerable<string> GetMetadataPaths(BaseItem item, IEnumerable<BaseItem> children)
|
2014-02-19 19:50:37 +01:00
|
|
|
{
|
|
|
|
var list = new List<string>
|
|
|
|
{
|
2014-09-28 17:27:26 +02:00
|
|
|
item.GetInternalMetadataPath()
|
2014-02-19 19:50:37 +01:00
|
|
|
};
|
|
|
|
|
2014-09-28 17:27:26 +02:00
|
|
|
list.AddRange(children.Select(i => i.GetInternalMetadataPath()));
|
2014-02-19 19:50:37 +01:00
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Resolves the item.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="args">The args.</param>
|
2016-03-19 20:32:37 +01:00
|
|
|
/// <param name="resolvers">The resolvers.</param>
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <returns>BaseItem.</returns>
|
2016-03-19 20:32:37 +01:00
|
|
|
private BaseItem ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2016-03-19 20:32:37 +01:00
|
|
|
var item = (resolvers ?? EntityResolvers).Select(r => Resolve(args, r))
|
2022-12-05 15:01:13 +01:00
|
|
|
.FirstOrDefault(i => i is not null);
|
2013-03-03 07:58:04 +01:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (item is not null)
|
2013-03-03 07:58:04 +01:00
|
|
|
{
|
2014-11-30 20:01:33 +01:00
|
|
|
ResolverHelper.SetInitialItemValues(item, args, _fileSystem, this);
|
2013-03-03 07:58:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
private BaseItem Resolve(ItemResolveArgs args, IItemResolver resolver)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
return resolver.ResolvePath(args);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogError(ex, "Error in {Resolver} resolving {Path}", resolver.GetType().Name, args.Path);
|
2014-12-04 06:24:41 +01:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-30 20:01:33 +01:00
|
|
|
public Guid GetNewItemId(string key, Type type)
|
2017-03-13 05:08:23 +01:00
|
|
|
{
|
|
|
|
return GetNewItemIdInternal(key, type, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
private Guid GetNewItemIdInternal(string key, Type type, bool forceCaseInsensitive)
|
2014-11-30 20:01:33 +01:00
|
|
|
{
|
2022-10-13 19:08:00 +02:00
|
|
|
ArgumentException.ThrowIfNullOrEmpty(key);
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(type);
|
2014-11-30 20:01:33 +01:00
|
|
|
|
2020-09-09 13:38:27 +02:00
|
|
|
string programDataPath = _configurationManager.ApplicationPaths.ProgramDataPath;
|
|
|
|
if (key.StartsWith(programDataPath, StringComparison.Ordinal))
|
2014-11-30 20:01:33 +01:00
|
|
|
{
|
|
|
|
// Try to normalize paths located underneath program-data in an attempt to make them more portable
|
2020-09-09 13:38:27 +02:00
|
|
|
key = key.Substring(programDataPath.Length)
|
2020-07-22 13:34:51 +02:00
|
|
|
.TrimStart('/', '\\')
|
|
|
|
.Replace('/', '\\');
|
2014-11-30 20:01:33 +01:00
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
if (forceCaseInsensitive || !_configurationManager.Configuration.EnableCaseSensitiveItemIds)
|
2016-03-24 07:04:58 +01:00
|
|
|
{
|
2019-01-27 12:03:43 +01:00
|
|
|
key = key.ToLowerInvariant();
|
2016-03-24 07:04:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
key = type.FullName + key;
|
2014-11-30 20:01:33 +01:00
|
|
|
|
|
|
|
return key.GetMD5();
|
|
|
|
}
|
|
|
|
|
2021-12-20 12:15:20 +01:00
|
|
|
public BaseItem ResolvePath(FileSystemMetadata fileInfo, Folder parent = null, IDirectoryService directoryService = null)
|
|
|
|
=> ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent);
|
2014-02-13 06:11:54 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
private BaseItem ResolvePath(
|
|
|
|
FileSystemMetadata fileInfo,
|
2016-08-13 07:49:00 +02:00
|
|
|
IDirectoryService directoryService,
|
|
|
|
IItemResolver[] resolvers,
|
|
|
|
Folder parent = null,
|
|
|
|
string collectionType = null,
|
2020-06-25 11:33:10 +02:00
|
|
|
LibraryOptions libraryOptions = null)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(fileInfo);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2014-12-22 07:50:29 +01:00
|
|
|
var fullPath = fileInfo.FullName;
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (string.IsNullOrEmpty(collectionType) && parent is not null)
|
2014-12-22 07:50:29 +01:00
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
collectionType = GetContentTypeOverride(fullPath, true);
|
2014-12-22 07:50:29 +01:00
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var args = new ItemResolveArgs(_configurationManager.ApplicationPaths, directoryService)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
Parent = parent,
|
2014-10-23 06:26:01 +02:00
|
|
|
FileInfo = fileInfo,
|
2016-08-13 07:49:00 +02:00
|
|
|
CollectionType = collectionType,
|
|
|
|
LibraryOptions = libraryOptions
|
2013-02-21 02:33:05 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
// Return null if ignore rules deem that we should do so
|
2020-06-25 11:33:10 +02:00
|
|
|
if (IgnoreFile(args.FileInfo, args.Parent))
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Gather child folder and files
|
|
|
|
if (args.IsDirectory)
|
|
|
|
{
|
2013-04-19 20:03:21 +02:00
|
|
|
var isPhysicalRoot = args.IsPhysicalRoot;
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
// When resolving the root, we need it's grandchildren (children of user views)
|
2013-04-19 20:03:21 +02:00
|
|
|
var flattenFolderDepth = isPhysicalRoot ? 2 : 0;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
FileSystemMetadata[] files;
|
|
|
|
var isVf = args.IsVf;
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
files = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, _fileSystem, _appHost, _logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || isVf);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (parent is not null && parent.IsPhysicalRoot)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error in GetFilteredFileSystemEntries isPhysicalRoot: {0} IsVf: {1}", isPhysicalRoot, isVf);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
files = Array.Empty<FileSystemMetadata>();
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
2014-02-22 21:20:22 +01:00
|
|
|
|
2013-05-24 19:48:48 +02:00
|
|
|
// Need to remove subpaths that may have been resolved from shortcuts
|
|
|
|
// Example: if \\server\movies exists, then strip out \\server\movies\action
|
|
|
|
if (isPhysicalRoot)
|
|
|
|
{
|
2017-08-20 21:10:00 +02:00
|
|
|
files = NormalizeRootPathList(files).ToArray();
|
2013-05-24 19:48:48 +02:00
|
|
|
}
|
2014-01-01 19:26:31 +01:00
|
|
|
|
2017-08-20 21:10:00 +02:00
|
|
|
args.FileSystemChildren = files;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check to see if we should resolve based on our contents
|
2013-03-03 07:58:04 +01:00
|
|
|
if (args.IsDirectory && !ShouldResolvePathContents(args))
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2016-03-19 20:32:37 +01:00
|
|
|
return ResolveItem(args, resolvers);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2015-11-13 21:53:29 +01:00
|
|
|
public bool IgnoreFile(FileSystemMetadata file, BaseItem parent)
|
2019-03-13 22:32:52 +01:00
|
|
|
=> EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(file, parent));
|
2015-11-05 00:49:06 +01:00
|
|
|
|
2017-08-20 21:10:00 +02:00
|
|
|
public List<FileSystemMetadata> NormalizeRootPathList(IEnumerable<FileSystemMetadata> paths)
|
2015-11-13 21:53:29 +01:00
|
|
|
{
|
2015-11-13 21:56:26 +01:00
|
|
|
var originalList = paths.ToList();
|
|
|
|
|
|
|
|
var list = originalList.Where(i => i.IsDirectory)
|
|
|
|
.Select(i => _fileSystem.NormalizePath(i.FullName))
|
2014-01-01 19:26:31 +01:00
|
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
var dupes = list.Where(subPath => !subPath.EndsWith(":\\", StringComparison.OrdinalIgnoreCase) && list.Any(i => _fileSystem.ContainsSubPath(i, subPath)))
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
foreach (var dupe in dupes)
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogInformation("Found duplicate path: {0}", dupe);
|
2014-01-01 19:26:31 +01:00
|
|
|
}
|
|
|
|
|
2015-11-13 21:56:26 +01:00
|
|
|
var newList = list.Except(dupes, StringComparer.OrdinalIgnoreCase).Select(_fileSystem.GetDirectoryInfo).ToList();
|
|
|
|
newList.AddRange(originalList.Where(i => !i.IsDirectory));
|
|
|
|
return newList;
|
2014-01-01 19:26:31 +01:00
|
|
|
}
|
|
|
|
|
2013-03-03 07:58:04 +01:00
|
|
|
/// <summary>
|
2020-06-16 00:37:52 +02:00
|
|
|
/// Determines whether a path should be ignored based on its contents - called after the contents have been read.
|
2013-03-03 07:58:04 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="args">The args.</param>
|
2021-10-02 19:59:58 +02:00
|
|
|
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
|
2013-03-03 07:58:04 +01:00
|
|
|
private static bool ShouldResolvePathContents(ItemResolveArgs args)
|
|
|
|
{
|
|
|
|
// Ignore any folders containing a file called .ignore
|
|
|
|
return !args.ContainsFileSystemEntryByName(".ignore");
|
|
|
|
}
|
|
|
|
|
2021-12-20 12:15:20 +01:00
|
|
|
public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemMetadata> files, IDirectoryService directoryService, Folder parent, LibraryOptions libraryOptions, string collectionType = null)
|
2016-03-19 20:32:37 +01:00
|
|
|
{
|
2016-08-13 07:49:00 +02:00
|
|
|
return ResolvePaths(files, directoryService, parent, libraryOptions, collectionType, EntityResolvers);
|
2016-03-19 20:32:37 +01:00
|
|
|
}
|
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
public IEnumerable<BaseItem> ResolvePaths(
|
|
|
|
IEnumerable<FileSystemMetadata> files,
|
2016-08-13 07:49:00 +02:00
|
|
|
IDirectoryService directoryService,
|
2016-09-14 23:34:19 +02:00
|
|
|
Folder parent,
|
2016-08-13 07:49:00 +02:00
|
|
|
LibraryOptions libraryOptions,
|
|
|
|
string collectionType,
|
|
|
|
IItemResolver[] resolvers)
|
2014-12-04 06:24:41 +01:00
|
|
|
{
|
2015-11-13 21:53:29 +01:00
|
|
|
var fileList = files.Where(i => !IgnoreFile(i, parent)).ToList();
|
2014-12-04 06:24:41 +01:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (parent is not null)
|
2014-12-04 06:24:41 +01:00
|
|
|
{
|
2022-12-05 15:00:20 +01:00
|
|
|
var multiItemResolvers = resolvers is null ? MultiItemResolvers : resolvers.OfType<IMultiItemResolver>().ToArray();
|
2016-03-19 20:32:37 +01:00
|
|
|
|
|
|
|
foreach (var resolver in multiItemResolvers)
|
2014-12-04 06:24:41 +01:00
|
|
|
{
|
|
|
|
var result = resolver.ResolveMultiple(parent, fileList, collectionType, directoryService);
|
|
|
|
|
2021-12-07 15:18:17 +01:00
|
|
|
if (result?.Items.Count > 0)
|
2014-12-04 06:24:41 +01:00
|
|
|
{
|
2022-02-17 08:15:26 +01:00
|
|
|
var items = result.Items;
|
2022-10-09 04:28:16 +02:00
|
|
|
items.RemoveAll(item => !ResolverHelper.SetInitialItemValues(item, parent, this, directoryService));
|
2016-08-13 07:49:00 +02:00
|
|
|
items.AddRange(ResolveFileList(result.ExtraFiles, directoryService, parent, collectionType, resolvers, libraryOptions));
|
2014-12-04 06:24:41 +01:00
|
|
|
return items;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-13 07:49:00 +02:00
|
|
|
return ResolveFileList(fileList, directoryService, parent, collectionType, resolvers, libraryOptions);
|
2014-12-04 06:24:41 +01:00
|
|
|
}
|
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
private IEnumerable<BaseItem> ResolveFileList(
|
2021-05-24 00:30:41 +02:00
|
|
|
IReadOnlyList<FileSystemMetadata> fileList,
|
2016-08-13 07:49:00 +02:00
|
|
|
IDirectoryService directoryService,
|
|
|
|
Folder parent,
|
|
|
|
string collectionType,
|
|
|
|
IItemResolver[] resolvers,
|
|
|
|
LibraryOptions libraryOptions)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
// Given that fileList is a list we can save enumerator allocations by indexing
|
|
|
|
for (var i = 0; i < fileList.Count; i++)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
var file = fileList[i];
|
|
|
|
BaseItem result = null;
|
2013-02-21 02:33:05 +01:00
|
|
|
try
|
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
result = ResolvePath(file, directoryService, resolvers, parent, collectionType, libraryOptions);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
_logger.LogError(ex, "Error resolving path {Path}", file.FullName);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
2021-05-24 00:30:41 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (result is not null)
|
2021-05-24 00:30:41 +02:00
|
|
|
{
|
|
|
|
yield return result;
|
|
|
|
}
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
2020-02-01 14:44:27 +01:00
|
|
|
/// Creates the root media folder.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <returns>AggregateFolder.</returns>
|
2020-02-01 14:44:27 +01:00
|
|
|
/// <exception cref="InvalidOperationException">Cannot create the root folder until plugins have loaded.</exception>
|
2013-02-28 20:32:41 +01:00
|
|
|
public AggregateFolder CreateRootFolder()
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
var rootFolderPath = _configurationManager.ApplicationPaths.RootFolderPath;
|
2013-06-04 18:48:23 +02:00
|
|
|
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(rootFolderPath);
|
2013-06-04 18:48:23 +02:00
|
|
|
|
2020-06-08 04:32:06 +02:00
|
|
|
var rootFolder = GetItemById(GetNewItemId(rootFolderPath, typeof(AggregateFolder))) as AggregateFolder ??
|
2020-08-20 12:16:24 +02:00
|
|
|
((Folder)ResolvePath(_fileSystem.GetDirectoryInfo(rootFolderPath)))
|
2020-06-08 04:32:06 +02:00
|
|
|
.DeepCopy<Folder, AggregateFolder>();
|
2018-12-30 01:24:30 +01:00
|
|
|
|
2017-11-10 22:22:38 +01:00
|
|
|
// In case program data folder was moved
|
2017-11-12 22:05:40 +01:00
|
|
|
if (!string.Equals(rootFolder.Path, rootFolderPath, StringComparison.Ordinal))
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogInformation("Resetting root folder path to {0}", rootFolderPath);
|
2017-11-12 22:05:40 +01:00
|
|
|
rootFolder.Path = rootFolderPath;
|
|
|
|
}
|
2017-11-10 22:22:38 +01:00
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
// Add in the plug-in folders
|
2020-04-05 00:28:46 +02:00
|
|
|
var path = Path.Combine(_configurationManager.ApplicationPaths.DataPath, "playlists");
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(path);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
Folder folder = new PlaylistsFolder
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
Path = path
|
|
|
|
};
|
2013-06-13 20:17:42 +02:00
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
if (folder.Id.Equals(default))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
if (string.IsNullOrEmpty(folder.Path))
|
2013-06-13 20:17:42 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
folder.Id = GetNewItemId(folder.GetType().Name, folder.GetType());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
folder.Id = GetNewItemId(folder.Path, folder.GetType());
|
|
|
|
}
|
|
|
|
}
|
2013-06-13 20:17:42 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var dbItem = GetItemById(folder.Id) as BasePluginFolder;
|
2015-04-06 22:43:40 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (dbItem is not null && string.Equals(dbItem.Path, folder.Path, StringComparison.OrdinalIgnoreCase))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
folder = dbItem;
|
|
|
|
}
|
2014-05-31 16:30:59 +02:00
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
if (!folder.ParentId.Equals(rootFolder.Id))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
folder.ParentId = rootFolder.Id;
|
2020-08-21 22:01:19 +02:00
|
|
|
folder.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, CancellationToken.None).GetAwaiter().GetResult();
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2015-11-13 21:53:29 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
rootFolder.AddVirtualChild(folder);
|
2014-06-04 05:34:36 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
RegisterItem(folder);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
|
|
return rootFolder;
|
|
|
|
}
|
|
|
|
|
2014-02-21 06:04:11 +01:00
|
|
|
public Folder GetUserRootFolder()
|
2013-04-05 06:13:41 +02:00
|
|
|
{
|
2022-12-05 15:00:20 +01:00
|
|
|
if (_userRootFolder is null)
|
2014-02-21 06:04:11 +01:00
|
|
|
{
|
2020-07-20 11:01:37 +02:00
|
|
|
lock (_userRootFolderSyncLock)
|
2014-12-13 04:56:30 +01:00
|
|
|
{
|
2022-12-05 15:00:20 +01:00
|
|
|
if (_userRootFolder is null)
|
2014-12-13 04:56:30 +01:00
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
var userRootPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
|
2013-04-22 06:38:03 +02:00
|
|
|
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogDebug("Creating userRootPath at {Path}", userRootPath);
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(userRootPath);
|
2014-02-22 23:41:29 +01:00
|
|
|
|
2019-09-03 05:32:03 +02:00
|
|
|
var newItemId = GetNewItemId(userRootPath, typeof(UserRootFolder));
|
|
|
|
UserRootFolder tmpItem = null;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
tmpItem = GetItemById(newItemId) as UserRootFolder;
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogError(ex, "Error creating UserRootFolder {Path}", newItemId);
|
2019-09-03 05:32:03 +02:00
|
|
|
}
|
2014-12-13 04:56:30 +01:00
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (tmpItem is null)
|
2014-12-13 04:56:30 +01:00
|
|
|
{
|
2019-09-03 05:32:03 +02:00
|
|
|
_logger.LogDebug("Creating new userRootFolder with DeepCopy");
|
2020-06-25 11:33:10 +02:00
|
|
|
tmpItem = ((Folder)ResolvePath(_fileSystem.GetDirectoryInfo(userRootPath))).DeepCopy<Folder, UserRootFolder>();
|
2014-12-13 04:56:30 +01:00
|
|
|
}
|
2015-01-27 23:45:59 +01:00
|
|
|
|
2017-11-10 22:22:38 +01:00
|
|
|
// In case program data folder was moved
|
2017-11-12 22:05:40 +01:00
|
|
|
if (!string.Equals(tmpItem.Path, userRootPath, StringComparison.Ordinal))
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogInformation("Resetting user root folder path to {0}", userRootPath);
|
2017-11-12 22:05:40 +01:00
|
|
|
tmpItem.Path = userRootPath;
|
|
|
|
}
|
2017-11-10 22:22:38 +01:00
|
|
|
|
2015-01-27 23:45:59 +01:00
|
|
|
_userRootFolder = tmpItem;
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogDebug("Setting userRootFolder: {Folder}", _userRootFolder);
|
2014-12-13 04:56:30 +01:00
|
|
|
}
|
|
|
|
}
|
2014-02-21 06:04:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return _userRootFolder;
|
2013-09-11 19:54:59 +02:00
|
|
|
}
|
2016-12-13 08:36:30 +01:00
|
|
|
|
2016-04-27 19:53:23 +02:00
|
|
|
public BaseItem FindByPath(string path, bool? isFolder)
|
2016-03-01 20:39:46 +01:00
|
|
|
{
|
2019-01-08 00:27:46 +01:00
|
|
|
// If this returns multiple items it could be tricky figuring out which one is correct.
|
2016-07-09 19:39:04 +02:00
|
|
|
// In most cases, the newest one will be and the others obsolete but not yet cleaned up
|
2022-10-13 19:08:00 +02:00
|
|
|
ArgumentException.ThrowIfNullOrEmpty(path);
|
2017-05-30 20:24:50 +02:00
|
|
|
|
2016-03-01 20:39:46 +01:00
|
|
|
var query = new InternalItemsQuery
|
|
|
|
{
|
2016-04-27 19:53:23 +02:00
|
|
|
Path = path,
|
2016-07-09 19:39:04 +02:00
|
|
|
IsFolder = isFolder,
|
2019-10-20 16:08:40 +02:00
|
|
|
OrderBy = new[] { (ItemSortBy.DateCreated, SortOrder.Descending) },
|
2017-05-21 09:25:49 +02:00
|
|
|
Limit = 1,
|
|
|
|
DtoOptions = new DtoOptions(true)
|
2016-03-01 20:39:46 +01:00
|
|
|
};
|
2016-12-15 07:41:10 +01:00
|
|
|
|
2016-07-09 19:39:04 +02:00
|
|
|
return GetItemList(query)
|
2016-05-10 20:43:17 +02:00
|
|
|
.FirstOrDefault();
|
2016-03-01 20:39:46 +01:00
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
2020-02-01 14:44:27 +01:00
|
|
|
/// Gets the person.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
/// <returns>Task{Person}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
public Person GetPerson(string name)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-10-03 13:36:53 +02:00
|
|
|
var path = Person.GetPath(name);
|
|
|
|
var id = GetItemByNameId<Person>(path);
|
2021-08-29 00:32:50 +02:00
|
|
|
if (GetItemById(id) is not Person item)
|
2020-10-03 13:36:53 +02:00
|
|
|
{
|
|
|
|
item = new Person
|
|
|
|
{
|
|
|
|
Name = name,
|
|
|
|
Id = id,
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
DateModified = DateTime.UtcNow,
|
|
|
|
Path = path
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
2020-02-01 14:44:27 +01:00
|
|
|
/// Gets the studio.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="name">The name.</param>
|
2013-09-10 20:56:00 +02:00
|
|
|
/// <returns>Task{Studio}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
public Studio GetStudio(string name)
|
2013-09-10 20:56:00 +02:00
|
|
|
{
|
2017-05-22 06:54:02 +02:00
|
|
|
return CreateItemByName<Studio>(Studio.GetPath, name, new DtoOptions(true));
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2017-05-18 23:05:47 +02:00
|
|
|
public Guid GetStudioId(string name)
|
|
|
|
{
|
2020-09-09 13:38:27 +02:00
|
|
|
return GetItemByNameId<Studio>(Studio.GetPath(name));
|
2017-05-18 23:05:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public Guid GetGenreId(string name)
|
|
|
|
{
|
2020-09-09 13:38:27 +02:00
|
|
|
return GetItemByNameId<Genre>(Genre.GetPath(name));
|
2017-05-18 23:05:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public Guid GetMusicGenreId(string name)
|
|
|
|
{
|
2020-09-09 13:38:27 +02:00
|
|
|
return GetItemByNameId<MusicGenre>(MusicGenre.GetPath(name));
|
2017-05-18 23:05:47 +02:00
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
2020-02-01 14:44:27 +01:00
|
|
|
/// Gets the genre.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="name">The name.</param>
|
2013-09-10 20:56:00 +02:00
|
|
|
/// <returns>Task{Genre}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
public Genre GetGenre(string name)
|
2013-09-10 20:56:00 +02:00
|
|
|
{
|
2017-05-22 06:54:02 +02:00
|
|
|
return CreateItemByName<Genre>(Genre.GetPath, name, new DtoOptions(true));
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2013-06-11 05:31:00 +02:00
|
|
|
/// <summary>
|
2020-02-01 14:44:27 +01:00
|
|
|
/// Gets the music genre.
|
2013-06-11 05:31:00 +02:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
/// <returns>Task{MusicGenre}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
public MusicGenre GetMusicGenre(string name)
|
2013-07-01 19:17:33 +02:00
|
|
|
{
|
2017-05-22 06:54:02 +02:00
|
|
|
return CreateItemByName<MusicGenre>(MusicGenre.GetPath, name, new DtoOptions(true));
|
2013-09-10 20:56:00 +02:00
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
2020-02-01 14:44:27 +01:00
|
|
|
/// Gets the year.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="value">The value.</param>
|
|
|
|
/// <returns>Task{Year}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
public Year GetYear(int value)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
if (value <= 0)
|
|
|
|
{
|
2019-01-13 20:21:32 +01:00
|
|
|
throw new ArgumentOutOfRangeException(nameof(value), "Years less than or equal to 0 are invalid.");
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2016-08-18 07:56:10 +02:00
|
|
|
var name = value.ToString(CultureInfo.InvariantCulture);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2017-05-22 06:54:02 +02:00
|
|
|
return CreateItemByName<Year>(Year.GetPath, name, new DtoOptions(true));
|
2015-01-13 04:46:44 +01:00
|
|
|
}
|
|
|
|
|
2013-11-21 21:48:26 +01:00
|
|
|
/// <summary>
|
2020-06-16 00:37:52 +02:00
|
|
|
/// Gets a Genre.
|
2013-11-21 21:48:26 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
/// <returns>Task{Genre}.</returns>
|
|
|
|
public MusicArtist GetArtist(string name)
|
|
|
|
{
|
2017-05-22 06:54:02 +02:00
|
|
|
return GetArtist(name, new DtoOptions(true));
|
2013-09-11 19:54:59 +02:00
|
|
|
}
|
|
|
|
|
2017-05-22 06:54:02 +02:00
|
|
|
public MusicArtist GetArtist(string name, DtoOptions options)
|
|
|
|
{
|
|
|
|
return CreateItemByName<MusicArtist>(MusicArtist.GetPath, name, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
private T CreateItemByName<T>(Func<string, string> getPathFn, string name, DtoOptions options)
|
2013-02-21 02:33:05 +01:00
|
|
|
where T : BaseItem, new()
|
|
|
|
{
|
2016-06-20 05:34:47 +02:00
|
|
|
if (typeof(T) == typeof(MusicArtist))
|
2013-11-21 21:48:26 +01:00
|
|
|
{
|
2016-05-04 18:33:22 +02:00
|
|
|
var existing = GetItemList(new InternalItemsQuery
|
|
|
|
{
|
2021-12-12 03:31:30 +01:00
|
|
|
IncludeItemTypes = new[] { BaseItemKind.MusicArtist },
|
2017-05-21 09:25:49 +02:00
|
|
|
Name = name,
|
2017-05-22 06:54:02 +02:00
|
|
|
DtoOptions = options
|
2016-05-04 18:33:22 +02:00
|
|
|
}).Cast<MusicArtist>()
|
2016-05-07 20:58:16 +02:00
|
|
|
.OrderBy(i => i.IsAccessedByName ? 1 : 0)
|
2016-05-04 18:33:22 +02:00
|
|
|
.Cast<T>()
|
|
|
|
.FirstOrDefault();
|
2013-11-21 21:48:26 +01:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (existing is not null)
|
2013-11-21 21:48:26 +01:00
|
|
|
{
|
2014-02-22 21:20:22 +01:00
|
|
|
return existing;
|
2013-11-21 21:48:26 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-09 13:38:27 +02:00
|
|
|
var path = getPathFn(name);
|
|
|
|
var id = GetItemByNameId<T>(path);
|
2020-09-11 12:56:11 +02:00
|
|
|
var item = GetItemById(id) as T;
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
item = new T
|
|
|
|
{
|
|
|
|
Name = name,
|
|
|
|
Id = id,
|
2015-08-06 03:21:18 +02:00
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
DateModified = DateTime.UtcNow,
|
2013-02-21 02:33:05 +01:00
|
|
|
Path = path
|
|
|
|
};
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
CreateItem(item, null);
|
2013-11-21 21:48:26 +01:00
|
|
|
}
|
|
|
|
|
2020-09-11 12:56:11 +02:00
|
|
|
return item;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-09-09 13:38:27 +02:00
|
|
|
private Guid GetItemByNameId<T>(string path)
|
2017-05-18 23:05:47 +02:00
|
|
|
where T : BaseItem, new()
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
var forceCaseInsensitiveId = _configurationManager.Configuration.EnableNormalizedItemByNameIds;
|
2017-05-18 23:05:47 +02:00
|
|
|
return GetNewItemIdInternal(path, typeof(T), forceCaseInsensitiveId);
|
|
|
|
}
|
|
|
|
|
2022-02-15 18:59:46 +01:00
|
|
|
/// <inheritdoc />
|
|
|
|
public Task ValidatePeopleAsync(IProgress<double> progress, CancellationToken cancellationToken)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2014-03-09 23:14:44 +01:00
|
|
|
// Ensure the location is available.
|
2020-04-05 00:28:46 +02:00
|
|
|
Directory.CreateDirectory(_configurationManager.ApplicationPaths.PeoplePath);
|
2014-03-02 19:01:46 +01:00
|
|
|
|
2019-02-06 20:38:42 +01:00
|
|
|
return new PeopleValidator(this, _logger, _fileSystem).ValidatePeople(cancellationToken, progress);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
2020-06-16 00:37:52 +02:00
|
|
|
/// Reloads the root media folder.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="progress">The progress.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>Task.</returns>
|
2013-04-14 21:39:25 +02:00
|
|
|
public Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
|
|
|
|
{
|
|
|
|
// Just run the scheduled task so that the user can see it
|
2013-09-24 17:08:51 +02:00
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return Task.CompletedTask;
|
2013-04-14 21:39:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Validates the media library internal.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="progress">The progress.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>Task.</returns>
|
|
|
|
public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
|
2013-11-27 03:38:11 +01:00
|
|
|
{
|
2016-04-26 05:39:21 +02:00
|
|
|
IsScanRunning = true;
|
2020-04-05 00:28:46 +02:00
|
|
|
LibraryMonitor.Stop();
|
2013-11-27 03:38:11 +01:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
|
|
|
|
}
|
|
|
|
finally
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
LibraryMonitor.Start();
|
2016-04-26 05:39:21 +02:00
|
|
|
IsScanRunning = false;
|
2013-11-27 03:38:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private async Task ValidateTopLibraryFolders(CancellationToken cancellationToken)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2013-02-28 20:32:41 +01:00
|
|
|
await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
|
|
// Start by just validating the children of the root, but go no further
|
2019-03-13 22:32:52 +01:00
|
|
|
await RootFolder.ValidateChildren(
|
|
|
|
new SimpleProgress<double>(),
|
2019-09-10 22:37:53 +02:00
|
|
|
new MetadataRefreshOptions(new DirectoryService(_fileSystem)),
|
2021-06-06 17:16:41 +02:00
|
|
|
recursive: false,
|
|
|
|
cancellationToken).ConfigureAwait(false);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2016-12-15 07:41:10 +01:00
|
|
|
await GetUserRootFolder().RefreshMetadata(cancellationToken).ConfigureAwait(false);
|
2014-02-21 06:04:11 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
await GetUserRootFolder().ValidateChildren(
|
|
|
|
new SimpleProgress<double>(),
|
2019-09-10 22:37:53 +02:00
|
|
|
new MetadataRefreshOptions(new DirectoryService(_fileSystem)),
|
2021-06-06 17:16:41 +02:00
|
|
|
recursive: false,
|
|
|
|
cancellationToken).ConfigureAwait(false);
|
2013-05-25 17:16:50 +02:00
|
|
|
|
2016-12-15 07:41:10 +01:00
|
|
|
// Quickly scan CollectionFolders for changes
|
2019-03-13 22:32:52 +01:00
|
|
|
foreach (var folder in GetUserRootFolder().Children.OfType<Folder>())
|
2016-12-15 07:41:10 +01:00
|
|
|
{
|
|
|
|
await folder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogInformation("Validating media library");
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
await ValidateTopLibraryFolders(cancellationToken).ConfigureAwait(false);
|
2016-12-15 07:41:10 +01:00
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
var innerProgress = new ActionableProgress<double>();
|
|
|
|
|
2020-02-22 07:04:52 +01:00
|
|
|
innerProgress.RegisterAction(pct => progress.Report(pct * 0.96));
|
2013-04-22 06:38:03 +02:00
|
|
|
|
2020-02-01 15:36:40 +01:00
|
|
|
// Validate the entire media library
|
2021-06-06 17:16:41 +02:00
|
|
|
await RootFolder.ValidateChildren(innerProgress, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), recursive: true, cancellationToken).ConfigureAwait(false);
|
2013-04-22 06:38:03 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
progress.Report(96);
|
2013-06-23 19:48:30 +02:00
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
innerProgress = new ActionableProgress<double>();
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
innerProgress.RegisterAction(pct => progress.Report(96 + (pct * .04)));
|
2013-09-26 00:41:25 +02:00
|
|
|
|
|
|
|
await RunPostScanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
|
2013-04-22 06:38:03 +02:00
|
|
|
|
|
|
|
progress.Report(100);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Runs the post scan tasks.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="progress">The progress.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>Task.</returns>
|
|
|
|
private async Task RunPostScanTasks(IProgress<double> progress, CancellationToken cancellationToken)
|
|
|
|
{
|
2013-09-26 00:41:25 +02:00
|
|
|
var tasks = PostscanTasks.ToList();
|
2013-05-27 18:53:10 +02:00
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
var numComplete = 0;
|
|
|
|
var numTasks = tasks.Count;
|
|
|
|
|
|
|
|
foreach (var task in tasks)
|
2013-05-27 18:53:10 +02:00
|
|
|
{
|
|
|
|
var innerProgress = new ActionableProgress<double>();
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
// Prevent access to modified closure
|
|
|
|
var currentNumComplete = numComplete;
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
innerProgress.RegisterAction(pct =>
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
double innerPercent = pct;
|
|
|
|
innerPercent /= 100;
|
|
|
|
innerPercent += currentNumComplete;
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
innerPercent /= numTasks;
|
2018-09-12 19:26:21 +02:00
|
|
|
innerPercent *= 100;
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
progress.Report(innerPercent);
|
2013-05-27 18:53:10 +02:00
|
|
|
});
|
|
|
|
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogDebug("Running post-scan task {0}", task.GetType().Name);
|
2015-07-10 06:44:21 +02:00
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
try
|
|
|
|
{
|
2015-02-08 19:21:24 +01:00
|
|
|
await task.Run(innerProgress, cancellationToken).ConfigureAwait(false);
|
2013-05-27 18:53:10 +02:00
|
|
|
}
|
2013-09-18 04:43:34 +02:00
|
|
|
catch (OperationCanceledException)
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogInformation("Post-scan task cancelled: {0}", task.GetType().Name);
|
2017-05-10 21:12:03 +02:00
|
|
|
throw;
|
2013-09-18 04:43:34 +02:00
|
|
|
}
|
2013-05-27 18:53:10 +02:00
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2020-02-01 14:44:27 +01:00
|
|
|
_logger.LogError(ex, "Error running post-scan task");
|
2013-05-27 18:53:10 +02:00
|
|
|
}
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
numComplete++;
|
|
|
|
double percent = numComplete;
|
|
|
|
percent /= numTasks;
|
|
|
|
progress.Report(percent * 100);
|
|
|
|
}
|
|
|
|
|
2021-04-22 15:28:24 +02:00
|
|
|
_itemRepository.UpdateInheritedValues();
|
2017-08-11 08:29:49 +02:00
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
progress.Report(100);
|
2013-05-25 17:16:50 +02:00
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the default view.
|
|
|
|
/// </summary>
|
|
|
|
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
|
2017-06-23 18:04:45 +02:00
|
|
|
public List<VirtualFolderInfo> GetVirtualFolders()
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2017-06-23 18:04:45 +02:00
|
|
|
return GetVirtualFolders(false);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2017-06-23 18:04:45 +02:00
|
|
|
public List<VirtualFolderInfo> GetVirtualFolders(bool includeRefreshState)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2019-09-03 05:32:03 +02:00
|
|
|
_logger.LogDebug("Getting topLibraryFolders");
|
2015-10-15 19:37:27 +02:00
|
|
|
var topLibraryFolders = GetUserRootFolder().Children.ToList();
|
|
|
|
|
2019-09-03 05:32:03 +02:00
|
|
|
_logger.LogDebug("Getting refreshQueue");
|
2020-04-05 00:28:46 +02:00
|
|
|
var refreshQueue = includeRefreshState ? ProviderManager.GetRefreshQueue() : null;
|
2017-06-23 18:04:45 +02:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
return _fileSystem.GetDirectoryPaths(_configurationManager.ApplicationPaths.DefaultUserViewsPath)
|
2017-06-23 18:04:45 +02:00
|
|
|
.Select(dir => GetVirtualFolderInfo(dir, topLibraryFolders, refreshQueue))
|
|
|
|
.ToList();
|
2015-10-15 19:37:27 +02:00
|
|
|
}
|
2013-07-12 21:56:40 +02:00
|
|
|
|
2022-12-07 18:02:12 +01:00
|
|
|
private VirtualFolderInfo GetVirtualFolderInfo(string dir, List<BaseItem> allCollectionFolders, HashSet<Guid> refreshQueue)
|
2015-10-15 19:37:27 +02:00
|
|
|
{
|
|
|
|
var info = new VirtualFolderInfo
|
|
|
|
{
|
|
|
|
Name = Path.GetFileName(dir),
|
2013-07-12 21:56:40 +02:00
|
|
|
|
2016-11-03 07:37:52 +01:00
|
|
|
Locations = _fileSystem.GetFilePaths(dir, false)
|
|
|
|
.Where(i => string.Equals(ShortcutFileExtension, Path.GetExtension(i), StringComparison.OrdinalIgnoreCase))
|
2018-09-12 19:26:21 +02:00
|
|
|
.Select(i =>
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
return _appHost.ExpandVirtualPath(_fileSystem.ResolveShortcut(i));
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogError(ex, "Error resolving shortcut file {File}", i);
|
2018-09-12 19:26:21 +02:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
})
|
2022-12-05 15:01:13 +01:00
|
|
|
.Where(i => i is not null)
|
2015-10-15 19:37:27 +02:00
|
|
|
.OrderBy(i => i)
|
2017-08-19 21:43:35 +02:00
|
|
|
.ToArray(),
|
2015-10-15 19:37:27 +02:00
|
|
|
|
|
|
|
CollectionType = GetCollectionType(dir)
|
|
|
|
};
|
|
|
|
|
2016-08-13 22:54:29 +02:00
|
|
|
var libraryFolder = allCollectionFolders.FirstOrDefault(i => string.Equals(i.Path, dir, StringComparison.OrdinalIgnoreCase));
|
2022-12-05 15:01:13 +01:00
|
|
|
if (libraryFolder is not null)
|
2015-10-16 07:36:16 +02:00
|
|
|
{
|
2022-12-07 18:02:12 +01:00
|
|
|
var libraryFolderId = libraryFolder.Id.ToString("N", CultureInfo.InvariantCulture);
|
|
|
|
info.ItemId = libraryFolderId;
|
|
|
|
if (libraryFolder.HasImage(ImageType.Primary))
|
|
|
|
{
|
|
|
|
info.PrimaryImageItemId = libraryFolderId;
|
|
|
|
}
|
|
|
|
|
2016-10-02 06:31:47 +02:00
|
|
|
info.LibraryOptions = GetLibraryOptions(libraryFolder);
|
2017-06-23 18:04:45 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (refreshQueue is not null)
|
2017-06-23 18:04:45 +02:00
|
|
|
{
|
|
|
|
info.RefreshProgress = libraryFolder.GetRefreshProgress();
|
|
|
|
|
2022-12-07 18:02:12 +01:00
|
|
|
info.RefreshStatus = info.RefreshProgress.HasValue ? "Active" : refreshQueue.Contains(libraryFolder.Id) ? "Queued" : "Idle";
|
2017-06-23 18:04:45 +02:00
|
|
|
}
|
2016-08-13 22:54:29 +02:00
|
|
|
}
|
|
|
|
|
2015-10-15 19:37:27 +02:00
|
|
|
return info;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
2013-02-28 20:32:41 +01:00
|
|
|
|
2021-02-24 11:57:04 +01:00
|
|
|
private CollectionTypeOptions? GetCollectionType(string path)
|
2013-07-12 21:56:40 +02:00
|
|
|
{
|
2021-02-24 02:34:50 +01:00
|
|
|
var files = _fileSystem.GetFilePaths(path, new[] { ".collection" }, true, false);
|
2021-05-23 00:20:19 +02:00
|
|
|
foreach (ReadOnlySpan<char> file in files)
|
2021-02-24 02:34:50 +01:00
|
|
|
{
|
2021-03-08 12:08:17 +01:00
|
|
|
if (Enum.TryParse<CollectionTypeOptions>(Path.GetFileNameWithoutExtension(file), true, out var res))
|
2021-02-24 02:34:50 +01:00
|
|
|
{
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-24 11:57:04 +01:00
|
|
|
return null;
|
2013-07-12 21:56:40 +02:00
|
|
|
}
|
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the item by id.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="id">The id.</param>
|
|
|
|
/// <returns>BaseItem.</returns>
|
2021-10-02 19:59:58 +02:00
|
|
|
/// <exception cref="ArgumentNullException"><paramref name="id"/> is <c>null</c>.</exception>
|
2013-02-28 20:32:41 +01:00
|
|
|
public BaseItem GetItemById(Guid id)
|
|
|
|
{
|
2022-02-21 14:15:09 +01:00
|
|
|
if (id.Equals(default))
|
2013-02-28 20:32:41 +01:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
throw new ArgumentException("Guid can't be empty", nameof(id));
|
2013-02-28 20:32:41 +01:00
|
|
|
}
|
2013-03-02 03:44:46 +01:00
|
|
|
|
2020-07-29 23:28:15 +02:00
|
|
|
if (_memoryCache.TryGetValue(id, out BaseItem item))
|
2013-05-08 22:58:52 +02:00
|
|
|
{
|
|
|
|
return item;
|
|
|
|
}
|
2013-03-31 19:39:28 +02:00
|
|
|
|
2014-03-20 16:55:22 +01:00
|
|
|
item = RetrieveItem(id);
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (item is not null)
|
2014-03-20 16:55:22 +01:00
|
|
|
{
|
|
|
|
RegisterItem(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
2013-03-02 03:44:46 +01:00
|
|
|
}
|
|
|
|
|
2017-08-09 21:56:38 +02:00
|
|
|
public List<BaseItem> GetItemList(InternalItemsQuery query, bool allowExternalContent)
|
2015-06-01 16:49:23 +02:00
|
|
|
{
|
2022-02-21 14:15:09 +01:00
|
|
|
if (query.Recursive && !query.ParentId.Equals(default))
|
2016-06-30 16:50:08 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var parent = GetItemById(query.ParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (parent is not null)
|
2016-06-30 16:50:08 +02:00
|
|
|
{
|
|
|
|
SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2015-11-13 21:53:29 +01:00
|
|
|
{
|
2017-06-03 09:36:32 +02:00
|
|
|
AddUserToQuery(query, query.User, allowExternalContent);
|
2015-11-13 21:53:29 +01:00
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetItemList(query);
|
2015-06-01 16:49:23 +02:00
|
|
|
}
|
|
|
|
|
2017-08-09 21:56:38 +02:00
|
|
|
public List<BaseItem> GetItemList(InternalItemsQuery query)
|
2017-06-03 09:36:32 +02:00
|
|
|
{
|
|
|
|
return GetItemList(query, true);
|
|
|
|
}
|
|
|
|
|
2016-12-12 20:40:27 +01:00
|
|
|
public int GetCount(InternalItemsQuery query)
|
|
|
|
{
|
2022-02-21 14:15:09 +01:00
|
|
|
if (query.Recursive && !query.ParentId.Equals(default))
|
2016-12-12 20:40:27 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var parent = GetItemById(query.ParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (parent is not null)
|
2016-12-12 20:40:27 +01:00
|
|
|
{
|
|
|
|
SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-12-12 20:40:27 +01:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetCount(query);
|
2016-12-12 20:40:27 +01:00
|
|
|
}
|
|
|
|
|
2017-08-09 21:56:38 +02:00
|
|
|
public List<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
|
2016-06-30 21:01:48 +02:00
|
|
|
{
|
|
|
|
SetTopParentIdsOrAncestors(query, parents);
|
|
|
|
|
|
|
|
if (query.AncestorIds.Length == 0 && query.TopParentIds.Length == 0)
|
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-06-30 21:01:48 +02:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetItemList(query);
|
2016-06-30 21:01:48 +02:00
|
|
|
}
|
|
|
|
|
2015-08-20 01:57:27 +02:00
|
|
|
public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
|
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2015-11-13 21:53:29 +01:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
2016-06-11 22:12:01 +02:00
|
|
|
if (query.EnableTotalRecordCount)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetItems(query);
|
2016-06-11 22:12:01 +02:00
|
|
|
}
|
|
|
|
|
2022-01-20 16:46:17 +01:00
|
|
|
return new QueryResult<BaseItem>(
|
|
|
|
query.StartIndex,
|
|
|
|
null,
|
|
|
|
_itemRepository.GetItemList(query));
|
2015-08-20 01:57:27 +02:00
|
|
|
}
|
|
|
|
|
2015-07-07 04:25:23 +02:00
|
|
|
public List<Guid> GetItemIds(InternalItemsQuery query)
|
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2015-11-13 21:53:29 +01:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetItemIdsList(query);
|
2015-07-07 04:25:23 +02:00
|
|
|
}
|
|
|
|
|
2021-12-24 22:18:24 +01:00
|
|
|
public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetStudios(InternalItemsQuery query)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetTopParentOrAncestorIds(query);
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetStudios(query);
|
2016-06-17 15:06:13 +02:00
|
|
|
}
|
|
|
|
|
2021-12-24 22:18:24 +01:00
|
|
|
public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetGenres(InternalItemsQuery query)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetTopParentOrAncestorIds(query);
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetGenres(query);
|
2016-06-17 15:06:13 +02:00
|
|
|
}
|
|
|
|
|
2021-12-24 22:18:24 +01:00
|
|
|
public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetMusicGenres(InternalItemsQuery query)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetTopParentOrAncestorIds(query);
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetMusicGenres(query);
|
2016-06-17 15:06:13 +02:00
|
|
|
}
|
|
|
|
|
2021-12-24 22:18:24 +01:00
|
|
|
public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAllArtists(InternalItemsQuery query)
|
2016-08-06 06:38:01 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-08-06 06:38:01 +02:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetTopParentOrAncestorIds(query);
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetAllArtists(query);
|
2016-08-06 06:38:01 +02:00
|
|
|
}
|
|
|
|
|
2021-12-24 22:18:24 +01:00
|
|
|
public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetArtists(InternalItemsQuery query)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetTopParentOrAncestorIds(query);
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetArtists(query);
|
2016-06-17 15:06:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private void SetTopParentOrAncestorIds(InternalItemsQuery query)
|
|
|
|
{
|
2020-02-19 21:56:35 +01:00
|
|
|
var ancestorIds = query.AncestorIds;
|
|
|
|
int len = ancestorIds.Length;
|
|
|
|
if (len == 0)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-02-19 21:56:35 +01:00
|
|
|
var parents = new BaseItem[len];
|
|
|
|
for (int i = 0; i < len; i++)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
2020-02-19 21:56:35 +01:00
|
|
|
parents[i] = GetItemById(ancestorIds[i]);
|
2022-01-05 10:58:57 +01:00
|
|
|
if (parents[i] is not (ICollectionFolder or UserView))
|
2016-12-15 07:41:10 +01:00
|
|
|
{
|
2020-02-19 21:56:35 +01:00
|
|
|
return;
|
2016-12-15 07:41:10 +01:00
|
|
|
}
|
2016-06-17 15:06:13 +02:00
|
|
|
}
|
2020-02-19 21:56:35 +01:00
|
|
|
|
|
|
|
// Optimize by querying against top level views
|
|
|
|
query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).ToArray();
|
|
|
|
query.AncestorIds = Array.Empty<Guid>();
|
|
|
|
|
|
|
|
// Prevent searching in all libraries due to empty filter
|
|
|
|
if (query.TopParentIds.Length == 0)
|
|
|
|
{
|
|
|
|
query.TopParentIds = new[] { Guid.NewGuid() };
|
|
|
|
}
|
2016-06-17 15:06:13 +02:00
|
|
|
}
|
|
|
|
|
2021-12-24 22:18:24 +01:00
|
|
|
public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAlbumArtists(InternalItemsQuery query)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-06-17 15:06:13 +02:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetTopParentOrAncestorIds(query);
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetAlbumArtists(query);
|
2016-06-17 15:06:13 +02:00
|
|
|
}
|
|
|
|
|
2016-03-20 07:46:51 +01:00
|
|
|
public QueryResult<BaseItem> GetItemsResult(InternalItemsQuery query)
|
|
|
|
{
|
2022-02-21 14:15:09 +01:00
|
|
|
if (query.Recursive && !query.ParentId.Equals(default))
|
2016-03-20 07:46:51 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var parent = GetItemById(query.ParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (parent is not null)
|
2016-03-20 07:46:51 +01:00
|
|
|
{
|
|
|
|
SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (query.User is not null)
|
2016-03-20 07:46:51 +01:00
|
|
|
{
|
|
|
|
AddUserToQuery(query, query.User);
|
|
|
|
}
|
|
|
|
|
2016-05-09 05:13:38 +02:00
|
|
|
if (query.EnableTotalRecordCount)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetItems(query);
|
2016-06-16 15:24:12 +02:00
|
|
|
}
|
|
|
|
|
2022-01-20 16:46:17 +01:00
|
|
|
return new QueryResult<BaseItem>(
|
|
|
|
query.StartIndex,
|
|
|
|
null,
|
|
|
|
_itemRepository.GetItemList(query));
|
2016-03-20 07:46:51 +01:00
|
|
|
}
|
|
|
|
|
2015-11-18 06:49:20 +01:00
|
|
|
private void SetTopParentIdsOrAncestors(InternalItemsQuery query, List<BaseItem> parents)
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
if (parents.All(i => i is ICollectionFolder || i is UserView))
|
2015-11-18 06:49:20 +01:00
|
|
|
{
|
|
|
|
// Optimize by querying against top level views
|
2018-09-12 19:26:21 +02:00
|
|
|
query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).ToArray();
|
2016-12-15 07:41:10 +01:00
|
|
|
|
|
|
|
// Prevent searching in all libraries due to empty filter
|
|
|
|
if (query.TopParentIds.Length == 0)
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
query.TopParentIds = new[] { Guid.NewGuid() };
|
2016-12-15 07:41:10 +01:00
|
|
|
}
|
2015-11-18 06:49:20 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// We need to be able to query from any arbitrary ancestor up the tree
|
2018-09-12 19:26:21 +02:00
|
|
|
query.AncestorIds = parents.SelectMany(i => i.GetIdsForAncestorQuery()).ToArray();
|
2016-12-15 07:41:10 +01:00
|
|
|
|
|
|
|
// Prevent searching in all libraries due to empty filter
|
|
|
|
if (query.AncestorIds.Length == 0)
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
query.AncestorIds = new[] { Guid.NewGuid() };
|
2016-12-15 07:41:10 +01:00
|
|
|
}
|
2015-11-18 06:49:20 +01:00
|
|
|
}
|
2016-12-15 07:41:10 +01:00
|
|
|
|
2017-05-23 18:43:24 +02:00
|
|
|
query.Parent = null;
|
2015-11-18 06:49:20 +01:00
|
|
|
}
|
|
|
|
|
2020-05-20 19:07:53 +02:00
|
|
|
private void AddUserToQuery(InternalItemsQuery query, User user, bool allowExternalContent = true)
|
2015-11-13 21:53:29 +01:00
|
|
|
{
|
2016-09-14 23:34:19 +02:00
|
|
|
if (query.AncestorIds.Length == 0 &&
|
2022-02-21 14:15:09 +01:00
|
|
|
query.ParentId.Equals(default) &&
|
2020-11-17 04:29:46 +01:00
|
|
|
query.ChannelIds.Count == 0 &&
|
2016-09-14 23:34:19 +02:00
|
|
|
query.TopParentIds.Length == 0 &&
|
2018-09-12 19:26:21 +02:00
|
|
|
string.IsNullOrEmpty(query.AncestorWithPresentationUniqueKey) &&
|
|
|
|
string.IsNullOrEmpty(query.SeriesPresentationUniqueKey) &&
|
2016-12-06 09:24:29 +01:00
|
|
|
query.ItemIds.Length == 0)
|
2015-11-13 21:53:29 +01:00
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
var userViews = UserViewManager.GetUserViews(new UserViewQuery
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
UserId = user.Id,
|
2017-06-03 09:36:32 +02:00
|
|
|
IncludeHidden = true,
|
|
|
|
IncludeExternalContent = allowExternalContent
|
2018-09-12 19:26:21 +02:00
|
|
|
});
|
2015-11-13 21:53:29 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
query.TopParentIds = userViews.SelectMany(i => GetTopParentIdsForQuery(i, user)).ToArray();
|
2015-11-13 21:53:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-20 19:07:53 +02:00
|
|
|
private IEnumerable<Guid> GetTopParentIdsForQuery(BaseItem item, User user)
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
if (item is UserView view)
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
if (string.Equals(view.ViewType, CollectionType.LiveTv, StringComparison.Ordinal))
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2016-12-13 08:36:30 +01:00
|
|
|
return new[] { view.Id };
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Translate view into folders
|
2022-02-21 14:15:09 +01:00
|
|
|
if (!view.DisplayParentId.Equals(default))
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
|
|
|
var displayParent = GetItemById(view.DisplayParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (displayParent is not null)
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2016-12-13 08:36:30 +01:00
|
|
|
return GetTopParentIdsForQuery(displayParent, user);
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return Array.Empty<Guid>();
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
if (!view.ParentId.Equals(default))
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
|
|
|
var displayParent = GetItemById(view.ParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (displayParent is not null)
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2016-12-13 08:36:30 +01:00
|
|
|
return GetTopParentIdsForQuery(displayParent, user);
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return Array.Empty<Guid>();
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Handle grouping
|
2022-12-05 15:01:13 +01:00
|
|
|
if (user is not null && !string.IsNullOrEmpty(view.ViewType) && UserView.IsEligibleForGrouping(view.ViewType)
|
2020-05-13 04:10:35 +02:00
|
|
|
&& user.GetPreference(PreferenceKind.GroupedFolders).Length > 0)
|
2015-11-18 06:49:20 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetUserRootFolder()
|
2016-05-18 07:34:10 +02:00
|
|
|
.GetChildren(user, true)
|
|
|
|
.OfType<CollectionFolder>()
|
2018-09-12 19:26:21 +02:00
|
|
|
.Where(i => string.IsNullOrEmpty(i.CollectionType) || string.Equals(i.CollectionType, view.ViewType, StringComparison.OrdinalIgnoreCase))
|
2016-05-18 19:02:56 +02:00
|
|
|
.Where(i => user.IsFolderGrouped(i.Id))
|
2016-12-13 08:36:30 +01:00
|
|
|
.SelectMany(i => GetTopParentIdsForQuery(i, user));
|
2015-11-18 06:49:20 +01:00
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return Array.Empty<Guid>();
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
if (item is CollectionFolder collectionFolder)
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2016-12-13 08:36:30 +01:00
|
|
|
return collectionFolder.PhysicalFolderIds;
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
2016-12-15 07:41:10 +01:00
|
|
|
|
2015-11-14 19:57:26 +01:00
|
|
|
var topParent = item.GetTopParent();
|
2022-12-05 15:01:13 +01:00
|
|
|
if (topParent is not null)
|
2015-11-14 19:57:26 +01:00
|
|
|
{
|
2016-12-13 08:36:30 +01:00
|
|
|
return new[] { topParent.Id };
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return Array.Empty<Guid>();
|
2015-11-14 19:57:26 +01:00
|
|
|
}
|
|
|
|
|
2013-03-02 03:44:46 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the intros.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
/// <returns>IEnumerable{System.String}.</returns>
|
2020-05-20 19:07:53 +02:00
|
|
|
public async Task<IEnumerable<Video>> GetIntros(BaseItem item, User user)
|
2013-03-02 03:44:46 +01:00
|
|
|
{
|
2014-09-22 23:56:54 +02:00
|
|
|
var tasks = IntroProviders
|
|
|
|
.Take(1)
|
|
|
|
.Select(i => GetIntros(i, item, user));
|
|
|
|
|
|
|
|
var items = await Task.WhenAll(tasks).ConfigureAwait(false);
|
|
|
|
|
|
|
|
return items
|
|
|
|
.SelectMany(i => i.ToArray())
|
2013-10-04 19:04:18 +02:00
|
|
|
.Select(ResolveIntro)
|
2022-12-05 15:01:13 +01:00
|
|
|
.Where(i => i is not null);
|
2013-10-04 19:04:18 +02:00
|
|
|
}
|
|
|
|
|
2014-09-22 23:56:54 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the intros.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="provider">The provider.</param>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
/// <returns>Task<IEnumerable<IntroInfo>>.</returns>
|
2020-05-20 19:07:53 +02:00
|
|
|
private async Task<IEnumerable<IntroInfo>> GetIntros(IIntroProvider provider, BaseItem item, User user)
|
2014-09-22 23:56:54 +02:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
return await provider.GetIntros(item, user).ConfigureAwait(false);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error getting intros");
|
2014-09-22 23:56:54 +02:00
|
|
|
|
|
|
|
return new List<IntroInfo>();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-04 19:04:18 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Resolves the intro.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="info">The info.</param>
|
|
|
|
/// <returns>Video.</returns>
|
|
|
|
private Video ResolveIntro(IntroInfo info)
|
|
|
|
{
|
|
|
|
Video video = null;
|
2013-10-13 19:52:57 +02:00
|
|
|
|
2013-10-04 19:04:18 +02:00
|
|
|
if (info.ItemId.HasValue)
|
|
|
|
{
|
|
|
|
// Get an existing item by Id
|
|
|
|
video = GetItemById(info.ItemId.Value) as Video;
|
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (video is null)
|
2013-10-04 19:04:18 +02:00
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError("Unable to locate item with Id {ID}.", info.ItemId.Value);
|
2013-10-04 19:04:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!string.IsNullOrEmpty(info.Path))
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2019-01-08 00:27:46 +01:00
|
|
|
// Try to resolve the path into a video
|
2013-10-30 15:40:14 +01:00
|
|
|
video = ResolvePath(_fileSystem.GetFileSystemInfo(info.Path)) as Video;
|
2013-10-04 19:04:18 +02:00
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (video is null)
|
2013-10-04 19:04:18 +02:00
|
|
|
{
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogError("Intro resolver returned null for {Path}.", info.Path);
|
2013-10-04 19:04:18 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Pull the saved db item that will include metadata
|
|
|
|
var dbItem = GetItemById(video.Id) as Video;
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (dbItem is not null)
|
2013-10-04 19:04:18 +02:00
|
|
|
{
|
|
|
|
video = dbItem;
|
|
|
|
}
|
2016-02-05 06:59:22 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
2013-10-04 19:04:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogError(ex, "Error resolving path {Path}.", info.Path);
|
2013-10-04 19:04:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogError("IntroProvider returned an IntroInfo with null Path and ItemId.");
|
2013-10-04 19:04:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return video;
|
2013-02-28 20:32:41 +01:00
|
|
|
}
|
2013-03-10 05:22:36 +01:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Sorts the specified sort by.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="items">The items.</param>
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
/// <param name="sortBy">The sort by.</param>
|
|
|
|
/// <param name="sortOrder">The sort order.</param>
|
|
|
|
/// <returns>IEnumerable{BaseItem}.</returns>
|
2020-05-20 19:07:53 +02:00
|
|
|
public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User user, IEnumerable<string> sortBy, SortOrder sortOrder)
|
2013-03-10 05:22:36 +01:00
|
|
|
{
|
|
|
|
var isFirst = true;
|
|
|
|
|
|
|
|
IOrderedEnumerable<BaseItem> orderedItems = null;
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
foreach (var orderBy in sortBy.Select(o => GetComparer(o, user)).Where(c => c is not null))
|
2013-03-10 05:22:36 +01:00
|
|
|
{
|
|
|
|
if (isFirst)
|
|
|
|
{
|
|
|
|
orderedItems = sortOrder == SortOrder.Descending ? items.OrderByDescending(i => i, orderBy) : items.OrderBy(i => i, orderBy);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
orderedItems = sortOrder == SortOrder.Descending ? orderedItems.ThenByDescending(i => i, orderBy) : orderedItems.ThenBy(i => i, orderBy);
|
|
|
|
}
|
|
|
|
|
|
|
|
isFirst = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return orderedItems ?? items;
|
|
|
|
}
|
|
|
|
|
2021-12-24 22:18:24 +01:00
|
|
|
public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User user, IEnumerable<(string OrderBy, SortOrder SortOrder)> orderBy)
|
2017-09-04 21:28:22 +02:00
|
|
|
{
|
|
|
|
var isFirst = true;
|
|
|
|
|
|
|
|
IOrderedEnumerable<BaseItem> orderedItems = null;
|
|
|
|
|
2021-09-03 18:46:34 +02:00
|
|
|
foreach (var (name, sortOrder) in orderBy)
|
2017-09-04 21:28:22 +02:00
|
|
|
{
|
2021-09-03 18:46:34 +02:00
|
|
|
var comparer = GetComparer(name, user);
|
2022-12-05 15:00:20 +01:00
|
|
|
if (comparer is null)
|
2017-09-04 21:28:22 +02:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isFirst)
|
|
|
|
{
|
|
|
|
orderedItems = sortOrder == SortOrder.Descending ? items.OrderByDescending(i => i, comparer) : items.OrderBy(i => i, comparer);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
orderedItems = sortOrder == SortOrder.Descending ? orderedItems.ThenByDescending(i => i, comparer) : orderedItems.ThenBy(i => i, comparer);
|
|
|
|
}
|
|
|
|
|
|
|
|
isFirst = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return orderedItems ?? items;
|
|
|
|
}
|
|
|
|
|
2013-03-10 05:22:36 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the comparer.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
/// <returns>IBaseItemComparer.</returns>
|
2020-05-20 19:07:53 +02:00
|
|
|
private IBaseItemComparer GetComparer(string name, User user)
|
2013-03-10 05:22:36 +01:00
|
|
|
{
|
|
|
|
var comparer = Comparers.FirstOrDefault(c => string.Equals(name, c.Name, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
// If it requires a user, create a new one, and assign the user
|
|
|
|
if (comparer is IUserBaseItemComparer)
|
2013-03-10 05:22:36 +01:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
var userComparer = (IUserBaseItemComparer)Activator.CreateInstance(comparer.GetType());
|
2013-03-10 05:22:36 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
userComparer.User = user;
|
|
|
|
userComparer.UserManager = _userManager;
|
|
|
|
userComparer.UserDataRepository = _userDataRepository;
|
2013-03-10 05:22:36 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
return userComparer;
|
2013-03-10 05:22:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return comparer;
|
|
|
|
}
|
2013-04-08 17:55:53 +02:00
|
|
|
|
2013-05-03 06:10:11 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Creates the item.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The item.</param>
|
2019-01-06 21:50:43 +01:00
|
|
|
/// <param name="parent">The parent item.</param>
|
2018-09-12 19:26:21 +02:00
|
|
|
public void CreateItem(BaseItem item, BaseItem parent)
|
2013-05-03 06:10:11 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
CreateItems(new[] { item }, parent, CancellationToken.None);
|
2013-05-23 17:39:48 +02:00
|
|
|
}
|
2013-05-03 06:10:11 +02:00
|
|
|
|
2013-05-23 17:39:48 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Creates the items.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="items">The items.</param>
|
2020-06-19 12:21:49 +02:00
|
|
|
/// <param name="parent">The parent item.</param>
|
2013-05-23 17:39:48 +02:00
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
2020-09-09 13:38:27 +02:00
|
|
|
public void CreateItems(IReadOnlyList<BaseItem> items, BaseItem parent, CancellationToken cancellationToken)
|
2013-05-23 17:39:48 +02:00
|
|
|
{
|
2020-09-09 13:38:27 +02:00
|
|
|
_itemRepository.SaveItems(items, cancellationToken);
|
2013-05-23 17:39:48 +02:00
|
|
|
|
2020-09-09 13:38:27 +02:00
|
|
|
foreach (var item in items)
|
2013-05-23 17:39:48 +02:00
|
|
|
{
|
2016-10-09 09:18:43 +02:00
|
|
|
RegisterItem(item);
|
2013-05-23 17:39:48 +02:00
|
|
|
}
|
2013-05-22 05:42:25 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (ItemAdded is not null)
|
2013-05-03 06:10:11 +02:00
|
|
|
{
|
2020-09-09 13:38:27 +02:00
|
|
|
foreach (var item in items)
|
2013-05-03 19:26:44 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
// With the live tv guide this just creates too much noise
|
|
|
|
if (item.SourceType != SourceType.Library)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-05-23 17:39:48 +02:00
|
|
|
try
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
ItemAdded(
|
|
|
|
this,
|
|
|
|
new ItemChangeEventArgs
|
|
|
|
{
|
|
|
|
Item = item,
|
|
|
|
Parent = parent ?? item.GetParent()
|
|
|
|
});
|
2013-05-23 17:39:48 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error in ItemAdded event handler");
|
2013-05-23 17:39:48 +02:00
|
|
|
}
|
2013-05-03 19:26:44 +02:00
|
|
|
}
|
2013-05-03 06:10:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-27 16:00:59 +02:00
|
|
|
private bool ImageNeedsRefresh(ItemImageInfo image)
|
2017-10-22 08:22:43 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (image.Path is not null && image.IsLocalFile)
|
2020-05-27 16:00:59 +02:00
|
|
|
{
|
|
|
|
if (image.Width == 0 || image.Height == 0 || string.IsNullOrEmpty(image.BlurHash))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2017-10-22 08:22:43 +02:00
|
|
|
|
2020-05-27 16:00:59 +02:00
|
|
|
try
|
|
|
|
{
|
|
|
|
return _fileSystem.GetLastWriteTimeUtc(image.Path) != image.DateModified;
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
_logger.LogError(ex, "Cannot get file info for {0}", image.Path);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
return image.Path is not null && !image.IsLocalFile;
|
2020-05-27 16:00:59 +02:00
|
|
|
}
|
|
|
|
|
2020-08-21 22:01:19 +02:00
|
|
|
/// <inheritdoc />
|
|
|
|
public async Task UpdateImagesAsync(BaseItem item, bool forceUpdate = false)
|
2017-10-22 08:22:43 +02:00
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(item);
|
2020-05-19 13:50:14 +02:00
|
|
|
|
2022-06-16 15:14:56 +02:00
|
|
|
var outdated = forceUpdate
|
2022-12-05 15:01:13 +01:00
|
|
|
? item.ImageInfos.Where(i => i.Path is not null).ToArray()
|
2022-06-16 15:14:56 +02:00
|
|
|
: item.ImageInfos.Where(ImageNeedsRefresh).ToArray();
|
2020-07-22 17:32:29 +02:00
|
|
|
// Skip image processing if current or live tv source
|
|
|
|
if (outdated.Length == 0 || item.SourceType != SourceType.Library)
|
2020-05-19 13:50:14 +02:00
|
|
|
{
|
2020-05-19 13:56:52 +02:00
|
|
|
RegisterItem(item);
|
2020-05-19 13:50:14 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-05-27 16:00:59 +02:00
|
|
|
foreach (var img in outdated)
|
2020-05-19 13:50:14 +02:00
|
|
|
{
|
2020-05-28 16:55:29 +02:00
|
|
|
var image = img;
|
|
|
|
if (!img.IsLocalFile)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
var index = item.GetImageIndex(img);
|
2020-08-21 22:01:19 +02:00
|
|
|
image = await ConvertImageToLocal(item, img, index).ConfigureAwait(false);
|
2020-05-28 16:55:29 +02:00
|
|
|
}
|
|
|
|
catch (ArgumentException)
|
|
|
|
{
|
2021-04-09 12:03:56 +02:00
|
|
|
_logger.LogWarning("Cannot get image index for {ImagePath}", img.Path);
|
2020-05-28 16:55:29 +02:00
|
|
|
continue;
|
|
|
|
}
|
2022-06-16 15:14:56 +02:00
|
|
|
catch (Exception ex) when (ex is InvalidOperationException or IOException)
|
2020-05-28 16:55:29 +02:00
|
|
|
{
|
2021-04-09 23:30:07 +02:00
|
|
|
_logger.LogWarning(ex, "Cannot fetch image from {ImagePath}", img.Path);
|
2021-04-09 12:03:56 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
catch (HttpRequestException ex)
|
|
|
|
{
|
2021-04-09 23:30:07 +02:00
|
|
|
_logger.LogWarning(ex, "Cannot fetch image from {ImagePath}. Http status code: {HttpStatus}", img.Path, ex.StatusCode);
|
2020-05-28 16:55:29 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-16 15:14:56 +02:00
|
|
|
ImageDimensions size;
|
2020-06-25 20:10:33 +02:00
|
|
|
try
|
|
|
|
{
|
2022-06-16 15:14:56 +02:00
|
|
|
size = _imageProcessor.GetImageDimensions(item, image);
|
2020-06-25 20:10:33 +02:00
|
|
|
image.Width = size.Width;
|
|
|
|
image.Height = size.Height;
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-04-09 12:03:56 +02:00
|
|
|
_logger.LogError(ex, "Cannot get image dimensions for {ImagePath}", image.Path);
|
2022-06-16 15:14:56 +02:00
|
|
|
size = new ImageDimensions(0, 0);
|
2020-06-25 20:10:33 +02:00
|
|
|
image.Width = 0;
|
|
|
|
image.Height = 0;
|
|
|
|
}
|
2020-06-01 17:12:49 +02:00
|
|
|
|
2020-05-27 14:01:03 +02:00
|
|
|
try
|
|
|
|
{
|
2022-06-16 15:14:56 +02:00
|
|
|
image.BlurHash = _imageProcessor.GetImageBlurHash(image.Path, size);
|
2020-05-27 14:01:03 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-04-09 12:03:56 +02:00
|
|
|
_logger.LogError(ex, "Cannot compute blurhash for {ImagePath}", image.Path);
|
2020-05-28 16:55:29 +02:00
|
|
|
image.BlurHash = string.Empty;
|
2020-05-27 14:01:03 +02:00
|
|
|
}
|
2020-03-23 20:05:49 +01:00
|
|
|
|
2020-05-27 16:00:59 +02:00
|
|
|
try
|
|
|
|
{
|
2020-05-28 16:55:29 +02:00
|
|
|
image.DateModified = _fileSystem.GetLastWriteTimeUtc(image.Path);
|
2020-05-27 16:00:59 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2021-04-09 12:03:56 +02:00
|
|
|
_logger.LogError(ex, "Cannot update DateModified for {ImagePath}", image.Path);
|
2020-05-27 16:00:59 +02:00
|
|
|
}
|
|
|
|
}
|
2017-10-22 08:22:43 +02:00
|
|
|
|
2020-05-27 16:00:59 +02:00
|
|
|
_itemRepository.SaveImages(item);
|
2017-10-22 08:22:43 +02:00
|
|
|
RegisterItem(item);
|
|
|
|
}
|
|
|
|
|
2020-08-21 22:01:19 +02:00
|
|
|
/// <inheritdoc />
|
2020-12-10 13:38:33 +01:00
|
|
|
public async Task UpdateItemsAsync(IReadOnlyList<BaseItem> items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken)
|
2013-05-03 06:10:11 +02:00
|
|
|
{
|
2020-12-10 14:47:47 +01:00
|
|
|
foreach (var item in items)
|
|
|
|
{
|
|
|
|
await RunMetadataSavers(item, updateReason).ConfigureAwait(false);
|
|
|
|
}
|
2014-02-06 05:39:16 +01:00
|
|
|
|
2020-07-20 11:01:37 +02:00
|
|
|
_itemRepository.SaveItems(items, cancellationToken);
|
2013-09-25 21:59:02 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (ItemUpdated is not null)
|
2013-06-25 03:22:21 +02:00
|
|
|
{
|
2020-07-20 11:01:37 +02:00
|
|
|
foreach (var item in items)
|
2013-06-25 03:22:21 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
// With the live tv guide this just creates too much noise
|
|
|
|
if (item.SourceType != SourceType.Library)
|
2013-11-13 17:45:41 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
ItemUpdated(
|
|
|
|
this,
|
|
|
|
new ItemChangeEventArgs
|
|
|
|
{
|
|
|
|
Item = item,
|
|
|
|
Parent = parent,
|
|
|
|
UpdateReason = updateReason
|
|
|
|
});
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error in ItemUpdated event handler");
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2013-06-25 03:22:21 +02:00
|
|
|
}
|
|
|
|
}
|
2013-05-24 17:01:53 +02:00
|
|
|
}
|
|
|
|
|
2020-08-21 22:01:19 +02:00
|
|
|
/// <inheritdoc />
|
|
|
|
public Task UpdateItemAsync(BaseItem item, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken)
|
|
|
|
=> UpdateItemsAsync(new[] { item }, parent, updateReason, cancellationToken);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2022-01-22 23:36:42 +01:00
|
|
|
public async Task RunMetadataSavers(BaseItem item, ItemUpdateType updateReason)
|
2020-10-03 13:36:53 +02:00
|
|
|
{
|
2020-12-10 14:47:47 +01:00
|
|
|
if (item.IsFileProtocol)
|
2020-10-03 13:36:53 +02:00
|
|
|
{
|
2022-01-22 23:36:42 +01:00
|
|
|
await ProviderManager.SaveMetadataAsync(item, updateReason).ConfigureAwait(false);
|
2020-12-10 14:47:47 +01:00
|
|
|
}
|
2020-10-03 13:36:53 +02:00
|
|
|
|
2020-12-10 14:47:47 +01:00
|
|
|
item.DateLastSaved = DateTime.UtcNow;
|
2020-12-10 13:38:33 +01:00
|
|
|
|
2022-01-22 23:36:42 +01:00
|
|
|
await UpdateImagesAsync(item, updateReason >= ItemUpdateType.ImageUpdate).ConfigureAwait(false);
|
2020-10-03 13:36:53 +02:00
|
|
|
}
|
|
|
|
|
2013-05-03 06:10:11 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Reports the item removed.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The item.</param>
|
2019-03-13 22:32:52 +01:00
|
|
|
/// <param name="parent">The parent item.</param>
|
2017-11-26 05:48:12 +01:00
|
|
|
public void ReportItemRemoved(BaseItem item, BaseItem parent)
|
2013-05-03 06:10:11 +02:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
if (ItemRemoved is not null)
|
2013-05-03 06:10:11 +02:00
|
|
|
{
|
2013-05-03 19:26:44 +02:00
|
|
|
try
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
ItemRemoved(
|
|
|
|
this,
|
|
|
|
new ItemChangeEventArgs
|
|
|
|
{
|
|
|
|
Item = item,
|
|
|
|
Parent = parent
|
|
|
|
});
|
2013-05-03 19:26:44 +02:00
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error in ItemRemoved event handler");
|
2013-05-03 19:26:44 +02:00
|
|
|
}
|
2013-05-03 06:10:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-08 17:55:53 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Retrieves the item.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="id">The id.</param>
|
2013-06-17 22:35:43 +02:00
|
|
|
/// <returns>BaseItem.</returns>
|
2013-06-26 18:08:16 +02:00
|
|
|
public BaseItem RetrieveItem(Guid id)
|
2013-04-08 17:55:53 +02:00
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.RetrieveItem(id);
|
2013-11-21 21:48:26 +01:00
|
|
|
}
|
|
|
|
|
2017-01-29 21:00:29 +01:00
|
|
|
public List<Folder> GetCollectionFolders(BaseItem item)
|
2022-05-17 22:58:49 +02:00
|
|
|
{
|
|
|
|
return GetCollectionFolders(item, GetUserRootFolder().Children.OfType<Folder>());
|
|
|
|
}
|
|
|
|
|
|
|
|
public List<Folder> GetCollectionFolders(BaseItem item, IEnumerable<Folder> allUserRootChildren)
|
2015-02-15 04:36:07 +01:00
|
|
|
{
|
2022-12-05 15:01:13 +01:00
|
|
|
while (item is not null)
|
2015-02-15 04:36:07 +01:00
|
|
|
{
|
2017-01-29 21:00:29 +01:00
|
|
|
var parent = item.GetParent();
|
|
|
|
|
2022-05-17 22:58:49 +02:00
|
|
|
if (parent is AggregateFolder)
|
2017-01-29 21:00:29 +01:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-05-17 22:58:49 +02:00
|
|
|
if (parent is null)
|
|
|
|
{
|
|
|
|
var owner = item.GetOwner();
|
2017-05-04 20:14:45 +02:00
|
|
|
|
2022-05-17 22:58:49 +02:00
|
|
|
if (owner is null)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2017-05-04 20:14:45 +02:00
|
|
|
|
2022-05-17 22:58:49 +02:00
|
|
|
item = owner;
|
|
|
|
}
|
|
|
|
else
|
2017-05-04 20:14:45 +02:00
|
|
|
{
|
2022-05-17 22:58:49 +02:00
|
|
|
item = parent;
|
2017-05-04 20:14:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null)
|
2017-05-04 20:14:45 +02:00
|
|
|
{
|
|
|
|
return new List<Folder>();
|
|
|
|
}
|
|
|
|
|
|
|
|
return GetCollectionFoldersInternal(item, allUserRootChildren);
|
|
|
|
}
|
|
|
|
|
2021-05-24 00:30:41 +02:00
|
|
|
private static List<Folder> GetCollectionFoldersInternal(BaseItem item, IEnumerable<Folder> allUserRootChildren)
|
2017-05-04 20:14:45 +02:00
|
|
|
{
|
|
|
|
return allUserRootChildren
|
2021-05-24 00:30:41 +02:00
|
|
|
.Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path.AsSpan(), StringComparison.OrdinalIgnoreCase))
|
2017-01-29 21:00:29 +01:00
|
|
|
.ToList();
|
2015-02-15 04:36:07 +01:00
|
|
|
}
|
|
|
|
|
2016-08-13 07:49:00 +02:00
|
|
|
public LibraryOptions GetLibraryOptions(BaseItem item)
|
|
|
|
{
|
2021-08-29 00:32:50 +02:00
|
|
|
if (item is not CollectionFolder collectionFolder)
|
2016-10-02 06:31:47 +02:00
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
// List.Find is more performant than FirstOrDefault due to enumerator allocation
|
2016-10-02 06:31:47 +02:00
|
|
|
collectionFolder = GetCollectionFolders(item)
|
2021-05-24 00:30:41 +02:00
|
|
|
.Find(folder => folder is CollectionFolder) as CollectionFolder;
|
2016-10-02 06:31:47 +02:00
|
|
|
}
|
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
return collectionFolder is null ? new LibraryOptions() : collectionFolder.GetLibraryOptions();
|
2016-08-13 07:49:00 +02:00
|
|
|
}
|
|
|
|
|
2014-12-21 19:58:17 +01:00
|
|
|
public string GetContentType(BaseItem item)
|
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
string configuredContentType = GetConfiguredContentType(item, false);
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!string.IsNullOrEmpty(configuredContentType))
|
2014-12-22 07:50:29 +01:00
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
return configuredContentType;
|
2014-12-22 07:50:29 +01:00
|
|
|
}
|
2019-02-08 22:59:28 +01:00
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
configuredContentType = GetConfiguredContentType(item, true);
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!string.IsNullOrEmpty(configuredContentType))
|
2015-01-10 02:38:01 +01:00
|
|
|
{
|
|
|
|
return configuredContentType;
|
|
|
|
}
|
2019-02-08 22:59:28 +01:00
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
return GetInheritedContentType(item);
|
2015-01-02 06:36:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public string GetInheritedContentType(BaseItem item)
|
|
|
|
{
|
|
|
|
var type = GetTopFolderContentType(item);
|
2014-12-22 07:50:29 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!string.IsNullOrEmpty(type))
|
2014-12-22 07:50:29 +01:00
|
|
|
{
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
2015-11-13 21:53:29 +01:00
|
|
|
return item.GetParents()
|
2014-12-22 07:50:29 +01:00
|
|
|
.Select(GetConfiguredContentType)
|
2018-09-12 19:26:21 +02:00
|
|
|
.LastOrDefault(i => !string.IsNullOrEmpty(i));
|
2014-12-22 07:50:29 +01:00
|
|
|
}
|
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
public string GetConfiguredContentType(BaseItem item)
|
2014-12-22 07:50:29 +01:00
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
return GetConfiguredContentType(item, false);
|
2014-12-22 07:50:29 +01:00
|
|
|
}
|
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
public string GetConfiguredContentType(string path)
|
2014-12-22 07:50:29 +01:00
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
return GetContentTypeOverride(path, false);
|
|
|
|
}
|
2014-12-22 07:50:29 +01:00
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
public string GetConfiguredContentType(BaseItem item, bool inheritConfiguredPath)
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
if (item is ICollectionFolder collectionFolder)
|
2015-01-10 02:38:01 +01:00
|
|
|
{
|
|
|
|
return collectionFolder.CollectionType;
|
|
|
|
}
|
2019-02-08 22:59:28 +01:00
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
return GetContentTypeOverride(item.ContainingFolderPath, inheritConfiguredPath);
|
2014-12-21 19:58:17 +01:00
|
|
|
}
|
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
private string GetContentTypeOverride(string path, bool inherit)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
var nameValuePair = _configurationManager.Configuration.ContentTypes
|
2019-03-13 22:32:52 +01:00
|
|
|
.FirstOrDefault(i => _fileSystem.AreEqual(i.Name, path)
|
|
|
|
|| (inherit && !string.IsNullOrEmpty(i.Name)
|
|
|
|
&& _fileSystem.ContainsSubPath(i.Name, path)));
|
|
|
|
return nameValuePair?.Value;
|
2015-01-10 02:38:01 +01:00
|
|
|
}
|
2015-02-15 04:36:07 +01:00
|
|
|
|
2014-12-21 19:58:17 +01:00
|
|
|
private string GetTopFolderContentType(BaseItem item)
|
2013-07-12 21:56:40 +02:00
|
|
|
{
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null)
|
2013-07-12 21:56:40 +02:00
|
|
|
{
|
2015-11-14 19:57:26 +01:00
|
|
|
return null;
|
2013-07-12 21:56:40 +02:00
|
|
|
}
|
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
while (!item.ParentId.Equals(default))
|
2013-07-12 21:56:40 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var parent = item.GetParent();
|
2022-12-05 15:00:20 +01:00
|
|
|
if (parent is null || parent is AggregateFolder)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
item = parent;
|
2013-07-12 21:56:40 +02:00
|
|
|
}
|
|
|
|
|
2014-12-21 02:23:56 +01:00
|
|
|
return GetUserRootFolder().Children
|
2014-10-12 03:46:02 +02:00
|
|
|
.OfType<ICollectionFolder>()
|
2014-12-21 02:23:56 +01:00
|
|
|
.Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path))
|
2013-07-12 21:56:40 +02:00
|
|
|
.Select(i => i.CollectionType)
|
2018-09-12 19:26:21 +02:00
|
|
|
.FirstOrDefault(i => !string.IsNullOrEmpty(i));
|
2013-07-12 21:56:40 +02:00
|
|
|
}
|
2013-11-21 21:48:26 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
public UserView GetNamedView(
|
2020-05-20 19:07:53 +02:00
|
|
|
User user,
|
2015-03-14 05:50:23 +01:00
|
|
|
string name,
|
|
|
|
string viewType,
|
2018-09-12 19:26:21 +02:00
|
|
|
string sortName)
|
2014-06-07 21:46:24 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetNamedView(user, name, Guid.Empty, viewType, sortName);
|
2015-08-14 20:00:26 +02:00
|
|
|
}
|
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
public UserView GetNamedView(
|
|
|
|
string name,
|
2015-08-14 20:00:26 +02:00
|
|
|
string viewType,
|
2018-09-12 19:26:21 +02:00
|
|
|
string sortName)
|
2015-08-14 20:00:26 +02:00
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
var path = Path.Combine(
|
2020-04-05 00:28:46 +02:00
|
|
|
_configurationManager.ApplicationPaths.InternalMetadataPath,
|
2019-03-13 22:32:52 +01:00
|
|
|
"views",
|
|
|
|
_fileSystem.GetValidFilename(viewType));
|
2014-06-07 21:46:24 +02:00
|
|
|
|
2014-11-30 20:01:33 +01:00
|
|
|
var id = GetNewItemId(path + "_namedview_" + name, typeof(UserView));
|
2014-07-26 19:30:15 +02:00
|
|
|
|
|
|
|
var item = GetItemById(id) as UserView;
|
2014-09-05 05:48:53 +02:00
|
|
|
|
2014-10-29 23:01:02 +01:00
|
|
|
var refresh = false;
|
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null || !string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
|
2014-06-07 21:46:24 +02:00
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(path);
|
2014-06-07 21:46:24 +02:00
|
|
|
|
|
|
|
item = new UserView
|
|
|
|
{
|
|
|
|
Path = path,
|
2014-07-26 19:30:15 +02:00
|
|
|
Id = id,
|
2014-06-07 21:46:24 +02:00
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
Name = name,
|
2015-03-14 05:50:23 +01:00
|
|
|
ViewType = viewType,
|
2014-06-07 21:46:24 +02:00
|
|
|
ForcedSortName = sortName
|
|
|
|
};
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
CreateItem(item, null);
|
2014-06-07 21:46:24 +02:00
|
|
|
|
2014-10-29 23:01:02 +01:00
|
|
|
refresh = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (refresh)
|
|
|
|
{
|
2020-08-21 22:01:19 +02:00
|
|
|
item.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, CancellationToken.None).GetAwaiter().GetResult();
|
2020-04-05 00:28:46 +02:00
|
|
|
ProviderManager.QueueRefresh(item.Id, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), RefreshPriority.Normal);
|
2014-10-29 23:01:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
public UserView GetNamedView(
|
2020-05-20 19:07:53 +02:00
|
|
|
User user,
|
2015-03-14 05:50:23 +01:00
|
|
|
string name,
|
2018-09-12 19:26:21 +02:00
|
|
|
Guid parentId,
|
2015-03-14 05:50:23 +01:00
|
|
|
string viewType,
|
2018-09-12 19:26:21 +02:00
|
|
|
string sortName)
|
2015-03-14 05:50:23 +01:00
|
|
|
{
|
2022-02-21 14:15:09 +01:00
|
|
|
var parentIdString = parentId.Equals(default)
|
|
|
|
? null
|
|
|
|
: parentId.ToString("N", CultureInfo.InvariantCulture);
|
2019-02-28 23:22:57 +01:00
|
|
|
var idValues = "38_namedview_" + name + user.Id.ToString("N", CultureInfo.InvariantCulture) + (parentIdString ?? string.Empty) + (viewType ?? string.Empty);
|
2015-04-20 20:04:02 +02:00
|
|
|
|
|
|
|
var id = GetNewItemId(idValues, typeof(UserView));
|
2014-10-29 23:01:02 +01:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var path = Path.Combine(_configurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N", CultureInfo.InvariantCulture));
|
2014-10-29 23:01:02 +01:00
|
|
|
|
|
|
|
var item = GetItemById(id) as UserView;
|
|
|
|
|
2015-03-14 18:02:51 +01:00
|
|
|
var isNew = false;
|
2014-10-29 23:01:02 +01:00
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null)
|
2014-10-29 23:01:02 +01:00
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(path);
|
2014-10-29 23:01:02 +01:00
|
|
|
|
|
|
|
item = new UserView
|
|
|
|
{
|
|
|
|
Path = path,
|
|
|
|
Id = id,
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
Name = name,
|
|
|
|
ViewType = viewType,
|
2015-09-15 20:09:44 +02:00
|
|
|
ForcedSortName = sortName,
|
2019-03-13 22:32:52 +01:00
|
|
|
UserId = user.Id,
|
|
|
|
DisplayParentId = parentId
|
2014-10-29 23:01:02 +01:00
|
|
|
};
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
CreateItem(item, null);
|
2015-08-14 20:00:26 +02:00
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
}
|
|
|
|
|
2016-03-27 23:11:27 +02:00
|
|
|
var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
|
2015-08-14 20:00:26 +02:00
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
if (!refresh && !item.DisplayParentId.Equals(default))
|
2015-10-18 03:18:29 +02:00
|
|
|
{
|
|
|
|
var displayParent = GetItemById(item.DisplayParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
refresh = displayParent is not null && displayParent.DateLastSaved > item.DateLastRefreshed;
|
2015-10-18 03:18:29 +02:00
|
|
|
}
|
|
|
|
|
2015-08-14 20:00:26 +02:00
|
|
|
if (refresh)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
ProviderManager.QueueRefresh(
|
2019-03-13 22:32:52 +01:00
|
|
|
item.Id,
|
2019-09-10 22:37:53 +02:00
|
|
|
new MetadataRefreshOptions(new DirectoryService(_fileSystem))
|
2019-03-13 22:32:52 +01:00
|
|
|
{
|
|
|
|
// Need to force save to increment DateLastSaved
|
|
|
|
ForceSave = true
|
|
|
|
},
|
|
|
|
RefreshPriority.Normal);
|
2015-08-14 20:00:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
public UserView GetShadowView(
|
|
|
|
BaseItem parent,
|
|
|
|
string viewType,
|
|
|
|
string sortName)
|
2015-10-16 06:46:41 +02:00
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(parent);
|
2015-10-16 06:46:41 +02:00
|
|
|
|
|
|
|
var name = parent.Name;
|
|
|
|
var parentId = parent.Id;
|
|
|
|
|
2015-11-18 06:49:20 +01:00
|
|
|
var idValues = "38_namedview_" + name + parentId + (viewType ?? string.Empty);
|
2015-10-16 06:46:41 +02:00
|
|
|
|
|
|
|
var id = GetNewItemId(idValues, typeof(UserView));
|
|
|
|
|
|
|
|
var path = parent.Path;
|
|
|
|
|
|
|
|
var item = GetItemById(id) as UserView;
|
|
|
|
|
|
|
|
var isNew = false;
|
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null)
|
2015-10-16 06:46:41 +02:00
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(path);
|
2015-10-16 06:46:41 +02:00
|
|
|
|
|
|
|
item = new UserView
|
|
|
|
{
|
|
|
|
Path = path,
|
|
|
|
Id = id,
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
Name = name,
|
|
|
|
ViewType = viewType,
|
|
|
|
ForcedSortName = sortName
|
|
|
|
};
|
|
|
|
|
|
|
|
item.DisplayParentId = parentId;
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
CreateItem(item, null);
|
2015-10-16 06:46:41 +02:00
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
}
|
|
|
|
|
2016-03-27 23:11:27 +02:00
|
|
|
var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
|
2015-10-16 06:46:41 +02:00
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
if (!refresh && !item.DisplayParentId.Equals(default))
|
2015-10-18 03:18:29 +02:00
|
|
|
{
|
|
|
|
var displayParent = GetItemById(item.DisplayParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
refresh = displayParent is not null && displayParent.DateLastSaved > item.DateLastRefreshed;
|
2015-10-18 03:18:29 +02:00
|
|
|
}
|
|
|
|
|
2015-10-16 06:46:41 +02:00
|
|
|
if (refresh)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
ProviderManager.QueueRefresh(
|
2019-03-13 22:32:52 +01:00
|
|
|
item.Id,
|
2019-09-10 22:37:53 +02:00
|
|
|
new MetadataRefreshOptions(new DirectoryService(_fileSystem))
|
2019-03-13 22:32:52 +01:00
|
|
|
{
|
|
|
|
// Need to force save to increment DateLastSaved
|
|
|
|
ForceSave = true
|
|
|
|
},
|
|
|
|
RefreshPriority.Normal);
|
2015-10-16 06:46:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
|
|
|
}
|
2015-11-13 21:53:29 +01:00
|
|
|
|
2019-03-13 22:32:52 +01:00
|
|
|
public UserView GetNamedView(
|
|
|
|
string name,
|
2018-09-12 19:26:21 +02:00
|
|
|
Guid parentId,
|
2015-08-14 20:00:26 +02:00
|
|
|
string viewType,
|
|
|
|
string sortName,
|
2018-09-12 19:26:21 +02:00
|
|
|
string uniqueId)
|
2015-08-14 20:00:26 +02:00
|
|
|
{
|
2022-10-13 19:08:00 +02:00
|
|
|
ArgumentException.ThrowIfNullOrEmpty(name);
|
2015-08-14 20:00:26 +02:00
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
var parentIdString = parentId.Equals(default)
|
|
|
|
? null
|
|
|
|
: parentId.ToString("N", CultureInfo.InvariantCulture);
|
2018-09-12 19:26:21 +02:00
|
|
|
var idValues = "37_namedview_" + name + (parentIdString ?? string.Empty) + (viewType ?? string.Empty);
|
|
|
|
if (!string.IsNullOrEmpty(uniqueId))
|
2015-08-14 20:00:26 +02:00
|
|
|
{
|
|
|
|
idValues += uniqueId;
|
|
|
|
}
|
|
|
|
|
|
|
|
var id = GetNewItemId(idValues, typeof(UserView));
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var path = Path.Combine(_configurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N", CultureInfo.InvariantCulture));
|
2015-08-14 20:00:26 +02:00
|
|
|
|
|
|
|
var item = GetItemById(id) as UserView;
|
|
|
|
|
|
|
|
var isNew = false;
|
|
|
|
|
2022-12-05 15:00:20 +01:00
|
|
|
if (item is null)
|
2015-08-14 20:00:26 +02:00
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(path);
|
2015-08-14 20:00:26 +02:00
|
|
|
|
|
|
|
item = new UserView
|
|
|
|
{
|
|
|
|
Path = path,
|
|
|
|
Id = id,
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
Name = name,
|
|
|
|
ViewType = viewType,
|
|
|
|
ForcedSortName = sortName
|
|
|
|
};
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
item.DisplayParentId = parentId;
|
2015-03-14 05:50:23 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
CreateItem(item, null);
|
2014-10-29 23:01:02 +01:00
|
|
|
|
2015-03-14 18:02:51 +01:00
|
|
|
isNew = true;
|
2014-10-29 23:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-04-15 23:59:20 +02:00
|
|
|
if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
|
|
|
|
{
|
|
|
|
item.ViewType = viewType;
|
2020-08-21 22:01:19 +02:00
|
|
|
item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
|
2015-04-15 23:59:20 +02:00
|
|
|
}
|
|
|
|
|
2016-03-27 23:11:27 +02:00
|
|
|
var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
|
2014-10-29 23:01:02 +01:00
|
|
|
|
2022-02-21 14:15:09 +01:00
|
|
|
if (!refresh && !item.DisplayParentId.Equals(default))
|
2015-10-18 03:18:29 +02:00
|
|
|
{
|
|
|
|
var displayParent = GetItemById(item.DisplayParentId);
|
2022-12-05 15:01:13 +01:00
|
|
|
refresh = displayParent is not null && displayParent.DateLastSaved > item.DateLastRefreshed;
|
2015-10-18 03:18:29 +02:00
|
|
|
}
|
|
|
|
|
2014-10-29 23:01:02 +01:00
|
|
|
if (refresh)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
ProviderManager.QueueRefresh(
|
2019-03-13 22:32:52 +01:00
|
|
|
item.Id,
|
2019-09-10 22:37:53 +02:00
|
|
|
new MetadataRefreshOptions(new DirectoryService(_fileSystem))
|
2019-03-13 22:32:52 +01:00
|
|
|
{
|
|
|
|
// Need to force save to increment DateLastSaved
|
|
|
|
ForceSave = true
|
|
|
|
},
|
|
|
|
RefreshPriority.Normal);
|
2014-06-07 21:46:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return item;
|
|
|
|
}
|
2014-11-16 21:44:08 +01:00
|
|
|
|
2020-12-01 19:07:41 +01:00
|
|
|
public BaseItem GetParentItem(Guid? parentId, Guid? userId)
|
|
|
|
{
|
|
|
|
if (parentId.HasValue)
|
|
|
|
{
|
|
|
|
return GetItemById(parentId.Value);
|
|
|
|
}
|
|
|
|
|
2022-02-17 08:15:26 +01:00
|
|
|
if (userId.HasValue && !userId.Equals(default))
|
2020-12-01 19:07:41 +01:00
|
|
|
{
|
|
|
|
return GetUserRootFolder();
|
|
|
|
}
|
|
|
|
|
|
|
|
return RootFolder;
|
|
|
|
}
|
2020-11-05 12:27:22 +01:00
|
|
|
|
2022-08-01 20:25:44 +02:00
|
|
|
/// <inheritdoc />
|
|
|
|
public void QueueLibraryScan()
|
|
|
|
{
|
|
|
|
_taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
|
|
|
|
}
|
|
|
|
|
2020-02-19 21:56:35 +01:00
|
|
|
/// <inheritdoc />
|
2014-11-16 21:44:08 +01:00
|
|
|
public int? GetSeasonNumberFromPath(string path)
|
2020-02-19 21:56:35 +01:00
|
|
|
=> SeasonPathParser.Parse(path, true, true).SeasonNumber;
|
2014-11-16 21:44:08 +01:00
|
|
|
|
2020-02-19 21:56:35 +01:00
|
|
|
/// <inheritdoc />
|
2018-09-12 19:26:21 +02:00
|
|
|
public bool FillMissingEpisodeNumbersFromPath(Episode episode, bool forceRefresh)
|
2014-11-16 21:44:08 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var series = episode.Series;
|
2022-12-05 15:01:13 +01:00
|
|
|
bool? isAbsoluteNaming = series is not null && string.Equals(series.DisplayOrder, "absolute", StringComparison.OrdinalIgnoreCase);
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!isAbsoluteNaming.Value)
|
|
|
|
{
|
|
|
|
// In other words, no filter applied
|
|
|
|
isAbsoluteNaming = null;
|
|
|
|
}
|
|
|
|
|
2021-11-15 15:56:02 +01:00
|
|
|
var resolver = new EpisodeResolver(_namingOptions);
|
2014-11-16 21:44:08 +01:00
|
|
|
|
2017-08-07 22:36:41 +02:00
|
|
|
var isFolder = episode.VideoType == VideoType.BluRay || episode.VideoType == VideoType.Dvd;
|
2014-12-23 04:58:14 +01:00
|
|
|
|
2020-11-01 10:47:31 +01:00
|
|
|
// TODO nullable - what are we trying to do there with empty episodeInfo?
|
2021-04-09 13:20:12 +02:00
|
|
|
EpisodeInfo episodeInfo = null;
|
|
|
|
if (episode.IsFileProtocol)
|
|
|
|
{
|
2021-04-09 13:43:40 +02:00
|
|
|
episodeInfo = resolver.Resolve(episode.Path, isFolder, null, null, isAbsoluteNaming);
|
2021-04-09 13:20:12 +02:00
|
|
|
// Resolve from parent folder if it's not the Season folder
|
2021-07-11 22:32:06 +02:00
|
|
|
var parent = episode.GetParent();
|
2022-12-05 15:00:20 +01:00
|
|
|
if (episodeInfo is null && parent.GetType() == typeof(Folder))
|
2021-04-09 13:43:40 +02:00
|
|
|
{
|
2021-07-11 22:32:06 +02:00
|
|
|
episodeInfo = resolver.Resolve(parent.Path, true, null, null, isAbsoluteNaming);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (episodeInfo is not null)
|
2021-04-09 13:43:40 +02:00
|
|
|
{
|
|
|
|
// add the container
|
|
|
|
episodeInfo.Container = Path.GetExtension(episode.Path)?.TrimStart('.');
|
|
|
|
}
|
2021-04-09 13:20:12 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
episodeInfo ??= new EpisodeInfo(episode.Path);
|
2014-12-19 05:20:07 +01:00
|
|
|
|
2020-02-19 08:39:01 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
var libraryOptions = GetLibraryOptions(episode);
|
2020-02-19 13:37:36 +01:00
|
|
|
if (libraryOptions.EnableEmbeddedEpisodeInfos && string.Equals(episodeInfo.Container, "mp4", StringComparison.OrdinalIgnoreCase))
|
|
|
|
{
|
2020-02-19 08:39:01 +01:00
|
|
|
// Read from metadata
|
2020-07-20 11:01:37 +02:00
|
|
|
var mediaInfo = _mediaEncoder.GetMediaInfo(
|
|
|
|
new MediaInfoRequest
|
|
|
|
{
|
|
|
|
MediaSource = episode.GetMediaSources(false)[0],
|
|
|
|
MediaType = DlnaProfileType.Video
|
|
|
|
},
|
|
|
|
CancellationToken.None).GetAwaiter().GetResult();
|
2020-02-19 19:41:10 +01:00
|
|
|
if (mediaInfo.ParentIndexNumber > 0)
|
|
|
|
{
|
2020-02-19 16:06:30 +01:00
|
|
|
episodeInfo.SeasonNumber = mediaInfo.ParentIndexNumber;
|
|
|
|
}
|
2020-02-19 13:39:51 +01:00
|
|
|
|
2020-02-19 19:41:10 +01:00
|
|
|
if (mediaInfo.IndexNumber > 0)
|
|
|
|
{
|
2020-02-19 16:06:30 +01:00
|
|
|
episodeInfo.EpisodeNumber = mediaInfo.IndexNumber;
|
|
|
|
}
|
2020-02-19 13:40:06 +01:00
|
|
|
|
2020-02-19 19:41:10 +01:00
|
|
|
if (!string.IsNullOrEmpty(mediaInfo.ShowName))
|
|
|
|
{
|
2020-02-19 16:06:30 +01:00
|
|
|
episodeInfo.SeriesName = mediaInfo.ShowName;
|
2020-02-19 08:39:01 +01:00
|
|
|
}
|
2020-02-17 14:56:31 +01:00
|
|
|
}
|
|
|
|
}
|
2020-02-19 08:39:01 +01:00
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2022-08-15 12:48:34 +02:00
|
|
|
_logger.LogError(ex, "Error reading the episode information with ffprobe. Episode: {EpisodeInfo}", episodeInfo.Path);
|
2020-02-19 08:39:01 +01:00
|
|
|
}
|
2020-02-17 14:56:31 +01:00
|
|
|
|
2014-12-19 05:20:07 +01:00
|
|
|
var changed = false;
|
|
|
|
|
2014-12-23 04:58:14 +01:00
|
|
|
if (episodeInfo.IsByDate)
|
2014-12-19 05:20:07 +01:00
|
|
|
{
|
|
|
|
if (episode.IndexNumber.HasValue)
|
|
|
|
{
|
2014-12-23 04:58:14 +01:00
|
|
|
episode.IndexNumber = null;
|
2014-12-19 05:20:07 +01:00
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (episode.IndexNumberEnd.HasValue)
|
|
|
|
{
|
2014-12-23 04:58:14 +01:00
|
|
|
episode.IndexNumberEnd = null;
|
2014-12-19 05:20:07 +01:00
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
|
2014-12-23 04:58:14 +01:00
|
|
|
if (!episode.PremiereDate.HasValue)
|
|
|
|
{
|
|
|
|
if (episodeInfo.Year.HasValue && episodeInfo.Month.HasValue && episodeInfo.Day.HasValue)
|
|
|
|
{
|
|
|
|
episode.PremiereDate = new DateTime(episodeInfo.Year.Value, episodeInfo.Month.Value, episodeInfo.Day.Value).ToUniversalTime();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (episode.PremiereDate.HasValue)
|
|
|
|
{
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!episode.ProductionYear.HasValue)
|
|
|
|
{
|
|
|
|
episode.ProductionYear = episodeInfo.Year;
|
|
|
|
|
|
|
|
if (episode.ProductionYear.HasValue)
|
|
|
|
{
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!episode.IndexNumber.HasValue || forceRefresh)
|
2014-12-23 04:58:14 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (episode.IndexNumber != episodeInfo.EpisodeNumber)
|
2014-12-23 04:58:14 +01:00
|
|
|
{
|
|
|
|
changed = true;
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
episode.IndexNumber = episodeInfo.EpisodeNumber;
|
2014-12-19 05:20:07 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!episode.IndexNumberEnd.HasValue || forceRefresh)
|
2014-12-19 05:20:07 +01:00
|
|
|
{
|
2020-11-01 11:19:22 +01:00
|
|
|
if (episode.IndexNumberEnd != episodeInfo.EndingEpisodeNumber)
|
2014-12-23 04:58:14 +01:00
|
|
|
{
|
|
|
|
changed = true;
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2020-11-01 11:19:22 +01:00
|
|
|
episode.IndexNumberEnd = episodeInfo.EndingEpisodeNumber;
|
2014-12-23 04:58:14 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!episode.ParentIndexNumber.HasValue || forceRefresh)
|
2014-12-23 04:58:14 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (episode.ParentIndexNumber != episodeInfo.SeasonNumber)
|
2014-12-23 04:58:14 +01:00
|
|
|
{
|
|
|
|
changed = true;
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
episode.ParentIndexNumber = episodeInfo.SeasonNumber;
|
2014-12-19 05:20:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!episode.ParentIndexNumber.HasValue)
|
2017-06-15 19:22:05 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var season = episode.Season;
|
2017-06-15 19:22:05 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (season is not null)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
episode.ParentIndexNumber = season.IndexNumber;
|
2017-06-15 19:22:05 +02:00
|
|
|
}
|
2019-10-11 12:24:55 +02:00
|
|
|
else
|
|
|
|
{
|
2019-11-07 02:50:02 +01:00
|
|
|
/*
|
|
|
|
Anime series don't generally have a season in their file name, however,
|
2022-04-15 19:27:38 +02:00
|
|
|
TVDb needs a season to correctly get the metadata.
|
2019-11-07 02:50:02 +01:00
|
|
|
Hence, a null season needs to be filled with something. */
|
2022-04-15 19:27:38 +02:00
|
|
|
// FIXME perhaps this would be better for TVDb parser to ask for season 1 if no season is specified
|
2019-10-11 12:24:55 +02:00
|
|
|
episode.ParentIndexNumber = 1;
|
|
|
|
}
|
2017-06-15 19:22:05 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (episode.ParentIndexNumber.HasValue)
|
|
|
|
{
|
|
|
|
changed = true;
|
|
|
|
}
|
2017-06-15 19:22:05 +02:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2014-11-16 23:46:01 +01:00
|
|
|
public ItemLookupInfo ParseName(string name)
|
|
|
|
{
|
2021-11-15 15:56:02 +01:00
|
|
|
var namingOptions = _namingOptions;
|
2021-05-24 00:30:41 +02:00
|
|
|
var result = VideoResolver.CleanDateTime(name, namingOptions);
|
2014-11-16 23:46:01 +01:00
|
|
|
|
|
|
|
return new ItemLookupInfo
|
|
|
|
{
|
2021-12-15 18:25:36 +01:00
|
|
|
Name = VideoResolver.TryCleanString(result.Name, namingOptions, out var newName) ? newName : result.Name,
|
2014-11-16 23:46:01 +01:00
|
|
|
Year = result.Year
|
|
|
|
};
|
|
|
|
}
|
2014-11-18 03:48:22 +01:00
|
|
|
|
2022-01-28 12:21:40 +01:00
|
|
|
public IEnumerable<BaseItem> FindExtras(BaseItem owner, IReadOnlyList<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
|
2014-12-01 19:42:07 +01:00
|
|
|
{
|
2021-12-07 15:18:17 +01:00
|
|
|
var ownerVideoInfo = VideoResolver.Resolve(owner.Path, owner.IsFolder, _namingOptions);
|
2022-12-05 15:00:20 +01:00
|
|
|
if (ownerVideoInfo is null)
|
2014-12-03 04:13:03 +01:00
|
|
|
{
|
2021-12-07 15:18:17 +01:00
|
|
|
yield break;
|
2014-12-03 04:13:03 +01:00
|
|
|
}
|
|
|
|
|
2021-12-07 15:18:17 +01:00
|
|
|
var count = fileSystemChildren.Count;
|
|
|
|
for (var i = 0; i < count; i++)
|
2016-03-19 20:32:37 +01:00
|
|
|
{
|
2021-12-07 15:18:17 +01:00
|
|
|
var current = fileSystemChildren[i];
|
2021-12-20 12:15:20 +01:00
|
|
|
if (current.IsDirectory && _namingOptions.AllExtrasTypesFolderNames.ContainsKey(current.Name))
|
2014-12-01 19:42:07 +01:00
|
|
|
{
|
2022-01-01 20:07:03 +01:00
|
|
|
var filesInSubFolder = _fileSystem.GetFiles(current.FullName, null, false, false);
|
2021-12-20 12:15:20 +01:00
|
|
|
foreach (var file in filesInSubFolder)
|
|
|
|
{
|
2021-12-28 00:37:40 +01:00
|
|
|
if (!_extraResolver.TryGetExtraTypeForOwner(file.FullName, ownerVideoInfo, out var extraType))
|
2021-12-20 12:15:20 +01:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-12-28 00:37:40 +01:00
|
|
|
var extra = GetExtra(file, extraType.Value);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (extra is not null)
|
2021-12-28 00:37:40 +01:00
|
|
|
{
|
|
|
|
yield return extra;
|
|
|
|
}
|
2021-12-20 12:15:20 +01:00
|
|
|
}
|
2021-12-07 15:18:17 +01:00
|
|
|
}
|
2021-12-28 00:37:40 +01:00
|
|
|
else if (!current.IsDirectory && _extraResolver.TryGetExtraTypeForOwner(current.FullName, ownerVideoInfo, out var extraType))
|
2021-12-07 15:18:17 +01:00
|
|
|
{
|
2021-12-28 00:37:40 +01:00
|
|
|
var extra = GetExtra(current, extraType.Value);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (extra is not null)
|
2021-12-20 12:15:20 +01:00
|
|
|
{
|
2021-12-28 00:37:40 +01:00
|
|
|
yield return extra;
|
2021-12-20 12:15:20 +01:00
|
|
|
}
|
2021-12-07 15:18:17 +01:00
|
|
|
}
|
|
|
|
}
|
2021-12-20 12:15:20 +01:00
|
|
|
|
2021-12-28 00:37:40 +01:00
|
|
|
BaseItem GetExtra(FileSystemMetadata file, ExtraType extraType)
|
2021-12-20 12:15:20 +01:00
|
|
|
{
|
2021-12-28 00:37:40 +01:00
|
|
|
var extra = ResolvePath(_fileSystem.GetFileInfo(file.FullName), directoryService, _extraResolver.GetResolversForExtraType(extraType));
|
|
|
|
if (extra is not Video && extra is not Audio)
|
2021-12-20 12:15:20 +01:00
|
|
|
{
|
2021-12-28 00:37:40 +01:00
|
|
|
return null;
|
2021-12-20 12:15:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Try to retrieve it from the db. If we don't find it, use the resolved version
|
2021-12-28 00:37:40 +01:00
|
|
|
var itemById = GetItemById(extra.Id);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (itemById is not null)
|
2021-12-20 12:15:20 +01:00
|
|
|
{
|
2021-12-28 00:37:40 +01:00
|
|
|
extra = itemById;
|
2021-12-20 12:15:20 +01:00
|
|
|
}
|
|
|
|
|
2021-12-28 00:37:40 +01:00
|
|
|
extra.ExtraType = extraType;
|
|
|
|
extra.ParentId = Guid.Empty;
|
|
|
|
extra.OwnerId = owner.Id;
|
|
|
|
return extra;
|
2021-12-20 12:15:20 +01:00
|
|
|
}
|
2014-12-01 19:42:07 +01:00
|
|
|
}
|
|
|
|
|
2016-09-23 08:21:54 +02:00
|
|
|
public string GetPathAfterNetworkSubstitution(string path, BaseItem ownerItem)
|
2016-09-12 20:10:09 +02:00
|
|
|
{
|
2021-03-06 21:18:20 +01:00
|
|
|
string newPath;
|
2022-12-05 15:01:13 +01:00
|
|
|
if (ownerItem is not null)
|
2016-09-23 08:21:54 +02:00
|
|
|
{
|
|
|
|
var libraryOptions = GetLibraryOptions(ownerItem);
|
2022-12-05 15:01:13 +01:00
|
|
|
if (libraryOptions is not null)
|
2016-09-23 08:21:54 +02:00
|
|
|
{
|
|
|
|
foreach (var pathInfo in libraryOptions.PathInfos)
|
|
|
|
{
|
2021-03-06 21:18:20 +01:00
|
|
|
if (path.TryReplaceSubPath(pathInfo.Path, pathInfo.NetworkPath, out newPath))
|
2016-09-23 08:21:54 +02:00
|
|
|
{
|
2021-03-05 14:09:23 +01:00
|
|
|
return newPath;
|
2016-09-23 08:21:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var metadataPath = _configurationManager.Configuration.MetadataPath;
|
|
|
|
var metadataNetworkPath = _configurationManager.Configuration.MetadataNetworkPath;
|
2016-09-27 19:51:01 +02:00
|
|
|
|
2021-03-06 21:18:20 +01:00
|
|
|
if (path.TryReplaceSubPath(metadataPath, metadataNetworkPath, out newPath))
|
2016-09-27 19:51:01 +02:00
|
|
|
{
|
2021-03-06 21:18:20 +01:00
|
|
|
return newPath;
|
2016-09-27 19:51:01 +02:00
|
|
|
}
|
2016-09-12 20:10:09 +02:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
foreach (var map in _configurationManager.Configuration.PathSubstitutions)
|
2017-02-08 19:50:33 +01:00
|
|
|
{
|
2021-03-06 21:18:20 +01:00
|
|
|
if (path.TryReplaceSubPath(map.From, map.To, out newPath))
|
2021-03-05 14:09:23 +01:00
|
|
|
{
|
|
|
|
return newPath;
|
2017-02-08 19:50:33 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-12 20:10:09 +02:00
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
2015-07-08 18:10:34 +02:00
|
|
|
public List<PersonInfo> GetPeople(InternalPeopleQuery query)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetPeople(query);
|
2015-07-08 18:10:34 +02:00
|
|
|
}
|
|
|
|
|
2015-06-21 05:35:22 +02:00
|
|
|
public List<PersonInfo> GetPeople(BaseItem item)
|
|
|
|
{
|
2015-07-28 21:42:24 +02:00
|
|
|
if (item.SupportsPeople)
|
2015-07-08 18:10:34 +02:00
|
|
|
{
|
2015-07-28 21:42:24 +02:00
|
|
|
var people = GetPeople(new InternalPeopleQuery
|
|
|
|
{
|
|
|
|
ItemId = item.Id
|
|
|
|
});
|
2015-07-13 23:26:11 +02:00
|
|
|
|
2015-07-28 21:42:24 +02:00
|
|
|
if (people.Count > 0)
|
|
|
|
{
|
|
|
|
return people;
|
|
|
|
}
|
2015-07-13 23:26:11 +02:00
|
|
|
}
|
|
|
|
|
2015-09-10 05:22:52 +02:00
|
|
|
return new List<PersonInfo>();
|
2015-06-21 05:35:22 +02:00
|
|
|
}
|
|
|
|
|
2015-07-08 18:10:34 +02:00
|
|
|
public List<Person> GetPeopleItems(InternalPeopleQuery query)
|
2015-07-07 04:25:23 +02:00
|
|
|
{
|
2022-09-24 05:09:38 +02:00
|
|
|
return _itemRepository.GetPeopleNames(query)
|
|
|
|
.Select(i =>
|
2015-07-07 04:25:23 +02:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
return GetPerson(i);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error getting person");
|
2015-07-07 04:25:23 +02:00
|
|
|
return null;
|
|
|
|
}
|
2022-09-24 05:09:38 +02:00
|
|
|
})
|
2022-12-05 15:01:13 +01:00
|
|
|
.Where(i => i is not null)
|
2022-12-05 15:00:20 +01:00
|
|
|
.Where(i => query.User is null ?
|
2022-09-24 05:09:38 +02:00
|
|
|
true :
|
|
|
|
i.IsVisible(query.User))
|
|
|
|
.ToList();
|
2015-07-07 04:25:23 +02:00
|
|
|
}
|
|
|
|
|
2015-07-08 18:10:34 +02:00
|
|
|
public List<string> GetPeopleNames(InternalPeopleQuery query)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
return _itemRepository.GetPeopleNames(query);
|
2015-07-08 18:10:34 +02:00
|
|
|
}
|
|
|
|
|
2017-08-27 02:32:33 +02:00
|
|
|
public void UpdatePeople(BaseItem item, List<PersonInfo> people)
|
2021-04-24 20:22:23 +02:00
|
|
|
{
|
|
|
|
UpdatePeopleAsync(item, people, CancellationToken.None).GetAwaiter().GetResult();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <inheritdoc />
|
|
|
|
public async Task UpdatePeopleAsync(BaseItem item, List<PersonInfo> people, CancellationToken cancellationToken)
|
2015-06-21 05:35:22 +02:00
|
|
|
{
|
2015-08-06 03:21:18 +02:00
|
|
|
if (!item.SupportsPeople)
|
|
|
|
{
|
2017-08-27 02:32:33 +02:00
|
|
|
return;
|
2015-08-06 03:21:18 +02:00
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
_itemRepository.UpdatePeople(item.Id, people);
|
2021-04-24 20:22:23 +02:00
|
|
|
|
|
|
|
await SavePeopleMetadataAsync(people, cancellationToken).ConfigureAwait(false);
|
2015-06-21 05:35:22 +02:00
|
|
|
}
|
2015-10-16 19:06:31 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
public async Task<ItemImageInfo> ConvertImageToLocal(BaseItem item, ItemImageInfo image, int imageIndex)
|
2015-10-16 19:06:31 +02:00
|
|
|
{
|
2016-01-24 05:21:31 +01:00
|
|
|
foreach (var url in image.Path.Split('|'))
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogDebug("ConvertImageToLocal item {0} - image url: {1}", item.Id, url);
|
2015-10-16 19:06:31 +02:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
await ProviderManager.SaveImage(item, url, image.Type, imageIndex, CancellationToken.None).ConfigureAwait(false);
|
2015-10-16 19:06:31 +02:00
|
|
|
|
2020-08-21 22:01:19 +02:00
|
|
|
await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
|
2016-01-24 05:21:31 +01:00
|
|
|
|
|
|
|
return item.GetImageInfo(image.Type, imageIndex);
|
|
|
|
}
|
2020-11-14 22:30:34 +01:00
|
|
|
catch (HttpRequestException ex)
|
2016-01-24 05:21:31 +01:00
|
|
|
{
|
2020-06-22 10:06:35 +02:00
|
|
|
if (ex.StatusCode.HasValue
|
|
|
|
&& (ex.StatusCode.Value == HttpStatusCode.NotFound || ex.StatusCode.Value == HttpStatusCode.Forbidden))
|
2016-01-24 05:21:31 +01:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2019-03-13 22:32:52 +01:00
|
|
|
|
2016-01-24 05:21:31 +01:00
|
|
|
throw;
|
|
|
|
}
|
2015-11-21 06:51:47 +01:00
|
|
|
}
|
|
|
|
|
2016-01-24 05:21:31 +01:00
|
|
|
// Remove this image to prevent it from retrying over and over
|
|
|
|
item.RemoveImage(image);
|
2020-08-21 22:01:19 +02:00
|
|
|
await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
|
2016-03-20 07:46:51 +01:00
|
|
|
|
2016-01-24 05:21:31 +01:00
|
|
|
throw new InvalidOperationException();
|
2015-10-16 19:06:31 +02:00
|
|
|
}
|
2016-05-04 18:33:22 +02:00
|
|
|
|
2021-02-24 02:05:12 +01:00
|
|
|
public async Task AddVirtualFolder(string name, CollectionTypeOptions? collectionType, LibraryOptions options, bool refreshLibrary)
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
|
|
|
if (string.IsNullOrWhiteSpace(name))
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
throw new ArgumentNullException(nameof(name));
|
2016-05-04 18:33:22 +02:00
|
|
|
}
|
|
|
|
|
2016-05-07 20:58:16 +02:00
|
|
|
name = _fileSystem.GetValidFilename(name);
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
|
2016-05-04 18:33:22 +02:00
|
|
|
|
2021-12-18 16:33:58 +01:00
|
|
|
var existingNameCount = 1; // first numbered name will be 2
|
2016-05-04 18:33:22 +02:00
|
|
|
var virtualFolderPath = Path.Combine(rootFolderPath, name);
|
2022-03-31 04:10:12 +02:00
|
|
|
var originalName = name;
|
2019-01-26 22:59:53 +01:00
|
|
|
while (Directory.Exists(virtualFolderPath))
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
2021-12-18 16:33:58 +01:00
|
|
|
existingNameCount++;
|
2022-03-31 04:10:12 +02:00
|
|
|
name = originalName + existingNameCount;
|
|
|
|
virtualFolderPath = Path.Combine(rootFolderPath, name);
|
2016-05-04 18:33:22 +02:00
|
|
|
}
|
|
|
|
|
2016-09-23 08:21:54 +02:00
|
|
|
var mediaPathInfos = options.PathInfos;
|
2022-12-05 15:01:13 +01:00
|
|
|
if (mediaPathInfos is not null)
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
2019-01-26 22:59:53 +01:00
|
|
|
var invalidpath = mediaPathInfos.FirstOrDefault(i => !Directory.Exists(i.Path));
|
2022-12-05 15:01:13 +01:00
|
|
|
if (invalidpath is not null)
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
2016-09-23 08:21:54 +02:00
|
|
|
throw new ArgumentException("The specified path does not exist: " + invalidpath.Path + ".");
|
2016-05-04 18:33:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
LibraryMonitor.Stop();
|
2016-05-04 18:33:22 +02:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.CreateDirectory(virtualFolderPath);
|
2016-05-04 18:33:22 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (collectionType is not null)
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
2021-03-08 12:08:17 +01:00
|
|
|
var path = Path.Combine(virtualFolderPath, collectionType.ToString().ToLowerInvariant() + ".collection");
|
2016-05-04 18:33:22 +02:00
|
|
|
|
2019-01-26 23:09:07 +01:00
|
|
|
File.WriteAllBytes(path, Array.Empty<byte>());
|
2016-05-04 18:33:22 +02:00
|
|
|
}
|
|
|
|
|
2016-08-13 07:49:00 +02:00
|
|
|
CollectionFolder.SaveLibraryOptions(virtualFolderPath, options);
|
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (mediaPathInfos is not null)
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
2016-09-23 08:21:54 +02:00
|
|
|
foreach (var path in mediaPathInfos)
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
2016-09-23 08:21:54 +02:00
|
|
|
AddMediaPathInternal(name, path, false);
|
2016-05-04 18:33:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
finally
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (refreshLibrary)
|
2016-05-04 18:33:22 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
await ValidateTopLibraryFolders(CancellationToken.None).ConfigureAwait(false);
|
2016-05-04 18:33:22 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
StartScanInBackground();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Need to add a delay here or directory watchers may still pick up the changes
|
|
|
|
await Task.Delay(1000).ConfigureAwait(false);
|
2020-04-05 00:28:46 +02:00
|
|
|
LibraryMonitor.Start();
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2016-05-04 18:33:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-24 20:22:23 +02:00
|
|
|
private async Task SavePeopleMetadataAsync(IEnumerable<PersonInfo> people, CancellationToken cancellationToken)
|
|
|
|
{
|
|
|
|
var personsToSave = new List<BaseItem>();
|
|
|
|
|
|
|
|
foreach (var person in people)
|
|
|
|
{
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
|
|
|
|
var itemUpdateType = ItemUpdateType.MetadataDownload;
|
|
|
|
var saveEntity = false;
|
|
|
|
var personEntity = GetPerson(person.Name);
|
|
|
|
|
|
|
|
// if PresentationUniqueKey is empty it's likely a new item.
|
|
|
|
if (string.IsNullOrEmpty(personEntity.PresentationUniqueKey))
|
|
|
|
{
|
|
|
|
personEntity.PresentationUniqueKey = personEntity.CreatePresentationUniqueKey();
|
|
|
|
saveEntity = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
itemUpdateType = ItemUpdateType.ImageUpdate;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (saveEntity)
|
|
|
|
{
|
|
|
|
personsToSave.Add(personEntity);
|
|
|
|
await RunMetadataSavers(personEntity, itemUpdateType).ConfigureAwait(false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-07 22:33:31 +01:00
|
|
|
if (personsToSave.Count > 0)
|
|
|
|
{
|
|
|
|
CreateItems(personsToSave, null, CancellationToken.None);
|
|
|
|
}
|
2021-04-24 20:22:23 +02:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private void StartScanInBackground()
|
|
|
|
{
|
|
|
|
Task.Run(() =>
|
|
|
|
{
|
|
|
|
// No need to start if scanning the library because it will handle it
|
|
|
|
ValidateMediaLibrary(new SimpleProgress<double>(), CancellationToken.None);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-09-03 18:46:34 +02:00
|
|
|
public void AddMediaPath(string virtualFolderName, MediaPathInfo mediaPath)
|
2016-09-23 08:21:54 +02:00
|
|
|
{
|
2021-09-03 18:46:34 +02:00
|
|
|
AddMediaPathInternal(virtualFolderName, mediaPath, true);
|
2016-09-23 08:21:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private void AddMediaPathInternal(string virtualFolderName, MediaPathInfo pathInfo, bool saveLibraryOptions)
|
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(pathInfo);
|
2016-09-23 08:21:54 +02:00
|
|
|
|
|
|
|
var path = pathInfo.Path;
|
|
|
|
|
|
|
|
if (string.IsNullOrWhiteSpace(path))
|
|
|
|
{
|
2019-03-13 22:32:52 +01:00
|
|
|
throw new ArgumentException(nameof(path));
|
2016-09-23 08:21:54 +02:00
|
|
|
}
|
|
|
|
|
2019-01-26 22:59:53 +01:00
|
|
|
if (!Directory.Exists(path))
|
2016-09-23 08:21:54 +02:00
|
|
|
{
|
2016-11-03 07:37:52 +01:00
|
|
|
throw new FileNotFoundException("The path does not exist.");
|
2016-09-23 08:21:54 +02:00
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
|
2016-09-23 08:21:54 +02:00
|
|
|
var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
|
|
|
|
|
2019-01-26 21:47:11 +01:00
|
|
|
var shortcutFilename = Path.GetFileNameWithoutExtension(path);
|
2016-09-23 08:21:54 +02:00
|
|
|
|
|
|
|
var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
|
|
|
|
|
2019-01-26 22:59:53 +01:00
|
|
|
while (File.Exists(lnk))
|
2016-09-23 08:21:54 +02:00
|
|
|
{
|
|
|
|
shortcutFilename += "1";
|
|
|
|
lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
_fileSystem.CreateShortcut(lnk, _appHost.ReverseVirtualPath(path));
|
2016-09-23 08:21:54 +02:00
|
|
|
|
|
|
|
RemoveContentTypeOverrides(path);
|
|
|
|
|
|
|
|
if (saveLibraryOptions)
|
|
|
|
{
|
|
|
|
var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
|
|
|
|
|
|
|
|
var list = libraryOptions.PathInfos.ToList();
|
|
|
|
list.Add(pathInfo);
|
|
|
|
libraryOptions.PathInfos = list.ToArray();
|
|
|
|
|
2016-09-28 07:11:41 +02:00
|
|
|
SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
|
|
|
|
|
2016-09-23 08:21:54 +02:00
|
|
|
CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-03 18:46:34 +02:00
|
|
|
public void UpdateMediaPath(string virtualFolderName, MediaPathInfo mediaPath)
|
2016-09-24 08:22:03 +02:00
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(mediaPath);
|
2016-09-24 08:22:03 +02:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
|
2016-09-24 08:22:03 +02:00
|
|
|
var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
|
|
|
|
|
|
|
|
var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
|
|
|
|
|
2016-09-24 19:58:17 +02:00
|
|
|
SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
|
|
|
|
|
2016-09-24 08:22:03 +02:00
|
|
|
var list = libraryOptions.PathInfos.ToList();
|
|
|
|
foreach (var originalPathInfo in list)
|
|
|
|
{
|
2021-09-03 18:46:34 +02:00
|
|
|
if (string.Equals(mediaPath.Path, originalPathInfo.Path, StringComparison.Ordinal))
|
2016-09-24 08:22:03 +02:00
|
|
|
{
|
2021-09-03 18:46:34 +02:00
|
|
|
originalPathInfo.NetworkPath = mediaPath.NetworkPath;
|
2016-09-24 08:22:03 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-09-24 19:58:17 +02:00
|
|
|
|
2016-09-24 08:22:03 +02:00
|
|
|
libraryOptions.PathInfos = list.ToArray();
|
|
|
|
|
|
|
|
CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
|
|
|
|
}
|
|
|
|
|
2016-09-24 19:58:17 +02:00
|
|
|
private void SyncLibraryOptionsToLocations(string virtualFolderPath, LibraryOptions options)
|
|
|
|
{
|
|
|
|
var topLibraryFolders = GetUserRootFolder().Children.ToList();
|
2017-06-23 18:04:45 +02:00
|
|
|
var info = GetVirtualFolderInfo(virtualFolderPath, topLibraryFolders, null);
|
2016-09-24 19:58:17 +02:00
|
|
|
|
2017-08-19 21:43:35 +02:00
|
|
|
if (info.Locations.Length > 0 && info.Locations.Length != options.PathInfos.Length)
|
2016-09-24 19:58:17 +02:00
|
|
|
{
|
|
|
|
var list = options.PathInfos.ToList();
|
|
|
|
|
|
|
|
foreach (var location in info.Locations)
|
|
|
|
{
|
|
|
|
if (!list.Any(i => string.Equals(i.Path, location, StringComparison.Ordinal)))
|
|
|
|
{
|
2021-08-28 17:32:09 +02:00
|
|
|
list.Add(new MediaPathInfo(location));
|
2016-09-24 19:58:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
options.PathInfos = list.ToArray();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
public async Task RemoveVirtualFolder(string name, bool refreshLibrary)
|
2016-05-04 22:50:47 +02:00
|
|
|
{
|
|
|
|
if (string.IsNullOrWhiteSpace(name))
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
throw new ArgumentNullException(nameof(name));
|
2016-05-04 22:50:47 +02:00
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
|
2016-05-04 22:50:47 +02:00
|
|
|
|
|
|
|
var path = Path.Combine(rootFolderPath, name);
|
|
|
|
|
2019-01-26 22:59:53 +01:00
|
|
|
if (!Directory.Exists(path))
|
2016-05-04 22:50:47 +02:00
|
|
|
{
|
2016-11-03 07:37:52 +01:00
|
|
|
throw new FileNotFoundException("The media folder does not exist");
|
2016-05-04 22:50:47 +02:00
|
|
|
}
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
LibraryMonitor.Stop();
|
2016-05-04 22:50:47 +02:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2019-01-26 22:08:04 +01:00
|
|
|
Directory.Delete(path, true);
|
2016-05-04 22:50:47 +02:00
|
|
|
}
|
|
|
|
finally
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
CollectionFolder.OnCollectionFolderChange();
|
|
|
|
|
|
|
|
if (refreshLibrary)
|
2016-05-04 22:50:47 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
await ValidateTopLibraryFolders(CancellationToken.None).ConfigureAwait(false);
|
2016-05-04 22:50:47 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
StartScanInBackground();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Need to add a delay here or directory watchers may still pick up the changes
|
|
|
|
await Task.Delay(1000).ConfigureAwait(false);
|
2020-04-05 00:28:46 +02:00
|
|
|
LibraryMonitor.Start();
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2016-05-04 22:50:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-27 22:33:35 +02:00
|
|
|
private void RemoveContentTypeOverrides(string path)
|
|
|
|
{
|
2016-07-10 17:44:53 +02:00
|
|
|
if (string.IsNullOrWhiteSpace(path))
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
throw new ArgumentNullException(nameof(path));
|
2016-07-10 17:44:53 +02:00
|
|
|
}
|
|
|
|
|
2016-06-27 22:33:35 +02:00
|
|
|
var removeList = new List<NameValuePair>();
|
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
foreach (var contentType in _configurationManager.Configuration.ContentTypes)
|
2016-06-27 22:33:35 +02:00
|
|
|
{
|
2016-12-24 08:41:53 +01:00
|
|
|
if (string.IsNullOrWhiteSpace(contentType.Name))
|
|
|
|
{
|
|
|
|
removeList.Add(contentType);
|
|
|
|
}
|
2017-01-11 18:56:26 +01:00
|
|
|
else if (_fileSystem.AreEqual(path, contentType.Name)
|
2016-06-27 22:33:35 +02:00
|
|
|
|| _fileSystem.ContainsSubPath(path, contentType.Name))
|
|
|
|
{
|
|
|
|
removeList.Add(contentType);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (removeList.Count > 0)
|
|
|
|
{
|
2020-04-05 00:28:46 +02:00
|
|
|
_configurationManager.Configuration.ContentTypes = _configurationManager.Configuration.ContentTypes
|
2016-06-27 22:33:35 +02:00
|
|
|
.Except(removeList)
|
2020-04-21 02:20:39 +02:00
|
|
|
.ToArray();
|
2016-06-27 22:33:35 +02:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
_configurationManager.SaveConfiguration();
|
2016-06-27 22:33:35 +02:00
|
|
|
}
|
2016-05-04 18:33:22 +02:00
|
|
|
}
|
2016-05-04 22:50:47 +02:00
|
|
|
|
|
|
|
public void RemoveMediaPath(string virtualFolderName, string mediaPath)
|
|
|
|
{
|
2022-10-13 19:08:00 +02:00
|
|
|
ArgumentException.ThrowIfNullOrEmpty(mediaPath);
|
2016-05-04 22:50:47 +02:00
|
|
|
|
2020-04-05 00:28:46 +02:00
|
|
|
var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
|
2016-09-24 08:22:03 +02:00
|
|
|
var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
|
2016-05-04 22:50:47 +02:00
|
|
|
|
2019-01-26 22:59:53 +01:00
|
|
|
if (!Directory.Exists(virtualFolderPath))
|
2016-05-04 22:50:47 +02:00
|
|
|
{
|
2020-07-20 11:01:37 +02:00
|
|
|
throw new FileNotFoundException(
|
|
|
|
string.Format(CultureInfo.InvariantCulture, "The media collection {0} does not exist", virtualFolderName));
|
2016-05-04 22:50:47 +02:00
|
|
|
}
|
|
|
|
|
2016-11-03 07:37:52 +01:00
|
|
|
var shortcut = _fileSystem.GetFilePaths(virtualFolderPath, true)
|
|
|
|
.Where(i => string.Equals(ShortcutFileExtension, Path.GetExtension(i), StringComparison.OrdinalIgnoreCase))
|
2018-09-12 19:26:21 +02:00
|
|
|
.FirstOrDefault(f => _appHost.ExpandVirtualPath(_fileSystem.ResolveShortcut(f)).Equals(mediaPath, StringComparison.OrdinalIgnoreCase));
|
2016-05-04 22:50:47 +02:00
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(shortcut))
|
|
|
|
{
|
|
|
|
_fileSystem.DeleteFile(shortcut);
|
|
|
|
}
|
2016-09-24 08:22:03 +02:00
|
|
|
|
|
|
|
var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
|
|
|
|
|
|
|
|
libraryOptions.PathInfos = libraryOptions
|
|
|
|
.PathInfos
|
|
|
|
.Where(i => !string.Equals(i.Path, mediaPath, StringComparison.Ordinal))
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
|
2016-05-04 22:50:47 +02:00
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
2018-12-15 19:53:09 +01:00
|
|
|
}
|