< Summary - Jellyfin

Information
Class: Jellyfin.Server.Implementations.Item.BaseItemRepository
Assembly: Jellyfin.Server.Implementations
File(s): /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
Line coverage
52%
Covered lines: 603
Uncovered lines: 556
Coverable lines: 1159
Total lines: 2367
Line coverage: 52%
Branch coverage
49%
Covered branches: 330
Total branches: 672
Branch coverage: 49.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
DeleteItem(...)50%4496.66%
UpdateInheritedValues()100%11100%
GetItemIdsList(...)100%11100%
GetAllArtists(...)100%210%
GetArtists(...)100%210%
GetAlbumArtists(...)100%210%
GetStudios(...)100%210%
GetGenres(...)100%210%
GetMusicGenres(...)100%210%
GetStudioNames()100%11100%
GetAllArtistNames()100%11100%
GetMusicGenreNames()100%11100%
GetGenreNames()100%11100%
GetItems(...)50%26835%
GetItemList(...)100%11100%
GetLatestItemList(...)0%4260%
GetNextUpSeriesKeys(...)0%620%
ApplyGroupingFilter(...)100%11100%
ApplyQueryPaging(...)87.5%8885.71%
ApplyQueryFilter(...)100%11100%
PrepareItemQuery(...)100%22100%
GetCount(...)100%210%
GetType(...)100%11100%
SaveImages(...)100%210%
SaveItems(...)100%11100%
UpdateOrInsertItems(...)85.71%292889.69%
RetrieveItem(...)50%4485.71%
Map(...)48.78%1448279.06%
Map(...)56.45%956279.46%
GetItemValueNames(...)100%44100%
TypeRequiresDeserialization(...)100%11100%
DeserializeBaseItem(...)50%101088.88%
DeserializeBaseItem(...)83.33%151272.72%
GetItemValues(...)0%210140%
PrepareFilterQuery(...)83.33%6680%
GetCleanValue(...)50%2266.66%
GetItemValuesToSave(...)50%4481.81%
Map(...)0%620%
Map(...)0%7280%
GetPathToSave(...)50%2266.66%
GetItemByNameTypesInQuery(...)100%1010100%
IsTypeInQuery(...)75%5466.66%
EnableGroupByPresentationUniqueKey(...)0%420200%
ApplyOrder(...)57.69%332678.26%
TranslateQuery(...)46.19%2605134239.65%

File(s)

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

