< Summary - Jellyfin

Information

Class:	Jellyfin.Server.Implementations.Item.BaseItemRepository
Assembly:	Jellyfin.Server.Implementations
File(s):	/srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs

Line coverage

51%

Covered lines:	689
Uncovered lines:	649
Coverable lines:	1338
Total lines:	2735
Line coverage:	51.4%

Branch coverage

50%

Covered branches:	386
Total branches:	764
Branch coverage:	50.5%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
.cctor()	100%	1	1	100%
.ctor(...)	100%	1	1	100%
DeleteItem(...)	50%	6	6	97.56%
UpdateInheritedValues()	100%	1	1	100%
GetItemIdsList(...)	100%	1	1	100%
GetAllArtists(...)	100%	2	1	0%
GetArtists(...)	100%	2	1	0%
GetAlbumArtists(...)	100%	2	1	0%
GetStudios(...)	100%	2	1	0%
GetGenres(...)	100%	2	1	0%
GetMusicGenres(...)	100%	2	1	0%
GetStudioNames()	100%	1	1	100%
GetAllArtistNames()	100%	1	1	100%
GetMusicGenreNames()	100%	1	1	100%
GetGenreNames()	100%	1	1	100%
GetItems(...)	50%	27	8	33.33%
GetItemList(...)	75%	4	4	71.42%
GetLatestItemList(...)	0%	72	8	0%
GetNextUpSeriesKeys(...)	0%	20	4	0%
ApplyGroupingFilter(...)	75%	10	8	69.23%
ApplyNavigations(...)	83.33%	12	12	90.9%
ApplyQueryPaging(...)	75%	9	8	80%
ApplyQueryFilter(...)	100%	1	1	100%
PrepareItemQuery(...)	100%	1	1	100%
GetCount(...)	100%	2	1	0%
GetItemCounts(...)	0%	420	20	0%
GetType(...)	100%	1	1	100%
SaveItems(...)	100%	1	1	100%
UpdateOrInsertItems(...)	82.35%	36	34	87.09%
RetrieveItem(...)	50%	4	4	90%
Map(...)	50%	142	82	79.31%
Map(...)	54.83%	95	62	79.46%
GetItemValueNames(...)	100%	4	4	100%
TypeRequiresDeserialization(...)	100%	1	1	100%
DeserializeBaseItem(...)	50%	10	10	88.88%
DeserializeBaseItem(...)	83.33%	16	12	70.58%
GetItemValues(...)	0%	272	16	0%
PrepareFilterQuery(...)	87.5%	9	8	80%
GetCleanValue(...)	91.66%	12	12	94.11%
GetItemValuesToSave(...)	50%	4	4	81.81%
Map(...)	0%	6	2	0%
Map(...)	0%	72	8	0%
GetPathToSave(...)	50%	2	2	66.66%
GetItemByNameTypesInQuery(...)	100%	10	10	100%
IsTypeInQuery(...)	75%	5	4	66.66%
EnableGroupByPresentationUniqueKey(...)	65%	21	20	87.5%
ApplyOrder(...)	56.66%	57	30	68.96%
TranslateQuery(...)	45.11%	30644	348	36.99%
GetIsPlayed(...)	0%	6	2	0%
TraverseHirachyDown(...)	50%	8	8	84.21%
FindArtists(...)	0%	20	4	0%

File(s)

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

#	Line	Line coverage
	`1`	`#pragma warning disable RS0030 // Do not use banned APIs`
	`2`	`// Do not enforce that because EFCore cannot deal with cultures well.`
	`3`	`#pragma warning disable CA1304 // Specify CultureInfo`
	`4`	`#pragma warning disable CA1311 // Specify a culture or use an invariant version`
	`5`	`#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string compari`
	`6`
	`7`	`using System;`
	`8`	`using System.Collections.Concurrent;`
	`9`	`using System.Collections.Generic;`
	`10`	`using System.Globalization;`
	`11`	`using System.Linq;`
	`12`	`using System.Linq.Expressions;`
	`13`	`using System.Reflection;`
	`14`	`using System.Text;`
	`15`	`using System.Text.Json;`
	`16`	`using System.Threading;`
	`17`	`using System.Threading.Tasks;`
	`18`	`using Jellyfin.Data.Enums;`
	`19`	`using Jellyfin.Database.Implementations;`
	`20`	`using Jellyfin.Database.Implementations.Entities;`
	`21`	`using Jellyfin.Database.Implementations.Enums;`
	`22`	`using Jellyfin.Extensions;`
	`23`	`using Jellyfin.Extensions.Json;`
	`24`	`using Jellyfin.Server.Implementations.Extensions;`
	`25`	`using MediaBrowser.Common;`
	`26`	`using MediaBrowser.Controller;`
	`27`	`using MediaBrowser.Controller.Channels;`
	`28`	`using MediaBrowser.Controller.Configuration;`
	`29`	`using MediaBrowser.Controller.Entities;`
	`30`	`using MediaBrowser.Controller.Entities.Audio;`
	`31`	`using MediaBrowser.Controller.Entities.TV;`
	`32`	`using MediaBrowser.Controller.LiveTv;`
	`33`	`using MediaBrowser.Controller.Persistence;`
	`34`	`using MediaBrowser.Model.Dto;`
	`35`	`using MediaBrowser.Model.Entities;`
	`36`	`using MediaBrowser.Model.LiveTv;`
	`37`	`using MediaBrowser.Model.Querying;`
	`38`	`using Microsoft.EntityFrameworkCore;`
	`39`	`using Microsoft.Extensions.Logging;`
	`40`	`using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;`
	`41`	`using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;`
	`42`
	`43`	`namespace Jellyfin.Server.Implementations.Item;`
	`44`
	`45`	`/*`
	`46`	`All queries in this class and all other nullable enabled EFCore repository classes will make liberal use of the null`
	`47`	`This is done as the code isn't actually executed client side, but only the expressions are interpret and the compile`
	`48`	`This is your only warning/message regarding this topic.`
	`49`	`*/`
	`50`
	`51`	`/// <summary>`
	`52`	`/// Handles all storage logic for BaseItems.`
	`53`	`/// </summary>`
	`54`	`public sealed class BaseItemRepository`
	`55`	`: IItemRepository`
	`56`	`{`
	`57`	`/// <summary>`
	`58`	`/// Gets the placeholder id for UserData detached items.`
	`59`	`/// </summary>`
2	`60`	`public static readonly Guid PlaceholderId = Guid.Parse("00000000-0000-0000-0000-000000000001");`
	`61`
	`62`	`/// <summary>`
	`63`	`/// This holds all the types in the running assemblies`
	`64`	`/// so that we can de-serialize properly when we don't have strong types.`
	`65`	`/// </summary>`
2	`66`	`private static readonly ConcurrentDictionary<string, Type?> _typeMap = new ConcurrentDictionary<string, Type?>();`
	`67`	`private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;`
	`68`	`private readonly IServerApplicationHost _appHost;`
	`69`	`private readonly IItemTypeLookup _itemTypeLookup;`
	`70`	`private readonly IServerConfigurationManager _serverConfigurationManager;`
	`71`	`private readonly ILogger<BaseItemRepository> _logger;`
	`72`
2	`73`	`private static readonly IReadOnlyList<ItemValueType> _getAllArtistsValueTypes = [ItemValueType.Artist, ItemValueType`
2	`74`	`private static readonly IReadOnlyList<ItemValueType> _getArtistValueTypes = [ItemValueType.Artist];`
2	`75`	`private static readonly IReadOnlyList<ItemValueType> _getAlbumArtistValueTypes = [ItemValueType.AlbumArtist];`
2	`76`	`private static readonly IReadOnlyList<ItemValueType> _getStudiosValueTypes = [ItemValueType.Studios];`
2	`77`	`private static readonly IReadOnlyList<ItemValueType> _getGenreValueTypes = [ItemValueType.Genre];`
2	`78`	`private static readonly IReadOnlyList<char> SearchWildcardTerms = ['%', '_', '[', ']', '^'];`
	`79`
	`80`	`/// <summary>`
	`81`	`/// Initializes a new instance of the <see cref="BaseItemRepository"/> class.`
	`82`	`/// </summary>`
	`83`	`/// <param name="dbProvider">The db factory.</param>`
	`84`	`/// <param name="appHost">The Application host.</param>`
	`85`	`/// <param name="itemTypeLookup">The static type lookup.</param>`
	`86`	`/// <param name="serverConfigurationManager">The server Configuration manager.</param>`
	`87`	`/// <param name="logger">System logger.</param>`
	`88`	`public BaseItemRepository(`
	`89`	`IDbContextFactory<JellyfinDbContext> dbProvider,`
	`90`	`IServerApplicationHost appHost,`
	`91`	`IItemTypeLookup itemTypeLookup,`
	`92`	`IServerConfigurationManager serverConfigurationManager,`
	`93`	`ILogger<BaseItemRepository> logger)`
	`94`	`{`
31	`95`	`_dbProvider = dbProvider;`
31	`96`	`_appHost = appHost;`
31	`97`	`_itemTypeLookup = itemTypeLookup;`
31	`98`	`_serverConfigurationManager = serverConfigurationManager;`
31	`99`	`_logger = logger;`
31	`100`	`}`
	`101`
	`102`	`/// <inheritdoc />`
	`103`	`public void DeleteItem(params IReadOnlyList<Guid> ids)`
	`104`	`{`
1	`105`	`if (ids is null \|\| ids.Count == 0 \|\| ids.Any(f => f.Equals(PlaceholderId)))`
	`106`	`{`
0	`107`	`throw new ArgumentException("Guid can't be empty or the placeholder id.", nameof(ids));`
	`108`	`}`
	`109`
1	`110`	`using var context = _dbProvider.CreateDbContext();`
1	`111`	`using var transaction = context.Database.BeginTransaction();`
	`112`
1	`113`	`var date = (DateTime?)DateTime.UtcNow;`
	`114`
1	`115`	`var relatedItems = ids.SelectMany(f => TraverseHirachyDown(f, context)).ToArray();`
	`116`
	`117`	`// Remove any UserData entries for the placeholder item that would conflict with the UserData`
	`118`	`// being detached from the item being deleted. This is necessary because, during an update,`
	`119`	`// UserData may be reattached to a new entry, but some entries can be left behind.`
	`120`	`// Ensures there are no duplicate UserId/CustomDataKey combinations for the placeholder.`
1	`121`	`context.UserData`
1	`122`	`.Join(`
1	`123`	`context.UserData.WhereOneOrMany(relatedItems, e => e.ItemId),`
1	`124`	`placeholder => new { placeholder.UserId, placeholder.CustomDataKey },`
1	`125`	`userData => new { userData.UserId, userData.CustomDataKey },`
1	`126`	`(placeholder, userData) => placeholder)`
1	`127`	`.Where(e => e.ItemId == PlaceholderId)`
1	`128`	`.ExecuteDelete();`
	`129`
	`130`	`// Detach all user watch data`
1	`131`	`context.UserData.WhereOneOrMany(relatedItems, e => e.ItemId)`
1	`132`	`.ExecuteUpdate(e => e`
1	`133`	`.SetProperty(f => f.RetentionDate, date)`
1	`134`	`.SetProperty(f => f.ItemId, PlaceholderId));`
	`135`
1	`136`	`context.AncestorIds.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`137`	`context.AncestorIds.WhereOneOrMany(relatedItems, e => e.ParentItemId).ExecuteDelete();`
1	`138`	`context.AttachmentStreamInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`139`	`context.BaseItemImageInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`140`	`context.BaseItemMetadataFields.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`141`	`context.BaseItemProviders.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`142`	`context.BaseItemTrailerTypes.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`143`	`context.BaseItems.WhereOneOrMany(relatedItems, e => e.Id).ExecuteDelete();`
1	`144`	`context.Chapters.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`145`	`context.CustomItemDisplayPreferences.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`146`	`context.ItemDisplayPreferences.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`147`	`context.ItemValues.Where(e => e.BaseItemsMap!.Count == 0).ExecuteDelete();`
1	`148`	`context.ItemValuesMap.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`149`	`context.KeyframeData.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`150`	`context.MediaSegments.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`151`	`context.MediaStreamInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`152`	`var query = context.PeopleBaseItemMap.WhereOneOrMany(relatedItems, e => e.ItemId).Select(f => f.PeopleId).Distin`
1	`153`	`context.PeopleBaseItemMap.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`154`	`context.Peoples.WhereOneOrMany(query, e => e.Id).Where(e => e.BaseItems!.Count == 0).ExecuteDelete();`
1	`155`	`context.TrickplayInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();`
1	`156`	`context.SaveChanges();`
1	`157`	`transaction.Commit();`
2	`158`	`}`
	`159`
	`160`	`/// <inheritdoc />`
	`161`	`public void UpdateInheritedValues()`
	`162`	`{`
16	`163`	`using var context = _dbProvider.CreateDbContext();`
16	`164`	`using var transaction = context.Database.BeginTransaction();`
	`165`
16	`166`	`context.ItemValuesMap.Where(e => e.ItemValue.Type == ItemValueType.InheritedTags).ExecuteDelete();`
	`167`	`// ItemValue Inheritance is now correctly mapped via AncestorId on demand`
16	`168`	`context.SaveChanges();`
	`169`
16	`170`	`transaction.Commit();`
32	`171`	`}`
	`172`
	`173`	`/// <inheritdoc />`
	`174`	`public IReadOnlyList<Guid> GetItemIdsList(InternalItemsQuery filter)`
	`175`	`{`
16	`176`	`ArgumentNullException.ThrowIfNull(filter);`
16	`177`	`PrepareFilterQuery(filter);`
	`178`
16	`179`	`using var context = _dbProvider.CreateDbContext();`
16	`180`	`return ApplyQueryFilter(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context`
16	`181`	`}`
	`182`
	`183`	`/// <inheritdoc />`
	`184`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAllArtists(InternalItemsQuery filter)`
	`185`	`{`
0	`186`	`return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtis`
	`187`	`}`
	`188`
	`189`	`/// <inheritdoc />`
	`190`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)`
	`191`	`{`
0	`192`	`return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);`
	`193`	`}`
	`194`
	`195`	`/// <inheritdoc />`
	`196`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)`
	`197`	`{`
0	`198`	`return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArti`
	`199`	`}`
	`200`
	`201`	`/// <inheritdoc />`
	`202`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)`
	`203`	`{`
0	`204`	`return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);`
	`205`	`}`
	`206`
	`207`	`/// <inheritdoc />`
	`208`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)`
	`209`	`{`
0	`210`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]);`
	`211`	`}`
	`212`
	`213`	`/// <inheritdoc />`
	`214`	`public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetMusicGenres(InternalItemsQuery filter)`
	`215`	`{`
0	`216`	`return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]);`
	`217`	`}`
	`218`
	`219`	`/// <inheritdoc />`
	`220`	`public IReadOnlyList<string> GetStudioNames()`
	`221`	`{`
16	`222`	`return GetItemValueNames(_getStudiosValueTypes, [], []);`
	`223`	`}`
	`224`
	`225`	`/// <inheritdoc />`
	`226`	`public IReadOnlyList<string> GetAllArtistNames()`
	`227`	`{`
16	`228`	`return GetItemValueNames(_getAllArtistsValueTypes, [], []);`
	`229`	`}`
	`230`
	`231`	`/// <inheritdoc />`
	`232`	`public IReadOnlyList<string> GetMusicGenreNames()`
	`233`	`{`
16	`234`	`return GetItemValueNames(`
16	`235`	`_getGenreValueTypes,`
16	`236`	`_itemTypeLookup.MusicGenreTypes,`
16	`237`	`[]);`
	`238`	`}`
	`239`
	`240`	`/// <inheritdoc />`
	`241`	`public IReadOnlyList<string> GetGenreNames()`
	`242`	`{`
16	`243`	`return GetItemValueNames(`
16	`244`	`_getGenreValueTypes,`
16	`245`	`[],`
16	`246`	`_itemTypeLookup.MusicGenreTypes);`
	`247`	`}`
	`248`
	`249`	`/// <inheritdoc />`
	`250`	`public QueryResult<BaseItemDto> GetItems(InternalItemsQuery filter)`
	`251`	`{`
1	`252`	`ArgumentNullException.ThrowIfNull(filter);`
1	`253`	`if (!filter.EnableTotalRecordCount \|\| ((filter.Limit ?? 0) == 0 && (filter.StartIndex ?? 0) == 0))`
	`254`	`{`
1	`255`	`var returnList = GetItemList(filter);`
1	`256`	`return new QueryResult<BaseItemDto>(`
1	`257`	`filter.StartIndex,`
1	`258`	`returnList.Count,`
1	`259`	`returnList);`
	`260`	`}`
	`261`
0	`262`	`PrepareFilterQuery(filter);`
0	`263`	`var result = new QueryResult<BaseItemDto>();`
	`264`
0	`265`	`using var context = _dbProvider.CreateDbContext();`
	`266`
0	`267`	`IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);`
	`268`
0	`269`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
0	`270`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
	`271`
0	`272`	`if (filter.EnableTotalRecordCount)`
	`273`	`{`
0	`274`	`result.TotalRecordCount = dbQuery.Count();`
	`275`	`}`
	`276`
0	`277`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
0	`278`	`dbQuery = ApplyNavigations(dbQuery, filter);`
	`279`
0	`280`	`result.Items = dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDe`
0	`281`	`result.StartIndex = filter.StartIndex ?? 0;`
0	`282`	`return result;`
0	`283`	`}`
	`284`
	`285`	`/// <inheritdoc />`
	`286`	`public IReadOnlyList<BaseItemDto> GetItemList(InternalItemsQuery filter)`
	`287`	`{`
320	`288`	`ArgumentNullException.ThrowIfNull(filter);`
320	`289`	`PrepareFilterQuery(filter);`
	`290`
320	`291`	`using var context = _dbProvider.CreateDbContext();`
320	`292`	`IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);`
	`293`
320	`294`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
	`295`
320	`296`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
320	`297`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
	`298`
320	`299`	`var hasRandomSort = filter.OrderBy.Any(e => e.OrderBy == ItemSortBy.Random);`
320	`300`	`if (hasRandomSort)`
	`301`	`{`
62	`302`	`var orderedIds = dbQuery.Select(e => e.Id).ToList();`
62	`303`	`if (orderedIds.Count == 0)`
	`304`	`{`
62	`305`	`return Array.Empty<BaseItemDto>();`
	`306`	`}`
	`307`
0	`308`	`var itemsById = ApplyNavigations(context.BaseItems.Where(e => orderedIds.Contains(e.Id)), filter)`
0	`309`	`.AsEnumerable()`
0	`310`	`.Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))`
0	`311`	`.Where(dto => dto is not null)`
0	`312`	`.ToDictionary(i => i!.Id);`
	`313`
0	`314`	`return orderedIds.Where(itemsById.ContainsKey).Select(id => itemsById[id]).ToArray()!;`
	`315`	`}`
	`316`
258	`317`	`dbQuery = ApplyNavigations(dbQuery, filter);`
	`318`
258	`319`	`return dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserializ`
320	`320`	`}`
	`321`
	`322`	`/// <inheritdoc/>`
	`323`	`public IReadOnlyList<BaseItem> GetLatestItemList(InternalItemsQuery filter, CollectionType collectionType)`
	`324`	`{`
0	`325`	`ArgumentNullException.ThrowIfNull(filter);`
0	`326`	`PrepareFilterQuery(filter);`
	`327`
	`328`	`// Early exit if collection type is not tvshows or music`
0	`329`	`if (collectionType != CollectionType.tvshows && collectionType != CollectionType.music)`
	`330`	`{`
0	`331`	`return Array.Empty<BaseItem>();`
	`332`	`}`
	`333`
0	`334`	`using var context = _dbProvider.CreateDbContext();`
	`335`
	`336`	`// Subquery to group by SeriesNames/Album and get the max Date Created for each group.`
0	`337`	`var subquery = PrepareItemQuery(context, filter);`
0	`338`	`subquery = TranslateQuery(subquery, context, filter);`
0	`339`	`var subqueryGrouped = subquery.GroupBy(g => collectionType == CollectionType.tvshows ? g.SeriesName : g.Album)`
0	`340`	`.Select(g => new`
0	`341`	`{`
0	`342`	`Key = g.Key,`
0	`343`	`MaxDateCreated = g.Max(a => a.DateCreated)`
0	`344`	`})`
0	`345`	`.OrderByDescending(g => g.MaxDateCreated)`
0	`346`	`.Select(g => g);`
	`347`
0	`348`	`if (filter.Limit.HasValue && filter.Limit.Value > 0)`
	`349`	`{`
0	`350`	`subqueryGrouped = subqueryGrouped.Take(filter.Limit.Value);`
	`351`	`}`
	`352`
0	`353`	`filter.Limit = null;`
	`354`
0	`355`	`var mainquery = PrepareItemQuery(context, filter);`
0	`356`	`mainquery = TranslateQuery(mainquery, context, filter);`
0	`357`	`mainquery = mainquery.Where(g => g.DateCreated >= subqueryGrouped.Min(s => s.MaxDateCreated));`
0	`358`	`mainquery = ApplyGroupingFilter(context, mainquery, filter);`
0	`359`	`mainquery = ApplyQueryPaging(mainquery, filter);`
	`360`
0	`361`	`mainquery = ApplyNavigations(mainquery, filter);`
	`362`
0	`363`	`return mainquery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserial`
0	`364`	`}`
	`365`
	`366`	`/// <inheritdoc />`
	`367`	`public IReadOnlyList<string> GetNextUpSeriesKeys(InternalItemsQuery filter, DateTime dateCutoff)`
	`368`	`{`
0	`369`	`ArgumentNullException.ThrowIfNull(filter);`
0	`370`	`ArgumentNullException.ThrowIfNull(filter.User);`
	`371`
0	`372`	`using var context = _dbProvider.CreateDbContext();`
	`373`
0	`374`	`var query = context.BaseItems`
0	`375`	`.AsNoTracking()`
0	`376`	`.Where(i => filter.TopParentIds.Contains(i.TopParentId!.Value))`
0	`377`	`.Where(i => i.Type == _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode])`
0	`378`	`.Join(`
0	`379`	`context.UserData.AsNoTracking().Where(e => e.ItemId != EF.Constant(PlaceholderId)),`
0	`380`	`i => new { UserId = filter.User.Id, ItemId = i.Id },`
0	`381`	`u => new { UserId = u.UserId, ItemId = u.ItemId },`
0	`382`	`(entity, data) => new { Item = entity, UserData = data })`
0	`383`	`.GroupBy(g => g.Item.SeriesPresentationUniqueKey)`
0	`384`	`.Select(g => new { g.Key, LastPlayedDate = g.Max(u => u.UserData.LastPlayedDate) })`
0	`385`	`.Where(g => g.Key != null && g.LastPlayedDate != null && g.LastPlayedDate >= dateCutoff)`
0	`386`	`.OrderByDescending(g => g.LastPlayedDate)`
0	`387`	`.Select(g => g.Key!);`
	`388`
0	`389`	`if (filter.Limit.HasValue && filter.Limit.Value > 0)`
	`390`	`{`
0	`391`	`query = query.Take(filter.Limit.Value);`
	`392`	`}`
	`393`
0	`394`	`return query.ToArray();`
0	`395`	`}`
	`396`
	`397`	`private IQueryable<BaseItemEntity> ApplyGroupingFilter(JellyfinDbContext context, IQueryable<BaseItemEntity> dbQuery`
	`398`	`{`
	`399`	`// This whole block is needed to filter duplicate entries on request`
	`400`	`// for the time being it cannot be used because it would destroy the ordering`
	`401`	`// this results in "duplicate" responses for queries that try to lookup individual series or multiple versions b`
	`402`	`// for that case the invoker has to run a DistinctBy(e => e.PresentationUniqueKey) on their own`
	`403`
336	`404`	`var enableGroupByPresentationUniqueKey = EnableGroupByPresentationUniqueKey(filter);`
336	`405`	`if (enableGroupByPresentationUniqueKey && filter.GroupBySeriesPresentationUniqueKey)`
	`406`	`{`
0	`407`	`var tempQuery = dbQuery.GroupBy(e => new { e.PresentationUniqueKey, e.SeriesPresentationUniqueKey }).Select(`
0	`408`	`dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));`
	`409`	`}`
336	`410`	`else if (enableGroupByPresentationUniqueKey)`
	`411`	`{`
1	`412`	`var tempQuery = dbQuery.GroupBy(e => e.PresentationUniqueKey).Select(e => e.FirstOrDefault()).Select(e => e!`
1	`413`	`dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));`
	`414`	`}`
335	`415`	`else if (filter.GroupBySeriesPresentationUniqueKey)`
	`416`	`{`
0	`417`	`var tempQuery = dbQuery.GroupBy(e => e.SeriesPresentationUniqueKey).Select(e => e.FirstOrDefault()).Select(e`
0	`418`	`dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));`
	`419`	`}`
	`420`	`else`
	`421`	`{`
335	`422`	`dbQuery = dbQuery.Distinct();`
	`423`	`}`
	`424`
336	`425`	`dbQuery = ApplyOrder(dbQuery, filter, context);`
	`426`
336	`427`	`return dbQuery;`
	`428`	`}`
	`429`
	`430`	`private static IQueryable<BaseItemEntity> ApplyNavigations(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery fi`
	`431`	`{`
274	`432`	`if (filter.TrailerTypes.Length > 0 \|\| filter.IncludeItemTypes.Contains(BaseItemKind.Trailer))`
	`433`	`{`
0	`434`	`dbQuery = dbQuery.Include(e => e.TrailerTypes);`
	`435`	`}`
	`436`
274	`437`	`if (filter.DtoOptions.ContainsField(ItemFields.ProviderIds))`
	`438`	`{`
273	`439`	`dbQuery = dbQuery.Include(e => e.Provider);`
	`440`	`}`
	`441`
274	`442`	`if (filter.DtoOptions.ContainsField(ItemFields.Settings))`
	`443`	`{`
273	`444`	`dbQuery = dbQuery.Include(e => e.LockedFields);`
	`445`	`}`
	`446`
274	`447`	`if (filter.DtoOptions.EnableUserData)`
	`448`	`{`
274	`449`	`dbQuery = dbQuery.Include(e => e.UserData);`
	`450`	`}`
	`451`
274	`452`	`if (filter.DtoOptions.EnableImages)`
	`453`	`{`
274	`454`	`dbQuery = dbQuery.Include(e => e.Images);`
	`455`	`}`
	`456`
274	`457`	`return dbQuery;`
	`458`	`}`
	`459`
	`460`	`private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)`
	`461`	`{`
336	`462`	`if (filter.StartIndex.HasValue && filter.StartIndex.Value > 0)`
	`463`	`{`
0	`464`	`dbQuery = dbQuery.Skip(filter.StartIndex.Value);`
	`465`	`}`
	`466`
336	`467`	`if (filter.Limit.HasValue && filter.Limit.Value > 0)`
	`468`	`{`
104	`469`	`dbQuery = dbQuery.Take(filter.Limit.Value);`
	`470`	`}`
	`471`
336	`472`	`return dbQuery;`
	`473`	`}`
	`474`
	`475`	`private IQueryable<BaseItemEntity> ApplyQueryFilter(IQueryable<BaseItemEntity> dbQuery, JellyfinDbContext context, I`
	`476`	`{`
16	`477`	`dbQuery = TranslateQuery(dbQuery, context, filter);`
16	`478`	`dbQuery = ApplyGroupingFilter(context, dbQuery, filter);`
16	`479`	`dbQuery = ApplyQueryPaging(dbQuery, filter);`
16	`480`	`dbQuery = ApplyNavigations(dbQuery, filter);`
16	`481`	`return dbQuery;`
	`482`	`}`
	`483`
	`484`	`private IQueryable<BaseItemEntity> PrepareItemQuery(JellyfinDbContext context, InternalItemsQuery filter)`
	`485`	`{`
406	`486`	`IQueryable<BaseItemEntity> dbQuery = context.BaseItems.AsNoTracking();`
406	`487`	`dbQuery = dbQuery.AsSingleQuery();`
	`488`
406	`489`	`return dbQuery;`
	`490`	`}`
	`491`
	`492`	`/// <inheritdoc/>`
	`493`	`public int GetCount(InternalItemsQuery filter)`
	`494`	`{`
0	`495`	`ArgumentNullException.ThrowIfNull(filter);`
	`496`	`// Hack for right now since we currently don't support filtering out these duplicates within a query`
0	`497`	`PrepareFilterQuery(filter);`
	`498`
0	`499`	`using var context = _dbProvider.CreateDbContext();`
0	`500`	`var dbQuery = TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);`
	`501`
0	`502`	`return dbQuery.Count();`
0	`503`	`}`
	`504`
	`505`	`/// <inheritdoc />`
	`506`	`public ItemCounts GetItemCounts(InternalItemsQuery filter)`
	`507`	`{`
0	`508`	`ArgumentNullException.ThrowIfNull(filter);`
	`509`	`// Hack for right now since we currently don't support filtering out these duplicates within a query`
0	`510`	`PrepareFilterQuery(filter);`
	`511`
0	`512`	`using var context = _dbProvider.CreateDbContext();`
0	`513`	`var dbQuery = TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);`
	`514`
0	`515`	`var counts = dbQuery`
0	`516`	`.GroupBy(x => x.Type)`
0	`517`	`.Select(x => new { x.Key, Count = x.Count() })`
0	`518`	`.ToArray();`
	`519`
0	`520`	`var lookup = _itemTypeLookup.BaseItemKindNames;`
0	`521`	`var result = new ItemCounts();`
0	`522`	`foreach (var count in counts)`
	`523`	`{`
0	`524`	`if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))`
	`525`	`{`
0	`526`	`result.AlbumCount = count.Count;`
	`527`	`}`
0	`528`	`else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))`
	`529`	`{`
0	`530`	`result.ArtistCount = count.Count;`
	`531`	`}`
0	`532`	`else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))`
	`533`	`{`
0	`534`	`result.EpisodeCount = count.Count;`
	`535`	`}`
0	`536`	`else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))`
	`537`	`{`
0	`538`	`result.MovieCount = count.Count;`
	`539`	`}`
0	`540`	`else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))`
	`541`	`{`
0	`542`	`result.MusicVideoCount = count.Count;`
	`543`	`}`
0	`544`	`else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))`
	`545`	`{`
0	`546`	`result.ProgramCount = count.Count;`
	`547`	`}`
0	`548`	`else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))`
	`549`	`{`
0	`550`	`result.SeriesCount = count.Count;`
	`551`	`}`
0	`552`	`else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))`
	`553`	`{`
0	`554`	`result.SongCount = count.Count;`
	`555`	`}`
0	`556`	`else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))`
	`557`	`{`
0	`558`	`result.TrailerCount = count.Count;`
	`559`	`}`
	`560`	`}`
	`561`
0	`562`	`return result;`
0	`563`	`}`
	`564`
	`565`	`#pragma warning disable CA1307 // Specify StringComparison for clarity`
	`566`	`/// <summary>`
	`567`	`/// Gets the type.`
	`568`	`/// </summary>`
	`569`	`/// <param name="typeName">Name of the type.</param>`
	`570`	`/// <returns>Type.</returns>`
	`571`	`/// <exception cref="ArgumentNullException"><c>typeName</c> is null.</exception>`
	`572`	`private static Type? GetType(string typeName)`
	`573`	`{`
145	`574`	`ArgumentException.ThrowIfNullOrEmpty(typeName);`
	`575`
	`576`	`// TODO: this isn't great. Refactor later to be both globally handled by a dedicated service not just an static`
	`577`	`// currently this is done so that plugins may introduce their own type of baseitems as we dont know when we are`
145	`578`	`return _typeMap.GetOrAdd(typeName, k => AppDomain.CurrentDomain.GetAssemblies()`
145	`579`	`.Select(a => a.GetType(k))`
145	`580`	`.FirstOrDefault(t => t is not null));`
	`581`	`}`
	`582`
	`583`	`/// <inheritdoc />`
	`584`	`public async Task SaveImagesAsync(BaseItemDto item, CancellationToken cancellationToken = default)`
	`585`	`{`
	`586`	`ArgumentNullException.ThrowIfNull(item);`
	`587`
	`588`	`var images = item.ImageInfos.Select(e => Map(item.Id, e)).ToArray();`
	`589`
	`590`	`var context = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);`
	`591`	`await using (context.ConfigureAwait(false))`
	`592`	`{`
	`593`	`if (!await context.BaseItems`
	`594`	`.AnyAsync(bi => bi.Id == item.Id, cancellationToken)`
	`595`	`.ConfigureAwait(false))`
	`596`	`{`
	`597`	`_logger.LogWarning("Unable to save ImageInfo for non existing BaseItem");`
	`598`	`return;`
	`599`	`}`
	`600`
	`601`	`await context.BaseItemImageInfos`
	`602`	`.Where(e => e.ItemId == item.Id)`
	`603`	`.ExecuteDeleteAsync(cancellationToken)`
	`604`	`.ConfigureAwait(false);`
	`605`
	`606`	`await context.BaseItemImageInfos`
	`607`	`.AddRangeAsync(images, cancellationToken)`
	`608`	`.ConfigureAwait(false);`
	`609`
	`610`	`await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);`
	`611`	`}`
	`612`	`}`
	`613`
	`614`	`/// <inheritdoc />`
	`615`	`public void SaveItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)`
	`616`	`{`
111	`617`	`UpdateOrInsertItems(items, cancellationToken);`
109	`618`	`}`
	`619`
	`620`	`/// <inheritdoc cref="IItemRepository"/>`
	`621`	`public void UpdateOrInsertItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)`
	`622`	`{`
111	`623`	`ArgumentNullException.ThrowIfNull(items);`
111	`624`	`cancellationToken.ThrowIfCancellationRequested();`
	`625`
109	`626`	`var tuples = new List<(BaseItemDto Item, List<Guid>? AncestorIds, BaseItemDto TopParent, IEnumerable<string> Use`
436	`627`	`foreach (var item in items.GroupBy(e => e.Id).Select(e => e.Last()).Where(e => e.Id != PlaceholderId))`
	`628`	`{`
109	`629`	`var ancestorIds = item.SupportsAncestors ?`
109	`630`	`item.GetAncestorIds().Distinct().ToList() :`
109	`631`	`null;`
	`632`
109	`633`	`var topParent = item.GetTopParent();`
	`634`
109	`635`	`var userdataKey = item.GetUserDataKeys();`
109	`636`	`var inheritedTags = item.GetInheritedTags();`
	`637`
109	`638`	`tuples.Add((item, ancestorIds, topParent, userdataKey, inheritedTags));`
	`639`	`}`
	`640`
109	`641`	`using var context = _dbProvider.CreateDbContext();`
109	`642`	`using var transaction = context.Database.BeginTransaction();`
	`643`
109	`644`	`var ids = tuples.Select(f => f.Item.Id).ToArray();`
109	`645`	`var existingItems = context.BaseItems.Where(e => ids.Contains(e.Id)).Select(f => f.Id).ToArray();`
	`646`
436	`647`	`foreach (var item in tuples)`
	`648`	`{`
109	`649`	`var entity = Map(item.Item);`
	`650`	`// TODO: refactor this "inconsistency"`
109	`651`	`entity.TopParentId = item.TopParent?.Id;`
	`652`
109	`653`	`if (!existingItems.Any(e => e == entity.Id))`
	`654`	`{`
59	`655`	`context.BaseItems.Add(entity);`
	`656`	`}`
	`657`	`else`
	`658`	`{`
50	`659`	`context.BaseItemProviders.Where(e => e.ItemId == entity.Id).ExecuteDelete();`
50	`660`	`context.BaseItemImageInfos.Where(e => e.ItemId == entity.Id).ExecuteDelete();`
50	`661`	`context.BaseItemMetadataFields.Where(e => e.ItemId == entity.Id).ExecuteDelete();`
	`662`
50	`663`	`if (entity.Images is { Count: > 0 })`
	`664`	`{`
0	`665`	`context.BaseItemImageInfos.AddRange(entity.Images);`
	`666`	`}`
	`667`
50	`668`	`if (entity.LockedFields is { Count: > 0 })`
	`669`	`{`
0	`670`	`context.BaseItemMetadataFields.AddRange(entity.LockedFields);`
	`671`	`}`
	`672`
50	`673`	`context.BaseItems.Attach(entity).State = EntityState.Modified;`
	`674`	`}`
	`675`	`}`
	`676`
109	`677`	`context.SaveChanges();`
	`678`
109	`679`	`var itemValueMaps = tuples`
109	`680`	`.Select(e => (e.Item, Values: GetItemValuesToSave(e.Item, e.InheritedTags)))`
109	`681`	`.ToArray();`
109	`682`	`var allListedItemValues = itemValueMaps`
109	`683`	`.SelectMany(f => f.Values)`
109	`684`	`.Distinct()`
109	`685`	`.ToArray();`
109	`686`	`var existingValues = context.ItemValues`
109	`687`	`.Select(e => new`
109	`688`	`{`
109	`689`	`item = e,`
109	`690`	`Key = e.Type + "+" + e.Value`
109	`691`	`})`
109	`692`	`.Where(f => allListedItemValues.Select(e => $"{(int)e.MagicNumber}+{e.Value}").Contains(f.Key))`
109	`693`	`.Select(e => e.item)`
109	`694`	`.ToArray();`
109	`695`	`var missingItemValues = allListedItemValues.Except(existingValues.Select(f => (MagicNumber: f.Type, f.Value))).S`
109	`696`	`{`
109	`697`	`CleanValue = GetCleanValue(f.Value),`
109	`698`	`ItemValueId = Guid.NewGuid(),`
109	`699`	`Type = f.MagicNumber,`
109	`700`	`Value = f.Value`
109	`701`	`}).ToArray();`
109	`702`	`context.ItemValues.AddRange(missingItemValues);`
109	`703`	`context.SaveChanges();`
	`704`
109	`705`	`var itemValuesStore = existingValues.Concat(missingItemValues).ToArray();`
109	`706`	`var valueMap = itemValueMaps`
109	`707`	`.Select(f => (f.Item, Values: f.Values.Select(e => itemValuesStore.First(g => g.Value == e.Value && g.Type =`
109	`708`	`.ToArray();`
	`709`
109	`710`	`var mappedValues = context.ItemValuesMap.Where(e => ids.Contains(e.ItemId)).ToList();`
	`711`
436	`712`	`foreach (var item in valueMap)`
	`713`	`{`
109	`714`	`var itemMappedValues = mappedValues.Where(e => e.ItemId == item.Item.Id).ToList();`
218	`715`	`foreach (var itemValue in item.Values)`
	`716`	`{`
0	`717`	`var existingItem = itemMappedValues.FirstOrDefault(f => f.ItemValueId == itemValue.ItemValueId);`
0	`718`	`if (existingItem is null)`
	`719`	`{`
0	`720`	`context.ItemValuesMap.Add(new ItemValueMap()`
0	`721`	`{`
0	`722`	`Item = null!,`
0	`723`	`ItemId = item.Item.Id,`
0	`724`	`ItemValue = null!,`
0	`725`	`ItemValueId = itemValue.ItemValueId`
0	`726`	`});`
	`727`	`}`
	`728`	`else`
	`729`	`{`
	`730`	`// map exists, remove from list so its been handled.`
0	`731`	`itemMappedValues.Remove(existingItem);`
	`732`	`}`
	`733`	`}`
	`734`
	`735`	`// all still listed values are not in the new list so remove them.`
109	`736`	`context.ItemValuesMap.RemoveRange(itemMappedValues);`
	`737`	`}`
	`738`
109	`739`	`context.SaveChanges();`
	`740`
436	`741`	`foreach (var item in tuples)`
	`742`	`{`
109	`743`	`if (item.Item.SupportsAncestors && item.AncestorIds != null)`
	`744`	`{`
109	`745`	`var existingAncestorIds = context.AncestorIds.Where(e => e.ItemId == item.Item.Id).ToList();`
109	`746`	`var validAncestorIds = context.BaseItems.Where(e => item.AncestorIds.Contains(e.Id)).Select(f => f.Id).T`
272	`747`	`foreach (var ancestorId in validAncestorIds)`
	`748`	`{`
27	`749`	`var existingAncestorId = existingAncestorIds.FirstOrDefault(e => e.ParentItemId == ancestorId);`
27	`750`	`if (existingAncestorId is null)`
	`751`	`{`
23	`752`	`context.AncestorIds.Add(new AncestorId()`
23	`753`	`{`
23	`754`	`ParentItemId = ancestorId,`
23	`755`	`ItemId = item.Item.Id,`
23	`756`	`Item = null!,`
23	`757`	`ParentItem = null!`
23	`758`	`});`
	`759`	`}`
	`760`	`else`
	`761`	`{`
4	`762`	`existingAncestorIds.Remove(existingAncestorId);`
	`763`	`}`
	`764`	`}`
	`765`
109	`766`	`context.AncestorIds.RemoveRange(existingAncestorIds);`
	`767`	`}`
	`768`	`}`
	`769`
109	`770`	`context.SaveChanges();`
109	`771`	`transaction.Commit();`
218	`772`	`}`
	`773`
	`774`	`/// <inheritdoc />`
	`775`	`public async Task ReattachUserDataAsync(BaseItemDto item, CancellationToken cancellationToken)`
	`776`	`{`
	`777`	`ArgumentNullException.ThrowIfNull(item);`
	`778`	`cancellationToken.ThrowIfCancellationRequested();`
	`779`
	`780`	`var dbContext = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);`
	`781`
	`782`	`await using (dbContext.ConfigureAwait(false))`
	`783`	`{`
	`784`	`var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);`
	`785`	`await using (transaction.ConfigureAwait(false))`
	`786`	`{`
	`787`	`var userKeys = item.GetUserDataKeys().ToArray();`
	`788`	`var retentionDate = (DateTime?)null;`
	`789`
	`790`	`await dbContext.UserData`
	`791`	`.Where(e => e.ItemId == PlaceholderId)`
	`792`	`.Where(e => userKeys.Contains(e.CustomDataKey))`
	`793`	`.ExecuteUpdateAsync(`
	`794`	`e => e`
	`795`	`.SetProperty(f => f.ItemId, item.Id)`
	`796`	`.SetProperty(f => f.RetentionDate, retentionDate),`
	`797`	`cancellationToken).ConfigureAwait(false);`
	`798`
	`799`	`// Rehydrate the cached userdata`
	`800`	`item.UserData = await dbContext.UserData`
	`801`	`.AsNoTracking()`
	`802`	`.Where(e => e.ItemId == item.Id)`
	`803`	`.ToArrayAsync(cancellationToken)`
	`804`	`.ConfigureAwait(false);`
	`805`
	`806`	`await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);`
	`807`	`}`
	`808`	`}`
	`809`	`}`
	`810`
	`811`	`/// <inheritdoc />`
	`812`	`public BaseItemDto? RetrieveItem(Guid id)`
	`813`	`{`
86	`814`	`if (id.IsEmpty())`
	`815`	`{`
0	`816`	`throw new ArgumentException("Guid can't be empty", nameof(id));`
	`817`	`}`
	`818`
86	`819`	`using var context = _dbProvider.CreateDbContext();`
86	`820`	`var dbQuery = PrepareItemQuery(context, new()`
86	`821`	`{`
86	`822`	`DtoOptions = new()`
86	`823`	`{`
86	`824`	`EnableImages = true`
86	`825`	`}`
86	`826`	`});`
86	`827`	`dbQuery = dbQuery.Include(e => e.TrailerTypes)`
86	`828`	`.Include(e => e.Provider)`
86	`829`	`.Include(e => e.LockedFields)`
86	`830`	`.Include(e => e.UserData)`
86	`831`	`.Include(e => e.Images);`
	`832`
86	`833`	`var item = dbQuery.FirstOrDefault(e => e.Id == id);`
86	`834`	`if (item is null)`
	`835`	`{`
86	`836`	`return null;`
	`837`	`}`
	`838`
0	`839`	`return DeserializeBaseItem(item);`
86	`840`	`}`
	`841`
	`842`	`/// <summary>`
	`843`	`/// Maps a Entity to the DTO.`
	`844`	`/// </summary>`
	`845`	`/// <param name="entity">The entity.</param>`
	`846`	`/// <param name="dto">The dto base instance.</param>`
	`847`	`/// <param name="appHost">The Application server Host.</param>`
	`848`	`/// <param name="logger">The applogger.</param>`
	`849`	`/// <returns>The dto to map.</returns>`
	`850`	`public static BaseItemDto Map(BaseItemEntity entity, BaseItemDto dto, IServerApplicationHost? appHost, ILogger logge`
	`851`	`{`
72	`852`	`dto.Id = entity.Id;`
72	`853`	`dto.ParentId = entity.ParentId.GetValueOrDefault();`
72	`854`	`dto.Path = appHost?.ExpandVirtualPath(entity.Path) ?? entity.Path;`
72	`855`	`dto.EndDate = entity.EndDate;`
72	`856`	`dto.CommunityRating = entity.CommunityRating;`
72	`857`	`dto.CustomRating = entity.CustomRating;`
72	`858`	`dto.IndexNumber = entity.IndexNumber;`
72	`859`	`dto.IsLocked = entity.IsLocked;`
72	`860`	`dto.Name = entity.Name;`
72	`861`	`dto.OfficialRating = entity.OfficialRating;`
72	`862`	`dto.Overview = entity.Overview;`
72	`863`	`dto.ParentIndexNumber = entity.ParentIndexNumber;`
72	`864`	`dto.PremiereDate = entity.PremiereDate;`
72	`865`	`dto.ProductionYear = entity.ProductionYear;`
72	`866`	`dto.SortName = entity.SortName;`
72	`867`	`dto.ForcedSortName = entity.ForcedSortName;`
72	`868`	`dto.RunTimeTicks = entity.RunTimeTicks;`
72	`869`	`dto.PreferredMetadataLanguage = entity.PreferredMetadataLanguage;`
72	`870`	`dto.PreferredMetadataCountryCode = entity.PreferredMetadataCountryCode;`
72	`871`	`dto.IsInMixedFolder = entity.IsInMixedFolder;`
72	`872`	`dto.InheritedParentalRatingValue = entity.InheritedParentalRatingValue;`
72	`873`	`dto.InheritedParentalRatingSubValue = entity.InheritedParentalRatingSubValue;`
72	`874`	`dto.CriticRating = entity.CriticRating;`
72	`875`	`dto.PresentationUniqueKey = entity.PresentationUniqueKey;`
72	`876`	`dto.OriginalTitle = entity.OriginalTitle;`
72	`877`	`dto.Album = entity.Album;`
72	`878`	`dto.LUFS = entity.LUFS;`
72	`879`	`dto.NormalizationGain = entity.NormalizationGain;`
72	`880`	`dto.IsVirtualItem = entity.IsVirtualItem;`
72	`881`	`dto.ExternalSeriesId = entity.ExternalSeriesId;`
72	`882`	`dto.Tagline = entity.Tagline;`
72	`883`	`dto.TotalBitrate = entity.TotalBitrate;`
72	`884`	`dto.ExternalId = entity.ExternalId;`
72	`885`	`dto.Size = entity.Size;`
72	`886`	`dto.Genres = string.IsNullOrWhiteSpace(entity.Genres) ? [] : entity.Genres.Split('\|');`
72	`887`	`dto.DateCreated = entity.DateCreated ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);`
72	`888`	`dto.DateModified = entity.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);`
72	`889`	`dto.ChannelId = entity.ChannelId ?? Guid.Empty;`
72	`890`	`dto.DateLastRefreshed = entity.DateLastRefreshed ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);`
72	`891`	`dto.DateLastSaved = entity.DateLastSaved ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);`
72	`892`	`dto.OwnerId = string.IsNullOrWhiteSpace(entity.OwnerId) ? Guid.Empty : (Guid.TryParse(entity.OwnerId, out var ow`
72	`893`	`dto.Width = entity.Width.GetValueOrDefault();`
72	`894`	`dto.Height = entity.Height.GetValueOrDefault();`
72	`895`	`dto.UserData = entity.UserData;`
	`896`
72	`897`	`if (entity.Provider is not null)`
	`898`	`{`
71	`899`	`dto.ProviderIds = entity.Provider.ToDictionary(e => e.ProviderId, e => e.ProviderValue);`
	`900`	`}`
	`901`
72	`902`	`if (entity.ExtraType is not null)`
	`903`	`{`
0	`904`	`dto.ExtraType = (ExtraType)entity.ExtraType;`
	`905`	`}`
	`906`
72	`907`	`if (entity.LockedFields is not null)`
	`908`	`{`
71	`909`	`dto.LockedFields = entity.LockedFields?.Select(e => (MetadataField)e.Id).ToArray() ?? [];`
	`910`	`}`
	`911`
72	`912`	`if (entity.Audio is not null)`
	`913`	`{`
0	`914`	`dto.Audio = (ProgramAudio)entity.Audio;`
	`915`	`}`
	`916`
72	`917`	`dto.ExtraIds = string.IsNullOrWhiteSpace(entity.ExtraIds) ? [] : entity.ExtraIds.Split('\|').Select(e => Guid.Par`
72	`918`	`dto.ProductionLocations = entity.ProductionLocations?.Split('\|', StringSplitOptions.RemoveEmptyEntries) ?? [];`
72	`919`	`dto.Studios = entity.Studios?.Split('\|') ?? [];`
72	`920`	`dto.Tags = string.IsNullOrWhiteSpace(entity.Tags) ? [] : entity.Tags.Split('\|');`
	`921`
72	`922`	`if (dto is IHasProgramAttributes hasProgramAttributes)`
	`923`	`{`
0	`924`	`hasProgramAttributes.IsMovie = entity.IsMovie;`
0	`925`	`hasProgramAttributes.IsSeries = entity.IsSeries;`
0	`926`	`hasProgramAttributes.EpisodeTitle = entity.EpisodeTitle;`
0	`927`	`hasProgramAttributes.IsRepeat = entity.IsRepeat;`
	`928`	`}`
	`929`
72	`930`	`if (dto is LiveTvChannel liveTvChannel)`
	`931`	`{`
0	`932`	`liveTvChannel.ServiceName = entity.ExternalServiceId;`
	`933`	`}`
	`934`
72	`935`	`if (dto is Trailer trailer)`
	`936`	`{`
0	`937`	`trailer.TrailerTypes = entity.TrailerTypes?.Select(e => (TrailerType)e.Id).ToArray() ?? [];`
	`938`	`}`
	`939`
72	`940`	`if (dto is Video video)`
	`941`	`{`
1	`942`	`video.PrimaryVersionId = entity.PrimaryVersionId;`
	`943`	`}`
	`944`
72	`945`	`if (dto is IHasSeries hasSeriesName)`
	`946`	`{`
0	`947`	`hasSeriesName.SeriesName = entity.SeriesName;`
0	`948`	`hasSeriesName.SeriesId = entity.SeriesId.GetValueOrDefault();`
0	`949`	`hasSeriesName.SeriesPresentationUniqueKey = entity.SeriesPresentationUniqueKey;`
	`950`	`}`
	`951`
72	`952`	`if (dto is Episode episode)`
	`953`	`{`
0	`954`	`episode.SeasonName = entity.SeasonName;`
0	`955`	`episode.SeasonId = entity.SeasonId.GetValueOrDefault();`
	`956`	`}`
	`957`
72	`958`	`if (dto is IHasArtist hasArtists)`
	`959`	`{`
0	`960`	`hasArtists.Artists = entity.Artists?.Split('\|', StringSplitOptions.RemoveEmptyEntries) ?? [];`
	`961`	`}`
	`962`
72	`963`	`if (dto is IHasAlbumArtist hasAlbumArtists)`
	`964`	`{`
0	`965`	`hasAlbumArtists.AlbumArtists = entity.AlbumArtists?.Split('\|', StringSplitOptions.RemoveEmptyEntries) ?? [];`
	`966`	`}`
	`967`
72	`968`	`if (dto is LiveTvProgram program)`
	`969`	`{`
0	`970`	`program.ShowId = entity.ShowId;`
	`971`	`}`
	`972`
72	`973`	`if (entity.Images is not null)`
	`974`	`{`
71	`975`	`dto.ImageInfos = entity.Images.Select(e => Map(e, appHost)).ToArray();`
	`976`	`}`
	`977`
	`978`	`// dto.Type = entity.Type;`
	`979`	`// dto.Data = entity.Data;`
	`980`	`// dto.MediaType = Enum.TryParse<MediaType>(entity.MediaType);`
72	`981`	`if (dto is IHasStartDate hasStartDate)`
	`982`	`{`
0	`983`	`hasStartDate.StartDate = entity.StartDate.GetValueOrDefault();`
	`984`	`}`
	`985`
	`986`	`// Fields that are present in the DB but are never actually used`
	`987`	`// dto.UnratedType = entity.UnratedType;`
	`988`	`// dto.TopParentId = entity.TopParentId;`
	`989`	`// dto.CleanName = entity.CleanName;`
	`990`	`// dto.UserDataKey = entity.UserDataKey;`
	`991`
72	`992`	`if (dto is Folder folder)`
	`993`	`{`
71	`994`	`folder.DateLastMediaAdded = entity.DateLastMediaAdded ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKin`
	`995`	`}`
	`996`
72	`997`	`return dto;`
	`998`	`}`
	`999`
	`1000`	`/// <summary>`
	`1001`	`/// Maps a Entity to the DTO.`
	`1002`	`/// </summary>`
	`1003`	`/// <param name="dto">The entity.</param>`
	`1004`	`/// <returns>The dto to map.</returns>`
	`1005`	`public BaseItemEntity Map(BaseItemDto dto)`
	`1006`	`{`
119	`1007`	`var dtoType = dto.GetType();`
119	`1008`	`var entity = new BaseItemEntity()`
119	`1009`	`{`
119	`1010`	`Type = dtoType.ToString(),`
119	`1011`	`Id = dto.Id`
119	`1012`	`};`
	`1013`
119	`1014`	`if (TypeRequiresDeserialization(dtoType))`
	`1015`	`{`
98	`1016`	`entity.Data = JsonSerializer.Serialize(dto, dtoType, JsonDefaults.Options);`
	`1017`	`}`
	`1018`
119	`1019`	`entity.ParentId = !dto.ParentId.IsEmpty() ? dto.ParentId : null;`
119	`1020`	`entity.Path = GetPathToSave(dto.Path);`
119	`1021`	`entity.EndDate = dto.EndDate;`
119	`1022`	`entity.CommunityRating = dto.CommunityRating;`
119	`1023`	`entity.CustomRating = dto.CustomRating;`
119	`1024`	`entity.IndexNumber = dto.IndexNumber;`
119	`1025`	`entity.IsLocked = dto.IsLocked;`
119	`1026`	`entity.Name = dto.Name;`
119	`1027`	`entity.CleanName = GetCleanValue(dto.Name);`
119	`1028`	`entity.OfficialRating = dto.OfficialRating;`
119	`1029`	`entity.Overview = dto.Overview;`
119	`1030`	`entity.ParentIndexNumber = dto.ParentIndexNumber;`
119	`1031`	`entity.PremiereDate = dto.PremiereDate;`
119	`1032`	`entity.ProductionYear = dto.ProductionYear;`
119	`1033`	`entity.SortName = dto.SortName;`
119	`1034`	`entity.ForcedSortName = dto.ForcedSortName;`
119	`1035`	`entity.RunTimeTicks = dto.RunTimeTicks;`
119	`1036`	`entity.PreferredMetadataLanguage = dto.PreferredMetadataLanguage;`
119	`1037`	`entity.PreferredMetadataCountryCode = dto.PreferredMetadataCountryCode;`
119	`1038`	`entity.IsInMixedFolder = dto.IsInMixedFolder;`
119	`1039`	`entity.InheritedParentalRatingValue = dto.InheritedParentalRatingValue;`
119	`1040`	`entity.InheritedParentalRatingSubValue = dto.InheritedParentalRatingSubValue;`
119	`1041`	`entity.CriticRating = dto.CriticRating;`
119	`1042`	`entity.PresentationUniqueKey = dto.PresentationUniqueKey;`
119	`1043`	`entity.OriginalTitle = dto.OriginalTitle;`
119	`1044`	`entity.Album = dto.Album;`
119	`1045`	`entity.LUFS = dto.LUFS;`
119	`1046`	`entity.NormalizationGain = dto.NormalizationGain;`
119	`1047`	`entity.IsVirtualItem = dto.IsVirtualItem;`
119	`1048`	`entity.ExternalSeriesId = dto.ExternalSeriesId;`
119	`1049`	`entity.Tagline = dto.Tagline;`
119	`1050`	`entity.TotalBitrate = dto.TotalBitrate;`
119	`1051`	`entity.ExternalId = dto.ExternalId;`
119	`1052`	`entity.Size = dto.Size;`
119	`1053`	`entity.Genres = string.Join('\|', dto.Genres);`
119	`1054`	`entity.DateCreated = dto.DateCreated == DateTime.MinValue ? null : dto.DateCreated;`
119	`1055`	`entity.DateModified = dto.DateModified == DateTime.MinValue ? null : dto.DateModified;`
119	`1056`	`entity.ChannelId = dto.ChannelId;`
119	`1057`	`entity.DateLastRefreshed = dto.DateLastRefreshed == DateTime.MinValue ? null : dto.DateLastRefreshed;`
119	`1058`	`entity.DateLastSaved = dto.DateLastSaved == DateTime.MinValue ? null : dto.DateLastSaved;`
119	`1059`	`entity.OwnerId = dto.OwnerId.ToString();`
119	`1060`	`entity.Width = dto.Width;`
119	`1061`	`entity.Height = dto.Height;`
119	`1062`	`entity.Provider = dto.ProviderIds.Select(e => new BaseItemProvider()`
119	`1063`	`{`
119	`1064`	`Item = entity,`
119	`1065`	`ProviderId = e.Key,`
119	`1066`	`ProviderValue = e.Value`
119	`1067`	`}).ToList();`
	`1068`
119	`1069`	`if (dto.Audio.HasValue)`
	`1070`	`{`
0	`1071`	`entity.Audio = (ProgramAudioEntity)dto.Audio;`
	`1072`	`}`
	`1073`
119	`1074`	`if (dto.ExtraType.HasValue)`
	`1075`	`{`
0	`1076`	`entity.ExtraType = (BaseItemExtraType)dto.ExtraType;`
	`1077`	`}`
	`1078`
119	`1079`	`entity.ExtraIds = dto.ExtraIds is not null ? string.Join('\|', dto.ExtraIds) : null;`
119	`1080`	`entity.ProductionLocations = dto.ProductionLocations is not null ? string.Join('\|', dto.ProductionLocations.Wher`
119	`1081`	`entity.Studios = dto.Studios is not null ? string.Join('\|', dto.Studios) : null;`
119	`1082`	`entity.Tags = dto.Tags is not null ? string.Join('\|', dto.Tags) : null;`
119	`1083`	`entity.LockedFields = dto.LockedFields is not null ? dto.LockedFields`
119	`1084`	`.Select(e => new BaseItemMetadataField()`
119	`1085`	`{`
119	`1086`	`Id = (int)e,`
119	`1087`	`Item = entity,`
119	`1088`	`ItemId = entity.Id`
119	`1089`	`})`
119	`1090`	`.ToArray() : null;`
	`1091`
119	`1092`	`if (dto is IHasProgramAttributes hasProgramAttributes)`
	`1093`	`{`
0	`1094`	`entity.IsMovie = hasProgramAttributes.IsMovie;`
0	`1095`	`entity.IsSeries = hasProgramAttributes.IsSeries;`
0	`1096`	`entity.EpisodeTitle = hasProgramAttributes.EpisodeTitle;`
0	`1097`	`entity.IsRepeat = hasProgramAttributes.IsRepeat;`
	`1098`	`}`
	`1099`
119	`1100`	`if (dto is LiveTvChannel liveTvChannel)`
	`1101`	`{`
0	`1102`	`entity.ExternalServiceId = liveTvChannel.ServiceName;`
	`1103`	`}`
	`1104`
119	`1105`	`if (dto is Video video)`
	`1106`	`{`
0	`1107`	`entity.PrimaryVersionId = video.PrimaryVersionId;`
	`1108`	`}`
	`1109`
119	`1110`	`if (dto is IHasSeries hasSeriesName)`
	`1111`	`{`
0	`1112`	`entity.SeriesName = hasSeriesName.SeriesName;`
0	`1113`	`entity.SeriesId = hasSeriesName.SeriesId;`
0	`1114`	`entity.SeriesPresentationUniqueKey = hasSeriesName.SeriesPresentationUniqueKey;`
	`1115`	`}`
	`1116`
119	`1117`	`if (dto is Episode episode)`
	`1118`	`{`
0	`1119`	`entity.SeasonName = episode.SeasonName;`
0	`1120`	`entity.SeasonId = episode.SeasonId;`
	`1121`	`}`
	`1122`
119	`1123`	`if (dto is IHasArtist hasArtists)`
	`1124`	`{`
0	`1125`	`entity.Artists = hasArtists.Artists is not null ? string.Join('\|', hasArtists.Artists) : null;`
	`1126`	`}`
	`1127`
119	`1128`	`if (dto is IHasAlbumArtist hasAlbumArtists)`
	`1129`	`{`
0	`1130`	`entity.AlbumArtists = hasAlbumArtists.AlbumArtists is not null ? string.Join('\|', hasAlbumArtists.AlbumArtis`
	`1131`	`}`
	`1132`
119	`1133`	`if (dto is LiveTvProgram program)`
	`1134`	`{`
0	`1135`	`entity.ShowId = program.ShowId;`
	`1136`	`}`
	`1137`
119	`1138`	`if (dto.ImageInfos is not null)`
	`1139`	`{`
119	`1140`	`entity.Images = dto.ImageInfos.Select(f => Map(dto.Id, f)).ToArray();`
	`1141`	`}`
	`1142`
119	`1143`	`if (dto is Trailer trailer)`
	`1144`	`{`
0	`1145`	`entity.TrailerTypes = trailer.TrailerTypes?.Select(e => new BaseItemTrailerType()`
0	`1146`	`{`
0	`1147`	`Id = (int)e,`
0	`1148`	`Item = entity,`
0	`1149`	`ItemId = entity.Id`
0	`1150`	`}).ToArray() ?? [];`
	`1151`	`}`
	`1152`
	`1153`	`// dto.Type = entity.Type;`
	`1154`	`// dto.Data = entity.Data;`
119	`1155`	`entity.MediaType = dto.MediaType.ToString();`
119	`1156`	`if (dto is IHasStartDate hasStartDate)`
	`1157`	`{`
0	`1158`	`entity.StartDate = hasStartDate.StartDate;`
	`1159`	`}`
	`1160`
119	`1161`	`entity.UnratedType = dto.GetBlockUnratedType().ToString();`
	`1162`
	`1163`	`// Fields that are present in the DB but are never actually used`
	`1164`	`// dto.UserDataKey = entity.UserDataKey;`
	`1165`
119	`1166`	`if (dto is Folder folder)`
	`1167`	`{`
119	`1168`	`entity.DateLastMediaAdded = folder.DateLastMediaAdded == DateTime.MinValue ? null : folder.DateLastMediaAdde`
119	`1169`	`entity.IsFolder = folder.IsFolder;`
	`1170`	`}`
	`1171`
119	`1172`	`return entity;`
	`1173`	`}`
	`1174`
	`1175`	`private string[] GetItemValueNames(IReadOnlyList<ItemValueType> itemValueTypes, IReadOnlyList<string> withItemTypes,`
	`1176`	`{`
64	`1177`	`using var context = _dbProvider.CreateDbContext();`
	`1178`
64	`1179`	`var query = context.ItemValuesMap`
64	`1180`	`.AsNoTracking()`
64	`1181`	`.Where(e => itemValueTypes.Any(w => (ItemValueType)w == e.ItemValue.Type));`
64	`1182`	`if (withItemTypes.Count > 0)`
	`1183`	`{`
16	`1184`	`query = query.Where(e => withItemTypes.Contains(e.Item.Type));`
	`1185`	`}`
	`1186`
64	`1187`	`if (excludeItemTypes.Count > 0)`
	`1188`	`{`
16	`1189`	`query = query.Where(e => !excludeItemTypes.Contains(e.Item.Type));`
	`1190`	`}`
	`1191`
	`1192`	`// query = query.DistinctBy(e => e.CleanValue);`
64	`1193`	`return query.Select(e => e.ItemValue)`
64	`1194`	`.GroupBy(e => e.CleanValue)`
64	`1195`	`.Select(e => e.First().Value)`
64	`1196`	`.ToArray();`
64	`1197`	`}`
	`1198`
	`1199`	`private static bool TypeRequiresDeserialization(Type type)`
	`1200`	`{`
191	`1201`	`return type.GetCustomAttribute<RequiresSourceSerialisationAttribute>() == null;`
	`1202`	`}`
	`1203`
	`1204`	`private BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, bool skipDeserialization = false)`
	`1205`	`{`
71	`1206`	`ArgumentNullException.ThrowIfNull(baseItemEntity, nameof(baseItemEntity));`
71	`1207`	`if (_serverConfigurationManager?.Configuration is null)`
	`1208`	`{`
0	`1209`	`throw new InvalidOperationException("Server Configuration manager or configuration is null");`
	`1210`	`}`
	`1211`
71	`1212`	`var typeToSerialise = GetType(baseItemEntity.Type);`
71	`1213`	`return BaseItemRepository.DeserializeBaseItem(`
71	`1214`	`baseItemEntity,`
71	`1215`	`_logger,`
71	`1216`	`_appHost,`
71	`1217`	`skipDeserialization \|\| (_serverConfigurationManager.Configuration.SkipDeserializationForBasicTypes && (typeT`
	`1218`	`}`
	`1219`
	`1220`	`/// <summary>`
	`1221`	`/// Deserializes a BaseItemEntity and sets all properties.`
	`1222`	`/// </summary>`
	`1223`	`/// <param name="baseItemEntity">The DB entity.</param>`
	`1224`	`/// <param name="logger">Logger.</param>`
	`1225`	`/// <param name="appHost">The application server Host.</param>`
	`1226`	`/// <param name="skipDeserialization">If only mapping should be processed.</param>`
	`1227`	`/// <returns>A mapped BaseItem, or null if the item type is unknown.</returns>`
	`1228`	`public static BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost`
	`1229`	`{`
74	`1230`	`var type = GetType(baseItemEntity.Type);`
74	`1231`	`if (type is null)`
	`1232`	`{`
2	`1233`	`logger.LogWarning(`
2	`1234`	`"Skipping item {ItemId} with unknown type '{ItemType}'. This may indicate a removed plugin or database c`
2	`1235`	`baseItemEntity.Id,`
2	`1236`	`baseItemEntity.Type);`
2	`1237`	`return null;`
	`1238`	`}`
	`1239`
72	`1240`	`BaseItemDto? dto = null;`
72	`1241`	`if (TypeRequiresDeserialization(type) && baseItemEntity.Data is not null && !skipDeserialization)`
	`1242`	`{`
	`1243`	`try`
	`1244`	`{`
12	`1245`	`dto = JsonSerializer.Deserialize(baseItemEntity.Data, type, JsonDefaults.Options) as BaseItemDto;`
12	`1246`	`}`
0	`1247`	`catch (JsonException ex)`
	`1248`	`{`
0	`1249`	`logger.LogError(ex, "Error deserializing item with JSON: {Data}", baseItemEntity.Data);`
0	`1250`	`}`
	`1251`	`}`
	`1252`
72	`1253`	`if (dto is null)`
	`1254`	`{`
60	`1255`	`dto = Activator.CreateInstance(type) as BaseItemDto ?? throw new InvalidOperationException("Cannot deseriali`
	`1256`	`}`
	`1257`
72	`1258`	`return Map(baseItemEntity, dto, appHost, logger);`
	`1259`	`}`
	`1260`
	`1261`	`private QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetItemValues(InternalItemsQuery filter, IReadOnlyLi`
	`1262`	`{`
0	`1263`	`ArgumentNullException.ThrowIfNull(filter);`
	`1264`
0	`1265`	`if (!(filter.Limit.HasValue && filter.Limit.Value > 0))`
	`1266`	`{`
0	`1267`	`filter.EnableTotalRecordCount = false;`
	`1268`	`}`
	`1269`
0	`1270`	`using var context = _dbProvider.CreateDbContext();`
	`1271`
0	`1272`	`var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context,`
0	`1273`	`{`
0	`1274`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`1275`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`1276`	`MediaTypes = filter.MediaTypes,`
0	`1277`	`AncestorIds = filter.AncestorIds,`
0	`1278`	`ItemIds = filter.ItemIds,`
0	`1279`	`TopParentIds = filter.TopParentIds,`
0	`1280`	`ParentId = filter.ParentId,`
0	`1281`	`IsAiring = filter.IsAiring,`
0	`1282`	`IsMovie = filter.IsMovie,`
0	`1283`	`IsSports = filter.IsSports,`
0	`1284`	`IsKids = filter.IsKids,`
0	`1285`	`IsNews = filter.IsNews,`
0	`1286`	`IsSeries = filter.IsSeries`
0	`1287`	`});`
	`1288`
0	`1289`	`var itemValuesQuery = context.ItemValues`
0	`1290`	`.Where(f => itemValueTypes.Contains(f.Type))`
0	`1291`	`.SelectMany(f => f.BaseItemsMap!, (f, w) => new { f, w })`
0	`1292`	`.Join(`
0	`1293`	`innerQueryFilter,`
0	`1294`	`fw => fw.w.ItemId,`
0	`1295`	`g => g.Id,`
0	`1296`	`(fw, g) => fw.f.CleanValue);`
	`1297`
0	`1298`	`var innerQuery = PrepareItemQuery(context, filter)`
0	`1299`	`.Where(e => e.Type == returnType)`
0	`1300`	`.Where(e => itemValuesQuery.Contains(e.CleanName));`
	`1301`
0	`1302`	`var outerQueryFilter = new InternalItemsQuery(filter.User)`
0	`1303`	`{`
0	`1304`	`IsPlayed = filter.IsPlayed,`
0	`1305`	`IsFavorite = filter.IsFavorite,`
0	`1306`	`IsFavoriteOrLiked = filter.IsFavoriteOrLiked,`
0	`1307`	`IsLiked = filter.IsLiked,`
0	`1308`	`IsLocked = filter.IsLocked,`
0	`1309`	`NameLessThan = filter.NameLessThan,`
0	`1310`	`NameStartsWith = filter.NameStartsWith,`
0	`1311`	`NameStartsWithOrGreater = filter.NameStartsWithOrGreater,`
0	`1312`	`Tags = filter.Tags,`
0	`1313`	`OfficialRatings = filter.OfficialRatings,`
0	`1314`	`StudioIds = filter.StudioIds,`
0	`1315`	`GenreIds = filter.GenreIds,`
0	`1316`	`Genres = filter.Genres,`
0	`1317`	`Years = filter.Years,`
0	`1318`	`NameContains = filter.NameContains,`
0	`1319`	`SearchTerm = filter.SearchTerm,`
0	`1320`	`ExcludeItemIds = filter.ExcludeItemIds`
0	`1321`	`};`
	`1322`
0	`1323`	`var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter)`
0	`1324`	`.GroupBy(e => e.PresentationUniqueKey)`
0	`1325`	`.Select(e => e.FirstOrDefault())`
0	`1326`	`.Select(e => e!.Id);`
	`1327`
0	`1328`	`var query = context.BaseItems`
0	`1329`	`.Include(e => e.TrailerTypes)`
0	`1330`	`.Include(e => e.Provider)`
0	`1331`	`.Include(e => e.LockedFields)`
0	`1332`	`.Include(e => e.Images)`
0	`1333`	`.AsSingleQuery()`
0	`1334`	`.Where(e => masterQuery.Contains(e.Id));`
	`1335`
0	`1336`	`query = ApplyOrder(query, filter, context);`
	`1337`
0	`1338`	`var result = new QueryResult<(BaseItemDto, ItemCounts?)>();`
0	`1339`	`if (filter.EnableTotalRecordCount)`
	`1340`	`{`
0	`1341`	`result.TotalRecordCount = query.Count();`
	`1342`	`}`
	`1343`
0	`1344`	`if (filter.StartIndex.HasValue && filter.StartIndex.Value > 0)`
	`1345`	`{`
0	`1346`	`query = query.Skip(filter.StartIndex.Value);`
	`1347`	`}`
	`1348`
0	`1349`	`if (filter.Limit.HasValue && filter.Limit.Value > 0)`
	`1350`	`{`
0	`1351`	`query = query.Take(filter.Limit.Value);`
	`1352`	`}`
	`1353`
0	`1354`	`IQueryable<BaseItemEntity>? itemCountQuery = null;`
	`1355`
0	`1356`	`if (filter.IncludeItemTypes.Length > 0)`
	`1357`	`{`
	`1358`	`// if we are to include more then one type, sub query those items beforehand.`
	`1359`
0	`1360`	`var typeSubQuery = new InternalItemsQuery(filter.User)`
0	`1361`	`{`
0	`1362`	`ExcludeItemTypes = filter.ExcludeItemTypes,`
0	`1363`	`IncludeItemTypes = filter.IncludeItemTypes,`
0	`1364`	`MediaTypes = filter.MediaTypes,`
0	`1365`	`AncestorIds = filter.AncestorIds,`
0	`1366`	`ExcludeItemIds = filter.ExcludeItemIds,`
0	`1367`	`ItemIds = filter.ItemIds,`
0	`1368`	`TopParentIds = filter.TopParentIds,`
0	`1369`	`ParentId = filter.ParentId,`
0	`1370`	`IsPlayed = filter.IsPlayed`
0	`1371`	`};`
	`1372`
0	`1373`	`itemCountQuery = TranslateQuery(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderI`
0	`1374`	`.Where(e => e.ItemValues!.Any(f => itemValueTypes!.Contains(f.ItemValue.Type)));`
	`1375`
0	`1376`	`var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];`
0	`1377`	`var movieTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];`
0	`1378`	`var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];`
0	`1379`	`var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum];`
0	`1380`	`var musicArtistTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];`
0	`1381`	`var audioTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Audio];`
0	`1382`	`var trailerTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Trailer];`
	`1383`
0	`1384`	`var resultQuery = query.Select(e => new`
0	`1385`	`{`
0	`1386`	`item = e,`
0	`1387`	`// TODO: This is bad refactor!`
0	`1388`	`itemCount = new ItemCounts()`
0	`1389`	`{`
0	`1390`	`SeriesCount = itemCountQuery!.Count(f => f.Type == seriesTypeName),`
0	`1391`	`EpisodeCount = itemCountQuery!.Count(f => f.Type == episodeTypeName),`
0	`1392`	`MovieCount = itemCountQuery!.Count(f => f.Type == movieTypeName),`
0	`1393`	`AlbumCount = itemCountQuery!.Count(f => f.Type == musicAlbumTypeName),`
0	`1394`	`ArtistCount = itemCountQuery!.Count(f => f.Type == musicArtistTypeName),`
0	`1395`	`SongCount = itemCountQuery!.Count(f => f.Type == audioTypeName),`
0	`1396`	`TrailerCount = itemCountQuery!.Count(f => f.Type == trailerTypeName),`
0	`1397`	`}`
0	`1398`	`});`
	`1399`
0	`1400`	`result.StartIndex = filter.StartIndex ?? 0;`
0	`1401`	`result.Items =`
0	`1402`	`[`
0	`1403`	`.. resultQuery`
0	`1404`	`.AsEnumerable()`
0	`1405`	`.Where(e => e is not null)`
0	`1406`	`.Select(e => (Item: DeserializeBaseItem(e.item, filter.SkipDeserialization), e.itemCount))`
0	`1407`	`.Where(e => e.Item is not null)`
0	`1408`	`.Select(e => (e.Item!, e.itemCount))`
0	`1409`	`];`
	`1410`	`}`
	`1411`	`else`
	`1412`	`{`
0	`1413`	`result.StartIndex = filter.StartIndex ?? 0;`
0	`1414`	`result.Items =`
0	`1415`	`[`
0	`1416`	`.. query`
0	`1417`	`.AsEnumerable()`
0	`1418`	`.Where(e => e is not null)`
0	`1419`	`.Select(e => (Item: DeserializeBaseItem(e, filter.SkipDeserialization), ItemCounts: (ItemCounts?)nul`
0	`1420`	`.Where(e => e.Item is not null)`
0	`1421`	`.Select(e => (e.Item!, e.ItemCounts))`
0	`1422`	`];`
	`1423`	`}`
	`1424`
0	`1425`	`return result;`
0	`1426`	`}`
	`1427`
	`1428`	`private static void PrepareFilterQuery(InternalItemsQuery query)`
	`1429`	`{`
336	`1430`	`if (query.Limit.HasValue && query.Limit.Value > 0 && query.EnableGroupByMetadataKey)`
	`1431`	`{`
0	`1432`	`query.Limit = query.Limit.Value + 4;`
	`1433`	`}`
	`1434`
336	`1435`	`if (query.IsResumable ?? false)`
	`1436`	`{`
1	`1437`	`query.IsVirtualItem = false;`
	`1438`	`}`
336	`1439`	`}`
	`1440`
	`1441`	`/// <summary>`
	`1442`	`/// Gets the clean value for search and sorting purposes.`
	`1443`	`/// </summary>`
	`1444`	`/// <param name="value">The value to clean.</param>`
	`1445`	`/// <returns>The cleaned value.</returns>`
	`1446`	`public static string GetCleanValue(string value)`
	`1447`	`{`
122	`1448`	`if (string.IsNullOrWhiteSpace(value))`
	`1449`	`{`
0	`1450`	`return value;`
	`1451`	`}`
	`1452`
122	`1453`	`var noDiacritics = value.RemoveDiacritics();`
	`1454`
	`1455`	`// Build a string where any punctuation or symbol is treated as a separator (space).`
122	`1456`	`var sb = new StringBuilder(noDiacritics.Length);`
122	`1457`	`var previousWasSpace = false;`
2044	`1458`	`foreach (var ch in noDiacritics)`
	`1459`	`{`
	`1460`	`char outCh;`
900	`1461`	`if (char.IsLetterOrDigit(ch) \|\| char.IsWhiteSpace(ch))`
	`1462`	`{`
878	`1463`	`outCh = ch;`
	`1464`	`}`
	`1465`	`else`
	`1466`	`{`
22	`1467`	`outCh = ' ';`
	`1468`	`}`
	`1469`
	`1470`	`// normalize any whitespace character to a single ASCII space.`
900	`1471`	`if (char.IsWhiteSpace(outCh))`
	`1472`	`{`
50	`1473`	`if (!previousWasSpace)`
	`1474`	`{`
39	`1475`	`sb.Append(' ');`
39	`1476`	`previousWasSpace = true;`
	`1477`	`}`
	`1478`	`}`
	`1479`	`else`
	`1480`	`{`
850	`1481`	`sb.Append(outCh);`
850	`1482`	`previousWasSpace = false;`
	`1483`	`}`
	`1484`	`}`
	`1485`
	`1486`	`// trim leading/trailing spaces that may have been added.`
122	`1487`	`var collapsed = sb.ToString().Trim();`
122	`1488`	`return collapsed.ToLowerInvariant();`
	`1489`	`}`
	`1490`
	`1491`	`private List<(ItemValueType MagicNumber, string Value)> GetItemValuesToSave(BaseItemDto item, List<string> inherited`
	`1492`	`{`
109	`1493`	`var list = new List<(ItemValueType, string)>();`
	`1494`
109	`1495`	`if (item is IHasArtist hasArtist)`
	`1496`	`{`
0	`1497`	`list.AddRange(hasArtist.Artists.Select(i => ((ItemValueType)0, i)));`
	`1498`	`}`
	`1499`
109	`1500`	`if (item is IHasAlbumArtist hasAlbumArtist)`
	`1501`	`{`
0	`1502`	`list.AddRange(hasAlbumArtist.AlbumArtists.Select(i => (ItemValueType.AlbumArtist, i)));`
	`1503`	`}`
	`1504`
109	`1505`	`list.AddRange(item.Genres.Select(i => (ItemValueType.Genre, i)));`
109	`1506`	`list.AddRange(item.Studios.Select(i => (ItemValueType.Studios, i)));`
109	`1507`	`list.AddRange(item.Tags.Select(i => (ItemValueType.Tags, i)));`
	`1508`
	`1509`	`// keywords was 5`
	`1510`
109	`1511`	`list.AddRange(inheritedTags.Select(i => (ItemValueType.InheritedTags, i)));`
	`1512`
	`1513`	`// Remove all invalid values.`
109	`1514`	`list.RemoveAll(i => string.IsNullOrWhiteSpace(i.Item2));`
	`1515`
109	`1516`	`return list;`
	`1517`	`}`
	`1518`
	`1519`	`private static BaseItemImageInfo Map(Guid baseItemId, ItemImageInfo e)`
	`1520`	`{`
0	`1521`	`return new BaseItemImageInfo()`
0	`1522`	`{`
0	`1523`	`ItemId = baseItemId,`
0	`1524`	`Id = Guid.NewGuid(),`
0	`1525`	`Path = e.Path,`
0	`1526`	`Blurhash = e.BlurHash is null ? null : Encoding.UTF8.GetBytes(e.BlurHash),`
0	`1527`	`DateModified = e.DateModified,`
0	`1528`	`Height = e.Height,`
0	`1529`	`Width = e.Width,`
0	`1530`	`ImageType = (ImageInfoImageType)e.Type,`
0	`1531`	`Item = null!`
0	`1532`	`};`
	`1533`	`}`
	`1534`
	`1535`	`private static ItemImageInfo Map(BaseItemImageInfo e, IServerApplicationHost? appHost)`
	`1536`	`{`
0	`1537`	`return new ItemImageInfo()`
0	`1538`	`{`
0	`1539`	`Path = appHost?.ExpandVirtualPath(e.Path) ?? e.Path,`
0	`1540`	`BlurHash = e.Blurhash is null ? null : Encoding.UTF8.GetString(e.Blurhash),`
0	`1541`	`DateModified = e.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc),`
0	`1542`	`Height = e.Height,`
0	`1543`	`Width = e.Width,`
0	`1544`	`Type = (ImageType)e.ImageType`
0	`1545`	`};`
	`1546`	`}`
	`1547`
	`1548`	`private string? GetPathToSave(string path)`
	`1549`	`{`
119	`1550`	`if (path is null)`
	`1551`	`{`
10	`1552`	`return null;`
	`1553`	`}`
	`1554`
109	`1555`	`return _appHost.ReverseVirtualPath(path);`
	`1556`	`}`
	`1557`
	`1558`	`private List<string> GetItemByNameTypesInQuery(InternalItemsQuery query)`
	`1559`	`{`
15	`1560`	`var list = new List<string>();`
	`1561`
15	`1562`	`if (IsTypeInQuery(BaseItemKind.Person, query))`
	`1563`	`{`
1	`1564`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Person]!);`
	`1565`	`}`
	`1566`
15	`1567`	`if (IsTypeInQuery(BaseItemKind.Genre, query))`
	`1568`	`{`
1	`1569`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]!);`
	`1570`	`}`
	`1571`
15	`1572`	`if (IsTypeInQuery(BaseItemKind.MusicGenre, query))`
	`1573`	`{`
1	`1574`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]!);`
	`1575`	`}`
	`1576`
15	`1577`	`if (IsTypeInQuery(BaseItemKind.MusicArtist, query))`
	`1578`	`{`
1	`1579`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!);`
	`1580`	`}`
	`1581`
15	`1582`	`if (IsTypeInQuery(BaseItemKind.Studio, query))`
	`1583`	`{`
1	`1584`	`list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]!);`
	`1585`	`}`
	`1586`
15	`1587`	`return list;`
	`1588`	`}`
	`1589`
	`1590`	`private bool IsTypeInQuery(BaseItemKind type, InternalItemsQuery query)`
	`1591`	`{`
75	`1592`	`if (query.ExcludeItemTypes.Contains(type))`
	`1593`	`{`
0	`1594`	`return false;`
	`1595`	`}`
	`1596`
75	`1597`	`return query.IncludeItemTypes.Length == 0 \|\| query.IncludeItemTypes.Contains(type);`
	`1598`	`}`
	`1599`
	`1600`	`private bool EnableGroupByPresentationUniqueKey(InternalItemsQuery query)`
	`1601`	`{`
336	`1602`	`if (!query.GroupByPresentationUniqueKey)`
	`1603`	`{`
142	`1604`	`return false;`
	`1605`	`}`
	`1606`
194	`1607`	`if (query.GroupBySeriesPresentationUniqueKey)`
	`1608`	`{`
0	`1609`	`return false;`
	`1610`	`}`
	`1611`
194	`1612`	`if (!string.IsNullOrWhiteSpace(query.PresentationUniqueKey))`
	`1613`	`{`
0	`1614`	`return false;`
	`1615`	`}`
	`1616`
194	`1617`	`if (query.User is null)`
	`1618`	`{`
192	`1619`	`return false;`
	`1620`	`}`
	`1621`
2	`1622`	`if (query.IncludeItemTypes.Length == 0)`
	`1623`	`{`
1	`1624`	`return true;`
	`1625`	`}`
	`1626`
1	`1627`	`return query.IncludeItemTypes.Contains(BaseItemKind.Episode)`
1	`1628`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Video)`
1	`1629`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Movie)`
1	`1630`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.MusicVideo)`
1	`1631`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Series)`
1	`1632`	`\|\| query.IncludeItemTypes.Contains(BaseItemKind.Season);`
	`1633`	`}`
	`1634`
	`1635`	`private IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter, JellyfinD`
	`1636`	`{`
336	`1637`	`var orderBy = filter.OrderBy.Where(e => e.OrderBy != ItemSortBy.Default).ToArray();`
336	`1638`	`var hasSearch = !string.IsNullOrEmpty(filter.SearchTerm);`
	`1639`
336	`1640`	`if (hasSearch)`
	`1641`	`{`
0	`1642`	`orderBy = [(ItemSortBy.SortName, SortOrder.Ascending), .. orderBy];`
	`1643`	`}`
336	`1644`	`else if (orderBy.Length == 0)`
	`1645`	`{`
231	`1646`	`return query.OrderBy(e => e.SortName);`
	`1647`	`}`
	`1648`
105	`1649`	`IOrderedQueryable<BaseItemEntity>? orderedQuery = null;`
	`1650`
	`1651`	`// When searching, prioritize by match quality: exact match > prefix match > contains`
105	`1652`	`if (hasSearch)`
	`1653`	`{`
0	`1654`	`orderedQuery = query.OrderBy(OrderMapper.MapSearchRelevanceOrder(filter.SearchTerm!));`
	`1655`	`}`
	`1656`
105	`1657`	`var firstOrdering = orderBy.FirstOrDefault();`
105	`1658`	`if (firstOrdering != default)`
	`1659`	`{`
105	`1660`	`var expression = OrderMapper.MapOrderByField(firstOrdering.OrderBy, filter, context);`
105	`1661`	`if (orderedQuery is null)`
	`1662`	`{`
	`1663`	`// No search relevance ordering, start fresh`
