< Summary - Jellyfin

Information
Class: MediaBrowser.XbmcMetadata.Parsers.BaseNfoParser<T>
Assembly: MediaBrowser.XbmcMetadata
File(s): /srv/git/jellyfin/MediaBrowser.XbmcMetadata/Parsers/BaseNfoParser.cs
Line coverage
85%
Covered lines: 362
Uncovered lines: 63
Coverable lines: 425
Total lines: 1019
Line coverage: 85.1%
Branch coverage
91%
Covered branches: 432
Total branches: 472
Branch coverage: 91.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 7/13/2025 - 12:11:30 AM Line coverage: 86.3% (361/418) Branch coverage: 91.9% (425/462) Total lines: 99510/12/2025 - 12:11:07 AM Line coverage: 86.4% (365/422) Branch coverage: 92% (429/466) Total lines: 100710/14/2025 - 12:11:23 AM Line coverage: 85.1% (362/425) Branch coverage: 91.5% (432/472) Total lines: 1019 7/13/2025 - 12:11:30 AM Line coverage: 86.3% (361/418) Branch coverage: 91.9% (425/462) Total lines: 99510/12/2025 - 12:11:07 AM Line coverage: 86.4% (365/422) Branch coverage: 92% (429/466) Total lines: 100710/14/2025 - 12:11:23 AM Line coverage: 85.1% (362/425) Branch coverage: 91.5% (432/472) Total lines: 1019

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_SupportsUrlAfterClosingXmlTag()100%11100%
Fetch(...)100%44100%
Fetch(...)95%202092.68%
ParseProviderLinks(...)91.66%121290.9%
FetchDataFromXmlNode(...)93.5%85630882.06%
FetchThumbNode(...)95.45%222296.42%
FetchFromFileInfoNode(...)80%111080%
FetchFromStreamDetailsNode(...)91.66%121288.23%
FetchFromVideoNode(...)70%633066.66%
FetchFromSubtitleNode(...)83.33%131282.35%
FetchFromRatingsNode(...)75%161270%
FetchFromRatingNode(...)100%1818100%
GetXmlReaderSettings()100%11100%
GetImageType(...)100%1212100%

File(s)