#LineLine 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
 7using System;
 8using System.Collections.Concurrent;
 9using System.Collections.Generic;
 10using System.Globalization;
 11using System.Linq;
 12using System.Linq.Expressions;
 13using System.Reflection;
 14using System.Text;
 15using System.Text.Json;
 16using System.Threading;
 17using System.Threading.Tasks;
 18using Jellyfin.Data.Enums;
 19using Jellyfin.Database.Implementations;
 20using Jellyfin.Database.Implementations.Entities;
 21using Jellyfin.Database.Implementations.Enums;
 22using Jellyfin.Extensions;
 23using Jellyfin.Extensions.Json;
 24using Jellyfin.Server.Implementations.Extensions;
 25using MediaBrowser.Common;
 26using MediaBrowser.Controller;
 27using MediaBrowser.Controller.Channels;
 28using MediaBrowser.Controller.Configuration;
 29using MediaBrowser.Controller.Entities;
 30using MediaBrowser.Controller.Entities.Audio;
 31using MediaBrowser.Controller.Entities.TV;
 32using MediaBrowser.Controller.LiveTv;
 33using MediaBrowser.Controller.Persistence;
 34using MediaBrowser.Model.Dto;
 35using MediaBrowser.Model.Entities;
 36using MediaBrowser.Model.LiveTv;
 37using MediaBrowser.Model.Querying;
 38using Microsoft.EntityFrameworkCore;
 39using Microsoft.Extensions.Logging;
 40using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
 41using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;
 42
 43namespace 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>
 54public sealed class BaseItemRepository
 55    : IItemRepository
 56{
 57    /// <summary>
 58    /// Gets the placeholder id for UserData detached items.
 59    /// </summary>
 160    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>
 166    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
 173    private static readonly IReadOnlyList<ItemValueType> _getAllArtistsValueTypes = [ItemValueType.Artist, ItemValueType
 174    private static readonly IReadOnlyList<ItemValueType> _getArtistValueTypes = [ItemValueType.Artist];
 175    private static readonly IReadOnlyList<ItemValueType> _getAlbumArtistValueTypes = [ItemValueType.AlbumArtist];
 176    private static readonly IReadOnlyList<ItemValueType> _getStudiosValueTypes = [ItemValueType.Studios];
 177    private static readonly IReadOnlyList<ItemValueType> _getGenreValueTypes = [ItemValueType.Genre];
 78
 79    /// <summary>
 80    /// Initializes a new instance of the <see cref="BaseItemRepository"/> class.
 81    /// </summary>
 82    /// <param name="dbProvider">The db factory.</param>
 83    /// <param name="appHost">The Application host.</param>
 84    /// <param name="itemTypeLookup">The static type lookup.</param>
 85    /// <param name="serverConfigurationManager">The server Configuration manager.</param>
 86    /// <param name="logger">System logger.</param>
 87    public BaseItemRepository(
 88        IDbContextFactory<JellyfinDbContext> dbProvider,
 89        IServerApplicationHost appHost,
 90        IItemTypeLookup itemTypeLookup,
 91        IServerConfigurationManager serverConfigurationManager,
 92        ILogger<BaseItemRepository> logger)
 93    {
 2194        _dbProvider = dbProvider;
 2195        _appHost = appHost;
 2196        _itemTypeLookup = itemTypeLookup;
 2197        _serverConfigurationManager = serverConfigurationManager;
 2198        _logger = logger;
 2199    }
 100
 101    /// <inheritdoc />
 102    public void DeleteItem(Guid id)
 103    {
 3104        if (id.IsEmpty() || id.Equals(PlaceholderId))
 105        {
 0106            throw new ArgumentException("Guid can't be empty or the placeholder id.", nameof(id));
 107        }
 108
 3109        using var context = _dbProvider.CreateDbContext();
 3110        using var transaction = context.Database.BeginTransaction();
 111
 3112        var date = (DateTime?)DateTime.UtcNow;
 113        // Detach all user watch data
 3114        context.UserData.Where(e => e.ItemId == id)
 3115            .ExecuteUpdate(e => e
 3116                .SetProperty(f => f.RetentionDate, date)
 3117                .SetProperty(f => f.ItemId, PlaceholderId));
 118
 3119        context.AncestorIds.Where(e => e.ItemId == id || e.ParentItemId == id).ExecuteDelete();
 3120        context.AttachmentStreamInfos.Where(e => e.ItemId == id).ExecuteDelete();
 3121        context.BaseItemImageInfos.Where(e => e.ItemId == id).ExecuteDelete();
 3122        context.BaseItemMetadataFields.Where(e => e.ItemId == id).ExecuteDelete();
 3123        context.BaseItemProviders.Where(e => e.ItemId == id).ExecuteDelete();
 3124        context.BaseItemTrailerTypes.Where(e => e.ItemId == id).ExecuteDelete();
 3125        context.BaseItems.Where(e => e.Id == id).ExecuteDelete();
 3126        context.Chapters.Where(e => e.ItemId == id).ExecuteDelete();
 3127        context.CustomItemDisplayPreferences.Where(e => e.ItemId == id).ExecuteDelete();
 3128        context.ItemDisplayPreferences.Where(e => e.ItemId == id).ExecuteDelete();
 3129        context.ItemValues.Where(e => e.BaseItemsMap!.Count == 0).ExecuteDelete();
 3130        context.ItemValuesMap.Where(e => e.ItemId == id).ExecuteDelete();
 3131        context.KeyframeData.Where(e => e.ItemId == id).ExecuteDelete();
 3132        context.MediaSegments.Where(e => e.ItemId == id).ExecuteDelete();
 3133        context.MediaStreamInfos.Where(e => e.ItemId == id).ExecuteDelete();
 3134        context.PeopleBaseItemMap.Where(e => e.ItemId == id).ExecuteDelete();
 3135        context.Peoples.Where(e => e.BaseItems!.Count == 0).ExecuteDelete();
 3136        context.TrickplayInfos.Where(e => e.ItemId == id).ExecuteDelete();
 3137        context.SaveChanges();
 3138        transaction.Commit();
 6139    }
 140
 141    /// <inheritdoc />
 142    public void UpdateInheritedValues()
 143    {
 10144        using var context = _dbProvider.CreateDbContext();
 10145        using var transaction = context.Database.BeginTransaction();
 146
 10147        context.ItemValuesMap.Where(e => e.ItemValue.Type == ItemValueType.InheritedTags).ExecuteDelete();
 148        // ItemValue Inheritance is now correctly mapped via AncestorId on demand
 10149        context.SaveChanges();
 150
 10151        transaction.Commit();
 20152    }
 153
 154    /// <inheritdoc />
 155    public IReadOnlyList<Guid> GetItemIdsList(InternalItemsQuery filter)
 156    {
 11157        ArgumentNullException.ThrowIfNull(filter);
 11158        PrepareFilterQuery(filter);
 159
 11160        using var context = _dbProvider.CreateDbContext();
 11161        return ApplyQueryFilter(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context
 11162    }
 163
 164    /// <inheritdoc />
 165    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAllArtists(InternalItemsQuery filter)
 166    {
 0167        return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtis
 168    }
 169
 170    /// <inheritdoc />
 171    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)
 172    {
 0173        return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);
 174    }
 175
 176    /// <inheritdoc />
 177    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)
 178    {
 0179        return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArti
 180    }
 181
 182    /// <inheritdoc />
 183    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)
 184    {
 0185        return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);
 186    }
 187
 188    /// <inheritdoc />
 189    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)
 190    {
 0191        return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]);
 192    }
 193
 194    /// <inheritdoc />
 195    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetMusicGenres(InternalItemsQuery filter)
 196    {
 0197        return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]);
 198    }
 199
 200    /// <inheritdoc />
 201    public IReadOnlyList<string> GetStudioNames()
 202    {
 11203        return GetItemValueNames(_getStudiosValueTypes, [], []);
 204    }
 205
 206    /// <inheritdoc />
 207    public IReadOnlyList<string> GetAllArtistNames()
 208    {
 11209        return GetItemValueNames(_getAllArtistsValueTypes, [], []);
 210    }
 211
 212    /// <inheritdoc />
 213    public IReadOnlyList<string> GetMusicGenreNames()
 214    {
 11215        return GetItemValueNames(
 11216            _getGenreValueTypes,
 11217            _itemTypeLookup.MusicGenreTypes,
 11218            []);
 219    }
 220
 221    /// <inheritdoc />
 222    public IReadOnlyList<string> GetGenreNames()
 223    {
 11224        return GetItemValueNames(
 11225            _getGenreValueTypes,
 11226            [],
 11227            _itemTypeLookup.MusicGenreTypes);
 228    }
 229
 230    /// <inheritdoc />
 231    public QueryResult<BaseItemDto> GetItems(InternalItemsQuery filter)
 232    {
 1233        ArgumentNullException.ThrowIfNull(filter);
 1234        if (!filter.EnableTotalRecordCount || (!filter.Limit.HasValue && (filter.StartIndex ?? 0) == 0))
 235        {
 1236            var returnList = GetItemList(filter);
 1237            return new QueryResult<BaseItemDto>(
 1238                filter.StartIndex,
 1239                returnList.Count,
 1240                returnList);
 241        }
 242
 0243        PrepareFilterQuery(filter);
 0244        var result = new QueryResult<BaseItemDto>();
 245
 0246        using var context = _dbProvider.CreateDbContext();
 247
 0248        IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);
 249
 0250        dbQuery = TranslateQuery(dbQuery, context, filter);
 0251        if (filter.EnableTotalRecordCount)
 252        {
 0253            result.TotalRecordCount = dbQuery.Count();
 254        }
 255
 0256        dbQuery = ApplyGroupingFilter(dbQuery, filter);
 0257        dbQuery = ApplyQueryPaging(dbQuery, filter);
 258
 0259        result.Items = dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDe
 0260        result.StartIndex = filter.StartIndex ?? 0;
 0261        return result;
 0262    }
 263
 264    /// <inheritdoc />
 265    public IReadOnlyList<BaseItemDto> GetItemList(InternalItemsQuery filter)
 266    {
 294267        ArgumentNullException.ThrowIfNull(filter);
 294268        PrepareFilterQuery(filter);
 269
 294270        using var context = _dbProvider.CreateDbContext();
 294271        IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);
 272
 294273        dbQuery = TranslateQuery(dbQuery, context, filter);
 274
 294275        dbQuery = ApplyGroupingFilter(dbQuery, filter);
 294276        dbQuery = ApplyQueryPaging(dbQuery, filter);
 277
 294278        return dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserializ
 294279    }
 280
 281    /// <inheritdoc/>
 282    public IReadOnlyList<BaseItem> GetLatestItemList(InternalItemsQuery filter, CollectionType collectionType)
 283    {
 0284        ArgumentNullException.ThrowIfNull(filter);
 0285        PrepareFilterQuery(filter);
 286
 287        // Early exit if collection type is not tvshows or music
 0288        if (collectionType != CollectionType.tvshows && collectionType != CollectionType.music)
 289        {
 0290            return Array.Empty<BaseItem>();
 291        }
 292
 0293        using var context = _dbProvider.CreateDbContext();
 294
 295        // Subquery to group by SeriesNames/Album and get the max Date Created for each group.
 0296        var subquery = PrepareItemQuery(context, filter);
 0297        subquery = TranslateQuery(subquery, context, filter);
 0298        var subqueryGrouped = subquery.GroupBy(g => collectionType == CollectionType.tvshows ? g.SeriesName : g.Album)
 0299            .Select(g => new
 0300            {
 0301                Key = g.Key,
 0302                MaxDateCreated = g.Max(a => a.DateCreated)
 0303            })
 0304            .OrderByDescending(g => g.MaxDateCreated)
 0305            .Select(g => g);
 306
 0307        if (filter.Limit.HasValue)
 308        {
 0309            subqueryGrouped = subqueryGrouped.Take(filter.Limit.Value);
 310        }
 311
 0312        filter.Limit = null;
 313
 0314        var mainquery = PrepareItemQuery(context, filter);
 0315        mainquery = TranslateQuery(mainquery, context, filter);
 0316        mainquery = mainquery.Where(g => g.DateCreated >= subqueryGrouped.Min(s => s.MaxDateCreated));
 0317        mainquery = ApplyGroupingFilter(mainquery, filter);
 0318        mainquery = ApplyQueryPaging(mainquery, filter);
 319
 0320        return mainquery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserial
 0321    }
 322
 323    /// <inheritdoc />
 324    public IReadOnlyList<string> GetNextUpSeriesKeys(InternalItemsQuery filter, DateTime dateCutoff)
 325    {
 0326        ArgumentNullException.ThrowIfNull(filter);
 0327        ArgumentNullException.ThrowIfNull(filter.User);
 328
 0329        using var context = _dbProvider.CreateDbContext();
 330
 0331        var query = context.BaseItems
 0332            .AsNoTracking()
 0333            .Where(i => filter.TopParentIds.Contains(i.TopParentId!.Value))
 0334            .Where(i => i.Type == _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode])
 0335            .Join(
 0336                context.UserData.AsNoTracking().Where(e => e.ItemId != EF.Constant(PlaceholderId)),
 0337                i => new { UserId = filter.User.Id, ItemId = i.Id },
 0338                u => new { UserId = u.UserId, ItemId = u.ItemId },
 0339                (entity, data) => new { Item = entity, UserData = data })
 0340            .GroupBy(g => g.Item.SeriesPresentationUniqueKey)
 0341            .Select(g => new { g.Key, LastPlayedDate = g.Max(u => u.UserData.LastPlayedDate) })
 0342            .Where(g => g.Key != null && g.LastPlayedDate != null && g.LastPlayedDate >= dateCutoff)
 0343            .OrderByDescending(g => g.LastPlayedDate)
 0344            .Select(g => g.Key!);
 345
 0346        if (filter.Limit.HasValue)
 347        {
 0348            query = query.Take(filter.Limit.Value);
 349        }
 350
 0351        return query.ToArray();
 0352    }
 353
 354    private IQueryable<BaseItemEntity> ApplyGroupingFilter(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter
 355    {
 356        // This whole block is needed to filter duplicate entries on request
 357        // for the time being it cannot be used because it would destroy the ordering
 358        // this results in "duplicate" responses for queries that try to lookup individual series or multiple versions b
 359        // for that case the invoker has to run a DistinctBy(e => e.PresentationUniqueKey) on their own
 360
 361        // var enableGroupByPresentationUniqueKey = EnableGroupByPresentationUniqueKey(filter);
 362        // if (enableGroupByPresentationUniqueKey && filter.GroupBySeriesPresentationUniqueKey)
 363        // {
 364        //     dbQuery = ApplyOrder(dbQuery, filter);
 365        //     dbQuery = dbQuery.GroupBy(e => new { e.PresentationUniqueKey, e.SeriesPresentationUniqueKey }).Select(e =
 366        // }
 367        // else if (enableGroupByPresentationUniqueKey)
 368        // {
 369        //     dbQuery = ApplyOrder(dbQuery, filter);
 370        //     dbQuery = dbQuery.GroupBy(e => e.PresentationUniqueKey).Select(e => e.First());
 371        // }
 372        // else if (filter.GroupBySeriesPresentationUniqueKey)
 373        // {
 374        //     dbQuery = ApplyOrder(dbQuery, filter);
 375        //     dbQuery = dbQuery.GroupBy(e => e.SeriesPresentationUniqueKey).Select(e => e.First());
 376        // }
 377        // else
 378        // {
 379        //     dbQuery = dbQuery.Distinct();
 380        //     dbQuery = ApplyOrder(dbQuery, filter);
 381        // }
 305382        dbQuery = dbQuery.Distinct();
 305383        dbQuery = ApplyOrder(dbQuery, filter);
 384
 305385        return dbQuery;
 386    }
 387
 388    private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
 389    {
 305390        if (filter.Limit.HasValue || filter.StartIndex.HasValue)
 391        {
 85392            var offset = filter.StartIndex ?? 0;
 393
 85394            if (offset > 0)
 395            {
 0396                dbQuery = dbQuery.Skip(offset);
 397            }
 398
 85399            if (filter.Limit.HasValue)
 400            {
 85401                dbQuery = dbQuery.Take(filter.Limit.Value);
 402            }
 403        }
 404
 305405        return dbQuery;
 406    }
 407
 408    private IQueryable<BaseItemEntity> ApplyQueryFilter(IQueryable<BaseItemEntity> dbQuery, JellyfinDbContext context, I
 409    {
 11410        dbQuery = TranslateQuery(dbQuery, context, filter);
 11411        dbQuery = ApplyOrder(dbQuery, filter);
 11412        dbQuery = ApplyGroupingFilter(dbQuery, filter);
 11413        dbQuery = ApplyQueryPaging(dbQuery, filter);
 11414        return dbQuery;
 415    }
 416
 417    private IQueryable<BaseItemEntity> PrepareItemQuery(JellyfinDbContext context, InternalItemsQuery filter)
 418    {
 510419        IQueryable<BaseItemEntity> dbQuery = context.BaseItems.AsNoTracking();
 510420        dbQuery = dbQuery.AsSingleQuery()
 510421            .Include(e => e.TrailerTypes)
 510422            .Include(e => e.Provider)
 510423            .Include(e => e.LockedFields);
 424
 510425        if (filter.DtoOptions.EnableImages)
 426        {
 510427            dbQuery = dbQuery.Include(e => e.Images);
 428        }
 429
 510430        return dbQuery;
 431    }
 432
 433    /// <inheritdoc/>
 434    public int GetCount(InternalItemsQuery filter)
 435    {
 0436        ArgumentNullException.ThrowIfNull(filter);
 437        // Hack for right now since we currently don't support filtering out these duplicates within a query
 0438        PrepareFilterQuery(filter);
 439
 0440        using var context = _dbProvider.CreateDbContext();
 0441        var dbQuery = TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);
 442
 0443        return dbQuery.Count();
 0444    }
 445
 446#pragma warning disable CA1307 // Specify StringComparison for clarity
 447    /// <summary>
 448    /// Gets the type.
 449    /// </summary>
 450    /// <param name="typeName">Name of the type.</param>
 451    /// <returns>Type.</returns>
 452    /// <exception cref="ArgumentNullException"><c>typeName</c> is null.</exception>
 453    private static Type? GetType(string typeName)
 454    {
 178455        ArgumentException.ThrowIfNullOrEmpty(typeName);
 456
 457        // TODO: this isn't great. Refactor later to be both globally handled by a dedicated service not just an static 
 458        // currently this is done so that plugins may introduce their own type of baseitems as we dont know when we are 
 178459        return _typeMap.GetOrAdd(typeName, k => AppDomain.CurrentDomain.GetAssemblies()
 178460            .Select(a => a.GetType(k))
 178461            .FirstOrDefault(t => t is not null));
 462    }
 463
 464    /// <inheritdoc  />
 465    public void SaveImages(BaseItemDto item)
 466    {
 0467        ArgumentNullException.ThrowIfNull(item);
 468
 0469        var images = item.ImageInfos.Select(e => Map(item.Id, e));
 0470        using var context = _dbProvider.CreateDbContext();
 0471        context.BaseItemImageInfos.Where(e => e.ItemId == item.Id).ExecuteDelete();
 0472        context.BaseItemImageInfos.AddRange(images);
 0473        context.SaveChanges();
 0474    }
 475
 476    /// <inheritdoc  />
 477    public void SaveItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)
 478    {
 87479        UpdateOrInsertItems(items, cancellationToken);
 87480    }
 481
 482    /// <inheritdoc cref="IItemRepository"/>
 483    public void UpdateOrInsertItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)
 484    {
 87485        ArgumentNullException.ThrowIfNull(items);
 87486        cancellationToken.ThrowIfCancellationRequested();
 487
 87488        var tuples = new List<(BaseItemDto Item, List<Guid>? AncestorIds, BaseItemDto TopParent, IEnumerable<string> Use
 348489        foreach (var item in items.GroupBy(e => e.Id).Select(e => e.Last()).Where(e => e.Id != PlaceholderId))
 490        {
 87491            var ancestorIds = item.SupportsAncestors ?
 87492                item.GetAncestorIds().Distinct().ToList() :
 87493                null;
 494
 87495            var topParent = item.GetTopParent();
 496
 87497            var userdataKey = item.GetUserDataKeys();
 87498            var inheritedTags = item.GetInheritedTags();
 499
 87500            tuples.Add((item, ancestorIds, topParent, userdataKey, inheritedTags));
 501        }
 502
 87503        using var context = _dbProvider.CreateDbContext();
 87504        using var transaction = context.Database.BeginTransaction();
 505
 87506        var ids = tuples.Select(f => f.Item.Id).ToArray();
 87507        var existingItems = context.BaseItems.Where(e => ids.Contains(e.Id)).Select(f => f.Id).ToArray();
 87508        var newItems = tuples.Where(e => !existingItems.Contains(e.Item.Id)).ToArray();
 509
 348510        foreach (var item in tuples)
 511        {
 87512            var entity = Map(item.Item);
 513            // TODO: refactor this "inconsistency"
 87514            entity.TopParentId = item.TopParent?.Id;
 515
 87516            if (!existingItems.Any(e => e == entity.Id))
 517            {
 48518                context.BaseItems.Add(entity);
 519            }
 520            else
 521            {
 39522                context.BaseItemProviders.Where(e => e.ItemId == entity.Id).ExecuteDelete();
 39523                context.BaseItems.Attach(entity).State = EntityState.Modified;
 524            }
 525        }
 526
 87527        context.SaveChanges();
 528
 270529        foreach (var item in newItems)
 530        {
 531            // reattach old userData entries
 48532            var userKeys = item.UserDataKey.ToArray();
 48533            var retentionDate = (DateTime?)null;
 48534            context.UserData
 48535                .Where(e => e.ItemId == PlaceholderId)
 48536                .Where(e => userKeys.Contains(e.CustomDataKey))
 48537                .ExecuteUpdate(e => e
 48538                    .SetProperty(f => f.ItemId, item.Item.Id)
 48539                    .SetProperty(f => f.RetentionDate, retentionDate));
 540        }
 541
 87542        var itemValueMaps = tuples
 87543            .Select(e => (e.Item, Values: GetItemValuesToSave(e.Item, e.InheritedTags)))
 87544            .ToArray();
 87545        var allListedItemValues = itemValueMaps
 87546            .SelectMany(f => f.Values)
 87547            .Distinct()
 87548            .ToArray();
 87549        var existingValues = context.ItemValues
 87550            .Select(e => new
 87551            {
 87552                item = e,
 87553                Key = e.Type + "+" + e.Value
 87554            })
 87555            .Where(f => allListedItemValues.Select(e => $"{(int)e.MagicNumber}+{e.Value}").Contains(f.Key))
 87556            .Select(e => e.item)
 87557            .ToArray();
 87558        var missingItemValues = allListedItemValues.Except(existingValues.Select(f => (MagicNumber: f.Type, f.Value))).S
 87559        {
 87560            CleanValue = GetCleanValue(f.Value),
 87561            ItemValueId = Guid.NewGuid(),
 87562            Type = f.MagicNumber,
 87563            Value = f.Value
 87564        }).ToArray();
 87565        context.ItemValues.AddRange(missingItemValues);
 87566        context.SaveChanges();
 567
 87568        var itemValuesStore = existingValues.Concat(missingItemValues).ToArray();
 87569        var valueMap = itemValueMaps
 87570            .Select(f => (f.Item, Values: f.Values.Select(e => itemValuesStore.First(g => g.Value == e.Value && g.Type =
 87571            .ToArray();
 572
 87573        var mappedValues = context.ItemValuesMap.Where(e => ids.Contains(e.ItemId)).ToList();
 574
 348575        foreach (var item in valueMap)
 576        {
 87577            var itemMappedValues = mappedValues.Where(e => e.ItemId == item.Item.Id).ToList();
 174578            foreach (var itemValue in item.Values)
 579            {
 0580                var existingItem = itemMappedValues.FirstOrDefault(f => f.ItemValueId == itemValue.ItemValueId);
 0581                if (existingItem is null)
 582                {
 0583                    context.ItemValuesMap.Add(new ItemValueMap()
 0584                    {
 0585                        Item = null!,
 0586                        ItemId = item.Item.Id,
 0587                        ItemValue = null!,
 0588                        ItemValueId = itemValue.ItemValueId
 0589                    });
 590                }
 591                else
 592                {
 593                    // map exists, remove from list so its been handled.
 0594                    itemMappedValues.Remove(existingItem);
 595                }
 596            }
 597
 598            // all still listed values are not in the new list so remove them.
 87599            context.ItemValuesMap.RemoveRange(itemMappedValues);
 600        }
 601
 87602        context.SaveChanges();
 603
 348604        foreach (var item in tuples)
 605        {
 87606            if (item.Item.SupportsAncestors && item.AncestorIds != null)
 607            {
 87608                var existingAncestorIds = context.AncestorIds.Where(e => e.ItemId == item.Item.Id).ToList();
 87609                var validAncestorIds = context.BaseItems.Where(e => item.AncestorIds.Contains(e.Id)).Select(f => f.Id).T
 190610                foreach (var ancestorId in validAncestorIds)
 611                {
 8612                    var existingAncestorId = existingAncestorIds.FirstOrDefault(e => e.ParentItemId == ancestorId);
 8613                    if (existingAncestorId is null)
 614                    {
 2615                        context.AncestorIds.Add(new AncestorId()
 2616                        {
 2617                            ParentItemId = ancestorId,
 2618                            ItemId = item.Item.Id,
 2619                            Item = null!,
 2620                            ParentItem = null!
 2621                        });
 622                    }
 623                    else
 624                    {
 6625                        existingAncestorIds.Remove(existingAncestorId);
 626                    }
 627                }
 628
 87629                context.AncestorIds.RemoveRange(existingAncestorIds);
 630            }
 631        }
 632
 87633        context.SaveChanges();
 87634        transaction.Commit();
 174635    }
 636
 637    /// <inheritdoc  />
 638    public BaseItemDto? RetrieveItem(Guid id)
 639    {
 216640        if (id.IsEmpty())
 641        {
 0642            throw new ArgumentException("Guid can't be empty", nameof(id));
 643        }
 644
 216645        using var context = _dbProvider.CreateDbContext();
 216646        var item = PrepareItemQuery(context, new()
 216647        {
 216648            DtoOptions = new()
 216649            {
 216650                EnableImages = true
 216651            }
 216652        }).FirstOrDefault(e => e.Id == id);
 216653        if (item is null)
 654        {
 216655            return null;
 656        }
 657
 0658        return DeserializeBaseItem(item);
 216659    }
 660
 661    /// <summary>
 662    /// Maps a Entity to the DTO.
 663    /// </summary>
 664    /// <param name="entity">The entity.</param>
 665    /// <param name="dto">The dto base instance.</param>
 666    /// <param name="appHost">The Application server Host.</param>
 667    /// <returns>The dto to map.</returns>
 668    public static BaseItemDto Map(BaseItemEntity entity, BaseItemDto dto, IServerApplicationHost? appHost)
 669    {
 89670        dto.Id = entity.Id;
 89671        dto.ParentId = entity.ParentId.GetValueOrDefault();
 89672        dto.Path = appHost?.ExpandVirtualPath(entity.Path) ?? entity.Path;
 89673        dto.EndDate = entity.EndDate;
 89674        dto.CommunityRating = entity.CommunityRating;
 89675        dto.CustomRating = entity.CustomRating;
 89676        dto.IndexNumber = entity.IndexNumber;
 89677        dto.IsLocked = entity.IsLocked;
 89678        dto.Name = entity.Name;
 89679        dto.OfficialRating = entity.OfficialRating;
 89680        dto.Overview = entity.Overview;
 89681        dto.ParentIndexNumber = entity.ParentIndexNumber;
 89682        dto.PremiereDate = entity.PremiereDate;
 89683        dto.ProductionYear = entity.ProductionYear;
 89684        dto.SortName = entity.SortName;
 89685        dto.ForcedSortName = entity.ForcedSortName;
 89686        dto.RunTimeTicks = entity.RunTimeTicks;
 89687        dto.PreferredMetadataLanguage = entity.PreferredMetadataLanguage;
 89688        dto.PreferredMetadataCountryCode = entity.PreferredMetadataCountryCode;
 89689        dto.IsInMixedFolder = entity.IsInMixedFolder;
 89690        dto.InheritedParentalRatingValue = entity.InheritedParentalRatingValue;
 89691        dto.InheritedParentalRatingSubValue = entity.InheritedParentalRatingSubValue;
 89692        dto.CriticRating = entity.CriticRating;
 89693        dto.PresentationUniqueKey = entity.PresentationUniqueKey;
 89694        dto.OriginalTitle = entity.OriginalTitle;
 89695        dto.Album = entity.Album;
 89696        dto.LUFS = entity.LUFS;
 89697        dto.NormalizationGain = entity.NormalizationGain;
 89698        dto.IsVirtualItem = entity.IsVirtualItem;
 89699        dto.ExternalSeriesId = entity.ExternalSeriesId;
 89700        dto.Tagline = entity.Tagline;
 89701        dto.TotalBitrate = entity.TotalBitrate;
 89702        dto.ExternalId = entity.ExternalId;
 89703        dto.Size = entity.Size;
 89704        dto.Genres = string.IsNullOrWhiteSpace(entity.Genres) ? [] : entity.Genres.Split('|');
 89705        dto.DateCreated = entity.DateCreated ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
 89706        dto.DateModified = entity.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
 89707        dto.ChannelId = entity.ChannelId ?? Guid.Empty;
 89708        dto.DateLastRefreshed = entity.DateLastRefreshed ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
 89709        dto.DateLastSaved = entity.DateLastSaved ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
 89710        dto.OwnerId = string.IsNullOrWhiteSpace(entity.OwnerId) ? Guid.Empty : (Guid.TryParse(entity.OwnerId, out var ow
 89711        dto.Width = entity.Width.GetValueOrDefault();
 89712        dto.Height = entity.Height.GetValueOrDefault();
 89713        if (entity.Provider is not null)
 714        {
 89715            dto.ProviderIds = entity.Provider.ToDictionary(e => e.ProviderId, e => e.ProviderValue);
 716        }
 717
 89718        if (entity.ExtraType is not null)
 719        {
 0720            dto.ExtraType = (ExtraType)entity.ExtraType;
 721        }
 722
 89723        if (entity.LockedFields is not null)
 724        {
 89725            dto.LockedFields = entity.LockedFields?.Select(e => (MetadataField)e.Id).ToArray() ?? [];
 726        }
 727
 89728        if (entity.Audio is not null)
 729        {
 0730            dto.Audio = (ProgramAudio)entity.Audio;
 731        }
 732
 89733        dto.ExtraIds = string.IsNullOrWhiteSpace(entity.ExtraIds) ? [] : entity.ExtraIds.Split('|').Select(e => Guid.Par
 89734        dto.ProductionLocations = entity.ProductionLocations?.Split('|') ?? [];
 89735        dto.Studios = entity.Studios?.Split('|') ?? [];
 89736        dto.Tags = string.IsNullOrWhiteSpace(entity.Tags) ? [] : entity.Tags.Split('|');
 737
 89738        if (dto is IHasProgramAttributes hasProgramAttributes)
 739        {
 0740            hasProgramAttributes.IsMovie = entity.IsMovie;
 0741            hasProgramAttributes.IsSeries = entity.IsSeries;
 0742            hasProgramAttributes.EpisodeTitle = entity.EpisodeTitle;
 0743            hasProgramAttributes.IsRepeat = entity.IsRepeat;
 744        }
 745
 89746        if (dto is LiveTvChannel liveTvChannel)
 747        {
 0748            liveTvChannel.ServiceName = entity.ExternalServiceId;
 749        }
 750
 89751        if (dto is Trailer trailer)
 752        {
 0753            trailer.TrailerTypes = entity.TrailerTypes?.Select(e => (TrailerType)e.Id).ToArray() ?? [];
 754        }
 755
 89756        if (dto is Video video)
 757        {
 0758            video.PrimaryVersionId = entity.PrimaryVersionId;
 759        }
 760
 89761        if (dto is IHasSeries hasSeriesName)
 762        {
 0763            hasSeriesName.SeriesName = entity.SeriesName;
 0764            hasSeriesName.SeriesId = entity.SeriesId.GetValueOrDefault();
 0765            hasSeriesName.SeriesPresentationUniqueKey = entity.SeriesPresentationUniqueKey;
 766        }
 767
 89768        if (dto is Episode episode)
 769        {
 0770            episode.SeasonName = entity.SeasonName;
 0771            episode.SeasonId = entity.SeasonId.GetValueOrDefault();
 772        }
 773
 89774        if (dto is IHasArtist hasArtists)
 775        {
 0776            hasArtists.Artists = entity.Artists?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
 777        }
 778
 89779        if (dto is IHasAlbumArtist hasAlbumArtists)
 780        {
 0781            hasAlbumArtists.AlbumArtists = entity.AlbumArtists?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
 782        }
 783
 89784        if (dto is LiveTvProgram program)
 785        {
 0786            program.ShowId = entity.ShowId;
 787        }
 788
 89789        if (entity.Images is not null)
 790        {
 89791            dto.ImageInfos = entity.Images.Select(e => Map(e, appHost)).ToArray();
 792        }
 793
 794        // dto.Type = entity.Type;
 795        // dto.Data = entity.Data;
 796        // dto.MediaType = Enum.TryParse<MediaType>(entity.MediaType);
 89797        if (dto is IHasStartDate hasStartDate)
 798        {
 0799            hasStartDate.StartDate = entity.StartDate.GetValueOrDefault();
 800        }
 801
 802        // Fields that are present in the DB but are never actually used
 803        // dto.UnratedType = entity.UnratedType;
 804        // dto.TopParentId = entity.TopParentId;
 805        // dto.CleanName = entity.CleanName;
 806        // dto.UserDataKey = entity.UserDataKey;
 807
 89808        if (dto is Folder folder)
 809        {
 89810            folder.DateLastMediaAdded = entity.DateLastMediaAdded ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKin
 811        }
 812
 89813        return dto;
 814    }
 815
 816    /// <summary>
 817    /// Maps a Entity to the DTO.
 818    /// </summary>
 819    /// <param name="dto">The entity.</param>
 820    /// <returns>The dto to map.</returns>
 821    public BaseItemEntity Map(BaseItemDto dto)
 822    {
 87823        var dtoType = dto.GetType();
 87824        var entity = new BaseItemEntity()
 87825        {
 87826            Type = dtoType.ToString(),
 87827            Id = dto.Id
 87828        };
 829
 87830        if (TypeRequiresDeserialization(dtoType))
 831        {
 66832            entity.Data = JsonSerializer.Serialize(dto, dtoType, JsonDefaults.Options);
 833        }
 834
 87835        entity.ParentId = !dto.ParentId.IsEmpty() ? dto.ParentId : null;
 87836        entity.Path = GetPathToSave(dto.Path);
 87837        entity.EndDate = dto.EndDate;
 87838        entity.CommunityRating = dto.CommunityRating;
 87839        entity.CustomRating = dto.CustomRating;
 87840        entity.IndexNumber = dto.IndexNumber;
 87841        entity.IsLocked = dto.IsLocked;
 87842        entity.Name = dto.Name;
 87843        entity.CleanName = GetCleanValue(dto.Name);
 87844        entity.OfficialRating = dto.OfficialRating;
 87845        entity.Overview = dto.Overview;
 87846        entity.ParentIndexNumber = dto.ParentIndexNumber;
 87847        entity.PremiereDate = dto.PremiereDate;
 87848        entity.ProductionYear = dto.ProductionYear;
 87849        entity.SortName = dto.SortName;
 87850        entity.ForcedSortName = dto.ForcedSortName;
 87851        entity.RunTimeTicks = dto.RunTimeTicks;
 87852        entity.PreferredMetadataLanguage = dto.PreferredMetadataLanguage;
 87853        entity.PreferredMetadataCountryCode = dto.PreferredMetadataCountryCode;
 87854        entity.IsInMixedFolder = dto.IsInMixedFolder;
 87855        entity.InheritedParentalRatingValue = dto.InheritedParentalRatingValue;
 87856        entity.InheritedParentalRatingSubValue = dto.InheritedParentalRatingSubValue;
 87857        entity.CriticRating = dto.CriticRating;
 87858        entity.PresentationUniqueKey = dto.PresentationUniqueKey;
 87859        entity.OriginalTitle = dto.OriginalTitle;
 87860        entity.Album = dto.Album;
 87861        entity.LUFS = dto.LUFS;
 87862        entity.NormalizationGain = dto.NormalizationGain;
 87863        entity.IsVirtualItem = dto.IsVirtualItem;
 87864        entity.ExternalSeriesId = dto.ExternalSeriesId;
 87865        entity.Tagline = dto.Tagline;
 87866        entity.TotalBitrate = dto.TotalBitrate;
 87867        entity.ExternalId = dto.ExternalId;
 87868        entity.Size = dto.Size;
 87869        entity.Genres = string.Join('|', dto.Genres);
 87870        entity.DateCreated = dto.DateCreated == DateTime.MinValue ? null : dto.DateCreated;
 87871        entity.DateModified = dto.DateModified == DateTime.MinValue ? null : dto.DateModified;
 87872        entity.ChannelId = dto.ChannelId;
 87873        entity.DateLastRefreshed = dto.DateLastRefreshed == DateTime.MinValue ? null : dto.DateLastRefreshed;
 87874        entity.DateLastSaved = dto.DateLastSaved == DateTime.MinValue ? null : dto.DateLastSaved;
 87875        entity.OwnerId = dto.OwnerId.ToString();
 87876        entity.Width = dto.Width;
 87877        entity.Height = dto.Height;
 87878        entity.Provider = dto.ProviderIds.Select(e => new BaseItemProvider()
 87879        {
 87880            Item = entity,
 87881            ProviderId = e.Key,
 87882            ProviderValue = e.Value
 87883        }).ToList();
 884
 87885        if (dto.Audio.HasValue)
 886        {
 0887            entity.Audio = (ProgramAudioEntity)dto.Audio;
 888        }
 889
 87890        if (dto.ExtraType.HasValue)
 891        {
 0892            entity.ExtraType = (BaseItemExtraType)dto.ExtraType;
 893        }
 894
 87895        entity.ExtraIds = dto.ExtraIds is not null ? string.Join('|', dto.ExtraIds) : null;
 87896        entity.ProductionLocations = dto.ProductionLocations is not null ? string.Join('|', dto.ProductionLocations) : n
 87897        entity.Studios = dto.Studios is not null ? string.Join('|', dto.Studios) : null;
 87898        entity.Tags = dto.Tags is not null ? string.Join('|', dto.Tags) : null;
 87899        entity.LockedFields = dto.LockedFields is not null ? dto.LockedFields
 87900            .Select(e => new BaseItemMetadataField()
 87901            {
 87902                Id = (int)e,
 87903                Item = entity,
 87904                ItemId = entity.Id
 87905            })
 87906            .ToArray() : null;
 907
 87908        if (dto is IHasProgramAttributes hasProgramAttributes)
 909        {
 0910            entity.IsMovie = hasProgramAttributes.IsMovie;
 0911            entity.IsSeries = hasProgramAttributes.IsSeries;
 0912            entity.EpisodeTitle = hasProgramAttributes.EpisodeTitle;
 0913            entity.IsRepeat = hasProgramAttributes.IsRepeat;
 914        }
 915
 87916        if (dto is LiveTvChannel liveTvChannel)
 917        {
 0918            entity.ExternalServiceId = liveTvChannel.ServiceName;
 919        }
 920
 87921        if (dto is Video video)
 922        {
 0923            entity.PrimaryVersionId = video.PrimaryVersionId;
 924        }
 925
 87926        if (dto is IHasSeries hasSeriesName)
 927        {
 0928            entity.SeriesName = hasSeriesName.SeriesName;
 0929            entity.SeriesId = hasSeriesName.SeriesId;
 0930            entity.SeriesPresentationUniqueKey = hasSeriesName.SeriesPresentationUniqueKey;
 931        }
 932
 87933        if (dto is Episode episode)
 934        {
 0935            entity.SeasonName = episode.SeasonName;
 0936            entity.SeasonId = episode.SeasonId;
 937        }
 938
 87939        if (dto is IHasArtist hasArtists)
 940        {
 0941            entity.Artists = hasArtists.Artists is not null ? string.Join('|', hasArtists.Artists) : null;
 942        }
 943
 87944        if (dto is IHasAlbumArtist hasAlbumArtists)
 945        {
 0946            entity.AlbumArtists = hasAlbumArtists.AlbumArtists is not null ? string.Join('|', hasAlbumArtists.AlbumArtis
 947        }
 948
 87949        if (dto is LiveTvProgram program)
 950        {
 0951            entity.ShowId = program.ShowId;
 952        }
 953
 87954        if (dto.ImageInfos is not null)
 955        {
 87956            entity.Images = dto.ImageInfos.Select(f => Map(dto.Id, f)).ToArray();
 957        }
 958
 87959        if (dto is Trailer trailer)
 960        {
 0961            entity.TrailerTypes = trailer.TrailerTypes?.Select(e => new BaseItemTrailerType()
 0962            {
 0963                Id = (int)e,
 0964                Item = entity,
 0965                ItemId = entity.Id
 0966            }).ToArray() ?? [];
 967        }
 968
 969        // dto.Type = entity.Type;
 970        // dto.Data = entity.Data;
 87971        entity.MediaType = dto.MediaType.ToString();
 87972        if (dto is IHasStartDate hasStartDate)
 973        {
 0974            entity.StartDate = hasStartDate.StartDate;
 975        }
 976
 87977        entity.UnratedType = dto.GetBlockUnratedType().ToString();
 978
 979        // Fields that are present in the DB but are never actually used
 980        // dto.UserDataKey = entity.UserDataKey;
 981
 87982        if (dto is Folder folder)
 983        {
 87984            entity.DateLastMediaAdded = folder.DateLastMediaAdded == DateTime.MinValue ? null : folder.DateLastMediaAdde
 87985            entity.IsFolder = folder.IsFolder;
 986        }
 987
 87988        return entity;
 989    }
 990
 991    private string[] GetItemValueNames(IReadOnlyList<ItemValueType> itemValueTypes, IReadOnlyList<string> withItemTypes,
 992    {
 44993        using var context = _dbProvider.CreateDbContext();
 994
 44995        var query = context.ItemValuesMap
 44996            .AsNoTracking()
 44997            .Where(e => itemValueTypes.Any(w => (ItemValueType)w == e.ItemValue.Type));
 44998        if (withItemTypes.Count > 0)
 999        {
 111000            query = query.Where(e => withItemTypes.Contains(e.Item.Type));
 1001        }
 1002
 441003        if (excludeItemTypes.Count > 0)
 1004        {
 111005            query = query.Where(e => !excludeItemTypes.Contains(e.Item.Type));
 1006        }
 1007
 1008        // query = query.DistinctBy(e => e.CleanValue);
 441009        return query.Select(e => e.ItemValue)
 441010            .GroupBy(e => e.CleanValue)
 441011            .Select(e => e.First().Value)
 441012            .ToArray();
 441013    }
 1014
 1015    private static bool TypeRequiresDeserialization(Type type)
 1016    {
 1761017        return type.GetCustomAttribute<RequiresSourceSerialisationAttribute>() == null;
 1018    }
 1019
 1020    private BaseItemDto DeserializeBaseItem(BaseItemEntity baseItemEntity, bool skipDeserialization = false)
 1021    {
 891022        ArgumentNullException.ThrowIfNull(baseItemEntity, nameof(baseItemEntity));
 891023        if (_serverConfigurationManager?.Configuration is null)
 1024        {
 01025            throw new InvalidOperationException("Server Configuration manager or configuration is null");
 1026        }
 1027
 891028        var typeToSerialise = GetType(baseItemEntity.Type);
 891029        return BaseItemRepository.DeserializeBaseItem(
 891030            baseItemEntity,
 891031            _logger,
 891032            _appHost,
 891033            skipDeserialization || (_serverConfigurationManager.Configuration.SkipDeserializationForBasicTypes && (typeT
 1034    }
 1035
 1036    /// <summary>
 1037    /// Deserializes a BaseItemEntity and sets all properties.
 1038    /// </summary>
 1039    /// <param name="baseItemEntity">The DB entity.</param>
 1040    /// <param name="logger">Logger.</param>
 1041    /// <param name="appHost">The application server Host.</param>
 1042    /// <param name="skipDeserialization">If only mapping should be processed.</param>
 1043    /// <returns>A mapped BaseItem.</returns>
 1044    /// <exception cref="InvalidOperationException">Will be thrown if an invalid serialisation is requested.</exception>
 1045    public static BaseItemDto DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost?
 1046    {
 891047        var type = GetType(baseItemEntity.Type) ?? throw new InvalidOperationException("Cannot deserialize unknown type.
 891048        BaseItemDto? dto = null;
 891049        if (TypeRequiresDeserialization(type) && baseItemEntity.Data is not null && !skipDeserialization)
 1050        {
 1051            try
 1052            {
 231053                dto = JsonSerializer.Deserialize(baseItemEntity.Data, type, JsonDefaults.Options) as BaseItemDto;
 231054            }
 01055            catch (JsonException ex)
 1056            {
 01057                logger.LogError(ex, "Error deserializing item with JSON: {Data}", baseItemEntity.Data);
 01058            }
 1059        }
 1060
 891061        if (dto is null)
 1062        {
 661063            dto = Activator.CreateInstance(type) as BaseItemDto ?? throw new InvalidOperationException("Cannot deseriali
 1064        }
 1065
 891066        return Map(baseItemEntity, dto, appHost);
 1067    }
 1068
 1069    private QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetItemValues(InternalItemsQuery filter, IReadOnlyLi
 1070    {
 01071        ArgumentNullException.ThrowIfNull(filter);
 1072
 01073        if (!filter.Limit.HasValue)
 1074        {
 01075            filter.EnableTotalRecordCount = false;
 1076        }
 1077
 01078        using var context = _dbProvider.CreateDbContext();
 1079
 01080        var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context,
 01081        {
 01082            ExcludeItemTypes = filter.ExcludeItemTypes,
 01083            IncludeItemTypes = filter.IncludeItemTypes,
 01084            MediaTypes = filter.MediaTypes,
 01085            AncestorIds = filter.AncestorIds,
 01086            ItemIds = filter.ItemIds,
 01087            TopParentIds = filter.TopParentIds,
 01088            ParentId = filter.ParentId,
 01089            IsAiring = filter.IsAiring,
 01090            IsMovie = filter.IsMovie,
 01091            IsSports = filter.IsSports,
 01092            IsKids = filter.IsKids,
 01093            IsNews = filter.IsNews,
 01094            IsSeries = filter.IsSeries
 01095        });
 1096
 01097        var innerQuery = PrepareItemQuery(context, filter)
 01098            .Where(e => e.Type == returnType)
 01099            .Where(e => context.ItemValues!
 01100                .Where(f => itemValueTypes.Contains(f.Type))
 01101                .Where(f => innerQueryFilter.Any(g => f.BaseItemsMap!.Any(w => w.ItemId == g.Id)))
 01102                .Select(f => f.CleanValue)
 01103                .Contains(e.CleanName));
 1104
 01105        var outerQueryFilter = new InternalItemsQuery(filter.User)
 01106        {
 01107            IsPlayed = filter.IsPlayed,
 01108            IsFavorite = filter.IsFavorite,
 01109            IsFavoriteOrLiked = filter.IsFavoriteOrLiked,
 01110            IsLiked = filter.IsLiked,
 01111            IsLocked = filter.IsLocked,
 01112            NameLessThan = filter.NameLessThan,
 01113            NameStartsWith = filter.NameStartsWith,
 01114            NameStartsWithOrGreater = filter.NameStartsWithOrGreater,
 01115            Tags = filter.Tags,
 01116            OfficialRatings = filter.OfficialRatings,
 01117            StudioIds = filter.StudioIds,
 01118            GenreIds = filter.GenreIds,
 01119            Genres = filter.Genres,
 01120            Years = filter.Years,
 01121            NameContains = filter.NameContains,
 01122            SearchTerm = filter.SearchTerm,
 01123            ExcludeItemIds = filter.ExcludeItemIds
 01124        };
 1125
 01126        var query = TranslateQuery(innerQuery, context, outerQueryFilter)
 01127            .GroupBy(e => e.PresentationUniqueKey);
 1128
 01129        var result = new QueryResult<(BaseItemDto, ItemCounts?)>();
 01130        if (filter.EnableTotalRecordCount)
 1131        {
 01132            result.TotalRecordCount = query.Count();
 1133        }
 1134
 01135        if (filter.Limit.HasValue || filter.StartIndex.HasValue)
 1136        {
 01137            var offset = filter.StartIndex ?? 0;
 1138
 01139            if (offset > 0)
 1140            {
 01141                query = query.Skip(offset);
 1142            }
 1143
 01144            if (filter.Limit.HasValue)
 1145            {
 01146                query = query.Take(filter.Limit.Value);
 1147            }
 1148        }
 1149
 01150        IQueryable<BaseItemEntity>? itemCountQuery = null;
 1151
 01152        if (filter.IncludeItemTypes.Length > 0)
 1153        {
 1154            // if we are to include more then one type, sub query those items beforehand.
 1155
 01156            var typeSubQuery = new InternalItemsQuery(filter.User)
 01157            {
 01158                ExcludeItemTypes = filter.ExcludeItemTypes,
 01159                IncludeItemTypes = filter.IncludeItemTypes,
 01160                MediaTypes = filter.MediaTypes,
 01161                AncestorIds = filter.AncestorIds,
 01162                ExcludeItemIds = filter.ExcludeItemIds,
 01163                ItemIds = filter.ItemIds,
 01164                TopParentIds = filter.TopParentIds,
 01165                ParentId = filter.ParentId,
 01166                IsPlayed = filter.IsPlayed
 01167            };
 1168
 01169            itemCountQuery = TranslateQuery(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderI
 01170                .Where(e => e.ItemValues!.Any(f => itemValueTypes!.Contains(f.ItemValue.Type)));
 1171
 01172            var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
 01173            var movieTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];
 01174            var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];
 01175            var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum];
 01176            var musicArtistTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];
 01177            var audioTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Audio];
 01178            var trailerTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Trailer];
 1179
 01180            var resultQuery = query.Select(e => new
 01181            {
 01182                item = e.AsQueryable()
 01183                        .Include(e => e.TrailerTypes)
 01184                        .Include(e => e.Provider)
 01185                        .Include(e => e.LockedFields)
 01186                        .Include(e => e.Images)
 01187                        .AsSingleQuery().First(),
 01188                // TODO: This is bad refactor!
 01189                itemCount = new ItemCounts()
 01190                {
 01191                    SeriesCount = itemCountQuery!.Count(f => f.Type == seriesTypeName),
 01192                    EpisodeCount = itemCountQuery!.Count(f => f.Type == episodeTypeName),
 01193                    MovieCount = itemCountQuery!.Count(f => f.Type == movieTypeName),
 01194                    AlbumCount = itemCountQuery!.Count(f => f.Type == musicAlbumTypeName),
 01195                    ArtistCount = itemCountQuery!.Count(f => f.Type == musicArtistTypeName),
 01196                    SongCount = itemCountQuery!.Count(f => f.Type == audioTypeName),
 01197                    TrailerCount = itemCountQuery!.Count(f => f.Type == trailerTypeName),
 01198                }
 01199            });
 1200
 01201            result.StartIndex = filter.StartIndex ?? 0;
 01202            result.Items =
 01203            [
 01204                .. resultQuery
 01205                    .AsEnumerable()
 01206                    .Where(e => e is not null)
 01207                    .Select(e =>
 01208                    {
 01209                        return (DeserializeBaseItem(e.item, filter.SkipDeserialization), e.itemCount);
 01210                    })
 01211            ];
 1212        }
 1213        else
 1214        {
 01215            result.StartIndex = filter.StartIndex ?? 0;
 01216            result.Items =
 01217            [
 01218                .. query
 01219                    .Select(e => e.First())
 01220                    .AsEnumerable()
 01221                    .Where(e => e is not null)
 01222                    .Select<BaseItemEntity, (BaseItemDto, ItemCounts?)>(e =>
 01223                    {
 01224                        return (DeserializeBaseItem(e, filter.SkipDeserialization), null);
 01225                    })
 01226            ];
 1227        }
 1228
 01229        return result;
 01230    }
 1231
 1232    private static void PrepareFilterQuery(InternalItemsQuery query)
 1233    {
 3051234        if (query.Limit.HasValue && query.EnableGroupByMetadataKey)
 1235        {
 01236            query.Limit = query.Limit.Value + 4;
 1237        }
 1238
 3051239        if (query.IsResumable ?? false)
 1240        {
 11241            query.IsVirtualItem = false;
 1242        }
 3051243    }
 1244
 1245    private string GetCleanValue(string value)
 1246    {
 901247        if (string.IsNullOrWhiteSpace(value))
 1248        {
 01249            return value;
 1250        }
 1251
 901252        return value.RemoveDiacritics().ToLowerInvariant();
 1253    }
 1254
 1255    private List<(ItemValueType MagicNumber, string Value)> GetItemValuesToSave(BaseItemDto item, List<string> inherited
 1256    {
 871257        var list = new List<(ItemValueType, string)>();
 1258
 871259        if (item is IHasArtist hasArtist)
 1260        {
 01261            list.AddRange(hasArtist.Artists.Select(i => ((ItemValueType)0, i)));
 1262        }
 1263
 871264        if (item is IHasAlbumArtist hasAlbumArtist)
 1265        {
 01266            list.AddRange(hasAlbumArtist.AlbumArtists.Select(i => (ItemValueType.AlbumArtist, i)));
 1267        }
 1268
 871269        list.AddRange(item.Genres.Select(i => (ItemValueType.Genre, i)));
 871270        list.AddRange(item.Studios.Select(i => (ItemValueType.Studios, i)));
 871271        list.AddRange(item.Tags.Select(i => (ItemValueType.Tags, i)));
 1272
 1273        // keywords was 5
 1274
 871275        list.AddRange(inheritedTags.Select(i => (ItemValueType.InheritedTags, i)));
 1276
 1277        // Remove all invalid values.
 871278        list.RemoveAll(i => string.IsNullOrWhiteSpace(i.Item2));
 1279
 871280        return list;
 1281    }
 1282
 1283    private static BaseItemImageInfo Map(Guid baseItemId, ItemImageInfo e)
 1284    {
 01285        return new BaseItemImageInfo()
 01286        {
 01287            ItemId = baseItemId,
 01288            Id = Guid.NewGuid(),
 01289            Path = e.Path,
 01290            Blurhash = e.BlurHash is null ? null : Encoding.UTF8.GetBytes(e.BlurHash),
 01291            DateModified = e.DateModified,
 01292            Height = e.Height,
 01293            Width = e.Width,
 01294            ImageType = (ImageInfoImageType)e.Type,
 01295            Item = null!
 01296        };
 1297    }
 1298
 1299    private static ItemImageInfo Map(BaseItemImageInfo e, IServerApplicationHost? appHost)
 1300    {
 01301        return new ItemImageInfo()
 01302        {
 01303            Path = appHost?.ExpandVirtualPath(e.Path) ?? e.Path,
 01304            BlurHash = e.Blurhash is null ? null : Encoding.UTF8.GetString(e.Blurhash),
 01305            DateModified = e.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc),
 01306            Height = e.Height,
 01307            Width = e.Width,
 01308            Type = (ImageType)e.ImageType
 01309        };
 1310    }
 1311
 1312    private string? GetPathToSave(string path)
 1313    {
 871314        if (path is null)
 1315        {
 01316            return null;
 1317        }
 1318
 871319        return _appHost.ReverseVirtualPath(path);
 1320    }
 1321
 1322    private List<string> GetItemByNameTypesInQuery(InternalItemsQuery query)
 1323    {
 161324        var list = new List<string>();
 1325
 161326        if (IsTypeInQuery(BaseItemKind.Person, query))
 1327        {
 11328            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Person]!);
 1329        }
 1330
 161331        if (IsTypeInQuery(BaseItemKind.Genre, query))
 1332        {
 11333            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]!);
 1334        }
 1335
 161336        if (IsTypeInQuery(BaseItemKind.MusicGenre, query))
 1337        {
 11338            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]!);
 1339        }
 1340
 161341        if (IsTypeInQuery(BaseItemKind.MusicArtist, query))
 1342        {
 11343            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!);
 1344        }
 1345
 161346        if (IsTypeInQuery(BaseItemKind.Studio, query))
 1347        {
 11348            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]!);
 1349        }
 1350
 161351        return list;
 1352    }
 1353
 1354    private bool IsTypeInQuery(BaseItemKind type, InternalItemsQuery query)
 1355    {
 801356        if (query.ExcludeItemTypes.Contains(type))
 1357        {
 01358            return false;
 1359        }
 1360
 801361        return query.IncludeItemTypes.Length == 0 || query.IncludeItemTypes.Contains(type);
 1362    }
 1363
 1364    private bool EnableGroupByPresentationUniqueKey(InternalItemsQuery query)
 1365    {
 01366        if (!query.GroupByPresentationUniqueKey)
 1367        {
 01368            return false;
 1369        }
 1370
 01371        if (query.GroupBySeriesPresentationUniqueKey)
 1372        {
 01373            return false;
 1374        }
 1375
 01376        if (!string.IsNullOrWhiteSpace(query.PresentationUniqueKey))
 1377        {
 01378            return false;
 1379        }
 1380
 01381        if (query.User is null)
 1382        {
 01383            return false;
 1384        }
 1385
 01386        if (query.IncludeItemTypes.Length == 0)
 1387        {
 01388            return true;
 1389        }
 1390
 01391        return query.IncludeItemTypes.Contains(BaseItemKind.Episode)
 01392            || query.IncludeItemTypes.Contains(BaseItemKind.Video)
 01393            || query.IncludeItemTypes.Contains(BaseItemKind.Movie)
 01394            || query.IncludeItemTypes.Contains(BaseItemKind.MusicVideo)
 01395            || query.IncludeItemTypes.Contains(BaseItemKind.Series)
 01396            || query.IncludeItemTypes.Contains(BaseItemKind.Season);
 1397    }
 1398
 1399    private IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter)
 1400    {
 3161401        var orderBy = filter.OrderBy;
 3161402        var hasSearch = !string.IsNullOrEmpty(filter.SearchTerm);
 1403
 3161404        if (hasSearch)
 1405        {
 01406            orderBy = filter.OrderBy = [(ItemSortBy.SortName, SortOrder.Ascending), .. orderBy];
 1407        }
 3161408        else if (orderBy.Count == 0)
 1409        {
 2301410            return query.OrderBy(e => e.SortName);
 1411        }
 1412
 861413        IOrderedQueryable<BaseItemEntity>? orderedQuery = null;
 1414
 861415        var firstOrdering = orderBy.FirstOrDefault();
 861416        if (firstOrdering != default)
 1417        {
 861418            var expression = OrderMapper.MapOrderByField(firstOrdering.OrderBy, filter);
 861419            if (firstOrdering.SortOrder == SortOrder.Ascending)
 1420            {
 851421                orderedQuery = query.OrderBy(expression);
 1422            }
 1423            else
 1424            {
 11425                orderedQuery = query.OrderByDescending(expression);
 1426            }
 1427
 861428            if (firstOrdering.OrderBy is ItemSortBy.Default or ItemSortBy.SortName)
 1429            {
 01430                if (firstOrdering.SortOrder is SortOrder.Ascending)
 1431                {
 01432                    orderedQuery = orderedQuery.ThenBy(e => e.Name);
 1433                }
 1434                else
 1435                {
 01436                    orderedQuery = orderedQuery.ThenByDescending(e => e.Name);
 1437                }
 1438            }
 1439        }
 1440
 2461441        foreach (var item in orderBy.Skip(1))
 1442        {
 371443            var expression = OrderMapper.MapOrderByField(item.OrderBy, filter);
 371444            if (item.SortOrder == SortOrder.Ascending)
 1445            {
 371446                orderedQuery = orderedQuery!.ThenBy(expression);
 1447            }
 1448            else
 1449            {
 01450                orderedQuery = orderedQuery!.ThenByDescending(expression);
 1451            }
 1452        }
 1453
 861454        return orderedQuery ?? query;
 1455    }
 1456
 1457    private IQueryable<BaseItemEntity> TranslateQuery(
 1458        IQueryable<BaseItemEntity> baseQuery,
 1459        JellyfinDbContext context,
 1460        InternalItemsQuery filter)
 1461    {
 1462        const int HDWidth = 1200;
 1463        const int UHDWidth = 3800;
 1464        const int UHDHeight = 2100;
 1465
 3051466        var minWidth = filter.MinWidth;
 3051467        var maxWidth = filter.MaxWidth;
 3051468        var now = DateTime.UtcNow;
 1469
 3051470        if (filter.IsHD.HasValue || filter.Is4K.HasValue)
 1471        {
 01472            bool includeSD = false;
 01473            bool includeHD = false;
 01474            bool include4K = false;
 1475
 01476            if (filter.IsHD.HasValue && !filter.IsHD.Value)
 1477            {
 01478                includeSD = true;
 1479            }
 1480
 01481            if (filter.IsHD.HasValue && filter.IsHD.Value)
 1482            {
 01483                includeHD = true;
 1484            }
 1485
 01486            if (filter.Is4K.HasValue && filter.Is4K.Value)
 1487            {
 01488                include4K = true;
 1489            }
 1490
 01491            baseQuery = baseQuery.Where(e =>
 01492                (includeSD && e.Width < HDWidth) ||
 01493                (includeHD && e.Width >= HDWidth && !(e.Width >= UHDWidth || e.Height >= UHDHeight)) ||
 01494                (include4K && (e.Width >= UHDWidth || e.Height >= UHDHeight)));
 1495        }
 1496
 3051497        if (minWidth.HasValue)
 1498        {
 01499            baseQuery = baseQuery.Where(e => e.Width >= minWidth);
 1500        }
 1501
 3051502        if (filter.MinHeight.HasValue)
 1503        {
 01504            baseQuery = baseQuery.Where(e => e.Height >= filter.MinHeight);
 1505        }
 1506
 3051507        if (maxWidth.HasValue)
 1508        {
 01509            baseQuery = baseQuery.Where(e => e.Width <= maxWidth);
 1510        }
 1511
 3051512        if (filter.MaxHeight.HasValue)
 1513        {
 01514            baseQuery = baseQuery.Where(e => e.Height <= filter.MaxHeight);
 1515        }
 1516
 3051517        if (filter.IsLocked.HasValue)
 1518        {
 331519            baseQuery = baseQuery.Where(e => e.IsLocked == filter.IsLocked);
 1520        }
 1521
 3051522        var tags = filter.Tags.ToList();
 3051523        var excludeTags = filter.ExcludeTags.ToList();
 1524
 3051525        if (filter.IsMovie == true)
 1526        {
 01527            if (filter.IncludeItemTypes.Length == 0
 01528                || filter.IncludeItemTypes.Contains(BaseItemKind.Movie)
 01529                || filter.IncludeItemTypes.Contains(BaseItemKind.Trailer))
 1530            {
 01531                baseQuery = baseQuery.Where(e => e.IsMovie);
 1532            }
 1533        }
 3051534        else if (filter.IsMovie.HasValue)
 1535        {
 01536            baseQuery = baseQuery.Where(e => e.IsMovie == filter.IsMovie);
 1537        }
 1538
 3051539        if (filter.IsSeries.HasValue)
 1540        {
 01541            baseQuery = baseQuery.Where(e => e.IsSeries == filter.IsSeries);
 1542        }
 1543
 3051544        if (filter.IsSports.HasValue)
 1545        {
 01546            if (filter.IsSports.Value)
 1547            {
 01548                tags.Add("Sports");
 1549            }
 1550            else
 1551            {
 01552                excludeTags.Add("Sports");
 1553            }
 1554        }
 1555
 3051556        if (filter.IsNews.HasValue)
 1557        {
 01558            if (filter.IsNews.Value)
 1559            {
 01560                tags.Add("News");
 1561            }
 1562            else
 1563            {
 01564                excludeTags.Add("News");
 1565            }
 1566        }
 1567
 3051568        if (filter.IsKids.HasValue)
 1569        {
 01570            if (filter.IsKids.Value)
 1571            {
 01572                tags.Add("Kids");
 1573            }
 1574            else
 1575            {
 01576                excludeTags.Add("Kids");
 1577            }
 1578        }
 1579
 3051580        if (!string.IsNullOrEmpty(filter.SearchTerm))
 1581        {
 01582            var searchTerm = filter.SearchTerm.ToLower();
 01583            baseQuery = baseQuery.Where(e => e.CleanName!.ToLower().Contains(searchTerm) || (e.OriginalTitle != null && 
 1584        }
 1585
 3051586        if (filter.IsFolder.HasValue)
 1587        {
 211588            baseQuery = baseQuery.Where(e => e.IsFolder == filter.IsFolder);
 1589        }
 1590
 3051591        var includeTypes = filter.IncludeItemTypes;
 1592
 1593        // Only specify excluded types if no included types are specified
 3051594        if (filter.IncludeItemTypes.Length == 0)
 1595        {
 2201596            var excludeTypes = filter.ExcludeItemTypes;
 2201597            if (excludeTypes.Length == 1)
 1598            {
 01599                if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeTypes[0], out var excludeTypeName))
 1600                {
 01601                    baseQuery = baseQuery.Where(e => e.Type != excludeTypeName);
 1602                }
 1603            }
 2201604            else if (excludeTypes.Length > 1)
 1605            {
 01606                var excludeTypeName = new List<string>();
 01607                foreach (var excludeType in excludeTypes)
 1608                {
 01609                    if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeType, out var baseItemKindName))
 1610                    {
 01611                        excludeTypeName.Add(baseItemKindName!);
 1612                    }
 1613                }
 1614
 01615                baseQuery = baseQuery.Where(e => !excludeTypeName.Contains(e.Type));
 1616            }
 1617        }
 1618        else
 1619        {
 851620            string[] types = includeTypes.Select(f => _itemTypeLookup.BaseItemKindNames.GetValueOrDefault(f)).Where(e =>
 851621            baseQuery = baseQuery.WhereOneOrMany(types, f => f.Type);
 1622        }
 1623
 3051624        if (filter.ChannelIds.Count > 0)
 1625        {
 01626            baseQuery = baseQuery.Where(e => e.ChannelId != null && filter.ChannelIds.Contains(e.ChannelId.Value));
 1627        }
 1628
 3051629        if (!filter.ParentId.IsEmpty())
 1630        {
 1501631            baseQuery = baseQuery.Where(e => e.ParentId!.Value == filter.ParentId);
 1632        }
 1633
 3051634        if (!string.IsNullOrWhiteSpace(filter.Path))
 1635        {
 01636            baseQuery = baseQuery.Where(e => e.Path == filter.Path);
 1637        }
 1638
 3051639        if (!string.IsNullOrWhiteSpace(filter.PresentationUniqueKey))
 1640        {
 01641            baseQuery = baseQuery.Where(e => e.PresentationUniqueKey == filter.PresentationUniqueKey);
 1642        }
 1643
 3051644        if (filter.MinCommunityRating.HasValue)
 1645        {
 01646            baseQuery = baseQuery.Where(e => e.CommunityRating >= filter.MinCommunityRating);
 1647        }
 1648
 3051649        if (filter.MinIndexNumber.HasValue)
 1650        {
 01651            baseQuery = baseQuery.Where(e => e.IndexNumber >= filter.MinIndexNumber);
 1652        }
 1653
 3051654        if (filter.MinParentAndIndexNumber.HasValue)
 1655        {
 01656            baseQuery = baseQuery
 01657                .Where(e => (e.ParentIndexNumber == filter.MinParentAndIndexNumber.Value.ParentIndexNumber && e.IndexNum
 1658        }
 1659
 3051660        if (filter.MinDateCreated.HasValue)
 1661        {
 01662            baseQuery = baseQuery.Where(e => e.DateCreated >= filter.MinDateCreated);
 1663        }
 1664
 3051665        if (filter.MinDateLastSaved.HasValue)
 1666        {
 01667            baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSaved.Value
 1668        }
 1669
 3051670        if (filter.MinDateLastSavedForUser.HasValue)
 1671        {
 01672            baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSavedForUse
 1673        }
 1674
 3051675        if (filter.IndexNumber.HasValue)
 1676        {
 01677            baseQuery = baseQuery.Where(e => e.IndexNumber == filter.IndexNumber.Value);
 1678        }
 1679
 3051680        if (filter.ParentIndexNumber.HasValue)
 1681        {
 01682            baseQuery = baseQuery.Where(e => e.ParentIndexNumber == filter.ParentIndexNumber.Value);
 1683        }
 1684
 3051685        if (filter.ParentIndexNumberNotEquals.HasValue)
 1686        {
 01687            baseQuery = baseQuery.Where(e => e.ParentIndexNumber != filter.ParentIndexNumberNotEquals.Value || e.ParentI
 1688        }
 1689
 3051690        var minEndDate = filter.MinEndDate;
 3051691        var maxEndDate = filter.MaxEndDate;
 1692
 3051693        if (filter.HasAired.HasValue)
 1694        {
 01695            if (filter.HasAired.Value)
 1696            {
 01697                maxEndDate = DateTime.UtcNow;
 1698            }
 1699            else
 1700            {
 01701                minEndDate = DateTime.UtcNow;
 1702            }
 1703        }
 1704
 3051705        if (minEndDate.HasValue)
 1706        {
 01707            baseQuery = baseQuery.Where(e => e.EndDate >= minEndDate);
 1708        }
 1709
 3051710        if (maxEndDate.HasValue)
 1711        {
 01712            baseQuery = baseQuery.Where(e => e.EndDate <= maxEndDate);
 1713        }
 1714
 3051715        if (filter.MinStartDate.HasValue)
 1716        {
 01717            baseQuery = baseQuery.Where(e => e.StartDate >= filter.MinStartDate.Value);
 1718        }
 1719
 3051720        if (filter.MaxStartDate.HasValue)
 1721        {
 01722            baseQuery = baseQuery.Where(e => e.StartDate <= filter.MaxStartDate.Value);
 1723        }
 1724
 3051725        if (filter.MinPremiereDate.HasValue)
 1726        {
 01727            baseQuery = baseQuery.Where(e => e.PremiereDate >= filter.MinPremiereDate.Value);
 1728        }
 1729
 3051730        if (filter.MaxPremiereDate.HasValue)
 1731        {
 01732            baseQuery = baseQuery.Where(e => e.PremiereDate <= filter.MaxPremiereDate.Value);
 1733        }
 1734
 3051735        if (filter.TrailerTypes.Length > 0)
 1736        {
 01737            var trailerTypes = filter.TrailerTypes.Select(e => (int)e).ToArray();
 01738            baseQuery = baseQuery.Where(e => trailerTypes.Any(f => e.TrailerTypes!.Any(w => w.Id == f)));
 1739        }
 1740
 3051741        if (filter.IsAiring.HasValue)
 1742        {
 01743            if (filter.IsAiring.Value)
 1744            {
 01745                baseQuery = baseQuery.Where(e => e.StartDate <= now && e.EndDate >= now);
 1746            }
 1747            else
 1748            {
 01749                baseQuery = baseQuery.Where(e => e.StartDate > now && e.EndDate < now);
 1750            }
 1751        }
 1752
 3051753        if (filter.PersonIds.Length > 0)
 1754        {
 01755            baseQuery = baseQuery
 01756                .Where(e =>
 01757                    context.PeopleBaseItemMap.Where(w => context.BaseItems.Where(r => filter.PersonIds.Contains(r.Id)).A
 01758                        .Any(f => f.ItemId == e.Id));
 1759        }
 1760
 3051761        if (!string.IsNullOrWhiteSpace(filter.Person))
 1762        {
 01763            baseQuery = baseQuery.Where(e => e.Peoples!.Any(f => f.People.Name == filter.Person));
 1764        }
 1765
 3051766        if (!string.IsNullOrWhiteSpace(filter.MinSortName))
 1767        {
 1768            // this does not makes sense.
 1769            // baseQuery = baseQuery.Where(e => e.SortName >= query.MinSortName);
 1770            // whereClauses.Add("SortName>=@MinSortName");
 1771            // statement?.TryBind("@MinSortName", query.MinSortName);
 1772        }
 1773
 3051774        if (!string.IsNullOrWhiteSpace(filter.ExternalSeriesId))
 1775        {
 01776            baseQuery = baseQuery.Where(e => e.ExternalSeriesId == filter.ExternalSeriesId);
 1777        }
 1778
 3051779        if (!string.IsNullOrWhiteSpace(filter.ExternalId))
 1780        {
 01781            baseQuery = baseQuery.Where(e => e.ExternalId == filter.ExternalId);
 1782        }
 1783
 3051784        if (!string.IsNullOrWhiteSpace(filter.Name))
 1785        {
 31786            var cleanName = GetCleanValue(filter.Name);
 31787            baseQuery = baseQuery.Where(e => e.CleanName == cleanName);
 1788        }
 1789
 1790        // These are the same, for now
 3051791        var nameContains = filter.NameContains;
 3051792        if (!string.IsNullOrWhiteSpace(nameContains))
 1793        {
 01794            baseQuery = baseQuery.Where(e =>
 01795                e.CleanName!.Contains(nameContains)
 01796                || e.OriginalTitle!.ToLower().Contains(nameContains!));
 1797        }
 1798
 3051799        if (!string.IsNullOrWhiteSpace(filter.NameStartsWith))
 1800        {
 01801            baseQuery = baseQuery.Where(e => e.SortName!.StartsWith(filter.NameStartsWith) || e.Name!.StartsWith(filter.
 1802        }
 1803
 3051804        if (!string.IsNullOrWhiteSpace(filter.NameStartsWithOrGreater))
 1805        {
 1806            // i hate this
 01807            baseQuery = baseQuery.Where(e => e.SortName!.FirstOrDefault() > filter.NameStartsWithOrGreater[0] || e.Name!
 1808        }
 1809
 3051810        if (!string.IsNullOrWhiteSpace(filter.NameLessThan))
 1811        {
 1812            // i hate this
 01813            baseQuery = baseQuery.Where(e => e.SortName!.FirstOrDefault() < filter.NameLessThan[0] || e.Name!.FirstOrDef
 1814        }
 1815
 3051816        if (filter.ImageTypes.Length > 0)
 1817        {
 851818            var imgTypes = filter.ImageTypes.Select(e => (ImageInfoImageType)e).ToArray();
 851819            baseQuery = baseQuery.Where(e => imgTypes.Any(f => e.Images!.Any(w => w.ImageType == f)));
 1820        }
 1821
 3051822        if (filter.IsLiked.HasValue)
 1823        {
 01824            baseQuery = baseQuery
 01825                .Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.Rating >= UserItemData.MinLike
 1826        }
 1827
 3051828        if (filter.IsFavoriteOrLiked.HasValue)
 1829        {
 01830            baseQuery = baseQuery
 01831                .Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.IsFavorite == filter.IsFavorit
 1832        }
 1833
 3051834        if (filter.IsFavorite.HasValue)
 1835        {
 01836            baseQuery = baseQuery
 01837                .Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.IsFavorite == filter.IsFavorit
 1838        }
 1839
 3051840        if (filter.IsPlayed.HasValue)
 1841        {
 1842            // We should probably figure this out for all folders, but for right now, this is the only place where we ne
 01843            if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.Series)
 1844            {
 01845                baseQuery = baseQuery.Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId))
 01846                    .Where(e => e.IsFolder == false && e.IsVirtualItem == false)
 01847                    .Where(f => f.UserData!.FirstOrDefault(e => e.UserId == filter.User!.Id && e.Played)!.Played)
 01848                    .Any(f => f.SeriesPresentationUniqueKey == e.PresentationUniqueKey) == filter.IsPlayed);
 1849            }
 1850            else
 1851            {
 01852                baseQuery = baseQuery
 01853                    .Select(e => new
 01854                    {
 01855                        IsPlayed = e.UserData!.Where(f => f.UserId == filter.User!.Id).Select(f => (bool?)f.Played).Firs
 01856                        Item = e
 01857                    })
 01858                    .Where(e => e.IsPlayed == filter.IsPlayed)
 01859                    .Select(f => f.Item);
 1860            }
 1861        }
 1862
 3051863        if (filter.IsResumable.HasValue)
 1864        {
 11865            if (filter.IsResumable.Value)
 1866            {
 11867                baseQuery = baseQuery
 11868                       .Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.PlaybackPositionTicks >
 1869            }
 1870            else
 1871            {
 01872                baseQuery = baseQuery
 01873                       .Where(e => e.UserData!.FirstOrDefault(f => f.UserId == filter.User!.Id)!.PlaybackPositionTicks =
 1874            }
 1875        }
 1876
 3051877        if (filter.ArtistIds.Length > 0)
 1878        {
 01879            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Artist, filter.ArtistIds);
 1880        }
 1881
 3051882        if (filter.AlbumArtistIds.Length > 0)
 1883        {
 01884            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Artist, filter.AlbumArtistIds);
 1885        }
 1886
 3051887        if (filter.ContributingArtistIds.Length > 0)
 1888        {
 01889            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Artist, filter.ContributingArtistIds);
 1890        }
 1891
 3051892        if (filter.AlbumIds.Length > 0)
 1893        {
 01894            var subQuery = context.BaseItems.WhereOneOrMany(filter.AlbumIds, f => f.Id);
 01895            baseQuery = baseQuery.Where(e => subQuery.Any(f => f.Name == e.Album));
 1896        }
 1897
 3051898        if (filter.ExcludeArtistIds.Length > 0)
 1899        {
 01900            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Artist, filter.ExcludeArtistIds, true);
 1901        }
 1902
 3051903        if (filter.GenreIds.Count > 0)
 1904        {
 01905            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Genre, filter.GenreIds.ToArray());
 1906        }
 1907
 3051908        if (filter.Genres.Count > 0)
 1909        {
 01910            var cleanGenres = filter.Genres.Select(e => GetCleanValue(e)).ToArray().OneOrManyExpressionBuilder<ItemValue
 01911            baseQuery = baseQuery
 01912                    .Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Genre).Any(clea
 1913        }
 1914
 3051915        if (tags.Count > 0)
 1916        {
 01917            var cleanValues = tags.Select(e => GetCleanValue(e)).ToArray().OneOrManyExpressionBuilder<ItemValueMap, stri
 01918            baseQuery = baseQuery
 01919                    .Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clean
 1920        }
 1921
 3051922        if (excludeTags.Count > 0)
 1923        {
 01924            var cleanValues = excludeTags.Select(e => GetCleanValue(e)).ToArray().OneOrManyExpressionBuilder<ItemValueMa
 01925            baseQuery = baseQuery
 01926                    .Where(e => !e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(clea
 1927        }
 1928
 3051929        if (filter.StudioIds.Length > 0)
 1930        {
 01931            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Studios, filter.StudioIds.ToArray());
 1932        }
 1933
 3051934        if (filter.OfficialRatings.Length > 0)
 1935        {
 01936            baseQuery = baseQuery
 01937                   .Where(e => filter.OfficialRatings.Contains(e.OfficialRating));
 1938        }
 1939
 3051940        Expression<Func<BaseItemEntity, bool>>? minParentalRatingFilter = null;
 3051941        if (filter.MinParentalRating != null)
 1942        {
 01943            var min = filter.MinParentalRating;
 01944            minParentalRatingFilter = e => e.InheritedParentalRatingValue >= min.Score || e.InheritedParentalRatingValue
 01945            if (min.SubScore != null)
 1946            {
 01947                minParentalRatingFilter = minParentalRatingFilter.And(e => e.InheritedParentalRatingValue >= min.SubScor
 1948            }
 1949        }
 1950
 3051951        Expression<Func<BaseItemEntity, bool>>? maxParentalRatingFilter = null;
 3051952        if (filter.MaxParentalRating != null)
 1953        {
 331954            var max = filter.MaxParentalRating;
 331955            maxParentalRatingFilter = e => e.InheritedParentalRatingValue <= max.Score || e.InheritedParentalRatingValue
 331956            if (max.SubScore != null)
 1957            {
 01958                maxParentalRatingFilter = maxParentalRatingFilter.And(e => e.InheritedParentalRatingValue <= max.SubScor
 1959            }
 1960        }
 1961
 3051962        if (filter.HasParentalRating ?? false)
 1963        {
 01964            if (minParentalRatingFilter != null)
 1965            {
 01966                baseQuery = baseQuery.Where(minParentalRatingFilter);
 1967            }
 1968
 01969            if (maxParentalRatingFilter != null)
 1970            {
 01971                baseQuery = baseQuery.Where(maxParentalRatingFilter);
 1972            }
 1973        }
 3051974        else if (filter.BlockUnratedItems.Length > 0)
 1975        {
 01976            var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();
 01977            Expression<Func<BaseItemEntity, bool>> unratedItemFilter = e => e.InheritedParentalRatingValue != null || !u
 1978
 01979            if (minParentalRatingFilter != null && maxParentalRatingFilter != null)
 1980            {
 01981                baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter.And(maxParentalRatingFilter)))
 1982            }
 01983            else if (minParentalRatingFilter != null)
 1984            {
 01985                baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter));
 1986            }
 01987            else if (maxParentalRatingFilter != null)
 1988            {
 01989                baseQuery = baseQuery.Where(unratedItemFilter.And(maxParentalRatingFilter));
 1990            }
 1991            else
 1992            {
 01993                baseQuery = baseQuery.Where(unratedItemFilter);
 1994            }
 1995        }
 3051996        else if (minParentalRatingFilter != null || maxParentalRatingFilter != null)
 1997        {
 331998            if (minParentalRatingFilter != null)
 1999            {
 02000                baseQuery = baseQuery.Where(minParentalRatingFilter);
 2001            }
 2002
 332003            if (maxParentalRatingFilter != null)
 2004            {
 332005                baseQuery = baseQuery.Where(maxParentalRatingFilter);
 2006            }
 2007        }
 2722008        else if (!filter.HasParentalRating ?? false)
 2009        {
 02010            baseQuery = baseQuery
 02011                .Where(e => e.InheritedParentalRatingValue == null);
 2012        }
 2013
 3052014        if (filter.HasOfficialRating.HasValue)
 2015        {
 02016            if (filter.HasOfficialRating.Value)
 2017            {
 02018                baseQuery = baseQuery
 02019                    .Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty);
 2020            }
 2021            else
 2022            {
 02023                baseQuery = baseQuery
 02024                    .Where(e => e.OfficialRating == null || e.OfficialRating == string.Empty);
 2025            }
 2026        }
 2027
 3052028        if (filter.HasOverview.HasValue)
 2029        {
 02030            if (filter.HasOverview.Value)
 2031            {
 02032                baseQuery = baseQuery
 02033                    .Where(e => e.Overview != null && e.Overview != string.Empty);
 2034            }
 2035            else
 2036            {
 02037                baseQuery = baseQuery
 02038                    .Where(e => e.Overview == null || e.Overview == string.Empty);
 2039            }
 2040        }
 2041
 3052042        if (filter.HasOwnerId.HasValue)
 2043        {
 02044            if (filter.HasOwnerId.Value)
 2045            {
 02046                baseQuery = baseQuery
 02047                    .Where(e => e.OwnerId != null);
 2048            }
 2049            else
 2050            {
 02051                baseQuery = baseQuery
 02052                    .Where(e => e.OwnerId == null);
 2053            }
 2054        }
 2055
 3052056        if (!string.IsNullOrWhiteSpace(filter.HasNoAudioTrackWithLanguage))
 2057        {
 02058            baseQuery = baseQuery
 02059                .Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Audio && f.Language == filte
 2060        }
 2061
 3052062        if (!string.IsNullOrWhiteSpace(filter.HasNoInternalSubtitleTrackWithLanguage))
 2063        {
 02064            baseQuery = baseQuery
 02065                .Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle && !f.IsExternal &&
 2066        }
 2067
 3052068        if (!string.IsNullOrWhiteSpace(filter.HasNoExternalSubtitleTrackWithLanguage))
 2069        {
 02070            baseQuery = baseQuery
 02071                .Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle && f.IsExternal && 
 2072        }
 2073
 3052074        if (!string.IsNullOrWhiteSpace(filter.HasNoSubtitleTrackWithLanguage))
 2075        {
 02076            baseQuery = baseQuery
 02077                .Where(e => !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle && f.Language == fi
 2078        }
 2079
 3052080        if (filter.HasSubtitles.HasValue)
 2081        {
 02082            baseQuery = baseQuery
 02083                .Where(e => e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle) == filter.HasSubtit
 2084        }
 2085
 3052086        if (filter.HasChapterImages.HasValue)
 2087        {
 02088            baseQuery = baseQuery
 02089                .Where(e => e.Chapters!.Any(f => f.ImagePath != null) == filter.HasChapterImages.Value);
 2090        }
 2091
 3052092        if (filter.HasDeadParentId.HasValue && filter.HasDeadParentId.Value)
 2093        {
 112094            baseQuery = baseQuery
 112095                .Where(e => e.ParentId.HasValue && !context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Any
 2096        }
 2097
 3052098        if (filter.IsDeadArtist.HasValue && filter.IsDeadArtist.Value)
 2099        {
 112100            baseQuery = baseQuery
 112101                    .Where(e => !context.ItemValues.Where(f => _getAllArtistsValueTypes.Contains(f.Type)).Any(f => f.Val
 2102        }
 2103
 3052104        if (filter.IsDeadStudio.HasValue && filter.IsDeadStudio.Value)
 2105        {
 112106            baseQuery = baseQuery
 112107                    .Where(e => !context.ItemValues.Where(f => _getStudiosValueTypes.Contains(f.Type)).Any(f => f.Value 
 2108        }
 2109
 3052110        if (filter.IsDeadGenre.HasValue && filter.IsDeadGenre.Value)
 2111        {
 112112            baseQuery = baseQuery
 112113                    .Where(e => !context.ItemValues.Where(f => _getGenreValueTypes.Contains(f.Type)).Any(f => f.Value ==
 2114        }
 2115
 3052116        if (filter.IsDeadPerson.HasValue && filter.IsDeadPerson.Value)
 2117        {
 02118            baseQuery = baseQuery
 02119                .Where(e => !context.Peoples.Any(f => f.Name == e.Name));
 2120        }
 2121
 3052122        if (filter.Years.Length > 0)
 2123        {
 02124            baseQuery = baseQuery.WhereOneOrMany(filter.Years, e => e.ProductionYear!.Value);
 2125        }
 2126
 3052127        var isVirtualItem = filter.IsVirtualItem ?? filter.IsMissing;
 3052128        if (isVirtualItem.HasValue)
 2129        {
 222130            baseQuery = baseQuery
 222131                .Where(e => e.IsVirtualItem == isVirtualItem.Value);
 2132        }
 2133
 3052134        if (filter.IsSpecialSeason.HasValue)
 2135        {
 02136            if (filter.IsSpecialSeason.Value)
 2137            {
 02138                baseQuery = baseQuery
 02139                    .Where(e => e.IndexNumber == 0);
 2140            }
 2141            else
 2142            {
 02143                baseQuery = baseQuery
 02144                    .Where(e => e.IndexNumber != 0);
 2145            }
 2146        }
 2147
 3052148        if (filter.IsUnaired.HasValue)
 2149        {
 02150            if (filter.IsUnaired.Value)
 2151            {
 02152                baseQuery = baseQuery
 02153                    .Where(e => e.PremiereDate >= now);
 2154            }
 2155            else
 2156            {
 02157                baseQuery = baseQuery
 02158                    .Where(e => e.PremiereDate < now);
 2159            }
 2160        }
 2161
 3052162        if (filter.MediaTypes.Length > 0)
 2163        {
 212164            var mediaTypes = filter.MediaTypes.Select(f => f.ToString()).ToArray();
 212165            baseQuery = baseQuery.WhereOneOrMany(mediaTypes, e => e.MediaType);
 2166        }
 2167
 3052168        if (filter.ItemIds.Length > 0)
 2169        {
 02170            baseQuery = baseQuery.WhereOneOrMany(filter.ItemIds, e => e.Id);
 2171        }
 2172
 3052173        if (filter.ExcludeItemIds.Length > 0)
 2174        {
 02175            baseQuery = baseQuery
 02176                .Where(e => !filter.ExcludeItemIds.Contains(e.Id));
 2177        }
 2178
 3052179        if (filter.ExcludeProviderIds is not null && filter.ExcludeProviderIds.Count > 0)
 2180        {
 02181            var exclude = filter.ExcludeProviderIds.Select(e => $"{e.Key}:{e.Value}").ToArray();
 02182            baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.All(f => !ex
 2183        }
 2184
 3052185        if (filter.HasAnyProviderId is not null && filter.HasAnyProviderId.Count > 0)
 2186        {
 02187            var include = filter.HasAnyProviderId.Select(e => $"{e.Key}:{e.Value}").ToArray();
 02188            baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.Any(f => inc
 2189        }
 2190
 3052191        if (filter.HasImdbId.HasValue)
 2192        {
 02193            baseQuery = baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId == "imdb"));
 2194        }
 2195
 3052196        if (filter.HasTmdbId.HasValue)
 2197        {
 02198            baseQuery = baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId == "tmdb"));
 2199        }
 2200
 3052201        if (filter.HasTvdbId.HasValue)
 2202        {
 02203            baseQuery = baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId == "tvdb"));
 2204        }
 2205
 3052206        var queryTopParentIds = filter.TopParentIds;
 2207
 3052208        if (queryTopParentIds.Length > 0)
 2209        {
 162210            var includedItemByNameTypes = GetItemByNameTypesInQuery(filter);
 162211            var enableItemsByName = (filter.IncludeItemsByName ?? false) && includedItemByNameTypes.Count > 0;
 162212            if (enableItemsByName && includedItemByNameTypes.Count > 0)
 2213            {
 02214                baseQuery = baseQuery.Where(e => includedItemByNameTypes.Contains(e.Type) || queryTopParentIds.Any(w => 
 2215            }
 2216            else
 2217            {
 162218                baseQuery = baseQuery.WhereOneOrMany(queryTopParentIds, e => e.TopParentId!.Value);
 2219            }
 2220        }
 2221
 3052222        if (filter.AncestorIds.Length > 0)
 2223        {
 382224            baseQuery = baseQuery.Where(e => e.Parents!.Any(f => filter.AncestorIds.Contains(f.ParentItemId)));
 2225        }
 2226
 3052227        if (!string.IsNullOrWhiteSpace(filter.AncestorWithPresentationUniqueKey))
 2228        {
 02229            baseQuery = baseQuery
 02230                .Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Where(f => f.PresentationUn
 2231        }
 2232
 3052233        if (!string.IsNullOrWhiteSpace(filter.SeriesPresentationUniqueKey))
 2234        {
 02235            baseQuery = baseQuery
 02236                .Where(e => e.SeriesPresentationUniqueKey == filter.SeriesPresentationUniqueKey);
 2237        }
 2238
 3052239        if (filter.ExcludeInheritedTags.Length > 0)
 2240        {
 02241            baseQuery = baseQuery
 02242                .Where(e => !e.ItemValues!.Where(w => w.ItemValue.Type == ItemValueType.InheritedTags)
 02243                    .Any(f => filter.ExcludeInheritedTags.Contains(f.ItemValue.CleanValue)));
 2244        }
 2245
 3052246        if (filter.IncludeInheritedTags.Length > 0)
 2247        {
 2248            // Episodes do not store inherit tags from their parents in the database, and the tag may be still required 
 2249            // In addition to the tags for the episodes themselves, we need to manually query its parent (the season)'s 
 02250            if (includeTypes.Length == 1 && includeTypes.FirstOrDefault() is BaseItemKind.Episode)
 2251            {
 02252                baseQuery = baseQuery
 02253                    .Where(e => e.ItemValues!.Where(f => f.ItemValue.Type == ItemValueType.InheritedTags)
 02254                        .Any(f => filter.IncludeInheritedTags.Contains(f.ItemValue.CleanValue))
 02255                        ||
 02256                        (e.ParentId.HasValue && context.ItemValuesMap.Where(w => w.ItemId == e.ParentId.Value)!.Where(w 
 02257                        .Any(f => filter.IncludeInheritedTags.Contains(f.ItemValue.CleanValue))));
 2258            }
 2259
 2260            // A playlist should be accessible to its owner regardless of allowed tags.
 02261            else if (includeTypes.Length == 1 && includeTypes.FirstOrDefault() is BaseItemKind.Playlist)
 2262            {
 02263                baseQuery = baseQuery
 02264                    .Where(e =>
 02265                    e.Parents!
 02266                        .Any(f =>
 02267                            f.ParentItem.ItemValues!.Any(w => w.ItemValue.Type == ItemValueType.Tags && filter.IncludeIn
 02268                            || e.Data!.Contains($"OwnerUserId\":\"{filter.User!.Id:N}\"")));
 2269                // d        ^^ this is stupid it hate this.
 2270            }
 2271            else
 2272            {
 02273                baseQuery = baseQuery
 02274                    .Where(e => e.Parents!.Any(f => f.ParentItem.ItemValues!.Any(w => w.ItemValue.Type == ItemValueType.
 2275            }
 2276        }
 2277
 3052278        if (filter.SeriesStatuses.Length > 0)
 2279        {
 02280            var seriesStatus = filter.SeriesStatuses.Select(e => e.ToString()).ToArray();
 02281            baseQuery = baseQuery
 02282                .Where(e => seriesStatus.Any(f => e.Data!.Contains(f)));
 2283        }
 2284
 3052285        if (filter.BoxSetLibraryFolders.Length > 0)
 2286        {
 02287            var boxsetFolders = filter.BoxSetLibraryFolders.Select(e => e.ToString("N", CultureInfo.InvariantCulture)).T
 02288            baseQuery = baseQuery
 02289                .Where(e => boxsetFolders.Any(f => e.Data!.Contains(f)));
 2290        }
 2291
 3052292        if (filter.VideoTypes.Length > 0)
 2293        {
 02294            var videoTypeBs = filter.VideoTypes.Select(e => $"\"VideoType\":\"{e}\"");
 02295            baseQuery = baseQuery
 02296                .Where(e => videoTypeBs.Any(f => e.Data!.Contains(f)));
 2297        }
 2298
 3052299        if (filter.Is3D.HasValue)
 2300        {
 02301            if (filter.Is3D.Value)
 2302            {
 02303                baseQuery = baseQuery
 02304                    .Where(e => e.Data!.Contains("Video3DFormat"));
 2305            }
 2306            else
 2307            {
 02308                baseQuery = baseQuery
 02309                    .Where(e => !e.Data!.Contains("Video3DFormat"));
 2310            }
 2311        }
 2312
 3052313        if (filter.IsPlaceHolder.HasValue)
 2314        {
 02315            if (filter.IsPlaceHolder.Value)
 2316            {
 02317                baseQuery = baseQuery
 02318                    .Where(e => e.Data!.Contains("IsPlaceHolder\":true"));
 2319            }
 2320            else
 2321            {
 02322                baseQuery = baseQuery
 02323                    .Where(e => !e.Data!.Contains("IsPlaceHolder\":true"));
 2324            }
 2325        }
 2326
 3052327        if (filter.HasSpecialFeature.HasValue)
 2328        {
 02329            if (filter.HasSpecialFeature.Value)
 2330            {
 02331                baseQuery = baseQuery
 02332                    .Where(e => e.ExtraIds != null);
 2333            }
 2334            else
 2335            {
 02336                baseQuery = baseQuery
 02337                    .Where(e => e.ExtraIds == null);
 2338            }
 2339        }
 2340
 3052341        if (filter.HasTrailer.HasValue || filter.HasThemeSong.HasValue || filter.HasThemeVideo.HasValue)
 2342        {
 02343            if (filter.HasTrailer.GetValueOrDefault() || filter.HasThemeSong.GetValueOrDefault() || filter.HasThemeVideo
 2344            {
 02345                baseQuery = baseQuery
 02346                    .Where(e => e.ExtraIds != null);
 2347            }
 2348            else
 2349            {
 02350                baseQuery = baseQuery
 02351                    .Where(e => e.ExtraIds == null);
 2352            }
 2353        }
 2354
 3052355        return baseQuery;
 2356    }
 2357
 2358    /// <inheritdoc/>
 2359    public async Task<bool> ItemExistsAsync(Guid id)
 2360    {
 2361        var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
 2362        await using (dbContext.ConfigureAwait(false))
 2363        {
 2364            return await dbContext.BaseItems.AnyAsync(f => f.Id == id).ConfigureAwait(false);
 2365        }
 2366    }
 2367}
Generated by: ReportGenerator 5.4.7.0
7/8/2025 - 12:12:28 AM
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(Microsoft.EntityFrameworkCore.IDbContextFactory`1<Jellyfin.Database.Implementations.JellyfinDbContext>,MediaBrowser.Controller.IServerApplicationHost,MediaBrowser.Controller.Persistence.IItemTypeLookup,MediaBrowser.Controller.Configuration.IServerConfigurationManager,Microsoft.Extensions.Logging.ILogger`1<Jellyfin.Server.Implementations.Item.BaseItemRepository>)
DeleteItem(System.Guid)
UpdateInheritedValues()
GetItemIdsList(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetAllArtists(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetArtists(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetAlbumArtists(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetStudios(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetGenres(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetMusicGenres(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetStudioNames()
GetAllArtistNames()
GetMusicGenreNames()
GetGenreNames()
GetItems(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetItemList(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetLatestItemList(MediaBrowser.Controller.Entities.InternalItemsQuery,Jellyfin.Data.Enums.CollectionType)
GetNextUpSeriesKeys(MediaBrowser.Controller.Entities.InternalItemsQuery,System.DateTime)
ApplyGroupingFilter(System.Linq.IQueryable`1<Jellyfin.Database.Implementations.Entities.BaseItemEntity>,MediaBrowser.Controller.Entities.InternalItemsQuery)
ApplyQueryPaging(System.Linq.IQueryable`1<Jellyfin.Database.Implementations.Entities.BaseItemEntity>,MediaBrowser.Controller.Entities.InternalItemsQuery)
ApplyQueryFilter(System.Linq.IQueryable`1<Jellyfin.Database.Implementations.Entities.BaseItemEntity>,Jellyfin.Database.Implementations.JellyfinDbContext,MediaBrowser.Controller.Entities.InternalItemsQuery)
PrepareItemQuery(Jellyfin.Database.Implementations.JellyfinDbContext,MediaBrowser.Controller.Entities.InternalItemsQuery)
GetCount(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetType(System.String)
SaveImages(MediaBrowser.Controller.Entities.BaseItem)
SaveItems(System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,System.Threading.CancellationToken)
UpdateOrInsertItems(System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,System.Threading.CancellationToken)
RetrieveItem(System.Guid)
Map(Jellyfin.Database.Implementations.Entities.BaseItemEntity,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.IServerApplicationHost)
Map(MediaBrowser.Controller.Entities.BaseItem)
GetItemValueNames(System.Collections.Generic.IReadOnlyList`1<Jellyfin.Database.Implementations.Entities.ItemValueType>,System.Collections.Generic.IReadOnlyList`1<System.String>,System.Collections.Generic.IReadOnlyList`1<System.String>)
TypeRequiresDeserialization(System.Type)
DeserializeBaseItem(Jellyfin.Database.Implementations.Entities.BaseItemEntity,System.Boolean)
DeserializeBaseItem(Jellyfin.Database.Implementations.Entities.BaseItemEntity,Microsoft.Extensions.Logging.ILogger,MediaBrowser.Controller.IServerApplicationHost,System.Boolean)
GetItemValues(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Collections.Generic.IReadOnlyList`1<Jellyfin.Database.Implementations.Entities.ItemValueType>,System.String)
PrepareFilterQuery(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetCleanValue(System.String)
GetItemValuesToSave(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.List`1<System.String>)
Map(System.Guid,MediaBrowser.Controller.Entities.ItemImageInfo)
Map(Jellyfin.Database.Implementations.Entities.BaseItemImageInfo,MediaBrowser.Controller.IServerApplicationHost)
GetPathToSave(System.String)
GetItemByNameTypesInQuery(MediaBrowser.Controller.Entities.InternalItemsQuery)
IsTypeInQuery(Jellyfin.Data.Enums.BaseItemKind,MediaBrowser.Controller.Entities.InternalItemsQuery)
EnableGroupByPresentationUniqueKey(MediaBrowser.Controller.Entities.InternalItemsQuery)
ApplyOrder(System.Linq.IQueryable`1<Jellyfin.Database.Implementations.Entities.BaseItemEntity>,MediaBrowser.Controller.Entities.InternalItemsQuery)
TranslateQuery(System.Linq.IQueryable`1<Jellyfin.Database.Implementations.Entities.BaseItemEntity>,Jellyfin.Database.Implementations.JellyfinDbContext,MediaBrowser.Controller.Entities.InternalItemsQuery)