< Summary - Jellyfin

Information

Class:	Jellyfin.Server.Implementations.Item.BaseItemRepository
Assembly:	Jellyfin.Server.Implementations
File(s):	File 1: /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs File 2: /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs File 3: /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs File 4: /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs File 5: /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs

Line coverage

28%

Covered lines:	402
Uncovered lines:	1030
Coverable lines:	1432
Total lines:	2864
Line coverage:	28%

Branch coverage

39%

Covered branches:	258
Total branches:	650
Branch coverage:	39.6%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage delta

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
File 1: GetAllArtists(...)	100%	2	1	0%
File 1: GetArtists(...)	100%	2	1	0%
File 1: GetAlbumArtists(...)	100%	2	1	0%
File 1: GetStudios(...)	100%	2	1	0%
File 1: GetGenres(...)	100%	2	1	0%
File 1: GetMusicGenres(...)	100%	2	1	0%
File 1: GetStudioNames()	100%	1	1	100%
File 1: GetAllArtistNames()	100%	1	1	100%
File 1: GetMusicGenreNames()	100%	1	1	100%
File 1: GetGenreNames()	100%	1	1	100%
File 1: GetItemValueNames(...)	100%	4	4	100%
File 1: GetItemValues(...)	0%	210	14	0%
File 1: BuildItemCountsByCleanName(...)	100%	2	1	0%
File 2: .cctor()	100%	1	1	100%
File 2: .ctor(...)	100%	1	1	100%
File 2: Map(...)	100%	2	1	0%
File 2: Map(...)	100%	1	1	100%
File 2: DeserializeBaseItem(...)	100%	1	1	100%
File 2: PrepareFilterQuery(...)	83.33%	6	6	80%
File 2: GetItemByNameTypesInQuery(...)	100%	10	10	100%
File 2: IsTypeInQuery(...)	75%	5	4	66.66%
File 2: EnableGroupByPresentationUniqueKey(...)	65%	21	20	87.5%
File 2: Map(...)	100%	2	1	0%
File 2: Map(...)	100%	2	1	0%
File 2: GetPathToSave(...)	0%	6	2	0%
File 2: DeserializeBaseItem(...)	50%	10	10	88.88%
File 3: PrepareItemQuery(...)	100%	1	1	100%
File 3: ApplyQueryFilter(...)	100%	1	1	100%
File 3: ApplyQueryPaging(...)	75%	8	8	85.71%
File 3: ApplyGroupingFilter(...)	70%	15	10	62.5%
File 3: ApplyBoxSetCollapsing(...)	0%	6	2	0%
File 3: ApplyBoxSetCollapsingAll(...)	100%	2	1	0%
File 3: ApplyNameFilters(...)	50%	14	6	40%
File 3: ApplyNavigations(...)	72.22%	18	18	91.3%
File 3: ApplyOrder(...)	70.58%	42	34	81.25%
File 3: ApplySeriesDatePlayedOrder(...)	0%	20	4	0%
File 3: BuildAccessFilteredDescendantsQuery(...)	100%	2	1	0%
File 3: ApplyAccessFiltering(...)	0%	156	12	0%
File 3: BuildMaxParentalRatingFilter(...)	100%	1	1	100%
File 3: GetFullyPlayedFolderIdsQuery(...)	100%	2	1	0%
File 4: GetItemIdsList(...)	100%	1	1	100%
File 4: GetItems(...)	37.5%	27	8	33.33%
File 4: GetItemList(...)	75%	5	4	68.18%
File 4: GetLatestItemList(...)	0%	210	14	0%
File 4: LoadLatestByIds(...)	100%	2	1	0%
File 4: GetLatestTvShowItems(...)	0%	4692	68	0%
File 4: ItemExistsAsync()	100%	1	1	100%
File 4: RetrieveItem(...)	50%	4	4	90.9%
File 4: GetIsPlayed(...)	0%	6	2	0%
File 4: GetQueryFiltersLegacy(...)	100%	2	1	0%
File 5: .cctor()	100%	1	1	100%
File 5: TranslateQuery(...)	40.67%	55421	386	28.25%

File(s)

/srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs

#	Line	Line coverage
	`1`	`#pragma warning disable RS0030 // Do not use banned APIs`
	`2`
	`3`	`using System;`
	`4`	`using System.Collections.Generic;`
	`5`	`using System.Linq;`
	`6`	`using Jellyfin.Data.Enums;`
	`7`	`using Jellyfin.Database.Implementations.Entities;`
	`8`	`using MediaBrowser.Controller.Entities;`
	`9`	`using MediaBrowser.Model.Dto;`
	`10`	`using MediaBrowser.Model.Querying;`
	`11`	`using Microsoft.EntityFrameworkCore;`
	`12`	`using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;`
	`13`
	`14`	`namespace Jellyfin.Server.Implementations.Item;`
	`15`
	`16`	`public sealed partial class BaseItemRepository`
	`17`	`{`
	`18`	`/// <inheritdoc />`
	`19`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAllArtists(InternalItemsQuery filter)`
	`20`	`{`
0	`21`	`return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtis`
	`22`	`}`
	`23`
	`24`	`/// <inheritdoc />`
	`25`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)`
	`26`	`{`
0	`27`	`return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);`
	`28`	`}`
	`29`
	`30`	`/// <inheritdoc />`
	`31`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)`
	`32`	`{`
0	`33`	`return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArti`
	`34`	`}`
	`35`
	`36`	`/// <inheritdoc />`
	`37`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)`
	`38`	`{`
0	`39`	`return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);`
	`40`	`}`
	`41`
	`42`	`/// <inheritdoc />`
	`43`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)`
	`44`	`{`
0	`45`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]);`
	`46`	`}`
	`47`
	`48`	`/// <inheritdoc />`
	`49`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetMusicGenres(InternalItemsQuery filter)`
	`50`	`{`
0	`51`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]);`
	`52`	`}`
	`53`
	`54`	`/// <inheritdoc />`
	`55`	`public IReadOnlyList<string> GetStudioNames()`
	`56`	`{`
17	`57`	`return GetItemValueNames(_getStudiosValueTypes, [], []);`
	`58`	`}`
	`59`
	`60`	`/// <inheritdoc />`
	`61`	`public IReadOnlyList<string> GetAllArtistNames()`
	`62`	`{`
17	`63`	`return GetItemValueNames(_getAllArtistsValueTypes, [], []);`
	`64`	`}`
	`65`
	`66`	`/// <inheritdoc />`
	`67`	`public IReadOnlyList<string> GetMusicGenreNames()`
	`68`	`{`
17	`69`	`return GetItemValueNames(`
17	`70`	`_getGenreValueTypes,`
17	`71`	`_itemTypeLookup.MusicGenreTypes,`
17	`72`	`[]);`
	`73`	`}`
	`74`
	`75`	`/// <inheritdoc />`
	`76`	`public IReadOnlyList<string> GetGenreNames()`
	`77`	`{`
17	`78`	`return GetItemValueNames(`
17	`79`	`_getGenreValueTypes,`
17	`80`	`[],`
17	`81`	`_itemTypeLookup.MusicGenreTypes);`
	`82`	`}`
	`83`
	`84`	`private string[] GetItemValueNames(IReadOnlyList<ItemValueType> itemValueTypes, IReadOnlyList<string> withItemTypes,`
	`85`	`{`
68	`86`	`using var context = _dbProvider.CreateDbContext();`
	`87`
68	`88`	`var query = context.ItemValuesMap`
68	`89`	`.AsNoTracking()`
68	`90`	`.Where(e => itemValueTypes.Any(w => w == e.ItemValue.Type));`
68	`91`	`if (withItemTypes.Count > 0)`
	`92`	`{`
17	`93`	`query = query.Where(e => withItemTypes.Contains(e.Item.Type));`
	`94`	`}`
	`95`
68	`96`	`if (excludeItemTypes.Count > 0)`
	`97`	`{`
17	`98`	`query = query.Where(e => !excludeItemTypes.Contains(e.Item.Type));`
	`99`	`}`
	`100`
68	`101`	`return query.Select(e => e.ItemValue)`
68	`102`	`.GroupBy(e => e.CleanValue)`
68	`103`	`.Select(g => g.Min(v => v.Value)!)`
68	`104`	`.ToArray();`
68	`105`	`}`
	`106`
	`107`	`private QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetItemValues(InternalItemsQuery filter, IReadOnlyLi`
	`108`	`{`
0	`109`	`ArgumentNullException.ThrowIfNull(filter);`
	`110`
0	`111`	`if (!filter.Limit.HasValue)`
	`112`	`{`
0	`113`	`filter.EnableTotalRecordCount = false;`
	`114`	`}`
	`115`
0	`116`	`using var context = _dbProvider.CreateDbContext();`
	`117`
0	`118`	`var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context,`
0	`119`	`{`
0	`120`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`121`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`122`	`MediaTypes = filter.MediaTypes,`
0	`123`	`AncestorIds = filter.AncestorIds,`
0	`124`	`ItemIds = filter.ItemIds,`
0	`125`	`TopParentIds = filter.TopParentIds,`
0	`126`	`ParentId = filter.ParentId,`
0	`127`	`IsAiring = filter.IsAiring,`
0	`128`	`IsMovie = filter.IsMovie,`
0	`129`	`IsSports = filter.IsSports,`
0	`130`	`IsKids = filter.IsKids,`
0	`131`	`IsNews = filter.IsNews,`
0	`132`	`IsSeries = filter.IsSeries`
0	`133`	`});`
	`134`
	`135`	`// Keep this as an IQueryable sub-select. Materializing to a list would inline one`
	`136`	`// bound parameter per CleanValue and hit SQLite's variable cap on libraries with`
	`137`	`// high-cardinality value types (e.g. tens of thousands of artists).`
0	`138`	`var matchingCleanValues = context.ItemValuesMap`
0	`139`	`.Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))`
0	`140`	`.Join(`
0	`141`	`innerQueryFilter,`
0	`142`	`ivm => ivm.ItemId,`
0	`143`	`g => g.Id,`
0	`144`	`(ivm, g) => ivm.ItemValue.CleanValue)`
0	`145`	`.Distinct();`
	`146`
0	`147`	`var innerQuery = PrepareItemQuery(context, filter)`
0	`148`	`.Where(e => e.Type == returnType)`
0	`149`	`.Where(e => matchingCleanValues.Contains(e.CleanName!));`
	`150`
0	`151`	`var outerQueryFilter = new InternalItemsQuery(filter.User)`
0	`152`	`{`
0	`153`	`IsPlayed = filter.IsPlayed,`
0	`154`	`IsFavorite = filter.IsFavorite,`
0	`155`	`IsFavoriteOrLiked = filter.IsFavoriteOrLiked,`
0	`156`	`IsLiked = filter.IsLiked,`
0	`157`	`IsLocked = filter.IsLocked,`
0	`158`	`NameLessThan = filter.NameLessThan,`
0	`159`	`NameStartsWith = filter.NameStartsWith,`
0	`160`	`NameStartsWithOrGreater = filter.NameStartsWithOrGreater,`
0	`161`	`Tags = filter.Tags,`
0	`162`	`OfficialRatings = filter.OfficialRatings,`
0	`163`	`StudioIds = filter.StudioIds,`
0	`164`	`GenreIds = filter.GenreIds,`
0	`165`	`Genres = filter.Genres,`
0	`166`	`Years = filter.Years,`
0	`167`	`NameContains = filter.NameContains,`
0	`168`	`SearchTerm = filter.SearchTerm,`
0	`169`	`ExcludeItemIds = filter.ExcludeItemIds`
0	`170`	`};`
	`171`
	`172`	`// Collapse rows that share a PresentationUniqueKey (e.g. alternate versions) by picking`
	`173`	`// the lowest Id per group. For MusicArtist, prefer the entity from a library the user`
	`174`	`// can actually access,since the same artist can have a folder in multiple libraries.`
	`175`	`// Keep as an IQueryable sub-select so paging is applied AFTER`
	`176`	`// ApplyOrder runs the caller's actual sort.`
0	`177`	`var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter);`
0	`178`	`var isMusicArtist = returnType == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];`
0	`179`	`var representativeIds = isMusicArtist`
0	`180`	`? masterQuery`
0	`181`	`.GroupBy(e => e.PresentationUniqueKey)`
0	`182`	`.Select(g => g`
0	`183`	`.OrderBy(e => filter.TopParentIds.Contains(e.TopParentId ?? Guid.Empty) ? 0 : 1)`
0	`184`	`.ThenBy(e => e.Id)`
0	`185`	`.First().Id)`
0	`186`	`: masterQuery`
0	`187`	`.GroupBy(e => e.PresentationUniqueKey)`
0	`188`	`.Select(g => g.Min(e => e.Id));`
	`189`
0	`190`	`var result = new QueryResult<(BaseItemDto, ItemCounts?)>();`
0	`191`	`if (filter.EnableTotalRecordCount)`
	`192`	`{`
0	`193`	`result.TotalRecordCount = representativeIds.Count();`
	`194`	`}`
	`195`
0	`196`	`var query = ApplyNavigations(`
0	`197`	`context.BaseItems.AsNoTracking().AsSingleQuery().Where(e => representativeIds.Contains(e.Id)),`
0	`198`	`filter);`
	`199`
0	`200`	`query = ApplyOrder(query, filter, context);`
	`201`
0	`202`	`if (filter.StartIndex.HasValue && filter.StartIndex.Value > 0)`
	`203`	`{`
0	`204`	`query = query.Skip(filter.StartIndex.Value);`
	`205`	`}`
	`206`
0	`207`	`if (filter.Limit.HasValue)`
	`208`	`{`
0	`209`	`query = query.Take(filter.Limit.Value);`
	`210`	`}`
	`211`
0	`212`	`result.StartIndex = filter.StartIndex ?? 0;`
0	`213`	`if (filter.IncludeItemTypes.Length > 0)`
	`214`	`{`
0	`215`	`var countsByCleanName = BuildItemCountsByCleanName(context, filter, itemValueTypes);`
0	`216`	`result.Items =`
0	`217`	`[`
0	`218`	`.. query`
0	`219`	`.AsEnumerable()`
0	`220`	`.Where(e => e is not null)`
0	`221`	`.Select(e =>`
0	`222`	`{`
0	`223`	`var item = DeserializeBaseItem(e, filter.SkipDeserialization);`
0	`224`	`countsByCleanName.TryGetValue(e.CleanName ?? string.Empty, out var itemCount);`
0	`225`	`return (item, itemCount);`
0	`226`	`})`
0	`227`	`.Where(x => x.item is not null)`
0	`228`	`.Select(x => (x.item!, x.itemCount))`
0	`229`	`];`
	`230`	`}`
	`231`	`else`
	`232`	`{`
0	`233`	`result.Items =`
0	`234`	`[`
0	`235`	`.. query`
0	`236`	`.AsEnumerable()`
0	`237`	`.Where(e => e != null)`
0	`238`	`.Select(e => DeserializeBaseItem(e, filter.SkipDeserialization))`
0	`239`	`.Where(item => item != null)`
0	`240`	`.Select(item => (item!, (ItemCounts?)null))`
0	`241`	`];`
	`242`	`}`
	`243`
0	`244`	`return result;`
0	`245`	`}`
	`246`
	`247`	`private Dictionary<string, ItemCounts> BuildItemCountsByCleanName(`
	`248`	`Database.Implementations.JellyfinDbContext context,`
	`249`	`InternalItemsQuery filter,`
	`250`	`IReadOnlyList<ItemValueType> itemValueTypes)`
	`251`	`{`
0	`252`	`var typeSubQuery = new InternalItemsQuery(filter.User)`
0	`253`	`{`
0	`254`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`255`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`256`	`MediaTypes = filter.MediaTypes,`
0	`257`	`AncestorIds = filter.AncestorIds,`
0	`258`	`ExcludeItemIds = filter.ExcludeItemIds,`
0	`259`	`ItemIds = filter.ItemIds,`
0	`260`	`TopParentIds = filter.TopParentIds,`
0	`261`	`ParentId = filter.ParentId,`
0	`262`	`IsPlayed = filter.IsPlayed`
0	`263`	`};`
	`264`
0	`265`	`var itemCountQuery = TranslateQuery(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderI`
0	`266`	`.Where(e => e.ItemValues!.Any(f => itemValueTypes!.Contains(f.ItemValue.Type)));`
	`267`
0	`268`	`var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];`
0	`269`	`var movieTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];`
0	`270`	`var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];`
0	`271`	`var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum];`
0	`272`	`var musicArtistTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];`
0	`273`	`var audioTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Audio];`
0	`274`	`var trailerTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Trailer];`
0	`275`	`var itemIds = itemCountQuery.Select(e => e.Id);`
	`276`
	`277`	`// Rewrite query to avoid SelectMany on navigation properties (which requires SQL APPLY, not supported on SQLite`
	`278`	`// Instead, start from ItemValueMaps and join with BaseItems`
0	`279`	`return context.ItemValuesMap`
0	`280`	`.Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))`
0	`281`	`.Where(ivm => itemIds.Contains(ivm.ItemId))`
0	`282`	`.Join(`
0	`283`	`context.BaseItems,`
0	`284`	`ivm => ivm.ItemId,`
0	`285`	`e => e.Id,`
0	`286`	`(ivm, e) => new { CleanName = ivm.ItemValue.CleanValue, e.Type })`
0	`287`	`.GroupBy(x => new { x.CleanName, x.Type })`
0	`288`	`.Select(g => new { g.Key.CleanName, g.Key.Type, Count = g.Count() })`
0	`289`	`.GroupBy(x => x.CleanName)`
0	`290`	`.ToDictionary(`
0	`291`	`g => g.Key,`
0	`292`	`g => new ItemCounts`
0	`293`	`{`
0	`294`	`SeriesCount = g.Where(x => x.Type == seriesTypeName).Sum(x => x.Count),`
0	`295`	`EpisodeCount = g.Where(x => x.Type == episodeTypeName).Sum(x => x.Count),`
0	`296`	`MovieCount = g.Where(x => x.Type == movieTypeName).Sum(x => x.Count),`
0	`297`	`AlbumCount = g.Where(x => x.Type == musicAlbumTypeName).Sum(x => x.Count),`
0	`298`	`ArtistCount = g.Where(x => x.Type == musicArtistTypeName).Sum(x => x.Count),`
0	`299`	`SongCount = g.Where(x => x.Type == audioTypeName).Sum(x => x.Count),`
0	`300`	`TrailerCount = g.Where(x => x.Type == trailerTypeName).Sum(x => x.Count),`
0	`301`	`});`
	`302`	`}`
	`303`	`}`

/srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs

#	Line	Line coverage
	`1`	`using System;`
	`2`	`using System.Collections.Generic;`
	`3`	`using System.Linq;`
	`4`	`using Jellyfin.Data.Enums;`
	`5`	`using Jellyfin.Database.Implementations;`
	`6`	`using Jellyfin.Database.Implementations.Entities;`
	`7`	`using Jellyfin.Extensions;`
	`8`	`using MediaBrowser.Controller;`
	`9`	`using MediaBrowser.Controller.Channels;`
	`10`	`using MediaBrowser.Controller.Configuration;`
	`11`	`using MediaBrowser.Controller.Entities;`
	`12`	`using MediaBrowser.Controller.Persistence;`
	`13`	`using Microsoft.EntityFrameworkCore;`
	`14`	`using Microsoft.Extensions.Logging;`
	`15`	`using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;`
	`16`	`using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;`
	`17`
	`18`	`namespace Jellyfin.Server.Implementations.Item;`
	`19`
	`20`	`/*`
	`21`	`All queries in this class and all other nullable enabled EFCore repository classes will make liberal use of the null`
	`22`	`This is done as the code isn't actually executed client side, but only the expressions are interpret and the compile`
	`23`	`This is your only warning/message regarding this topic.`
	`24`	`*/`
	`25`
	`26`	`/// <summary>`
	`27`	`/// Handles all storage logic for BaseItems.`
	`28`	`/// </summary>`
	`29`	`public sealed partial class BaseItemRepository`
	`30`	`: IItemRepository, IItemQueryHelpers`
	`31`	`{`
	`32`	`/// <summary>`
	`33`	`/// Gets the placeholder id for UserData detached items.`
	`34`	`/// </summary>`
1	`35`	`public static readonly Guid PlaceholderId = Guid.Parse("00000000-0000-0000-0000-000000000001");`
	`36`
	`37`	`private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;`
	`38`	`private readonly IServerApplicationHost _appHost;`
	`39`	`private readonly IItemTypeLookup _itemTypeLookup;`
	`40`	`private readonly IServerConfigurationManager _serverConfigurationManager;`
	`41`	`private readonly ILogger<BaseItemRepository> _logger;`
	`42`
1	`43`	`private static readonly IReadOnlyList<ItemValueType> _getAllArtistsValueTypes = [ItemValueType.Artist, ItemValueType`
1	`44`	`private static readonly IReadOnlyList<ItemValueType> _getArtistValueTypes = [ItemValueType.Artist];`
1	`45`	`private static readonly IReadOnlyList<ItemValueType> _getAlbumArtistValueTypes = [ItemValueType.AlbumArtist];`
1	`46`	`private static readonly IReadOnlyList<ItemValueType> _getStudiosValueTypes = [ItemValueType.Studios];`
1	`47`	`private static readonly IReadOnlyList<ItemValueType> _getGenreValueTypes = [ItemValueType.Genre];`
	`48`
	`49`	`/// <summary>`
	`50`	`/// Initializes a new instance of the <see cref="BaseItemRepository"/> class.`
	`51`	`/// </summary>`
	`52`	`/// <param name="dbProvider">The db factory.</param>`
	`53`	`/// <param name="appHost">The Application host.</param>`
	`54`	`/// <param name="itemTypeLookup">The static type lookup.</param>`
	`55`	`/// <param name="serverConfigurationManager">The server Configuration manager.</param>`
	`56`	`/// <param name="logger">System logger.</param>`
	`57`	`public BaseItemRepository(`
	`58`	`IDbContextFactory<JellyfinDbContext> dbProvider,`
	`59`	`IServerApplicationHost appHost,`
	`60`	`IItemTypeLookup itemTypeLookup,`
	`61`	`IServerConfigurationManager serverConfigurationManager,`
	`62`	`ILogger<BaseItemRepository> logger)`
	`63`	`{`
31	`64`	`_dbProvider = dbProvider;`
31	`65`	`_appHost = appHost;`
31	`66`	`_itemTypeLookup = itemTypeLookup;`
31	`67`	`_serverConfigurationManager = serverConfigurationManager;`
31	`68`	`_logger = logger;`
31	`69`	`}`
	`70`
	`71`	`/// <summary>`
	`72`	`/// Maps a Entity to the DTO. Delegates to <see cref="BaseItemMapper"/>.`
	`73`	`/// </summary>`
	`74`	`/// <param name="entity">The database entity.</param>`
	`75`	`/// <param name="dto">The target DTO.</param>`
	`76`	`/// <param name="appHost">The application host.</param>`
	`77`	`/// <param name="logger">The logger.</param>`
	`78`	`/// <returns>The mapped DTO.</returns>`
	`79`	`public static BaseItemDto Map(BaseItemEntity entity, BaseItemDto dto, IServerApplicationHost? appHost, ILogger logge`
	`80`	`{`
0	`81`	`return BaseItemMapper.Map(entity, dto, appHost);`
	`82`	`}`
	`83`
	`84`	`/// <summary>`
	`85`	`/// Maps a DTO to a database entity. Delegates to <see cref="BaseItemMapper"/>.`
	`86`	`/// </summary>`
	`87`	`/// <param name="dto">The DTO to map.</param>`
	`88`	`/// <returns>The mapped database entity.</returns>`
	`89`	`public BaseItemEntity Map(BaseItemDto dto)`
	`90`	`{`
10	`91`	`return BaseItemMapper.Map(dto, _appHost);`
	`92`	`}`
	`93`
	`94`	`/// <summary>`
	`95`	`/// Deserializes a BaseItemEntity and sets all properties.`
	`96`	`/// </summary>`
	`97`	`/// <param name="baseItemEntity">The entity to deserialize.</param>`
	`98`	`/// <param name="logger">The logger.</param>`
	`99`	`/// <param name="appHost">The application host.</param>`
	`100`	`/// <param name="skipDeserialization">Whether to skip JSON deserialization.</param>`
	`101`	`/// <returns>The deserialized item, or null.</returns>`
	`102`	`public static BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost`
	`103`	`{`
3	`104`	`return BaseItemMapper.DeserializeBaseItem(baseItemEntity, logger, appHost, skipDeserialization);`
	`105`	`}`
	`106`
	`107`	`/// <inheritdoc />`
	`108`	`public void PrepareFilterQuery(InternalItemsQuery query)`
	`109`	`{`
468	`110`	`if (query.Limit.HasValue && query.EnableGroupByMetadataKey)`
	`111`	`{`
0	`112`	`query.Limit = query.Limit.Value + 4;`
	`113`	`}`
	`114`
468	`115`	`if (query.IsResumable ?? false)`
	`116`	`{`
1	`117`	`query.IsVirtualItem = false;`
	`118`	`}`
468	`119`	`}`
	`120`
	`121`	`private List<string> GetItemByNameTypesInQuery(InternalItemsQuery query)`
	`122`	`{`
15	`123`	`var list = new List<string>();`
	`124`
15	`125`	`if (IsTypeInQuery(BaseItemKind.Person, query))`
	`126`	`{`
1	`127`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Person]!);`
	`128`	`}`
	`129`
15	`130`	`if (IsTypeInQuery(BaseItemKind.Genre, query))`
	`131`	`{`
1	`132`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]!);`
	`133`	`}`
	`134`
15	`135`	`if (IsTypeInQuery(BaseItemKind.MusicGenre, query))`
	`136`	`{`
1	`137`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]!);`
	`138`	`}`
	`139`
15	`140`	`if (IsTypeInQuery(BaseItemKind.MusicArtist, query))`
	`141`	`{`
1	`142`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!);`
	`143`	`}`
	`144`
15	`145`	`if (IsTypeInQuery(BaseItemKind.Studio, query))`
	`146`	`{`
1	`147`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]!);`
	`148`	`}`
	`149`
15	`150`	`return list;`
	`151`	`}`
	`152`
	`153`	`private bool IsTypeInQuery(BaseItemKind type, InternalItemsQuery query)`
	`154`	`{`
75	`155`	`if (query.ExcludeItemTypes.Contains(type))`
	`156`	`{`
0	`157`	`return false;`
	`158`	`}`
	`159`
75	`160`	`return query.IncludeItemTypes.Length == 0 \|\| query.IncludeItemTypes.Contains(type);`
	`161`	`}`
	`162`
	`163`	`private bool EnableGroupByPresentationUniqueKey(InternalItemsQuery query)`
	`164`	`{`
468	`165`	`if (!query.GroupByPresentationUniqueKey)`
	`166`	`{`
142	`167`	`return false;`
	`168`	`}`
	`169`
326	`170`	`if (query.GroupBySeriesPresentationUniqueKey)`
	`171`	`{`
0	`172`	`return false;`
	`173`	`}`
	`174`
326	`175`	`if (!string.IsNullOrWhiteSpace(query.PresentationUniqueKey))`
	`176`	`{`
0	`177`	`return false;`
	`178`	`}`
	`179`
326	`180`	`if (query.User is null)`
	`181`	`{`
324	`182`	`return false;`
	`183`	`}`
	`184`
2	`185`	`if (query.IncludeItemTypes.Length == 0)`
	`186`	`{`
1	`187`	`return true;`
	`188`	`}`
	`189`
1	`190`	`return query.IncludeItemTypes.Contains(BaseItemKind.Episode)`
1	`191`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Video)`
1	`192`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Movie)`
1	`193`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.MusicVideo)`
1	`194`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Series)`
1	`195`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Season);`
	`196`	`}`
	`197`
	`198`	`private static BaseItemImageInfo Map(Guid baseItemId, ItemImageInfo e)`
	`199`	`{`
