Merge with default

MediaBrowser.Controller/Entities/BaseEntity.cs

@@ -1,4 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.IO;
 
 namespace MediaBrowser.Controller.Entities
 {
@@ -11,6 +15,10 @@ namespace MediaBrowser.Controller.Entities
 
         public Guid Id { get; set; }
 
+        public string Path { get; set; }
+
+        public Folder Parent { get; set; }
+
         public string PrimaryImagePath { get; set; }
 
         public DateTime DateCreated { get; set; }
@@ -21,5 +29,45 @@ namespace MediaBrowser.Controller.Entities
         {
             return Name;
         }
+
+        protected ItemResolveEventArgs _resolveArgs;
+        /// <summary>
+        /// We attach these to the item so that we only ever have to hit the file system once
+        /// (this includes the children of the containing folder)
+        /// Use ResolveArgs.FileSystemChildren to check for the existence of files instead of File.Exists
+        /// </summary>
+        public ItemResolveEventArgs ResolveArgs
+        {
+            get
+            {
+                if (_resolveArgs == null)
+                {
+                    _resolveArgs = new ItemResolveEventArgs()
+                    {
+                        FileInfo = FileData.GetFileData(this.Path),
+                        Parent = this.Parent,
+                        Cancel = false,
+                        Path = this.Path
+                    };
+                    _resolveArgs = FileSystemHelper.FilterChildFileSystemEntries(_resolveArgs, (this.Parent != null && this.Parent.IsRoot));
+                }
+                return _resolveArgs;
+            }
+            set
+            {
+                _resolveArgs = value;
+            }
+        }
+
+        /// <summary>
+        /// Refresh metadata on us by execution our provider chain
+        /// </summary>
+        /// <returns>true if a provider reports we changed</returns>
+        public bool RefreshMetadata()
+        {
+            Kernel.Instance.ExecuteMetadataProviders(this).ConfigureAwait(false);
+            return true;
+        }
+
     }
 }

MediaBrowser.Controller/Entities/BaseItem.cs

@@ -1,4 +1,6 @@
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.IO;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -14,10 +16,6 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public DateTime? PremiereDate { get; set; }
 
-        public string Path { get; set; }
-
-        public Folder Parent { get; set; }
-
         public string LogoImagePath { get; set; }
 
         public string ArtImagePath { get; set; }
@@ -134,6 +132,18 @@ namespace MediaBrowser.Controller.Entities
             }
         }
 
+        /// <summary>
+        /// Determine if we have changed vs the passed in copy
+        /// </summary>
+        /// <param name="original"></param>
+        /// <returns></returns>
+        public virtual bool IsChanged(BaseItem original)
+        {
+            bool changed = original.DateModified != this.DateModified;
+            changed |= original.DateCreated != this.DateCreated;
+            return changed;
+        }
+
         /// <summary>
         /// Determines if the item is considered new based on user settings
         /// </summary>

MediaBrowser.Controller/Entities/Folder.cs

@@ -1,5 +1,10 @@
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Common.Logging;
+using MediaBrowser.Controller.Resolvers;
 using System;
