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

1549 lines
54 KiB
C#
Raw Normal View History

2013-05-03 04:32:16 +00:00
using MediaBrowser.Common.Extensions;
using MediaBrowser.Common.IO;
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;
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;
using MediaBrowser.Server.Implementations.Library.Validators;
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.Threading;
using System.Threading.Tasks;
2013-03-10 04:22:36 +00:00
using SortOrder = MediaBrowser.Model.Entities.SortOrder;
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 IEnumerable<ILibraryPostScanTask> PostscanTasks { get; set; }
/// <summary>
/// Gets or sets the prescan tasks.
/// </summary>
/// <value>The prescan tasks.</value>
private IEnumerable<ILibraryPrescanTask> PrescanTasks { get; set; }
/// <summary>
/// Gets or sets the people prescan tasks.
/// </summary>
/// <value>The people prescan tasks.</value>
private IEnumerable<IPeoplePrescanTask> PeoplePrescanTasks { get; set; }
/// <summary>
/// Gets the intro providers.
/// </summary>
/// <value>The intro providers.</value>
private IEnumerable<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; }
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 IEnumerable<IMetadataSaver> _savers;
private readonly Func<IDirectoryWatchers> _directoryWatchersFactory;
/// <summary>
/// The _library items cache
/// </summary>
private ConcurrentDictionary<Guid, BaseItem> _libraryItemsCache;
/// <summary>
/// The _library items cache sync lock
/// </summary>
private object _libraryItemsCacheSyncLock = new object();
/// <summary>
/// The _library items cache initialized
/// </summary>
private bool _libraryItemsCacheInitialized;
/// <summary>
/// Gets the library items cache.
/// </summary>
/// <value>The library items cache.</value>
private ConcurrentDictionary<Guid, BaseItem> LibraryItemsCache
{
get
{
LazyInitializer.EnsureInitialized(ref _libraryItemsCache, ref _libraryItemsCacheInitialized, ref _libraryItemsCacheSyncLock, CreateLibraryItemsCache);
return _libraryItemsCache;
}
}
/// <summary>
/// The _user root folders
/// </summary>
private readonly ConcurrentDictionary<string, UserRootFolder> _userRootFolders =
2013-04-05 04:13:41 +00:00
new ConcurrentDictionary<string, UserRootFolder>();
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>
public LibraryManager(ILogger logger, ITaskManager taskManager, IUserManager userManager, IServerConfigurationManager configurationManager, IUserDataManager userDataRepository, Func<IDirectoryWatchers> directoryWatchersFactory, IFileSystem fileSystem)
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;
_directoryWatchersFactory = directoryWatchersFactory;
_fileSystem = fileSystem;
ByReferenceItems = 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="prescanTasks">The prescan tasks.</param>
/// <param name="postscanTasks">The postscan tasks.</param>
/// <param name="peoplePrescanTasks">The people prescan tasks.</param>
/// <param name="savers">The savers.</param>
public void AddParts(IEnumerable<IResolverIgnoreRule> rules,
IEnumerable<IVirtualFolderCreator> pluginFolders,
IEnumerable<IItemResolver> resolvers,
IEnumerable<IIntroProvider> introProviders,
IEnumerable<IBaseItemComparer> itemComparers,
IEnumerable<ILibraryPrescanTask> prescanTasks,
IEnumerable<ILibraryPostScanTask> postscanTasks,
IEnumerable<IPeoplePrescanTask> peoplePrescanTasks,
IEnumerable<IMetadataSaver> savers)
{
EntityResolutionIgnoreRules = rules.ToArray();
PluginFolderCreators = pluginFolders.ToArray();
2013-03-02 01:09:05 +00:00
EntityResolvers = resolvers.OrderBy(i => i.Priority).ToArray();
IntroProviders = introProviders;
Comparers = itemComparers.ToArray();
PrescanTasks = prescanTasks;
PostscanTasks = postscanTasks;
PeoplePrescanTasks = peoplePrescanTasks;
_savers = savers;
}
/// <summary>
/// The _root folder
/// </summary>
private AggregateFolder _rootFolder;
/// <summary>
/// The _root folder sync lock
/// </summary>
private object _rootFolderSyncLock = new object();
/// <summary>
/// The _root folder initialized
/// </summary>
private bool _rootFolderInitialized;
/// <summary>
/// Gets the root folder.
/// </summary>
/// <value>The root folder.</value>
public AggregateFolder RootFolder
{
get
{
LazyInitializer.EnsureInitialized(ref _rootFolder, ref _rootFolderInitialized, ref _rootFolderSyncLock, CreateRootFolder);
return _rootFolder;
}
private set
{
_rootFolder = value;
if (value == null)
{
_rootFolderInitialized = false;
}
}
}
/// <summary>
/// The _items by name path
/// </summary>
2013-04-23 19:17:21 +00:00
private string _itemsByNamePath;
/// <summary>
/// The _season zero display name
/// </summary>
private string _seasonZeroDisplayName;
/// <summary>
/// Records the configuration values.
/// </summary>
/// <param name="configuration">The configuration.</param>
private void RecordConfigurationValues(ServerConfiguration configuration)
{
_seasonZeroDisplayName = ConfigurationManager.Configuration.SeasonZeroDisplayName;
2013-04-23 19:17:21 +00:00
_itemsByNamePath = ConfigurationManager.ApplicationPaths.ItemsByNamePath;
}
/// <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 ibnPathChanged = !string.Equals(_itemsByNamePath, ConfigurationManager.ApplicationPaths.ItemsByNamePath, StringComparison.CurrentCulture);
2013-04-23 19:17:21 +00:00
if (ibnPathChanged)
{
_itemsByName.Clear();
}
var newSeasonZeroName = ConfigurationManager.Configuration.SeasonZeroDisplayName;
var seasonZeroNameChanged = !string.Equals(_seasonZeroDisplayName, newSeasonZeroName, StringComparison.CurrentCulture);
RecordConfigurationValues(config);
Task.Run(async () =>
{
if (seasonZeroNameChanged)
{
await UpdateSeasonZeroNames(newSeasonZeroName, CancellationToken.None).ConfigureAwait(false);
}
// Any number of configuration settings could change the way the library is refreshed, so do that now
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
});
2013-02-21 01:33:05 +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)
{
var seasons = RootFolder.RecursiveChildren
.OfType<Season>()
.Where(i => i.IndexNumber.HasValue && i.IndexNumber.Value == 0 && !string.Equals(i.Name, newName, StringComparison.CurrentCulture))
.ToList();
foreach (var season in seasons)
{
season.Name = newName;
try
{
await UpdateItem(season, ItemUpdateType.MetadataDownload, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.ErrorException("Error saving {0}", ex, season.Path);
}
}
}
/// <summary>
/// Creates the library items cache.
/// </summary>
/// <returns>ConcurrentDictionary{GuidBaseItem}.</returns>
private ConcurrentDictionary<Guid, BaseItem> CreateLibraryItemsCache()
{
2013-09-27 12:24:28 +00:00
var items = RootFolder.GetRecursiveChildren();
items.Add(RootFolder);
2013-09-19 00:37:01 +00:00
// Need to use Distinct because there could be multiple instances with the same id
2013-04-02 14:16:13 +00:00
// due to sharing the default library
var userRootFolders = _userManager.Users.Select(i => i.RootFolder)
.Distinct()
2013-04-02 14:16:13 +00:00
.ToList();
2013-09-27 12:24:28 +00:00
foreach (var folder in userRootFolders)
{
items.Add(folder);
}
2013-04-02 14:16:13 +00:00
// Get all user collection folders
// Skip BasePluginFolders because we already got them from RootFolder.RecursiveChildren
2013-08-08 20:18:05 +00:00
var userFolders = userRootFolders.SelectMany(i => i.Children)
2013-04-02 14:16:13 +00:00
.Where(i => !(i is BasePluginFolder))
.ToList();
2013-09-27 12:24:28 +00:00
foreach (var folder in userFolders)
{
items.Add(folder);
}
2013-09-19 00:37:01 +00:00
var dictionary = new ConcurrentDictionary<Guid, BaseItem>();
2013-08-08 20:18:05 +00:00
2013-09-19 00:37:01 +00:00
foreach (var item in items)
{
dictionary[item.Id] = item;
}
return dictionary;
}
/// <summary>
/// Updates the item in library cache.
/// </summary>
/// <param name="item">The item.</param>
private void UpdateItemInLibraryCache(BaseItem item)
{
2013-11-21 20:48:26 +00:00
if (item is IItemByName)
2013-06-27 19:29:58 +00:00
{
2013-11-21 20:48:26 +00:00
var hasDualAccess = item as IHasDualAccess;
if (hasDualAccess != null)
{
if (hasDualAccess.IsAccessedByName)
{
return;
}
}
else
{
return;
}
2013-06-27 19:29:58 +00:00
}
2013-11-21 20:48:26 +00:00
LibraryItemsCache.AddOrUpdate(item.Id, item, delegate { return item; });
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Resolves the item.
/// </summary>
/// <param name="args">The args.</param>
/// <returns>BaseItem.</returns>
public BaseItem ResolveItem(ItemResolveArgs args)
{
var item = EntityResolvers.Select(r =>
{
try
{
return r.ResolvePath(args);
}
catch (Exception ex)
{
_logger.ErrorException("Error in {0} resolving {1}", ex, r.GetType().Name, args.Path);
return null;
}
}).FirstOrDefault(i => i != null);
if (item != null)
{
ResolverHelper.SetInitialItemValues(item, args, _fileSystem);
// Now handle the issue with posibly having the same item referenced from multiple physical
// places within the library. Be sure we always end up with just one instance.
if (item is IByReferenceItem)
{
item = GetOrAddByReferenceItem(item);
}
}
return item;
2013-02-21 01:33:05 +00:00
}
/// <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;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Resolves a path into a BaseItem
/// </summary>
/// <param name="fileInfo">The file info.</param>
/// <param name="parent">The parent.</param>
2013-02-21 01:33:05 +00:00
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public BaseItem ResolvePath(FileSystemInfo fileInfo, Folder parent = 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
}
var args = new ItemResolveArgs(ConfigurationManager.ApplicationPaths, this)
2013-02-21 01:33:05 +00:00
{
Parent = parent,
Path = fileInfo.FullName,
FileInfo = fileInfo
2013-02-21 01:33:05 +00:00
};
// Return null if ignore rules deem that we should do so
if (EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(args)))
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
args.FileSystemDictionary = FileData.GetFilteredFileSystemEntries(args.Path, _fileSystem, _logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || args.IsVf);
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)
{
var paths = args.FileSystemDictionary.Keys.ToList();
2013-05-27 01:24:56 +00:00
foreach (var subPath in paths
.Where(subPath => !subPath.EndsWith(":\\", StringComparison.OrdinalIgnoreCase) && paths.Any(i => subPath.StartsWith(i.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))))
2013-05-24 17:48:48 +00:00
{
2013-05-27 01:24:56 +00:00
_logger.Info("Ignoring duplicate path: {0}", subPath);
2013-05-24 17:48:48 +00:00
args.FileSystemDictionary.Remove(subPath);
}
}
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;
}
return ResolveItem(args);
}
/// <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");
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Resolves a set of files into a list of BaseItem
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="files">The files.</param>
/// <param name="parent">The parent.</param>
/// <returns>List{``0}.</returns>
public List<T> ResolvePaths<T>(IEnumerable<FileSystemInfo> files, Folder parent)
2013-02-21 01:33:05 +00:00
where T : BaseItem
{
var list = new List<T>();
Parallel.ForEach(files, f =>
{
try
{
var item = ResolvePath(f, parent) as T;
if (item != null)
{
lock (list)
2013-02-21 01:33:05 +00:00
{
list.Add(item);
2013-02-21 01:33:05 +00:00
}
}
}
catch (Exception ex)
{
_logger.ErrorException("Error resolving path {0}", ex, f.FullName);
2013-02-21 01:33:05 +00:00
}
});
return list;
}
/// <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
if (!Directory.Exists(rootFolderPath))
{
Directory.CreateDirectory(rootFolderPath);
}
2013-06-26 16:08:16 +00:00
var rootFolder = RetrieveItem(rootFolderPath.GetMBId(typeof(AggregateFolder))) as AggregateFolder ?? (AggregateFolder)ResolvePath(new DirectoryInfo(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();
if (folder.Id == Guid.Empty)
{
2013-08-10 01:16:31 +00:00
folder.Id = (folder.Path ?? folder.GetType().Name).GetMBId(folder.GetType());
}
rootFolder.AddVirtualChild(folder);
2013-02-21 01:33:05 +00:00
}
return rootFolder;
}
2013-04-05 04:13:41 +00:00
/// <summary>
/// Gets the user root folder.
/// </summary>
/// <param name="userRootPath">The user root path.</param>
/// <returns>UserRootFolder.</returns>
public UserRootFolder GetUserRootFolder(string userRootPath)
{
2013-06-26 16:08:16 +00:00
return _userRootFolders.GetOrAdd(userRootPath, key => RetrieveItem(userRootPath.GetMBId(typeof(UserRootFolder))) as UserRootFolder ??
2013-06-17 20:35:43 +00:00
(UserRootFolder)ResolvePath(new DirectoryInfo(userRootPath)));
2013-04-05 04:13:41 +00:00
}
2013-04-22 04:38:03 +00:00
2013-09-11 17:54:59 +00:00
public Person GetPersonSync(string name)
{
return GetItemByName<Person>(ConfigurationManager.ApplicationPaths.PeoplePath, name);
}
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)
{
throw new ArgumentOutOfRangeException();
}
return GetItemByName<Year>(ConfigurationManager.ApplicationPaths.YearPath, value.ToString(UsCulture));
2013-02-21 01:33:05 +00:00
}
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>(ConfigurationManager.ApplicationPaths.ArtistsPath, name);
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// The images by name item cache
/// </summary>
2013-04-23 19:17:21 +00:00
private readonly ConcurrentDictionary<string, BaseItem> _itemsByName = new ConcurrentDictionary<string, BaseItem>(StringComparer.OrdinalIgnoreCase);
2013-02-21 01:33:05 +00:00
2013-09-11 17:54:59 +00:00
private T GetItemByName<T>(string path, string name)
where T : BaseItem, new()
{
if (string.IsNullOrEmpty(path))
{
2013-11-21 20:48:26 +00:00
throw new ArgumentNullException("path");
2013-09-11 17:54:59 +00:00
}
if (string.IsNullOrEmpty(name))
{
2013-11-21 20:48:26 +00:00
throw new ArgumentNullException("name");
2013-09-11 17:54:59 +00:00
}
var validFilename = _fileSystem.GetValidFilename(name).Trim();
2013-09-11 17:54:59 +00:00
string subFolderPrefix = null;
if (typeof(T) == typeof(Person) && ConfigurationManager.Configuration.EnablePeoplePrefixSubFolders)
{
subFolderPrefix = validFilename.Substring(0, 1);
}
var key = string.IsNullOrEmpty(subFolderPrefix) ?
Path.Combine(path, validFilename) :
Path.Combine(path, subFolderPrefix, validFilename);
2013-09-11 17:54:59 +00:00
BaseItem obj;
if (!_itemsByName.TryGetValue(key, out obj))
{
var tuple = CreateItemByName<T>(key, name);
obj = tuple.Item2;
_itemsByName.AddOrUpdate(key, obj, (keyName, oldValue) => obj);
}
return obj as T;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Creates an IBN item based on a given path
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path">The path.</param>
/// <param name="name">The name.</param>
/// <returns>Task{``0}.</returns>
/// <exception cref="System.IO.IOException">Path not created: + path</exception>
2013-09-11 17:54:59 +00:00
private Tuple<bool, T> CreateItemByName<T>(string path, string name)
2013-02-21 01:33:05 +00:00
where T : BaseItem, new()
{
2013-11-21 20:48:26 +00:00
var isArtist = typeof(T) == typeof(MusicArtist);
if (isArtist)
{
var existing = RootFolder.RecursiveChildren
.OfType<T>()
.FirstOrDefault(i => string.Equals(i.Name, name, StringComparison.OrdinalIgnoreCase));
if (existing != null)
{
return new Tuple<bool, T>(false, existing);
}
}
var fileInfo = new DirectoryInfo(path);
2013-02-21 01:33:05 +00:00
var isNew = false;
if (!fileInfo.Exists)
2013-02-21 01:33:05 +00:00
{
Directory.CreateDirectory(path);
fileInfo = new DirectoryInfo(path);
2013-02-21 01:33:05 +00:00
if (!fileInfo.Exists)
2013-02-21 01:33:05 +00:00
{
throw new IOException("Path not created: " + path);
}
isNew = true;
}
2013-06-17 20:35:43 +00:00
var type = typeof(T);
2013-02-21 01:33:05 +00:00
2013-06-17 20:35:43 +00:00
var id = path.GetMBId(type);
2013-06-26 16:08:16 +00:00
var item = RetrieveItem(id) as T;
2013-02-21 01:33:05 +00:00
if (item == null)
{
item = new T
{
Name = name,
Id = id,
DateCreated = _fileSystem.GetCreationTimeUtc(fileInfo),
DateModified = _fileSystem.GetLastWriteTimeUtc(fileInfo),
2013-02-21 01:33:05 +00:00
Path = path
};
isNew = true;
}
2013-11-21 20:48:26 +00:00
if (isArtist)
{
(item as MusicArtist).IsAccessedByName = true;
}
2013-02-21 01:33:05 +00:00
// Set this now so we don't cause additional file system access during provider executions
item.ResetResolveArgs(fileInfo);
2013-09-11 17:54:59 +00:00
return new Tuple<bool, T>(isNew, item);
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
{
return new PeopleValidator(this, PeoplePrescanTasks, _logger).ValidatePeople(cancellationToken, progress);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Validates the artists.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task.</returns>
public Task ValidateArtists(CancellationToken cancellationToken, IProgress<double> progress)
2013-04-22 04:38:03 +00:00
{
return new ArtistsValidator(this, _userManager, _logger).Run(progress, cancellationToken);
}
2013-04-22 04:38:03 +00:00
/// <summary>
/// Validates the music genres.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task.</returns>
public Task ValidateMusicGenres(CancellationToken cancellationToken, IProgress<double> progress)
{
return new MusicGenresValidator(this, _userManager, _logger).Run(progress, cancellationToken);
}
2013-04-22 04:38:03 +00:00
/// <summary>
/// Validates the game genres.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task.</returns>
public Task ValidateGameGenres(CancellationToken cancellationToken, IProgress<double> progress)
{
return new GameGenresValidator(this, _userManager, _logger).Run(progress, cancellationToken);
}
2013-04-22 04:38:03 +00:00
/// <summary>
/// Validates the studios.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task.</returns>
public Task ValidateStudios(CancellationToken cancellationToken, IProgress<double> progress)
{
return new StudiosValidator(this, _userManager, _logger).Run(progress, cancellationToken);
}
2013-04-22 04:38:03 +00:00
/// <summary>
/// Validates the genres.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task.</returns>
public Task ValidateGenres(CancellationToken cancellationToken, IProgress<double> progress)
{
return new GenresValidator(this, _userManager, _logger).Run(progress, cancellationToken);
2013-04-22 04:38:03 +00:00
}
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>
/// 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)
{
_directoryWatchersFactory().Stop();
try
{
await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
}
finally
{
_directoryWatchersFactory().Start();
}
}
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
await RootFolder.ValidateChildren(new Progress<double>(), cancellationToken, recursive: false);
2013-02-21 01:33:05 +00:00
progress.Report(1);
2013-04-05 04:13:41 +00:00
foreach (var folder in _userManager.Users.Select(u => u.RootFolder).Distinct())
{
await ValidateCollectionFolders(folder, cancellationToken).ConfigureAwait(false);
}
2013-02-21 01:33:05 +00:00
progress.Report(2);
2013-09-25 22:41:25 +00:00
var innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(pct => progress.Report(2 + pct * .13));
// Run prescan tasks
2013-09-25 22:41:25 +00:00
await RunPrescanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
progress.Report(15);
2013-09-25 22:41:25 +00:00
innerProgress = new ActionableProgress<double>();
2013-04-22 04:38:03 +00:00
innerProgress.RegisterAction(pct => progress.Report(15 + pct * .6));
2013-04-22 04:38:03 +00:00
2013-02-21 01:33:05 +00:00
// Now validate the entire media library
2013-04-22 04:38:03 +00:00
await RootFolder.ValidateChildren(innerProgress, cancellationToken, recursive: true).ConfigureAwait(false);
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 prescan tasks.
/// </summary>
/// <param name="progress">The progress.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task RunPrescanTasks(IProgress<double> progress, CancellationToken cancellationToken)
{
2013-09-25 22:41:25 +00:00
var tasks = PrescanTasks.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 =>
{
2013-09-25 22:41:25 +00:00
double innerPercent = (currentNumComplete * 100) + pct;
innerPercent /= numTasks;
progress.Report(innerPercent);
});
try
{
2013-09-25 22:41:25 +00:00
await task.Run(innerProgress, cancellationToken);
}
2013-09-18 02:43:34 +00:00
catch (OperationCanceledException)
{
2013-09-25 22:41:25 +00:00
_logger.Info("Pre-scan task cancelled: {0}", task.GetType().Name);
2013-09-18 02:43:34 +00:00
}
catch (Exception ex)
{
2013-09-25 22:41:25 +00:00
_logger.ErrorException("Error running pre-scan task", ex);
}
2013-09-25 22:41:25 +00:00
numComplete++;
double percent = numComplete;
percent /= numTasks;
progress.Report(percent * 100);
}
progress.Report(100);
}
/// <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 =>
{
2013-09-25 22:41:25 +00:00
double innerPercent = (currentNumComplete * 100) + pct;
innerPercent /= numTasks;
progress.Report(innerPercent);
});
try
{
2013-09-25 22:41:25 +00:00
await task.Run(innerProgress, cancellationToken);
}
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-04-05 04:13:41 +00:00
/// <summary>
/// Validates only the collection folders for a User and goes no further
/// </summary>
/// <param name="userRootFolder">The user root folder.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task ValidateCollectionFolders(UserRootFolder userRootFolder, CancellationToken cancellationToken)
{
_logger.Info("Validating collection folders within {0}", userRootFolder.Path);
await userRootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
await userRootFolder.ValidateChildren(new Progress<double>(), cancellationToken, recursive: false).ConfigureAwait(false);
2013-04-05 04:13:41 +00:00
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the default view.
/// </summary>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
public IEnumerable<VirtualFolderInfo> GetDefaultVirtualFolders()
{
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="user">The user.</param>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
public IEnumerable<VirtualFolderInfo> GetVirtualFolders(User user)
{
return GetView(user.RootFolderPath);
}
/// <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 19:56:40 +00:00
2013-10-01 20:20:48 +00:00
Locations = Directory.EnumerateFiles(dir, "*.mblink", SearchOption.TopDirectoryOnly)
.Select(_fileSystem.ResolveShortcut)
2013-07-12 19:56:40 +00:00
.OrderBy(i => i)
.ToList(),
CollectionType = GetCollectionType(dir)
2013-02-21 01:33:05 +00:00
});
}
2013-07-12 19:56:40 +00:00
private string GetCollectionType(string path)
{
return new DirectoryInfo(path).EnumerateFiles("*.collection", SearchOption.TopDirectoryOnly)
.Select(i => Path.GetFileNameWithoutExtension(i.FullName))
.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;
}
2013-06-27 13:31:49 +00:00
return RetrieveItem(id);
}
/// <summary>
/// Gets the intros.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{System.String}.</returns>
public IEnumerable<Video> GetIntros(BaseItem item, User user)
{
return IntroProviders.SelectMany(i => i.GetIntros(item, user))
.Select(ResolveIntro)
.Where(i => i != null);
}
/// <summary>
/// Gets all intro files.
/// </summary>
/// <returns>IEnumerable{System.String}.</returns>
public IEnumerable<string> GetAllIntroFiles()
{
return IntroProviders.SelectMany(i => i.GetAllIntroFiles());
}
/// <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)
{
dbItem.ResetResolveArgs(video.ResolveArgs);
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-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);
}
UpdateCollectionFolders();
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)
{
if (item.LocationType == LocationType.FileSystem)
{
await SaveMetadata(item, updateReason).ConfigureAwait(false);
}
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)
{
UpdateCollectionFolders();
if (ItemRemoved != null)
{
try
{
ItemRemoved(this, new ItemChangeEventArgs { Item = item });
}
catch (Exception ex)
{
_logger.ErrorException("Error in ItemRemoved event handler", ex);
}
}
}
private void UpdateCollectionFolders()
{
foreach (var folder in _userManager.Users.SelectMany(i => i.RootFolder.Children).OfType<CollectionFolder>().ToList())
{
folder.ResetDynamicChildren();
}
}
/// <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-09-25 18:05:21 +00:00
var item = ItemRepository.RetrieveItem(id);
2013-11-21 20:48:26 +00:00
if (item != null && item.IsFolder)
2013-09-25 18:05:21 +00:00
{
2013-11-21 20:48:26 +00:00
LoadSavedChildren(item as Folder);
2013-09-25 18:05:21 +00:00
}
return item;
}
2013-11-21 20:48:26 +00:00
private void LoadSavedChildren(Folder item)
{
item.LoadSavedChildren();
}
private readonly ConcurrentDictionary<string, SemaphoreSlim> _fileLocks = new ConcurrentDictionary<string, SemaphoreSlim>();
/// <summary>
/// Saves the metadata.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="updateType">Type of the update.</param>
/// <returns>Task.</returns>
2013-11-13 16:45:41 +00:00
public async Task SaveMetadata(BaseItem item, ItemUpdateType updateType)
{
2013-11-13 16:45:41 +00:00
var locationType = item.LocationType;
if (locationType == LocationType.Remote || locationType == LocationType.Virtual)
{
throw new ArgumentException("Only file-system based items can save metadata.");
}
foreach (var saver in _savers.Where(i => i.IsEnabledFor(item, updateType)))
{
var path = saver.GetSavePath(item);
var semaphore = _fileLocks.GetOrAdd(path, key => new SemaphoreSlim(1, 1));
var directoryWatchers = _directoryWatchersFactory();
await semaphore.WaitAsync().ConfigureAwait(false);
try
{
directoryWatchers.TemporarilyIgnore(path);
saver.Save(item, CancellationToken.None);
}
catch (Exception ex)
{
_logger.ErrorException("Error in metadata saver", ex);
}
finally
{
directoryWatchers.RemoveTempIgnore(path);
semaphore.Release();
}
}
}
2013-07-12 19:56:40 +00:00
/// <summary>
/// Finds the type of the collection.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>System.String.</returns>
public string FindCollectionType(BaseItem item)
{
while (!(item.Parent is AggregateFolder) && item.Parent != null)
{
item = item.Parent;
}
if (item == null)
{
return null;
}
var collectionTypes = _userManager.Users
.Select(i => i.RootFolder)
.Distinct()
.SelectMany(i => i.Children)
.OfType<CollectionFolder>()
.Where(i =>
{
var locationType = i.LocationType;
if (locationType == LocationType.Remote || locationType == LocationType.Virtual)
{
return false;
}
if (string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase))
{
return true;
}
2013-07-12 19:56:40 +00:00
try
{
2013-11-13 16:45:41 +00:00
return i.ResolveArgs.PhysicalLocations.Contains(item.Path);
2013-07-12 19:56:40 +00:00
}
catch (IOException ex)
{
_logger.ErrorException("Error getting resolve args for {0}", ex, i.Path);
return false;
}
})
.Select(i => i.CollectionType)
.Where(i => !string.IsNullOrEmpty(i))
2013-08-03 13:24:39 +00:00
.Distinct()
.ToList();
2013-07-12 19:56:40 +00:00
2013-08-03 13:24:39 +00:00
return collectionTypes.Count == 1 ? collectionTypes[0] : null;
2013-07-12 19:56:40 +00:00
}
2013-11-21 20:48:26 +00:00
public IEnumerable<string> GetAllArtists()
{
return GetAllArtists(RootFolder.RecursiveChildren);
}
public IEnumerable<string> GetAllArtists(IEnumerable<BaseItem> items)
{
return items
.OfType<Audio>()
.SelectMany(i =>
{
var list = new List<string>();
if (!string.IsNullOrEmpty(i.AlbumArtist))
{
list.Add(i.AlbumArtist);
}
list.AddRange(i.Artists);
return list;
})
.Distinct(StringComparer.OrdinalIgnoreCase);
}
2013-02-21 01:33:05 +00:00
}
}