< Summary - Jellyfin

Information
Class: MediaBrowser.Providers.Music.AlbumMetadataService
Assembly: MediaBrowser.Providers
File(s): /srv/git/jellyfin/MediaBrowser.Providers/Music/AlbumMetadataService.cs
Line coverage
1%
Covered lines: 2
Uncovered lines: 102
Coverable lines: 104
Total lines: 266
Line coverage: 1.9%
Branch coverage
0%
Covered branches: 0
Total branches: 58
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 8/14/2025 - 12:11:05 AM Line coverage: 1.9% (2/104) Branch coverage: 0% (0/58) Total lines: 266 8/14/2025 - 12:11:05 AM Line coverage: 1.9% (2/104) Branch coverage: 0% (0/58) Total lines: 266

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_EnableUpdatingPremiereDateFromChildren()100%210%
get_EnableUpdatingGenresFromChildren()100%210%
get_EnableUpdatingStudiosFromChildren()100%210%
GetChildrenForMetadataUpdates(...)100%210%
AfterMetadataRefresh(...)100%210%
UpdateMetadataFromChildren(...)0%156120%
SetAlbumArtistFromSongs(...)0%620%
SetArtistsFromSongs(...)0%620%
SetAlbumFromSongs(...)100%210%
SetProviderIdFromSongs(...)0%7280%
SetProviderId(...)0%4260%
SetPeople(...)0%156120%
MergeData(...)0%272160%

File(s)

