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

320 lines
11 KiB
C#
Raw Normal View History

2014-07-08 01:41:03 +00:00
using MediaBrowser.Common.Events;
using MediaBrowser.Common.IO;
2014-03-06 05:17:13 +00:00
using MediaBrowser.Controller.Collections;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Providers;
2014-07-08 01:41:03 +00:00
using MediaBrowser.Model.Logging;
2014-03-06 05:17:13 +00:00
using System;
using System.Collections.Generic;
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;
namespace MediaBrowser.Server.Implementations.Collections
{
public class CollectionManager : ICollectionManager
{
private readonly ILibraryManager _libraryManager;
private readonly IFileSystem _fileSystem;
private readonly ILibraryMonitor _iLibraryMonitor;
2014-07-08 01:41:03 +00:00
private readonly ILogger _logger;
2015-09-29 16:29:06 +00:00
private readonly IProviderManager _providerManager;
2014-03-06 05:17:13 +00:00
2014-07-08 01:41:03 +00:00
public event EventHandler<CollectionCreatedEventArgs> CollectionCreated;
public event EventHandler<CollectionModifiedEventArgs> ItemsAddedToCollection;
public event EventHandler<CollectionModifiedEventArgs> ItemsRemovedFromCollection;
2015-09-29 16:29:06 +00:00
public CollectionManager(ILibraryManager libraryManager, IFileSystem fileSystem, ILibraryMonitor iLibraryMonitor, ILogger logger, IProviderManager providerManager)
2014-03-06 05:17:13 +00:00
{
_libraryManager = libraryManager;
_fileSystem = fileSystem;
_iLibraryMonitor = iLibraryMonitor;
2014-07-08 01:41:03 +00:00
_logger = logger;
2015-09-29 16:29:06 +00:00
_providerManager = providerManager;
2014-03-06 05:17:13 +00:00
}
2014-07-01 04:06:28 +00:00
public Folder GetCollectionsFolder(string userId)
{
2014-08-02 02:34:45 +00:00
return _libraryManager.RootFolder.Children.OfType<ManualCollectionsFolder>()
2014-07-01 04:06:28 +00:00
.FirstOrDefault();
}
2015-01-24 19:03:55 +00:00
public IEnumerable<BoxSet> GetCollections(User user)
{
var folder = GetCollectionsFolder(user.Id.ToString("N"));
return folder == null ?
new List<BoxSet>() :
folder.GetChildren(user, true).OfType<BoxSet>();
}
2014-03-15 15:17:46 +00:00
public async Task<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
var parentFolder = GetParentFolder(options.ParentId);
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
{
2015-09-13 21:32:02 +00:00
_fileSystem.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,
Shares = options.UserIds.Select(i => new Share
{
2015-04-26 04:39:40 +00:00
UserId = i.ToString("N"),
CanEdit = true
2014-12-13 03:56:30 +00:00
}).ToList()
2014-03-06 05:17:13 +00:00
};
await parentFolder.AddChild(collection, CancellationToken.None).ConfigureAwait(false);
2014-03-15 15:17:46 +00:00
if (options.ItemIdList.Count > 0)
{
2014-07-08 01:41:03 +00:00
await AddToCollection(collection.Id, options.ItemIdList, false);
2014-03-15 15:17:46 +00:00
}
2015-09-29 16:29:06 +00:00
else
{
_providerManager.QueueRefresh(collection.Id, new MetadataRefreshOptions(_fileSystem));
}
2014-03-15 15:17:46 +00:00
2014-07-08 01:41:03 +00:00
EventHelper.FireEventIfNotNull(CollectionCreated, this, new CollectionCreatedEventArgs
{
Collection = collection,
Options = options
}, _logger);
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);
}
}
private Folder GetParentFolder(Guid? parentId)
2014-03-06 05:17:13 +00:00
{
if (parentId.HasValue)
{
if (parentId.Value == Guid.Empty)
{
throw new ArgumentNullException("parentId");
}
2014-03-10 17:38:53 +00:00
var folder = _libraryManager.GetItemById(parentId.Value) as Folder;
// Find an actual physical folder
if (folder is CollectionFolder)
{
2014-05-07 02:28:19 +00:00
var child = _libraryManager.RootFolder.Children.OfType<Folder>()
.FirstOrDefault(i => folder.PhysicalLocations.Contains(i.Path, StringComparer.OrdinalIgnoreCase));
if (child != null)
{
return child;
}
2014-03-10 17:38:53 +00:00
}
}
2014-07-01 04:06:28 +00:00
return GetCollectionsFolder(string.Empty);
2014-03-06 05:17:13 +00:00
}
2014-07-08 01:41:03 +00:00
public Task AddToCollection(Guid collectionId, IEnumerable<Guid> ids)
{
return AddToCollection(collectionId, ids, true);
}
private async Task AddToCollection(Guid collectionId, IEnumerable<Guid> ids, bool fireEvent)
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>();
var currentLinkedChildren = collection.GetLinkedChildren().ToList();
foreach (var itemId in ids)
{
var item = _libraryManager.GetItemById(itemId);
if (item == null)
{
throw new ArgumentException("No item exists with the supplied Id");
}
2014-07-08 01:41:03 +00:00
itemList.Add(item);
2014-12-13 03:56:30 +00:00
if (currentLinkedChildren.Any(i => i.Id == itemId))
{
throw new ArgumentException("Item already exists in collection");
}
list.Add(LinkedChild.Create(item));
}
collection.LinkedChildren.AddRange(list);
2015-01-19 04:29:57 +00:00
collection.UpdateRatingToContent();
2015-01-19 04:29:57 +00:00
await collection.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
2015-09-29 16:29:06 +00:00
_providerManager.QueueRefresh(collection.Id, new MetadataRefreshOptions(_fileSystem));
2014-07-08 01:41:03 +00:00
if (fireEvent)
{
2014-07-16 20:01:38 +00:00
EventHelper.FireEventIfNotNull(ItemsAddedToCollection, this, new CollectionModifiedEventArgs
2014-07-08 01:41:03 +00:00
{
Collection = collection,
ItemsChanged = itemList
}, _logger);
}
}
public async Task 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>();
foreach (var itemId in itemIds)
{
var child = collection.LinkedChildren.FirstOrDefault(i => i.ItemId.HasValue && i.ItemId.Value == itemId);
if (child == null)
{
throw new ArgumentException("No collection title exists with the supplied Id");
}
list.Add(child);
2014-03-15 04:14:07 +00:00
var childItem = _libraryManager.GetItemById(itemId);
2014-07-08 01:41:03 +00:00
if (childItem != null)
{
itemList.Add(childItem);
}
}
2015-09-24 17:50:49 +00:00
var shortcutFiles = _fileSystem
.GetFilePaths(collection.Path)
.Where(i => _fileSystem.IsShortcut(i))
.ToList();
var shortcutFilesToDelete = list.Where(child => !string.IsNullOrWhiteSpace(child.Path) && child.Type == LinkedChildType.Shortcut)
.Select(child => shortcutFiles.FirstOrDefault(i => string.Equals(child.Path, _fileSystem.ResolveShortcut(i), StringComparison.OrdinalIgnoreCase)))
.Where(i => !string.IsNullOrWhiteSpace(i))
.ToList();
foreach (var file in shortcutFilesToDelete)
{
_iLibraryMonitor.ReportFileSystemChangeBeginning(file);
}
try
{
foreach (var file in shortcutFilesToDelete)
{
_fileSystem.DeleteFile(file);
}
2014-07-08 01:41:03 +00:00
foreach (var child in list)
{
collection.LinkedChildren.Remove(child);
}
}
finally
{
foreach (var file in shortcutFilesToDelete)
{
_iLibraryMonitor.ReportFileSystemChangeComplete(file, false);
}
}
2015-01-19 04:29:57 +00:00
collection.UpdateRatingToContent();
2015-01-19 04:29:57 +00:00
await collection.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
2015-09-29 16:29:06 +00:00
_providerManager.QueueRefresh(collection.Id, new MetadataRefreshOptions(_fileSystem));
2014-07-08 01:41:03 +00:00
EventHelper.FireEventIfNotNull(ItemsRemovedFromCollection, this, new CollectionModifiedEventArgs
{
Collection = collection,
ItemsChanged = itemList
}, _logger);
2014-03-06 05:17:13 +00:00
}
2014-04-22 17:25:54 +00:00
public IEnumerable<BaseItem> CollapseItemsWithinBoxSets(IEnumerable<BaseItem> items, User user)
{
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
{
2015-01-22 16:41:34 +00:00
var grouping = item as ISupportsBoxSetGrouping;
2014-04-22 17:25:54 +00:00
2015-01-22 16:41:34 +00:00
if (grouping == null)
{
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
.Where(i => i.GetLinkedChildren().Any(j => j.Id == itemId))
.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
}
}