< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Library.UserDataManager
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Library/UserDataManager.cs
Line coverage
57%
Covered lines: 146
Uncovered lines: 110
Coverable lines: 256
Total lines: 567
Line coverage: 57%
Branch coverage
28%
Covered branches: 39
Total branches: 136
Branch coverage: 28.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 5/31/2026 - 12:15:44 AM Line coverage: 32.9% (57/173) Branch coverage: 24.3% (20/82) Total lines: 3897/6/2026 - 12:16:28 AM Line coverage: 28.5% (67/235) Branch coverage: 21% (27/128) Total lines: 5267/21/2026 - 12:16:33 AM Line coverage: 37% (90/243) Branch coverage: 25.7% (35/136) Total lines: 5507/26/2026 - 12:17:51 AM Line coverage: 37.2% (91/244) Branch coverage: 25.7% (35/136) Total lines: 55110/29/2026 - 12:17:11 AM Line coverage: 57% (146/256) Branch coverage: 28.6% (39/136) Total lines: 567 5/31/2026 - 12:15:44 AM Line coverage: 32.9% (57/173) Branch coverage: 24.3% (20/82) Total lines: 3897/6/2026 - 12:16:28 AM Line coverage: 28.5% (67/235) Branch coverage: 21% (27/128) Total lines: 5267/21/2026 - 12:16:33 AM Line coverage: 37% (90/243) Branch coverage: 25.7% (35/136) Total lines: 5507/26/2026 - 12:17:51 AM Line coverage: 37.2% (91/244) Branch coverage: 25.7% (35/136) Total lines: 55110/29/2026 - 12:17:11 AM Line coverage: 57% (146/256) Branch coverage: 28.6% (39/136) Total lines: 567

Coverage delta

