mirror of
https://github.com/jellyfin/jellyfin.git
synced 2026-11-21 15:22:34 +00:00
Years, Ratings for filters endpoints
This commit is contained in:
parent
7b8c6451b5
commit
2cfcb9ac0c
8 changed files with 685 additions and 23 deletions
|
|
@ -4199,6 +4199,30 @@ namespace Emby.Server.Implementations.Library
|
|||
return _itemRepository.GetQueryFiltersLegacy(query);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<int> GetYears(InternalItemsQuery query)
|
||||
{
|
||||
if (query.User is not null)
|
||||
{
|
||||
AddUserToQuery(query, query.User);
|
||||
}
|
||||
|
||||
SetTopParentOrAncestorIds(query);
|
||||
return _itemRepository.GetYears(query);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery query)
|
||||
{
|
||||
if (query.User is not null)
|
||||
{
|
||||
AddUserToQuery(query, query.User);
|
||||
}
|
||||
|
||||
SetTopParentOrAncestorIds(query);
|
||||
return _itemRepository.GetOfficialRatings(query);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<string> GetTagNames(InternalItemsQuery query)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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<Guid>() : 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)
|
||||
|
|
|
|||
|
|
@ -599,6 +599,30 @@ public sealed partial class BaseItemRepository
|
|||
return dbContext.BaseItems.Where(e => e.ParentId == id).All(BuildLeafIsPlayedFilter(dbContext, user.Id));
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<int> GetYears(InternalItemsQuery filter)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(filter);
|
||||
PrepareFilterQuery(filter);
|
||||
|
||||
using var context = _dbProvider.CreateDbContext();
|
||||
var baseQuery = PrepareItemQuery(context, filter);
|
||||
baseQuery = TranslateQuery(baseQuery, context, filter);
|
||||
return GetYears(baseQuery);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery filter)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(filter);
|
||||
PrepareFilterQuery(filter);
|
||||
|
||||
using var context = _dbProvider.CreateDbContext();
|
||||
var baseQuery = PrepareItemQuery(context, filter);
|
||||
baseQuery = TranslateQuery(baseQuery, context, filter);
|
||||
return GetOfficialRatings(baseQuery);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter)
|
||||
{
|
||||
|
|
@ -610,20 +634,8 @@ public sealed partial class BaseItemRepository
|
|||
baseQuery = TranslateQuery(baseQuery, context, filter);
|
||||
|
||||
var matchingItemIds = baseQuery.Select(e => e.Id);
|
||||
|
||||
var years = baseQuery
|
||||
.Where(e => e.ProductionYear != null && e.ProductionYear > 0)
|
||||
.Select(e => e.ProductionYear!.Value)
|
||||
.Distinct()
|
||||
.OrderBy(y => y)
|
||||
.ToArray();
|
||||
|
||||
var officialRatings = baseQuery
|
||||
.Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)
|
||||
.Select(e => e.OfficialRating!)
|
||||
.Distinct()
|
||||
.OrderBy(r => r)
|
||||
.ToArray();
|
||||
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<int> GetYears(IQueryable<BaseItemEntity> query)
|
||||
{
|
||||
return query
|
||||
.Where(e => e.ProductionYear != null && e.ProductionYear > 0)
|
||||
.Select(e => e.ProductionYear!.Value)
|
||||
.Distinct()
|
||||
.OrderBy(y => y)
|
||||
.ToArray();
|
||||
}
|
||||
|
||||
private static IReadOnlyList<string> GetOfficialRatings(IQueryable<BaseItemEntity> query)
|
||||
{
|
||||
return query
|
||||
.Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)
|
||||
.Select(e => e.OfficialRating!)
|
||||
.Distinct()
|
||||
.OrderBy(r => r)
|
||||
.ToArray();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -850,6 +850,20 @@ namespace MediaBrowser.Controller.Library
|
|||
/// <returns>Aggregated filter values.</returns>
|
||||
QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery query);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the distinct, sorted production years of the matching items.
|
||||
/// </summary>
|
||||
/// <param name="query">The query filter.</param>
|
||||
/// <returns>The production years.</returns>
|
||||
IReadOnlyList<int> GetYears(InternalItemsQuery query);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the distinct, sorted official ratings of the matching items.
|
||||
/// </summary>
|
||||
/// <param name="query">The query filter.</param>
|
||||
/// <returns>The official ratings.</returns>
|
||||
IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery query);
|
||||
|
||||
/// <summary>
|
||||
/// Gets a list of all distinct tags of the matching items.
|
||||
/// </summary>
|
||||
|
|
|
|||
|
|
@ -148,6 +148,20 @@ public interface IItemRepository
|
|||
/// <returns>Aggregated filter values.</returns>
|
||||
QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the distinct, sorted production years of the matching items.
|
||||
/// </summary>
|
||||
/// <param name="filter">The query filter.</param>
|
||||
/// <returns>The production years.</returns>
|
||||
IReadOnlyList<int> GetYears(InternalItemsQuery filter);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the distinct, sorted official ratings of the matching items.
|
||||
/// </summary>
|
||||
/// <param name="filter">The query filter.</param>
|
||||
/// <returns>The official ratings.</returns>
|
||||
IReadOnlyList<string> GetOfficialRatings(InternalItemsQuery filter);
|
||||
|
||||
/// <summary>
|
||||
/// Gets whether all children of the requested item have been played.
|
||||
/// </summary>
|
||||
|
|
|
|||
|
|
@ -15,6 +15,8 @@ namespace MediaBrowser.Model.Querying
|
|||
Genres = Array.Empty<NameGuidPair>();
|
||||
AudioLanguages = Array.Empty<NameValuePair>();
|
||||
SubtitleLanguages = Array.Empty<NameValuePair>();
|
||||
Years = Array.Empty<int>();
|
||||
OfficialRatings = Array.Empty<string>();
|
||||
}
|
||||
|
||||
public IReadOnlyList<NameGuidPair> Genres { get; set; }
|
||||
|
|
@ -24,5 +26,9 @@ namespace MediaBrowser.Model.Querying
|
|||
public IReadOnlyList<NameValuePair> AudioLanguages { get; set; }
|
||||
|
||||
public IReadOnlyList<NameValuePair> SubtitleLanguages { get; set; }
|
||||
|
||||
public IReadOnlyList<int> Years { get; set; }
|
||||
|
||||
public IReadOnlyList<string> OfficialRatings { get; set; }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<IUserViewManager> _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<IItemRepository>(CreateBaseItemRepository(_itemTypeLookup));
|
||||
fixture.Inject(new Lazy<IUserViewManager>(() => _userViewManager.Object));
|
||||
var configuration = fixture.Freeze<Mock<IServerConfigurationManager>>();
|
||||
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<ServerLibraryManager>();
|
||||
_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<UserViewQuery>(q => q.User == _user && q.IncludeHidden)))
|
||||
.Returns([_collection, secondCollection]);
|
||||
var userManager = fixture.Freeze<Mock<IUserManager>>();
|
||||
userManager.Setup(m => m.GetUserById(_user.Id)).Returns(_user);
|
||||
_controller = new FilterController(libraryManager, userManager.Object, Mock.Of<ILocalizationManager>())
|
||||
{
|
||||
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<QueryFiltersLegacy>(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<UserViewQuery>())).Returns([]);
|
||||
|
||||
var result = _controller.GetQueryFiltersLegacy(null, null, [itemType], []);
|
||||
var filters = Assert.IsType<QueryFiltersLegacy>(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<UserViewQuery>())).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<QueryFilters>(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<QueryFilters>(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<int> years, IReadOnlyList<string> 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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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<JellyfinApplicationFactory>
|
||||
{
|
||||
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<JsonElement>($"/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());
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue