< 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

52%

Covered lines:	692
Uncovered lines:	630
Coverable lines:	1322
Total lines:	2671
Line coverage:	52.3%

Branch coverage

50%

Covered branches:	383
Total branches:	752
Branch coverage:	50.9%

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

Methods/Properties