0	`200`	`return BaseItemMapper.MapImageToEntity(baseItemId, e);`
	`201`	`}`
	`202`
	`203`	`private static ItemImageInfo Map(BaseItemImageInfo e, IServerApplicationHost? appHost)`
	`204`	`{`
0	`205`	`return BaseItemMapper.MapImageFromEntity(e, appHost);`
	`206`	`}`
	`207`
	`208`	`private string? GetPathToSave(string path)`
	`209`	`{`
0	`210`	`if (path is null)`
	`211`	`{`
0	`212`	`return null;`
	`213`	`}`
	`214`
0	`215`	`return _appHost.ReverseVirtualPath(path);`
	`216`	`}`
	`217`
	`218`	`/// <inheritdoc />`
	`219`	`public BaseItemDto? DeserializeBaseItem(BaseItemEntity entity, bool skipDeserialization = false)`
	`220`	`{`
72	`221`	`ArgumentNullException.ThrowIfNull(entity, nameof(entity));`
72	`222`	`if (_serverConfigurationManager?.Configuration is null)`
	`223`	`{`
0	`224`	`throw new InvalidOperationException("Server Configuration manager or configuration is null");`
	`225`	`}`
	`226`
72	`227`	`var typeToSerialise = BaseItemMapper.GetType(entity.Type);`
72	`228`	`return BaseItemMapper.DeserializeBaseItem(`
72	`229`	`entity,`
72	`230`	`_logger,`
72	`231`	`_appHost,`
72	`232`	`skipDeserialization \|\| (_serverConfigurationManager.Configuration.SkipDeserializationForBasicTypes && (typeT`
	`233`	`}`
	`234`	`}`

/srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs

#	Line	Line coverage
	`1`	`#pragma warning disable RS0030 // Do not use banned APIs`
	`2`	`#pragma warning disable CA1304 // Specify CultureInfo`
	`3`	`#pragma warning disable CA1311 // Specify a culture or use an invariant version`
	`4`	`#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string compari`
	`5`
	`6`	`using System;`
	`7`	`using System.Collections.Generic;`
	`8`	`using System.Linq;`
	`9`	`using System.Linq.Expressions;`
	`10`	`using Jellyfin.Data.Enums;`
	`11`	`using Jellyfin.Database.Implementations;`
	`12`	`using Jellyfin.Database.Implementations.Entities;`
	`13`	`using Jellyfin.Database.Implementations.Enums;`
	`14`	`using Jellyfin.Extensions;`
	`15`	`using MediaBrowser.Controller.Entities;`
	`16`	`using MediaBrowser.Model.Entities;`
	`17`	`using MediaBrowser.Model.Querying;`
	`18`	`using Microsoft.EntityFrameworkCore;`
	`19`	`using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;`
	`20`
	`21`	`namespace Jellyfin.Server.Implementations.Item;`
	`22`
	`23`	`public sealed partial class BaseItemRepository`
	`24`	`{`
	`25`	`/// <inheritdoc />`
	`26`	`public IQueryable<BaseItemEntity> PrepareItemQuery(JellyfinDbContext context, InternalItemsQuery filter)`
	`27`	`{`
470	`28`	`IQueryable<BaseItemEntity> dbQuery = context.BaseItems.AsNoTracking();`
470	`29`	`dbQuery = dbQuery.AsSingleQuery();`
	`30`
470	`31`	`return dbQuery;`
	`32`	`}`
	`33`
	`34`	`private IQueryable<BaseItemEntity> ApplyQueryFilter(IQueryable<BaseItemEntity> dbQuery, JellyfinDbContext context, I`
	`35`	`{`
85	`36`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
85	`37`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
85	`38`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
85	`39`	`dbQuery = ApplyNavigations(dbQuery, filter);`
85	`40`	`return dbQuery;`
	`41`	`}`
	`42`
	`43`	`private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)`
	`44`	`{`
468	`45`	`if (filter.Limit.HasValue \|\| filter.StartIndex.HasValue)`
	`46`	`{`
107	`47`	`var offset = filter.StartIndex ?? 0;`
	`48`
107	`49`	`if (offset > 0)`
	`50`	`{`
0	`51`	`dbQuery = dbQuery.Skip(offset);`
	`52`	`}`
	`53`
107	`54`	`if (filter.Limit.HasValue)`
	`55`	`{`
107	`56`	`dbQuery = dbQuery.Take(filter.Limit.Value);`
	`57`	`}`
	`58`	`}`
	`59`
468	`60`	`return dbQuery;`
	`61`	`}`
	`62`
	`63`	`private IQueryable<BaseItemEntity> ApplyGroupingFilter(JellyfinDbContext context, IQueryable<BaseItemEntity> dbQuery`
	`64`	`{`
	`65`	`// Collapse duplicates sharing a presentation key (e.g. alternate versions) by picking`
	`66`	`// the min Id per group. Keep the grouped ids as an IQueryable sub-select; materializing`
	`67`	`// to a List would inline one bound parameter per id and hit SQLite's variable cap.`
468	`68`	`var enableGroupByPresentationUniqueKey = EnableGroupByPresentationUniqueKey(filter);`
468	`69`	`if (enableGroupByPresentationUniqueKey && filter.GroupBySeriesPresentationUniqueKey)`
	`70`	`{`
0	`71`	`var groupedIds = dbQuery.GroupBy(e => new { e.PresentationUniqueKey, e.SeriesPresentationUniqueKey }).Select`
0	`72`	`dbQuery = context.BaseItems.AsNoTracking().Where(e => groupedIds.Contains(e.Id));`
	`73`	`}`
468	`74`	`else if (enableGroupByPresentationUniqueKey)`
	`75`	`{`
1	`76`	`var groupedIds = dbQuery.GroupBy(e => e.PresentationUniqueKey).Select(e => e.Min(x => x.Id));`
1	`77`	`dbQuery = context.BaseItems.AsNoTracking().Where(e => groupedIds.Contains(e.Id));`
	`78`	`}`
467	`79`	`else if (filter.GroupBySeriesPresentationUniqueKey)`
	`80`	`{`
0	`81`	`var groupedIds = dbQuery.GroupBy(e => e.SeriesPresentationUniqueKey).Select(e => e.Min(x => x.Id));`
0	`82`	`dbQuery = context.BaseItems.AsNoTracking().Where(e => groupedIds.Contains(e.Id));`
	`83`	`}`
	`84`	`else`
	`85`	`{`
467	`86`	`dbQuery = dbQuery.Distinct();`
	`87`	`}`
	`88`
468	`89`	`if (filter.CollapseBoxSetItems == true)`
	`90`	`{`
0	`91`	`dbQuery = ApplyBoxSetCollapsing(context, dbQuery, filter.CollapseBoxSetItemTypes);`
	`92`
	`93`	`// Name filters run after collapse so BoxSets match by their own name, not a child's.`
0	`94`	`dbQuery = ApplyNameFilters(dbQuery, filter);`
	`95`	`}`
	`96`
468	`97`	`dbQuery = ApplyOrder(dbQuery, filter, context);`
	`98`
468	`99`	`return dbQuery;`
	`100`	`}`
	`101`
	`102`	`private IQueryable<BaseItemEntity> ApplyBoxSetCollapsing(`
	`103`	`JellyfinDbContext context,`
	`104`	`IQueryable<BaseItemEntity> dbQuery,`
	`105`	`BaseItemKind[] collapsibleTypes)`
	`106`	`{`
0	`107`	`var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];`
	`108`
0	`109`	`var currentIds = dbQuery.Select(e => e.Id);`
	`110`
0	`111`	`if (collapsibleTypes.Length == 0)`
	`112`	`{`
	`113`	`// Collapse all item types into box sets`
0	`114`	`return ApplyBoxSetCollapsingAll(context, currentIds, boxSetTypeName);`
	`115`	`}`
	`116`
	`117`	`// Only collapse specific item types, keep others untouched`
0	`118`	`var collapsibleTypeNames = collapsibleTypes.Select(t => _itemTypeLookup.BaseItemKindNames[t]).ToList();`
	`119`
	`120`	`// Categorize items in currentIds in a single pass to avoid multiple correlated EXISTS over BaseItems.`
0	`121`	`var categorized = context.BaseItems`
0	`122`	`.AsNoTracking()`
0	`123`	`.Where(bi => currentIds.Contains(bi.Id))`
0	`124`	`.Select(bi => new`
0	`125`	`{`
0	`126`	`bi.Id,`
0	`127`	`IsCollapsible = collapsibleTypeNames.Contains(bi.Type),`
0	`128`	`IsBoxSet = bi.Type == boxSetTypeName`
0	`129`	`});`
	`130`
0	`131`	`var collapsibleChildIds = categorized.Where(c => c.IsCollapsible).Select(c => c.Id);`
	`132`
	`133`	`// Single JOIN: manual links to BoxSet parents, restricted to currentIds children.`
0	`134`	`var manualBoxSetLinks = context.LinkedChildren`
0	`135`	`.Where(lc => lc.ChildType == Database.Implementations.Entities.LinkedChildType.Manual`
0	`136`	`&& currentIds.Contains(lc.ChildId))`
0	`137`	`.Join(`
0	`138`	`context.BaseItems.Where(bs => bs.Type == boxSetTypeName),`
0	`139`	`lc => lc.ParentId,`
0	`140`	`bs => bs.Id,`
0	`141`	`(lc, bs) => new { lc.ChildId, lc.ParentId });`
	`142`
0	`143`	`var childrenInBoxSet = manualBoxSetLinks.Select(x => x.ChildId).Distinct();`
	`144`
	`145`	`// Items whose type is NOT collapsible (always kept in results)`
0	`146`	`var nonCollapsibleIds = categorized.Where(c => !c.IsCollapsible).Select(c => c.Id);`
	`147`
	`148`	`// Collapsible items that are not a BoxSet themselves and not a manual child of any BoxSet`
0	`149`	`var collapsibleNotInBoxSet = categorized`
0	`150`	`.Where(c => c.IsCollapsible && !c.IsBoxSet)`
0	`151`	`.Select(c => c.Id)`
0	`152`	`.Where(id => !childrenInBoxSet.Contains(id));`
	`153`
	`154`	`// BoxSet IDs containing at least one collapsible child item from currentIds`
