< Summary - Jellyfin

Information

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

Line coverage

28%

Covered lines:	424
Uncovered lines:	1067
Coverable lines:	1491
Total lines:	2949
Line coverage:	28.4%

Branch coverage

39%

Covered branches:	263
Total branches:	660
Branch coverage:	39.8%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage delta

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
File 1: GetAllArtists(...)	100%	2	1	0%
File 1: GetArtists(...)	100%	2	1	0%
File 1: GetAlbumArtists(...)	100%	2	1	0%
File 1: GetStudios(...)	100%	2	1	0%
File 1: GetGenres(...)	100%	2	1	0%
File 1: GetMusicGenres(...)	100%	2	1	0%
File 1: GetStudioNames()	100%	1	1	100%
File 1: GetAllArtistNames()	100%	1	1	100%
File 1: GetMusicGenreNames()	100%	1	1	100%
File 1: GetGenreNames()	100%	1	1	100%
File 1: GetMediaStreamLanguages(...)	100%	2	1	0%
File 1: GetItemValueNames(...)	100%	4	4	100%
File 1: GetItemValues(...)	0%	210	14	0%
File 1: BuildItemCountsByCleanName(...)	100%	2	1	0%
File 2: .cctor()	100%	1	1	100%
File 2: .ctor(...)	100%	1	1	100%
File 2: Map(...)	100%	2	1	0%
File 2: Map(...)	100%	1	1	100%
File 2: DeserializeBaseItem(...)	100%	1	1	100%
File 2: PrepareFilterQuery(...)	83.33%	6	6	80%
File 2: GetItemByNameTypesInQuery(...)	100%	10	10	100%
File 2: IsTypeInQuery(...)	75%	5	4	66.66%
File 2: EnableGroupByPresentationUniqueKey(...)	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: 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	91.3%
File 3: ApplyOrder(...)	70.58%	42	34	81.25%
File 3: ApplySeriesDatePlayedOrder(...)	0%	20	4	0%
File 3: BuildAccessFilteredDescendantsQuery(...)	100%	2	1	0%
File 3: ApplyAccessFiltering(...)	0%	156	12	0%
File 3: BuildMaxParentalRatingFilter(...)	100%	1	1	100%
File 3: GetFullyPlayedFolderIdsQuery(...)	100%	2	1	0%
File 4: GetItemIdsList(...)	100%	1	1	100%
File 4: GetItems(...)	37.5%	27	8	33.33%
File 4: GetItemList(...)	75%	5	4	68.18%
File 4: GetLatestItemList(...)	0%	210	14	0%
File 4: LoadLatestByIds(...)	100%	2	1	0%
File 4: GetLatestTvShowItems(...)	0%	4692	68	0%
File 4: ItemExistsAsync()	100%	1	1	100%
File 4: RetrieveItem(...)	50%	4	4	90.9%
File 4: GetIsPlayed(...)	0%	6	2	0%
File 4: GetQueryFiltersLegacy(...)	100%	2	1	0%
File 5: .cctor()	100%	1	1	100%
File 5: TranslateQuery(...)	40.6%	52777	394	30.38%

File(s)

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

