< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Library.LibraryManager
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Library/LibraryManager.cs
Line coverage
39%
Covered lines: 417
Uncovered lines: 645
Coverable lines: 1062
Total lines: 3241
Line coverage: 39.2%
Branch coverage
32%
Covered branches: 190
Total branches: 592
Branch coverage: 32%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_RootFolder()100%44100%
get_LibraryMonitor()100%11100%
get_ProviderManager()100%11100%
get_UserViewManager()100%11100%
AddParts(...)100%11100%
RecordConfigurationValues(...)100%11100%
ConfigurationUpdated(...)100%22100%
RegisterItem(...)50%191055.55%
DeleteItem(...)100%210%
DeleteItem(...)0%620%
DeleteItem(...)23.91%9394625%
GetMetadataPaths(...)50%2275%
GetInternalMetadataPaths(...)50%2285.71%
ResolveItem(...)100%44100%
Resolve(...)100%1140%
GetNewItemId(...)100%11100%
GetNewItemIdInternal(...)100%66100%
ResolvePath(...)100%22100%
ResolvePath(...)70%272074.19%
IgnoreFile(...)100%11100%
NormalizeRootPathList(...)50%2291.66%
ShouldResolvePathContents(...)100%11100%
ResolvePaths(...)100%11100%
ResolvePaths(...)58.33%221258.33%
CreateRootFolder()71.42%141488%
GetUserRootFolder()80%111079.16%
FindByPath(...)100%210%
GetPerson(...)50%2280%
GetStudio(...)100%210%
GetStudioId(...)100%210%
GetGenreId(...)100%210%
GetMusicGenreId(...)100%210%
GetGenre(...)100%210%
GetMusicGenre(...)100%210%
GetYear(...)0%620%
GetArtist(...)100%210%
GetArtist(...)100%210%
CreateItemByName(...)0%7280%
GetItemByNameId(...)100%11100%
ValidatePeopleAsync(...)100%210%
ValidateMediaLibrary(...)100%11100%
GetVirtualFolders()100%11100%
GetVirtualFolders(...)100%22100%
GetVirtualFolderInfo(...)70%101097.14%
GetCollectionType(...)50%6450%
GetItemById(...)66.66%7675%
GetItemById(...)100%22100%
GetItemById(...)50%22100%
GetItemById(...)50%22100%
GetItemList(...)100%1010100%
GetItemList(...)100%11100%
GetCount(...)0%7280%
GetItemList(...)0%4260%
GetLatestItemList(...)0%4260%
GetNextUpSeriesKeys(...)0%4260%
QueryItems(...)0%2040%
GetItemIds(...)50%2266.66%
GetStudios(...)0%620%
GetGenres(...)0%620%
GetMusicGenres(...)0%620%
GetAllArtists(...)0%620%
GetArtists(...)0%620%
SetTopParentOrAncestorIds(...)0%210140%
GetAlbumArtists(...)0%620%
GetItemsResult(...)100%1010100%
SetTopParentIdsOrAncestors(...)83.33%6688.88%
AddUserToQuery(...)100%1616100%
GetTopParentIdsForQuery(...)8.33%4342410.71%
ResolveIntro(...)0%110100%
Sort(...)57.14%341453.33%
Sort(...)0%210140%
GetComparer(...)50%3237.5%
CreateItem(...)100%210%
CreateItems(...)90%101083.33%
ImageNeedsRefresh(...)0%156120%
UpdateItemAsync(...)100%11100%
ReportItemRemoved(...)100%2276.92%
RetrieveItem(...)100%11100%
GetCollectionFolders(...)100%11100%
GetCollectionFolders(...)80%111081.81%
GetCollectionFoldersInternal(...)100%11100%
GetLibraryOptions(...)75%44100%
GetContentType(...)50%4471.42%
GetInheritedContentType(...)50%2283.33%
GetConfiguredContentType(...)100%210%
GetConfiguredContentType(...)100%210%
GetConfiguredContentType(...)50%2266.66%
GetContentTypeOverride(...)50%4485.71%
GetTopFolderContentType(...)50%11863.63%
GetNamedView(...)100%210%
GetNamedView(...)0%4260%
GetNamedView(...)0%420200%
GetShadowView(...)0%272160%
GetNamedView(...)0%600240%
GetParentItem(...)33.33%8660%
QueueLibraryScan()100%210%
GetSeasonNumberFromPath(...)0%2040%
FillMissingEpisodeNumbersFromPath(...)0%4422660%
ParseName(...)0%620%
GetPathAfterNetworkSubstitution(...)25%6450%
GetPeople(...)100%210%
GetPeople(...)50%11425%
GetPeopleItems(...)100%210%
GetPeopleNames(...)100%210%
UpdatePeople(...)100%210%
StartScanInBackground()100%11100%
AddMediaPath(...)100%1150%
AddMediaPathInternal(...)25%36823.8%
UpdateMediaPath(...)100%210%
SyncLibraryOptionsToLocations(...)0%7280%
RemoveContentTypeOverrides(...)0%210140%
RemoveMediaPath(...)25%9433.33%
ItemIsVisible(...)16.66%14640%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Library/LibraryManager.cs

