< 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

58%

Covered lines:	975
Uncovered lines:	704
Coverable lines:	1679
Total lines:	3407
Line coverage:	58%

Branch coverage

49%

Covered branches:	349
Total branches:	712
Branch coverage:	49%

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%	1	1	100%
File 1: GetArtists(...)	100%	1	1	100%
File 1: GetAlbumArtists(...)	100%	1	1	100%
File 1: GetStudios(...)	100%	1	1	100%
File 1: GetGenres(...)	100%	1	1	100%
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: GetMediaStreamLanguages(...)	100%	2	1	0%
File 1: GetTagNames(...)	100%	1	1	100%
File 1: GetItemValueNames(...)	100%	4	4	100%
File 1: GetItemValues(...)	83.33%	12	12	99.1%
File 1: BuildItemCountsByCleanName(...)	75%	12	12	90.9%
File 1: BuildEpisodeCountsByCleanName(...)	28.57%	17	14	75%
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(...)	81.81%	24	22	83.33%
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: ApplyAdjacencyFilter(...)	25%	12	4	20%
File 3: ApplyQueryPaging(...)	75%	8	8	85.71%
File 3: ApplyGroupingFilter(...)	70%	16	10	61.11%
File 3: ApplyBoxSetCollapsing(...)	0%	6	2	0%
File 3: ApplyBoxSetCollapsingAll(...)	100%	2	1	0%
File 3: ApplyNameFilters(...)	50%	14	6	40%
File 3: ApplyNavigations(...)	83.33%	18	18	96.15%
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: RequiresParentalRestrictions(...)	0%	42	6	0%
File 3: ApplyAccessFiltering(...)	100%	2	2	100%
File 3: ApplyAlternateVersionFiltering(...)	100%	1	1	100%
File 3: ApplyTopParentFiltering(...)	100%	6	6	100%
File 3: GetExemptedItemByNameTypes(...)	100%	4	4	100%
File 3: ApplyItemByNameAccessFiltering(...)	66.66%	6	6	100%
File 3: ApplyParentalRestrictions(...)	50%	47	8	15.15%
File 3: ItemsBelowTaggedAncestor(...)	100%	1	1	100%
File 3: BuildMaxParentalRatingFilter(...)	100%	1	1	100%
File 3: GetAccessFilteredLeafItemsQuery(...)	100%	1	1	100%
File 3: AsOrderKey(...)	100%	1	1	100%
File 3: BuildHasDescendantFilter(...)	100%	1	1	100%
File 4: GetItemIdsList(...)	100%	1	1	100%
File 4: GetItems(...)	62.5%	9	8	77.27%
File 4: GetItemList(...)	75%	4	4	95.65%
File 4: GetLatestItemList(...)	0%	342	18	0%
File 4: LoadLatestByIds(...)	100%	2	1	0%
File 4: LoadLatestByIds(...)	0%	6	2	0%
File 4: GetLatestMovieItems(...)	100%	2	1	0%
File 4: GetLatestTvShowItems(...)	0%	7482	86	0%
File 4: ItemExistsAsync()	100%	1	1	100%
File 4: RetrieveItem(...)	50%	4	4	90.9%
File 4: GetIsPlayed(...)	50%	2	2	87.5%
File 4: GetQueryFiltersLegacy(...)	100%	1	1	100%
File 5: .cctor()	100%	1	1	100%
File 5: get_IsFolderFilter()	100%	1	1	100%
File 5: BuildIsPlayedFilter(...)	100%	1	1	100%
File 5: BuildLeafIsPlayedFilter(...)	100%	1	1	100%
File 5: NormalizeLanguage(...)	100%	2	2	100%
File 5: VersionsMatchingDimension(...)	100%	1	1	100%
File 5: TranslateQuery(...)	46.77%	16120	372	51.54%

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;`
	`8`	`using Jellyfin.Database.Implementations.Entities;`
	`9`	`using MediaBrowser.Controller.Entities;`
	`10`	`using MediaBrowser.Model.Dto;`
	`11`	`using MediaBrowser.Model.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 QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAllArtists(InternalItemsQuery filter)`
	`22`	`{`
4	`23`	`return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtis`
	`24`	`}`
	`25`
	`26`	`/// <inheritdoc />`
	`27`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)`
	`28`	`{`
5	`29`	`return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);`
	`30`	`}`
	`31`
	`32`	`/// <inheritdoc />`
	`33`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)`
	`34`	`{`
1	`35`	`return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArti`
	`36`	`}`
	`37`
	`38`	`/// <inheritdoc />`
	`39`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)`
	`40`	`{`
1	`41`	`return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);`
	`42`	`}`
	`43`
	`44`	`/// <inheritdoc />`
	`45`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)`
	`46`	`{`
4	`47`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]);`
	`48`	`}`
	`49`
	`50`	`/// <inheritdoc />`
	`51`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetMusicGenres(InternalItemsQuery filter)`
	`52`	`{`
0	`53`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]);`
	`54`	`}`
	`55`
	`56`	`/// <inheritdoc />`
	`57`	`public IReadOnlyList<string> GetStudioNames()`
	`58`	`{`
20	`59`	`return GetItemValueNames(_getStudiosValueTypes, [], []);`
	`60`	`}`
	`61`
	`62`	`/// <inheritdoc />`
	`63`	`public IReadOnlyList<string> GetAllArtistNames()`
	`64`	`{`
20	`65`	`return GetItemValueNames(_getAllArtistsValueTypes, [], []);`
	`66`	`}`
	`67`
	`68`	`/// <inheritdoc />`
	`69`	`public IReadOnlyList<string> GetMusicGenreNames()`
	`70`	`{`
21	`71`	`return GetItemValueNames(`
21	`72`	`_getGenreValueTypes,`
21	`73`	`_itemTypeLookup.MusicGenreTypes,`
21	`74`	`[]);`
	`75`	`}`
	`76`
	`77`	`/// <inheritdoc />`
	`78`	`public IReadOnlyList<string> GetGenreNames()`
	`79`	`{`
21	`80`	`return GetItemValueNames(`
21	`81`	`_getGenreValueTypes,`
21	`82`	`[],`
21	`83`	`_itemTypeLookup.MusicGenreTypes);`
	`84`	`}`
	`85`
	`86`	`/// <inheritdoc />`
	`87`	`public IReadOnlyList<string> GetMediaStreamLanguages(InternalItemsQuery filter, MediaStreamType mediaStreamType)`
	`88`	`{`
0	`89`	`ArgumentNullException.ThrowIfNull(filter);`
	`90`
0	`91`	`using var context = _dbProvider.CreateDbContext();`
	`92`
0	`93`	`return TranslateQuery(`
0	`94`	`context.BaseItems.Include(e => e.MediaStreams).Where(e => e.Id != EF.Constant(PlaceholderId)),`
0	`95`	`context,`
0	`96`	`new InternalItemsQuery(filter.User)`
0	`97`	`{`
0	`98`	`IncludeOwnedItems = filter.IncludeOwnedItems,`
0	`99`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`100`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`101`	`MediaTypes = filter.MediaTypes,`
0	`102`	`AncestorIds = filter.AncestorIds,`
0	`103`	`ItemIds = filter.ItemIds,`
0	`104`	`TopParentIds = filter.TopParentIds,`
0	`105`	`ParentId = filter.ParentId,`
0	`106`	`IsAiring = filter.IsAiring,`
0	`107`	`IsMovie = filter.IsMovie,`
0	`108`	`IsSports = filter.IsSports,`
0	`109`	`IsKids = filter.IsKids,`
0	`110`	`IsNews = filter.IsNews,`
0	`111`	`IsSeries = filter.IsSeries`
0	`112`	`})`
0	`113`	`.SelectMany(e => e.MediaStreams!)`
0	`114`	`.Where(e => e.StreamType == (MediaStreamTypeEntity)mediaStreamType)`
0	`115`	`.Select(s => string.IsNullOrEmpty(s.Language) ? "und" : s.Language) // und = undetermined`
0	`116`	`.Distinct()`
0	`117`	`.ToArray();`
0	`118`	`}`
	`119`
	`120`	`/// <inheritdoc />`
	`121`	`public IReadOnlyList<string> GetTagNames(InternalItemsQuery filter)`
	`122`	`{`
1	`123`	`ArgumentNullException.ThrowIfNull(filter);`
1	`124`	`PrepareFilterQuery(filter);`
	`125`
1	`126`	`using var context = _dbProvider.CreateDbContext();`
1	`127`	`var baseQuery = PrepareItemQuery(context, filter);`
1	`128`	`baseQuery = TranslateQuery(baseQuery, context, filter);`
	`129`
1	`130`	`var matchingItemIds = baseQuery.Select(e => e.Id);`
	`131`
	`132`	`// Project the join before grouping. Grouping over the ItemValue navigation instead makes EF`
	`133`	`// re-resolve the aggregate as a correlated subquery per group, which is orders of magnitude slower.`
1	`134`	`return context.ItemValuesMap`
1	`135`	`.AsNoTracking()`
1	`136`	`.Join(`
1	`137`	`context.ItemValues,`
1	`138`	`ivm => ivm.ItemValueId,`
1	`139`	`iv => iv.ItemValueId,`
1	`140`	`(ivm, iv) => new { ivm.ItemId, iv.Type, iv.CleanValue, iv.Value })`
1	`141`	`.Where(iv => iv.Type == ItemValueType.Tags)`
1	`142`	`.Where(iv => matchingItemIds.Contains(iv.ItemId))`
1	`143`	`.GroupBy(iv => iv.CleanValue)`
1	`144`	`.Select(g => g.Min(iv => iv.Value)!)`
1	`145`	`.OrderBy(t => t)`
1	`146`	`.ToArray();`
1	`147`	`}`
	`148`
	`149`	`private string[] GetItemValueNames(IReadOnlyList<ItemValueType> itemValueTypes, IReadOnlyList<string> withItemTypes,`
	`150`	`{`
82	`151`	`using var context = _dbProvider.CreateDbContext();`
	`152`
82	`153`	`var maps = context.ItemValuesMap.AsNoTracking();`
82	`154`	`if (withItemTypes.Count > 0)`
	`155`	`{`
21	`156`	`maps = maps.Where(e => withItemTypes.Contains(e.Item.Type));`
	`157`	`}`
	`158`
82	`159`	`if (excludeItemTypes.Count > 0)`
	`160`	`{`
21	`161`	`maps = maps.Where(e => !excludeItemTypes.Contains(e.Item.Type));`
	`162`	`}`
	`163`
82	`164`	`return context.ItemValues`
82	`165`	`.AsNoTracking()`
82	`166`	`.WhereOneOrMany(itemValueTypes, e => e.Type)`
82	`167`	`.Where(e => maps.Any(m => m.ItemValueId == e.ItemValueId))`
82	`168`	`.Select(e => new { e.CleanValue, e.Value })`
82	`169`	`.GroupBy(e => e.CleanValue)`
82	`170`	`.Select(g => g.Min(v => v.Value)!)`
82	`171`	`.ToArray();`
82	`172`	`}`
	`173`
	`174`	`private QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetItemValues(InternalItemsQuery filter, IReadOnlyLi`
	`175`	`{`
15	`176`	`ArgumentNullException.ThrowIfNull(filter);`
	`177`
15	`178`	`using var context = _dbProvider.CreateDbContext();`
	`179`
15	`180`	`var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context,`
15	`181`	`{`
15	`182`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
15	`183`	`IncludeItemTypes = filter.IncludeItemTypes,`
15	`184`	`MediaTypes = filter.MediaTypes,`
15	`185`	`AncestorIds = filter.AncestorIds,`
15	`186`	`ItemIds = filter.ItemIds,`
15	`187`	`TopParentIds = filter.TopParentIds,`
15	`188`	`ParentId = filter.ParentId,`
15	`189`	`IsAiring = filter.IsAiring,`
15	`190`	`IsMovie = filter.IsMovie,`
15	`191`	`IsSports = filter.IsSports,`
15	`192`	`IsKids = filter.IsKids,`
15	`193`	`IsNews = filter.IsNews,`
15	`194`	`IsSeries = filter.IsSeries`
15	`195`	`});`
	`196`
15	`197`	`var innerQuery = PrepareItemQuery(context, filter)`
15	`198`	`.Where(e => e.Type == returnType)`
15	`199`	`.Where(e => context.ItemValuesMap`
15	`200`	`.Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type) && ivm.ItemValue.CleanValue == e.CleanName)`
15	`201`	`.Join(`
15	`202`	`innerQueryFilter,`
15	`203`	`ivm => ivm.ItemId,`
15	`204`	`g => g.Id,`
15	`205`	`(ivm, g) => ivm.ItemId)`
15	`206`	`.Any());`
	`207`
15	`208`	`var outerQueryFilter = new InternalItemsQuery(filter.User)`
15	`209`	`{`
15	`210`	`IsPlayed = filter.IsPlayed,`
15	`211`	`IsFavorite = filter.IsFavorite,`
15	`212`	`IsFavoriteOrLiked = filter.IsFavoriteOrLiked,`
15	`213`	`IsLiked = filter.IsLiked,`
15	`214`	`IsLocked = filter.IsLocked,`
15	`215`	`ImageTypes = filter.ImageTypes,`
15	`216`	`NameLessThan = filter.NameLessThan,`
15	`217`	`NameStartsWith = filter.NameStartsWith,`
15	`218`	`NameStartsWithOrGreater = filter.NameStartsWithOrGreater,`
15	`219`	`Tags = filter.Tags,`
15	`220`	`OfficialRatings = filter.OfficialRatings,`
15	`221`	`StudioIds = filter.StudioIds,`
15	`222`	`GenreIds = filter.GenreIds,`
15	`223`	`Genres = filter.Genres,`
15	`224`	`Years = filter.Years,`
15	`225`	`NameContains = filter.NameContains,`
15	`226`	`SearchTerm = filter.SearchTerm,`
15	`227`	`ExcludeItemIds = filter.ExcludeItemIds,`
15	`228`
15	`229`	`// A genre, studio or artist carries none of the tags of the media it describes, so an`
15	`230`	`// allow list can only ever hide all of them. Reachability is settled by innerQueryFilter`
15	`231`	`// instead: a value gets this far only when an item the user may see carries it.`
15	`232`	`IncludeInheritedTags = []`
15	`233`	`};`
	`234`
	`235`	`// Collapse rows that share a PresentationUniqueKey (e.g. alternate versions) into one`
	`236`	`// representative id per group, then materialize the representative ids once.`
15	`237`	`var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter);`
15	`238`	`var isMusicArtist = returnType == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];`
	`239`	`List<Guid> representativeIds;`
15	`240`	`if (isMusicArtist)`
	`241`	`{`
	`242`	`// For MusicArtist, prefer the entity from a library the user can actually access.`
	`243`	`// Materialize to prevent correlated per-group first-row queries which hurt performance.`
10	`244`	`var topParentIds = filter.TopParentIds;`
10	`245`	`representativeIds = masterQuery`
10	`246`	`.Select(e => new { e.Id, e.PresentationUniqueKey, e.TopParentId })`
10	`247`	`.AsEnumerable()`
10	`248`	`.GroupBy(e => e.PresentationUniqueKey)`
10	`249`	`.Select(g => g`
10	`250`	`.OrderBy(e => topParentIds.Contains(e.TopParentId ?? Guid.Empty) ? 0 : 1)`
10	`251`	`.ThenBy(e => e.Id)`
10	`252`	`.First().Id)`
10	`253`	`.ToList();`
	`254`	`}`
	`255`	`else`
	`256`	`{`
5	`257`	`representativeIds = masterQuery`
5	`258`	`.GroupBy(e => e.PresentationUniqueKey)`
5	`259`	`.Select(g => g.Min(e => e.Id))`
5	`260`	`.ToList();`
	`261`	`}`
	`262`
15	`263`	`var result = new QueryResult<(BaseItemDto, ItemCounts?)>();`
15	`264`	`if (filter.EnableTotalRecordCount)`
	`265`	`{`
14	`266`	`result.TotalRecordCount = representativeIds.Count;`
	`267`	`}`
	`268`
15	`269`	`var query = ApplyNavigations(`
15	`270`	`context.BaseItems.AsNoTracking().AsSingleQuery().WhereOneOrMany(representativeIds, e => e.Id),`
15	`271`	`filter);`
	`272`
15	`273`	`query = ApplyOrder(query, filter, context);`
	`274`
15	`275`	`if (filter.StartIndex.HasValue && filter.StartIndex.Value > 0)`
	`276`	`{`
0	`277`	`query = query.Skip(filter.StartIndex.Value);`
	`278`	`}`
	`279`
15	`280`	`if (filter.Limit.HasValue)`
	`281`	`{`
1	`282`	`query = query.Take(filter.Limit.Value);`
	`283`	`}`
	`284`
15	`285`	`result.StartIndex = filter.StartIndex ?? 0;`
15	`286`	`var page = query.AsEnumerable().Where(e => e is not null).ToList();`
	`287`
15	`288`	`if (filter.DtoOptions.ContainsField(ItemFields.ItemCounts))`
	`289`	`{`
13	`290`	`var pageCleanNames = page`
13	`291`	`.Where(e => !string.IsNullOrEmpty(e.CleanName))`
13	`292`	`.Select(e => e.CleanName!)`
13	`293`	`.Distinct()`
13	`294`	`.ToList();`
	`295`
13	`296`	`var countsByCleanName = BuildItemCountsByCleanName(context, filter, itemValueTypes, pageCleanNames);`
13	`297`	`result.Items =`
13	`298`	`[`
13	`299`	`.. page`
13	`300`	`.Select(e =>`
13	`301`	`{`
13	`302`	`var item = DeserializeBaseItem(e, filter.SkipDeserialization);`
13	`303`	`countsByCleanName.TryGetValue(e.CleanName ?? string.Empty, out var itemCount);`
13	`304`	`return (item, itemCount);`
13	`305`	`})`
13	`306`	`.Where(x => x.item is not null)`
13	`307`	`.Select(x => (x.item!, x.itemCount))`
13	`308`	`];`
	`309`	`}`
	`310`	`else`
	`311`	`{`
2	`312`	`result.Items =`
2	`313`	`[`
2	`314`	`.. page`
2	`315`	`.Select(e => DeserializeBaseItem(e, filter.SkipDeserialization))`
2	`316`	`.Where(item => item != null)`
2	`317`	`.Select(item => (item!, (ItemCounts?)null))`
2	`318`	`];`
	`319`	`}`
	`320`
15	`321`	`return result;`
15	`322`	`}`
	`323`
	`324`	`private Dictionary<string, ItemCounts> BuildItemCountsByCleanName(`
	`325`	`JellyfinDbContext context,`
	`326`	`InternalItemsQuery filter,`
	`327`	`IReadOnlyList<ItemValueType> itemValueTypes,`
	`328`	`IReadOnlyList<string> cleanNames)`
	`329`	`{`
13	`330`	`var countsByCleanName = new Dictionary<string, ItemCounts>();`
13	`331`	`if (cleanNames.Count == 0)`
	`332`	`{`
0	`333`	`return countsByCleanName;`
	`334`	`}`
	`335`
	`336`	`// The counts describe everything the value is attached to, not only the types the list was`
	`337`	`// filtered down to.`
13	`338`	`var scopeQuery = new InternalItemsQuery(filter.User)`
13	`339`	`{`
13	`340`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
13	`341`	`MediaTypes = filter.MediaTypes,`
13	`342`	`AncestorIds = filter.AncestorIds,`
13	`343`	`ExcludeItemIds = filter.ExcludeItemIds,`
13	`344`	`ItemIds = filter.ItemIds,`
13	`345`	`TopParentIds = filter.TopParentIds,`
13	`346`	`ParentId = filter.ParentId,`
13	`347`	`IsPlayed = filter.IsPlayed`
13	`348`	`};`
	`349`
13	`350`	`var scopedItems = TranslateQuery(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId))`
13	`351`	`var valueLinks = context.ItemValuesMap`
13	`352`	`.AsNoTracking()`
13	`353`	`.Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))`
13	`354`	`.WhereOneOrMany(cleanNames, ivm => ivm.ItemValue.CleanValue);`
	`355`
13	`356`	`var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];`
13	`357`	`var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];`
	`358`
	`359`	`// Rewrite query to avoid SelectMany on navigation properties (which requires SQL APPLY, not supported on SQLite`
	`360`	`// Instead, start from ItemValueMaps and join with BaseItems.`
13	`361`	`var rawCounts = valueLinks`
13	`362`	`.Join(`
13	`363`	`scopedItems,`
13	`364`	`ivm => ivm.ItemId,`
13	`365`	`e => e.Id,`
13	`366`	`(ivm, e) => new { CleanName = ivm.ItemValue.CleanValue, e.Type, e.SeriesId, e.Id })`
13	`367`	`.GroupBy(x => new { x.CleanName, x.Type, x.SeriesId })`
13	`368`	`.Select(g => new { g.Key.CleanName, g.Key.Type, g.Key.SeriesId, Count = g.Select(x => x.Id).Distinct().Count`
13	`369`	`.ToList();`
	`370`
	`371`	`// Only studios and genres pass down from a series to its episodes; an artist credit does not.`
13	`372`	`var inheritsToEpisodes = itemValueTypes.Contains(ItemValueType.Studios) \|\| itemValueTypes.Contains(ItemValueType`
13	`373`	`var episodeCounts = inheritsToEpisodes`
13	`374`	`? BuildEpisodeCountsByCleanName(`
13	`375`	`scopedItems,`
13	`376`	`valueLinks,`
13	`377`	`rawCounts`
13	`378`	`.Where(x => x.Type == episodeTypeName)`
13	`379`	`.Select(x => (x.CleanName, x.SeriesId, x.Count))`
13	`380`	`.ToList(),`
13	`381`	`seriesTypeName,`
13	`382`	`episodeTypeName)`
13	`383`	`: rawCounts`
13	`384`	`.Where(x => x.Type == episodeTypeName)`
13	`385`	`.GroupBy(x => x.CleanName)`
13	`386`	`.ToDictionary(g => g.Key, g => g.Sum(x => x.Count));`
	`387`
66	`388`	`foreach (var group in rawCounts.GroupBy(x => x.CleanName))`
	`389`	`{`
20	`390`	`var counts = ItemCountBuilder.Build(_itemTypeLookup, group.Select(row => (row.Type, row.Count)));`
	`391`
	`392`	`// Episodes are counted separately: the value is usually only written on the series.`
20	`393`	`ItemCountBuilder.SetEpisodeCount(counts, episodeCounts.GetValueOrDefault(group.Key));`
20	`394`	`countsByCleanName[group.Key] = counts;`
	`395`	`}`
	`396`
	`397`	`// A value carried by nothing but the episodes below a tagged series has no row of its own.`
26	`398`	`foreach (var (cleanName, episodeCount) in episodeCounts)`
	`399`	`{`
0	`400`	`if (!countsByCleanName.ContainsKey(cleanName))`
	`401`	`{`
0	`402`	`var counts = new ItemCounts();`
0	`403`	`ItemCountBuilder.SetEpisodeCount(counts, episodeCount);`
0	`404`	`countsByCleanName[cleanName] = counts;`
	`405`	`}`
	`406`	`}`
	`407`
13	`408`	`return countsByCleanName;`
	`409`	`}`
	`410`
	`411`	`private static Dictionary<string, int> BuildEpisodeCountsByCleanName(`
	`412`	`IQueryable<BaseItemEntity> scopedItems,`
	`413`	`IQueryable<ItemValueMap> valueLinks,`
	`414`	`IReadOnlyList<(string CleanName, Guid? SeriesId, int Count)> taggedEpisodes,`
	`415`	`string seriesTypeName,`
	`416`	`string episodeTypeName)`
	`417`	`{`
	`418`	`// Resolved in steps rather than as one union: each of these drives off an index, while the`
	`419`	`// single-statement form leaves SQLite free to scan every episode in the library instead.`
5	`420`	`var taggedSeries = valueLinks`
5	`421`	`.Join(`
5	`422`	`scopedItems.Where(e => e.Type == seriesTypeName),`
5	`423`	`ivm => ivm.ItemId,`
5	`424`	`e => e.Id,`
5	`425`	`(ivm, e) => new { CleanName = ivm.ItemValue.CleanValue, SeriesId = e.Id })`
5	`426`	`.ToList();`
	`427`
5	`428`	`var seriesIds = taggedSeries.Select(x => x.SeriesId).Distinct().ToArray();`
5	`429`	`var episodesPerSeries = seriesIds.Length == 0`
5	`430`	`? []`
5	`431`	`: scopedItems`
5	`432`	`.Where(e => e.Type == episodeTypeName && e.SeriesId != null)`
5	`433`	`.WhereOneOrMany(seriesIds, e => e.SeriesId!.Value)`
5	`434`	`.GroupBy(e => e.SeriesId!.Value)`
5	`435`	`.Select(g => new { SeriesId = g.Key, Count = g.Count() })`
5	`436`	`.ToDictionary(x => x.SeriesId, x => x.Count);`
	`437`
5	`438`	`var episodeCounts = new Dictionary<string, int>();`
5	`439`	`var seriesByCleanName = new Dictionary<string, HashSet<Guid>>();`
10	`440`	`foreach (var group in taggedSeries.GroupBy(x => x.CleanName))`
	`441`	`{`
0	`442`	`var series = group.Select(x => x.SeriesId).ToHashSet();`
0	`443`	`seriesByCleanName[group.Key] = series;`
0	`444`	`episodeCounts[group.Key] = series.Sum(id => episodesPerSeries.GetValueOrDefault(id));`
	`445`	`}`
	`446`
10	`447`	`foreach (var (cleanName, seriesId, count) in taggedEpisodes)`
	`448`	`{`
0	`449`	`if (seriesId is not null`
0	`450`	`&& seriesByCleanName.TryGetValue(cleanName, out var series)`
0	`451`	`&& series.Contains(seriesId.Value))`
	`452`	`{`
	`453`	`continue;`
	`454`	`}`
	`455`
0	`456`	`episodeCounts[cleanName] = episodeCounts.GetValueOrDefault(cleanName) + count;`
	`457`	`}`
	`458`
5	`459`	`return episodeCounts;`
	`460`	`}`
	`461`	`}`

/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>`
3	`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`
3	`43`	`private static readonly IReadOnlyList<ItemValueType> _getAllArtistsValueTypes = [ItemValueType.Artist, ItemValueType`
3	`44`	`private static readonly IReadOnlyList<ItemValueType> _getArtistValueTypes = [ItemValueType.Artist];`
3	`45`	`private static readonly IReadOnlyList<ItemValueType> _getAlbumArtistValueTypes = [ItemValueType.AlbumArtist];`
3	`46`	`private static readonly IReadOnlyList<ItemValueType> _getStudiosValueTypes = [ItemValueType.Studios];`
3	`47`	`private static readonly IReadOnlyList<ItemValueType> _getGenreValueTypes = [ItemValueType.Genre];`
	`48`
3	`49`	`private static readonly BaseItemKind[] _itemByNameKinds =`
3	`50`	`[`
3	`51`	`BaseItemKind.Person,`
3	`52`	`BaseItemKind.Genre,`
3	`53`	`BaseItemKind.MusicGenre,`
3	`54`	`BaseItemKind.MusicArtist,`
3	`55`	`BaseItemKind.Studio`
3	`56`	`];`
	`57`
3	`58`	`private static readonly (BaseItemKind Kind, IReadOnlyList<ItemValueType> ValueTypes)[] _itemByNameValueTypes =`
3	`59`	`[`
3	`60`	`(BaseItemKind.Genre, _getGenreValueTypes),`
3	`61`	`(BaseItemKind.MusicGenre, _getGenreValueTypes),`
3	`62`	`(BaseItemKind.MusicArtist, _getAllArtistsValueTypes),`
3	`63`	`(BaseItemKind.Studio, _getStudiosValueTypes)`
3	`64`	`];`
	`65`
	`66`	`// The only folder kinds whose children form a single viewing sequence, so playback progress on a`
	`67`	`// child rolls up to them. Every other folder kind is a container that cannot be resumed.`
3	`68`	`private static readonly BaseItemKind[] _resumableFolderKinds =`
3	`69`	`[`
3	`70`	`BaseItemKind.Series,`
3	`71`	`BaseItemKind.Season`
3	`72`	`];`
	`73`
	`74`	`/// <summary>`
	`75`	`/// Initializes a new instance of the <see cref="BaseItemRepository"/> class.`
	`76`	`/// </summary>`
	`77`	`/// <param name="dbProvider">The db factory.</param>`
	`78`	`/// <param name="appHost">The Application host.</param>`
	`79`	`/// <param name="itemTypeLookup">The static type lookup.</param>`
	`80`	`/// <param name="serverConfigurationManager">The server Configuration manager.</param>`
	`81`	`/// <param name="logger">System logger.</param>`
	`82`	`public BaseItemRepository(`
	`83`	`IDbContextFactory<JellyfinDbContext> dbProvider,`
	`84`	`IServerApplicationHost appHost,`
	`85`	`IItemTypeLookup itemTypeLookup,`
	`86`	`IServerConfigurationManager serverConfigurationManager,`
	`87`	`ILogger<BaseItemRepository> logger)`
	`88`	`{`
126	`89`	`_dbProvider = dbProvider;`
126	`90`	`_appHost = appHost;`
126	`91`	`_itemTypeLookup = itemTypeLookup;`
126	`92`	`_serverConfigurationManager = serverConfigurationManager;`
126	`93`	`_logger = logger;`
126	`94`	`}`
	`95`
	`96`	`/// <summary>`
	`97`	`/// Maps a Entity to the DTO. Delegates to <see cref="BaseItemMapper"/>.`
	`98`	`/// </summary>`
	`99`	`/// <param name="entity">The database entity.</param>`
	`100`	`/// <param name="dto">The target DTO.</param>`
	`101`	`/// <param name="appHost">The application host.</param>`
	`102`	`/// <param name="logger">The logger.</param>`
	`103`	`/// <returns>The mapped DTO.</returns>`
	`104`	`public static BaseItemDto Map(BaseItemEntity entity, BaseItemDto dto, IServerApplicationHost? appHost, ILogger logge`
	`105`	`{`
0	`106`	`return BaseItemMapper.Map(entity, dto, appHost);`
	`107`	`}`
	`108`
	`109`	`/// <summary>`
	`110`	`/// Maps a DTO to a database entity. Delegates to <see cref="BaseItemMapper"/>.`
	`111`	`/// </summary>`
	`112`	`/// <param name="dto">The DTO to map.</param>`
	`113`	`/// <returns>The mapped database entity.</returns>`
	`114`	`public BaseItemEntity Map(BaseItemDto dto)`
	`115`	`{`
10	`116`	`return BaseItemMapper.Map(dto, _appHost);`
	`117`	`}`
	`118`
	`119`	`/// <summary>`
	`120`	`/// Deserializes a BaseItemEntity and sets all properties.`
	`121`	`/// </summary>`
	`122`	`/// <param name="baseItemEntity">The entity to deserialize.</param>`
	`123`	`/// <param name="logger">The logger.</param>`
	`124`	`/// <param name="appHost">The application host.</param>`
	`125`	`/// <param name="skipDeserialization">Whether to skip JSON deserialization.</param>`
	`126`	`/// <returns>The deserialized item, or null.</returns>`
	`127`	`public static BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost`
	`128`	`{`
3	`129`	`return BaseItemMapper.DeserializeBaseItem(baseItemEntity, logger, appHost, skipDeserialization);`
	`130`	`}`
	`131`
	`132`	`/// <inheritdoc />`
	`133`	`public void PrepareFilterQuery(InternalItemsQuery query)`
	`134`	`{`
760	`135`	`if (query.Limit.HasValue && query.EnableGroupByMetadataKey)`
	`136`	`{`
0	`137`	`query.Limit = query.Limit.Value + 4;`
	`138`	`}`
	`139`
760	`140`	`if (query.IsResumable ?? false)`
	`141`	`{`
2	`142`	`query.IsVirtualItem = false;`
	`143`	`}`
760	`144`	`}`
	`145`
	`146`	`private List<string> GetItemByNameTypesInQuery(InternalItemsQuery query)`
	`147`	`{`
17	`148`	`var list = new List<string>();`
	`149`
17	`150`	`if (IsTypeInQuery(BaseItemKind.Person, query))`
	`151`	`{`
7	`152`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Person]!);`
	`153`	`}`
	`154`
17	`155`	`if (IsTypeInQuery(BaseItemKind.Genre, query))`
	`156`	`{`
7	`157`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]!);`
	`158`	`}`
	`159`
17	`160`	`if (IsTypeInQuery(BaseItemKind.MusicGenre, query))`
	`161`	`{`
7	`162`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]!);`
	`163`	`}`
	`164`
17	`165`	`if (IsTypeInQuery(BaseItemKind.MusicArtist, query))`
	`166`	`{`
8	`167`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!);`
	`168`	`}`
	`169`
17	`170`	`if (IsTypeInQuery(BaseItemKind.Studio, query))`
	`171`	`{`
7	`172`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]!);`
	`173`	`}`
	`174`
17	`175`	`return list;`
	`176`	`}`
	`177`
	`178`	`private bool IsTypeInQuery(BaseItemKind type, InternalItemsQuery query)`
	`179`	`{`
85	`180`	`if (query.ExcludeItemTypes.Contains(type))`
	`181`	`{`
0	`182`	`return false;`
	`183`	`}`
	`184`
85	`185`	`return query.IncludeItemTypes.Length == 0 \|\| query.IncludeItemTypes.Contains(type);`
	`186`	`}`
	`187`
	`188`	`private bool EnableGroupByPresentationUniqueKey(InternalItemsQuery query)`
	`189`	`{`
751	`190`	`if (!query.GroupByPresentationUniqueKey)`
	`191`	`{`
262	`192`	`return false;`
	`193`	`}`
	`194`
	`195`	`// Resume queries surface the actually-played version (which may be an alternate sharing the`
	`196`	`// primary's presentation key). The resumable filter already keeps one version per group, so`
	`197`	`// presentation-key grouping must not collapse the surfaced version back onto the primary.`
489	`198`	`if (query.IsResumable == true)`
	`199`	`{`
2	`200`	`return false;`
	`201`	`}`
	`202`
487	`203`	`if (query.GroupBySeriesPresentationUniqueKey)`
	`204`	`{`
0	`205`	`return false;`
	`206`	`}`
	`207`
487	`208`	`if (!string.IsNullOrWhiteSpace(query.PresentationUniqueKey))`
	`209`	`{`
0	`210`	`return false;`
	`211`	`}`
	`212`
487	`213`	`if (query.User is null)`
	`214`	`{`
467	`215`	`return false;`
	`216`	`}`
	`217`
20	`218`	`if (query.IncludeItemTypes.Length == 0)`
	`219`	`{`
0	`220`	`return true;`
	`221`	`}`
	`222`
20	`223`	`return query.IncludeItemTypes.Contains(BaseItemKind.Episode)`
20	`224`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Video)`
20	`225`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Movie)`
20	`226`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.MusicVideo)`
20	`227`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Series)`
20	`228`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Season);`
	`229`	`}`
	`230`
	`231`	`private static BaseItemImageInfo Map(Guid baseItemId, ItemImageInfo e)`
	`232`	`{`
0	`233`	`return BaseItemMapper.MapImageToEntity(baseItemId, e);`
	`234`	`}`
	`235`
	`236`	`private static ItemImageInfo Map(BaseItemImageInfo e, IServerApplicationHost? appHost)`
	`237`	`{`
0	`238`	`return BaseItemMapper.MapImageFromEntity(e, appHost);`
	`239`	`}`
	`240`
	`241`	`private string? GetPathToSave(string path)`
	`242`	`{`
0	`243`	`if (path is null)`
	`244`	`{`
0	`245`	`return null;`
	`246`	`}`
	`247`
0	`248`	`return _appHost.ReverseVirtualPath(path);`
	`249`	`}`
	`250`
	`251`	`/// <inheritdoc />`
	`252`	`public BaseItemDto? DeserializeBaseItem(BaseItemEntity entity, bool skipDeserialization = false)`
	`253`	`{`
261	`254`	`ArgumentNullException.ThrowIfNull(entity, nameof(entity));`
261	`255`	`if (_serverConfigurationManager?.Configuration is null)`
	`256`	`{`
0	`257`	`throw new InvalidOperationException("Server Configuration manager or configuration is null");`
	`258`	`}`
	`259`
261	`260`	`var typeToSerialise = BaseItemMapper.GetType(entity.Type);`
261	`261`	`return BaseItemMapper.DeserializeBaseItem(`
261	`262`	`entity,`
261	`263`	`_logger,`
261	`264`	`_appHost,`
261	`265`	`skipDeserialization \|\| (_serverConfigurationManager.Configuration.SkipDeserializationForBasicTypes && (typeT`
	`266`	`}`
	`267`	`}`

/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 Jellyfin.Server.Implementations.Extensions;`
	`16`	`using MediaBrowser.Controller.Entities;`
	`17`	`using MediaBrowser.Model.Entities;`
	`18`	`using MediaBrowser.Model.Querying;`
	`19`	`using Microsoft.EntityFrameworkCore;`
	`20`	`using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;`
	`21`
	`22`	`namespace Jellyfin.Server.Implementations.Item;`
	`23`
	`24`	`public sealed partial class BaseItemRepository`
	`25`	`{`
	`26`	`/// <inheritdoc />`
	`27`	`public IQueryable<BaseItemEntity> PrepareItemQuery(JellyfinDbContext context, InternalItemsQuery filter)`
	`28`	`{`
743	`29`	`IQueryable<BaseItemEntity> dbQuery = context.BaseItems.AsNoTracking();`
743	`30`	`dbQuery = dbQuery.AsSingleQuery();`
	`31`
743	`32`	`return dbQuery;`
	`33`	`}`
	`34`
	`35`	`private IQueryable<BaseItemEntity> ApplyQueryFilter(IQueryable<BaseItemEntity> dbQuery, JellyfinDbContext context, I`
	`36`	`{`
141	`37`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
141	`38`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
141	`39`	`dbQuery = ApplyAdjacencyFilter(context, dbQuery, filter);`
141	`40`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
141	`41`	`dbQuery = ApplyNavigations(dbQuery, filter);`
141	`42`	`return dbQuery;`
	`43`	`}`
	`44`
	`45`	`/// <summary>`
	`46`	`/// Trims an ordered query down to the AdjacentTo item and its immediate neighbours.`
	`47`	`/// </summary>`
	`48`	`private IQueryable<BaseItemEntity> ApplyAdjacencyFilter(JellyfinDbContext context, IQueryable<BaseItemEntity> dbQuer`
	`49`	`{`
751	`50`	`if (filter.AdjacentTo.IsNullOrEmpty())`
	`51`	`{`
751	`52`	`return dbQuery;`
	`53`	`}`
	`54`
	`55`	`// Adjacency is relative to the result set and the order the query asked for, so the ids have`
	`56`	`// to be read back in that order.`
0	`57`	`var orderedIds = dbQuery.Select(e => e.Id).ToList();`
0	`58`	`var index = orderedIds.IndexOf(filter.AdjacentTo.Value);`
0	`59`	`if (index < 0)`
	`60`	`{`
	`61`	`// The item isn't part of this result set, so it has no neighbours in it either.`
0	`62`	`return dbQuery.Take(0);`
	`63`	`}`
	`64`
0	`65`	`var start = Math.Max(index - 1, 0);`
0	`66`	`var adjacentIds = orderedIds.GetRange(start, Math.Min(index + 2, orderedIds.Count) - start);`
	`67`
0	`68`	`var adjacentQuery = context.BaseItems.AsNoTracking().AsSingleQuery().Where(e => adjacentIds.Contains(e.Id));`
	`69`
0	`70`	`return ApplyOrder(adjacentQuery, filter, context);`
	`71`	`}`
	`72`
	`73`	`private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)`
	`74`	`{`
751	`75`	`if (filter.Limit.HasValue \|\| filter.StartIndex.HasValue)`
	`76`	`{`
164	`77`	`var offset = filter.StartIndex ?? 0;`
	`78`
164	`79`	`if (offset > 0)`
	`80`	`{`
0	`81`	`dbQuery = dbQuery.Skip(offset);`
	`82`	`}`
	`83`
164	`84`	`if (filter.Limit.HasValue)`
	`85`	`{`
164	`86`	`dbQuery = dbQuery.Take(filter.Limit.Value);`
	`87`	`}`
	`88`	`}`
	`89`
751	`90`	`return dbQuery;`
	`91`	`}`
	`92`
	`93`	`private IQueryable<BaseItemEntity> ApplyGroupingFilter(JellyfinDbContext context, IQueryable<BaseItemEntity> dbQuery`
	`94`	`{`
	`95`	`// Collapse duplicates sharing a presentation key (e.g. alternate versions), preferring the`
	`96`	`// primary version (PrimaryVersionId is null) so detail pages and actions target it instead`
	`97`	`// of an arbitrary alternate. Keep the grouped ids as an IQueryable sub-select; materializing`
	`98`	`// to a List would inline one bound parameter per id and hit SQLite's variable cap.`
751	`99`	`var enableGroupByPresentationUniqueKey = EnableGroupByPresentationUniqueKey(filter);`
751	`100`	`if (enableGroupByPresentationUniqueKey && filter.GroupBySeriesPresentationUniqueKey)`
	`101`	`{`
0	`102`	`var groupedIds = dbQuery.GroupBy(e => new { e.PresentationUniqueKey, e.SeriesPresentationUniqueKey })`
0	`103`	`.Select(g => g.Where(e => e.PrimaryVersionId == null).Min(e => (Guid?)e.Id) ?? g.Min(e => (Guid?)e.Id));`
0	`104`	`dbQuery = context.BaseItems.AsNoTracking().Where(e => groupedIds.Contains(e.Id));`
	`105`	`}`
751	`106`	`else if (enableGroupByPresentationUniqueKey)`
	`107`	`{`
19	`108`	`var groupedIds = dbQuery.GroupBy(e => e.PresentationUniqueKey)`
19	`109`	`.Select(g => g.Where(e => e.PrimaryVersionId == null).Min(e => (Guid?)e.Id) ?? g.Min(e => (Guid?)e.Id));`
19	`110`	`dbQuery = context.BaseItems.AsNoTracking().Where(e => groupedIds.Contains(e.Id));`
	`111`	`}`
732	`112`	`else if (filter.GroupBySeriesPresentationUniqueKey)`
	`113`	`{`
0	`114`	`var groupedIds = dbQuery.GroupBy(e => e.SeriesPresentationUniqueKey).Select(e => e.Min(x => x.Id));`
0	`115`	`dbQuery = context.BaseItems.AsNoTracking().Where(e => groupedIds.Contains(e.Id));`
	`116`	`}`
	`117`	`else`
	`118`	`{`
732	`119`	`dbQuery = dbQuery.Distinct();`
	`120`	`}`
	`121`
751	`122`	`if (filter.CollapseBoxSetItems == true)`
	`123`	`{`
0	`124`	`dbQuery = ApplyBoxSetCollapsing(context, dbQuery, filter.CollapseBoxSetItemTypes);`
	`125`
	`126`	`// Name filters run after collapse so BoxSets match by their own name, not a child's.`
0	`127`	`dbQuery = ApplyNameFilters(dbQuery, filter);`
	`128`	`}`
	`129`
751	`130`	`dbQuery = ApplyOrder(dbQuery, filter, context);`
	`131`
751	`132`	`return dbQuery;`
	`133`	`}`
	`134`
	`135`	`private IQueryable<BaseItemEntity> ApplyBoxSetCollapsing(`
	`136`	`JellyfinDbContext context,`
	`137`	`IQueryable<BaseItemEntity> dbQuery,`
	`138`	`BaseItemKind[] collapsibleTypes)`
	`139`	`{`
0	`140`	`var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];`
	`141`
0	`142`	`var currentIds = dbQuery.Select(e => e.Id);`
	`143`
0	`144`	`if (collapsibleTypes.Length == 0)`
	`145`	`{`
	`146`	`// Collapse all item types into box sets`
0	`147`	`return ApplyBoxSetCollapsingAll(context, currentIds, boxSetTypeName);`
	`148`	`}`
	`149`
	`150`	`// Only collapse specific item types, keep others untouched`
0	`151`	`var collapsibleTypeNames = collapsibleTypes.Select(t => _itemTypeLookup.BaseItemKindNames[t]).ToList();`
	`152`
	`153`	`// Categorize items in currentIds in a single pass to avoid multiple correlated EXISTS over BaseItems.`
0	`154`	`var categorized = context.BaseItems`
0	`155`	`.AsNoTracking()`
0	`156`	`.Where(bi => currentIds.Contains(bi.Id))`
0	`157`	`.Select(bi => new`
0	`158`	`{`
0	`159`	`bi.Id,`
0	`160`	`IsCollapsible = collapsibleTypeNames.Contains(bi.Type),`
0	`161`	`IsBoxSet = bi.Type == boxSetTypeName`
0	`162`	`});`
	`163`
0	`164`	`var collapsibleChildIds = categorized.Where(c => c.IsCollapsible).Select(c => c.Id);`
	`165`
	`166`	`// Single JOIN: manual links to BoxSet parents, restricted to currentIds children.`
0	`167`	`var manualBoxSetLinks = context.LinkedChildren`
0	`168`	`.Where(lc => lc.ChildType == Database.Implementations.Entities.LinkedChildType.Manual`
0	`169`	`&& currentIds.Contains(lc.ChildId))`
0	`170`	`.Join(`
0	`171`	`context.BaseItems.Where(bs => bs.Type == boxSetTypeName),`
0	`172`	`lc => lc.ParentId,`
0	`173`	`bs => bs.Id,`
0	`174`	`(lc, bs) => new { lc.ChildId, lc.ParentId });`
	`175`
0	`176`	`var childrenInBoxSet = manualBoxSetLinks.Select(x => x.ChildId).Distinct();`
	`177`
	`178`	`// Items whose type is NOT collapsible (always kept in results)`
0	`179`	`var nonCollapsibleIds = categorized.Where(c => !c.IsCollapsible).Select(c => c.Id);`
	`180`
	`181`	`// Collapsible items that are not a BoxSet themselves and not a manual child of any BoxSet`
0	`182`	`var collapsibleNotInBoxSet = categorized`
0	`183`	`.Where(c => c.IsCollapsible && !c.IsBoxSet)`
0	`184`	`.Select(c => c.Id)`
0	`185`	`.Where(id => !childrenInBoxSet.Contains(id));`
	`186`
	`187`	`// BoxSet IDs containing at least one collapsible child item from currentIds`
0	`188`	`var boxSetIds = manualBoxSetLinks`
0	`189`	`.Where(x => collapsibleChildIds.Contains(x.ChildId))`
0	`190`	`.Select(x => x.ParentId)`
0	`191`	`.Distinct();`
	`192`
0	`193`	`var collapsedIds = nonCollapsibleIds.Union(collapsibleNotInBoxSet).Union(boxSetIds);`
0	`194`	`return context.BaseItems.AsNoTracking().Where(e => collapsedIds.Contains(e.Id));`
	`195`	`}`
	`196`
	`197`	`private static IQueryable<BaseItemEntity> ApplyBoxSetCollapsingAll(`
	`198`	`JellyfinDbContext context,`
	`199`	`IQueryable<Guid> currentIds,`
	`200`	`string boxSetTypeName)`
	`201`	`{`
	`202`	`// Single JOIN: manual links to BoxSet parents, restricted to currentIds children.`
0	`203`	`var manualBoxSetLinks = context.LinkedChildren`
0	`204`	`.Where(lc => lc.ChildType == Database.Implementations.Entities.LinkedChildType.Manual`
0	`205`	`&& currentIds.Contains(lc.ChildId))`
0	`206`	`.Join(`
0	`207`	`context.BaseItems.Where(bs => bs.Type == boxSetTypeName),`
0	`208`	`lc => lc.ParentId,`
0	`209`	`bs => bs.Id,`
0	`210`	`(lc, bs) => new { lc.ChildId, lc.ParentId });`
	`211`
0	`212`	`var childrenInBoxSet = manualBoxSetLinks.Select(x => x.ChildId).Distinct();`
0	`213`	`var boxSetIds = manualBoxSetLinks.Select(x => x.ParentId).Distinct();`
	`214`
	`215`	`// Items in currentIds that are not BoxSets themselves and not a manual child of any BoxSet`
0	`216`	`var notInBoxSet = context.BaseItems`
0	`217`	`.AsNoTracking()`
0	`218`	`.Where(e => currentIds.Contains(e.Id) && e.Type != boxSetTypeName)`
0	`219`	`.Select(e => e.Id)`
0	`220`	`.Where(id => !childrenInBoxSet.Contains(id));`
	`221`
0	`222`	`var collapsedIds = notInBoxSet.Union(boxSetIds);`
0	`223`	`return context.BaseItems.AsNoTracking().Where(e => collapsedIds.Contains(e.Id));`
	`224`	`}`
	`225`
	`226`	`private static IQueryable<BaseItemEntity> ApplyNameFilters(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery fi`
	`227`	`{`
802	`228`	`if (!string.IsNullOrWhiteSpace(filter.NameStartsWith))`
	`229`	`{`
0	`230`	`var nameStartsWithLower = filter.NameStartsWith.ToLowerInvariant();`
0	`231`	`dbQuery = dbQuery.Where(e => e.SortName!.ToLower().StartsWith(nameStartsWithLower));`
	`232`	`}`
	`233`
802	`234`	`if (!string.IsNullOrWhiteSpace(filter.NameStartsWithOrGreater))`
	`235`	`{`
0	`236`	`var startsOrGreaterLower = filter.NameStartsWithOrGreater.ToLowerInvariant();`
0	`237`	`dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(startsOrGreaterLower) >= 0);`
	`238`	`}`
	`239`
802	`240`	`if (!string.IsNullOrWhiteSpace(filter.NameLessThan))`
	`241`	`{`
0	`242`	`var lessThanLower = filter.NameLessThan.ToLowerInvariant();`
0	`243`	`dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(lessThanLower) < 0);`
	`244`	`}`
	`245`
802	`246`	`return dbQuery;`
	`247`	`}`
	`248`
	`249`	`/// <inheritdoc />`
	`250`	`public IQueryable<BaseItemEntity> ApplyNavigations(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)`
	`251`	`{`
670	`252`	`if (filter.TrailerTypes.Length > 0 \|\| filter.IncludeItemTypes.Contains(BaseItemKind.Trailer))`
	`253`	`{`
6	`254`	`dbQuery = dbQuery.Include(e => e.TrailerTypes);`
	`255`	`}`
	`256`
670	`257`	`if (filter.DtoOptions.ContainsField(ItemFields.ProviderIds))`
	`258`	`{`
658	`259`	`dbQuery = dbQuery.Include(e => e.Provider);`
	`260`	`}`
	`261`
670	`262`	`if (filter.DtoOptions.ContainsField(ItemFields.Settings))`
	`263`	`{`
658	`264`	`dbQuery = dbQuery.Include(e => e.LockedFields);`
	`265`	`}`
	`266`
670	`267`	`if (filter.DtoOptions.EnableUserData)`
	`268`	`{`
669	`269`	`dbQuery = dbQuery.Include(e => e.UserData);`
	`270`	`}`
	`271`
670	`272`	`if (filter.DtoOptions.EnableImages)`
	`273`	`{`
669	`274`	`dbQuery = dbQuery.Include(e => e.Images!.OrderBy(i => i.Id));`
	`275`	`}`
	`276`
	`277`	`// Include LinkedChildEntities for container types and videos that use them (BoxSet, Playlist,`
	`278`	`// CollectionFolder for manual linking; every video type for alternate versions).`
	`279`	`// When IncludeItemTypes is empty (any type may be returned), always include them to ensure`
	`280`	`// LinkedChildren are loaded before items are saved back, preventing accidental deletion.`
670	`281`	`var linkedChildTypes = new[]`
670	`282`	`{`
670	`283`	`BaseItemKind.BoxSet,`
670	`284`	`BaseItemKind.Playlist,`
670	`285`	`BaseItemKind.CollectionFolder,`
670	`286`	`BaseItemKind.Video,`
670	`287`	`BaseItemKind.Movie,`
670	`288`	`BaseItemKind.Episode,`
670	`289`	`BaseItemKind.MusicVideo,`
670	`290`	`BaseItemKind.Trailer`
670	`291`	`};`
670	`292`	`if (filter.IncludeItemTypes.Length == 0 \|\| filter.IncludeItemTypes.Any(linkedChildTypes.Contains))`
	`293`	`{`
474	`294`	`dbQuery = dbQuery.Include(e => e.LinkedChildEntities!.OrderBy(l => l.SortOrder));`
	`295`	`}`
	`296`
670	`297`	`if (filter.IncludeExtras)`
	`298`	`{`
0	`299`	`dbQuery = dbQuery.Include(e => e.Extras);`
	`300`	`}`
	`301`
670	`302`	`return dbQuery;`
	`303`	`}`
	`304`
	`305`	`/// <inheritdoc />`
	`306`	`public IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter, JellyfinDb`
	`307`	`{`
766	`308`	`var orderBy = filter.OrderBy.Where(e => e.OrderBy != ItemSortBy.Default).ToArray();`
766	`309`	`var hasSearch = !string.IsNullOrEmpty(filter.SearchTerm);`
	`310`
	`311`	`// SeriesDatePlayed requires special handling to avoid correlated subqueries.`
	`312`	`// Instead of running a MAX() subquery per-row in ORDER BY, we pre-aggregate`
	`313`	`// max played dates per series in one query and left-join it.`
766	`314`	`if (!hasSearch && orderBy.Any(o => o.OrderBy == ItemSortBy.SeriesDatePlayed))`
	`315`	`{`
0	`316`	`return ApplySeriesDatePlayedOrder(query, filter, context, orderBy);`
	`317`	`}`
	`318`
766	`319`	`IOrderedQueryable<BaseItemEntity>? orderedQuery = null;`
	`320`
766	`321`	`if (hasSearch)`
	`322`	`{`
0	`323`	`var relevanceExpression = OrderMapper.MapSearchRelevanceOrder(filter.SearchTerm!);`
0	`324`	`orderedQuery = query.OrderBy(relevanceExpression);`
	`325`	`}`
	`326`
	`327`	`// Folders carry no played flag of their own, so these two keys go through the same predicate`
	`328`	`// the isPlayed filter uses rather than through the stored-column lookup in OrderMapper.`
	`329`	`Expression<Func<BaseItemEntity, object?>> MapOrderByField(ItemSortBy sortBy) => sortBy switch`
	`330`	`{`
	`331`	`ItemSortBy.IsPlayed when filter.User is not null`
	`332`	`=> AsOrderKey(BuildIsPlayedFilter(context, filter.User)),`
	`333`	`ItemSortBy.IsUnplayed when filter.User is not null`
	`334`	`=> AsOrderKey(BuildIsPlayedFilter(context, filter.User).Not()),`
	`335`	`_ => OrderMapper.MapOrderByField(sortBy, filter, context)`
	`336`	`};`
	`337`
766	`338`	`if (orderBy.Length > 0)`
	`339`	`{`
175	`340`	`var firstOrdering = orderBy[0];`
175	`341`	`var expression = MapOrderByField(firstOrdering.OrderBy);`
	`342`
175	`343`	`if (orderedQuery is null)`
	`344`	`{`
175	`345`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
175	`346`	`? query.OrderBy(expression)`
175	`347`	`: query.OrderByDescending(expression);`
	`348`	`}`
	`349`	`else`
	`350`	`{`
0	`351`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
0	`352`	`? orderedQuery.ThenBy(expression)`
0	`353`	`: orderedQuery.ThenByDescending(expression);`
	`354`	`}`
	`355`
175	`356`	`if (firstOrdering.OrderBy is ItemSortBy.Default or ItemSortBy.SortName)`
	`357`	`{`
6	`358`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
6	`359`	`? orderedQuery.ThenBy(e => e.Name)`
6	`360`	`: orderedQuery.ThenByDescending(e => e.Name);`
	`361`	`}`
	`362`
470	`363`	`foreach (var item in orderBy.Skip(1))`
	`364`	`{`
60	`365`	`expression = MapOrderByField(item.OrderBy);`
60	`366`	`orderedQuery = item.SortOrder == SortOrder.Ascending`
60	`367`	`? orderedQuery.ThenBy(expression)`
60	`368`	`: orderedQuery.ThenByDescending(expression);`
	`369`	`}`
	`370`	`}`
	`371`
766	`372`	`if (orderedQuery is null)`
	`373`	`{`
591	`374`	`return query.OrderBy(e => e.SortName);`
	`375`	`}`
	`376`
	`377`	`// Add SortName as final tiebreaker`
175	`378`	`if (!hasSearch && (orderBy.Length == 0 \|\| orderBy.All(o => o.OrderBy is not ItemSortBy.SortName and not ItemSort`
	`379`	`{`
111	`380`	`orderedQuery = orderedQuery.ThenBy(e => e.SortName);`
	`381`	`}`
	`382`
175	`383`	`return orderedQuery;`
	`384`	`}`
	`385`
	`386`	`private IQueryable<BaseItemEntity> ApplySeriesDatePlayedOrder(`
	`387`	`IQueryable<BaseItemEntity> query,`
	`388`	`InternalItemsQuery filter,`
	`389`	`JellyfinDbContext context,`
	`390`	`(ItemSortBy OrderBy, SortOrder SortOrder)[] orderBy)`
	`391`	`{`
	`392`	`// Pre-aggregate max played date per series key in ONE query.`
	`393`	`// This generates a single: SELECT SeriesPresentationUniqueKey, MAX(LastPlayedDate) ... GROUP BY`
	`394`	`// instead of a correlated subquery per outer row.`
0	`395`	`IQueryable<UserData> userDataQuery = filter.User is not null`
0	`396`	`? context.UserData.Where(ud => ud.UserId == filter.User.Id && ud.Played)`
0	`397`	`: context.UserData.Where(ud => ud.Played);`
	`398`
0	`399`	`var seriesMaxDates = userDataQuery`
0	`400`	`.Join(`
0	`401`	`context.BaseItems,`
0	`402`	`ud => ud.ItemId,`
0	`403`	`bi => bi.Id,`
0	`404`	`(ud, bi) => new { bi.SeriesPresentationUniqueKey, ud.LastPlayedDate })`
0	`405`	`.Where(x => x.SeriesPresentationUniqueKey != null)`
0	`406`	`.GroupBy(x => x.SeriesPresentationUniqueKey)`
0	`407`	`.Select(g => new { SeriesKey = g.Key!, MaxDate = g.Max(x => x.LastPlayedDate) });`
	`408`
0	`409`	`var joined = query.LeftJoin(`
0	`410`	`seriesMaxDates,`
0	`411`	`e => e.PresentationUniqueKey,`
0	`412`	`s => s.SeriesKey,`
0	`413`	`(e, s) => new { Item = e, MaxDate = s != null ? s.MaxDate : (DateTime?)null });`
	`414`
0	`415`	`var seriesSort = orderBy.First(o => o.OrderBy == ItemSortBy.SeriesDatePlayed);`
	`416`
0	`417`	`return seriesSort.SortOrder == SortOrder.Ascending`
0	`418`	`? joined.OrderBy(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item)`
0	`419`	`: joined.OrderByDescending(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item);`
	`420`	`}`
	`421`
	`422`	`/// <summary>`
	`423`	`/// Builds a query for descendants of an ancestor with user access filtering applied.`
	`424`	`/// Uses recursive CTE to traverse both hierarchical (AncestorIds) and linked (LinkedChildren) relationships.`
	`425`	`/// </summary>`
	`426`	`/// <inheritdoc />`
	`427`	`public IQueryable<BaseItemEntity> BuildAccessFilteredDescendantsQuery(`
	`428`	`JellyfinDbContext context,`
	`429`	`InternalItemsQuery filter,`
	`430`	`Guid ancestorId)`
	`431`	`{`
	`432`	`// Use recursive CTE to get all descendants (hierarchical and linked)`
0	`433`	`var allDescendantIds = DescendantQueryHelper.GetAllDescendantIds(context, ancestorId);`
	`434`
0	`435`	`var baseQuery = context.BaseItems`
0	`436`	`.AsNoTracking()`
0	`437`	`.Where(b => allDescendantIds.Contains(b.Id))`
0	`438`	`.Where(DescendantQueryHelper.IsCountableLeaf);`
	`439`
0	`440`	`return ApplyAccessFiltering(context, baseQuery, filter);`
	`441`	`}`
	`442`
	`443`	`/// <summary>`
	`444`	`/// Checks whether the user restricts access to items by parental rating or tags.`
	`445`	`/// </summary>`
	`446`	`/// <param name="filter">The query filter.</param>`
	`447`	`/// <returns><c>true</c> if the query carries parental restrictions.</returns>`
	`448`	`private static bool RequiresParentalRestrictions(InternalItemsQuery filter)`
0	`449`	`=> filter.IncludeInheritedTags.Length > 0`
0	`450`	`\|\| filter.ExcludeInheritedTags.Length > 0`
0	`451`	`\|\| filter.MaxParentalRating is not null`
0	`452`	`\|\| filter.BlockUnratedItems.Length > 0;`
	`453`
	`454`	`/// <summary>`
	`455`	`/// Applies user access filtering to a query.`
	`456`	`/// Includes TopParentIds, parental rating, and tag filtering.`
	`457`	`/// </summary>`
	`458`	`/// <inheritdoc />`
	`459`	`public IQueryable<BaseItemEntity> ApplyAccessFiltering(`
	`460`	`JellyfinDbContext context,`
	`461`	`IQueryable<BaseItemEntity> baseQuery,`
	`462`	`InternalItemsQuery filter)`
	`463`	`{`
33	`464`	`baseQuery = ApplyTopParentFiltering(context, baseQuery, filter);`
	`465`
33	`466`	`baseQuery = ApplyParentalRestrictions(context, baseQuery, filter);`
	`467`
	`468`	`// Hide alternate versions behind the primary of their library, and exclude owned non-extra`
	`469`	`// items. Extras (trailers, etc.) have OwnerId set but also have ExtraType set — keep those.`
33	`470`	`if (!filter.IncludeOwnedItems)`
	`471`	`{`
29	`472`	`baseQuery = ApplyAlternateVersionFiltering(context, baseQuery)`
29	`473`	`.Where(e => e.OwnerId == null \|\| e.ExtraType != null);`
	`474`	`}`
	`475`
33	`476`	`return baseQuery;`
	`477`	`}`
	`478`
	`479`	`private static IQueryable<BaseItemEntity> ApplyAlternateVersionFiltering(`
	`480`	`JellyfinDbContext context,`
	`481`	`IQueryable<BaseItemEntity> baseQuery)`
715	`482`	`=> baseQuery.Where(e => e.PrimaryVersionId == null`
715	`483`	`\|\| !context.BaseItems.Any(p => p.Id == e.PrimaryVersionId && p.TopParentId == e.TopParentId));`
	`484`
	`485`	`/// <summary>`
	`486`	`/// Restricts a query to the libraries the user may open, exempting requested by-name items.`
	`487`	`/// </summary>`
	`488`	`/// <param name="context">The database context.</param>`
	`489`	`/// <param name="baseQuery">The query to filter.</param>`
	`490`	`/// <param name="filter">The query filter.</param>`
	`491`	`/// <returns>The filtered query.</returns>`
	`492`	`private IQueryable<BaseItemEntity> ApplyTopParentFiltering(`
	`493`	`JellyfinDbContext context,`
	`494`	`IQueryable<BaseItemEntity> baseQuery,`
	`495`	`InternalItemsQuery filter)`
	`496`	`{`
835	`497`	`var queryTopParentIds = filter.TopParentIds;`
835	`498`	`if (queryTopParentIds.Length == 0)`
	`499`	`{`
818	`500`	`return baseQuery;`
	`501`	`}`
	`502`
17	`503`	`var exemptedItemByNameTypes = GetExemptedItemByNameTypes(filter);`
17	`504`	`if (exemptedItemByNameTypes.Count == 0)`
	`505`	`{`
14	`506`	`return baseQuery.WhereOneOrMany(queryTopParentIds, e => e.TopParentId!.Value);`
	`507`	`}`
	`508`
3	`509`	`baseQuery = baseQuery.Where(e => exemptedItemByNameTypes.Contains(e.Type) \|\| queryTopParentIds.Any(w => w == e.T`
3	`510`	`if (filter.UserHasContentRestrictions)`
	`511`	`{`
2	`512`	`baseQuery = ApplyItemByNameAccessFiltering(baseQuery, context, filter, exemptedItemByNameTypes, queryTopPare`
	`513`	`}`
	`514`
3	`515`	`return baseQuery;`
	`516`	`}`
	`517`
	`518`	`/// <summary>`
	`519`	`/// Returns the by-name types a query asks for, which carry no TopParentId to filter on.`
	`520`	`/// </summary>`
	`521`	`/// <param name="filter">The query filter.</param>`
	`522`	`/// <returns>The type names exempt from library filtering.</returns>`
	`523`	`private List<string> GetExemptedItemByNameTypes(InternalItemsQuery filter)`
	`524`	`{`
17	`525`	`var includedItemByNameTypes = GetItemByNameTypesInQuery(filter);`
17	`526`	`if ((filter.IncludeItemsByName ?? false) && includedItemByNameTypes.Count > 0)`
	`527`	`{`
2	`528`	`return includedItemByNameTypes;`
	`529`	`}`
	`530`
15	`531`	`return _itemByNameKinds.Where(filter.IncludeItemTypes.Contains).Select(e => _itemTypeLookup.BaseItemKindNames[e]`
	`532`	`}`
	`533`
	`534`	`/// <summary>`
	`535`	`/// Keeps a by-name row only when at least one item behind its name is reachable for the user.`
	`536`	`/// </summary>`
	`537`	`/// <param name="baseQuery">The query to filter.</param>`
	`538`	`/// <param name="context">The database context.</param>`
	`539`	`/// <param name="filter">The query filter.</param>`
	`540`	`/// <param name="itemByNameTypes">The exempted by-name type names.</param>`
	`541`	`/// <param name="topParentIds">The libraries the user may open.</param>`
	`542`	`/// <returns>The filtered query.</returns>`
	`543`	`private IQueryable<BaseItemEntity> ApplyItemByNameAccessFiltering(`
	`544`	`IQueryable<BaseItemEntity> baseQuery,`
	`545`	`JellyfinDbContext context,`
	`546`	`InternalItemsQuery filter,`
	`547`	`IReadOnlyList<string> itemByNameTypes,`
	`548`	`Guid[] topParentIds)`
	`549`	`{`
	`550`	`// IncludeOwnedItems: a credit on an alternate version of a reachable movie still counts.`
2	`551`	`var accessibleItems = ApplyAccessFiltering(`
2	`552`	`context,`
2	`553`	`context.BaseItems.AsNoTracking(),`
2	`554`	`new InternalItemsQuery(filter.User) { TopParentIds = topParentIds, IncludeOwnedItems = true });`
	`555`
2	`556`	`var personType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];`
2	`557`	`if (itemByNameTypes.Contains(personType))`
	`558`	`{`
2	`559`	`baseQuery = baseQuery.Where(e => e.Type != personType`
2	`560`	`\|\| context.Peoples.Any(p => p.Name == e.Name`
2	`561`	`&& context.PeopleBaseItemMap.Any(m => m.PeopleId == p.Id && accessibleItems.Any(i => i.Id == m.ItemI`
	`562`	`}`
	`563`
20	`564`	`foreach (var (kind, valueTypes) in _itemByNameValueTypes)`
	`565`	`{`
8	`566`	`var typeName = _itemTypeLookup.BaseItemKindNames[kind];`
8	`567`	`if (!itemByNameTypes.Contains(typeName))`
	`568`	`{`
	`569`	`continue;`
	`570`	`}`
	`571`
8	`572`	`baseQuery = baseQuery.Where(e => e.Type != typeName`
8	`573`	`\|\| context.ItemValues.Any(v => valueTypes.Contains(v.Type) && v.CleanValue == e.CleanName`
8	`574`	`&& context.ItemValuesMap.Any(m => m.ItemValueId == v.ItemValueId && accessibleItems.Any(i => i.Id ==`
	`575`	`}`
	`576`
2	`577`	`return baseQuery;`
	`578`	`}`
	`579`
	`580`	`/// <summary>`
	`581`	`/// Applies the user's parental rating and tag restrictions to a query.`
	`582`	`/// </summary>`
	`583`	`/// <param name="context">The database context.</param>`
	`584`	`/// <param name="baseQuery">The query to filter.</param>`
	`585`	`/// <param name="filter">The query filter.</param>`
	`586`	`/// <returns>The filtered query.</returns>`
	`587`	`private IQueryable<BaseItemEntity> ApplyParentalRestrictions(`
	`588`	`JellyfinDbContext context,`
	`589`	`IQueryable<BaseItemEntity> baseQuery,`
	`590`	`InternalItemsQuery filter)`
	`591`	`{`
	`592`	`// Apply parental rating filtering`
33	`593`	`if (filter.MaxParentalRating is not null)`
	`594`	`{`
0	`595`	`baseQuery = baseQuery.Where(BuildMaxParentalRatingFilter(context, filter.MaxParentalRating));`
	`596`	`}`
	`597`
	`598`	`// Apply block unrated items filtering`
33	`599`	`if (filter.BlockUnratedItems.Length > 0)`
	`600`	`{`
0	`601`	`var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();`
0	`602`	`baseQuery = baseQuery.Where(e =>`
0	`603`	`e.InheritedParentalRatingValue != null \|\| !unratedItemTypes.Contains(e.UnratedType));`
	`604`	`}`
	`605`
	`606`	`// Apply excluded tags filtering (blocked tags).`
	`607`	`// Pre-build the blocked-item-id set as a sub-select; then four index-seek Contains checks`
	`608`	`// instead of one EXISTS over a 4-way OR predicate that defeats index seeks.`
33	`609`	`if (filter.ExcludeInheritedTags.Length > 0)`
	`610`	`{`
0	`611`	`var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
0	`612`	`var blockedTagItemIds = context.ItemValuesMap`
0	`613`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && excludedTags.Contains(f.ItemValue.CleanValue))`
0	`614`	`.Select(f => f.ItemId);`
0	`615`	`var blockedByAncestor = ItemsBelowTaggedAncestor(context, blockedTagItemIds);`
	`616`
0	`617`	`baseQuery = baseQuery.Where(e =>`
0	`618`	`!blockedTagItemIds.Contains(e.Id)`
0	`619`	`&& !(e.SeriesId.HasValue && blockedTagItemIds.Contains(e.SeriesId.Value))`
0	`620`	`&& !blockedByAncestor.Contains(e.Id)`
0	`621`	`&& !(e.TopParentId.HasValue && blockedTagItemIds.Contains(e.TopParentId.Value)));`
	`622`	`}`
	`623`
	`624`	`// Apply included tags filtering (allowed tags - item must have at least one).`
33	`625`	`if (filter.IncludeInheritedTags.Length > 0)`
	`626`	`{`
0	`627`	`var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
0	`628`	`var personTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];`
0	`629`	`var allowedTagItemIds = context.ItemValuesMap`
0	`630`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && includeTags.Contains(f.ItemValue.CleanValue))`
0	`631`	`.Select(f => f.ItemId);`
	`632`
0	`633`	`var allowedByAncestor = ItemsBelowTaggedAncestor(context, allowedTagItemIds);`
	`634`
0	`635`	`baseQuery = baseQuery.Where(e =>`
0	`636`	`allowedTagItemIds.Contains(e.Id)`
0	`637`	`\|\| (e.SeriesId.HasValue && allowedTagItemIds.Contains(e.SeriesId.Value))`
0	`638`	`\|\| allowedByAncestor.Contains(e.Id)`
0	`639`	`\|\| (e.TopParentId.HasValue && allowedTagItemIds.Contains(e.TopParentId.Value))`
0	`640`
0	`641`	`// People don't carry the tags of the media they appear in and would never match`
0	`642`	`\|\| e.Type == personTypeName);`
	`643`	`}`
	`644`
33	`645`	`return baseQuery;`
	`646`	`}`
	`647`
	`648`	`/// <summary>`
	`649`	`/// Reads back the items that carry one of the tagged items as an ancestor.`
	`650`	`/// </summary>`
	`651`	`/// <param name="context">The database context.</param>`
	`652`	`/// <param name="taggedItemIds">The ids of the items carrying the tag.</param>`
	`653`	`/// <returns>The ids of the items below one of them.</returns>`
	`654`	`private static IQueryable<Guid> ItemsBelowTaggedAncestor(JellyfinDbContext context, IQueryable<Guid> taggedItemIds)`
12	`655`	`=> context.AncestorIds`
12	`656`	`.Where(a => taggedItemIds.Contains(a.ParentItemId))`
12	`657`	`.Select(a => a.ItemId);`
	`658`
	`659`	`/// <summary>`
	`660`	`/// Builds a filter expression for max parental rating that handles both rated items`
	`661`	`/// and unrated BoxSets/Playlists (which check linked children's ratings).`
	`662`	`/// </summary>`
	`663`	`private static Expression<Func<BaseItemEntity, bool>> BuildMaxParentalRatingFilter(`
	`664`	`JellyfinDbContext context,`
	`665`	`ParentalRatingScore maxRating)`
	`666`	`{`
60	`667`	`var maxScore = maxRating.Score;`
60	`668`	`var maxSubScore = maxRating.SubScore ?? 0;`
	`669`
	`670`	`// Only a manual link makes an item a container of other items.`
60	`671`	`var members = context.LinkedChildren`
60	`672`	`.Where(lc => lc.ChildType == Database.Implementations.Entities.LinkedChildType.Manual);`
	`673`
60	`674`	`return e =>`
60	`675`	`// The item's own rating, where it has one, has to be within the limit. An unrated item`
60	`676`	`// passes here; blocking those is what BlockUnratedItems does.`
60	`677`	`(e.InheritedParentalRatingValue == null`
60	`678`	`\|\| e.InheritedParentalRatingValue < maxScore`
60	`679`	`\|\| (e.InheritedParentalRatingValue == maxScore && (e.InheritedParentalRatingSubValue ?? 0) <= maxSubScor`
60	`680`	`// A container is only as visible as its members: a BoxSet or Playlist with nothing left`
60	`681`	`// in it for this user is hidden whatever rating it carries itself. BoxSet.IsVisible`
60	`682`	`// applies the same rule in memory, and a count has to agree with the listing it counts.`
60	`683`	`&& (!members.Any(lc => lc.ParentId == e.Id)`
60	`684`	`\|\| members.Any(lc => lc.ParentId == e.Id`
60	`685`	`&& (lc.Child!.InheritedParentalRatingValue == null`
60	`686`	`\|\| lc.Child.InheritedParentalRatingValue < maxScore`
60	`687`	`\|\| (lc.Child.InheritedParentalRatingValue == maxScore`
60	`688`	`&& (lc.Child.InheritedParentalRatingSubValue ?? 0) <= maxSubScore))));`
	`689`	`}`
	`690`
	`691`	`/// <inheritdoc />`
	`692`	`public IQueryable<BaseItemEntity> GetAccessFilteredLeafItemsQuery(JellyfinDbContext context, User user, bool include`
	`693`	`{`
21	`694`	`ArgumentNullException.ThrowIfNull(context);`
21	`695`	`ArgumentNullException.ThrowIfNull(user);`
	`696`
21	`697`	`var leafItems = context.BaseItems`
21	`698`	`.AsNoTracking()`
21	`699`	`.Where(DescendantQueryHelper.IsCountableLeaf);`
	`700`
21	`701`	`return ApplyAccessFiltering(context, leafItems, new InternalItemsQuery(user) { IncludeOwnedItems = includeOwnedI`
	`702`	`}`
	`703`
	`704`	`private static Expression<Func<BaseItemEntity, object?>> AsOrderKey(Expression<Func<BaseItemEntity, bool>> predicate`
6	`705`	`=> Expression.Lambda<Func<BaseItemEntity, object?>>(Expression.Convert(predicate.Body, typeof(object)), predicat`
	`706`
	`707`	`/// <inheritdoc />`
	`708`	`public Expression<Func<BaseItemEntity, bool>> BuildHasDescendantFilter(JellyfinDbContext context, IQueryable<BaseIte`
	`709`	`{`
23	`710`	`ArgumentNullException.ThrowIfNull(context);`
23	`711`	`ArgumentNullException.ThrowIfNull(descendants);`
	`712`
	`713`	`// Descendants are reachable through the ancestor chain and - for BoxSets and Playlists - as`
	`714`	`// linked children, which can themselves be folders contributing their own descendants.`
	`715`	`// Every step is a correlated index seek, so only the rows the outer query keeps are visited`
	`716`	`// and a folder is left as soon as its first matching descendant is found.`
23	`717`	`return e => context.AncestorIds.Any(a => a.ParentItemId == e.Id && descendants.Any(d => d.Id == a.ItemId))`
23	`718`	`\|\| context.LinkedChildren.Any(lc => lc.ParentId == e.Id`
23	`719`	`&& (descendants.Any(d => d.Id == lc.ChildId)`
23	`720`	`\|\| context.AncestorIds.Any(a => a.ParentItemId == lc.ChildId && descendants.Any(d => d.Id == a.ItemI`
	`721`	`}`
	`722`	`}`