+using System.Threading.Tasks;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -7,6 +12,28 @@ namespace MediaBrowser.Controller.Entities
 {
     public class Folder : BaseItem
     {
+        #region Events
+        /// <summary>
+        /// Fires whenever a validation routine updates our children.  The added and removed children are properties of the args.
+        /// *** Will fire asynchronously. ***
+        /// </summary>
+        public event EventHandler<ChildrenChangedEventArgs> ChildrenChanged;
+        protected void OnChildrenChanged(ChildrenChangedEventArgs args)
+        {
+            if (ChildrenChanged != null)
+            {
+                Task.Run( () => 
+                    {
+                        ChildrenChanged(this, args);
+                        Kernel.Instance.OnLibraryChanged(args);
+                    });
+            }
+        }
+
+        #endregion
+
+        public IEnumerable<string> PhysicalLocations { get; set; }
+
         public override bool IsFolder
         {
             get
@@ -24,23 +51,266 @@ namespace MediaBrowser.Controller.Entities
                 return Parent != null && Parent.IsRoot;
             }
         }
+        protected object childLock = new object();
+        protected List<BaseItem> children;
+        protected virtual List<BaseItem> ActualChildren
+        {
+            get
+            {
+                if (children == null)
+                {
+                    LoadChildren();
+                }
+                return children;
+            }
 
-        public IEnumerable<BaseItem> Children { get; set; }
+            set
+            {
+                children = value;
+            }
+        }
+
+        /// <summary>
+        /// thread-safe access to the actual children of this folder - without regard to user
+        /// </summary>
+        public IEnumerable<BaseItem> Children
+        {
+            get
+            {
+                lock (childLock)
+                    return ActualChildren.ToList();
+            }
+        }
+
+        /// <summary>
+        /// thread-safe access to all recursive children of this folder - without regard to user
+        /// </summary>
+        public IEnumerable<BaseItem> RecursiveChildren
+        {
+            get
+            {
+                foreach (var item in Children)
+                {
+                    yield return item;
+
+                    var subFolder = item as Folder;
+
+                    if (subFolder != null)
+                    {
+                        foreach (var subitem in subFolder.RecursiveChildren)
+                        {
+                            yield return subitem;
+                        }
+                    }
+                }
+            }
+        }
+                
+
+        /// <summary>
+        /// Loads and validates our children
+        /// </summary>
+        protected virtual void LoadChildren()
+        {
+            //first - load our children from the repo
+            lock (childLock)
+                children = GetCachedChildren();
+
+            //then kick off a validation against the actual file system
+            Task.Run(() => ValidateChildren());
+        }
+
+        protected bool ChildrenValidating = false;
+
+        /// <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>
+        /// <returns></returns>
+        protected async virtual void ValidateChildren()
+        {
+            if (ChildrenValidating) return; //only ever want one of these going at once and don't want them to fire off in sequence so don't use lock
+            ChildrenValidating = true;
+            bool changed = false; //this will save us a little time at the end if nothing changes
+            var changedArgs = new ChildrenChangedEventArgs(this);
+            //get the current valid children from filesystem (or wherever)
+            var nonCachedChildren = await GetNonCachedChildren();
+            if (nonCachedChildren == null) return; //nothing to validate
+            //build a dictionary of the current children we have now by Id so we can compare quickly and easily
+            Dictionary<Guid, BaseItem> currentChildren;
+            lock (childLock)
+                currentChildren =  ActualChildren.ToDictionary(i => i.Id);
+            
+            //create a list for our validated children
+            var validChildren = new List<BaseItem>();
+            //now traverse the valid children and find any changed or new items
+            foreach (var child in nonCachedChildren)
+            {
+                BaseItem currentChild;
+                currentChildren.TryGetValue(child.Id, out currentChild);
+                if (currentChild == null)
+                {
+                    //brand new item - needs to be added
+                    changed = true;
+                    changedArgs.ItemsAdded.Add(child);
+                    //Logger.LogInfo("New Item Added to Library: ("+child.GetType().Name+")"+ child.Name + "(" + child.Path + ")");
+                    //refresh it
+                    child.RefreshMetadata();
+                    //save it in repo...
+
+                    //and add it to our valid children
+                    validChildren.Add(child);
+                    //fire an added event...?
+                    //if it is a folder we need to validate its children as well
+                    Folder folder = child as Folder;
+                    if (folder != null)
+                    {
+                        folder.ValidateChildren();
+                        //probably need to refresh too...
+                    }
+                }
+                else
+                {
+                    //existing item - check if it has changed
+                    if (currentChild.IsChanged(child))
+                    {
+                        changed = true;
+                        //update resolve args and refresh meta
+                        //  Note - we are refreshing the existing child instead of the newly found one so the "Except" operation below
+                        //  will identify this item as the same one
+                        currentChild.ResolveArgs = child.ResolveArgs;
+                        currentChild.RefreshMetadata();
+                        //save it in repo...
+                        validChildren.Add(currentChild);
+                    }
+                    else
+                    {
+                        //current child that didn't change - just put it in the valid children
+                        validChildren.Add(currentChild);
+                    }
+                }
+            }
+
+            //that's all the new and changed ones - now see if there are any that are missing
+            changedArgs.ItemsRemoved = currentChildren.Values.Except(validChildren);
+            changed |= changedArgs.ItemsRemoved != null;
+
+            //now, if anything changed - replace our children
+            if (changed)
+            {
+                lock (childLock)
+                    ActualChildren = validChildren;
+                //and save children in repo...
+
+                //and fire event
+                this.OnChildrenChanged(changedArgs);
+            }
+            ChildrenValidating = false;
+
+        }
+
+        /// <summary>
+        /// Get the children of this folder from the actual file system
+        /// </summary>
+        /// <returns></returns>
+        protected async virtual Task<IEnumerable<BaseItem>> GetNonCachedChildren()
+        {
+            ItemResolveEventArgs args = new ItemResolveEventArgs()
+            {
+                FileInfo = FileData.GetFileData(this.Path),
+                Parent = this.Parent,
+                Cancel = false,
+                Path = this.Path
+            };
+
+            // Gather child folder and files
+            if (args.IsDirectory)
+            {
+                args.FileSystemChildren = FileData.GetFileSystemEntries(this.Path, "*").ToArray();
+
+                bool isVirtualFolder = Parent != null && Parent.IsRoot;
+                args = FileSystemHelper.FilterChildFileSystemEntries(args, isVirtualFolder);
+            }
+            else
+            {
+                Logger.LogError("Folder has a path that is not a directory: " + this.Path);
+                return null;
+            }
+
+            if (!EntityResolutionHelper.ShouldResolvePathContents(args))
+            {
+                return null;
+            }
+            return (await Task.WhenAll<BaseItem>(GetChildren(args.FileSystemChildren)).ConfigureAwait(false))
+                        .Where(i => i != null).OrderBy(f =>
+                        {
+                            return string.IsNullOrEmpty(f.SortName) ? f.Name : f.SortName;
+
+                        });
+
+        }
+
+        /// <summary>
+        /// Resolves a path into a BaseItem
+        /// </summary>
+        protected async Task<BaseItem> GetChild(string path,  WIN32_FIND_DATA? fileInfo = null)
+        {
+            ItemResolveEventArgs args = new ItemResolveEventArgs()
+            {
+                FileInfo = fileInfo ?? FileData.GetFileData(path),
+                Parent = this,
+                Cancel = false,
+                Path = path
+            };
+
+            args.FileSystemChildren = FileData.GetFileSystemEntries(path, "*").ToArray();
+            args = FileSystemHelper.FilterChildFileSystemEntries(args, false);
+
+            return Kernel.Instance.ResolveItem(args);
+
+        }
+
+        /// <summary>
+        /// Finds child BaseItems for a given Folder
+        /// </summary>
+        protected Task<BaseItem>[] GetChildren(WIN32_FIND_DATA[] fileSystemChildren)
+        {
+            Task<BaseItem>[] tasks = new Task<BaseItem>[fileSystemChildren.Length];
+
+            for (int i = 0; i < fileSystemChildren.Length; i++)
+            {
+                var child = fileSystemChildren[i];
+
+                tasks[i] = GetChild(child.Path, child);
+            }
+
+            return tasks;
+        }
+
+
+        /// <summary>
+        /// Get our children from the repo - stubbed for now
+        /// </summary>
+        /// <returns></returns>
+        protected virtual List<BaseItem> GetCachedChildren()
+        {
+            return new List<BaseItem>();
+        }
 
         /// <summary>
         /// Gets allowed children of an item
         /// </summary>
-        public IEnumerable<BaseItem> GetParentalAllowedChildren(User user)
+        public IEnumerable<BaseItem> GetChildren(User user)
         {
-            return Children.Where(c => c.IsParentalAllowed(user));
+            return ActualChildren.Where(c => c.IsParentalAllowed(user));
         }
 
         /// <summary>
         /// Gets allowed recursive children of an item
         /// </summary>
-        public IEnumerable<BaseItem> GetParentalAllowedRecursiveChildren(User user)
+        public IEnumerable<BaseItem> GetRecursiveChildren(User user)
         {
-            foreach (var item in GetParentalAllowedChildren(user))
+            foreach (var item in GetChildren(user))
             {
                 yield return item;
 
@@ -48,7 +318,7 @@ namespace MediaBrowser.Controller.Entities
 
                 if (subFolder != null)
                 {
-                    foreach (var subitem in subFolder.GetParentalAllowedRecursiveChildren(user))
+                    foreach (var subitem in subFolder.GetRecursiveChildren(user))
                     {
                         yield return subitem;
                     }
@@ -63,7 +333,7 @@ namespace MediaBrowser.Controller.Entities
         {
             var counts = new ItemSpecialCounts();
 
-            IEnumerable<BaseItem> recursiveChildren = GetParentalAllowedRecursiveChildren(user);
+            IEnumerable<BaseItem> recursiveChildren = GetRecursiveChildren(user);
 
             var recentlyAddedItems = GetRecentlyAddedItems(recursiveChildren, user);
 
@@ -80,7 +350,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public IEnumerable<BaseItem> GetItemsWithGenre(string genre, User user)
         {
-            return GetParentalAllowedRecursiveChildren(user).Where(f => f.Genres != null && f.Genres.Any(s => s.Equals(genre, StringComparison.OrdinalIgnoreCase)));
+            return GetRecursiveChildren(user).Where(f => f.Genres != null && f.Genres.Any(s => s.Equals(genre, StringComparison.OrdinalIgnoreCase)));
         }
 
         /// <summary>
@@ -88,7 +358,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public IEnumerable<BaseItem> GetItemsWithYear(int year, User user)
         {
-            return GetParentalAllowedRecursiveChildren(user).Where(f => f.ProductionYear.HasValue && f.ProductionYear == year);
+            return GetRecursiveChildren(user).Where(f => f.ProductionYear.HasValue && f.ProductionYear == year);
         }
 
         /// <summary>
@@ -96,7 +366,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public IEnumerable<BaseItem> GetItemsWithStudio(string studio, User user)
         {
-            return GetParentalAllowedRecursiveChildren(user).Where(f => f.Studios != null && f.Studios.Any(s => s.Equals(studio, StringComparison.OrdinalIgnoreCase)));
+            return GetRecursiveChildren(user).Where(f => f.Studios != null && f.Studios.Any(s => s.Equals(studio, StringComparison.OrdinalIgnoreCase)));
         }
 
         /// <summary>
@@ -104,7 +374,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public IEnumerable<BaseItem> GetFavoriteItems(User user)
         {
-            return GetParentalAllowedRecursiveChildren(user).Where(c =>
+            return GetRecursiveChildren(user).Where(c =>
             {
                 UserItemData data = c.GetUserData(user, false);
 
@@ -122,7 +392,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public IEnumerable<BaseItem> GetItemsWithPerson(string person, User user)
         {
-            return GetParentalAllowedRecursiveChildren(user).Where(c =>
+            return GetRecursiveChildren(user).Where(c =>
             {
                 if (c.People != null)
                 {
@@ -139,7 +409,7 @@ namespace MediaBrowser.Controller.Entities
         /// <param name="personType">Specify this to limit results to a specific PersonType</param>
         public IEnumerable<BaseItem> GetItemsWithPerson(string person, string personType, User user)
         {
-            return GetParentalAllowedRecursiveChildren(user).Where(c =>
+            return GetRecursiveChildren(user).Where(c =>
             {
                 if (c.People != null)
                 {
@@ -155,7 +425,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public List<BaseItem> GetRecentlyAddedItems(User user)
         {
-            return GetRecentlyAddedItems(GetParentalAllowedRecursiveChildren(user), user);
+            return GetRecentlyAddedItems(GetRecursiveChildren(user), user);
         }
 
         /// <summary>
@@ -163,7 +433,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public List<BaseItem> GetRecentlyAddedUnplayedItems(User user)
         {
-            return GetRecentlyAddedUnplayedItems(GetParentalAllowedRecursiveChildren(user), user);
+            return GetRecentlyAddedUnplayedItems(GetRecursiveChildren(user), user);
         }
 
         /// <summary>
@@ -171,7 +441,7 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         public List<BaseItem> GetInProgressItems(User user)
         {
-            return GetInProgressItems(GetParentalAllowedRecursiveChildren(user), user);
+            return GetInProgressItems(GetRecursiveChildren(user), user);
         }
 
         /// <summary>
@@ -288,7 +558,7 @@ namespace MediaBrowser.Controller.Entities
             base.SetPlayedStatus(user, wasPlayed);
 
             // Now sweep through recursively and update status
-            foreach (BaseItem item in GetParentalAllowedChildren(user))
+            foreach (BaseItem item in GetChildren(user))
             {
                 item.SetPlayedStatus(user, wasPlayed);
             }
@@ -306,7 +576,7 @@ namespace MediaBrowser.Controller.Entities
                 return result;
             }
 
-            foreach (BaseItem item in Children)
+            foreach (BaseItem item in ActualChildren)
             {
                 result = item.FindItemById(id);
 
@@ -329,7 +599,7 @@ namespace MediaBrowser.Controller.Entities
                 return this;
             }
 
-            foreach (BaseItem item in Children)
+            foreach (BaseItem item in ActualChildren)
             {
                 var folder = item as Folder;