105	`1664`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
105	`1665`	`? query.OrderBy(expression)`
105	`1666`	`: query.OrderByDescending(expression);`
	`1667`	`}`
	`1668`	`else`
	`1669`	`{`
	`1670`	`// Search relevance ordering already applied, chain with ThenBy`
0	`1671`	`orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending`
0	`1672`	`? orderedQuery.ThenBy(expression)`
0	`1673`	`: orderedQuery.ThenByDescending(expression);`
	`1674`	`}`
	`1675`
105	`1676`	`if (firstOrdering.OrderBy is ItemSortBy.Default or ItemSortBy.SortName)`
	`1677`	`{`
0	`1678`	`orderedQuery = firstOrdering.SortOrder is SortOrder.Ascending`
0	`1679`	`? orderedQuery.ThenBy(e => e.Name)`
0	`1680`	`: orderedQuery.ThenByDescending(e => e.Name);`
	`1681`	`}`
	`1682`	`}`
	`1683`
294	`1684`	`foreach (var item in orderBy.Skip(1))`
	`1685`	`{`
42	`1686`	`var expression = OrderMapper.MapOrderByField(item.OrderBy, filter, context);`
42	`1687`	`if (item.SortOrder == SortOrder.Ascending)`
	`1688`	`{`
42	`1689`	`orderedQuery = orderedQuery!.ThenBy(expression);`
	`1690`	`}`
	`1691`	`else`
	`1692`	`{`
