Moved some entities to the main project

1 files changed, 323 insertions, 0 deletions

diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
new file mode 100644
index 000000000..a9c92c1fa
--- /dev/null
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -0,0 +1,323 @@
+using MediaBrowser.Model.Entities;

+using System;

+using System.Collections.Generic;

+using System.Linq;

+

+namespace MediaBrowser.Controller.Entities

+{

+    public class Folder : BaseItem

+    {

+        public override bool IsFolder

+        {

+            get

+            {

+                return true;

+            }

+        }

+

+        public bool IsRoot { get; set; }

+

+        public bool IsVirtualFolder

+        {

+            get

+            {

+                return Parent != null && Parent.IsRoot;

+            }

+        }

+

+        public IEnumerable<BaseItem> Children { get; set; }

+

+        /// <summary>

+        /// Gets allowed children of an item

+        /// </summary>

+        public IEnumerable<BaseItem> GetParentalAllowedChildren(User user)

+        {

+            return Children.Where(c => c.IsParentalAllowed(user));

+        }

+

+        /// <summary>

+        /// Gets allowed recursive children of an item

+        /// </summary>

+        public IEnumerable<BaseItem> GetParentalAllowedRecursiveChildren(User user)

+        {

+            foreach (var item in GetParentalAllowedChildren(user))

+            {

+                yield return item;

+

+                var subFolder = item as Folder;

+

+                if (subFolder != null)

+                {

+                    foreach (var subitem in subFolder.GetParentalAllowedRecursiveChildren(user))

+                    {

+                        yield return subitem;

+                    }

+                }

+            }

+        }

+

+        /// <summary>

+        /// Since it can be slow to make all of these calculations at once, this method will provide a way to get them all back together

+        /// </summary>

+        public ItemSpecialCounts GetSpecialCounts(User user)

+        {

+            ItemSpecialCounts counts = new ItemSpecialCounts();

+

+            IEnumerable<BaseItem> recursiveChildren = GetParentalAllowedRecursiveChildren(user);

+

+            counts.RecentlyAddedItemCount = GetRecentlyAddedItems(recursiveChildren, user).Count();

+            counts.RecentlyAddedUnPlayedItemCount = GetRecentlyAddedUnplayedItems(recursiveChildren, user).Count();

+            counts.InProgressItemCount = GetInProgressItems(recursiveChildren, user).Count();

+            counts.PlayedPercentage = GetPlayedPercentage(recursiveChildren, user);

+

+            return counts;

+        }

+

+        /// <summary>

+        /// Finds all recursive items within a top-level parent that contain the given genre and are allowed for the current user

+        /// </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)));

+        }

+

+        /// <summary>

+        /// Finds all recursive items within a top-level parent that contain the given year and are allowed for the current user

+        /// </summary>

+        public IEnumerable<BaseItem> GetItemsWithYear(int year, User user)

+        {

+            return GetParentalAllowedRecursiveChildren(user).Where(f => f.ProductionYear.HasValue && f.ProductionYear == year);

+        }

+

+        /// <summary>

+        /// Finds all recursive items within a top-level parent that contain the given studio and are allowed for the current user

+        /// </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)));

+        }

+

+        /// <summary>

+        /// Finds all recursive items within a top-level parent that the user has marked as a favorite

+        /// </summary>

+        public IEnumerable<BaseItem> GetFavoriteItems(User user)

+        {

+            return GetParentalAllowedRecursiveChildren(user).Where(c =>

+            {

+                UserItemData data = c.GetUserData(user, false);

+

+                if (data != null)

+                {

+                    return data.IsFavorite;

+                }

+

+                return false;

+            });

+        }

+

+        /// <summary>

+        /// Finds all recursive items within a top-level parent that contain the given person and are allowed for the current user

+        /// </summary>

+        public IEnumerable<BaseItem> GetItemsWithPerson(string person, User user)

+        {

+            return GetParentalAllowedRecursiveChildren(user).Where(c =>

+            {

+                if (c.People != null)

+                {

+                    return c.People.ContainsKey(person);

+                }

+

+                return false;

+            });

+        }

+

+        /// <summary>

+        /// Finds all recursive items within a top-level parent that contain the given person and are allowed for the current user

+        /// </summary>

+        /// <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 =>

+            {

+                if (c.People != null)

+                {

+                    return c.People.ContainsKey(person) && c.People[person].Type.Equals(personType, StringComparison.OrdinalIgnoreCase);

+                }

+

+                return false;

+            });

+        }

+

+        /// <summary>

+        /// Gets all recently added items (recursive) within a folder, based on configuration and parental settings

+        /// </summary>

+        public IEnumerable<BaseItem> GetRecentlyAddedItems(User user)

+        {

+            return GetRecentlyAddedItems(GetParentalAllowedRecursiveChildren(user), user);

+        }