/srv/git/jellyfin/MediaBrowser.Providers/Music/AlbumMetadataService.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Linq;
 4using System.Threading;
 5using System.Threading.Tasks;
 6using Jellyfin.Data.Enums;
 7using MediaBrowser.Controller.Configuration;
 8using MediaBrowser.Controller.Entities;
 9using MediaBrowser.Controller.Entities.Audio;
 10using MediaBrowser.Controller.IO;
 11using MediaBrowser.Controller.Library;
 12using MediaBrowser.Controller.Persistence;
 13using MediaBrowser.Controller.Providers;
 14using MediaBrowser.Model.Entities;
 15using MediaBrowser.Model.IO;
 16using MediaBrowser.Providers.Manager;
 17using Microsoft.Extensions.Logging;
 18
 19namespace MediaBrowser.Providers.Music;
 20
 21/// <summary>
 22/// The album metadata service.
 23/// </summary>
 24public class AlbumMetadataService : MetadataService<MusicAlbum, AlbumInfo>
 25{
 26    /// <summary>
 27    /// Initializes a new instance of the <see cref="AlbumMetadataService"/> class.
 28    /// </summary>
 29    /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/>.</param>
 30    /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
 31    /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
 32    /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
 33    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
 34    /// <param name="externalDataManager">Instance of the <see cref="IExternalDataManager"/> interface.</param>
 35    /// <param name="itemRepository">Instance of the <see cref="IItemRepository"/> interface.</param>
 36    public AlbumMetadataService(
 37        IServerConfigurationManager serverConfigurationManager,
 38        ILogger<AlbumMetadataService> logger,
 39        IProviderManager providerManager,
 40        IFileSystem fileSystem,
 41        ILibraryManager libraryManager,
 42        IExternalDataManager externalDataManager,
 43        IItemRepository itemRepository)
 2144        : base(serverConfigurationManager, logger, providerManager, fileSystem, libraryManager, externalDataManager, ite
 45    {
 2146    }
 47
 48    /// <inheritdoc />
 049    protected override bool EnableUpdatingPremiereDateFromChildren => true;
 50
 51    /// <inheritdoc />
 052    protected override bool EnableUpdatingGenresFromChildren => true;
 53
 54    /// <inheritdoc />
 055    protected override bool EnableUpdatingStudiosFromChildren => true;
 56
 57    /// <inheritdoc />
 58    protected override IReadOnlyList<BaseItem> GetChildrenForMetadataUpdates(MusicAlbum item)
 059        => item.GetRecursiveChildren(i => i is Audio);
 60
 61    /// <inheritdoc />
 62    protected override Task AfterMetadataRefresh(MusicAlbum item, MetadataRefreshOptions refreshOptions, CancellationTok
 63    {
 064        base.AfterMetadataRefresh(item, refreshOptions, cancellationToken);
 65
 066        SetPeople(item);
 67
 068        return Task.CompletedTask;
 69    }
 70
 71    /// <inheritdoc />
 72    protected override ItemUpdateType UpdateMetadataFromChildren(MusicAlbum item, IReadOnlyList<BaseItem> children, bool
 73    {
 074        var updateType = base.UpdateMetadataFromChildren(item, children, isFullRefresh, currentUpdateType);
 75
 76        // don't update user-changeable metadata for locked items
 077        if (item.IsLocked)
 78        {
 079            return updateType;
 80        }
 81
 082        if (isFullRefresh || currentUpdateType > ItemUpdateType.None)
 83        {
 084            if (!item.LockedFields.Contains(MetadataField.Name))
 85            {
 086                var name = children.Select(i => i.Album).FirstOrDefault(i => !string.IsNullOrEmpty(i));
 87
 088                if (!string.IsNullOrEmpty(name)
 089                    && !string.Equals(item.Name, name, StringComparison.Ordinal))
 90                {
 091                    item.Name = name;
 092                    updateType |= ItemUpdateType.MetadataEdit;
 93                }
 94            }
 95
 096            var songs = children.Cast<Audio>().ToArray();
 97
 098            updateType |= SetArtistsFromSongs(item, songs);
 099            updateType |= SetAlbumArtistFromSongs(item, songs);
 0100            updateType |= SetAlbumFromSongs(item, songs);
 101        }
 102
 0103        return updateType;
 104    }
 105
 106    private ItemUpdateType SetAlbumArtistFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 107    {
 0108        var updateType = ItemUpdateType.None;
 109
 0110        var albumArtists = songs
 0111            .SelectMany(i => i.AlbumArtists)
 0112            .GroupBy(i => i, StringComparer.OrdinalIgnoreCase)
 0113            .OrderByDescending(g => g.Count())
 0114            .Select(g => g.Key)
 0115            .ToArray();
 116
 0117        updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbumArtist);
 118
 0119        if (!item.AlbumArtists.SequenceEqual(albumArtists, StringComparer.Ordinal))
 120        {
 0121            item.AlbumArtists = albumArtists;
 0122            updateType |= ItemUpdateType.MetadataEdit;
 123        }
 124
 0125        return updateType;
 126    }
 127
 128    private ItemUpdateType SetArtistsFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 129    {
 0130        var updateType = ItemUpdateType.None;
 131
 0132        var artists = songs
 0133            .SelectMany(i => i.Artists)
 0134            .GroupBy(i => i, StringComparer.OrdinalIgnoreCase)
 0135            .OrderByDescending(g => g.Count())
 0136            .Select(g => g.Key)
 0137            .ToArray();
 138
 0139        if (!item.Artists.SequenceEqual(artists, StringComparer.Ordinal))
 140        {
 0141            item.Artists = artists;
 0142            updateType |= ItemUpdateType.MetadataEdit;
 143        }
 144
 0145        return updateType;
 146    }
 147
 148    private ItemUpdateType SetAlbumFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 149    {
 0150        var updateType = ItemUpdateType.None;
 151
 0152        updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbum);
 0153        updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzReleaseGroup);
 154
 0155        return updateType;
 156    }
 157
 158    private ItemUpdateType SetProviderIdFromSongs(BaseItem item, IReadOnlyList<Audio> songs, MetadataProvider provider)
 159    {
 0160        var ids = songs
 0161            .Select(i => i.GetProviderId(provider))
 0162            .GroupBy(i => i)
 0163            .OrderByDescending(g => g.Count())
 0164            .Select(g => g.Key)
 0165            .ToArray();
 166
 0167        var id = item.GetProviderId(provider);
 0168        if (ids.Length != 0)
 169        {
 0170            var firstId = ids[0];
 0171            if (!string.IsNullOrEmpty(firstId)
 0172                && (string.IsNullOrEmpty(id)
 0173                    || !id.Equals(firstId, StringComparison.OrdinalIgnoreCase)))
 174            {
 0175                item.SetProviderId(provider, firstId);
 0176                return ItemUpdateType.MetadataEdit;
 177            }
 178        }
 179
 0180        return ItemUpdateType.None;
 181    }
 182
 183    private void SetProviderId(MusicAlbum sourceItem, MusicAlbum targetItem, MetadataProvider provider)
 184    {
 0185        var source = sourceItem.GetProviderId(provider);
 0186        var target = targetItem.GetProviderId(provider);
 0187        if (!string.IsNullOrEmpty(source)
 0188            && (string.IsNullOrEmpty(target)
 0189                || !target.Equals(source, StringComparison.Ordinal)))
 190        {
 0191            targetItem.SetProviderId(provider, source);
 192        }
 0193    }
 194
 195    private void SetPeople(MusicAlbum item)
 196    {
 0197        if (item.AlbumArtists.Any() || item.Artists.Any())
 198        {
 0199            var people = new List<PersonInfo>();
 200
 0201            foreach (var albumArtist in item.AlbumArtists)
 202            {
 0203                if (!string.IsNullOrWhiteSpace(albumArtist))
 204                {
 0205                    PeopleHelper.AddPerson(people, new PersonInfo
 0206                    {
 0207                        Name = albumArtist,
 0208                        Type = PersonKind.AlbumArtist
 0209                    });
 210                }
 211            }
 212
 0213            foreach (var artist in item.Artists)
 214            {
 0215                if (!string.IsNullOrWhiteSpace(artist))
 216                {
 0217                    PeopleHelper.AddPerson(people, new PersonInfo
 0218                    {
 0219                        Name = artist,
 0220                        Type = PersonKind.Artist
 0221                    });
 222                }
 223            }
 224
 0225            LibraryManager.UpdatePeople(item, people);
 226        }
 0227    }
 228
 229    /// <inheritdoc />
 230    protected override void MergeData(
 231        MetadataResult<MusicAlbum> source,
 232        MetadataResult<MusicAlbum> target,
 233        MetadataField[] lockedFields,
 234        bool replaceData,
 235        bool mergeMetadataSettings)
 236    {
 0237        base.MergeData(source, target, lockedFields, replaceData, mergeMetadataSettings);
 238
 0239        var sourceItem = source.Item;
 0240        var targetItem = target.Item;
 241
 0242        if (replaceData || targetItem.Artists.Count == 0)
 243        {
 0244            targetItem.Artists = sourceItem.Artists;
 245        }
 246        else
 247        {
 0248            targetItem.Artists = targetItem.Artists.Concat(sourceItem.Artists).Distinct(StringComparer.OrdinalIgnoreCase
 249        }
 250
 0251        if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist)))
 252        {
 0253            SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbumArtist);
 254        }
 255
 0256        if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum)))
 257        {
 0258            SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbum);
 259        }
 260
 0261        if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup)))
 262        {
 0263            SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzReleaseGroup);
 264        }
 0265    }
 266}
