1 files changed, 47 insertions, 25 deletions

diff --git a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
index a8dfd4cd3..be58e2a52 100644
--- a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
@@ -2,8 +2,10 @@ using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
-using Jellyfin.Data.Entities;
 using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Entities.Libraries;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Persistence;
@@ -39,6 +41,12 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
             dbQuery = dbQuery.Take(filter.Limit);
         }
 
+        // Include PeopleBaseItemMap
+        if (!filter.ItemId.IsEmpty())
+        {
+            dbQuery = dbQuery.Include(p => p.BaseItems!.Where(m => m.ItemId == filter.ItemId));
+        }
+
         return dbQuery.AsEnumerable().Select(Map).ToArray();
     }
 
@@ -46,7 +54,7 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
     public IReadOnlyList<string> GetPeopleNames(InternalPeopleQuery filter)
     {
         using var context = _dbProvider.CreateDbContext();
-        var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter);
+        var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter).Select(e => e.Name).Distinct();
 
         // dbQuery = dbQuery.OrderBy(e => e.ListOrder);
         if (filter.Limit > 0)
@@ -54,49 +62,59 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
             dbQuery = dbQuery.Take(filter.Limit);
         }
 
-        return dbQuery.Select(e => e.Name).ToArray();
+        return dbQuery.ToArray();
     }
 
     /// <inheritdoc />
     public void UpdatePeople(Guid itemId, IReadOnlyList<PersonInfo> people)
     {
         using var context = _dbProvider.CreateDbContext();
-        using var transaction = context.Database.BeginTransaction();
 
-        context.PeopleBaseItemMap.Where(e => e.ItemId == itemId).ExecuteDelete();
         // TODO: yes for __SOME__ reason there can be duplicates.
-        foreach (var item in people.DistinctBy(e => e.Id))
+        people = people.DistinctBy(e => e.Id).ToArray();
+        var personids = people.Select(f => f.Id);
+        var existingPersons = context.Peoples.Where(p => personids.Contains(p.Id)).Select(f => f.Id).ToArray();
+        context.Peoples.AddRange(people.Where(e => !existingPersons.Contains(e.Id)).Select(Map));
+        context.SaveChanges();
+
+        var maps = context.PeopleBaseItemMap.Where(e => e.ItemId == itemId).ToList();
+        foreach (var person in people)
         {
-            var personEntity = Map(item);
-            var existingEntity = context.Peoples.FirstOrDefault(e => e.Id == personEntity.Id);
-            if (existingEntity is null)
+            var existingMap = maps.FirstOrDefault(e => e.PeopleId == person.Id);
+            if (existingMap is null)
             {
-                context.Peoples.Add(personEntity);
-                existingEntity = personEntity;
+                context.PeopleBaseItemMap.Add(new PeopleBaseItemMap()
+                {
+                    Item = null!,
+                    ItemId = itemId,
+                    People = null!,
+                    PeopleId = person.Id,
+                    ListOrder = person.SortOrder,
+                    SortOrder = person.SortOrder,
+                    Role = person.Role
+                });
             }
-
-            context.PeopleBaseItemMap.Add(new PeopleBaseItemMap()
+            else
             {
-                Item = null!,
-                ItemId = itemId,
-                People = existingEntity,
-                PeopleId = existingEntity.Id,
-                ListOrder = item.SortOrder,
-                SortOrder = item.SortOrder,
-                Role = item.Role
-            });
+                // person mapping already exists so remove from list
+                maps.Remove(existingMap);
+            }
         }
 
+        context.PeopleBaseItemMap.RemoveRange(maps);
+
         context.SaveChanges();
-        transaction.Commit();
     }
 
     private PersonInfo Map(People people)
     {
+        var mapping = people.BaseItems?.FirstOrDefault();
         var personInfo = new PersonInfo()
         {
             Id = people.Id,
             Name = people.Name,
+            Role = mapping?.Role,
+            SortOrder = mapping?.SortOrder
         };
         if (Enum.TryParse<PersonKind>(people.PersonType, out var kind))
         {
@@ -123,9 +141,13 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
         if (filter.User is not null && filter.IsFavorite.HasValue)
         {
             var personType = itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];
-            query = query.Where(e => e.PersonType == personType)
-                .Where(e => context.BaseItems.Where(d => d.UserData!.Any(w => w.IsFavorite == filter.IsFavorite && w.UserId.Equals(filter.User.Id)))
-                    .Select(f => f.Name).Contains(e.Name));
+            var oldQuery = query;
+
+            query = context.UserData
+                .Where(u => u.Item!.Type == personType && u.IsFavorite == filter.IsFavorite && u.UserId.Equals(filter.User.Id))
+                .Join(oldQuery, e => e.Item!.Name, e => e.Name, (item, person) => person)
+                .Distinct()
+                .AsNoTracking();
         }
 
         if (!filter.ItemId.IsEmpty())