< Summary - Jellyfin

Information
Class: Jellyfin.Server.Implementations.Item.PeopleRepository
Assembly: Jellyfin.Server.Implementations
File(s): /srv/git/jellyfin/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
Line coverage
1%
Covered lines: 1
Uncovered lines: 89
Coverable lines: 90
Total lines: 214
Line coverage: 1.1%
Branch coverage
0%
Covered branches: 0
Total branches: 44
Branch coverage: 0%
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
.ctor(...)100%11100%
GetPeople(...)0%2040%
GetPeopleNames(...)0%620%
UpdatePeople(...)0%2040%
Map(...)0%7280%
Map(...)100%210%
TranslateQuery(...)0%342180%
IsAlphaNumeric(...)0%7280%
IsValidPersonType(...)100%210%

File(s)

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

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Collections.Immutable;
 4using System.Linq;
 5using Jellyfin.Data.Enums;
 6using Jellyfin.Database.Implementations;
 7using Jellyfin.Database.Implementations.Entities;
 8using Jellyfin.Database.Implementations.Entities.Libraries;
 9using Jellyfin.Extensions;
 10using MediaBrowser.Controller.Entities;
 11using MediaBrowser.Controller.Persistence;
 12using Microsoft.EntityFrameworkCore;
 13
 14namespace Jellyfin.Server.Implementations.Item;
 15#pragma warning disable RS0030 // Do not use banned APIs
 16#pragma warning disable CA1304 // Specify CultureInfo
 17#pragma warning disable CA1311 // Specify a culture or use an invariant version
 18#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string compari
 19
 20/// <summary>
 21/// Manager for handling people.
 22/// </summary>
 23/// <param name="dbProvider">Efcore Factory.</param>
 24/// <param name="itemTypeLookup">Items lookup service.</param>
 25/// <remarks>
 26/// Initializes a new instance of the <see cref="PeopleRepository"/> class.
 27/// </remarks>
 28public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, IItemTypeLookup itemTypeLookup) : IPeople
 29{
 2130    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider = dbProvider;
 31
 32    /// <inheritdoc/>
 33    public IReadOnlyList<PersonInfo> GetPeople(InternalPeopleQuery filter)
 34    {
 035        using var context = _dbProvider.CreateDbContext();
 036        var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter);
 37
 38        // dbQuery = dbQuery.OrderBy(e => e.ListOrder);
 039        if (filter.Limit > 0)
 40        {
 041            dbQuery = dbQuery.Take(filter.Limit);
 42        }
 43
 44        // Include PeopleBaseItemMap
 045        if (!filter.ItemId.IsEmpty())
 46        {
 047            dbQuery = dbQuery.Include(p => p.BaseItems!.Where(m => m.ItemId == filter.ItemId));
 48        }
 49
 050        return dbQuery.AsEnumerable().Select(Map).ToArray();
 051    }
 52
 53    /// <inheritdoc/>
 54    public IReadOnlyList<string> GetPeopleNames(InternalPeopleQuery filter)
 55    {
 056        using var context = _dbProvider.CreateDbContext();
 057        var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter).Select(e => e.Name).Distinct();
 58
 59        // dbQuery = dbQuery.OrderBy(e => e.ListOrder);
 060        if (filter.Limit > 0)
 61        {
 062            dbQuery = dbQuery.Take(filter.Limit);
 63        }
 64
 065        return dbQuery.ToArray();
 066    }
 67
 68    /// <inheritdoc />
 69    public void UpdatePeople(Guid itemId, IReadOnlyList<PersonInfo> people)
 70    {
 71        // TODO: yes for __SOME__ reason there can be duplicates.
 072        people = people.DistinctBy(e => e.Id).ToArray();
 073        var personids = people.Select(f => f.Id);
 74
 075        using var context = _dbProvider.CreateDbContext();
 076        using var transaction = context.Database.BeginTransaction();
 077        var existingPersons = context.Peoples.Where(p => personids.Contains(p.Id)).Select(f => f.Id).ToArray();
 078        context.Peoples.AddRange(people.Where(e => !existingPersons.Contains(e.Id)).Select(Map));
 079        context.SaveChanges();
 80
 081        var maps = context.PeopleBaseItemMap.Where(e => e.ItemId == itemId).ToList();
 082        foreach (var person in people)
 83        {
 084            var existingMap = maps.FirstOrDefault(e => e.PeopleId == person.Id);
 085            if (existingMap is null)
 86            {
 087                context.PeopleBaseItemMap.Add(new PeopleBaseItemMap()
 088                {
 089                    Item = null!,
 090                    ItemId = itemId,
 091                    People = null!,
 092                    PeopleId = person.Id,
 093                    ListOrder = person.SortOrder,
 094                    SortOrder = person.SortOrder,
 095                    Role = person.Role
 096                });
 97            }
 98            else
 99            {
 100                // person mapping already exists so remove from list
 0101                maps.Remove(existingMap);
 102            }
 103        }
 104
 0105        context.PeopleBaseItemMap.RemoveRange(maps);
 106
 0107        context.SaveChanges();
 0108        transaction.Commit();
 0109    }
 110
 111    private PersonInfo Map(People people)
 112    {
 0113        var mapping = people.BaseItems?.FirstOrDefault();
 0114        var personInfo = new PersonInfo()
 0115        {
 0116            Id = people.Id,
 0117            Name = people.Name,
 0118            Role = mapping?.Role,
 0119            SortOrder = mapping?.SortOrder
 0120        };
 0121        if (Enum.TryParse<PersonKind>(people.PersonType, out var kind))
 122        {
 0123            personInfo.Type = kind;
 124        }
 125
 0126        return personInfo;
 127    }
 128
 129    private People Map(PersonInfo people)
 130    {
 0131        var personInfo = new People()
 0132        {
 0133            Name = people.Name,
 0134            PersonType = people.Type.ToString(),
 0135            Id = people.Id,
 0136        };
 137
 0138        return personInfo;
 139    }
 140
 141    private IQueryable<People> TranslateQuery(IQueryable<People> query, JellyfinDbContext context, InternalPeopleQuery f
 142    {
 0143        if (filter.User is not null && filter.IsFavorite.HasValue)
 144        {
 0145            var personType = itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];
 0146            var oldQuery = query;
 147
 0148            query = context.UserData
 0149                .Where(u => u.Item!.Type == personType && u.IsFavorite == filter.IsFavorite && u.UserId.Equals(filter.Us
 0150                .Join(oldQuery, e => e.Item!.Name, e => e.Name, (item, person) => person)
 0151                .Distinct()
 0152                .AsNoTracking();
 153        }
 154
 0155        if (!filter.ItemId.IsEmpty())
 156        {
 0157            query = query.Where(e => e.BaseItems!.Any(w => w.ItemId.Equals(filter.ItemId)));
 158        }
 159
 0160        if (!filter.AppearsInItemId.IsEmpty())
 161        {
 0162            query = query.Where(e => e.BaseItems!.Any(w => w.ItemId.Equals(filter.AppearsInItemId)));
 163        }
 164
 0165        var queryPersonTypes = filter.PersonTypes.Where(IsValidPersonType).ToList();
 0166        if (queryPersonTypes.Count > 0)
 167        {
 0168            query = query.Where(e => queryPersonTypes.Contains(e.PersonType));
 169        }
 170
 0171        var queryExcludePersonTypes = filter.ExcludePersonTypes.Where(IsValidPersonType).ToList();
 172
 0173        if (queryExcludePersonTypes.Count > 0)
 174        {
 0175            query = query.Where(e => !queryPersonTypes.Contains(e.PersonType));
 176        }
 177
 0178        if (filter.MaxListOrder.HasValue && !filter.ItemId.IsEmpty())
 179        {
 0180            query = query.Where(e => e.BaseItems!.First(w => w.ItemId == filter.ItemId).ListOrder <= filter.MaxListOrder
 181        }
 182
 0183        if (!string.IsNullOrWhiteSpace(filter.NameContains))
 184        {
 0185            var nameContainsUpper = filter.NameContains.ToUpper();
 0186            query = query.Where(e => e.Name.ToUpper().Contains(nameContainsUpper));
 187        }
 188
 0189        return query;
 190    }
 191
 192    private bool IsAlphaNumeric(string str)
 193    {
 0194        if (string.IsNullOrWhiteSpace(str))
 195        {
 0196            return false;
 197        }
 198
 0199        for (int i = 0; i < str.Length; i++)
 200        {
 0201            if (!char.IsLetter(str[i]) && !char.IsNumber(str[i]))
 202            {
 0203                return false;
 204            }
 205        }
 206
 0207        return true;
 208    }
 209
 210    private bool IsValidPersonType(string value)
 211    {
 0212        return IsAlphaNumeric(value);
 213    }
 214}
Generated by: ReportGenerator 5.4.11.0
9/17/2025 - 12:11:25 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.EntityFrameworkCore.IDbContextFactory`1<Jellyfin.Database.Implementations.JellyfinDbContext>,MediaBrowser.Controller.Persistence.IItemTypeLookup)
GetPeople(MediaBrowser.Controller.Entities.InternalPeopleQuery)
GetPeopleNames(MediaBrowser.Controller.Entities.InternalPeopleQuery)
UpdatePeople(System.Guid,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.PersonInfo>)
Map(Jellyfin.Database.Implementations.Entities.People)
Map(MediaBrowser.Controller.Entities.PersonInfo)
TranslateQuery(System.Linq.IQueryable`1<Jellyfin.Database.Implementations.Entities.People>,Jellyfin.Database.Implementations.JellyfinDbContext,MediaBrowser.Controller.Entities.InternalPeopleQuery)
IsAlphaNumeric(System.String)
IsValidPersonType(System.String)