Merge branch 'jellyfin:master' into master

1 files changed, 380 insertions, 327 deletions

diff --git a/Jellyfin.Api/Controllers/ItemUpdateController.cs b/Jellyfin.Api/Controllers/ItemUpdateController.cs
index af3d779f5..504f2fa1d 100644
--- a/Jellyfin.Api/Controllers/ItemUpdateController.cs
+++ b/Jellyfin.Api/Controllers/ItemUpdateController.cs
@@ -20,332 +20,386 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 
-namespace Jellyfin.Api.Controllers
+namespace Jellyfin.Api.Controllers;
+
+/// <summary>
+/// Item update controller.
+/// </summary>
+[Route("")]
+[Authorize(Policy = Policies.RequiresElevation)]
+public class ItemUpdateController : BaseJellyfinApiController
 {
+    private readonly ILibraryManager _libraryManager;
+    private readonly IProviderManager _providerManager;
+    private readonly ILocalizationManager _localizationManager;
+    private readonly IFileSystem _fileSystem;
+    private readonly IServerConfigurationManager _serverConfigurationManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ItemUpdateController"/> class.
+    /// </summary>
+    /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
+    /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+    /// <param name="localizationManager">Instance of the <see cref="ILocalizationManager"/> interface.</param>
+    /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
+    public ItemUpdateController(
+        IFileSystem fileSystem,
+        ILibraryManager libraryManager,
+        IProviderManager providerManager,
+        ILocalizationManager localizationManager,
+        IServerConfigurationManager serverConfigurationManager)
+    {
+        _libraryManager = libraryManager;
+        _providerManager = providerManager;
+        _localizationManager = localizationManager;
+        _fileSystem = fileSystem;
+        _serverConfigurationManager = serverConfigurationManager;
+    }
+
     /// <summary>
-    /// Item update controller.
+    /// Updates an item.
     /// </summary>
-    [Route("")]
-    [Authorize(Policy = Policies.RequiresElevation)]
-    public class ItemUpdateController : BaseJellyfinApiController
+    /// <param name="itemId">The item id.</param>
+    /// <param name="request">The new item properties.</param>
+    /// <response code="204">Item updated.</response>
+    /// <response code="404">Item not found.</response>
+    /// <returns>An <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
+    [HttpPost("Items/{itemId}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult> UpdateItem([FromRoute, Required] Guid itemId, [FromBody, Required] BaseItemDto request)
     {
-        private readonly ILibraryManager _libraryManager;
-        private readonly IProviderManager _providerManager;
-        private readonly ILocalizationManager _localizationManager;
-        private readonly IFileSystem _fileSystem;
-        private readonly IServerConfigurationManager _serverConfigurationManager;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ItemUpdateController"/> class.
-        /// </summary>
-        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
-        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
-        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
-        /// <param name="localizationManager">Instance of the <see cref="ILocalizationManager"/> interface.</param>
-        /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
-        public ItemUpdateController(
-            IFileSystem fileSystem,
-            ILibraryManager libraryManager,
-            IProviderManager providerManager,
-            ILocalizationManager localizationManager,
-            IServerConfigurationManager serverConfigurationManager)
-        {
-            _libraryManager = libraryManager;
-            _providerManager = providerManager;
-            _localizationManager = localizationManager;
-            _fileSystem = fileSystem;
-            _serverConfigurationManager = serverConfigurationManager;
+        var item = _libraryManager.GetItemById(itemId);
+        if (item is null)
+        {
+            return NotFound();
         }
 
-        /// <summary>
-        /// Updates an item.
-        /// </summary>
-        /// <param name="itemId">The item id.</param>
-        /// <param name="request">The new item properties.</param>
-        /// <response code="204">Item updated.</response>
-        /// <response code="404">Item not found.</response>
-        /// <returns>An <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
-        [HttpPost("Items/{itemId}")]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public async Task<ActionResult> UpdateItem([FromRoute, Required] Guid itemId, [FromBody, Required] BaseItemDto request)
-        {
-            var item = _libraryManager.GetItemById(itemId);
-            if (item is null)
-            {
-                return NotFound();
-            }
+        var newLockData = request.LockData ?? false;
+        var isLockedChanged = item.IsLocked != newLockData;
 
-            var newLockData = request.LockData ?? false;
-            var isLockedChanged = item.IsLocked != newLockData;
+        var series = item as Series;
+        var displayOrderChanged = series is not null && !string.Equals(
+            series.DisplayOrder ?? string.Empty,
+            request.DisplayOrder ?? string.Empty,
+            StringComparison.OrdinalIgnoreCase);
 
-            var series = item as Series;
-            var displayOrderChanged = series is not null && !string.Equals(
-                series.DisplayOrder ?? string.Empty,
-                request.DisplayOrder ?? string.Empty,
-                StringComparison.OrdinalIgnoreCase);
+        // Do this first so that metadata savers can pull the updates from the database.
+        if (request.People is not null)
+        {
+            _libraryManager.UpdatePeople(
+                item,
+                request.People.Select(x => new PersonInfo
+                {
+                    Name = x.Name,
+                    Role = x.Role,
+                    Type = x.Type
+                }).ToList());
+        }
 
-            // Do this first so that metadata savers can pull the updates from the database.
-            if (request.People is not null)
-            {
-                _libraryManager.UpdatePeople(
-                    item,
-                    request.People.Select(x => new PersonInfo
-                    {
-                        Name = x.Name,
-                        Role = x.Role,
-                        Type = x.Type
-                    }).ToList());
-            }
+        await UpdateItem(request, item).ConfigureAwait(false);
 
-            UpdateItem(request, item);
+        item.OnMetadataChanged();
 
-            item.OnMetadataChanged();
+        await item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
 
-            await item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
+        if (isLockedChanged && item.IsFolder)
+        {
+            var folder = (Folder)item;
 
-            if (isLockedChanged && item.IsFolder)
+            foreach (var child in folder.GetRecursiveChildren())
             {
-                var folder = (Folder)item;
+                child.IsLocked = newLockData;
+                await child.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
+            }
+        }
 
-                foreach (var child in folder.GetRecursiveChildren())
+        if (displayOrderChanged)
+        {
+            _providerManager.QueueRefresh(
+                series!.Id,
+                new MetadataRefreshOptions(new DirectoryService(_fileSystem))
                 {
-                    child.IsLocked = newLockData;
-                    await child.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
-                }
-            }
+                    MetadataRefreshMode = MetadataRefreshMode.FullRefresh,
+                    ImageRefreshMode = MetadataRefreshMode.FullRefresh,
+                    ReplaceAllMetadata = true
+                },
+                RefreshPriority.High);
+        }
 
-            if (displayOrderChanged)
-            {
-                _providerManager.QueueRefresh(
-                    series!.Id,
-                    new MetadataRefreshOptions(new DirectoryService(_fileSystem))
-                    {
-                        MetadataRefreshMode = MetadataRefreshMode.FullRefresh,
-                        ImageRefreshMode = MetadataRefreshMode.FullRefresh,
-                        ReplaceAllMetadata = true
-                    },
-                    RefreshPriority.High);
-            }
+        return NoContent();
+    }
 
-            return NoContent();
-        }
+    /// <summary>
+    /// Gets metadata editor info for an item.
+    /// </summary>
+    /// <param name="itemId">The item id.</param>
+    /// <response code="200">Item metadata editor returned.</response>
+    /// <response code="404">Item not found.</response>
+    /// <returns>An <see cref="OkResult"/> on success containing the metadata editor, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
+    [HttpGet("Items/{itemId}/MetadataEditor")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public ActionResult<MetadataEditorInfo> GetMetadataEditorInfo([FromRoute, Required] Guid itemId)
+    {
+        var item = _libraryManager.GetItemById(itemId);
 
-        /// <summary>
-        /// Gets metadata editor info for an item.
-        /// </summary>
-        /// <param name="itemId">The item id.</param>
-        /// <response code="200">Item metadata editor returned.</response>
-        /// <response code="404">Item not found.</response>
-        /// <returns>An <see cref="OkResult"/> on success containing the metadata editor, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
-        [HttpGet("Items/{itemId}/MetadataEditor")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult<MetadataEditorInfo> GetMetadataEditorInfo([FromRoute, Required] Guid itemId)
-        {
-            var item = _libraryManager.GetItemById(itemId);
-
-            var info = new MetadataEditorInfo
-            {
-                ParentalRatingOptions = _localizationManager.GetParentalRatings().ToArray(),
-                ExternalIdInfos = _providerManager.GetExternalIdInfos(item).ToArray(),
-                Countries = _localizationManager.GetCountries().ToArray(),
-                Cultures = _localizationManager.GetCultures().ToArray()
-            };
-
-            if (!item.IsVirtualItem
-                && item is not ICollectionFolder
-                && item is not UserView
-                && item is not AggregateFolder
-                && item is not LiveTvChannel
-                && item is not IItemByName
-                && item.SourceType == SourceType.Library)
+        var info = new MetadataEditorInfo
+        {
+            ParentalRatingOptions = _localizationManager.GetParentalRatings().ToList(),
+            ExternalIdInfos = _providerManager.GetExternalIdInfos(item).ToArray(),
+            Countries = _localizationManager.GetCountries().ToArray(),
+            Cultures = _localizationManager.GetCultures().ToArray()
+        };
+
+        if (!item.IsVirtualItem
+            && item is not ICollectionFolder
+            && item is not UserView
+            && item is not AggregateFolder
+            && item is not LiveTvChannel
+            && item is not IItemByName
+            && item.SourceType == SourceType.Library)
+        {
+            var inheritedContentType = _libraryManager.GetInheritedContentType(item);
+            var configuredContentType = _libraryManager.GetConfiguredContentType(item);
+
+            if (string.IsNullOrWhiteSpace(inheritedContentType) ||
+                !string.IsNullOrWhiteSpace(configuredContentType))
             {
-                var inheritedContentType = _libraryManager.GetInheritedContentType(item);
-                var configuredContentType = _libraryManager.GetConfiguredContentType(item);
+                info.ContentTypeOptions = GetContentTypeOptions(true).ToArray();
+                info.ContentType = configuredContentType;
 
-                if (string.IsNullOrWhiteSpace(inheritedContentType) ||
-                    !string.IsNullOrWhiteSpace(configuredContentType))
+                if (string.IsNullOrWhiteSpace(inheritedContentType)
+                    || string.Equals(inheritedContentType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
                 {
-                    info.ContentTypeOptions = GetContentTypeOptions(true).ToArray();
-                    info.ContentType = configuredContentType;
-
-                    if (string.IsNullOrWhiteSpace(inheritedContentType)
-                        || string.Equals(inheritedContentType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
-                    {
-                        info.ContentTypeOptions = info.ContentTypeOptions
-                            .Where(i => string.IsNullOrWhiteSpace(i.Value)
-                                        || string.Equals(i.Value, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
-                            .ToArray();
-                    }
+                    info.ContentTypeOptions = info.ContentTypeOptions
+                        .Where(i => string.IsNullOrWhiteSpace(i.Value)
+                                    || string.Equals(i.Value, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
+                        .ToArray();
                 }
             }
+        }
 
-            return info;
+        return info;
+    }
+
+    /// <summary>
+    /// Updates an item's content type.
+    /// </summary>
+    /// <param name="itemId">The item id.</param>
+    /// <param name="contentType">The content type of the item.</param>
+    /// <response code="204">Item content type updated.</response>
+    /// <response code="404">Item not found.</response>
+    /// <returns>An <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
+    [HttpPost("Items/{itemId}/ContentType")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public ActionResult UpdateItemContentType([FromRoute, Required] Guid itemId, [FromQuery] string? contentType)
+    {
+        var item = _libraryManager.GetItemById(itemId);
+        if (item is null)
+        {
+            return NotFound();
         }
 
-        /// <summary>
-        /// Updates an item's content type.
-        /// </summary>
-        /// <param name="itemId">The item id.</param>
-        /// <param name="contentType">The content type of the item.</param>
-        /// <response code="204">Item content type updated.</response>
-        /// <response code="404">Item not found.</response>
-        /// <returns>An <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
-        [HttpPost("Items/{itemId}/ContentType")]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult UpdateItemContentType([FromRoute, Required] Guid itemId, [FromQuery] string? contentType)
-        {
-            var item = _libraryManager.GetItemById(itemId);
-            if (item is null)
+        var path = item.ContainingFolderPath;
+
+        var types = _serverConfigurationManager.Configuration.ContentTypes
+            .Where(i => !string.IsNullOrWhiteSpace(i.Name))
+            .Where(i => !string.Equals(i.Name, path, StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        if (!string.IsNullOrWhiteSpace(contentType))
+        {
+            types.Add(new NameValuePair
             {
-                return NotFound();
-            }
+                Name = path,
+                Value = contentType
+            });
+        }
 
-            var path = item.ContainingFolderPath;
+        _serverConfigurationManager.Configuration.ContentTypes = types.ToArray();
+        _serverConfigurationManager.SaveConfiguration();
+        return NoContent();
+    }
 
-            var types = _serverConfigurationManager.Configuration.ContentTypes
-                .Where(i => !string.IsNullOrWhiteSpace(i.Name))
-                .Where(i => !string.Equals(i.Name, path, StringComparison.OrdinalIgnoreCase))
-                .ToList();
+    private async Task UpdateItem(BaseItemDto request, BaseItem item)
+    {
+        item.Name = request.Name;
+        item.ForcedSortName = request.ForcedSortName;
 
-            if (!string.IsNullOrWhiteSpace(contentType))
-            {
-                types.Add(new NameValuePair
-                {
-                    Name = path,
-                    Value = contentType
-                });
-            }
+        item.OriginalTitle = string.IsNullOrWhiteSpace(request.OriginalTitle) ? null : request.OriginalTitle;
+
+        item.CriticRating = request.CriticRating;
+
+        item.CommunityRating = request.CommunityRating;
+        item.IndexNumber = request.IndexNumber;
+        item.ParentIndexNumber = request.ParentIndexNumber;
+        item.Overview = request.Overview;
+        item.Genres = request.Genres;
 
-            _serverConfigurationManager.Configuration.ContentTypes = types.ToArray();
-            _serverConfigurationManager.SaveConfiguration();
-            return NoContent();
+        if (item is Episode episode)
+        {
+            episode.AirsAfterSeasonNumber = request.AirsAfterSeasonNumber;
+            episode.AirsBeforeEpisodeNumber = request.AirsBeforeEpisodeNumber;
+            episode.AirsBeforeSeasonNumber = request.AirsBeforeSeasonNumber;
         }
 
-        private void UpdateItem(BaseItemDto request, BaseItem item)
+        if (request.Height is not null && item is LiveTvChannel channel)
         {
-            item.Name = request.Name;
-            item.ForcedSortName = request.ForcedSortName;
+            channel.Height = request.Height.Value;
+        }
 
-            item.OriginalTitle = string.IsNullOrWhiteSpace(request.OriginalTitle) ? null : request.OriginalTitle;
+        if (request.Taglines is not null)
+        {
+            item.Tagline = request.Taglines.FirstOrDefault();
+        }
 
-            item.CriticRating = request.CriticRating;
+        if (request.Studios is not null)
+        {
+            item.Studios = request.Studios.Select(x => x.Name).ToArray();
+        }
 
-            item.CommunityRating = request.CommunityRating;
-            item.IndexNumber = request.IndexNumber;
-            item.ParentIndexNumber = request.ParentIndexNumber;
-            item.Overview = request.Overview;
-            item.Genres = request.Genres;
+        if (request.DateCreated.HasValue)
+        {
+            item.DateCreated = NormalizeDateTime(request.DateCreated.Value);
+        }
 
-            if (item is Episode episode)
-            {
-                episode.AirsAfterSeasonNumber = request.AirsAfterSeasonNumber;
-                episode.AirsBeforeEpisodeNumber = request.AirsBeforeEpisodeNumber;
-                episode.AirsBeforeSeasonNumber = request.AirsBeforeSeasonNumber;
-            }
+        item.EndDate = request.EndDate.HasValue ? NormalizeDateTime(request.EndDate.Value) : null;
+        item.PremiereDate = request.PremiereDate.HasValue ? NormalizeDateTime(request.PremiereDate.Value) : null;
+        item.ProductionYear = request.ProductionYear;
 
-            item.Tags = request.Tags;
+        request.OfficialRating = string.IsNullOrWhiteSpace(request.OfficialRating) ? null : request.OfficialRating;
+        item.OfficialRating = request.OfficialRating;
+        item.CustomRating = request.CustomRating;
 
-            if (request.Taglines is not null)
-            {
-                item.Tagline = request.Taglines.FirstOrDefault();
-            }
+        var currentTags = item.Tags;
+        var newTags = request.Tags;
+        var removedTags = currentTags.Except(newTags).ToList();
+        var addedTags = newTags.Except(currentTags).ToList();
+        item.Tags = newTags;
 
-            if (request.Studios is not null)
+        if (item is Series rseries)
+        {
+            foreach (Season season in rseries.Children)
             {
-                item.Studios = request.Studios.Select(x => x.Name).ToArray();
-            }
+                season.OfficialRating = request.OfficialRating;
+                season.CustomRating = request.CustomRating;
+                season.Tags = season.Tags.Concat(addedTags).Except(removedTags).Distinct().ToArray();
+                season.OnMetadataChanged();
+                await season.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
 
-            if (request.DateCreated.HasValue)
+                foreach (Episode ep in season.Children)
+                {
+                    ep.OfficialRating = request.OfficialRating;
+                    ep.CustomRating = request.CustomRating;
+                    ep.Tags = ep.Tags.Concat(addedTags).Except(removedTags).Distinct().ToArray();
+                    ep.OnMetadataChanged();
+                    await ep.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
+                }
+            }
+        }
+        else if (item is Season season)
+        {
+            foreach (Episode ep in season.Children)
             {
-                item.DateCreated = NormalizeDateTime(request.DateCreated.Value);
+                ep.OfficialRating = request.OfficialRating;
+                ep.CustomRating = request.CustomRating;
+                ep.Tags = ep.Tags.Concat(addedTags).Except(removedTags).Distinct().ToArray();
+                ep.OnMetadataChanged();
+                await ep.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
             }
-
-            item.EndDate = request.EndDate.HasValue ? NormalizeDateTime(request.EndDate.Value) : null;
-            item.PremiereDate = request.PremiereDate.HasValue ? NormalizeDateTime(request.PremiereDate.Value) : null;
-            item.ProductionYear = request.ProductionYear;
-            item.OfficialRating = string.IsNullOrWhiteSpace(request.OfficialRating) ? null : request.OfficialRating;
-            item.CustomRating = request.CustomRating;
-
-            if (request.ProductionLocations is not null)
+        }
+        else if (item is MusicAlbum album)
+        {
+            foreach (BaseItem track in album.Children)
             {
-                item.ProductionLocations = request.ProductionLocations;
+                track.OfficialRating = request.OfficialRating;
+                track.CustomRating = request.CustomRating;
+                track.Tags = track.Tags.Concat(addedTags).Except(removedTags).Distinct().ToArray();
+                track.OnMetadataChanged();
+                await track.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
             }
+        }
 
-            item.PreferredMetadataCountryCode = request.PreferredMetadataCountryCode;
-            item.PreferredMetadataLanguage = request.PreferredMetadataLanguage;
+        if (request.ProductionLocations is not null)
+        {
+            item.ProductionLocations = request.ProductionLocations;
+        }
 
-            if (item is IHasDisplayOrder hasDisplayOrder)
-            {
-                hasDisplayOrder.DisplayOrder = request.DisplayOrder;
-            }
+        item.PreferredMetadataCountryCode = request.PreferredMetadataCountryCode;
+        item.PreferredMetadataLanguage = request.PreferredMetadataLanguage;
 
-            if (item is IHasAspectRatio hasAspectRatio)
-            {
-                hasAspectRatio.AspectRatio = request.AspectRatio;
-            }
+        if (item is IHasDisplayOrder hasDisplayOrder)
+        {
+            hasDisplayOrder.DisplayOrder = request.DisplayOrder;
+        }
 
-            item.IsLocked = request.LockData ?? false;
+        if (item is IHasAspectRatio hasAspectRatio)
+        {
+            hasAspectRatio.AspectRatio = request.AspectRatio;
+        }
 
-            if (request.LockedFields is not null)
-            {
-                item.LockedFields = request.LockedFields;
-            }
+        item.IsLocked = request.LockData ?? false;
 
-            // Only allow this for series. Runtimes for media comes from ffprobe.
-            if (item is Series)
-            {
-                item.RunTimeTicks = request.RunTimeTicks;
-            }
+        if (request.LockedFields is not null)
+        {
+            item.LockedFields = request.LockedFields;
+        }
 
-            foreach (var pair in request.ProviderIds.ToList())
+        // Only allow this for series. Runtimes for media comes from ffprobe.
+        if (item is Series)
+        {
+            item.RunTimeTicks = request.RunTimeTicks;
+        }
+
+        foreach (var pair in request.ProviderIds.ToList())
+        {
+            if (string.IsNullOrEmpty(pair.Value))
             {
-                if (string.IsNullOrEmpty(pair.Value))
-                {
-                    request.ProviderIds.Remove(pair.Key);
-                }
+                request.ProviderIds.Remove(pair.Key);
             }
+        }
 
-            item.ProviderIds = request.ProviderIds;
+        item.ProviderIds = request.ProviderIds;
 
-            if (item is Video video)
-            {
-                video.Video3DFormat = request.Video3DFormat;
-            }
+        if (item is Video video)
+        {
+            video.Video3DFormat = request.Video3DFormat;
+        }
 
-            if (request.AlbumArtists is not null)
+        if (request.AlbumArtists is not null)
+        {
+            if (item is IHasAlbumArtist hasAlbumArtists)
             {
-                if (item is IHasAlbumArtist hasAlbumArtists)
-                {
-                    hasAlbumArtists.AlbumArtists = request
-                        .AlbumArtists
-                        .Select(i => i.Name)
-                        .ToArray();
-                }
+                hasAlbumArtists.AlbumArtists = request
+                    .AlbumArtists
+                    .Select(i => i.Name)
+                    .ToArray();
             }
+        }
 
-            if (request.ArtistItems is not null)
+        if (request.ArtistItems is not null)
+        {
+            if (item is IHasArtist hasArtists)
             {
-                if (item is IHasArtist hasArtists)
-                {
-                    hasArtists.Artists = request
-                        .ArtistItems
-                        .Select(i => i.Name)
-                        .ToArray();
-                }
+                hasArtists.Artists = request
+                    .ArtistItems
+                    .Select(i => i.Name)
+                    .ToArray();
             }
+        }
 
-            switch (item)
-            {
-                case Audio song:
-                    song.Album = request.Album;
-                    break;
-                case MusicVideo musicVideo:
-                    musicVideo.Album = request.Album;
-                    break;
-                case Series series:
+        switch (item)
+        {
+            case Audio song:
+                song.Album = request.Album;
+                break;
+            case MusicVideo musicVideo:
+                musicVideo.Album = request.Album;
+                break;
+            case Series series:
                 {
                     series.Status = GetSeriesStatus(request);
 
@@ -357,93 +411,92 @@ namespace Jellyfin.Api.Controllers
 
                     break;
                 }
-            }
         }
+    }
 
-        private SeriesStatus? GetSeriesStatus(BaseItemDto item)
+    private SeriesStatus? GetSeriesStatus(BaseItemDto item)
+    {
+        if (string.IsNullOrEmpty(item.Status))
         {
-            if (string.IsNullOrEmpty(item.Status))
-            {
-                return null;
-            }
-
-            return (SeriesStatus)Enum.Parse(typeof(SeriesStatus), item.Status, true);
+            return null;
         }
 
-        private DateTime NormalizeDateTime(DateTime val)
-        {
-            return DateTime.SpecifyKind(val, DateTimeKind.Utc);
-        }
+        return (SeriesStatus)Enum.Parse(typeof(SeriesStatus), item.Status, true);
+    }
 
-        private List<NameValuePair> GetContentTypeOptions(bool isForItem)
-        {
-            var list = new List<NameValuePair>();
+    private DateTime NormalizeDateTime(DateTime val)
+    {
+        return DateTime.SpecifyKind(val, DateTimeKind.Utc);
+    }
 
-            if (isForItem)
-            {
-                list.Add(new NameValuePair
-                {
-                    Name = "Inherit",
-                    Value = string.Empty
-                });
-            }
+    private List<NameValuePair> GetContentTypeOptions(bool isForItem)
+    {
+        var list = new List<NameValuePair>();
 
+        if (isForItem)
+        {
             list.Add(new NameValuePair
             {
-                Name = "Movies",
-                Value = "movies"
-            });
-            list.Add(new NameValuePair
-            {
-                Name = "Music",
-                Value = "music"
-            });
-            list.Add(new NameValuePair
-            {
-                Name = "Shows",
-                Value = "tvshows"
+                Name = "Inherit",
+                Value = string.Empty
             });
+        }
 
-            if (!isForItem)
-            {
-                list.Add(new NameValuePair
-                {
-                    Name = "Books",
-                    Value = "books"
-                });
-            }
+        list.Add(new NameValuePair
+        {
+            Name = "Movies",
+            Value = "movies"
+        });
+        list.Add(new NameValuePair
+        {
+            Name = "Music",
+            Value = "music"
+        });
+        list.Add(new NameValuePair
+        {
+            Name = "Shows",
+            Value = "tvshows"
+        });
 
+        if (!isForItem)
+        {
             list.Add(new NameValuePair
             {
-                Name = "HomeVideos",
-                Value = "homevideos"
-            });
-            list.Add(new NameValuePair
-            {
-                Name = "MusicVideos",
-                Value = "musicvideos"
-            });
-            list.Add(new NameValuePair
-            {
-                Name = "Photos",
-                Value = "photos"
+                Name = "Books",
+                Value = "books"
             });
+        }
 
-            if (!isForItem)
-            {
-                list.Add(new NameValuePair
-                {
-                    Name = "MixedContent",
-                    Value = string.Empty
-                });
-            }
+        list.Add(new NameValuePair
+        {
+            Name = "HomeVideos",
+            Value = "homevideos"
+        });
+        list.Add(new NameValuePair
+        {
+            Name = "MusicVideos",
+            Value = "musicvideos"
+        });
+        list.Add(new NameValuePair
+        {
+            Name = "Photos",
+            Value = "photos"
+        });
 
-            foreach (var val in list)
+        if (!isForItem)
+        {
+            list.Add(new NameValuePair
             {
-                val.Name = _localizationManager.GetLocalizedString(val.Name);
-            }
+                Name = "MixedContent",
+                Value = string.Empty
+            });
+        }
 
-            return list;
+        foreach (var val in list)
+        {
+            val.Name = _localizationManager.GetLocalizedString(val.Name);
         }
+
+        return list;
     }
 }