< Summary - Jellyfin

Information
Class: Jellyfin.Server.Implementations.Item.ItemCountService
Assembly: Jellyfin.Server.Implementations
File(s): /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/ItemCountService.cs
Line coverage
1%
Covered lines: 4
Uncovered lines: 231
Coverable lines: 235
Total lines: 427
Line coverage: 1.7%
Branch coverage
0%
Covered branches: 0
Total branches: 75
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 5/4/2026 - 12:15:16 AM Line coverage: 1.7% (4/235) Branch coverage: 0% (0/75) Total lines: 427 5/4/2026 - 12:15:16 AM Line coverage: 1.7% (4/235) Branch coverage: 0% (0/75) Total lines: 427

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
GetCount(...)100%210%
GetItemCounts(...)0%600240%
GetItemCountsForNameItem(...)0%1722410%
GetPlayedCount(...)100%210%
GetTotalCount(...)100%210%
GetPlayedAndTotalCount(...)100%210%
GetPlayedAndTotalCountFromLinkedChildren(...)100%210%
GetChildCountBatch(...)0%4260%
GetPlayedAndTotalCountBatch(...)0%620%
GetPlayedAndTotalCountFromQuery(...)0%620%

File(s)

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

#LineLine coverage
 1#pragma warning disable RS0030 // Do not use banned APIs
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Globalization;
 6using System.Linq;
 7using Jellyfin.Data.Enums;
 8using Jellyfin.Database.Implementations;
 9using Jellyfin.Database.Implementations.Entities;
 10using Jellyfin.Extensions;
 11using MediaBrowser.Controller.Entities;
 12using MediaBrowser.Controller.Persistence;
 13using MediaBrowser.Model.Dto;
 14using Microsoft.EntityFrameworkCore;
 15
 16namespace Jellyfin.Server.Implementations.Item;
 17
 18/// <summary>
 19/// Provides item counting and played-status query operations.
 20/// </summary>
 21public class ItemCountService : IItemCountService
 22{
 23    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
 24    private readonly IItemTypeLookup _itemTypeLookup;
 25    private readonly IItemQueryHelpers _queryHelpers;
 26
 27    /// <summary>
 28    /// Initializes a new instance of the <see cref="ItemCountService"/> class.
 29    /// </summary>
 30    /// <param name="dbProvider">The database context factory.</param>
 31    /// <param name="itemTypeLookup">The item type lookup.</param>
 32    /// <param name="queryHelpers">The shared query helpers.</param>
 33    public ItemCountService(
 34        IDbContextFactory<JellyfinDbContext> dbProvider,
 35        IItemTypeLookup itemTypeLookup,
 36        IItemQueryHelpers queryHelpers)
 37    {
 2138        _dbProvider = dbProvider;
 2139        _itemTypeLookup = itemTypeLookup;
 2140        _queryHelpers = queryHelpers;
 2141    }
 42
 43    /// <inheritdoc/>
 44    public int GetCount(InternalItemsQuery filter)
 45    {
 046        ArgumentNullException.ThrowIfNull(filter);
 047        _queryHelpers.PrepareFilterQuery(filter);
 48
 049        using var context = _dbProvider.CreateDbContext();
 050        var dbQuery = _queryHelpers.TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);
 51
 052        return dbQuery.Count();
 053    }
 54
 55    /// <inheritdoc />
 56    public ItemCounts GetItemCounts(InternalItemsQuery filter)
 57    {
 058        ArgumentNullException.ThrowIfNull(filter);
 059        _queryHelpers.PrepareFilterQuery(filter);
 60
 061        using var context = _dbProvider.CreateDbContext();
 062        var dbQuery = _queryHelpers.TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);
 63
 064        var counts = dbQuery
 065            .GroupBy(x => x.Type)
 066            .Select(x => new { x.Key, Count = x.Count() })
 067            .ToArray();
 68
 069        var lookup = _itemTypeLookup.BaseItemKindNames;
 070        var result = new ItemCounts
 071        {
 072            ItemCount = counts.Sum(c => c.Count)
 073        };
 074        foreach (var count in counts)
 75        {
 076            if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))
 77            {
 078                result.AlbumCount = count.Count;
 79            }
 080            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))
 81            {
 082                result.ArtistCount = count.Count;
 83            }
 084            else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))
 85            {
 086                result.EpisodeCount = count.Count;
 87            }
 088            else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))
 89            {
 090                result.MovieCount = count.Count;
 91            }
 092            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))
 93            {
 094                result.MusicVideoCount = count.Count;
 95            }
 096            else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))
 97            {
 098                result.ProgramCount = count.Count;
 99            }
 0100            else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))
 101            {
 0102                result.SeriesCount = count.Count;
 103            }
 0104            else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))
 105            {
 0106                result.SongCount = count.Count;
 107            }
 0108            else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))
 109            {
 0110                result.TrailerCount = count.Count;
 111            }
 0112            else if (string.Equals(count.Key, lookup[BaseItemKind.BoxSet], StringComparison.Ordinal))
 113            {
 0114                result.BoxSetCount = count.Count;
 115            }
 0116            else if (string.Equals(count.Key, lookup[BaseItemKind.Book], StringComparison.Ordinal))
 117            {
 0118                result.BookCount = count.Count;
 119            }
 120        }
 121
 0122        return result;
 0123    }
 124
 125    /// <inheritdoc />
 126    public ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, InternalItem
 127    {
 0128        using var context = _dbProvider.CreateDbContext();
 129
 0130        var item = context.BaseItems.AsNoTracking()
 0131            .Where(e => e.Id == id)
 0132            .Select(e => new { e.Name, e.CleanName })
 0133            .FirstOrDefault();
 134
 0135        if (item is null)
 136        {
 0137            return new ItemCounts();
 138        }
 139
 140        IQueryable<BaseItemEntity> baseQuery;
 141        switch (kind)
 142        {
 143            case BaseItemKind.Person:
 0144                baseQuery = context.PeopleBaseItemMap
 0145                    .AsNoTracking()
 0146                    .Where(m => m.People.Name == item.Name)
 0147                    .Select(m => m.Item);
 0148                break;
 149            case BaseItemKind.MusicArtist:
 0150                baseQuery = context.ItemValuesMap
 0151                    .AsNoTracking()
 0152                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
 0153                        && (ivm.ItemValue.Type == ItemValueType.Artist || ivm.ItemValue.Type == ItemValueType.AlbumArtis
 0154                    .Select(ivm => ivm.Item);
 0155                break;
 156            case BaseItemKind.Genre:
 157            case BaseItemKind.MusicGenre:
 0158                baseQuery = context.ItemValuesMap
 0159                    .AsNoTracking()
 0160                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
 0161                        && ivm.ItemValue.Type == ItemValueType.Genre)
 0162                    .Select(ivm => ivm.Item);
 0163                break;
 164            case BaseItemKind.Studio:
 0165                baseQuery = context.ItemValuesMap
 0166                    .AsNoTracking()
 0167                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
 0168                        && ivm.ItemValue.Type == ItemValueType.Studios)
 0169                    .Select(ivm => ivm.Item);
 0170                break;
 171            case BaseItemKind.Year:
 0172                if (int.TryParse(item.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var year))
 173                {
 0174                    baseQuery = context.BaseItems
 0175                        .AsNoTracking()
 0176                        .Where(e => e.ProductionYear == year);
 177                }
 178                else
 179                {
 0180                    return new ItemCounts();
 181                }
 182
 183                break;
 184            default:
 0185                return new ItemCounts();
 186        }
 187
 0188        var typeNames = relatedItemKinds.Select(k => _itemTypeLookup.BaseItemKindNames[k]).ToArray();
 0189        baseQuery = baseQuery.Where(e => typeNames.Contains(e.Type));
 190
 0191        baseQuery = _queryHelpers.ApplyAccessFiltering(context, baseQuery, accessFilter);
 192
 0193        var counts = baseQuery
 0194            .GroupBy(x => x.Type)
 0195            .Select(x => new { x.Key, Count = x.Count() })
 0196            .ToArray();
 197
 0198        var lookup = _itemTypeLookup.BaseItemKindNames;
 0199        var result = new ItemCounts();
 0200        var totalCount = 0;
 201
 0202        foreach (var count in counts)
 203        {
 0204            totalCount += count.Count;
 205
 0206            if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))
 207            {
 0208                result.AlbumCount = count.Count;
 209            }
 0210            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))
 211            {
 0212                result.ArtistCount = count.Count;
 213            }
 0214            else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))
 215            {
 0216                result.EpisodeCount = count.Count;
 217            }
 0218            else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))
 219            {
 0220                result.MovieCount = count.Count;
 221            }
 0222            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))
 223            {
 0224                result.MusicVideoCount = count.Count;
 225            }
 0226            else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))
 227            {
 0228                result.ProgramCount = count.Count;
 229            }
 0230            else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))
 231            {
 0232                result.SeriesCount = count.Count;
 233            }
 0234            else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))
 235            {
 0236                result.SongCount = count.Count;
 237            }
 0238            else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))
 239            {
 0240                result.TrailerCount = count.Count;
 241            }
 0242            else if (string.Equals(count.Key, lookup[BaseItemKind.BoxSet], StringComparison.Ordinal))
 243            {
 0244                result.BoxSetCount = count.Count;
 245            }
 0246            else if (string.Equals(count.Key, lookup[BaseItemKind.Book], StringComparison.Ordinal))
 247            {
 0248                result.BookCount = count.Count;
 249            }
 250        }
 251
 0252        result.ItemCount = totalCount;
 253
 0254        return result;
 0255    }
 256
 257    /// <inheritdoc/>
 258    public int GetPlayedCount(InternalItemsQuery filter, Guid ancestorId)
 259    {
 0260        ArgumentNullException.ThrowIfNull(filter.User);
 0261        using var dbContext = _dbProvider.CreateDbContext();
 262
 0263        var baseQuery = _queryHelpers.BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
 0264        return baseQuery.Count(b => b.UserData!.Any(u => u.UserId == filter.User.Id && u.Played));
 0265    }
 266
 267    /// <inheritdoc/>
 268    public int GetTotalCount(InternalItemsQuery filter, Guid ancestorId)
 269    {
 0270        using var dbContext = _dbProvider.CreateDbContext();
 271
 0272        var baseQuery = _queryHelpers.BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
 0273        return baseQuery.Count();
 0274    }
 275
 276    /// <inheritdoc/>
 277    public (int Played, int Total) GetPlayedAndTotalCount(InternalItemsQuery filter, Guid ancestorId)
 278    {
 0279        ArgumentNullException.ThrowIfNull(filter);
 0280        ArgumentNullException.ThrowIfNull(filter.User);
 0281        using var dbContext = _dbProvider.CreateDbContext();
 282
 0283        var baseQuery = _queryHelpers.BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
 0284        return GetPlayedAndTotalCountFromQuery(baseQuery, filter.User.Id);
 0285    }
 286
 287    /// <inheritdoc/>
 288    public (int Played, int Total) GetPlayedAndTotalCountFromLinkedChildren(InternalItemsQuery filter, Guid parentId)
 289    {
 0290        ArgumentNullException.ThrowIfNull(filter);
 0291        ArgumentNullException.ThrowIfNull(filter.User);
 0292        using var dbContext = _dbProvider.CreateDbContext();
 293
 0294        var allDescendantIds = DescendantQueryHelper.GetAllDescendantIds(dbContext, parentId);
 0295        var baseQuery = dbContext.BaseItems
 0296            .Where(b => allDescendantIds.Contains(b.Id) && !b.IsFolder && !b.IsVirtualItem);
 0297        baseQuery = _queryHelpers.ApplyAccessFiltering(dbContext, baseQuery, filter);
 298
 0299        return GetPlayedAndTotalCountFromQuery(baseQuery, filter.User.Id);
 0300    }
 301
 302    /// <inheritdoc/>
 303    public Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId)
 304    {
 0305        ArgumentNullException.ThrowIfNull(parentIds);
 306
 0307        if (parentIds.Count == 0)
 308        {
 0309            return new Dictionary<Guid, int>();
 310        }
 311
 0312        using var dbContext = _dbProvider.CreateDbContext();
 313
 0314        var parentIdsArray = parentIds.ToArray();
 315
 0316        var hierarchicalCounts = dbContext.BaseItems
 0317            .Where(b => b.ParentId.HasValue && parentIdsArray.Contains(b.ParentId.Value))
 0318            .GroupBy(b => b.ParentId!.Value)
 0319            .Select(g => new { ParentId = g.Key, Count = g.Count() })
 0320            .ToDictionary(x => x.ParentId, x => x.Count);
 321
 0322        var linkedCounts = dbContext.LinkedChildren
 0323            .Where(lc => parentIdsArray.Contains(lc.ParentId))
 0324            .GroupBy(lc => lc.ParentId)
 0325            .Select(g => new { ParentId = g.Key, Count = g.Count() })
 0326            .ToDictionary(x => x.ParentId, x => x.Count);
 327
 0328        var result = new Dictionary<Guid, int>();
 0329        foreach (var parentId in parentIds)
 330        {
 0331            var hierarchicalCount = hierarchicalCounts.GetValueOrDefault(parentId, 0);
 0332            var linkedCount = linkedCounts.GetValueOrDefault(parentId, 0);
 333
 0334            result[parentId] = linkedCount > 0 ? linkedCount : hierarchicalCount;
 335        }
 336
 0337        return result;
 0338    }
 339
 340    /// <inheritdoc/>
 341    public Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User use
 342    {
 0343        ArgumentNullException.ThrowIfNull(folderIds);
 0344        ArgumentNullException.ThrowIfNull(user);
 345
 0346        if (folderIds.Count == 0)
 347        {
 0348            return new Dictionary<Guid, (int Played, int Total)>();
 349        }
 350
 0351        using var dbContext = _dbProvider.CreateDbContext();
 0352        var folderIdsArray = folderIds.ToArray();
 0353        var filter = new InternalItemsQuery(user);
 0354        var userId = user.Id;
 355
 0356        var leafItems = dbContext.BaseItems
 0357            .Where(b => !b.IsFolder && !b.IsVirtualItem);
 0358        leafItems = _queryHelpers.ApplyAccessFiltering(dbContext, leafItems, filter);
 359
 0360        var playedLeafItems = leafItems
 0361            .Select(b => new { b.Id, Played = b.UserData!.Any(ud => ud.UserId == userId && ud.Played) });
 362
 0363        var ancestorLeaves = dbContext.AncestorIds
 0364            .WhereOneOrMany(folderIdsArray, a => a.ParentItemId)
 0365            .Join(
 0366                playedLeafItems,
 0367                a => a.ItemId,
 0368                b => b.Id,
 0369                (a, b) => new { FolderId = a.ParentItemId, b.Id, b.Played });
 370
 0371        var linkedLeaves = dbContext.LinkedChildren
 0372            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
 0373            .Join(
 0374                playedLeafItems,
 0375                lc => lc.ChildId,
 0376                b => b.Id,
 0377                (lc, b) => new { FolderId = lc.ParentId, b.Id, b.Played });
 378
 0379        var linkedFolderLeaves = dbContext.LinkedChildren
 0380            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
 0381            .Join(
 0382                dbContext.BaseItems.Where(b => b.IsFolder),
 0383                lc => lc.ChildId,
 0384                b => b.Id,
 0385                (lc, b) => new { lc.ParentId, FolderChildId = b.Id })
 0386            .Join(
 0387                dbContext.AncestorIds,
 0388                x => x.FolderChildId,
 0389                a => a.ParentItemId,
 0390                (x, a) => new { x.ParentId, DescendantId = a.ItemId })
 0391            .Join(
 0392                playedLeafItems,
 0393                x => x.DescendantId,
 0394                b => b.Id,
 0395                (x, b) => new { FolderId = x.ParentId, b.Id, b.Played });
 396
 0397        var results = ancestorLeaves
 0398            .Union(linkedLeaves)
 0399            .Union(linkedFolderLeaves)
 0400            .GroupBy(x => x.FolderId)
 0401            .Select(g => new
 0402            {
 0403                FolderId = g.Key,
 0404                Total = g.Select(x => x.Id).Distinct().Count(),
 0405                Played = g.Where(x => x.Played).Select(x => x.Id).Distinct().Count()
 0406            })
 0407            .ToDictionary(x => x.FolderId, x => (x.Played, x.Total));
 408
 0409        return results;
 0410    }
 411
 412    private static (int Played, int Total) GetPlayedAndTotalCountFromQuery(IQueryable<BaseItemEntity> query, Guid userId
 413    {
 0414        var result = query
 0415            .Select(b => b.UserData!.Any(u => u.UserId == userId && u.Played))
 0416            .GroupBy(_ => 1)
 0417            .OrderBy(g => g.Key)
 0418            .Select(g => new
 0419            {
 0420                Total = g.Count(),
 0421                Played = g.Count(isPlayed => isPlayed)
 0422            })
 0423            .FirstOrDefault();
 424
 0425        return result is null ? (0, 0) : (result.Played, result.Total);
 426    }
 427}