/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`	`{`
141	`23`	`ArgumentNullException.ThrowIfNull(filter);`
141	`24`	`PrepareFilterQuery(filter);`
	`25`
141	`26`	`using var context = _dbProvider.CreateDbContext();`
141	`27`	`return ApplyQueryFilter(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context`
141	`28`	`}`
	`29`
	`30`	`/// <inheritdoc />`
	`31`	`public QueryResult<BaseItemDto> GetItems(InternalItemsQuery filter)`
	`32`	`{`
3	`33`	`ArgumentNullException.ThrowIfNull(filter);`
3	`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`
2	`43`	`PrepareFilterQuery(filter);`
2	`44`	`var result = new QueryResult<BaseItemDto>();`
	`45`
2	`46`	`using var context = _dbProvider.CreateDbContext();`
	`47`
2	`48`	`IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);`
	`49`
2	`50`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
2	`51`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
2	`52`	`dbQuery = ApplyAdjacencyFilter(context, dbQuery, filter);`
	`53`
2	`54`	`if (filter.EnableTotalRecordCount)`
	`55`	`{`
2	`56`	`result.TotalRecordCount = dbQuery.Count();`
	`57`	`}`
	`58`
2	`59`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
2	`60`	`dbQuery = ApplyNavigations(dbQuery, filter);`
	`61`
2	`62`	`result.Items = dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeseri`
2	`63`	`result.StartIndex = filter.StartIndex ?? 0;`
2	`64`	`return result;`
2	`65`	`}`
	`66`
	`67`	`/// <inheritdoc />`
	`68`	`public IReadOnlyList<BaseItemDto> GetItemList(InternalItemsQuery filter)`
	`69`	`{`
608	`70`	`ArgumentNullException.ThrowIfNull(filter);`
608	`71`	`PrepareFilterQuery(filter);`
	`72`
608	`73`	`using var context = _dbProvider.CreateDbContext();`
608	`74`	`IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);`
	`75`
608	`76`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
	`77`
608	`78`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
608	`79`	`dbQuery = ApplyAdjacencyFilter(context, dbQuery, filter);`
608	`80`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
	`81`
608	`82`	`var hasRandomSort = filter.OrderBy.Any(e => e.OrderBy == ItemSortBy.Random);`
608	`83`	`if (hasRandomSort)`
	`84`	`{`
105	`85`	`var orderedIds = dbQuery.AsNoTracking().Select(e => e.Id).ToList();`
105	`86`	`if (orderedIds.Count == 0)`
	`87`	`{`
104	`88`	`return Array.Empty<BaseItemDto>();`
	`89`	`}`
	`90`
1	`91`	`var itemsById = ApplyNavigations(context.BaseItems.AsNoTracking().WhereOneOrMany(orderedIds, e => e.Id), fil`
1	`92`	`.AsSplitQuery()`
1	`93`	`.AsEnumerable()`
1	`94`	`.Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))`
1	`95`	`.Where(dto => dto != null)`
1	`96`	`.ToDictionary(i => i!.Id);`
	`97`
1	`98`	`return orderedIds.Where(itemsById.ContainsKey).Select(id => itemsById[id]).ToArray()!;`
	`99`	`}`
	`100`
503	`101`	`dbQuery = ApplyNavigations(dbQuery, filter);`
	`102`
503	`103`	`return dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeserializatio`
608	`104`	`}`
	`105`
	`106`	`/// <inheritdoc/>`
	`107`	`public IReadOnlyList<BaseItemDto> GetLatestItemList(InternalItemsQuery filter, CollectionType collectionType)`
	`108`	`{`
0	`109`	`ArgumentNullException.ThrowIfNull(filter);`
0	`110`	`PrepareFilterQuery(filter);`
	`111`
	`112`	`// Early exit if collection type is not supported`
0	`113`	`if (collectionType is not CollectionType.movies and not CollectionType.tvshows and not CollectionType.music and`
	`114`	`{`
0	`115`	`return [];`
	`116`	`}`
	`117`
0	`118`	`var limit = filter.Limit;`
0	`119`	`using var context = _dbProvider.CreateDbContext();`
	`120`
0	`121`	`var baseQuery = PrepareItemQuery(context, filter);`
0	`122`	`baseQuery = TranslateQuery(baseQuery, context, filter);`
	`123`
0	`124`	`if (collectionType is CollectionType.tvshows)`
	`125`	`{`
0	`126`	`return GetLatestTvShowItems(context, baseQuery, filter, limit);`
	`127`	`}`
	`128`
0	`129`	`if (collectionType is CollectionType.movies)`
	`130`	`{`
0	`131`	`return GetLatestMovieItems(context, baseQuery, filter, limit);`
	`132`	`}`
	`133`
0	`134`	`if (collectionType is CollectionType.unknown)`
	`135`	`{`
0	`136`	`var moviesQuery = baseQuery.Where(e => e.SeriesName == null);`
0	`137`	`var latestMovies = GetLatestMovieItems(context, moviesQuery, filter, limit);`
0	`138`	`var latestShows = GetLatestTvShowItems(context, baseQuery, filter, limit);`
	`139`
0	`140`	`return latestMovies.Concat(latestShows)`
0	`141`	`.OrderByDescending(dto => dto.DateCreated)`
0	`142`	`.ThenByDescending(dto => dto.Id)`
0	`143`	`.Take(limit ?? int.MaxValue)`
0	`144`	`.ToList();`
	`145`	`}`
	`146`
0	`147`	`var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum]!;`
	`148`	`IQueryable<BaseItemEntity> topAlbumsQuery;`
	`149`
	`150`	`// When the query is scoped to whole libraries, read the newest albums directly by their own TopParentId.`
0	`151`	`if (filter.TopParentIds.Length > 0)`
	`152`	`{`
0	`153`	`topAlbumsQuery = context.BaseItems.AsNoTracking()`
0	`154`	`.Where(album => album.Type == musicAlbumTypeName`
0	`155`	`&& !album.IsVirtualItem`
0	`156`	`&& album.TopParentId.HasValue)`
0	`157`	`.WhereOneOrMany(filter.TopParentIds, album => album.TopParentId!.Value);`
	`158`	`}`
	`159`	`else`
	`160`	`{`
	`161`	`// Fallback (e.g. AncestorIds-scoped callers): albums that are the parent of a matching track.`
0	`162`	`var albumIdsWithMatchingTrack = context.AncestorIds`
0	`163`	`.Join(baseQuery, ai => ai.ItemId, t => t.Id, (ai, _) => ai.ParentItemId);`
0	`164`	`topAlbumsQuery = context.BaseItems.AsNoTracking()`
0	`165`	`.Where(album => album.Type == musicAlbumTypeName)`
0	`166`	`.Where(album => albumIdsWithMatchingTrack.Contains(album.Id));`
	`167`	`}`
	`168`
	`169`	`// The album is what gets returned, and neither branch above reads it through the`
	`170`	`// user's filters, so its own parental restrictions have to be applied here: a`
	`171`	`// matching track does not make an album the user may not see visible.`
0	`172`	`var orderedAlbums = ApplyParentalRestrictions(context, topAlbumsQuery, filter)`
0	`173`	`.OrderByDescending(album => album.DateCreated)`
0	`174`	`.ThenByDescending(album => album.Id);`
	`175`
0	`176`	`var albumIdsQuery = limit.HasValue`
0	`177`	`? orderedAlbums.Take(limit.Value).Select(a => a.Id)`
0	`178`	`: orderedAlbums.Select(a => a.Id);`
	`179`
0	`180`	`return LoadLatestByIds(context, albumIdsQuery, filter);`
0	`181`	`}`
	`182`
	`183`	// Keeping idsQuery deferred lets EF emit `WHERE Id IN (<subquery>)`.
	`184`	`private IReadOnlyList<BaseItemDto> LoadLatestByIds(`
	`185`	`JellyfinDbContext context,`
	`186`	`IQueryable<Guid> idsQuery,`
	`187`	`InternalItemsQuery filter)`
	`188`	`{`
0	`189`	`var itemsQuery = ApplyNavigations(`
0	`190`	`context.BaseItems.AsNoTracking().Where(e => idsQuery.Contains(e.Id)),`
0	`191`	`filter);`
	`192`
0	`193`	`return itemsQuery`
0	`194`	`.OrderByDescending(e => e.DateCreated)`
0	`195`	`.ThenByDescending(e => e.Id)`
0	`196`	`.AsEnumerable()`
0	`197`	`.Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))`
0	`198`	`.Where(dto => dto != null)`
0	`199`	`.ToArray()!;`
	`200`	`}`
	`201`
	`202`	`private IReadOnlyList<BaseItemDto> LoadLatestByIds(`
	`203`	`JellyfinDbContext context,`
	`204`	`List<Guid> ids,`
	`205`	`InternalItemsQuery filter)`
	`206`	`{`
0	`207`	`if (ids.Count == 0)`
	`208`	`{`
0	`209`	`return [];`
	`210`	`}`
	`211`
0	`212`	`var itemsQuery = ApplyNavigations(`
0	`213`	`context.BaseItems.AsNoTracking().WhereOneOrMany(ids, e => e.Id),`
0	`214`	`filter);`
	`215`
0	`216`	`return itemsQuery`
0	`217`	`.OrderByDescending(e => e.DateCreated)`
0	`218`	`.ThenByDescending(e => e.Id)`
0	`219`	`.AsEnumerable()`
0	`220`	`.Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))`
0	`221`	`.Where(dto => dto != null)`
0	`222`	`.ToArray()!;`
	`223`	`}`
	`224`
	`225`	`/// <summary>`
	`226`	`/// Gets the latest movies, deduplicated so each movie only appears once.`
	`227`	`/// </summary>`
	`228`	`/// <param name="context">The database context.</param>`
	`229`	`/// <param name="baseQuery">The query to pull movies from, with filters already applied.</param>`
	`230`	`/// <param name="filter">The original query filter, used when loading the final items.</param>`
	`231`	`/// <param name="limit">How many items to return.</param>`
	`232`	`/// <returns>The latest movies, newest first.</returns>`
	`233`	`private IReadOnlyList<BaseItemDto> GetLatestMovieItems(`
	`234`	`JellyfinDbContext context,`
	`235`	`IQueryable<BaseItemEntity> baseQuery,`
	`236`	`InternalItemsQuery filter,`
	`237`	`int? limit)`
	`238`	`{`
	`239`	// Pick, per PresentationUniqueKey, the newest item; return the newest `limit` of those.
	`240`	`// Build up until limit by streaming through results and deduplicating on the fly.`
0	`241`	`var orderedIds = baseQuery`
0	`242`	`.Where(e => e.PresentationUniqueKey != null)`
0	`243`	`.OrderByDescending(e => e.DateCreated)`
0	`244`	`.ThenByDescending(e => e.Id)`
0	`245`	`.Select(e => new { e.Id, e.PresentationUniqueKey });`
	`246`
	`247`	`// DistinctBy and Take are lazy, so enumeration stops as soon as limit distinct keys are read.`
0	`248`	`var firstIds = orderedIds`
0	`249`	`.AsEnumerable()`
0	`250`	`.DistinctBy(row => row.PresentationUniqueKey)`
0	`251`	`.Select(row => row.Id)`
0	`252`	`.Take(limit ?? int.MaxValue)`
0	`253`	`.ToList();`
	`254`
0	`255`	`return LoadLatestByIds(context, firstIds, filter);`
	`256`	`}`
	`257`
	`258`	`/// <summary>`
	`259`	`/// Gets the latest TV show items with smart Season/Series container selection.`
	`260`	`/// </summary>`
	`261`	`/// <remarks>`
	`262`	`/// <para>`
	`263`	`/// This method implements intelligent container selection for TV shows in the "Latest" section.`
	`264`	`/// Instead of always showing individual episodes, it analyzes recent additions and may return`
	`265`	`/// a Season or Series container when multiple related episodes were recently added.`
	`266`	`/// </para>`
	`267`	`/// <para>`
	`268`	`/// The selection logic is:`
	`269`	`/// <list type="bullet">`
	`270`	`/// <item>If recent episodes span multiple seasons → return the Series</item>`
	`271`	`/// <item>If multiple recent episodes are from one season AND the series has multiple seasons → return the Seaso`
	`272`	`/// <item>If multiple recent episodes are from one season AND the series has only one season → return the Series`
	`273`	`/// <item>Otherwise → return the most recent Episode</item>`
	`274`	`/// </list>`
	`275`	`/// </para>`
	`276`	`/// </remarks>`
	`277`	`/// <param name="context">The database context.</param>`
	`278`	`/// <param name="baseQuery">The base query with filters already applied.</param>`
	`279`	`/// <param name="filter">The query filter options.</param>`
	`280`	`/// <param name="limit">Maximum number of items to return.</param>`
	`281`	`/// <returns>A list of BaseItemDto representing the latest TV content.</returns>`
	`282`	`private IReadOnlyList<BaseItemDto> GetLatestTvShowItems(JellyfinDbContext context, IQueryable<BaseItemEntity> baseQu`
	`283`	`{`
	`284`	`// Episodes added within this window are considered "recently added together"`
	`285`	`const double RecentAdditionWindowHours = 24.0;`
	`286`
	`287`	`// Step 1: Find the top N series with recently added content, ordered by most recent addition`
0	`288`	`var topSeriesWithDates = baseQuery`
0	`289`	`.Where(e => e.SeriesName != null)`
0	`290`	`.GroupBy(e => e.SeriesName)`
0	`291`	`.Select(g => new { SeriesName = g.Key!, MaxDate = g.Max(e => e.DateCreated) })`
0	`292`	`.OrderByDescending(g => g.MaxDate);`
	`293`
0	`294`	`if (limit.HasValue)`
	`295`	`{`
0	`296`	`topSeriesWithDates = topSeriesWithDates.Take(limit.Value).OrderByDescending(g => g.MaxDate);`
	`297`	`}`
	`298`
	`299`	`// Materialize series names and cutoff to avoid embedding the GroupBy+OrderBy`
	`300`	`// expression tree as a subquery inside the episode query.`
0	`301`	`var topSeriesData = topSeriesWithDates`
0	`302`	`.Select(g => new { g.SeriesName, g.MaxDate })`
0	`303`	`.ToList();`
0	`304`	`var topSeriesNames = topSeriesData.Select(g => g.SeriesName).ToList();`
	`305`
	`306`	`// Compute a global date cutoff: the oldest series' max date minus the window.`
	`307`	`// Episodes before this cutoff cannot be in any series' "recent additions" window,`
	`308`	`// so we can safely exclude them to avoid loading ancient episodes.`
0	`309`	`var globalCutoff = topSeriesData.Count > 0`
0	`310`	`? topSeriesData.Min(g => g.MaxDate)?.AddHours(-RecentAdditionWindowHours)`
0	`311`	`: null;`
	`312`
	`313`	`// Restrict to episodes of the top series, optionally bounded by the global cutoff.`
0	`314`	`var episodeQuery = baseQuery.Where(e => e.SeriesName != null && topSeriesNames.Contains(e.SeriesName));`
0	`315`	`if (globalCutoff is not null)`
	`316`	`{`
0	`317`	`episodeQuery = episodeQuery.Where(e => e.DateCreated >= globalCutoff);`
	`318`	`}`
	`319`
	`320`	`// Lightweight projection: only the columns needed for the in-memory analysis below.`
0	`321`	`var allEpisodes = episodeQuery`
0	`322`	`.OrderByDescending(e => e.DateCreated)`
0	`323`	`.ThenByDescending(e => e.Id)`
0	`324`	`.Select(e => new { e.Id, e.SeriesName, e.DateCreated, e.SeasonId, e.SeriesId })`
0	`325`	`.AsEnumerable();`
	`326`
	`327`	`// Collect all season/series IDs we'll need to look up for count information`
0	`328`	`var allSeasonIds = new HashSet<Guid>();`
0	`329`	`var allSeriesIds = new HashSet<Guid>();`
	`330`
	`331`	`// Analysis data for each series: recent episode count, season IDs, and the most recent episode ID`
0	`332`	`var analysisData = new List<(`
0	`333`	`int RecentEpisodeCount,`
0	`334`	`List<Guid> SeasonIds,`
0	`335`	`Guid? FirstRecentSeriesId,`
0	`336`	`DateTime MaxDate,`
0	`337`	`Guid MostRecentEpisodeId)>();`
	`338`
	`339`	`// Step 3: Analyze each series to identify recent additions within the time window`
0	`340`	`foreach (var group in allEpisodes.GroupBy(e => e.SeriesName))`
	`341`	`{`
0	`342`	`var episodes = group.ToList();`
0	`343`	`var mostRecentDate = episodes[0].DateCreated ?? DateTime.MinValue;`
0	`344`	`var recentCutoff = mostRecentDate.AddHours(-RecentAdditionWindowHours);`
	`345`
	`346`	`// Find episodes added within the recent window`
0	`347`	`var recentEpisodeCount = 0;`
0	`348`	`var seasonIdSet = new HashSet<Guid>();`
0	`349`	`Guid? firstRecentSeriesId = null;`
	`350`
0	`351`	`foreach (var ep in episodes)`
	`352`	`{`
0	`353`	`if (ep.DateCreated >= recentCutoff)`
	`354`	`{`
0	`355`	`recentEpisodeCount++;`
0	`356`	`if (ep.SeasonId.HasValue)`
	`357`	`{`
0	`358`	`seasonIdSet.Add(ep.SeasonId.Value);`
	`359`	`}`
	`360`
0	`361`	`firstRecentSeriesId ??= ep.SeriesId;`
	`362`	`}`
	`363`	`}`
	`364`
0	`365`	`var seasonIds = seasonIdSet.ToList();`
0	`366`	`analysisData.Add((recentEpisodeCount, seasonIds, firstRecentSeriesId, mostRecentDate, episodes[0].Id));`
	`367`
	`368`	`// Track all unique season/series IDs for batch lookups`
0	`369`	`foreach (var sid in seasonIds)`
	`370`	`{`
0	`371`	`allSeasonIds.Add(sid);`
	`372`	`}`
	`373`
0	`374`	`if (firstRecentSeriesId.HasValue)`
	`375`	`{`
0	`376`	`allSeriesIds.Add(firstRecentSeriesId.Value);`
	`377`	`}`
	`378`	`}`
	`379`
	`380`	`// Step 4: Batch fetch counts - episodes per season and seasons per series`
	`381`	`// These counts help determine whether to show Season or Series as the container`
0	`382`	`var episodeType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];`
0	`383`	`var seasonType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Season];`
0	`384`	`var seasonEpisodeCounts = allSeasonIds.Count > 0`
0	`385`	`? context.BaseItems`
0	`386`	`.AsNoTracking()`
0	`387`	`.Where(e => e.SeasonId.HasValue && allSeasonIds.Contains(e.SeasonId.Value) && e.Type == episodeType)`
0	`388`	`.GroupBy(e => e.SeasonId!.Value)`
0	`389`	`.Select(g => new { SeasonId = g.Key, Count = g.Count() })`
0	`390`	`.ToDictionary(x => x.SeasonId, x => x.Count)`
0	`391`	`: [];`
	`392`
0	`393`	`var seriesSeasonCounts = allSeriesIds.Count > 0`
0	`394`	`? context.BaseItems`
0	`395`	`.AsNoTracking()`
0	`396`	`.Where(e => e.SeriesId.HasValue && allSeriesIds.Contains(e.SeriesId.Value) && e.Type == seasonType)`
0	`397`	`.GroupBy(e => e.SeriesId!.Value)`
0	`398`	`.Select(g => new { SeriesId = g.Key, Count = g.Count() })`
0	`399`	`.ToDictionary(x => x.SeriesId, x => x.Count)`
0	`400`	`: [];`
	`401`
	`402`	`// Step 5: Apply the container selection logic for each series.`
	`403`	`// For each series, decide which entity best represents the recent additions:`
	`404`	`// - 1 episode added → show the Episode itself`
	`405`	`// - Multiple episodes in 1 season (multi-season series) → show the Season`
	`406`	`// - Multiple episodes in 1 season (single-season series) → show the Series`
	`407`	`// - Episodes across multiple seasons → show the Series`
0	`408`	`var entitiesToFetch = new HashSet<Guid>();`
0	`409`	`var seriesResults = new List<(Guid? SeasonId, Guid? SeriesId, DateTime MaxDate, Guid MostRecentEpisodeId)>(analy`
	`410`
0	`411`	`foreach (var (recentEpisodeCount, seasonIds, firstRecentSeriesId, maxDate, mostRecentEpisodeId) in analysisData)`
	`412`	`{`
0	`413`	`Guid? seasonId = null;`
0	`414`	`Guid? seriesId = null;`
	`415`
0	`416`	`if (seasonIds.Count == 1)`
	`417`	`{`
	`418`	`// All recent episodes are from a single season`
0	`419`	`var sid = seasonIds[0];`
0	`420`	`var totalEpisodes = seasonEpisodeCounts.GetValueOrDefault(sid, 0);`
0	`421`	`var totalSeasonsInSeries = firstRecentSeriesId.HasValue`
0	`422`	`? seriesSeasonCounts.GetValueOrDefault(firstRecentSeriesId.Value, 1)`
0	`423`	`: 1;`
	`424`
	`425`	`// Check if multiple episodes were added, or if all episodes in the season were added`
0	`426`	`var hasMultipleOrAllEpisodes = recentEpisodeCount > 1 \|\| recentEpisodeCount == totalEpisodes;`
	`427`
0	`428`	`if (totalSeasonsInSeries > 1 && hasMultipleOrAllEpisodes)`
	`429`	`{`
	`430`	`// Multi-season series with bulk additions: show the Season`
0	`431`	`seasonId = sid;`
0	`432`	`entitiesToFetch.Add(sid);`
	`433`	`}`
0	`434`	`else if (hasMultipleOrAllEpisodes && firstRecentSeriesId.HasValue)`
	`435`	`{`
	`436`	`// Single-season series with bulk additions: show the Series`
0	`437`	`seriesId = firstRecentSeriesId;`
0	`438`	`entitiesToFetch.Add(firstRecentSeriesId.Value);`
	`439`	`}`
	`440`
	`441`	`// Otherwise: single episode, will fall through to show the Episode`
	`442`	`}`
0	`443`	`else if (seasonIds.Count > 1 && firstRecentSeriesId.HasValue)`
	`444`	`{`
	`445`	`// Recent episodes span multiple seasons: show the Series`
0	`446`	`seriesId = firstRecentSeriesId;`
0	`447`	`entitiesToFetch.Add(seriesId!.Value);`
	`448`	`}`
	`449`
0	`450`	`if (seasonId is null && seriesId is null)`
	`451`	`{`
0	`452`	`entitiesToFetch.Add(mostRecentEpisodeId);`
	`453`	`}`
	`454`
0	`455`	`seriesResults.Add((seasonId, seriesId, maxDate, mostRecentEpisodeId));`
	`456`	`}`
	`457`
	`458`	`// Step 5b: A container is what gets returned, so it has to pass the user's access`
	`459`	`// filters on its own - a matching episode does not make a Season or Series the user`
	`460`	`// may not see visible. Containers that don't pass are replaced by their episode.`
0	`461`	`if (RequiresParentalRestrictions(filter) && entitiesToFetch.Count > 0)`
	`462`	`{`
0	`463`	`var allowedContainerIds = ApplyParentalRestrictions(`
0	`464`	`context,`
0	`465`	`context.BaseItems.AsNoTracking().Where(e => entitiesToFetch.Contains(e.Id)),`
0	`466`	`filter)`
0	`467`	`.Select(e => e.Id)`
0	`468`	`.ToHashSet();`
	`469`
0	`470`	`for (var i = 0; i < seriesResults.Count; i++)`
	`471`	`{`
0	`472`	`var (seasonId, seriesId, maxDate, mostRecentEpisodeId) = seriesResults[i];`
0	`473`	`if (seasonId.HasValue && !allowedContainerIds.Contains(seasonId.Value))`
	`474`	`{`
0	`475`	`seasonId = null;`
	`476`	`}`
	`477`
0	`478`	`if (seriesId.HasValue && !allowedContainerIds.Contains(seriesId.Value))`
	`479`	`{`
0	`480`	`seriesId = null;`
	`481`	`}`
	`482`
0	`483`	`if (seasonId is null && seriesId is null)`
	`484`	`{`
0	`485`	`entitiesToFetch.Add(mostRecentEpisodeId);`
	`486`	`}`
	`487`
0	`488`	`seriesResults[i] = (seasonId, seriesId, maxDate, mostRecentEpisodeId);`
	`489`	`}`
	`490`	`}`
	`491`
	`492`	`// Step 6: Fetch the Season/Series entities we decided to return`
0	`493`	`var entities = entitiesToFetch.Count > 0`
0	`494`	`? ApplyNavigations(`
0	`495`	`context.BaseItems.AsNoTracking().Where(e => entitiesToFetch.Contains(e.Id)),`
0	`496`	`filter)`
0	`497`	`.AsSingleQuery()`
0	`498`	`.ToDictionary(e => e.Id)`
0	`499`	`: [];`
	`500`
	`501`	`// Step 7: Build final results, preferring Season > Series > Episode.`
	`502`	`// All needed entities are already fetched in step 6 with navigation properties.`
0	`503`	`var results = new List<(BaseItemEntity Entity, DateTime MaxDate)>(seriesResults.Count);`
0	`504`	`foreach (var (seasonId, seriesId, maxDate, mostRecentEpisodeId) in seriesResults)`
	`505`	`{`
0	`506`	`if (seasonId.HasValue && entities.TryGetValue(seasonId.Value, out var seasonEntity))`
	`507`	`{`
0	`508`	`results.Add((seasonEntity, maxDate));`
0	`509`	`continue;`
	`510`	`}`
	`511`
0	`512`	`if (seriesId.HasValue && entities.TryGetValue(seriesId.Value, out var seriesEntity))`
	`513`	`{`
0	`514`	`results.Add((seriesEntity, maxDate));`
0	`515`	`continue;`
	`516`	`}`
	`517`
0	`518`	`if (entities.TryGetValue(mostRecentEpisodeId, out var episodeEntity))`
	`519`	`{`
0	`520`	`results.Add((episodeEntity, maxDate));`
	`521`	`}`
	`522`	`}`
	`523`
0	`524`	`var finalResults = results`
0	`525`	`.OrderByDescending(r => r.MaxDate)`
0	`526`	`.ThenByDescending(r => r.Entity.Id);`
	`527`
0	`528`	`if (limit.HasValue)`
	`529`	`{`
0	`530`	`finalResults = finalResults`
0	`531`	`.Take(limit.Value)`
0	`532`	`.OrderByDescending(r => r.MaxDate)`
0	`533`	`.ThenByDescending(r => r.Entity.Id);`
	`534`	`}`
	`535`
0	`536`	`return finalResults`
0	`537`	`.Select(r => DeserializeBaseItem(r.Entity, filter.SkipDeserialization))`
0	`538`	`.Where(dto => dto is not null)`
0	`539`	`.ToArray()!;`
	`540`	`}`
	`541`
	`542`	`/// <inheritdoc/>`
	`543`	`public async Task<bool> ItemExistsAsync(Guid id)`
	`544`	`{`
61	`545`	`var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);`
61	`546`	`await using (dbContext.ConfigureAwait(false))`
	`547`	`{`
61	`548`	`return await dbContext.BaseItems.AnyAsync(f => f.Id == id).ConfigureAwait(false);`
	`549`	`}`
61	`550`	`}`
	`551`
	`552`	`/// <inheritdoc />`
	`553`	`public BaseItemDto? RetrieveItem(Guid id)`
	`554`	`{`
110	`555`	`if (id.IsEmpty())`
	`556`	`{`
0	`557`	`throw new ArgumentException("Guid can't be empty", nameof(id));`
	`558`	`}`
	`559`
110	`560`	`using var context = _dbProvider.CreateDbContext();`
110	`561`	`var dbQuery = PrepareItemQuery(context, new()`
110	`562`	`{`
110	`563`	`DtoOptions = new()`
110	`564`	`{`
110	`565`	`EnableImages = true`
110	`566`	`}`
110	`567`	`});`
110	`568`	`dbQuery = dbQuery.Include(e => e.TrailerTypes)`
110	`569`	`.Include(e => e.Provider)`
110	`570`	`.Include(e => e.LockedFields)`
110	`571`	`.Include(e => e.UserData)`
110	`572`	`.Include(e => e.Images)`
110	`573`	`.Include(e => e.LinkedChildEntities)`
110	`574`	`.AsSingleQuery();`
	`575`
110	`576`	`var item = dbQuery.FirstOrDefault(e => e.Id == id);`
110	`577`	`if (item is null)`
	`578`	`{`
110	`579`	`return null;`
	`580`	`}`
	`581`
0	`582`	`return DeserializeBaseItem(item);`
110	`583`	`}`
	`584`
	`585`	`/// <inheritdoc />`
	`586`	`public bool GetIsPlayed(User user, Guid id, bool recursive)`
	`587`	`{`
2	`588`	`using var dbContext = _dbProvider.CreateDbContext();`
	`589`
2	`590`	`if (recursive)`
	`591`	`{`
2	`592`	`var descendantIds = DescendantQueryHelper.GetAllDescendantIds(dbContext, id);`
	`593`
2	`594`	`return dbContext.BaseItems`
2	`595`	`.Where(e => descendantIds.Contains(e.Id) && !e.IsFolder && !e.IsVirtualItem)`
2	`596`	`.All(BuildLeafIsPlayedFilter(dbContext, user.Id));`
	`597`	`}`
	`598`
0	`599`	`return dbContext.BaseItems.Where(e => e.ParentId == id).All(BuildLeafIsPlayedFilter(dbContext, user.Id));`
2	`600`	`}`
	`601`
	`602`	`/// <inheritdoc />`
	`603`	`public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter)`
	`604`	`{`
1	`605`	`ArgumentNullException.ThrowIfNull(filter);`
1	`606`	`PrepareFilterQuery(filter);`
	`607`
1	`608`	`using var context = _dbProvider.CreateDbContext();`
1	`609`	`var baseQuery = PrepareItemQuery(context, filter);`
1	`610`	`baseQuery = TranslateQuery(baseQuery, context, filter);`
	`611`
1	`612`	`var matchingItemIds = baseQuery.Select(e => e.Id);`
	`613`
1	`614`	`var years = baseQuery`
1	`615`	`.Where(e => e.ProductionYear != null && e.ProductionYear > 0)`
1	`616`	`.Select(e => e.ProductionYear!.Value)`
1	`617`	`.Distinct()`
1	`618`	`.OrderBy(y => y)`
1	`619`	`.ToArray();`
	`620`
1	`621`	`var officialRatings = baseQuery`
1	`622`	`.Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)`
1	`623`	`.Select(e => e.OfficialRating!)`
1	`624`	`.Distinct()`
1	`625`	`.OrderBy(r => r)`
1	`626`	`.ToArray();`
	`627`
1	`628`	`var tags = context.ItemValuesMap`
1	`629`	`.Join(`
1	`630`	`context.ItemValues,`
1	`631`	`ivm => ivm.ItemValueId,`
1	`632`	`iv => iv.ItemValueId,`
1	`633`	`(ivm, iv) => new { ivm.ItemId, iv.Type, iv.CleanValue, iv.Value })`
1	`634`	`.Where(iv => iv.Type == ItemValueType.Tags)`
1	`635`	`.Where(iv => matchingItemIds.Contains(iv.ItemId))`
1	`636`	`.GroupBy(iv => iv.CleanValue)`
1	`637`	`.Select(g => g.Min(iv => iv.Value))`
1	`638`	`.OrderBy(t => t)`
1	`639`	`.ToArray();`
	`640`
1	`641`	`var genres = context.ItemValuesMap`
1	`642`	`.Join(`
1	`643`	`context.ItemValues,`
1	`644`	`ivm => ivm.ItemValueId,`
1	`645`	`iv => iv.ItemValueId,`
1	`646`	`(ivm, iv) => new { ivm.ItemId, iv.Type, iv.CleanValue, iv.Value })`
1	`647`	`.Where(iv => iv.Type == ItemValueType.Genre)`
1	`648`	`.Where(iv => matchingItemIds.Contains(iv.ItemId))`
1	`649`	`.GroupBy(iv => iv.CleanValue)`
1	`650`	`.Select(g => g.Min(iv => iv.Value))`
1	`651`	`.OrderBy(g => g)`
1	`652`	`.ToArray();`
	`653`
1	`654`	`return new QueryFiltersLegacy`
1	`655`	`{`
1	`656`	`Years = years,`
1	`657`	`OfficialRatings = officialRatings,`
1	`658`	`Tags = tags,`
1	`659`	`Genres = genres`
1	`660`	`};`
1	`661`	`}`
	`662`	`}`

/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`	`{`
3	`28`	`private static readonly IReadOnlyList<char> SearchWildcardTerms = ['%', '_', '[', ']', '^'];`
	`29`
3	`30`	`private static readonly string ImdbProviderName = MetadataProvider.Imdb.ToString().ToLowerInvariant();`
3	`31`	`private static readonly string TmdbProviderName = MetadataProvider.Tmdb.ToString().ToLowerInvariant();`
3	`32`	`private static readonly string TvdbProviderName = MetadataProvider.Tvdb.ToString().ToLowerInvariant();`
	`33`
	`34`	`// A fresh expression per access: EF rejects a query tree that reuses one lambda parameter`
	`35`	`// instance across several lambdas, and this filter is combined into a tree more than once.`
38	`36`	`private static Expression<Func<BaseItemEntity, bool>> IsFolderFilter => e => e.IsFolder;`
	`37`
	`38`	`// Shared by the isPlayed filter and the IsPlayed/IsUnplayed ordering so the two cannot disagree.`
	`39`	`private Expression<Func<BaseItemEntity, bool>> BuildIsPlayedFilter(JellyfinDbContext context, User user)`
	`40`	`{`
	`41`	`// Folders (Series, Seasons, BoxSets, albums, ...) carry no played state of their own and count`
	`42`	`// as played once no descendant is left unplayed.`
17	`43`	`var unplayedLeafItems = GetAccessFilteredLeafItemsQuery(context, user)`
17	`44`	`.Where(BuildLeafIsPlayedFilter(context, user.Id).Not());`
	`45`
17	`46`	`return IsFolderFilter.And(BuildHasDescendantFilter(context, unplayedLeafItems).Not())`
17	`47`	`.Or(IsFolderFilter.Not().And(BuildLeafIsPlayedFilter(context, user.Id)));`
	`48`	`}`
	`49`
	`50`	`private static Expression<Func<BaseItemEntity, bool>> BuildLeafIsPlayedFilter(JellyfinDbContext context, Guid userId`
	`51`	`{`
40	`52`	`var playedItemIds = context.UserData`
40	`53`	`.Where(ud => ud.UserId == userId && ud.Played)`
40	`54`	`.Select(ud => ud.ItemId);`
	`55`
	`56`	`// The primaries of every version group holding a played row, whichever version carries it.`
40	`57`	`var playedGroupIds = context.BaseItems`
40	`58`	`.Where(v => v.PrimaryVersionId != null`
40	`59`	`&& context.UserData.Any(ud => ud.UserId == userId`
40	`60`	`&& ud.Played`
40	`61`	`&& (ud.ItemId == v.Id \|\| ud.ItemId == v.PrimaryVersionId)))`
40	`62`	`.Select(v => v.PrimaryVersionId!.Value);`
	`63`
40	`64`	`return e => playedItemIds.Contains(e.Id)`
40	`65`	`\|\| playedGroupIds.Contains(e.Id)`
40	`66`	`\|\| (e.PrimaryVersionId != null && playedGroupIds.Contains(e.PrimaryVersionId.Value));`
	`67`	`}`
	`68`
	`69`	`// "und" is the language filters' stand-in for a track that declares no language at all.`
	`70`	`private static string NormalizeLanguage(string language)`
5	`71`	`=> string.Equals(language, "und", StringComparison.OrdinalIgnoreCase) ? "und" : language;`
	`72`
	`73`	`// The primary versions whose alternate version satisfies a dimension bound. Anchored on`
	`74`	`// PrimaryVersionId so the filtered index carries it rather than a scan of every item.`
	`75`	`private static IQueryable<Guid> VersionsMatchingDimension(JellyfinDbContext context, Expression<Func<BaseItemEntity,`
30	`76`	`=> context.BaseItems`
30	`77`	`.Where(v => v.PrimaryVersionId != null)`
30	`78`	`.Where(bound)`
30	`79`	`.Select(v => v.PrimaryVersionId!.Value);`
	`80`
	`81`	`/// <inheritdoc />`
	`82`	`public IQueryable<BaseItemEntity> TranslateQuery(`
	`83`	`IQueryable<BaseItemEntity> baseQuery,`
	`84`	`JellyfinDbContext context,`
	`85`	`InternalItemsQuery filter)`
	`86`	`{`
	`87`	`const int HDWidth = 1200;`
	`88`	`const int UHDWidth = 3800;`
	`89`	`const int UHDHeight = 2100;`
	`90`
802	`91`	`var minWidth = filter.MinWidth;`
802	`92`	`var maxWidth = filter.MaxWidth;`
802	`93`	`var now = DateTime.UtcNow;`
	`94`
802	`95`	`if (filter.IsHD.HasValue \|\| filter.Is4K.HasValue)`
	`96`	`{`
8	`97`	`bool includeSD = false;`
8	`98`	`bool includeHD = false;`
8	`99`	`bool include4K = false;`
	`100`
8	`101`	`if (filter.IsHD.HasValue && !filter.IsHD.Value)`
	`102`	`{`
3	`103`	`includeSD = true;`
	`104`	`}`
	`105`
8	`106`	`if (filter.IsHD.HasValue && filter.IsHD.Value)`
	`107`	`{`
2	`108`	`includeHD = true;`
	`109`	`}`
	`110`
8	`111`	`if (filter.Is4K.HasValue && filter.Is4K.Value)`
	`112`	`{`
3	`113`	`include4K = true;`
	`114`	`}`
	`115`
	`116`	`// A 4K remux of an SD primary is a version of the same item, so the bucket a caller filters`
	`117`	`// on is the best any of the item's versions offers, not just the primary file's. Three sets,`
	`118`	`// because a bucket is as much about what the version group does not have as what it does, and`
	`119`	`// because an unprobed primary can still be placed by a version that does carry dimensions.`
	`120`	`// The filtered PrimaryVersionId index keeps all three to the few items that have versions.`
8	`121`	`var versionsSd = VersionsMatchingDimension(context, v => v.Width > 0 && v.Width < HDWidth);`
8	`122`	`var versionsHd = VersionsMatchingDimension(context, v => v.Width >= HDWidth);`
8	`123`	`var versions4K = VersionsMatchingDimension(context, v => v.Width >= UHDWidth \|\| v.Height >= UHDHeight);`
	`124`
	`125`	`// Only the SD test needs the Width > 0 guard against a row with no dimensions: such a row`
	`126`	`// cannot reach the HD or 4K bound anyway, and EF lowers the HD bucket's negated "not itself`
	`127`	`// 4K" guard to CASE WHEN ... THEN 0 ELSE 1, which already reads unknown as not 4K rather`
	`128`	`// than propagating a null. Folders (Series, BoxSets) answer on their descendants, bucketed`
	`129`	`// exactly as a top-level item is so that the two cannot disagree; the navigation properties`
	`130`	`// (a.Item, lc.Child) give EXISTS + JOIN rather than nested IN (SELECT ...).`
8	`131`	`baseQuery = baseQuery.Where(e =>`
8	`132`	`(!e.IsFolder`
8	`133`	`&& ((includeSD`
8	`134`	`&& ((e.Width > 0 && e.Width < HDWidth) \|\| versionsSd.Contains(e.Id))`
8	`135`	`&& !versionsHd.Contains(e.Id)`
8	`136`	`&& !versions4K.Contains(e.Id))`
8	`137`	`\|\| (includeHD`
8	`138`	`&& (e.Width >= HDWidth \|\| versionsHd.Contains(e.Id))`
8	`139`	`&& !(e.Width >= UHDWidth \|\| e.Height >= UHDHeight)`
8	`140`	`&& !versions4K.Contains(e.Id))`
8	`141`	`\|\| (include4K`
8	`142`	`&& (e.Width >= UHDWidth \|\| e.Height >= UHDHeight \|\| versions4K.Contains(e.Id)))))`
8	`143`	`\|\| (e.IsFolder`
8	`144`	`&& (e.Children!.Any(a =>`
8	`145`	`(includeSD`
8	`146`	`&& ((a.Item.Width > 0 && a.Item.Width < HDWidth) \|\| versionsSd.Contains(a.ItemId))`
8	`147`	`&& !versionsHd.Contains(a.ItemId)`
8	`148`	`&& !versions4K.Contains(a.ItemId))`
8	`149`	`\|\| (includeHD`
8	`150`	`&& (a.Item.Width >= HDWidth \|\| versionsHd.Contains(a.ItemId))`
8	`151`	`&& !(a.Item.Width >= UHDWidth \|\| a.Item.Height >= UHDHeight)`
8	`152`	`&& !versions4K.Contains(a.ItemId))`
8	`153`	`\|\| (include4K`
8	`154`	`&& (a.Item.Width >= UHDWidth \|\| a.Item.Height >= UHDHeight \|\| versions4K.Contains(a.Item`
8	`155`	`\|\| context.LinkedChildren.Any(lc =>`
8	`156`	`lc.ParentId == e.Id`
8	`157`	`&& ((includeSD`
8	`158`	`&& ((lc.Child!.Width > 0 && lc.Child!.Width < HDWidth) \|\| versionsSd.Contains(lc.Chi`
8	`159`	`&& !versionsHd.Contains(lc.ChildId)`
8	`160`	`&& !versions4K.Contains(lc.ChildId))`
8	`161`	`\|\| (includeHD`
8	`162`	`&& (lc.Child!.Width >= HDWidth \|\| versionsHd.Contains(lc.ChildId))`
8	`163`	`&& !(lc.Child!.Width >= UHDWidth \|\| lc.Child!.Height >= UHDHeight)`
8	`164`	`&& !versions4K.Contains(lc.ChildId))`
8	`165`	`\|\| (include4K`
8	`166`	`&& (lc.Child!.Width >= UHDWidth \|\| lc.Child!.Height >= UHDHeight \|\| versions4K.Conta`
	`167`	`}`
	`168`
	`169`	`// Same reasoning as the resolution filter: a dimension bound is met if any version meets it.`
802	`170`	`if (minWidth.HasValue)`
	`171`	`{`
2	`172`	`var versionsWideEnough = VersionsMatchingDimension(context, v => v.Width >= minWidth);`
2	`173`	`baseQuery = baseQuery.Where(e => e.Width >= minWidth \|\| versionsWideEnough.Contains(e.Id));`
	`174`	`}`
	`175`
802	`176`	`if (filter.MinHeight.HasValue)`
	`177`	`{`
0	`178`	`var minHeight = filter.MinHeight;`
0	`179`	`var versionsTallEnough = VersionsMatchingDimension(context, v => v.Height >= minHeight);`
0	`180`	`baseQuery = baseQuery.Where(e => e.Height >= minHeight \|\| versionsTallEnough.Contains(e.Id));`
	`181`	`}`
	`182`
	`183`	`// An upper bound inverts that: it is met only if no version breaches it, since the item's`
	`184`	`// resolution is the best its version group offers.`
802	`185`	`if (maxWidth.HasValue)`
	`186`	`{`
2	`187`	`var versionsTooWide = VersionsMatchingDimension(context, v => v.Width > maxWidth);`
2	`188`	`baseQuery = baseQuery.Where(e => e.Width <= maxWidth && !versionsTooWide.Contains(e.Id));`
	`189`	`}`
	`190`
802	`191`	`if (filter.MaxHeight.HasValue)`
	`192`	`{`
2	`193`	`var maxHeight = filter.MaxHeight;`
2	`194`	`var versionsTooTall = VersionsMatchingDimension(context, v => v.Height > maxHeight);`
2	`195`	`baseQuery = baseQuery.Where(e => e.Height <= maxHeight && !versionsTooTall.Contains(e.Id));`
	`196`	`}`
	`197`
802	`198`	`if (filter.IsLocked.HasValue)`
	`199`	`{`
60	`200`	`baseQuery = baseQuery.Where(e => e.IsLocked == filter.IsLocked);`
	`201`	`}`
	`202`
802	`203`	`var tags = filter.Tags.ToList();`
802	`204`	`var excludeTags = filter.ExcludeTags.ToList();`
	`205`
802	`206`	`if (filter.IsMovie.HasValue)`
	`207`	`{`
6	`208`	`var shouldIncludeAllMovieTypes = filter.IsMovie.Value`
6	`209`	`&& (filter.IncludeItemTypes.Length == 0`
6	`210`	`\|\| filter.IncludeItemTypes.Contains(BaseItemKind.Movie)`
6	`211`	`\|\| filter.IncludeItemTypes.Contains(BaseItemKind.Trailer));`
	`212`
6	`213`	`if (!shouldIncludeAllMovieTypes)`
	`214`	`{`
0	`215`	`baseQuery = baseQuery.Where(e => e.IsMovie == filter.IsMovie.Value);`
	`216`	`}`
	`217`	`}`
	`218`
802	`219`	`if (filter.IsSeries.HasValue)`
	`220`	`{`
0	`221`	`baseQuery = baseQuery.Where(e => e.IsSeries == filter.IsSeries);`
	`222`	`}`
	`223`
802	`224`	`if (filter.IsSports.HasValue)`
	`225`	`{`
0	`226`	`if (filter.IsSports.Value)`
	`227`	`{`
0	`228`	`tags.Add("Sports");`
	`229`	`}`
	`230`	`else`
	`231`	`{`
0	`232`	`excludeTags.Add("Sports");`
	`233`	`}`
	`234`	`}`
	`235`
802	`236`	`if (filter.IsNews.HasValue)`
	`237`	`{`
0	`238`	`if (filter.IsNews.Value)`
	`239`	`{`
0	`240`	`tags.Add("News");`
	`241`	`}`
	`242`	`else`
	`243`	`{`
0	`244`	`excludeTags.Add("News");`
	`245`	`}`
	`246`	`}`
	`247`
802	`248`	`if (filter.IsKids.HasValue)`
	`249`	`{`
0	`250`	`if (filter.IsKids.Value)`
	`251`	`{`
0	`252`	`tags.Add("Kids");`
	`253`	`}`
	`254`	`else`
	`255`	`{`
0	`256`	`excludeTags.Add("Kids");`
	`257`	`}`
	`258`	`}`
	`259`
802	`260`	`if (!string.IsNullOrEmpty(filter.SearchTerm))`
	`261`	`{`
0	`262`	`var cleanedSearchTerm = filter.SearchTerm.GetCleanValue();`
0	`263`	`var originalSearchTerm = filter.SearchTerm;`
0	`264`	`if (SearchWildcardTerms.Any(f => cleanedSearchTerm.Contains(f)))`
	`265`	`{`
0	`266`	`cleanedSearchTerm = $"%{cleanedSearchTerm.Trim('%')}%";`
0	`267`	`var likeSearchTerm = $"%{originalSearchTerm.Trim('%')}%";`
0	`268`	`baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName!, cleanedSearchTerm) \|\| (e.OriginalTitle`
	`269`	`}`
	`270`	`else`
	`271`	`{`
0	`272`	`var likeSearchTerm = $"%{originalSearchTerm}%";`
0	`273`	`baseQuery = baseQuery.Where(e => e.CleanName!.Contains(cleanedSearchTerm) \|\| (e.OriginalTitle != null &&`
	`274`	`}`
	`275`	`}`
	`276`
802	`277`	`if (filter.IsFolder.HasValue)`
	`278`	`{`
27	`279`	`baseQuery = baseQuery.Where(e => e.IsFolder == filter.IsFolder);`
	`280`	`}`
	`281`
802	`282`	`var includeTypes = filter.IncludeItemTypes;`
	`283`
	`284`	`// Only specify excluded types if no included types are specified`
802	`285`	`if (filter.IncludeItemTypes.Length == 0)`
	`286`	`{`
457	`287`	`var excludeTypes = filter.ExcludeItemTypes;`
457	`288`	`if (excludeTypes.Length == 1)`
	`289`	`{`
0	`290`	`if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeTypes[0], out var excludeTypeName))`
	`291`	`{`
0	`292`	`baseQuery = baseQuery.Where(e => e.Type != excludeTypeName);`
	`293`	`}`
	`294`	`}`
457	`295`	`else if (excludeTypes.Length > 1)`
	`296`	`{`
0	`297`	`var excludeTypeName = new List<string>();`
0	`298`	`foreach (var excludeType in excludeTypes)`
	`299`	`{`
0	`300`	`if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeType, out var baseItemKindName))`
	`301`	`{`
0	`302`	`excludeTypeName.Add(baseItemKindName!);`
	`303`	`}`
	`304`	`}`
	`305`
0	`306`	`baseQuery = baseQuery.Where(e => !excludeTypeName.Contains(e.Type));`
	`307`	`}`
	`308`	`}`
	`309`	`else`
	`310`	`{`
345	`311`	`string[] types = includeTypes.Select(f => _itemTypeLookup.BaseItemKindNames.GetValueOrDefault(f)).Where(e =>`
345	`312`	`baseQuery = baseQuery.WhereOneOrMany(types, f => f.Type);`
	`313`	`}`
	`314`
802	`315`	`if (filter.ChannelIds.Count > 0)`
	`316`	`{`
0	`317`	`baseQuery = baseQuery.Where(e => e.ChannelId != null && filter.ChannelIds.Contains(e.ChannelId.Value));`
	`318`	`}`
	`319`
802	`320`	`if (!filter.ParentId.IsEmpty())`
	`321`	`{`
264	`322`	`baseQuery = baseQuery.Where(e => e.ParentId!.Value == filter.ParentId);`
	`323`	`}`
	`324`
802	`325`	`if (!string.IsNullOrWhiteSpace(filter.Path))`
	`326`	`{`
0	`327`	`var pathToQuery = GetPathToSave(filter.Path);`
0	`328`	`baseQuery = baseQuery.Where(e => e.Path == pathToQuery);`
	`329`	`}`
	`330`
802	`331`	`if (!string.IsNullOrWhiteSpace(filter.PresentationUniqueKey))`
	`332`	`{`
0	`333`	`baseQuery = baseQuery.Where(e => e.PresentationUniqueKey == filter.PresentationUniqueKey);`
	`334`	`}`
	`335`
802	`336`	`if (filter.MinCommunityRating.HasValue)`
	`337`	`{`
0	`338`	`baseQuery = baseQuery.Where(e => e.CommunityRating >= filter.MinCommunityRating);`
	`339`	`}`
	`340`
802	`341`	`if (filter.MinIndexNumber.HasValue)`
	`342`	`{`
0	`343`	`baseQuery = baseQuery.Where(e => e.IndexNumber >= filter.MinIndexNumber);`
	`344`	`}`
	`345`
802	`346`	`if (filter.MinParentAndIndexNumber.HasValue)`
	`347`	`{`
0	`348`	`baseQuery = baseQuery`
0	`349`	`.Where(e => (e.ParentIndexNumber == filter.MinParentAndIndexNumber.Value.ParentIndexNumber && e.IndexNum`
	`350`	`}`
	`351`
802	`352`	`if (filter.MinDateCreated.HasValue)`
	`353`	`{`
0	`354`	`baseQuery = baseQuery.Where(e => e.DateCreated >= filter.MinDateCreated);`
	`355`	`}`
	`356`
802	`357`	`if (filter.MinDateLastSaved.HasValue)`
	`358`	`{`
0	`359`	`baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSaved.Value`
	`360`	`}`
	`361`
802	`362`	`if (filter.MinDateLastSavedForUser.HasValue)`
	`363`	`{`
0	`364`	`baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSavedForUse`
	`365`	`}`
	`366`
802	`367`	`if (filter.IndexNumber.HasValue)`
	`368`	`{`
0	`369`	`baseQuery = baseQuery.Where(e => e.IndexNumber == filter.IndexNumber.Value);`
	`370`	`}`
	`371`
802	`372`	`if (filter.ParentIndexNumber.HasValue)`
	`373`	`{`
0	`374`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber == filter.ParentIndexNumber.Value);`
	`375`	`}`
	`376`
802	`377`	`if (filter.ParentIndexNumberNotEquals.HasValue)`
	`378`	`{`
0	`379`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber != filter.ParentIndexNumberNotEquals.Value \|\| e.ParentI`
	`380`	`}`
	`381`
802	`382`	`var minEndDate = filter.MinEndDate;`
802	`383`	`var maxEndDate = filter.MaxEndDate;`
	`384`
802	`385`	`if (filter.HasAired.HasValue)`
	`386`	`{`
0	`387`	`if (filter.HasAired.Value)`
	`388`	`{`
0	`389`	`maxEndDate = DateTime.UtcNow;`
	`390`	`}`
	`391`	`else`
	`392`	`{`
0	`393`	`minEndDate = DateTime.UtcNow;`
	`394`	`}`
	`395`	`}`
	`396`
802	`397`	`if (minEndDate.HasValue)`
	`398`	`{`
0	`399`	`baseQuery = baseQuery.Where(e => e.EndDate >= minEndDate);`
	`400`	`}`
	`401`
802	`402`	`if (maxEndDate.HasValue)`
	`403`	`{`
0	`404`	`baseQuery = baseQuery.Where(e => e.EndDate <= maxEndDate);`
	`405`	`}`
	`406`
802	`407`	`if (filter.MinStartDate.HasValue)`
	`408`	`{`
0	`409`	`baseQuery = baseQuery.Where(e => e.StartDate >= filter.MinStartDate.Value);`
	`410`	`}`
	`411`
802	`412`	`if (filter.MaxStartDate.HasValue)`
	`413`	`{`
0	`414`	`baseQuery = baseQuery.Where(e => e.StartDate <= filter.MaxStartDate.Value);`
	`415`	`}`
	`416`
802	`417`	`if (filter.MinPremiereDate.HasValue)`
	`418`	`{`
0	`419`	`baseQuery = baseQuery.Where(e => e.PremiereDate >= filter.MinPremiereDate.Value);`
	`420`	`}`
	`421`
802	`422`	`if (filter.MaxPremiereDate.HasValue)`
	`423`	`{`
0	`424`	`baseQuery = baseQuery.Where(e => e.PremiereDate <= filter.MaxPremiereDate.Value);`
	`425`	`}`
	`426`
802	`427`	`if (filter.TrailerTypes.Length > 0)`
	`428`	`{`
0	`429`	`var trailerTypes = filter.TrailerTypes.Select(e => (int)e).ToArray();`
0	`430`	`baseQuery = baseQuery.Where(e => e.TrailerTypes!.Any(w => trailerTypes.Contains(w.Id)));`
	`431`	`}`
	`432`
802	`433`	`if (filter.IsAiring.HasValue)`
	`434`	`{`
0	`435`	`if (filter.IsAiring.Value)`
	`436`	`{`
0	`437`	`baseQuery = baseQuery.Where(e => e.StartDate <= now && e.EndDate >= now);`
	`438`	`}`
	`439`	`else`
	`440`	`{`
0	`441`	`baseQuery = baseQuery.Where(e => e.StartDate > now \|\| e.EndDate < now);`
	`442`	`}`
	`443`	`}`
	`444`
802	`445`	`if (filter.PersonIds.Length > 0)`
	`446`	`{`
0	`447`	`var peopleEntityIds = context.BaseItems`
0	`448`	`.WhereOneOrMany(filter.PersonIds, b => b.Id)`
0	`449`	`.Join(`
0	`450`	`context.Peoples,`
0	`451`	`b => b.Name,`
0	`452`	`p => p.Name,`
0	`453`	`(b, p) => p.Id);`
	`454`
0	`455`	`var personTypes = filter.PersonTypes;`
0	`456`	`baseQuery = baseQuery`
0	`457`	`.Where(e => context.PeopleBaseItemMap`
0	`458`	`.Any(m => m.ItemId == e.Id && peopleEntityIds.Contains(m.PeopleId) && (personTypes.Length == 0 \|\| pe`
	`459`	`}`
	`460`
802	`461`	`if (!string.IsNullOrWhiteSpace(filter.Person))`
	`462`	`{`
0	`463`	`var personTypes = filter.PersonTypes;`
0	`464`	`baseQuery = baseQuery.Where(e => e.Peoples!.Any(f => f.People.Name == filter.Person && (personTypes.Length =`
	`465`	`}`
	`466`
802	`467`	`if (!string.IsNullOrWhiteSpace(filter.ExternalSeriesId))`
	`468`	`{`
0	`469`	`baseQuery = baseQuery.Where(e => e.ExternalSeriesId == filter.ExternalSeriesId);`
	`470`	`}`
	`471`
802	`472`	`if (!string.IsNullOrWhiteSpace(filter.ExternalId))`
	`473`	`{`
0	`474`	`baseQuery = baseQuery.Where(e => e.ExternalId == filter.ExternalId);`
	`475`	`}`
	`476`
802	`477`	`if (!string.IsNullOrWhiteSpace(filter.Name))`
	`478`	`{`
8	`479`	`var cleanName = filter.Name.GetCleanValue();`
8	`480`	`baseQuery = baseQuery.Where(e => e.CleanName == cleanName);`
	`481`	`}`
	`482`
802	`483`	`var nameContains = filter.NameContains;`
802	`484`	`if (!string.IsNullOrWhiteSpace(nameContains))`
	`485`	`{`
0	`486`	`if (SearchWildcardTerms.Any(f => nameContains.Contains(f)))`
	`487`	`{`
0	`488`	`nameContains = $"%{nameContains.Trim('%')}%";`
0	`489`	`baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName, nameContains) \|\| EF.Functions.Like(e.Ori`
	`490`	`}`
	`491`	`else`
	`492`	`{`
0	`493`	`var likeNameContains = $"%{nameContains}%";`
0	`494`	`baseQuery = baseQuery.Where(e =>`
0	`495`	`e.CleanName!.Contains(nameContains)`
0	`496`	`\|\| EF.Functions.Like(e.OriginalTitle, likeNameContains));`
	`497`	`}`
	`498`	`}`
	`499`
	`500`	`// When box set collapsing is active, defer name-range filters to after the collapse.`
	`501`	`// Otherwise, items are filtered by their own name but then collapsed into a BoxSet`
	`502`	`// whose name may fall in a different range (e.g. "21 Jump Street" is under "#"`
	`503`	`// but its BoxSet "Jump Street Collection" should appear under "J").`
802	`504`	`if (filter.CollapseBoxSetItems != true)`
	`505`	`{`
802	`506`	`baseQuery = ApplyNameFilters(baseQuery, filter);`
	`507`	`}`
	`508`
802	`509`	`if (filter.ImageTypes.Length > 0)`
	`510`	`{`
163	`511`	`var imgTypes = filter.ImageTypes.Select(e => (ImageInfoImageType)e).ToArray();`
163	`512`	`baseQuery = baseQuery.Where(e => e.Images!.Any(w => imgTypes.Contains(w.ImageType)));`
	`513`	`}`
	`514`
802	`515`	`if (filter.IsLiked.HasValue)`
	`516`	`{`
0	`517`	`var likedIds = context.UserData`
0	`518`	`.Where(ud => ud.UserId == filter.User!.Id && ud.Rating >= UserItemData.MinLikeValue)`
0	`519`	`.Select(ud => ud.ItemId);`
	`520`
0	`521`	`baseQuery = filter.IsLiked.Value`
0	`522`	`? baseQuery.Where(e => likedIds.Contains(e.Id))`
0	`523`	`: baseQuery.Where(e => !likedIds.Contains(e.Id));`
	`524`	`}`
	`525`
802	`526`	`if (filter.IsFavoriteOrLiked.HasValue \|\| filter.IsFavorite.HasValue)`
	`527`	`{`
0	`528`	`var favoriteIds = context.UserData`
0	`529`	`.Where(ud => ud.UserId == filter.User!.Id && ud.IsFavorite)`
0	`530`	`.Select(ud => ud.ItemId);`
	`531`
0	`532`	`if (filter.IsFavoriteOrLiked.HasValue)`
	`533`	`{`
0	`534`	`baseQuery = filter.IsFavoriteOrLiked.Value`
0	`535`	`? baseQuery.Where(e => favoriteIds.Contains(e.Id))`
0	`536`	`: baseQuery.Where(e => !favoriteIds.Contains(e.Id));`
	`537`	`}`
	`538`
0	`539`	`if (filter.IsFavorite.HasValue)`
	`540`	`{`
0	`541`	`baseQuery = filter.IsFavorite.Value`
0	`542`	`? baseQuery.Where(e => favoriteIds.Contains(e.Id))`
0	`543`	`: baseQuery.Where(e => !favoriteIds.Contains(e.Id));`
	`544`	`}`
	`545`	`}`
	`546`
802	`547`	`if (filter.IsPlayed.HasValue)`
	`548`	`{`
11	`549`	`var isPlayedFilter = BuildIsPlayedFilter(context, filter.User!);`
	`550`
11	`551`	`baseQuery = baseQuery.Where(filter.IsPlayed.Value ? isPlayedFilter : isPlayedFilter.Not());`
	`552`	`}`
	`553`
802	`554`	`if (filter.IsResumable.HasValue)`
	`555`	`{`
2	`556`	`var userId = filter.User!.Id;`
2	`557`	`var isResumable = filter.IsResumable.Value;`
	`558`
	`559`	`// In-progress user data rows; alternate versions track their own progress.`
2	`560`	`var inProgress = context.UserData`
2	`561`	`.Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0);`
	`562`
	`563`	`// Series and Seasons are resumable when a descendant is in progress, or when they hold both`
	`564`	`// played and unplayed descendants (partially watched). Alternate versions keep their own`
	`565`	`// progress, so they count towards the in-progress check but not towards the played/unplayed one.`
2	`566`	`var leafItems = GetAccessFilteredLeafItemsQuery(context, filter.User!);`
2	`567`	`var inProgressLeafItems = GetAccessFilteredLeafItemsQuery(context, filter.User!, includeOwnedItems: true)`
2	`568`	`.Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0));`
	`569`
	`570`	`// Every other folder kind is a container rather than one continuous piece of media`
2	`571`	`var resumableFolderTypes = _resumableFolderKinds`
2	`572`	`.Select(kind => _itemTypeLookup.BaseItemKindNames.GetValueOrDefault(kind))`
2	`573`	`.ToArray();`
2	`574`	`var folderIsResumableFilter = IsFolderFilter.And(e => resumableFolderTypes.Contains(e.Type))`
2	`575`	`.And(BuildHasDescendantFilter(context, inProgressLeafItems)`
2	`576`	`.Or(BuildHasDescendantFilter(context, leafItems.Where(BuildLeafIsPlayedFilter(context, userId)))`
2	`577`	`.And(BuildHasDescendantFilter(context, leafItems.Where(BuildLeafIsPlayedFilter(context, userId).`
	`578`
2	`579`	`if (isResumable)`
	`580`	`{`
	`581`	`// Resume queries surface the version that was actually played, which may be an alternate.`
	`582`	`// Match each version on its own progress rather than coalescing onto the primary.`
2	`583`	`var inProgressIds = inProgress.Select(ud => ud.ItemId);`
	`584`
2	`585`	`baseQuery = baseQuery.Where(folderIsResumableFilter`
2	`586`	`.Or(IsFolderFilter.Not().And(e => inProgressIds.Contains(e.Id))));`
	`587`
	`588`	`// When several versions of the same item are in progress, keep only the most recently played one, use i`
	`589`	`// Only in-progress siblings can eliminate a candidate: a version without progress has a NULL max LastPl`
	`590`	`// which is never greater and never ties. Restricting the sibling scan to the in-progress set keeps this`
	`591`	`// the user's Continue Watching count instead of forcing a full BaseItems scan (COALESCE keys are non-in`
	`592`	`// Items in no version group at all have no sibling that could eliminate them, so short-circuit the scan`
2	`593`	`baseQuery = baseQuery.Where(e => e.IsFolder`
2	`594`	`\|\| (e.PrimaryVersionId == null && !context.BaseItems.Any(a => a.PrimaryVersionId == e.Id))`
2	`595`	`\|\| !context.BaseItems`
2	`596`	`.Where(s => s.Id != e.Id`
2	`597`	`&& inProgressIds.Contains(s.Id)`
2	`598`	`&& (s.PrimaryVersionId ?? s.Id) == (e.PrimaryVersionId ?? e.Id))`
2	`599`	`.Any(s =>`
2	`600`	`inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)`
2	`601`	`> inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)`
2	`602`	`\|\| (inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)`
2	`603`	`== inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)`
2	`604`	`&& s.Id.CompareTo(e.Id) < 0)));`
	`605`	`}`
	`606`	`else`
	`607`	`{`
	`608`	`// Not-resumable queries operate on primaries only.`
0	`609`	`var resumableMovieIds = inProgress`
0	`610`	`.Join(context.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);`
	`611`
0	`612`	`baseQuery = baseQuery.Where(IsFolderFilter.And(folderIsResumableFilter.Not())`
0	`613`	`.Or(IsFolderFilter.Not().And(e => !resumableMovieIds.Contains(e.Id))));`
	`614`	`}`
	`615`	`}`
	`616`
802	`617`	`if (filter.ArtistIds.Length > 0)`
	`618`	`{`
0	`619`	`baseQuery = baseQuery.WhereReferencedItem(context, [ItemValueType.Artist, ItemValueType.AlbumArtist], filter`
	`620`	`}`
	`621`
802	`622`	`if (filter.AlbumArtistIds.Length > 0)`
	`623`	`{`
0	`624`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.AlbumArtist, filter.AlbumArtistIds);`
	`625`	`}`
	`626`
802	`627`	`if (filter.ContributingArtistIds.Length > 0)`
	`628`	`{`
0	`629`	`var contributingNames = context.BaseItems`
0	`630`	`.Where(b => filter.ContributingArtistIds.Contains(b.Id))`
0	`631`	`.Select(b => b.CleanName);`
	`632`
0	`633`	`baseQuery = baseQuery.Where(e =>`
0	`634`	`e.ItemValues!.Any(ivm =>`
0	`635`	`ivm.ItemValue.Type == ItemValueType.Artist &&`
0	`636`	`contributingNames.Contains(ivm.ItemValue.CleanValue))`
0	`637`	`&&`
0	`638`	`!e.ItemValues!.Any(ivm =>`
0	`639`	`ivm.ItemValue.Type == ItemValueType.AlbumArtist &&`
0	`640`	`contributingNames.Contains(ivm.ItemValue.CleanValue)));`
	`641`	`}`
	`642`
802	`643`	`if (filter.AlbumIds.Length > 0)`
	`644`	`{`
0	`645`	`baseQuery = baseQuery.Where(e => e.ParentId.HasValue && filter.AlbumIds.Contains(e.ParentId.Value));`
	`646`	`}`
	`647`
802	`648`	`if (filter.ExcludeArtistIds.Length > 0)`
	`649`	`{`
0	`650`	`baseQuery = baseQuery.WhereReferencedItem(context, [ItemValueType.Artist, ItemValueType.AlbumArtist], filter`
	`651`	`}`
	`652`
802	`653`	`if (filter.GenreIds.Count > 0)`
	`654`	`{`
0	`655`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Genre, filter.GenreIds);`
	`656`	`}`
	`657`
802	`658`	`if (filter.Genres.Count > 0)`
	`659`	`{`
0	`660`	`var cleanGenres = filter.Genres.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValu`
0	`661`	`baseQuery = baseQuery`
0	`662`	`.Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Genre).Any(clea`
	`663`	`}`
	`664`
802	`665`	`if (tags.Count > 0)`
	`666`	`{`
0	`667`	`var cleanValues = tags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, str`
0	`668`	`baseQuery = baseQuery`
0	`669`	`.Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clean`
	`670`	`}`
	`671`
802	`672`	`if (excludeTags.Count > 0)`
	`673`	`{`
0	`674`	`var cleanValues = excludeTags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueM`
0	`675`	`baseQuery = baseQuery`
0	`676`	`.Where(e => !e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clea`
	`677`	`}`
	`678`
802	`679`	`if (filter.StudioIds.Length > 0)`
	`680`	`{`
0	`681`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Studios, filter.StudioIds);`
	`682`	`}`
	`683`
802	`684`	`if (filter.OfficialRatings.Length > 0)`
	`685`	`{`
0	`686`	`var ratings = filter.OfficialRatings;`
0	`687`	`baseQuery = baseQuery.WhereItemOrDescendantMatches(context, e => ratings.Contains(e.OfficialRating));`
	`688`	`}`
	`689`
802	`690`	`Expression<Func<BaseItemEntity, bool>>? minParentalRatingFilter = null;`
802	`691`	`if (filter.MinParentalRating != null)`
	`692`	`{`
0	`693`	`var min = filter.MinParentalRating;`
0	`694`	`var minScore = min.Score;`
0	`695`	`var minSubScore = min.SubScore ?? 0;`
	`696`
0	`697`	`minParentalRatingFilter = e =>`
0	`698`	`e.InheritedParentalRatingValue == null \|\|`
0	`699`	`e.InheritedParentalRatingValue > minScore \|\|`
0	`700`	`(e.InheritedParentalRatingValue == minScore && (e.InheritedParentalRatingSubValue ?? 0) >= minSubScore);`
	`701`	`}`
	`702`
802	`703`	`Expression<Func<BaseItemEntity, bool>>? maxParentalRatingFilter = null;`
802	`704`	`if (filter.MaxParentalRating != null)`
	`705`	`{`
60	`706`	`maxParentalRatingFilter = BuildMaxParentalRatingFilter(context, filter.MaxParentalRating);`
	`707`	`}`
	`708`
802	`709`	`if (filter.HasParentalRating ?? false)`
	`710`	`{`
0	`711`	`if (minParentalRatingFilter != null)`
	`712`	`{`
0	`713`	`baseQuery = baseQuery.Where(minParentalRatingFilter);`
	`714`	`}`
	`715`
0	`716`	`if (maxParentalRatingFilter != null)`
	`717`	`{`
0	`718`	`baseQuery = baseQuery.Where(maxParentalRatingFilter);`
	`719`	`}`
	`720`	`}`
802	`721`	`else if (filter.BlockUnratedItems.Length > 0)`
	`722`	`{`
0	`723`	`var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();`
0	`724`	`Expression<Func<BaseItemEntity, bool>> unratedItemFilter = e => e.InheritedParentalRatingValue != null \|\| !u`
	`725`
0	`726`	`if (minParentalRatingFilter != null && maxParentalRatingFilter != null)`
	`727`	`{`
0	`728`	`baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter.And(maxParentalRatingFilter)))`
	`729`	`}`
0	`730`	`else if (minParentalRatingFilter != null)`
	`731`	`{`
0	`732`	`baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter));`
	`733`	`}`
0	`734`	`else if (maxParentalRatingFilter != null)`
	`735`	`{`
0	`736`	`baseQuery = baseQuery.Where(unratedItemFilter.And(maxParentalRatingFilter));`
	`737`	`}`
	`738`	`else`
	`739`	`{`
0	`740`	`baseQuery = baseQuery.Where(unratedItemFilter);`
	`741`	`}`
	`742`	`}`
802	`743`	`else if (minParentalRatingFilter != null \|\| maxParentalRatingFilter != null)`
	`744`	`{`
60	`745`	`if (minParentalRatingFilter != null)`
	`746`	`{`
0	`747`	`baseQuery = baseQuery.Where(minParentalRatingFilter);`
	`748`	`}`
	`749`
60	`750`	`if (maxParentalRatingFilter != null)`
	`751`	`{`
60	`752`	`baseQuery = baseQuery.Where(maxParentalRatingFilter);`
	`753`	`}`
	`754`	`}`
742	`755`	`else if (!filter.HasParentalRating ?? false)`
	`756`	`{`
0	`757`	`baseQuery = baseQuery`
0	`758`	`.Where(e => e.InheritedParentalRatingValue == null);`
	`759`	`}`
	`760`
802	`761`	`if (filter.HasOfficialRating.HasValue)`
	`762`	`{`
0	`763`	`Expression<Func<BaseItemEntity, bool>> hasRating =`
0	`764`	`e => e.OfficialRating != null && e.OfficialRating != string.Empty;`
	`765`
0	`766`	`baseQuery = filter.HasOfficialRating.Value`
0	`767`	`? baseQuery.WhereItemOrDescendantMatches(context, hasRating)`
0	`768`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasRating);`
	`769`	`}`
	`770`
802	`771`	`if (filter.HasOverview.HasValue)`
	`772`	`{`
0	`773`	`if (filter.HasOverview.Value)`
	`774`	`{`
0	`775`	`baseQuery = baseQuery`
0	`776`	`.Where(e => e.Overview != null && e.Overview != string.Empty);`
	`777`	`}`
	`778`	`else`
	`779`	`{`
0	`780`	`baseQuery = baseQuery`
0	`781`	`.Where(e => e.Overview == null \|\| e.Overview == string.Empty);`
	`782`	`}`
	`783`	`}`
	`784`
802	`785`	`if (filter.HasOwnerId.HasValue)`
	`786`	`{`
0	`787`	`if (filter.HasOwnerId.Value)`
	`788`	`{`
0	`789`	`baseQuery = baseQuery`
0	`790`	`.Where(e => e.OwnerId != null);`
	`791`	`}`
	`792`	`else`
	`793`	`{`
0	`794`	`baseQuery = baseQuery`
0	`795`	`.Where(e => e.OwnerId == null);`
	`796`	`}`
	`797`	`}`
802	`798`	`else if (filter.OwnerIds.Length == 0 && filter.ExtraTypes.Length == 0 && !filter.IncludeOwnedItems)`
	`799`	`{`
	`800`	`// Exclude owned non-extra items from general queries.`
	`801`	`// Extras (trailers, etc.) have OwnerId set but also have ExtraType set - keep those.`
766	`802`	`baseQuery = baseQuery.Where(e => e.OwnerId == null \|\| e.ExtraType != null);`
	`803`
	`804`	`// Alternate versions (PrimaryVersionId set) are normally hidden behind their primary, but`
	`805`	`// resume queries keep them so the actually-played version can surface instead of collapsing`
	`806`	`// onto the primary, and the library scan keeps them so a merged version is not mistaken for`
	`807`	`// a new item.`
766	`808`	`if (filter.IsResumable != true && !filter.IncludeAlternateVersions)`
	`809`	`{`
686	`810`	`baseQuery = ApplyAlternateVersionFiltering(context, baseQuery);`
	`811`	`}`
	`812`	`}`
	`813`
802	`814`	`if (filter.OwnerIds.Length > 0)`
	`815`	`{`
6	`816`	`baseQuery = baseQuery.Where(e => e.OwnerId != null && filter.OwnerIds.Contains(e.OwnerId.Value));`
	`817`	`}`
	`818`
802	`819`	`if (filter.ExtraTypes.Length > 0)`
	`820`	`{`
	`821`	`// Convert ExtraType enum to BaseItemExtraType enum via int cast (same underlying values)`
0	`822`	`var extraTypeValues = filter.ExtraTypes.Select(e => (BaseItemExtraType?)(int)e).ToArray();`
0	`823`	`baseQuery = baseQuery.Where(e => e.ExtraType != null && extraTypeValues.Contains(e.ExtraType));`
	`824`	`}`
	`825`
802	`826`	`if (!string.IsNullOrWhiteSpace(filter.HasNoAudioTrackWithLanguage))`
	`827`	`{`
3	`828`	`var lang = NormalizeLanguage(filter.HasNoAudioTrackWithLanguage);`
3	`829`	`var undetermined = string.Equals(lang, "und", StringComparison.Ordinal);`
3	`830`	`var criteria = new HasMediaStreamType(MediaStreamTypeEntity.Audio, lang);`
	`831`	`// A track only an alternate version carries still belongs to the item a caller sees, so the`
	`832`	`// item's own streams alone do not decide this. Same for every stream filter below.`
3	`833`	`var versionsWithAudio = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
3	`834`	`var foldersWithAudio = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
	`835`
3	`836`	`baseQuery = baseQuery`
3	`837`	`.Where(e =>`
3	`838`	`(!e.IsFolder`
3	`839`	`&& !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Audio`
3	`840`	`&& (ms.Language == lang \|\| (undetermined && string.IsNullOrEmpty(ms.Language))))`
3	`841`	`&& !versionsWithAudio.Contains(e.Id))`
3	`842`	`\|\| (e.IsFolder && !foldersWithAudio.Contains(e.Id)));`
	`843`	`}`
	`844`
802	`845`	`if (!string.IsNullOrWhiteSpace(filter.HasNoInternalSubtitleTrackWithLanguage))`
	`846`	`{`
0	`847`	`var lang = NormalizeLanguage(filter.HasNoInternalSubtitleTrackWithLanguage);`
0	`848`	`var undetermined = string.Equals(lang, "und", StringComparison.Ordinal);`
0	`849`	`var criteria = new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang, IsExternal: false);`
0	`850`	`var versionsWithSubtitles = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
0	`851`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
	`852`
0	`853`	`baseQuery = baseQuery`
0	`854`	`.Where(e =>`
0	`855`	`(!e.IsFolder`
0	`856`	`&& !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && !ms.IsExternal`
0	`857`	`&& (ms.Language == lang \|\| (undetermined && string.IsNullOrEmpty(ms.Language))))`
0	`858`	`&& !versionsWithSubtitles.Contains(e.Id))`
0	`859`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`860`	`}`
	`861`
802	`862`	`if (!string.IsNullOrWhiteSpace(filter.HasNoExternalSubtitleTrackWithLanguage))`
	`863`	`{`
0	`864`	`var lang = NormalizeLanguage(filter.HasNoExternalSubtitleTrackWithLanguage);`
0	`865`	`var undetermined = string.Equals(lang, "und", StringComparison.Ordinal);`
0	`866`	`var criteria = new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang, IsExternal: true);`
0	`867`	`var versionsWithSubtitles = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
0	`868`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
	`869`
