< Summary - Jellyfin

Information

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

Line coverage

51%

Covered lines:	681
Uncovered lines:	631
Coverable lines:	1312
Total lines:	2654
Line coverage:	51.9%

Branch coverage

49%

Covered branches:	369
Total branches:	746
Branch coverage:	49.4%

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

Methods/Properties