< 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: 100
Coverable lines: 102
Total lines: 251
Line coverage: 1.9%
Branch coverage
0%
Covered branches: 0
Total branches: 54
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%
get_EnableUpdatingPremiereDateFromChildren()100%210%
get_EnableUpdatingGenresFromChildren()100%210%
get_EnableUpdatingStudiosFromChildren()100%210%
GetChildrenForMetadataUpdates(...)100%210%
UpdateMetadataFromChildren(...)0%156120%
SetAlbumArtistFromSongs(...)0%620%
SetArtistsFromSongs(...)0%620%
SetAlbumFromSongs(...)100%210%
SetProviderIdFromSongs(...)0%7280%
SetProviderId(...)0%4260%
SetPeople(...)0%7280%
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 Jellyfin.Data.Enums;
 5using MediaBrowser.Controller.Configuration;
 6using MediaBrowser.Controller.Entities;
 7using MediaBrowser.Controller.Entities.Audio;
 8using MediaBrowser.Controller.IO;
 9using MediaBrowser.Controller.Library;
 10using MediaBrowser.Controller.Providers;
 11using MediaBrowser.Model.Entities;
 12using MediaBrowser.Model.IO;
 13using MediaBrowser.Providers.Manager;
 14using Microsoft.Extensions.Logging;
 15
 16namespace MediaBrowser.Providers.Music;
 17
 18/// <summary>
 19/// The album metadata service.
 20/// </summary>
 21public class AlbumMetadataService : MetadataService<MusicAlbum, AlbumInfo>
 22{
 23    /// <summary>
 24    /// Initializes a new instance of the <see cref="AlbumMetadataService"/> class.
 25    /// </summary>
 26    /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/>.</param>
 27    /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
 28    /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
 29    /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
 30    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
 31    /// <param name="externalDataManager">Instance of the <see cref="IExternalDataManager"/> interface.</param>
 32    public AlbumMetadataService(
 33        IServerConfigurationManager serverConfigurationManager,
 34        ILogger<AlbumMetadataService> logger,
 35        IProviderManager providerManager,
 36        IFileSystem fileSystem,
 37        ILibraryManager libraryManager,
 38        IExternalDataManager externalDataManager)
 2139        : base(serverConfigurationManager, logger, providerManager, fileSystem, libraryManager, externalDataManager)
 40    {
 2141    }
 42
 43    /// <inheritdoc />
 044    protected override bool EnableUpdatingPremiereDateFromChildren => true;
 45
 46    /// <inheritdoc />
 047    protected override bool EnableUpdatingGenresFromChildren => true;
 48
 49    /// <inheritdoc />
 050    protected override bool EnableUpdatingStudiosFromChildren => true;
 51
 52    /// <inheritdoc />
 53    protected override IReadOnlyList<BaseItem> GetChildrenForMetadataUpdates(MusicAlbum item)
 054        => item.GetRecursiveChildren(i => i is Audio);
 55
 56    /// <inheritdoc />
 57    protected override ItemUpdateType UpdateMetadataFromChildren(MusicAlbum item, IReadOnlyList<BaseItem> children, bool
 58    {
 059        var updateType = base.UpdateMetadataFromChildren(item, children, isFullRefresh, currentUpdateType);
 60
 61        // don't update user-changeable metadata for locked items
 062        if (item.IsLocked)
 63        {
 064            return updateType;
 65        }
 66
 067        if (isFullRefresh || currentUpdateType > ItemUpdateType.None)
 68        {
 069            if (!item.LockedFields.Contains(MetadataField.Name))
 70            {
 071                var name = children.Select(i => i.Album).FirstOrDefault(i => !string.IsNullOrEmpty(i));
 72
 073                if (!string.IsNullOrEmpty(name)
 074                    && !string.Equals(item.Name, name, StringComparison.Ordinal))
 75                {
 076                    item.Name = name;
 077                    updateType |= ItemUpdateType.MetadataEdit;
 78                }
 79            }
 80
 081            var songs = children.Cast<Audio>().ToArray();
 82
 083            updateType |= SetArtistsFromSongs(item, songs);
 084            updateType |= SetAlbumArtistFromSongs(item, songs);
 085            updateType |= SetAlbumFromSongs(item, songs);
 086            updateType |= SetPeople(item);
 87        }
 88
 089        return updateType;
 90    }
 91
 92    private ItemUpdateType SetAlbumArtistFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 93    {
 094        var updateType = ItemUpdateType.None;
 95
 096        var albumArtists = songs
 097            .SelectMany(i => i.AlbumArtists)
 098            .GroupBy(i => i)
 099            .OrderByDescending(g => g.Count())
 0100            .Select(g => g.Key)
 0101            .ToArray();
 102
 0103        updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbumArtist);
 104
 0105        if (!item.AlbumArtists.SequenceEqual(albumArtists, StringComparer.OrdinalIgnoreCase))
 106        {
 0107            item.AlbumArtists = albumArtists;
 0108            updateType |= ItemUpdateType.MetadataEdit;
 109        }
 110
 0111        return updateType;
 112    }
 113
 114    private ItemUpdateType SetArtistsFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 115    {
 0116        var updateType = ItemUpdateType.None;
 117
 0118        var artists = songs
 0119            .SelectMany(i => i.Artists)
 0120            .GroupBy(i => i)
 0121            .OrderByDescending(g => g.Count())
 0122            .Select(g => g.Key)
 0123            .ToArray();
 124
 0125        if (!item.Artists.SequenceEqual(artists, StringComparer.OrdinalIgnoreCase))
 126        {
 0127            item.Artists = artists;
 0128            updateType |= ItemUpdateType.MetadataEdit;
 129        }
 130
 0131        return updateType;
 132    }
 133
 134    private ItemUpdateType SetAlbumFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 135    {
 0136        var updateType = ItemUpdateType.None;
 137
 0138        updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbum);
 0139        updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzReleaseGroup);
 140
 0141        return updateType;
 142    }
 143
 144    private ItemUpdateType SetProviderIdFromSongs(BaseItem item, IReadOnlyList<Audio> songs, MetadataProvider provider)
 145    {
 0146        var ids = songs
 0147            .Select(i => i.GetProviderId(provider))
 0148            .GroupBy(i => i)
 0149            .OrderByDescending(g => g.Count())
 0150            .Select(g => g.Key)
 0151            .ToArray();
 152
 0153        var id = item.GetProviderId(provider);
 0154        if (ids.Length != 0)
 155        {
 0156            var firstId = ids[0];
 0157            if (!string.IsNullOrEmpty(firstId)
 0158                && (string.IsNullOrEmpty(id)
 0159                    || !id.Equals(firstId, StringComparison.OrdinalIgnoreCase)))
 160            {
 0161                item.SetProviderId(provider, firstId);
 0162                return ItemUpdateType.MetadataEdit;
 163            }
 164        }
 165
 0166        return ItemUpdateType.None;
 167    }
 168
 169    private void SetProviderId(MusicAlbum sourceItem, MusicAlbum targetItem, MetadataProvider provider)
 170    {
 0171        var source = sourceItem.GetProviderId(provider);
 0172        var target = targetItem.GetProviderId(provider);
 0173        if (!string.IsNullOrEmpty(source)
 0174            && (string.IsNullOrEmpty(target)
 0175                || !target.Equals(source, StringComparison.Ordinal)))
 176        {
 0177            targetItem.SetProviderId(provider, source);
 178        }
 0179    }
 180
 181    private ItemUpdateType SetPeople(MusicAlbum item)
 182    {
 0183        var updateType = ItemUpdateType.None;
 184
 0185        if (item.AlbumArtists.Any() || item.Artists.Any())
 186        {
 0187            var people = new List<PersonInfo>();
 188
 0189            foreach (var albumArtist in item.AlbumArtists)
 190            {
 0191                PeopleHelper.AddPerson(people, new PersonInfo
 0192                {
 0193                    Name = albumArtist.Trim(),
 0194                    Type = PersonKind.AlbumArtist
 0195                });
 196            }
 197
 0198            foreach (var artist in item.Artists)
 199            {
 0200                PeopleHelper.AddPerson(people, new PersonInfo
 0201                {
 0202                    Name = artist.Trim(),
 0203                    Type = PersonKind.Artist
 0204                });
 205            }
 206
 0207            LibraryManager.UpdatePeople(item, people);
 0208            updateType |= ItemUpdateType.MetadataEdit;
 209        }
 210
 0211        return updateType;
 212    }
 213
 214    /// <inheritdoc />
 215    protected override void MergeData(
 216        MetadataResult<MusicAlbum> source,
 217        MetadataResult<MusicAlbum> target,
 218        MetadataField[] lockedFields,
 219        bool replaceData,
 220        bool mergeMetadataSettings)
 221    {
 0222        base.MergeData(source, target, lockedFields, replaceData, mergeMetadataSettings);
 223
 0224        var sourceItem = source.Item;
 0225        var targetItem = target.Item;
 226
 0227        if (replaceData || targetItem.Artists.Count == 0)
 228        {
 0229            targetItem.Artists = sourceItem.Artists;
 230        }
 231        else
 232        {
 0233            targetItem.Artists = targetItem.Artists.Concat(sourceItem.Artists).Distinct(StringComparer.OrdinalIgnoreCase
 234        }
 235
 0236        if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist)))
 237        {
 0238            SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbumArtist);
 239        }
 240
 0241        if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum)))
 242        {
 0243            SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbum);
 244        }
 245
 0246        if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup)))
 247        {
 0248            SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzReleaseGroup);
 249        }
 0250    }
 251}
Generated by: ReportGenerator 5.4.7.0
5/17/2025 - 12:09:41 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)
get_EnableUpdatingPremiereDateFromChildren()
get_EnableUpdatingGenresFromChildren()
get_EnableUpdatingStudiosFromChildren()
GetChildrenForMetadataUpdates(MediaBrowser.Controller.Entities.Audio.MusicAlbum)
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)