Implemented some IBN functionality - GetPerson, GetYear, GetStudio, GetGenre

MediaBrowser.Controller/Kernel.cs

@@ -314,6 +314,14 @@ namespace MediaBrowser.Controller
             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>
@@ -322,6 +330,57 @@ namespace MediaBrowser.Controller
             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<CategoryInfo<Year>> GetAllYears(Folder parent, Guid userId)
+        {
+            Dictionary<int, int> data = new Dictionary<int, int>();
+
+            // Get all the allowed recursive children
+            IEnumerable<BaseItem> allItems = Kernel.Instance.GetParentalAllowedRecursiveChildren(parent, userId);
+
+            foreach (var item in allItems)
+            {
+                // Add the year from the item to the data dictionary
+                // If the year already exists, increment the count
+                if (item.ProductionYear == null)
+                {
+                    continue;
+                }
+
+                if (!data.ContainsKey(item.ProductionYear.Value))
+                {
+                    data.Add(item.ProductionYear.Value, 1);
+                }
+                else
+                {
+                    data[item.ProductionYear.Value]++;
+                }
+            }
+
+            // Now go through the dictionary and create a Category for each studio
+            List<CategoryInfo<Year>> list = new List<CategoryInfo<Year>>();
+
+            foreach (int key in data.Keys)
+            {
+                // Get the original entity so that we can also supply the PrimaryImagePath
+                Year entity = Kernel.Instance.ItemController.GetYear(key);
+
+                if (entity != null)
+                {
+                    list.Add(new CategoryInfo<Year>()
+                    {
+                        Item = entity,
+                        ItemCount = data[key]
+                    });
+                }
+            }
+
+            return list;
+        }
+
         /// <summary>
         /// 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
@@ -441,7 +500,7 @@ namespace MediaBrowser.Controller
             User user = new User();
 
             user.Name = "Default User";
-            user.Id = Guid.NewGuid();
+            user.Id = Guid.Parse("5d1cf7fce25943b790d140095457a42b");
 
             list.Add(user);
 

MediaBrowser.Controller/Library/ItemController.cs

@@ -8,6 +8,7 @@ using MediaBrowser.Controller.Events;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Common.Configuration;
 
 namespace MediaBrowser.Controller.Library
 {
@@ -57,41 +58,41 @@ namespace MediaBrowser.Controller.Library
         }
         #endregion
 
-        #region Item Events
+        #region BaseItem Events
         /// <summary>
         /// Called when an item is being created.
         /// This should be used to fill item values, such as metadata
         /// </summary>
-        public event EventHandler<GenericItemEventArgs<BaseItem>> ItemCreating;
+        public event EventHandler<GenericItemEventArgs<BaseItem>> BaseItemCreating;
 
         /// <summary>
         /// Called when an item has been created.
         /// This should be used to process or modify item values.
         /// </summary>
-        public event EventHandler<GenericItemEventArgs<BaseItem>> ItemCreated;
+        public event EventHandler<GenericItemEventArgs<BaseItem>> BaseItemCreated;
         #endregion
 
         /// <summary>
         /// Called when an item has been created
         /// </summary>
-        private void OnItemCreated(BaseItem item, Folder parent)
+        private void OnBaseItemCreated(BaseItem item, Folder parent)
         {
             GenericItemEventArgs<BaseItem> args = new GenericItemEventArgs<BaseItem> { Item = item };
 
-            if (ItemCreating != null)
+            if (BaseItemCreating != null)
             {
-                ItemCreating(this, args);
+                BaseItemCreating(this, args);
             }
 
-            if (ItemCreated != null)
+            if (BaseItemCreated != null)
             {
-                ItemCreated(this, args);
+                BaseItemCreated(this, args);
             }
         }
 
         private void FireCreateEventsRecursive(Folder folder, Folder parent)
         {
-            OnItemCreated(folder, parent);
+            OnBaseItemCreated(folder, parent);
 
             int count = folder.Children.Length;
 
@@ -107,7 +108,7 @@ namespace MediaBrowser.Controller.Library
                 }
                 else
                 {
-                    OnItemCreated(item, folder);
+                    OnBaseItemCreated(item, folder);
                 }
             });
         }
@@ -153,7 +154,7 @@ namespace MediaBrowser.Controller.Library
                 }
                 else
                 {
-                    OnItemCreated(item, parent);
+                    OnBaseItemCreated(item, parent);
                 }
             }
 
@@ -299,28 +300,98 @@ namespace MediaBrowser.Controller.Library
             return returnFiles;
         }
 
+        /// <summary>
+        /// Gets a Person
+        /// </summary>
         public Person GetPerson(string name)
         {
-            // not yet implemented
-            return null;
+            string path = Path.Combine(ApplicationPaths.PeoplePath, name);
+
+            return GetImagesByNameItem<Person>(path, name);
         }
 
+        /// <summary>
+        /// Gets a Studio
+        /// </summary>
         public Studio GetStudio(string name)
         {
-            // not yet implemented
-            return null;
+            string path = Path.Combine(ApplicationPaths.StudioPath, name);
+
+            return GetImagesByNameItem<Studio>(path, name);
         }
 
+        /// <summary>
+        /// Gets a Genre
+        /// </summary>
         public Genre GetGenre(string name)
         {
-            // not yet implemented
-            return null;
+            string path = Path.Combine(ApplicationPaths.GenrePath, name);
+
+            return GetImagesByNameItem<Genre>(path, name);
         }
 
+        /// <summary>
+        /// Gets a Year
+        /// </summary>
         public Year GetYear(int value)
         {
-            // not yet implemented
-            return null;
+            string path = Path.Combine(ApplicationPaths.YearPath, value.ToString());
+
+            return GetImagesByNameItem<Year>(path, value.ToString());
+        }
+
+        private Dictionary<string, object> ImagesByNameItemCache = new Dictionary<string, object>();
+
+        /// <summary>
+        /// Generically retrieves an IBN item
+        /// </summary>
+        private T GetImagesByNameItem<T>(string path, string name)
+            where T : BaseEntity, new()
+        {
+            string key = path.ToLower();
+
+            // Look for it in the cache, if it's not there, create it
+            if (!ImagesByNameItemCache.ContainsKey(key))
+            {
+                ImagesByNameItemCache[key] = CreateImagesByNameItem<T>(path, name);
+            }
+
+            return ImagesByNameItemCache[key] as T;
+        }
+
+        /// <summary>
+        /// Creates an IBN item based on a given path
+        /// </summary>
+        private T CreateImagesByNameItem<T>(string path, string name)
+            where T : BaseEntity, new ()
+        {
+            T item = new T();
+
+            item.Name = name;
+            item.Id = Kernel.GetMD5(path);
+
+            if (Directory.Exists(path))
+            {
+                item.DateCreated = Directory.GetCreationTime(path);
+                item.DateModified = Directory.GetLastAccessTime(path);
+                if (File.Exists(Path.Combine(path, "folder.jpg")))
+                {
+                    item.PrimaryImagePath = Path.Combine(path, "folder.jpg");
+                }
+                else if (File.Exists(Path.Combine(path, "folder.png")))
+                {
+                    item.PrimaryImagePath = Path.Combine(path, "folder.png");
+                }
+            }
+            else
+            {
+                DateTime now = DateTime.Now;
+
+                item.DateCreated = now;
+                item.DateModified = now;
+            }
+
+            return item;
         }
     }
 }