Moved some logic into domain entities, which is possible now that we're embracing DTO's

MediaBrowser.Api/ApiService.cs

@@ -6,6 +6,7 @@ using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller;
 using MediaBrowser.Model.DTO;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Users;
 
 namespace MediaBrowser.Api
 {
@@ -26,10 +27,12 @@ namespace MediaBrowser.Api
         /// </summary>
         public static BaseItemContainer<BaseItem> GetSerializationObject(BaseItem item, bool includeChildren, Guid userId)
         {
+            User user = Kernel.Instance.Users.First(u => u.Id == userId);
+
             BaseItemContainer<BaseItem> wrapper = new BaseItemContainer<BaseItem>()
             {
                 Item = item,
-                UserItemData = Kernel.Instance.GetUserItemData(userId, item.Id),
+                UserItemData = user.GetItemData(item.Id),
                 Type = item.GetType().Name,
                 IsFolder = (item is Folder)
             };
@@ -57,7 +60,7 @@ namespace MediaBrowser.Api
 
                 if (folder != null)
                 {
-                    wrapper.Children = Kernel.Instance.GetParentalAllowedChildren(folder, userId).Select(c => GetSerializationObject(c, false, userId));
+                    wrapper.Children = folder.GetParentalAllowedChildren(user).Select(c => GetSerializationObject(c, false, userId));
                 }
 
                 // Attach People by transforming them into BaseItemPerson (DTO)

MediaBrowser.Api/HttpHandlers/GenresHandler.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using MediaBrowser.Common.Net.Handlers;
 using MediaBrowser.Controller;
 using MediaBrowser.Model.DTO;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Users;
 
 namespace MediaBrowser.Api.HttpHandlers
 {
@@ -13,8 +15,9 @@ namespace MediaBrowser.Api.HttpHandlers
         {
             Folder parent = ApiService.GetItemById(QueryString["id"]) as Folder;
             Guid userId = Guid.Parse(QueryString["userid"]);
+            User user = Kernel.Instance.Users.First(u => u.Id == userId);
 
-            return Kernel.Instance.GetAllGenres(parent, userId);
+            return Kernel.Instance.GetAllGenres(parent, user);
         }
     }
 }

MediaBrowser.Api/HttpHandlers/ItemListHandler.cs

@@ -5,6 +5,7 @@ using MediaBrowser.Common.Net.Handlers;
 using MediaBrowser.Controller;
 using MediaBrowser.Model.DTO;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Users;
 
 namespace MediaBrowser.Api.HttpHandlers
 {
@@ -25,33 +26,35 @@ namespace MediaBrowser.Api.HttpHandlers
             {
                 Folder parent = ApiService.GetItemById(ItemId) as Folder;
 
+                User user = Kernel.Instance.Users.First(u => u.Id == UserId);
+                
                 if (ListType.Equals("inprogressitems", StringComparison.OrdinalIgnoreCase))
                 {
-                    return Kernel.Instance.GetInProgressItems(parent, UserId);
+                    return parent.GetInProgressItems(user);
                 }
                 else if (ListType.Equals("recentlyaddeditems", StringComparison.OrdinalIgnoreCase))
                 {
-                    return Kernel.Instance.GetRecentlyAddedItems(parent, UserId);
+                    return parent.GetRecentlyAddedItems(user);
                 }
                 else if (ListType.Equals("recentlyaddedunplayeditems", StringComparison.OrdinalIgnoreCase))
                 {
-                    return Kernel.Instance.GetRecentlyAddedUnplayedItems(parent, UserId);
+                    return parent.GetRecentlyAddedUnplayedItems(user);
                 }
                 else if (ListType.Equals("itemswithgenre", StringComparison.OrdinalIgnoreCase))
                 {
-                    return Kernel.Instance.GetItemsWithGenre(parent, QueryString["name"], UserId);
+                    return parent.GetItemsWithGenre(QueryString["name"], user);
                 }
                 else if (ListType.Equals("itemswithyear", StringComparison.OrdinalIgnoreCase))
                 {
-                    return Kernel.Instance.GetItemsWithYear(parent, int.Parse(QueryString["year"]), UserId);
+                    return parent.GetItemsWithYear(int.Parse(QueryString["year"]), user);
                 }
                 else if (ListType.Equals("itemswithstudio", StringComparison.OrdinalIgnoreCase))
                 {
-                    return Kernel.Instance.GetItemsWithStudio(parent, QueryString["name"], UserId);
+                    return parent.GetItemsWithStudio(QueryString["name"], user);
                 }
                 else if (ListType.Equals("itemswithperson", StringComparison.OrdinalIgnoreCase))
                 {
-                    return Kernel.Instance.GetItemsWithPerson(parent, QueryString["name"], UserId);
+                    return parent.GetItemsWithPerson(QueryString["name"], null, user);
                 }
 
                 throw new InvalidOperationException();

MediaBrowser.Api/HttpHandlers/StudiosHandler.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using MediaBrowser.Common.Net.Handlers;
 using MediaBrowser.Controller;
 using MediaBrowser.Model.DTO;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Users;
 
 namespace MediaBrowser.Api.HttpHandlers
 {
@@ -13,8 +15,9 @@ namespace MediaBrowser.Api.HttpHandlers
         {
             Folder parent = ApiService.GetItemById(QueryString["id"]) as Folder;
             Guid userId = Guid.Parse(QueryString["userid"]);
+            User user = Kernel.Instance.Users.First(u => u.Id == userId);
 
-            return Kernel.Instance.GetAllStudios(parent, userId);
+            return Kernel.Instance.GetAllStudios(parent, user);
         }
     }
 }

MediaBrowser.Api/HttpHandlers/YearsHandler.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using MediaBrowser.Common.Net.Handlers;
 using MediaBrowser.Controller;
 using MediaBrowser.Model.DTO;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Users;
 
 namespace MediaBrowser.Api.HttpHandlers
 {
@@ -13,8 +15,9 @@ namespace MediaBrowser.Api.HttpHandlers
         {
             Folder parent = ApiService.GetItemById(QueryString["id"]) as Folder;
             Guid userId = Guid.Parse(QueryString["userid"]);
+            User user = Kernel.Instance.Users.First(u => u.Id == userId);
 
-            return Kernel.Instance.GetAllYears(parent, userId);
+            return Kernel.Instance.GetAllYears(parent, user);
         }
     }
 }

MediaBrowser.Controller/Kernel.cs

@@ -197,167 +197,16 @@ namespace MediaBrowser.Controller
             return RootFolder.FindById(id);
         }
 