0	`870`	`baseQuery = baseQuery`
0	`871`	`.Where(e =>`
0	`872`	`(!e.IsFolder`
0	`873`	`&& !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && ms.IsExternal`
0	`874`	`&& (ms.Language == lang \|\| (undetermined && string.IsNullOrEmpty(ms.Language))))`
0	`875`	`&& !versionsWithSubtitles.Contains(e.Id))`
0	`876`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`877`	`}`
	`878`
802	`879`	`if (!string.IsNullOrWhiteSpace(filter.HasNoSubtitleTrackWithLanguage))`
	`880`	`{`
2	`881`	`var lang = NormalizeLanguage(filter.HasNoSubtitleTrackWithLanguage);`
2	`882`	`var undetermined = string.Equals(lang, "und", StringComparison.Ordinal);`
2	`883`	`var criteria = new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang);`
2	`884`	`var versionsWithSubtitles = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
2	`885`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
	`886`
2	`887`	`baseQuery = baseQuery`
2	`888`	`.Where(e =>`
2	`889`	`(!e.IsFolder`
2	`890`	`&& !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle`
2	`891`	`&& (ms.Language == lang \|\| (undetermined && string.IsNullOrEmpty(ms.Language))))`
2	`892`	`&& !versionsWithSubtitles.Contains(e.Id))`
2	`893`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`894`	`}`
	`895`
802	`896`	`if (filter.HasSubtitles.HasValue)`
	`897`	`{`
6	`898`	`var hasSubtitles = filter.HasSubtitles.Value;`
6	`899`	`var criteria = new HasSubtitles();`
6	`900`	`var versionsWithSubtitles = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
6	`901`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
6	`902`	`if (hasSubtitles)`
	`903`	`{`
3	`904`	`baseQuery = baseQuery`
3	`905`	`.Where(e =>`
3	`906`	`(!e.IsFolder && (e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle)`
3	`907`	`\|\| versionsWithSubtitles.Contains(e.Id)))`
3	`908`	`\|\| (e.IsFolder && foldersWithSubtitles.Contains(e.Id)));`
	`909`	`}`
	`910`	`else`
	`911`	`{`
3	`912`	`baseQuery = baseQuery`
3	`913`	`.Where(e =>`
3	`914`	`(!e.IsFolder && !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle)`
3	`915`	`&& !versionsWithSubtitles.Contains(e.Id))`
3	`916`	`\|\| (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));`
	`917`	`}`
	`918`	`}`
	`919`
802	`920`	`if (filter.SubtitleLanguages.Count > 0)`
	`921`	`{`
4	`922`	`var criteria = new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, filter.SubtitleLanguages);`
4	`923`	`var versionsWithSubtitles = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
4	`924`	`var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
4	`925`	`baseQuery = baseQuery`
4	`926`	`.Where(e =>`
4	`927`	`(!e.IsFolder && (e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle`
4	`928`	`&& (filter.SubtitleLanguages.Contains(f.Language) \|\| (filter.SubtitleLanguages.Contains("und") &`
4	`929`	`\|\| versionsWithSubtitles.Contains(e.Id)))`
4	`930`	`\|\| (e.IsFolder && foldersWithSubtitles.Contains(e.Id)));`
	`931`	`}`
	`932`
802	`933`	`if (filter.AudioLanguages.Count > 0)`
	`934`	`{`
1	`935`	`var criteria = new HasMediaStreamType(MediaStreamTypeEntity.Audio, filter.AudioLanguages);`
1	`936`	`var versionsWithAudio = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
1	`937`	`var foldersWithAudio = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
1	`938`	`baseQuery = baseQuery`
1	`939`	`.Where(e =>`
1	`940`	`(!e.IsFolder && (e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Audio`
1	`941`	`&& (filter.AudioLanguages.Contains(f.Language) \|\| (filter.AudioLanguages.Contains("und") && stri`
1	`942`	`\|\| versionsWithAudio.Contains(e.Id)))`
1	`943`	`\|\| (e.IsFolder && foldersWithAudio.Contains(e.Id)));`
	`944`	`}`
	`945`
802	`946`	`if (filter.HasChapterImages.HasValue)`
	`947`	`{`
2	`948`	`var hasChapterImages = filter.HasChapterImages.Value;`
2	`949`	`var criteria = new HasChapterImages();`
2	`950`	`var versionsWithChapterImages = DescendantQueryHelper.GetPrimaryVersionIdsMatching(context, criteria);`
2	`951`	`var foldersWithChapterImages = DescendantQueryHelper.GetFolderIdsMatching(context, criteria);`
2	`952`	`if (hasChapterImages)`
	`953`	`{`
2	`954`	`baseQuery = baseQuery`
2	`955`	`.Where(e =>`
2	`956`	`(!e.IsFolder && (e.Chapters!.Any(f => f.ImagePath != null)`
2	`957`	`\|\| versionsWithChapterImages.Contains(e.Id)))`
2	`958`	`\|\| (e.IsFolder && foldersWithChapterImages.Contains(e.Id)));`
	`959`	`}`
	`960`	`else`
	`961`	`{`
0	`962`	`baseQuery = baseQuery`
0	`963`	`.Where(e =>`
0	`964`	`(!e.IsFolder && !e.Chapters!.Any(f => f.ImagePath != null)`
0	`965`	`&& !versionsWithChapterImages.Contains(e.Id))`
0	`966`	`\|\| (e.IsFolder && !foldersWithChapterImages.Contains(e.Id)));`
	`967`	`}`
	`968`	`}`
	`969`
802	`970`	`if (filter.HasDeadParentId.HasValue && filter.HasDeadParentId.Value)`
	`971`	`{`
20	`972`	`baseQuery = baseQuery`
20	`973`	`.Where(e => e.ParentId.HasValue && !context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Any`
	`974`	`}`
	`975`
802	`976`	`if (filter.IsDeadArtist.HasValue && filter.IsDeadArtist.Value)`
	`977`	`{`
0	`978`	`baseQuery = baseQuery`
0	`979`	`.Where(e => !context.ItemValues.Where(f => _getAllArtistsValueTypes.Contains(f.Type)).Any(f => f.Val`
	`980`	`}`
	`981`
802	`982`	`if (filter.IsDeadStudio.HasValue && filter.IsDeadStudio.Value)`
	`983`	`{`
20	`984`	`baseQuery = baseQuery`
20	`985`	`.Where(e => !context.ItemValues.Where(f => _getStudiosValueTypes.Contains(f.Type)).Any(f => f.Value`
	`986`	`}`
	`987`
802	`988`	`if (filter.IsDeadGenre.HasValue && filter.IsDeadGenre.Value)`
	`989`	`{`
20	`990`	`baseQuery = baseQuery`
20	`991`	`.Where(e => !context.ItemValues.Where(f => _getGenreValueTypes.Contains(f.Type)).Any(f => f.Value ==`
	`992`	`}`
	`993`
802	`994`	`if (filter.IsDeadPerson.HasValue && filter.IsDeadPerson.Value)`
	`995`	`{`
0	`996`	`baseQuery = baseQuery`
0	`997`	`.Where(e => !context.Peoples.Any(f => f.Name == e.Name));`
	`998`	`}`
	`999`
802	`1000`	`if (filter.Years.Length > 0)`
	`1001`	`{`
0	`1002`	`baseQuery = baseQuery.WhereOneOrMany(filter.Years, e => e.ProductionYear!.Value);`
	`1003`	`}`
	`1004`
802	`1005`	`var isVirtualItem = filter.IsVirtualItem ?? filter.IsMissing;`
802	`1006`	`if (isVirtualItem.HasValue)`
	`1007`	`{`
29	`1008`	`baseQuery = baseQuery`
29	`1009`	`.Where(e => e.IsVirtualItem == isVirtualItem.Value);`
	`1010`	`}`
	`1011`
802	`1012`	`if (filter.IsSpecialSeason.HasValue)`
	`1013`	`{`
0	`1014`	`if (filter.IsSpecialSeason.Value)`
	`1015`	`{`
0	`1016`	`baseQuery = baseQuery`
0	`1017`	`.Where(e => e.IndexNumber == 0);`
	`1018`	`}`
	`1019`	`else`
	`1020`	`{`
0	`1021`	`baseQuery = baseQuery`
0	`1022`	`.Where(e => e.IndexNumber != 0);`
	`1023`	`}`
	`1024`	`}`
	`1025`
802	`1026`	`if (filter.IsUnaired.HasValue)`
	`1027`	`{`
0	`1028`	`if (filter.IsUnaired.Value)`
	`1029`	`{`
0	`1030`	`baseQuery = baseQuery`
0	`1031`	`.Where(e => e.PremiereDate >= now);`
	`1032`	`}`
	`1033`	`else`
	`1034`	`{`
0	`1035`	`baseQuery = baseQuery`
0	`1036`	`.Where(e => e.PremiereDate < now);`
	`1037`	`}`
	`1038`	`}`
	`1039`
802	`1040`	`if (filter.MediaTypes.Length > 0)`
	`1041`	`{`
27	`1042`	`var mediaTypes = filter.MediaTypes.Select(f => f.ToString()).ToArray();`
27	`1043`	`baseQuery = baseQuery.WhereOneOrMany(mediaTypes, e => e.MediaType);`
	`1044`	`}`
	`1045`
802	`1046`	`if (filter.ItemIds.Length > 0)`
	`1047`	`{`
0	`1048`	`baseQuery = baseQuery.WhereOneOrMany(filter.ItemIds, e => e.Id);`
	`1049`	`}`
	`1050`
802	`1051`	`if (filter.ExcludeItemIds.Length > 0)`
	`1052`	`{`
0	`1053`	`baseQuery = baseQuery`
0	`1054`	`.Where(e => !filter.ExcludeItemIds.Contains(e.Id));`
	`1055`	`}`
	`1056`
802	`1057`	`if (filter.ExcludeProviderIds is not null && filter.ExcludeProviderIds.Count > 0)`
	`1058`	`{`
0	`1059`	`baseQuery = baseQuery.WhereExcludeProviderIds(filter.ExcludeProviderIds);`
	`1060`	`}`
	`1061`
802	`1062`	`if (filter.HasAnyProviderId is not null && filter.HasAnyProviderId.Count > 0)`
	`1063`	`{`
0	`1064`	`baseQuery = baseQuery.WhereHasAnyProviderId(filter.HasAnyProviderId);`
	`1065`	`}`
	`1066`
802	`1067`	`if (filter.HasAnyProviderIds is not null && filter.HasAnyProviderIds.Count > 0)`
	`1068`	`{`
0	`1069`	`baseQuery = baseQuery.WhereHasAnyProviderIds(filter.HasAnyProviderIds);`
	`1070`	`}`
	`1071`
802	`1072`	`if (filter.HasImdbId.HasValue)`
	`1073`	`{`
0	`1074`	`baseQuery = filter.HasImdbId.Value`
0	`1075`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == ImdbProviderName))`
0	`1076`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != ImdbProviderName));`
	`1077`	`}`
	`1078`
