< 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

37%

Covered lines:	565
Uncovered lines:	945
Coverable lines:	1510
Total lines:	3126
Line coverage:	37.4%

Branch coverage

39%

Covered branches:	274
Total branches:	696
Branch coverage:	39.3%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage delta

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
File 1: GetAllArtists(...)	100%	2	1	0%
File 1: GetArtists(...)	100%	1	1	100%
File 1: GetAlbumArtists(...)	100%	2	1	0%
File 1: GetStudios(...)	100%	2	1	0%
File 1: GetGenres(...)	100%	2	1	0%
File 1: GetMusicGenres(...)	100%	2	1	0%
File 1: GetStudioNames()	100%	1	1	100%
File 1: GetAllArtistNames()	100%	1	1	100%
File 1: GetMusicGenreNames()	100%	1	1	100%
File 1: GetGenreNames()	100%	1	1	100%
File 1: GetMediaStreamLanguages(...)	100%	2	1	0%
File 1: GetItemValueNames(...)	100%	4	4	100%
File 1: GetItemValues(...)	66.66%	13	12	80.76%
File 1: BuildItemCountsByCleanName(...)	0%	342	18	0%
File 2: .cctor()	100%	1	1	100%
File 2: .ctor(...)	100%	1	1	100%
File 2: Map(...)	100%	2	1	0%
File 2: Map(...)	100%	1	1	100%
File 2: DeserializeBaseItem(...)	100%	1	1	100%
File 2: PrepareFilterQuery(...)	83.33%	6	6	80%
File 2: GetItemByNameTypesInQuery(...)	100%	10	10	100%
File 2: IsTypeInQuery(...)	75%	5	4	66.66%
File 2: EnableGroupByPresentationUniqueKey(...)	63.63%	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(...)	50%	23	10	50%
File 3: ApplyBoxSetCollapsing(...)	0%	6	2	0%
File 3: ApplyBoxSetCollapsingAll(...)	100%	2	1	0%
File 3: ApplyNameFilters(...)	50%	14	6	40%
File 3: ApplyNavigations(...)	72.22%	18	18	92.3%
File 3: ApplyOrder(...)	70.58%	42	34	81.25%
File 3: ApplySeriesDatePlayedOrder(...)	0%	20	4	0%
File 3: BuildAccessFilteredDescendantsQuery(...)	100%	2	1	0%
File 3: RequiresParentalRestrictions(...)	0%	42	6	0%
File 3: ApplyAccessFiltering(...)	100%	2	2	100%
File 3: ApplyTopParentFiltering(...)	50%	8	6	60%
File 3: GetExemptedItemByNameTypes(...)	50%	4	4	75%
File 3: ApplyItemByNameAccessFiltering(...)	0%	42	6	0%
File 3: ApplyParentalRestrictions(...)	50%	46	8	16.12%
File 3: BuildMaxParentalRatingFilter(...)	100%	1	1	100%
File 3: GetAccessFilteredLeafItemsQuery(...)	100%	1	1	100%
File 3: BuildHasDescendantFilter(...)	100%	1	1	100%
File 4: GetItemIdsList(...)	100%	1	1	100%
File 4: GetItems(...)	37.5%	28	8	31.81%
File 4: GetItemList(...)	75%	4	4	69.56%
File 4: GetLatestItemList(...)	0%	210	14	0%
File 4: LoadLatestByIds(...)	100%	2	1	0%
File 4: LoadLatestByIds(...)	0%	6	2	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(...)	0%	6	2	0%
File 4: GetQueryFiltersLegacy(...)	100%	2	1	0%
File 5: .cctor()	100%	1	1	100%
File 5: get_IsFolderFilter()	100%	1	1	100%
File 5: TranslateQuery(...)	40.81%	41563	370	32.99%

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`	`{`
0	`23`	`return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtis`
	`24`	`}`
	`25`
	`26`	`/// <inheritdoc />`
	`27`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)`
	`28`	`{`
4	`29`	`return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);`
	`30`	`}`
	`31`
	`32`	`/// <inheritdoc />`
	`33`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)`
	`34`	`{`
0	`35`	`return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArti`
	`36`	`}`
	`37`
	`38`	`/// <inheritdoc />`
	`39`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)`
	`40`	`{`
0	`41`	`return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);`
	`42`	`}`
	`43`
	`44`	`/// <inheritdoc />`
	`45`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)`
	`46`	`{`
0	`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`	`{`
18	`59`	`return GetItemValueNames(_getStudiosValueTypes, [], []);`
	`60`	`}`
	`61`
	`62`	`/// <inheritdoc />`
	`63`	`public IReadOnlyList<string> GetAllArtistNames()`
	`64`	`{`
18	`65`	`return GetItemValueNames(_getAllArtistsValueTypes, [], []);`
	`66`	`}`
	`67`
	`68`	`/// <inheritdoc />`
	`69`	`public IReadOnlyList<string> GetMusicGenreNames()`
	`70`	`{`
18	`71`	`return GetItemValueNames(`
18	`72`	`_getGenreValueTypes,`
18	`73`	`_itemTypeLookup.MusicGenreTypes,`
18	`74`	`[]);`
	`75`	`}`
	`76`
	`77`	`/// <inheritdoc />`
	`78`	`public IReadOnlyList<string> GetGenreNames()`
	`79`	`{`
18	`80`	`return GetItemValueNames(`
18	`81`	`_getGenreValueTypes,`
18	`82`	`[],`
18	`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`	`private string[] GetItemValueNames(IReadOnlyList<ItemValueType> itemValueTypes, IReadOnlyList<string> withItemTypes,`
	`121`	`{`
72	`122`	`using var context = _dbProvider.CreateDbContext();`
	`123`
72	`124`	`var query = context.ItemValuesMap`
72	`125`	`.AsNoTracking()`
72	`126`	`.Where(e => itemValueTypes.Any(w => w == e.ItemValue.Type));`
72	`127`	`if (withItemTypes.Count > 0)`
	`128`	`{`
18	`129`	`query = query.Where(e => withItemTypes.Contains(e.Item.Type));`
	`130`	`}`
	`131`
72	`132`	`if (excludeItemTypes.Count > 0)`
	`133`	`{`
18	`134`	`query = query.Where(e => !excludeItemTypes.Contains(e.Item.Type));`
	`135`	`}`
	`136`
72	`137`	`return query.Select(e => e.ItemValue)`
72	`138`	`.GroupBy(e => e.CleanValue)`
72	`139`	`.Select(g => g.Min(v => v.Value)!)`
72	`140`	`.ToArray();`
72	`141`	`}`
	`142`
	`143`	`private QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetItemValues(InternalItemsQuery filter, IReadOnlyLi`
	`144`	`{`
4	`145`	`ArgumentNullException.ThrowIfNull(filter);`
	`146`
4	`147`	`using var context = _dbProvider.CreateDbContext();`
	`148`
4	`149`	`var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context,`
4	`150`	`{`
4	`151`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
4	`152`	`IncludeItemTypes = filter.IncludeItemTypes,`
4	`153`	`MediaTypes = filter.MediaTypes,`
4	`154`	`AncestorIds = filter.AncestorIds,`
4	`155`	`ItemIds = filter.ItemIds,`
4	`156`	`TopParentIds = filter.TopParentIds,`
4	`157`	`ParentId = filter.ParentId,`
4	`158`	`IsAiring = filter.IsAiring,`
4	`159`	`IsMovie = filter.IsMovie,`
4	`160`	`IsSports = filter.IsSports,`
4	`161`	`IsKids = filter.IsKids,`
4	`162`	`IsNews = filter.IsNews,`
4	`163`	`IsSeries = filter.IsSeries`
4	`164`	`});`
	`165`
4	`166`	`var innerQuery = PrepareItemQuery(context, filter)`
4	`167`	`.Where(e => e.Type == returnType)`
4	`168`	`.Where(e => context.ItemValuesMap`
4	`169`	`.Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type) && ivm.ItemValue.CleanValue == e.CleanName)`
4	`170`	`.Join(`
4	`171`	`innerQueryFilter,`
4	`172`	`ivm => ivm.ItemId,`
4	`173`	`g => g.Id,`
4	`174`	`(ivm, g) => ivm.ItemId)`
4	`175`	`.Any());`
	`176`
4	`177`	`var outerQueryFilter = new InternalItemsQuery(filter.User)`
4	`178`	`{`
4	`179`	`IsPlayed = filter.IsPlayed,`
4	`180`	`IsFavorite = filter.IsFavorite,`
4	`181`	`IsFavoriteOrLiked = filter.IsFavoriteOrLiked,`
4	`182`	`IsLiked = filter.IsLiked,`
4	`183`	`IsLocked = filter.IsLocked,`
4	`184`	`NameLessThan = filter.NameLessThan,`
4	`185`	`NameStartsWith = filter.NameStartsWith,`
4	`186`	`NameStartsWithOrGreater = filter.NameStartsWithOrGreater,`
4	`187`	`Tags = filter.Tags,`
4	`188`	`OfficialRatings = filter.OfficialRatings,`
4	`189`	`StudioIds = filter.StudioIds,`
4	`190`	`GenreIds = filter.GenreIds,`
4	`191`	`Genres = filter.Genres,`
4	`192`	`Years = filter.Years,`
4	`193`	`NameContains = filter.NameContains,`
4	`194`	`SearchTerm = filter.SearchTerm,`
4	`195`	`ExcludeItemIds = filter.ExcludeItemIds`
4	`196`	`};`
	`197`
	`198`	`// Collapse rows that share a PresentationUniqueKey (e.g. alternate versions) into one`
	`199`	`// representative id per group, then materialize the representative ids once.`
4	`200`	`var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter);`
4	`201`	`var isMusicArtist = returnType == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];`
	`202`	`List<Guid> representativeIds;`
4	`203`	`if (isMusicArtist)`
	`204`	`{`
	`205`	`// For MusicArtist, prefer the entity from a library the user can actually access.`
	`206`	`// Materialize to prevent correlated per-group first-row queries which hurt performance.`
4	`207`	`var topParentIds = filter.TopParentIds;`
4	`208`	`representativeIds = masterQuery`
4	`209`	`.Select(e => new { e.Id, e.PresentationUniqueKey, e.TopParentId })`
4	`210`	`.AsEnumerable()`
4	`211`	`.GroupBy(e => e.PresentationUniqueKey)`
4	`212`	`.Select(g => g`
4	`213`	`.OrderBy(e => topParentIds.Contains(e.TopParentId ?? Guid.Empty) ? 0 : 1)`
4	`214`	`.ThenBy(e => e.Id)`
4	`215`	`.First().Id)`
4	`216`	`.ToList();`
	`217`	`}`
	`218`	`else`
	`219`	`{`
0	`220`	`representativeIds = masterQuery`
0	`221`	`.GroupBy(e => e.PresentationUniqueKey)`
0	`222`	`.Select(g => g.Min(e => e.Id))`
0	`223`	`.ToList();`
	`224`	`}`
	`225`
4	`226`	`var result = new QueryResult<(BaseItemDto, ItemCounts?)>();`
4	`227`	`if (filter.EnableTotalRecordCount)`
	`228`	`{`
3	`229`	`result.TotalRecordCount = representativeIds.Count;`
	`230`	`}`
	`231`
4	`232`	`var query = ApplyNavigations(`
4	`233`	`context.BaseItems.AsNoTracking().AsSingleQuery().WhereOneOrMany(representativeIds, e => e.Id),`
4	`234`	`filter);`
	`235`
4	`236`	`query = ApplyOrder(query, filter, context);`
	`237`
4	`238`	`if (filter.StartIndex.HasValue && filter.StartIndex.Value > 0)`
	`239`	`{`
0	`240`	`query = query.Skip(filter.StartIndex.Value);`
	`241`	`}`
	`242`
4	`243`	`if (filter.Limit.HasValue)`
	`244`	`{`
1	`245`	`query = query.Take(filter.Limit.Value);`
	`246`	`}`
	`247`
4	`248`	`result.StartIndex = filter.StartIndex ?? 0;`
4	`249`	`if (filter.IncludeItemTypes.Length > 0)`
	`250`	`{`
0	`251`	`var countsByCleanName = BuildItemCountsByCleanName(context, filter, itemValueTypes);`
0	`252`	`result.Items =`
0	`253`	`[`
0	`254`	`.. query`
0	`255`	`.AsEnumerable()`
0	`256`	`.Where(e => e is not null)`
0	`257`	`.Select(e =>`
0	`258`	`{`
0	`259`	`var item = DeserializeBaseItem(e, filter.SkipDeserialization);`
0	`260`	`countsByCleanName.TryGetValue(e.CleanName ?? string.Empty, out var itemCount);`
0	`261`	`return (item, itemCount);`
0	`262`	`})`
0	`263`	`.Where(x => x.item is not null)`
0	`264`	`.Select(x => (x.item!, x.itemCount))`
0	`265`	`];`
	`266`	`}`
	`267`	`else`
	`268`	`{`
4	`269`	`result.Items =`
4	`270`	`[`
4	`271`	`.. query`
4	`272`	`.AsEnumerable()`
4	`273`	`.Where(e => e != null)`
4	`274`	`.Select(e => DeserializeBaseItem(e, filter.SkipDeserialization))`
4	`275`	`.Where(item => item != null)`
4	`276`	`.Select(item => (item!, (ItemCounts?)null))`
4	`277`	`];`
	`278`	`}`
	`279`
4	`280`	`return result;`
4	`281`	`}`
	`282`
	`283`	`private Dictionary<string, ItemCounts> BuildItemCountsByCleanName(`
	`284`	`Database.Implementations.JellyfinDbContext context,`
	`285`	`InternalItemsQuery filter,`
	`286`	`IReadOnlyList<ItemValueType> itemValueTypes)`
	`287`	`{`
0	`288`	`var typeSubQuery = new InternalItemsQuery(filter.User)`
0	`289`	`{`
0	`290`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`291`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`292`	`MediaTypes = filter.MediaTypes,`
0	`293`	`AncestorIds = filter.AncestorIds,`
0	`294`	`ExcludeItemIds = filter.ExcludeItemIds,`
0	`295`	`ItemIds = filter.ItemIds,`
0	`296`	`TopParentIds = filter.TopParentIds,`
0	`297`	`ParentId = filter.ParentId,`
0	`298`	`IsPlayed = filter.IsPlayed`
0	`299`	`};`
	`300`
0	`301`	`var itemCountQuery = TranslateQuery(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderI`
0	`302`	`.Where(e => e.ItemValues!.Any(f => itemValueTypes!.Contains(f.ItemValue.Type)));`
	`303`
0	`304`	`var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];`
0	`305`	`var movieTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];`
0	`306`	`var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];`
0	`307`	`var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum];`
0	`308`	`var musicArtistTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];`
0	`309`	`var audioTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Audio];`
0	`310`	`var trailerTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Trailer];`
0	`311`	`var itemIds = itemCountQuery.Select(e => e.Id);`
	`312`
	`313`	`// Rewrite query to avoid SelectMany on navigation properties (which requires SQL APPLY, not supported on SQLite`
	`314`	`// Instead, start from ItemValueMaps and join with BaseItems.`
0	`315`	`var rawCounts = context.ItemValuesMap`
0	`316`	`.Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))`
0	`317`	`.Where(ivm => itemIds.Contains(ivm.ItemId))`
0	`318`	`.Join(`
0	`319`	`context.BaseItems,`
0	`320`	`ivm => ivm.ItemId,`
0	`321`	`e => e.Id,`
0	`322`	`(ivm, e) => new { CleanName = ivm.ItemValue.CleanValue, e.Type })`
0	`323`	`.GroupBy(x => new { x.CleanName, x.Type })`
0	`324`	`.Select(g => new { g.Key.CleanName, g.Key.Type, Count = g.Count() })`
0	`325`	`.AsEnumerable();`
	`326`
0	`327`	`var countsByCleanName = new Dictionary<string, ItemCounts>();`
0	`328`	`foreach (var group in rawCounts.GroupBy(x => x.CleanName))`
	`329`	`{`
0	`330`	`var counts = new ItemCounts();`
0	`331`	`foreach (var row in group)`
	`332`	`{`
0	`333`	`if (row.Type == seriesTypeName)`
	`334`	`{`
0	`335`	`counts.SeriesCount += row.Count;`
	`336`	`}`
0	`337`	`else if (row.Type == episodeTypeName)`
	`338`	`{`
0	`339`	`counts.EpisodeCount += row.Count;`
	`340`	`}`
0	`341`	`else if (row.Type == movieTypeName)`
	`342`	`{`
0	`343`	`counts.MovieCount += row.Count;`
	`344`	`}`
0	`345`	`else if (row.Type == musicAlbumTypeName)`
	`346`	`{`
0	`347`	`counts.AlbumCount += row.Count;`
	`348`	`}`
0	`349`	`else if (row.Type == musicArtistTypeName)`
	`350`	`{`
0	`351`	`counts.ArtistCount += row.Count;`
	`352`	`}`
0	`353`	`else if (row.Type == audioTypeName)`
	`354`	`{`
0	`355`	`counts.SongCount += row.Count;`
	`356`	`}`
0	`357`	`else if (row.Type == trailerTypeName)`
	`358`	`{`
0	`359`	`counts.TrailerCount += row.Count;`
	`360`	`}`
	`361`	`}`
	`362`
0	`363`	`countsByCleanName[group.Key] = counts;`
	`364`	`}`
	`365`
0	`366`	`return countsByCleanName;`
	`367`	`}`
	`368`	`}`

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

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

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

Methods/Properties