update icons

MediaBrowser.Controller/Entities/Audio/MusicArtist.cs

@@ -40,6 +40,20 @@ namespace MediaBrowser.Controller.Entities.Audio
             return !IsAccessedByName;
         }
 
+        public IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query)
+        {
+            var itemByNameFilter = GetItemFilter();
+
+            if (query.User != null)
+            {
+                return query.User.RootFolder
+                    .GetRecursiveChildren(query.User, i => !i.IsFolder && itemByNameFilter(i));
+            }
+
+            return LibraryManager.RootFolder
+                .GetRecursiveChildren(i => !i.IsFolder && itemByNameFilter(i));
+        }
+
         protected override IEnumerable<BaseItem> ActualChildren
         {
             get

MediaBrowser.Controller/Entities/Audio/MusicGenre.cs

@@ -79,5 +79,13 @@ namespace MediaBrowser.Controller.Entities.Audio
                 return false;
             }
         }
+
+        public IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query)
+        {
+            query.Genres = new[] { Name };
+            query.ExcludeItemTypes = new[] { typeof(MusicVideo).Name, typeof(Audio).Name, typeof(MusicAlbum).Name, typeof(MusicArtist).Name };
+
+            return LibraryManager.GetItemList(query);
+        }
     }
 }

MediaBrowser.Controller/Entities/GameGenre.cs

@@ -62,6 +62,14 @@ namespace MediaBrowser.Controller.Entities
             return i => i is Game && i.Genres.Contains(Name, StringComparer.OrdinalIgnoreCase);
         }
 
+        public IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query)
+        {
+            query.Genres = new[] { Name };
+            query.IncludeItemTypes = new[] { typeof(Game).Name };
+
+            return LibraryManager.GetItemList(query);
+        }
+
         [IgnoreDataMember]
         public override bool SupportsPeople
         {

MediaBrowser.Controller/Entities/Genre.cs

@@ -66,6 +66,14 @@ namespace MediaBrowser.Controller.Entities
             return i => !(i is Game) && !(i is IHasMusicGenres) && i.Genres.Contains(Name, StringComparer.OrdinalIgnoreCase);
         }
 
+        public IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query)
+        {
+            query.Genres = new[] { Name };
+            query.ExcludeItemTypes = new[] { typeof(Game).Name, typeof(MusicVideo).Name, typeof(Audio.Audio).Name, typeof(MusicAlbum).Name, typeof(MusicArtist).Name };
+
+            return LibraryManager.GetItemList(query);
+        }
+
         [IgnoreDataMember]
         public override bool SupportsPeople
         {

MediaBrowser.Controller/Entities/IItemByName.cs

@@ -20,6 +20,8 @@ namespace MediaBrowser.Controller.Entities
         /// </summary>
         /// <returns>Func&lt;BaseItem, System.Boolean&gt;.</returns>
         Func<BaseItem, bool> GetItemFilter();
+
+        IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query);
     }
 
     public interface IHasDualAccess : IItemByName

MediaBrowser.Controller/Entities/InternalItemsQuery.cs

@@ -134,6 +134,7 @@ namespace MediaBrowser.Controller.Entities
 
         public string[] AlbumNames { get; set; }
         public string[] ArtistNames { get; set; }
+        public string AncestorWithPresentationUniqueKey { get; set; }
 
         public bool GroupByPresentationUniqueKey { get; set; }
 

MediaBrowser.Controller/Entities/Person.cs

@@ -31,6 +31,13 @@ namespace MediaBrowser.Controller.Entities
             return GetItemLookupInfo<PersonLookupInfo>();
         }
 
+        public IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query)
+        {
+            query.Person = Name;
+
+            return LibraryManager.GetItemList(query);
+        }
+
         /// <summary>
         /// Returns the folder containing the item.
         /// If the item is a folder, it returns the folder itself

MediaBrowser.Controller/Entities/PhotoAlbum.cs

@@ -7,15 +7,6 @@ namespace MediaBrowser.Controller.Entities
 {
     public class PhotoAlbum : Folder
     {
-        [IgnoreDataMember]
-        public override bool SupportsLocalMetadata
-        {
-            get
-            {
-                return false;
-            }
-        }
-
         [IgnoreDataMember]
         public override bool AlwaysScanInternalMetadataPath
         {

MediaBrowser.Controller/Entities/Studio.cs

@@ -65,6 +65,13 @@ namespace MediaBrowser.Controller.Entities
             return i => i.Studios.Contains(Name, StringComparer.OrdinalIgnoreCase);
         }
 
+        public IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query)
+        {
+            query.Studios = new[] { Name };
+
+            return LibraryManager.GetItemList(query);
+        }
+
         [IgnoreDataMember]
         public override bool SupportsPeople
         {

MediaBrowser.Controller/Entities/TV/Series.cs

@@ -9,6 +9,7 @@ using System.Linq;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
+using MoreLinq;
 
 namespace MediaBrowser.Controller.Entities.TV
 {
@@ -180,7 +181,7 @@ namespace MediaBrowser.Controller.Entities.TV
             else
             {
                 items = query.Recursive
-                   ? GetRecursiveChildren(user, filter)
+                   ? GetSeasons(user).Cast<BaseItem>().Concat(GetEpisodes(user)).Where(filter)
                    : GetSeasons(user).Where(filter);
             }
 
@@ -211,7 +212,7 @@ namespace MediaBrowser.Controller.Entities.TV
             }
             else
             {
-                seasons = base.GetChildren(user, true).OfType<Season>();
+                seasons = LibraryManager.Sort(base.GetChildren(user, true), user, new[] { ItemSortBy.SortName }, SortOrder.Ascending).OfType<Season>();
             }
 
             if (!includeMissingSeasons && !includeVirtualUnaired)
@@ -250,17 +251,8 @@ namespace MediaBrowser.Controller.Entities.TV
             // Specials could appear twice based on above - once in season 0, once in the aired season
             // This depends on settings for that series
             // When this happens, remove the duplicate from season 0
-            var returnList = new List<Episode>();
 
-            foreach (var episode in allEpisodes)
+            return allEpisodes.DistinctBy(i => i.Id).Reverse();
-            {
-                if (!returnList.Contains(episode))
-                {
-                    returnList.Insert(0, episode);
-                }
-            }
-
-            return returnList;
         }
 
         public async Task RefreshAllMetadata(MetadataRefreshOptions refreshOptions, IProgress<double> progress, CancellationToken cancellationToken)

MediaBrowser.Controller/Entities/Year.cs

@@ -70,6 +70,22 @@ namespace MediaBrowser.Controller.Entities
             return inputItems.Where(i => i.ProductionYear.HasValue && i.ProductionYear.Value == year);
         }
 