Coverage delta 20 -20

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
SaveUserData(...)66.66%6697.43%
SaveUserData(...)0%272160%
Map(...)100%11100%
Map(...)100%11100%
GetUserDataBatch(...)72.72%222290.62%
GetResumeUserData(...)100%11100%
GetResumeUserDataBatch(...)15.78%7773820%
GetCacheKey(...)100%11100%
GetUserData(...)75%44100%
ResolveUserDataRow(...)80%1010100%
GetUserDataDto(...)100%210%
GetUserDataDto(...)50%4485.71%
GetUserItemDataDto(...)100%11100%
UpdatePlayState(...)0%930300%
ResetPlaybackStreamSelections(...)0%4260%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Library/UserDataManager.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 System.Threading;
 8using BitFaster.Caching.Lru;
 9using Jellyfin.Database.Implementations;
 10using Jellyfin.Database.Implementations.Entities;
 11using MediaBrowser.Controller.Configuration;
 12using MediaBrowser.Controller.Dto;
 13using MediaBrowser.Controller.Entities;
 14using MediaBrowser.Controller.Library;
 15using MediaBrowser.Model.Dto;
 16using MediaBrowser.Model.Entities;
 17using Microsoft.EntityFrameworkCore;
 18using AudioBook = MediaBrowser.Controller.Entities.AudioBook;
 19using Book = MediaBrowser.Controller.Entities.Book;
 20
 21namespace Emby.Server.Implementations.Library
 22{
 23    /// <summary>
 24    /// Class UserDataManager.
 25    /// </summary>
 26    public class UserDataManager : IUserDataManager
 27    {
 28        private readonly IServerConfigurationManager _config;
 29        private readonly IDbContextFactory<JellyfinDbContext> _repository;
 30        private readonly FastConcurrentLru<string, UserItemData> _cache;
 31
 32        /// <summary>
 33        /// Initializes a new instance of the <see cref="UserDataManager"/> class.
 34        /// </summary>
 35        /// <param name="config">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
 36        /// <param name="repository">Instance of the <see cref="IDbContextFactory{JellyfinDbContext}"/> interface.</para
 37        public UserDataManager(
 38            IServerConfigurationManager config,
 39            IDbContextFactory<JellyfinDbContext> repository)
 40        {
 3541            _config = config;
 3542            _repository = repository;
 3543            _cache = new FastConcurrentLru<string, UserItemData>(Environment.ProcessorCount, _config.Configuration.Cache
 3544        }
 45
 46        /// <inheritdoc />
 47        public event EventHandler<UserDataSaveEventArgs>? UserDataSaved;
 48
 49        /// <inheritdoc />
 50        public void SaveUserData(User user, BaseItem item, UserItemData userData, UserDataSaveReason reason, Cancellatio
 51        {
 152            ArgumentNullException.ThrowIfNull(userData);
 53
 154            ArgumentNullException.ThrowIfNull(item);
 55
 156            cancellationToken.ThrowIfCancellationRequested();
 57
 158            var keys = item.GetUserDataKeys();
 59
 160            using var dbContext = _repository.CreateDbContext();
 161            using var transaction = dbContext.Database.BeginTransaction();
 62
 663            foreach (var key in keys)
 64            {
 265                userData.Key = key;
 266                var userDataEntry = Map(userData, user.Id, item.Id);
 267                if (dbContext.UserData.Any(f => f.ItemId == userDataEntry.ItemId && f.UserId == userDataEntry.UserId && 
 68                {
 069                    dbContext.UserData.Attach(userDataEntry).State = EntityState.Modified;
 70                }
 71                else
 72                {
 273                    dbContext.UserData.Add(userDataEntry);
 74                }
 75            }
 76
 177            dbContext.SaveChanges();
 78
 79            // Rows under keys the item no longer reports are kept, not deleted: the key set is briefly
 80            // incomplete mid-refresh, and those rows are what a deleted and re-added item reattaches by.
 181            dbContext.UserData
 182                .Where(e => e.ItemId == item.Id && e.UserId == user.Id && !keys.Contains(e.CustomDataKey))
 183                .ExecuteUpdate(e => e
 184                    .SetProperty(f => f.AudioStreamIndex, userData.AudioStreamIndex)
 185                    .SetProperty(f => f.IsFavorite, userData.IsFavorite)
 186                    .SetProperty(f => f.LastPlayedDate, userData.LastPlayedDate)
 187                    .SetProperty(f => f.Likes, userData.Likes)
 188                    .SetProperty(f => f.PlaybackPositionTicks, userData.PlaybackPositionTicks)
 189                    .SetProperty(f => f.PlayCount, userData.PlayCount)
 190                    .SetProperty(f => f.Played, userData.Played)
 191                    .SetProperty(f => f.Rating, userData.Rating)
 192                    .SetProperty(f => f.SubtitleStreamIndex, userData.SubtitleStreamIndex));
 93
 194            transaction.Commit();
 95
 196            var userId = user.InternalId;
 197            var cacheKey = GetCacheKey(userId, item.Id);
 198            _cache.AddOrUpdate(cacheKey, userData);
 199            item.UserData = dbContext.UserData.Where(e => e.ItemId == item.Id).AsNoTracking().ToArray(); // rehydrate th
 100
 1101            UserDataSaved?.Invoke(this, new UserDataSaveEventArgs
 1102            {
 1103                Keys = keys,
 1104                UserData = userData,
 1105                SaveReason = reason,
 1106                UserId = user.Id,
 1107                Item = item
 1108            });
 1109        }
 110
 111        /// <inheritdoc />
 112        public void SaveUserData(User user, BaseItem item, UpdateUserItemDataDto userDataDto, UserDataSaveReason reason)
 113        {
 0114            ArgumentNullException.ThrowIfNull(user);
 0115            ArgumentNullException.ThrowIfNull(item);
 0116            ArgumentNullException.ThrowIfNull(userDataDto);
 117
 0118            var userData = GetUserData(user, item) ?? throw new InvalidOperationException("UserData should not be null."
 119
 0120            if (userDataDto.PlaybackPositionTicks.HasValue)
 121            {
 0122                userData.PlaybackPositionTicks = userDataDto.PlaybackPositionTicks.Value;
 123            }
 124
 0125            if (userDataDto.PlayCount.HasValue)
 126            {
 0127                userData.PlayCount = userDataDto.PlayCount.Value;
 128            }
 129
 0130            if (userDataDto.IsFavorite.HasValue)
 131            {
 0132                userData.IsFavorite = userDataDto.IsFavorite.Value;
 133            }
 134
 0135            if (userDataDto.Likes.HasValue)
 136            {
 0137                userData.Likes = userDataDto.Likes.Value;
 138            }
 139
 0140            if (userDataDto.Played.HasValue)
 141            {
 0142                userData.Played = userDataDto.Played.Value;
 143            }
 144
 0145            if (userDataDto.LastPlayedDate.HasValue)
 146            {
 0147                userData.LastPlayedDate = userDataDto.LastPlayedDate.Value;
 148            }
 149
 0150            if (userDataDto.Rating.HasValue)
 151            {
 0152                userData.Rating = userDataDto.Rating.Value;
 153            }
 154
 0155            SaveUserData(user, item, userData, reason, CancellationToken.None);
 0156        }
 157
 158        private UserData Map(UserItemData dto, Guid userId, Guid itemId)
 159        {
 2160            return new UserData()
 2161            {
 2162                ItemId = itemId,
 2163                CustomDataKey = dto.Key,
 2164                Item = null,
 2165                User = null,
 2166                AudioStreamIndex = dto.AudioStreamIndex,
 2167                IsFavorite = dto.IsFavorite,
 2168                LastPlayedDate = dto.LastPlayedDate,
 2169                Likes = dto.Likes,
 2170                PlaybackPositionTicks = dto.PlaybackPositionTicks,
 2171                PlayCount = dto.PlayCount,
 2172                Played = dto.Played,
 2173                Rating = dto.Rating,
 2174                UserId = userId,
 2175                SubtitleStreamIndex = dto.SubtitleStreamIndex,
 2176            };
 177        }
 178
 179        private static UserItemData Map(UserData dto)
 180        {
 6181            return new UserItemData()
 6182            {
 6183                Key = dto.CustomDataKey!,
 6184                AudioStreamIndex = dto.AudioStreamIndex,
 6185                IsFavorite = dto.IsFavorite,
 6186                LastPlayedDate = dto.LastPlayedDate,
 6187                Likes = dto.Likes,
 6188                PlaybackPositionTicks = dto.PlaybackPositionTicks,
 6189                PlayCount = dto.PlayCount,
 6190                Played = dto.Played,
 6191                Rating = dto.Rating,
 6192                SubtitleStreamIndex = dto.SubtitleStreamIndex,
 6193            };
 194        }
 195
 196        /// <inheritdoc />
 197        public Dictionary<Guid, UserItemData> GetUserDataBatch(IReadOnlyList<BaseItem> items, User user)
 198        {
 5199            var result = new Dictionary<Guid, UserItemData>(items.Count);
 5200            var itemsNeedingQuery = new List<(BaseItem Item, List<string> Keys)>();
 201
 20202            foreach (var item in items)
 203            {
 5204                var cacheKey = GetCacheKey(user.InternalId, item.Id);
 5205                if (_cache.TryGet(cacheKey, out var cachedData))
 206                {
 2207                    result[item.Id] = cachedData;
 208                }
 209                else
 210                {
 3211                    var userDataRow = ResolveUserDataRow(item, item.UserData?.Where(e => e.UserId.Equals(user.Id)));
 3212                    var userData = userDataRow is not null ? Map(userDataRow) : null;
 3213                    if (userData is not null)
 214                    {
 0215                        result[item.Id] = userData;
 0216                        _cache.AddOrUpdate(cacheKey, userData);
 217                    }
 218                    else
 219                    {
 3220                        var keys = item.GetUserDataKeys();
 3221                        itemsNeedingQuery.Add((item, keys));
 222                    }
 223                }
 224            }
 225
 5226            if (itemsNeedingQuery.Count == 0)
 227            {
 3228                return result;
 229            }
 230
 231            // Build a single query for all missing items. Fetch rows by item alone so rows kept
 232            // under keys from older metadata resolve the same way as the in-memory path.
 2233            var allItemIds = itemsNeedingQuery.Select(x => x.Item.Id).ToList();
 2234            using var context = _repository.CreateDbContext();
 2235            var userDataArray = context.UserData
 2236                .AsNoTracking()
 2237                .Where(e => e.UserId.Equals(user.Id))
 2238                .WhereOneOrMany(allItemIds, e => e.ItemId)
 2239                .ToArray();
 240
 2241            var userDataByItem = userDataArray.GroupBy(e => e.ItemId).ToDictionary(g => g.Key, g => g.ToArray());
 10242            foreach (var (item, keys) in itemsNeedingQuery)
 243            {
 244                UserItemData userData;
 3245                if (userDataByItem.TryGetValue(item.Id, out var itemUserData) && itemUserData.Length > 0)
 246                {
 2247                    userData = Map(ResolveUserDataRow(item, itemUserData)!);
 248                }
 249                else
 250                {
 1251                    userData = new UserItemData { Key = keys.Count > 0 ? keys[0] : string.Empty };
 252                }
 253
 3254                result[item.Id] = userData;
 3255                var cacheKey = GetCacheKey(user.InternalId, item.Id);
 3256                _cache.AddOrUpdate(cacheKey, userData);
 257            }
 258
 2259            return result;
 2260        }
 261
 262        /// <inheritdoc />
 263        public VersionResumeData? GetResumeUserData(User user, BaseItem item)
 264        {
 6265            return GetResumeUserDataBatch([item], user).GetValueOrDefault(item.Id);
 266        }
 267
 268        /// <inheritdoc />
 269        public IReadOnlyDictionary<Guid, VersionResumeData> GetResumeUserDataBatch(IReadOnlyList<BaseItem> items, User u
 270        {
 10271            ArgumentNullException.ThrowIfNull(user);
 272
 10273            var result = new Dictionary<Guid, VersionResumeData>();
 274
 275            // Candidate primaries: a directly queried version (PrimaryVersionId set) keeps its own data.
 276            // Linked alternates are already known in memory; only the local-alternate existence check
 277            // would otherwise hit the database (one query per item via Video.HasLocalAlternateVersions),
 278            // so collect those ids and resolve them all in a single query below.
 10279            List<Video>? candidates = null;
 10280            List<Guid>? localProbeIds = null;
 38281            foreach (var item in items)
 282            {
 9283                if (item is not Video video || video.PrimaryVersionId.HasValue)
 284                {
 285                    continue;
 286                }
 287
 0288                (candidates ??= []).Add(video);
 289
 0290                if (video.LinkedAlternateVersions.Length == 0)
 291                {
 0292                    (localProbeIds ??= []).Add(video.Id);
 293                }
 294            }
 295
 10296            if (candidates is null)
 297            {
 10298                return result;
 299            }
 300
 0301            HashSet<Guid>? withLocalAlternates = null;
 0302            if (localProbeIds is not null)
 303            {
 0304                using var dbContext = _repository.CreateDbContext();
 0305                withLocalAlternates = dbContext.LinkedChildren
 0306                    .Where(lc => lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.LocalAlterna
 0307                    .WhereOneOrMany(localProbeIds, lc => lc.ParentId)
 0308                    .Select(lc => lc.ParentId)
 0309                    .Distinct()
 0310                    .ToHashSet();
 311            }
 312
 0313            List<(Guid PrimaryId, IReadOnlyList<Video> Versions)>? versionGroups = null;
 0314            List<BaseItem>? allVersions = null;
 315
 0316            foreach (var video in candidates)
 317            {
 318                // Only items that actually have alternate versions aggregate over them.
 0319                if (video.LinkedAlternateVersions.Length == 0
 0320                    && (withLocalAlternates is null || !withLocalAlternates.Contains(video.Id)))
 321                {
 322                    continue;
 323                }
 324
 0325                var versions = video.GetAllVersions();
 0326                if (versions.Count < 2)
 327                {
 328                    continue;
 329                }
 330
 0331                (versionGroups ??= []).Add((video.Id, versions));
 0332                (allVersions ??= []).AddRange(versions);
 333            }
 334
 0335            if (versionGroups is null)
 336            {
 0337                return result;
 338            }
 339
 0340            var userDataByVersion = GetUserDataBatch(allVersions!.DistinctBy(i => i.Id).ToList(), user);
 341
 0342            foreach (var (primaryId, versions) in versionGroups)
 343            {
 344                // Consider both in-progress and completed versions so a finished alternate still marks the primary as p
 0345                var resumeVersion = VersionPlaybackSelector.SelectMostRecentlyPlayed(
 0346                    versions,
 0347                    version => userDataByVersion.GetValueOrDefault(version.Id),
 0348                    data => data.PlaybackPositionTicks > 0 || data.Played);
 349
 0350                if (resumeVersion is not null)
 351                {
 0352                    result[primaryId] = new VersionResumeData(resumeVersion.Id, userDataByVersion[resumeVersion.Id]);
 353                }
 354            }
 355
 0356            return result;
 357        }
 358
 359        /// <summary>
 360        /// Gets the internal key.
 361        /// </summary>
 362        /// <returns>System.String.</returns>
 363        private static string GetCacheKey(long internalUserId, Guid itemId)
 364        {
 9365            return internalUserId.ToString(CultureInfo.InvariantCulture) + "-" + itemId.ToString("N", CultureInfo.Invari
 366        }
 367
 368        /// <inheritdoc />
 369        public UserItemData? GetUserData(User user, BaseItem item)
 370        {
 12371            ArgumentNullException.ThrowIfNull(user);
 11372            var row = ResolveUserDataRow(item, item.UserData?.Where(e => e.UserId.Equals(user.Id)));
 11373            return row is not null ? Map(row) : new UserItemData()
 11374            {
 11375                Key = item.GetUserDataKeys()[0],
 11376            };
 377        }
 378
 379        /// <summary>
 380        /// Picks the row matching the item's current user data keys, in key order, so rows left behind
 381        /// under keys from older metadata don't take priority over the rows the write path updates.
 382        /// </summary>
 383        /// <param name="item">The item whose keys to match.</param>
 384        /// <param name="rows">The candidate user data rows for a single user.</param>
 385        /// <returns>The best matching row, or <c>null</c> when there are none.</returns>
 386        private static UserData? ResolveUserDataRow(BaseItem item, IEnumerable<UserData>? rows)
 387        {
 16388            var candidates = rows?.ToList();
 16389            if (candidates is null || candidates.Count == 0)
 390            {
 10391                return null;
 392            }
 393
 26394            foreach (var key in item.GetUserDataKeys())
 395            {
 9396                var match = candidates.Find(e => string.Equals(e.CustomDataKey, key, StringComparison.Ordinal));
 9397                if (match is not null)
 398                {
 4399                    return match;
 400                }
 401            }
 402
 2403            return candidates[0];
 4404        }
 405
 406        /// <inheritdoc />
 407        public UserItemDataDto? GetUserDataDto(BaseItem item, User user)
 0408            => GetUserDataDto(item, null, user, new DtoOptions());
 409
 410        /// <inheritdoc />
 411        public UserItemDataDto? GetUserDataDto(BaseItem item, BaseItemDto? itemDto, User user, DtoOptions options)
 412        {
 6413            var userData = GetUserData(user, item);
 6414            if (userData is null)
 415            {
 0416                return null;
 417            }
 418
 6419            var dto = GetUserItemDataDto(userData, item.Id);
 420
 6421            item.FillUserDataDtoValues(dto, userData, itemDto, user, options);
 422
 423            // For an item with alternate versions, surface the most recently played version's resume point.
 6424            GetResumeUserData(user, item)?.ApplyTo(dto);
 425
 6426            return dto;
 427        }
 428
 429        /// <summary>
 430        /// Converts a UserItemData to a DTOUserItemData.
 431        /// </summary>
 432        /// <param name="data">The data.</param>
 433        /// <param name="itemId">The reference key to an Item.</param>
 434        /// <returns>DtoUserItemData.</returns>
 435        /// <exception cref="ArgumentNullException"><paramref name="data"/> is <c>null</c>.</exception>
 436        private UserItemDataDto GetUserItemDataDto(UserItemData data, Guid itemId)
 437        {
 6438            ArgumentNullException.ThrowIfNull(data);
 439
 6440            return new UserItemDataDto
 6441            {
 6442                IsFavorite = data.IsFavorite,
 6443                Likes = data.Likes,
 6444                PlaybackPositionTicks = data.PlaybackPositionTicks,
 6445                PlayCount = data.PlayCount,
 6446                Rating = data.Rating,
 6447                Played = data.Played,
 6448                LastPlayedDate = data.LastPlayedDate,
 6449                ItemId = itemId,
 6450                Key = data.Key
 6451            };
 452        }
 453
 454        /// <inheritdoc />
 455        public bool UpdatePlayState(BaseItem item, UserItemData data, long? reportedPositionTicks)
 456        {
 0457            var playedToCompletion = false;
 458
 0459            var runtimeTicks = item.GetRunTimeTicksForPlayState();
 460
 0461            var positionTicks = reportedPositionTicks ?? runtimeTicks;
 0462            var hasRuntime = runtimeTicks > 0;
 463
 464            // If a position has been reported, and if we know the duration
 0465            if (positionTicks > 0 && hasRuntime && item is not AudioBook && item is not Book)
 466            {
 0467                var pctIn = decimal.Divide(positionTicks, runtimeTicks) * 100;
 468
 0469                if (pctIn < _config.Configuration.MinResumePct)
 470                {
 471                    // ignore progress during the beginning
 0472                    positionTicks = 0;
 473                }
 0474                else if (pctIn > _config.Configuration.MaxResumePct || positionTicks >= (runtimeTicks - TimeSpan.TicksPe
 475                {
 476                    // mark as completed close to the end
 0477                    positionTicks = 0;
 0478                    data.Played = playedToCompletion = true;
 479                }
 480                else
 481                {
 482                    // Enforce MinResumeDuration
 0483                    var durationSeconds = TimeSpan.FromTicks(runtimeTicks).TotalSeconds;
 0484                    if (durationSeconds < _config.Configuration.MinResumeDurationSeconds)
 485                    {
 0486                        positionTicks = 0;
 0487                        data.Played = playedToCompletion = true;
 488                    }
 489                }
 490            }
 0491            else if (positionTicks > 0 && hasRuntime && item is AudioBook)
 492            {
 0493                var playbackPositionInMinutes = TimeSpan.FromTicks(positionTicks).TotalMinutes;
 0494                var remainingTimeInMinutes = TimeSpan.FromTicks(runtimeTicks - positionTicks).TotalMinutes;
 495
 0496                if (playbackPositionInMinutes < _config.Configuration.MinAudiobookResume)
 497                {
 498                    // ignore progress during the beginning
 0499                    positionTicks = 0;
 500                }
 0501                else if (remainingTimeInMinutes < _config.Configuration.MaxAudiobookResume || positionTicks >= runtimeTi
 502                {
 503                    // mark as completed close to the end
 0504                    positionTicks = 0;
 0505                    data.Played = playedToCompletion = true;
 506                }
 507            }
 0508            else if (!hasRuntime)
 509            {
 510                // If we don't know the runtime we'll just have to assume it was fully played
 0511                data.Played = playedToCompletion = true;
 0512                positionTicks = 0;
 513            }
 514
 0515            if (!item.SupportsPlayedStatus)
 516            {
 0517                positionTicks = 0;
 0518                data.Played = false;
 519            }
 520
 0521            if (!item.SupportsPositionTicksResume)
 522            {
 0523                positionTicks = 0;
 524            }
 525
 0526            data.PlaybackPositionTicks = positionTicks;
 527
 0528            return playedToCompletion;
 529        }
 530
 531        /// <inheritdoc />
 532        public void ResetPlaybackStreamSelections(User user, BaseItem item)
 533        {
 0534            ArgumentNullException.ThrowIfNull(user);
 0535            ArgumentNullException.ThrowIfNull(item);
 536
 0537            using var dbContext = _repository.CreateDbContext();
 0538            var rows = dbContext.UserData
 0539                .Where(e => e.ItemId == item.Id && e.UserId == user.Id
 0540                            && (e.AudioStreamIndex != null || e.SubtitleStreamIndex != null))
 0541                .ToList();
 542
 0543            if (rows.Count == 0)
 544            {
 0545                return;
 546            }
 547
 0548            foreach (var row in rows)
 549            {
 0550                row.AudioStreamIndex = null;
 0551                row.SubtitleStreamIndex = null;
 552            }
 553
 0554            dbContext.SaveChanges();
 555
 0556            var cacheKey = GetCacheKey(user.InternalId, item.Id);
 0557            if (_cache.TryGet(cacheKey, out var cached))
 558            {
 0559                cached.AudioStreamIndex = null;
 0560                cached.SubtitleStreamIndex = null;
 0561                _cache.AddOrUpdate(cacheKey, cached);
 562            }
 563
 0564            item.UserData = dbContext.UserData.Where(e => e.ItemId == item.Id).AsNoTracking().ToArray();
 0565        }
 566    }
 567}

Methods/Properties

.ctor(MediaBrowser.Controller.Configuration.IServerConfigurationManager,Microsoft.EntityFrameworkCore.IDbContextFactory`1<Jellyfin.Database.Implementations.JellyfinDbContext>)
SaveUserData(Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.UserItemData,MediaBrowser.Model.Entities.UserDataSaveReason,System.Threading.CancellationToken)
SaveUserData(Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Dto.UpdateUserItemDataDto,MediaBrowser.Model.Entities.UserDataSaveReason)
Map(MediaBrowser.Controller.Entities.UserItemData,System.Guid,System.Guid)
Map(Jellyfin.Database.Implementations.Entities.UserData)
GetUserDataBatch(System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,Jellyfin.Database.Implementations.Entities.User)
GetResumeUserData(Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem)
GetResumeUserDataBatch(System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,Jellyfin.Database.Implementations.Entities.User)
GetCacheKey(System.Int64,System.Guid)
GetUserData(Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem)
ResolveUserDataRow(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IEnumerable`1<Jellyfin.Database.Implementations.Entities.UserData>)
GetUserDataDto(MediaBrowser.Controller.Entities.BaseItem,Jellyfin.Database.Implementations.Entities.User)
GetUserDataDto(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Dto.BaseItemDto,Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Dto.DtoOptions)
GetUserItemDataDto(MediaBrowser.Controller.Entities.UserItemData,System.Guid)
UpdatePlayState(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Controller.Entities.UserItemData,System.Nullable`1<System.Int64>)
ResetPlaybackStreamSelections(Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem)