2015-04-29 20:48:34 +02:00
|
|
|
|
using Interfaces.IO;
|
|
|
|
|
using MediaBrowser.Common.Extensions;
|
2013-10-31 15:03:23 +01:00
|
|
|
|
using MediaBrowser.Common.IO;
|
2013-04-22 06:38:03 +02:00
|
|
|
|
using MediaBrowser.Common.Progress;
|
2013-02-26 17:10:55 +01:00
|
|
|
|
using MediaBrowser.Common.ScheduledTasks;
|
2015-08-20 01:57:27 +02:00
|
|
|
|
using MediaBrowser.Controller.Channels;
|
2013-03-04 06:43:06 +01:00
|
|
|
|
using MediaBrowser.Controller.Configuration;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
using MediaBrowser.Controller.Entities;
|
2013-04-21 03:02:16 +02:00
|
|
|
|
using MediaBrowser.Controller.Entities.Audio;
|
2013-05-24 17:01:53 +02:00
|
|
|
|
using MediaBrowser.Controller.Entities.TV;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
using MediaBrowser.Controller.IO;
|
2013-02-28 20:32:41 +01:00
|
|
|
|
using MediaBrowser.Controller.Library;
|
2015-08-20 01:57:27 +02:00
|
|
|
|
using MediaBrowser.Controller.LiveTv;
|
2013-04-08 17:55:53 +02:00
|
|
|
|
using MediaBrowser.Controller.Persistence;
|
2014-02-02 14:36:31 +01:00
|
|
|
|
using MediaBrowser.Controller.Providers;
|
2013-03-03 17:53:58 +01:00
|
|
|
|
using MediaBrowser.Controller.Resolvers;
|
2013-03-10 05:22:36 +01:00
|
|
|
|
using MediaBrowser.Controller.Sorting;
|
2013-03-12 06:40:24 +01:00
|
|
|
|
using MediaBrowser.Model.Configuration;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
using MediaBrowser.Model.Entities;
|
2013-02-21 22:39:53 +01:00
|
|
|
|
using MediaBrowser.Model.Logging;
|
2015-06-01 16:49:23 +02:00
|
|
|
|
using MediaBrowser.Model.Querying;
|
2014-11-16 21:44:08 +01:00
|
|
|
|
using MediaBrowser.Naming.Audio;
|
2014-11-28 18:41:47 +01:00
|
|
|
|
using MediaBrowser.Naming.Common;
|
2014-12-19 05:20:07 +01:00
|
|
|
|
using MediaBrowser.Naming.TV;
|
2014-11-16 21:44:08 +01:00
|
|
|
|
using MediaBrowser.Naming.Video;
|
2013-09-10 20:56:00 +02:00
|
|
|
|
using MediaBrowser.Server.Implementations.Library.Validators;
|
2015-01-17 05:38:24 +01:00
|
|
|
|
using MediaBrowser.Server.Implementations.Logging;
|
2013-03-05 04:34:02 +01:00
|
|
|
|
using MediaBrowser.Server.Implementations.ScheduledTasks;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
using System;
|
|
|
|
|
using System.Collections.Concurrent;
|
|
|
|
|
using System.Collections.Generic;
|
|
|
|
|
using System.Globalization;
|
|
|
|
|
using System.IO;
|
|
|
|
|
using System.Linq;
|
|
|
|
|
using System.Threading;
|
|
|
|
|
using System.Threading.Tasks;
|
2015-06-21 05:35:22 +02:00
|
|
|
|
using MoreLinq;
|
2013-03-10 05:22:36 +01:00
|
|
|
|
using SortOrder = MediaBrowser.Model.Entities.SortOrder;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
|
namespace MediaBrowser.Server.Implementations.Library
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Class LibraryManager
|
|
|
|
|
/// </summary>
|
2013-02-28 20:32:41 +01:00
|
|
|
|
public class LibraryManager : ILibraryManager
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets or sets the postscan tasks.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The postscan tasks.</value>
|
2014-02-10 00:08:01 +01:00
|
|
|
|
private ILibraryPostScanTask[] PostscanTasks { get; set; }
|
2013-10-13 19:52:57 +02:00
|
|
|
|
|
2013-03-02 03:44:46 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the intro providers.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The intro providers.</value>
|
2014-02-10 00:08:01 +01:00
|
|
|
|
private IIntroProvider[] IntroProviders { get; set; }
|
2013-03-02 03:44:46 +01:00
|
|
|
|
|
2013-03-01 22:22:34 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the list of entity resolution ignore rules
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The entity resolution ignore rules.</value>
|
2013-11-04 20:04:23 +01:00
|
|
|
|
private IResolverIgnoreRule[] EntityResolutionIgnoreRules { get; set; }
|
2013-03-01 22:22:34 +01:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the list of BasePluginFolders added by plugins
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The plugin folders.</value>
|
2013-11-04 20:04:23 +01:00
|
|
|
|
private IVirtualFolderCreator[] PluginFolderCreators { get; set; }
|
2013-03-01 22:22:34 +01:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the list of currently registered entity resolvers
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The entity resolvers enumerable.</value>
|
2013-11-04 20:04:23 +01:00
|
|
|
|
private IItemResolver[] EntityResolvers { get; set; }
|
2014-12-28 07:21:39 +01:00
|
|
|
|
private IMultiItemResolver[] MultiItemResolvers { get; set; }
|
2013-03-01 22:22:34 +01:00
|
|
|
|
|
2013-03-10 05:22:36 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets or sets the comparers.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The comparers.</value>
|
2013-11-04 20:04:23 +01:00
|
|
|
|
private IBaseItemComparer[] Comparers { get; set; }
|
2013-03-10 05:22:36 +01:00
|
|
|
|
|
2013-04-08 17:55:53 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the active item repository
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The item repository.</value>
|
|
|
|
|
public IItemRepository ItemRepository { get; set; }
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// <summary>
|
2013-05-03 06:10:11 +02:00
|
|
|
|
/// Occurs when [item added].
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// </summary>
|
2013-05-03 06:10:11 +02:00
|
|
|
|
public event EventHandler<ItemChangeEventArgs> ItemAdded;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
2013-05-03 06:10:11 +02:00
|
|
|
|
/// Occurs when [item updated].
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// </summary>
|
2013-05-03 06:10:11 +02:00
|
|
|
|
public event EventHandler<ItemChangeEventArgs> ItemUpdated;
|
2013-03-31 19:39:28 +02:00
|
|
|
|
|
2013-05-03 06:10:11 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Occurs when [item removed].
|
|
|
|
|
/// </summary>
|
|
|
|
|
public event EventHandler<ItemChangeEventArgs> ItemRemoved;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2013-02-21 22:39:53 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _logger
|
|
|
|
|
/// </summary>
|
|
|
|
|
private readonly ILogger _logger;
|
|
|
|
|
|
2013-02-26 17:10:55 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _task manager
|
|
|
|
|
/// </summary>
|
|
|
|
|
private readonly ITaskManager _taskManager;
|
|
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _user manager
|
|
|
|
|
/// </summary>
|
2013-02-27 21:25:45 +01:00
|
|
|
|
private readonly IUserManager _userManager;
|
2013-02-28 20:32:41 +01:00
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _user data repository
|
|
|
|
|
/// </summary>
|
2013-10-02 18:08:58 +02:00
|
|
|
|
private readonly IUserDataManager _userDataRepository;
|
2013-04-22 06:38:03 +02:00
|
|
|
|
|
2013-03-04 06:43:06 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets or sets the configuration manager.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The configuration manager.</value>
|
|
|
|
|
private IServerConfigurationManager ConfigurationManager { get; set; }
|
|
|
|
|
|
2013-03-15 20:08:49 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// A collection of items that may be referenced from multiple physical places in the library
|
|
|
|
|
/// (typically, multiple user roots). We store them here and be sure they all reference a
|
|
|
|
|
/// single instance.
|
|
|
|
|
/// </summary>
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <value>The by reference items.</value>
|
2013-03-31 19:39:28 +02:00
|
|
|
|
private ConcurrentDictionary<Guid, BaseItem> ByReferenceItems { get; set; }
|
|
|
|
|
|
2014-01-28 22:25:10 +01:00
|
|
|
|
private readonly Func<ILibraryMonitor> _libraryMonitorFactory;
|
2014-02-02 14:36:31 +01:00
|
|
|
|
private readonly Func<IProviderManager> _providerManagerFactory;
|
2013-06-25 03:22:21 +02:00
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _library items cache
|
|
|
|
|
/// </summary>
|
2014-03-20 16:55:22 +01:00
|
|
|
|
private readonly ConcurrentDictionary<Guid, BaseItem> _libraryItemsCache;
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the library items cache.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The library items cache.</value>
|
2013-03-31 19:39:28 +02:00
|
|
|
|
private ConcurrentDictionary<Guid, BaseItem> LibraryItemsCache
|
|
|
|
|
{
|
|
|
|
|
get
|
|
|
|
|
{
|
|
|
|
|
return _libraryItemsCache;
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-03-15 20:08:49 +01:00
|
|
|
|
|
2013-10-30 15:40:14 +01:00
|
|
|
|
private readonly IFileSystem _fileSystem;
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Initializes a new instance of the <see cref="LibraryManager" /> class.
|
|
|
|
|
/// </summary>
|
2013-02-21 22:39:53 +01:00
|
|
|
|
/// <param name="logger">The logger.</param>
|
2013-02-26 17:10:55 +01:00
|
|
|
|
/// <param name="taskManager">The task manager.</param>
|
2013-02-28 20:32:41 +01:00
|
|
|
|
/// <param name="userManager">The user manager.</param>
|
2013-03-04 06:43:06 +01:00
|
|
|
|
/// <param name="configurationManager">The configuration manager.</param>
|
2013-04-13 20:02:30 +02:00
|
|
|
|
/// <param name="userDataRepository">The user data repository.</param>
|
2014-02-02 14:36:31 +01:00
|
|
|
|
public LibraryManager(ILogger logger, ITaskManager taskManager, IUserManager userManager, IServerConfigurationManager configurationManager, IUserDataManager userDataRepository, Func<ILibraryMonitor> libraryMonitorFactory, IFileSystem fileSystem, Func<IProviderManager> providerManagerFactory)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-02-21 22:39:53 +01:00
|
|
|
|
_logger = logger;
|
2013-02-26 17:10:55 +01:00
|
|
|
|
_taskManager = taskManager;
|
2013-02-27 21:25:45 +01:00
|
|
|
|
_userManager = userManager;
|
2013-03-04 06:43:06 +01:00
|
|
|
|
ConfigurationManager = configurationManager;
|
2013-04-13 20:02:30 +02:00
|
|
|
|
_userDataRepository = userDataRepository;
|
2014-01-28 22:25:10 +01:00
|
|
|
|
_libraryMonitorFactory = libraryMonitorFactory;
|
2013-10-30 15:40:14 +01:00
|
|
|
|
_fileSystem = fileSystem;
|
2014-02-02 14:36:31 +01:00
|
|
|
|
_providerManagerFactory = providerManagerFactory;
|
2013-03-15 20:08:49 +01:00
|
|
|
|
ByReferenceItems = new ConcurrentDictionary<Guid, BaseItem>();
|
2014-03-20 16:55:22 +01:00
|
|
|
|
_libraryItemsCache = new ConcurrentDictionary<Guid, BaseItem>();
|
2013-02-26 17:10:55 +01:00
|
|
|
|
|
2013-04-08 17:55:53 +02:00
|
|
|
|
ConfigurationManager.ConfigurationUpdated += ConfigurationUpdated;
|
2013-03-12 06:40:24 +01:00
|
|
|
|
|
|
|
|
|
RecordConfigurationValues(configurationManager.Configuration);
|
2013-02-26 17:10:55 +01:00
|
|
|
|
}
|
|
|
|
|
|
2013-03-01 22:22:34 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Adds the parts.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="rules">The rules.</param>
|
|
|
|
|
/// <param name="pluginFolders">The plugin folders.</param>
|
|
|
|
|
/// <param name="resolvers">The resolvers.</param>
|
2013-03-02 03:44:46 +01:00
|
|
|
|
/// <param name="introProviders">The intro providers.</param>
|
2013-03-10 05:22:36 +01:00
|
|
|
|
/// <param name="itemComparers">The item comparers.</param>
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <param name="postscanTasks">The postscan tasks.</param>
|
2013-04-08 17:55:53 +02:00
|
|
|
|
public void AddParts(IEnumerable<IResolverIgnoreRule> rules,
|
|
|
|
|
IEnumerable<IVirtualFolderCreator> pluginFolders,
|
|
|
|
|
IEnumerable<IItemResolver> resolvers,
|
|
|
|
|
IEnumerable<IIntroProvider> introProviders,
|
2013-05-21 05:16:43 +02:00
|
|
|
|
IEnumerable<IBaseItemComparer> itemComparers,
|
2014-02-10 00:08:01 +01:00
|
|
|
|
IEnumerable<ILibraryPostScanTask> postscanTasks)
|
2013-03-01 22:22:34 +01:00
|
|
|
|
{
|
2013-11-04 20:04:23 +01:00
|
|
|
|
EntityResolutionIgnoreRules = rules.ToArray();
|
|
|
|
|
PluginFolderCreators = pluginFolders.ToArray();
|
2013-03-02 02:09:05 +01:00
|
|
|
|
EntityResolvers = resolvers.OrderBy(i => i.Priority).ToArray();
|
2014-12-28 07:21:39 +01:00
|
|
|
|
MultiItemResolvers = EntityResolvers.OfType<IMultiItemResolver>().ToArray();
|
2014-02-10 00:08:01 +01:00
|
|
|
|
IntroProviders = introProviders.ToArray();
|
2013-11-04 20:04:23 +01:00
|
|
|
|
Comparers = itemComparers.ToArray();
|
2015-01-10 02:38:01 +01:00
|
|
|
|
|
2014-02-10 00:08:01 +01:00
|
|
|
|
PostscanTasks = postscanTasks.OrderBy(i =>
|
|
|
|
|
{
|
|
|
|
|
var hasOrder = i as IHasOrder;
|
|
|
|
|
|
|
|
|
|
return hasOrder == null ? 0 : hasOrder.Order;
|
|
|
|
|
|
|
|
|
|
}).ToArray();
|
2013-03-01 22:22:34 +01:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _root folder
|
|
|
|
|
/// </summary>
|
|
|
|
|
private AggregateFolder _rootFolder;
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _root folder sync lock
|
|
|
|
|
/// </summary>
|
2015-01-26 17:47:15 +01:00
|
|
|
|
private readonly object _rootFolderSyncLock = new object();
|
2013-02-28 20:32:41 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the root folder.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The root folder.</value>
|
|
|
|
|
public AggregateFolder RootFolder
|
|
|
|
|
{
|
|
|
|
|
get
|
|
|
|
|
{
|
2015-01-26 17:47:15 +01:00
|
|
|
|
if (_rootFolder == null)
|
2013-02-28 20:32:41 +01:00
|
|
|
|
{
|
2015-01-26 17:47:15 +01:00
|
|
|
|
lock (_rootFolderSyncLock)
|
|
|
|
|
{
|
|
|
|
|
if (_rootFolder == null)
|
|
|
|
|
{
|
|
|
|
|
_rootFolder = CreateRootFolder();
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-02-28 20:32:41 +01:00
|
|
|
|
}
|
2015-01-26 17:47:15 +01:00
|
|
|
|
return _rootFolder;
|
2013-02-28 20:32:41 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The _season zero display name
|
|
|
|
|
/// </summary>
|
2013-05-24 17:01:53 +02:00
|
|
|
|
private string _seasonZeroDisplayName;
|
2013-03-12 06:40:24 +01:00
|
|
|
|
|
2014-02-04 05:04:19 +01:00
|
|
|
|
private bool _wizardCompleted;
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Records the configuration values.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="configuration">The configuration.</param>
|
2013-03-12 06:40:24 +01:00
|
|
|
|
private void RecordConfigurationValues(ServerConfiguration configuration)
|
|
|
|
|
{
|
2014-02-03 21:51:28 +01:00
|
|
|
|
_seasonZeroDisplayName = configuration.SeasonZeroDisplayName;
|
2014-02-04 05:04:19 +01:00
|
|
|
|
_wizardCompleted = configuration.IsStartupWizardCompleted;
|
2013-03-12 06:40:24 +01:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-26 17:10:55 +01:00
|
|
|
|
/// <summary>
|
2013-04-08 17:55:53 +02:00
|
|
|
|
/// Configurations the updated.
|
2013-02-26 17:10:55 +01:00
|
|
|
|
/// </summary>
|
2013-04-08 17:55:53 +02:00
|
|
|
|
/// <param name="sender">The sender.</param>
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
|
2013-04-08 17:55:53 +02:00
|
|
|
|
void ConfigurationUpdated(object sender, EventArgs e)
|
2013-02-26 17:10:55 +01:00
|
|
|
|
{
|
2013-03-12 06:40:24 +01:00
|
|
|
|
var config = ConfigurationManager.Configuration;
|
|
|
|
|
|
2013-05-24 17:01:53 +02:00
|
|
|
|
var newSeasonZeroName = ConfigurationManager.Configuration.SeasonZeroDisplayName;
|
2014-11-14 07:27:10 +01:00
|
|
|
|
var seasonZeroNameChanged = !string.Equals(_seasonZeroDisplayName, newSeasonZeroName, StringComparison.Ordinal);
|
2014-02-04 05:04:19 +01:00
|
|
|
|
var wizardChanged = config.IsStartupWizardCompleted != _wizardCompleted;
|
2013-05-25 17:16:50 +02:00
|
|
|
|
|
2013-03-12 06:40:24 +01:00
|
|
|
|
RecordConfigurationValues(config);
|
2013-02-26 17:10:55 +01:00
|
|
|
|
|
2015-08-20 01:57:27 +02:00
|
|
|
|
if (seasonZeroNameChanged || wizardChanged)
|
2013-02-26 17:10:55 +01:00
|
|
|
|
{
|
2015-08-20 01:57:27 +02:00
|
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
|
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2015-08-20 01:57:27 +02:00
|
|
|
|
if (seasonZeroNameChanged)
|
2014-02-22 21:20:22 +01:00
|
|
|
|
{
|
2015-08-20 01:57:27 +02:00
|
|
|
|
Task.Run(async () =>
|
|
|
|
|
{
|
|
|
|
|
await UpdateSeasonZeroNames(newSeasonZeroName, CancellationToken.None).ConfigureAwait(false);
|
2014-02-22 21:20:22 +01:00
|
|
|
|
|
2015-08-20 01:57:27 +02:00
|
|
|
|
});
|
2014-02-22 21:20:22 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-24 17:01:53 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Updates the season zero names.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="newName">The new name.</param>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
2013-06-25 03:22:21 +02:00
|
|
|
|
private async Task UpdateSeasonZeroNames(string newName, CancellationToken cancellationToken)
|
2013-05-24 17:01:53 +02:00
|
|
|
|
{
|
2015-01-25 07:34:50 +01:00
|
|
|
|
var seasons = RootFolder.GetRecursiveChildren(i => i is Season)
|
|
|
|
|
.Cast<Season>()
|
2014-11-14 07:27:10 +01:00
|
|
|
|
.Where(i => i.IndexNumber.HasValue && i.IndexNumber.Value == 0 && !string.Equals(i.Name, newName, StringComparison.Ordinal))
|
2013-05-24 17:01:53 +02:00
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var season in seasons)
|
|
|
|
|
{
|
|
|
|
|
season.Name = newName;
|
|
|
|
|
|
2013-06-25 03:22:21 +02:00
|
|
|
|
try
|
|
|
|
|
{
|
2015-07-13 23:26:11 +02:00
|
|
|
|
await UpdateItem(season, ItemUpdateType.MetadataDownload, cancellationToken).ConfigureAwait(false);
|
2013-06-25 03:22:21 +02:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error saving {0}", ex, season.Path);
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-05-24 17:01:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-03-31 19:39:28 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Updates the item in library cache.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
private void UpdateItemInLibraryCache(BaseItem item)
|
|
|
|
|
{
|
2014-01-11 06:49:18 +01:00
|
|
|
|
RegisterItem(item);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public void RegisterItem(BaseItem item)
|
|
|
|
|
{
|
2014-03-20 16:55:22 +01:00
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("item");
|
|
|
|
|
}
|
2014-02-22 21:20:22 +01:00
|
|
|
|
RegisterItem(item.Id, item);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void RegisterItem(Guid id, BaseItem item)
|
|
|
|
|
{
|
2015-08-20 01:57:27 +02:00
|
|
|
|
if (item is LiveTvProgram)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (item is IChannelItem)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (item is IItemByName)
|
|
|
|
|
{
|
|
|
|
|
if (!(item is MusicArtist))
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-02-22 21:20:22 +01:00
|
|
|
|
LibraryItemsCache.AddOrUpdate(id, item, delegate { return item; });
|
2013-03-31 19:39:28 +02:00
|
|
|
|
}
|
|
|
|
|
|
2014-02-20 05:53:15 +01:00
|
|
|
|
public async Task DeleteItem(BaseItem item, DeleteOptions options)
|
2014-02-19 19:50:37 +01:00
|
|
|
|
{
|
2014-02-20 05:53:15 +01:00
|
|
|
|
_logger.Debug("Deleting item, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
|
|
|
|
|
item.GetType().Name,
|
|
|
|
|
item.Name,
|
|
|
|
|
item.Path ?? string.Empty,
|
|
|
|
|
item.Id);
|
|
|
|
|
|
2014-02-19 19:50:37 +01:00
|
|
|
|
var parent = item.Parent;
|
|
|
|
|
|
|
|
|
|
var locationType = item.LocationType;
|
|
|
|
|
|
|
|
|
|
var children = item.IsFolder
|
2015-01-25 07:34:50 +01:00
|
|
|
|
? ((Folder)item).GetRecursiveChildren().ToList()
|
2014-02-19 19:50:37 +01:00
|
|
|
|
: new List<BaseItem>();
|
|
|
|
|
|
|
|
|
|
foreach (var metadataPath in GetMetadataPaths(item, children))
|
|
|
|
|
{
|
|
|
|
|
_logger.Debug("Deleting path {0}", metadataPath);
|
|
|
|
|
|
|
|
|
|
try
|
|
|
|
|
{
|
2015-01-13 04:46:44 +01:00
|
|
|
|
_fileSystem.DeleteDirectory(metadataPath, true);
|
2014-02-19 19:50:37 +01:00
|
|
|
|
}
|
|
|
|
|
catch (DirectoryNotFoundException)
|
|
|
|
|
{
|
2015-02-15 04:36:07 +01:00
|
|
|
|
|
2014-02-19 19:50:37 +01:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error deleting {0}", ex, metadataPath);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-03 06:11:03 +01:00
|
|
|
|
if (options.DeleteFileLocation && locationType != LocationType.Remote && locationType != LocationType.Virtual)
|
2014-02-19 19:50:37 +01:00
|
|
|
|
{
|
|
|
|
|
foreach (var path in item.GetDeletePaths().ToList())
|
|
|
|
|
{
|
|
|
|
|
if (Directory.Exists(path))
|
|
|
|
|
{
|
|
|
|
|
_logger.Debug("Deleting path {0}", path);
|
2015-01-13 04:46:44 +01:00
|
|
|
|
_fileSystem.DeleteDirectory(path, true);
|
2014-02-19 19:50:37 +01:00
|
|
|
|
}
|
|
|
|
|
else if (File.Exists(path))
|
|
|
|
|
{
|
|
|
|
|
_logger.Debug("Deleting path {0}", path);
|
2015-01-13 04:46:44 +01:00
|
|
|
|
_fileSystem.DeleteFile(path);
|
2014-02-19 19:50:37 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (parent != null)
|
|
|
|
|
{
|
|
|
|
|
await parent.ValidateChildren(new Progress<double>(), CancellationToken.None)
|
|
|
|
|
.ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (parent != null)
|
|
|
|
|
{
|
|
|
|
|
await parent.RemoveChild(item, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-20 05:53:15 +01:00
|
|
|
|
await ItemRepository.DeleteItem(item.Id, CancellationToken.None).ConfigureAwait(false);
|
2014-02-19 19:50:37 +01:00
|
|
|
|
foreach (var child in children)
|
|
|
|
|
{
|
|
|
|
|
await ItemRepository.DeleteItem(child.Id, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
}
|
2014-02-20 05:53:15 +01:00
|
|
|
|
|
2014-03-09 23:14:44 +01:00
|
|
|
|
BaseItem removed;
|
|
|
|
|
_libraryItemsCache.TryRemove(item.Id, out removed);
|
|
|
|
|
|
2014-02-20 05:53:15 +01:00
|
|
|
|
ReportItemRemoved(item);
|
2014-02-19 19:50:37 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private IEnumerable<string> GetMetadataPaths(BaseItem item, IEnumerable<BaseItem> children)
|
|
|
|
|
{
|
|
|
|
|
var list = new List<string>
|
|
|
|
|
{
|
2014-09-28 17:27:26 +02:00
|
|
|
|
item.GetInternalMetadataPath()
|
2014-02-19 19:50:37 +01:00
|
|
|
|
};
|
|
|
|
|
|
2014-09-28 17:27:26 +02:00
|
|
|
|
list.AddRange(children.Select(i => i.GetInternalMetadataPath()));
|
2014-02-19 19:50:37 +01:00
|
|
|
|
|
|
|
|
|
return list;
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Resolves the item.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="args">The args.</param>
|
|
|
|
|
/// <returns>BaseItem.</returns>
|
2014-12-04 06:24:41 +01:00
|
|
|
|
private BaseItem ResolveItem(ItemResolveArgs args)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2014-12-04 06:24:41 +01:00
|
|
|
|
var item = EntityResolvers.Select(r => Resolve(args, r))
|
|
|
|
|
.FirstOrDefault(i => i != null);
|
2013-03-03 07:58:04 +01:00
|
|
|
|
|
|
|
|
|
if (item != null)
|
|
|
|
|
{
|
2014-11-30 20:01:33 +01:00
|
|
|
|
ResolverHelper.SetInitialItemValues(item, args, _fileSystem, this);
|
2013-03-03 07:58:04 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return item;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
private BaseItem Resolve(ItemResolveArgs args, IItemResolver resolver)
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
return resolver.ResolvePath(args);
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error in {0} resolving {1}", ex, resolver.GetType().Name, args.Path);
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 20:01:33 +01:00
|
|
|
|
public Guid GetNewItemId(string key, Type type)
|
|
|
|
|
{
|
|
|
|
|
if (string.IsNullOrWhiteSpace(key))
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("key");
|
|
|
|
|
}
|
|
|
|
|
if (type == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("type");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ConfigurationManager.Configuration.EnableLocalizedGuids && key.StartsWith(ConfigurationManager.ApplicationPaths.ProgramDataPath))
|
|
|
|
|
{
|
|
|
|
|
// Try to normalize paths located underneath program-data in an attempt to make them more portable
|
|
|
|
|
key = key.Substring(ConfigurationManager.ApplicationPaths.ProgramDataPath.Length)
|
|
|
|
|
.TrimStart(new[] { '/', '\\' })
|
|
|
|
|
.Replace("/", "\\");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
key = type.FullName + key.ToLower();
|
|
|
|
|
|
|
|
|
|
return key.GetMD5();
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-19 05:59:45 +01:00
|
|
|
|
public IEnumerable<BaseItem> ReplaceVideosWithPrimaryVersions(IEnumerable<BaseItem> items)
|
|
|
|
|
{
|
2015-02-05 04:01:37 +01:00
|
|
|
|
if (items == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("items");
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-07 01:58:46 +02:00
|
|
|
|
var dict = new Dictionary<Guid, BaseItem>();
|
|
|
|
|
|
|
|
|
|
foreach (var item in items)
|
2014-03-19 05:59:45 +01:00
|
|
|
|
{
|
2014-10-07 01:58:46 +02:00
|
|
|
|
var video = item as Video;
|
2014-03-19 05:59:45 +01:00
|
|
|
|
|
|
|
|
|
if (video != null)
|
|
|
|
|
{
|
|
|
|
|
if (video.PrimaryVersionId.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var primary = GetItemById(video.PrimaryVersionId.Value) as Video;
|
|
|
|
|
|
|
|
|
|
if (primary != null)
|
|
|
|
|
{
|
2014-10-07 01:58:46 +02:00
|
|
|
|
dict[primary.Id] = primary;
|
|
|
|
|
continue;
|
2014-03-19 05:59:45 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-10-07 01:58:46 +02:00
|
|
|
|
dict[item.Id] = item;
|
|
|
|
|
}
|
2014-03-19 05:59:45 +01:00
|
|
|
|
|
2014-10-07 01:58:46 +02:00
|
|
|
|
return dict.Values;
|
2014-03-19 05:59:45 +01:00
|
|
|
|
}
|
2013-03-15 20:08:49 +01:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Ensure supplied item has only one instance throughout
|
|
|
|
|
/// </summary>
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <param name="item">The item.</param>
|
2013-03-15 20:08:49 +01:00
|
|
|
|
/// <returns>The proper instance to the item</returns>
|
|
|
|
|
public BaseItem GetOrAddByReferenceItem(BaseItem item)
|
|
|
|
|
{
|
|
|
|
|
// Add this item to our list if not there already
|
|
|
|
|
if (!ByReferenceItems.TryAdd(item.Id, item))
|
|
|
|
|
{
|
|
|
|
|
// Already there - return the existing reference
|
|
|
|
|
item = ByReferenceItems[item.Id];
|
|
|
|
|
}
|
|
|
|
|
return item;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-29 23:01:02 +01:00
|
|
|
|
public BaseItem ResolvePath(FileSystemInfo fileInfo,
|
2014-12-22 07:50:29 +01:00
|
|
|
|
Folder parent = null)
|
2014-02-13 06:11:54 +01:00
|
|
|
|
{
|
2014-12-22 07:50:29 +01:00
|
|
|
|
return ResolvePath(fileInfo, new DirectoryService(_logger), parent);
|
2014-02-13 06:11:54 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
private BaseItem ResolvePath(FileSystemInfo fileInfo, IDirectoryService directoryService, Folder parent = null, string collectionType = null)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-06-11 22:35:54 +02:00
|
|
|
|
if (fileInfo == null)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-06-11 22:35:54 +02:00
|
|
|
|
throw new ArgumentNullException("fileInfo");
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-22 07:50:29 +01:00
|
|
|
|
var fullPath = fileInfo.FullName;
|
|
|
|
|
|
2015-01-12 06:07:19 +01:00
|
|
|
|
if (string.IsNullOrWhiteSpace(collectionType) && parent != null)
|
2014-12-22 07:50:29 +01:00
|
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
|
collectionType = GetContentTypeOverride(fullPath, true);
|
2014-12-22 07:50:29 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-01-27 23:45:59 +01:00
|
|
|
|
var args = new ItemResolveArgs(ConfigurationManager.ApplicationPaths, directoryService)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
|
|
|
|
Parent = parent,
|
2014-12-22 07:50:29 +01:00
|
|
|
|
Path = fullPath,
|
2014-10-23 06:26:01 +02:00
|
|
|
|
FileInfo = fileInfo,
|
|
|
|
|
CollectionType = collectionType
|
2013-02-21 02:33:05 +01:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Return null if ignore rules deem that we should do so
|
2013-03-01 22:22:34 +01:00
|
|
|
|
if (EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(args)))
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Gather child folder and files
|
|
|
|
|
if (args.IsDirectory)
|
|
|
|
|
{
|
2013-04-19 20:03:21 +02:00
|
|
|
|
var isPhysicalRoot = args.IsPhysicalRoot;
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
// When resolving the root, we need it's grandchildren (children of user views)
|
2013-04-19 20:03:21 +02:00
|
|
|
|
var flattenFolderDepth = isPhysicalRoot ? 2 : 0;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2014-02-11 22:41:01 +01:00
|
|
|
|
var fileSystemDictionary = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, _fileSystem, _logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || args.IsVf);
|
2014-02-22 21:20:22 +01:00
|
|
|
|
|
2013-05-24 19:48:48 +02:00
|
|
|
|
// Need to remove subpaths that may have been resolved from shortcuts
|
|
|
|
|
// Example: if \\server\movies exists, then strip out \\server\movies\action
|
|
|
|
|
if (isPhysicalRoot)
|
|
|
|
|
{
|
2014-01-01 19:26:31 +01:00
|
|
|
|
var paths = NormalizeRootPathList(fileSystemDictionary.Keys);
|
2013-05-24 19:48:48 +02:00
|
|
|
|
|
2014-01-01 19:26:31 +01:00
|
|
|
|
fileSystemDictionary = paths.Select(i => (FileSystemInfo)new DirectoryInfo(i)).ToDictionary(i => i.FullName);
|
2013-05-24 19:48:48 +02:00
|
|
|
|
}
|
2014-01-01 19:26:31 +01:00
|
|
|
|
|
|
|
|
|
args.FileSystemDictionary = fileSystemDictionary;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Check to see if we should resolve based on our contents
|
2013-03-03 07:58:04 +01:00
|
|
|
|
if (args.IsDirectory && !ShouldResolvePathContents(args))
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ResolveItem(args);
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-01 19:26:31 +01:00
|
|
|
|
public IEnumerable<string> NormalizeRootPathList(IEnumerable<string> paths)
|
|
|
|
|
{
|
|
|
|
|
var list = paths.Select(_fileSystem.NormalizePath)
|
|
|
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
var dupes = list.Where(subPath => !subPath.EndsWith(":\\", StringComparison.OrdinalIgnoreCase) && list.Any(i => _fileSystem.ContainsSubPath(i, subPath)))
|
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var dupe in dupes)
|
|
|
|
|
{
|
|
|
|
|
_logger.Info("Found duplicate path: {0}", dupe);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return list.Except(dupes, StringComparer.OrdinalIgnoreCase);
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-03 07:58:04 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Determines whether a path should be ignored based on its contents - called after the contents have been read
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="args">The args.</param>
|
|
|
|
|
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
|
|
|
|
|
private static bool ShouldResolvePathContents(ItemResolveArgs args)
|
|
|
|
|
{
|
|
|
|
|
// Ignore any folders containing a file called .ignore
|
|
|
|
|
return !args.ContainsFileSystemEntryByName(".ignore");
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemInfo> files, IDirectoryService directoryService, Folder parent, string collectionType)
|
|
|
|
|
{
|
|
|
|
|
var fileList = files.ToList();
|
|
|
|
|
|
|
|
|
|
if (parent != null)
|
|
|
|
|
{
|
2014-12-28 07:21:39 +01:00
|
|
|
|
foreach (var resolver in MultiItemResolvers)
|
2014-12-04 06:24:41 +01:00
|
|
|
|
{
|
|
|
|
|
var result = resolver.ResolveMultiple(parent, fileList, collectionType, directoryService);
|
|
|
|
|
|
|
|
|
|
if (result != null && result.Items.Count > 0)
|
|
|
|
|
{
|
|
|
|
|
var items = new List<BaseItem>();
|
|
|
|
|
items.AddRange(result.Items);
|
|
|
|
|
|
|
|
|
|
foreach (var item in items)
|
|
|
|
|
{
|
|
|
|
|
ResolverHelper.SetInitialItemValues(item, parent, _fileSystem, this, directoryService);
|
|
|
|
|
}
|
|
|
|
|
items.AddRange(ResolveFileList(result.ExtraFiles, directoryService, parent, collectionType));
|
|
|
|
|
return items;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ResolveFileList(fileList, directoryService, parent, collectionType);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private IEnumerable<BaseItem> ResolveFileList(IEnumerable<FileSystemInfo> fileList, IDirectoryService directoryService, Folder parent, string collectionType)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2014-12-04 06:24:41 +01:00
|
|
|
|
return fileList.Select(f =>
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
2014-12-04 06:24:41 +01:00
|
|
|
|
return ResolvePath(f, directoryService, parent, collectionType);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
2013-04-28 07:29:27 +02:00
|
|
|
|
_logger.ErrorException("Error resolving path {0}", ex, f.FullName);
|
2014-11-26 05:12:29 +01:00
|
|
|
|
return null;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
2014-12-04 06:24:41 +01:00
|
|
|
|
}).Where(i => i != null);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Creates the root media folder
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <returns>AggregateFolder.</returns>
|
|
|
|
|
/// <exception cref="System.InvalidOperationException">Cannot create the root folder until plugins have loaded</exception>
|
2013-02-28 20:32:41 +01:00
|
|
|
|
public AggregateFolder CreateRootFolder()
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-03-04 06:43:06 +01:00
|
|
|
|
var rootFolderPath = ConfigurationManager.ApplicationPaths.RootFolderPath;
|
2013-06-04 18:48:23 +02:00
|
|
|
|
|
2014-02-13 06:11:54 +01:00
|
|
|
|
Directory.CreateDirectory(rootFolderPath);
|
2013-06-04 18:48:23 +02:00
|
|
|
|
|
2014-11-30 20:01:33 +01:00
|
|
|
|
var rootFolder = GetItemById(GetNewItemId(rootFolderPath, typeof(AggregateFolder))) as AggregateFolder ?? (AggregateFolder)ResolvePath(new DirectoryInfo(rootFolderPath));
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
|
|
|
|
// Add in the plug-in folders
|
2013-03-01 22:22:34 +01:00
|
|
|
|
foreach (var child in PluginFolderCreators)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-06-13 20:17:42 +02:00
|
|
|
|
var folder = child.GetFolder();
|
|
|
|
|
|
2014-06-04 05:34:36 +02:00
|
|
|
|
if (folder != null)
|
2013-06-13 20:17:42 +02:00
|
|
|
|
{
|
2014-06-04 05:34:36 +02:00
|
|
|
|
if (folder.Id == Guid.Empty)
|
|
|
|
|
{
|
2014-11-30 20:01:33 +01:00
|
|
|
|
if (string.IsNullOrWhiteSpace(folder.Path))
|
|
|
|
|
{
|
|
|
|
|
folder.Id = GetNewItemId(folder.GetType().Name, folder.GetType());
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
folder.Id = GetNewItemId(folder.Path, folder.GetType());
|
|
|
|
|
}
|
2014-06-04 05:34:36 +02:00
|
|
|
|
}
|
2013-06-13 20:17:42 +02:00
|
|
|
|
|
2015-04-06 22:43:40 +02:00
|
|
|
|
var dbItem = GetItemById(folder.Id) as BasePluginFolder;
|
|
|
|
|
|
|
|
|
|
if (dbItem != null && string.Equals(dbItem.Path, folder.Path, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
folder = dbItem;
|
|
|
|
|
}
|
2014-05-31 16:30:59 +02:00
|
|
|
|
|
2014-06-04 05:34:36 +02:00
|
|
|
|
rootFolder.AddVirtualChild(folder);
|
|
|
|
|
|
|
|
|
|
RegisterItem(folder);
|
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return rootFolder;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-21 06:04:11 +01:00
|
|
|
|
private UserRootFolder _userRootFolder;
|
2014-12-13 04:56:30 +01:00
|
|
|
|
private readonly object _syncLock = new object();
|
2014-02-21 06:04:11 +01:00
|
|
|
|
public Folder GetUserRootFolder()
|
2013-04-05 06:13:41 +02:00
|
|
|
|
{
|
2014-02-21 06:04:11 +01:00
|
|
|
|
if (_userRootFolder == null)
|
|
|
|
|
{
|
2014-12-13 04:56:30 +01:00
|
|
|
|
lock (_syncLock)
|
|
|
|
|
{
|
|
|
|
|
if (_userRootFolder == null)
|
|
|
|
|
{
|
|
|
|
|
var userRootPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
|
2013-04-22 06:38:03 +02:00
|
|
|
|
|
2014-12-13 04:56:30 +01:00
|
|
|
|
Directory.CreateDirectory(userRootPath);
|
2014-02-22 23:41:29 +01:00
|
|
|
|
|
2015-01-27 23:45:59 +01:00
|
|
|
|
var tmpItem = GetItemById(GetNewItemId(userRootPath, typeof(UserRootFolder))) as UserRootFolder;
|
2014-12-13 04:56:30 +01:00
|
|
|
|
|
2015-01-27 23:45:59 +01:00
|
|
|
|
if (tmpItem == null)
|
2014-12-13 04:56:30 +01:00
|
|
|
|
{
|
2015-01-27 23:45:59 +01:00
|
|
|
|
tmpItem = (UserRootFolder)ResolvePath(new DirectoryInfo(userRootPath));
|
2014-12-13 04:56:30 +01:00
|
|
|
|
}
|
2015-01-27 23:45:59 +01:00
|
|
|
|
|
|
|
|
|
_userRootFolder = tmpItem;
|
2014-12-13 04:56:30 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-02-21 06:04:11 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return _userRootFolder;
|
2013-09-11 19:54:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets a Person
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
|
/// <returns>Task{Person}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
|
public Person GetPerson(string name)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-09-17 04:08:18 +02:00
|
|
|
|
return GetItemByName<Person>(ConfigurationManager.ApplicationPaths.PeoplePath, name);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets a Studio
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="name">The name.</param>
|
2013-09-10 20:56:00 +02:00
|
|
|
|
/// <returns>Task{Studio}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
|
public Studio GetStudio(string name)
|
2013-09-10 20:56:00 +02:00
|
|
|
|
{
|
2013-09-17 04:08:18 +02:00
|
|
|
|
return GetItemByName<Studio>(ConfigurationManager.ApplicationPaths.StudioPath, name);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets a Genre
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="name">The name.</param>
|
2013-09-10 20:56:00 +02:00
|
|
|
|
/// <returns>Task{Genre}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
|
public Genre GetGenre(string name)
|
2013-09-10 20:56:00 +02:00
|
|
|
|
{
|
2013-09-17 04:08:18 +02:00
|
|
|
|
return GetItemByName<Genre>(ConfigurationManager.ApplicationPaths.GenrePath, name);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-11 05:31:00 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the genre.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
|
/// <returns>Task{MusicGenre}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
|
public MusicGenre GetMusicGenre(string name)
|
2013-07-01 19:17:33 +02:00
|
|
|
|
{
|
2013-09-17 04:08:18 +02:00
|
|
|
|
return GetItemByName<MusicGenre>(ConfigurationManager.ApplicationPaths.MusicGenrePath, name);
|
2013-09-10 20:56:00 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the game genre.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
|
/// <returns>Task{GameGenre}.</returns>
|
2013-09-17 04:08:18 +02:00
|
|
|
|
public GameGenre GetGameGenre(string name)
|
2013-09-10 20:56:00 +02:00
|
|
|
|
{
|
2013-09-17 04:08:18 +02:00
|
|
|
|
return GetItemByName<GameGenre>(ConfigurationManager.ApplicationPaths.GameGenrePath, name);
|
2013-07-01 19:17:33 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// The us culture
|
|
|
|
|
/// </summary>
|
|
|
|
|
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets a Year
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="value">The value.</param>
|
|
|
|
|
/// <returns>Task{Year}.</returns>
|
|
|
|
|
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
|
2013-09-17 04:08:18 +02:00
|
|
|
|
public Year GetYear(int value)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
|
|
|
|
if (value <= 0)
|
|
|
|
|
{
|
2014-01-16 18:56:50 +01:00
|
|
|
|
throw new ArgumentOutOfRangeException("Years less than or equal to 0 are invalid.");
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-17 04:08:18 +02:00
|
|
|
|
return GetItemByName<Year>(ConfigurationManager.ApplicationPaths.YearPath, value.ToString(UsCulture));
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-01-13 04:46:44 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the artists path.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The artists path.</value>
|
|
|
|
|
public string ArtistsPath
|
|
|
|
|
{
|
|
|
|
|
get
|
|
|
|
|
{
|
|
|
|
|
return Path.Combine(ConfigurationManager.ApplicationPaths.ItemsByNamePath, "artists");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-21 21:48:26 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets a Genre
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
|
/// <returns>Task{Genre}.</returns>
|
|
|
|
|
public MusicArtist GetArtist(string name)
|
|
|
|
|
{
|
2015-01-13 04:46:44 +01:00
|
|
|
|
return GetItemByName<MusicArtist>(ArtistsPath, name);
|
2013-11-21 21:48:26 +01:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-11 19:54:59 +02:00
|
|
|
|
private T GetItemByName<T>(string path, string name)
|
|
|
|
|
where T : BaseItem, new()
|
|
|
|
|
{
|
2014-04-05 17:02:50 +02:00
|
|
|
|
if (string.IsNullOrWhiteSpace(path))
|
2013-09-11 19:54:59 +02:00
|
|
|
|
{
|
2013-11-21 21:48:26 +01:00
|
|
|
|
throw new ArgumentNullException("path");
|
2013-09-11 19:54:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
2014-04-05 17:02:50 +02:00
|
|
|
|
if (string.IsNullOrWhiteSpace(name))
|
2013-09-11 19:54:59 +02:00
|
|
|
|
{
|
2013-11-21 21:48:26 +01:00
|
|
|
|
throw new ArgumentNullException("name");
|
2013-09-11 19:54:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-10-30 15:40:14 +01:00
|
|
|
|
var validFilename = _fileSystem.GetValidFilename(name).Trim();
|
2013-09-11 19:54:59 +02:00
|
|
|
|
|
2013-10-23 18:51:51 +02:00
|
|
|
|
string subFolderPrefix = null;
|
|
|
|
|
|
2014-02-22 21:20:22 +01:00
|
|
|
|
var type = typeof(T);
|
|
|
|
|
|
2014-12-19 05:20:07 +01:00
|
|
|
|
if (type == typeof(Person))
|
2013-10-23 18:51:51 +02:00
|
|
|
|
{
|
2015-03-20 18:17:03 +01:00
|
|
|
|
var subFolderIndex = 0;
|
|
|
|
|
|
|
|
|
|
while (!char.IsLetterOrDigit(validFilename[subFolderIndex]))
|
|
|
|
|
{
|
|
|
|
|
subFolderIndex++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
subFolderPrefix = validFilename.Substring(subFolderIndex, 1);
|
2013-10-23 18:51:51 +02:00
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 21:20:22 +01:00
|
|
|
|
var fullPath = string.IsNullOrEmpty(subFolderPrefix) ?
|
2013-10-23 18:51:51 +02:00
|
|
|
|
Path.Combine(path, validFilename) :
|
|
|
|
|
Path.Combine(path, subFolderPrefix, validFilename);
|
2013-09-11 19:54:59 +02:00
|
|
|
|
|
2014-11-30 20:01:33 +01:00
|
|
|
|
var id = GetNewItemId(fullPath, type);
|
2014-02-22 21:20:22 +01:00
|
|
|
|
|
2013-09-11 19:54:59 +02:00
|
|
|
|
BaseItem obj;
|
|
|
|
|
|
2014-02-22 21:20:22 +01:00
|
|
|
|
if (!_libraryItemsCache.TryGetValue(id, out obj))
|
2013-09-11 19:54:59 +02:00
|
|
|
|
{
|
2014-02-22 21:20:22 +01:00
|
|
|
|
obj = CreateItemByName<T>(fullPath, name, id);
|
2013-09-11 19:54:59 +02:00
|
|
|
|
|
2014-02-22 21:20:22 +01:00
|
|
|
|
RegisterItem(id, obj);
|
2013-09-11 19:54:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return obj as T;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 21:20:22 +01:00
|
|
|
|
private T CreateItemByName<T>(string path, string name, Guid id)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
where T : BaseItem, new()
|
|
|
|
|
{
|
2013-11-21 21:48:26 +01:00
|
|
|
|
var isArtist = typeof(T) == typeof(MusicArtist);
|
|
|
|
|
|
|
|
|
|
if (isArtist)
|
|
|
|
|
{
|
2015-01-25 07:34:50 +01:00
|
|
|
|
var existing = RootFolder
|
2015-04-09 23:11:57 +02:00
|
|
|
|
.GetRecursiveChildren(i => i is T && NameExtensions.AreEqual(i.Name, name))
|
2015-01-25 07:34:50 +01:00
|
|
|
|
.Cast<T>()
|
|
|
|
|
.FirstOrDefault();
|
2013-11-21 21:48:26 +01:00
|
|
|
|
|
|
|
|
|
if (existing != null)
|
|
|
|
|
{
|
2014-02-22 21:20:22 +01:00
|
|
|
|
return existing;
|
2013-11-21 21:48:26 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-06 03:21:18 +02:00
|
|
|
|
var item = GetItemById(id) as T;
|
2013-09-10 20:56:00 +02:00
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
item = new T
|
|
|
|
|
{
|
|
|
|
|
Name = name,
|
|
|
|
|
Id = id,
|
2015-08-06 03:21:18 +02:00
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
|
DateModified = DateTime.UtcNow,
|
2013-02-21 02:33:05 +01:00
|
|
|
|
Path = path
|
|
|
|
|
};
|
|
|
|
|
|
2015-08-20 01:57:27 +02:00
|
|
|
|
if (isArtist)
|
|
|
|
|
{
|
|
|
|
|
(item as MusicArtist).IsAccessedByName = true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-24 04:08:20 +02:00
|
|
|
|
var task = CreateItem(item, CancellationToken.None);
|
2015-08-20 01:57:27 +02:00
|
|
|
|
Task.WaitAll(task);
|
2013-11-21 21:48:26 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 21:20:22 +01:00
|
|
|
|
return item;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-06 03:21:18 +02:00
|
|
|
|
public IEnumerable<MusicArtist> GetAlbumArtists(IEnumerable<IHasAlbumArtist> items)
|
|
|
|
|
{
|
|
|
|
|
var names = items
|
|
|
|
|
.SelectMany(i => i.AlbumArtists)
|
|
|
|
|
.DistinctNames()
|
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var artist = GetArtist(i);
|
|
|
|
|
|
|
|
|
|
return artist;
|
|
|
|
|
}
|
|
|
|
|
catch
|
|
|
|
|
{
|
|
|
|
|
// Already logged at lower levels
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
.Where(i => i != null);
|
|
|
|
|
|
|
|
|
|
return names;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public IEnumerable<MusicArtist> GetArtists(IEnumerable<IHasArtist> items)
|
|
|
|
|
{
|
|
|
|
|
var names = items
|
|
|
|
|
.SelectMany(i => i.AllArtists)
|
|
|
|
|
.DistinctNames()
|
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var artist = GetArtist(i);
|
|
|
|
|
|
|
|
|
|
return artist;
|
|
|
|
|
}
|
|
|
|
|
catch
|
|
|
|
|
{
|
|
|
|
|
// Already logged at lower levels
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
.Where(i => i != null);
|
|
|
|
|
|
|
|
|
|
return names;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void SetPropertiesFromSongs(MusicArtist artist, IEnumerable<IHasMetadata> items)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Validate and refresh the People sub-set of the IBN.
|
|
|
|
|
/// The items are stored in the db but not loaded into memory until actually requested by an operation.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <param name="progress">The progress.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
2013-10-13 19:52:57 +02:00
|
|
|
|
public Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2014-03-09 23:14:44 +01:00
|
|
|
|
// Ensure the location is available.
|
2014-03-02 19:01:46 +01:00
|
|
|
|
Directory.CreateDirectory(ConfigurationManager.ApplicationPaths.PeoplePath);
|
|
|
|
|
|
2014-08-14 15:24:30 +02:00
|
|
|
|
return new PeopleValidator(this, _logger, ConfigurationManager).ValidatePeople(cancellationToken, progress);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Reloads the root media folder
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="progress">The progress.</param>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
2013-04-14 21:39:25 +02:00
|
|
|
|
public Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
// Just run the scheduled task so that the user can see it
|
2013-09-24 17:08:51 +02:00
|
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
|
|
|
|
|
|
|
|
|
|
return Task.FromResult(true);
|
2013-04-14 21:39:25 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-12-15 17:53:32 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Queues the library scan.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void QueueLibraryScan()
|
|
|
|
|
{
|
|
|
|
|
// Just run the scheduled task so that the user can see it
|
|
|
|
|
_taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
|
|
|
|
|
}
|
2014-02-21 06:04:11 +01:00
|
|
|
|
|
2013-04-14 21:39:25 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Validates the media library internal.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="progress">The progress.</param>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
|
|
|
|
public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
|
2013-11-27 03:38:11 +01:00
|
|
|
|
{
|
2014-01-28 22:25:10 +01:00
|
|
|
|
_libraryMonitorFactory().Stop();
|
2013-11-27 03:38:11 +01:00
|
|
|
|
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
finally
|
|
|
|
|
{
|
2014-01-28 22:25:10 +01:00
|
|
|
|
_libraryMonitorFactory().Start();
|
2013-11-27 03:38:11 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-02-21 22:39:53 +01:00
|
|
|
|
_logger.Info("Validating media library");
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
|
await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2013-05-25 17:16:50 +02:00
|
|
|
|
progress.Report(.5);
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
// Start by just validating the children of the root, but go no further
|
2014-02-09 08:27:44 +01:00
|
|
|
|
await RootFolder.ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(), recursive: false);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2013-05-25 17:16:50 +02:00
|
|
|
|
progress.Report(1);
|
|
|
|
|
|
2014-02-21 06:04:11 +01:00
|
|
|
|
var userRoot = GetUserRootFolder();
|
2013-02-21 02:33:05 +01:00
|
|
|
|
|
2014-02-21 06:04:11 +01:00
|
|
|
|
await userRoot.RefreshMetadata(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
await userRoot.ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(), recursive: false).ConfigureAwait(false);
|
2013-05-25 17:16:50 +02:00
|
|
|
|
progress.Report(2);
|
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
|
var innerProgress = new ActionableProgress<double>();
|
|
|
|
|
|
2014-02-10 00:08:01 +01:00
|
|
|
|
innerProgress.RegisterAction(pct => progress.Report(2 + pct * .73));
|
2013-04-22 06:38:03 +02:00
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
// Now validate the entire media library
|
2014-02-09 08:27:44 +01:00
|
|
|
|
await RootFolder.ValidateChildren(innerProgress, cancellationToken, new MetadataRefreshOptions(), recursive: true).ConfigureAwait(false);
|
2013-04-22 06:38:03 +02:00
|
|
|
|
|
2013-09-10 20:56:00 +02:00
|
|
|
|
progress.Report(75);
|
2013-06-23 19:48:30 +02:00
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
|
innerProgress = new ActionableProgress<double>();
|
|
|
|
|
|
|
|
|
|
innerProgress.RegisterAction(pct => progress.Report(75 + pct * .25));
|
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
|
// Run post-scan tasks
|
2013-09-26 00:41:25 +02:00
|
|
|
|
await RunPostScanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
|
2013-04-22 06:38:03 +02:00
|
|
|
|
|
|
|
|
|
progress.Report(100);
|
2013-09-11 19:54:59 +02:00
|
|
|
|
|
|
|
|
|
// Bad practice, i know. But we keep a lot in memory, unfortunately.
|
|
|
|
|
GC.Collect(2, GCCollectionMode.Forced, true);
|
|
|
|
|
GC.Collect(2, GCCollectionMode.Forced, true);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Runs the post scan tasks.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="progress">The progress.</param>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
|
|
|
|
private async Task RunPostScanTasks(IProgress<double> progress, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2013-09-26 00:41:25 +02:00
|
|
|
|
var tasks = PostscanTasks.ToList();
|
2013-05-27 18:53:10 +02:00
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
|
var numComplete = 0;
|
|
|
|
|
var numTasks = tasks.Count;
|
|
|
|
|
|
|
|
|
|
foreach (var task in tasks)
|
2013-05-27 18:53:10 +02:00
|
|
|
|
{
|
|
|
|
|
var innerProgress = new ActionableProgress<double>();
|
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
|
// Prevent access to modified closure
|
|
|
|
|
var currentNumComplete = numComplete;
|
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
|
innerProgress.RegisterAction(pct =>
|
|
|
|
|
{
|
2013-09-26 00:41:25 +02:00
|
|
|
|
double innerPercent = (currentNumComplete * 100) + pct;
|
|
|
|
|
innerPercent /= numTasks;
|
|
|
|
|
progress.Report(innerPercent);
|
2013-05-27 18:53:10 +02:00
|
|
|
|
});
|
|
|
|
|
|
2015-07-10 06:44:21 +02:00
|
|
|
|
_logger.Debug("Running post-scan task {0}", task.GetType().Name);
|
|
|
|
|
|
2013-05-27 18:53:10 +02:00
|
|
|
|
try
|
|
|
|
|
{
|
2015-02-08 19:21:24 +01:00
|
|
|
|
await task.Run(innerProgress, cancellationToken).ConfigureAwait(false);
|
2013-05-27 18:53:10 +02:00
|
|
|
|
}
|
2013-09-18 04:43:34 +02:00
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
|
{
|
2013-09-26 00:41:25 +02:00
|
|
|
|
_logger.Info("Post-scan task cancelled: {0}", task.GetType().Name);
|
2013-09-18 04:43:34 +02:00
|
|
|
|
}
|
2013-05-27 18:53:10 +02:00
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error running postscan task", ex);
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-26 00:41:25 +02:00
|
|
|
|
numComplete++;
|
|
|
|
|
double percent = numComplete;
|
|
|
|
|
percent /= numTasks;
|
|
|
|
|
progress.Report(percent * 100);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
progress.Report(100);
|
2013-05-25 17:16:50 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the default view.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
|
2015-01-21 04:54:45 +01:00
|
|
|
|
public IEnumerable<VirtualFolderInfo> GetVirtualFolders()
|
2013-02-21 02:33:05 +01:00
|
|
|
|
{
|
2013-03-04 06:43:06 +01:00
|
|
|
|
return GetView(ConfigurationManager.ApplicationPaths.DefaultUserViewsPath);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the view.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="path">The path.</param>
|
|
|
|
|
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
|
|
|
|
|
private IEnumerable<VirtualFolderInfo> GetView(string path)
|
|
|
|
|
{
|
|
|
|
|
return Directory.EnumerateDirectories(path, "*", SearchOption.TopDirectoryOnly)
|
|
|
|
|
.Select(dir => new VirtualFolderInfo
|
|
|
|
|
{
|
|
|
|
|
Name = Path.GetFileName(dir),
|
2013-07-12 21:56:40 +02:00
|
|
|
|
|
2013-10-01 22:20:48 +02:00
|
|
|
|
Locations = Directory.EnumerateFiles(dir, "*.mblink", SearchOption.TopDirectoryOnly)
|
2013-10-30 15:40:14 +01:00
|
|
|
|
.Select(_fileSystem.ResolveShortcut)
|
2013-07-12 21:56:40 +02:00
|
|
|
|
.OrderBy(i => i)
|
|
|
|
|
.ToList(),
|
|
|
|
|
|
|
|
|
|
CollectionType = GetCollectionType(dir)
|
2013-02-21 02:33:05 +01:00
|
|
|
|
});
|
|
|
|
|
}
|
2013-02-28 20:32:41 +01:00
|
|
|
|
|
2013-07-12 21:56:40 +02:00
|
|
|
|
private string GetCollectionType(string path)
|
|
|
|
|
{
|
|
|
|
|
return new DirectoryInfo(path).EnumerateFiles("*.collection", SearchOption.TopDirectoryOnly)
|
2014-07-26 19:30:15 +02:00
|
|
|
|
.Select(i => _fileSystem.GetFileNameWithoutExtension(i))
|
2013-07-12 21:56:40 +02:00
|
|
|
|
.FirstOrDefault();
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-28 20:32:41 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the item by id.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="id">The id.</param>
|
|
|
|
|
/// <returns>BaseItem.</returns>
|
|
|
|
|
/// <exception cref="System.ArgumentNullException">id</exception>
|
|
|
|
|
public BaseItem GetItemById(Guid id)
|
|
|
|
|
{
|
|
|
|
|
if (id == Guid.Empty)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("id");
|
|
|
|
|
}
|
2013-03-02 03:44:46 +01:00
|
|
|
|
|
2013-03-31 19:39:28 +02:00
|
|
|
|
BaseItem item;
|
|
|
|
|
|
2013-05-08 22:58:52 +02:00
|
|
|
|
if (LibraryItemsCache.TryGetValue(id, out item))
|
|
|
|
|
{
|
|
|
|
|
return item;
|
|
|
|
|
}
|
2013-03-31 19:39:28 +02:00
|
|
|
|
|
2014-03-20 16:55:22 +01:00
|
|
|
|
item = RetrieveItem(id);
|
|
|
|
|
|
|
|
|
|
if (item != null)
|
|
|
|
|
{
|
|
|
|
|
RegisterItem(item);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return item;
|
2013-03-02 03:44:46 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-10-23 06:26:01 +02:00
|
|
|
|
public BaseItem GetMemoryItemById(Guid id)
|
|
|
|
|
{
|
|
|
|
|
if (id == Guid.Empty)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("id");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BaseItem item;
|
|
|
|
|
|
|
|
|
|
LibraryItemsCache.TryGetValue(id, out item);
|
|
|
|
|
|
|
|
|
|
return item;
|
|
|
|
|
}
|
2014-10-29 23:01:02 +01:00
|
|
|
|
|
2015-06-01 16:49:23 +02:00
|
|
|
|
public QueryResult<BaseItem> GetItems(InternalItemsQuery query)
|
|
|
|
|
{
|
|
|
|
|
var result = ItemRepository.GetItemIdsList(query);
|
|
|
|
|
|
2015-08-05 05:43:54 +02:00
|
|
|
|
var items = result.Select(GetItemById).Where(i => i != null).ToArray();
|
2015-06-01 16:49:23 +02:00
|
|
|
|
|
|
|
|
|
return new QueryResult<BaseItem>
|
|
|
|
|
{
|
|
|
|
|
Items = items
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-20 01:57:27 +02:00
|
|
|
|
public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
|
|
|
|
|
{
|
|
|
|
|
return ItemRepository.GetItems(query);
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-07 04:25:23 +02:00
|
|
|
|
public List<Guid> GetItemIds(InternalItemsQuery query)
|
|
|
|
|
{
|
|
|
|
|
return ItemRepository.GetItemIdsList(query);
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-02 03:44:46 +01:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the intros.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
|
/// <returns>IEnumerable{System.String}.</returns>
|
2014-09-22 23:56:54 +02:00
|
|
|
|
public async Task<IEnumerable<Video>> GetIntros(BaseItem item, User user)
|
2013-03-02 03:44:46 +01:00
|
|
|
|
{
|
2014-09-22 23:56:54 +02:00
|
|
|
|
var tasks = IntroProviders
|
2014-09-26 05:47:46 +02:00
|
|
|
|
.OrderBy(i => (i.GetType().Name.IndexOf("Default", StringComparison.OrdinalIgnoreCase) == -1 ? 0 : 1))
|
2014-09-22 23:56:54 +02:00
|
|
|
|
.Take(1)
|
|
|
|
|
.Select(i => GetIntros(i, item, user));
|
|
|
|
|
|
|
|
|
|
var items = await Task.WhenAll(tasks).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
return items
|
|
|
|
|
.SelectMany(i => i.ToArray())
|
2013-10-04 19:04:18 +02:00
|
|
|
|
.Select(ResolveIntro)
|
|
|
|
|
.Where(i => i != null);
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-22 23:56:54 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the intros.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="provider">The provider.</param>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
|
/// <returns>Task<IEnumerable<IntroInfo>>.</returns>
|
|
|
|
|
private async Task<IEnumerable<IntroInfo>> GetIntros(IIntroProvider provider, BaseItem item, User user)
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
return await provider.GetIntros(item, user).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting intros", ex);
|
|
|
|
|
|
|
|
|
|
return new List<IntroInfo>();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-04 19:04:18 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets all intro files.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <returns>IEnumerable{System.String}.</returns>
|
|
|
|
|
public IEnumerable<string> GetAllIntroFiles()
|
|
|
|
|
{
|
2014-09-23 02:04:50 +02:00
|
|
|
|
return IntroProviders.SelectMany(i =>
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
return i.GetAllIntroFiles().ToList();
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting intro files", ex);
|
|
|
|
|
|
|
|
|
|
return new List<string>();
|
|
|
|
|
}
|
|
|
|
|
});
|
2013-10-04 19:04:18 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Resolves the intro.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="info">The info.</param>
|
|
|
|
|
/// <returns>Video.</returns>
|
|
|
|
|
private Video ResolveIntro(IntroInfo info)
|
|
|
|
|
{
|
|
|
|
|
Video video = null;
|
2013-10-13 19:52:57 +02:00
|
|
|
|
|
2013-10-04 19:04:18 +02:00
|
|
|
|
if (info.ItemId.HasValue)
|
|
|
|
|
{
|
|
|
|
|
// Get an existing item by Id
|
|
|
|
|
video = GetItemById(info.ItemId.Value) as Video;
|
|
|
|
|
|
|
|
|
|
if (video == null)
|
|
|
|
|
{
|
|
|
|
|
_logger.Error("Unable to locate item with Id {0}.", info.ItemId.Value);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (!string.IsNullOrEmpty(info.Path))
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
// Try to resolve the path into a video
|
2013-10-30 15:40:14 +01:00
|
|
|
|
video = ResolvePath(_fileSystem.GetFileSystemInfo(info.Path)) as Video;
|
2013-10-04 19:04:18 +02:00
|
|
|
|
|
|
|
|
|
if (video == null)
|
|
|
|
|
{
|
|
|
|
|
_logger.Error("Intro resolver returned null for {0}.", info.Path);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// Pull the saved db item that will include metadata
|
|
|
|
|
var dbItem = GetItemById(video.Id) as Video;
|
|
|
|
|
|
|
|
|
|
if (dbItem != null)
|
|
|
|
|
{
|
|
|
|
|
video = dbItem;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error resolving path {0}.", ex, info.Path);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
_logger.Error("IntroProvider returned an IntroInfo with null Path and ItemId.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return video;
|
2013-02-28 20:32:41 +01:00
|
|
|
|
}
|
2013-03-10 05:22:36 +01:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Sorts the specified sort by.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="items">The items.</param>
|
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
|
/// <param name="sortBy">The sort by.</param>
|
|
|
|
|
/// <param name="sortOrder">The sort order.</param>
|
|
|
|
|
/// <returns>IEnumerable{BaseItem}.</returns>
|
|
|
|
|
public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User user, IEnumerable<string> sortBy, SortOrder sortOrder)
|
|
|
|
|
{
|
|
|
|
|
var isFirst = true;
|
|
|
|
|
|
|
|
|
|
IOrderedEnumerable<BaseItem> orderedItems = null;
|
|
|
|
|
|
|
|
|
|
foreach (var orderBy in sortBy.Select(o => GetComparer(o, user)).Where(c => c != null))
|
|
|
|
|
{
|
|
|
|
|
if (isFirst)
|
|
|
|
|
{
|
|
|
|
|
orderedItems = sortOrder == SortOrder.Descending ? items.OrderByDescending(i => i, orderBy) : items.OrderBy(i => i, orderBy);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
orderedItems = sortOrder == SortOrder.Descending ? orderedItems.ThenByDescending(i => i, orderBy) : orderedItems.ThenBy(i => i, orderBy);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
isFirst = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return orderedItems ?? items;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the comparer.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="name">The name.</param>
|
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
|
/// <returns>IBaseItemComparer.</returns>
|
|
|
|
|
private IBaseItemComparer GetComparer(string name, User user)
|
|
|
|
|
{
|
|
|
|
|
var comparer = Comparers.FirstOrDefault(c => string.Equals(name, c.Name, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (comparer != null)
|
|
|
|
|
{
|
|
|
|
|
// If it requires a user, create a new one, and assign the user
|
|
|
|
|
if (comparer is IUserBaseItemComparer)
|
|
|
|
|
{
|
|
|
|
|
var userComparer = (IUserBaseItemComparer)Activator.CreateInstance(comparer.GetType());
|
|
|
|
|
|
|
|
|
|
userComparer.User = user;
|
2013-04-02 21:25:16 +02:00
|
|
|
|
userComparer.UserManager = _userManager;
|
2013-04-13 20:02:30 +02:00
|
|
|
|
userComparer.UserDataRepository = _userDataRepository;
|
2013-03-10 05:22:36 +01:00
|
|
|
|
|
|
|
|
|
return userComparer;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return comparer;
|
|
|
|
|
}
|
2013-04-08 17:55:53 +02:00
|
|
|
|
|
2013-05-03 06:10:11 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Creates the item.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
2013-05-23 17:39:48 +02:00
|
|
|
|
public Task CreateItem(BaseItem item, CancellationToken cancellationToken)
|
2013-05-03 06:10:11 +02:00
|
|
|
|
{
|
2013-05-23 17:39:48 +02:00
|
|
|
|
return CreateItems(new[] { item }, cancellationToken);
|
|
|
|
|
}
|
2013-05-03 06:10:11 +02:00
|
|
|
|
|
2013-05-23 17:39:48 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Creates the items.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="items">The items.</param>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
|
|
|
|
public async Task CreateItems(IEnumerable<BaseItem> items, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var list = items.ToList();
|
|
|
|
|
|
|
|
|
|
await ItemRepository.SaveItems(list, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
foreach (var item in list)
|
|
|
|
|
{
|
|
|
|
|
UpdateItemInLibraryCache(item);
|
|
|
|
|
}
|
2013-05-22 05:42:25 +02:00
|
|
|
|
|
2013-05-03 06:10:11 +02:00
|
|
|
|
if (ItemAdded != null)
|
|
|
|
|
{
|
2013-05-23 17:39:48 +02:00
|
|
|
|
foreach (var item in list)
|
2013-05-03 19:26:44 +02:00
|
|
|
|
{
|
2013-05-23 17:39:48 +02:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
ItemAdded(this, new ItemChangeEventArgs { Item = item });
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
2013-06-09 19:37:16 +02:00
|
|
|
|
_logger.ErrorException("Error in ItemAdded event handler", ex);
|
2013-05-23 17:39:48 +02:00
|
|
|
|
}
|
2013-05-03 19:26:44 +02:00
|
|
|
|
}
|
2013-05-03 06:10:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
2013-06-25 03:22:21 +02:00
|
|
|
|
/// Updates the item.
|
2013-05-03 06:10:11 +02:00
|
|
|
|
/// </summary>
|
2013-06-25 03:22:21 +02:00
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
/// <param name="updateReason">The update reason.</param>
|
2013-05-03 06:10:11 +02:00
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
2013-06-25 03:22:21 +02:00
|
|
|
|
public async Task UpdateItem(BaseItem item, ItemUpdateType updateReason, CancellationToken cancellationToken)
|
2013-05-03 06:10:11 +02:00
|
|
|
|
{
|
2014-02-17 22:35:08 +01:00
|
|
|
|
var locationType = item.LocationType;
|
|
|
|
|
if (locationType != LocationType.Remote && locationType != LocationType.Virtual)
|
2013-05-24 17:01:53 +02:00
|
|
|
|
{
|
2014-02-02 14:36:31 +01:00
|
|
|
|
await _providerManagerFactory().SaveMetadata(item, updateReason).ConfigureAwait(false);
|
2013-05-03 06:10:11 +02:00
|
|
|
|
}
|
2014-02-21 06:04:11 +01:00
|
|
|
|
|
2013-12-06 16:59:40 +01:00
|
|
|
|
item.DateLastSaved = DateTime.UtcNow;
|
|
|
|
|
|
2014-09-28 22:49:43 +02:00
|
|
|
|
var logName = item.LocationType == LocationType.Remote ? item.Name ?? item.Path : item.Path ?? item.Name;
|
|
|
|
|
_logger.Debug("Saving {0} to database.", logName);
|
2014-02-06 05:39:16 +01:00
|
|
|
|
|
2013-09-25 21:59:02 +02:00
|
|
|
|
await ItemRepository.SaveItem(item, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
UpdateItemInLibraryCache(item);
|
|
|
|
|
|
2013-06-25 03:22:21 +02:00
|
|
|
|
if (ItemUpdated != null)
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
2013-11-13 17:45:41 +01:00
|
|
|
|
ItemUpdated(this, new ItemChangeEventArgs
|
|
|
|
|
{
|
|
|
|
|
Item = item,
|
|
|
|
|
UpdateReason = updateReason
|
|
|
|
|
});
|
2013-06-25 03:22:21 +02:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error in ItemUpdated event handler", ex);
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-05-24 17:01:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-05-03 06:10:11 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Reports the item removed.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
public void ReportItemRemoved(BaseItem item)
|
|
|
|
|
{
|
|
|
|
|
if (ItemRemoved != null)
|
|
|
|
|
{
|
2013-05-03 19:26:44 +02:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
ItemRemoved(this, new ItemChangeEventArgs { Item = item });
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error in ItemRemoved event handler", ex);
|
|
|
|
|
}
|
2013-05-03 06:10:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-08 17:55:53 +02:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Retrieves the item.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="id">The id.</param>
|
2013-06-17 22:35:43 +02:00
|
|
|
|
/// <returns>BaseItem.</returns>
|
2013-06-26 18:08:16 +02:00
|
|
|
|
public BaseItem RetrieveItem(Guid id)
|
2013-04-08 17:55:53 +02:00
|
|
|
|
{
|
2013-12-03 22:11:09 +01:00
|
|
|
|
return ItemRepository.RetrieveItem(id);
|
2013-11-21 21:48:26 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-02-15 04:36:07 +01:00
|
|
|
|
public IEnumerable<Folder> GetCollectionFolders(BaseItem item)
|
|
|
|
|
{
|
|
|
|
|
while (!(item.Parent is AggregateFolder) && item.Parent != null)
|
|
|
|
|
{
|
|
|
|
|
item = item.Parent;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
return new List<Folder>();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return GetUserRootFolder().Children
|
|
|
|
|
.OfType<Folder>()
|
2015-04-10 16:01:16 +02:00
|
|
|
|
.Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path, StringComparer.OrdinalIgnoreCase));
|
2015-02-15 04:36:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-21 19:58:17 +01:00
|
|
|
|
public string GetContentType(BaseItem item)
|
|
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
|
string configuredContentType = GetConfiguredContentType(item, false);
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(configuredContentType))
|
2014-12-22 07:50:29 +01:00
|
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
|
return configuredContentType;
|
2014-12-22 07:50:29 +01:00
|
|
|
|
}
|
2015-01-10 02:38:01 +01:00
|
|
|
|
configuredContentType = GetConfiguredContentType(item, true);
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(configuredContentType))
|
|
|
|
|
{
|
|
|
|
|
return configuredContentType;
|
|
|
|
|
}
|
|
|
|
|
return GetInheritedContentType(item);
|
2015-01-02 06:36:27 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public string GetInheritedContentType(BaseItem item)
|
|
|
|
|
{
|
|
|
|
|
var type = GetTopFolderContentType(item);
|
2014-12-22 07:50:29 +01:00
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(type))
|
|
|
|
|
{
|
|
|
|
|
return type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return item.Parents
|
|
|
|
|
.Select(GetConfiguredContentType)
|
|
|
|
|
.LastOrDefault(i => !string.IsNullOrWhiteSpace(i));
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
|
public string GetConfiguredContentType(BaseItem item)
|
2014-12-22 07:50:29 +01:00
|
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
|
return GetConfiguredContentType(item, false);
|
2014-12-22 07:50:29 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
|
public string GetConfiguredContentType(string path)
|
2014-12-22 07:50:29 +01:00
|
|
|
|
{
|
2015-01-10 02:38:01 +01:00
|
|
|
|
return GetContentTypeOverride(path, false);
|
|
|
|
|
}
|
2014-12-22 07:50:29 +01:00
|
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
|
public string GetConfiguredContentType(BaseItem item, bool inheritConfiguredPath)
|
|
|
|
|
{
|
|
|
|
|
ICollectionFolder collectionFolder = item as ICollectionFolder;
|
|
|
|
|
if (collectionFolder != null)
|
|
|
|
|
{
|
|
|
|
|
return collectionFolder.CollectionType;
|
|
|
|
|
}
|
|
|
|
|
return GetContentTypeOverride(item.ContainingFolderPath, inheritConfiguredPath);
|
2014-12-21 19:58:17 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-01-10 02:38:01 +01:00
|
|
|
|
private string GetContentTypeOverride(string path, bool inherit)
|
|
|
|
|
{
|
|
|
|
|
var nameValuePair = ConfigurationManager.Configuration.ContentTypes.FirstOrDefault(i => string.Equals(i.Name, path, StringComparison.OrdinalIgnoreCase) || (inherit && _fileSystem.ContainsSubPath(i.Name, path)));
|
|
|
|
|
if (nameValuePair != null)
|
|
|
|
|
{
|
|
|
|
|
return nameValuePair.Value;
|
|
|
|
|
}
|
|
|
|
|
return null;
|
|
|
|
|
}
|
2015-02-15 04:36:07 +01:00
|
|
|
|
|
2014-12-21 19:58:17 +01:00
|
|
|
|
private string GetTopFolderContentType(BaseItem item)
|
2013-07-12 21:56:40 +02:00
|
|
|
|
{
|
|
|
|
|
while (!(item.Parent is AggregateFolder) && item.Parent != null)
|
|
|
|
|
{
|
|
|
|
|
item = item.Parent;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-21 02:23:56 +01:00
|
|
|
|
return GetUserRootFolder().Children
|
2014-10-12 03:46:02 +02:00
|
|
|
|
.OfType<ICollectionFolder>()
|
2014-12-21 02:23:56 +01:00
|
|
|
|
.Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path))
|
2013-07-12 21:56:40 +02:00
|
|
|
|
.Select(i => i.CollectionType)
|
2014-12-21 02:23:56 +01:00
|
|
|
|
.FirstOrDefault(i => !string.IsNullOrWhiteSpace(i));
|
2013-07-12 21:56:40 +02:00
|
|
|
|
}
|
2013-11-21 21:48:26 +01:00
|
|
|
|
|
2015-07-29 22:31:15 +02:00
|
|
|
|
private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromHours(24);
|
2015-05-08 21:10:53 +02:00
|
|
|
|
|
2015-08-14 20:00:26 +02:00
|
|
|
|
public Task<UserView> GetNamedView(User user,
|
2015-03-14 05:50:23 +01:00
|
|
|
|
string name,
|
|
|
|
|
string viewType,
|
2014-10-29 23:01:02 +01:00
|
|
|
|
string sortName,
|
|
|
|
|
CancellationToken cancellationToken)
|
2014-06-07 21:46:24 +02:00
|
|
|
|
{
|
2015-03-14 05:50:23 +01:00
|
|
|
|
if (ConfigurationManager.Configuration.EnableUserSpecificUserViews)
|
|
|
|
|
{
|
2015-08-14 20:00:26 +02:00
|
|
|
|
return GetNamedViewInternal(user, name, null, viewType, sortName, null, cancellationToken);
|
2015-03-14 05:50:23 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-14 20:00:26 +02:00
|
|
|
|
return GetNamedView(name, viewType, sortName, cancellationToken);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<UserView> GetNamedView(string name,
|
|
|
|
|
string viewType,
|
|
|
|
|
string sortName,
|
|
|
|
|
CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-08-14 20:30:08 +02:00
|
|
|
|
var path = Path.Combine(ConfigurationManager.ApplicationPaths.ItemsByNamePath, "views");
|
2014-09-05 05:48:53 +02:00
|
|
|
|
|
2015-03-14 05:50:23 +01:00
|
|
|
|
path = Path.Combine(path, _fileSystem.GetValidFilename(viewType));
|
2014-06-07 21:46:24 +02:00
|
|
|
|
|
2014-11-30 20:01:33 +01:00
|
|
|
|
var id = GetNewItemId(path + "_namedview_" + name, typeof(UserView));
|
2014-07-26 19:30:15 +02:00
|
|
|
|
|
|
|
|
|
var item = GetItemById(id) as UserView;
|
2014-09-05 05:48:53 +02:00
|
|
|
|
|
2014-10-29 23:01:02 +01:00
|
|
|
|
var refresh = false;
|
|
|
|
|
|
2014-09-22 23:56:54 +02:00
|
|
|
|
if (item == null ||
|
2014-09-06 22:09:35 +02:00
|
|
|
|
!string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
|
2014-06-07 21:46:24 +02:00
|
|
|
|
{
|
2014-09-06 22:09:35 +02:00
|
|
|
|
Directory.CreateDirectory(path);
|
2014-06-07 21:46:24 +02:00
|
|
|
|
|
|
|
|
|
item = new UserView
|
|
|
|
|
{
|
|
|
|
|
Path = path,
|
2014-07-26 19:30:15 +02:00
|
|
|
|
Id = id,
|
2014-06-07 21:46:24 +02:00
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
|
Name = name,
|
2015-03-14 05:50:23 +01:00
|
|
|
|
ViewType = viewType,
|
2014-06-07 21:46:24 +02:00
|
|
|
|
ForcedSortName = sortName
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
await CreateItem(item, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2014-10-29 23:01:02 +01:00
|
|
|
|
refresh = true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-16 16:59:39 +02:00
|
|
|
|
if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
item.ViewType = viewType;
|
|
|
|
|
await item.UpdateToRepository(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-27 07:03:34 +02:00
|
|
|
|
if (!refresh)
|
2014-10-29 23:01:02 +01:00
|
|
|
|
{
|
2015-05-08 21:10:53 +02:00
|
|
|
|
refresh = (DateTime.UtcNow - item.DateLastSaved) >= _viewRefreshInterval;
|
2014-10-29 23:01:02 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (refresh)
|
|
|
|
|
{
|
2015-03-14 05:50:23 +01:00
|
|
|
|
await item.UpdateToRepository(ItemUpdateType.MetadataImport, CancellationToken.None).ConfigureAwait(false);
|
2015-05-08 21:10:53 +02:00
|
|
|
|
_providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions
|
|
|
|
|
{
|
|
|
|
|
// Not sure why this is necessary but need to figure it out
|
|
|
|
|
// View images are not getting utilized without this
|
|
|
|
|
ForceSave = true
|
|
|
|
|
});
|
2014-10-29 23:01:02 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return item;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-14 05:50:23 +01:00
|
|
|
|
public Task<UserView> GetNamedView(User user,
|
2014-10-29 23:01:02 +01:00
|
|
|
|
string name,
|
|
|
|
|
string parentId,
|
|
|
|
|
string viewType,
|
|
|
|
|
string sortName,
|
2015-04-20 20:04:02 +02:00
|
|
|
|
string uniqueId,
|
2014-10-29 23:01:02 +01:00
|
|
|
|
CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-03-14 05:50:23 +01:00
|
|
|
|
if (string.IsNullOrWhiteSpace(parentId))
|
2014-10-29 23:01:02 +01:00
|
|
|
|
{
|
2015-03-14 05:50:23 +01:00
|
|
|
|
throw new ArgumentNullException("parentId");
|
2014-10-29 23:01:02 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-04-20 20:04:02 +02:00
|
|
|
|
return GetNamedViewInternal(user, name, parentId, viewType, sortName, uniqueId, cancellationToken);
|
2015-03-14 05:50:23 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private async Task<UserView> GetNamedViewInternal(User user,
|
|
|
|
|
string name,
|
|
|
|
|
string parentId,
|
|
|
|
|
string viewType,
|
|
|
|
|
string sortName,
|
2015-04-20 20:04:02 +02:00
|
|
|
|
string uniqueId,
|
2015-03-14 05:50:23 +01:00
|
|
|
|
CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
if (string.IsNullOrWhiteSpace(name))
|
2014-10-29 23:01:02 +01:00
|
|
|
|
{
|
2015-03-14 05:50:23 +01:00
|
|
|
|
throw new ArgumentNullException("name");
|
2014-10-29 23:01:02 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-04-20 20:04:02 +02:00
|
|
|
|
var idValues = "37_namedview_" + name + user.Id.ToString("N") + (parentId ?? string.Empty);
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(uniqueId))
|
|
|
|
|
{
|
|
|
|
|
idValues += uniqueId;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var id = GetNewItemId(idValues, typeof(UserView));
|
2014-10-29 23:01:02 +01:00
|
|
|
|
|
2015-03-14 05:50:23 +01:00
|
|
|
|
var path = Path.Combine(ConfigurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N"));
|
2014-10-29 23:01:02 +01:00
|
|
|
|
|
|
|
|
|
var item = GetItemById(id) as UserView;
|
|
|
|
|
|
2015-03-14 18:02:51 +01:00
|
|
|
|
var isNew = false;
|
2014-10-29 23:01:02 +01:00
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
Directory.CreateDirectory(path);
|
|
|
|
|
|
|
|
|
|
item = new UserView
|
|
|
|
|
{
|
|
|
|
|
Path = path,
|
|
|
|
|
Id = id,
|
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
|
Name = name,
|
|
|
|
|
ViewType = viewType,
|
2015-08-14 19:24:07 +02:00
|
|
|
|
ForcedSortName = sortName
|
2014-10-29 23:01:02 +01:00
|
|
|
|
};
|
|
|
|
|
|
2015-03-14 05:50:23 +01:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(parentId))
|
2015-08-14 20:00:26 +02:00
|
|
|
|
{
|
|
|
|
|
item.ParentId = new Guid(parentId);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
await CreateItem(item, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
item.ViewType = viewType;
|
|
|
|
|
await item.UpdateToRepository(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var refresh = isNew || (DateTime.UtcNow - item.DateLastSaved) >= _viewRefreshInterval;
|
|
|
|
|
|
|
|
|
|
if (refresh)
|
|
|
|
|
{
|
|
|
|
|
_providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions
|
|
|
|
|
{
|
|
|
|
|
// Need to force save to increment DateLastSaved
|
|
|
|
|
ForceSave = true
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return item;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<UserView> GetNamedView(string name,
|
|
|
|
|
string parentId,
|
|
|
|
|
string viewType,
|
|
|
|
|
string sortName,
|
|
|
|
|
string uniqueId,
|
|
|
|
|
CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
if (string.IsNullOrWhiteSpace(name))
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("name");
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-14 21:14:54 +02:00
|
|
|
|
var idValues = "37_namedview_" + name + (parentId ?? string.Empty) + (viewType ?? string.Empty);
|
2015-08-14 20:00:26 +02:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(uniqueId))
|
|
|
|
|
{
|
|
|
|
|
idValues += uniqueId;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var id = GetNewItemId(idValues, typeof(UserView));
|
|
|
|
|
|
|
|
|
|
var path = Path.Combine(ConfigurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N"));
|
|
|
|
|
|
|
|
|
|
var item = GetItemById(id) as UserView;
|
|
|
|
|
|
|
|
|
|
var isNew = false;
|
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
Directory.CreateDirectory(path);
|
|
|
|
|
|
|
|
|
|
item = new UserView
|
|
|
|
|
{
|
|
|
|
|
Path = path,
|
|
|
|
|
Id = id,
|
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
|
Name = name,
|
|
|
|
|
ViewType = viewType,
|
|
|
|
|
ForcedSortName = sortName
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(parentId))
|
2015-03-14 05:50:23 +01:00
|
|
|
|
{
|
|
|
|
|
item.ParentId = new Guid(parentId);
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-29 23:01:02 +01:00
|
|
|
|
await CreateItem(item, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2015-03-14 18:02:51 +01:00
|
|
|
|
isNew = true;
|
2014-10-29 23:01:02 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-04-15 23:59:20 +02:00
|
|
|
|
if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
item.ViewType = viewType;
|
|
|
|
|
await item.UpdateToRepository(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-08 21:10:53 +02:00
|
|
|
|
var refresh = isNew || (DateTime.UtcNow - item.DateLastSaved) >= _viewRefreshInterval;
|
2014-10-29 23:01:02 +01:00
|
|
|
|
|
|
|
|
|
if (refresh)
|
|
|
|
|
{
|
2015-03-27 00:10:34 +01:00
|
|
|
|
_providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions
|
|
|
|
|
{
|
|
|
|
|
// Need to force save to increment DateLastSaved
|
|
|
|
|
ForceSave = true
|
|
|
|
|
});
|
2014-06-07 21:46:24 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return item;
|
|
|
|
|
}
|
2014-11-16 21:44:08 +01:00
|
|
|
|
|
|
|
|
|
public bool IsVideoFile(string path)
|
|
|
|
|
{
|
2015-01-17 05:38:24 +01:00
|
|
|
|
var resolver = new VideoResolver(GetNamingOptions(), new PatternsLogger());
|
2014-11-16 23:46:01 +01:00
|
|
|
|
return resolver.IsVideoFile(path);
|
2014-11-16 21:44:08 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public bool IsAudioFile(string path)
|
|
|
|
|
{
|
2015-01-10 06:53:35 +01:00
|
|
|
|
var parser = new AudioFileParser(GetNamingOptions());
|
2014-11-16 21:44:08 +01:00
|
|
|
|
return parser.IsAudioFile(path);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public int? GetSeasonNumberFromPath(string path)
|
|
|
|
|
{
|
2015-01-10 06:53:35 +01:00
|
|
|
|
return new SeasonPathParser(GetNamingOptions(), new RegexProvider()).Parse(path, true, true).SeasonNumber;
|
2014-11-16 21:44:08 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-19 05:20:07 +01:00
|
|
|
|
public bool FillMissingEpisodeNumbersFromPath(Episode episode)
|
2014-11-16 21:44:08 +01:00
|
|
|
|
{
|
2015-01-10 06:53:35 +01:00
|
|
|
|
var resolver = new EpisodeResolver(GetNamingOptions(),
|
2015-01-17 05:38:24 +01:00
|
|
|
|
new PatternsLogger());
|
2014-11-16 21:44:08 +01:00
|
|
|
|
|
2015-04-29 20:48:34 +02:00
|
|
|
|
var isFolder = episode.VideoType == VideoType.BluRay || episode.VideoType == VideoType.Dvd ||
|
|
|
|
|
episode.VideoType == VideoType.HdDvd;
|
2014-12-23 04:58:14 +01:00
|
|
|
|
|
2014-12-19 05:20:07 +01:00
|
|
|
|
var locationType = episode.LocationType;
|
2014-12-21 02:23:56 +01:00
|
|
|
|
|
2014-12-19 05:20:07 +01:00
|
|
|
|
var episodeInfo = locationType == LocationType.FileSystem || locationType == LocationType.Offline ?
|
2015-04-29 20:48:34 +02:00
|
|
|
|
resolver.Resolve(episode.Path, isFolder) :
|
2014-12-19 05:20:07 +01:00
|
|
|
|
new Naming.TV.EpisodeInfo();
|
2014-11-16 21:44:08 +01:00
|
|
|
|
|
2014-12-19 05:20:07 +01:00
|
|
|
|
if (episodeInfo == null)
|
|
|
|
|
{
|
|
|
|
|
episodeInfo = new Naming.TV.EpisodeInfo();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var changed = false;
|
|
|
|
|
|
2014-12-23 04:58:14 +01:00
|
|
|
|
if (episodeInfo.IsByDate)
|
2014-12-19 05:20:07 +01:00
|
|
|
|
{
|
|
|
|
|
if (episode.IndexNumber.HasValue)
|
|
|
|
|
{
|
2014-12-23 04:58:14 +01:00
|
|
|
|
episode.IndexNumber = null;
|
2014-12-19 05:20:07 +01:00
|
|
|
|
changed = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (episode.IndexNumberEnd.HasValue)
|
|
|
|
|
{
|
2014-12-23 04:58:14 +01:00
|
|
|
|
episode.IndexNumberEnd = null;
|
2014-12-19 05:20:07 +01:00
|
|
|
|
changed = true;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-23 04:58:14 +01:00
|
|
|
|
if (!episode.PremiereDate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
if (episodeInfo.Year.HasValue && episodeInfo.Month.HasValue && episodeInfo.Day.HasValue)
|
|
|
|
|
{
|
|
|
|
|
episode.PremiereDate = new DateTime(episodeInfo.Year.Value, episodeInfo.Month.Value, episodeInfo.Day.Value).ToUniversalTime();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (episode.PremiereDate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
changed = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!episode.ProductionYear.HasValue)
|
|
|
|
|
{
|
|
|
|
|
episode.ProductionYear = episodeInfo.Year;
|
|
|
|
|
|
|
|
|
|
if (episode.ProductionYear.HasValue)
|
|
|
|
|
{
|
|
|
|
|
changed = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-12-19 05:20:07 +01:00
|
|
|
|
|
|
|
|
|
if (!episode.ParentIndexNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var season = episode.Season;
|
|
|
|
|
|
|
|
|
|
if (season != null)
|
|
|
|
|
{
|
|
|
|
|
episode.ParentIndexNumber = season.IndexNumber;
|
|
|
|
|
}
|
2014-12-23 04:58:14 +01:00
|
|
|
|
|
|
|
|
|
if (episode.ParentIndexNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
changed = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (!episode.IndexNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
episode.IndexNumber = episodeInfo.EpisodeNumber;
|
|
|
|
|
|
|
|
|
|
if (episode.IndexNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
changed = true;
|
|
|
|
|
}
|
2014-12-19 05:20:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-23 04:58:14 +01:00
|
|
|
|
if (!episode.IndexNumberEnd.HasValue)
|
2014-12-19 05:20:07 +01:00
|
|
|
|
{
|
2014-12-23 04:58:14 +01:00
|
|
|
|
episode.IndexNumberEnd = episodeInfo.EndingEpsiodeNumber;
|
|
|
|
|
|
|
|
|
|
if (episode.IndexNumberEnd.HasValue)
|
|
|
|
|
{
|
|
|
|
|
changed = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!episode.ParentIndexNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
episode.ParentIndexNumber = episodeInfo.SeasonNumber;
|
|
|
|
|
|
|
|
|
|
if (!episode.ParentIndexNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var season = episode.Season;
|
|
|
|
|
|
|
|
|
|
if (season != null)
|
|
|
|
|
{
|
|
|
|
|
episode.ParentIndexNumber = season.IndexNumber;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (episode.ParentIndexNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
changed = true;
|
|
|
|
|
}
|
2014-12-19 05:20:07 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return changed;
|
2014-11-16 21:44:08 +01:00
|
|
|
|
}
|
2014-11-16 23:46:01 +01:00
|
|
|
|
|
2015-01-10 06:53:35 +01:00
|
|
|
|
public NamingOptions GetNamingOptions()
|
|
|
|
|
{
|
|
|
|
|
var options = new ExtendedNamingOptions();
|
|
|
|
|
|
2015-03-12 04:38:59 +01:00
|
|
|
|
// These cause apps to have problems
|
|
|
|
|
options.AudioFileExtensions.Remove(".m3u");
|
|
|
|
|
options.AudioFileExtensions.Remove(".wpl");
|
2015-03-14 05:50:23 +01:00
|
|
|
|
|
2015-01-10 06:53:35 +01:00
|
|
|
|
if (!ConfigurationManager.Configuration.EnableAudioArchiveFiles)
|
|
|
|
|
{
|
|
|
|
|
options.AudioFileExtensions.Remove(".rar");
|
|
|
|
|
options.AudioFileExtensions.Remove(".zip");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!ConfigurationManager.Configuration.EnableVideoArchiveFiles)
|
|
|
|
|
{
|
|
|
|
|
options.VideoFileExtensions.Remove(".rar");
|
|
|
|
|
options.VideoFileExtensions.Remove(".zip");
|
|
|
|
|
}
|
2015-02-15 04:36:07 +01:00
|
|
|
|
|
2015-01-10 06:53:35 +01:00
|
|
|
|
return options;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-16 23:46:01 +01:00
|
|
|
|
public ItemLookupInfo ParseName(string name)
|
|
|
|
|
{
|
2015-01-17 05:38:24 +01:00
|
|
|
|
var resolver = new VideoResolver(GetNamingOptions(), new PatternsLogger());
|
2014-11-16 23:46:01 +01:00
|
|
|
|
|
|
|
|
|
var result = resolver.CleanDateTime(name);
|
2014-11-21 15:28:30 +01:00
|
|
|
|
var cleanName = resolver.CleanString(result.Name);
|
2014-11-16 23:46:01 +01:00
|
|
|
|
|
|
|
|
|
return new ItemLookupInfo
|
|
|
|
|
{
|
2014-11-21 15:28:30 +01:00
|
|
|
|
Name = cleanName.Name,
|
2014-11-16 23:46:01 +01:00
|
|
|
|
Year = result.Year
|
|
|
|
|
};
|
|
|
|
|
}
|
2014-11-18 03:48:22 +01:00
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
public IEnumerable<Video> FindTrailers(BaseItem owner, List<FileSystemInfo> fileSystemChildren, IDirectoryService directoryService)
|
2014-12-01 19:42:07 +01:00
|
|
|
|
{
|
|
|
|
|
var files = fileSystemChildren.OfType<DirectoryInfo>()
|
|
|
|
|
.Where(i => string.Equals(i.Name, BaseItem.TrailerFolderName, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
.SelectMany(i => i.EnumerateFiles("*", SearchOption.TopDirectoryOnly))
|
|
|
|
|
.ToList();
|
|
|
|
|
|
2015-01-17 05:38:24 +01:00
|
|
|
|
var videoListResolver = new VideoListResolver(GetNamingOptions(), new PatternsLogger());
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2015-04-29 20:48:34 +02:00
|
|
|
|
var videos = videoListResolver.Resolve(fileSystemChildren.Select(i => new FileMetadata
|
2014-12-03 04:13:03 +01:00
|
|
|
|
{
|
2015-04-29 20:48:34 +02:00
|
|
|
|
Id = i.FullName,
|
|
|
|
|
IsFolder = ((i.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
}).ToList());
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
if (currentVideo != null)
|
|
|
|
|
{
|
|
|
|
|
files.AddRange(currentVideo.Extras.Where(i => string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => new FileInfo(i.Path)));
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
return ResolvePaths(files, directoryService, null, null)
|
|
|
|
|
.OfType<Video>()
|
|
|
|
|
.Select(video =>
|
2014-12-01 19:42:07 +01:00
|
|
|
|
{
|
|
|
|
|
// Try to retrieve it from the db. If we don't find it, use the resolved version
|
2014-12-03 04:13:03 +01:00
|
|
|
|
var dbItem = GetItemById(video.Id) as Video;
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
|
|
|
|
if (dbItem != null)
|
|
|
|
|
{
|
|
|
|
|
video = dbItem;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
video.ExtraType = ExtraType.Trailer;
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
|
|
|
|
return video;
|
|
|
|
|
|
|
|
|
|
// Sort them so that the list can be easily compared for changes
|
|
|
|
|
}).OrderBy(i => i.Path).ToList();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public IEnumerable<Video> FindExtras(BaseItem owner, List<FileSystemInfo> fileSystemChildren, IDirectoryService directoryService)
|
|
|
|
|
{
|
|
|
|
|
var files = fileSystemChildren.OfType<DirectoryInfo>()
|
|
|
|
|
.Where(i => string.Equals(i.Name, "extras", StringComparison.OrdinalIgnoreCase) || string.Equals(i.Name, "specials", StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
.SelectMany(i => i.EnumerateFiles("*", SearchOption.TopDirectoryOnly))
|
|
|
|
|
.ToList();
|
|
|
|
|
|
2015-01-17 05:38:24 +01:00
|
|
|
|
var videoListResolver = new VideoListResolver(GetNamingOptions(), new PatternsLogger());
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2015-04-29 20:48:34 +02:00
|
|
|
|
var videos = videoListResolver.Resolve(fileSystemChildren.Select(i => new FileMetadata
|
2014-12-03 04:13:03 +01:00
|
|
|
|
{
|
2015-04-29 20:48:34 +02:00
|
|
|
|
Id = i.FullName,
|
|
|
|
|
IsFolder = ((i.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
}).ToList());
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (currentVideo != null)
|
|
|
|
|
{
|
|
|
|
|
files.AddRange(currentVideo.Extras.Where(i => !string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => new FileInfo(i.Path)));
|
|
|
|
|
}
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
return ResolvePaths(files, directoryService, null, null)
|
|
|
|
|
.OfType<Video>()
|
|
|
|
|
.Select(video =>
|
2014-12-01 19:42:07 +01:00
|
|
|
|
{
|
2014-12-04 06:24:41 +01:00
|
|
|
|
// Try to retrieve it from the db. If we don't find it, use the resolved version
|
|
|
|
|
var dbItem = GetItemById(video.Id) as Video;
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
if (dbItem != null)
|
|
|
|
|
{
|
|
|
|
|
video = dbItem;
|
|
|
|
|
}
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
SetExtraTypeFromFilename(video);
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-04 06:24:41 +01:00
|
|
|
|
return video;
|
|
|
|
|
|
|
|
|
|
// Sort them so that the list can be easily compared for changes
|
|
|
|
|
}).OrderBy(i => i.Path).ToList();
|
2014-12-01 19:42:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void SetExtraTypeFromFilename(Video item)
|
|
|
|
|
{
|
2015-01-17 05:38:24 +01:00
|
|
|
|
var resolver = new ExtraResolver(GetNamingOptions(), new PatternsLogger(), new RegexProvider());
|
2014-12-01 19:42:07 +01:00
|
|
|
|
|
2014-12-03 04:13:03 +01:00
|
|
|
|
var result = resolver.GetExtraInfo(item.Path);
|
|
|
|
|
|
|
|
|
|
if (string.Equals(result.ExtraType, "deletedscene", StringComparison.OrdinalIgnoreCase))
|
2014-12-01 19:42:07 +01:00
|
|
|
|
{
|
2014-12-03 04:13:03 +01:00
|
|
|
|
item.ExtraType = ExtraType.DeletedScene;
|
|
|
|
|
}
|
|
|
|
|
else if (string.Equals(result.ExtraType, "behindthescenes", StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
item.ExtraType = ExtraType.BehindTheScenes;
|
|
|
|
|
}
|
|
|
|
|
else if (string.Equals(result.ExtraType, "interview", StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
item.ExtraType = ExtraType.Interview;
|
|
|
|
|
}
|
|
|
|
|
else if (string.Equals(result.ExtraType, "scene", StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
item.ExtraType = ExtraType.Scene;
|
|
|
|
|
}
|
|
|
|
|
else if (string.Equals(result.ExtraType, "sample", StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
item.ExtraType = ExtraType.Sample;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
item.ExtraType = ExtraType.Clip;
|
2014-12-01 19:42:07 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-06-21 05:35:22 +02:00
|
|
|
|
|
2015-07-08 18:10:34 +02:00
|
|
|
|
public List<PersonInfo> GetPeople(InternalPeopleQuery query)
|
|
|
|
|
{
|
|
|
|
|
return ItemRepository.GetPeople(query);
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-21 05:35:22 +02:00
|
|
|
|
public List<PersonInfo> GetPeople(BaseItem item)
|
|
|
|
|
{
|
2015-07-28 21:42:24 +02:00
|
|
|
|
if (item.SupportsPeople)
|
2015-07-08 18:10:34 +02:00
|
|
|
|
{
|
2015-07-28 21:42:24 +02:00
|
|
|
|
var people = GetPeople(new InternalPeopleQuery
|
|
|
|
|
{
|
|
|
|
|
ItemId = item.Id
|
|
|
|
|
});
|
2015-07-13 23:26:11 +02:00
|
|
|
|
|
2015-07-28 21:42:24 +02:00
|
|
|
|
if (people.Count > 0)
|
|
|
|
|
{
|
|
|
|
|
return people;
|
|
|
|
|
}
|
2015-07-13 23:26:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return item.People ?? new List<PersonInfo>();
|
2015-06-21 05:35:22 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-08 18:10:34 +02:00
|
|
|
|
public List<Person> GetPeopleItems(InternalPeopleQuery query)
|
2015-07-07 04:25:23 +02:00
|
|
|
|
{
|
2015-07-08 18:10:34 +02:00
|
|
|
|
return ItemRepository.GetPeopleNames(query).Select(i =>
|
2015-07-07 04:25:23 +02:00
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
return GetPerson(i);
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting person", ex);
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}).Where(i => i != null).ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-08 18:10:34 +02:00
|
|
|
|
public List<string> GetPeopleNames(InternalPeopleQuery query)
|
|
|
|
|
{
|
|
|
|
|
return ItemRepository.GetPeopleNames(query);
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-21 05:35:22 +02:00
|
|
|
|
public List<PersonInfo> GetAllPeople()
|
|
|
|
|
{
|
2015-07-08 18:10:34 +02:00
|
|
|
|
return GetPeople(new InternalPeopleQuery())
|
2015-06-21 05:35:22 +02:00
|
|
|
|
.DistinctBy(i => i.Name, StringComparer.OrdinalIgnoreCase)
|
|
|
|
|
.ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-13 23:26:11 +02:00
|
|
|
|
public Task UpdatePeople(BaseItem item, List<PersonInfo> people)
|
2015-06-21 05:35:22 +02:00
|
|
|
|
{
|
2015-08-06 03:21:18 +02:00
|
|
|
|
if (!item.SupportsPeople)
|
|
|
|
|
{
|
|
|
|
|
return Task.FromResult(true);
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-13 23:26:11 +02:00
|
|
|
|
return ItemRepository.UpdatePeople(item.Id, people);
|
2015-06-21 05:35:22 +02:00
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
|
}
|
|
|
|
|
}
|