< 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: 83
Coverable lines: 84
Total lines: 207
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);
 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.Select(e => e.Name).ToArray();
 066    }
 67
 68    /// <inheritdoc />
 69    public void UpdatePeople(Guid itemId, IReadOnlyList<PersonInfo> people)
 70    {
 071        using var context = _dbProvider.CreateDbContext();
 72
 73        // TODO: yes for __SOME__ reason there can be duplicates.
 074        people = people.DistinctBy(e => e.Id).ToArray();
 075        var personids = people.Select(f => f.Id);
 076        var existingPersons = context.Peoples.Where(p => personids.Contains(p.Id)).Select(f => f.Id).ToArray();
 077        context.Peoples.AddRange(people.Where(e => !existingPersons.Contains(e.Id)).Select(Map));
 078        context.SaveChanges();
 79
 080        var maps = context.PeopleBaseItemMap.Where(e => e.ItemId == itemId).ToList();
 081        foreach (var person in people)
 82        {
 083            var existingMap = maps.FirstOrDefault(e => e.PeopleId == person.Id);
 084            if (existingMap is null)
 85            {
 086                context.PeopleBaseItemMap.Add(new PeopleBaseItemMap()
 087                {
 088                    Item = null!,
 089                    ItemId = itemId,
 090                    People = null!,
 091                    PeopleId = person.Id,
 092                    ListOrder = person.SortOrder,
 093                    SortOrder = person.SortOrder,
 094                    Role = person.Role
 095                });
 96            }
 97            else
 98            {
 99                // person mapping already exists so remove from list
 0100                maps.Remove(existingMap);
 101            }
 102        }
 103
 0104        context.PeopleBaseItemMap.RemoveRange(maps);
 105
 0106        context.SaveChanges();
 0107    }
 108
 109    private PersonInfo Map(People people)
 110    {
 0111        var mapping = people.BaseItems?.FirstOrDefault();
 0112        var personInfo = new PersonInfo()
 0113        {
 0114            Id = people.Id,
 0115            Name = people.Name,
 0116            Role = mapping?.Role,
 0117            SortOrder = mapping?.SortOrder
 0118        };
 0119        if (Enum.TryParse<PersonKind>(people.PersonType, out var kind))
 120        {
 0121            personInfo.Type = kind;
 122        }
 123
 0124        return personInfo;
 125    }
 126
 127    private People Map(PersonInfo people)
 128    {
 0129        var personInfo = new People()
 0130        {
 0131            Name = people.Name,
 0132            PersonType = people.Type.ToString(),
 0133            Id = people.Id,
 0134        };
 135
 0136        return personInfo;
 137    }
 138
 139    private IQueryable<People> TranslateQuery(IQueryable<People> query, JellyfinDbContext context, InternalPeopleQuery f
 140    {
 0141        if (filter.User is not null && filter.IsFavorite.HasValue)
 142        {
 0143            var personType = itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];
 0144            query = query
 0145                .Where(e => context.BaseItems.Any(b => b.Type == personType && b.Name == e.Name && b.UserData!.Any(u => 
 146        }
 147
 0148        if (!filter.ItemId.IsEmpty())
 149        {
 0150            query = query.Where(e => e.BaseItems!.Any(w => w.ItemId.Equals(filter.ItemId)));
 151        }
 152
 0153        if (!filter.AppearsInItemId.IsEmpty())
 154        {
 0155            query = query.Where(e => e.BaseItems!.Any(w => w.ItemId.Equals(filter.AppearsInItemId)));
 156        }
 157
 0158        var queryPersonTypes = filter.PersonTypes.Where(IsValidPersonType).ToList();
 0159        if (queryPersonTypes.Count > 0)
 160        {
 0161            query = query.Where(e => queryPersonTypes.Contains(e.PersonType));
 162        }
 163
 0164        var queryExcludePersonTypes = filter.ExcludePersonTypes.Where(IsValidPersonType).ToList();
 165
 0166        if (queryExcludePersonTypes.Count > 0)
 167        {
 0168            query = query.Where(e => !queryPersonTypes.Contains(e.PersonType));
 169        }
 170
 0171        if (filter.MaxListOrder.HasValue && !filter.ItemId.IsEmpty())
 172        {
 0173            query = query.Where(e => e.BaseItems!.First(w => w.ItemId == filter.ItemId).ListOrder <= filter.MaxListOrder
 174        }
 175
 0176        if (!string.IsNullOrWhiteSpace(filter.NameContains))
 177        {
 0178            var nameContainsUpper = filter.NameContains.ToUpper();
 0179            query = query.Where(e => e.Name.ToUpper().Contains(nameContainsUpper));
 180        }
 181
 0182        return query;
 183    }
 184
 185    private bool IsAlphaNumeric(string str)
 186    {
 0187        if (string.IsNullOrWhiteSpace(str))
 188        {
 0189            return false;
 190        }
 191
 0192        for (int i = 0; i < str.Length; i++)
 193        {
 0194            if (!char.IsLetter(str[i]) && !char.IsNumber(str[i]))
 195            {
 0196                return false;
 197            }
 198        }
 199
 0200        return true;
 201    }
 202
 203    private bool IsValidPersonType(string value)
 204    {
 0205        return IsAlphaNumeric(value);
 206    }
 207}
Generated by: ReportGenerator 5.4.7.0
5/17/2025 - 12:09:40 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)