0	`1693`	`orderedQuery = orderedQuery!.ThenByDescending(expression);`
	`1694`	`}`
	`1695`	`}`
	`1696`
105	`1697`	`return orderedQuery ?? query;`
	`1698`	`}`
	`1699`
	`1700`	`private IQueryable<BaseItemEntity> TranslateQuery(`
	`1701`	`IQueryable<BaseItemEntity> baseQuery,`
	`1702`	`JellyfinDbContext context,`
	`1703`	`InternalItemsQuery filter)`
	`1704`	`{`
	`1705`	`const int HDWidth = 1200;`
	`1706`	`const int UHDWidth = 3800;`
	`1707`	`const int UHDHeight = 2100;`
	`1708`
336	`1709`	`var minWidth = filter.MinWidth;`
336	`1710`	`var maxWidth = filter.MaxWidth;`
336	`1711`	`var now = DateTime.UtcNow;`
	`1712`
336	`1713`	`if (filter.IsHD.HasValue \|\| filter.Is4K.HasValue)`
	`1714`	`{`
0	`1715`	`bool includeSD = false;`
0	`1716`	`bool includeHD = false;`
0	`1717`	`bool include4K = false;`
	`1718`
0	`1719`	`if (filter.IsHD.HasValue && !filter.IsHD.Value)`
	`1720`	`{`
