< 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: 249
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.Library;
 9using MediaBrowser.Controller.Providers;
 10using MediaBrowser.Model.Entities;
 11using MediaBrowser.Model.IO;
 12using MediaBrowser.Providers.Manager;
 13using Microsoft.Extensions.Logging;
 14
 15namespace MediaBrowser.Providers.Music
 16{
 17    /// <summary>
 18    /// The album metadata service.
 19    /// </summary>
 20    public class AlbumMetadataService : MetadataService<MusicAlbum, AlbumInfo>
 21    {
 22        /// <summary>
 23        /// Initializes a new instance of the <see cref="AlbumMetadataService"/> class.
 24        /// </summary>
 25        /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/>.</param>
 26        /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
 27        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
 28        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
 29        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
 30        public AlbumMetadataService(
 31            IServerConfigurationManager serverConfigurationManager,
 32            ILogger<AlbumMetadataService> logger,
 33            IProviderManager providerManager,
 34            IFileSystem fileSystem,
 35            ILibraryManager libraryManager)
 2136            : base(serverConfigurationManager, logger, providerManager, fileSystem, libraryManager)
 37        {
 2138        }
 39
 40        /// <inheritdoc />
 041        protected override bool EnableUpdatingPremiereDateFromChildren => true;
 42
 43        /// <inheritdoc />
 044        protected override bool EnableUpdatingGenresFromChildren => true;
 45
 46        /// <inheritdoc />
 047        protected override bool EnableUpdatingStudiosFromChildren => true;
 48
 49        /// <inheritdoc />
 50        protected override IReadOnlyList<BaseItem> GetChildrenForMetadataUpdates(MusicAlbum item)
 051            => item.GetRecursiveChildren(i => i is Audio);
 52
 53        /// <inheritdoc />
 54        protected override ItemUpdateType UpdateMetadataFromChildren(MusicAlbum item, IReadOnlyList<BaseItem> children, 
 55        {
 056            var updateType = base.UpdateMetadataFromChildren(item, children, isFullRefresh, currentUpdateType);
 57
 58            // don't update user-changeable metadata for locked items
 059            if (item.IsLocked)
 60            {
 061                return updateType;
 62            }
 63
 064            if (isFullRefresh || currentUpdateType > ItemUpdateType.None)
 65            {
 066                if (!item.LockedFields.Contains(MetadataField.Name))
 67                {
 068                    var name = children.Select(i => i.Album).FirstOrDefault(i => !string.IsNullOrEmpty(i));
 69
 070                    if (!string.IsNullOrEmpty(name)
 071                        && !string.Equals(item.Name, name, StringComparison.Ordinal))
 72                    {
 073                        item.Name = name;
 074                        updateType |= ItemUpdateType.MetadataEdit;
 75                    }
 76                }
 77
 078                var songs = children.Cast<Audio>().ToArray();
 79
 080                updateType |= SetArtistsFromSongs(item, songs);
 081                updateType |= SetAlbumArtistFromSongs(item, songs);
 082                updateType |= SetAlbumFromSongs(item, songs);
 083                updateType |= SetPeople(item);
 84            }
 85
 086            return updateType;
 87        }
 88
 89        private ItemUpdateType SetAlbumArtistFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 90        {
 091            var updateType = ItemUpdateType.None;
 92
 093            var albumArtists = songs
 094                .SelectMany(i => i.AlbumArtists)
 095                .GroupBy(i => i)
 096                .OrderByDescending(g => g.Count())
 097                .Select(g => g.Key)
 098                .ToArray();
 99
 0100            updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbumArtist);
 101
 0102            if (!item.AlbumArtists.SequenceEqual(albumArtists, StringComparer.OrdinalIgnoreCase))
 103            {
 0104                item.AlbumArtists = albumArtists;
 0105                updateType |= ItemUpdateType.MetadataEdit;
 106            }
 107
 0108            return updateType;
 109        }
 110
 111        private ItemUpdateType SetArtistsFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 112        {
 0113            var updateType = ItemUpdateType.None;
 114
 0115            var artists = songs
 0116                .SelectMany(i => i.Artists)
 0117                .GroupBy(i => i)
 0118                .OrderByDescending(g => g.Count())
 0119                .Select(g => g.Key)
 0120                .ToArray();
 121
 0122            if (!item.Artists.SequenceEqual(artists, StringComparer.OrdinalIgnoreCase))
 123            {
 0124                item.Artists = artists;
 0125                updateType |= ItemUpdateType.MetadataEdit;
 126            }
 127
 0128            return updateType;
 129        }
 130
 131        private ItemUpdateType SetAlbumFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
 132        {
 0133            var updateType = ItemUpdateType.None;
 134
 0135            updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbum);
 0136            updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzReleaseGroup);
 137
 0138            return updateType;
 139        }
 140
 141        private ItemUpdateType SetProviderIdFromSongs(BaseItem item, IReadOnlyList<Audio> songs, MetadataProvider provid
 142        {
 0143            var ids = songs
 0144                .Select(i => i.GetProviderId(provider))
 0145                .GroupBy(i => i)
 0146                .OrderByDescending(g => g.Count())
 0147                .Select(g => g.Key)
 0148                .ToArray();
 149
 0150            var id = item.GetProviderId(provider);
 0151            if (ids.Length != 0)
 152            {
 0153                var firstId = ids[0];
 0154                if (!string.IsNullOrEmpty(firstId)
 0155                    && (string.IsNullOrEmpty(id)
 0156                        || !id.Equals(firstId, StringComparison.OrdinalIgnoreCase)))
 157                {
 0158                    item.SetProviderId(provider, firstId);
 0159                    return ItemUpdateType.MetadataEdit;
 160                }
 161            }
 162
 0163            return ItemUpdateType.None;
 164        }
 165
 166        private void SetProviderId(MusicAlbum sourceItem, MusicAlbum targetItem, MetadataProvider provider)
 167        {
 0168            var source = sourceItem.GetProviderId(provider);
 0169            var target = targetItem.GetProviderId(provider);
 0170            if (!string.IsNullOrEmpty(source)
 0171                && (string.IsNullOrEmpty(target)
 0172                    || !target.Equals(source, StringComparison.Ordinal)))
 173            {
 0174                targetItem.SetProviderId(provider, source);
 175            }
 0176        }
 177
 178        private ItemUpdateType SetPeople(MusicAlbum item)
 179        {
 0180            var updateType = ItemUpdateType.None;
 181
 0182            if (item.AlbumArtists.Any() || item.Artists.Any())
 183            {
 0184                var people = new List<PersonInfo>();
 185
 0186                foreach (var albumArtist in item.AlbumArtists)
 187                {
 0188                    PeopleHelper.AddPerson(people, new PersonInfo
 0189                    {
 0190                        Name = albumArtist.Trim(),
 0191                        Type = PersonKind.AlbumArtist
 0192                    });
 193                }
 194
 0195                foreach (var artist in item.Artists)
 196                {
 0197                    PeopleHelper.AddPerson(people, new PersonInfo
 0198                    {
 0199                        Name = artist.Trim(),
 0200                        Type = PersonKind.Artist
 0201                    });
 202                }
 203
 0204                LibraryManager.UpdatePeople(item, people);
 0205                updateType |= ItemUpdateType.MetadataEdit;
 206            }
 207
 0208            return updateType;
 209        }
 210
 211        /// <inheritdoc />
 212        protected override void MergeData(
 213            MetadataResult<MusicAlbum> source,
 214            MetadataResult<MusicAlbum> target,
 215            MetadataField[] lockedFields,
 216            bool replaceData,
 217            bool mergeMetadataSettings)
 218        {
 0219            base.MergeData(source, target, lockedFields, replaceData, mergeMetadataSettings);
 220
 0221            var sourceItem = source.Item;
 0222            var targetItem = target.Item;
 223
 0224            if (replaceData || targetItem.Artists.Count == 0)
 225            {
 0226                targetItem.Artists = sourceItem.Artists;
 227            }
 228            else
 229            {
 0230                targetItem.Artists = targetItem.Artists.Concat(sourceItem.Artists).Distinct().ToArray();
 231            }
 232
 0233            if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist)))
 234            {
 0235                SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbumArtist);
 236            }
 237
 0238            if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum)))
 239            {
 0240                SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbum);
 241            }
 242
 0243            if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup)))
 244            {
 0245                SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzReleaseGroup);
 246            }
 0247        }
 248    }
 249}
Generated by: ReportGenerator 5.4.5.0
4/26/2025 - 12:11:00 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)
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)