+

+        /// <summary>

+        /// Gets all recently added unplayed items (recursive) within a folder, based on configuration and parental settings

+        /// </summary>

+        public IEnumerable<BaseItem> GetRecentlyAddedUnplayedItems(User user)

+        {

+            return GetRecentlyAddedUnplayedItems(GetParentalAllowedRecursiveChildren(user), user);

+        }

+

+        /// <summary>

+        /// Gets all in-progress items (recursive) within a folder

+        /// </summary>

+        public IEnumerable<BaseItem> GetInProgressItems(User user)

+        {

+            return GetInProgressItems(GetParentalAllowedRecursiveChildren(user), user);

+        }

+

+        /// <summary>

+        /// Takes a list of items and returns the ones that are recently added

+        /// </summary>

+        private static IEnumerable<BaseItem> GetRecentlyAddedItems(IEnumerable<BaseItem> itemSet, User user)

+        {

+            return itemSet.Where(i => !(i.IsFolder) && i.IsRecentlyAdded(user));

+        }

+

+        /// <summary>

+        /// Takes a list of items and returns the ones that are recently added and unplayed

+        /// </summary>

+        private static IEnumerable<BaseItem> GetRecentlyAddedUnplayedItems(IEnumerable<BaseItem> itemSet, User user)

+        {

+            return GetRecentlyAddedItems(itemSet, user).Where(i =>

+            {

+                var userdata = i.GetUserData(user, false);

+

+                return userdata == null || userdata.PlayCount == 0;

+            });

+        }

+

+        /// <summary>

+        /// Takes a list of items and returns the ones that are in progress

+        /// </summary>

+        private static IEnumerable<BaseItem> GetInProgressItems(IEnumerable<BaseItem> itemSet, User user)

+        {

+            return itemSet.Where(i =>

+            {

+                if (i.IsFolder)

+                {

+                    return false;

+                }

+

+                var userdata = i.GetUserData(user, false);

+

+                return userdata != null && userdata.PlaybackPositionTicks > 0;

+            });

+        }

+

+        /// <summary>

+        /// Gets the total played percentage for a set of items

+        /// </summary>

+        private static decimal GetPlayedPercentage(IEnumerable<BaseItem> itemSet, User user)

+        {

+            itemSet = itemSet.Where(i => !(i.IsFolder));

+

+            if (!itemSet.Any())

+            {

+                return 0;

+            }

+

+            decimal totalPercent = 0;

+

+            foreach (BaseItem item in itemSet)

+            {

+                UserItemData data = item.GetUserData(user, false);

+

+                if (data == null)

+                {

+                    continue;

+                }

+

+                if (data.PlayCount > 0)

+                {

+                    totalPercent += 100;

+                }

+                else if (data.PlaybackPositionTicks > 0 && item.RunTimeTicks.HasValue)

+                {

+                    decimal itemPercent = data.PlaybackPositionTicks;

+                    itemPercent /= item.RunTimeTicks.Value;

+                    totalPercent += itemPercent;

+                }

+            }

+

+            return totalPercent / itemSet.Count();

+        }

+

+        /// <summary>

+        /// Marks the item as either played or unplayed

+        /// </summary>

+        public override void SetPlayedStatus(User user, bool wasPlayed)

+        {

+            base.SetPlayedStatus(user, wasPlayed);

+

+            // Now sweep through recursively and update status

+            foreach (BaseItem item in GetParentalAllowedChildren(user))

+            {

+                item.SetPlayedStatus(user, wasPlayed);

+            }

+        }

+

+        /// <summary>

+        /// Finds an item by ID, recursively

+        /// </summary>

+        public override BaseItem FindItemById(Guid id)

+        {

+            var result = base.FindItemById(id);

+

+            if (result != null)

+            {

+                return result;

+            }

+

+            foreach (BaseItem item in Children)

+            {

+                result = item.FindItemById(id);

+

+                if (result != null)

+                {

+                    return result;

+                }

+            }

+

+            return null;

+        }

+

+        /// <summary>

+        /// Finds an item by path, recursively

+        /// </summary>

+        public BaseItem FindByPath(string path)

+        {

+            if (Path.Equals(path, StringComparison.OrdinalIgnoreCase))

+            {

+                return this;

+            }

+

+            foreach (BaseItem item in Children)

+            {

+                var folder = item as Folder;

+

+                if (folder != null)

+                {

+                    var foundItem = folder.FindByPath(path);

+

+                    if (foundItem != null)

+                    {

+                        return foundItem;

+                    }

+                }

+                else if (item.Path.Equals(path, StringComparison.OrdinalIgnoreCase))

+                {

+                    return item;

+                }

+            }

+

+            return null;

+        }

+    }

+}