< 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
0%
Covered lines: 1
Uncovered lines: 113
Coverable lines: 114
Total lines: 253
Line coverage: 0.8%
Branch coverage
0%
Covered branches: 0
Total branches: 50
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%110100%
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        // Include PeopleBaseItemMap
 039        if (!filter.ItemId.IsEmpty())
 40        {
 041            dbQuery = dbQuery.Include(p => p.BaseItems!.Where(m => m.ItemId == filter.ItemId))
 042                .OrderBy(e => e.BaseItems!.First(e => e.ItemId == filter.ItemId).ListOrder)
 043                .ThenBy(e => e.PersonType)
 044                .ThenBy(e => e.Name);
 45        }
 46        else
 47        {
 048            dbQuery = dbQuery.OrderBy(e => e.Name);
 49        }
 50
 051        if (filter.Limit > 0)
 52        {
 053            dbQuery = dbQuery.Take(filter.Limit);
 54        }
 55
 056        return dbQuery.AsEnumerable().Select(Map).ToArray();
 057    }
 58
 59    /// <inheritdoc/>
 60    public IReadOnlyList<string> GetPeopleNames(InternalPeopleQuery filter)
 61    {
 062        using var context = _dbProvider.CreateDbContext();
 063        var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter).Select(e => e.Name).Distinct();
 64
 65        // dbQuery = dbQuery.OrderBy(e => e.ListOrder);
 066        if (filter.Limit > 0)
 67        {
 068            dbQuery = dbQuery.Take(filter.Limit);
 69        }
 70
 071        return dbQuery.ToArray();
 072    }
 73
 74    /// <inheritdoc />
 75    public void UpdatePeople(Guid itemId, IReadOnlyList<PersonInfo> people)
 76    {
 077        foreach (var item in people.Where(e => e.Role is null))
 78        {
 079            item.Role = string.Empty;
 80        }
 81
 82        // multiple metadata providers can provide the _same_ person
 083        people = people.DistinctBy(e => e.Name + "-" + e.Type).ToArray();
 084        var personKeys = people.Select(e => e.Name + "-" + e.Type).ToArray();
 85
 086        using var context = _dbProvider.CreateDbContext();
 087        using var transaction = context.Database.BeginTransaction();
 088        var existingPersons = context.Peoples.Select(e => new
 089            {
 090                item = e,
 091                SelectionKey = e.Name + "-" + e.PersonType
 092            })
 093            .Where(p => personKeys.Contains(p.SelectionKey))
 094            .Select(f => f.item)
 095            .ToArray();
 96
 097        var toAdd = people
 098            .Where(e => e.Type is not PersonKind.Artist && e.Type is not PersonKind.AlbumArtist)
 099            .Where(e => !existingPersons.Any(f => f.Name == e.Name && f.PersonType == e.Type.ToString()))
 0100            .Select(Map);
 0101        context.Peoples.AddRange(toAdd);
 0102        context.SaveChanges();
 103
 0104        var personsEntities = toAdd.Concat(existingPersons).ToArray();
 105
 0106        var existingMaps = context.PeopleBaseItemMap.Include(e => e.People).Where(e => e.ItemId == itemId).ToList();
 107
 0108        var listOrder = 0;
 109
 0110        foreach (var person in people)
 111        {
 0112            if (person.Type == PersonKind.Artist || person.Type == PersonKind.AlbumArtist)
 113            {
 114                continue;
 115            }
 116
 0117            var entityPerson = personsEntities.First(e => e.Name == person.Name && e.PersonType == person.Type.ToString(
 0118            var existingMap = existingMaps.FirstOrDefault(e => e.People.Name == person.Name && e.People.PersonType == pe
 0119            if (existingMap is null)
 120            {
 0121                context.PeopleBaseItemMap.Add(new PeopleBaseItemMap()
 0122                {
 0123                    Item = null!,
 0124                    ItemId = itemId,
 0125                    People = null!,
 0126                    PeopleId = entityPerson.Id,
 0127                    ListOrder = listOrder,
 0128                    SortOrder = person.SortOrder,
 0129                    Role = person.Role
 0130                });
 131            }
 132            else
 133            {
 134                // Update the order for existing mappings
 0135                existingMap.ListOrder = listOrder;
 0136                existingMap.SortOrder = person.SortOrder;
 137                // person mapping already exists so remove from list
 0138                existingMaps.Remove(existingMap);
 139            }
 140
 0141            listOrder++;
 142        }
 143
 0144        context.PeopleBaseItemMap.RemoveRange(existingMaps);
 145
 0146        context.SaveChanges();
 0147        transaction.Commit();
 0148    }
 149
 150    private PersonInfo Map(People people)
 151    {
 0152        var mapping = people.BaseItems?.FirstOrDefault();
 0153        var personInfo = new PersonInfo()
 0154        {
 0155            Id = people.Id,
 0156            Name = people.Name,
 0157            Role = mapping?.Role,
 0158            SortOrder = mapping?.SortOrder
 0159        };
 0160        if (Enum.TryParse<PersonKind>(people.PersonType, out var kind))
 161        {
 0162            personInfo.Type = kind;
 163        }
 164
 0165        return personInfo;
 166    }
 167
 168    private People Map(PersonInfo people)
 169    {
 0170        var personInfo = new People()
 0171        {
 0172            Name = people.Name,
 0173            PersonType = people.Type.ToString(),
 0174            Id = people.Id,
 0175        };
 176
 0177        return personInfo;
 178    }
 179
 180    private IQueryable<People> TranslateQuery(IQueryable<People> query, JellyfinDbContext context, InternalPeopleQuery f
 181    {
 0182        if (filter.User is not null && filter.IsFavorite.HasValue)
 183        {
 0184            var personType = itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];
 0185            var oldQuery = query;
 186
 0187            query = context.UserData
 0188                .Where(u => u.Item!.Type == personType && u.IsFavorite == filter.IsFavorite && u.UserId.Equals(filter.Us
 0189                .Join(oldQuery, e => e.Item!.Name, e => e.Name, (item, person) => person)
 0190                .Distinct()
 0191                .AsNoTracking();
 192        }
 193
 0194        if (!filter.ItemId.IsEmpty())
 195        {
 0196            query = query.Where(e => e.BaseItems!.Any(w => w.ItemId.Equals(filter.ItemId)));
 197        }
 198
 0199        if (!filter.AppearsInItemId.IsEmpty())
 200        {
 0201            query = query.Where(e => e.BaseItems!.Any(w => w.ItemId.Equals(filter.AppearsInItemId)));
 202        }
 203
 0204        var queryPersonTypes = filter.PersonTypes.Where(IsValidPersonType).ToList();
 0205        if (queryPersonTypes.Count > 0)
 206        {
 0207            query = query.Where(e => queryPersonTypes.Contains(e.PersonType));
 208        }
 209
 0210        var queryExcludePersonTypes = filter.ExcludePersonTypes.Where(IsValidPersonType).ToList();
 211
 0212        if (queryExcludePersonTypes.Count > 0)
 213        {
 0214            query = query.Where(e => !queryPersonTypes.Contains(e.PersonType));
 215        }
 216
 0217        if (filter.MaxListOrder.HasValue && !filter.ItemId.IsEmpty())
 218        {
 0219            query = query.Where(e => e.BaseItems!.First(w => w.ItemId == filter.ItemId).ListOrder <= filter.MaxListOrder
 220        }
 221
 0222        if (!string.IsNullOrWhiteSpace(filter.NameContains))
 223        {
 0224            var nameContainsUpper = filter.NameContains.ToUpper();
 0225            query = query.Where(e => e.Name.ToUpper().Contains(nameContainsUpper));
 226        }
 227
 0228        return query;
 229    }
 230
 231    private bool IsAlphaNumeric(string str)
 232    {
 0233        if (string.IsNullOrWhiteSpace(str))
 234        {
 0235            return false;
 236        }
 237
 0238        for (int i = 0; i < str.Length; i++)
 239        {
 0240            if (!char.IsLetter(str[i]) && !char.IsNumber(str[i]))
 241            {
 0242                return false;
 243            }
 244        }
 245
 0246        return true;
 247    }
 248
 249    private bool IsValidPersonType(string value)
 250    {
 0251        return IsAlphaNumeric(value);
 252    }
 253}
Generated by: ReportGenerator 5.4.11.0
10/13/2025 - 12:11:04 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)