jellyfin/MediaBrowser.Server.Implementations/Library/LibraryManager.cs

2910 lines
100 KiB
C#
Raw Normal View History

2015-04-29 18:48:34 +00:00
using Interfaces.IO;
using MediaBrowser.Common.Extensions;
2013-04-22 04:38:03 +00:00
using MediaBrowser.Common.Progress;
using MediaBrowser.Common.ScheduledTasks;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Controller.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Entities.TV;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.IO;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Persistence;
2014-02-02 13:36:31 +00:00
using MediaBrowser.Controller.Providers;
using MediaBrowser.Controller.Resolvers;
2013-03-10 04:22:36 +00:00
using MediaBrowser.Controller.Sorting;
using MediaBrowser.Model.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
2013-02-21 21:39:53 +00:00
using MediaBrowser.Model.Logging;
2015-06-01 14:49:23 +00:00
using MediaBrowser.Model.Querying;
2014-11-16 20:44:08 +00:00
using MediaBrowser.Naming.Audio;
2014-11-28 17:41:47 +00:00
using MediaBrowser.Naming.Common;
2014-12-19 04:20:07 +00:00
using MediaBrowser.Naming.TV;
2014-11-16 20:44:08 +00:00
using MediaBrowser.Naming.Video;
using MediaBrowser.Server.Implementations.Library.Validators;
2015-01-17 04:38:24 +00:00
using MediaBrowser.Server.Implementations.Logging;
2013-03-05 03:34:02 +00:00
using MediaBrowser.Server.Implementations.ScheduledTasks;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
2013-02-21 01:33:05 +00:00
using System.Threading;
using System.Threading.Tasks;
2015-10-04 04:23:11 +00:00
using CommonIO;
2016-07-09 17:39:04 +00:00
using MediaBrowser.Controller.Channels;
2016-06-30 19:25:38 +00:00
using MediaBrowser.Model.Channels;
2016-06-17 13:06:13 +00:00
using MediaBrowser.Model.Dto;
2015-10-04 03:38:46 +00:00
using MediaBrowser.Model.Extensions;
2015-11-13 20:53:29 +00:00
using MediaBrowser.Model.Library;
using MediaBrowser.Model.Net;
2016-03-19 19:32:37 +00:00
using MediaBrowser.Server.Implementations.Library.Resolvers;
2015-06-21 03:35:22 +00:00
using MoreLinq;
2013-03-10 04:22:36 +00:00
using SortOrder = MediaBrowser.Model.Entities.SortOrder;
2016-03-19 19:32:37 +00:00
using VideoResolver = MediaBrowser.Naming.Video.VideoResolver;
2013-02-21 01:33:05 +00:00
namespace MediaBrowser.Server.Implementations.Library
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// Class LibraryManager
/// </summary>
public class LibraryManager : ILibraryManager
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// Gets or sets the postscan tasks.
/// </summary>
/// <value>The postscan tasks.</value>
private ILibraryPostScanTask[] PostscanTasks { get; set; }
/// <summary>
/// Gets the intro providers.
/// </summary>
/// <value>The intro providers.</value>
private IIntroProvider[] IntroProviders { get; set; }
/// <summary>
/// Gets the list of entity resolution ignore rules
/// </summary>
/// <value>The entity resolution ignore rules.</value>
private IResolverIgnoreRule[] EntityResolutionIgnoreRules { get; set; }
/// <summary>
/// Gets the list of BasePluginFolders added by plugins
/// </summary>
/// <value>The plugin folders.</value>
private IVirtualFolderCreator[] PluginFolderCreators { get; set; }
/// <summary>
/// Gets the list of currently registered entity resolvers
/// </summary>
/// <value>The entity resolvers enumerable.</value>
private IItemResolver[] EntityResolvers { get; set; }
2014-12-28 06:21:39 +00:00
private IMultiItemResolver[] MultiItemResolvers { get; set; }
2013-03-10 04:22:36 +00:00
/// <summary>
/// Gets or sets the comparers.
/// </summary>
/// <value>The comparers.</value>
private IBaseItemComparer[] Comparers { get; set; }
2013-03-10 04:22:36 +00:00
/// <summary>
/// Gets the active item repository
/// </summary>
/// <value>The item repository.</value>
public IItemRepository ItemRepository { get; set; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Occurs when [item added].
2013-02-21 01:33:05 +00:00
/// </summary>
public event EventHandler<ItemChangeEventArgs> ItemAdded;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Occurs when [item updated].
2013-02-21 01:33:05 +00:00
/// </summary>
public event EventHandler<ItemChangeEventArgs> ItemUpdated;
/// <summary>
/// Occurs when [item removed].
/// </summary>
public event EventHandler<ItemChangeEventArgs> ItemRemoved;
2013-02-21 01:33:05 +00:00
2013-02-21 21:39:53 +00:00
/// <summary>
/// The _logger
/// </summary>
private readonly ILogger _logger;
/// <summary>
/// The _task manager
/// </summary>
private readonly ITaskManager _taskManager;
/// <summary>
/// The _user manager
/// </summary>
private readonly IUserManager _userManager;
/// <summary>
/// The _user data repository
/// </summary>
2013-10-02 16:08:58 +00:00
private readonly IUserDataManager _userDataRepository;
2013-04-22 04:38:03 +00:00
2013-03-04 05:43:06 +00:00
/// <summary>
/// Gets or sets the configuration manager.
/// </summary>
/// <value>The configuration manager.</value>
private IServerConfigurationManager ConfigurationManager { get; set; }
/// <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>
/// <value>The by reference items.</value>
private ConcurrentDictionary<Guid, BaseItem> ByReferenceItems { get; set; }
private readonly Func<ILibraryMonitor> _libraryMonitorFactory;
2014-02-02 13:36:31 +00:00
private readonly Func<IProviderManager> _providerManagerFactory;
2015-11-13 20:53:29 +00:00
private readonly Func<IUserViewManager> _userviewManager;
2016-04-26 03:39:21 +00:00
public bool IsScanRunning { get; private set; }
/// <summary>
/// The _library items cache
/// </summary>
2014-03-20 15:55:22 +00:00
private readonly ConcurrentDictionary<Guid, BaseItem> _libraryItemsCache;
/// <summary>
/// Gets the library items cache.
/// </summary>
/// <value>The library items cache.</value>
private ConcurrentDictionary<Guid, BaseItem> LibraryItemsCache
{
get
{
return _libraryItemsCache;
}
}
private readonly IFileSystem _fileSystem;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="LibraryManager" /> class.
/// </summary>
2013-02-21 21:39:53 +00:00
/// <param name="logger">The logger.</param>
/// <param name="taskManager">The task manager.</param>
/// <param name="userManager">The user manager.</param>
2013-03-04 05:43:06 +00:00
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
2015-11-13 20:53:29 +00:00
public LibraryManager(ILogger logger, ITaskManager taskManager, IUserManager userManager, IServerConfigurationManager configurationManager, IUserDataManager userDataRepository, Func<ILibraryMonitor> libraryMonitorFactory, IFileSystem fileSystem, Func<IProviderManager> providerManagerFactory, Func<IUserViewManager> userviewManager)
2013-02-21 01:33:05 +00:00
{
2013-02-21 21:39:53 +00:00
_logger = logger;
_taskManager = taskManager;
_userManager = userManager;
2013-03-04 05:43:06 +00:00
ConfigurationManager = configurationManager;
_userDataRepository = userDataRepository;
_libraryMonitorFactory = libraryMonitorFactory;
_fileSystem = fileSystem;
2014-02-02 13:36:31 +00:00
_providerManagerFactory = providerManagerFactory;
2015-11-13 20:53:29 +00:00
_userviewManager = userviewManager;
ByReferenceItems = new ConcurrentDictionary<Guid, BaseItem>();
2014-03-20 15:55:22 +00:00
_libraryItemsCache = new ConcurrentDictionary<Guid, BaseItem>();
ConfigurationManager.ConfigurationUpdated += ConfigurationUpdated;
RecordConfigurationValues(configurationManager.Configuration);
}
/// <summary>
/// Adds the parts.
/// </summary>
/// <param name="rules">The rules.</param>
/// <param name="pluginFolders">The plugin folders.</param>
/// <param name="resolvers">The resolvers.</param>
/// <param name="introProviders">The intro providers.</param>
2013-03-10 04:22:36 +00:00
/// <param name="itemComparers">The item comparers.</param>
/// <param name="postscanTasks">The postscan tasks.</param>
public void AddParts(IEnumerable<IResolverIgnoreRule> rules,
IEnumerable<IVirtualFolderCreator> pluginFolders,
IEnumerable<IItemResolver> resolvers,
IEnumerable<IIntroProvider> introProviders,
IEnumerable<IBaseItemComparer> itemComparers,
IEnumerable<ILibraryPostScanTask> postscanTasks)
{
EntityResolutionIgnoreRules = rules.ToArray();
PluginFolderCreators = pluginFolders.ToArray();
2013-03-02 01:09:05 +00:00
EntityResolvers = resolvers.OrderBy(i => i.Priority).ToArray();
2014-12-28 06:21:39 +00:00
MultiItemResolvers = EntityResolvers.OfType<IMultiItemResolver>().ToArray();
IntroProviders = introProviders.ToArray();
Comparers = itemComparers.ToArray();
2015-01-10 01:38:01 +00:00
PostscanTasks = postscanTasks.OrderBy(i =>
{
var hasOrder = i as IHasOrder;
return hasOrder == null ? 0 : hasOrder.Order;
}).ToArray();
}
/// <summary>
/// The _root folder
/// </summary>
2016-02-01 00:57:40 +00:00
private volatile AggregateFolder _rootFolder;
/// <summary>
/// The _root folder sync lock
/// </summary>
private readonly object _rootFolderSyncLock = new object();
/// <summary>
/// Gets the root folder.
/// </summary>
/// <value>The root folder.</value>
public AggregateFolder RootFolder
{
get
{
if (_rootFolder == null)
{
lock (_rootFolderSyncLock)
{
if (_rootFolder == null)
{
_rootFolder = CreateRootFolder();
}
}
}
return _rootFolder;
}
}
/// <summary>
/// The _season zero display name
/// </summary>
private string _seasonZeroDisplayName;
private bool _wizardCompleted;
/// <summary>
/// Records the configuration values.
/// </summary>
/// <param name="configuration">The configuration.</param>
private void RecordConfigurationValues(ServerConfiguration configuration)
{
2014-02-03 20:51:28 +00:00
_seasonZeroDisplayName = configuration.SeasonZeroDisplayName;
_wizardCompleted = configuration.IsStartupWizardCompleted;
}
/// <summary>
/// Configurations the updated.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
void ConfigurationUpdated(object sender, EventArgs e)
{
var config = ConfigurationManager.Configuration;
var newSeasonZeroName = ConfigurationManager.Configuration.SeasonZeroDisplayName;
2014-11-14 06:27:10 +00:00
var seasonZeroNameChanged = !string.Equals(_seasonZeroDisplayName, newSeasonZeroName, StringComparison.Ordinal);
var wizardChanged = config.IsStartupWizardCompleted != _wizardCompleted;
RecordConfigurationValues(config);
2015-08-19 23:57:27 +00:00
if (seasonZeroNameChanged || wizardChanged)
{
2015-08-19 23:57:27 +00:00
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
}
2013-02-21 01:33:05 +00:00
2015-08-19 23:57:27 +00:00
if (seasonZeroNameChanged)
2014-02-22 20:20:22 +00:00
{
2015-08-19 23:57:27 +00:00
Task.Run(async () =>
{
await UpdateSeasonZeroNames(newSeasonZeroName, CancellationToken.None).ConfigureAwait(false);
2014-02-22 20:20:22 +00:00
2015-08-19 23:57:27 +00:00
});
2014-02-22 20:20:22 +00: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>
private async Task UpdateSeasonZeroNames(string newName, CancellationToken cancellationToken)
{
2016-05-10 19:20:17 +00:00
var seasons = GetItemList(new InternalItemsQuery
{
IncludeItemTypes = new[] { typeof(Season).Name },
Recursive = true,
IndexNumber = 0
}).Cast<Season>()
.Where(i => !string.Equals(i.Name, newName, StringComparison.Ordinal))
.ToList();
foreach (var season in seasons)
{
season.Name = newName;
try
{
2015-07-13 21:26:11 +00:00
await UpdateItem(season, ItemUpdateType.MetadataDownload, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.ErrorException("Error saving {0}", ex, season.Path);
}
}
}
/// <summary>
/// Updates the item in library cache.
/// </summary>
/// <param name="item">The item.</param>
private void UpdateItemInLibraryCache(BaseItem item)
{
2014-01-11 05:49:18 +00:00
RegisterItem(item);
}
public void RegisterItem(BaseItem item)
{
2014-03-20 15:55:22 +00:00
if (item == null)
{
throw new ArgumentNullException("item");
}
2014-02-22 20:20:22 +00:00
RegisterItem(item.Id, item);
}
private void RegisterItem(Guid id, BaseItem item)
{
2015-08-19 23:57:27 +00:00
if (item is IItemByName)
{
if (!(item is MusicArtist))
{
return;
}
}
2016-07-09 17:39:04 +00:00
if (item.IsFolder)
2016-06-07 05:42:26 +00:00
{
2016-07-09 17:39:04 +00:00
if (!(item is ICollectionFolder) && !(item is UserView) && !(item is Channel))
{
if (item.SourceType != SourceType.Library)
{
return;
}
}
2016-06-07 05:42:26 +00:00
}
2016-07-09 17:39:04 +00:00
else
2016-07-05 05:40:18 +00:00
{
2016-07-09 17:39:04 +00:00
if (item is Photo)
{
return;
}
2016-07-05 05:40:18 +00:00
}
2016-07-09 17:39:04 +00:00
2014-02-22 20:20:22 +00:00
LibraryItemsCache.AddOrUpdate(id, item, delegate { return item; });
}
public async Task DeleteItem(BaseItem item, DeleteOptions options)
2014-02-19 18:50:37 +00:00
{
2016-03-20 21:32:26 +00:00
if (item == null)
{
throw new ArgumentNullException("item");
}
_logger.Debug("Deleting item, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
item.GetType().Name,
2016-03-20 21:32:26 +00:00
item.Name ?? "Unknown name",
item.Path ?? string.Empty,
item.Id);
2014-02-19 18:50:37 +00:00
var parent = item.Parent;
var locationType = item.LocationType;
var children = item.IsFolder
2015-01-25 06:34:50 +00:00
? ((Folder)item).GetRecursiveChildren().ToList()
2014-02-19 18:50:37 +00:00
: new List<BaseItem>();
foreach (var metadataPath in GetMetadataPaths(item, children))
{
_logger.Debug("Deleting path {0}", metadataPath);
try
{
_fileSystem.DeleteDirectory(metadataPath, true);
2014-02-19 18:50:37 +00:00
}
catch (DirectoryNotFoundException)
{
2015-02-15 03:36:07 +00:00
2014-02-19 18:50:37 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error deleting {0}", ex, metadataPath);
}
}
if (options.DeleteFileLocation && locationType != LocationType.Remote && locationType != LocationType.Virtual)
2014-02-19 18:50:37 +00:00
{
foreach (var path in item.GetDeletePaths().ToList())
{
2015-11-13 20:53:29 +00:00
if (_fileSystem.DirectoryExists(path))
2014-02-19 18:50:37 +00:00
{
_logger.Debug("Deleting path {0}", path);
_fileSystem.DeleteDirectory(path, true);
2014-02-19 18:50:37 +00:00
}
2015-11-13 20:53:29 +00:00
else if (_fileSystem.FileExists(path))
2014-02-19 18:50:37 +00:00
{
_logger.Debug("Deleting path {0}", path);
_fileSystem.DeleteFile(path);
2014-02-19 18:50:37 +00:00
}
}
if (parent != null)
{
await parent.ValidateChildren(new Progress<double>(), CancellationToken.None)
.ConfigureAwait(false);
}
}
else if (parent != null)
{
2016-03-21 20:15:18 +00:00
parent.RemoveChild(item);
2014-02-19 18:50:37 +00:00
}
await ItemRepository.DeleteItem(item.Id, CancellationToken.None).ConfigureAwait(false);
2014-02-19 18:50:37 +00:00
foreach (var child in children)
{
await ItemRepository.DeleteItem(child.Id, CancellationToken.None).ConfigureAwait(false);
}
BaseItem removed;
_libraryItemsCache.TryRemove(item.Id, out removed);
ReportItemRemoved(item);
2014-02-19 18:50:37 +00:00
}
private IEnumerable<string> GetMetadataPaths(BaseItem item, IEnumerable<BaseItem> children)
{
var list = new List<string>
{
2014-09-28 15:27:26 +00:00
item.GetInternalMetadataPath()
2014-02-19 18:50:37 +00:00
};
2014-09-28 15:27:26 +00:00
list.AddRange(children.Select(i => i.GetInternalMetadataPath()));
2014-02-19 18:50:37 +00:00
return list;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Resolves the item.
/// </summary>
/// <param name="args">The args.</param>
2016-03-19 19:32:37 +00:00
/// <param name="resolvers">The resolvers.</param>
2013-02-21 01:33:05 +00:00
/// <returns>BaseItem.</returns>
2016-03-19 19:32:37 +00:00
private BaseItem ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers)
2013-02-21 01:33:05 +00:00
{
2016-03-19 19:32:37 +00:00
var item = (resolvers ?? EntityResolvers).Select(r => Resolve(args, r))
2014-12-04 05:24:41 +00:00
.FirstOrDefault(i => i != null);
if (item != null)
{
2014-11-30 19:01:33 +00:00
ResolverHelper.SetInitialItemValues(item, args, _fileSystem, this);
}
return item;
2013-02-21 01:33:05 +00:00
}
2014-12-04 05:24:41 +00: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 19:01:33 +00:00
public Guid GetNewItemId(string key, Type type)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentNullException("key");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
2016-05-23 17:52:16 +00:00
if (ConfigurationManager.Configuration.EnableLocalizedGuids && key.StartsWith(ConfigurationManager.ApplicationPaths.ProgramDataPath))
2014-11-30 19:01:33 +00:00
{
// 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("/", "\\");
}
if (!ConfigurationManager.Configuration.EnableCaseSensitiveItemIds)
{
key = key.ToLower();
}
key = type.FullName + key;
2014-11-30 19:01:33 +00:00
return key.GetMD5();
}
/// <summary>
/// Ensure supplied item has only one instance throughout
/// </summary>
/// <param name="item">The item.</param>
/// <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;
}
2015-10-04 03:38:46 +00:00
public BaseItem ResolvePath(FileSystemMetadata fileInfo,
2014-12-22 06:50:29 +00:00
Folder parent = null)
2014-02-13 05:11:54 +00:00
{
2016-03-19 19:32:37 +00:00
return ResolvePath(fileInfo, new DirectoryService(_logger, _fileSystem), null, parent);
2014-02-13 05:11:54 +00:00
}
private BaseItem ResolvePath(FileSystemMetadata fileInfo,
IDirectoryService directoryService,
IItemResolver[] resolvers,
Folder parent = null,
string collectionType = null,
LibraryOptions libraryOptions = null)
2013-02-21 01:33:05 +00:00
{
if (fileInfo == null)
2013-02-21 01:33:05 +00:00
{
throw new ArgumentNullException("fileInfo");
2013-02-21 01:33:05 +00:00
}
2014-12-22 06:50:29 +00:00
var fullPath = fileInfo.FullName;
2015-01-12 05:07:19 +00:00
if (string.IsNullOrWhiteSpace(collectionType) && parent != null)
2014-12-22 06:50:29 +00:00
{
2015-01-10 01:38:01 +00:00
collectionType = GetContentTypeOverride(fullPath, true);
2014-12-22 06:50:29 +00:00
}
2015-01-27 22:45:59 +00:00
var args = new ItemResolveArgs(ConfigurationManager.ApplicationPaths, directoryService)
2013-02-21 01:33:05 +00:00
{
Parent = parent,
2014-12-22 06:50:29 +00:00
Path = fullPath,
2014-10-23 04:26:01 +00:00
FileInfo = fileInfo,
CollectionType = collectionType,
LibraryOptions = libraryOptions
2013-02-21 01:33:05 +00:00
};
// Return null if ignore rules deem that we should do so
2015-11-13 20:53:29 +00:00
if (IgnoreFile(args.FileInfo, args.Parent))
2013-02-21 01:33:05 +00:00
{
return null;
}
// Gather child folder and files
if (args.IsDirectory)
{
2013-04-19 18:03:21 +00:00
var isPhysicalRoot = args.IsPhysicalRoot;
2013-02-21 01:33:05 +00:00
// When resolving the root, we need it's grandchildren (children of user views)
2013-04-19 18:03:21 +00:00
var flattenFolderDepth = isPhysicalRoot ? 2 : 0;
2013-02-21 01:33:05 +00:00
2014-02-11 21:41:01 +00:00
var fileSystemDictionary = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, _fileSystem, _logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || args.IsVf);
2014-02-22 20:20:22 +00:00
2013-05-24 17:48:48 +00: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)
{
2015-11-13 20:56:26 +00:00
var paths = NormalizeRootPathList(fileSystemDictionary.Values);
2013-05-24 17:48:48 +00:00
2015-11-13 20:56:26 +00:00
fileSystemDictionary = paths.ToDictionary(i => i.FullName);
2013-05-24 17:48:48 +00:00
}
args.FileSystemDictionary = fileSystemDictionary;
2013-02-21 01:33:05 +00:00
}
// Check to see if we should resolve based on our contents
if (args.IsDirectory && !ShouldResolvePathContents(args))
2013-02-21 01:33:05 +00:00
{
return null;
}
2016-03-19 19:32:37 +00:00
return ResolveItem(args, resolvers);
2013-02-21 01:33:05 +00:00
}
2015-11-13 20:53:29 +00:00
public bool IgnoreFile(FileSystemMetadata file, BaseItem parent)
{
2015-11-13 20:53:29 +00:00
return EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(file, parent));
}
2015-11-13 20:56:26 +00:00
public IEnumerable<FileSystemMetadata> NormalizeRootPathList(IEnumerable<FileSystemMetadata> paths)
2015-11-13 20:53:29 +00:00
{
2015-11-13 20:56:26 +00:00
var originalList = paths.ToList();
var list = originalList.Where(i => i.IsDirectory)
.Select(i => _fileSystem.NormalizePath(i.FullName))
.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);
}
2015-11-13 20:56:26 +00:00
var newList = list.Except(dupes, StringComparer.OrdinalIgnoreCase).Select(_fileSystem.GetDirectoryInfo).ToList();
newList.AddRange(originalList.Where(i => !i.IsDirectory));
return newList;
}
/// <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");
}
public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemMetadata> files, IDirectoryService directoryService, Folder parent, LibraryOptions libraryOptions, string collectionType)
2016-03-19 19:32:37 +00:00
{
return ResolvePaths(files, directoryService, parent, libraryOptions, collectionType, EntityResolvers);
2016-03-19 19:32:37 +00:00
}
public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemMetadata> files,
IDirectoryService directoryService,
Folder parent,
LibraryOptions libraryOptions,
string collectionType,
IItemResolver[] resolvers)
2014-12-04 05:24:41 +00:00
{
2015-11-13 20:53:29 +00:00
var fileList = files.Where(i => !IgnoreFile(i, parent)).ToList();
2014-12-04 05:24:41 +00:00
if (parent != null)
{
2016-03-19 19:32:37 +00:00
var multiItemResolvers = resolvers == null ? MultiItemResolvers : resolvers.OfType<IMultiItemResolver>().ToArray();
foreach (var resolver in multiItemResolvers)
2014-12-04 05:24:41 +00: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, resolvers, libraryOptions));
2014-12-04 05:24:41 +00:00
return items;
}
}
}
return ResolveFileList(fileList, directoryService, parent, collectionType, resolvers, libraryOptions);
2014-12-04 05:24:41 +00:00
}
private IEnumerable<BaseItem> ResolveFileList(IEnumerable<FileSystemMetadata> fileList,
IDirectoryService directoryService,
Folder parent,
string collectionType,
IItemResolver[] resolvers,
LibraryOptions libraryOptions)
2013-02-21 01:33:05 +00:00
{
2014-12-04 05:24:41 +00:00
return fileList.Select(f =>
2013-02-21 01:33:05 +00:00
{
try
{
return ResolvePath(f, directoryService, resolvers, parent, collectionType, libraryOptions);
2013-02-21 01:33:05 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error resolving path {0}", ex, f.FullName);
2014-11-26 04:12:29 +00:00
return null;
2013-02-21 01:33:05 +00:00
}
2014-12-04 05:24:41 +00:00
}).Where(i => i != null);
2013-02-21 01:33:05 +00: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>
public AggregateFolder CreateRootFolder()
2013-02-21 01:33:05 +00:00
{
2013-03-04 05:43:06 +00:00
var rootFolderPath = ConfigurationManager.ApplicationPaths.RootFolderPath;
2013-06-04 16:48:23 +00:00
2015-11-13 20:53:29 +00:00
_fileSystem.CreateDirectory(rootFolderPath);
2013-06-04 16:48:23 +00:00
2015-10-04 03:38:46 +00:00
var rootFolder = GetItemById(GetNewItemId(rootFolderPath, typeof(AggregateFolder))) as AggregateFolder ?? (AggregateFolder)ResolvePath(_fileSystem.GetDirectoryInfo(rootFolderPath));
2013-02-21 01:33:05 +00:00
// Add in the plug-in folders
foreach (var child in PluginFolderCreators)
2013-02-21 01:33:05 +00:00
{
var folder = child.GetFolder();
2014-06-04 03:34:36 +00:00
if (folder != null)
{
2014-06-04 03:34:36 +00:00
if (folder.Id == Guid.Empty)
{
2014-11-30 19:01:33 +00: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 03:34:36 +00:00
}
2015-04-06 20:43:40 +00:00
var dbItem = GetItemById(folder.Id) as BasePluginFolder;
if (dbItem != null && string.Equals(dbItem.Path, folder.Path, StringComparison.OrdinalIgnoreCase))
{
folder = dbItem;
}
2014-05-31 14:30:59 +00:00
2015-11-13 20:53:29 +00:00
if (folder.ParentId != rootFolder.Id)
{
folder.ParentId = rootFolder.Id;
var task = folder.UpdateToRepository(ItemUpdateType.MetadataImport, CancellationToken.None);
Task.WaitAll(task);
}
2014-06-04 03:34:36 +00:00
rootFolder.AddVirtualChild(folder);
RegisterItem(folder);
}
2013-02-21 01:33:05 +00:00
}
return rootFolder;
}
2016-02-01 00:57:40 +00:00
private volatile UserRootFolder _userRootFolder;
2014-12-13 03:56:30 +00:00
private readonly object _syncLock = new object();
2014-02-21 05:04:11 +00:00
public Folder GetUserRootFolder()
2013-04-05 04:13:41 +00:00
{
2014-02-21 05:04:11 +00:00
if (_userRootFolder == null)
{
2014-12-13 03:56:30 +00:00
lock (_syncLock)
{
if (_userRootFolder == null)
{
var userRootPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
2013-04-22 04:38:03 +00:00
2015-11-13 20:53:29 +00:00
_fileSystem.CreateDirectory(userRootPath);
2015-01-27 22:45:59 +00:00
var tmpItem = GetItemById(GetNewItemId(userRootPath, typeof(UserRootFolder))) as UserRootFolder;
2014-12-13 03:56:30 +00:00
2015-01-27 22:45:59 +00:00
if (tmpItem == null)
2014-12-13 03:56:30 +00:00
{
2015-10-04 03:38:46 +00:00
tmpItem = (UserRootFolder)ResolvePath(_fileSystem.GetDirectoryInfo(userRootPath));
2014-12-13 03:56:30 +00:00
}
2015-01-27 22:45:59 +00:00
_userRootFolder = tmpItem;
2014-12-13 03:56:30 +00:00
}
}
2014-02-21 05:04:11 +00:00
}
return _userRootFolder;
2013-09-11 17:54:59 +00:00
}
2016-04-27 17:53:23 +00:00
public BaseItem FindByPath(string path, bool? isFolder)
2016-03-01 19:39:46 +00:00
{
2016-07-09 17:39:04 +00:00
// If this returns multiple items it could be tricky figuring out which one is correct.
// In most cases, the newest one will be and the others obsolete but not yet cleaned up
2016-03-01 19:39:46 +00:00
var query = new InternalItemsQuery
{
2016-04-27 17:53:23 +00:00
Path = path,
2016-07-09 17:39:04 +00:00
IsFolder = isFolder,
SortBy = new[] { ItemSortBy.DateCreated },
SortOrder = SortOrder.Descending,
Limit = 1
2016-03-01 19:39:46 +00:00
};
2016-07-09 17:39:04 +00:00
return GetItemList(query)
2016-05-10 18:43:17 +00:00
.FirstOrDefault();
2016-03-01 19:39:46 +00:00
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets a Person
/// </summary>
/// <param name="name">The name.</param>
/// <returns>Task{Person}.</returns>
public Person GetPerson(string name)
2013-02-21 01:33:05 +00:00
{
return GetItemByName<Person>(ConfigurationManager.ApplicationPaths.PeoplePath, name);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets a Studio
/// </summary>
/// <param name="name">The name.</param>
/// <returns>Task{Studio}.</returns>
public Studio GetStudio(string name)
{
return GetItemByName<Studio>(ConfigurationManager.ApplicationPaths.StudioPath, name);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets a Genre
/// </summary>
/// <param name="name">The name.</param>
/// <returns>Task{Genre}.</returns>
public Genre GetGenre(string name)
{
return GetItemByName<Genre>(ConfigurationManager.ApplicationPaths.GenrePath, name);
2013-02-21 01:33:05 +00:00
}
2013-06-11 03:31:00 +00:00
/// <summary>
/// Gets the genre.
/// </summary>
/// <param name="name">The name.</param>
/// <returns>Task{MusicGenre}.</returns>
public MusicGenre GetMusicGenre(string name)
2013-07-01 17:17:33 +00:00
{
return GetItemByName<MusicGenre>(ConfigurationManager.ApplicationPaths.MusicGenrePath, name);
}
/// <summary>
/// Gets the game genre.
/// </summary>
/// <param name="name">The name.</param>
/// <returns>Task{GameGenre}.</returns>
public GameGenre GetGameGenre(string name)
{
return GetItemByName<GameGenre>(ConfigurationManager.ApplicationPaths.GameGenrePath, name);
2013-07-01 17:17:33 +00:00
}
2013-02-21 01:33:05 +00: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>
public Year GetYear(int value)
2013-02-21 01:33:05 +00:00
{
if (value <= 0)
{
2014-01-16 17:56:50 +00:00
throw new ArgumentOutOfRangeException("Years less than or equal to 0 are invalid.");
2013-02-21 01:33:05 +00:00
}
return GetItemByName<Year>(ConfigurationManager.ApplicationPaths.YearPath, value.ToString(UsCulture));
2013-02-21 01:33:05 +00: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 20:48:26 +00:00
/// <summary>
/// Gets a Genre
/// </summary>
/// <param name="name">The name.</param>
/// <returns>Task{Genre}.</returns>
public MusicArtist GetArtist(string name)
{
return GetItemByName<MusicArtist>(ArtistsPath, name);
2013-11-21 20:48:26 +00:00
}
2013-09-11 17:54:59 +00:00
private T GetItemByName<T>(string path, string name)
where T : BaseItem, new()
{
2014-04-05 15:02:50 +00:00
if (string.IsNullOrWhiteSpace(path))
2013-09-11 17:54:59 +00:00
{
2013-11-21 20:48:26 +00:00
throw new ArgumentNullException("path");
2013-09-11 17:54:59 +00:00
}
2014-04-05 15:02:50 +00:00
if (string.IsNullOrWhiteSpace(name))
2013-09-11 17:54:59 +00:00
{
2013-11-21 20:48:26 +00:00
throw new ArgumentNullException("name");
2013-09-11 17:54:59 +00:00
}
2016-05-04 17:29:24 +00:00
// Trim the period at the end because windows will have a hard time with that
var validFilename = _fileSystem.GetValidFilename(name)
.Trim()
.TrimEnd('.');
2013-09-11 17:54:59 +00:00
string subFolderPrefix = null;
2014-02-22 20:20:22 +00:00
var type = typeof(T);
2014-12-19 04:20:07 +00:00
if (type == typeof(Person))
{
foreach (char c in validFilename)
2015-03-20 17:17:03 +00:00
{
if (char.IsLetterOrDigit(c))
{
subFolderPrefix = c.ToString();
break;
}
2015-03-20 17:17:03 +00:00
}
}
2014-02-22 20:20:22 +00:00
var fullPath = string.IsNullOrEmpty(subFolderPrefix) ?
Path.Combine(path, validFilename) :
Path.Combine(path, subFolderPrefix, validFilename);
2013-09-11 17:54:59 +00:00
2016-05-13 02:36:01 +00:00
return CreateItemByName<T>(fullPath, name);
2013-09-11 17:54:59 +00:00
}
2016-05-13 02:36:01 +00:00
private T CreateItemByName<T>(string path, string name)
2013-02-21 01:33:05 +00:00
where T : BaseItem, new()
{
2016-06-20 03:34:47 +00:00
if (typeof(T) == typeof(MusicArtist))
2013-11-21 20:48:26 +00:00
{
2016-05-04 16:33:22 +00:00
var existing = GetItemList(new InternalItemsQuery
{
IncludeItemTypes = new[] { typeof(T).Name },
Name = name
}).Cast<MusicArtist>()
2016-05-07 18:58:16 +00:00
.OrderBy(i => i.IsAccessedByName ? 1 : 0)
2016-05-04 16:33:22 +00:00
.Cast<T>()
.FirstOrDefault();
2013-11-21 20:48:26 +00:00
if (existing != null)
{
2014-02-22 20:20:22 +00:00
return existing;
2013-11-21 20:48:26 +00:00
}
}
2016-05-13 02:36:01 +00:00
var id = GetNewItemId(path, typeof(T));
2015-08-06 01:21:18 +00:00
var item = GetItemById(id) as T;
2013-02-21 01:33:05 +00:00
if (item == null)
{
item = new T
{
Name = name,
Id = id,
2015-08-06 01:21:18 +00:00
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow,
2013-02-21 01:33:05 +00:00
Path = path
};
2015-08-24 02:08:20 +00:00
var task = CreateItem(item, CancellationToken.None);
2015-08-19 23:57:27 +00:00
Task.WaitAll(task);
2013-11-21 20:48:26 +00:00
}
2014-02-22 20:20:22 +00:00
return item;
2013-02-21 01:33:05 +00:00
}
2015-08-06 01:21:18 +00: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;
}
2013-02-21 01:33:05 +00: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>
public Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
2013-02-21 01:33:05 +00:00
{
// Ensure the location is available.
2015-11-13 20:53:29 +00:00
_fileSystem.CreateDirectory(ConfigurationManager.ApplicationPaths.PeoplePath);
2014-03-02 18:01:46 +00:00
2015-09-13 23:07:54 +00:00
return new PeopleValidator(this, _logger, ConfigurationManager, _fileSystem).ValidatePeople(cancellationToken, progress);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Reloads the root media folder
/// </summary>
/// <param name="progress">The progress.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
{
// Just run the scheduled task so that the user can see it
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
return Task.FromResult(true);
}
/// <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 05:04:11 +00: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)
{
2016-04-26 03:39:21 +00:00
IsScanRunning = true;
_libraryMonitorFactory().Stop();
try
{
await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
}
finally
{
_libraryMonitorFactory().Start();
2016-04-26 03:39:21 +00:00
IsScanRunning = false;
}
}
private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
2013-02-21 01:33:05 +00:00
{
2013-02-21 21:39:53 +00:00
_logger.Info("Validating media library");
2013-02-21 01:33:05 +00:00
await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
progress.Report(.5);
2013-02-21 01:33:05 +00:00
// Start by just validating the children of the root, but go no further
2015-09-13 23:07:54 +00:00
await RootFolder.ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: false);
2013-02-21 01:33:05 +00:00
progress.Report(1);
2014-02-21 05:04:11 +00:00
var userRoot = GetUserRootFolder();
2013-02-21 01:33:05 +00:00
2014-02-21 05:04:11 +00:00
await userRoot.RefreshMetadata(cancellationToken).ConfigureAwait(false);
2015-09-13 23:07:54 +00:00
await userRoot.ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: false).ConfigureAwait(false);
progress.Report(2);
2013-09-25 22:41:25 +00:00
var innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(pct => progress.Report(2 + pct * .73));
2013-04-22 04:38:03 +00:00
2013-02-21 01:33:05 +00:00
// Now validate the entire media library
2015-09-13 23:07:54 +00:00
await RootFolder.ValidateChildren(innerProgress, cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: true).ConfigureAwait(false);
2013-04-22 04:38:03 +00:00
progress.Report(75);
2013-09-25 22:41:25 +00:00
innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(pct => progress.Report(75 + pct * .25));
// Run post-scan tasks
2013-09-25 22:41:25 +00:00
await RunPostScanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
2013-04-22 04:38:03 +00:00
progress.Report(100);
2013-09-11 17:54:59 +00: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 01:33:05 +00: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-25 22:41:25 +00:00
var tasks = PostscanTasks.ToList();
2013-09-25 22:41:25 +00:00
var numComplete = 0;
var numTasks = tasks.Count;
foreach (var task in tasks)
{
var innerProgress = new ActionableProgress<double>();
2013-09-25 22:41:25 +00:00
// Prevent access to modified closure
var currentNumComplete = numComplete;
innerProgress.RegisterAction(pct =>
{
2016-03-27 21:11:27 +00:00
double innerPercent = currentNumComplete * 100 + pct;
2013-09-25 22:41:25 +00:00
innerPercent /= numTasks;
progress.Report(innerPercent);
});
2015-07-10 04:44:21 +00:00
_logger.Debug("Running post-scan task {0}", task.GetType().Name);
try
{
2015-02-08 18:21:24 +00:00
await task.Run(innerProgress, cancellationToken).ConfigureAwait(false);
}
2013-09-18 02:43:34 +00:00
catch (OperationCanceledException)
{
2013-09-25 22:41:25 +00:00
_logger.Info("Post-scan task cancelled: {0}", task.GetType().Name);
2013-09-18 02:43:34 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error running postscan task", ex);
}
2013-09-25 22:41:25 +00:00
numComplete++;
double percent = numComplete;
percent /= numTasks;
progress.Report(percent * 100);
}
progress.Report(100);
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the default view.
/// </summary>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
2015-01-21 03:54:45 +00:00
public IEnumerable<VirtualFolderInfo> GetVirtualFolders()
2013-02-21 01:33:05 +00:00
{
2013-03-04 05:43:06 +00:00
return GetView(ConfigurationManager.ApplicationPaths.DefaultUserViewsPath);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets the view.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
private IEnumerable<VirtualFolderInfo> GetView(string path)
{
2015-10-15 17:37:27 +00:00
var topLibraryFolders = GetUserRootFolder().Children.ToList();
2015-09-22 01:05:33 +00:00
return _fileSystem.GetDirectoryPaths(path)
2015-10-15 17:37:27 +00:00
.Select(dir => GetVirtualFolderInfo(dir, topLibraryFolders));
}
2013-07-12 19:56:40 +00:00
2015-10-15 17:37:27 +00:00
private VirtualFolderInfo GetVirtualFolderInfo(string dir, List<BaseItem> collectionFolders)
{
var info = new VirtualFolderInfo
{
Name = Path.GetFileName(dir),
2013-07-12 19:56:40 +00:00
2015-10-15 17:37:27 +00:00
Locations = Directory.EnumerateFiles(dir, "*.mblink", SearchOption.TopDirectoryOnly)
.Select(_fileSystem.ResolveShortcut)
.OrderBy(i => i)
.ToList(),
CollectionType = GetCollectionType(dir)
};
var libraryFolder = collectionFolders.FirstOrDefault(i => string.Equals(i.Path, dir, StringComparison.OrdinalIgnoreCase));
if (libraryFolder != null && libraryFolder.HasImage(ImageType.Primary))
{
info.PrimaryImageItemId = libraryFolder.Id.ToString("N");
}
2015-10-16 05:36:16 +00:00
if (libraryFolder != null)
{
info.ItemId = libraryFolder.Id.ToString("N");
}
2015-10-15 17:37:27 +00:00
return info;
2013-02-21 01:33:05 +00:00
}
2013-07-12 19:56:40 +00:00
private string GetCollectionType(string path)
{
2015-10-04 03:38:46 +00:00
return _fileSystem.GetFiles(path, false)
.Where(i => string.Equals(i.Extension, ".collection", StringComparison.OrdinalIgnoreCase))
2014-07-26 17:30:15 +00:00
.Select(i => _fileSystem.GetFileNameWithoutExtension(i))
2013-07-12 19:56:40 +00:00
.FirstOrDefault();
}
/// <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");
}
BaseItem item;
if (LibraryItemsCache.TryGetValue(id, out item))
{
return item;
}
2014-03-20 15:55:22 +00:00
item = RetrieveItem(id);
2016-07-09 17:39:04 +00:00
//_logger.Debug("GetitemById {0}", id);
2014-03-20 15:55:22 +00:00
if (item != null)
{
RegisterItem(item);
}
return item;
}
2016-03-20 06:46:51 +00:00
public IEnumerable<BaseItem> GetItemList(InternalItemsQuery query)
2015-06-01 14:49:23 +00:00
{
2016-06-30 14:50:08 +00:00
if (query.Recursive && query.ParentId.HasValue)
{
var parent = GetItemById(query.ParentId.Value);
if (parent != null)
{
SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
query.ParentId = null;
}
}
2015-11-13 20:53:29 +00:00
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
2016-06-20 03:34:47 +00:00
return ItemRepository.GetItemList(query);
2015-06-01 14:49:23 +00:00
}
public IEnumerable<BaseItem> GetItemList(InternalItemsQuery query, IEnumerable<string> parentIds)
{
var parents = parentIds.Select(i => GetItemById(new Guid(i))).Where(i => i != null).ToList();
SetTopParentIdsOrAncestors(query, parents);
if (query.AncestorIds.Length == 0 && query.TopParentIds.Length == 0)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
}
return ItemRepository.GetItemList(query);
}
2015-08-19 23:57:27 +00:00
public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
{
2015-11-13 20:53:29 +00:00
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
2016-06-11 20:12:01 +00:00
if (query.EnableTotalRecordCount)
{
return ItemRepository.GetItems(query);
}
return new QueryResult<BaseItem>
{
Items = ItemRepository.GetItemList(query).ToArray()
};
2015-08-19 23:57:27 +00:00
}
2015-07-07 02:25:23 +00:00
public List<Guid> GetItemIds(InternalItemsQuery query)
{
2015-11-13 20:53:29 +00:00
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
2015-07-07 02:25:23 +00:00
return ItemRepository.GetItemIdsList(query);
}
2016-06-17 13:06:13 +00:00
public QueryResult<Tuple<BaseItem, ItemCounts>> GetStudios(InternalItemsQuery query)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return ItemRepository.GetStudios(query);
}
public QueryResult<Tuple<BaseItem, ItemCounts>> GetGenres(InternalItemsQuery query)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return ItemRepository.GetGenres(query);
}
public QueryResult<Tuple<BaseItem, ItemCounts>> GetGameGenres(InternalItemsQuery query)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return ItemRepository.GetGameGenres(query);
}
public QueryResult<Tuple<BaseItem, ItemCounts>> GetMusicGenres(InternalItemsQuery query)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return ItemRepository.GetMusicGenres(query);
}
2016-08-06 04:38:01 +00:00
public QueryResult<Tuple<BaseItem, ItemCounts>> GetAllArtists(InternalItemsQuery query)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return ItemRepository.GetAllArtists(query);
}
2016-06-17 13:06:13 +00:00
public QueryResult<Tuple<BaseItem, ItemCounts>> GetArtists(InternalItemsQuery query)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return ItemRepository.GetArtists(query);
}
private void SetTopParentOrAncestorIds(InternalItemsQuery query)
{
if (query.AncestorIds.Length == 0)
{
return;
}
var parents = query.AncestorIds.Select(i => GetItemById(new Guid(i))).ToList();
if (parents.All(i =>
{
if (i is ICollectionFolder || i is UserView)
{
return true;
}
2016-06-19 06:18:29 +00:00
//_logger.Debug("Query requires ancestor query due to type: " + i.GetType().Name);
2016-06-17 13:06:13 +00:00
return false;
}))
{
// Optimize by querying against top level views
query.TopParentIds = parents.SelectMany(i => GetTopParentsForQuery(i, query.User)).Select(i => i.Id.ToString("N")).ToArray();
query.AncestorIds = new string[] { };
}
}
public QueryResult<Tuple<BaseItem, ItemCounts>> GetAlbumArtists(InternalItemsQuery query)
{
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
SetTopParentOrAncestorIds(query);
return ItemRepository.GetAlbumArtists(query);
}
2016-03-20 06:46:51 +00:00
public QueryResult<BaseItem> GetItemsResult(InternalItemsQuery query)
{
if (query.Recursive && query.ParentId.HasValue)
{
var parent = GetItemById(query.ParentId.Value);
if (parent != null)
{
SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
query.ParentId = null;
}
}
if (query.User != null)
{
AddUserToQuery(query, query.User);
}
2016-05-09 03:13:38 +00:00
if (query.EnableTotalRecordCount)
{
2016-06-20 03:34:47 +00:00
return ItemRepository.GetItems(query);
2016-06-16 13:24:12 +00:00
}
2016-03-20 06:46:51 +00:00
return new QueryResult<BaseItem>
{
2016-06-20 03:34:47 +00:00
Items = ItemRepository.GetItemList(query).ToArray()
2016-03-20 06:46:51 +00:00
};
}
2015-11-18 05:49:20 +00:00
private void SetTopParentIdsOrAncestors(InternalItemsQuery query, List<BaseItem> parents)
{
if (parents.All(i =>
{
2016-03-27 21:11:27 +00:00
if (i is ICollectionFolder || i is UserView)
2015-11-18 05:49:20 +00:00
{
return true;
}
2016-06-20 04:56:06 +00:00
//_logger.Debug("Query requires ancestor query due to type: " + i.GetType().Name);
2015-11-18 05:49:20 +00:00
return false;
}))
{
// Optimize by querying against top level views
query.TopParentIds = parents.SelectMany(i => GetTopParentsForQuery(i, query.User)).Select(i => i.Id.ToString("N")).ToArray();
}
else
{
// We need to be able to query from any arbitrary ancestor up the tree
query.AncestorIds = parents.SelectMany(i => i.GetIdsForAncestorQuery()).Select(i => i.ToString("N")).ToArray();
}
}
2015-11-13 20:53:29 +00:00
private void AddUserToQuery(InternalItemsQuery query, User user)
{
2016-05-08 06:31:08 +00:00
if (query.AncestorIds.Length == 0 && !query.ParentId.HasValue && query.ChannelIds.Length == 0 && query.TopParentIds.Length == 0 && string.IsNullOrWhiteSpace(query.AncestorWithPresentationUniqueKey))
2015-11-13 20:53:29 +00:00
{
2015-11-14 18:57:26 +00:00
var userViews = _userviewManager().GetUserViews(new UserViewQuery
{
UserId = user.Id.ToString("N"),
IncludeHidden = true
2015-11-13 20:53:29 +00:00
2015-11-14 18:57:26 +00:00
}, CancellationToken.None).Result.ToList();
2015-11-13 20:53:29 +00:00
2015-11-18 05:49:20 +00:00
query.TopParentIds = userViews.SelectMany(i => GetTopParentsForQuery(i, user)).Select(i => i.Id.ToString("N")).ToArray();
2015-11-13 20:53:29 +00:00
}
}
2015-11-18 05:49:20 +00:00
private IEnumerable<BaseItem> GetTopParentsForQuery(BaseItem item, User user)
2015-11-14 18:57:26 +00:00
{
var view = item as UserView;
if (view != null)
{
if (string.Equals(view.ViewType, CollectionType.LiveTv))
{
return new[] { view };
}
if (string.Equals(view.ViewType, CollectionType.Channels))
{
2016-06-30 19:25:38 +00:00
var channelResult = BaseItem.ChannelManager.GetChannelsInternal(new ChannelQuery
{
UserId = user.Id.ToString("N")
}, CancellationToken.None).Result;
2016-07-09 17:39:04 +00:00
2016-06-30 19:25:38 +00:00
return channelResult.Items;
2015-11-14 18:57:26 +00:00
}
// Translate view into folders
if (view.DisplayParentId != Guid.Empty)
{
var displayParent = GetItemById(view.DisplayParentId);
if (displayParent != null)
{
2015-11-18 05:49:20 +00:00
return GetTopParentsForQuery(displayParent, user);
2015-11-14 18:57:26 +00:00
}
return new BaseItem[] { };
}
if (view.ParentId != Guid.Empty)
{
var displayParent = GetItemById(view.ParentId);
if (displayParent != null)
{
2015-11-18 05:49:20 +00:00
return GetTopParentsForQuery(displayParent, user);
2015-11-14 18:57:26 +00:00
}
return new BaseItem[] { };
}
// Handle grouping
2015-11-18 05:49:20 +00:00
if (user != null && !string.IsNullOrWhiteSpace(view.ViewType) && UserView.IsEligibleForGrouping(view.ViewType))
{
2016-05-18 05:34:10 +00:00
return user.RootFolder
.GetChildren(user, true)
.OfType<CollectionFolder>()
.Where(i => string.IsNullOrWhiteSpace(i.CollectionType) || string.Equals(i.CollectionType, view.ViewType, StringComparison.OrdinalIgnoreCase))
2016-05-18 17:02:56 +00:00
.Where(i => user.IsFolderGrouped(i.Id))
2016-05-18 05:34:10 +00:00
.SelectMany(i => GetTopParentsForQuery(i, user));
2015-11-18 05:49:20 +00:00
}
2015-11-14 18:57:26 +00:00
return new BaseItem[] { };
}
var collectionFolder = item as CollectionFolder;
if (collectionFolder != null)
{
return collectionFolder.GetPhysicalParents();
}
var topParent = item.GetTopParent();
if (topParent != null)
{
return new[] { topParent };
}
return new BaseItem[] { };
}
/// <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 21:56:54 +00:00
public async Task<IEnumerable<Video>> GetIntros(BaseItem item, User user)
{
2014-09-22 21:56:54 +00:00
var tasks = IntroProviders
2016-03-27 21:11:27 +00:00
.OrderBy(i => i.GetType().Name.IndexOf("Default", StringComparison.OrdinalIgnoreCase) == -1 ? 0 : 1)
2014-09-22 21:56:54 +00:00
.Take(1)
.Select(i => GetIntros(i, item, user));
var items = await Task.WhenAll(tasks).ConfigureAwait(false);
return items
.SelectMany(i => i.ToArray())
.Select(ResolveIntro)
.Where(i => i != null);
}
2014-09-22 21:56:54 +00: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&lt;IEnumerable&lt;IntroInfo&gt;&gt;.</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>();
}
}
/// <summary>
/// Gets all intro files.
/// </summary>
/// <returns>IEnumerable{System.String}.</returns>
public IEnumerable<string> GetAllIntroFiles()
{
2014-09-23 00:04:50 +00:00
return IntroProviders.SelectMany(i =>
{
try
{
return i.GetAllIntroFiles().ToList();
}
catch (Exception ex)
{
_logger.ErrorException("Error getting intro files", ex);
return new List<string>();
}
});
}
/// <summary>
/// Resolves the intro.
/// </summary>
/// <param name="info">The info.</param>
/// <returns>Video.</returns>
private Video ResolveIntro(IntroInfo info)
{
Video video = null;
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
video = ResolvePath(_fileSystem.GetFileSystemInfo(info.Path)) as Video;
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;
}
else
{
return null;
}
}
}
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-03-10 04:22:36 +00: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;
userComparer.UserManager = _userManager;
userComparer.UserDataRepository = _userDataRepository;
2013-03-10 04:22:36 +00:00
return userComparer;
}
}
return comparer;
}
/// <summary>
/// Creates the item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
2013-05-23 15:39:48 +00:00
public Task CreateItem(BaseItem item, CancellationToken cancellationToken)
{
2013-05-23 15:39:48 +00:00
return CreateItems(new[] { item }, cancellationToken);
}
2013-05-23 15:39:48 +00: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);
}
if (ItemAdded != null)
{
2013-05-23 15:39:48 +00:00
foreach (var item in list)
{
2013-05-23 15:39:48 +00:00
try
{
ItemAdded(this, new ItemChangeEventArgs { Item = item });
}
catch (Exception ex)
{
_logger.ErrorException("Error in ItemAdded event handler", ex);
2013-05-23 15:39:48 +00:00
}
}
}
}
/// <summary>
/// Updates the item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="updateReason">The update reason.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public async Task UpdateItem(BaseItem item, ItemUpdateType updateReason, CancellationToken cancellationToken)
{
var locationType = item.LocationType;
if (locationType != LocationType.Remote && locationType != LocationType.Virtual)
{
2014-02-02 13:36:31 +00:00
await _providerManagerFactory().SaveMetadata(item, updateReason).ConfigureAwait(false);
}
2014-02-21 05:04:11 +00:00
item.DateLastSaved = DateTime.UtcNow;
2014-09-28 20:49:43 +00:00
var logName = item.LocationType == LocationType.Remote ? item.Name ?? item.Path : item.Path ?? item.Name;
_logger.Debug("Saving {0} to database.", logName);
2013-09-25 19:59:02 +00:00
await ItemRepository.SaveItem(item, cancellationToken).ConfigureAwait(false);
UpdateItemInLibraryCache(item);
if (ItemUpdated != null)
{
try
{
2013-11-13 16:45:41 +00:00
ItemUpdated(this, new ItemChangeEventArgs
{
Item = item,
UpdateReason = updateReason
});
}
catch (Exception ex)
{
_logger.ErrorException("Error in ItemUpdated event handler", ex);
}
}
}
/// <summary>
/// Reports the item removed.
/// </summary>
/// <param name="item">The item.</param>
public void ReportItemRemoved(BaseItem item)
{
if (ItemRemoved != null)
{
try
{
ItemRemoved(this, new ItemChangeEventArgs { Item = item });
}
catch (Exception ex)
{
_logger.ErrorException("Error in ItemRemoved event handler", ex);
}
}
}
/// <summary>
/// Retrieves the item.
/// </summary>
/// <param name="id">The id.</param>
2013-06-17 20:35:43 +00:00
/// <returns>BaseItem.</returns>
2013-06-26 16:08:16 +00:00
public BaseItem RetrieveItem(Guid id)
{
2013-12-03 21:11:09 +00:00
return ItemRepository.RetrieveItem(id);
2013-11-21 20:48:26 +00:00
}
2015-02-15 03:36:07 +00:00
public IEnumerable<Folder> GetCollectionFolders(BaseItem item)
{
2015-11-13 20:53:29 +00:00
while (!(item.GetParent() is AggregateFolder) && item.GetParent() != null)
2015-02-15 03:36:07 +00:00
{
2015-11-13 20:53:29 +00:00
item = item.GetParent();
2015-02-15 03:36:07 +00:00
}
if (item == null)
{
return new List<Folder>();
}
return GetUserRootFolder().Children
.OfType<Folder>()
2015-04-10 14:01:16 +00:00
.Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path, StringComparer.OrdinalIgnoreCase));
2015-02-15 03:36:07 +00:00
}
public LibraryOptions GetLibraryOptions(BaseItem item)
{
var collectionFolder = GetCollectionFolders(item)
.OfType<CollectionFolder>()
.FirstOrDefault();
return collectionFolder == null ? new LibraryOptions() : collectionFolder.GetLibraryOptions();
}
2014-12-21 18:58:17 +00:00
public string GetContentType(BaseItem item)
{
2015-01-10 01:38:01 +00:00
string configuredContentType = GetConfiguredContentType(item, false);
if (!string.IsNullOrWhiteSpace(configuredContentType))
2014-12-22 06:50:29 +00:00
{
2015-01-10 01:38:01 +00:00
return configuredContentType;
2014-12-22 06:50:29 +00:00
}
2015-01-10 01:38:01 +00:00
configuredContentType = GetConfiguredContentType(item, true);
if (!string.IsNullOrWhiteSpace(configuredContentType))
{
return configuredContentType;
}
return GetInheritedContentType(item);
2015-01-02 05:36:27 +00:00
}
public string GetInheritedContentType(BaseItem item)
{
var type = GetTopFolderContentType(item);
2014-12-22 06:50:29 +00:00
if (!string.IsNullOrWhiteSpace(type))
{
return type;
}
2015-11-13 20:53:29 +00:00
return item.GetParents()
2014-12-22 06:50:29 +00:00
.Select(GetConfiguredContentType)
.LastOrDefault(i => !string.IsNullOrWhiteSpace(i));
}
2015-01-10 01:38:01 +00:00
public string GetConfiguredContentType(BaseItem item)
2014-12-22 06:50:29 +00:00
{
2015-01-10 01:38:01 +00:00
return GetConfiguredContentType(item, false);
2014-12-22 06:50:29 +00:00
}
2015-01-10 01:38:01 +00:00
public string GetConfiguredContentType(string path)
2014-12-22 06:50:29 +00:00
{
2015-01-10 01:38:01 +00:00
return GetContentTypeOverride(path, false);
}
2014-12-22 06:50:29 +00:00
2015-01-10 01:38:01 +00: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 18:58:17 +00:00
}
2015-01-10 01:38:01 +00:00
private string GetContentTypeOverride(string path, bool inherit)
{
2016-07-10 15:44:53 +00:00
var nameValuePair = ConfigurationManager.Configuration.ContentTypes.FirstOrDefault(i => string.Equals(i.Name, path, StringComparison.OrdinalIgnoreCase) || (inherit && !string.IsNullOrWhiteSpace(i.Name) && _fileSystem.ContainsSubPath(i.Name, path)));
2015-01-10 01:38:01 +00:00
if (nameValuePair != null)
{
return nameValuePair.Value;
}
return null;
}
2015-02-15 03:36:07 +00:00
2014-12-21 18:58:17 +00:00
private string GetTopFolderContentType(BaseItem item)
2013-07-12 19:56:40 +00:00
{
2015-11-14 18:57:26 +00:00
if (item == null)
2013-07-12 19:56:40 +00:00
{
2015-11-14 18:57:26 +00:00
return null;
2013-07-12 19:56:40 +00:00
}
2015-11-14 18:57:26 +00:00
while (!(item.GetParent() is AggregateFolder) && item.GetParent() != null)
2013-07-12 19:56:40 +00:00
{
2015-11-14 18:57:26 +00:00
item = item.GetParent();
2013-07-12 19:56:40 +00:00
}
2014-12-21 01:23:56 +00:00
return GetUserRootFolder().Children
2014-10-12 01:46:02 +00:00
.OfType<ICollectionFolder>()
2014-12-21 01:23:56 +00:00
.Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path))
2013-07-12 19:56:40 +00:00
.Select(i => i.CollectionType)
2014-12-21 01:23:56 +00:00
.FirstOrDefault(i => !string.IsNullOrWhiteSpace(i));
2013-07-12 19:56:40 +00:00
}
2013-11-21 20:48:26 +00:00
2015-09-17 01:33:46 +00:00
private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromHours(24);
//private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromMinutes(1);
2015-05-08 19:10:53 +00:00
2015-08-14 18:00:26 +00:00
public Task<UserView> GetNamedView(User user,
2015-03-14 04:50:23 +00:00
string name,
string viewType,
2014-10-29 22:01:02 +00:00
string sortName,
CancellationToken cancellationToken)
2014-06-07 19:46:24 +00:00
{
2015-11-18 05:49:20 +00:00
return GetNamedView(user, name, null, viewType, sortName, cancellationToken);
2015-08-14 18:00:26 +00:00
}
public async Task<UserView> GetNamedView(string name,
string viewType,
string sortName,
CancellationToken cancellationToken)
{
2015-08-14 18:30:08 +00:00
var path = Path.Combine(ConfigurationManager.ApplicationPaths.ItemsByNamePath, "views");
2014-09-05 03:48:53 +00:00
2015-03-14 04:50:23 +00:00
path = Path.Combine(path, _fileSystem.GetValidFilename(viewType));
2014-06-07 19:46:24 +00:00
2014-11-30 19:01:33 +00:00
var id = GetNewItemId(path + "_namedview_" + name, typeof(UserView));
2014-07-26 17:30:15 +00:00
var item = GetItemById(id) as UserView;
2014-09-05 03:48:53 +00:00
2014-10-29 22:01:02 +00:00
var refresh = false;
2015-11-18 05:49:20 +00:00
if (item == null || !string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
2014-06-07 19:46:24 +00:00
{
2015-11-13 20:53:29 +00:00
_fileSystem.CreateDirectory(path);
2014-06-07 19:46:24 +00:00
item = new UserView
{
Path = path,
2014-07-26 17:30:15 +00:00
Id = id,
2014-06-07 19:46:24 +00:00
DateCreated = DateTime.UtcNow,
Name = name,
2015-03-14 04:50:23 +00:00
ViewType = viewType,
2014-06-07 19:46:24 +00:00
ForcedSortName = sortName
};
await CreateItem(item, cancellationToken).ConfigureAwait(false);
2014-10-29 22:01:02 +00:00
refresh = true;
}
2015-07-27 05:03:34 +00:00
if (!refresh)
2014-10-29 22:01:02 +00:00
{
2016-03-27 21:11:27 +00:00
refresh = DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
2014-10-29 22:01:02 +00:00
}
2015-10-18 01:18:29 +00:00
if (!refresh && item.DisplayParentId != Guid.Empty)
{
var displayParent = GetItemById(item.DisplayParentId);
refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
}
2014-10-29 22:01:02 +00:00
if (refresh)
{
2015-03-14 04:50:23 +00:00
await item.UpdateToRepository(ItemUpdateType.MetadataImport, CancellationToken.None).ConfigureAwait(false);
2015-09-13 23:07:54 +00:00
_providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
2015-05-08 19:10:53 +00:00
{
// 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 22:01:02 +00:00
}
return item;
}
2015-11-18 05:49:20 +00:00
public async Task<UserView> GetNamedView(User user,
2015-03-14 04:50:23 +00:00
string name,
string parentId,
string viewType,
string sortName,
CancellationToken cancellationToken)
{
2015-11-18 05:49:20 +00:00
var idValues = "38_namedview_" + name + user.Id.ToString("N") + (parentId ?? string.Empty) + (viewType ?? string.Empty);
2015-04-20 18:04:02 +00:00
var id = GetNewItemId(idValues, typeof(UserView));
2014-10-29 22:01:02 +00:00
2015-03-14 04:50:23 +00:00
var path = Path.Combine(ConfigurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N"));
2014-10-29 22:01:02 +00:00
var item = GetItemById(id) as UserView;
2015-03-14 17:02:51 +00:00
var isNew = false;
2014-10-29 22:01:02 +00:00
if (item == null)
{
2015-11-13 20:53:29 +00:00
_fileSystem.CreateDirectory(path);
2014-10-29 22:01:02 +00:00
item = new UserView
{
Path = path,
Id = id,
DateCreated = DateTime.UtcNow,
Name = name,
ViewType = viewType,
2015-09-15 18:09:44 +00:00
ForcedSortName = sortName,
UserId = user.Id
2014-10-29 22:01:02 +00:00
};
2015-03-14 04:50:23 +00:00
if (!string.IsNullOrWhiteSpace(parentId))
2015-08-14 18:00:26 +00:00
{
2015-10-16 04:46:41 +00:00
item.DisplayParentId = new Guid(parentId);
2015-08-14 18:00:26 +00:00
}
await CreateItem(item, cancellationToken).ConfigureAwait(false);
isNew = true;
}
2016-03-27 21:11:27 +00:00
var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
2015-08-14 18:00:26 +00:00
2015-10-18 01:18:29 +00:00
if (!refresh && item.DisplayParentId != Guid.Empty)
{
var displayParent = GetItemById(item.DisplayParentId);
refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
}
2015-08-14 18:00:26 +00:00
if (refresh)
{
2015-09-13 23:07:54 +00:00
_providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
2015-08-14 18:00:26 +00:00
{
// Need to force save to increment DateLastSaved
ForceSave = true
});
}
return item;
}
2015-10-16 04:46:41 +00:00
public async Task<UserView> GetShadowView(BaseItem parent,
string viewType,
string sortName,
CancellationToken cancellationToken)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
var name = parent.Name;
var parentId = parent.Id;
2015-11-18 05:49:20 +00:00
var idValues = "38_namedview_" + name + parentId + (viewType ?? string.Empty);
2015-10-16 04:46:41 +00:00
var id = GetNewItemId(idValues, typeof(UserView));
var path = parent.Path;
var item = GetItemById(id) as UserView;
var isNew = false;
if (item == null)
{
_fileSystem.CreateDirectory(path);
item = new UserView
{
Path = path,
Id = id,
DateCreated = DateTime.UtcNow,
Name = name,
ViewType = viewType,
ForcedSortName = sortName
};
item.DisplayParentId = parentId;
await CreateItem(item, cancellationToken).ConfigureAwait(false);
isNew = true;
}
2016-03-27 21:11:27 +00:00
var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
2015-10-16 04:46:41 +00:00
2015-10-18 01:18:29 +00:00
if (!refresh && item.DisplayParentId != Guid.Empty)
{
var displayParent = GetItemById(item.DisplayParentId);
refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
}
2015-10-16 04:46:41 +00:00
if (refresh)
{
_providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
{
// Need to force save to increment DateLastSaved
ForceSave = true
});
}
return item;
}
2015-11-13 20:53:29 +00:00
2015-08-14 18:00:26 +00:00
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 19:14:54 +00:00
var idValues = "37_namedview_" + name + (parentId ?? string.Empty) + (viewType ?? string.Empty);
2015-08-14 18:00:26 +00: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)
{
2015-11-13 20:53:29 +00:00
_fileSystem.CreateDirectory(path);
2015-08-14 18:00:26 +00:00
item = new UserView
{
Path = path,
Id = id,
DateCreated = DateTime.UtcNow,
Name = name,
ViewType = viewType,
ForcedSortName = sortName
};
if (!string.IsNullOrWhiteSpace(parentId))
2015-03-14 04:50:23 +00:00
{
2015-10-16 04:46:41 +00:00
item.DisplayParentId = new Guid(parentId);
2015-03-14 04:50:23 +00:00
}
2014-10-29 22:01:02 +00:00
await CreateItem(item, cancellationToken).ConfigureAwait(false);
2015-03-14 17:02:51 +00:00
isNew = true;
2014-10-29 22:01:02 +00:00
}
2015-04-15 21:59:20 +00:00
if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
{
item.ViewType = viewType;
await item.UpdateToRepository(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
}
2016-03-27 21:11:27 +00:00
var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
2014-10-29 22:01:02 +00:00
2015-10-18 01:18:29 +00:00
if (!refresh && item.DisplayParentId != Guid.Empty)
{
var displayParent = GetItemById(item.DisplayParentId);
refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
}
2014-10-29 22:01:02 +00:00
if (refresh)
{
2015-09-13 23:07:54 +00:00
_providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
2015-03-26 23:10:34 +00:00
{
// Need to force save to increment DateLastSaved
ForceSave = true
});
2014-06-07 19:46:24 +00:00
}
return item;
}
2014-11-16 20:44:08 +00:00
public bool IsVideoFile(string path, LibraryOptions libraryOptions)
2014-11-16 20:44:08 +00:00
{
var resolver = new VideoResolver(GetNamingOptions(libraryOptions), new PatternsLogger());
2014-11-16 22:46:01 +00:00
return resolver.IsVideoFile(path);
2014-11-16 20:44:08 +00:00
}
public bool IsVideoFile(string path)
{
return IsVideoFile(path, new LibraryOptions());
}
public bool IsAudioFile(string path, LibraryOptions libraryOptions)
2014-11-16 20:44:08 +00:00
{
var parser = new AudioFileParser(GetNamingOptions(libraryOptions));
2014-11-16 20:44:08 +00:00
return parser.IsAudioFile(path);
}
public bool IsAudioFile(string path)
{
return IsAudioFile(path, new LibraryOptions());
}
2014-11-16 20:44:08 +00:00
public int? GetSeasonNumberFromPath(string path)
{
2015-01-10 05:53:35 +00:00
return new SeasonPathParser(GetNamingOptions(), new RegexProvider()).Parse(path, true, true).SeasonNumber;
2014-11-16 20:44:08 +00:00
}
2014-12-19 04:20:07 +00:00
public bool FillMissingEpisodeNumbersFromPath(Episode episode)
2014-11-16 20:44:08 +00:00
{
2015-01-10 05:53:35 +00:00
var resolver = new EpisodeResolver(GetNamingOptions(),
2015-01-17 04:38:24 +00:00
new PatternsLogger());
2014-11-16 20:44:08 +00:00
2015-04-29 18:48:34 +00:00
var isFolder = episode.VideoType == VideoType.BluRay || episode.VideoType == VideoType.Dvd ||
episode.VideoType == VideoType.HdDvd;
2014-12-23 03:58:14 +00:00
2014-12-19 04:20:07 +00:00
var locationType = episode.LocationType;
2014-12-21 01:23:56 +00:00
2014-12-19 04:20:07 +00:00
var episodeInfo = locationType == LocationType.FileSystem || locationType == LocationType.Offline ?
2015-04-29 18:48:34 +00:00
resolver.Resolve(episode.Path, isFolder) :
2014-12-19 04:20:07 +00:00
new Naming.TV.EpisodeInfo();
2014-11-16 20:44:08 +00:00
2014-12-19 04:20:07 +00:00
if (episodeInfo == null)
{
episodeInfo = new Naming.TV.EpisodeInfo();
}
var changed = false;
2014-12-23 03:58:14 +00:00
if (episodeInfo.IsByDate)
2014-12-19 04:20:07 +00:00
{
if (episode.IndexNumber.HasValue)
{
2014-12-23 03:58:14 +00:00
episode.IndexNumber = null;
2014-12-19 04:20:07 +00:00
changed = true;
}
if (episode.IndexNumberEnd.HasValue)
{
2014-12-23 03:58:14 +00:00
episode.IndexNumberEnd = null;
2014-12-19 04:20:07 +00:00
changed = true;
}
2014-12-23 03:58:14 +00: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 04:20:07 +00:00
if (!episode.ParentIndexNumber.HasValue)
{
var season = episode.Season;
if (season != null)
{
episode.ParentIndexNumber = season.IndexNumber;
}
2014-12-23 03:58:14 +00: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 04:20:07 +00:00
}
2014-12-23 03:58:14 +00:00
if (!episode.IndexNumberEnd.HasValue)
2014-12-19 04:20:07 +00:00
{
2014-12-23 03:58:14 +00: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 04:20:07 +00:00
}
}
return changed;
2014-11-16 20:44:08 +00:00
}
2014-11-16 22:46:01 +00:00
2015-01-10 05:53:35 +00:00
public NamingOptions GetNamingOptions()
{
return GetNamingOptions(new LibraryOptions());
}
public NamingOptions GetNamingOptions(LibraryOptions libraryOptions)
2015-01-10 05:53:35 +00:00
{
var options = new ExtendedNamingOptions();
2015-03-12 03:38:59 +00:00
// These cause apps to have problems
options.AudioFileExtensions.Remove(".m3u");
options.AudioFileExtensions.Remove(".wpl");
2015-03-14 04:50:23 +00:00
if (!libraryOptions.EnableAudioArchiveFiles)
2015-01-10 05:53:35 +00:00
{
options.AudioFileExtensions.Remove(".rar");
options.AudioFileExtensions.Remove(".zip");
}
if (!libraryOptions.EnableVideoArchiveFiles)
2015-01-10 05:53:35 +00:00
{
options.VideoFileExtensions.Remove(".rar");
options.VideoFileExtensions.Remove(".zip");
}
2015-02-15 03:36:07 +00:00
2015-01-10 05:53:35 +00:00
return options;
}
2014-11-16 22:46:01 +00:00
public ItemLookupInfo ParseName(string name)
{
2015-01-17 04:38:24 +00:00
var resolver = new VideoResolver(GetNamingOptions(), new PatternsLogger());
2014-11-16 22:46:01 +00:00
var result = resolver.CleanDateTime(name);
2014-11-21 14:28:30 +00:00
var cleanName = resolver.CleanString(result.Name);
2014-11-16 22:46:01 +00:00
return new ItemLookupInfo
{
2014-11-21 14:28:30 +00:00
Name = cleanName.Name,
2014-11-16 22:46:01 +00:00
Year = result.Year
};
}
2014-11-18 02:48:22 +00:00
2015-10-04 03:38:46 +00:00
public IEnumerable<Video> FindTrailers(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
{
2016-06-01 15:54:11 +00:00
var files = owner.IsInMixedFolder ? new List<FileSystemMetadata>() : fileSystemChildren.Where(i => i.IsDirectory)
.Where(i => string.Equals(i.Name, BaseItem.TrailerFolderName, StringComparison.OrdinalIgnoreCase))
2015-10-04 03:38:46 +00:00
.SelectMany(i => _fileSystem.GetFiles(i.FullName, false))
.ToList();
2015-01-17 04:38:24 +00:00
var videoListResolver = new VideoListResolver(GetNamingOptions(), new PatternsLogger());
2015-04-29 18:48:34 +00:00
var videos = videoListResolver.Resolve(fileSystemChildren.Select(i => new FileMetadata
2014-12-03 03:13:03 +00:00
{
2015-04-29 18:48:34 +00:00
Id = i.FullName,
2016-03-27 21:11:27 +00:00
IsFolder = (i.Attributes & FileAttributes.Directory) == FileAttributes.Directory
2014-12-03 03:13:03 +00:00
}).ToList());
2014-12-03 03:13:03 +00:00
var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
2014-12-03 03:13:03 +00:00
if (currentVideo != null)
{
2015-10-04 03:38:46 +00:00
files.AddRange(currentVideo.Extras.Where(i => string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => _fileSystem.GetFileInfo(i.Path)));
2014-12-03 03:13:03 +00:00
}
2016-03-19 19:32:37 +00:00
var resolvers = new IItemResolver[]
{
new GenericVideoResolver<Trailer>(this)
};
return ResolvePaths(files, directoryService, null, new LibraryOptions(), null, resolvers)
2016-03-19 19:32:37 +00:00
.OfType<Trailer>()
2014-12-04 05:24:41 +00:00
.Select(video =>
{
2015-11-13 20:53:29 +00:00
// Try to retrieve it from the db. If we don't find it, use the resolved version
2016-03-19 19:32:37 +00:00
var dbItem = GetItemById(video.Id) as Trailer;
2015-11-13 20:53:29 +00:00
if (dbItem != null)
{
video = dbItem;
}
2015-11-13 20:53:29 +00:00
video.ExtraType = ExtraType.Trailer;
2016-03-30 16:37:29 +00:00
video.TrailerTypes = new List<TrailerType> { TrailerType.LocalTrailer };
2015-11-13 20:53:29 +00:00
return video;
// Sort them so that the list can be easily compared for changes
}).OrderBy(i => i.Path).ToList();
}
2015-10-04 03:38:46 +00:00
public IEnumerable<Video> FindExtras(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
{
2015-10-04 03:38:46 +00:00
var files = fileSystemChildren.Where(i => i.IsDirectory)
.Where(i => string.Equals(i.Name, "extras", StringComparison.OrdinalIgnoreCase) || string.Equals(i.Name, "specials", StringComparison.OrdinalIgnoreCase))
2015-10-04 03:38:46 +00:00
.SelectMany(i => _fileSystem.GetFiles(i.FullName, false))
.ToList();
2015-01-17 04:38:24 +00:00
var videoListResolver = new VideoListResolver(GetNamingOptions(), new PatternsLogger());
2015-04-29 18:48:34 +00:00
var videos = videoListResolver.Resolve(fileSystemChildren.Select(i => new FileMetadata
2014-12-03 03:13:03 +00:00
{
2015-04-29 18:48:34 +00:00
Id = i.FullName,
2016-03-27 21:11:27 +00:00
IsFolder = (i.Attributes & FileAttributes.Directory) == FileAttributes.Directory
2014-12-03 03:13:03 +00:00
}).ToList());
2014-12-03 03:13:03 +00:00
var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
if (currentVideo != null)
{
2015-10-04 03:38:46 +00:00
files.AddRange(currentVideo.Extras.Where(i => !string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => _fileSystem.GetFileInfo(i.Path)));
2014-12-03 03:13:03 +00:00
}
return ResolvePaths(files, directoryService, null, new LibraryOptions(), null)
2014-12-04 05:24:41 +00:00
.OfType<Video>()
.Select(video =>
{
2014-12-04 05:24:41 +00: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-04 05:24:41 +00:00
if (dbItem != null)
{
video = dbItem;
}
2014-12-04 05:24:41 +00:00
SetExtraTypeFromFilename(video);
2014-12-04 05:24:41 +00:00
return video;
// Sort them so that the list can be easily compared for changes
}).OrderBy(i => i.Path).ToList();
}
2015-10-04 03:38:46 +00:00
public string SubstitutePath(string path, string from, string to)
{
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentNullException("path");
}
if (string.IsNullOrWhiteSpace(from))
{
throw new ArgumentNullException("from");
}
if (string.IsNullOrWhiteSpace(to))
{
throw new ArgumentNullException("to");
}
var newPath = path.Replace(from, to, StringComparison.OrdinalIgnoreCase);
if (!string.Equals(newPath, path))
{
if (to.IndexOf('/') != -1)
{
newPath = newPath.Replace('\\', '/');
}
else
{
newPath = newPath.Replace('/', '\\');
}
}
return newPath;
}
private void SetExtraTypeFromFilename(Video item)
{
2015-01-17 04:38:24 +00:00
var resolver = new ExtraResolver(GetNamingOptions(), new PatternsLogger(), new RegexProvider());
2014-12-03 03:13:03 +00:00
var result = resolver.GetExtraInfo(item.Path);
if (string.Equals(result.ExtraType, "deletedscene", StringComparison.OrdinalIgnoreCase))
{
2014-12-03 03:13:03 +00: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;
}
}
2015-06-21 03:35:22 +00:00
2015-07-08 16:10:34 +00:00
public List<PersonInfo> GetPeople(InternalPeopleQuery query)
{
return ItemRepository.GetPeople(query);
}
2015-06-21 03:35:22 +00:00
public List<PersonInfo> GetPeople(BaseItem item)
{
2015-07-28 19:42:24 +00:00
if (item.SupportsPeople)
2015-07-08 16:10:34 +00:00
{
2015-07-28 19:42:24 +00:00
var people = GetPeople(new InternalPeopleQuery
{
ItemId = item.Id
});
2015-07-13 21:26:11 +00:00
2015-07-28 19:42:24 +00:00
if (people.Count > 0)
{
return people;
}
2015-07-13 21:26:11 +00:00
}
2015-09-10 03:22:52 +00:00
return new List<PersonInfo>();
2015-06-21 03:35:22 +00:00
}
2015-07-08 16:10:34 +00:00
public List<Person> GetPeopleItems(InternalPeopleQuery query)
2015-07-07 02:25:23 +00:00
{
2015-07-08 16:10:34 +00:00
return ItemRepository.GetPeopleNames(query).Select(i =>
2015-07-07 02:25:23 +00:00
{
try
{
return GetPerson(i);
}
catch (Exception ex)
{
_logger.ErrorException("Error getting person", ex);
return null;
}
}).Where(i => i != null).ToList();
}
2015-07-08 16:10:34 +00:00
public List<string> GetPeopleNames(InternalPeopleQuery query)
{
return ItemRepository.GetPeopleNames(query);
}
2015-07-13 21:26:11 +00:00
public Task UpdatePeople(BaseItem item, List<PersonInfo> people)
2015-06-21 03:35:22 +00:00
{
2015-08-06 01:21:18 +00:00
if (!item.SupportsPeople)
{
return Task.FromResult(true);
}
2015-07-13 21:26:11 +00:00
return ItemRepository.UpdatePeople(item.Id, people);
2015-06-21 03:35:22 +00:00
}
2015-10-16 17:06:31 +00:00
2015-11-13 20:53:29 +00:00
private readonly SemaphoreSlim _dynamicImageResourcePool = new SemaphoreSlim(1, 1);
2015-10-16 17:06:31 +00:00
public async Task<ItemImageInfo> ConvertImageToLocal(IHasImages item, ItemImageInfo image, int imageIndex)
{
foreach (var url in image.Path.Split('|'))
{
try
{
_logger.Debug("ConvertImageToLocal item {0} - image url: {1}", item.Id, url);
2015-10-16 17:06:31 +00:00
await _providerManagerFactory().SaveImage(item, url, _dynamicImageResourcePool, image.Type, imageIndex, CancellationToken.None).ConfigureAwait(false);
2015-10-16 17:06:31 +00:00
var newImage = item.GetImageInfo(image.Type, imageIndex);
2015-11-21 05:51:47 +00:00
if (newImage != null)
{
newImage.IsPlaceholder = image.IsPlaceholder;
}
await item.UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
return item.GetImageInfo(image.Type, imageIndex);
}
catch (HttpException ex)
{
if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound)
{
continue;
}
throw;
}
2015-11-21 05:51:47 +00:00
}
// Remove this image to prevent it from retrying over and over
item.RemoveImage(image);
2015-10-16 17:06:31 +00:00
await item.UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
2016-03-20 06:46:51 +00:00
throw new InvalidOperationException();
2015-10-16 17:06:31 +00:00
}
2016-05-04 16:33:22 +00:00
public void AddVirtualFolder(string name, string collectionType, string[] mediaPaths, LibraryOptions options, bool refreshLibrary)
2016-05-04 16:33:22 +00:00
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException("name");
}
2016-05-07 18:58:16 +00:00
name = _fileSystem.GetValidFilename(name);
2016-05-04 16:33:22 +00:00
var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
var virtualFolderPath = Path.Combine(rootFolderPath, name);
while (_fileSystem.DirectoryExists(virtualFolderPath))
{
name += "1";
virtualFolderPath = Path.Combine(rootFolderPath, name);
}
if (mediaPaths != null)
{
var invalidpath = mediaPaths.FirstOrDefault(i => !_fileSystem.DirectoryExists(i));
if (invalidpath != null)
{
throw new ArgumentException("The specified path does not exist: " + invalidpath + ".");
}
}
_libraryMonitorFactory().Stop();
try
{
_fileSystem.CreateDirectory(virtualFolderPath);
if (!string.IsNullOrEmpty(collectionType))
{
var path = Path.Combine(virtualFolderPath, collectionType + ".collection");
using (File.Create(path))
{
}
}
CollectionFolder.SaveLibraryOptions(virtualFolderPath, options);
2016-05-04 16:33:22 +00:00
if (mediaPaths != null)
{
foreach (var path in mediaPaths)
{
AddMediaPath(name, path);
}
}
}
finally
{
Task.Run(() =>
{
// No need to start if scanning the library because it will handle it
if (refreshLibrary)
{
ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
}
else
{
// Need to add a delay here or directory watchers may still pick up the changes
var task = Task.Delay(1000);
// Have to block here to allow exceptions to bubble
Task.WaitAll(task);
_libraryMonitorFactory().Start();
}
});
}
}
2016-05-04 20:50:47 +00:00
public void RemoveVirtualFolder(string name, bool refreshLibrary)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException("name");
}
var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
var path = Path.Combine(rootFolderPath, name);
if (!_fileSystem.DirectoryExists(path))
{
throw new DirectoryNotFoundException("The media folder does not exist");
}
_libraryMonitorFactory().Stop();
try
{
_fileSystem.DeleteDirectory(path, true);
}
finally
{
Task.Run(() =>
{
// No need to start if scanning the library because it will handle it
if (refreshLibrary)
{
ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
}
else
{
// Need to add a delay here or directory watchers may still pick up the changes
var task = Task.Delay(1000);
// Have to block here to allow exceptions to bubble
Task.WaitAll(task);
_libraryMonitorFactory().Start();
}
});
}
}
2016-05-04 16:33:22 +00:00
private const string ShortcutFileExtension = ".mblink";
2016-05-04 20:50:47 +00:00
private const string ShortcutFileSearch = "*" + ShortcutFileExtension;
2016-05-04 16:33:22 +00:00
public void AddMediaPath(string virtualFolderName, string path)
{
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentNullException("path");
}
if (!_fileSystem.DirectoryExists(path))
{
throw new DirectoryNotFoundException("The path does not exist.");
}
var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
var shortcutFilename = _fileSystem.GetFileNameWithoutExtension(path);
var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
while (_fileSystem.FileExists(lnk))
{
shortcutFilename += "1";
lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
}
_fileSystem.CreateShortcut(lnk, path);
RemoveContentTypeOverrides(path);
}
private void RemoveContentTypeOverrides(string path)
{
2016-07-10 15:44:53 +00:00
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentNullException("path");
}
var removeList = new List<NameValuePair>();
foreach (var contentType in ConfigurationManager.Configuration.ContentTypes)
{
if (string.Equals(path, contentType.Name, StringComparison.OrdinalIgnoreCase)
|| _fileSystem.ContainsSubPath(path, contentType.Name))
{
removeList.Add(contentType);
}
}
if (removeList.Count > 0)
{
ConfigurationManager.Configuration.ContentTypes = ConfigurationManager.Configuration.ContentTypes
.Except(removeList)
.ToArray();
ConfigurationManager.SaveConfiguration();
}
2016-05-04 16:33:22 +00:00
}
2016-05-04 20:50:47 +00:00
public void RemoveMediaPath(string virtualFolderName, string mediaPath)
{
if (string.IsNullOrWhiteSpace(mediaPath))
{
throw new ArgumentNullException("mediaPath");
}
var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
var path = Path.Combine(rootFolderPath, virtualFolderName);
if (!_fileSystem.DirectoryExists(path))
{
throw new DirectoryNotFoundException(string.Format("The media collection {0} does not exist", virtualFolderName));
}
var shortcut = Directory.EnumerateFiles(path, ShortcutFileSearch, SearchOption.AllDirectories).FirstOrDefault(f => _fileSystem.ResolveShortcut(f).Equals(mediaPath, StringComparison.OrdinalIgnoreCase));
if (!string.IsNullOrEmpty(shortcut))
{
_fileSystem.DeleteFile(shortcut);
}
}
2013-02-21 01:33:05 +00:00
}
2015-11-13 20:53:29 +00:00
}