0	`155`	`var boxSetIds = manualBoxSetLinks`
0	`156`	`.Where(x => collapsibleChildIds.Contains(x.ChildId))`
0	`157`	`.Select(x => x.ParentId)`
0	`158`	`.Distinct();`
	`159`
0	`160`	`var collapsedIds = nonCollapsibleIds.Union(collapsibleNotInBoxSet).Union(boxSetIds);`
0	`161`	`return context.BaseItems.AsNoTracking().Where(e => collapsedIds.Contains(e.Id));`
	`162`	`}`
	`163`
	`164`	`private static IQueryable<BaseItemEntity> ApplyBoxSetCollapsingAll(`
	`165`	`JellyfinDbContext context,`
	`166`	`IQueryable<Guid> currentIds,`
	`167`	`string boxSetTypeName)`
	`168`	`{`
	`169`	`// Single JOIN: manual links to BoxSet parents, restricted to currentIds children.`
0	`170`	`var manualBoxSetLinks = context.LinkedChildren`
0	`171`	`.Where(lc => lc.ChildType == Database.Implementations.Entities.LinkedChildType.Manual`
0	`172`	`&& currentIds.Contains(lc.ChildId))`
0	`173`	`.Join(`
0	`174`	`context.BaseItems.Where(bs => bs.Type == boxSetTypeName),`
0	`175`	`lc => lc.ParentId,`
0	`176`	`bs => bs.Id,`
0	`177`	`(lc, bs) => new { lc.ChildId, lc.ParentId });`
	`178`
0	`179`	`var childrenInBoxSet = manualBoxSetLinks.Select(x => x.ChildId).Distinct();`
0	`180`	`var boxSetIds = manualBoxSetLinks.Select(x => x.ParentId).Distinct();`
	`181`
	`182`	`// Items in currentIds that are not BoxSets themselves and not a manual child of any BoxSet`
0	`183`	`var notInBoxSet = context.BaseItems`
0	`184`	`.AsNoTracking()`
0	`185`	`.Where(e => currentIds.Contains(e.Id) && e.Type != boxSetTypeName)`
0	`186`	`.Select(e => e.Id)`
0	`187`	`.Where(id => !childrenInBoxSet.Contains(id));`
	`188`
0	`189`	`var collapsedIds = notInBoxSet.Union(boxSetIds);`
0	`190`	`return context.BaseItems.AsNoTracking().Where(e => collapsedIds.Contains(e.Id));`
	`191`	`}`
	`192`
	`193`	`private static IQueryable<BaseItemEntity> ApplyNameFilters(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery fi`
	`194`	`{`
468	`195`	`if (!string.IsNullOrWhiteSpace(filter.NameStartsWith))`
	`196`	`{`
0	`197`	`var nameStartsWithLower = filter.NameStartsWith.ToLowerInvariant();`
0	`198`	`dbQuery = dbQuery.Where(e => e.SortName!.ToLower().StartsWith(nameStartsWithLower));`
	`199`	`}`
	`200`
468	`201`	`if (!string.IsNullOrWhiteSpace(filter.NameStartsWithOrGreater))`
	`202`	`{`
0	`203`	`var startsOrGreaterLower = filter.NameStartsWithOrGreater.ToLowerInvariant();`
0	`204`	`dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(startsOrGreaterLower) >= 0);`
	`205`	`}`
	`206`
468	`207`	`if (!string.IsNullOrWhiteSpace(filter.NameLessThan))`
	`208`	`{`
0	`209`	`var lessThanLower = filter.NameLessThan.ToLowerInvariant();`
0	`210`	`dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(lessThanLower) < 0);`
	`211`	`}`
	`212`
468	`213`	`return dbQuery;`
	`214`	`}`
	`215`
	`216`	`/// <inheritdoc />`
	`217`	`public IQueryable<BaseItemEntity> ApplyNavigations(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)`
	`218`	`{`
403	`219`	`if (filter.TrailerTypes.Length > 0 \|\| filter.IncludeItemTypes.Contains(BaseItemKind.Trailer))`
	`220`	`{`
0	`221`	`dbQuery = dbQuery.Include(e => e.TrailerTypes);`
	`222`	`}`
	`223`
403	`224`	`if (filter.DtoOptions.ContainsField(ItemFields.ProviderIds))`
	`225`	`{`
402	`226`	`dbQuery = dbQuery.Include(e => e.Provider);`
	`227`	`}`
	`228`
403	`229`	`if (filter.DtoOptions.ContainsField(ItemFields.Settings))`
	`230`	`{`
402	`231`	`dbQuery = dbQuery.Include(e => e.LockedFields);`
	`232`	`}`
	`233`
403	`234`	`if (filter.DtoOptions.EnableUserData)`
	`235`	`{`
403	`236`	`dbQuery = dbQuery.Include(e => e.UserData);`
	`237`	`}`
	`238`
403	`239`	`if (filter.DtoOptions.EnableImages)`
	`240`	`{`
403	`241`	`dbQuery = dbQuery.Include(e => e.Images);`
	`242`	`}`
	`243`
	`244`	`// Include LinkedChildEntities for container types and videos that use them`
	`245`	`// (BoxSet, Playlist, CollectionFolder for manual linking; Video, Movie for alternate versions).`
	`246`	`// When IncludeItemTypes is empty (any type may be returned), always include them to ensure`
	`247`	`// LinkedChildren are loaded before items are saved back, preventing accidental deletion.`
403	`248`	`var linkedChildTypes = new[]`
403	`249`	`{`
403	`250`	`BaseItemKind.BoxSet,`
403	`251`	`BaseItemKind.Playlist,`
403	`252`	`BaseItemKind.CollectionFolder,`
403	`253`	`BaseItemKind.Video,`
403	`254`	`BaseItemKind.Movie`
403	`255`	`};`
403	`256`	`if (filter.IncludeItemTypes.Length == 0 \|\| filter.IncludeItemTypes.Any(linkedChildTypes.Contains))`
	`257`	`{`
247	`258`	`dbQuery = dbQuery.Include(e => e.LinkedChildEntities);`
	`259`	`}`
	`260`
403	`261`	`if (filter.IncludeExtras)`
	`262`	`{`
0	`263`	`dbQuery = dbQuery.Include(e => e.Extras);`
	`264`	`}`
	`265`
403	`266`	`return dbQuery;`
	`267`	`}`
	`268`
	`269`	`/// <inheritdoc />`
	`270`	`public IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter, JellyfinDb`
	`271`	`{`
468	`272`	`var orderBy = filter.OrderBy.Where(e => e.OrderBy != ItemSortBy.Default).ToArray();`
468	`273`	`var hasSearch = !string.IsNullOrEmpty(filter.SearchTerm);`
	`274`
	`275`	`// SeriesDatePlayed requires special handling to avoid correlated subqueries.`
	`276`	`// Instead of running a MAX() subquery per-row in ORDER BY, we pre-aggregate`
	`277`	`// max played dates per series in one query and left-join it.`
468	`278`	`if (!hasSearch && orderBy.Any(o => o.OrderBy == ItemSortBy.SeriesDatePlayed))`
	`279`	`{`
0	`280`	`return ApplySeriesDatePlayedOrder(query, filter, context, orderBy);`
	`281`	`}`
	`282`
468	`283`	`IOrderedQueryable<BaseItemEntity>? orderedQuery = null;`
	`284`
468	`285`	`if (hasSearch)`
	`286`	`{`
0	`287`	`var relevanceExpression = OrderMapper.MapSearchRelevanceOrder(filter.SearchTerm!);`
0	`288`	`orderedQuery = query.OrderBy(relevanceExpression);`
	`289`	`}`
	`290`
468	`291`	`if (orderBy.Length > 0)`
	`292`	`{`
114	`293`	`var firstOrdering = orderBy[0];`
114	`294`	`var expression = OrderMapper.MapOrderByField(firstOrdering.OrderBy, filter, context);`
	`295`
114	`296`	`if (orderedQuery is null)`
	`297`	`{`
114	`298`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
114	`299`	`? query.OrderBy(expression)`
114	`300`	`: query.OrderByDescending(expression);`
	`301`	`}`
	`302`	`else`
	`303`	`{`
0	`304`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
0	`305`	`? orderedQuery.ThenBy(expression)`
0	`306`	`: orderedQuery.ThenByDescending(expression);`
	`307`	`}`
	`308`
114	`309`	`if (firstOrdering.OrderBy is ItemSortBy.Default or ItemSortBy.SortName)`
	`310`	`{`
6	`311`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
6	`312`	`? orderedQuery.ThenBy(e => e.Name)`
6	`313`	`: orderedQuery.ThenByDescending(e => e.Name);`
	`314`	`}`
	`315`
312	`316`	`foreach (var item in orderBy.Skip(1))`
	`317`	`{`
42	`318`	`expression = OrderMapper.MapOrderByField(item.OrderBy, filter, context);`
42	`319`	`orderedQuery = item.SortOrder == SortOrder.Ascending`
42	`320`	`? orderedQuery.ThenBy(expression)`
42	`321`	`: orderedQuery.ThenByDescending(expression);`
	`322`	`}`
	`323`	`}`
	`324`
468	`325`	`if (orderedQuery is null)`
	`326`	`{`
354	`327`	`return query.OrderBy(e => e.SortName);`
	`328`	`}`
	`329`
	`330`	`// Add SortName as final tiebreaker`
114	`331`	`if (!hasSearch && (orderBy.Length == 0 \|\| orderBy.All(o => o.OrderBy is not ItemSortBy.SortName and not ItemSort`
	`332`	`{`
66	`333`	`orderedQuery = orderedQuery.ThenBy(e => e.SortName);`
	`334`	`}`
	`335`
114	`336`	`return orderedQuery;`
	`337`	`}`
	`338`
	`339`	`private IQueryable<BaseItemEntity> ApplySeriesDatePlayedOrder(`
	`340`	`IQueryable<BaseItemEntity> query,`
	`341`	`InternalItemsQuery filter,`
	`342`	`JellyfinDbContext context,`
	`343`	`(ItemSortBy OrderBy, SortOrder SortOrder)[] orderBy)`
	`344`	`{`
	`345`	`// Pre-aggregate max played date per series key in ONE query.`
	`346`	`// This generates a single: SELECT SeriesPresentationUniqueKey, MAX(LastPlayedDate) ... GROUP BY`
	`347`	`// instead of a correlated subquery per outer row.`
0	`348`	`IQueryable<UserData> userDataQuery = filter.User is not null`
0	`349`	`? context.UserData.Where(ud => ud.UserId == filter.User.Id && ud.Played)`
0	`350`	`: context.UserData.Where(ud => ud.Played);`
	`351`
0	`352`	`var seriesMaxDates = userDataQuery`
0	`353`	`.Join(`
0	`354`	`context.BaseItems,`
0	`355`	`ud => ud.ItemId,`
0	`356`	`bi => bi.Id,`
0	`357`	`(ud, bi) => new { bi.SeriesPresentationUniqueKey, ud.LastPlayedDate })`
0	`358`	`.Where(x => x.SeriesPresentationUniqueKey != null)`
0	`359`	`.GroupBy(x => x.SeriesPresentationUniqueKey)`
0	`360`	`.Select(g => new { SeriesKey = g.Key!, MaxDate = g.Max(x => x.LastPlayedDate) });`
	`361`
0	`362`	`var joined = query.LeftJoin(`
0	`363`	`seriesMaxDates,`
0	`364`	`e => e.PresentationUniqueKey,`
0	`365`	`s => s.SeriesKey,`
0	`366`	`(e, s) => new { Item = e, MaxDate = s != null ? s.MaxDate : (DateTime?)null });`
	`367`
0	`368`	`var seriesSort = orderBy.First(o => o.OrderBy == ItemSortBy.SeriesDatePlayed);`
	`369`
0	`370`	`return seriesSort.SortOrder == SortOrder.Ascending`
0	`371`	`? joined.OrderBy(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item)`
0	`372`	`: joined.OrderByDescending(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item);`
	`373`	`}`
	`374`
	`375`	`/// <summary>`
	`376`	`/// Builds a query for descendants of an ancestor with user access filtering applied.`
	`377`	`/// Uses recursive CTE to traverse both hierarchical (AncestorIds) and linked (LinkedChildren) relationships.`
	`378`	`/// </summary>`
	`379`	`/// <inheritdoc />`
	`380`	`public IQueryable<BaseItemEntity> BuildAccessFilteredDescendantsQuery(`
	`381`	`JellyfinDbContext context,`
	`382`	`InternalItemsQuery filter,`
	`383`	`Guid ancestorId)`
	`384`	`{`
	`385`	`// Use recursive CTE to get all descendants (hierarchical and linked)`
0	`386`	`var allDescendantIds = DescendantQueryHelper.GetAllDescendantIds(context, ancestorId);`
	`387`
0	`388`	`var baseQuery = context.BaseItems`
0	`389`	`.AsNoTracking()`
0	`390`	`.Where(b => allDescendantIds.Contains(b.Id) && !b.IsFolder && !b.IsVirtualItem);`
	`391`
0	`392`	`return ApplyAccessFiltering(context, baseQuery, filter);`
	`393`	`}`
	`394`
	`395`	`/// <summary>`
	`396`	`/// Applies user access filtering to a query.`
	`397`	`/// Includes TopParentIds, parental rating, and tag filtering.`
	`398`	`/// </summary>`
	`399`	`/// <inheritdoc />`
	`400`	`public IQueryable<BaseItemEntity> ApplyAccessFiltering(`
	`401`	`JellyfinDbContext context,`
	`402`	`IQueryable<BaseItemEntity> baseQuery,`
	`403`	`InternalItemsQuery filter)`
	`404`	`{`
	`405`	`// Apply TopParentIds filtering (library folder access)`
0	`406`	`if (filter.TopParentIds.Length > 0)`
	`407`	`{`
0	`408`	`var topParentIds = filter.TopParentIds;`
0	`409`	`baseQuery = baseQuery.Where(e => topParentIds.Contains(e.TopParentId!.Value));`
	`410`	`}`
	`411`
	`412`	`// Apply parental rating filtering`
0	`413`	`if (filter.MaxParentalRating is not null)`
	`414`	`{`
0	`415`	`baseQuery = baseQuery.Where(BuildMaxParentalRatingFilter(context, filter.MaxParentalRating));`
	`416`	`}`
	`417`
	`418`	`// Apply block unrated items filtering`
0	`419`	`if (filter.BlockUnratedItems.Length > 0)`
	`420`	`{`
0	`421`	`var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();`
0	`422`	`baseQuery = baseQuery.Where(e =>`
0	`423`	`e.InheritedParentalRatingValue != null \|\| !unratedItemTypes.Contains(e.UnratedType));`
	`424`	`}`
	`425`
	`426`	`// Apply excluded tags filtering (blocked tags).`
	`427`	`// Pre-build the blocked-item-id set as a sub-select; then four index-seek Contains checks`
	`428`	`// instead of one EXISTS over a 4-way OR predicate that defeats index seeks.`
0	`429`	`if (filter.ExcludeInheritedTags.Length > 0)`
	`430`	`{`
0	`431`	`var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
0	`432`	`var blockedTagItemIds = context.ItemValuesMap`
0	`433`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && excludedTags.Contains(f.ItemValue.CleanValue))`
0	`434`	`.Select(f => f.ItemId);`
	`435`
0	`436`	`baseQuery = baseQuery.Where(e =>`
0	`437`	`!blockedTagItemIds.Contains(e.Id)`
0	`438`	`&& !(e.SeriesId.HasValue && blockedTagItemIds.Contains(e.SeriesId.Value))`
0	`439`	`&& !e.Parents!.Any(p => blockedTagItemIds.Contains(p.ParentItemId))`
0	`440`	`&& !(e.TopParentId.HasValue && blockedTagItemIds.Contains(e.TopParentId.Value)));`
	`441`	`}`
	`442`
	`443`	`// Apply included tags filtering (allowed tags - item must have at least one).`
0	`444`	`if (filter.IncludeInheritedTags.Length > 0)`
	`445`	`{`
0	`446`	`var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
0	`447`	`var allowedTagItemIds = context.ItemValuesMap`
0	`448`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && includeTags.Contains(f.ItemValue.CleanValue))`
0	`449`	`.Select(f => f.ItemId);`
	`450`
0	`451`	`baseQuery = baseQuery.Where(e =>`
0	`452`	`allowedTagItemIds.Contains(e.Id)`
0	`453`	`\|\| (e.SeriesId.HasValue && allowedTagItemIds.Contains(e.SeriesId.Value))`
0	`454`	`\|\| e.Parents!.Any(p => allowedTagItemIds.Contains(p.ParentItemId))`
0	`455`	`\|\| (e.TopParentId.HasValue && allowedTagItemIds.Contains(e.TopParentId.Value)));`
	`456`	`}`
	`457`
	`458`	`// Exclude alternate versions (have PrimaryVersionId set) and owned non-extra items.`
	`459`	`// Extras (trailers, etc.) have OwnerId set but also have ExtraType set — keep those.`
0	`460`	`if (!filter.IncludeOwnedItems)`
	`461`	`{`
0	`462`	`baseQuery = baseQuery.Where(e => e.PrimaryVersionId == null && (e.OwnerId == null \|\| e.ExtraType != null));`
	`463`	`}`
	`464`
0	`465`	`return baseQuery;`
	`466`	`}`
	`467`
	`468`	`/// <summary>`
	`469`	`/// Builds a filter expression for max parental rating that handles both rated items`
	`470`	`/// and unrated BoxSets/Playlists (which check linked children's ratings).`
	`471`	`/// </summary>`
	`472`	`private static Expression<Func<BaseItemEntity, bool>> BuildMaxParentalRatingFilter(`
	`473`	`JellyfinDbContext context,`
	`474`	`ParentalRatingScore maxRating)`
	`475`	`{`
51	`476`	`var maxScore = maxRating.Score;`
51	`477`	`var maxSubScore = maxRating.SubScore ?? 0;`
51	`478`	`var linkedChildren = context.LinkedChildren;`
	`479`
51	`480`	`return e =>`
51	`481`	`// Item has a rating: check against limit`
51	`482`	`(e.InheritedParentalRatingValue != null`
51	`483`	`&& (e.InheritedParentalRatingValue < maxScore`
51	`484`	`\|\| (e.InheritedParentalRatingValue == maxScore && (e.InheritedParentalRatingSubValue ?? 0) <= maxSub`
51	`485`	`// Item has no rating`
51	`486`	`\|\| (e.InheritedParentalRatingValue == null`
51	`487`	`&& (`
51	`488`	`// No linked children (not a BoxSet/Playlist): pass as unrated`
51	`489`	`!linkedChildren.Any(lc => lc.ParentId == e.Id)`
51	`490`	`// Has linked children: at least one child must be within limits`
51	`491`	`\|\| linkedChildren.Any(lc => lc.ParentId == e.Id`
51	`492`	`&& (lc.Child!.InheritedParentalRatingValue == null`
51	`493`	`\|\| lc.Child.InheritedParentalRatingValue < maxScore`
51	`494`	`\|\| (lc.Child.InheritedParentalRatingValue == maxScore`
51	`495`	`&& (lc.Child.InheritedParentalRatingSubValue ?? 0) <= maxSubScore)))));`
	`496`	`}`
	`497`
	`498`	`/// <inheritdoc />`
	`499`	`public IQueryable<Guid> GetFullyPlayedFolderIdsQuery(JellyfinDbContext context, IQueryable<Guid> folderIds, User use`
	`500`	`{`