802	`1079`	`if (filter.HasTmdbId.HasValue)`
	`1080`	`{`
0	`1081`	`baseQuery = filter.HasTmdbId.Value`
0	`1082`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TmdbProviderName))`
0	`1083`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TmdbProviderName));`
	`1084`	`}`
	`1085`
802	`1086`	`if (filter.HasTvdbId.HasValue)`
	`1087`	`{`
0	`1088`	`baseQuery = filter.HasTvdbId.Value`
0	`1089`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TvdbProviderName))`
0	`1090`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TvdbProviderName));`
	`1091`	`}`
	`1092`
802	`1093`	`baseQuery = ApplyTopParentFiltering(context, baseQuery, filter);`
	`1094`
802	`1095`	`if (filter.AncestorIds.Length > 0)`
	`1096`	`{`
104	`1097`	`var ancestorFilter = filter.AncestorIds.OneOrManyExpressionBuilder<AncestorId, Guid>(f => f.ParentItemId);`
104	`1098`	`baseQuery = baseQuery.Where(e => e.Parents!.AsQueryable().Any(ancestorFilter));`
	`1099`	`}`
	`1100`
802	`1101`	`if (filter.DescendantOfId.HasValue)`
	`1102`	`{`
4	`1103`	`var descendantIds = DescendantQueryHelper.GetAllDescendantIds(context, filter.DescendantOfId.Value);`
4	`1104`	`baseQuery = baseQuery.Where(e => descendantIds.Contains(e.Id));`
	`1105`	`}`
	`1106`