#LineLine coverage
 1#pragma warning disable CS1591
 2#pragma warning disable CA5394
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Globalization;
 7using System.IO;
 8using System.Linq;
 9using System.Net;
 10using System.Net.Http;
 11using System.Threading;
 12using System.Threading.Tasks;
 13using BitFaster.Caching.Lru;
 14using Emby.Naming.Common;
 15using Emby.Naming.TV;
 16using Emby.Server.Implementations.Library.Resolvers;
 17using Emby.Server.Implementations.Library.Validators;
 18using Emby.Server.Implementations.Playlists;
 19using Emby.Server.Implementations.ScheduledTasks.Tasks;
 20using Emby.Server.Implementations.Sorting;
 21using Jellyfin.Data;
 22using Jellyfin.Data.Enums;
 23using Jellyfin.Database.Implementations.Entities;
 24using Jellyfin.Database.Implementations.Enums;
 25using Jellyfin.Extensions;
 26using MediaBrowser.Common.Extensions;
 27using MediaBrowser.Controller;
 28using MediaBrowser.Controller.Configuration;
 29using MediaBrowser.Controller.Drawing;
 30using MediaBrowser.Controller.Dto;
 31using MediaBrowser.Controller.Entities;
 32using MediaBrowser.Controller.Entities.Audio;
 33using MediaBrowser.Controller.IO;
 34using MediaBrowser.Controller.Library;
 35using MediaBrowser.Controller.LiveTv;
 36using MediaBrowser.Controller.MediaEncoding;
 37using MediaBrowser.Controller.Persistence;
 38using MediaBrowser.Controller.Providers;
 39using MediaBrowser.Controller.Resolvers;
 40using MediaBrowser.Controller.Sorting;
 41using MediaBrowser.Model.Configuration;
 42using MediaBrowser.Model.Dlna;
 43using MediaBrowser.Model.Drawing;
 44using MediaBrowser.Model.Dto;
 45using MediaBrowser.Model.Entities;
 46using MediaBrowser.Model.IO;
 47using MediaBrowser.Model.Library;
 48using MediaBrowser.Model.Querying;
 49using MediaBrowser.Model.Tasks;
 50using Microsoft.Extensions.Logging;
 51using Episode = MediaBrowser.Controller.Entities.TV.Episode;
 52using EpisodeInfo = Emby.Naming.TV.EpisodeInfo;
 53using Genre = MediaBrowser.Controller.Entities.Genre;
 54using Person = MediaBrowser.Controller.Entities.Person;
 55using VideoResolver = Emby.Naming.Video.VideoResolver;
 56
 57namespace Emby.Server.Implementations.Library
 58{
 59    /// <summary>
 60    /// Class LibraryManager.
 61    /// </summary>
 62    public class LibraryManager : ILibraryManager
 63    {
 64        private const string ShortcutFileExtension = ".mblink";
 65
 66        private readonly ILogger<LibraryManager> _logger;
 67        private readonly ITaskManager _taskManager;
 68        private readonly IUserManager _userManager;
 69        private readonly IUserDataManager _userDataRepository;
 70        private readonly IServerConfigurationManager _configurationManager;
 71        private readonly Lazy<ILibraryMonitor> _libraryMonitorFactory;
 72        private readonly Lazy<IProviderManager> _providerManagerFactory;
 73        private readonly Lazy<IUserViewManager> _userviewManagerFactory;
 74        private readonly IServerApplicationHost _appHost;
 75        private readonly IMediaEncoder _mediaEncoder;
 76        private readonly IFileSystem _fileSystem;
 77        private readonly IItemRepository _itemRepository;
 78        private readonly IImageProcessor _imageProcessor;
 79        private readonly NamingOptions _namingOptions;
 80        private readonly IPeopleRepository _peopleRepository;
 81        private readonly ExtraResolver _extraResolver;
 82        private readonly IPathManager _pathManager;
 83        private readonly FastConcurrentLru<Guid, BaseItem> _cache;
 84
 85        /// <summary>
 86        /// The _root folder sync lock.
 87        /// </summary>
 2888        private readonly Lock _rootFolderSyncLock = new();
 2889        private readonly Lock _userRootFolderSyncLock = new();
 90
 2891        private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromHours(24);
 92
 93        /// <summary>
 94        /// The _root folder.
 95        /// </summary>
 96        private volatile AggregateFolder? _rootFolder;
 97        private volatile UserRootFolder? _userRootFolder;
 98
 99        private bool _wizardCompleted;
 100
 101        /// <summary>
 102        /// Initializes a new instance of the <see cref="LibraryManager" /> class.
 103        /// </summary>
 104        /// <param name="appHost">The application host.</param>
 105        /// <param name="loggerFactory">The logger factory.</param>
 106        /// <param name="taskManager">The task manager.</param>
 107        /// <param name="userManager">The user manager.</param>
 108        /// <param name="configurationManager">The configuration manager.</param>
 109        /// <param name="userDataRepository">The user data repository.</param>
 110        /// <param name="libraryMonitorFactory">The library monitor.</param>
 111        /// <param name="fileSystem">The file system.</param>
 112        /// <param name="providerManagerFactory">The provider manager.</param>
 113        /// <param name="userviewManagerFactory">The userview manager.</param>
 114        /// <param name="mediaEncoder">The media encoder.</param>
 115        /// <param name="itemRepository">The item repository.</param>
 116        /// <param name="imageProcessor">The image processor.</param>
 117        /// <param name="namingOptions">The naming options.</param>
 118        /// <param name="directoryService">The directory service.</param>
 119        /// <param name="peopleRepository">The people repository.</param>
 120        /// <param name="pathManager">The path manager.</param>
 121        public LibraryManager(
 122            IServerApplicationHost appHost,
 123            ILoggerFactory loggerFactory,
 124            ITaskManager taskManager,
 125            IUserManager userManager,
 126            IServerConfigurationManager configurationManager,
 127            IUserDataManager userDataRepository,
 128            Lazy<ILibraryMonitor> libraryMonitorFactory,
 129            IFileSystem fileSystem,
 130            Lazy<IProviderManager> providerManagerFactory,
 131            Lazy<IUserViewManager> userviewManagerFactory,
 132            IMediaEncoder mediaEncoder,
 133            IItemRepository itemRepository,
 134            IImageProcessor imageProcessor,
 135            NamingOptions namingOptions,
 136            IDirectoryService directoryService,
 137            IPeopleRepository peopleRepository,
 138            IPathManager pathManager)
 139        {
 28140            _appHost = appHost;
 28141            _logger = loggerFactory.CreateLogger<LibraryManager>();
 28142            _taskManager = taskManager;
 28143            _userManager = userManager;
 28144            _configurationManager = configurationManager;
 28145            _userDataRepository = userDataRepository;
 28146            _libraryMonitorFactory = libraryMonitorFactory;
 28147            _fileSystem = fileSystem;
 28148            _providerManagerFactory = providerManagerFactory;
 28149            _userviewManagerFactory = userviewManagerFactory;
 28150            _mediaEncoder = mediaEncoder;
 28151            _itemRepository = itemRepository;
 28152            _imageProcessor = imageProcessor;
 153
 28154            _cache = new FastConcurrentLru<Guid, BaseItem>(_configurationManager.Configuration.CacheSize);
 155
 28156            _namingOptions = namingOptions;
 28157            _peopleRepository = peopleRepository;
 28158            _pathManager = pathManager;
 28159            _extraResolver = new ExtraResolver(loggerFactory.CreateLogger<ExtraResolver>(), namingOptions, directoryServ
 160
 28161            _configurationManager.ConfigurationUpdated += ConfigurationUpdated;
 162
 28163            RecordConfigurationValues(_configurationManager.Configuration);
 28164        }
 165
 166        /// <summary>
 167        /// Occurs when [item added].
 168        /// </summary>
 169        public event EventHandler<ItemChangeEventArgs>? ItemAdded;
 170
 171        /// <summary>
 172        /// Occurs when [item updated].
 173        /// </summary>
 174        public event EventHandler<ItemChangeEventArgs>? ItemUpdated;
 175
 176        /// <summary>
 177        /// Occurs when [item removed].
 178        /// </summary>
 179        public event EventHandler<ItemChangeEventArgs>? ItemRemoved;
 180
 181        /// <summary>
 182        /// Gets the root folder.
 183        /// </summary>
 184        /// <value>The root folder.</value>
 185        public AggregateFolder RootFolder
 186        {
 187            get
 188            {
 151189                if (_rootFolder is null)
 21190                {
 191                    lock (_rootFolderSyncLock)
 192                    {
 21193                        _rootFolder ??= CreateRootFolder();
 21194                    }
 195                }
 196
 151197                return _rootFolder;
 198            }
 199        }
 200
 41201        private ILibraryMonitor LibraryMonitor => _libraryMonitorFactory.Value;
 202
 79203        private IProviderManager ProviderManager => _providerManagerFactory.Value;
 204
 1205        private IUserViewManager UserViewManager => _userviewManagerFactory.Value;
 206
 207        /// <summary>
 208        /// Gets or sets the postscan tasks.
 209        /// </summary>
 210        /// <value>The postscan tasks.</value>
 211        private ILibraryPostScanTask[] PostscanTasks { get; set; } = [];
 212
 213        /// <summary>
 214        /// Gets or sets the intro providers.
 215        /// </summary>
 216        /// <value>The intro providers.</value>
 217        private IIntroProvider[] IntroProviders { get; set; } = [];
 218
 219        /// <summary>
 220        /// Gets or sets the list of entity resolution ignore rules.
 221        /// </summary>
 222        /// <value>The entity resolution ignore rules.</value>
 223        private IResolverIgnoreRule[] EntityResolutionIgnoreRules { get; set; } = [];
 224
 225        /// <summary>
 226        /// Gets or sets the list of currently registered entity resolvers.
 227        /// </summary>
 228        /// <value>The entity resolvers enumerable.</value>
 229        private IItemResolver[] EntityResolvers { get; set; } = [];
 230
 231        private IMultiItemResolver[] MultiItemResolvers { get; set; } = [];
 232
 233        /// <summary>
 234        /// Gets or sets the comparers.
 235        /// </summary>
 236        /// <value>The comparers.</value>
 237        private IBaseItemComparer[] Comparers { get; set; } = [];
 238
 239        public bool IsScanRunning { get; private set; }
 240
 241        /// <summary>
 242        /// Adds the parts.
 243        /// </summary>
 244        /// <param name="rules">The rules.</param>
 245        /// <param name="resolvers">The resolvers.</param>
 246        /// <param name="introProviders">The intro providers.</param>
 247        /// <param name="itemComparers">The item comparers.</param>
 248        /// <param name="postscanTasks">The post scan tasks.</param>
 249        public void AddParts(
 250            IEnumerable<IResolverIgnoreRule> rules,
 251            IEnumerable<IItemResolver> resolvers,
 252            IEnumerable<IIntroProvider> introProviders,
 253            IEnumerable<IBaseItemComparer> itemComparers,
 254            IEnumerable<ILibraryPostScanTask> postscanTasks)
 255        {
 28256            EntityResolutionIgnoreRules = rules.ToArray();
 28257            EntityResolvers = resolvers.OrderBy(i => i.Priority).ToArray();
 28258            MultiItemResolvers = EntityResolvers.OfType<IMultiItemResolver>().ToArray();
 28259            IntroProviders = introProviders.ToArray();
 28260            Comparers = itemComparers.ToArray();
 28261            PostscanTasks = postscanTasks.ToArray();
 28262        }
 263
 264        /// <summary>
 265        /// Records the configuration values.
 266        /// </summary>
 267        /// <param name="configuration">The configuration.</param>
 268        private void RecordConfigurationValues(ServerConfiguration configuration)
 269        {
 66270            _wizardCompleted = configuration.IsStartupWizardCompleted;
 66271        }
 272
 273        /// <summary>
 274        /// Configurations the updated.
 275        /// </summary>
 276        /// <param name="sender">The sender.</param>
 277        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
 278        private void ConfigurationUpdated(object? sender, EventArgs e)
 279        {
 38280            var config = _configurationManager.Configuration;
 281
 38282            var wizardChanged = config.IsStartupWizardCompleted != _wizardCompleted;
 283
 38284            RecordConfigurationValues(config);
 285
 38286            if (wizardChanged)
 287            {
 16288                _taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
 289            }
 38290        }
 291
 292        public void RegisterItem(BaseItem item)
 293        {
 146294            ArgumentNullException.ThrowIfNull(item);
 295
 146296            if (item is IItemByName)
 297            {
 0298                if (item is not MusicArtist)
 299                {
 0300                    return;
 301                }
 302            }
 146303            else if (!item.IsFolder)
 304            {
 0305                if (item is not Video && item is not LiveTvChannel)
 306                {
 0307                    return;
 308                }
 309            }
 310
 146311            _cache.AddOrUpdate(item.Id, item);
 146312        }
 313
 314        public void DeleteItem(BaseItem item, DeleteOptions options)
 315        {
 0316            DeleteItem(item, options, false);
 0317        }
 318
 319        public void DeleteItem(BaseItem item, DeleteOptions options, bool notifyParentItem)
 320        {
 0321            ArgumentNullException.ThrowIfNull(item);
 322
 0323            var parent = item.GetOwner() ?? item.GetParent();
 324
 0325            DeleteItem(item, options, parent, notifyParentItem);
 0326        }
 327
 328        public void DeleteItem(BaseItem item, DeleteOptions options, BaseItem parent, bool notifyParentItem)
 329        {
 2330            ArgumentNullException.ThrowIfNull(item);
 331
 2332            if (item.SourceType == SourceType.Channel)
 333            {
 0334                if (options.DeleteFromExternalProvider)
 335                {
 336                    try
 337                    {
 0338                        BaseItem.ChannelManager.DeleteItem(item).GetAwaiter().GetResult();
 0339                    }
 0340                    catch (ArgumentException)
 341                    {
 342                        // channel no longer installed
 0343                    }
 344                }
 345
 0346                options.DeleteFileLocation = false;
 347            }
 348
 2349            if (item is LiveTvProgram)
 350            {
 0351                _logger.LogDebug(
 0352                    "Removing item, Type: {Type}, Name: {Name}, Path: {Path}, Id: {Id}",
 0353                    item.GetType().Name,
 0354                    item.Name ?? "Unknown name",
 0355                    item.Path ?? string.Empty,
 0356                    item.Id);
 357            }
 358            else
 359            {
 2360                _logger.LogInformation(
 2361                    "Removing item, Type: {Type}, Name: {Name}, Path: {Path}, Id: {Id}",
 2362                    item.GetType().Name,
 2363                    item.Name ?? "Unknown name",
 2364                    item.Path ?? string.Empty,
 2365                    item.Id);
 366            }
 367
 2368            var children = item.IsFolder
 2369                ? ((Folder)item).GetRecursiveChildren(false)
 2370                : [];
 371
 8372            foreach (var metadataPath in GetMetadataPaths(item, children))
 373            {
 2374                if (!Directory.Exists(metadataPath))
 375                {
 376                    continue;
 377                }
 378
 0379                _logger.LogDebug(
 0380                    "Deleting metadata path, Type: {Type}, Name: {Name}, Path: {Path}, Id: {Id}",
 0381                    item.GetType().Name,
 0382                    item.Name ?? "Unknown name",
 0383                    metadataPath,
 0384                    item.Id);
 385
 386                try
 387                {
 0388                    Directory.Delete(metadataPath, true);
 0389                }
 0390                catch (Exception ex)
 391                {
 0392                    _logger.LogError(ex, "Error deleting {MetadataPath}", metadataPath);
 0393                }
 394            }
 395
 2396            if (options.DeleteFileLocation && item.IsFileProtocol)
 397            {
 398                // Assume only the first is required
 399                // Add this flag to GetDeletePaths if required in the future
 0400                var isRequiredForDelete = true;
 401
 0402                foreach (var fileSystemInfo in item.GetDeletePaths())
 403                {
 0404                    if (Directory.Exists(fileSystemInfo.FullName) || File.Exists(fileSystemInfo.FullName))
 405                    {
 406                        try
 407                        {
 0408                            _logger.LogInformation(
 0409                                "Deleting item path, Type: {Type}, Name: {Name}, Path: {Path}, Id: {Id}",
 0410                                item.GetType().Name,
 0411                                item.Name ?? "Unknown name",
 0412                                fileSystemInfo.FullName,
 0413                                item.Id);
 414
 0415                            if (fileSystemInfo.IsDirectory)
 416                            {
 0417                                Directory.Delete(fileSystemInfo.FullName, true);
 418                            }
 419                            else
 420                            {
 0421                                File.Delete(fileSystemInfo.FullName);
 422                            }
 0423                        }
 0424                        catch (DirectoryNotFoundException)
 425                        {
 0426                            _logger.LogInformation(
 0427                                "Directory not found, only removing from database, Type: {Type}, Name: {Name}, Path: {Pa
 0428                                item.GetType().Name,
 0429                                item.Name ?? "Unknown name",
 0430                                fileSystemInfo.FullName,
 0431                                item.Id);
 0432                        }
 0433                        catch (FileNotFoundException)
 434                        {
 0435                            _logger.LogInformation(
 0436                                "File not found, only removing from database, Type: {Type}, Name: {Name}, Path: {Path}, 
 0437                                item.GetType().Name,
 0438                                item.Name ?? "Unknown name",
 0439                                fileSystemInfo.FullName,
 0440                                item.Id);
 0441                        }
 0442                        catch (IOException)
 443                        {
 0444                            if (isRequiredForDelete)
 445                            {
 0446                                throw;
 447                            }
 0448                        }
 0449                        catch (UnauthorizedAccessException)
 450                        {
 0451                            if (isRequiredForDelete)
 452                            {
 0453                                throw;
 454                            }
 0455                        }
 456                    }
 457
 0458                    isRequiredForDelete = false;
 459                }
 460            }
 461
 2462            item.SetParent(null);
 463
 2464            _itemRepository.DeleteItem(item.Id);
 2465            _cache.TryRemove(item.Id, out _);
 4466            foreach (var child in children)
 467            {
 0468                _itemRepository.DeleteItem(child.Id);
 0469                _cache.TryRemove(child.Id, out _);
 470            }
 471
 2472            ReportItemRemoved(item, parent);
 2473        }
 474
 475        private List<string> GetMetadataPaths(BaseItem item, IEnumerable<BaseItem> children)
 476        {
 2477            var list = GetInternalMetadataPaths(item);
 4478            foreach (var child in children)
 479            {
 0480                list.AddRange(GetInternalMetadataPaths(child));
 481            }
 482
 2483            return list;
 484        }
 485
 486        private List<string> GetInternalMetadataPaths(BaseItem item)
 487        {
 2488            var list = new List<string>
 2489            {
 2490                item.GetInternalMetadataPath()
 2491            };
 492
 2493            if (item is Video video)
 494            {
 0495                list.Add(_pathManager.GetTrickplayDirectory(video));
 496            }
 497
 2498            return list;
 499        }
 500
 501        /// <summary>
 502        /// Resolves the item.
 503        /// </summary>
 504        /// <param name="args">The args.</param>
 505        /// <param name="resolvers">The resolvers.</param>
 506        /// <returns>BaseItem.</returns>
 507        private BaseItem? ResolveItem(ItemResolveArgs args, IItemResolver[]? resolvers)
 508        {
 79509            var item = (resolvers ?? EntityResolvers).Select(r => Resolve(args, r))
 79510                .FirstOrDefault(i => i is not null);
 511
 79512            if (item is not null)
 513            {
 67514                ResolverHelper.SetInitialItemValues(item, args, _fileSystem, this);
 515            }
 516
 79517            return item;
 518        }
 519
 520        private BaseItem? Resolve(ItemResolveArgs args, IItemResolver resolver)
 521        {
 522            try
 523            {
 335524                return resolver.ResolvePath(args);
 525            }
 0526            catch (Exception ex)
 527            {
 0528                _logger.LogError(ex, "Error in {Resolver} resolving {Path}", resolver.GetType().Name, args.Path);
 0529                return null;
 530            }
 335531        }
 532
 533        public Guid GetNewItemId(string key, Type type)
 534        {
 130535            return GetNewItemIdInternal(key, type, false);
 536        }
 537
 538        private Guid GetNewItemIdInternal(string key, Type type, bool forceCaseInsensitive)
 539        {
 131540            ArgumentException.ThrowIfNullOrEmpty(key);
 131541            ArgumentNullException.ThrowIfNull(type);
 542
 131543            string programDataPath = _configurationManager.ApplicationPaths.ProgramDataPath;
 131544            if (key.StartsWith(programDataPath, StringComparison.Ordinal))
 545            {
 546                // Try to normalize paths located underneath program-data in an attempt to make them more portable
 114547                key = key.Substring(programDataPath.Length)
 114548                    .TrimStart('/', '\\')
 114549                    .Replace('/', '\\');
 550            }
 551
 131552            if (forceCaseInsensitive || !_configurationManager.Configuration.EnableCaseSensitiveItemIds)
 553            {
 1554                key = key.ToLowerInvariant();
 555            }
 556
 131557            key = type.FullName + key;
 558
 131559            return key.GetMD5();
 560        }
 561
 562        public BaseItem? ResolvePath(FileSystemMetadata fileInfo, Folder? parent = null, IDirectoryService? directorySer
 42563            => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent);
 564
 565        private BaseItem? ResolvePath(
 566            FileSystemMetadata fileInfo,
 567            IDirectoryService directoryService,
 568            IItemResolver[]? resolvers,
 569            Folder? parent = null,
 570            CollectionType? collectionType = null,
 571            LibraryOptions? libraryOptions = null)
 572        {
 79573            ArgumentNullException.ThrowIfNull(fileInfo);
 574
 79575            var fullPath = fileInfo.FullName;
 576
 79577            if (collectionType is null && parent is not null)
 578            {
 20579                collectionType = GetContentTypeOverride(fullPath, true);
 580            }
 581
 79582            var args = new ItemResolveArgs(_configurationManager.ApplicationPaths, this)
 79583            {
 79584                Parent = parent,
 79585                FileInfo = fileInfo,
 79586                CollectionType = collectionType,
 79587                LibraryOptions = libraryOptions
 79588            };
 589
 590            // Return null if ignore rules deem that we should do so
 79591            if (IgnoreFile(args.FileInfo, args.Parent))
 592            {
 0593                return null;
 594            }
 595
 596            // Gather child folder and files
 79597            if (args.IsDirectory)
 598            {
 50599                var isPhysicalRoot = args.IsPhysicalRoot;
 600
 601                // When resolving the root, we need it's grandchildren (children of user views)
 50602                var flattenFolderDepth = isPhysicalRoot ? 2 : 0;
 603
 604                FileSystemMetadata[] files;
 50605                var isVf = args.IsVf;
 606
 607                try
 608                {
 50609                    files = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, _fileSystem, _appHost, _l
 50610                }
 0611                catch (Exception ex)
 612                {
 0613                    if (parent is not null && parent.IsPhysicalRoot)
 614                    {
 0615                        _logger.LogError(ex, "Error in GetFilteredFileSystemEntries isPhysicalRoot: {0} IsVf: {1}", isPh
 616
 0617                        files = [];
 618                    }
 619                    else
 620                    {
 0621                        throw;
 622                    }
 0623                }
 624
 625                // Need to remove subpaths that may have been resolved from shortcuts
 626                // Example: if \\server\movies exists, then strip out \\server\movies\action
 50627                if (isPhysicalRoot)
 628                {
 21629                    files = NormalizeRootPathList(files).ToArray();
 630                }
 631
 50632                args.FileSystemChildren = files;
 633            }
 634
 635            // Check to see if we should resolve based on our contents
 79636            if (args.IsDirectory && !ShouldResolvePathContents(args))
 637            {
 0638                return null;
 639            }
 640
 79641            return ResolveItem(args, resolvers);
 642        }
 643
 644        public bool IgnoreFile(FileSystemMetadata file, BaseItem? parent)
 100645            => EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(file, parent));
 646
 647        public List<FileSystemMetadata> NormalizeRootPathList(IEnumerable<FileSystemMetadata> paths)
 648        {
 68649            var originalList = paths.ToList();
 650
 68651            var list = originalList.Where(i => i.IsDirectory)
 68652                .Select(i => Path.TrimEndingDirectorySeparator(i.FullName))
 68653                .Distinct(StringComparer.OrdinalIgnoreCase)
 68654                .ToList();
 655
 68656            var dupes = list.Where(subPath => !subPath.EndsWith(":\\", StringComparison.OrdinalIgnoreCase) && list.Any(i
 68657                .ToList();
 658
 136659            foreach (var dupe in dupes)
 660            {
 0661                _logger.LogInformation("Found duplicate path: {0}", dupe);
 662            }
 663
 68664            var newList = list.Except(dupes, StringComparer.OrdinalIgnoreCase).Select(_fileSystem.GetDirectoryInfo).ToLi
 68665            newList.AddRange(originalList.Where(i => !i.IsDirectory));
 68666            return newList;
 667        }
 668
 669        /// <summary>
 670        /// Determines whether a path should be ignored based on its contents - called after the contents have been read
 671        /// </summary>
 672        /// <param name="args">The args.</param>
 673        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
 674        private static bool ShouldResolvePathContents(ItemResolveArgs args)
 675        {
 676            // Ignore any folders containing a file called .ignore
 50677            return !args.ContainsFileSystemEntryByName(".ignore");
 678        }
 679
 680        public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemMetadata> files, IDirectoryService directoryServ
 681        {
 40682            return ResolvePaths(files, directoryService, parent, libraryOptions, collectionType, EntityResolvers);
 683        }
 684
 685        public IEnumerable<BaseItem> ResolvePaths(
 686            IEnumerable<FileSystemMetadata> files,
 687            IDirectoryService directoryService,
 688            Folder parent,
 689            LibraryOptions libraryOptions,
 690            CollectionType? collectionType,
 691            IItemResolver[] resolvers)
 692        {
 40693            var fileList = files.Where(i => !IgnoreFile(i, parent)).ToList();
 694
 40695            if (parent is not null)
 696            {
 40697                var multiItemResolvers = resolvers is null ? MultiItemResolvers : resolvers.OfType<IMultiItemResolver>()
 698
 240699                foreach (var resolver in multiItemResolvers)
 700                {
 80701                    var result = resolver.ResolveMultiple(parent, fileList, collectionType, directoryService);
 702
 80703                    if (result?.Items.Count > 0)
 704                    {
 0705                        var items = result.Items;
 0706                        items.RemoveAll(item => !ResolverHelper.SetInitialItemValues(item, parent, this, directoryServic
 0707                        items.AddRange(ResolveFileList(result.ExtraFiles, directoryService, parent, collectionType, reso
 0708                        return items;
 709                    }
 710                }
 711            }
 712
 40713            return ResolveFileList(fileList, directoryService, parent, collectionType, resolvers, libraryOptions);
 0714        }
 715
 716        private IEnumerable<BaseItem> ResolveFileList(
 717            IReadOnlyList<FileSystemMetadata> fileList,
 718            IDirectoryService directoryService,
 719            Folder? parent,
 720            CollectionType? collectionType,
 721            IItemResolver[]? resolvers,
 722            LibraryOptions libraryOptions)
 723        {
 724            // Given that fileList is a list we can save enumerator allocations by indexing
 725            for (var i = 0; i < fileList.Count; i++)
 726            {
 727                var file = fileList[i];
 728                BaseItem? result = null;
 729                try
 730                {
 731                    result = ResolvePath(file, directoryService, resolvers, parent, collectionType, libraryOptions);
 732                }
 733                catch (Exception ex)
 734                {
 735                    _logger.LogError(ex, "Error resolving path {Path}", file.FullName);
 736                }
 737
 738                if (result is not null)
 739                {
 740                    yield return result;
 741                }
 742            }
 743        }
 744
 745        /// <summary>
 746        /// Creates the root media folder.
 747        /// </summary>
 748        /// <returns>AggregateFolder.</returns>
 749        /// <exception cref="InvalidOperationException">Cannot create the root folder until plugins have loaded.</except
 750        public AggregateFolder CreateRootFolder()
 751        {
 21752            var rootFolderPath = _configurationManager.ApplicationPaths.RootFolderPath;
 753
 21754            Directory.CreateDirectory(rootFolderPath);
 755
 21756            var rootFolder = GetItemById(GetNewItemId(rootFolderPath, typeof(AggregateFolder))) as AggregateFolder ??
 21757                             (ResolvePath(_fileSystem.GetDirectoryInfo(rootFolderPath)) as Folder ?? throw new InvalidOp
 21758                             .DeepCopy<Folder, AggregateFolder>();
 759
 760            // In case program data folder was moved
 21761            if (!string.Equals(rootFolder.Path, rootFolderPath, StringComparison.Ordinal))
 762            {
 0763                _logger.LogInformation("Resetting root folder path to {0}", rootFolderPath);
 0764                rootFolder.Path = rootFolderPath;
 765            }
 766
 767            // Add in the plug-in folders
 21768            var path = Path.Combine(_configurationManager.ApplicationPaths.DataPath, "playlists");
 769
 21770            Directory.CreateDirectory(path);
 771
 21772            Folder folder = new PlaylistsFolder
 21773            {
 21774                Path = path
 21775            };
 776
 21777            if (folder.Id.IsEmpty())
 778            {
 21779                folder.Id = GetNewItemId(folder.Path, folder.GetType());
 780            }
 781
 21782            var dbItem = GetItemById(folder.Id) as BasePluginFolder;
 783
 21784            if (dbItem is not null && string.Equals(dbItem.Path, folder.Path, StringComparison.OrdinalIgnoreCase))
 785            {
 0786                folder = dbItem;
 787            }
 788
 21789            if (!folder.ParentId.Equals(rootFolder.Id))
 790            {
 21791                folder.ParentId = rootFolder.Id;
 21792                folder.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, CancellationToken.None).GetAwaiter().GetRe
 793            }
 794
 21795            rootFolder.AddVirtualChild(folder);
 796
 21797            RegisterItem(folder);
 798
 21799            return rootFolder;
 800        }
 801
 802        public Folder GetUserRootFolder()
 803        {
 748804            if (_userRootFolder is null)
 21805            {
 806                lock (_userRootFolderSyncLock)
 807                {
 21808                    if (_userRootFolder is null)
 809                    {
 21810                        var userRootPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
 811
 21812                        _logger.LogDebug("Creating userRootPath at {Path}", userRootPath);
 21813                        Directory.CreateDirectory(userRootPath);
 814
 21815                        var newItemId = GetNewItemId(userRootPath, typeof(UserRootFolder));
 21816                        UserRootFolder? tmpItem = null;
 817                        try
 818                        {
 21819                            tmpItem = GetItemById(newItemId) as UserRootFolder;
 21820                        }
 0821                        catch (Exception ex)
 822                        {
 0823                            _logger.LogError(ex, "Error creating UserRootFolder {Path}", newItemId);
 0824                        }
 825
 21826                        if (tmpItem is null)
 827                        {
 21828                            _logger.LogDebug("Creating new userRootFolder with DeepCopy");
 21829                            tmpItem = (ResolvePath(_fileSystem.GetDirectoryInfo(userRootPath)) as Folder ?? throw new In
 21830                                        .DeepCopy<Folder, UserRootFolder>();
 831                        }
 832
 833                        // In case program data folder was moved
 21834                        if (!string.Equals(tmpItem.Path, userRootPath, StringComparison.Ordinal))
 835                        {
 0836                            _logger.LogInformation("Resetting user root folder path to {0}", userRootPath);
 0837                            tmpItem.Path = userRootPath;
 838                        }
 839
 21840                        _userRootFolder = tmpItem;
 21841                        _logger.LogDebug("Setting userRootFolder: {Folder}", _userRootFolder);
 842                    }
 21843                }
 844            }
 845
 748846            return _userRootFolder;
 847        }
 848
 849        /// <inheritdoc />
 850        public BaseItem? FindByPath(string path, bool? isFolder)
 851        {
 852            // If this returns multiple items it could be tricky figuring out which one is correct.
 853            // In most cases, the newest one will be and the others obsolete but not yet cleaned up
 0854            ArgumentException.ThrowIfNullOrEmpty(path);
 855
 0856            var query = new InternalItemsQuery
 0857            {
 0858                Path = path,
 0859                IsFolder = isFolder,
 0860                OrderBy = new[] { (ItemSortBy.DateCreated, SortOrder.Descending) },
 0861                Limit = 1,
 0862                DtoOptions = new DtoOptions(true)
 0863            };
 864
 0865            return GetItemList(query)
 0866                .FirstOrDefault();
 867        }
 868
 869        /// <inheritdoc />
 870        public Person? GetPerson(string name)
 871        {
 1872            var path = Person.GetPath(name);
 1873            var id = GetItemByNameId<Person>(path);
 1874            if (GetItemById(id) is Person item)
 875            {
 0876                return item;
 877            }
 878
 1879            return null;
 880        }
 881
 882        /// <summary>
 883        /// Gets the studio.
 884        /// </summary>
 885        /// <param name="name">The name.</param>
 886        /// <returns>Task{Studio}.</returns>
 887        public Studio GetStudio(string name)
 888        {
 0889            return CreateItemByName<Studio>(Studio.GetPath, name, new DtoOptions(true));
 890        }
 891
 892        public Guid GetStudioId(string name)
 893        {
 0894            return GetItemByNameId<Studio>(Studio.GetPath(name));
 895        }
 896
 897        public Guid GetGenreId(string name)
 898        {
 0899            return GetItemByNameId<Genre>(Genre.GetPath(name));
 900        }
 901
 902        public Guid GetMusicGenreId(string name)
 903        {
 0904            return GetItemByNameId<MusicGenre>(MusicGenre.GetPath(name));
 905        }
 906
 907        /// <summary>
 908        /// Gets the genre.
 909        /// </summary>
 910        /// <param name="name">The name.</param>
 911        /// <returns>Task{Genre}.</returns>
 912        public Genre GetGenre(string name)
 913        {
 0914            return CreateItemByName<Genre>(Genre.GetPath, name, new DtoOptions(true));
 915        }
 916
 917        /// <summary>
 918        /// Gets the music genre.
 919        /// </summary>
 920        /// <param name="name">The name.</param>
 921        /// <returns>Task{MusicGenre}.</returns>
 922        public MusicGenre GetMusicGenre(string name)
 923        {
 0924            return CreateItemByName<MusicGenre>(MusicGenre.GetPath, name, new DtoOptions(true));
 925        }
 926
 927        /// <summary>
 928        /// Gets the year.
 929        /// </summary>
 930        /// <param name="value">The value.</param>
 931        /// <returns>Task{Year}.</returns>
 932        public Year GetYear(int value)
 933        {
 0934            if (value <= 0)
 935            {
 0936                throw new ArgumentOutOfRangeException(nameof(value), "Years less than or equal to 0 are invalid.");
 937            }
 938
 0939            var name = value.ToString(CultureInfo.InvariantCulture);
 940
 0941            return CreateItemByName<Year>(Year.GetPath, name, new DtoOptions(true));
 942        }
 943
 944        /// <summary>
 945        /// Gets a Genre.
 946        /// </summary>
 947        /// <param name="name">The name.</param>
 948        /// <returns>Task{Genre}.</returns>
 949        public MusicArtist GetArtist(string name)
 950        {
 0951            return GetArtist(name, new DtoOptions(true));
 952        }
 953
 954        public MusicArtist GetArtist(string name, DtoOptions options)
 955        {
 0956            return CreateItemByName<MusicArtist>(MusicArtist.GetPath, name, options);
 957        }
 958
 959        private T CreateItemByName<T>(Func<string, string> getPathFn, string name, DtoOptions options)
 960            where T : BaseItem, new()
 961        {
 0962            if (typeof(T) == typeof(MusicArtist))
 963            {
 0964                var existing = GetItemList(new InternalItemsQuery
 0965                {
 0966                    IncludeItemTypes = new[] { BaseItemKind.MusicArtist },
 0967                    Name = name,
 0968                    DtoOptions = options
 0969                }).Cast<MusicArtist>()
 0970                .OrderBy(i => i.IsAccessedByName ? 1 : 0)
 0971                .Cast<T>()
 0972                .FirstOrDefault();
 973
 0974                if (existing is not null)
 975                {
 0976                    return existing;
 977                }
 978            }
 979
 0980            var path = getPathFn(name);
 0981            var id = GetItemByNameId<T>(path);
 0982            var item = GetItemById(id) as T;
 0983            if (item is null)
 984            {
 0985                item = new T
 0986                {
 0987                    Name = name,
 0988                    Id = id,
 0989                    DateCreated = DateTime.UtcNow,
 0990                    DateModified = DateTime.UtcNow,
 0991                    Path = path
 0992                };
 993
 0994                CreateItem(item, null);
 995            }
 996
 0997            return item;
 998        }
 999
 1000        private Guid GetItemByNameId<T>(string path)
 1001              where T : BaseItem, new()
 1002        {
 11003            var forceCaseInsensitiveId = _configurationManager.Configuration.EnableNormalizedItemByNameIds;
 11004            return GetNewItemIdInternal(path, typeof(T), forceCaseInsensitiveId);
 1005        }
 1006
 1007        /// <inheritdoc />
 1008        public Task ValidatePeopleAsync(IProgress<double> progress, CancellationToken cancellationToken)
 1009        {
 1010            // Ensure the location is available.
 01011            Directory.CreateDirectory(_configurationManager.ApplicationPaths.PeoplePath);
 1012
 01013            return new PeopleValidator(this, _logger, _fileSystem).ValidatePeople(cancellationToken, progress);
 1014        }
 1015
 1016        /// <summary>
 1017        /// Reloads the root media folder.
 1018        /// </summary>
 1019        /// <param name="progress">The progress.</param>
 1020        /// <param name="cancellationToken">The cancellation token.</param>
 1021        /// <returns>Task.</returns>
 1022        public Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
 1023        {
 1024            // Just run the scheduled task so that the user can see it
 31025            _taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
 1026
 31027            return Task.CompletedTask;
 1028        }
 1029
 1030        /// <summary>
 1031        /// Validates the media library internal.
 1032        /// </summary>
 1033        /// <param name="progress">The progress.</param>
 1034        /// <param name="cancellationToken">The cancellation token.</param>
 1035        /// <returns>Task.</returns>
 1036        public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
 1037        {
 1038            IsScanRunning = true;
 1039            LibraryMonitor.Stop();
 1040
 1041            try
 1042            {
 1043                await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
 1044            }
 1045            finally
 1046            {
 1047                LibraryMonitor.Start();
 1048                IsScanRunning = false;
 1049            }
 1050        }
 1051
 1052        public async Task ValidateTopLibraryFolders(CancellationToken cancellationToken, bool removeRoot = false)
 1053        {
 1054            await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
 1055
 1056            // Start by just validating the children of the root, but go no further
 1057            await RootFolder.ValidateChildren(
 1058                new Progress<double>(),
 1059                new MetadataRefreshOptions(new DirectoryService(_fileSystem)),
 1060                recursive: false,
 1061                allowRemoveRoot: removeRoot,
 1062                cancellationToken: cancellationToken).ConfigureAwait(false);
 1063
 1064            await GetUserRootFolder().RefreshMetadata(cancellationToken).ConfigureAwait(false);
 1065
 1066            await GetUserRootFolder().ValidateChildren(
 1067                new Progress<double>(),
 1068                new MetadataRefreshOptions(new DirectoryService(_fileSystem)),
 1069                recursive: false,
 1070                allowRemoveRoot: removeRoot,
 1071                cancellationToken: cancellationToken).ConfigureAwait(false);
 1072
 1073            // Quickly scan CollectionFolders for changes
 1074            foreach (var child in GetUserRootFolder().Children.OfType<Folder>())
 1075            {
 1076                // If the user has somehow deleted the collection directory, remove the metadata from the database.
 1077                if (child is CollectionFolder collectionFolder && !Directory.Exists(collectionFolder.Path))
 1078                {
 1079                    _itemRepository.DeleteItem(collectionFolder.Id);
 1080                }
 1081                else
 1082                {
 1083                    await child.RefreshMetadata(cancellationToken).ConfigureAwait(false);
 1084                }
 1085            }
 1086        }
 1087
 1088        private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
 1089        {
 1090            _logger.LogInformation("Validating media library");
 1091
 1092            await ValidateTopLibraryFolders(cancellationToken).ConfigureAwait(false);
 1093
 1094            var innerProgress = new Progress<double>(pct => progress.Report(pct * 0.96));
 1095
 1096            // Validate the entire media library
 1097            await RootFolder.ValidateChildren(innerProgress, new MetadataRefreshOptions(new DirectoryService(_fileSystem
 1098
 1099            progress.Report(96);
 1100
 1101            innerProgress = new Progress<double>(pct => progress.Report(96 + (pct * .04)));
 1102
 1103            await RunPostScanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
 1104
 1105            progress.Report(100);
 1106        }
 1107
 1108        /// <summary>
 1109        /// Runs the post scan tasks.
 1110        /// </summary>
 1111        /// <param name="progress">The progress.</param>
 1112        /// <param name="cancellationToken">The cancellation token.</param>
 1113        /// <returns>Task.</returns>
 1114        private async Task RunPostScanTasks(IProgress<double> progress, CancellationToken cancellationToken)
 1115        {
 1116            var tasks = PostscanTasks.ToList();
 1117
 1118            var numComplete = 0;
 1119            var numTasks = tasks.Count;
 1120
 1121            foreach (var task in tasks)
 1122            {
 1123                // Prevent access to modified closure
 1124                var currentNumComplete = numComplete;
 1125
 1126                var innerProgress = new Progress<double>(pct =>
 1127                {
 1128                    double innerPercent = pct;
 1129                    innerPercent /= 100;
 1130                    innerPercent += currentNumComplete;
 1131
 1132                    innerPercent /= numTasks;
 1133                    innerPercent *= 100;
 1134
 1135                    progress.Report(innerPercent);
 1136                });
 1137
 1138                _logger.LogDebug("Running post-scan task {0}", task.GetType().Name);
 1139
 1140                try
 1141                {
 1142                    await task.Run(innerProgress, cancellationToken).ConfigureAwait(false);
 1143                }
 1144                catch (OperationCanceledException)
 1145                {
 1146                    _logger.LogInformation("Post-scan task cancelled: {0}", task.GetType().Name);
 1147                    throw;
 1148                }
 1149                catch (Exception ex)
 1150                {
 1151                    _logger.LogError(ex, "Error running post-scan task");
 1152                }
 1153
 1154                numComplete++;
 1155                double percent = numComplete;
 1156                percent /= numTasks;
 1157                progress.Report(percent * 100);
 1158            }
 1159
 1160            _itemRepository.UpdateInheritedValues();
 1161
 1162            progress.Report(100);
 1163        }
 1164
 1165        /// <summary>
 1166        /// Gets the default view.
 1167        /// </summary>
 1168        /// <returns>IEnumerable{VirtualFolderInfo}.</returns>
 1169        public List<VirtualFolderInfo> GetVirtualFolders()
 1170        {
 231171            return GetVirtualFolders(false);
 1172        }
 1173
 1174        public List<VirtualFolderInfo> GetVirtualFolders(bool includeRefreshState)
 1175        {
 241176            _logger.LogDebug("Getting topLibraryFolders");
 241177            var topLibraryFolders = GetUserRootFolder().Children.ToList();
 1178
 241179            _logger.LogDebug("Getting refreshQueue");
 241180            var refreshQueue = includeRefreshState ? ProviderManager.GetRefreshQueue() : null;
 1181
 241182            return _fileSystem.GetDirectoryPaths(_configurationManager.ApplicationPaths.DefaultUserViewsPath)
 241183                .Select(dir => GetVirtualFolderInfo(dir, topLibraryFolders, refreshQueue))
 241184                .ToList();
 1185        }
 1186
 1187        private VirtualFolderInfo GetVirtualFolderInfo(string dir, List<BaseItem> allCollectionFolders, HashSet<Guid>? r
 1188        {
 11189            var info = new VirtualFolderInfo
 11190            {
 11191                Name = Path.GetFileName(dir),
 11192
 11193                Locations = _fileSystem.GetFilePaths(dir, false)
 11194                .Where(i => Path.GetExtension(i.AsSpan()).Equals(ShortcutFileExtension, StringComparison.OrdinalIgnoreCa
 11195                    .Select(i =>
 11196                    {
 11197                        try
 11198                        {
 11199                            return _appHost.ExpandVirtualPath(_fileSystem.ResolveShortcut(i));
 11200                        }
 11201                        catch (Exception ex)
 11202                        {
 11203                            _logger.LogError(ex, "Error resolving shortcut file {File}", i);
 11204                            return null;
 11205                        }
 11206                    })
 11207                    .Where(i => i is not null)
 11208                    .Order()
 11209                    .ToArray(),
 11210
 11211                CollectionType = GetCollectionType(dir)
 11212            };
 1213
 11214            var libraryFolder = allCollectionFolders.FirstOrDefault(i => string.Equals(i.Path, dir, StringComparison.Ord
 11215            if (libraryFolder is not null)
 1216            {
 11217                var libraryFolderId = libraryFolder.Id.ToString("N", CultureInfo.InvariantCulture);
 11218                info.ItemId = libraryFolderId;
 11219                if (libraryFolder.HasImage(ImageType.Primary))
 1220                {
 01221                    info.PrimaryImageItemId = libraryFolderId;
 1222                }
 1223
 11224                info.LibraryOptions = GetLibraryOptions(libraryFolder);
 1225
 11226                if (refreshQueue is not null)
 1227                {
 11228                    info.RefreshProgress = libraryFolder.GetRefreshProgress();
 1229
 11230                    info.RefreshStatus = info.RefreshProgress.HasValue ? "Active" : refreshQueue.Contains(libraryFolder.
 1231                }
 1232            }
 1233
 11234            return info;
 1235        }
 1236
 1237        private CollectionTypeOptions? GetCollectionType(string path)
 1238        {
 11239            var files = _fileSystem.GetFilePaths(path, new[] { ".collection" }, true, false);
 21240            foreach (ReadOnlySpan<char> file in files)
 1241            {
 01242                if (Enum.TryParse<CollectionTypeOptions>(Path.GetFileNameWithoutExtension(file), true, out var res))
 1243                {
 01244                    return res;
 1245                }
 1246            }
 1247
 11248            return null;
 01249        }
 1250
 1251        /// <inheritdoc />
 1252        public BaseItem? GetItemById(Guid id)
 1253        {
 8111254            if (id.IsEmpty())
 1255            {
 01256                throw new ArgumentException("Guid can't be empty", nameof(id));
 1257            }
 1258
 8111259            if (_cache.TryGet(id, out var item))
 1260            {
 5801261                return item;
 1262            }
 1263
 2311264            item = RetrieveItem(id);
 1265
 2311266            if (item is not null)
 1267            {
 01268                RegisterItem(item);
 1269            }
 1270
 2311271            return item;
 1272        }
 1273
 1274        /// <inheritdoc />
 1275        public T? GetItemById<T>(Guid id)
 1276            where T : BaseItem
 1277        {
 231278            var item = GetItemById(id);
 231279            if (item is T typedItem)
 1280            {
 11281                return typedItem;
 1282            }
 1283
 221284            return null;
 1285        }
 1286
 1287        /// <inheritdoc />
 1288        public T? GetItemById<T>(Guid id, Guid userId)
 1289            where T : BaseItem
 1290        {
 11291            var user = userId.IsEmpty() ? null : _userManager.GetUserById(userId);
 11292            return GetItemById<T>(id, user);
 1293        }
 1294
 1295        /// <inheritdoc />
 1296        public T? GetItemById<T>(Guid id, User? user)
 1297            where T : BaseItem
 1298        {
 211299            var item = GetItemById<T>(id);
 211300            return ItemIsVisible(item, user) ? item : null;
 1301        }
 1302
 1303        public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query, bool allowExternalContent)
 1304        {
 611305            if (query.Recursive && !query.ParentId.IsEmpty())
 1306            {
 381307                var parent = GetItemById(query.ParentId);
 381308                if (parent is not null)
 1309                {
 381310                    SetTopParentIdsOrAncestors(query, new[] { parent });
 1311                }
 1312            }
 1313
 611314            if (query.User is not null)
 1315            {
 11316                AddUserToQuery(query, query.User, allowExternalContent);
 1317            }
 1318
 611319            var itemList = _itemRepository.GetItemList(query);
 601320            var user = query.User;
 601321            if (user is not null)
 1322            {
 11323                return itemList.Where(i => i.IsVisible(user)).ToList();
 1324            }
 1325
 591326            return itemList;
 1327        }
 1328
 1329        public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query)
 1330        {
 611331            return GetItemList(query, true);
 1332        }
 1333
 1334        public int GetCount(InternalItemsQuery query)
 1335        {
 01336            if (query.Recursive && !query.ParentId.IsEmpty())
 1337            {
 01338                var parent = GetItemById(query.ParentId);
 01339                if (parent is not null)
 1340                {
 01341                    SetTopParentIdsOrAncestors(query, new[] { parent });
 1342                }
 1343            }
 1344
 01345            if (query.User is not null)
 1346            {
 01347                AddUserToQuery(query, query.User);
 1348            }
 1349
 01350            return _itemRepository.GetCount(query);
 1351        }
 1352
 1353        public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
 1354        {
 01355            SetTopParentIdsOrAncestors(query, parents);
 1356
 01357            if (query.AncestorIds.Length == 0 && query.TopParentIds.Length == 0)
 1358            {
 01359                if (query.User is not null)
 1360                {
 01361                    AddUserToQuery(query, query.User);
 1362                }
 1363            }
 1364
 01365            return _itemRepository.GetItemList(query);
 1366        }
 1367
 1368        public IReadOnlyList<BaseItem> GetLatestItemList(InternalItemsQuery query, IReadOnlyList<BaseItem> parents, Coll
 1369        {
 01370            SetTopParentIdsOrAncestors(query, parents);
 1371
 01372            if (query.AncestorIds.Length == 0 && query.TopParentIds.Length == 0)
 1373            {
 01374                if (query.User is not null)
 1375                {
 01376                    AddUserToQuery(query, query.User);
 1377                }
 1378            }
 1379
 01380            return _itemRepository.GetLatestItemList(query, collectionType);
 1381        }
 1382
 1383        public IReadOnlyList<string> GetNextUpSeriesKeys(InternalItemsQuery query, IReadOnlyCollection<BaseItem> parents
 1384        {
 01385            SetTopParentIdsOrAncestors(query, parents);
 1386
 01387            if (query.AncestorIds.Length == 0 && query.TopParentIds.Length == 0)
 1388            {
 01389                if (query.User is not null)
 1390                {
 01391                    AddUserToQuery(query, query.User);
 1392                }
 1393            }
 1394
 01395            return _itemRepository.GetNextUpSeriesKeys(query, dateCutoff);
 1396        }
 1397
 1398        public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
 1399        {
 01400            if (query.User is not null)
 1401            {
 01402                AddUserToQuery(query, query.User);
 1403            }
 1404
 01405            if (query.EnableTotalRecordCount)
 1406            {
 01407                return _itemRepository.GetItems(query);
 1408            }
 1409
 01410            return new QueryResult<BaseItem>(
 01411                query.StartIndex,
 01412                null,
 01413                _itemRepository.GetItemList(query));
 1414        }
 1415
 1416        public IReadOnlyList<Guid> GetItemIds(InternalItemsQuery query)
 1417        {
 101418            if (query.User is not null)
 1419            {
 01420                AddUserToQuery(query, query.User);
 1421            }
 1422
 101423            return _itemRepository.GetItemIdsList(query);
 1424        }
 1425
 1426        public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetStudios(InternalItemsQuery query)
 1427        {
 01428            if (query.User is not null)
 1429            {
 01430                AddUserToQuery(query, query.User);
 1431            }
 1432
 01433            SetTopParentOrAncestorIds(query);
 01434            return _itemRepository.GetStudios(query);
 1435        }
 1436
 1437        public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetGenres(InternalItemsQuery query)
 1438        {
 01439            if (query.User is not null)
 1440            {
 01441                AddUserToQuery(query, query.User);
 1442            }
 1443
 01444            SetTopParentOrAncestorIds(query);
 01445            return _itemRepository.GetGenres(query);
 1446        }
 1447
 1448        public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetMusicGenres(InternalItemsQuery query)
 1449        {
 01450            if (query.User is not null)
 1451            {
 01452                AddUserToQuery(query, query.User);
 1453            }
 1454
 01455            SetTopParentOrAncestorIds(query);
 01456            return _itemRepository.GetMusicGenres(query);
 1457        }
 1458
 1459        public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAllArtists(InternalItemsQuery query)
 1460        {
 01461            if (query.User is not null)
 1462            {
 01463                AddUserToQuery(query, query.User);
 1464            }
 1465
 01466            SetTopParentOrAncestorIds(query);
 01467            return _itemRepository.GetAllArtists(query);
 1468        }
 1469
 1470        public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetArtists(InternalItemsQuery query)
 1471        {
 01472            if (query.User is not null)
 1473            {
 01474                AddUserToQuery(query, query.User);
 1475            }
 1476
 01477            SetTopParentOrAncestorIds(query);
 01478            return _itemRepository.GetArtists(query);
 1479        }
 1480
 1481        private void SetTopParentOrAncestorIds(InternalItemsQuery query)
 1482        {
 01483            var ancestorIds = query.AncestorIds;
 01484            int len = ancestorIds.Length;
 01485            if (len == 0)
 1486            {
 01487                return;
 1488            }
 1489
 01490            var parents = new BaseItem[len];
 01491            for (int i = 0; i < len; i++)
 1492            {
 01493                parents[i] = GetItemById(ancestorIds[i]) ?? throw new ArgumentException($"Failed to find parent with id:
 01494                if (parents[i] is not (ICollectionFolder or UserView))
 1495                {
 01496                    return;
 1497                }
 1498            }
 1499
 1500            // Optimize by querying against top level views
 01501            query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).ToArray();
 01502            query.AncestorIds = [];
 1503
 1504            // Prevent searching in all libraries due to empty filter
 01505            if (query.TopParentIds.Length == 0)
 1506            {
 01507                query.TopParentIds = [Guid.NewGuid()];
 1508            }
 01509        }
 1510
 1511        public QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAlbumArtists(InternalItemsQuery query)
 1512        {
 01513            if (query.User is not null)
 1514            {
 01515                AddUserToQuery(query, query.User);
 1516            }
 1517
 01518            SetTopParentOrAncestorIds(query);
 01519            return _itemRepository.GetAlbumArtists(query);
 1520        }
 1521
 1522        public QueryResult<BaseItem> GetItemsResult(InternalItemsQuery query)
 1523        {
 171524            if (query.Recursive && !query.ParentId.IsEmpty())
 1525            {
 161526                var parent = GetItemById(query.ParentId);
 161527                if (parent is not null)
 1528                {
 161529                    SetTopParentIdsOrAncestors(query, new[] { parent });
 1530                }
 1531            }
 1532
 171533            if (query.User is not null)
 1534            {
 11535                AddUserToQuery(query, query.User);
 1536            }
 1537
 171538            if (query.EnableTotalRecordCount)
 1539            {
 11540                return _itemRepository.GetItems(query);
 1541            }
 1542
 161543            return new QueryResult<BaseItem>(
 161544                query.StartIndex,
 161545                null,
 161546                _itemRepository.GetItemList(query));
 1547        }
 1548
 1549        private void SetTopParentIdsOrAncestors(InternalItemsQuery query, IReadOnlyCollection<BaseItem> parents)
 1550        {
 541551            if (parents.All(i => i is ICollectionFolder || i is UserView))
 1552            {
 1553                // Optimize by querying against top level views
 161554                query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).ToArray();
 1555
 1556                // Prevent searching in all libraries due to empty filter
 161557                if (query.TopParentIds.Length == 0)
 1558                {
 161559                    query.TopParentIds = new[] { Guid.NewGuid() };
 1560                }
 1561            }
 1562            else
 1563            {
 1564                // We need to be able to query from any arbitrary ancestor up the tree
 381565                query.AncestorIds = parents.SelectMany(i => i.GetIdsForAncestorQuery()).ToArray();
 1566
 1567                // Prevent searching in all libraries due to empty filter
 381568                if (query.AncestorIds.Length == 0)
 1569                {
 01570                    query.AncestorIds = new[] { Guid.NewGuid() };
 1571                }
 1572            }
 1573
 541574            query.Parent = null;
 541575        }
 1576
 1577        private void AddUserToQuery(InternalItemsQuery query, User user, bool allowExternalContent = true)
 1578        {
 21579            if (query.AncestorIds.Length == 0 &&
 21580                query.ParentId.IsEmpty() &&
 21581                query.ChannelIds.Count == 0 &&
 21582                query.TopParentIds.Length == 0 &&
 21583                string.IsNullOrEmpty(query.AncestorWithPresentationUniqueKey) &&
 21584                string.IsNullOrEmpty(query.SeriesPresentationUniqueKey) &&
 21585                query.ItemIds.Length == 0)
 1586            {
 11587                var userViews = UserViewManager.GetUserViews(new UserViewQuery
 11588                {
 11589                    User = user,
 11590                    IncludeHidden = true,
 11591                    IncludeExternalContent = allowExternalContent
 11592                });
 1593
 11594                query.TopParentIds = userViews.SelectMany(i => GetTopParentIdsForQuery(i, user)).ToArray();
 1595
 1596                // Prevent searching in all libraries due to empty filter
 11597                if (query.TopParentIds.Length == 0)
 1598                {
 11599                    query.TopParentIds = new[] { Guid.NewGuid() };
 1600                }
 1601            }
 21602        }
 1603
 1604        private IEnumerable<Guid> GetTopParentIdsForQuery(BaseItem item, User? user)
 1605        {
 161606            if (item is UserView view)
 1607            {
 01608                if (view.ViewType == CollectionType.livetv)
 1609                {
 01610                    return new[] { view.Id };
 1611                }
 1612
 1613                // Translate view into folders
 01614                if (!view.DisplayParentId.IsEmpty())
 1615                {
 01616                    var displayParent = GetItemById(view.DisplayParentId);
 01617                    if (displayParent is not null)
 1618                    {
 01619                        return GetTopParentIdsForQuery(displayParent, user);
 1620                    }
 1621
 01622                    return [];
 1623                }
 1624
 01625                if (!view.ParentId.IsEmpty())
 1626                {
 01627                    var displayParent = GetItemById(view.ParentId);
 01628                    if (displayParent is not null)
 1629                    {
 01630                        return GetTopParentIdsForQuery(displayParent, user);
 1631                    }
 1632
 01633                    return [];
 1634                }
 1635
 1636                // Handle grouping
 01637                if (user is not null && view.ViewType != CollectionType.unknown && UserView.IsEligibleForGrouping(view.V
 01638                    && user.GetPreference(PreferenceKind.GroupedFolders).Length > 0)
 1639                {
 01640                    return GetUserRootFolder()
 01641                        .GetChildren(user, true)
 01642                        .OfType<CollectionFolder>()
 01643                        .Where(i => i.CollectionType is null || i.CollectionType == view.ViewType)
 01644                        .Where(i => user.IsFolderGrouped(i.Id))
 01645                        .SelectMany(i => GetTopParentIdsForQuery(i, user));
 1646                }
 1647
 01648                return [];
 1649            }
 1650
 161651            if (item is CollectionFolder collectionFolder)
 1652            {
 161653                return collectionFolder.PhysicalFolderIds;
 1654            }
 1655
 01656            var topParent = item.GetTopParent();
 01657            if (topParent is not null)
 1658            {
 01659                return new[] { topParent.Id };
 1660            }
 1661
 01662            return [];
 1663        }
 1664
 1665        /// <summary>
 1666        /// Gets the intros.
 1667        /// </summary>
 1668        /// <param name="item">The item.</param>
 1669        /// <param name="user">The user.</param>
 1670        /// <returns>IEnumerable{System.String}.</returns>
 1671        public async Task<IEnumerable<Video>> GetIntros(BaseItem item, User user)
 1672        {
 1673            if (IntroProviders.Length == 0)
 1674            {
 1675                return [];
 1676            }
 1677
 1678            var tasks = IntroProviders
 1679                .Select(i => GetIntros(i, item, user));
 1680
 1681            var items = await Task.WhenAll(tasks).ConfigureAwait(false);
 1682
 1683            return items
 1684                .SelectMany(i => i)
 1685                .Select(ResolveIntro)
 1686                .Where(i => i is not null)!; // null values got filtered out
 1687        }
 1688
 1689        /// <summary>
 1690        /// Gets the intros.
 1691        /// </summary>
 1692        /// <param name="provider">The provider.</param>
 1693        /// <param name="item">The item.</param>
 1694        /// <param name="user">The user.</param>
 1695        /// <returns>Task&lt;IEnumerable&lt;IntroInfo&gt;&gt;.</returns>
 1696        private async Task<IEnumerable<IntroInfo>> GetIntros(IIntroProvider provider, BaseItem item, User user)
 1697        {
 1698            try
 1699            {
 1700                return await provider.GetIntros(item, user).ConfigureAwait(false);
 1701            }
 1702            catch (Exception ex)
 1703            {
 1704                _logger.LogError(ex, "Error getting intros");
 1705
 1706                return [];
 1707            }
 1708        }
 1709
 1710        /// <summary>
 1711        /// Resolves the intro.
 1712        /// </summary>
 1713        /// <param name="info">The info.</param>
 1714        /// <returns>Video.</returns>
 1715        private Video? ResolveIntro(IntroInfo info)
 1716        {
 01717            Video? video = null;
 1718
 01719            if (info.ItemId.HasValue)
 1720            {
 1721                // Get an existing item by Id
 01722                video = GetItemById(info.ItemId.Value) as Video;
 1723
 01724                if (video is null)
 1725                {
 01726                    _logger.LogError("Unable to locate item with Id {ID}.", info.ItemId.Value);
 1727                }
 1728            }
 01729            else if (!string.IsNullOrEmpty(info.Path))
 1730            {
 1731                try
 1732                {
 1733                    // Try to resolve the path into a video
 01734                    video = ResolvePath(_fileSystem.GetFileSystemInfo(info.Path)) as Video;
 1735
 01736                    if (video is null)
 1737                    {
 01738                        _logger.LogError("Intro resolver returned null for {Path}.", info.Path);
 1739                    }
 1740                    else
 1741                    {
 1742                        // Pull the saved db item that will include metadata
 01743                        var dbItem = GetItemById(video.Id) as Video;
 1744
 01745                        if (dbItem is not null)
 1746                        {
 01747                            video = dbItem;
 1748                        }
 1749                        else
 1750                        {
 01751                            return null;
 1752                        }
 1753                    }
 01754                }
 01755                catch (Exception ex)
 1756                {
 01757                    _logger.LogError(ex, "Error resolving path {Path}.", info.Path);
 01758                }
 1759            }
 1760            else
 1761            {
 01762                _logger.LogError("IntroProvider returned an IntroInfo with null Path and ItemId.");
 1763            }
 1764
 01765            return video;
 01766        }
 1767
 1768        /// <inheritdoc />
 1769        public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User? user, IEnumerable<ItemSortBy> sortBy, SortO
 1770        {
 11771            IOrderedEnumerable<BaseItem>? orderedItems = null;
 1772
 41773            foreach (var orderBy in sortBy.Select(o => GetComparer(o, user)).Where(c => c is not null))
 1774            {
 11775                if (orderBy is RandomComparer)
 1776                {
 01777                    var randomItems = items.ToArray();
 01778                    Random.Shared.Shuffle(randomItems);
 01779                    items = randomItems;
 1780                    // Items are no longer ordered at this point, so set orderedItems back to null
 01781                    orderedItems = null;
 1782                }
 11783                else if (orderedItems is null)
 1784                {
 11785                    orderedItems = sortOrder == SortOrder.Descending
 11786                        ? items.OrderByDescending(i => i, orderBy)
 11787                        : items.OrderBy(i => i, orderBy);
 1788                }
 1789                else
 1790                {
 01791                    orderedItems = sortOrder == SortOrder.Descending
 01792                        ? orderedItems!.ThenByDescending(i => i, orderBy)
 01793                        : orderedItems!.ThenBy(i => i, orderBy); // orderedItems is set during the first iteration
 1794                }
 1795            }
 1796
 11797            return orderedItems ?? items;
 1798        }
 1799
 1800        /// <inheritdoc />
 1801        public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User? user, IEnumerable<(ItemSortBy OrderBy, Sort
 1802        {
 01803            IOrderedEnumerable<BaseItem>? orderedItems = null;
 1804
 01805            foreach (var (name, sortOrder) in orderBy)
 1806            {
 01807                var comparer = GetComparer(name, user);
 01808                if (comparer is null)
 1809                {
 1810                    continue;
 1811                }
 1812
 01813                if (comparer is RandomComparer)
 1814                {
 01815                    var randomItems = items.ToArray();
 01816                    Random.Shared.Shuffle(randomItems);
 01817                    items = randomItems;
 1818                    // Items are no longer ordered at this point, so set orderedItems back to null
 01819                    orderedItems = null;
 1820                }
 01821                else if (orderedItems is null)
 1822                {
 01823                    orderedItems = sortOrder == SortOrder.Descending
 01824                        ? items.OrderByDescending(i => i, comparer)
 01825                        : items.OrderBy(i => i, comparer);
 1826                }
 1827                else
 1828                {
 01829                    orderedItems = sortOrder == SortOrder.Descending
 01830                        ? orderedItems!.ThenByDescending(i => i, comparer)
 01831                        : orderedItems!.ThenBy(i => i, comparer); // orderedItems is set during the first iteration
 1832                }
 1833            }
 1834
 01835            return orderedItems ?? items;
 1836        }
 1837
 1838        /// <summary>
 1839        /// Gets the comparer.
 1840        /// </summary>
 1841        /// <param name="name">The name.</param>
 1842        /// <param name="user">The user.</param>
 1843        /// <returns>IBaseItemComparer.</returns>
 1844        private IBaseItemComparer? GetComparer(ItemSortBy name, User? user)
 1845        {
 11846            var comparer = Comparers.FirstOrDefault(c => name == c.Type);
 1847
 1848            // If it requires a user, create a new one, and assign the user
 11849            if (comparer is IUserBaseItemComparer)
 1850            {
 01851                var userComparer = (IUserBaseItemComparer)Activator.CreateInstance(comparer.GetType())!; // only null fo
 1852
 01853                userComparer.User = user;
 01854                userComparer.UserManager = _userManager;
 01855                userComparer.UserDataRepository = _userDataRepository;
 1856
 01857                return userComparer;
 1858            }
 1859
 11860            return comparer;
 1861        }
 1862
 1863        /// <inheritdoc />
 1864        public void CreateItem(BaseItem item, BaseItem? parent)
 1865        {
 01866            CreateItems(new[] { item }, parent, CancellationToken.None);
 01867        }
 1868
 1869        /// <inheritdoc />
 1870        public void CreateItems(IReadOnlyList<BaseItem> items, BaseItem? parent, CancellationToken cancellationToken)
 1871        {
 21872            _itemRepository.SaveItems(items, cancellationToken);
 1873
 81874            foreach (var item in items)
 1875            {
 21876                RegisterItem(item);
 1877            }
 1878
 21879            if (ItemAdded is not null)
 1880            {
 81881                foreach (var item in items)
 1882                {
 1883                    // With the live tv guide this just creates too much noise
 21884                    if (item.SourceType != SourceType.Library)
 1885                    {
 1886                        continue;
 1887                    }
 1888
 1889                    try
 1890                    {
 21891                        ItemAdded(
 21892                            this,
 21893                            new ItemChangeEventArgs
 21894                            {
 21895                                Item = item,
 21896                                Parent = parent ?? item.GetParent()
 21897                            });
 21898                    }
 01899                    catch (Exception ex)
 1900                    {
 01901                        _logger.LogError(ex, "Error in ItemAdded event handler");
 01902                    }
 1903                }
 1904            }
 21905        }
 1906
 1907        private bool ImageNeedsRefresh(ItemImageInfo image)
 1908        {
 01909            if (image.Path is not null && image.IsLocalFile)
 1910            {
 01911                if (image.Width == 0 || image.Height == 0 || string.IsNullOrEmpty(image.BlurHash))
 1912                {
 01913                    return true;
 1914                }
 1915
 1916                try
 1917                {
 01918                    return _fileSystem.GetLastWriteTimeUtc(image.Path) != image.DateModified;
 1919                }
 01920                catch (Exception ex)
 1921                {
 01922                    _logger.LogError(ex, "Cannot get file info for {0}", image.Path);
 01923                    return false;
 1924                }
 1925            }
 1926
 01927            return image.Path is not null && !image.IsLocalFile;
 01928        }
 1929
 1930        /// <inheritdoc />
 1931        public async Task UpdateImagesAsync(BaseItem item, bool forceUpdate = false)
 1932        {
 1933            ArgumentNullException.ThrowIfNull(item);
 1934
 1935            var outdated = forceUpdate
 1936                ? item.ImageInfos.Where(i => i.Path is not null).ToArray()
 1937                : item.ImageInfos.Where(ImageNeedsRefresh).ToArray();
 1938            // Skip image processing if current or live tv source
 1939            if (outdated.Length == 0 || item.SourceType != SourceType.Library)
 1940            {
 1941                RegisterItem(item);
 1942                return;
 1943            }
 1944
 1945            foreach (var img in outdated)
 1946            {
 1947                var image = img;
 1948                if (!img.IsLocalFile)
 1949                {
 1950                    try
 1951                    {
 1952                        var index = item.GetImageIndex(img);
 1953                        image = await ConvertImageToLocal(item, img, index, true).ConfigureAwait(false);
 1954                    }
 1955                    catch (ArgumentException)
 1956                    {
 1957                        _logger.LogWarning("Cannot get image index for {ImagePath}", img.Path);
 1958                        continue;
 1959                    }
 1960                    catch (Exception ex) when (ex is InvalidOperationException or IOException)
 1961                    {
 1962                        _logger.LogWarning(ex, "Cannot fetch image from {ImagePath}", img.Path);
 1963                        continue;
 1964                    }
 1965                    catch (HttpRequestException ex)
 1966                    {
 1967                        _logger.LogWarning(ex, "Cannot fetch image from {ImagePath}. Http status code: {HttpStatus}", im
 1968                        continue;
 1969                    }
 1970                }
 1971
 1972                ImageDimensions size;
 1973                try
 1974                {
 1975                    size = _imageProcessor.GetImageDimensions(item, image);
 1976                    image.Width = size.Width;
 1977                    image.Height = size.Height;
 1978                }
 1979                catch (Exception ex)
 1980                {
 1981                    _logger.LogError(ex, "Cannot get image dimensions for {ImagePath}", image.Path);
 1982                    size = default;
 1983                    image.Width = 0;
 1984                    image.Height = 0;
 1985                }
 1986
 1987                try
 1988                {
 1989                    image.BlurHash = _imageProcessor.GetImageBlurHash(image.Path, size);
 1990                }
 1991                catch (Exception ex)
 1992                {
 1993                    _logger.LogError(ex, "Cannot compute blurhash for {ImagePath}", image.Path);
 1994                    image.BlurHash = string.Empty;
 1995                }
 1996
 1997                try
 1998                {
 1999                    image.DateModified = _fileSystem.GetLastWriteTimeUtc(image.Path);
 2000                }
 2001                catch (Exception ex)
 2002                {
 2003                    _logger.LogError(ex, "Cannot update DateModified for {ImagePath}", image.Path);
 2004                }
 2005            }
 2006
 2007            _itemRepository.SaveImages(item);
 2008            RegisterItem(item);
 2009        }
 2010
 2011        /// <inheritdoc />
 2012        public async Task UpdateItemsAsync(IReadOnlyList<BaseItem> items, BaseItem parent, ItemUpdateType updateReason, 
 2013        {
 2014            _itemRepository.SaveItems(items, cancellationToken);
 2015
 2016            foreach (var item in items)
 2017            {
 2018                await RunMetadataSavers(item, updateReason).ConfigureAwait(false);
 2019            }
 2020
 2021            if (ItemUpdated is not null)
 2022            {
 2023                foreach (var item in items)
 2024                {
 2025                    // With the live tv guide this just creates too much noise
 2026                    if (item.SourceType != SourceType.Library)
 2027                    {
 2028                        continue;
 2029                    }
 2030
 2031                    try
 2032                    {
 2033                        ItemUpdated(
 2034                            this,
 2035                            new ItemChangeEventArgs
 2036                            {
 2037                                Item = item,
 2038                                Parent = parent,
 2039                                UpdateReason = updateReason
 2040                            });
 2041                    }
 2042                    catch (Exception ex)
 2043                    {
 2044                        _logger.LogError(ex, "Error in ItemUpdated event handler");
 2045                    }
 2046                }
 2047            }
 2048        }
 2049
 2050        /// <inheritdoc />
 2051        public Task UpdateItemAsync(BaseItem item, BaseItem parent, ItemUpdateType updateReason, CancellationToken cance
 792052            => UpdateItemsAsync(new[] { item }, parent, updateReason, cancellationToken);
 2053
 2054        public async Task RunMetadataSavers(BaseItem item, ItemUpdateType updateReason)
 2055        {
 2056            if (item.IsFileProtocol)
 2057            {
 2058                await ProviderManager.SaveMetadataAsync(item, updateReason).ConfigureAwait(false);
 2059            }
 2060
 2061            item.DateLastSaved = DateTime.UtcNow;
 2062
 2063            await UpdateImagesAsync(item, updateReason >= ItemUpdateType.ImageUpdate).ConfigureAwait(false);
 2064        }
 2065
 2066        /// <summary>
 2067        /// Reports the item removed.
 2068        /// </summary>
 2069        /// <param name="item">The item.</param>
 2070        /// <param name="parent">The parent item.</param>
 2071        public void ReportItemRemoved(BaseItem item, BaseItem parent)
 2072        {
 22073            if (ItemRemoved is not null)
 2074            {
 2075                try
 2076                {
 22077                    ItemRemoved(
 22078                        this,
 22079                        new ItemChangeEventArgs
 22080                        {
 22081                            Item = item,
 22082                            Parent = parent
 22083                        });
 22084                }
 02085                catch (Exception ex)
 2086                {
 02087                    _logger.LogError(ex, "Error in ItemRemoved event handler");
 02088                }
 2089            }
 22090        }
 2091
 2092        /// <summary>
 2093        /// Retrieves the item.
 2094        /// </summary>
 2095        /// <param name="id">The id.</param>
 2096        /// <returns>BaseItem.</returns>
 2097        public BaseItem RetrieveItem(Guid id)
 2098        {
 2312099            return _itemRepository.RetrieveItem(id);
 2100        }
 2101
 2102        public List<Folder> GetCollectionFolders(BaseItem item)
 2103        {
 6252104            return GetCollectionFolders(item, GetUserRootFolder().Children.OfType<Folder>());
 2105        }
 2106
 2107        public List<Folder> GetCollectionFolders(BaseItem item, IEnumerable<Folder> allUserRootChildren)
 2108        {
 6692109            while (item is not null)
 2110            {
 6692111                var parent = item.GetParent();
 2112
 6692113                if (parent is AggregateFolder)
 2114                {
 2115                    break;
 2116                }
 2117
 6462118                if (parent is null)
 2119                {
 6022120                    var owner = item.GetOwner();
 2121
 6022122                    if (owner is null)
 2123                    {
 2124                        break;
 2125                    }
 2126
 02127                    item = owner;
 2128                }
 2129                else
 2130                {
 442131                    item = parent;
 2132                }
 2133            }
 2134
 6252135            if (item is null)
 2136            {
 02137                return new List<Folder>();
 2138            }
 2139
 6252140            return GetCollectionFoldersInternal(item, allUserRootChildren);
 2141        }
 2142
 2143        private static List<Folder> GetCollectionFoldersInternal(BaseItem item, IEnumerable<Folder> allUserRootChildren)
 2144        {
 6252145            return allUserRootChildren
 6252146                .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.
 6252147                .ToList();
 2148        }
 2149
 2150        public LibraryOptions GetLibraryOptions(BaseItem item)
 2151        {
 4152152            if (item is CollectionFolder collectionFolder)
 2153            {
 692154                return collectionFolder.GetLibraryOptions();
 2155            }
 2156
 2157            // List.Find is more performant than FirstOrDefault due to enumerator allocation
 3462158            return GetCollectionFolders(item)
 3462159                .Find(folder => folder is CollectionFolder) is CollectionFolder collectionFolder2
 3462160                ? collectionFolder2.GetLibraryOptions()
 3462161                : new LibraryOptions();
 2162        }
 2163
 2164        public CollectionType? GetContentType(BaseItem item)
 2165        {
 402166            var configuredContentType = GetConfiguredContentType(item, false);
 402167            if (configuredContentType is not null)
 2168            {
 02169                return configuredContentType;
 2170            }
 2171
 402172            configuredContentType = GetConfiguredContentType(item, true);
 402173            if (configuredContentType is not null)
 2174            {
 02175                return configuredContentType;
 2176            }
 2177
 402178            return GetInheritedContentType(item);
 2179        }
 2180
 2181        public CollectionType? GetInheritedContentType(BaseItem item)
 2182        {
 402183            var type = GetTopFolderContentType(item);
 2184
 402185            if (type is not null)
 2186            {
 02187                return type;
 2188            }
 2189
 402190            return item.GetParents()
 402191                .Select(GetConfiguredContentType)
 402192                .LastOrDefault(i => i is not null);
 2193        }
 2194
 2195        public CollectionType? GetConfiguredContentType(BaseItem item)
 2196        {
 02197            return GetConfiguredContentType(item, false);
 2198        }
 2199
 2200        public CollectionType? GetConfiguredContentType(string path)
 2201        {
 02202            return GetContentTypeOverride(path, false);
 2203        }
 2204
 2205        public CollectionType? GetConfiguredContentType(BaseItem item, bool inheritConfiguredPath)
 2206        {
 802207            if (item is ICollectionFolder collectionFolder)
 2208            {
 02209                return collectionFolder.CollectionType;
 2210            }
 2211
 802212            return GetContentTypeOverride(item.ContainingFolderPath, inheritConfiguredPath);
 2213        }
 2214
 2215        private CollectionType? GetContentTypeOverride(string path, bool inherit)
 2216        {
 1002217            var nameValuePair = _configurationManager.Configuration.ContentTypes
 1002218                                    .FirstOrDefault(i => _fileSystem.AreEqual(i.Name, path)
 1002219                                                         || (inherit && !string.IsNullOrEmpty(i.Name)
 1002220                                                                     && _fileSystem.ContainsSubPath(i.Name, path)));
 1002221            if (Enum.TryParse<CollectionType>(nameValuePair?.Value, out var collectionType))
 2222            {
 02223                return collectionType;
 2224            }
 2225
 1002226            return null;
 2227        }
 2228
 2229        private CollectionType? GetTopFolderContentType(BaseItem item)
 2230        {
 402231            if (item is null)
 2232            {
 02233                return null;
 2234            }
 2235
 402236            while (!item.ParentId.IsEmpty())
 2237            {
 02238                var parent = item.GetParent();
 02239                if (parent is null || parent is AggregateFolder)
 2240                {
 2241                    break;
 2242                }
 2243
 02244                item = parent;
 2245            }
 2246
 402247            return GetUserRootFolder().Children
 402248                .OfType<ICollectionFolder>()
 402249                .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.
 402250                .Select(i => i.CollectionType)
 402251                .FirstOrDefault(i => i is not null);
 2252        }
 2253
 2254        public UserView GetNamedView(
 2255            User user,
 2256            string name,
 2257            CollectionType? viewType,
 2258            string sortName)
 2259        {
 02260            return GetNamedView(user, name, Guid.Empty, viewType, sortName);
 2261        }
 2262
 2263        public UserView GetNamedView(
 2264            string name,
 2265            CollectionType viewType,
 2266            string sortName)
 2267        {
 02268            var path = Path.Combine(
 02269                _configurationManager.ApplicationPaths.InternalMetadataPath,
 02270                "views",
 02271                _fileSystem.GetValidFilename(viewType.ToString()));
 2272
 02273            var id = GetNewItemId(path + "_namedview_" + name, typeof(UserView));
 2274
 02275            var item = GetItemById(id) as UserView;
 2276
 02277            var refresh = false;
 2278
 02279            if (item is null || !string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
 2280            {
 02281                Directory.CreateDirectory(path);
 2282
 02283                item = new UserView
 02284                {
 02285                    Path = path,
 02286                    Id = id,
 02287                    DateCreated = DateTime.UtcNow,
 02288                    Name = name,
 02289                    ViewType = viewType,
 02290                    ForcedSortName = sortName
 02291                };
 2292
 02293                CreateItem(item, null);
 2294
 02295                refresh = true;
 2296            }
 2297
 02298            if (refresh)
 2299            {
 02300                item.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, CancellationToken.None).GetAwaiter().GetResu
 02301                ProviderManager.QueueRefresh(item.Id, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), Ref
 2302            }
 2303
 02304            return item;
 2305        }
 2306
 2307        public UserView GetNamedView(
 2308            User user,
 2309            string name,
 2310            Guid parentId,
 2311            CollectionType? viewType,
 2312            string sortName)
 2313        {
 02314            var parentIdString = parentId.IsEmpty()
 02315                ? null
 02316                : parentId.ToString("N", CultureInfo.InvariantCulture);
 02317            var idValues = "38_namedview_" + name + user.Id.ToString("N", CultureInfo.InvariantCulture) + (parentIdStrin
 2318
 02319            var id = GetNewItemId(idValues, typeof(UserView));
 2320
 02321            var path = Path.Combine(_configurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N
 2322
 02323            var item = GetItemById(id) as UserView;
 2324
 02325            var isNew = false;
 2326
 02327            if (item is null)
 2328            {
 02329                Directory.CreateDirectory(path);
 2330
 02331                item = new UserView
 02332                {
 02333                    Path = path,
 02334                    Id = id,
 02335                    DateCreated = DateTime.UtcNow,
 02336                    Name = name,
 02337                    ViewType = viewType,
 02338                    ForcedSortName = sortName,
 02339                    UserId = user.Id,
 02340                    DisplayParentId = parentId
 02341                };
 2342
 02343                CreateItem(item, null);
 2344
 02345                isNew = true;
 2346            }
 2347
 02348            var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
 2349
 02350            if (!refresh && !item.DisplayParentId.IsEmpty())
 2351            {
 02352                var displayParent = GetItemById(item.DisplayParentId);
 02353                refresh = displayParent is not null && displayParent.DateLastSaved > item.DateLastRefreshed;
 2354            }
 2355
 02356            if (refresh)
 2357            {
 02358                ProviderManager.QueueRefresh(
 02359                    item.Id,
 02360                    new MetadataRefreshOptions(new DirectoryService(_fileSystem))
 02361                    {
 02362                        // Need to force save to increment DateLastSaved
 02363                        ForceSave = true
 02364                    },
 02365                    RefreshPriority.Normal);
 2366            }
 2367
 02368            return item;
 2369        }
 2370
 2371        public UserView GetShadowView(
 2372            BaseItem parent,
 2373            CollectionType? viewType,
 2374            string sortName)
 2375        {
 02376            ArgumentNullException.ThrowIfNull(parent);
 2377
 02378            var name = parent.Name;
 02379            var parentId = parent.Id;
 2380
 02381            var idValues = "38_namedview_" + name + parentId + (viewType?.ToString() ?? string.Empty);
 2382
 02383            var id = GetNewItemId(idValues, typeof(UserView));
 2384
 02385            var path = parent.Path;
 2386
 02387            var item = GetItemById(id) as UserView;
 2388
 02389            var isNew = false;
 2390
 02391            if (item is null)
 2392            {
 02393                Directory.CreateDirectory(path);
 2394
 02395                item = new UserView
 02396                {
 02397                    Path = path,
 02398                    Id = id,
 02399                    DateCreated = DateTime.UtcNow,
 02400                    Name = name,
 02401                    ViewType = viewType,
 02402                    ForcedSortName = sortName
 02403                };
 2404
 02405                item.DisplayParentId = parentId;
 2406
 02407                CreateItem(item, null);
 2408
 02409                isNew = true;
 2410            }
 2411
 02412            var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
 2413
 02414            if (!refresh && !item.DisplayParentId.IsEmpty())
 2415            {
 02416                var displayParent = GetItemById(item.DisplayParentId);
 02417                refresh = displayParent is not null && displayParent.DateLastSaved > item.DateLastRefreshed;
 2418            }
 2419
 02420            if (refresh)
 2421            {
 02422                ProviderManager.QueueRefresh(
 02423                    item.Id,
 02424                    new MetadataRefreshOptions(new DirectoryService(_fileSystem))
 02425                    {
 02426                        // Need to force save to increment DateLastSaved
 02427                        ForceSave = true
 02428                    },
 02429                    RefreshPriority.Normal);
 2430            }
 2431
 02432            return item;
 2433        }
 2434
 2435        public UserView GetNamedView(
 2436            string name,
 2437            Guid parentId,
 2438            CollectionType? viewType,
 2439            string sortName,
 2440            string uniqueId)
 2441        {
 02442            ArgumentException.ThrowIfNullOrEmpty(name);
 2443
 02444            var parentIdString = parentId.IsEmpty()
 02445                ? null
 02446                : parentId.ToString("N", CultureInfo.InvariantCulture);
 02447            var idValues = "37_namedview_" + name + (parentIdString ?? string.Empty) + (viewType?.ToString() ?? string.E
 02448            if (!string.IsNullOrEmpty(uniqueId))
 2449            {
 02450                idValues += uniqueId;
 2451            }
 2452
 02453            var id = GetNewItemId(idValues, typeof(UserView));
 2454
 02455            var path = Path.Combine(_configurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N
 2456
 02457            var item = GetItemById(id) as UserView;
 2458
 02459            var isNew = false;
 2460
 02461            if (item is null)
 2462            {
 02463                Directory.CreateDirectory(path);
 2464
 02465                item = new UserView
 02466                {
 02467                    Path = path,
 02468                    Id = id,
 02469                    DateCreated = DateTime.UtcNow,
 02470                    Name = name,
 02471                    ViewType = viewType,
 02472                    ForcedSortName = sortName
 02473                };
 2474
 02475                item.DisplayParentId = parentId;
 2476
 02477                CreateItem(item, null);
 2478
 02479                isNew = true;
 2480            }
 2481
 02482            if (viewType != item.ViewType)
 2483            {
 02484                item.ViewType = viewType;
 02485                item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult
 2486            }
 2487
 02488            var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
 2489
 02490            if (!refresh && !item.DisplayParentId.IsEmpty())
 2491            {
 02492                var displayParent = GetItemById(item.DisplayParentId);
 02493                refresh = displayParent is not null && displayParent.DateLastSaved > item.DateLastRefreshed;
 2494            }
 2495
 02496            if (refresh)
 2497            {
 02498                ProviderManager.QueueRefresh(
 02499                    item.Id,
 02500                    new MetadataRefreshOptions(new DirectoryService(_fileSystem))
 02501                    {
 02502                        // Need to force save to increment DateLastSaved
 02503                        ForceSave = true
 02504                    },
 02505                    RefreshPriority.Normal);
 2506            }
 2507
 02508            return item;
 2509        }
 2510
 2511        public BaseItem GetParentItem(Guid? parentId, Guid? userId)
 2512        {
 32513            if (parentId.HasValue)
 2514            {
 02515                return GetItemById(parentId.Value) ?? throw new ArgumentException($"Invalid parent id: {parentId.Value}"
 2516            }
 2517
 32518            if (!userId.IsNullOrEmpty())
 2519            {
 32520                return GetUserRootFolder();
 2521            }
 2522
 02523            return RootFolder;
 2524        }
 2525
 2526        /// <inheritdoc />
 2527        public void QueueLibraryScan()
 2528        {
 02529            _taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
 02530        }
 2531
 2532        /// <inheritdoc />
 2533        public int? GetSeasonNumberFromPath(string path, Guid? parentId)
 2534        {
 02535            var parentPath = parentId.HasValue ? GetItemById(parentId.Value)?.ContainingFolderPath : null;
 02536            return SeasonPathParser.Parse(path, parentPath, true, true).SeasonNumber;
 2537        }
 2538
 2539        /// <inheritdoc />
 2540        public bool FillMissingEpisodeNumbersFromPath(Episode episode, bool forceRefresh)
 2541        {
 02542            var series = episode.Series;
 02543            bool? isAbsoluteNaming = series is not null && string.Equals(series.DisplayOrder, "absolute", StringComparis
 02544            if (!isAbsoluteNaming.Value)
 2545            {
 2546                // In other words, no filter applied
 02547                isAbsoluteNaming = null;
 2548            }
 2549
 02550            var resolver = new EpisodeResolver(_namingOptions);
 2551
 02552            var isFolder = episode.VideoType == VideoType.BluRay || episode.VideoType == VideoType.Dvd;
 2553
 2554            // TODO nullable - what are we trying to do there with empty episodeInfo?
 02555            EpisodeInfo? episodeInfo = null;
 02556            if (episode.IsFileProtocol)
 2557            {
 02558                episodeInfo = resolver.Resolve(episode.Path, isFolder, null, null, isAbsoluteNaming);
 2559                // Resolve from parent folder if it's not the Season folder
 02560                var parent = episode.GetParent();
 02561                if (episodeInfo is null && parent.GetType() == typeof(Folder))
 2562                {
 02563                    episodeInfo = resolver.Resolve(parent.Path, true, null, null, isAbsoluteNaming);
 02564                    if (episodeInfo is not null)
 2565                    {
 2566                        // add the container
 02567                        episodeInfo.Container = Path.GetExtension(episode.Path)?.TrimStart('.');
 2568                    }
 2569                }
 2570            }
 2571
 02572            episodeInfo ??= new EpisodeInfo(episode.Path);
 2573
 2574            try
 2575            {
 02576                var libraryOptions = GetLibraryOptions(episode);
 02577                if (libraryOptions.EnableEmbeddedEpisodeInfos && string.Equals(episodeInfo.Container, "mp4", StringCompa
 2578                {
 2579                    // Read from metadata
 02580                    var mediaInfo = _mediaEncoder.GetMediaInfo(
 02581                        new MediaInfoRequest
 02582                        {
 02583                            MediaSource = episode.GetMediaSources(false)[0],
 02584                            MediaType = DlnaProfileType.Video
 02585                        },
 02586                        CancellationToken.None).GetAwaiter().GetResult();
 02587                    if (mediaInfo.ParentIndexNumber > 0)
 2588                    {
 02589                        episodeInfo.SeasonNumber = mediaInfo.ParentIndexNumber;
 2590                    }
 2591
 02592                    if (mediaInfo.IndexNumber > 0)
 2593                    {
 02594                        episodeInfo.EpisodeNumber = mediaInfo.IndexNumber;
 2595                    }
 2596
 02597                    if (!string.IsNullOrEmpty(mediaInfo.ShowName))
 2598                    {
 02599                        episodeInfo.SeriesName = mediaInfo.ShowName;
 2600                    }
 2601                }
 02602            }
 02603            catch (Exception ex)
 2604            {
 02605                _logger.LogError(ex, "Error reading the episode information with ffprobe. Episode: {EpisodeInfo}", episo
 02606            }
 2607
 02608            var changed = false;
 2609
 02610            if (episodeInfo.IsByDate)
 2611            {
 02612                if (episode.IndexNumber.HasValue)
 2613                {
 02614                    episode.IndexNumber = null;
 02615                    changed = true;
 2616                }
 2617
 02618                if (episode.IndexNumberEnd.HasValue)
 2619                {
 02620                    episode.IndexNumberEnd = null;
 02621                    changed = true;
 2622                }
 2623
 02624                if (!episode.PremiereDate.HasValue)
 2625                {
 02626                    if (episodeInfo.Year.HasValue && episodeInfo.Month.HasValue && episodeInfo.Day.HasValue)
 2627                    {
 02628                        episode.PremiereDate = new DateTime(episodeInfo.Year.Value, episodeInfo.Month.Value, episodeInfo
 2629                    }
 2630
 02631                    if (episode.PremiereDate.HasValue)
 2632                    {
 02633                        changed = true;
 2634                    }
 2635                }
 2636
 02637                if (!episode.ProductionYear.HasValue)
 2638                {
 02639                    episode.ProductionYear = episodeInfo.Year;
 2640
 02641                    if (episode.ProductionYear.HasValue)
 2642                    {
 02643                        changed = true;
 2644                    }
 2645                }
 2646            }
 2647            else
 2648            {
 02649                if (!episode.IndexNumber.HasValue || forceRefresh)
 2650                {
 02651                    if (episode.IndexNumber != episodeInfo.EpisodeNumber)
 2652                    {
 02653                        changed = true;
 2654                    }
 2655
 02656                    episode.IndexNumber = episodeInfo.EpisodeNumber;
 2657                }
 2658
 02659                if (!episode.IndexNumberEnd.HasValue || forceRefresh)
 2660                {
 02661                    if (episode.IndexNumberEnd != episodeInfo.EndingEpisodeNumber)
 2662                    {
 02663                        changed = true;
 2664                    }
 2665
 02666                    episode.IndexNumberEnd = episodeInfo.EndingEpisodeNumber;
 2667                }
 2668
 02669                if (!episode.ParentIndexNumber.HasValue || forceRefresh)
 2670                {
 02671                    if (episode.ParentIndexNumber != episodeInfo.SeasonNumber)
 2672                    {
 02673                        changed = true;
 2674                    }
 2675
 02676                    episode.ParentIndexNumber = episodeInfo.SeasonNumber;
 2677                }
 2678            }
 2679
 02680            if (!episode.ParentIndexNumber.HasValue)
 2681            {
 02682                var season = episode.Season;
 2683
 02684                if (season is not null)
 2685                {
 02686                    episode.ParentIndexNumber = season.IndexNumber;
 2687                }
 2688
 02689                if (episode.ParentIndexNumber.HasValue)
 2690                {
 02691                    changed = true;
 2692                }
 2693            }
 2694
 02695            return changed;
 2696        }
 2697
 2698        public ItemLookupInfo ParseName(string name)
 2699        {
 02700            var namingOptions = _namingOptions;
 02701            var result = VideoResolver.CleanDateTime(name, namingOptions);
 2702
 02703            return new ItemLookupInfo
 02704            {
 02705                Name = VideoResolver.TryCleanString(result.Name, namingOptions, out var newName) ? newName : result.Name
 02706                Year = result.Year
 02707            };
 2708        }
 2709
 2710        public IEnumerable<BaseItem> FindExtras(BaseItem owner, IReadOnlyList<FileSystemMetadata> fileSystemChildren, ID
 2711        {
 2712            var ownerVideoInfo = VideoResolver.Resolve(owner.Path, owner.IsFolder, _namingOptions, libraryRoot: owner.Co
 2713            if (ownerVideoInfo is null)
 2714            {
 2715                yield break;
 2716            }
 2717
 2718            var count = fileSystemChildren.Count;
 2719            for (var i = 0; i < count; i++)
 2720            {
 2721                var current = fileSystemChildren[i];
 2722                if (current.IsDirectory && _namingOptions.AllExtrasTypesFolderNames.ContainsKey(current.Name))
 2723                {
 2724                    var filesInSubFolder = _fileSystem.GetFiles(current.FullName, null, false, false);
 2725                    foreach (var file in filesInSubFolder)
 2726                    {
 2727                        if (!_extraResolver.TryGetExtraTypeForOwner(file.FullName, ownerVideoInfo, out var extraType))
 2728                        {
 2729                            continue;
 2730                        }
 2731
 2732                        var extra = GetExtra(file, extraType.Value);
 2733                        if (extra is not null)
 2734                        {
 2735                            yield return extra;
 2736                        }
 2737                    }
 2738                }
 2739                else if (!current.IsDirectory && _extraResolver.TryGetExtraTypeForOwner(current.FullName, ownerVideoInfo
 2740                {
 2741                    var extra = GetExtra(current, extraType.Value);
 2742                    if (extra is not null)
 2743                    {
 2744                        yield return extra;
 2745                    }
 2746                }
 2747            }
 2748
 2749            BaseItem? GetExtra(FileSystemMetadata file, ExtraType extraType)
 2750            {
 2751                var extra = ResolvePath(_fileSystem.GetFileInfo(file.FullName), directoryService, _extraResolver.GetReso
 2752                if (extra is not Video && extra is not Audio)
 2753                {
 2754                    return null;
 2755                }
 2756
 2757                // Try to retrieve it from the db. If we don't find it, use the resolved version
 2758                var itemById = GetItemById(extra.Id);
 2759                if (itemById is not null)
 2760                {
 2761                    extra = itemById;
 2762                }
 2763
 2764                // Only update extra type if it is more specific then the currently known extra type
 2765                if (extra.ExtraType is null or ExtraType.Unknown || extraType != ExtraType.Unknown)
 2766                {
 2767                    extra.ExtraType = extraType;
 2768                }
 2769
 2770                extra.ParentId = Guid.Empty;
 2771                extra.OwnerId = owner.Id;
 2772                return extra;
 2773            }
 2774        }
 2775
 2776        public string GetPathAfterNetworkSubstitution(string path, BaseItem? ownerItem)
 2777        {
 122778            foreach (var map in _configurationManager.Configuration.PathSubstitutions)
 2779            {
 02780                if (path.TryReplaceSubPath(map.From, map.To, out var newPath))
 2781                {
 02782                    return newPath;
 2783                }
 2784            }
 2785
 62786            return path;
 2787        }
 2788
 2789        public IReadOnlyList<PersonInfo> GetPeople(InternalPeopleQuery query)
 2790        {
 02791            return _peopleRepository.GetPeople(query);
 2792        }
 2793
 2794        public IReadOnlyList<PersonInfo> GetPeople(BaseItem item)
 2795        {
 592796            if (item.SupportsPeople)
 2797            {
 02798                var people = GetPeople(new InternalPeopleQuery
 02799                {
 02800                    ItemId = item.Id
 02801                });
 2802
 02803                if (people.Count > 0)
 2804                {
 02805                    return people;
 2806                }
 2807            }
 2808
 592809            return [];
 2810        }
 2811
 2812        public IReadOnlyList<Person> GetPeopleItems(InternalPeopleQuery query)
 2813        {
 02814            return _peopleRepository.GetPeopleNames(query)
 02815            .Select(i =>
 02816            {
 02817                try
 02818                {
 02819                    return GetPerson(i);
 02820                }
 02821                catch (Exception ex)
 02822                {
 02823                    _logger.LogError(ex, "Error getting person");
 02824                    return null;
 02825                }
 02826            })
 02827            .Where(i => i is not null)
 02828            .Where(i => query.User is null || i!.IsVisible(query.User))
 02829            .ToList()!; // null values are filtered out
 2830        }
 2831
 2832        public IReadOnlyList<string> GetPeopleNames(InternalPeopleQuery query)
 2833        {
 02834            return _peopleRepository.GetPeopleNames(query);
 2835        }
 2836
 2837        public void UpdatePeople(BaseItem item, List<PersonInfo> people)
 2838        {
 02839            UpdatePeopleAsync(item, people, CancellationToken.None).GetAwaiter().GetResult();
 02840        }
 2841
 2842        /// <inheritdoc />
 2843        public async Task UpdatePeopleAsync(BaseItem item, IReadOnlyList<PersonInfo> people, CancellationToken cancellat
 2844        {
 2845            if (!item.SupportsPeople)
 2846            {
 2847                return;
 2848            }
 2849
 2850            if (people is not null)
 2851            {
 2852                people = people.Where(e => e is not null).ToArray();
 2853                _peopleRepository.UpdatePeople(item.Id, people);
 2854                await SavePeopleMetadataAsync(people, cancellationToken).ConfigureAwait(false);
 2855            }
 2856        }
 2857
 2858        public async Task<ItemImageInfo> ConvertImageToLocal(BaseItem item, ItemImageInfo image, int imageIndex, bool re
 2859        {
 2860            foreach (var url in image.Path.Split('|'))
 2861            {
 2862                try
 2863                {
 2864                    _logger.LogDebug("ConvertImageToLocal item {0} - image url: {1}", item.Id, url);
 2865
 2866                    await ProviderManager.SaveImage(item, url, image.Type, imageIndex, CancellationToken.None).Configure
 2867
 2868                    await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwai
 2869
 2870                    return item.GetImageInfo(image.Type, imageIndex);
 2871                }
 2872                catch (HttpRequestException ex)
 2873                {
 2874                    if (ex.StatusCode.HasValue
 2875                        && (ex.StatusCode.Value == HttpStatusCode.NotFound || ex.StatusCode.Value == HttpStatusCode.Forb
 2876                    {
 2877                        _logger.LogDebug(ex, "Error downloading image {Url}", url);
 2878                        continue;
 2879                    }
 2880
 2881                    throw;
 2882                }
 2883            }
 2884
 2885            if (removeOnFailure)
 2886            {
 2887                // Remove this image to prevent it from retrying over and over
 2888                item.RemoveImage(image);
 2889                await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(fa
 2890            }
 2891
 2892            throw new InvalidOperationException("Unable to convert any images to local");
 2893        }
 2894
 2895        public async Task AddVirtualFolder(string name, CollectionTypeOptions? collectionType, LibraryOptions options, b
 2896        {
 2897            if (string.IsNullOrWhiteSpace(name))
 2898            {
 2899                throw new ArgumentNullException(nameof(name));
 2900            }
 2901
 2902            name = _fileSystem.GetValidFilename(name);
 2903
 2904            var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
 2905
 2906            var existingNameCount = 1; // first numbered name will be 2
 2907            var virtualFolderPath = Path.Combine(rootFolderPath, name);
 2908            var originalName = name;
 2909            while (Directory.Exists(virtualFolderPath))
 2910            {
 2911                existingNameCount++;
 2912                name = originalName + existingNameCount;
 2913                virtualFolderPath = Path.Combine(rootFolderPath, name);
 2914            }
 2915
 2916            var mediaPathInfos = options.PathInfos;
 2917            if (mediaPathInfos is not null)
 2918            {
 2919                var invalidpath = mediaPathInfos.FirstOrDefault(i => !Directory.Exists(i.Path));
 2920                if (invalidpath is not null)
 2921                {
 2922                    throw new ArgumentException("The specified path does not exist: " + invalidpath.Path + ".");
 2923                }
 2924            }
 2925
 2926            LibraryMonitor.Stop();
 2927
 2928            try
 2929            {
 2930                Directory.CreateDirectory(virtualFolderPath);
 2931
 2932                if (collectionType is not null)
 2933                {
 2934                    var path = Path.Combine(virtualFolderPath, collectionType.ToString()!.ToLowerInvariant() + ".collect
 2935
 2936                    await File.WriteAllBytesAsync(path, []).ConfigureAwait(false);
 2937                }
 2938
 2939                CollectionFolder.SaveLibraryOptions(virtualFolderPath, options);
 2940
 2941                if (mediaPathInfos is not null)
 2942                {
 2943                    foreach (var path in mediaPathInfos)
 2944                    {
 2945                        AddMediaPathInternal(name, path, false);
 2946                    }
 2947                }
 2948            }
 2949            finally
 2950            {
 2951                if (refreshLibrary)
 2952                {
 2953                    await ValidateTopLibraryFolders(CancellationToken.None).ConfigureAwait(false);
 2954
 2955                    StartScanInBackground();
 2956                }
 2957                else
 2958                {
 2959                    // Need to add a delay here or directory watchers may still pick up the changes
 2960                    await Task.Delay(1000).ConfigureAwait(false);
 2961                    LibraryMonitor.Start();
 2962                }
 2963            }
 2964        }
 2965
 2966        private async Task SavePeopleMetadataAsync(IEnumerable<PersonInfo> people, CancellationToken cancellationToken)
 2967        {
 2968            foreach (var person in people)
 2969            {
 2970                cancellationToken.ThrowIfCancellationRequested();
 2971
 2972                var itemUpdateType = ItemUpdateType.MetadataDownload;
 2973                var saveEntity = false;
 2974                var createEntity = false;
 2975                var personEntity = GetPerson(person.Name);
 2976
 2977                if (personEntity is null)
 2978                {
 2979                    var path = Person.GetPath(person.Name);
 2980                    personEntity = new Person()
 2981                    {
 2982                        Name = person.Name,
 2983                        Id = GetItemByNameId<Person>(path),
 2984                        DateCreated = DateTime.UtcNow,
 2985                        DateModified = DateTime.UtcNow,
 2986                        Path = path
 2987                    };
 2988
 2989                    personEntity.PresentationUniqueKey = personEntity.CreatePresentationUniqueKey();
 2990                    saveEntity = true;
 2991                    createEntity = true;
 2992                }
 2993
 2994                foreach (var id in person.ProviderIds)
 2995                {
 2996                    if (!string.Equals(personEntity.GetProviderId(id.Key), id.Value, StringComparison.OrdinalIgnoreCase)
 2997                    {
 2998                        personEntity.SetProviderId(id.Key, id.Value);
 2999                        saveEntity = true;
 3000                    }
 3001                }
 3002
 3003                if (!string.IsNullOrWhiteSpace(person.ImageUrl) && !personEntity.HasImage(ImageType.Primary))
 3004                {
 3005                    personEntity.SetImage(
 3006                        new ItemImageInfo
 3007                        {
 3008                            Path = person.ImageUrl,
 3009                            Type = ImageType.Primary
 3010                        },
 3011                        0);
 3012
 3013                    saveEntity = true;
 3014                    itemUpdateType = ItemUpdateType.ImageUpdate;
 3015                }
 3016
 3017                if (saveEntity)
 3018                {
 3019                    if (createEntity)
 3020                    {
 3021                        CreateItems([personEntity], null, CancellationToken.None);
 3022                    }
 3023
 3024                    await RunMetadataSavers(personEntity, itemUpdateType).ConfigureAwait(false);
 3025                    CreateItems([personEntity], null, CancellationToken.None);
 3026                }
 3027            }
 3028        }
 3029
 3030        private void StartScanInBackground()
 3031        {
 33032            Task.Run(() =>
 33033            {
 33034                // No need to start if scanning the library because it will handle it
 33035                ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
 33036            });
 33037        }
 3038
 3039        public void AddMediaPath(string virtualFolderName, MediaPathInfo mediaPath)
 3040        {
 13041            AddMediaPathInternal(virtualFolderName, mediaPath, true);
 03042        }
 3043
 3044        private void AddMediaPathInternal(string virtualFolderName, MediaPathInfo pathInfo, bool saveLibraryOptions)
 3045        {
 13046            ArgumentNullException.ThrowIfNull(pathInfo);
 3047
 13048            var path = pathInfo.Path;
 3049
 13050            if (string.IsNullOrWhiteSpace(path))
 3051            {
 03052                throw new ArgumentException(nameof(path));
 3053            }
 3054
 13055            if (!Directory.Exists(path))
 3056            {
 13057                throw new FileNotFoundException("The path does not exist.");
 3058            }
 3059
 03060            var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
 03061            var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
 3062
 03063            var shortcutFilename = Path.GetFileNameWithoutExtension(path);
 3064
 03065            var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
 3066
 03067            while (File.Exists(lnk))
 3068            {
 03069                shortcutFilename += "1";
 03070                lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
 3071            }
 3072
 03073            _fileSystem.CreateShortcut(lnk, _appHost.ReverseVirtualPath(path));
 3074
 03075            RemoveContentTypeOverrides(path);
 3076
 03077            if (saveLibraryOptions)
 3078            {
 03079                var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
 3080
 03081                libraryOptions.PathInfos = [.. libraryOptions.PathInfos, pathInfo];
 3082
 03083                SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
 3084
 03085                CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
 3086            }
 03087        }
 3088
 3089        public void UpdateMediaPath(string virtualFolderName, MediaPathInfo mediaPath)
 3090        {
 03091            ArgumentNullException.ThrowIfNull(mediaPath);
 3092
 03093            var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
 03094            var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
 3095
 03096            var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
 3097
 03098            SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
 3099
 03100            CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
 03101        }
 3102
 3103        private void SyncLibraryOptionsToLocations(string virtualFolderPath, LibraryOptions options)
 3104        {
 03105            var topLibraryFolders = GetUserRootFolder().Children.ToList();
 03106            var info = GetVirtualFolderInfo(virtualFolderPath, topLibraryFolders, null);
 3107
 03108            if (info.Locations.Length > 0 && info.Locations.Length != options.PathInfos.Length)
 3109            {
 03110                var list = options.PathInfos.ToList();
 3111
 03112                foreach (var location in info.Locations)
 3113                {
 03114                    if (!list.Any(i => string.Equals(i.Path, location, StringComparison.Ordinal)))
 3115                    {
 03116                        list.Add(new MediaPathInfo(location));
 3117                    }
 3118                }
 3119
 03120                options.PathInfos = list.ToArray();
 3121            }
 03122        }
 3123
 3124        public async Task RemoveVirtualFolder(string name, bool refreshLibrary)
 3125        {
 3126            if (string.IsNullOrWhiteSpace(name))
 3127            {
 3128                throw new ArgumentNullException(nameof(name));
 3129            }
 3130
 3131            var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
 3132
 3133            var path = Path.Combine(rootFolderPath, name);
 3134
 3135            if (!Directory.Exists(path))
 3136            {
 3137                throw new FileNotFoundException("The media folder does not exist");
 3138            }
 3139
 3140            LibraryMonitor.Stop();
 3141
 3142            try
 3143            {
 3144                Directory.Delete(path, true);
 3145            }
 3146            finally
 3147            {
 3148                CollectionFolder.OnCollectionFolderChange();
 3149
 3150                if (refreshLibrary)
 3151                {
 3152                    await ValidateTopLibraryFolders(CancellationToken.None, true).ConfigureAwait(false);
 3153
 3154                    StartScanInBackground();
 3155                }
 3156                else
 3157                {
 3158                    // Need to add a delay here or directory watchers may still pick up the changes
 3159                    await Task.Delay(1000).ConfigureAwait(false);
 3160                    LibraryMonitor.Start();
 3161                }
 3162            }
 3163        }
 3164
 3165        private void RemoveContentTypeOverrides(string path)
 3166        {
 03167            if (string.IsNullOrWhiteSpace(path))
 3168            {
 03169                throw new ArgumentNullException(nameof(path));
 3170            }
 3171
 03172            List<NameValuePair>? removeList = null;
 3173
 03174            foreach (var contentType in _configurationManager.Configuration.ContentTypes)
 3175            {
 03176                if (string.IsNullOrWhiteSpace(contentType.Name)
 03177                    || _fileSystem.AreEqual(path, contentType.Name)
 03178                    || _fileSystem.ContainsSubPath(path, contentType.Name))
 3179                {
 03180                    (removeList ??= new()).Add(contentType);
 3181                }
 3182            }
 3183
 03184            if (removeList is not null)
 3185            {
 03186                _configurationManager.Configuration.ContentTypes = _configurationManager.Configuration.ContentTypes
 03187                    .Except(removeList)
 03188                    .ToArray();
 3189
 03190                _configurationManager.SaveConfiguration();
 3191            }
 03192        }
 3193
 3194        public void RemoveMediaPath(string virtualFolderName, string mediaPath)
 3195        {
 13196            ArgumentException.ThrowIfNullOrEmpty(mediaPath);
 3197
 13198            var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
 13199            var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
 3200
 13201            if (!Directory.Exists(virtualFolderPath))
 3202            {
 13203                throw new FileNotFoundException(
 13204                    string.Format(CultureInfo.InvariantCulture, "The media collection {0} does not exist", virtualFolder
 3205            }
 3206
 03207            var shortcut = _fileSystem.GetFilePaths(virtualFolderPath, true)
 03208                .Where(i => Path.GetExtension(i.AsSpan()).Equals(ShortcutFileExtension, StringComparison.OrdinalIgnoreCa
 03209                .FirstOrDefault(f => _appHost.ExpandVirtualPath(_fileSystem.ResolveShortcut(f)).Equals(mediaPath, String
 3210
 03211            if (!string.IsNullOrEmpty(shortcut))
 3212            {
 03213                _fileSystem.DeleteFile(shortcut);
 3214            }
 3215
 03216            var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
 3217
 03218            libraryOptions.PathInfos = libraryOptions
 03219                .PathInfos
 03220                .Where(i => !string.Equals(i.Path, mediaPath, StringComparison.Ordinal))
 03221                .ToArray();
 3222
 03223            CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
 03224        }
 3225
 3226        private static bool ItemIsVisible(BaseItem? item, User? user)
 3227        {
 213228            if (item is null)
 3229            {
 213230                return false;
 3231            }
 3232
 03233            if (user is null)
 3234            {
 03235                return true;
 3236            }
 3237
 03238            return item is UserRootFolder || item.IsVisibleStandalone(user);
 3239        }
 3240    }
 3241}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:20 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Controller.IServerApplicationHost,Microsoft.Extensions.Logging.ILoggerFactory,MediaBrowser.Model.Tasks.ITaskManager,MediaBrowser.Controller.Library.IUserManager,MediaBrowser.Controller.Configuration.IServerConfigurationManager,MediaBrowser.Controller.Library.IUserDataManager,System.Lazy`1<MediaBrowser.Controller.Library.ILibraryMonitor>,MediaBrowser.Model.IO.IFileSystem,System.Lazy`1<MediaBrowser.Controller.Providers.IProviderManager>,System.Lazy`1<MediaBrowser.Controller.Library.IUserViewManager>,MediaBrowser.Controller.MediaEncoding.IMediaEncoder,MediaBrowser.Controller.Persistence.IItemRepository,MediaBrowser.Controller.Drawing.IImageProcessor,Emby.Naming.Common.NamingOptions,MediaBrowser.Controller.Providers.IDirectoryService,MediaBrowser.Controller.Persistence.IPeopleRepository,MediaBrowser.Controller.IO.IPathManager)
get_RootFolder()
get_LibraryMonitor()
get_ProviderManager()
get_UserViewManager()
AddParts(System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Resolvers.IResolverIgnoreRule>,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Resolvers.IItemResolver>,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Library.IIntroProvider>,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Sorting.IBaseItemComparer>,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Library.ILibraryPostScanTask>)
RecordConfigurationValues(MediaBrowser.Model.Configuration.ServerConfiguration)
ConfigurationUpdated(System.Object,System.EventArgs)
RegisterItem(MediaBrowser.Controller.Entities.BaseItem)
DeleteItem(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Library.DeleteOptions)
DeleteItem(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Library.DeleteOptions,System.Boolean)
DeleteItem(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Library.DeleteOptions,MediaBrowser.Controller.Entities.BaseItem,System.Boolean)
GetMetadataPaths(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>)
GetInternalMetadataPaths(MediaBrowser.Controller.Entities.BaseItem)
ResolveItem(MediaBrowser.Controller.Library.ItemResolveArgs,MediaBrowser.Controller.Resolvers.IItemResolver[])
Resolve(MediaBrowser.Controller.Library.ItemResolveArgs,MediaBrowser.Controller.Resolvers.IItemResolver)
GetNewItemId(System.String,System.Type)
GetNewItemIdInternal(System.String,System.Type,System.Boolean)
ResolvePath(MediaBrowser.Model.IO.FileSystemMetadata,MediaBrowser.Controller.Entities.Folder,MediaBrowser.Controller.Providers.IDirectoryService)
ResolvePath(MediaBrowser.Model.IO.FileSystemMetadata,MediaBrowser.Controller.Providers.IDirectoryService,MediaBrowser.Controller.Resolvers.IItemResolver[],MediaBrowser.Controller.Entities.Folder,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,MediaBrowser.Model.Configuration.LibraryOptions)
IgnoreFile(MediaBrowser.Model.IO.FileSystemMetadata,MediaBrowser.Controller.Entities.BaseItem)
NormalizeRootPathList(System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.IO.FileSystemMetadata>)
ShouldResolvePathContents(MediaBrowser.Controller.Library.ItemResolveArgs)
ResolvePaths(System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.IO.FileSystemMetadata>,MediaBrowser.Controller.Providers.IDirectoryService,MediaBrowser.Controller.Entities.Folder,MediaBrowser.Model.Configuration.LibraryOptions,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>)
ResolvePaths(System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.IO.FileSystemMetadata>,MediaBrowser.Controller.Providers.IDirectoryService,MediaBrowser.Controller.Entities.Folder,MediaBrowser.Model.Configuration.LibraryOptions,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,MediaBrowser.Controller.Resolvers.IItemResolver[])
CreateRootFolder()
GetUserRootFolder()
FindByPath(System.String,System.Nullable`1<System.Boolean>)
GetPerson(System.String)
GetStudio(System.String)
GetStudioId(System.String)
GetGenreId(System.String)
GetMusicGenreId(System.String)
GetGenre(System.String)
GetMusicGenre(System.String)
GetYear(System.Int32)
GetArtist(System.String)
GetArtist(System.String,MediaBrowser.Controller.Dto.DtoOptions)
CreateItemByName(System.Func`2<System.String,System.String>,System.String,MediaBrowser.Controller.Dto.DtoOptions)
GetItemByNameId(System.String)
ValidatePeopleAsync(System.IProgress`1<System.Double>,System.Threading.CancellationToken)
ValidateMediaLibrary(System.IProgress`1<System.Double>,System.Threading.CancellationToken)
GetVirtualFolders()
GetVirtualFolders(System.Boolean)
GetVirtualFolderInfo(System.String,System.Collections.Generic.List`1<MediaBrowser.Controller.Entities.BaseItem>,System.Collections.Generic.HashSet`1<System.Guid>)
GetCollectionType(System.String)
GetItemById(System.Guid)
GetItemById(System.Guid)
GetItemById(System.Guid,System.Guid)
GetItemById(System.Guid,Jellyfin.Database.Implementations.Entities.User)
GetItemList(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Boolean)
GetItemList(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetCount(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetItemList(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Collections.Generic.List`1<MediaBrowser.Controller.Entities.BaseItem>)
GetLatestItemList(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,Jellyfin.Data.Enums.CollectionType)
GetNextUpSeriesKeys(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Collections.Generic.IReadOnlyCollection`1<MediaBrowser.Controller.Entities.BaseItem>,System.DateTime)
QueryItems(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetItemIds(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetStudios(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetGenres(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetMusicGenres(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetAllArtists(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetArtists(MediaBrowser.Controller.Entities.InternalItemsQuery)
SetTopParentOrAncestorIds(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetAlbumArtists(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetItemsResult(MediaBrowser.Controller.Entities.InternalItemsQuery)
SetTopParentIdsOrAncestors(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Collections.Generic.IReadOnlyCollection`1<MediaBrowser.Controller.Entities.BaseItem>)
AddUserToQuery(MediaBrowser.Controller.Entities.InternalItemsQuery,Jellyfin.Database.Implementations.Entities.User,System.Boolean)
GetTopParentIdsForQuery(MediaBrowser.Controller.Entities.BaseItem,Jellyfin.Database.Implementations.Entities.User)
ResolveIntro(MediaBrowser.Controller.Library.IntroInfo)
Sort(System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,Jellyfin.Database.Implementations.Entities.User,System.Collections.Generic.IEnumerable`1<Jellyfin.Data.Enums.ItemSortBy>,Jellyfin.Database.Implementations.Enums.SortOrder)
Sort(System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.BaseItem>,Jellyfin.Database.Implementations.Entities.User,System.Collections.Generic.IEnumerable`1<System.ValueTuple`2<Jellyfin.Data.Enums.ItemSortBy,Jellyfin.Database.Implementations.Enums.SortOrder>>)
GetComparer(Jellyfin.Data.Enums.ItemSortBy,Jellyfin.Database.Implementations.Entities.User)
CreateItem(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.BaseItem)
CreateItems(System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,MediaBrowser.Controller.Entities.BaseItem,System.Threading.CancellationToken)
ImageNeedsRefresh(MediaBrowser.Controller.Entities.ItemImageInfo)
UpdateItemAsync(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Library.ItemUpdateType,System.Threading.CancellationToken)
ReportItemRemoved(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.BaseItem)
RetrieveItem(System.Guid)
GetCollectionFolders(MediaBrowser.Controller.Entities.BaseItem)
GetCollectionFolders(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.Folder>)
GetCollectionFoldersInternal(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Entities.Folder>)
GetLibraryOptions(MediaBrowser.Controller.Entities.BaseItem)
GetContentType(MediaBrowser.Controller.Entities.BaseItem)
GetInheritedContentType(MediaBrowser.Controller.Entities.BaseItem)
GetConfiguredContentType(MediaBrowser.Controller.Entities.BaseItem)
GetConfiguredContentType(System.String)
GetConfiguredContentType(MediaBrowser.Controller.Entities.BaseItem,System.Boolean)
GetContentTypeOverride(System.String,System.Boolean)
GetTopFolderContentType(MediaBrowser.Controller.Entities.BaseItem)
GetNamedView(Jellyfin.Database.Implementations.Entities.User,System.String,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,System.String)
GetNamedView(System.String,Jellyfin.Data.Enums.CollectionType,System.String)
GetNamedView(Jellyfin.Database.Implementations.Entities.User,System.String,System.Guid,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,System.String)
GetShadowView(MediaBrowser.Controller.Entities.BaseItem,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,System.String)
GetNamedView(System.String,System.Guid,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,System.String,System.String)
GetParentItem(System.Nullable`1<System.Guid>,System.Nullable`1<System.Guid>)
QueueLibraryScan()
GetSeasonNumberFromPath(System.String,System.Nullable`1<System.Guid>)
FillMissingEpisodeNumbersFromPath(MediaBrowser.Controller.Entities.TV.Episode,System.Boolean)
ParseName(System.String)
GetPathAfterNetworkSubstitution(System.String,MediaBrowser.Controller.Entities.BaseItem)
GetPeople(MediaBrowser.Controller.Entities.InternalPeopleQuery)
GetPeople(MediaBrowser.Controller.Entities.BaseItem)
GetPeopleItems(MediaBrowser.Controller.Entities.InternalPeopleQuery)
GetPeopleNames(MediaBrowser.Controller.Entities.InternalPeopleQuery)
UpdatePeople(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.List`1<MediaBrowser.Controller.Entities.PersonInfo>)
StartScanInBackground()
AddMediaPath(System.String,MediaBrowser.Model.Configuration.MediaPathInfo)
AddMediaPathInternal(System.String,MediaBrowser.Model.Configuration.MediaPathInfo,System.Boolean)
UpdateMediaPath(System.String,MediaBrowser.Model.Configuration.MediaPathInfo)
SyncLibraryOptionsToLocations(System.String,MediaBrowser.Model.Configuration.LibraryOptions)
RemoveContentTypeOverrides(System.String)
RemoveMediaPath(System.String,System.String)
ItemIsVisible(MediaBrowser.Controller.Entities.BaseItem,Jellyfin.Database.Implementations.Entities.User)