/srv/git/jellyfin/MediaBrowser.XbmcMetadata/Parsers/BaseNfoParser.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Globalization;
 4using System.IO;
 5using System.Linq;
 6using System.Text;
 7using System.Threading;
 8using System.Xml;
 9using Jellyfin.Data.Enums;
 10using Jellyfin.Extensions;
 11using MediaBrowser.Common.Configuration;
 12using MediaBrowser.Common.Providers;
 13using MediaBrowser.Controller.Entities;
 14using MediaBrowser.Controller.Entities.Movies;
 15using MediaBrowser.Controller.Entities.TV;
 16using MediaBrowser.Controller.Extensions;
 17using MediaBrowser.Controller.Library;
 18using MediaBrowser.Controller.Providers;
 19using MediaBrowser.Model.Entities;
 20using MediaBrowser.XbmcMetadata.Configuration;
 21using MediaBrowser.XbmcMetadata.Savers;
 22using Microsoft.Extensions.Logging;
 23
 24namespace MediaBrowser.XbmcMetadata.Parsers
 25{
 26    /// <summary>
 27    /// The BaseNfoParser class.
 28    /// </summary>
 29    /// <typeparam name="T">The type.</typeparam>
 30    public class BaseNfoParser<T>
 31        where T : BaseItem
 32    {
 33        private readonly IConfigurationManager _config;
 34        private readonly IUserManager _userManager;
 35        private readonly IUserDataManager _userDataManager;
 36        private readonly IDirectoryService _directoryService;
 37        private Dictionary<string, string> _validProviderIds;
 38
 39        /// <summary>
 40        /// Initializes a new instance of the <see cref="BaseNfoParser{T}" /> class.
 41        /// </summary>
 42        /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
 43        /// <param name="config">Instance of the <see cref="IConfigurationManager"/> interface.</param>
 44        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
 45        /// <param name="userManager">Instance of the <see cref="IUserManager"/> interface.</param>
 46        /// <param name="userDataManager">Instance of the <see cref="IUserDataManager"/> interface.</param>
 47        /// <param name="directoryService">Instance of the <see cref="IDirectoryService"/> interface.</param>
 48        public BaseNfoParser(
 49            ILogger logger,
 50            IConfigurationManager config,
 51            IProviderManager providerManager,
 52            IUserManager userManager,
 53            IUserDataManager userDataManager,
 54            IDirectoryService directoryService)
 55        {
 3156            Logger = logger;
 3157            _config = config;
 3158            ProviderManager = providerManager;
 3159            _validProviderIds = new Dictionary<string, string>();
 3160            _userManager = userManager;
 3161            _userDataManager = userDataManager;
 3162            _directoryService = directoryService;
 3163        }
 64
 65        /// <summary>
 66        /// Gets the logger.
 67        /// </summary>
 68        protected ILogger Logger { get; }
 69
 70        /// <summary>
 71        /// Gets the provider manager.
 72        /// </summary>
 73        protected IProviderManager ProviderManager { get; }
 74
 75        /// <summary>
 76        /// Gets a value indicating whether URLs after a closing XML tag are supported.
 77        /// </summary>
 378        protected virtual bool SupportsUrlAfterClosingXmlTag => false;
 79
 80        /// <summary>
 81        /// Fetches metadata for an item from one xml file.
 82        /// </summary>
 83        /// <param name="item">The <see cref="MetadataResult{T}"/>.</param>
 84        /// <param name="metadataFile">The metadata file.</param>
 85        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
 86        /// <exception cref="ArgumentNullException"><c>item</c> is <c>null</c>.</exception>
 87        /// <exception cref="ArgumentException"><c>metadataFile</c> is <c>null</c> or empty.</exception>
 88        public void Fetch(MetadataResult<T> item, string metadataFile, CancellationToken cancellationToken)
 89        {
 3190            if (item.Item is null)
 91            {
 792                throw new ArgumentException("Item can't be null.", nameof(item));
 93            }
 94
 2495            ArgumentException.ThrowIfNullOrEmpty(metadataFile);
 96
 1797            _validProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 98
 1799            var idInfos = ProviderManager.GetExternalIdInfos(item.Item);
 100
 60101            foreach (var info in idInfos)
 102            {
 13103                var id = info.Key + "Id";
 13104                _validProviderIds.TryAdd(id, info.Key);
 105            }
 106
 107            // Additional Mappings
 17108            _validProviderIds.Add("collectionnumber", "TmdbCollection");
 17109            _validProviderIds.Add("tmdbcolid", "TmdbCollection");
 17110            _validProviderIds.Add("tmdbcol", "TmdbCollection");
 17111            _validProviderIds.Add("imdb_id", "Imdb");
 112
 17113            Fetch(item, metadataFile, GetXmlReaderSettings(), cancellationToken);
 17114        }
 115
 116        /// <summary>
 117        /// Fetches the specified item.
 118        /// </summary>
 119        /// <param name="item">The <see cref="MetadataResult{T}"/>.</param>
 120        /// <param name="metadataFile">The metadata file.</param>
 121        /// <param name="settings">The <see cref="XmlReaderSettings"/>.</param>
 122        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
 123        protected virtual void Fetch(MetadataResult<T> item, string metadataFile, XmlReaderSettings settings, Cancellati
 124        {
 13125            if (!SupportsUrlAfterClosingXmlTag)
 126            {
 3127                using (var fileStream = File.OpenRead(metadataFile))
 3128                using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
 3129                using (var reader = XmlReader.Create(streamReader, settings))
 130                {
 3131                    item.ResetPeople();
 132
 3133                    reader.MoveToContent();
 3134                    reader.Read();
 135
 136                    // Loop through each element
 187137                    while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 138                    {
 184139                        cancellationToken.ThrowIfCancellationRequested();
 140
 184141                        if (reader.NodeType == XmlNodeType.Element)
 142                        {
 82143                            FetchDataFromXmlNode(reader, item);
 144                        }
 145                        else
 146                        {
 102147                            reader.Read();
 148                        }
 149                    }
 3150                }
 151
 3152                return;
 153            }
 154
 10155            item.ResetPeople();
 156
 157            // Need to handle a url after the xml data
 158            // http://kodi.wiki/view/NFO_files/movies
 159
 10160            var xml = File.ReadAllText(metadataFile);
 161
 162            // Find last closing Tag
 163            // Need to do this in two steps to account for random > characters after the closing xml
 10164            var index = xml.LastIndexOf("</", StringComparison.Ordinal);
 165
 166            // If closing tag exists, move to end of Tag
 10167            if (index != -1)
 168            {
 6169                index = xml.IndexOf('>', index);
 170            }
 171
 10172            if (index != -1)
 173            {
 6174                var endingXml = xml.AsSpan().Slice(index);
 175
 6176                ParseProviderLinks(item.Item, endingXml);
 177
 178                // If the file is just an IMDb url, don't go any further
 6179                if (index == 0)
 180                {
 0181                    return;
 182                }
 183
 6184                xml = xml.Substring(0, index + 1);
 185            }
 186            else
 187            {
 188                // If the file is just provider urls, handle that
 4189                ParseProviderLinks(item.Item, xml);
 190
 4191                return;
 192            }
 193
 194            // These are not going to be valid xml so no sense in causing the provider to fail and spamming the log with
 195            try
 196            {
 6197                using (var stringReader = new StringReader(xml))
 6198                using (var reader = XmlReader.Create(stringReader, settings))
 199                {
 6200                    reader.MoveToContent();
 6201                    reader.Read();
 202
 203                    // Loop through each element
 617204                    while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 205                    {
 611206                        cancellationToken.ThrowIfCancellationRequested();
 207
 611208                        if (reader.NodeType == XmlNodeType.Element)
 209                        {
 285210                            FetchDataFromXmlNode(reader, item);
 211                        }
 212                        else
 213                        {
 326214                            reader.Read();
 215                        }
 216                    }
 6217                }
 6218            }
 0219            catch (XmlException)
 220            {
 0221            }
 6222        }
 223
 224        /// <summary>
 225        /// Parses a XML tag to a provider id.
 226        /// </summary>
 227        /// <param name="item">The item.</param>
 228        /// <param name="xml">The xml tag.</param>
 229        protected void ParseProviderLinks(T item, ReadOnlySpan<char> xml)
 230        {
 10231            if (ProviderIdParsers.TryFindImdbId(xml, out var imdbId))
 232            {
 2233                item.SetProviderId(MetadataProvider.Imdb, imdbId.ToString());
 234            }
 235
 10236            if (item is Movie)
 237            {
 7238                if (ProviderIdParsers.TryFindTmdbMovieId(xml, out var tmdbId))
 239                {
 2240                    item.SetProviderId(MetadataProvider.Tmdb, tmdbId.ToString());
 241                }
 242            }
 243
 10244            if (item is Series)
 245            {
 2246                if (ProviderIdParsers.TryFindTmdbSeriesId(xml, out var tmdbId))
 247                {
 0248                    item.SetProviderId(MetadataProvider.Tmdb, tmdbId.ToString());
 249                }
 250
 2251                if (ProviderIdParsers.TryFindTvdbId(xml, out var tvdbId))
 252                {
 1253                    item.SetProviderId(MetadataProvider.Tvdb, tvdbId.ToString());
 254                }
 255            }
 10256        }
 257
 258        /// <summary>
 259        /// Fetches metadata from an XML node.
 260        /// </summary>
 261        /// <param name="reader">The <see cref="XmlReader"/>.</param>
 262        /// <param name="itemResult">The <see cref="MetadataResult{T}"/>.</param>
 263        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult<T> itemResult)
 264        {
 449265            var item = itemResult.Item;
 449266            var nfoConfiguration = _config.GetNfoConfiguration();
 267            UserItemData? userData;
 268
 449269            switch (reader.Name)
 270            {
 271                case "dateadded":
 5272                    if (reader.TryReadDateTime(out var dateCreated))
 273                    {
 5274                        item.DateCreated = dateCreated;
 275                    }
 276
 5277                    break;
 278                case "originaltitle":
 8279                    item.OriginalTitle = reader.ReadNormalizedString();
 8280                    break;
 281                case "name":
 282                case "title":
 283                case "localtitle":
 15284                    item.Name = reader.ReadNormalizedString();
 15285                    break;
 286                case "sortname":
 1287                    item.SortName = reader.ReadNormalizedString();
 1288                    break;
 289                case "criticrating":
 1290                    var criticRatingText = reader.ReadElementContentAsString();
 1291                    if (float.TryParse(criticRatingText, CultureInfo.InvariantCulture, out var value))
 292                    {
 1293                        item.CriticRating = value;
 294                    }
 295
 1296                    break;
 297                case "sorttitle":
 1298                    item.ForcedSortName = reader.ReadNormalizedString();
 1299                    break;
 300                case "biography":
 301                case "plot":
 302                case "review":
 13303                    item.Overview = reader.ReadNormalizedString();
 13304                    break;
 305                case "language":
 1306                    item.PreferredMetadataLanguage = reader.ReadNormalizedString();
 1307                    break;
 308                case "watched":
 8309                    var played = reader.ReadElementContentAsBoolean();
 8310                    if (Guid.TryParse(nfoConfiguration.UserId, out var userId))
 311                    {
 1312                        var user = _userManager.GetUserById(userId);
 1313                        if (user is not null)
 314                        {
 1315                            userData = _userDataManager.GetUserData(user, item);
 1316                            if (userData is not null)
 317                            {
 1318                                userData.Played = played;
 319
 1320                                if (!item.Id.IsEmpty())
 321                                {
 0322                                    _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, Cance
 323                                }
 324                            }
 325                        }
 326                    }
 327
 0328                    break;
 329                case "playcount":
 4330                    if (reader.TryReadInt(out var count)
 4331                        && Guid.TryParse(nfoConfiguration.UserId, out var playCountUserId))
 332                    {
 1333                        var user = _userManager.GetUserById(playCountUserId);
 1334                        if (user is not null)
 335                        {
 1336                            userData = _userDataManager.GetUserData(user, item);
 1337                            if (userData is not null)
 338                            {
 1339                                userData.PlayCount = count;
 340
 1341                                if (!item.Id.IsEmpty())
 342                                {
 0343                                    _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, Cance
 344                                }
 345                            }
 346                        }
 347                    }
 348
 0349                    break;
 350                case "lastplayed":
 4351                    if (reader.TryReadDateTime(out var lastPlayed)
 4352                        && Guid.TryParse(nfoConfiguration.UserId, out var lastPlayedUserId))
 353                    {
 1354                        var user = _userManager.GetUserById(lastPlayedUserId);
 1355                        if (user is not null)
 356                        {
 1357                            userData = _userDataManager.GetUserData(user, item);
 1358                            if (userData is not null)
 359                            {
 1360                                userData.LastPlayedDate = lastPlayed;
 361
 1362                                if (!item.Id.IsEmpty())
 363                                {
 0364                                    _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, Cance
 365                                }
 366                            }
 367                        }
 368                    }
 369
 0370                    break;
 371                case "countrycode":
 1372                    item.PreferredMetadataCountryCode = reader.ReadNormalizedString();
 1373                    break;
 374                case "lockedfields":
 375                    {
 0376                        var val = reader.ReadElementContentAsString();
 377
 0378                        if (!string.IsNullOrWhiteSpace(val))
 379                        {
 0380                            item.LockedFields = val.Split('|').Select(i =>
 0381                            {
 0382                                if (Enum.TryParse(i, true, out MetadataField field))
 0383                                {
 0384                                    return (MetadataField?)field;
 0385                                }
 0386
 0387                                return null;
 0388                            }).OfType<MetadataField>().ToArray();
 389                        }
 390
 0391                        break;
 392                    }
 393
 394                case "tagline":
 4395                    item.Tagline = reader.ReadNormalizedString();
 4396                    break;
 397                case "country":
 398                    {
 3399                        var val = reader.ReadElementContentAsString();
 400
 3401                        if (!string.IsNullOrWhiteSpace(val))
 402                        {
 3403                            item.ProductionLocations = val.Split('/')
 3404                                .Select(i => i.Trim())
 3405                                .Where(i => !string.IsNullOrWhiteSpace(i))
 3406                                .ToArray();
 407                        }
 408
 3409                        break;
 410                    }
 411
 412                case "mpaa":
 4413                    item.OfficialRating = reader.ReadNormalizedString();
 4414                    break;
 415                case "customrating":
 1416                    item.CustomRating = reader.ReadNormalizedString();
 1417                    break;
 418                case "runtime":
 4419                    var runtimeText = reader.ReadElementContentAsString();
 4420                    if (int.TryParse(runtimeText.AsSpan().LeftPart(' '), NumberStyles.Integer, CultureInfo.InvariantCult
 421                    {
 4422                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
 423                    }
 424
 4425                    break;
 426                case "aspectratio":
 1427                    var aspectRatio = reader.ReadNormalizedString();
 1428                    if (!string.IsNullOrEmpty(aspectRatio) && item is IHasAspectRatio hasAspectRatio)
 429                    {
 1430                        hasAspectRatio.AspectRatio = aspectRatio;
 431                    }
 432
 1433                    break;
 434                case "lockdata":
 1435                    item.IsLocked = string.Equals(reader.ReadElementContentAsString(), "true", StringComparison.OrdinalI
 1436                    break;
 437                case "studio":
 4438                    var studio = reader.ReadNormalizedString();
 4439                    if (!string.IsNullOrEmpty(studio))
 440                    {
 4441                        item.AddStudio(studio);
 442                    }
 443
 4444                    break;
 445                case "director":
 12446                    foreach (var director in reader.GetPersonArray(PersonKind.Director))
 447                    {
 3448                        itemResult.AddPerson(director);
 449                    }
 450
 451                    break;
 452                case "credits":
 453                    {
 4454                        var val = reader.ReadElementContentAsString();
 455
 4456                        if (!string.IsNullOrWhiteSpace(val))
 457                        {
 4458                            var parts = val.Split('/').Select(i => i.Trim())
 4459                                .Where(i => !string.IsNullOrEmpty(i));
 460
 16461                            foreach (var p in parts.Select(v => new PersonInfo { Name = v.Trim(), Type = PersonKind.Writ
 462                            {
 4463                                if (string.IsNullOrWhiteSpace(p.Name))
 464                                {
 465                                    continue;
 466                                }
 467
 4468                                itemResult.AddPerson(p);
 469                            }
 470                        }
 471
 472                        break;
 473                    }
 474
 475                case "writer":
 4476                    foreach (var writer in reader.GetPersonArray(PersonKind.Writer))
 477                    {
 1478                        itemResult.AddPerson(writer);
 479                    }
 480
 481                    break;
 482                case "actor":
 55483                    var person = reader.GetPersonFromXmlNode();
 55484                    if (person is not null)
 485                    {
 55486                        itemResult.AddPerson(person);
 487                    }
 488
 55489                    break;
 490                case "trailer":
 4491                    var trailer = reader.ReadNormalizedString();
 4492                    if (!string.IsNullOrEmpty(trailer))
 493                    {
 1494                        if (trailer.StartsWith("plugin://plugin.video.youtube/?action=play_video&videoid=", StringCompar
 495                        {
 496                            // Deprecated format
 1497                            item.AddTrailerUrl(trailer.Replace(
 1498                                "plugin://plugin.video.youtube/?action=play_video&videoid=",
 1499                                BaseNfoSaver.YouTubeWatchUrl,
 1500                                StringComparison.OrdinalIgnoreCase));
 501
 1502                            var suggestedUrl = trailer.Replace(
 1503                                "plugin://plugin.video.youtube/?action=play_video&videoid=",
 1504                                "plugin://plugin.video.youtube/play/?video_id=",
 1505                                StringComparison.OrdinalIgnoreCase);
 1506                            Logger.LogWarning("Trailer URL uses a deprecated format : {Url}. Using {NewUrl} instead is a
 507                        }
 0508                        else if (trailer.StartsWith("plugin://plugin.video.youtube/play/?video_id=", StringComparison.Or
 509                        {
 510                            // Proper format
 0511                            item.AddTrailerUrl(trailer.Replace(
 0512                                "plugin://plugin.video.youtube/play/?video_id=",
 0513                                BaseNfoSaver.YouTubeWatchUrl,
 0514                                StringComparison.OrdinalIgnoreCase));
 515                        }
 516                    }
 517
 0518                    break;
 519                case "displayorder":
 0520                    var displayOrder = reader.ReadNormalizedString();
 0521                    if (!string.IsNullOrEmpty(displayOrder) && item is IHasDisplayOrder hasDisplayOrder)
 522                    {
 0523                        hasDisplayOrder.DisplayOrder = displayOrder;
 524                    }
 525
 0526                    break;
 527                case "year":
 6528                    if (reader.TryReadInt(out var productionYear) && productionYear > 1850)
 529                    {
 6530                        item.ProductionYear = productionYear;
 531                    }
 532
 6533                    break;
 534                case "rating":
 7535                    var rating = reader.ReadElementContentAsString().Replace(',', '.');
 536                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
 7537                    if (float.TryParse(rating, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var com
 538                    {
 6539                        item.CommunityRating = communityRating;
 540                    }
 541
 6542                    break;
 543                case "ratings":
 3544                    FetchFromRatingsNode(reader, item);
 3545                    break;
 546                case "aired":
 547                case "formed":
 548                case "premiered":
 549                case "releasedate":
 19550                    if (reader.TryReadDateTimeExact(nfoConfiguration.ReleaseDateFormat, out var releaseDate))
 551                    {
 14552                        item.PremiereDate = releaseDate;
 553
 554                        // Production year can already be set by the year tag
 14555                        item.ProductionYear ??= releaseDate.Year;
 556                    }
 557
 558                    break;
 559                case "enddate":
 1560                    if (reader.TryReadDateTimeExact(nfoConfiguration.ReleaseDateFormat, out var endDate))
 561                    {
 1562                        item.EndDate = endDate;
 563                    }
 564
 1565                    break;
 566                case "genre":
 567                    {
 13568                        var val = reader.ReadElementContentAsString();
 569
 13570                        if (!string.IsNullOrWhiteSpace(val))
 571                        {
 13572                            var parts = val.Split('/')
 13573                                .Select(i => i.Trim())
 13574                                .Where(i => !string.IsNullOrWhiteSpace(i));
 575
 52576                            foreach (var p in parts)
 577                            {
 13578                                item.AddGenre(p);
 579                            }
 580                        }
 581
 582                        break;
 583                    }
 584
 585                case "style":
 586                case "tag":
 2587                    var tag = reader.ReadNormalizedString();
 2588                    if (!string.IsNullOrEmpty(tag))
 589                    {
 2590                        item.AddTag(tag);
 591                    }
 592
 2593                    break;
 594                case "fileinfo":
 3595                    FetchFromFileInfoNode(reader, item);
 3596                    break;
 597                case "uniqueid":
 8598                    if (reader.IsEmptyElement)
 599                    {
 0600                        reader.Read();
 0601                        break;
 602                    }
 603
 8604                    var provider = reader.GetAttribute("type");
 8605                    var providerId = reader.ReadElementContentAsString();
 606
 8607                    if (!string.IsNullOrEmpty(provider))
 608                    {
 8609                        if (_validProviderIds.TryGetValue(provider, out string? normalizedProvider))
 610                        {
 2611                            item.TrySetProviderId(normalizedProvider, providerId);
 612                        }
 613                        else
 614                        {
 6615                            item.TrySetProviderId(provider, providerId);
 616                        }
 617                    }
 618
 6619                    break;
 620                case "thumb":
 166621                    FetchThumbNode(reader, itemResult, "thumb");
 166622                    break;
 623                case "fanart":
 624                    {
 4625                        if (reader.IsEmptyElement)
 626                        {
 0627                            reader.Read();
 0628                            break;
 629                        }
 630
 4631                        using var subtree = reader.ReadSubtree();
 4632                        if (!subtree.ReadToDescendant("thumb"))
 633                        {
 0634                            break;
 635                        }
 636
 4637                        FetchThumbNode(subtree, itemResult, "fanart");
 4638                        break;
 639                    }
 640
 641                default:
 66642                    string readerName = reader.Name;
 66643                    if (_validProviderIds.TryGetValue(readerName, out string? providerIdValue))
 644                    {
 3645                        var id = reader.ReadElementContentAsString();
 3646                        item.TrySetProviderId(providerIdValue, id);
 647                    }
 648                    else
 649                    {
 63650                        reader.Skip();
 651                    }
 652
 653                    break;
 654            }
 116655        }
 656
 657        private void FetchThumbNode(XmlReader reader, MetadataResult<T> itemResult, string parentNode)
 658        {
 170659            var artType = reader.GetAttribute("aspect");
 170660            var val = reader.ReadElementContentAsString();
 661
 662            // artType is null if the thumb node is a child of the fanart tag
 663            // -> set image type to fanart
 170664            if (string.IsNullOrWhiteSpace(artType) && parentNode.Equals("fanart", StringComparison.Ordinal))
 665            {
 4666                artType = "fanart";
 667            }
 166668            else if (string.IsNullOrWhiteSpace(artType))
 669            {
 670                // Sonarr writes thumb tags for posters without aspect property
 14671                artType = "poster";
 672            }
 673
 674            // skip:
 675            // - empty uri
 676            // - tag containing '.' because we can't set images for seasons, episodes or movie sets within series or mov
 170677            if (string.IsNullOrEmpty(val) || artType.Contains('.', StringComparison.Ordinal))
 678            {
 11679                return;
 680            }
 681
 159682            ImageType imageType = GetImageType(artType);
 683
 159684            if (!Uri.TryCreate(val, UriKind.Absolute, out var uri))
 685            {
 1686                Logger.LogError("Image location {Path} specified in nfo file for {ItemName} is not a valid URL or file p
 1687                return;
 688            }
 689
 158690            if (uri.IsFile)
 691            {
 692                // only allow one item of each type
 2693                if (itemResult.Images.Any(x => x.Type == imageType))
 694                {
 0695                    return;
 696                }
 697
 2698                var fileSystemMetadata = _directoryService.GetFile(val);
 699                // nonexistent file returns null
 2700                if (fileSystemMetadata is null || !fileSystemMetadata.Exists)
 701                {
 1702                    Logger.LogWarning("Artwork file {Path} specified in nfo file for {ItemName} does not exist.", uri, i
 1703                    return;
 704                }
 705
 1706                itemResult.Images.Add(new LocalImageInfo()
 1707                {
 1708                    FileInfo = fileSystemMetadata,
 1709                    Type = imageType
 1710                });
 711            }
 712            else
 713            {
 714                // only allow one item of each type
 156715                if (itemResult.RemoteImages.Any(x => x.Type == imageType))
 716                {
 121717                    return;
 718                }
 719
 35720                itemResult.RemoteImages.Add((uri.ToString(), imageType));
 721            }
 35722        }
 723
 724        private void FetchFromFileInfoNode(XmlReader parentReader, T item)
 725        {
 3726            if (parentReader.IsEmptyElement)
 727            {
 0728                parentReader.Read();
 0729                return;
 730            }
 731
 3732            using var reader = parentReader.ReadSubtree();
 3733            reader.MoveToContent();
 3734            reader.Read();
 735
 736            // Loop through each element
 18737            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 738            {
 15739                if (reader.NodeType != XmlNodeType.Element)
 740                {
 12741                    reader.Read();
 12742                    continue;
 743                }
 744
 3745                switch (reader.Name)
 746                {
 747                    case "streamdetails":
 3748                        FetchFromStreamDetailsNode(reader, item);
 3749                        break;
 750                    default:
 0751                        reader.Skip();
 752                        break;
 753                }
 754            }
 6755        }
 756
 757        private void FetchFromStreamDetailsNode(XmlReader parentReader, T item)
 758        {
 3759            if (parentReader.IsEmptyElement)
 760            {
 0761                parentReader.Read();
 0762                return;
 763            }
 764
 3765            using var reader = parentReader.ReadSubtree();
 3766            reader.MoveToContent();
 3767            reader.Read();
 768
 769            // Loop through each element
 32770            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 771            {
 29772                if (reader.NodeType != XmlNodeType.Element)
 773                {
 20774                    reader.Read();
 20775                    continue;
 776                }
 777
 9778                switch (reader.Name)
 779                {
 780                    case "video":
 3781                        FetchFromVideoNode(reader, item);
 3782                        break;
 783                    case "subtitle":
 2784                        FetchFromSubtitleNode(reader, item);
 2785                        break;
 786                    default:
 4787                        reader.Skip();
 788                        break;
 789                }
 790            }
 6791        }
 792
 793        private void FetchFromVideoNode(XmlReader parentReader, T item)
 794        {
 3795            if (parentReader.IsEmptyElement)
 796            {
 0797                parentReader.Read();
 0798                return;
 799            }
 800
 3801            using var reader = parentReader.ReadSubtree();
 3802            reader.MoveToContent();
 3803            reader.Read();
 804
 805            // Loop through each element
 53806            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 807            {
 50808                if (reader.NodeType != XmlNodeType.Element || item is not Video video)
 809                {
 28810                    reader.Read();
 28811                    continue;
 812                }
 813
 22814                switch (reader.Name)
 815                {
 816                    case "format3d":
 1817                        var format = reader.ReadElementContentAsString();
 1818                        if (string.Equals("HSBS", format, StringComparison.OrdinalIgnoreCase))
 819                        {
 1820                            video.Video3DFormat = Video3DFormat.HalfSideBySide;
 821                        }
 0822                        else if (string.Equals("HTAB", format, StringComparison.OrdinalIgnoreCase))
 823                        {
 0824                            video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
 825                        }
 0826                        else if (string.Equals("FTAB", format, StringComparison.OrdinalIgnoreCase))
 827                        {
 0828                            video.Video3DFormat = Video3DFormat.FullTopAndBottom;
 829                        }
 0830                        else if (string.Equals("FSBS", format, StringComparison.OrdinalIgnoreCase))
 831                        {
 0832                            video.Video3DFormat = Video3DFormat.FullSideBySide;
 833                        }
 0834                        else if (string.Equals("MVC", format, StringComparison.OrdinalIgnoreCase))
 835                        {
 0836                            video.Video3DFormat = Video3DFormat.MVC;
 837                        }
 838
 0839                        break;
 840                    case "aspect":
 3841                        video.AspectRatio = reader.ReadNormalizedString();
 3842                        break;
 843                    case "width":
 3844                        video.Width = reader.ReadElementContentAsInt();
 3845                        break;
 846                    case "height":
 3847                        video.Height = reader.ReadElementContentAsInt();
 3848                        break;
 849                    case "durationinseconds":
 3850                        video.RunTimeTicks = new TimeSpan(0, 0, reader.ReadElementContentAsInt()).Ticks;
 3851                        break;
 852                    default:
 9853                        reader.Skip();
 854                        break;
 855                }
 856            }
 6857        }
 858
 859        private void FetchFromSubtitleNode(XmlReader parentReader, T item)
 860        {
 2861            if (parentReader.IsEmptyElement)
 862            {
 0863                parentReader.Read();
 0864                return;
 865            }
 866
 2867            using var reader = parentReader.ReadSubtree();
 2868            reader.MoveToContent();
 2869            reader.Read();
 870
 871            // Loop through each element
 10872            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 873            {
 8874                if (reader.NodeType != XmlNodeType.Element)
 875                {
 6876                    reader.Read();
 6877                    continue;
 878                }
 879
 2880                switch (reader.Name)
 881                {
 882                    case "language":
 2883                        _ = reader.ReadElementContentAsString();
 2884                        if (item is Video video)
 885                        {
 2886                            video.HasSubtitles = true;
 887                        }
 888
 2889                        break;
 890                    default:
 0891                        reader.Skip();
 892                        break;
 893                }
 894            }
 4895        }
 896
 897        private void FetchFromRatingsNode(XmlReader parentReader, T item)
 898        {
 3899            if (parentReader.IsEmptyElement)
 900            {
 0901                parentReader.Read();
 0902                return;
 903            }
 904
 3905            using var reader = parentReader.ReadSubtree();
 3906            reader.MoveToContent();
 3907            reader.Read();
 908
 909            // Loop through each element
 42910            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 911            {
 39912                if (reader.NodeType == XmlNodeType.Element)
 913                {
 11914                    switch (reader.Name)
 915                    {
 916                        case "rating":
 917                            {
 11918                                if (reader.IsEmptyElement)
 919                                {
 0920                                    reader.Read();
 0921                                    continue;
 922                                }
 923
 11924                                var ratingName = reader.GetAttribute("name");
 925
 11926                                using var subtree = reader.ReadSubtree();
 11927                                FetchFromRatingNode(subtree, item, ratingName);
 928
 11929                                break;
 930                            }
 931
 932                        default:
 0933                            reader.Skip();
 0934                            break;
 935                    }
 936                }
 937                else
 938                {
 28939                    reader.Read();
 940                }
 941            }
 6942        }
 943
 944        private void FetchFromRatingNode(XmlReader reader, T item, string? ratingName)
 945        {
 11946            reader.MoveToContent();
 11947            reader.Read();
 948
 949            // Loop through each element
 77950            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 951            {
 66952                if (reader.NodeType == XmlNodeType.Element)
 953                {
 22954                    switch (reader.Name)
 955                    {
 956                        case "value":
 11957                            var val = reader.ReadElementContentAsString();
 958
 11959                            if (float.TryParse(val, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out va
 960                            {
 961                                // if ratingName contains tomato --> assume critic rating
 11962                                if (ratingName is not null
 11963                                    && ratingName.Contains("tomato", StringComparison.OrdinalIgnoreCase)
 11964                                    && !ratingName.Contains("audience", StringComparison.OrdinalIgnoreCase))
 965                                {
 2966                                    if (!ratingName.Contains("avg", StringComparison.OrdinalIgnoreCase))
 967                                    {
 2968                                        item.CriticRating = ratingValue;
 969                                    }
 970                                }
 971                                else
 972                                {
 9973                                    item.CommunityRating = ratingValue;
 974                                }
 975                            }
 976
 9977                            break;
 978                        default:
 11979                            reader.Skip();
 11980                            break;
 981                    }
 982                }
 983                else
 984                {
 44985                    reader.Read();
 986                }
 987            }
 11988        }
 989
 990        internal XmlReaderSettings GetXmlReaderSettings()
 20991            => new XmlReaderSettings()
 20992            {
 20993                ValidationType = ValidationType.None,
 20994                CheckCharacters = false,
 20995                IgnoreProcessingInstructions = true,
 20996                IgnoreComments = true
 20997            };
 998
 999        /// <summary>
 1000        /// Parses the <see cref="ImageType"/> from the NFO aspect property.
 1001        /// </summary>
 1002        /// <param name="aspect">The NFO aspect property.</param>
 1003        /// <returns>The <see cref="ImageType"/>.</returns>
 1004        private static ImageType GetImageType(string aspect)
 1005        {
 1591006            return aspect switch
 1591007            {
 231008                "banner" => ImageType.Banner,
 231009                "clearlogo" => ImageType.Logo,
 121010                "discart" => ImageType.Disc,
 181011                "landscape" => ImageType.Thumb,
 81012                "clearart" => ImageType.Art,
 61013                "fanart" => ImageType.Backdrop,
 1591014                // unknown type (including "poster") --> primary
 691015                _ => ImageType.Primary,
 1591016            };
 1017        }
 1018    }
 1019}