0	`501`	`ArgumentNullException.ThrowIfNull(context);`
0	`502`	`ArgumentNullException.ThrowIfNull(folderIds);`
0	`503`	`ArgumentNullException.ThrowIfNull(user);`
	`504`
0	`505`	`var filter = new InternalItemsQuery(user);`
0	`506`	`var userId = user.Id;`
	`507`
0	`508`	`var leafItems = context.BaseItems`
0	`509`	`.AsNoTracking()`
0	`510`	`.Where(b => !b.IsFolder && !b.IsVirtualItem);`
0	`511`	`leafItems = ApplyAccessFiltering(context, leafItems, filter);`
	`512`
0	`513`	`var playedLeafItems = leafItems`
0	`514`	`.Select(b => new { b.Id, Played = b.UserData!.Any(ud => ud.UserId == userId && ud.Played) });`
	`515`
0	`516`	`var ancestorLeaves = context.AncestorIds`
0	`517`	`.Where(a => folderIds.Contains(a.ParentItemId))`
0	`518`	`.Join(`
0	`519`	`playedLeafItems,`
0	`520`	`a => a.ItemId,`
0	`521`	`b => b.Id,`
0	`522`	`(a, b) => new { FolderId = a.ParentItemId, b.Id, b.Played });`
	`523`
0	`524`	`var linkedLeaves = context.LinkedChildren`
0	`525`	`.Where(lc => folderIds.Contains(lc.ParentId))`
0	`526`	`.Join(`
0	`527`	`playedLeafItems,`
0	`528`	`lc => lc.ChildId,`
0	`529`	`b => b.Id,`
0	`530`	`(lc, b) => new { FolderId = lc.ParentId, b.Id, b.Played });`
	`531`
0	`532`	`var linkedFolderLeaves = context.LinkedChildren`
0	`533`	`.Where(lc => folderIds.Contains(lc.ParentId))`
0	`534`	`.Join(`
0	`535`	`context.BaseItems.Where(b => b.IsFolder),`
0	`536`	`lc => lc.ChildId,`
0	`537`	`b => b.Id,`
0	`538`	`(lc, b) => new { lc.ParentId, FolderChildId = b.Id })`
0	`539`	`.Join(`
0	`540`	`context.AncestorIds,`
0	`541`	`x => x.FolderChildId,`
0	`542`	`a => a.ParentItemId,`
0	`543`	`(x, a) => new { x.ParentId, DescendantId = a.ItemId })`
0	`544`	`.Join(`
0	`545`	`playedLeafItems,`
0	`546`	`x => x.DescendantId,`
0	`547`	`b => b.Id,`
0	`548`	`(x, b) => new { FolderId = x.ParentId, b.Id, b.Played });`
	`549`
0	`550`	`return ancestorLeaves`
0	`551`	`.Union(linkedLeaves)`
0	`552`	`.Union(linkedFolderLeaves)`
0	`553`	`.GroupBy(x => x.FolderId)`
0	`554`	`.Where(g => g.Select(x => x.Id).Distinct().Count() == g.Where(x => x.Played).Select(x => x.Id).Distinct().Co`
0	`555`	`.Select(g => g.Key);`
	`556`	`}`
	`557`	`}`

/srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs

#	Line	Line coverage
	`1`	`#pragma warning disable RS0030 // Do not use banned APIs`
	`2`
	`3`	`using System;`
	`4`	`using System.Collections.Generic;`
	`5`	`using System.Linq;`
	`6`	`using System.Threading.Tasks;`
	`7`	`using Jellyfin.Data.Enums;`
	`8`	`using Jellyfin.Database.Implementations;`
	`9`	`using Jellyfin.Database.Implementations.Entities;`
	`10`	`using Jellyfin.Extensions;`
	`11`	`using MediaBrowser.Controller.Entities;`
	`12`	`using MediaBrowser.Model.Querying;`
	`13`	`using Microsoft.EntityFrameworkCore;`
	`14`	`using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;`
	`15`
	`16`	`namespace Jellyfin.Server.Implementations.Item;`
	`17`
	`18`	`public sealed partial class BaseItemRepository`
	`19`	`{`
	`20`	`/// <inheritdoc />`
	`21`	`public IReadOnlyList<Guid> GetItemIdsList(InternalItemsQuery filter)`
	`22`	`{`
85	`23`	`ArgumentNullException.ThrowIfNull(filter);`
85	`24`	`PrepareFilterQuery(filter);`
	`25`
85	`26`	`using var context = _dbProvider.CreateDbContext();`
85	`27`	`return ApplyQueryFilter(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context`
85	`28`	`}`
	`29`
	`30`	`/// <inheritdoc />`
	`31`	`public QueryResult<BaseItemDto> GetItems(InternalItemsQuery filter)`
	`32`	`{`
1	`33`	`ArgumentNullException.ThrowIfNull(filter);`
1	`34`	`if (!filter.EnableTotalRecordCount \|\| (!filter.Limit.HasValue && (filter.StartIndex ?? 0) == 0))`
	`35`	`{`
1	`36`	`var returnList = GetItemList(filter);`
1	`37`	`return new QueryResult<BaseItemDto>(`
1	`38`	`filter.StartIndex,`
1	`39`	`returnList.Count,`
1	`40`	`returnList);`
	`41`	`}`
	`42`
0	`43`	`PrepareFilterQuery(filter);`
0	`44`	`var result = new QueryResult<BaseItemDto>();`
	`45`
0	`46`	`using var context = _dbProvider.CreateDbContext();`
	`47`
0	`48`	`IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);`
	`49`
0	`50`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
0	`51`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
	`52`
0	`53`	`if (filter.EnableTotalRecordCount)`
	`54`	`{`
0	`55`	`result.TotalRecordCount = dbQuery.Count();`
	`56`	`}`
	`57`
0	`58`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
0	`59`	`dbQuery = ApplyNavigations(dbQuery, filter);`
	`60`
0	`61`	`result.Items = dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeseri`
0	`62`	`result.StartIndex = filter.StartIndex ?? 0;`
0	`63`	`return result;`
0	`64`	`}`
	`65`
	`66`	`/// <inheritdoc />`
	`67`	`public IReadOnlyList<BaseItemDto> GetItemList(InternalItemsQuery filter)`
	`68`	`{`
383	`69`	`ArgumentNullException.ThrowIfNull(filter);`
383	`70`	`PrepareFilterQuery(filter);`
	`71`
383	`72`	`using var context = _dbProvider.CreateDbContext();`
383	`73`	`IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);`
	`74`
383	`75`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
	`76`
383	`77`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
383	`78`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
	`79`
383	`80`	`var hasRandomSort = filter.OrderBy.Any(e => e.OrderBy == ItemSortBy.Random);`
383	`81`	`if (hasRandomSort)`
	`82`	`{`
65	`83`	`var orderedIds = dbQuery.AsNoTracking().Select(e => e.Id).ToList();`
65	`84`	`if (orderedIds.Count == 0)`
	`85`	`{`
65	`86`	`return Array.Empty<BaseItemDto>();`
	`87`	`}`
	`88`
0	`89`	`var itemsById = ApplyNavigations(context.BaseItems.AsNoTracking().WhereOneOrMany(orderedIds, e => e.Id), fil`
0	`90`	`.AsSplitQuery()`
0	`91`	`.AsEnumerable()`
0	`92`	`.Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))`
0	`93`	`.Where(dto => dto != null)`
0	`94`	`.ToDictionary(i => i!.Id);`
	`95`
0	`96`	`return orderedIds.Where(itemsById.ContainsKey).Select(id => itemsById[id]).ToArray()!;`
	`97`	`}`
	`98`
318	`99`	`dbQuery = ApplyNavigations(dbQuery, filter);`
	`100`
318	`101`	`return dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeserializatio`
383	`102`	`}`
	`103`
	`104`	`/// <inheritdoc/>`
	`105`	`public IReadOnlyList<BaseItemDto> GetLatestItemList(InternalItemsQuery filter, CollectionType collectionType)`
	`106`	`{`
0	`107`	`ArgumentNullException.ThrowIfNull(filter);`
0	`108`	`PrepareFilterQuery(filter);`
	`109`
	`110`	`// Early exit if collection type is not supported`
0	`111`	`if (collectionType is not CollectionType.movies and not CollectionType.tvshows and not CollectionType.music)`
	`112`	`{`
0	`113`	`return [];`
	`114`	`}`
	`115`
0	`116`	`var limit = filter.Limit;`
0	`117`	`using var context = _dbProvider.CreateDbContext();`
	`118`
0	`119`	`var baseQuery = PrepareItemQuery(context, filter);`
0	`120`	`baseQuery = TranslateQuery(baseQuery, context, filter);`
	`121`
0	`122`	`if (collectionType == CollectionType.tvshows)`
	`123`	`{`
0	`124`	`return GetLatestTvShowItems(context, baseQuery, filter, limit);`
	`125`	`}`
	`126`
0	`127`	`if (collectionType is CollectionType.movies)`
	`128`	`{`
	`129`	`// Group by PresentationUniqueKey, pick the newest item per group.`
0	`130`	`var topGroupItems = baseQuery`
0	`131`	`.Where(e => e.PresentationUniqueKey != null)`
0	`132`	`.GroupBy(e => e.PresentationUniqueKey)`
0	`133`	`.Select(g => new`
0	`134`	`{`
0	`135`	`MaxDate = g.Max(e => e.DateCreated),`
0	`136`	`FirstId = g.OrderByDescending(e => e.DateCreated).ThenByDescending(e => e.Id).Select(e => e.Id).Firs`
0	`137`	`})`
0	`138`	`.OrderByDescending(g => g.MaxDate);`
	`139`
0	`140`	`var firstIdsQuery = filter.Limit.HasValue`
0	`141`	`? topGroupItems.Take(filter.Limit.Value).Select(g => g.FirstId)`
0	`142`	`: topGroupItems.Select(g => g.FirstId);`
	`143`
0	`144`	`return LoadLatestByIds(context, firstIdsQuery, filter);`
	`145`	`}`
	`146`
	`147`	`// Albums whose Id is the parent of any track matching the user's filter.`
0	`148`	`var albumIdsWithMatchingTrack = context.AncestorIds`
0	`149`	`.Join(baseQuery, ai => ai.ItemId, t => t.Id, (ai, _) => ai.ParentItemId);`
	`150`
0	`151`	`var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum]!;`
0	`152`	`var topAlbumsQuery = context.BaseItems.AsNoTracking()`
0	`153`	`.Where(album => album.Type == musicAlbumTypeName)`
0	`154`	`.Where(album => albumIdsWithMatchingTrack.Contains(album.Id))`
0	`155`	`.OrderByDescending(album => album.DateCreated)`
0	`156`	`.ThenByDescending(album => album.Id);`
	`157`
0	`158`	`var albumIdsQuery = filter.Limit.HasValue`
0	`159`	`? topAlbumsQuery.Take(filter.Limit.Value).Select(a => a.Id)`
0	`160`	`: topAlbumsQuery.Select(a => a.Id);`
	`161`
0	`162`	`return LoadLatestByIds(context, albumIdsQuery, filter);`
0	`163`	`}`
	`164`
	`165`	// Keeping idsQuery deferred lets EF emit `WHERE Id IN (<subquery>)`.
	`166`	`private IReadOnlyList<BaseItemDto> LoadLatestByIds(`
	`167`	`JellyfinDbContext context,`
	`168`	`IQueryable<Guid> idsQuery,`
	`169`	`InternalItemsQuery filter)`
	`170`	`{`
0	`171`	`var itemsQuery = ApplyNavigations(`
0	`172`	`context.BaseItems.AsNoTracking().Where(e => idsQuery.Contains(e.Id)),`
0	`173`	`filter);`
	`174`
0	`175`	`return itemsQuery`
0	`176`	`.OrderByDescending(e => e.DateCreated)`
0	`177`	`.ThenByDescending(e => e.Id)`
0	`178`	`.AsEnumerable()`
0	`179`	`.Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))`
0	`180`	`.Where(dto => dto != null)`
0	`181`	`.ToArray()!;`
	`182`	`}`
	`183`
	`184`	`/// <summary>`
	`185`	`/// Gets the latest TV show items with smart Season/Series container selection.`
	`186`	`/// </summary>`
	`187`	`/// <remarks>`
	`188`	`/// <para>`
	`189`	`/// This method implements intelligent container selection for TV shows in the "Latest" section.`
	`190`	`/// Instead of always showing individual episodes, it analyzes recent additions and may return`
	`191`	`/// a Season or Series container when multiple related episodes were recently added.`
	`192`	`/// </para>`
	`193`	`/// <para>`
	`194`	`/// The selection logic is:`
	`195`	`/// <list type="bullet">`
	`196`	`/// <item>If recent episodes span multiple seasons → return the Series</item>`
	`197`	`/// <item>If multiple recent episodes are from one season AND the series has multiple seasons → return the Seaso`
	`198`	`/// <item>If multiple recent episodes are from one season AND the series has only one season → return the Series`
	`199`	`/// <item>Otherwise → return the most recent Episode</item>`
	`200`	`/// </list>`
	`201`	`/// </para>`
	`202`	`/// </remarks>`
	`203`	`/// <param name="context">The database context.</param>`
	`204`	`/// <param name="baseQuery">The base query with filters already applied.</param>`
	`205`	`/// <param name="filter">The query filter options.</param>`
	`206`	`/// <param name="limit">Maximum number of items to return.</param>`
	`207`	`/// <returns>A list of BaseItemDto representing the latest TV content.</returns>`
	`208`	`private IReadOnlyList<BaseItemDto> GetLatestTvShowItems(JellyfinDbContext context, IQueryable<BaseItemEntity> baseQu`
	`209`	`{`
	`210`	`// Episodes added within this window are considered "recently added together"`
	`211`	`const double RecentAdditionWindowHours = 24.0;`
	`212`
	`213`	`// Step 1: Find the top N series with recently added content, ordered by most recent addition`
0	`214`	`var topSeriesWithDates = baseQuery`
0	`215`	`.Where(e => e.SeriesName != null)`
0	`216`	`.GroupBy(e => e.SeriesName)`
0	`217`	`.Select(g => new { SeriesName = g.Key!, MaxDate = g.Max(e => e.DateCreated) })`
0	`218`	`.OrderByDescending(g => g.MaxDate);`
	`219`
0	`220`	`if (limit.HasValue)`
	`221`	`{`
0	`222`	`topSeriesWithDates = topSeriesWithDates.Take(limit.Value).OrderByDescending(g => g.MaxDate);`
	`223`	`}`
	`224`
	`225`	`// Materialize series names and cutoff to avoid embedding the GroupBy+OrderBy`
	`226`	`// expression tree as a subquery inside the episode query.`
0	`227`	`var topSeriesData = topSeriesWithDates`
0	`228`	`.Select(g => new { g.SeriesName, g.MaxDate })`
0	`229`	`.ToList();`
0	`230`	`var topSeriesNames = topSeriesData.Select(g => g.SeriesName).ToList();`
	`231`
	`232`	`// Compute a global date cutoff: the oldest series' max date minus the window.`
	`233`	`// Episodes before this cutoff cannot be in any series' "recent additions" window,`
	`234`	`// so we can safely exclude them to avoid loading ancient episodes.`
0	`235`	`var globalCutoff = topSeriesData.Count > 0`
0	`236`	`? topSeriesData.Min(g => g.MaxDate)?.AddHours(-RecentAdditionWindowHours)`
0	`237`	`: null;`
	`238`
	`239`	`// Restrict to episodes of the top series, optionally bounded by the global cutoff.`
0	`240`	`var episodeQuery = baseQuery.Where(e => e.SeriesName != null && topSeriesNames.Contains(e.SeriesName));`
0	`241`	`if (globalCutoff is not null)`
	`242`	`{`
0	`243`	`episodeQuery = episodeQuery.Where(e => e.DateCreated >= globalCutoff);`
	`244`	`}`
	`245`
	`246`	`// Lightweight projection: only the columns needed for the in-memory analysis below.`
0	`247`	`var allEpisodes = episodeQuery`
0	`248`	`.OrderByDescending(e => e.DateCreated)`
0	`249`	`.ThenByDescending(e => e.Id)`
0	`250`	`.Select(e => new { e.Id, e.SeriesName, e.DateCreated, e.SeasonId, e.SeriesId })`
0	`251`	`.AsEnumerable();`
	`252`
	`253`	`// Collect all season/series IDs we'll need to look up for count information`
0	`254`	`var allSeasonIds = new HashSet<Guid>();`
0	`255`	`var allSeriesIds = new HashSet<Guid>();`
	`256`
	`257`	`// Analysis data for each series: recent episode count, season IDs, and the most recent episode ID`
0	`258`	`var analysisData = new List<(`
0	`259`	`int RecentEpisodeCount,`
0	`260`	`List<Guid> SeasonIds,`
0	`261`	`Guid? FirstRecentSeriesId,`
0	`262`	`DateTime MaxDate,`
0	`263`	`Guid MostRecentEpisodeId)>();`
	`264`
	`265`	`// Step 3: Analyze each series to identify recent additions within the time window`
0	`266`	`foreach (var group in allEpisodes.GroupBy(e => e.SeriesName))`
	`267`	`{`
0	`268`	`var episodes = group.ToList();`
0	`269`	`var mostRecentDate = episodes[0].DateCreated ?? DateTime.MinValue;`
0	`270`	`var recentCutoff = mostRecentDate.AddHours(-RecentAdditionWindowHours);`
	`271`
	`272`	`// Find episodes added within the recent window`
0	`273`	`var recentEpisodeCount = 0;`
0	`274`	`var seasonIdSet = new HashSet<Guid>();`
0	`275`	`Guid? firstRecentSeriesId = null;`
	`276`
0	`277`	`foreach (var ep in episodes)`
	`278`	`{`
0	`279`	`if (ep.DateCreated >= recentCutoff)`
	`280`	`{`
0	`281`	`recentEpisodeCount++;`
0	`282`	`if (ep.SeasonId.HasValue)`
	`283`	`{`
0	`284`	`seasonIdSet.Add(ep.SeasonId.Value);`
	`285`	`}`
	`286`
0	`287`	`firstRecentSeriesId ??= ep.SeriesId;`
	`288`	`}`
	`289`	`}`
	`290`
0	`291`	`var seasonIds = seasonIdSet.ToList();`
0	`292`	`analysisData.Add((recentEpisodeCount, seasonIds, firstRecentSeriesId, mostRecentDate, episodes[0].Id));`
	`293`
	`294`	`// Track all unique season/series IDs for batch lookups`