#	Line	Line coverage
	`1`	`#pragma warning disable RS0030 // Do not use banned APIs`
	`2`
	`3`	`using System;`
	`4`	`using System.Collections.Generic;`
	`5`	`using System.Linq;`
	`6`	`using Jellyfin.Data.Enums;`
	`7`	`using Jellyfin.Database.Implementations.Entities;`
	`8`	`using MediaBrowser.Controller.Entities;`
	`9`	`using MediaBrowser.Model.Dto;`
	`10`	`using MediaBrowser.Model.Entities;`
	`11`	`using MediaBrowser.Model.Querying;`
	`12`	`using Microsoft.EntityFrameworkCore;`
	`13`	`using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;`
	`14`
	`15`	`namespace Jellyfin.Server.Implementations.Item;`
	`16`
	`17`	`public sealed partial class BaseItemRepository`
	`18`	`{`
	`19`	`/// <inheritdoc />`
	`20`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAllArtists(InternalItemsQuery filter)`
	`21`	`{`
0	`22`	`return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtis`
	`23`	`}`
	`24`
	`25`	`/// <inheritdoc />`
	`26`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)`
	`27`	`{`
0	`28`	`return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);`
	`29`	`}`
	`30`
	`31`	`/// <inheritdoc />`
	`32`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)`
	`33`	`{`
0	`34`	`return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArti`
	`35`	`}`
	`36`
	`37`	`/// <inheritdoc />`
	`38`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)`
	`39`	`{`
0	`40`	`return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);`
	`41`	`}`
	`42`
	`43`	`/// <inheritdoc />`
	`44`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)`
	`45`	`{`
0	`46`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]);`
	`47`	`}`
	`48`
	`49`	`/// <inheritdoc />`
	`50`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetMusicGenres(InternalItemsQuery filter)`
	`51`	`{`
0	`52`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]);`
	`53`	`}`
	`54`
	`55`	`/// <inheritdoc />`
	`56`	`public IReadOnlyList<string> GetStudioNames()`
	`57`	`{`
18	`58`	`return GetItemValueNames(_getStudiosValueTypes, [], []);`
	`59`	`}`
	`60`
	`61`	`/// <inheritdoc />`
	`62`	`public IReadOnlyList<string> GetAllArtistNames()`
	`63`	`{`
18	`64`	`return GetItemValueNames(_getAllArtistsValueTypes, [], []);`
	`65`	`}`
	`66`
	`67`	`/// <inheritdoc />`
	`68`	`public IReadOnlyList<string> GetMusicGenreNames()`
	`69`	`{`
18	`70`	`return GetItemValueNames(`
18	`71`	`_getGenreValueTypes,`
18	`72`	`_itemTypeLookup.MusicGenreTypes,`
18	`73`	`[]);`
	`74`	`}`
	`75`
	`76`	`/// <inheritdoc />`
	`77`	`public IReadOnlyList<string> GetGenreNames()`
	`78`	`{`
18	`79`	`return GetItemValueNames(`
18	`80`	`_getGenreValueTypes,`
18	`81`	`[],`
18	`82`	`_itemTypeLookup.MusicGenreTypes);`
	`83`	`}`
	`84`
	`85`	`/// <inheritdoc />`
	`86`	`public IReadOnlyList<string> GetMediaStreamLanguages(InternalItemsQuery filter, MediaStreamType mediaStreamType)`
	`87`	`{`
0	`88`	`ArgumentNullException.ThrowIfNull(filter);`
	`89`
0	`90`	`using var context = _dbProvider.CreateDbContext();`
	`91`
0	`92`	`return TranslateQuery(`
0	`93`	`context.BaseItems.Include(e => e.MediaStreams).Where(e => e.Id != EF.Constant(PlaceholderId)),`
0	`94`	`context,`
0	`95`	`new InternalItemsQuery(filter.User)`
0	`96`	`{`
0	`97`	`IncludeOwnedItems = filter.IncludeOwnedItems,`
0	`98`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`99`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`100`	`MediaTypes = filter.MediaTypes,`
0	`101`	`AncestorIds = filter.AncestorIds,`
0	`102`	`ItemIds = filter.ItemIds,`
0	`103`	`TopParentIds = filter.TopParentIds,`
0	`104`	`ParentId = filter.ParentId,`
0	`105`	`IsAiring = filter.IsAiring,`
0	`106`	`IsMovie = filter.IsMovie,`
0	`107`	`IsSports = filter.IsSports,`
0	`108`	`IsKids = filter.IsKids,`
0	`109`	`IsNews = filter.IsNews,`
0	`110`	`IsSeries = filter.IsSeries`
0	`111`	`})`
0	`112`	`.Where(e => e.MediaStreams != null)`
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`	`{`
0	`145`	`ArgumentNullException.ThrowIfNull(filter);`
	`146`
0	`147`	`if (!filter.Limit.HasValue)`
	`148`	`{`
0	`149`	`filter.EnableTotalRecordCount = false;`
	`150`	`}`
	`151`
0	`152`	`using var context = _dbProvider.CreateDbContext();`
	`153`
0	`154`	`var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context,`
0	`155`	`{`
0	`156`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`157`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`158`	`MediaTypes = filter.MediaTypes,`
0	`159`	`AncestorIds = filter.AncestorIds,`
0	`160`	`ItemIds = filter.ItemIds,`
0	`161`	`TopParentIds = filter.TopParentIds,`
0	`162`	`ParentId = filter.ParentId,`
0	`163`	`IsAiring = filter.IsAiring,`
0	`164`	`IsMovie = filter.IsMovie,`
0	`165`	`IsSports = filter.IsSports,`
0	`166`	`IsKids = filter.IsKids,`
0	`167`	`IsNews = filter.IsNews,`
0	`168`	`IsSeries = filter.IsSeries`
0	`169`	`});`
	`170`
	`171`	`// Keep this as an IQueryable sub-select. Materializing to a list would inline one`
	`172`	`// bound parameter per CleanValue and hit SQLite's variable cap on libraries with`
	`173`	`// high-cardinality value types (e.g. tens of thousands of artists).`
0	`174`	`var matchingCleanValues = context.ItemValuesMap`
0	`175`	`.Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))`
0	`176`	`.Join(`
0	`177`	`innerQueryFilter,`
0	`178`	`ivm => ivm.ItemId,`
0	`179`	`g => g.Id,`
0	`180`	`(ivm, g) => ivm.ItemValue.CleanValue)`
0	`181`	`.Distinct();`
	`182`
0	`183`	`var innerQuery = PrepareItemQuery(context, filter)`
0	`184`	`.Where(e => e.Type == returnType)`
0	`185`	`.Where(e => matchingCleanValues.Contains(e.CleanName!));`
	`186`
0	`187`	`var outerQueryFilter = new InternalItemsQuery(filter.User)`
0	`188`	`{`
0	`189`	`IsPlayed = filter.IsPlayed,`
0	`190`	`IsFavorite = filter.IsFavorite,`
0	`191`	`IsFavoriteOrLiked = filter.IsFavoriteOrLiked,`
0	`192`	`IsLiked = filter.IsLiked,`
0	`193`	`IsLocked = filter.IsLocked,`
0	`194`	`NameLessThan = filter.NameLessThan,`
0	`195`	`NameStartsWith = filter.NameStartsWith,`
0	`196`	`NameStartsWithOrGreater = filter.NameStartsWithOrGreater,`
0	`197`	`Tags = filter.Tags,`
0	`198`	`OfficialRatings = filter.OfficialRatings,`
0	`199`	`StudioIds = filter.StudioIds,`
0	`200`	`GenreIds = filter.GenreIds,`
0	`201`	`Genres = filter.Genres,`
0	`202`	`Years = filter.Years,`
0	`203`	`NameContains = filter.NameContains,`
0	`204`	`SearchTerm = filter.SearchTerm,`
0	`205`	`ExcludeItemIds = filter.ExcludeItemIds`
0	`206`	`};`
	`207`
	`208`	`// Collapse rows that share a PresentationUniqueKey (e.g. alternate versions) by picking`
	`209`	`// the lowest Id per group. For MusicArtist, prefer the entity from a library the user`
	`210`	`// can actually access,since the same artist can have a folder in multiple libraries.`
	`211`	`// Keep as an IQueryable sub-select so paging is applied AFTER`
	`212`	`// ApplyOrder runs the caller's actual sort.`
0	`213`	`var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter);`
0	`214`	`var isMusicArtist = returnType == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];`
0	`215`	`var representativeIds = isMusicArtist`
0	`216`	`? masterQuery`
0	`217`	`.GroupBy(e => e.PresentationUniqueKey)`
0	`218`	`.Select(g => g`
0	`219`	`.OrderBy(e => filter.TopParentIds.Contains(e.TopParentId ?? Guid.Empty) ? 0 : 1)`
0	`220`	`.ThenBy(e => e.Id)`
0	`221`	`.First().Id)`
0	`222`	`: masterQuery`
0	`223`	`.GroupBy(e => e.PresentationUniqueKey)`
0	`224`	`.Select(g => g.Min(e => e.Id));`
	`225`
0	`226`	`var result = new QueryResult<(BaseItemDto, ItemCounts?)>();`
0	`227`	`if (filter.EnableTotalRecordCount)`
	`228`	`{`
0	`229`	`result.TotalRecordCount = representativeIds.Count();`
	`230`	`}`
	`231`
0	`232`	`var query = ApplyNavigations(`
0	`233`	`context.BaseItems.AsNoTracking().AsSingleQuery().Where(e => representativeIds.Contains(e.Id)),`
0	`234`	`filter);`
	`235`
0	`236`	`query = ApplyOrder(query, filter, context);`
	`237`
0	`238`	`if (filter.StartIndex.HasValue && filter.StartIndex.Value > 0)`
	`239`	`{`
0	`240`	`query = query.Skip(filter.StartIndex.Value);`
	`241`	`}`
	`242`
0	`243`	`if (filter.Limit.HasValue)`
	`244`	`{`
0	`245`	`query = query.Take(filter.Limit.Value);`
	`246`	`}`
	`247`
0	`248`	`result.StartIndex = filter.StartIndex ?? 0;`
0	`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`	`{`
0	`269`	`result.Items =`
0	`270`	`[`
0	`271`	`.. query`
0	`272`	`.AsEnumerable()`
0	`273`	`.Where(e => e != null)`
0	`274`	`.Select(e => DeserializeBaseItem(e, filter.SkipDeserialization))`
0	`275`	`.Where(item => item != null)`
0	`276`	`.Select(item => (item!, (ItemCounts?)null))`
0	`277`	`];`
	`278`	`}`
	`279`
0	`280`	`return result;`
0	`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`	`return 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`	`.GroupBy(x => x.CleanName)`
0	`326`	`.ToDictionary(`
0	`327`	`g => g.Key,`
0	`328`	`g => new ItemCounts`
0	`329`	`{`
0	`330`	`SeriesCount = g.Where(x => x.Type == seriesTypeName).Sum(x => x.Count),`
0	`331`	`EpisodeCount = g.Where(x => x.Type == episodeTypeName).Sum(x => x.Count),`
0	`332`	`MovieCount = g.Where(x => x.Type == movieTypeName).Sum(x => x.Count),`
0	`333`	`AlbumCount = g.Where(x => x.Type == musicAlbumTypeName).Sum(x => x.Count),`
0	`334`	`ArtistCount = g.Where(x => x.Type == musicArtistTypeName).Sum(x => x.Count),`
0	`335`	`SongCount = g.Where(x => x.Type == audioTypeName).Sum(x => x.Count),`
0	`336`	`TrailerCount = g.Where(x => x.Type == trailerTypeName).Sum(x => x.Count),`
0	`337`	`});`
	`338`	`}`
	`339`	`}`

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

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

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

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

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

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

Methods/Properties