+        public IEnumerable<BaseItem> GetTaggedItems(InternalItemsQuery query)
+        {
+            int year;
+
+            var usCulture = new CultureInfo("en-US");
+
+            if (!int.TryParse(Name, NumberStyles.Integer, usCulture, out year))
+            {
+                return new List<BaseItem>();
+            }
+
+            query.Years = new[] { year };
+
+            return LibraryManager.GetItemList(query);
+        }
+
         public int? GetYearValue()
         {
             int i;

MediaBrowser.Controller/Playlists/Playlist.cs

@@ -99,11 +99,12 @@ namespace MediaBrowser.Controller.Playlists
             var musicGenre = item as MusicGenre;
             if (musicGenre != null)
             {
-                Func<BaseItem, bool> filter = i => i is Audio && i.Genres.Contains(musicGenre.Name, StringComparer.OrdinalIgnoreCase);
+                var items = LibraryManager.GetItemList(new InternalItemsQuery(user)
-
+                {
-                var items = user == null
+                    Recursive = true,
-                    ? LibraryManager.RootFolder.GetRecursiveChildren(filter)
+                    IncludeItemTypes = new[] { typeof(Audio).Name },
-                    : user.RootFolder.GetRecursiveChildren(user, filter);
+                    Genres = new[] { musicGenre.Name }
+                });
 
                 return LibraryManager.Sort(items, user, new[] { ItemSortBy.AlbumArtist, ItemSortBy.Album, ItemSortBy.SortName }, SortOrder.Ascending);
             }

MediaBrowser.Server.Implementations/Library/MusicManager.cs

@@ -55,7 +55,7 @@ namespace MediaBrowser.Server.Implementations.Library
         public IEnumerable<Audio> GetInstantMixFromFolder(Folder item, User user)
         {
             var genres = item
-                .GetRecursiveChildren(user, i => i is Audio)
+               .GetRecursiveChildren(user, i => i is Audio)
                .Cast<Audio>()
                .SelectMany(i => i.Genres)
                .Concat(item.Genres)

MediaBrowser.Server.Implementations/Persistence/SqliteItemRepository.cs

@@ -2334,6 +2334,12 @@ namespace MediaBrowser.Server.Implementations.Persistence
                 var inClause = string.Join(",", query.AncestorIds.Select(i => "'" + new Guid(i).ToString("N") + "'").ToArray());
                 whereClauses.Add(string.Format("Guid in (select itemId from AncestorIds where AncestorIdText in ({0}))", inClause));
             }
+            if (!string.IsNullOrWhiteSpace(query.AncestorWithPresentationUniqueKey))
+            {
+                var inClause = "select guid from TypedBaseItems where PresentationUniqueKey=@AncestorWithPresentationUniqueKey";
+                whereClauses.Add(string.Format("Guid in (select itemId from AncestorIds where AncestorId in ({0}))", inClause));
+                cmd.Parameters.Add(cmd, "@AncestorWithPresentationUniqueKey", DbType.String).Value = query.AncestorWithPresentationUniqueKey;
+            }
 
             if (query.BlockUnratedItems.Length == 1)
             {

MediaBrowser.Server.Implementations/Photos/BaseDynamicImageProvider.cs

@@ -109,6 +109,21 @@ namespace MediaBrowser.Server.Implementations.Photos
 
         protected async Task<ItemUpdateType> FetchAsync(IHasImages item, ImageType imageType, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
+            var image = item.GetImageInfo(imageType, 0);
+
+            if (image != null)
+            {
+                if (!image.IsLocalFile)
+                {
+                    return ItemUpdateType.None;
+                }
+
+                if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
+                {
+                    return ItemUpdateType.None;
+                }
+            }
+
             var items = await GetItemsWithImages(item).ConfigureAwait(false);
 
             return await FetchToFileInternal(item, items, imageType, cancellationToken).ConfigureAwait(false);

MediaBrowser.Server.Implementations/Session/SessionManager.cs

@@ -848,7 +848,7 @@ namespace MediaBrowser.Server.Implementations.Session
             if (!playbackFailed)
             {
                 var data = _userDataRepository.GetUserData(userId, item);
-                
+
                 if (positionTicks.HasValue)
                 {
                     playedToCompletion = _userDataRepository.UpdatePlayState(item, data, positionTicks.Value);
@@ -1026,11 +1026,11 @@ namespace MediaBrowser.Server.Implementations.Session
 
             if (byName != null)
             {
-                var itemFilter = byName.GetItemFilter();
+                var items = byName.GetTaggedItems(new InternalItemsQuery(user)
-
+                {
-                var items = user == null ?
+                    IsFolder = false,
-                    _libraryManager.RootFolder.GetRecursiveChildren(i => !i.IsFolder && itemFilter(i)) :
+                    Recursive = true
-                    user.RootFolder.GetRecursiveChildren(user, i => !i.IsFolder && itemFilter(i));
+                });
 
                 return FilterToSingleMediaType(items)
                     .OrderBy(i => i.SortName);
@@ -1040,9 +1040,12 @@ namespace MediaBrowser.Server.Implementations.Session
             {
                 var folder = (Folder)item;
 
-                var items = user == null ?
+                var items = folder.GetItems(new InternalItemsQuery(user)
-                    folder.GetRecursiveChildren(i => !i.IsFolder) :
+                {
-                    folder.GetRecursiveChildren(user, i => !i.IsFolder);
+                    Recursive = true,
+                    IsFolder = false
+
+                }).Result.Items;
 
                 return FilterToSingleMediaType(items)
                     .OrderBy(i => i.SortName);
@@ -1367,8 +1370,8 @@ namespace MediaBrowser.Server.Implementations.Session
                 ServerId = _appHost.SystemId
             };
         }
-        
+
-        
+
         private async Task<string> GetAuthorizationToken(string userId, string deviceId, string app, string appVersion, string deviceName)
         {
             var existing = _authRepo.Get(new AuthenticationInfoQuery

MediaBrowser.Server.Implementations/Sync/SyncJobProcessor.cs

@@ -326,32 +326,26 @@ namespace MediaBrowser.Server.Implementations.Sync
             var itemByName = item as IItemByName;
             if (itemByName != null)
             {
-                var itemByNameFilter = itemByName.GetItemFilter();
+                return itemByName.GetTaggedItems(new InternalItemsQuery(user)
-
+                {
-                return user.RootFolder
+                    IsFolder = false,
-                    .GetRecursiveChildren(user, i => !i.IsFolder && itemByNameFilter(i));
+                    Recursive = true
-            }
+                });
-
-            var series = item as Series;
-            if (series != null)
-            {
-                return series.GetEpisodes(user, false, false);
-            }
-
-            var season = item as Season;
-            if (season != null)
-            {
-                return season.GetEpisodes(user, false, false);
             }
 
             if (item.IsFolder)
             {
                 var folder = (Folder)item;
-                var items = folder.GetRecursiveChildren(user, i => !i.IsFolder);
+                var items = folder.GetItems(new InternalItemsQuery(user)
+                {
+                    Recursive = true,
+                    IsFolder = false
+
+                }).Result.Items;
 
                 if (!folder.IsPreSorted)
                 {
-                    items = items.OrderBy(i => i.SortName);
+                    items = items.OrderBy(i => i.SortName).ToArray();
                 }
 
                 return items;