jellyfin/Emby.Server.Implementations/Collections/CollectionManager.cs

423 lines
15 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
using System.Globalization;
2014-03-06 05:17:13 +00:00
using System.IO;
using System.Linq;
2014-03-06 05:17:13 +00:00
using System.Threading;
using System.Threading.Tasks;
2020-05-20 17:07:53 +00:00
using Jellyfin.Data.Entities;
2018-09-12 17:26:21 +00:00
using MediaBrowser.Common.Configuration;
using MediaBrowser.Controller.Collections;
2018-09-12 17:26:21 +00:00
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Library;
2018-09-12 17:26:21 +00:00
using MediaBrowser.Controller.Plugins;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Configuration;
using MediaBrowser.Model.Entities;
2018-09-12 17:26:21 +00:00
using MediaBrowser.Model.Globalization;
using MediaBrowser.Model.IO;
using Microsoft.Extensions.Logging;
2014-03-06 05:17:13 +00:00
namespace Emby.Server.Implementations.Collections
2014-03-06 05:17:13 +00:00
{
/// <summary>
/// The collection manager.
/// </summary>
2014-03-06 05:17:13 +00:00
public class CollectionManager : ICollectionManager
{
private readonly ILibraryManager _libraryManager;
private readonly IFileSystem _fileSystem;
private readonly ILibraryMonitor _iLibraryMonitor;
2020-06-06 00:15:56 +00:00
private readonly ILogger<CollectionManager> _logger;
2015-09-29 16:29:06 +00:00
private readonly IProviderManager _providerManager;
2018-09-12 17:26:21 +00:00
private readonly ILocalizationManager _localizationManager;
2019-12-30 15:03:20 +00:00
private readonly IApplicationPaths _appPaths;
2014-07-08 01:41:03 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="CollectionManager"/> class.
/// </summary>
/// <param name="libraryManager">The library manager.</param>
/// <param name="appPaths">The application paths.</param>
/// <param name="localizationManager">The localization manager.</param>
/// <param name="fileSystem">The filesystem.</param>
/// <param name="iLibraryMonitor">The library monitor.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="providerManager">The provider manager.</param>
public CollectionManager(
ILibraryManager libraryManager,
IApplicationPaths appPaths,
ILocalizationManager localizationManager,
IFileSystem fileSystem,
ILibraryMonitor iLibraryMonitor,
ILoggerFactory loggerFactory,
IProviderManager providerManager)
2014-03-06 05:17:13 +00:00
{
_libraryManager = libraryManager;
_fileSystem = fileSystem;
_iLibraryMonitor = iLibraryMonitor;
2020-06-06 00:15:56 +00:00
_logger = loggerFactory.CreateLogger<CollectionManager>();
2015-09-29 16:29:06 +00:00
_providerManager = providerManager;
2018-09-12 17:26:21 +00:00
_localizationManager = localizationManager;
_appPaths = appPaths;
2014-03-06 05:17:13 +00:00
}
/// <inheritdoc />
2019-12-30 15:03:20 +00:00
public event EventHandler<CollectionCreatedEventArgs> CollectionCreated;
/// <inheritdoc />
2019-12-30 15:03:20 +00:00
public event EventHandler<CollectionModifiedEventArgs> ItemsAddedToCollection;
/// <inheritdoc />
2019-12-30 15:03:20 +00:00
public event EventHandler<CollectionModifiedEventArgs> ItemsRemovedFromCollection;
2018-09-12 17:26:21 +00:00
private IEnumerable<Folder> FindFolders(string path)
2014-07-01 04:06:28 +00:00
{
2018-09-12 17:26:21 +00:00
return _libraryManager
.RootFolder
.Children
.OfType<Folder>()
.Where(i => _fileSystem.AreEqual(path, i.Path) || _fileSystem.ContainsSubPath(i.Path, path));
2014-07-01 04:06:28 +00:00
}
2018-09-12 17:26:21 +00:00
internal async Task<Folder> EnsureLibraryFolder(string path, bool createIfNeeded)
2015-01-24 19:03:55 +00:00
{
2018-09-12 17:26:21 +00:00
var existingFolders = FindFolders(path)
.ToList();
if (existingFolders.Count > 0)
{
return existingFolders[0];
}
if (!createIfNeeded)
{
return null;
}
Directory.CreateDirectory(path);
2018-09-12 17:26:21 +00:00
var libraryOptions = new LibraryOptions
{
PathInfos = new[] { new MediaPathInfo { Path = path } },
EnableRealtimeMonitor = false,
SaveLocalMetadata = true
};
var name = _localizationManager.GetLocalizedString("Collections");
await _libraryManager.AddVirtualFolder(name, CollectionType.BoxSets, libraryOptions, true).ConfigureAwait(false);
return FindFolders(path).First();
}
internal string GetCollectionsFolderPath()
{
return Path.Combine(_appPaths.DataPath, "collections");
}
private Task<Folder> GetCollectionsFolder(bool createIfNeeded)
{
return EnsureLibraryFolder(GetCollectionsFolderPath(), createIfNeeded);
}
2020-05-20 17:07:53 +00:00
private IEnumerable<BoxSet> GetCollections(User user)
2018-09-12 17:26:21 +00:00
{
var folder = GetCollectionsFolder(false).Result;
2020-04-11 10:03:10 +00:00
return folder == null
? Enumerable.Empty<BoxSet>()
: folder.GetChildren(user, true).OfType<BoxSet>();
2015-01-24 19:03:55 +00:00
}
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public BoxSet CreateCollection(CollectionCreationOptions options)
2014-03-06 05:17:13 +00:00
{
var name = options.Name;
2014-03-08 04:20:31 +00:00
// Need to use the [boxset] suffix
// If internet metadata is not found, or if xml saving is off there will be no collection.xml
// This could cause it to get re-resolved as a plain folder
var folderName = _fileSystem.GetValidFilename(name) + " [boxset]";
2014-03-06 05:17:13 +00:00
2019-10-25 10:47:20 +00:00
var parentFolder = GetCollectionsFolder(true).GetAwaiter().GetResult();
2014-03-06 05:17:13 +00:00
if (parentFolder == null)
{
throw new ArgumentException();
}
var path = Path.Combine(parentFolder.Path, folderName);
_iLibraryMonitor.ReportFileSystemChangeBeginning(path);
try
{
Directory.CreateDirectory(path);
2014-03-06 05:17:13 +00:00
var collection = new BoxSet
{
Name = name,
Path = path,
2014-04-27 03:42:05 +00:00
IsLocked = options.IsLocked,
2014-12-13 03:56:30 +00:00
ProviderIds = options.ProviderIds,
2018-09-12 17:26:21 +00:00
DateCreated = DateTime.UtcNow
2014-03-06 05:17:13 +00:00
};
parentFolder.AddChild(collection, CancellationToken.None);
2014-03-06 05:17:13 +00:00
2017-08-19 19:43:35 +00:00
if (options.ItemIdList.Length > 0)
2014-03-15 15:17:46 +00:00
{
2019-09-10 20:37:53 +00:00
AddToCollection(collection.Id, options.ItemIdList, false, new MetadataRefreshOptions(new DirectoryService(_fileSystem))
2015-10-14 05:02:30 +00:00
{
// The initial adding of items is going to create a local metadata file
// This will cause internet metadata to be skipped as a result
MetadataRefreshMode = MetadataRefreshMode.FullRefresh
});
2014-03-15 15:17:46 +00:00
}
2015-09-29 16:29:06 +00:00
else
{
2019-09-10 20:37:53 +00:00
_providerManager.QueueRefresh(collection.Id, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), RefreshPriority.High);
2015-09-29 16:29:06 +00:00
}
2014-03-15 15:17:46 +00:00
CollectionCreated?.Invoke(this, new CollectionCreatedEventArgs
2014-07-08 01:41:03 +00:00
{
Collection = collection,
Options = options
});
2014-07-08 01:41:03 +00:00
2014-03-15 15:17:46 +00:00
return collection;
2014-03-06 05:17:13 +00:00
}
finally
{
// Refresh handled internally
_iLibraryMonitor.ReportFileSystemChangeComplete(path, false);
}
}
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public void AddToCollection(Guid collectionId, IEnumerable<string> ids)
2014-03-06 05:17:13 +00:00
{
2019-09-10 20:37:53 +00:00
AddToCollection(collectionId, ids, true, new MetadataRefreshOptions(new DirectoryService(_fileSystem)));
2014-07-08 01:41:03 +00:00
}
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public void AddToCollection(Guid collectionId, IEnumerable<Guid> ids)
2017-08-20 21:07:47 +00:00
{
2019-09-10 20:37:53 +00:00
AddToCollection(collectionId, ids.Select(i => i.ToString("N", CultureInfo.InvariantCulture)), true, new MetadataRefreshOptions(new DirectoryService(_fileSystem)));
2017-08-20 21:07:47 +00:00
}
2018-09-12 17:26:21 +00:00
private void AddToCollection(Guid collectionId, IEnumerable<string> ids, bool fireEvent, MetadataRefreshOptions refreshOptions)
2014-03-06 05:17:13 +00:00
{
var collection = _libraryManager.GetItemById(collectionId) as BoxSet;
if (collection == null)
{
throw new ArgumentException("No collection exists with the supplied Id");
}
var list = new List<LinkedChild>();
2014-07-08 01:41:03 +00:00
var itemList = new List<BaseItem>();
2018-09-12 17:26:21 +00:00
var linkedChildrenList = collection.GetLinkedChildren();
var currentLinkedChildrenIds = linkedChildrenList.Select(i => i.Id).ToList();
2017-08-20 21:07:47 +00:00
foreach (var id in ids)
{
2017-08-20 21:07:47 +00:00
var guidId = new Guid(id);
2017-08-19 19:43:35 +00:00
var item = _libraryManager.GetItemById(guidId);
if (item == null)
{
throw new ArgumentException("No item exists with the supplied Id");
}
2017-08-19 19:43:35 +00:00
if (!currentLinkedChildrenIds.Contains(guidId))
{
2018-09-12 17:26:21 +00:00
itemList.Add(item);
2015-10-07 21:42:29 +00:00
list.Add(LinkedChild.Create(item));
2018-09-12 17:26:21 +00:00
linkedChildrenList.Add(item);
}
}
2015-10-07 21:42:29 +00:00
if (list.Count > 0)
{
2017-08-10 18:01:31 +00:00
var newList = collection.LinkedChildren.ToList();
newList.AddRange(list);
2018-12-28 15:48:26 +00:00
collection.LinkedChildren = newList.ToArray();
2018-09-12 17:26:21 +00:00
collection.UpdateRatingToItems(linkedChildrenList);
2017-10-03 18:39:37 +00:00
collection.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None);
2015-09-29 16:29:06 +00:00
2018-09-12 17:26:21 +00:00
refreshOptions.ForceSave = true;
2017-04-30 02:37:51 +00:00
_providerManager.QueueRefresh(collection.Id, refreshOptions, RefreshPriority.High);
2014-07-08 01:41:03 +00:00
2015-10-07 21:42:29 +00:00
if (fireEvent)
2014-07-08 01:41:03 +00:00
{
ItemsAddedToCollection?.Invoke(this, new CollectionModifiedEventArgs
2015-10-07 21:42:29 +00:00
{
Collection = collection,
ItemsChanged = itemList
});
2015-10-07 21:42:29 +00:00
}
2014-07-08 01:41:03 +00:00
}
}
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public void RemoveFromCollection(Guid collectionId, IEnumerable<string> itemIds)
2017-08-20 21:07:47 +00:00
{
2018-09-12 17:26:21 +00:00
RemoveFromCollection(collectionId, itemIds.Select(i => new Guid(i)));
2017-08-20 21:07:47 +00:00
}
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public void RemoveFromCollection(Guid collectionId, IEnumerable<Guid> itemIds)
{
var collection = _libraryManager.GetItemById(collectionId) as BoxSet;
if (collection == null)
{
throw new ArgumentException("No collection exists with the supplied Id");
}
var list = new List<LinkedChild>();
2014-07-08 01:41:03 +00:00
var itemList = new List<BaseItem>();
2017-08-20 21:07:47 +00:00
foreach (var guidId in itemIds)
{
2017-08-19 19:43:35 +00:00
var childItem = _libraryManager.GetItemById(guidId);
2016-10-10 18:18:28 +00:00
2017-08-19 19:43:35 +00:00
var child = collection.LinkedChildren.FirstOrDefault(i => (i.ItemId.HasValue && i.ItemId.Value == guidId) || (childItem != null && string.Equals(childItem.Path, i.Path, StringComparison.OrdinalIgnoreCase)));
if (child == null)
{
_logger.LogWarning("No collection title exists with the supplied Id");
2018-09-12 17:26:21 +00:00
continue;
}
list.Add(child);
2014-03-15 04:14:07 +00:00
2014-07-08 01:41:03 +00:00
if (childItem != null)
{
itemList.Add(childItem);
}
}
2017-08-10 18:01:31 +00:00
if (list.Count > 0)
{
2017-08-10 18:01:31 +00:00
collection.LinkedChildren = collection.LinkedChildren.Except(list).ToArray();
}
2017-10-03 18:39:37 +00:00
collection.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None);
2020-04-11 10:03:10 +00:00
_providerManager.QueueRefresh(
collection.Id,
new MetadataRefreshOptions(new DirectoryService(_fileSystem))
{
ForceSave = true
},
RefreshPriority.High);
2014-07-08 01:41:03 +00:00
ItemsRemovedFromCollection?.Invoke(this, new CollectionModifiedEventArgs
2014-07-08 01:41:03 +00:00
{
Collection = collection,
ItemsChanged = itemList
});
2014-03-06 05:17:13 +00:00
}
2014-04-22 17:25:54 +00:00
/// <inheritdoc />
2020-05-20 17:07:53 +00:00
public IEnumerable<BaseItem> CollapseItemsWithinBoxSets(IEnumerable<BaseItem> items, User user)
2014-04-22 17:25:54 +00:00
{
2015-01-22 16:41:34 +00:00
var results = new Dictionary<Guid, BaseItem>();
2015-01-24 19:03:55 +00:00
var allBoxsets = GetCollections(user).ToList();
2014-04-22 17:25:54 +00:00
2015-01-22 16:41:34 +00:00
foreach (var item in items)
2014-04-22 17:25:54 +00:00
{
if (!(item is ISupportsBoxSetGrouping))
2015-01-22 16:41:34 +00:00
{
results[item.Id] = item;
}
else
2014-04-22 17:25:54 +00:00
{
2015-01-22 16:41:34 +00:00
var itemId = item.Id;
var currentBoxSets = allBoxsets
2018-09-12 17:26:21 +00:00
.Where(i => i.ContainsLinkedChildByItemId(itemId))
2015-01-22 16:41:34 +00:00
.ToList();
if (currentBoxSets.Count > 0)
{
foreach (var boxset in currentBoxSets)
{
results[boxset.Id] = boxset;
}
}
else
{
results[item.Id] = item;
}
2014-04-22 17:25:54 +00:00
}
}
2015-01-22 16:41:34 +00:00
return results.Values;
2014-04-22 17:25:54 +00:00
}
2014-03-06 05:17:13 +00:00
}
2018-09-12 17:26:21 +00:00
/// <summary>
/// The collection manager entry point.
/// </summary>
2019-12-30 15:03:20 +00:00
public sealed class CollectionManagerEntryPoint : IServerEntryPoint
2018-09-12 17:26:21 +00:00
{
private readonly CollectionManager _collectionManager;
private readonly IServerConfigurationManager _config;
2020-06-06 00:15:56 +00:00
private readonly ILogger<CollectionManagerEntryPoint> _logger;
2018-09-12 17:26:21 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="CollectionManagerEntryPoint"/> class.
/// </summary>
/// <param name="collectionManager">The collection manager.</param>
/// <param name="config">The server configuration manager.</param>
/// <param name="logger">The logger.</param>
public CollectionManagerEntryPoint(
ICollectionManager collectionManager,
IServerConfigurationManager config,
ILogger<CollectionManagerEntryPoint> logger)
2018-09-12 17:26:21 +00:00
{
_collectionManager = (CollectionManager)collectionManager;
_config = config;
_logger = logger;
}
2019-12-30 15:03:20 +00:00
/// <inheritdoc />
2019-01-27 14:40:37 +00:00
public async Task RunAsync()
2018-09-12 17:26:21 +00:00
{
if (!_config.Configuration.CollectionsUpgraded && _config.Configuration.IsStartupWizardCompleted)
{
var path = _collectionManager.GetCollectionsFolderPath();
if (Directory.Exists(path))
2018-09-12 17:26:21 +00:00
{
try
{
await _collectionManager.EnsureLibraryFolder(path, true).ConfigureAwait(false);
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error creating camera uploads library");
2018-09-12 17:26:21 +00:00
}
_config.Configuration.CollectionsUpgraded = true;
_config.SaveConfiguration();
}
}
}
2019-12-30 15:03:20 +00:00
/// <inheritdoc />
2018-09-12 17:26:21 +00:00
public void Dispose()
{
2019-12-30 15:03:20 +00:00
// Nothing to dispose
2018-09-12 17:26:21 +00:00
}
}
2014-03-06 05:17:13 +00:00
}