0	`295`	`foreach (var sid in seasonIds)`
	`296`	`{`
0	`297`	`allSeasonIds.Add(sid);`
	`298`	`}`
	`299`
0	`300`	`if (firstRecentSeriesId.HasValue)`
	`301`	`{`
0	`302`	`allSeriesIds.Add(firstRecentSeriesId.Value);`
	`303`	`}`
	`304`	`}`
	`305`
	`306`	`// Step 4: Batch fetch counts - episodes per season and seasons per series`
	`307`	`// These counts help determine whether to show Season or Series as the container`
0	`308`	`var episodeType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];`
0	`309`	`var seasonType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Season];`
0	`310`	`var seasonEpisodeCounts = allSeasonIds.Count > 0`
0	`311`	`? context.BaseItems`
0	`312`	`.AsNoTracking()`
0	`313`	`.Where(e => e.SeasonId.HasValue && allSeasonIds.Contains(e.SeasonId.Value) && e.Type == episodeType)`
0	`314`	`.GroupBy(e => e.SeasonId!.Value)`
0	`315`	`.Select(g => new { SeasonId = g.Key, Count = g.Count() })`
0	`316`	`.ToDictionary(x => x.SeasonId, x => x.Count)`
0	`317`	`: [];`
	`318`
0	`319`	`var seriesSeasonCounts = allSeriesIds.Count > 0`
0	`320`	`? context.BaseItems`
0	`321`	`.AsNoTracking()`
0	`322`	`.Where(e => e.SeriesId.HasValue && allSeriesIds.Contains(e.SeriesId.Value) && e.Type == seasonType)`
0	`323`	`.GroupBy(e => e.SeriesId!.Value)`
0	`324`	`.Select(g => new { SeriesId = g.Key, Count = g.Count() })`
0	`325`	`.ToDictionary(x => x.SeriesId, x => x.Count)`
0	`326`	`: [];`
	`327`
	`328`	`// Step 5: Apply the container selection logic for each series.`
	`329`	`// For each series, decide which entity best represents the recent additions:`
	`330`	`// - 1 episode added → show the Episode itself`
	`331`	`// - Multiple episodes in 1 season (multi-season series) → show the Season`
	`332`	`// - Multiple episodes in 1 season (single-season series) → show the Series`
	`333`	`// - Episodes across multiple seasons → show the Series`
0	`334`	`var entitiesToFetch = new HashSet<Guid>();`
0	`335`	`var seriesResults = new List<(Guid? SeasonId, Guid? SeriesId, DateTime MaxDate, Guid MostRecentEpisodeId)>(analy`
	`336`
0	`337`	`foreach (var (recentEpisodeCount, seasonIds, firstRecentSeriesId, maxDate, mostRecentEpisodeId) in analysisData)`
	`338`	`{`
0	`339`	`Guid? seasonId = null;`
0	`340`	`Guid? seriesId = null;`
	`341`
0	`342`	`if (seasonIds.Count == 1)`
	`343`	`{`
	`344`	`// All recent episodes are from a single season`
0	`345`	`var sid = seasonIds[0];`
0	`346`	`var totalEpisodes = seasonEpisodeCounts.GetValueOrDefault(sid, 0);`
0	`347`	`var totalSeasonsInSeries = firstRecentSeriesId.HasValue`
0	`348`	`? seriesSeasonCounts.GetValueOrDefault(firstRecentSeriesId.Value, 1)`
0	`349`	`: 1;`
	`350`
	`351`	`// Check if multiple episodes were added, or if all episodes in the season were added`
0	`352`	`var hasMultipleOrAllEpisodes = recentEpisodeCount > 1 \|\| recentEpisodeCount == totalEpisodes;`
	`353`
0	`354`	`if (totalSeasonsInSeries > 1 && hasMultipleOrAllEpisodes)`
	`355`	`{`
	`356`	`// Multi-season series with bulk additions: show the Season`
0	`357`	`seasonId = sid;`
0	`358`	`entitiesToFetch.Add(sid);`
	`359`	`}`
0	`360`	`else if (hasMultipleOrAllEpisodes && firstRecentSeriesId.HasValue)`
	`361`	`{`
	`362`	`// Single-season series with bulk additions: show the Series`
0	`363`	`seriesId = firstRecentSeriesId;`
0	`364`	`entitiesToFetch.Add(firstRecentSeriesId.Value);`
	`365`	`}`
	`366`
	`367`	`// Otherwise: single episode, will fall through to show the Episode`
	`368`	`}`
0	`369`	`else if (seasonIds.Count > 1 && firstRecentSeriesId.HasValue)`
	`370`	`{`
	`371`	`// Recent episodes span multiple seasons: show the Series`
0	`372`	`seriesId = firstRecentSeriesId;`
0	`373`	`entitiesToFetch.Add(seriesId!.Value);`
	`374`	`}`
	`375`
0	`376`	`if (seasonId is null && seriesId is null)`
	`377`	`{`
0	`378`	`entitiesToFetch.Add(mostRecentEpisodeId);`
	`379`	`}`
	`380`
0	`381`	`seriesResults.Add((seasonId, seriesId, maxDate, mostRecentEpisodeId));`
	`382`	`}`
	`383`
	`384`	`// Step 6: Fetch the Season/Series entities we decided to return`
0	`385`	`var entities = entitiesToFetch.Count > 0`
0	`386`	`? ApplyNavigations(`
0	`387`	`context.BaseItems.AsNoTracking().Where(e => entitiesToFetch.Contains(e.Id)),`
0	`388`	`filter)`
0	`389`	`.AsSingleQuery()`
0	`390`	`.ToDictionary(e => e.Id)`
0	`391`	`: [];`
	`392`
	`393`	`// Step 7: Build final results, preferring Season > Series > Episode.`
	`394`	`// All needed entities are already fetched in step 6 with navigation properties.`
0	`395`	`var results = new List<(BaseItemEntity Entity, DateTime MaxDate)>(seriesResults.Count);`
0	`396`	`foreach (var (seasonId, seriesId, maxDate, mostRecentEpisodeId) in seriesResults)`
	`397`	`{`
0	`398`	`if (seasonId.HasValue && entities.TryGetValue(seasonId.Value, out var seasonEntity))`
	`399`	`{`
0	`400`	`results.Add((seasonEntity, maxDate));`
0	`401`	`continue;`
	`402`	`}`
	`403`
0	`404`	`if (seriesId.HasValue && entities.TryGetValue(seriesId.Value, out var seriesEntity))`
	`405`	`{`
0	`406`	`results.Add((seriesEntity, maxDate));`
0	`407`	`continue;`
	`408`	`}`
	`409`
0	`410`	`if (entities.TryGetValue(mostRecentEpisodeId, out var episodeEntity))`
	`411`	`{`
0	`412`	`results.Add((episodeEntity, maxDate));`
	`413`	`}`
	`414`	`}`
	`415`
0	`416`	`var finalResults = results`
0	`417`	`.OrderByDescending(r => r.MaxDate)`
0	`418`	`.ThenByDescending(r => r.Entity.Id);`
	`419`
0	`420`	`if (limit.HasValue)`
	`421`	`{`
0	`422`	`finalResults = finalResults`
0	`423`	`.Take(limit.Value)`
0	`424`	`.OrderByDescending(r => r.MaxDate)`
0	`425`	`.ThenByDescending(r => r.Entity.Id);`
	`426`	`}`
	`427`
0	`428`	`return finalResults`
0	`429`	`.Select(r => DeserializeBaseItem(r.Entity, filter.SkipDeserialization))`
0	`430`	`.Where(dto => dto is not null)`
0	`431`	`.ToArray()!;`
	`432`	`}`
	`433`
	`434`	`/// <inheritdoc/>`
	`435`	`public async Task<bool> ItemExistsAsync(Guid id)`
	`436`	`{`
23	`437`	`var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);`
23	`438`	`await using (dbContext.ConfigureAwait(false))`
	`439`	`{`
23	`440`	`return await dbContext.BaseItems.AnyAsync(f => f.Id == id).ConfigureAwait(false);`
	`441`	`}`
23	`442`	`}`
	`443`
	`444`	`/// <inheritdoc />`
	`445`	`public BaseItemDto? RetrieveItem(Guid id)`
	`446`	`{`
87	`447`	`if (id.IsEmpty())`
	`448`	`{`
0	`449`	`throw new ArgumentException("Guid can't be empty", nameof(id));`
	`450`	`}`
	`451`
87	`452`	`using var context = _dbProvider.CreateDbContext();`
87	`453`	`var dbQuery = PrepareItemQuery(context, new()`
87	`454`	`{`
87	`455`	`DtoOptions = new()`
87	`456`	`{`
87	`457`	`EnableImages = true`
87	`458`	`}`
87	`459`	`});`
87	`460`	`dbQuery = dbQuery.Include(e => e.TrailerTypes)`
87	`461`	`.Include(e => e.Provider)`
87	`462`	`.Include(e => e.LockedFields)`
87	`463`	`.Include(e => e.UserData)`
87	`464`	`.Include(e => e.Images)`
87	`465`	`.Include(e => e.LinkedChildEntities)`
87	`466`	`.AsSingleQuery();`
	`467`
87	`468`	`var item = dbQuery.FirstOrDefault(e => e.Id == id);`
87	`469`	`if (item is null)`
	`470`	`{`
87	`471`	`return null;`
	`472`	`}`
	`473`
0	`474`	`return DeserializeBaseItem(item);`
87	`475`	`}`
	`476`
	`477`	`/// <inheritdoc />`
	`478`	`public bool GetIsPlayed(User user, Guid id, bool recursive)`
	`479`	`{`
0	`480`	`using var dbContext = _dbProvider.CreateDbContext();`
	`481`
0	`482`	`if (recursive)`
	`483`	`{`
0	`484`	`var descendantIds = DescendantQueryHelper.GetAllDescendantIds(dbContext, id);`
	`485`
0	`486`	`return dbContext.BaseItems`
0	`487`	`.Where(e => descendantIds.Contains(e.Id) && !e.IsFolder && !e.IsVirtualItem)`
0	`488`	`.All(f => f.UserData!.Any(e => e.UserId == user.Id && e.Played));`
	`489`	`}`
	`490`
0	`491`	`return dbContext.BaseItems.Where(e => e.ParentId == id).All(f => f.UserData!.Any(e => e.UserId == user.Id && e.P`
0	`492`	`}`
	`493`
	`494`	`/// <inheritdoc />`
	`495`	`public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter)`
	`496`	`{`
0	`497`	`ArgumentNullException.ThrowIfNull(filter);`
0	`498`	`PrepareFilterQuery(filter);`
	`499`
0	`500`	`using var context = _dbProvider.CreateDbContext();`
0	`501`	`var baseQuery = PrepareItemQuery(context, filter);`
0	`502`	`baseQuery = TranslateQuery(baseQuery, context, filter);`
	`503`
0	`504`	`var matchingItemIds = baseQuery.Select(e => e.Id);`
	`505`
0	`506`	`var years = baseQuery`
0	`507`	`.Where(e => e.ProductionYear != null && e.ProductionYear > 0)`
0	`508`	`.Select(e => e.ProductionYear!.Value)`
0	`509`	`.Distinct()`
0	`510`	`.OrderBy(y => y)`
0	`511`	`.ToArray();`
	`512`
0	`513`	`var officialRatings = baseQuery`
0	`514`	`.Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)`
0	`515`	`.Select(e => e.OfficialRating!)`
0	`516`	`.Distinct()`
0	`517`	`.OrderBy(r => r)`
0	`518`	`.ToArray();`
	`519`
0	`520`	`var tags = context.ItemValuesMap`
0	`521`	`.Where(ivm => ivm.ItemValue.Type == ItemValueType.Tags)`
0	`522`	`.Where(ivm => matchingItemIds.Contains(ivm.ItemId))`
0	`523`	`.Select(ivm => ivm.ItemValue)`
0	`524`	`.GroupBy(iv => iv.CleanValue)`
0	`525`	`.Select(g => g.Min(iv => iv.Value))`
0	`526`	`.OrderBy(t => t)`
0	`527`	`.ToArray();`
	`528`
0	`529`	`var genres = context.ItemValuesMap`
0	`530`	`.Where(ivm => ivm.ItemValue.Type == ItemValueType.Genre)`
0	`531`	`.Where(ivm => matchingItemIds.Contains(ivm.ItemId))`
0	`532`	`.Select(ivm => ivm.ItemValue)`
0	`533`	`.GroupBy(iv => iv.CleanValue)`
0	`534`	`.Select(g => g.Min(iv => iv.Value))`
0	`535`	`.OrderBy(g => g)`
0	`536`	`.ToArray();`
	`537`
0	`538`	`return new QueryFiltersLegacy`
0	`539`	`{`
0	`540`	`Years = years,`
0	`541`	`OfficialRatings = officialRatings,`
0	`542`	`Tags = tags,`
0	`543`	`Genres = genres`
0	`544`	`};`
0	`545`	`}`
	`546`	`}`

/srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs

#	Line	Line coverage
	`1`	`#pragma warning disable RS0030 // Do not use banned APIs`
	`2`	`#pragma warning disable CA1304 // Specify CultureInfo`
	`3`	`#pragma warning disable CA1309 // Use ordinal string comparison`
	`4`	`#pragma warning disable CA1311 // Specify a culture or use an invariant version`
	`5`	`#pragma warning disable CA1307 // Specify StringComparison for clarity`
	`6`	`#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string compari`
	`7`
	`8`	`using System;`
	`9`	`using System.Collections.Generic;`
	`10`	`using System.Globalization;`
	`11`	`using System.Linq;`
	`12`	`using System.Linq.Expressions;`
	`13`	`using Jellyfin.Data.Enums;`
	`14`	`using Jellyfin.Database.Implementations;`
	`15`	`using Jellyfin.Database.Implementations.Entities;`
	`16`	`using Jellyfin.Database.Implementations.MatchCriteria;`
	`17`	`using Jellyfin.Extensions;`
	`18`	`using Jellyfin.Server.Implementations.Extensions;`
	`19`	`using MediaBrowser.Controller.Entities;`
	`20`	`using MediaBrowser.Model.Entities;`
	`21`	`using Microsoft.EntityFrameworkCore;`
	`22`	`using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;`
	`23`
	`24`	`namespace Jellyfin.Server.Implementations.Item;`
	`25`
	`26`	`public sealed partial class BaseItemRepository`
	`27`	`{`
1	`28`	`private static readonly IReadOnlyList<char> SearchWildcardTerms = ['%', '_', '[', ']', '^'];`
	`29`
1	`30`	`private static readonly string ImdbProviderName = MetadataProvider.Imdb.ToString().ToLowerInvariant();`
1	`31`	`private static readonly string TmdbProviderName = MetadataProvider.Tmdb.ToString().ToLowerInvariant();`
1	`32`	`private static readonly string TvdbProviderName = MetadataProvider.Tvdb.ToString().ToLowerInvariant();`
	`33`
	`34`	`/// <inheritdoc />`
	`35`	`public IQueryable<BaseItemEntity> TranslateQuery(`
	`36`	`IQueryable<BaseItemEntity> baseQuery,`
	`37`	`JellyfinDbContext context,`
	`38`	`InternalItemsQuery filter)`
	`39`	`{`
	`40`	`const int HDWidth = 1200;`
	`41`	`const int UHDWidth = 3800;`
	`42`	`const int UHDHeight = 2100;`
	`43`
468	`44`	`var minWidth = filter.MinWidth;`
468	`45`	`var maxWidth = filter.MaxWidth;`
468	`46`	`var now = DateTime.UtcNow;`
	`47`
468	`48`	`if (filter.IsHD.HasValue \|\| filter.Is4K.HasValue)`
	`49`	`{`
0	`50`	`bool includeSD = false;`
0	`51`	`bool includeHD = false;`
0	`52`	`bool include4K = false;`
	`53`
0	`54`	`if (filter.IsHD.HasValue && !filter.IsHD.Value)`
	`55`	`{`
0	`56`	`includeSD = true;`
	`57`	`}`
	`58`
0	`59`	`if (filter.IsHD.HasValue && filter.IsHD.Value)`
	`60`	`{`
0	`61`	`includeHD = true;`
	`62`	`}`
	`63`
0	`64`	`if (filter.Is4K.HasValue && filter.Is4K.Value)`
	`65`	`{`
0	`66`	`include4K = true;`
	`67`	`}`
	`68`
	`69`	`// Non-folders: check own resolution directly (no subquery).`
	`70`	`// Folders (Series, BoxSets): EXISTS check on descendants/linked children.`
	`71`	`// Using navigation properties (a.Item, lc.Child) produces efficient`
	`72`	`// EXISTS + JOIN instead of nested IN (SELECT ...) subqueries.`
0	`73`	`baseQuery = baseQuery.Where(e =>`
0	`74`	`(!e.IsFolder && e.Width > 0`
0	`75`	`&& ((includeSD && e.Width < HDWidth)`
0	`76`	`\|\| (includeHD && e.Width >= HDWidth && !(e.Width >= UHDWidth \|\| e.Height >= UHDHeight))`
0	`77`	`\|\| (include4K && (e.Width >= UHDWidth \|\| e.Height >= UHDHeight))))`
0	`78`	`\|\| (e.IsFolder`
0	`79`	`&& (e.Children!.Any(a =>`
0	`80`	`a.Item.Width > 0`
0	`81`	`&& ((includeSD && a.Item.Width < HDWidth)`
0	`82`	`\|\| (includeHD && a.Item.Width >= HDWidth && !(a.Item.Width >= UHDWidth \|\| a.Item.Height`
0	`83`	`\|\| (include4K && (a.Item.Width >= UHDWidth \|\| a.Item.Height >= UHDHeight))))`
0	`84`	`\|\| context.LinkedChildren.Any(lc =>`
0	`85`	`lc.ParentId == e.Id`
0	`86`	`&& lc.Child!.Width > 0`
0	`87`	`&& ((includeSD && lc.Child.Width < HDWidth)`
0	`88`	`\|\| (includeHD && lc.Child.Width >= HDWidth && !(lc.Child.Width >= UHDWidth \|\| lc.Child.H`
0	`89`	`\|\| (include4K && (lc.Child.Width >= UHDWidth \|\| lc.Child.Height >= UHDHeight)))))));`
	`90`	`}`
	`91`
468	`92`	`if (minWidth.HasValue)`
	`93`	`{`
0	`94`	`baseQuery = baseQuery.Where(e => e.Width >= minWidth);`
	`95`	`}`
	`96`
468	`97`	`if (filter.MinHeight.HasValue)`
	`98`	`{`
0	`99`	`baseQuery = baseQuery.Where(e => e.Height >= filter.MinHeight);`
	`100`	`}`
	`101`
468	`102`	`if (maxWidth.HasValue)`
	`103`	`{`
0	`104`	`baseQuery = baseQuery.Where(e => e.Width <= maxWidth);`
	`105`	`}`
	`106`
468	`107`	`if (filter.MaxHeight.HasValue)`
	`108`	`{`
0	`109`	`baseQuery = baseQuery.Where(e => e.Height <= filter.MaxHeight);`
	`110`	`}`
	`111`
