From 2cfcb9ac0cfae50aa1a5be456fa6178cb4a2aaef Mon Sep 17 00:00:00 2001 From: Ethan Pippin Date: Thu, 12 Nov 2026 00:42:03 -0500 Subject: Years, Ratings for filters endpoints --- .../Library/LibraryManager.cs | 24 + Jellyfin.Api/Controllers/FilterController.cs | 21 +- .../Item/BaseItemRepository.Querying.cs | 60 ++- MediaBrowser.Controller/Library/ILibraryManager.cs | 14 + .../Persistence/IItemRepository.cs | 14 + MediaBrowser.Model/Querying/QueryFilters.cs | 6 + .../Library/QueryFiltersTests.cs | 534 +++++++++++++++++++++ .../Controllers/FilterControllerTests.cs | 35 ++ 8 files changed, 685 insertions(+), 23 deletions(-) create mode 100644 tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs create mode 100644 tests/Jellyfin.Server.Integration.Tests/Controllers/FilterControllerTests.cs diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs index 16616dd328..92c83756c3 100644 --- a/Emby.Server.Implementations/Library/LibraryManager.cs +++ b/Emby.Server.Implementations/Library/LibraryManager.cs @@ -4199,6 +4199,30 @@ namespace Emby.Server.Implementations.Library return _itemRepository.GetQueryFiltersLegacy(query); } + /// + public IReadOnlyList GetYears(InternalItemsQuery query) + { + if (query.User is not null) + { + AddUserToQuery(query, query.User); + } + + SetTopParentOrAncestorIds(query); + return _itemRepository.GetYears(query); + } + + /// + public IReadOnlyList GetOfficialRatings(InternalItemsQuery query) + { + if (query.User is not null) + { + AddUserToQuery(query, query.User); + } + + SetTopParentOrAncestorIds(query); + return _itemRepository.GetOfficialRatings(query); + } + /// public IReadOnlyList GetTagNames(InternalItemsQuery query) { diff --git a/Jellyfin.Api/Controllers/FilterController.cs b/Jellyfin.Api/Controllers/FilterController.cs index b9ca45cc1c..e0fb231df5 100644 --- a/Jellyfin.Api/Controllers/FilterController.cs +++ b/Jellyfin.Api/Controllers/FilterController.cs @@ -82,7 +82,8 @@ public class FilterController : BaseJellyfinApiController IncludeItemTypes = includeItemTypes, Recursive = true, EnableTotalRecordCount = false, - AncestorIds = [folder.Id], + // Let LibraryManager scope virtual roots to the user's accessible libraries. + AncestorIds = folder is UserRootFolder or AggregateFolder ? [] : [folder.Id], DtoOptions = new DtoOptions { Fields = [], @@ -160,8 +161,7 @@ public class FilterController : BaseJellyfinApiController var streamLanguageQuery = new InternalItemsQuery(user) { - // It's possible that different langauges are only available on alternative versions. - // To fetch them all, owned items are included. + // Include alternate versions that may have additional languages. IncludeOwnedItems = true, IncludeItemTypes = includeItemTypes, DtoOptions = new DtoOptions @@ -178,7 +178,7 @@ public class FilterController : BaseJellyfinApiController IsSeries = isSeries }; - var tagQuery = new InternalItemsQuery(user) + var itemQuery = new InternalItemsQuery(user) { IncludeItemTypes = includeItemTypes, DtoOptions = new DtoOptions @@ -197,22 +197,23 @@ public class FilterController : BaseJellyfinApiController if ((recursive ?? true) || parentItem is UserView || parentItem is ICollectionFolder) { - var ancestorIds = parentItem is null ? Array.Empty() : new[] { parentItem.Id }; + // Let LibraryManager scope virtual roots to the user's accessible libraries. + Guid[] ancestorIds = parentItem is null or UserRootFolder or AggregateFolder ? [] : [parentItem.Id]; genreQuery.AncestorIds = ancestorIds; streamLanguageQuery.AncestorIds = ancestorIds; - tagQuery.AncestorIds = ancestorIds; + itemQuery.AncestorIds = ancestorIds; } else { genreQuery.Parent = parentItem; streamLanguageQuery.Parent = parentItem; - tagQuery.Parent = parentItem; + itemQuery.Parent = parentItem; } if ((includeItemTypes.Contains(BaseItemKind.Series) || includeItemTypes.Contains(BaseItemKind.Season)) && !includeItemTypes.Contains(BaseItemKind.Episode)) { - // streams are joined on epsiodes not shows or seasons + // Series and season languages come from their episodes. streamLanguageQuery.IncludeItemTypes = [.. includeItemTypes, BaseItemKind.Episode]; } @@ -237,7 +238,9 @@ public class FilterController : BaseJellyfinApiController }).ToArray(); } - filters.Tags = _libraryManager.GetTagNames(tagQuery); + filters.Tags = _libraryManager.GetTagNames(itemQuery); + filters.Years = _libraryManager.GetYears(itemQuery); + filters.OfficialRatings = _libraryManager.GetOfficialRatings(itemQuery); if (includeItemTypes.Contains(BaseItemKind.Movie) || includeItemTypes.Contains(BaseItemKind.Series) diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs index 8d573569e9..a46cd9ab99 100644 --- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs +++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs @@ -600,7 +600,7 @@ public sealed partial class BaseItemRepository } /// - public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter) + public IReadOnlyList GetYears(InternalItemsQuery filter) { ArgumentNullException.ThrowIfNull(filter); PrepareFilterQuery(filter); @@ -608,22 +608,34 @@ public sealed partial class BaseItemRepository using var context = _dbProvider.CreateDbContext(); var baseQuery = PrepareItemQuery(context, filter); baseQuery = TranslateQuery(baseQuery, context, filter); + return GetYears(baseQuery); + } - var matchingItemIds = baseQuery.Select(e => e.Id); + /// + public IReadOnlyList GetOfficialRatings(InternalItemsQuery filter) + { + ArgumentNullException.ThrowIfNull(filter); + PrepareFilterQuery(filter); - var years = baseQuery - .Where(e => e.ProductionYear != null && e.ProductionYear > 0) - .Select(e => e.ProductionYear!.Value) - .Distinct() - .OrderBy(y => y) - .ToArray(); + using var context = _dbProvider.CreateDbContext(); + var baseQuery = PrepareItemQuery(context, filter); + baseQuery = TranslateQuery(baseQuery, context, filter); + return GetOfficialRatings(baseQuery); + } - var officialRatings = baseQuery - .Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty) - .Select(e => e.OfficialRating!) - .Distinct() - .OrderBy(r => r) - .ToArray(); + /// + public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter) + { + ArgumentNullException.ThrowIfNull(filter); + PrepareFilterQuery(filter); + + using var context = _dbProvider.CreateDbContext(); + var baseQuery = PrepareItemQuery(context, filter); + baseQuery = TranslateQuery(baseQuery, context, filter); + + var matchingItemIds = baseQuery.Select(e => e.Id); + var years = GetYears(baseQuery); + var officialRatings = GetOfficialRatings(baseQuery); var tags = context.ItemValuesMap .Join( @@ -659,4 +671,24 @@ public sealed partial class BaseItemRepository Genres = genres }; } + + private static IReadOnlyList GetYears(IQueryable query) + { + return query + .Where(e => e.ProductionYear != null && e.ProductionYear > 0) + .Select(e => e.ProductionYear!.Value) + .Distinct() + .OrderBy(y => y) + .ToArray(); + } + + private static IReadOnlyList GetOfficialRatings(IQueryable query) + { + return query + .Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty) + .Select(e => e.OfficialRating!) + .Distinct() + .OrderBy(r => r) + .ToArray(); + } } diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs index ae15c75350..8d00858b37 100644 --- a/MediaBrowser.Controller/Library/ILibraryManager.cs +++ b/MediaBrowser.Controller/Library/ILibraryManager.cs @@ -850,6 +850,20 @@ namespace MediaBrowser.Controller.Library /// Aggregated filter values. QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery query); + /// + /// Gets the distinct, sorted production years of the matching items. + /// + /// The query filter. + /// The production years. + IReadOnlyList GetYears(InternalItemsQuery query); + + /// + /// Gets the distinct, sorted official ratings of the matching items. + /// + /// The query filter. + /// The official ratings. + IReadOnlyList GetOfficialRatings(InternalItemsQuery query); + /// /// Gets a list of all distinct tags of the matching items. /// diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs index 3cf06b897c..69c74d3757 100644 --- a/MediaBrowser.Controller/Persistence/IItemRepository.cs +++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs @@ -148,6 +148,20 @@ public interface IItemRepository /// Aggregated filter values. QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter); + /// + /// Gets the distinct, sorted production years of the matching items. + /// + /// The query filter. + /// The production years. + IReadOnlyList GetYears(InternalItemsQuery filter); + + /// + /// Gets the distinct, sorted official ratings of the matching items. + /// + /// The query filter. + /// The official ratings. + IReadOnlyList GetOfficialRatings(InternalItemsQuery filter); + /// /// Gets whether all children of the requested item have been played. /// diff --git a/MediaBrowser.Model/Querying/QueryFilters.cs b/MediaBrowser.Model/Querying/QueryFilters.cs index 095f460923..d4a3d92934 100644 --- a/MediaBrowser.Model/Querying/QueryFilters.cs +++ b/MediaBrowser.Model/Querying/QueryFilters.cs @@ -15,6 +15,8 @@ namespace MediaBrowser.Model.Querying Genres = Array.Empty(); AudioLanguages = Array.Empty(); SubtitleLanguages = Array.Empty(); + Years = Array.Empty(); + OfficialRatings = Array.Empty(); } public IReadOnlyList Genres { get; set; } @@ -24,5 +26,9 @@ namespace MediaBrowser.Model.Querying public IReadOnlyList AudioLanguages { get; set; } public IReadOnlyList SubtitleLanguages { get; set; } + + public IReadOnlyList Years { get; set; } + + public IReadOnlyList OfficialRatings { get; set; } } } diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs new file mode 100644 index 0000000000..72a20d7f98 --- /dev/null +++ b/tests/Jellyfin.Server.Implementations.Tests/Library/QueryFiltersTests.cs @@ -0,0 +1,534 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Security.Claims; +using AutoFixture; +using AutoFixture.AutoMoq; +using Emby.Naming.Common; +using Emby.Server.Implementations.Data; +using Jellyfin.Api.Constants; +using Jellyfin.Api.Controllers; +using Jellyfin.Data; +using Jellyfin.Database.Implementations.Entities; +using Jellyfin.Database.Implementations.Enums; +using Jellyfin.Server.Implementations.Tests.Item; +using MediaBrowser.Controller.Configuration; +using MediaBrowser.Controller.Entities; +using MediaBrowser.Controller.Library; +using MediaBrowser.Controller.Persistence; +using MediaBrowser.Model.Configuration; +using MediaBrowser.Model.Globalization; +using MediaBrowser.Model.Library; +using MediaBrowser.Model.Querying; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Mvc; +using Moq; +using Xunit; +using BaseItemKind = Jellyfin.Data.Enums.BaseItemKind; +using ServerLibraryManager = Emby.Server.Implementations.Library.LibraryManager; + +namespace Jellyfin.Server.Implementations.Tests.Library; + +public sealed class QueryFiltersTests : SqliteDbTestFixture +{ + private readonly DirectoryInfo _rootDirectory; + private readonly ItemTypeLookup _itemTypeLookup = new(); + private readonly Mock _userViewManager = new(); + private readonly User _user = new("restricted", "auth", "reset") + { + MaxParentalRatingScore = 50 + }; + + private readonly Guid _firstLibraryId = Guid.NewGuid(); + private readonly Guid _secondLibraryId = Guid.NewGuid(); + private readonly Guid _inaccessibleLibraryId = Guid.NewGuid(); + private readonly Folder _folder = new() { Id = Guid.NewGuid() }; + private readonly AggregateFolder _aggregateRoot = new() { Id = Guid.NewGuid() }; + private readonly CollectionFolder _collection; + private readonly UserView _view; + private readonly UserRootFolder _userRoot; + private readonly FilterController _controller; + + public QueryFiltersTests() + { + _rootDirectory = Directory.CreateTempSubdirectory("jellyfin-query-filters-"); + _user.SetPreference(PreferenceKind.BlockedTags, ["blocked"]); + + var fixture = new Fixture().Customize(new AutoMoqCustomization()); + fixture.Register(() => new NamingOptions()); + fixture.Inject(CreateBaseItemRepository(_itemTypeLookup)); + fixture.Inject(new Lazy(() => _userViewManager.Object)); + var configuration = fixture.Freeze>(); + configuration.Setup(c => c.Configuration).Returns(new ServerConfiguration()); + configuration.Setup(c => c.ApplicationPaths.ProgramDataPath).Returns(_rootDirectory.FullName); + configuration.Setup(c => c.ApplicationPaths.DefaultUserViewsPath).Returns(_rootDirectory.FullName); + + var libraryManager = fixture.Create(); + _userRoot = new UserRootFolder + { + Id = libraryManager.GetNewItemId(_rootDirectory.FullName, typeof(UserRootFolder)), + Path = _rootDirectory.FullName + }; + _collection = new CollectionFolder + { + Id = Guid.NewGuid(), + PhysicalFolderIds = [_firstLibraryId] + }; + _view = new UserView + { + Id = Guid.NewGuid(), + DisplayParentId = _collection.Id + }; + var secondCollection = new CollectionFolder + { + Id = Guid.NewGuid(), + PhysicalFolderIds = [_secondLibraryId] + }; + libraryManager.RegisterItem(_userRoot); + libraryManager.RegisterItem(_aggregateRoot); + libraryManager.RegisterItem(_collection); + libraryManager.RegisterItem(_view); + libraryManager.RegisterItem(_folder); + + _userViewManager.Setup(m => m.GetUserViews(It.Is(q => q.User == _user && q.IncludeHidden))) + .Returns([_collection, secondCollection]); + var userManager = fixture.Freeze>(); + userManager.Setup(m => m.GetUserById(_user.Id)).Returns(_user); + _controller = new FilterController(libraryManager, userManager.Object, Mock.Of()) + { + ControllerContext = new ControllerContext + { + HttpContext = new DefaultHttpContext + { + User = new ClaimsPrincipal(new ClaimsIdentity( + [new Claim(InternalClaimTypes.UserId, _user.Id.ToString("N"))])) + } + } + }; + + using var context = CreateDbContext(); + foreach (var id in new[] { _firstLibraryId, _secondLibraryId, _inaccessibleLibraryId, _folder.Id, _userRoot.Id, _aggregateRoot.Id }) + { + context.BaseItems.Add(new BaseItemEntity + { + Id = id, + Type = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder], + IsFolder = true + }); + } + + context.SaveChanges(); + + SeedItems(BaseItemKind.Movie, 0, "PG", "G", "PG-13"); + SeedItems(BaseItemKind.Series, 1, "TV-PG", "TV-G", "TV-14"); + } + + [Theory] + [InlineData(BaseItemKind.Movie, null)] + [InlineData(BaseItemKind.Series, null)] + [InlineData(BaseItemKind.Movie, "library")] + [InlineData(BaseItemKind.Series, "library")] + [InlineData(BaseItemKind.Movie, "view")] + [InlineData(BaseItemKind.Series, "view")] + [InlineData(BaseItemKind.Movie, "folder")] + [InlineData(BaseItemKind.Series, "folder")] + [InlineData(BaseItemKind.Movie, "userRoot")] + [InlineData(BaseItemKind.Series, "userRoot")] + [InlineData(BaseItemKind.Movie, "aggregateRoot")] + [InlineData(BaseItemKind.Series, "aggregateRoot")] + public void GetQueryFiltersLegacy_ReturnsAccessibleYearsAndRatings(BaseItemKind itemType, string? parent) + { + // A missing userId uses the authenticated user's access restrictions. + var result = _controller.GetQueryFiltersLegacy(null, GetParentId(parent), [itemType], []); + var filters = Assert.IsType(result.Value); + + AssertYearsAndRatings(itemType, parent, filters.Years, filters.OfficialRatings); + } + + [Theory] + [InlineData(BaseItemKind.Movie)] + [InlineData(BaseItemKind.Series)] + public void GetQueryFiltersLegacy_NoAccessibleLibraries_ReturnsEmptyFilters(BaseItemKind itemType) + { + _userViewManager.Setup(m => m.GetUserViews(It.IsAny())).Returns([]); + + var result = _controller.GetQueryFiltersLegacy(null, null, [itemType], []); + var filters = Assert.IsType(result.Value); + + Assert.Empty(filters.Years); + Assert.Empty(filters.OfficialRatings); + Assert.Empty(filters.Tags); + Assert.Empty(filters.Genres); + } + + [Theory] + [InlineData(BaseItemKind.Movie, null, true)] + [InlineData(BaseItemKind.Series, null, true)] + [InlineData(BaseItemKind.Movie, null, false)] + [InlineData(BaseItemKind.Series, null, false)] + [InlineData(BaseItemKind.Movie, "library", true)] + [InlineData(BaseItemKind.Series, "library", true)] + [InlineData(BaseItemKind.Movie, "library", false)] + [InlineData(BaseItemKind.Series, "library", false)] + [InlineData(BaseItemKind.Movie, "view", true)] + [InlineData(BaseItemKind.Series, "view", true)] + [InlineData(BaseItemKind.Movie, "view", false)] + [InlineData(BaseItemKind.Series, "view", false)] + [InlineData(BaseItemKind.Movie, "folder", true)] + [InlineData(BaseItemKind.Series, "folder", true)] + [InlineData(BaseItemKind.Movie, "folder", false)] + [InlineData(BaseItemKind.Series, "folder", false)] + [InlineData(BaseItemKind.Movie, "userRoot", true)] + [InlineData(BaseItemKind.Series, "userRoot", true)] + [InlineData(BaseItemKind.Movie, "aggregateRoot", true)] + [InlineData(BaseItemKind.Series, "aggregateRoot", true)] + public void GetQueryFilters_ReturnsAccessibleYearsAndRatings(BaseItemKind itemType, string? parent, bool recursive) + { + var filters = GetFilters(itemType, GetParentId(parent), recursive); + + AssertYearsAndRatings(itemType, parent, filters.Years, filters.OfficialRatings); + } + + [Theory] + [InlineData(BaseItemKind.Movie, true)] + [InlineData(BaseItemKind.Series, true)] + [InlineData(BaseItemKind.Movie, false)] + [InlineData(BaseItemKind.Series, false)] + public void GetQueryFilters_Recursive_ControlsWhetherDescendantsContribute(BaseItemKind itemType, bool recursive) + { + using var context = CreateDbContext(); + var nestedFolder = new BaseItemEntity + { + Id = Guid.NewGuid(), + Type = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Folder], + IsFolder = true, + ParentId = _folder.Id, + TopParentId = _firstLibraryId + }; + context.BaseItems.Add(nestedFolder); + context.SaveChanges(); + var descendantId = AddItem(itemType, _firstLibraryId, nestedFolder.Id, 2019, "Descendant"); + context.AncestorIds.Add(new AncestorId + { + ItemId = descendantId, + Item = context.BaseItems.Find(descendantId)!, + ParentItemId = _folder.Id, + ParentItem = context.BaseItems.Find(_folder.Id)! + }); + context.SaveChanges(); + + var filters = GetFilters(itemType, _folder.Id, recursive); + var firstYear = itemType == BaseItemKind.Movie ? 2001 : 2002; + var firstRating = itemType == BaseItemKind.Movie ? "PG" : "TV-PG"; + + Assert.Equal(recursive ? [firstYear, 2019] : new[] { firstYear }, filters.Years); + Assert.Equal(recursive ? ["Descendant", firstRating] : new[] { firstRating }, filters.OfficialRatings); + } + + [Theory] + [InlineData(BaseItemKind.Movie, false)] + [InlineData(BaseItemKind.Series, false)] + [InlineData(BaseItemKind.Movie, true)] + [InlineData(BaseItemKind.Series, true)] + public void GetQueryFilters_MissingMetadata_DoesNotExcludeTheOtherField(BaseItemKind itemType, bool withParent) + { + using (var context = CreateDbContext()) + { + foreach (var item in context.BaseItems) + { + item.ProductionYear = null; + item.OfficialRating = null; + } + + context.SaveChanges(); + } + + AddItem(itemType, _firstLibraryId, _folder.Id, null, "PG"); + AddItem(itemType, _firstLibraryId, _folder.Id, 2019, null); + AddItem(itemType, _firstLibraryId, _folder.Id, 2019, string.Empty); + AddItem(itemType, _firstLibraryId, _folder.Id, -1, "PG"); + + var filters = GetFilters(itemType, withParent ? _collection.Id : null); + + Assert.Equal([2019], filters.Years); + Assert.Equal(["PG"], filters.OfficialRatings); + } + + [Theory] + [InlineData(BaseItemKind.Movie, false)] + [InlineData(BaseItemKind.Series, false)] + [InlineData(BaseItemKind.Movie, true)] + [InlineData(BaseItemKind.Series, true)] + public void GetQueryFilters_AllowedTags_OnlyIncludesAllowedItems(BaseItemKind itemType, bool withParent) + { + _user.SetPreference(PreferenceKind.AllowedTags, ["allowed"]); + var allowedId = AddItem(itemType, _firstLibraryId, _folder.Id, 2017, "Allowed"); + AddItemValue(allowedId, ItemValueType.Tags, "allowed"); + var blockedId = AddItem(itemType, _firstLibraryId, _folder.Id, 2018, "Blocked", blockedTag: true); + AddItemValue(blockedId, ItemValueType.Tags, "allowed"); + + var filters = GetFilters(itemType, withParent ? _collection.Id : null); + + Assert.Equal([2017], filters.Years); + Assert.Equal(["Allowed"], filters.OfficialRatings); + Assert.Equal(["allowed"], filters.Tags); + } + + [Theory] + [InlineData(BaseItemKind.Movie)] + [InlineData(BaseItemKind.Series)] + public void GetQueryFilters_NoAccessibleLibraries_ReturnsEmptyFilters(BaseItemKind itemType) + { + _userViewManager.Setup(m => m.GetUserViews(It.IsAny())).Returns([]); + + var filters = GetFilters(itemType); + + Assert.Empty(filters.Years); + Assert.Empty(filters.OfficialRatings); + Assert.Empty(filters.Genres); + Assert.Empty(filters.Tags); + Assert.Empty(filters.AudioLanguages); + Assert.Empty(filters.SubtitleLanguages); + } + + [Theory] + [InlineData(BaseItemKind.Movie, false)] + [InlineData(BaseItemKind.Series, false)] + [InlineData(BaseItemKind.Movie, true)] + [InlineData(BaseItemKind.Series, true)] + public void GetQueryFilters_IsMovie_UsesTheSameFilterForMetadata(BaseItemKind itemType, bool withParent) + { + var result = _controller.GetQueryFilters( + userId: null, + parentId: withParent ? _collection.Id : null, + includeItemTypes: [itemType], + isAiring: null, + isMovie: itemType != BaseItemKind.Movie, + isSports: null, + isKids: null, + isNews: null, + isSeries: null, + recursive: null); + var filters = Assert.IsType(result.Value); + + Assert.Empty(filters.Years); + Assert.Empty(filters.OfficialRatings); + } + + [Theory] + [InlineData(BaseItemKind.Movie, false)] + [InlineData(BaseItemKind.Series, false)] + [InlineData(BaseItemKind.Movie, true)] + [InlineData(BaseItemKind.Series, true)] + public void GetQueryFilters_PreservesGenresTagsAndLanguages(BaseItemKind itemType, bool withParent) + { + var isMovie = itemType == BaseItemKind.Movie; + var visibleId = AddItem(itemType, _firstLibraryId, _folder.Id, isMovie ? 2001 : 2002, isMovie ? "PG" : "TV-PG"); + AddItemValue(visibleId, ItemValueType.Tags, "visible"); + AddItemValue(visibleId, ItemValueType.Genre, "Drama"); + var hiddenId = AddItem(itemType, _inaccessibleLibraryId, _inaccessibleLibraryId, 2099, "Hidden"); + AddItemValue(hiddenId, ItemValueType.Tags, "hidden"); + AddItemValue(hiddenId, ItemValueType.Genre, "Horror"); + + // Languages come from episodes; years and ratings come from the series. + if (!isMovie) + { + visibleId = AddItem(BaseItemKind.Episode, _firstLibraryId, visibleId, 2088, "Episode rating"); + hiddenId = AddItem(BaseItemKind.Episode, _inaccessibleLibraryId, hiddenId, 2089, "Hidden episode rating"); + } + + AddLanguages(visibleId, "eng", "spa"); + AddLanguages(hiddenId, "ger", "fre"); + using (var context = CreateDbContext()) + { + foreach (var name in new[] { "Drama", "Horror" }) + { + var id = Guid.NewGuid(); + context.BaseItems.Add(new BaseItemEntity + { + Id = id, + Type = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre], + Name = name, + CleanName = name.ToLowerInvariant(), + PresentationUniqueKey = id.ToString("N") + }); + } + + context.SaveChanges(); + } + + var filters = GetFilters(itemType, withParent ? _collection.Id : null); + + Assert.Equal(["Drama"], filters.Genres.Select(g => g.Name)); + Assert.NotEqual(Guid.Empty, Assert.Single(filters.Genres).Id); + Assert.Equal(["visible"], filters.Tags); + var audioLanguage = Assert.Single(filters.AudioLanguages); + Assert.Equal("eng", audioLanguage.Value); + Assert.Equal("eng", audioLanguage.Name); + var subtitleLanguage = Assert.Single(filters.SubtitleLanguages); + Assert.Equal("spa", subtitleLanguage.Value); + Assert.Equal("spa", subtitleLanguage.Name); + AssertYearsAndRatings(itemType, withParent ? "library" : null, filters.Years, filters.OfficialRatings); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + if (disposing) + { + _rootDirectory.Delete(true); + } + } + + private QueryFilters GetFilters(BaseItemKind itemType, Guid? parentId = null, bool? recursive = null) + { + var result = _controller.GetQueryFilters( + userId: null, + parentId: parentId, + includeItemTypes: [itemType], + isAiring: null, + isMovie: null, + isSports: null, + isKids: null, + isNews: null, + isSeries: null, + recursive: recursive); + return Assert.IsType(result.Value); + } + + private Guid? GetParentId(string? parent) + { + return parent switch + { + null => null, + "library" => _collection.Id, + "view" => _view.Id, + "folder" => _folder.Id, + "userRoot" => _userRoot.Id, + "aggregateRoot" => _aggregateRoot.Id, + _ => throw new ArgumentOutOfRangeException(nameof(parent)) + }; + } + + private static void AssertYearsAndRatings(BaseItemKind itemType, string? parent, IReadOnlyList years, IReadOnlyList officialRatings) + { + var offset = itemType == BaseItemKind.Movie ? 0 : 1; + int[] expectedYears = parent switch + { + "folder" => [2001 + offset], + "library" or "view" => [2001 + offset, 2005 + offset], + _ => [2001 + offset, 2005 + offset, 2011 + offset] + }; + string[] ratings = itemType == BaseItemKind.Movie ? ["PG", "G", "PG-13"] : ["TV-PG", "TV-G", "TV-14"]; + + Assert.Equal(expectedYears, years); + Assert.Equal(ratings.Take(expectedYears.Length).Order(StringComparer.Ordinal), officialRatings); + } + + private void SeedItems(BaseItemKind kind, int yearOffset, string firstRating, string siblingRating, string secondRating) + { + // Unsorted, duplicate, and missing values exercise metadata aggregation. + AddItem(kind, _secondLibraryId, _secondLibraryId, 2011 + yearOffset, secondRating); + AddItem(kind, _firstLibraryId, _firstLibraryId, 2005 + yearOffset, siblingRating); + AddItem(kind, _firstLibraryId, _folder.Id, 2001 + yearOffset, firstRating); + AddItem(kind, _firstLibraryId, _folder.Id, 2001 + yearOffset, firstRating); + AddItem(kind, _firstLibraryId, _folder.Id, null, null); + AddItem(kind, _firstLibraryId, _folder.Id, 0, string.Empty); + + // Distinct metadata reveals any restricted items in the response. + AddItem(kind, _inaccessibleLibraryId, _inaccessibleLibraryId, 1991 + yearOffset, "Inaccessible library"); + AddItem(kind, _firstLibraryId, _folder.Id, 2021 + yearOffset, "Above parental limit", parentalRating: 100); + AddItem(kind, _firstLibraryId, _folder.Id, 2031 + yearOffset, "Blocked tag", blockedTag: true); + } + + private Guid AddItem(BaseItemKind kind, Guid libraryId, Guid parentId, int? year, string? rating, int parentalRating = 10, bool blockedTag = false) + { + using var context = CreateDbContext(); + var item = new BaseItemEntity + { + Id = Guid.NewGuid(), + Type = _itemTypeLookup.BaseItemKindNames[kind], + MediaType = "Video", + IsFolder = kind == BaseItemKind.Series, + IsMovie = kind == BaseItemKind.Movie, + IsVirtualItem = false, + TopParentId = libraryId, + ParentId = parentId, + ProductionYear = year, + OfficialRating = rating, + InheritedParentalRatingValue = parentalRating + }; + context.BaseItems.Add(item); + + // Virtual roots and collection views are not stored ancestors. + foreach (var ancestorId in new[] { libraryId, parentId }.Distinct()) + { + context.AncestorIds.Add(new AncestorId + { + ItemId = item.Id, + Item = item, + ParentItemId = ancestorId, + ParentItem = context.BaseItems.Find(ancestorId)! + }); + } + + context.SaveChanges(); + if (blockedTag) + { + AddItemValue(item.Id, ItemValueType.Tags, "blocked"); + } + + return item.Id; + } + + private void AddItemValue(Guid itemId, ItemValueType type, string value) + { + using var context = CreateDbContext(); + var itemValue = context.ItemValues.SingleOrDefault(t => t.Type == type && t.Value == value); + if (itemValue is null) + { + itemValue = new ItemValue + { + ItemValueId = Guid.NewGuid(), + Type = type, + Value = value, + CleanValue = value.ToLowerInvariant() + }; + context.ItemValues.Add(itemValue); + } + + context.ItemValuesMap.Add(new ItemValueMap + { + ItemId = itemId, + ItemValueId = itemValue.ItemValueId, + Item = context.BaseItems.Find(itemId)!, + ItemValue = itemValue + }); + context.SaveChanges(); + } + + private void AddLanguages(Guid itemId, string audioLanguage, string subtitleLanguage) + { + using var context = CreateDbContext(); + var item = context.BaseItems.Find(itemId)!; + context.MediaStreamInfos.AddRange( + new MediaStreamInfo + { + ItemId = itemId, + Item = item, + StreamIndex = 0, + StreamType = MediaStreamTypeEntity.Audio, + Language = audioLanguage + }, + new MediaStreamInfo + { + ItemId = itemId, + Item = item, + StreamIndex = 1, + StreamType = MediaStreamTypeEntity.Subtitle, + Language = subtitleLanguage + }); + context.SaveChanges(); + } +} diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/FilterControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/FilterControllerTests.cs new file mode 100644 index 0000000000..0e174fb597 --- /dev/null +++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/FilterControllerTests.cs @@ -0,0 +1,35 @@ +using System.Net.Http.Json; +using System.Text.Json; +using System.Threading.Tasks; +using Xunit; + +namespace Jellyfin.Server.Integration.Tests.Controllers; + +public sealed class FilterControllerTests : IClassFixture +{ + private readonly JellyfinApplicationFactory _factory; + private static string? _accessToken; + + public FilterControllerTests(JellyfinApplicationFactory factory) + { + _factory = factory; + } + + [Theory] + [InlineData("Movie")] + [InlineData("Series")] + public async Task GetQueryFilters_EmptyLibrary_SerializesEmptyArrays(string itemType) + { + using var client = _factory.CreateClient(); + client.DefaultRequestHeaders.AddAuthHeader(_accessToken ??= await AuthHelper.CompleteStartupAsync(client)); + + var filters = await client.GetFromJsonAsync($"/Items/Filters2?includeItemTypes={itemType}", TestContext.Current.CancellationToken); + + foreach (var field in new[] { "Years", "OfficialRatings", "Genres", "Tags", "AudioLanguages", "SubtitleLanguages" }) + { + var values = filters.GetProperty(field); + Assert.Equal(JsonValueKind.Array, values.ValueKind); + Assert.Equal(0, values.GetArrayLength()); + } + } +} -- cgit v1.2.3