-        /// <summary>
-        /// Determines if an item is allowed for a given user
-        /// </summary>
-        public bool IsParentalAllowed(BaseItem item, Guid userId)
-        {
-            // not yet implemented
-            return true;
-        }
-
-        /// <summary>
-        /// Gets allowed children of an item
-        /// </summary>
-        public IEnumerable<BaseItem> GetParentalAllowedChildren(Folder folder, Guid userId)
-        {
-            return folder.Children.Where(i => IsParentalAllowed(i, userId));
-        }
-
-        /// <summary>
-        /// Gets allowed recursive children of an item
-        /// </summary>
-        public IEnumerable<BaseItem> GetParentalAllowedRecursiveChildren(Folder folder, Guid userId)
-        {
-            foreach (var item in GetParentalAllowedChildren(folder, userId))
-            {
-                yield return item;
-
-                var subFolder = item as Folder;
-
-                if (subFolder != null)
-                {
-                    foreach (var subitem in GetParentalAllowedRecursiveChildren(subFolder, userId))
-                    {
-                        yield return subitem;
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets user data for an item, if there is any
-        /// </summary>
-        public UserItemData GetUserItemData(Guid userId, Guid itemId)
-        {
-            User user = Users.First(u => u.Id == userId);
-
-            if (user.ItemData.ContainsKey(itemId))
-            {
-                return user.ItemData[itemId];
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Gets all recently added items (recursive) within a folder, based on configuration and parental settings
-        /// </summary>
-        public IEnumerable<BaseItem> GetRecentlyAddedItems(Folder parent, Guid userId)
-        {
-            DateTime now = DateTime.Now;
-
-            User user = Users.First(u => u.Id == userId);
-
-            return GetParentalAllowedRecursiveChildren(parent, userId).Where(i => !(i is Folder) && (now - i.DateCreated).TotalDays < user.RecentItemDays);
-        }
-
-        /// <summary>
-        /// Gets all recently added unplayed items (recursive) within a folder, based on configuration and parental settings
-        /// </summary>
-        public IEnumerable<BaseItem> GetRecentlyAddedUnplayedItems(Folder parent, Guid userId)
-        {
-            return GetRecentlyAddedItems(parent, userId).Where(i =>
-            {
-                var userdata = GetUserItemData(userId, i.Id);
-
-                return userdata == null || userdata.PlayCount == 0;
-            });
-        }
-
-        /// <summary>
-        /// Gets all in-progress items (recursive) within a folder
-        /// </summary>
-        public IEnumerable<BaseItem> GetInProgressItems(Folder parent, Guid userId)
-        {
-            return GetParentalAllowedRecursiveChildren(parent, userId).Where(i =>
-            {
-                if (i is Folder)
-                {
-                    return false;
-                }
-
-                var userdata = GetUserItemData(userId, i.Id);
-
-                return userdata != null && userdata.PlaybackPosition.Ticks > 0;
-            });
-        }
-
-        /// <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(Folder parent, string studio, Guid userId)
-        {
-            return GetParentalAllowedRecursiveChildren(parent, userId).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 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(Folder parent, string person, PersonType? personType, Guid userId)
-        {
-            return GetParentalAllowedRecursiveChildren(parent, userId).Where(c =>
-            {
-                if (c.People != null)
-                {
-                    if (personType.HasValue)
-                    {
-                        return c.People.Any(p => p.Name.Equals(person, StringComparison.OrdinalIgnoreCase) && p.PersonType == personType.Value);
-                    }
-                    else
-                    {
-                        return c.People.Any(p => p.Name.Equals(person, StringComparison.OrdinalIgnoreCase));
-                    }
-                }
-
-                return false;
-            });
-        }
-        /// <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(Folder parent, string genre, Guid userId)
-        {
-            return GetParentalAllowedRecursiveChildren(parent, userId).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(Folder parent, int year, Guid userId)
-        {
-            return GetParentalAllowedRecursiveChildren(parent, userId).Where(f => f.ProductionYear.HasValue && f.ProductionYear == year);
-        }
-
-        /// <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(Folder parent, string personName, Guid userId)
-        {
-            return GetParentalAllowedRecursiveChildren(parent, userId).Where(f => f.People != null && f.People.Any(s => s.Name.Equals(personName, StringComparison.OrdinalIgnoreCase)));
-        }
-
         /// <summary>
         /// Gets all years from all recursive children of a folder
         /// The CategoryInfo class is used to keep track of the number of times each year appears
         /// </summary>
-        public IEnumerable<IBNItem<Year>> GetAllYears(Folder parent, Guid userId)
+        public IEnumerable<IBNItem<Year>> GetAllYears(Folder parent, User user)
         {
             Dictionary<int, int> data = new Dictionary<int, int>();
 
             // Get all the allowed recursive children
-            IEnumerable<BaseItem> allItems = Kernel.Instance.GetParentalAllowedRecursiveChildren(parent, userId);
+            IEnumerable<BaseItem> allItems = parent.GetParentalAllowedRecursiveChildren(user);
 
             foreach (var item in allItems)
             {
@@ -403,12 +252,12 @@ namespace MediaBrowser.Controller
         /// Gets all studios from all recursive children of a folder
         /// The CategoryInfo class is used to keep track of the number of times each studio appears
         /// </summary>
-        public IEnumerable<IBNItem<Studio>> GetAllStudios(Folder parent, Guid userId)
+        public IEnumerable<IBNItem<Studio>> GetAllStudios(Folder parent, User user)
         {
             Dictionary<string, int> data = new Dictionary<string, int>();
 
             // Get all the allowed recursive children
-            IEnumerable<BaseItem> allItems = Kernel.Instance.GetParentalAllowedRecursiveChildren(parent, userId);
+            IEnumerable<BaseItem> allItems = parent.GetParentalAllowedRecursiveChildren(user);
 
             foreach (var item in allItems)
             {
@@ -457,12 +306,12 @@ namespace MediaBrowser.Controller
         /// Gets all genres from all recursive children of a folder
         /// The CategoryInfo class is used to keep track of the number of times each genres appears
         /// </summary>
-        public IEnumerable<IBNItem<Genre>> GetAllGenres(Folder parent, Guid userId)
+        public IEnumerable<IBNItem<Genre>> GetAllGenres(Folder parent, User user)
         {
             Dictionary<string, int> data = new Dictionary<string, int>();
 
             // Get all the allowed recursive children
-            IEnumerable<BaseItem> allItems = Kernel.Instance.GetParentalAllowedRecursiveChildren(parent, userId);
+            IEnumerable<BaseItem> allItems = parent.GetParentalAllowedRecursiveChildren(user);
 
             foreach (var item in allItems)
             {

MediaBrowser.Model/Entities/BaseItem.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.Serialization;
+using MediaBrowser.Model.Users;
 
 namespace MediaBrowser.Model.Entities
 {
@@ -101,5 +102,13 @@ namespace MediaBrowser.Model.Entities
         {
             SetProviderId(provider.ToString(), value);
         }
+
+        /// <summary>
+        /// Determines if a given user has access to this item
+        /// </summary>
+        internal bool IsParentalAllowed(User user)
+        {
+            return true;
+        }
     }
 }

MediaBrowser.Model/Entities/Folder.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.Serialization;
+using MediaBrowser.Model.Users;
 
 namespace MediaBrowser.Model.Entities
 {
@@ -18,6 +21,124 @@ namespace MediaBrowser.Model.Entities
         [IgnoreDataMember]
         public 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>
+        /// 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 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, PersonType? personType, User user)
+        {
+            return GetParentalAllowedRecursiveChildren(user).Where(c =>
+            {
+                if (c.People != null)
+                {
+                    if (personType.HasValue)
+                    {
+                        return c.People.Any(p => p.Name.Equals(person, StringComparison.OrdinalIgnoreCase) && p.PersonType == personType.Value);
+                    }
+                    else
+                    {
+                        return c.People.Any(p => p.Name.Equals(person, 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)
+        {
+            DateTime now = DateTime.Now;
+
+            return GetParentalAllowedRecursiveChildren(user).Where(i => !(i is Folder) && (now - i.DateCreated).TotalDays < user.RecentItemDays);
+        }
+
+        /// <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 GetRecentlyAddedItems(user).Where(i =>
+            {
+                var userdata = user.GetItemData(i.Id);
+
+                return userdata == null || userdata.PlayCount == 0;
+            });
+        }
+
+        /// <summary>
+        /// Gets all in-progress items (recursive) within a folder
+        /// </summary>
+        public IEnumerable<BaseItem> GetInProgressItems(User user)
+        {
+            return GetParentalAllowedRecursiveChildren(user).Where(i =>
+            {
+                if (i is Folder)
+                {
+                    return false;
+                }
+
+                var userdata = user.GetItemData(i.Id);
+
+                return userdata != null && userdata.PlaybackPosition.Ticks > 0;
+            });
+        }
+
         /// <summary>
         /// Finds an item by ID, recursively
         /// </summary>

MediaBrowser.Model/Users/User.cs

@@ -17,5 +17,18 @@ namespace MediaBrowser.Model.Users
         {
             RecentItemDays = 14;
         }
+
+        /// <summary>
+        /// Gets user data for an item, if there is any
+        /// </summary>
+        public UserItemData GetItemData(Guid itemId)
+        {
+            if (ItemData.ContainsKey(itemId))
+            {
+                return ItemData[itemId];
+            }
+
+            return null;
+        }
     }
 }