468	`112`	`if (filter.IsLocked.HasValue)`
	`113`	`{`
51	`114`	`baseQuery = baseQuery.Where(e => e.IsLocked == filter.IsLocked);`
	`115`	`}`
	`116`
468	`117`	`var tags = filter.Tags.ToList();`
468	`118`	`var excludeTags = filter.ExcludeTags.ToList();`
	`119`
468	`120`	`if (filter.IsMovie.HasValue)`
	`121`	`{`
0	`122`	`var shouldIncludeAllMovieTypes = filter.IsMovie.Value`
0	`123`	`&& (filter.IncludeItemTypes.Length == 0`
0	`124`	`\|\| filter.IncludeItemTypes.Contains(BaseItemKind.Movie)`
0	`125`	`\|\| filter.IncludeItemTypes.Contains(BaseItemKind.Trailer));`
	`126`
0	`127`	`if (!shouldIncludeAllMovieTypes)`
	`128`	`{`
0	`129`	`baseQuery = baseQuery.Where(e => e.IsMovie == filter.IsMovie.Value);`
	`130`	`}`
	`131`	`}`
	`132`
468	`133`	`if (filter.IsSeries.HasValue)`
	`134`	`{`
0	`135`	`baseQuery = baseQuery.Where(e => e.IsSeries == filter.IsSeries);`
	`136`	`}`
	`137`
468	`138`	`if (filter.IsSports.HasValue)`
	`139`	`{`
0	`140`	`if (filter.IsSports.Value)`
	`141`	`{`
0	`142`	`tags.Add("Sports");`
	`143`	`}`
	`144`	`else`
	`145`	`{`
0	`146`	`excludeTags.Add("Sports");`
	`147`	`}`
	`148`	`}`
	`149`
468	`150`	`if (filter.IsNews.HasValue)`
	`151`	`{`
0	`152`	`if (filter.IsNews.Value)`
	`153`	`{`
0	`154`	`tags.Add("News");`
	`155`	`}`
	`156`	`else`
	`157`	`{`
0	`158`	`excludeTags.Add("News");`
	`159`	`}`
	`160`	`}`
	`161`
468	`162`	`if (filter.IsKids.HasValue)`
	`163`	`{`
0	`164`	`if (filter.IsKids.Value)`
	`165`	`{`
0	`166`	`tags.Add("Kids");`
	`167`	`}`
	`168`	`else`
	`169`	`{`
0	`170`	`excludeTags.Add("Kids");`
	`171`	`}`
	`172`	`}`
	`173`
468	`174`	`if (!string.IsNullOrEmpty(filter.SearchTerm))`
	`175`	`{`
0	`176`	`var cleanedSearchTerm = filter.SearchTerm.GetCleanValue();`
0	`177`	`var originalSearchTerm = filter.SearchTerm;`
0	`178`	`if (SearchWildcardTerms.Any(f => cleanedSearchTerm.Contains(f)))`
	`179`	`{`
0	`180`	`cleanedSearchTerm = $"%{cleanedSearchTerm.Trim('%')}%";`
0	`181`	`var likeSearchTerm = $"%{originalSearchTerm.Trim('%')}%";`
0	`182`	`baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName!, cleanedSearchTerm) \|\| (e.OriginalTitle`
	`183`	`}`
	`184`	`else`
	`185`	`{`
0	`186`	`var likeSearchTerm = $"%{originalSearchTerm}%";`
0	`187`	`baseQuery = baseQuery.Where(e => e.CleanName!.Contains(cleanedSearchTerm) \|\| (e.OriginalTitle != null &&`
	`188`	`}`
	`189`	`}`
	`190`
468	`191`	`if (filter.IsFolder.HasValue)`
	`192`	`{`
21	`193`	`baseQuery = baseQuery.Where(e => e.IsFolder == filter.IsFolder);`
	`194`	`}`
	`195`
468	`196`	`var includeTypes = filter.IncludeItemTypes;`
	`197`
	`198`	`// Only specify excluded types if no included types are specified`
468	`199`	`if (filter.IncludeItemTypes.Length == 0)`
	`200`	`{`
229	`201`	`var excludeTypes = filter.ExcludeItemTypes;`
229	`202`	`if (excludeTypes.Length == 1)`
	`203`	`{`
0	`204`	`if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeTypes[0], out var excludeTypeName))`
	`205`	`{`
0	`206`	`baseQuery = baseQuery.Where(e => e.Type != excludeTypeName);`
	`207`	`}`
	`208`	`}`
229	`209`	`else if (excludeTypes.Length > 1)`
	`210`	`{`
0	`211`	`var excludeTypeName = new List<string>();`
0	`212`	`foreach (var excludeType in excludeTypes)`
	`213`	`{`
0	`214`	`if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeType, out var baseItemKindName))`
	`215`	`{`
0	`216`	`excludeTypeName.Add(baseItemKindName!);`
	`217`	`}`
	`218`	`}`
	`219`
0	`220`	`baseQuery = baseQuery.Where(e => !excludeTypeName.Contains(e.Type));`
	`221`	`}`
	`222`	`}`
	`223`	`else`
	`224`	`{`
239	`225`	`string[] types = includeTypes.Select(f => _itemTypeLookup.BaseItemKindNames.GetValueOrDefault(f)).Where(e =>`
239	`226`	`baseQuery = baseQuery.WhereOneOrMany(types, f => f.Type);`
	`227`	`}`
	`228`
468	`229`	`if (filter.ChannelIds.Count > 0)`
	`230`	`{`
0	`231`	`baseQuery = baseQuery.Where(e => e.ChannelId != null && filter.ChannelIds.Contains(e.ChannelId.Value));`
	`232`	`}`
	`233`
468	`234`	`if (!filter.ParentId.IsEmpty())`
	`235`	`{`
142	`236`	`baseQuery = baseQuery.Where(e => e.ParentId!.Value == filter.ParentId);`
	`237`	`}`
	`238`
468	`239`	`if (!string.IsNullOrWhiteSpace(filter.Path))`
	`240`	`{`
0	`241`	`var pathToQuery = GetPathToSave(filter.Path);`
0	`242`	`baseQuery = baseQuery.Where(e => e.Path == pathToQuery);`
	`243`	`}`
	`244`
468	`245`	`if (!string.IsNullOrWhiteSpace(filter.PresentationUniqueKey))`
	`246`	`{`
0	`247`	`baseQuery = baseQuery.Where(e => e.PresentationUniqueKey == filter.PresentationUniqueKey);`
	`248`	`}`
	`249`
468	`250`	`if (filter.MinCommunityRating.HasValue)`
	`251`	`{`
0	`252`	`baseQuery = baseQuery.Where(e => e.CommunityRating >= filter.MinCommunityRating);`
	`253`	`}`
	`254`
468	`255`	`if (filter.MinIndexNumber.HasValue)`
	`256`	`{`
0	`257`	`baseQuery = baseQuery.Where(e => e.IndexNumber >= filter.MinIndexNumber);`
	`258`	`}`
	`259`
468	`260`	`if (filter.MinParentAndIndexNumber.HasValue)`
	`261`	`{`
0	`262`	`baseQuery = baseQuery`
0	`263`	`.Where(e => (e.ParentIndexNumber == filter.MinParentAndIndexNumber.Value.ParentIndexNumber && e.IndexNum`
	`264`	`}`
	`265`
468	`266`	`if (filter.MinDateCreated.HasValue)`
	`267`	`{`
0	`268`	`baseQuery = baseQuery.Where(e => e.DateCreated >= filter.MinDateCreated);`
	`269`	`}`
	`270`
468	`271`	`if (filter.MinDateLastSaved.HasValue)`
	`272`	`{`
0	`273`	`baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSaved.Value`
	`274`	`}`
	`275`
468	`276`	`if (filter.MinDateLastSavedForUser.HasValue)`
	`277`	`{`
0	`278`	`baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSavedForUse`
	`279`	`}`
	`280`
468	`281`	`if (filter.IndexNumber.HasValue)`
	`282`	`{`
0	`283`	`baseQuery = baseQuery.Where(e => e.IndexNumber == filter.IndexNumber.Value);`
	`284`	`}`
	`285`
468	`286`	`if (filter.ParentIndexNumber.HasValue)`
	`287`	`{`
