Fix played/unplayed filter for empty Series and BoxSets

2 files changed, 26 insertions, 29 deletions

diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs
index a4de9feb05..f5e2e9447a 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs
@@ -503,7 +503,7 @@ public sealed partial class BaseItemRepository
     }
 
     /// <inheritdoc />
-    public IQueryable<Guid> GetFullyPlayedFolderIdsQuery(JellyfinDbContext context, IQueryable<Guid> folderIds, User user)
+    public IQueryable<Guid> GetFoldersWithUnplayedItemsQuery(JellyfinDbContext context, IQueryable<Guid> folderIds, User user)
     {
         ArgumentNullException.ThrowIfNull(context);
         ArgumentNullException.ThrowIfNull(folderIds);
@@ -517,24 +517,27 @@ public sealed partial class BaseItemRepository
             .Where(b => !b.IsFolder && !b.IsVirtualItem);
         leafItems = ApplyAccessFiltering(context, leafItems, filter);
 
-        var playedLeafItems = leafItems
-            .Select(b => new { b.Id, Played = b.UserData!.Any(ud => ud.UserId == userId && ud.Played) });
+        // Only unplayed leaves are joined, so each branch is a semi-join per folder instead of a
+        // played-vs-total count per folder. Folders with no leaves at all simply never match.
+        var unplayedLeafItems = leafItems
+            .Where(b => !b.UserData!.Any(ud => ud.UserId == userId && ud.Played))
+            .Select(b => new { b.Id });
 
         var ancestorLeaves = context.AncestorIds
             .Where(a => folderIds.Contains(a.ParentItemId))
             .Join(
-                playedLeafItems,
+                unplayedLeafItems,
                 a => a.ItemId,
                 b => b.Id,
-                (a, b) => new { FolderId = a.ParentItemId, b.Id, b.Played });
+                (a, b) => a.ParentItemId);
 
         var linkedLeaves = context.LinkedChildren
             .Where(lc => folderIds.Contains(lc.ParentId))
             .Join(
-                playedLeafItems,
+                unplayedLeafItems,
                 lc => lc.ChildId,
                 b => b.Id,
-                (lc, b) => new { FolderId = lc.ParentId, b.Id, b.Played });
+                (lc, b) => lc.ParentId);
 
         var linkedFolderLeaves = context.LinkedChildren
             .Where(lc => folderIds.Contains(lc.ParentId))
@@ -549,16 +552,13 @@ public sealed partial class BaseItemRepository
                 a => a.ParentItemId,
                 (x, a) => new { x.ParentId, DescendantId = a.ItemId })
             .Join(
-                playedLeafItems,
+                unplayedLeafItems,
                 x => x.DescendantId,
                 b => b.Id,
-                (x, b) => new { FolderId = x.ParentId, b.Id, b.Played });
+                (x, b) => x.ParentId);
 
         return ancestorLeaves
             .Union(linkedLeaves)
-            .Union(linkedFolderLeaves)
-            .GroupBy(x => x.FolderId)
-            .Where(g => g.Select(x => x.Id).Distinct().Count() == g.Where(x => x.Played).Select(x => x.Id).Distinct().Count())
-            .Select(g => g.Key);
+            .Union(linkedFolderLeaves);
     }
 }
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
index 47f8a40b9c..6006bfb2bf 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
@@ -476,19 +476,14 @@ public sealed partial class BaseItemRepository
                 var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
                 var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];
 
-                // Series: played = at least one episode AND all episodes played; unplayed = otherwise.
-                IQueryable<Guid> playedSeriesIds = hasSeries
-                    ? context.BaseItems
-                        .AsNoTracking()
-                        .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)
-                        .GroupBy(e => e.SeriesId!.Value)
-                        .Where(g => !g.Any(e => !e.UserData!.Any(ud => ud.UserId == userId && ud.Played)))
-                        .Select(g => g.Key)
-                    : Enumerable.Empty<Guid>().AsQueryable();
+                // Series and BoxSets are matched by absence of an unplayed descendant rather than by
+                // "all descendants played".
+                var seriesEpisodes = context.BaseItems
+                    .AsNoTracking()
+                    .Where(e => !e.IsFolder && !e.IsVirtualItem);
 
-                // BoxSet: played = all children played.
-                IQueryable<Guid> playedBoxSetIds = hasBoxSet
-                    ? GetFullyPlayedFolderIdsQuery(
+                IQueryable<Guid> unplayedBoxSetIds = hasBoxSet
+                    ? GetFoldersWithUnplayedItemsQuery(
                         context,
                         baseQuery.Where(e => e.Type == boxSetTypeName).Select(e => e.Id),
                         filter.User!)
@@ -502,15 +497,17 @@ public sealed partial class BaseItemRepository
                 if (isPlayed)
                 {
                     baseQuery = baseQuery.Where(e =>
-                        (e.Type == seriesTypeName && playedSeriesIds.Contains(e.Id))
-                        || (e.Type == boxSetTypeName && playedBoxSetIds.Contains(e.Id))
+                        (e.Type == seriesTypeName && !seriesEpisodes.Any(ep => ep.SeriesId == e.Id
+                            && !ep.UserData!.Any(ud => ud.UserId == userId && ud.Played)))
+                        || (e.Type == boxSetTypeName && !unplayedBoxSetIds.Contains(e.Id))
                         || (e.Type != seriesTypeName && e.Type != boxSetTypeName && playedItemIds.Contains(e.Id)));
                 }
                 else
                 {
                     baseQuery = baseQuery.Where(e =>
-                        (e.Type == seriesTypeName && !playedSeriesIds.Contains(e.Id))
-                        || (e.Type == boxSetTypeName && !playedBoxSetIds.Contains(e.Id))
+                        (e.Type == seriesTypeName && seriesEpisodes.Any(ep => ep.SeriesId == e.Id
+                            && !ep.UserData!.Any(ud => ud.UserId == userId && ud.Played)))
+                        || (e.Type == boxSetTypeName && unplayedBoxSetIds.Contains(e.Id))
                         || (e.Type != seriesTypeName && e.Type != boxSetTypeName && !playedItemIds.Contains(e.Id)));
                 }
             }