jellyfin/MediaBrowser.Controller/Entities/Folder.cs

1356 lines
50 KiB
C#
Raw Normal View History

2013-07-12 19:56:40 +00:00
using MediaBrowser.Common.Extensions;
using MediaBrowser.Common.Progress;
2013-07-16 17:18:32 +00:00
using MediaBrowser.Controller.Entities.TV;
2013-07-05 13:47:10 +00:00
using MediaBrowser.Controller.IO;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Localization;
using MediaBrowser.Controller.Resolvers;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
2013-10-04 15:22:03 +00:00
using MoreLinq;
2013-02-21 01:33:05 +00:00
using System;
2013-07-12 19:56:40 +00:00
using System.Collections;
2013-02-21 01:33:05 +00:00
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Controller.Entities
{
/// <summary>
/// Class Folder
/// </summary>
public class Folder : BaseItem
{
2013-10-06 01:04:41 +00:00
public static IUserManager UserManager { get; set; }
2013-07-05 13:47:10 +00:00
public Folder()
{
LinkedChildren = new List<LinkedChild>();
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets a value indicating whether this instance is folder.
/// </summary>
/// <value><c>true</c> if this instance is folder; otherwise, <c>false</c>.</value>
[IgnoreDataMember]
public override bool IsFolder
{
get
{
return true;
}
}
/// <summary>
/// Gets or sets a value indicating whether this instance is physical root.
/// </summary>
/// <value><c>true</c> if this instance is physical root; otherwise, <c>false</c>.</value>
public bool IsPhysicalRoot { get; set; }
/// <summary>
/// Gets or sets a value indicating whether this instance is root.
/// </summary>
/// <value><c>true</c> if this instance is root; otherwise, <c>false</c>.</value>
public bool IsRoot { get; set; }
/// <summary>
/// Gets a value indicating whether this instance is virtual folder.
/// </summary>
/// <value><c>true</c> if this instance is virtual folder; otherwise, <c>false</c>.</value>
[IgnoreDataMember]
public virtual bool IsVirtualFolder
{
get
{
return false;
}
}
public virtual List<LinkedChild> LinkedChildren { get; set; }
2013-07-05 13:47:10 +00:00
protected virtual bool SupportsShortcutChildren
2013-07-05 13:47:10 +00:00
{
get { return true; }
2013-07-05 13:47:10 +00:00
}
/// <summary>
/// Adds the child.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
/// <exception cref="System.InvalidOperationException">Unable to add + item.Name</exception>
public async Task AddChild(BaseItem item, CancellationToken cancellationToken)
{
2013-05-12 13:13:57 +00:00
item.Parent = this;
if (item.Id == Guid.Empty)
{
item.Id = item.Path.GetMBId(item.GetType());
2013-05-12 13:13:57 +00:00
}
2013-10-06 01:04:41 +00:00
if (_children.Any(i => i.Id == item.Id))
{
throw new ArgumentException(string.Format("A child with the Id {0} already exists.", item.Id));
}
2013-05-12 13:13:57 +00:00
if (item.DateCreated == DateTime.MinValue)
{
2013-07-17 15:19:28 +00:00
item.DateCreated = DateTime.UtcNow;
2013-05-12 13:13:57 +00:00
}
if (item.DateModified == DateTime.MinValue)
{
2013-07-17 15:19:28 +00:00
item.DateModified = DateTime.UtcNow;
2013-05-12 13:13:57 +00:00
}
2013-09-21 15:06:21 +00:00
AddChildInternal(item);
await LibraryManager.CreateItem(item, cancellationToken).ConfigureAwait(false);
await ItemRepository.SaveChildren(Id, _children.Select(i => i.Id).ToList(), cancellationToken).ConfigureAwait(false);
}
protected void AddChildrenInternal(IEnumerable<BaseItem> children)
{
2013-09-25 18:58:03 +00:00
lock (_childrenSyncLock)
{
2013-09-25 18:05:21 +00:00
var newChildren = _children.ToList();
newChildren.AddRange(children);
_children = newChildren;
}
}
2013-09-21 15:06:21 +00:00
protected void AddChildInternal(BaseItem child)
{
2013-09-25 18:58:03 +00:00
lock (_childrenSyncLock)
2013-09-25 18:05:21 +00:00
{
var newChildren = _children.ToList();
newChildren.Add(child);
_children = newChildren;
}
2013-09-21 15:06:21 +00:00
}
protected void RemoveChildrenInternal(IEnumerable<BaseItem> children)
{
2013-09-25 18:58:03 +00:00
lock (_childrenSyncLock)
{
2013-09-25 18:05:21 +00:00
_children = _children.Except(children).ToList();
}
}
protected void ClearChildrenInternal()
{
2013-09-25 18:58:03 +00:00
lock (_childrenSyncLock)
{
2013-09-25 18:05:21 +00:00
_children = new List<BaseItem>();
}
}
2013-05-23 15:07:25 +00:00
/// <summary>
/// Never want folders to be blocked by "BlockNotRated"
/// </summary>
2013-08-03 13:24:23 +00:00
[IgnoreDataMember]
public override string OfficialRatingForComparison
2013-05-23 15:07:25 +00:00
{
get
{
2013-07-16 17:18:32 +00:00
if (this is Series)
{
2013-08-03 13:24:23 +00:00
return base.OfficialRatingForComparison;
2013-07-16 17:18:32 +00:00
}
2013-08-03 13:24:23 +00:00
return !string.IsNullOrEmpty(base.OfficialRatingForComparison) ? base.OfficialRatingForComparison : "None";
2013-05-23 15:07:25 +00:00
}
}
/// <summary>
/// Removes the child.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
/// <exception cref="System.InvalidOperationException">Unable to remove + item.Name</exception>
public Task RemoveChild(BaseItem item, CancellationToken cancellationToken)
{
RemoveChildrenInternal(new[] { item });
item.Parent = null;
2013-06-20 16:44:24 +00:00
LibraryManager.ReportItemRemoved(item);
return ItemRepository.SaveChildren(Id, ActualChildren.Select(i => i.Id).ToList(), cancellationToken);
}
2013-09-23 18:28:07 +00:00
/// <summary>
/// Clears the children.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public Task ClearChildren(CancellationToken cancellationToken)
{
var items = ActualChildren.ToList();
ClearChildrenInternal();
foreach (var item in items)
{
LibraryManager.ReportItemRemoved(item);
}
return ItemRepository.SaveChildren(Id, ActualChildren.Select(i => i.Id).ToList(), cancellationToken);
}
2013-02-21 01:33:05 +00:00
#region Indexing
/// <summary>
/// The _index by options
/// </summary>
private Dictionary<string, Func<User, IEnumerable<BaseItem>>> _indexByOptions;
/// <summary>
/// Dictionary of index options - consists of a display value and an indexing function
/// which takes User as a parameter and returns an IEnum of BaseItem
/// </summary>
/// <value>The index by options.</value>
[IgnoreDataMember]
public Dictionary<string, Func<User, IEnumerable<BaseItem>>> IndexByOptions
{
get { return _indexByOptions ?? (_indexByOptions = GetIndexByOptions()); }
}
/// <summary>
/// Returns the valid set of index by options for this folder type.
/// Override or extend to modify.
/// </summary>
/// <returns>Dictionary{System.StringFunc{UserIEnumerable{BaseItem}}}.</returns>
protected virtual Dictionary<string, Func<User, IEnumerable<BaseItem>>> GetIndexByOptions()
{
return new Dictionary<string, Func<User, IEnumerable<BaseItem>>> {
{LocalizedStrings.Instance.GetString("NoneDispPref"), null},
{LocalizedStrings.Instance.GetString("PerformerDispPref"), GetIndexByPerformer},
{LocalizedStrings.Instance.GetString("GenreDispPref"), GetIndexByGenre},
{LocalizedStrings.Instance.GetString("DirectorDispPref"), GetIndexByDirector},
{LocalizedStrings.Instance.GetString("YearDispPref"), GetIndexByYear},
//{LocalizedStrings.Instance.GetString("OfficialRatingDispPref"), null},
2013-02-21 01:33:05 +00:00
{LocalizedStrings.Instance.GetString("StudioDispPref"), GetIndexByStudio}
};
}
/// <summary>
/// Gets the index by actor.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
protected IEnumerable<BaseItem> GetIndexByPerformer(User user)
{
return GetIndexByPerson(user, new List<string> { PersonType.Actor, PersonType.GuestStar }, true, LocalizedStrings.Instance.GetString("PerformerDispPref"));
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets the index by director.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
protected IEnumerable<BaseItem> GetIndexByDirector(User user)
{
return GetIndexByPerson(user, new List<string> { PersonType.Director }, false, LocalizedStrings.Instance.GetString("DirectorDispPref"));
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets the index by person.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="personTypes">The person types we should match on</param>
/// <param name="includeAudio">if set to <c>true</c> [include audio].</param>
2013-02-21 01:33:05 +00:00
/// <param name="indexName">Name of the index.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
private IEnumerable<BaseItem> GetIndexByPerson(User user, List<string> personTypes, bool includeAudio, string indexName)
2013-02-21 01:33:05 +00:00
{
// Even though this implementation means multiple iterations over the target list - it allows us to defer
// the retrieval of the individual children for each index value until they are requested.
2013-02-21 20:26:35 +00:00
using (new Profiler(indexName + " Index Build for " + Name, Logger))
2013-02-21 01:33:05 +00:00
{
// Put this in a local variable to avoid an implicitly captured closure
var currentIndexName = indexName;
var us = this;
var recursiveChildren = GetRecursiveChildren(user).Where(i => i.IncludeInIndex).ToList();
2013-02-21 01:33:05 +00:00
// Get the candidates, but handle audio separately
var candidates = recursiveChildren.Where(i => i.AllPeople != null && !(i is Audio.Audio)).ToList();
var indexFolders = candidates.AsParallel().SelectMany(i => i.AllPeople.Where(p => personTypes.Contains(p.Type))
2013-02-21 01:33:05 +00:00
.Select(a => a.Name))
.Distinct()
.Select(i =>
{
try
{
return LibraryManager.GetPerson(i);
2013-02-21 01:33:05 +00:00
}
catch (IOException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting person {0}", ex, i);
2013-02-21 01:33:05 +00:00
return null;
}
catch (AggregateException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting person {0}", ex, i);
2013-02-21 01:33:05 +00:00
return null;
}
})
.Where(i => i != null)
.Select(a => new IndexFolder(us, a,
candidates.Where(i => i.AllPeople.Any(p => personTypes.Contains(p.Type) && p.Name.Equals(a.Name, StringComparison.OrdinalIgnoreCase))
), currentIndexName)).AsEnumerable();
if (includeAudio)
{
var songs = recursiveChildren.OfType<Audio.Audio>().ToList();
indexFolders = songs.SelectMany(i => i.Artists)
2013-04-23 03:56:11 +00:00
.Distinct(StringComparer.OrdinalIgnoreCase)
.Select(i =>
{
try
{
return LibraryManager.GetArtist(i);
}
catch (IOException ex)
{
Logger.ErrorException("Error getting artist {0}", ex, i);
return null;
}
catch (AggregateException ex)
{
Logger.ErrorException("Error getting artist {0}", ex, i);
return null;
}
})
.Where(i => i != null)
.Select(a => new IndexFolder(us, a,
songs.Where(i => i.Artists.Contains(a.Name, StringComparer.OrdinalIgnoreCase)
2013-06-20 16:44:24 +00:00
), currentIndexName)).Concat(indexFolders);
}
2013-02-21 01:33:05 +00:00
return indexFolders;
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Gets the index by studio.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
protected IEnumerable<BaseItem> GetIndexByStudio(User user)
{
// Even though this implementation means multiple iterations over the target list - it allows us to defer
// the retrieval of the individual children for each index value until they are requested.
2013-02-21 20:26:35 +00:00
using (new Profiler("Studio Index Build for " + Name, Logger))
2013-02-21 01:33:05 +00:00
{
var indexName = LocalizedStrings.Instance.GetString("StudioDispPref");
2013-08-03 13:24:23 +00:00
var candidates = GetRecursiveChildren(user).Where(i => i.IncludeInIndex).ToList();
2013-02-21 01:33:05 +00:00
2013-08-03 13:24:23 +00:00
return candidates.AsParallel().SelectMany(i => i.AllStudios)
2013-02-21 01:33:05 +00:00
.Distinct()
.Select(i =>
{
try
{
return LibraryManager.GetStudio(i);
2013-02-21 01:33:05 +00:00
}
catch (IOException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting studio {0}", ex, i);
2013-02-21 01:33:05 +00:00
return null;
}
catch (AggregateException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting studio {0}", ex, i);
2013-02-21 01:33:05 +00:00
return null;
}
})
.Where(i => i != null)
2013-08-03 13:24:23 +00:00
.Select(ndx => new IndexFolder(this, ndx, candidates.Where(i => i.AllStudios.Any(s => s.Equals(ndx.Name, StringComparison.OrdinalIgnoreCase))), indexName));
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Gets the index by genre.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
protected IEnumerable<BaseItem> GetIndexByGenre(User user)
{
// Even though this implementation means multiple iterations over the target list - it allows us to defer
// the retrieval of the individual children for each index value until they are requested.
2013-02-21 20:26:35 +00:00
using (new Profiler("Genre Index Build for " + Name, Logger))
2013-02-21 01:33:05 +00:00
{
var indexName = LocalizedStrings.Instance.GetString("GenreDispPref");
//we need a copy of this so we don't double-recurse
2013-08-03 13:24:23 +00:00
var candidates = GetRecursiveChildren(user).Where(i => i.IncludeInIndex).ToList();
2013-02-21 01:33:05 +00:00
2013-08-03 13:24:23 +00:00
return candidates.AsParallel().SelectMany(i => i.AllGenres)
.Distinct(StringComparer.OrdinalIgnoreCase)
2013-02-21 01:33:05 +00:00
.Select(i =>
{
try
{
return LibraryManager.GetGenre(i);
2013-02-21 01:33:05 +00:00
}
catch (Exception ex)
2013-02-21 01:33:05 +00:00
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting genre {0}", ex, i);
2013-02-21 01:33:05 +00:00
return null;
}
})
.Where(i => i != null)
2013-08-03 13:24:23 +00:00
.Select(genre => new IndexFolder(this, genre, candidates.Where(i => i.AllGenres.Any(g => g.Equals(genre.Name, StringComparison.OrdinalIgnoreCase))), indexName)
2013-02-21 01:33:05 +00:00
);
}
}
/// <summary>
/// Gets the index by year.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
protected IEnumerable<BaseItem> GetIndexByYear(User user)
{
// Even though this implementation means multiple iterations over the target list - it allows us to defer
// the retrieval of the individual children for each index value until they are requested.
2013-02-21 20:26:35 +00:00
using (new Profiler("Production Year Index Build for " + Name, Logger))
2013-02-21 01:33:05 +00:00
{
var indexName = LocalizedStrings.Instance.GetString("YearDispPref");
//we need a copy of this so we don't double-recurse
var candidates = GetRecursiveChildren(user).Where(i => i.IncludeInIndex && i.ProductionYear.HasValue).ToList();
2013-02-21 01:33:05 +00:00
return candidates.AsParallel().Select(i => i.ProductionYear.Value)
.Distinct()
.Select(i =>
{
try
{
return LibraryManager.GetYear(i);
2013-02-21 01:33:05 +00:00
}
catch (IOException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting year {0}", ex, i);
2013-02-21 01:33:05 +00:00
return null;
}
catch (AggregateException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting year {0}", ex, i);
2013-02-21 01:33:05 +00:00
return null;
}
})
.Where(i => i != null)
.Select(ndx => new IndexFolder(this, ndx, candidates.Where(i => i.ProductionYear == int.Parse(ndx.Name)), indexName));
}
}
/// <summary>
/// Returns the indexed children for this user from the cache. Caches them if not already there.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="indexBy">The index by.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
private IEnumerable<BaseItem> GetIndexedChildren(User user, string indexBy)
{
2013-09-19 00:37:01 +00:00
List<BaseItem> result = null;
2013-02-21 01:33:05 +00:00
var cacheKey = user.Name + indexBy;
2013-09-19 00:37:01 +00:00
if (IndexCache != null)
{
IndexCache.TryGetValue(cacheKey, out result);
}
2013-02-21 01:33:05 +00:00
if (result == null)
{
//not cached - cache it
Func<User, IEnumerable<BaseItem>> indexing;
IndexByOptions.TryGetValue(indexBy, out indexing);
result = BuildIndex(indexBy, indexing, user);
}
return result;
}
/// <summary>
/// Get the list of indexy by choices for this folder (localized).
/// </summary>
/// <value>The index by option strings.</value>
[IgnoreDataMember]
public IEnumerable<string> IndexByOptionStrings
{
get { return IndexByOptions.Keys; }
}
/// <summary>
/// The index cache
/// </summary>
2013-09-19 00:37:01 +00:00
protected ConcurrentDictionary<string, List<BaseItem>> IndexCache;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Builds the index.
/// </summary>
/// <param name="indexKey">The index key.</param>
/// <param name="indexFunction">The index function.</param>
/// <param name="user">The user.</param>
/// <returns>List{BaseItem}.</returns>
protected virtual List<BaseItem> BuildIndex(string indexKey, Func<User, IEnumerable<BaseItem>> indexFunction, User user)
{
2013-09-19 00:37:01 +00:00
if (IndexCache == null)
{
IndexCache = new ConcurrentDictionary<string, List<BaseItem>>();
}
2013-02-21 01:33:05 +00:00
return indexFunction != null
? IndexCache[user.Name + indexKey] = indexFunction(user).ToList()
: null;
}
#endregion
/// <summary>
/// The children
/// </summary>
2013-09-26 02:22:54 +00:00
private IReadOnlyList<BaseItem> _children = new List<BaseItem>();
2013-02-21 01:33:05 +00:00
/// <summary>
/// The _children sync lock
/// </summary>
2013-09-25 18:58:03 +00:00
private readonly object _childrenSyncLock = new object();
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the actual children.
/// </summary>
/// <value>The actual children.</value>
2013-09-19 00:37:01 +00:00
protected virtual IEnumerable<BaseItem> ActualChildren
2013-02-21 01:33:05 +00:00
{
get
{
return _children;
}
}
2013-09-25 18:05:21 +00:00
public void LoadSavedChildren()
{
_children = LoadChildrenInternal();
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// thread-safe access to the actual children of this folder - without regard to user
/// </summary>
/// <value>The children.</value>
[IgnoreDataMember]
public IEnumerable<BaseItem> Children
2013-02-21 01:33:05 +00:00
{
2013-09-19 00:37:01 +00:00
get { return ActualChildren; }
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// thread-safe access to all recursive children of this folder - without regard to user
/// </summary>
/// <value>The recursive children.</value>
[IgnoreDataMember]
public IEnumerable<BaseItem> RecursiveChildren
{
2013-09-27 12:24:28 +00:00
get { return GetRecursiveChildren(); }
2013-02-21 01:33:05 +00:00
}
2013-09-25 18:05:21 +00:00
private List<BaseItem> LoadChildrenInternal()
{
2013-09-25 18:05:21 +00:00
return LoadChildren().ToList();
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Loads our children. Validation will occur externally.
/// We want this sychronous.
/// </summary>
protected virtual IEnumerable<BaseItem> LoadChildren()
2013-02-21 01:33:05 +00:00
{
//just load our children from the repo - the library will be validated and maintained in other processes
return GetCachedChildren();
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets or sets the current validation cancellation token source.
/// </summary>
/// <value>The current validation cancellation token source.</value>
private CancellationTokenSource CurrentValidationCancellationTokenSource { get; set; }
/// <summary>
/// Validates that the children of the folder still exist
/// </summary>
/// <param name="progress">The progress.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="recursive">if set to <c>true</c> [recursive].</param>
2013-05-22 04:39:10 +00:00
/// <param name="forceRefreshMetadata">if set to <c>true</c> [force refresh metadata].</param>
2013-02-21 01:33:05 +00:00
/// <returns>Task.</returns>
2013-05-22 04:39:10 +00:00
public async Task ValidateChildren(IProgress<double> progress, CancellationToken cancellationToken, bool? recursive = null, bool forceRefreshMetadata = false)
2013-02-21 01:33:05 +00:00
{
cancellationToken.ThrowIfCancellationRequested();
// Cancel the current validation, if any
if (CurrentValidationCancellationTokenSource != null)
{
CurrentValidationCancellationTokenSource.Cancel();
}
// Create an inner cancellation token. This can cancel all validations from this level on down,
// but nothing above this
var innerCancellationTokenSource = new CancellationTokenSource();
try
{
CurrentValidationCancellationTokenSource = innerCancellationTokenSource;
var linkedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(innerCancellationTokenSource.Token, cancellationToken);
2013-05-22 04:39:10 +00:00
await ValidateChildrenInternal(progress, linkedCancellationTokenSource.Token, recursive, forceRefreshMetadata).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
}
catch (OperationCanceledException ex)
{
2013-02-21 20:26:35 +00:00
Logger.Info("ValidateChildren cancelled for " + Name);
2013-02-21 01:33:05 +00:00
// If the outer cancelletion token in the cause for the cancellation, throw it
if (cancellationToken.IsCancellationRequested && ex.CancellationToken == cancellationToken)
{
throw;
}
}
finally
{
// Null out the token source
if (CurrentValidationCancellationTokenSource == innerCancellationTokenSource)
{
CurrentValidationCancellationTokenSource = null;
}
innerCancellationTokenSource.Dispose();
}
}
/// <summary>
/// Compare our current children (presumably just read from the repo) with the current state of the file system and adjust for any changes
/// ***Currently does not contain logic to maintain items that are unavailable in the file system***
/// </summary>
/// <param name="progress">The progress.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="recursive">if set to <c>true</c> [recursive].</param>
2013-05-22 04:39:10 +00:00
/// <param name="forceRefreshMetadata">if set to <c>true</c> [force refresh metadata].</param>
2013-02-21 01:33:05 +00:00
/// <returns>Task.</returns>
2013-05-22 04:39:10 +00:00
protected async virtual Task ValidateChildrenInternal(IProgress<double> progress, CancellationToken cancellationToken, bool? recursive = null, bool forceRefreshMetadata = false)
2013-02-21 01:33:05 +00:00
{
var locationType = LocationType;
2013-02-21 01:33:05 +00:00
// Nothing to do here
if (locationType == LocationType.Remote || locationType == LocationType.Virtual)
2013-02-21 01:33:05 +00:00
{
return;
}
cancellationToken.ThrowIfCancellationRequested();
2013-07-07 15:53:38 +00:00
IEnumerable<BaseItem> nonCachedChildren;
try
{
nonCachedChildren = GetNonCachedChildren();
}
catch (IOException ex)
{
nonCachedChildren = new BaseItem[] { };
Logger.ErrorException("Error getting file system entries for {0}", ex, Path);
}
2013-02-21 01:33:05 +00:00
if (nonCachedChildren == null) return; //nothing to validate
2013-02-22 04:23:06 +00:00
progress.Report(5);
2013-02-21 01:33:05 +00:00
//build a dictionary of the current children we have now by Id so we can compare quickly and easily
2013-09-19 00:37:01 +00:00
var currentChildren = ActualChildren.ToDictionary(i => i.Id);
2013-02-21 01:33:05 +00:00
//create a list for our validated children
2013-09-27 12:24:28 +00:00
var validChildren = new List<Tuple<BaseItem, bool>>();
var newItems = new List<BaseItem>();
2013-02-21 01:33:05 +00:00
cancellationToken.ThrowIfCancellationRequested();
2013-04-12 18:22:40 +00:00
2013-09-27 12:24:28 +00:00
foreach (var child in nonCachedChildren)
2013-02-21 01:33:05 +00:00
{
BaseItem currentChild;
if (currentChildren.TryGetValue(child.Id, out currentChild))
{
2013-09-25 18:05:21 +00:00
currentChild.ResetResolveArgs(child.ResolveArgs);
2013-02-21 01:33:05 +00:00
//existing item - check if it has changed
if (currentChild.HasChanged(child))
{
2013-08-14 12:17:45 +00:00
EntityResolutionHelper.EnsureDates(currentChild, child.ResolveArgs, false);
2013-02-21 01:33:05 +00:00
validChildren.Add(new Tuple<BaseItem, bool>(currentChild, true));
}
else
{
validChildren.Add(new Tuple<BaseItem, bool>(currentChild, false));
}
2013-07-07 15:53:38 +00:00
currentChild.IsOffline = false;
2013-02-21 01:33:05 +00:00
}
else
{
//brand new item - needs to be added
newItems.Add(child);
2013-02-21 01:33:05 +00:00
validChildren.Add(new Tuple<BaseItem, bool>(child, true));
}
2013-09-27 12:24:28 +00:00
}
2013-02-21 01:33:05 +00:00
// If any items were added or removed....
2013-09-27 12:24:28 +00:00
if (newItems.Count > 0 || currentChildren.Count != validChildren.Count)
2013-02-21 01:33:05 +00:00
{
var newChildren = validChildren.Select(c => c.Item1).ToList();
//that's all the new and changed ones - now see if there are any that are missing
var itemsRemoved = currentChildren.Values.Except(newChildren).ToList();
2013-02-21 01:33:05 +00:00
2013-09-19 00:37:01 +00:00
var actualRemovals = new List<BaseItem>();
foreach (var item in itemsRemoved)
2013-02-21 01:33:05 +00:00
{
2013-10-10 16:55:19 +00:00
if (!string.IsNullOrEmpty(item.Path) && IsPathOffline(item.Path))
{
2013-07-05 14:54:14 +00:00
item.IsOffline = true;
validChildren.Add(new Tuple<BaseItem, bool>(item, false));
}
2013-10-06 01:04:41 +00:00
else
{
item.IsOffline = false;
actualRemovals.Add(item);
}
2013-02-21 01:33:05 +00:00
}
2013-09-19 00:37:01 +00:00
if (actualRemovals.Count > 0)
{
RemoveChildrenInternal(actualRemovals);
2013-09-23 18:28:07 +00:00
foreach (var item in actualRemovals)
{
LibraryManager.ReportItemRemoved(item);
}
2013-09-19 00:37:01 +00:00
}
2013-05-23 15:39:48 +00:00
await LibraryManager.CreateItems(newItems, cancellationToken).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
2013-09-25 18:05:21 +00:00
AddChildrenInternal(newItems);
2013-02-21 01:33:05 +00:00
await ItemRepository.SaveChildren(Id, _children.Select(i => i.Id).ToList(), cancellationToken).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
//force the indexes to rebuild next time
2013-09-19 00:37:01 +00:00
if (IndexCache != null)
{
IndexCache.Clear();
}
2013-02-21 01:33:05 +00:00
}
progress.Report(10);
2013-02-21 01:33:05 +00:00
cancellationToken.ThrowIfCancellationRequested();
2013-05-22 04:39:10 +00:00
await RefreshChildren(validChildren, progress, cancellationToken, recursive, forceRefreshMetadata).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
2013-02-22 04:23:06 +00:00
progress.Report(100);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Refreshes the children.
/// </summary>
/// <param name="children">The children.</param>
/// <param name="progress">The progress.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="recursive">if set to <c>true</c> [recursive].</param>
2013-05-22 04:39:10 +00:00
/// <param name="forceRefreshMetadata">if set to <c>true</c> [force refresh metadata].</param>
2013-02-21 01:33:05 +00:00
/// <returns>Task.</returns>
2013-09-27 12:24:28 +00:00
private async Task RefreshChildren(IList<Tuple<BaseItem, bool>> children, IProgress<double> progress, CancellationToken cancellationToken, bool? recursive, bool forceRefreshMetadata = false)
2013-02-21 01:33:05 +00:00
{
2013-09-27 12:24:28 +00:00
var list = children;
2013-02-21 01:33:05 +00:00
2013-09-11 17:54:59 +00:00
var percentages = new Dictionary<Guid, double>(list.Count);
var tasks = new List<Task>();
foreach (var tuple in list)
2013-02-21 01:33:05 +00:00
{
if (tasks.Count > 5)
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
Tuple<BaseItem, bool> currentTuple = tuple;
tasks.Add(Task.Run(async () =>
{
cancellationToken.ThrowIfCancellationRequested();
2013-02-21 01:33:05 +00:00
var child = currentTuple.Item1;
2013-02-21 01:33:05 +00:00
//refresh it
await child.RefreshMetadata(cancellationToken, forceSave: currentTuple.Item2, forceRefresh: forceRefreshMetadata, resetResolveArgs: false).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
// Refresh children if a folder and the item changed or recursive is set to true
var refreshChildren = child.IsFolder && (currentTuple.Item2 || (recursive.HasValue && recursive.Value));
2013-02-21 01:33:05 +00:00
if (refreshChildren)
2013-02-21 01:33:05 +00:00
{
// Don't refresh children if explicitly set to false
if (recursive.HasValue && recursive.Value == false)
{
refreshChildren = false;
}
2013-02-21 01:33:05 +00:00
}
if (refreshChildren)
{
cancellationToken.ThrowIfCancellationRequested();
var innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(p =>
{
lock (percentages)
{
2013-06-20 16:44:24 +00:00
percentages[child.Id] = p / 100;
2013-02-21 01:33:05 +00:00
var percent = percentages.Values.Sum();
percent /= list.Count;
2013-02-21 01:33:05 +00:00
progress.Report((90 * percent) + 10);
}
});
await ((Folder)child).ValidateChildren(innerProgress, cancellationToken, recursive, forceRefreshMetadata).ConfigureAwait(false);
// Some folder providers are unable to refresh until children have been refreshed.
await child.RefreshMetadata(cancellationToken, resetResolveArgs: false).ConfigureAwait(false);
}
else
{
lock (percentages)
{
percentages[child.Id] = 1;
2013-02-21 01:33:05 +00:00
var percent = percentages.Values.Sum();
percent /= list.Count;
progress.Report((90 * percent) + 10);
}
}
}));
}
2013-02-21 01:33:05 +00:00
cancellationToken.ThrowIfCancellationRequested();
await Task.WhenAll(tasks).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
}
2013-07-05 14:54:14 +00:00
/// <summary>
2013-10-06 01:04:41 +00:00
/// Determines whether the specified path is offline.
2013-07-05 14:54:14 +00:00
/// </summary>
2013-10-06 01:04:41 +00:00
/// <param name="path">The path.</param>
/// <returns><c>true</c> if the specified path is offline; otherwise, <c>false</c>.</returns>
private bool IsPathOffline(string path)
2013-07-05 14:54:14 +00:00
{
2013-07-07 15:53:38 +00:00
if (File.Exists(path))
{
2013-10-06 01:04:41 +00:00
return false;
2013-07-07 15:53:38 +00:00
}
2013-10-06 01:04:41 +00:00
var originalPath = path;
// Depending on whether the path is local or unc, it may return either null or '\' at the top
2013-07-07 01:41:04 +00:00
while (!string.IsNullOrEmpty(path) && path.Length > 1)
2013-07-05 14:54:14 +00:00
{
2013-07-07 01:41:04 +00:00
if (Directory.Exists(path))
2013-07-05 14:54:14 +00:00
{
2013-10-06 01:04:41 +00:00
return false;
2013-07-05 14:54:14 +00:00
}
2013-07-07 01:41:04 +00:00
path = System.IO.Path.GetDirectoryName(path);
2013-07-05 14:54:14 +00:00
}
2013-10-06 01:04:41 +00:00
if (ContainsPath(LibraryManager.GetDefaultVirtualFolders(), originalPath))
{
return true;
}
return UserManager.Users.Any(user => ContainsPath(LibraryManager.GetVirtualFolders(user), originalPath));
}
/// <summary>
/// Determines whether the specified folders contains path.
/// </summary>
/// <param name="folders">The folders.</param>
/// <param name="path">The path.</param>
/// <returns><c>true</c> if the specified folders contains path; otherwise, <c>false</c>.</returns>
private bool ContainsPath(IEnumerable<VirtualFolderInfo> folders, string path)
{
return folders.SelectMany(i => i.Locations).Any(i => ContainsPath(i, path));
}
private bool ContainsPath(string parent, string path)
{
return string.Equals(parent, path, StringComparison.OrdinalIgnoreCase) || path.IndexOf(parent.TrimEnd(System.IO.Path.DirectorySeparatorChar) + System.IO.Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) != -1;
2013-07-05 14:54:14 +00:00
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Get the children of this folder from the actual file system
/// </summary>
/// <returns>IEnumerable{BaseItem}.</returns>
protected virtual IEnumerable<BaseItem> GetNonCachedChildren()
{
2013-07-07 15:53:38 +00:00
if (ResolveArgs == null || ResolveArgs.FileSystemDictionary == null)
2013-02-21 01:33:05 +00:00
{
2013-07-07 15:53:38 +00:00
Logger.Error("Null for {0}", Path);
2013-02-21 01:33:05 +00:00
}
2013-07-07 15:53:38 +00:00
return LibraryManager.ResolvePaths<BaseItem>(ResolveArgs.FileSystemChildren, this);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Get our children from the repo - stubbed for now
/// </summary>
/// <returns>IEnumerable{BaseItem}.</returns>
2013-06-17 20:35:43 +00:00
protected IEnumerable<BaseItem> GetCachedChildren()
2013-02-21 01:33:05 +00:00
{
2013-06-24 14:12:56 +00:00
return ItemRepository.GetChildren(Id).Select(RetrieveChild).Where(i => i != null);
2013-06-17 20:35:43 +00:00
}
/// <summary>
/// Retrieves the child.
/// </summary>
/// <param name="child">The child.</param>
/// <returns>BaseItem.</returns>
2013-06-26 16:08:16 +00:00
private BaseItem RetrieveChild(Guid child)
2013-06-17 20:35:43 +00:00
{
2013-06-26 16:08:16 +00:00
var item = LibraryManager.RetrieveItem(child);
2013-06-17 20:35:43 +00:00
2013-06-26 16:08:16 +00:00
if (item != null)
2013-06-17 20:35:43 +00:00
{
2013-06-26 16:08:16 +00:00
if (item is IByReferenceItem)
{
return LibraryManager.GetOrAddByReferenceItem(item);
}
2013-06-17 20:35:43 +00:00
2013-06-26 16:08:16 +00:00
item.Parent = this;
2013-06-24 14:12:56 +00:00
}
return item;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets allowed children of an item
/// </summary>
/// <param name="user">The user.</param>
2013-07-05 13:47:10 +00:00
/// <param name="includeLinkedChildren">if set to <c>true</c> [include linked children].</param>
2013-02-21 01:33:05 +00:00
/// <param name="indexBy">The index by.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
2013-07-05 13:47:10 +00:00
public virtual IEnumerable<BaseItem> GetChildren(User user, bool includeLinkedChildren, string indexBy = null)
2013-02-21 01:33:05 +00:00
{
if (user == null)
{
throw new ArgumentNullException();
}
//the true root should return our users root folder children
2013-07-05 13:47:10 +00:00
if (IsPhysicalRoot) return user.RootFolder.GetChildren(user, includeLinkedChildren, indexBy);
2013-02-21 01:33:05 +00:00
IEnumerable<BaseItem> result = null;
if (!string.IsNullOrEmpty(indexBy))
{
result = GetIndexedChildren(user, indexBy);
}
2013-07-05 13:47:10 +00:00
if (result != null)
{
return result;
}
var initialCount = _children.Count;
var list = new List<BaseItem>(initialCount);
2013-09-26 21:20:26 +00:00
AddChildrenToList(user, includeLinkedChildren, list, false, null);
return list;
2013-09-20 02:03:37 +00:00
}
/// <summary>
/// Adds the children to list.
2013-09-20 02:03:37 +00:00
/// </summary>
/// <param name="user">The user.</param>
/// <param name="includeLinkedChildren">if set to <c>true</c> [include linked children].</param>
/// <param name="list">The list.</param>
/// <param name="recursive">if set to <c>true</c> [recursive].</param>
2013-09-26 21:20:26 +00:00
/// <param name="filter">The filter.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
2013-09-27 12:24:28 +00:00
private bool AddChildrenToList(User user, bool includeLinkedChildren, List<BaseItem> list, bool recursive, Func<BaseItem, bool> filter)
2013-09-20 02:03:37 +00:00
{
var hasLinkedChildren = false;
2013-09-20 02:03:37 +00:00
foreach (var child in Children)
{
if (child.IsVisible(user))
{
2013-09-26 21:20:26 +00:00
if (filter == null || filter(child))
{
list.Add(child);
}
2013-09-20 02:03:37 +00:00
}
if (recursive)
{
var folder = child as Folder;
if (folder != null)
{
2013-09-26 21:20:26 +00:00
if (folder.AddChildrenToList(user, includeLinkedChildren, list, true, filter))
{
hasLinkedChildren = true;
}
}
}
2013-09-20 02:03:37 +00:00
}
2013-07-05 13:47:10 +00:00
if (includeLinkedChildren)
{
2013-09-20 02:03:37 +00:00
foreach (var child in GetLinkedChildren())
{
2013-09-26 21:20:26 +00:00
if (filter != null && !filter(child))
{
continue;
}
2013-09-27 12:24:28 +00:00
2013-09-20 02:03:37 +00:00
if (child.IsVisible(user))
{
2013-10-04 15:22:03 +00:00
hasLinkedChildren = true;
2013-09-20 02:03:37 +00:00
list.Add(child);
}
}
2013-07-05 13:47:10 +00:00
}
return hasLinkedChildren;
2013-02-21 01:33:05 +00:00
}
private int _lastRecursiveCount;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets allowed recursive children of an item
/// </summary>
/// <param name="user">The user.</param>
2013-07-05 13:47:10 +00:00
/// <param name="includeLinkedChildren">if set to <c>true</c> [include linked children].</param>
2013-02-21 01:33:05 +00:00
/// <returns>IEnumerable{BaseItem}.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
2013-08-23 22:15:45 +00:00
public IEnumerable<BaseItem> GetRecursiveChildren(User user, bool includeLinkedChildren = true)
2013-09-26 21:20:26 +00:00
{
2013-10-04 19:48:31 +00:00
return GetRecursiveChildren(user, null, includeLinkedChildren);
2013-09-26 21:20:26 +00:00
}
2013-09-27 12:24:28 +00:00
/// <summary>
/// Gets the recursive children.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="filter">The filter.</param>
/// <param name="includeLinkedChildren">if set to <c>true</c> [include linked children].</param>
/// <returns>IList{BaseItem}.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public IList<BaseItem> GetRecursiveChildren(User user, Func<BaseItem, bool> filter, bool includeLinkedChildren = true)
2013-02-21 01:33:05 +00:00
{
if (user == null)
{
2013-10-04 19:48:31 +00:00
throw new ArgumentNullException("user");
2013-02-21 01:33:05 +00:00
}
var initialCount = _lastRecursiveCount == 0 ? _children.Count : _lastRecursiveCount;
2013-09-22 18:29:07 +00:00
var list = new List<BaseItem>(initialCount);
2013-09-20 02:03:37 +00:00
2013-09-27 12:24:28 +00:00
var hasLinkedChildren = AddChildrenToList(user, includeLinkedChildren, list, true, filter);
2013-08-23 22:13:18 +00:00
_lastRecursiveCount = list.Count;
2013-09-26 21:20:26 +00:00
2013-10-04 19:48:31 +00:00
return hasLinkedChildren ? list.DistinctBy(i => i.Id).ToList() : list;
2013-08-23 22:13:18 +00:00
}
2013-09-27 12:24:28 +00:00
/// <summary>
/// Gets the recursive children.
/// </summary>
/// <returns>IList{BaseItem}.</returns>
public IList<BaseItem> GetRecursiveChildren()
{
2013-10-04 20:08:45 +00:00
return GetRecursiveChildren(i => true);
2013-09-27 12:24:28 +00:00
}
/// <summary>
/// Gets the recursive children.
/// </summary>
/// <param name="filter">The filter.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
public IList<BaseItem> GetRecursiveChildren(Func<BaseItem, bool> filter)
{
var initialCount = _lastRecursiveCount == 0 ? _children.Count : _lastRecursiveCount;
var list = new List<BaseItem>(initialCount);
AddChildrenToList(list, true, filter);
return list;
}
/// <summary>
/// Adds the children to list.
/// </summary>
/// <param name="list">The list.</param>
/// <param name="recursive">if set to <c>true</c> [recursive].</param>
/// <param name="filter">The filter.</param>
private void AddChildrenToList(List<BaseItem> list, bool recursive, Func<BaseItem, bool> filter)
{
foreach (var child in Children)
{
if (filter == null || filter(child))
{
list.Add(child);
}
if (recursive)
{
var folder = child as Folder;
if (folder != null)
{
folder.AddChildrenToList(list, true, filter);
}
}
}
}
2013-07-05 13:47:10 +00:00
/// <summary>
/// Gets the linked children.
/// </summary>
/// <returns>IEnumerable{BaseItem}.</returns>
public IEnumerable<BaseItem> GetLinkedChildren()
{
return LinkedChildren
.Select(GetLinkedChild)
2013-07-05 13:47:10 +00:00
.Where(i => i != null);
}
/// <summary>
/// Gets the linked child.
/// </summary>
/// <param name="info">The info.</param>
/// <returns>BaseItem.</returns>
private BaseItem GetLinkedChild(LinkedChild info)
{
if (string.IsNullOrEmpty(info.Path))
{
throw new ArgumentException("Encountered linked child with empty path.");
}
2013-09-19 00:37:01 +00:00
2013-10-03 15:24:32 +00:00
BaseItem item = null;
2013-10-03 15:24:32 +00:00
// First get using the cached Id
if (info.ItemId != Guid.Empty)
{
item = LibraryManager.GetItemById(info.ItemId);
}
// If still null, search by path
if (item == null)
{
item = LibraryManager.RootFolder.FindByPath(info.Path);
}
// If still null, log
if (item == null)
{
Logger.Warn("Unable to find linked item at {0}", info.Path);
}
2013-10-03 15:24:32 +00:00
else
{
// Cache the id for next time
info.ItemId = item.Id;
}
return item;
}
2013-07-05 13:47:10 +00:00
public override async Task<bool> RefreshMetadata(CancellationToken cancellationToken, bool forceSave = false, bool forceRefresh = false, bool allowSlowProviders = true, bool resetResolveArgs = true)
{
var changed = await base.RefreshMetadata(cancellationToken, forceSave, forceRefresh, allowSlowProviders, resetResolveArgs).ConfigureAwait(false);
return changed || (SupportsShortcutChildren && LocationType == LocationType.FileSystem && RefreshLinkedChildren());
2013-07-05 13:47:10 +00:00
}
/// <summary>
/// Refreshes the linked children.
/// </summary>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
private bool RefreshLinkedChildren()
{
ItemResolveArgs resolveArgs;
try
{
resolveArgs = ResolveArgs;
if (!resolveArgs.IsDirectory)
{
return false;
}
}
catch (IOException ex)
{
Logger.ErrorException("Error getting ResolveArgs for {0}", ex, Path);
return false;
}
var currentManualLinks = LinkedChildren.Where(i => i.Type == LinkedChildType.Manual).ToList();
var currentShortcutLinks = LinkedChildren.Where(i => i.Type == LinkedChildType.Shortcut).ToList();
var newShortcutLinks = resolveArgs.FileSystemChildren
.Where(i => (i.Attributes & FileAttributes.Directory) != FileAttributes.Directory && FileSystem.IsShortcut(i.FullName))
.Select(i =>
{
try
{
2013-08-04 00:59:23 +00:00
Logger.Debug("Found shortcut at {0}", i.FullName);
var resolvedPath = FileSystem.ResolveShortcut(i.FullName);
if (!string.IsNullOrEmpty(resolvedPath))
2013-07-05 13:47:10 +00:00
{
return new LinkedChild
{
Path = resolvedPath,
Type = LinkedChildType.Shortcut
};
}
Logger.Error("Error resolving shortcut {0}", i.FullName);
return null;
2013-07-05 13:47:10 +00:00
}
catch (IOException ex)
{
Logger.ErrorException("Error resolving shortcut {0}", ex, i.FullName);
return null;
}
})
.Where(i => i != null)
.ToList();
2013-10-03 15:24:32 +00:00
if (!newShortcutLinks.SequenceEqual(currentShortcutLinks, new LinkedChildComparer()))
2013-07-05 13:47:10 +00:00
{
Logger.Info("Shortcut links have changed for {0}", Path);
2013-08-04 00:59:23 +00:00
2013-07-05 13:47:10 +00:00
newShortcutLinks.AddRange(currentManualLinks);
LinkedChildren = newShortcutLinks;
return true;
}
return false;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Folders need to validate and refresh
/// </summary>
/// <returns>Task.</returns>
public override async Task ChangedExternally()
{
await base.ChangedExternally().ConfigureAwait(false);
var progress = new Progress<double>();
2013-02-21 01:33:05 +00:00
await ValidateChildren(progress, CancellationToken.None).ConfigureAwait(false);
}
/// <summary>
/// Marks the played.
2013-02-21 01:33:05 +00:00
/// </summary>
/// <param name="user">The user.</param>
/// <param name="datePlayed">The date played.</param>
/// <param name="userManager">The user manager.</param>
2013-02-21 01:33:05 +00:00
/// <returns>Task.</returns>
2013-10-02 16:08:58 +00:00
public override async Task MarkPlayed(User user, DateTime? datePlayed, IUserDataManager userManager)
2013-02-21 01:33:05 +00:00
{
// Sweep through recursively and update status
var tasks = GetRecursiveChildren(user, true).Where(i => !i.IsFolder).Select(c => c.MarkPlayed(user, datePlayed, userManager));
await Task.WhenAll(tasks).ConfigureAwait(false);
}
/// <summary>
/// Marks the unplayed.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="userManager">The user manager.</param>
/// <returns>Task.</returns>
2013-10-02 16:08:58 +00:00
public override async Task MarkUnplayed(User user, IUserDataManager userManager)
{
// Sweep through recursively and update status
var tasks = GetRecursiveChildren(user, true).Where(i => !i.IsFolder).Select(c => c.MarkUnplayed(user, userManager));
2013-02-21 01:33:05 +00:00
await Task.WhenAll(tasks).ConfigureAwait(false);
}
/// <summary>
/// Finds an item by path, recursively
/// </summary>
/// <param name="path">The path.</param>
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public BaseItem FindByPath(string path)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException();
}
try
{
if (ResolveArgs.PhysicalLocations.Contains(path, StringComparer.OrdinalIgnoreCase))
{
return this;
}
}
catch (IOException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting ResolveArgs for {0}", ex, Path);
2013-02-21 01:33:05 +00:00
}
//this should be functionally equivilent to what was here since it is IEnum and works on a thread-safe copy
return RecursiveChildren.FirstOrDefault(i =>
{
try
{
return i.ResolveArgs.PhysicalLocations.Contains(path, StringComparer.OrdinalIgnoreCase);
}
catch (IOException ex)
{
2013-02-21 20:26:35 +00:00
Logger.ErrorException("Error getting ResolveArgs for {0}", ex, Path);
2013-02-21 01:33:05 +00:00
return false;
}
});
}
}
}