jellyfin/MediaBrowser.Controller/Entities/AggregateFolder.cs

217 lines
6.9 KiB
C#
Raw Normal View History

using MediaBrowser.Controller.IO;
using MediaBrowser.Controller.Library;
using System;
2013-02-21 01:33:05 +00:00
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
2016-08-16 00:22:59 +00:00
using System.Threading;
using System.Threading.Tasks;
2015-10-04 04:23:11 +00:00
using CommonIO;
2014-02-08 22:38:02 +00:00
using MediaBrowser.Controller.Providers;
2013-02-21 01:33:05 +00:00
namespace MediaBrowser.Controller.Entities
{
/// <summary>
/// Specialized folder that can have items added to it's children by external entities.
/// Used for our RootFolder so plug-ins can add items.
/// </summary>
public class AggregateFolder : Folder
{
public AggregateFolder()
{
PhysicalLocationsList = new List<string>();
}
/// <summary>
/// We don't support manual shortcuts
/// </summary>
protected override bool SupportsShortcutChildren
{
get
{
return false;
}
}
2015-02-06 05:39:07 +00:00
public override bool CanDelete()
{
return false;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// The _virtual children
/// </summary>
private readonly ConcurrentBag<BaseItem> _virtualChildren = new ConcurrentBag<BaseItem>();
/// <summary>
/// Gets the virtual children.
/// </summary>
/// <value>The virtual children.</value>
public ConcurrentBag<BaseItem> VirtualChildren
{
get { return _virtualChildren; }
}
[IgnoreDataMember]
public override IEnumerable<string> PhysicalLocations
{
get
{
return PhysicalLocationsList;
}
}
public List<string> PhysicalLocationsList { get; set; }
2015-10-04 03:38:46 +00:00
protected override IEnumerable<FileSystemMetadata> GetFileSystemChildren(IDirectoryService directoryService)
{
return CreateResolveArgs(directoryService, true).FileSystemChildren;
}
2016-08-13 19:53:20 +00:00
private List<Guid> _childrenIds = null;
private readonly object _childIdsLock = new object();
protected override IEnumerable<BaseItem> LoadChildren()
{
lock (_childIdsLock)
{
if (_childrenIds == null || _childrenIds.Count == 0)
{
var list = base.LoadChildren().ToList();
_childrenIds = list.Select(i => i.Id).ToList();
return list;
}
return _childrenIds.Select(LibraryManager.GetItemById).Where(i => i != null).ToList();
}
}
2016-08-16 00:22:59 +00:00
private void ClearCache()
2016-08-13 19:53:20 +00:00
{
lock (_childIdsLock)
{
_childrenIds = null;
}
}
private bool _requiresRefresh;
public override bool RequiresRefresh()
{
var changed = base.RequiresRefresh() || _requiresRefresh;
if (!changed)
{
var locations = PhysicalLocations.ToList();
2016-08-06 04:48:00 +00:00
var newLocations = CreateResolveArgs(new DirectoryService(Logger, FileSystem), false).PhysicalLocations.ToList();
if (!locations.SequenceEqual(newLocations))
{
changed = true;
}
}
return changed;
}
public override bool BeforeMetadataRefresh()
{
2016-08-16 00:22:59 +00:00
ClearCache();
2016-08-13 19:53:20 +00:00
var changed = base.BeforeMetadataRefresh() || _requiresRefresh;
_requiresRefresh = false;
return changed;
}
private ItemResolveArgs CreateResolveArgs(IDirectoryService directoryService, bool setPhysicalLocations)
{
2016-08-16 00:22:59 +00:00
ClearCache();
2016-08-13 19:53:20 +00:00
var path = ContainingFolderPath;
2016-08-13 19:53:20 +00:00
var args = new ItemResolveArgs(ConfigurationManager.ApplicationPaths, directoryService)
{
2015-10-04 03:38:46 +00:00
FileInfo = FileSystem.GetDirectoryInfo(path),
Path = path,
Parent = Parent
};
// Gather child folder and files
if (args.IsDirectory)
{
var isPhysicalRoot = args.IsPhysicalRoot;
// When resolving the root, we need it's grandchildren (children of user views)
var flattenFolderDepth = isPhysicalRoot ? 2 : 0;
2014-02-11 21:41:01 +00:00
var fileSystemDictionary = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, FileSystem, Logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || args.IsVf);
// 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:49:21 +00:00
var paths = LibraryManager.NormalizeRootPathList(fileSystemDictionary.Values);
2015-11-13 20:49:21 +00:00
fileSystemDictionary = paths.ToDictionary(i => i.FullName);
}
args.FileSystemDictionary = fileSystemDictionary;
}
2016-05-19 19:57:30 +00:00
_requiresRefresh = _requiresRefresh || !args.PhysicalLocations.SequenceEqual(PhysicalLocations);
if (setPhysicalLocations)
{
PhysicalLocationsList = args.PhysicalLocations.ToList();
}
return args;
}
2016-08-13 19:53:20 +00:00
2016-08-16 02:40:29 +00:00
protected override IEnumerable<BaseItem> GetNonCachedChildren(IDirectoryService directoryService)
{
return base.GetNonCachedChildren(directoryService).Concat(_virtualChildren);
}
2016-08-16 00:22:59 +00:00
protected override async Task ValidateChildrenInternal(IProgress<double> progress, CancellationToken cancellationToken, bool recursive, bool refreshChildMetadata, MetadataRefreshOptions refreshOptions, IDirectoryService directoryService)
{
ClearCache();
await base.ValidateChildrenInternal(progress, cancellationToken, recursive, refreshChildMetadata, refreshOptions, directoryService)
.ConfigureAwait(false);
ClearCache();
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Adds the virtual child.
/// </summary>
/// <param name="child">The child.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void AddVirtualChild(BaseItem child)
{
if (child == null)
{
throw new ArgumentNullException();
}
_virtualChildren.Add(child);
}
/// <summary>
/// Finds the virtual child.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentNullException">id</exception>
public BaseItem FindVirtualChild(Guid id)
{
if (id == Guid.Empty)
{
throw new ArgumentNullException("id");
}
return _virtualChildren.FirstOrDefault(i => i.Id == id);
}
}
}