0	`288`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber == filter.ParentIndexNumber.Value);`
	`289`	`}`
	`290`
468	`291`	`if (filter.ParentIndexNumberNotEquals.HasValue)`
	`292`	`{`
0	`293`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber != filter.ParentIndexNumberNotEquals.Value \|\| e.ParentI`
	`294`	`}`
	`295`
468	`296`	`var minEndDate = filter.MinEndDate;`
468	`297`	`var maxEndDate = filter.MaxEndDate;`
	`298`
468	`299`	`if (filter.HasAired.HasValue)`
	`300`	`{`
0	`301`	`if (filter.HasAired.Value)`
	`302`	`{`
0	`303`	`maxEndDate = DateTime.UtcNow;`
	`304`	`}`
	`305`	`else`
	`306`	`{`
0	`307`	`minEndDate = DateTime.UtcNow;`
	`308`	`}`
	`309`	`}`
	`310`
468	`311`	`if (minEndDate.HasValue)`
	`312`	`{`
0	`313`	`baseQuery = baseQuery.Where(e => e.EndDate >= minEndDate);`
	`314`	`}`
	`315`
468	`316`	`if (maxEndDate.HasValue)`
	`317`	`{`
0	`318`	`baseQuery = baseQuery.Where(e => e.EndDate <= maxEndDate);`
	`319`	`}`
	`320`
468	`321`	`if (filter.MinStartDate.HasValue)`
	`322`	`{`
0	`323`	`baseQuery = baseQuery.Where(e => e.StartDate >= filter.MinStartDate.Value);`
	`324`	`}`
	`325`
468	`326`	`if (filter.MaxStartDate.HasValue)`
	`327`	`{`
0	`328`	`baseQuery = baseQuery.Where(e => e.StartDate <= filter.MaxStartDate.Value);`
	`329`	`}`
	`330`
468	`331`	`if (filter.MinPremiereDate.HasValue)`
	`332`	`{`
0	`333`	`baseQuery = baseQuery.Where(e => e.PremiereDate >= filter.MinPremiereDate.Value);`
	`334`	`}`
	`335`
468	`336`	`if (filter.MaxPremiereDate.HasValue)`
	`337`	`{`
0	`338`	`baseQuery = baseQuery.Where(e => e.PremiereDate <= filter.MaxPremiereDate.Value);`
	`339`	`}`
	`340`
468	`341`	`if (filter.TrailerTypes.Length > 0)`
	`342`	`{`
0	`343`	`var trailerTypes = filter.TrailerTypes.Select(e => (int)e).ToArray();`
0	`344`	`baseQuery = baseQuery.Where(e => e.TrailerTypes!.Any(w => trailerTypes.Contains(w.Id)));`
	`345`	`}`
	`346`
468	`347`	`if (filter.IsAiring.HasValue)`
	`348`	`{`
0	`349`	`if (filter.IsAiring.Value)`
	`350`	`{`
0	`351`	`baseQuery = baseQuery.Where(e => e.StartDate <= now && e.EndDate >= now);`
	`352`	`}`
	`353`	`else`
	`354`	`{`
0	`355`	`baseQuery = baseQuery.Where(e => e.StartDate > now && e.EndDate < now);`
	`356`	`}`
	`357`	`}`
	`358`
468	`359`	`if (filter.PersonIds.Length > 0)`
	`360`	`{`
0	`361`	`var peopleEntityIds = context.BaseItems`
0	`362`	`.WhereOneOrMany(filter.PersonIds, b => b.Id)`
0	`363`	`.Join(`
0	`364`	`context.Peoples,`
0	`365`	`b => b.Name,`
0	`366`	`p => p.Name,`
0	`367`	`(b, p) => p.Id);`
	`368`
0	`369`	`baseQuery = baseQuery`
0	`370`	`.Where(e => context.PeopleBaseItemMap`
0	`371`	`.Any(m => m.ItemId == e.Id && peopleEntityIds.Contains(m.PeopleId)));`
	`372`	`}`
	`373`
468	`374`	`if (!string.IsNullOrWhiteSpace(filter.Person))`
	`375`	`{`
0	`376`	`baseQuery = baseQuery.Where(e => e.Peoples!.Any(f => f.People.Name == filter.Person));`
	`377`	`}`
	`378`
468	`379`	`if (!string.IsNullOrWhiteSpace(filter.ExternalSeriesId))`
	`380`	`{`
0	`381`	`baseQuery = baseQuery.Where(e => e.ExternalSeriesId == filter.ExternalSeriesId);`
	`382`	`}`
	`383`
468	`384`	`if (!string.IsNullOrWhiteSpace(filter.ExternalId))`
	`385`	`{`
0	`386`	`baseQuery = baseQuery.Where(e => e.ExternalId == filter.ExternalId);`
	`387`	`}`
	`388`
468	`389`	`if (!string.IsNullOrWhiteSpace(filter.Name))`
	`390`	`{`
3	`391`	`if (filter.UseRawName == true)`
	`392`	`{`
0	`393`	`var nameLower = filter.Name.ToLowerInvariant();`
0	`394`	`baseQuery = baseQuery.Where(e => e.Name!.ToLower() == nameLower);`
	`395`	`}`
	`396`	`else`
	`397`	`{`
3	`398`	`var cleanName = filter.Name.GetCleanValue();`
3	`399`	`baseQuery = baseQuery.Where(e => e.CleanName == cleanName);`
	`400`	`}`
	`401`	`}`
	`402`
468	`403`	`var nameContains = filter.NameContains;`
468	`404`	`if (!string.IsNullOrWhiteSpace(nameContains))`
	`405`	`{`
0	`406`	`if (SearchWildcardTerms.Any(f => nameContains.Contains(f)))`
	`407`	`{`
0	`408`	`nameContains = $"%{nameContains.Trim('%')}%";`
0	`409`	`baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName, nameContains) \|\| EF.Functions.Like(e.Ori`
	`410`	`}`
	`411`	`else`
	`412`	`{`
0	`413`	`var likeNameContains = $"%{nameContains}%";`
0	`414`	`baseQuery = baseQuery.Where(e =>`
0	`415`	`e.CleanName!.Contains(nameContains)`
0	`416`	`\|\| EF.Functions.Like(e.OriginalTitle, likeNameContains));`
	`417`	`}`
	`418`	`}`
	`419`
	`420`	`// When box set collapsing is active, defer name-range filters to after the collapse.`
	`421`	`// Otherwise, items are filtered by their own name but then collapsed into a BoxSet`
	`422`	`// whose name may fall in a different range (e.g. "21 Jump Street" is under "#"`
	`423`	`// but its BoxSet "Jump Street Collection" should appear under "J").`
468	`424`	`if (filter.CollapseBoxSetItems != true)`
	`425`	`{`
468	`426`	`baseQuery = ApplyNameFilters(baseQuery, filter);`
	`427`	`}`
	`428`
468	`429`	`if (filter.ImageTypes.Length > 0)`
	`430`	`{`
107	`431`	`var imgTypes = filter.ImageTypes.Select(e => (ImageInfoImageType)e).ToArray();`
107	`432`	`baseQuery = baseQuery.Where(e => e.Images!.Any(w => imgTypes.Contains(w.ImageType)));`
	`433`	`}`
	`434`
468	`435`	`if (filter.IsLiked.HasValue)`
	`436`	`{`
0	`437`	`var isLiked = filter.IsLiked.Value;`
0	`438`	`baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.Rating >= UserItem`
	`439`	`}`
	`440`
468	`441`	`if (filter.IsFavoriteOrLiked.HasValue)`
	`442`	`{`
0	`443`	`var isFavoriteOrLiked = filter.IsFavoriteOrLiked.Value;`
0	`444`	`baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.IsFavorite) == isF`
	`445`	`}`
	`446`
468	`447`	`if (filter.IsFavorite.HasValue)`
	`448`	`{`
0	`449`	`var isFavorite = filter.IsFavorite.Value;`
0	`450`	`baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.IsFavorite) == isF`
	`451`	`}`
	`452`
468	`453`	`if (filter.IsPlayed.HasValue)`
	`454`	`{`
0	`455`	`var hasSeries = filter.IncludeItemTypes.Contains(BaseItemKind.Series);`
0	`456`	`var hasBoxSet = filter.IncludeItemTypes.Contains(BaseItemKind.BoxSet);`
	`457`
0	`458`	`if (hasSeries \|\| hasBoxSet)`
	`459`	`{`
0	`460`	`var userId = filter.User!.Id;`
0	`461`	`var isPlayed = filter.IsPlayed.Value;`
0	`462`	`var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];`
0	`463`	`var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];`
	`464`
	`465`	`// Series: played = at least one episode AND all episodes played; unplayed = otherwise.`
0	`466`	`IQueryable<Guid> playedSeriesIds = hasSeries`
0	`467`	`? context.BaseItems`
0	`468`	`.AsNoTracking()`
0	`469`	`.Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)`
0	`470`	`.GroupBy(e => e.SeriesId!.Value)`
0	`471`	`.Where(g => !g.Any(e => !e.UserData!.Any(ud => ud.UserId == userId && ud.Played)))`
0	`472`	`.Select(g => g.Key)`
0	`473`	`: Enumerable.Empty<Guid>().AsQueryable();`
	`474`
	`475`	`// BoxSet: played = all children played.`
0	`476`	`IQueryable<Guid> playedBoxSetIds = hasBoxSet`
0	`477`	`? GetFullyPlayedFolderIdsQuery(`
0	`478`	`context,`
0	`479`	`baseQuery.Where(e => e.Type == boxSetTypeName).Select(e => e.Id),`
0	`480`	`filter.User!)`
0	`481`	`: Enumerable.Empty<Guid>().AsQueryable();`
	`482`
	`483`	`// Non-folder items: check UserData directly`
0	`484`	`var playedItemIds = context.UserData`
0	`485`	`.Where(ud => ud.UserId == userId && ud.Played)`
0	`486`	`.Select(ud => ud.ItemId);`
	`487`
0	`488`	`if (isPlayed)`
	`489`	`{`
0	`490`	`baseQuery = baseQuery.Where(e =>`
0	`491`	`(e.Type == seriesTypeName && playedSeriesIds.Contains(e.Id))`
0	`492`	`\|\| (e.Type == boxSetTypeName && playedBoxSetIds.Contains(e.Id))`
0	`493`	`\|\| (e.Type != seriesTypeName && e.Type != boxSetTypeName && playedItemIds.Contains(e.Id)));`
	`494`	`}`
	`495`	`else`
	`496`	`{`
0	`497`	`baseQuery = baseQuery.Where(e =>`
0	`498`	`(e.Type == seriesTypeName && !playedSeriesIds.Contains(e.Id))`
0	`499`	`\|\| (e.Type == boxSetTypeName && !playedBoxSetIds.Contains(e.Id))`
0	`500`	`\|\| (e.Type != seriesTypeName && e.Type != boxSetTypeName && !playedItemIds.Contains(e.Id)));`
	`501`	`}`
	`502`	`}`
	`503`	`else`
	`504`	`{`
0	`505`	`var playedItemIds = context.UserData`
0	`506`	`.Where(ud => ud.UserId == filter.User!.Id && ud.Played)`
0	`507`	`.Select(ud => ud.ItemId);`
0	`508`	`var isPlayedItem = filter.IsPlayed.Value;`
0	`509`	`baseQuery = baseQuery.Where(e => playedItemIds.Contains(e.Id) == isPlayedItem);`
	`510`	`}`
	`511`	`}`
	`512`
468	`513`	`if (filter.IsResumable.HasValue)`
	`514`	`{`
1	`515`	`var hasSeries = filter.IncludeItemTypes.Contains(BaseItemKind.Series);`
	`516`
1	`517`	`if (hasSeries)`
	`518`	`{`
0	`519`	`var userId = filter.User!.Id;`
0	`520`	`var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];`
0	`521`	`var isResumable = filter.IsResumable.Value;`
	`522`
	`523`	`// Aggregate per series in a single GROUP BY pass, instead of three full scans.`
0	`524`	`var seriesEpisodeStats = context.BaseItems`
0	`525`	`.AsNoTracking()`
0	`526`	`.Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)`
0	`527`	`.GroupBy(e => e.SeriesId!.Value)`
0	`528`	`.Select(g => new`
0	`529`	`{`
0	`530`	`SeriesId = g.Key,`
0	`531`	`HasInProgress = g.Any(e => e.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks`
0	`532`	`HasPlayed = g.Any(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played)),`
0	`533`	`HasUnplayed = g.Any(e => !e.UserData!.Any(ud => ud.UserId == userId && ud.Played))`
0	`534`	`});`
	`535`
	`536`	`// A series is resumable if it has an in-progress episode,`
	`537`	`// or if it has both played and unplayed episodes (partially watched).`
0	`538`	`var resumableSeriesIds = seriesEpisodeStats`
0	`539`	`.Where(s => s.HasInProgress \|\| (s.HasPlayed && s.HasUnplayed))`
0	`540`	`.Select(s => s.SeriesId);`
	`541`
	`542`	`// Non-series items: resumable if PlaybackPositionTicks > 0`
0	`543`	`var resumableItemIds = context.UserData`
0	`544`	`.Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0)`
0	`545`	`.Select(ud => ud.ItemId);`
	`546`
0	`547`	`baseQuery = baseQuery.Where(e =>`
0	`548`	`(e.Type == seriesTypeName && resumableSeriesIds.Contains(e.Id) == isResumable)`
0	`549`	`\|\| (e.Type != seriesTypeName && resumableItemIds.Contains(e.Id) == isResumable));`
	`550`	`}`
	`551`	`else`
	`552`	`{`
1	`553`	`var resumableItemIds = context.UserData`
1	`554`	`.Where(ud => ud.UserId == filter.User!.Id && ud.PlaybackPositionTicks > 0)`
1	`555`	`.Select(ud => ud.ItemId);`
1	`556`	`var isResumable = filter.IsResumable.Value;`
1	`557`	`baseQuery = baseQuery.Where(e => resumableItemIds.Contains(e.Id) == isResumable);`
	`558`	`}`
	`559`	`}`
	`560`
468	`561`	`if (filter.ArtistIds.Length > 0)`
	`562`	`{`
0	`563`	`baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumAr`
	`564`	`}`
	`565`
468	`566`	`if (filter.AlbumArtistIds.Length > 0)`
	`567`	`{`
0	`568`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.AlbumArtist, filter.AlbumArtistIds);`
	`569`	`}`
	`570`
468	`571`	`if (filter.ContributingArtistIds.Length > 0)`
	`572`	`{`
0	`573`	`var contributingNames = context.BaseItems`
0	`574`	`.Where(b => filter.ContributingArtistIds.Contains(b.Id))`
0	`575`	`.Select(b => b.CleanName);`
	`576`
0	`577`	`baseQuery = baseQuery.Where(e =>`
0	`578`	`e.ItemValues!.Any(ivm =>`
0	`579`	`ivm.ItemValue.Type == ItemValueType.Artist &&`
0	`580`	`contributingNames.Contains(ivm.ItemValue.CleanValue))`
0	`581`	`&&`
0	`582`	`!e.ItemValues!.Any(ivm =>`
0	`583`	`ivm.ItemValue.Type == ItemValueType.AlbumArtist &&`
0	`584`	`contributingNames.Contains(ivm.ItemValue.CleanValue)));`
	`585`	`}`
	`586`
468	`587`	`if (filter.AlbumIds.Length > 0)`
	`588`	`{`
0	`589`	`baseQuery = baseQuery.Where(e => e.ParentId.HasValue && filter.AlbumIds.Contains(e.ParentId.Value));`
	`590`	`}`
	`591`
468	`592`	`if (filter.ExcludeArtistIds.Length > 0)`
	`593`	`{`
0	`594`	`baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumAr`
	`595`	`}`
	`596`
468	`597`	`if (filter.GenreIds.Count > 0)`
	`598`	`{`
0	`599`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Genre, filter.GenreIds.ToArray());`
	`600`	`}`
	`601`
468	`602`	`if (filter.Genres.Count > 0)`
	`603`	`{`
0	`604`	`var cleanGenres = filter.Genres.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValu`
0	`605`	`baseQuery = baseQuery`
0	`606`	`.Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Genre).Any(clea`
	`607`	`}`
	`608`
468	`609`	`if (tags.Count > 0)`
	`610`	`{`
0	`611`	`var cleanValues = tags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, str`
0	`612`	`baseQuery = baseQuery`
0	`613`	`.Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clean`
	`614`	`}`
	`615`
468	`616`	`if (excludeTags.Count > 0)`
	`617`	`{`
0	`618`	`var cleanValues = excludeTags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueM`
0	`619`	`baseQuery = baseQuery`
0	`620`	`.Where(e => !e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clea`
	`621`	`}`
	`622`
468	`623`	`if (filter.StudioIds.Length > 0)`
	`624`	`{`
0	`625`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Studios, filter.StudioIds.ToArray());`
	`626`	`}`
	`627`
468	`628`	`if (filter.OfficialRatings.Length > 0)`
	`629`	`{`
0	`630`	`var ratings = filter.OfficialRatings;`
0	`631`	`baseQuery = baseQuery.WhereItemOrDescendantMatches(context, e => ratings.Contains(e.OfficialRating));`
	`632`	`}`
	`633`
468	`634`	`Expression<Func<BaseItemEntity, bool>>? minParentalRatingFilter = null;`
468	`635`	`if (filter.MinParentalRating != null)`
	`636`	`{`
0	`637`	`var min = filter.MinParentalRating;`
0	`638`	`var minScore = min.Score;`
0	`639`	`var minSubScore = min.SubScore ?? 0;`
	`640`
0	`641`	`minParentalRatingFilter = e =>`
0	`642`	`e.InheritedParentalRatingValue == null \|\|`
0	`643`	`e.InheritedParentalRatingValue > minScore \|\|`
0	`644`	`(e.InheritedParentalRatingValue == minScore && (e.InheritedParentalRatingSubValue ?? 0) >= minSubScore);`
	`645`	`}`
	`646`
468	`647`	`Expression<Func<BaseItemEntity, bool>>? maxParentalRatingFilter = null;`
468	`648`	`if (filter.MaxParentalRating != null)`
	`649`	`{`
51	`650`	`maxParentalRatingFilter = BuildMaxParentalRatingFilter(context, filter.MaxParentalRating);`
	`651`	`}`
	`652`
468	`653`	`if (filter.HasParentalRating ?? false)`
	`654`	`{`
0	`655`	`if (minParentalRatingFilter != null)`
	`656`	`{`
0	`657`	`baseQuery = baseQuery.Where(minParentalRatingFilter);`
	`658`	`}`
	`659`
0	`660`	`if (maxParentalRatingFilter != null)`
	`661`	`{`
0	`662`	`baseQuery = baseQuery.Where(maxParentalRatingFilter);`
	`663`	`}`
	`664`	`}`
468	`665`	`else if (filter.BlockUnratedItems.Length > 0)`
	`666`	`{`
0	`667`	`var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();`
0	`668`	`Expression<Func<BaseItemEntity, bool>> unratedItemFilter = e => e.InheritedParentalRatingValue != null \|\| !u`
	`669`
0	`670`	`if (minParentalRatingFilter != null && maxParentalRatingFilter != null)`
	`671`	`{`
0	`672`	`baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter.And(maxParentalRatingFilter)))`
	`673`	`}`
0	`674`	`else if (minParentalRatingFilter != null)`
	`675`	`{`
0	`676`	`baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter));`
	`677`	`}`
0	`678`	`else if (maxParentalRatingFilter != null)`
	`679`	`{`
0	`680`	`baseQuery = baseQuery.Where(unratedItemFilter.And(maxParentalRatingFilter));`
	`681`	`}`
	`682`	`else`
	`683`	`{`
0	`684`	`baseQuery = baseQuery.Where(unratedItemFilter);`
	`685`	`}`
	`686`	`}`
468	`687`	`else if (minParentalRatingFilter != null \|\| maxParentalRatingFilter != null)`
	`688`	`{`
51	`689`	`if (minParentalRatingFilter != null)`
	`690`	`{`
0	`691`	`baseQuery = baseQuery.Where(minParentalRatingFilter);`
	`692`	`}`
	`693`
51	`694`	`if (maxParentalRatingFilter != null)`
	`695`	`{`
51	`696`	`baseQuery = baseQuery.Where(maxParentalRatingFilter);`
	`697`	`}`
	`698`	`}`
417	`699`	`else if (!filter.HasParentalRating ?? false)`
	`700`	`{`
0	`701`	`baseQuery = baseQuery`
0	`702`	`.Where(e => e.InheritedParentalRatingValue == null);`
	`703`	`}`
	`704`
468	`705`	`if (filter.HasOfficialRating.HasValue)`
	`706`	`{`
0	`707`	`Expression<Func<BaseItemEntity, bool>> hasRating =`
0	`708`	`e => e.OfficialRating != null && e.OfficialRating != string.Empty;`
	`709`
0	`710`	`baseQuery = filter.HasOfficialRating.Value`
0	`711`	`? baseQuery.WhereItemOrDescendantMatches(context, hasRating)`
0	`712`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasRating);`
	`713`	`}`
	`714`
468	`715`	`if (filter.HasOverview.HasValue)`
	`716`	`{`
0	`717`	`if (filter.HasOverview.Value)`
	`718`	`{`
0	`719`	`baseQuery = baseQuery`
0	`720`	`.Where(e => e.Overview != null && e.Overview != string.Empty);`
	`721`	`}`
	`722`	`else`
	`723`	`{`
0	`724`	`baseQuery = baseQuery`
0	`725`	`.Where(e => e.Overview == null \|\| e.Overview == string.Empty);`
	`726`	`}`
	`727`	`}`
	`728`
468	`729`	`if (filter.HasOwnerId.HasValue)`
	`730`	`{`
0	`731`	`if (filter.HasOwnerId.Value)`
	`732`	`{`
0	`733`	`baseQuery = baseQuery`
0	`734`	`.Where(e => e.OwnerId != null);`
	`735`	`}`
	`736`	`else`
	`737`	`{`
0	`738`	`baseQuery = baseQuery`
0	`739`	`.Where(e => e.OwnerId == null);`
	`740`	`}`
	`741`	`}`
468	`742`	`else if (filter.OwnerIds.Length == 0 && filter.ExtraTypes.Length == 0 && !filter.IncludeOwnedItems)`
	`743`	`{`
	`744`	`// Exclude alternate versions and owned non-extra items from general queries.`
	`745`	`// Alternate versions have PrimaryVersionId set (pointing to their primary).`
	`746`	`// Extras (trailers, etc.) have OwnerId set but also have ExtraType set - keep those.`
440	`747`	`baseQuery = baseQuery.Where(e => e.PrimaryVersionId == null && (e.OwnerId == null \|\| e.ExtraType != null));`
	`748`	`}`
	`749`
468	`750`	`if (filter.OwnerIds.Length > 0)`
	`751`	`{`
6	`752`	`baseQuery = baseQuery.Where(e => e.OwnerId != null && filter.OwnerIds.Contains(e.OwnerId.Value));`
	`753`	`}`
	`754`
468	`755`	`if (filter.ExtraTypes.Length > 0)`
	`756`	`{`
	`757`	`// Convert ExtraType enum to BaseItemExtraType enum via int cast (same underlying values)`
0	`758`	`var extraTypeValues = filter.ExtraTypes.Select(e => (BaseItemExtraType?)(int)e).ToArray();`
0	`759`	`baseQuery = baseQuery.Where(e => e.ExtraType != null && extraTypeValues.Contains(e.ExtraType));`
	`760`	`}`
	`761`
468	`762`	`if (!string.IsNullOrWhiteSpace(filter.HasNoAudioTrackWithLanguage))`
	`763`	`{`
0	`764`	`var lang = filter.HasNoAudioTrackWithLanguage;`
0	`765`	`var foldersWithAudio = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStrea`
	`766`
0	`767`	`baseQuery = baseQuery`
0	`768`	`.Where(e =>`
0	`769`	`(!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Audio && ms.Langua`
0	`770`	`\|\| (e.IsFolder && !foldersWithAudio.Contains(e.Id)));`
	`771`	`}`
	`772`
468	`773`	`if (!string.IsNullOrWhiteSpace(filter.HasNoInternalSubtitleTrackWithLanguage))`
	`774`	`{`
0	`775`	`var lang = filter.HasNoInternalSubtitleTrackWithLanguage;`
0	`776`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaS`
	`777`
0	`778`	`baseQuery = baseQuery`
0	`779`	`.Where(e =>`
0	`780`	`(!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && !ms.Is`
0	`781`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`782`	`}`
	`783`
468	`784`	`if (!string.IsNullOrWhiteSpace(filter.HasNoExternalSubtitleTrackWithLanguage))`
	`785`	`{`
0	`786`	`var lang = filter.HasNoExternalSubtitleTrackWithLanguage;`
0	`787`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaS`
	`788`
0	`789`	`baseQuery = baseQuery`
0	`790`	`.Where(e =>`
0	`791`	`(!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && ms.IsE`
0	`792`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`793`	`}`
	`794`
468	`795`	`if (!string.IsNullOrWhiteSpace(filter.HasNoSubtitleTrackWithLanguage))`
	`796`	`{`
0	`797`	`var lang = filter.HasNoSubtitleTrackWithLanguage;`
0	`798`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaS`
	`799`
0	`800`	`baseQuery = baseQuery`
0	`801`	`.Where(e =>`
0	`802`	`(!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && ms.Lan`
0	`803`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`804`	`}`
	`805`
468	`806`	`if (filter.HasSubtitles.HasValue)`
	`807`	`{`
0	`808`	`var hasSubtitles = filter.HasSubtitles.Value;`
0	`809`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasSubtitles());`
0	`810`	`if (hasSubtitles)`
	`811`	`{`
0	`812`	`baseQuery = baseQuery`
0	`813`	`.Where(e =>`
0	`814`	`(!e.IsFolder && e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle))`
0	`815`	`\|\| (e.IsFolder && foldersWithSubtitles.Contains(e.Id)));`
	`816`	`}`
	`817`	`else`
	`818`	`{`
0	`819`	`baseQuery = baseQuery`
0	`820`	`.Where(e =>`
0	`821`	`(!e.IsFolder && !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle))`
0	`822`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`823`	`}`
	`824`	`}`
	`825`
468	`826`	`if (filter.SubtitleLanguages.Count > 0)`
	`827`	`{`
0	`828`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaS`
0	`829`	`baseQuery = baseQuery`
0	`830`	`.Where(e =>`
0	`831`	`(!e.IsFolder && e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle`
0	`832`	`&& (filter.SubtitleLanguages.Contains(f.Language) \|\| (filter.SubtitleLanguages.Contains("und") && s`
0	`833`	`\|\| (e.IsFolder && foldersWithSubtitles.Contains(e.Id)));`
	`834`	`}`
	`835`
468	`836`	`if (filter.AudioLanguages.Count > 0)`
	`837`	`{`
0	`838`	`var foldersWithAudio = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStrea`
0	`839`	`baseQuery = baseQuery`
0	`840`	`.Where(e =>`
0	`841`	`(!e.IsFolder && e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Audio`
0	`842`	`&& (filter.AudioLanguages.Contains(f.Language) \|\| (filter.AudioLanguages.Contains("und") && string.`
0	`843`	`\|\| (e.IsFolder && foldersWithAudio.Contains(e.Id)));`
	`844`	`}`
	`845`
468	`846`	`if (filter.HasChapterImages.HasValue)`
	`847`	`{`
0	`848`	`var hasChapterImages = filter.HasChapterImages.Value;`
0	`849`	`var foldersWithChapterImages = DescendantQueryHelper.GetFolderIdsMatching(context, new HasChapterImages());`
0	`850`	`if (hasChapterImages)`
	`851`	`{`
0	`852`	`baseQuery = baseQuery`
0	`853`	`.Where(e =>`
0	`854`	`(!e.IsFolder && e.Chapters!.Any(f => f.ImagePath != null))`
0	`855`	`\|\| (e.IsFolder && foldersWithChapterImages.Contains(e.Id)));`
	`856`	`}`
	`857`	`else`
	`858`	`{`
0	`859`	`baseQuery = baseQuery`
0	`860`	`.Where(e =>`
0	`861`	`(!e.IsFolder && !e.Chapters!.Any(f => f.ImagePath != null))`
0	`862`	`\|\| (e.IsFolder && !foldersWithChapterImages.Contains(e.Id)));`
	`863`	`}`
	`864`	`}`
	`865`
468	`866`	`if (filter.HasDeadParentId.HasValue && filter.HasDeadParentId.Value)`
	`867`	`{`
17	`868`	`baseQuery = baseQuery`
17	`869`	`.Where(e => e.ParentId.HasValue && !context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Any`
	`870`	`}`
	`871`
468	`872`	`if (filter.IsDeadArtist.HasValue && filter.IsDeadArtist.Value)`
	`873`	`{`
17	`874`	`baseQuery = baseQuery`
17	`875`	`.Where(e => !context.ItemValues.Where(f => _getAllArtistsValueTypes.Contains(f.Type)).Any(f => f.Val`
	`876`	`}`
	`877`
468	`878`	`if (filter.IsDeadStudio.HasValue && filter.IsDeadStudio.Value)`
	`879`	`{`
17	`880`	`baseQuery = baseQuery`
17	`881`	`.Where(e => !context.ItemValues.Where(f => _getStudiosValueTypes.Contains(f.Type)).Any(f => f.Value`
	`882`	`}`
	`883`
468	`884`	`if (filter.IsDeadGenre.HasValue && filter.IsDeadGenre.Value)`
	`885`	`{`
17	`886`	`baseQuery = baseQuery`
17	`887`	`.Where(e => !context.ItemValues.Where(f => _getGenreValueTypes.Contains(f.Type)).Any(f => f.Value ==`
	`888`	`}`
	`889`
468	`890`	`if (filter.IsDeadPerson.HasValue && filter.IsDeadPerson.Value)`
	`891`	`{`
0	`892`	`baseQuery = baseQuery`
0	`893`	`.Where(e => !context.Peoples.Any(f => f.Name == e.Name));`
	`894`	`}`
	`895`
468	`896`	`if (filter.Years.Length > 0)`
	`897`	`{`
0	`898`	`baseQuery = baseQuery.WhereOneOrMany(filter.Years, e => e.ProductionYear!.Value);`
	`899`	`}`
	`900`
468	`901`	`var isVirtualItem = filter.IsVirtualItem ?? filter.IsMissing;`
468	`902`	`if (isVirtualItem.HasValue)`
	`903`	`{`
22	`904`	`baseQuery = baseQuery`
22	`905`	`.Where(e => e.IsVirtualItem == isVirtualItem.Value);`
	`906`	`}`
	`907`
468	`908`	`if (filter.IsSpecialSeason.HasValue)`
	`909`	`{`
0	`910`	`if (filter.IsSpecialSeason.Value)`
	`911`	`{`
0	`912`	`baseQuery = baseQuery`
0	`913`	`.Where(e => e.IndexNumber == 0);`
	`914`	`}`
	`915`	`else`
	`916`	`{`
0	`917`	`baseQuery = baseQuery`
0	`918`	`.Where(e => e.IndexNumber != 0);`
	`919`	`}`
	`920`	`}`
	`921`
468	`922`	`if (filter.IsUnaired.HasValue)`
	`923`	`{`
0	`924`	`if (filter.IsUnaired.Value)`
	`925`	`{`
0	`926`	`baseQuery = baseQuery`
0	`927`	`.Where(e => e.PremiereDate >= now);`
	`928`	`}`
	`929`	`else`
	`930`	`{`
0	`931`	`baseQuery = baseQuery`
0	`932`	`.Where(e => e.PremiereDate < now);`
	`933`	`}`
	`934`	`}`
	`935`
468	`936`	`if (filter.MediaTypes.Length > 0)`
	`937`	`{`
21	`938`	`var mediaTypes = filter.MediaTypes.Select(f => f.ToString()).ToArray();`
21	`939`	`baseQuery = baseQuery.WhereOneOrMany(mediaTypes, e => e.MediaType);`
	`940`	`}`
	`941`
468	`942`	`if (filter.ItemIds.Length > 0)`
	`943`	`{`
0	`944`	`baseQuery = baseQuery.WhereOneOrMany(filter.ItemIds, e => e.Id);`
	`945`	`}`
	`946`
468	`947`	`if (filter.ExcludeItemIds.Length > 0)`
	`948`	`{`
0	`949`	`baseQuery = baseQuery`
0	`950`	`.Where(e => !filter.ExcludeItemIds.Contains(e.Id));`
	`951`	`}`
	`952`
468	`953`	`if (filter.ExcludeProviderIds is not null && filter.ExcludeProviderIds.Count > 0)`
	`954`	`{`
0	`955`	`baseQuery = baseQuery.WhereExcludeProviderIds(filter.ExcludeProviderIds);`
	`956`	`}`
	`957`
468	`958`	`if (filter.HasAnyProviderId is not null && filter.HasAnyProviderId.Count > 0)`
	`959`	`{`
0	`960`	`baseQuery = baseQuery.WhereHasAnyProviderId(filter.HasAnyProviderId);`
	`961`	`}`
	`962`
468	`963`	`if (filter.HasAnyProviderIds is not null && filter.HasAnyProviderIds.Count > 0)`
	`964`	`{`
0	`965`	`baseQuery = baseQuery.WhereHasAnyProviderIds(filter.HasAnyProviderIds);`
	`966`	`}`
	`967`
468	`968`	`if (filter.HasAnyProviderIds is not null && filter.HasAnyProviderIds.Count > 0)`
	`969`	`{`
0	`970`	`var includeAny = filter.HasAnyProviderIds`
0	`971`	`.SelectMany(kvp => kvp.Value.Select(v => $"{kvp.Key}:{v}"))`
0	`972`	`.ToArray();`
0	`973`	`if (includeAny.Length > 0)`
	`974`	`{`
0	`975`	`baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.Any(f =>`
	`976`	`}`
	`977`	`}`
	`978`
468	`979`	`if (filter.HasImdbId.HasValue)`
	`980`	`{`
0	`981`	`baseQuery = filter.HasImdbId.Value`
0	`982`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == ImdbProviderName))`
0	`983`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != ImdbProviderName));`
	`984`	`}`
	`985`
468	`986`	`if (filter.HasTmdbId.HasValue)`
	`987`	`{`
0	`988`	`baseQuery = filter.HasTmdbId.Value`
0	`989`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TmdbProviderName))`
0	`990`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TmdbProviderName));`
	`991`	`}`
	`992`
468	`993`	`if (filter.HasTvdbId.HasValue)`
	`994`	`{`
0	`995`	`baseQuery = filter.HasTvdbId.Value`
0	`996`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TvdbProviderName))`
0	`997`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TvdbProviderName));`
	`998`	`}`
	`999`
468	`1000`	`var queryTopParentIds = filter.TopParentIds;`
	`1001`
468	`1002`	`if (queryTopParentIds.Length > 0)`
	`1003`	`{`
15	`1004`	`var includedItemByNameTypes = GetItemByNameTypesInQuery(filter);`
15	`1005`	`var enableItemsByName = (filter.IncludeItemsByName ?? false) && includedItemByNameTypes.Count > 0;`
15	`1006`	`if (enableItemsByName && includedItemByNameTypes.Count > 0)`
	`1007`	`{`
0	`1008`	`baseQuery = baseQuery.Where(e => includedItemByNameTypes.Contains(e.Type) \|\| queryTopParentIds.Any(w =>`
	`1009`	`}`
	`1010`	`else`
	`1011`	`{`
15	`1012`	`baseQuery = baseQuery.WhereOneOrMany(queryTopParentIds, e => e.TopParentId!.Value);`
	`1013`	`}`
	`1014`	`}`
	`1015`
468	`1016`	`if (filter.AncestorIds.Length > 0)`
	`1017`	`{`
43	`1018`	`var ancestorFilter = filter.AncestorIds.OneOrManyExpressionBuilder<AncestorId, Guid>(f => f.ParentItemId);`
43	`1019`	`baseQuery = baseQuery.Where(e => e.Parents!.AsQueryable().Any(ancestorFilter));`
	`1020`	`}`
	`1021`
468	`1022`	`if (filter.LinkedChildAncestorIds.Length > 0)`
	`1023`	`{`
	`1024`	`// Keep folder-like items (BoxSets, Playlists) whose linked children descend from any of the requested ances`
0	`1025`	`var linkedChildAncestorIds = filter.LinkedChildAncestorIds;`
0	`1026`	`baseQuery = baseQuery.Where(e => context.LinkedChildren.Any(lc =>`
0	`1027`	`lc.ParentId == e.Id`
0	`1028`	`&& lc.Child!.Parents!.Any(a => linkedChildAncestorIds.Contains(a.ParentItemId))));`
	`1029`	`}`
	`1030`
468	`1031`	`if (!string.IsNullOrWhiteSpace(filter.AncestorWithPresentationUniqueKey))`
	`1032`	`{`
0	`1033`	`baseQuery = baseQuery`
0	`1034`	`.Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Where(f => f.PresentationUn`
	`1035`	`}`
	`1036`
468	`1037`	`if (!string.IsNullOrWhiteSpace(filter.SeriesPresentationUniqueKey))`
	`1038`	`{`
0	`1039`	`baseQuery = baseQuery`
0	`1040`	`.Where(e => e.SeriesPresentationUniqueKey == filter.SeriesPresentationUniqueKey);`
	`1041`	`}`
	`1042`
	`1043`	`// Pre-build the blocked-item-id set as a sub-select`
468	`1044`	`if (filter.ExcludeInheritedTags.Length > 0)`
	`1045`	`{`
0	`1046`	`var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
0	`1047`	`var blockedTagItemIds = context.ItemValuesMap`
0	`1048`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && excludedTags.Contains(f.ItemValue.CleanValue))`
0	`1049`	`.Select(f => f.ItemId);`
	`1050`
0	`1051`	`baseQuery = baseQuery.Where(e =>`
0	`1052`	`!blockedTagItemIds.Contains(e.Id)`
0	`1053`	`&& !(e.SeriesId.HasValue && blockedTagItemIds.Contains(e.SeriesId.Value))`
0	`1054`	`&& !e.Parents!.Any(p => blockedTagItemIds.Contains(p.ParentItemId))`
0	`1055`	`&& !(e.TopParentId.HasValue && blockedTagItemIds.Contains(e.TopParentId.Value)));`
	`1056`	`}`
	`1057`
468	`1058`	`if (filter.IncludeInheritedTags.Length > 0)`
	`1059`	`{`
0	`1060`	`var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
0	`1061`	`var isPlaylistOnlyQuery = includeTypes.Length == 1 && includeTypes.FirstOrDefault() == BaseItemKind.Playlist`
0	`1062`	`var allowedTagItemIds = context.ItemValuesMap`
0	`1063`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && includeTags.Contains(f.ItemValue.CleanValue))`
0	`1064`	`.Select(f => f.ItemId);`
	`1065`
0	`1066`	`baseQuery = baseQuery.Where(e =>`
0	`1067`	`allowedTagItemIds.Contains(e.Id)`
0	`1068`	`\|\| (e.SeriesId.HasValue && allowedTagItemIds.Contains(e.SeriesId.Value))`
0	`1069`	`\|\| e.Parents!.Any(p => allowedTagItemIds.Contains(p.ParentItemId))`
0	`1070`	`\|\| (e.TopParentId.HasValue && allowedTagItemIds.Contains(e.TopParentId.Value))`
0	`1071`
0	`1072`	`// A playlist should be accessible to its owner regardless of allowed tags`
0	`1073`	`\|\| (isPlaylistOnlyQuery && e.Data!.Contains($"OwnerUserId\":\"{filter.User!.Id:N}\"")));`
	`1074`	`}`
	`1075`
468	`1076`	`if (filter.SeriesStatuses.Length > 0)`
	`1077`	`{`
0	`1078`	`var seriesStatus = filter.SeriesStatuses.Select(e => e.ToString()).ToArray();`
0	`1079`	`baseQuery = baseQuery`
0	`1080`	`.Where(e => seriesStatus.Any(f => e.Data!.Contains(f)));`
	`1081`	`}`
	`1082`
468	`1083`	`if (filter.BoxSetLibraryFolders.Length > 0)`
	`1084`	`{`
0	`1085`	`var boxsetFolders = filter.BoxSetLibraryFolders.Select(e => e.ToString("N", CultureInfo.InvariantCulture)).T`
0	`1086`	`baseQuery = baseQuery`
0	`1087`	`.Where(e => boxsetFolders.Any(f => e.Data!.Contains(f)));`
	`1088`	`}`
	`1089`
468	`1090`	`if (filter.VideoTypes.Length > 0)`
	`1091`	`{`
	`1092`	`// Dvds and Blu-rays can either be stored in a folder structure or as an iso file`
	`1093`	`// => to find all matches we need to check both: VideoType and IsoType`
	`1094`	`// alternatively, we could provide specific IsoType filters`
0	`1095`	`var videoTypeBs = filter.VideoTypes.Select(vt => $"\"VideoType\":\"{vt}\"").ToArray();`
0	`1096`	`var isoTypeBs = filter.VideoTypes.Select(vt => $"\"IsoType\":\"{vt}\"").ToArray();`
0	`1097`	`Expression<Func<BaseItemEntity, bool>> hasVideoType = e => videoTypeBs.Any(f => e.Data!.Contains(f)) \|\| isoT`
0	`1098`	`baseQuery = baseQuery.WhereItemOrDescendantMatches(context, hasVideoType);`
	`1099`	`}`
	`1100`
468	`1101`	`if (filter.Is3D.HasValue)`
	`1102`	`{`
0	`1103`	`Expression<Func<BaseItemEntity, bool>> is3D = e => e.Data!.Contains("Video3DFormat");`
	`1104`
0	`1105`	`baseQuery = filter.Is3D.Value`
0	`1106`	`? baseQuery.WhereItemOrDescendantMatches(context, is3D)`
0	`1107`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, is3D);`
	`1108`	`}`
	`1109`
468	`1110`	`if (filter.IsPlaceHolder.HasValue)`
	`1111`	`{`
0	`1112`	`Expression<Func<BaseItemEntity, bool>> isPlaceHolder = e => e.Data!.Contains("IsPlaceHolder\":true");`
	`1113`
0	`1114`	`baseQuery = filter.IsPlaceHolder.Value`
0	`1115`	`? baseQuery.WhereItemOrDescendantMatches(context, isPlaceHolder)`
0	`1116`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, isPlaceHolder);`
	`1117`	`}`
	`1118`
468	`1119`	`if (filter.HasSpecialFeature.HasValue)`
	`1120`	`{`
0	`1121`	`var itemsWithExtras = context.BaseItems`
0	`1122`	`.Where(extra => extra.OwnerId != null`
0	`1123`	`&& extra.ExtraType != null`
0	`1124`	`&& extra.ExtraType != BaseItemExtraType.Unknown`
0	`1125`	`&& extra.ExtraType != BaseItemExtraType.Trailer`
0	`1126`	`&& extra.ExtraType != BaseItemExtraType.ThemeSong`
0	`1127`	`&& extra.ExtraType != BaseItemExtraType.ThemeVideo)`
0	`1128`	`.Select(extra => extra.OwnerId!.Value)`
0	`1129`	`.Distinct();`
	`1130`
0	`1131`	`Expression<Func<BaseItemEntity, bool>> hasExtras = e => itemsWithExtras.Contains(e.Id);`
	`1132`
0	`1133`	`baseQuery = filter.HasSpecialFeature.Value`
0	`1134`	`? baseQuery.WhereItemOrDescendantMatches(context, hasExtras)`
0	`1135`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasExtras);`
	`1136`	`}`
	`1137`
468	`1138`	`if (filter.HasTrailer.HasValue)`
	`1139`	`{`
0	`1140`	`var trailerOwnerIds = context.BaseItems`
0	`1141`	`.Where(extra => extra.ExtraType == BaseItemExtraType.Trailer && extra.OwnerId != null)`
0	`1142`	`.Select(extra => extra.OwnerId!.Value);`
	`1143`
0	`1144`	`Expression<Func<BaseItemEntity, bool>> hasTrailer = e => trailerOwnerIds.Contains(e.Id);`
	`1145`
0	`1146`	`baseQuery = filter.HasTrailer.Value`
0	`1147`	`? baseQuery.WhereItemOrDescendantMatches(context, hasTrailer)`
0	`1148`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasTrailer);`
	`1149`	`}`
	`1150`
468	`1151`	`if (filter.HasThemeSong.HasValue)`
	`1152`	`{`
0	`1153`	`var themeSongOwnerIds = context.BaseItems`
0	`1154`	`.Where(extra => extra.ExtraType == BaseItemExtraType.ThemeSong && extra.OwnerId != null)`
0	`1155`	`.Select(extra => extra.OwnerId!.Value);`
	`1156`
0	`1157`	`Expression<Func<BaseItemEntity, bool>> hasThemeSong = e => themeSongOwnerIds.Contains(e.Id);`
	`1158`
0	`1159`	`baseQuery = filter.HasThemeSong.Value`
0	`1160`	`? baseQuery.WhereItemOrDescendantMatches(context, hasThemeSong)`
0	`1161`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeSong);`
	`1162`	`}`
	`1163`
468	`1164`	`if (filter.HasThemeVideo.HasValue)`
	`1165`	`{`
0	`1166`	`var themeVideoOwnerIds = context.BaseItems`
0	`1167`	`.Where(extra => extra.ExtraType == BaseItemExtraType.ThemeVideo && extra.OwnerId != null)`
0	`1168`	`.Select(extra => extra.OwnerId!.Value);`
	`1169`
0	`1170`	`Expression<Func<BaseItemEntity, bool>> hasThemeVideo = e => themeVideoOwnerIds.Contains(e.Id);`
	`1171`
0	`1172`	`baseQuery = filter.HasThemeVideo.Value`
0	`1173`	`? baseQuery.WhereItemOrDescendantMatches(context, hasThemeVideo)`
0	`1174`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeVideo);`
	`1175`	`}`
	`1176`
468	`1177`	`if (filter.AiredDuringSeason.HasValue)`
	`1178`	`{`
0	`1179`	`var seasonNumber = filter.AiredDuringSeason.Value;`
0	`1180`	`if (seasonNumber < 1)`
	`1181`	`{`
0	`1182`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber == seasonNumber);`
	`1183`	`}`
	`1184`	`else`
	`1185`	`{`
0	`1186`	`var seasonStr = seasonNumber.ToString(CultureInfo.InvariantCulture);`
0	`1187`	`baseQuery = baseQuery.Where(e =>`
0	`1188`	`e.ParentIndexNumber == seasonNumber`
0	`1189`	`\|\| (e.Data != null && (`
0	`1190`	`e.Data.Contains("\"AirsAfterSeasonNumber\":" + seasonStr)`
0	`1191`	`\|\| e.Data.Contains("\"AirsBeforeSeasonNumber\":" + seasonStr))));`
	`1192`	`}`
	`1193`	`}`
	`1194`
468	`1195`	`if (filter.AdjacentTo.HasValue && !filter.AdjacentTo.Value.IsEmpty())`
	`1196`	`{`
0	`1197`	`var adjacentToId = filter.AdjacentTo.Value;`
0	`1198`	`var targetItem = context.BaseItems.Where(e => e.Id == adjacentToId).Select(e => new { e.SortName, e.Id }).Fi`
0	`1199`	`if (targetItem is not null)`
	`1200`	`{`
0	`1201`	`var targetSortName = targetItem.SortName ?? string.Empty;`
	`1202`
	`1203`	`// Fetch both prev and next adjacent items in a single query using Concat (UNION ALL).`
0	`1204`	`var adjacentIds = context.BaseItems`
0	`1205`	`.Where(e => string.Compare(e.SortName, targetSortName) < 0)`
0	`1206`	`.OrderByDescending(e => e.SortName)`
0	`1207`	`.Select(e => e.Id)`
0	`1208`	`.Take(1)`
0	`1209`	`.Concat(`
0	`1210`	`context.BaseItems`
0	`1211`	`.Where(e => string.Compare(e.SortName, targetSortName) > 0)`
0	`1212`	`.OrderBy(e => e.SortName)`
0	`1213`	`.Select(e => e.Id)`
0	`1214`	`.Take(1))`
0	`1215`	`.ToList();`
	`1216`
0	`1217`	`adjacentIds.Add(adjacentToId);`
0	`1218`	`baseQuery = baseQuery.Where(e => adjacentIds.Contains(e.Id));`
	`1219`	`}`
	`1220`	`}`
	`1221`
468	`1222`	`return baseQuery;`
	`1223`	`}`
	`1224`	`}`

Methods/Properties