Generated by: ReportGenerator 5.4.18.0
11/22/2025 - 12:10:02 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Controller.Configuration.IServerConfigurationManager,Microsoft.Extensions.Logging.ILogger`1<MediaBrowser.Providers.Music.AlbumMetadataService>,MediaBrowser.Controller.Providers.IProviderManager,MediaBrowser.Model.IO.IFileSystem,MediaBrowser.Controller.Library.ILibraryManager,MediaBrowser.Controller.IO.IExternalDataManager,MediaBrowser.Controller.Persistence.IItemRepository)
get_EnableUpdatingPremiereDateFromChildren()
get_EnableUpdatingGenresFromChildren()
get_EnableUpdatingStudiosFromChildren()
GetChildrenForMetadataUpdates(MediaBrowser.Controller.Entities.Audio.MusicAlbum)
AfterMetadataRefresh(MediaBrowser.Controller.Entities.Audio.MusicAlbum,MediaBrowser.Controller.Providers.MetadataRefreshOptions,System.Threading.CancellationToken)
UpdateMetadataFromChildren(MediaBrowser.Controller.Entities.Audio.MusicAlbum,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.BaseItem>,System.Boolean,MediaBrowser.Controller.Library.ItemUpdateType)
SetAlbumArtistFromSongs(MediaBrowser.Controller.Entities.Audio.MusicAlbum,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.Audio.Audio>)
SetArtistsFromSongs(MediaBrowser.Controller.Entities.Audio.MusicAlbum,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.Audio.Audio>)
SetAlbumFromSongs(MediaBrowser.Controller.Entities.Audio.MusicAlbum,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.Audio.Audio>)
SetProviderIdFromSongs(MediaBrowser.Controller.Entities.BaseItem,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Controller.Entities.Audio.Audio>,MediaBrowser.Model.Entities.MetadataProvider)
SetProviderId(MediaBrowser.Controller.Entities.Audio.MusicAlbum,MediaBrowser.Controller.Entities.Audio.MusicAlbum,MediaBrowser.Model.Entities.MetadataProvider)
SetPeople(MediaBrowser.Controller.Entities.Audio.MusicAlbum)
MergeData(MediaBrowser.Controller.Providers.MetadataResult`1<MediaBrowser.Controller.Entities.Audio.MusicAlbum>,MediaBrowser.Controller.Providers.MetadataResult`1<MediaBrowser.Controller.Entities.Audio.MusicAlbum>,MediaBrowser.Model.Entities.MetadataField[],System.Boolean,System.Boolean)