0	`1721`	`includeSD = true;`
	`1722`	`}`
	`1723`
0	`1724`	`if (filter.IsHD.HasValue && filter.IsHD.Value)`
	`1725`	`{`
0	`1726`	`includeHD = true;`
	`1727`	`}`
	`1728`
0	`1729`	`if (filter.Is4K.HasValue && filter.Is4K.Value)`
	`1730`	`{`
0	`1731`	`include4K = true;`
	`1732`	`}`
	`1733`
0	`1734`	`baseQuery = baseQuery.Where(e =>`
0	`1735`	`(includeSD && e.Width < HDWidth) \|\|`
0	`1736`	`(includeHD && e.Width >= HDWidth && !(e.Width >= UHDWidth \|\| e.Height >= UHDHeight)) \|\|`
0	`1737`	`(include4K && (e.Width >= UHDWidth \|\| e.Height >= UHDHeight)));`
	`1738`	`}`
	`1739`
336	`1740`	`if (minWidth.HasValue)`
	`1741`	`{`
0	`1742`	`baseQuery = baseQuery.Where(e => e.Width >= minWidth);`
	`1743`	`}`
	`1744`
336	`1745`	`if (filter.MinHeight.HasValue)`
	`1746`	`{`
0	`1747`	`baseQuery = baseQuery.Where(e => e.Height >= filter.MinHeight);`
	`1748`	`}`
	`1749`
336	`1750`	`if (maxWidth.HasValue)`
	`1751`	`{`
0	`1752`	`baseQuery = baseQuery.Where(e => e.Width <= maxWidth);`
	`1753`	`}`
	`1754`
336	`1755`	`if (filter.MaxHeight.HasValue)`
	`1756`	`{`
0	`1757`	`baseQuery = baseQuery.Where(e => e.Height <= filter.MaxHeight);`
	`1758`	`}`
	`1759`
336	`1760`	`if (filter.IsLocked.HasValue)`
	`1761`	`{`
48	`1762`	`baseQuery = baseQuery.Where(e => e.IsLocked == filter.IsLocked);`
	`1763`	`}`
	`1764`
336	`1765`	`var tags = filter.Tags.ToList();`
336	`1766`	`var excludeTags = filter.ExcludeTags.ToList();`
	`1767`
336	`1768`	`if (filter.IsMovie.HasValue)`
	`1769`	`{`
0	`1770`	`var shouldIncludeAllMovieTypes = filter.IsMovie.Value`
0	`1771`	`&& (filter.IncludeItemTypes.Length == 0`
0	`1772`	`\|\| filter.IncludeItemTypes.Contains(BaseItemKind.Movie)`
0	`1773`	`\|\| filter.IncludeItemTypes.Contains(BaseItemKind.Trailer));`
	`1774`
0	`1775`	`if (!shouldIncludeAllMovieTypes)`
	`1776`	`{`
0	`1777`	`baseQuery = baseQuery.Where(e => e.IsMovie == filter.IsMovie.Value);`
	`1778`	`}`
	`1779`	`}`
	`1780`
336	`1781`	`if (filter.IsSeries.HasValue)`
	`1782`	`{`
0	`1783`	`baseQuery = baseQuery.Where(e => e.IsSeries == filter.IsSeries);`
	`1784`	`}`
	`1785`
336	`1786`	`if (filter.IsSports.HasValue)`
	`1787`	`{`
0	`1788`	`if (filter.IsSports.Value)`
	`1789`	`{`
0	`1790`	`tags.Add("Sports");`
	`1791`	`}`
	`1792`	`else`
	`1793`	`{`
0	`1794`	`excludeTags.Add("Sports");`
	`1795`	`}`
	`1796`	`}`
	`1797`
336	`1798`	`if (filter.IsNews.HasValue)`
	`1799`	`{`
0	`1800`	`if (filter.IsNews.Value)`
	`1801`	`{`
0	`1802`	`tags.Add("News");`
	`1803`	`}`
	`1804`	`else`
	`1805`	`{`
0	`1806`	`excludeTags.Add("News");`
	`1807`	`}`
	`1808`	`}`
	`1809`
336	`1810`	`if (filter.IsKids.HasValue)`
	`1811`	`{`
0	`1812`	`if (filter.IsKids.Value)`
	`1813`	`{`
0	`1814`	`tags.Add("Kids");`
	`1815`	`}`
	`1816`	`else`
	`1817`	`{`
0	`1818`	`excludeTags.Add("Kids");`
	`1819`	`}`
	`1820`	`}`
	`1821`
336	`1822`	`if (!string.IsNullOrEmpty(filter.SearchTerm))`
	`1823`	`{`
0	`1824`	`var cleanedSearchTerm = GetCleanValue(filter.SearchTerm);`
0	`1825`	`var originalSearchTerm = filter.SearchTerm.ToLower();`
0	`1826`	`if (SearchWildcardTerms.Any(f => cleanedSearchTerm.Contains(f)))`
	`1827`	`{`
0	`1828`	`cleanedSearchTerm = $"%{cleanedSearchTerm.Trim('%')}%";`
0	`1829`	`baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName!, cleanedSearchTerm) \|\| (e.OriginalTitle`
	`1830`	`}`
	`1831`	`else`
	`1832`	`{`
0	`1833`	`baseQuery = baseQuery.Where(e => e.CleanName!.Contains(cleanedSearchTerm) \|\| (e.OriginalTitle != null &&`
	`1834`	`}`
	`1835`	`}`
	`1836`
336	`1837`	`if (filter.IsFolder.HasValue)`
	`1838`	`{`
21	`1839`	`baseQuery = baseQuery.Where(e => e.IsFolder == filter.IsFolder);`
	`1840`	`}`
	`1841`
336	`1842`	`var includeTypes = filter.IncludeItemTypes;`
	`1843`
	`1844`	`// Only specify excluded types if no included types are specified`
336	`1845`	`if (filter.IncludeItemTypes.Length == 0)`
	`1846`	`{`
222	`1847`	`var excludeTypes = filter.ExcludeItemTypes;`
222	`1848`	`if (excludeTypes.Length == 1)`
	`1849`	`{`
0	`1850`	`if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeTypes[0], out var excludeTypeName))`
	`1851`	`{`
0	`1852`	`baseQuery = baseQuery.Where(e => e.Type != excludeTypeName);`
	`1853`	`}`
	`1854`	`}`
222	`1855`	`else if (excludeTypes.Length > 1)`
	`1856`	`{`
0	`1857`	`var excludeTypeName = new List<string>();`
0	`1858`	`foreach (var excludeType in excludeTypes)`
	`1859`	`{`
0	`1860`	`if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeType, out var baseItemKindName))`
	`1861`	`{`
0	`1862`	`excludeTypeName.Add(baseItemKindName!);`
	`1863`	`}`
	`1864`	`}`
	`1865`
0	`1866`	`baseQuery = baseQuery.Where(e => !excludeTypeName.Contains(e.Type));`
	`1867`	`}`
	`1868`	`}`
	`1869`	`else`
	`1870`	`{`
114	`1871`	`string[] types = includeTypes.Select(f => _itemTypeLookup.BaseItemKindNames.GetValueOrDefault(f)).Where(e =>`
114	`1872`	`baseQuery = baseQuery.WhereOneOrMany(types, f => f.Type);`
	`1873`	`}`
	`1874`
336	`1875`	`if (filter.ChannelIds.Count > 0)`
	`1876`	`{`
0	`1877`	`baseQuery = baseQuery.Where(e => e.ChannelId != null && filter.ChannelIds.Contains(e.ChannelId.Value));`
	`1878`	`}`
	`1879`
336	`1880`	`if (!filter.ParentId.IsEmpty())`
	`1881`	`{`
142	`1882`	`baseQuery = baseQuery.Where(e => e.ParentId!.Value == filter.ParentId);`
	`1883`	`}`
	`1884`
336	`1885`	`if (!string.IsNullOrWhiteSpace(filter.Path))`
	`1886`	`{`
0	`1887`	`var pathToQuery = GetPathToSave(filter.Path);`
0	`1888`	`baseQuery = baseQuery.Where(e => e.Path == pathToQuery);`
	`1889`	`}`
	`1890`
336	`1891`	`if (!string.IsNullOrWhiteSpace(filter.PresentationUniqueKey))`
	`1892`	`{`
0	`1893`	`baseQuery = baseQuery.Where(e => e.PresentationUniqueKey == filter.PresentationUniqueKey);`
	`1894`	`}`
	`1895`
336	`1896`	`if (filter.MinCommunityRating.HasValue)`
	`1897`	`{`
0	`1898`	`baseQuery = baseQuery.Where(e => e.CommunityRating >= filter.MinCommunityRating);`
	`1899`	`}`
	`1900`
336	`1901`	`if (filter.MinIndexNumber.HasValue)`
	`1902`	`{`
0	`1903`	`baseQuery = baseQuery.Where(e => e.IndexNumber >= filter.MinIndexNumber);`
	`1904`	`}`
	`1905`
336	`1906`	`if (filter.MinParentAndIndexNumber.HasValue)`
	`1907`	`{`
0	`1908`	`baseQuery = baseQuery`
0	`1909`	`.Where(e => (e.ParentIndexNumber == filter.MinParentAndIndexNumber.Value.ParentIndexNumber && e.IndexNum`
	`1910`	`}`
	`1911`
336	`1912`	`if (filter.MinDateCreated.HasValue)`
	`1913`	`{`
0	`1914`	`baseQuery = baseQuery.Where(e => e.DateCreated >= filter.MinDateCreated);`
	`1915`	`}`
	`1916`
336	`1917`	`if (filter.MinDateLastSaved.HasValue)`
	`1918`	`{`
0	`1919`	`baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSaved.Value`
	`1920`	`}`
	`1921`
336	`1922`	`if (filter.MinDateLastSavedForUser.HasValue)`
	`1923`	`{`
0	`1924`	`baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSavedForUse`
	`1925`	`}`
	`1926`
336	`1927`	`if (filter.IndexNumber.HasValue)`
	`1928`	`{`
0	`1929`	`baseQuery = baseQuery.Where(e => e.IndexNumber == filter.IndexNumber.Value);`
	`1930`	`}`
	`1931`
336	`1932`	`if (filter.ParentIndexNumber.HasValue)`
	`1933`	`{`
0	`1934`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber == filter.ParentIndexNumber.Value);`
	`1935`	`}`
	`1936`
336	`1937`	`if (filter.ParentIndexNumberNotEquals.HasValue)`
	`1938`	`{`
0	`1939`	`baseQuery = baseQuery.Where(e => e.ParentIndexNumber != filter.ParentIndexNumberNotEquals.Value \|\| e.ParentI`
	`1940`	`}`
	`1941`
336	`1942`	`var minEndDate = filter.MinEndDate;`
336	`1943`	`var maxEndDate = filter.MaxEndDate;`
	`1944`
336	`1945`	`if (filter.HasAired.HasValue)`
	`1946`	`{`
0	`1947`	`if (filter.HasAired.Value)`
	`1948`	`{`
0	`1949`	`maxEndDate = DateTime.UtcNow;`
	`1950`	`}`
	`1951`	`else`
	`1952`	`{`
0	`1953`	`minEndDate = DateTime.UtcNow;`
	`1954`	`}`
	`1955`	`}`
	`1956`
336	`1957`	`if (minEndDate.HasValue)`
	`1958`	`{`
0	`1959`	`baseQuery = baseQuery.Where(e => e.EndDate >= minEndDate);`
	`1960`	`}`
	`1961`
336	`1962`	`if (maxEndDate.HasValue)`
	`1963`	`{`
0	`1964`	`baseQuery = baseQuery.Where(e => e.EndDate <= maxEndDate);`
	`1965`	`}`
	`1966`
336	`1967`	`if (filter.MinStartDate.HasValue)`
	`1968`	`{`
0	`1969`	`baseQuery = baseQuery.Where(e => e.StartDate >= filter.MinStartDate.Value);`
	`1970`	`}`
	`1971`
336	`1972`	`if (filter.MaxStartDate.HasValue)`
	`1973`	`{`
0	`1974`	`baseQuery = baseQuery.Where(e => e.StartDate <= filter.MaxStartDate.Value);`
	`1975`	`}`
	`1976`
336	`1977`	`if (filter.MinPremiereDate.HasValue)`
	`1978`	`{`
0	`1979`	`baseQuery = baseQuery.Where(e => e.PremiereDate >= filter.MinPremiereDate.Value);`
	`1980`	`}`
	`1981`
336	`1982`	`if (filter.MaxPremiereDate.HasValue)`
	`1983`	`{`
0	`1984`	`baseQuery = baseQuery.Where(e => e.PremiereDate <= filter.MaxPremiereDate.Value);`
	`1985`	`}`
	`1986`
336	`1987`	`if (filter.TrailerTypes.Length > 0)`
	`1988`	`{`
0	`1989`	`var trailerTypes = filter.TrailerTypes.Select(e => (int)e).ToArray();`
0	`1990`	`baseQuery = baseQuery.Where(e => trailerTypes.Any(f => e.TrailerTypes!.Any(w => w.Id == f)));`
	`1991`	`}`
	`1992`
336	`1993`	`if (filter.IsAiring.HasValue)`
	`1994`	`{`
0	`1995`	`if (filter.IsAiring.Value)`
	`1996`	`{`
0	`1997`	`baseQuery = baseQuery.Where(e => e.StartDate <= now && e.EndDate >= now);`
	`1998`	`}`
	`1999`	`else`
	`2000`	`{`
0	`2001`	`baseQuery = baseQuery.Where(e => e.StartDate > now && e.EndDate < now);`
	`2002`	`}`
	`2003`	`}`
	`2004`
336	`2005`	`if (filter.PersonIds.Length > 0)`
	`2006`	`{`
0	`2007`	`var peopleEntityIds = context.BaseItems`
0	`2008`	`.WhereOneOrMany(filter.PersonIds, b => b.Id)`
0	`2009`	`.Join(`
0	`2010`	`context.Peoples,`
0	`2011`	`b => b.Name,`
0	`2012`	`p => p.Name,`
0	`2013`	`(b, p) => p.Id);`
	`2014`
0	`2015`	`baseQuery = baseQuery`
0	`2016`	`.Where(e => context.PeopleBaseItemMap`
0	`2017`	`.Any(m => m.ItemId == e.Id && peopleEntityIds.Contains(m.PeopleId)));`
	`2018`	`}`
	`2019`
336	`2020`	`if (!string.IsNullOrWhiteSpace(filter.Person))`
	`2021`	`{`
0	`2022`	`baseQuery = baseQuery.Where(e => e.Peoples!.Any(f => f.People.Name == filter.Person));`
	`2023`	`}`
	`2024`
336	`2025`	`if (!string.IsNullOrWhiteSpace(filter.MinSortName))`
	`2026`	`{`
	`2027`	`// this does not makes sense.`
	`2028`	`// baseQuery = baseQuery.Where(e => e.SortName >= query.MinSortName);`
	`2029`	`// whereClauses.Add("SortName>=@MinSortName");`
	`2030`	`// statement?.TryBind("@MinSortName", query.MinSortName);`
	`2031`	`}`
	`2032`
336	`2033`	`if (!string.IsNullOrWhiteSpace(filter.ExternalSeriesId))`
	`2034`	`{`
0	`2035`	`baseQuery = baseQuery.Where(e => e.ExternalSeriesId == filter.ExternalSeriesId);`
	`2036`	`}`
	`2037`
336	`2038`	`if (!string.IsNullOrWhiteSpace(filter.ExternalId))`
	`2039`	`{`
0	`2040`	`baseQuery = baseQuery.Where(e => e.ExternalId == filter.ExternalId);`
	`2041`	`}`
	`2042`
336	`2043`	`if (!string.IsNullOrWhiteSpace(filter.Name))`
	`2044`	`{`
3	`2045`	`if (filter.UseRawName == true)`
	`2046`	`{`
0	`2047`	`baseQuery = baseQuery.Where(e => e.Name == filter.Name);`
	`2048`	`}`
	`2049`	`else`
	`2050`	`{`
3	`2051`	`var cleanName = GetCleanValue(filter.Name);`
3	`2052`	`baseQuery = baseQuery.Where(e => e.CleanName == cleanName);`
	`2053`	`}`
	`2054`	`}`
	`2055`
	`2056`	`// These are the same, for now`
336	`2057`	`var nameContains = filter.NameContains;`
336	`2058`	`if (!string.IsNullOrWhiteSpace(nameContains))`
	`2059`	`{`
0	`2060`	`if (SearchWildcardTerms.Any(f => nameContains.Contains(f)))`
	`2061`	`{`
0	`2062`	`nameContains = $"%{nameContains.Trim('%')}%";`
0	`2063`	`baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName, nameContains) \|\| EF.Functions.Like(e.Ori`
	`2064`	`}`
	`2065`	`else`
	`2066`	`{`
0	`2067`	`baseQuery = baseQuery.Where(e =>`
0	`2068`	`e.CleanName!.Contains(nameContains)`
0	`2069`	`\|\| e.OriginalTitle!.ToLower().Contains(nameContains!));`
	`2070`	`}`
	`2071`	`}`
	`2072`
336	`2073`	`if (!string.IsNullOrWhiteSpace(filter.NameStartsWith))`
	`2074`	`{`
0	`2075`	`var startsWithLower = filter.NameStartsWith.ToLowerInvariant();`
0	`2076`	`baseQuery = baseQuery.Where(e => e.SortName!.StartsWith(startsWithLower));`
	`2077`	`}`
	`2078`
336	`2079`	`if (!string.IsNullOrWhiteSpace(filter.NameStartsWithOrGreater))`
	`2080`	`{`
0	`2081`	`var startsOrGreaterLower = filter.NameStartsWithOrGreater.ToLowerInvariant();`
0	`2082`	`baseQuery = baseQuery.Where(e => e.SortName!.CompareTo(startsOrGreaterLower) >= 0);`
	`2083`	`}`
	`2084`
336	`2085`	`if (!string.IsNullOrWhiteSpace(filter.NameLessThan))`
	`2086`	`{`
0	`2087`	`var lessThanLower = filter.NameLessThan.ToLowerInvariant();`
0	`2088`	`baseQuery = baseQuery.Where(e => e.SortName!.CompareTo(lessThanLower ) < 0);`
	`2089`	`}`
	`2090`
336	`2091`	`if (filter.ImageTypes.Length > 0)`
	`2092`	`{`
104	`2093`	`var imgTypes = filter.ImageTypes.Select(e => (ImageInfoImageType)e).ToArray();`
104	`2094`	`baseQuery = baseQuery.Where(e => imgTypes.Any(f => e.Images!.Any(w => w.ImageType == f)));`
	`2095`	`}`
	`2096`
336	`2097`	`if (filter.IsLiked.HasValue)`
	`2098`	`{`
0	`2099`	`baseQuery = baseQuery`
0	`2100`	`.Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.Rating >= UserItemData.MinLike`
	`2101`	`}`
	`2102`
336	`2103`	`if (filter.IsFavoriteOrLiked.HasValue)`
	`2104`	`{`
0	`2105`	`baseQuery = baseQuery`
0	`2106`	`.Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.IsFavorite == filter.IsFavorit`
	`2107`	`}`
	`2108`
336	`2109`	`if (filter.IsFavorite.HasValue)`
	`2110`	`{`
0	`2111`	`baseQuery = baseQuery`
0	`2112`	`.Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.IsFavorite == filter.IsFavorit`
	`2113`	`}`
	`2114`
336	`2115`	`if (filter.IsPlayed.HasValue)`
	`2116`	`{`
	`2117`	`// We should probably figure this out for all folders, but for right now, this is the only place where we ne`
0	`2118`	`if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.Series)`
	`2119`	`{`
0	`2120`	`baseQuery = baseQuery.Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId))`
0	`2121`	`.Where(e => e.IsFolder == false && e.IsVirtualItem == false)`
0	`2122`	`.Where(f => f.UserData!.FirstOrDefault(e => e.UserId == filter.User!.Id && e.Played)!.Played)`
0	`2123`	`.Any(f => f.SeriesPresentationUniqueKey == e.PresentationUniqueKey) == filter.IsPlayed);`
	`2124`	`}`
	`2125`	`else`
	`2126`	`{`
0	`2127`	`baseQuery = baseQuery`
0	`2128`	`.Select(e => new`
0	`2129`	`{`
0	`2130`	`IsPlayed = e.UserData!.Where(f => f.UserId == filter.User!.Id).Select(f => (bool?)f.Played).Firs`
0	`2131`	`Item = e`
0	`2132`	`})`
0	`2133`	`.Where(e => e.IsPlayed == filter.IsPlayed)`
0	`2134`	`.Select(f => f.Item);`
	`2135`	`}`
	`2136`	`}`
	`2137`
336	`2138`	`if (filter.IsResumable.HasValue)`
	`2139`	`{`
1	`2140`	`if (filter.IsResumable.Value)`
	`2141`	`{`
1	`2142`	`baseQuery = baseQuery`
1	`2143`	`.Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.PlaybackPositionTicks >`
	`2144`	`}`
	`2145`	`else`
	`2146`	`{`
0	`2147`	`baseQuery = baseQuery`
0	`2148`	`.Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.PlaybackPositionTicks =`
	`2149`	`}`
	`2150`	`}`
	`2151`
336	`2152`	`if (filter.ArtistIds.Length > 0)`
	`2153`	`{`
0	`2154`	`baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumAr`
	`2155`	`}`
	`2156`
336	`2157`	`if (filter.AlbumArtistIds.Length > 0)`
	`2158`	`{`
0	`2159`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.AlbumArtist, filter.AlbumArtistIds);`
	`2160`	`}`
	`2161`
336	`2162`	`if (filter.ContributingArtistIds.Length > 0)`
	`2163`	`{`
0	`2164`	`var contributingNames = context.BaseItems`
0	`2165`	`.Where(b => filter.ContributingArtistIds.Contains(b.Id))`
0	`2166`	`.Select(b => b.CleanName);`
	`2167`
0	`2168`	`baseQuery = baseQuery.Where(e =>`
0	`2169`	`e.ItemValues!.Any(ivm =>`
0	`2170`	`ivm.ItemValue.Type == ItemValueType.Artist &&`
0	`2171`	`contributingNames.Contains(ivm.ItemValue.CleanValue))`
0	`2172`	`&&`
0	`2173`	`!e.ItemValues!.Any(ivm =>`
0	`2174`	`ivm.ItemValue.Type == ItemValueType.AlbumArtist &&`
0	`2175`	`contributingNames.Contains(ivm.ItemValue.CleanValue)));`
	`2176`	`}`
	`2177`
336	`2178`	`if (filter.AlbumIds.Length > 0)`
	`2179`	`{`
0	`2180`	`var subQuery = context.BaseItems.WhereOneOrMany(filter.AlbumIds, f => f.Id);`
0	`2181`	`baseQuery = baseQuery.Where(e => subQuery.Any(f => f.Name == e.Album));`
	`2182`	`}`
	`2183`
336	`2184`	`if (filter.ExcludeArtistIds.Length > 0)`
	`2185`	`{`
0	`2186`	`baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumAr`
	`2187`	`}`
	`2188`
336	`2189`	`if (filter.GenreIds.Count > 0)`
	`2190`	`{`
0	`2191`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Genre, filter.GenreIds.ToArray());`
	`2192`	`}`
	`2193`
336	`2194`	`if (filter.Genres.Count > 0)`
	`2195`	`{`
0	`2196`	`var cleanGenres = filter.Genres.Select(e => GetCleanValue(e)).ToArray().OneOrManyExpressionBuilder<ItemValue`
0	`2197`	`baseQuery = baseQuery`
0	`2198`	`.Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Genre).Any(clea`
	`2199`	`}`
	`2200`
336	`2201`	`if (tags.Count > 0)`
	`2202`	`{`
0	`2203`	`var cleanValues = tags.Select(e => GetCleanValue(e)).ToArray().OneOrManyExpressionBuilder<ItemValueMap, stri`
0	`2204`	`baseQuery = baseQuery`
0	`2205`	`.Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clean`
	`2206`	`}`
	`2207`
336	`2208`	`if (excludeTags.Count > 0)`
	`2209`	`{`
0	`2210`	`var cleanValues = excludeTags.Select(e => GetCleanValue(e)).ToArray().OneOrManyExpressionBuilder<ItemValueMa`
0	`2211`	`baseQuery = baseQuery`
0	`2212`	`.Where(e => !e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clea`
	`2213`	`}`
	`2214`
336	`2215`	`if (filter.StudioIds.Length > 0)`
	`2216`	`{`
0	`2217`	`baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Studios, filter.StudioIds.ToArray());`
	`2218`	`}`
	`2219`
336	`2220`	`if (filter.OfficialRatings.Length > 0)`
	`2221`	`{`
0	`2222`	`baseQuery = baseQuery`
0	`2223`	`.Where(e => filter.OfficialRatings.Contains(e.OfficialRating));`
	`2224`	`}`
	`2225`
336	`2226`	`Expression<Func<BaseItemEntity, bool>>? minParentalRatingFilter = null;`
336	`2227`	`if (filter.MinParentalRating != null)`
	`2228`	`{`
0	`2229`	`var min = filter.MinParentalRating;`
0	`2230`	`var minScore = min.Score;`
0	`2231`	`var minSubScore = min.SubScore ?? 0;`
	`2232`
0	`2233`	`minParentalRatingFilter = e =>`
0	`2234`	`e.InheritedParentalRatingValue == null \|\|`
0	`2235`	`e.InheritedParentalRatingValue > minScore \|\|`
0	`2236`	`(e.InheritedParentalRatingValue == minScore && (e.InheritedParentalRatingSubValue ?? 0) >= minSubScore);`
	`2237`	`}`
	`2238`
336	`2239`	`Expression<Func<BaseItemEntity, bool>>? maxParentalRatingFilter = null;`
336	`2240`	`if (filter.MaxParentalRating != null)`
	`2241`	`{`
48	`2242`	`var max = filter.MaxParentalRating;`
48	`2243`	`var maxScore = max.Score;`
48	`2244`	`var maxSubScore = max.SubScore ?? 0;`
	`2245`
48	`2246`	`maxParentalRatingFilter = e =>`
48	`2247`	`e.InheritedParentalRatingValue == null \|\|`
48	`2248`	`e.InheritedParentalRatingValue < maxScore \|\|`
48	`2249`	`(e.InheritedParentalRatingValue == maxScore && (e.InheritedParentalRatingSubValue ?? 0) <= maxSubScore);`
	`2250`	`}`
	`2251`
336	`2252`	`if (filter.HasParentalRating ?? false)`
	`2253`	`{`
0	`2254`	`if (minParentalRatingFilter != null)`
	`2255`	`{`
0	`2256`	`baseQuery = baseQuery.Where(minParentalRatingFilter);`
	`2257`	`}`
	`2258`
0	`2259`	`if (maxParentalRatingFilter != null)`
	`2260`	`{`
0	`2261`	`baseQuery = baseQuery.Where(maxParentalRatingFilter);`
	`2262`	`}`
	`2263`	`}`
336	`2264`	`else if (filter.BlockUnratedItems.Length > 0)`
	`2265`	`{`
0	`2266`	`var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();`
0	`2267`	`Expression<Func<BaseItemEntity, bool>> unratedItemFilter = e => e.InheritedParentalRatingValue != null \|\| !u`
	`2268`
0	`2269`	`if (minParentalRatingFilter != null && maxParentalRatingFilter != null)`
	`2270`	`{`
0	`2271`	`baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter.And(maxParentalRatingFilter)))`
	`2272`	`}`
0	`2273`	`else if (minParentalRatingFilter != null)`
	`2274`	`{`
0	`2275`	`baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter));`
	`2276`	`}`
0	`2277`	`else if (maxParentalRatingFilter != null)`
	`2278`	`{`
0	`2279`	`baseQuery = baseQuery.Where(unratedItemFilter.And(maxParentalRatingFilter));`
	`2280`	`}`
	`2281`	`else`
	`2282`	`{`
0	`2283`	`baseQuery = baseQuery.Where(unratedItemFilter);`
	`2284`	`}`
	`2285`	`}`
336	`2286`	`else if (minParentalRatingFilter != null \|\| maxParentalRatingFilter != null)`
	`2287`	`{`
48	`2288`	`if (minParentalRatingFilter != null)`
	`2289`	`{`
0	`2290`	`baseQuery = baseQuery.Where(minParentalRatingFilter);`
	`2291`	`}`
	`2292`
48	`2293`	`if (maxParentalRatingFilter != null)`
	`2294`	`{`
48	`2295`	`baseQuery = baseQuery.Where(maxParentalRatingFilter);`
	`2296`	`}`
	`2297`	`}`
288	`2298`	`else if (!filter.HasParentalRating ?? false)`
	`2299`	`{`
0	`2300`	`baseQuery = baseQuery`
0	`2301`	`.Where(e => e.InheritedParentalRatingValue == null);`
	`2302`	`}`
	`2303`
336	`2304`	`if (filter.HasOfficialRating.HasValue)`
	`2305`	`{`
0	`2306`	`if (filter.HasOfficialRating.Value)`
	`2307`	`{`
0	`2308`	`baseQuery = baseQuery`
0	`2309`	`.Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty);`
	`2310`	`}`
	`2311`	`else`
	`2312`	`{`
0	`2313`	`baseQuery = baseQuery`
0	`2314`	`.Where(e => e.OfficialRating == null \|\| e.OfficialRating == string.Empty);`
	`2315`	`}`
	`2316`	`}`
	`2317`
336	`2318`	`if (filter.HasOverview.HasValue)`
	`2319`	`{`
0	`2320`	`if (filter.HasOverview.Value)`
	`2321`	`{`
0	`2322`	`baseQuery = baseQuery`
0	`2323`	`.Where(e => e.Overview != null && e.Overview != string.Empty);`
	`2324`	`}`
	`2325`	`else`
	`2326`	`{`
0	`2327`	`baseQuery = baseQuery`
0	`2328`	`.Where(e => e.Overview == null \|\| e.Overview == string.Empty);`
	`2329`	`}`
	`2330`	`}`
	`2331`
336	`2332`	`if (filter.HasOwnerId.HasValue)`
	`2333`	`{`
0	`2334`	`if (filter.HasOwnerId.Value)`
	`2335`	`{`
0	`2336`	`baseQuery = baseQuery`
0	`2337`	`.Where(e => e.OwnerId != null);`
	`2338`	`}`
	`2339`	`else`
	`2340`	`{`
0	`2341`	`baseQuery = baseQuery`
0	`2342`	`.Where(e => e.OwnerId == null);`
	`2343`	`}`
	`2344`	`}`
	`2345`
336	`2346`	`if (!string.IsNullOrWhiteSpace(filter.HasNoAudioTrackWithLanguage))`
	`2347`	`{`
0	`2348`	`baseQuery = baseQuery`
0	`2349`	`.Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Audio && f.Language == filte`
	`2350`	`}`
	`2351`
336	`2352`	`if (!string.IsNullOrWhiteSpace(filter.HasNoInternalSubtitleTrackWithLanguage))`
	`2353`	`{`
0	`2354`	`baseQuery = baseQuery`
0	`2355`	`.Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle && !f.IsExternal &&`
	`2356`	`}`
	`2357`
336	`2358`	`if (!string.IsNullOrWhiteSpace(filter.HasNoExternalSubtitleTrackWithLanguage))`
	`2359`	`{`
0	`2360`	`baseQuery = baseQuery`
0	`2361`	`.Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle && f.IsExternal &&`
	`2362`	`}`
	`2363`
336	`2364`	`if (!string.IsNullOrWhiteSpace(filter.HasNoSubtitleTrackWithLanguage))`
	`2365`	`{`
0	`2366`	`baseQuery = baseQuery`
0	`2367`	`.Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle && f.Language == fi`
	`2368`	`}`
	`2369`
336	`2370`	`if (filter.HasSubtitles.HasValue)`
	`2371`	`{`
0	`2372`	`baseQuery = baseQuery`
0	`2373`	`.Where(e => e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle) == filter.HasSubtit`
	`2374`	`}`
	`2375`
336	`2376`	`if (filter.HasChapterImages.HasValue)`
	`2377`	`{`
0	`2378`	`baseQuery = baseQuery`
0	`2379`	`.Where(e => e.Chapters!.Any(f => f.ImagePath != null) == filter.HasChapterImages.Value);`
	`2380`	`}`
	`2381`
336	`2382`	`if (filter.HasDeadParentId.HasValue && filter.HasDeadParentId.Value)`
	`2383`	`{`
16	`2384`	`baseQuery = baseQuery`
16	`2385`	`.Where(e => e.ParentId.HasValue && !context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Any`
	`2386`	`}`
	`2387`
336	`2388`	`if (filter.IsDeadArtist.HasValue && filter.IsDeadArtist.Value)`
	`2389`	`{`
16	`2390`	`baseQuery = baseQuery`
16	`2391`	`.Where(e => !context.ItemValues.Where(f => _getAllArtistsValueTypes.Contains(f.Type)).Any(f => f.Val`
	`2392`	`}`
	`2393`
336	`2394`	`if (filter.IsDeadStudio.HasValue && filter.IsDeadStudio.Value)`
	`2395`	`{`
16	`2396`	`baseQuery = baseQuery`
16	`2397`	`.Where(e => !context.ItemValues.Where(f => _getStudiosValueTypes.Contains(f.Type)).Any(f => f.Value`
	`2398`	`}`
	`2399`
336	`2400`	`if (filter.IsDeadGenre.HasValue && filter.IsDeadGenre.Value)`
	`2401`	`{`
16	`2402`	`baseQuery = baseQuery`
16	`2403`	`.Where(e => !context.ItemValues.Where(f => _getGenreValueTypes.Contains(f.Type)).Any(f => f.Value ==`
	`2404`	`}`
	`2405`
336	`2406`	`if (filter.IsDeadPerson.HasValue && filter.IsDeadPerson.Value)`
	`2407`	`{`
0	`2408`	`baseQuery = baseQuery`
0	`2409`	`.Where(e => !context.Peoples.Any(f => f.Name == e.Name));`
	`2410`	`}`
	`2411`
336	`2412`	`if (filter.Years.Length > 0)`
	`2413`	`{`
0	`2414`	`baseQuery = baseQuery.WhereOneOrMany(filter.Years, e => e.ProductionYear!.Value);`
	`2415`	`}`
	`2416`
336	`2417`	`var isVirtualItem = filter.IsVirtualItem ?? filter.IsMissing;`
336	`2418`	`if (isVirtualItem.HasValue)`
	`2419`	`{`
22	`2420`	`baseQuery = baseQuery`
22	`2421`	`.Where(e => e.IsVirtualItem == isVirtualItem.Value);`
	`2422`	`}`
	`2423`
336	`2424`	`if (filter.IsSpecialSeason.HasValue)`
	`2425`	`{`
0	`2426`	`if (filter.IsSpecialSeason.Value)`
	`2427`	`{`
0	`2428`	`baseQuery = baseQuery`
0	`2429`	`.Where(e => e.IndexNumber == 0);`
	`2430`	`}`
	`2431`	`else`
	`2432`	`{`
0	`2433`	`baseQuery = baseQuery`
0	`2434`	`.Where(e => e.IndexNumber != 0);`
	`2435`	`}`
	`2436`	`}`
	`2437`
336	`2438`	`if (filter.IsUnaired.HasValue)`
	`2439`	`{`
0	`2440`	`if (filter.IsUnaired.Value)`
	`2441`	`{`
0	`2442`	`baseQuery = baseQuery`
0	`2443`	`.Where(e => e.PremiereDate >= now);`
	`2444`	`}`
	`2445`	`else`
	`2446`	`{`
0	`2447`	`baseQuery = baseQuery`
0	`2448`	`.Where(e => e.PremiereDate < now);`
	`2449`	`}`
	`2450`	`}`
	`2451`
336	`2452`	`if (filter.MediaTypes.Length > 0)`
	`2453`	`{`
21	`2454`	`var mediaTypes = filter.MediaTypes.Select(f => f.ToString()).ToArray();`
21	`2455`	`baseQuery = baseQuery.WhereOneOrMany(mediaTypes, e => e.MediaType);`
	`2456`	`}`
	`2457`
336	`2458`	`if (filter.ItemIds.Length > 0)`
	`2459`	`{`
0	`2460`	`baseQuery = baseQuery.WhereOneOrMany(filter.ItemIds, e => e.Id);`
	`2461`	`}`
	`2462`
336	`2463`	`if (filter.ExcludeItemIds.Length > 0)`
	`2464`	`{`
0	`2465`	`baseQuery = baseQuery`
0	`2466`	`.Where(e => !filter.ExcludeItemIds.Contains(e.Id));`
	`2467`	`}`
	`2468`
336	`2469`	`if (filter.ExcludeProviderIds is not null && filter.ExcludeProviderIds.Count > 0)`
	`2470`	`{`
0	`2471`	`var exclude = filter.ExcludeProviderIds.Select(e => $"{e.Key}:{e.Value}").ToArray();`
0	`2472`	`baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.All(f => !ex`
	`2473`	`}`
	`2474`
336	`2475`	`if (filter.HasAnyProviderId is not null && filter.HasAnyProviderId.Count > 0)`
	`2476`	`{`
	`2477`	`// Allow setting a null or empty value to get all items that have the specified provider set.`
0	`2478`	`var includeAny = filter.HasAnyProviderId.Where(e => string.IsNullOrEmpty(e.Value)).Select(e => e.Key).ToArra`
0	`2479`	`if (includeAny.Length > 0)`
	`2480`	`{`
0	`2481`	`baseQuery = baseQuery.Where(e => e.Provider!.Any(f => includeAny.Contains(f.ProviderId)));`
	`2482`	`}`
	`2483`
0	`2484`	`var includeSelected = filter.HasAnyProviderId.Where(e => !string.IsNullOrEmpty(e.Value)).Select(e => $"{e.Ke`
0	`2485`	`if (includeSelected.Length > 0)`
	`2486`	`{`
0	`2487`	`baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.Any(f =>`
	`2488`	`}`
	`2489`	`}`
	`2490`
336	`2491`	`if (filter.HasImdbId.HasValue)`
	`2492`	`{`
0	`2493`	`baseQuery = filter.HasImdbId.Value`
0	`2494`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == MetadataProvider.Imdb.ToString().T`
0	`2495`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != MetadataProvider.Imdb.ToString().T`
	`2496`	`}`
	`2497`
336	`2498`	`if (filter.HasTmdbId.HasValue)`
	`2499`	`{`
0	`2500`	`baseQuery = filter.HasTmdbId.Value`
0	`2501`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == MetadataProvider.Tmdb.ToString().T`
0	`2502`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != MetadataProvider.Tmdb.ToString().T`
	`2503`	`}`
	`2504`
336	`2505`	`if (filter.HasTvdbId.HasValue)`
	`2506`	`{`
0	`2507`	`baseQuery = filter.HasTvdbId.Value`
0	`2508`	`? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == MetadataProvider.Tvdb.ToString().T`
0	`2509`	`: baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != MetadataProvider.Tvdb.ToString().T`
	`2510`	`}`
	`2511`
336	`2512`	`var queryTopParentIds = filter.TopParentIds;`
	`2513`
336	`2514`	`if (queryTopParentIds.Length > 0)`
	`2515`	`{`
15	`2516`	`var includedItemByNameTypes = GetItemByNameTypesInQuery(filter);`
15	`2517`	`var enableItemsByName = (filter.IncludeItemsByName ?? false) && includedItemByNameTypes.Count > 0;`
15	`2518`	`if (enableItemsByName && includedItemByNameTypes.Count > 0)`
	`2519`	`{`
0	`2520`	`baseQuery = baseQuery.Where(e => includedItemByNameTypes.Contains(e.Type) \|\| queryTopParentIds.Any(w =>`
	`2521`	`}`
	`2522`	`else`
	`2523`	`{`
15	`2524`	`baseQuery = baseQuery.WhereOneOrMany(queryTopParentIds, e => e.TopParentId!.Value);`
	`2525`	`}`
	`2526`	`}`
	`2527`
336	`2528`	`if (filter.AncestorIds.Length > 0)`
	`2529`	`{`
43	`2530`	`baseQuery = baseQuery.Where(e => e.Parents!.Any(f => filter.AncestorIds.Contains(f.ParentItemId)));`
	`2531`	`}`
	`2532`
336	`2533`	`if (!string.IsNullOrWhiteSpace(filter.AncestorWithPresentationUniqueKey))`
	`2534`	`{`
0	`2535`	`baseQuery = baseQuery`
0	`2536`	`.Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Where(f => f.PresentationUn`
	`2537`	`}`
	`2538`
336	`2539`	`if (!string.IsNullOrWhiteSpace(filter.SeriesPresentationUniqueKey))`
	`2540`	`{`
0	`2541`	`baseQuery = baseQuery`
0	`2542`	`.Where(e => e.SeriesPresentationUniqueKey == filter.SeriesPresentationUniqueKey);`
	`2543`	`}`
	`2544`
336	`2545`	`if (filter.ExcludeInheritedTags.Length > 0)`
	`2546`	`{`
0	`2547`	`var excludedTags = filter.ExcludeInheritedTags;`
0	`2548`	`baseQuery = baseQuery.Where(e =>`
0	`2549`	`!e.ItemValues!.Any(f => f.ItemValue.Type == ItemValueType.Tags && excludedTags.Contains(f.ItemValue.Clea`
0	`2550`	`&& (!e.SeriesId.HasValue \|\| !context.ItemValuesMap.Any(f => f.ItemId == e.SeriesId.Value && f.ItemValue.`
	`2551`	`}`
	`2552`
336	`2553`	`if (filter.IncludeInheritedTags.Length > 0)`
	`2554`	`{`
0	`2555`	`var includeTags = filter.IncludeInheritedTags;`
0	`2556`	`var isPlaylistOnlyQuery = includeTypes.Length == 1 && includeTypes.FirstOrDefault() == BaseItemKind.Playlist`
0	`2557`	`baseQuery = baseQuery.Where(e =>`
0	`2558`	`e.ItemValues!.Any(f => f.ItemValue.Type == ItemValueType.Tags && includeTags.Contains(f.ItemValue.CleanV`
0	`2559`
0	`2560`	`// For seasons and episodes, we also need to check the parent series' tags.`
0	`2561`	`\|\| (e.SeriesId.HasValue && context.ItemValuesMap.Any(f => f.ItemId == e.SeriesId.Value && f.ItemValue.Ty`
0	`2562`
0	`2563`	`// A playlist should be accessible to its owner regardless of allowed tags`
0	`2564`	`\|\| (isPlaylistOnlyQuery && e.Data!.Contains($"OwnerUserId\":\"{filter.User!.Id:N}\"")));`
	`2565`	`}`
	`2566`
336	`2567`	`if (filter.SeriesStatuses.Length > 0)`
	`2568`	`{`
0	`2569`	`var seriesStatus = filter.SeriesStatuses.Select(e => e.ToString()).ToArray();`
0	`2570`	`baseQuery = baseQuery`
0	`2571`	`.Where(e => seriesStatus.Any(f => e.Data!.Contains(f)));`
	`2572`	`}`
	`2573`
336	`2574`	`if (filter.BoxSetLibraryFolders.Length > 0)`
	`2575`	`{`
0	`2576`	`var boxsetFolders = filter.BoxSetLibraryFolders.Select(e => e.ToString("N", CultureInfo.InvariantCulture)).T`
0	`2577`	`baseQuery = baseQuery`
0	`2578`	`.Where(e => boxsetFolders.Any(f => e.Data!.Contains(f)));`
	`2579`	`}`
	`2580`
336	`2581`	`if (filter.VideoTypes.Length > 0)`
	`2582`	`{`
0	`2583`	`var videoTypeBs = filter.VideoTypes.Select(e => $"\"VideoType\":\"{e}\"");`
0	`2584`	`baseQuery = baseQuery`
0	`2585`	`.Where(e => videoTypeBs.Any(f => e.Data!.Contains(f)));`
	`2586`	`}`
	`2587`
336	`2588`	`if (filter.Is3D.HasValue)`
	`2589`	`{`
0	`2590`	`if (filter.Is3D.Value)`
	`2591`	`{`
0	`2592`	`baseQuery = baseQuery`
0	`2593`	`.Where(e => e.Data!.Contains("Video3DFormat"));`
	`2594`	`}`
	`2595`	`else`
	`2596`	`{`
0	`2597`	`baseQuery = baseQuery`
0	`2598`	`.Where(e => !e.Data!.Contains("Video3DFormat"));`
	`2599`	`}`
	`2600`	`}`
	`2601`
336	`2602`	`if (filter.IsPlaceHolder.HasValue)`
	`2603`	`{`
0	`2604`	`if (filter.IsPlaceHolder.Value)`
	`2605`	`{`
0	`2606`	`baseQuery = baseQuery`
0	`2607`	`.Where(e => e.Data!.Contains("IsPlaceHolder\":true"));`
	`2608`	`}`
	`2609`	`else`
	`2610`	`{`
0	`2611`	`baseQuery = baseQuery`
0	`2612`	`.Where(e => !e.Data!.Contains("IsPlaceHolder\":true"));`
	`2613`	`}`
	`2614`	`}`
	`2615`
336	`2616`	`if (filter.HasSpecialFeature.HasValue)`
	`2617`	`{`
0	`2618`	`if (filter.HasSpecialFeature.Value)`
	`2619`	`{`
0	`2620`	`baseQuery = baseQuery`
0	`2621`	`.Where(e => e.ExtraIds != null);`
	`2622`	`}`
	`2623`	`else`
	`2624`	`{`
0	`2625`	`baseQuery = baseQuery`
0	`2626`	`.Where(e => e.ExtraIds == null);`
	`2627`	`}`
	`2628`	`}`
	`2629`
336	`2630`	`if (filter.HasTrailer.HasValue \|\| filter.HasThemeSong.HasValue \|\| filter.HasThemeVideo.HasValue)`
	`2631`	`{`
0	`2632`	`if (filter.HasTrailer.GetValueOrDefault() \|\| filter.HasThemeSong.GetValueOrDefault() \|\| filter.HasThemeVideo`
	`2633`	`{`
0	`2634`	`baseQuery = baseQuery`
0	`2635`	`.Where(e => e.ExtraIds != null);`
	`2636`	`}`
	`2637`	`else`
	`2638`	`{`
0	`2639`	`baseQuery = baseQuery`
0	`2640`	`.Where(e => e.ExtraIds == null);`
	`2641`	`}`
	`2642`	`}`
	`2643`
336	`2644`	`return baseQuery;`
	`2645`	`}`
	`2646`
	`2647`	`/// <inheritdoc/>`
	`2648`	`public async Task<bool> ItemExistsAsync(Guid id)`
	`2649`	`{`
	`2650`	`var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);`
	`2651`	`await using (dbContext.ConfigureAwait(false))`
	`2652`	`{`
	`2653`	`return await dbContext.BaseItems.AnyAsync(f => f.Id == id).ConfigureAwait(false);`
	`2654`	`}`
	`2655`	`}`
	`2656`
	`2657`	`/// <inheritdoc/>`
	`2658`	`public bool GetIsPlayed(User user, Guid id, bool recursive)`
	`2659`	`{`
0	`2660`	`using var dbContext = _dbProvider.CreateDbContext();`
	`2661`
0	`2662`	`if (recursive)`
	`2663`	`{`
0	`2664`	`var folderList = TraverseHirachyDown(id, dbContext, item => (item.IsFolder \|\| item.IsVirtualItem));`
	`2665`
0	`2666`	`return dbContext.BaseItems`
0	`2667`	`.Where(e => folderList.Contains(e.ParentId!.Value) && !e.IsFolder && !e.IsVirtualItem)`
0	`2668`	`.All(f => f.UserData!.Any(e => e.UserId == user.Id && e.Played));`
	`2669`	`}`
	`2670`
0	`2671`	`return dbContext.BaseItems.Where(e => e.ParentId == id).All(f => f.UserData!.Any(e => e.UserId == user.Id && e.P`
0	`2672`	`}`
	`2673`
	`2674`	`private static HashSet<Guid> TraverseHirachyDown(Guid parentId, JellyfinDbContext dbContext, Expression<Func<BaseIte`
	`2675`	`{`
1	`2676`	`var folderStack = new HashSet<Guid>()`
1	`2677`	`{`
1	`2678`	`parentId`
1	`2679`	`};`
1	`2680`	`var folderList = new HashSet<Guid>()`
1	`2681`	`{`
1	`2682`	`parentId`
1	`2683`	`};`
	`2684`
2	`2685`	`while (folderStack.Count != 0)`
	`2686`	`{`
1	`2687`	`var items = folderStack.ToArray();`
1	`2688`	`folderStack.Clear();`
1	`2689`	`var query = dbContext.BaseItems`
1	`2690`	`.WhereOneOrMany(items, e => e.ParentId!.Value);`
	`2691`
1	`2692`	`if (filter != null)`
	`2693`	`{`
0	`2694`	`query = query.Where(filter);`
	`2695`	`}`
	`2696`
2	`2697`	`foreach (var item in query.Select(e => e.Id).ToArray())`
	`2698`	`{`
0	`2699`	`if (folderList.Add(item))`
	`2700`	`{`
0	`2701`	`folderStack.Add(item);`
	`2702`	`}`
	`2703`	`}`
	`2704`	`}`
	`2705`
1	`2706`	`return folderList;`
	`2707`	`}`
	`2708`
	`2709`	`/// <inheritdoc/>`
	`2710`	`public IReadOnlyDictionary<string, MusicArtist[]> FindArtists(IReadOnlyList<string> artistNames)`
	`2711`	`{`
0	`2712`	`using var dbContext = _dbProvider.CreateDbContext();`
	`2713`
0	`2714`	`var artists = dbContext.BaseItems.Where(e => e.Type == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtis`
0	`2715`	`.Where(e => artistNames.Contains(e.Name))`
0	`2716`	`.ToArray();`
	`2717`
0	`2718`	`var lookup = artists`
0	`2719`	`.GroupBy(e => e.Name!)`
0	`2720`	`.ToDictionary(`
0	`2721`	`g => g.Key,`
0	`2722`	`g => g.Select(f => DeserializeBaseItem(f)).Where(dto => dto is not null).Cast<MusicArtist>().ToArray());`
	`2723`
0	`2724`	`var result = new Dictionary<string, MusicArtist[]>(artistNames.Count);`
0	`2725`	`foreach (var name in artistNames)`
	`2726`	`{`
0	`2727`	`if (lookup.TryGetValue(name, out var artistArray))`
	`2728`	`{`
0	`2729`	`result[name] = artistArray;`
	`2730`	`}`
	`2731`	`}`
	`2732`
0	`2733`	`return result;`
0	`2734`	`}`
	`2735`	`}`

Methods/Properties