Generated by: ReportGenerator 5.5.7.0
5/7/2026 - 12:15:47 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.EntityFrameworkCore.IDbContextFactory`1<Jellyfin.Database.Implementations.JellyfinDbContext>,MediaBrowser.Controller.Persistence.IItemTypeLookup,MediaBrowser.Controller.Persistence.IItemQueryHelpers)
GetCount(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetItemCounts(MediaBrowser.Controller.Entities.InternalItemsQuery)
GetItemCountsForNameItem(Jellyfin.Data.Enums.BaseItemKind,System.Guid,Jellyfin.Data.Enums.BaseItemKind[],MediaBrowser.Controller.Entities.InternalItemsQuery)
GetPlayedCount(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Guid)
GetTotalCount(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Guid)
GetPlayedAndTotalCount(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Guid)
GetPlayedAndTotalCountFromLinkedChildren(MediaBrowser.Controller.Entities.InternalItemsQuery,System.Guid)
GetChildCountBatch(System.Collections.Generic.IReadOnlyList`1<System.Guid>,System.Nullable`1<System.Guid>)
GetPlayedAndTotalCountBatch(System.Collections.Generic.IReadOnlyList`1<System.Guid>,Jellyfin.Database.Implementations.Entities.User)
GetPlayedAndTotalCountFromQuery(System.Linq.IQueryable`1<Jellyfin.Database.Implementations.Entities.BaseItemEntity>,System.Guid)