802	`1107`	`if (filter.LinkedChildAncestorIds.Length > 0)`
	`1108`	`{`
	`1109`	`// Keep folder-like items (BoxSets, Playlists) whose linked children descend from any of the requested ances`
0	`1110`	`var linkedChildAncestorIds = filter.LinkedChildAncestorIds;`
0	`1111`	`baseQuery = baseQuery.Where(e => context.LinkedChildren.Any(lc =>`
0	`1112`	`lc.ParentId == e.Id`
0	`1113`	`&& lc.Child!.Parents!.Any(a => linkedChildAncestorIds.Contains(a.ParentItemId))));`
	`1114`	`}`
	`1115`
802	`1116`	`if (!string.IsNullOrWhiteSpace(filter.AncestorWithPresentationUniqueKey))`
	`1117`	`{`
0	`1118`	`baseQuery = baseQuery`
0	`1119`	`.Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Where(f => f.PresentationUn`
	`1120`	`}`
	`1121`
802	`1122`	`if (!string.IsNullOrWhiteSpace(filter.SeriesPresentationUniqueKey))`
	`1123`	`{`
0	`1124`	`baseQuery = baseQuery`
0	`1125`	`.Where(e => e.SeriesPresentationUniqueKey == filter.SeriesPresentationUniqueKey);`
	`1126`	`}`
	`1127`
	`1128`	`// Pre-build the blocked-item-id set as a sub-select`
802	`1129`	`if (filter.ExcludeInheritedTags.Length > 0)`
	`1130`	`{`
5	`1131`	`var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
5	`1132`	`var blockedTagItemIds = context.ItemValuesMap`
5	`1133`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && excludedTags.Contains(f.ItemValue.CleanValue))`
5	`1134`	`.Select(f => f.ItemId);`
5	`1135`	`var blockedByAncestor = ItemsBelowTaggedAncestor(context, blockedTagItemIds);`
	`1136`
5	`1137`	`baseQuery = baseQuery.Where(e =>`
5	`1138`	`!blockedTagItemIds.Contains(e.Id)`
5	`1139`	`&& !(e.SeriesId.HasValue && blockedTagItemIds.Contains(e.SeriesId.Value))`
5	`1140`	`&& !blockedByAncestor.Contains(e.Id)`
5	`1141`	`&& !(e.TopParentId.HasValue && blockedTagItemIds.Contains(e.TopParentId.Value)));`
	`1142`	`}`
	`1143`
802	`1144`	`if (filter.IncludeInheritedTags.Length > 0)`
	`1145`	`{`
7	`1146`	`var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();`
7	`1147`	`var isPlaylistOnlyQuery = includeTypes.Length == 1 && includeTypes.FirstOrDefault() == BaseItemKind.Playlist`
7	`1148`	`var personTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];`
7	`1149`	`var allowedTagItemIds = context.ItemValuesMap`
7	`1150`	`.Where(f => f.ItemValue.Type == ItemValueType.Tags && includeTags.Contains(f.ItemValue.CleanValue))`
7	`1151`	`.Select(f => f.ItemId);`
7	`1152`	`var allowedByAncestor = ItemsBelowTaggedAncestor(context, allowedTagItemIds);`
	`1153`
7	`1154`	`baseQuery = baseQuery.Where(e =>`
7	`1155`	`allowedTagItemIds.Contains(e.Id)`
7	`1156`	`\|\| (e.SeriesId.HasValue && allowedTagItemIds.Contains(e.SeriesId.Value))`
7	`1157`	`\|\| allowedByAncestor.Contains(e.Id)`
7	`1158`	`\|\| (e.TopParentId.HasValue && allowedTagItemIds.Contains(e.TopParentId.Value))`
7	`1159`
7	`1160`	`// People don't carry the tags of the media they appear in and would never match`
7	`1161`	`\|\| e.Type == personTypeName`
7	`1162`
7	`1163`	`// A playlist should be accessible to its owner regardless of allowed tags`
7	`1164`	`\|\| (isPlaylistOnlyQuery && e.Data!.Contains($"OwnerUserId\":\"{filter.User!.Id:N}\"")));`
	`1165`	`}`
	`1166`
802	`1167`	`if (filter.SeriesStatuses.Length > 0)`
	`1168`	`{`
0	`1169`	`var seriesStatus = filter.SeriesStatuses.Select(e => e.ToString()).ToArray();`
0	`1170`	`baseQuery = baseQuery`
0	`1171`	`.Where(e => seriesStatus.Any(f => e.Data!.Contains(f)));`
	`1172`	`}`
	`1173`
802	`1174`	`if (filter.BoxSetLibraryFolders.Length > 0)`
	`1175`	`{`
0	`1176`	`var boxsetFolders = filter.BoxSetLibraryFolders.Select(e => e.ToString("N", CultureInfo.InvariantCulture)).T`
0	`1177`	`baseQuery = baseQuery`
0	`1178`	`.Where(e => boxsetFolders.Any(f => e.Data!.Contains(f)));`
	`1179`	`}`
	`1180`
802	`1181`	`if (filter.VideoTypes.Length > 0)`
	`1182`	`{`
	`1183`	`// Dvds and Blu-rays can either be stored in a folder structure or as an iso file`
	`1184`	`// => to find all matches we need to check both: VideoType and IsoType`
	`1185`	`// alternatively, we could provide specific IsoType filters`
0	`1186`	`var videoTypeBs = filter.VideoTypes.Select(vt => $"\"VideoType\":\"{vt}\"").ToArray();`
0	`1187`	`var isoTypeBs = filter.VideoTypes.Select(vt => $"\"IsoType\":\"{vt}\"").ToArray();`
0	`1188`	`Expression<Func<BaseItemEntity, bool>> hasVideoType = e => videoTypeBs.Any(f => e.Data!.Contains(f)) \|\| isoT`
0	`1189`	`baseQuery = baseQuery.WhereItemOrDescendantMatches(context, hasVideoType);`
	`1190`	`}`
	`1191`
802	`1192`	`if (filter.Is3D.HasValue)`
	`1193`	`{`
0	`1194`	`Expression<Func<BaseItemEntity, bool>> is3D = e => e.Data!.Contains("Video3DFormat");`
	`1195`
0	`1196`	`baseQuery = filter.Is3D.Value`
0	`1197`	`? baseQuery.WhereItemOrDescendantMatches(context, is3D)`
0	`1198`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, is3D);`
	`1199`	`}`
	`1200`
802	`1201`	`if (filter.IsPlaceHolder.HasValue)`
	`1202`	`{`
0	`1203`	`Expression<Func<BaseItemEntity, bool>> isPlaceHolder = e => e.Data!.Contains("IsPlaceHolder\":true");`
	`1204`
0	`1205`	`baseQuery = filter.IsPlaceHolder.Value`
0	`1206`	`? baseQuery.WhereItemOrDescendantMatches(context, isPlaceHolder)`
0	`1207`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, isPlaceHolder);`
	`1208`	`}`
	`1209`
	`1210`	`// An extra is owned by the single version of an item it is named after, so an extra on any`
	`1211`	`// version counts for the item itself`
	`1212`	`IQueryable<Guid> WithPrimaryVersions(IQueryable<Guid> ownerIds)`
	`1213`	`=> ownerIds.Concat(context.BaseItems`
	`1214`	`.Where(version => version.PrimaryVersionId != null && ownerIds.Contains(version.Id))`
	`1215`	`.Select(version => version.PrimaryVersionId!.Value));`
	`1216`
802	`1217`	`if (filter.HasSpecialFeature.HasValue)`
	`1218`	`{`
0	`1219`	`var itemsWithExtras = WithPrimaryVersions(context.BaseItems`
0	`1220`	`.Where(extra => extra.OwnerId != null`
0	`1221`	`&& extra.ExtraType != null`
0	`1222`	`&& extra.ExtraType != BaseItemExtraType.Unknown`
0	`1223`	`&& extra.ExtraType != BaseItemExtraType.Trailer`
0	`1224`	`&& extra.ExtraType != BaseItemExtraType.ThemeSong`
0	`1225`	`&& extra.ExtraType != BaseItemExtraType.ThemeVideo)`
0	`1226`	`.Select(extra => extra.OwnerId!.Value))`
0	`1227`	`.Distinct();`
	`1228`
0	`1229`	`Expression<Func<BaseItemEntity, bool>> hasExtras = e => itemsWithExtras.Contains(e.Id);`
	`1230`
0	`1231`	`baseQuery = filter.HasSpecialFeature.Value`
0	`1232`	`? baseQuery.WhereItemOrDescendantMatches(context, hasExtras)`
0	`1233`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasExtras);`
	`1234`	`}`
	`1235`
802	`1236`	`if (filter.HasTrailer.HasValue)`
	`1237`	`{`
0	`1238`	`var trailerOwnerIds = WithPrimaryVersions(context.BaseItems`
0	`1239`	`.Where(extra => extra.ExtraType == BaseItemExtraType.Trailer && extra.OwnerId != null)`
0	`1240`	`.Select(extra => extra.OwnerId!.Value));`
	`1241`
0	`1242`	`Expression<Func<BaseItemEntity, bool>> hasTrailer = e => trailerOwnerIds.Contains(e.Id);`
	`1243`
0	`1244`	`baseQuery = filter.HasTrailer.Value`
0	`1245`	`? baseQuery.WhereItemOrDescendantMatches(context, hasTrailer)`
0	`1246`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasTrailer);`
	`1247`	`}`
	`1248`
802	`1249`	`if (filter.HasThemeSong.HasValue)`
	`1250`	`{`
0	`1251`	`var themeSongOwnerIds = WithPrimaryVersions(context.BaseItems`
0	`1252`	`.Where(extra => extra.ExtraType == BaseItemExtraType.ThemeSong && extra.OwnerId != null)`
0	`1253`	`.Select(extra => extra.OwnerId!.Value));`
	`1254`
0	`1255`	`Expression<Func<BaseItemEntity, bool>> hasThemeSong = e => themeSongOwnerIds.Contains(e.Id);`
	`1256`
0	`1257`	`baseQuery = filter.HasThemeSong.Value`
0	`1258`	`? baseQuery.WhereItemOrDescendantMatches(context, hasThemeSong)`
0	`1259`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeSong);`
	`1260`	`}`
	`1261`
802	`1262`	`if (filter.HasThemeVideo.HasValue)`
	`1263`	`{`
0	`1264`	`var themeVideoOwnerIds = WithPrimaryVersions(context.BaseItems`
0	`1265`	`.Where(extra => extra.ExtraType == BaseItemExtraType.ThemeVideo && extra.OwnerId != null)`
0	`1266`	`.Select(extra => extra.OwnerId!.Value));`
	`1267`
0	`1268`	`Expression<Func<BaseItemEntity, bool>> hasThemeVideo = e => themeVideoOwnerIds.Contains(e.Id);`
	`1269`
0	`1270`	`baseQuery = filter.HasThemeVideo.Value`
0	`1271`	`? baseQuery.WhereItemOrDescendantMatches(context, hasThemeVideo)`
0	`1272`	`: baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeVideo);`
	`1273`	`}`
	`1274`
802	`1275`	`if (filter.AiredDuringSeason.HasValue)`
	`1276`	`{`
0	`1277`	`var seasonNumber = filter.AiredDuringSeason.Value;`
0	`1278`	`if (seasonNumber < 1)`
	`1279`	`{`
0	`1280`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber == seasonNumber);`
	`1281`	`}`
	`1282`	`else`
	`1283`	`{`
0	`1284`	`var seasonStr = seasonNumber.ToString(CultureInfo.InvariantCulture);`
0	`1285`	`baseQuery = baseQuery.Where(e =>`
0	`1286`	`e.ParentIndexNumber == seasonNumber`
0	`1287`	`\|\| (e.Data != null && (`
0	`1288`	`e.Data.Contains("\"AirsAfterSeasonNumber\":" + seasonStr)`
0	`1289`	`\|\| e.Data.Contains("\"AirsBeforeSeasonNumber\":" + seasonStr))));`
	`1290`	`}`
	`1291`	`}`
	`1292`
802	`1293`	`return baseQuery;`
	`1294`	`}`
	`1295`	`}`

Methods/Properties