< Summary - Jellyfin

Information
Class: MediaBrowser.XbmcMetadata.Parsers.BaseNfoParser<T>
Assembly: MediaBrowser.XbmcMetadata
File(s): /srv/git/jellyfin/MediaBrowser.XbmcMetadata/Parsers/BaseNfoParser.cs
Line coverage
86%
Covered lines: 365
Uncovered lines: 57
Coverable lines: 422
Total lines: 1007
Line coverage: 86.4%
Branch coverage
92%
Covered branches: 429
Total branches: 466
Branch coverage: 92%
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_SupportsUrlAfterClosingXmlTag()100%11100%
Fetch(...)100%44100%
Fetch(...)95%202092.68%
ParseProviderLinks(...)91.66%121290.9%
FetchDataFromXmlNode(...)94.37%60530285.08%
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;
 1319                                _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, Cancellat
 320                            }
 321                        }
 322                    }
 323
 1324                    break;
 325                case "playcount":
 4326                    if (reader.TryReadInt(out var count)
 4327                        && Guid.TryParse(nfoConfiguration.UserId, out var playCountUserId))
 328                    {
 1329                        var user = _userManager.GetUserById(playCountUserId);
 1330                        if (user is not null)
 331                        {
 1332                            userData = _userDataManager.GetUserData(user, item);
 1333                            if (userData is not null)
 334                            {
 1335                                userData.PlayCount = count;
 1336                                _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, Cancellat
 337                            }
 338                        }
 339                    }
 340
 1341                    break;
 342                case "lastplayed":
 4343                    if (reader.TryReadDateTime(out var lastPlayed)
 4344                        && Guid.TryParse(nfoConfiguration.UserId, out var lastPlayedUserId))
 345                    {
 1346                        var user = _userManager.GetUserById(lastPlayedUserId);
 1347                        if (user is not null)
 348                        {
 1349                            userData = _userDataManager.GetUserData(user, item);
 1350                            if (userData is not null)
 351                            {
 1352                                userData.LastPlayedDate = lastPlayed;
 1353                                _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, Cancellat
 354                            }
 355                        }
 356                    }
 357
 1358                    break;
 359                case "countrycode":
 1360                    item.PreferredMetadataCountryCode = reader.ReadNormalizedString();
 1361                    break;
 362                case "lockedfields":
 363                    {
 0364                        var val = reader.ReadElementContentAsString();
 365
 0366                        if (!string.IsNullOrWhiteSpace(val))
 367                        {
 0368                            item.LockedFields = val.Split('|').Select(i =>
 0369                            {
 0370                                if (Enum.TryParse(i, true, out MetadataField field))
 0371                                {
 0372                                    return (MetadataField?)field;
 0373                                }
 0374
 0375                                return null;
 0376                            }).OfType<MetadataField>().ToArray();
 377                        }
 378
 0379                        break;
 380                    }
 381
 382                case "tagline":
 4383                    item.Tagline = reader.ReadNormalizedString();
 4384                    break;
 385                case "country":
 386                    {
 3387                        var val = reader.ReadElementContentAsString();
 388
 3389                        if (!string.IsNullOrWhiteSpace(val))
 390                        {
 3391                            item.ProductionLocations = val.Split('/')
 3392                                .Select(i => i.Trim())
 3393                                .Where(i => !string.IsNullOrWhiteSpace(i))
 3394                                .ToArray();
 395                        }
 396
 3397                        break;
 398                    }
 399
 400                case "mpaa":
 4401                    item.OfficialRating = reader.ReadNormalizedString();
 4402                    break;
 403                case "customrating":
 1404                    item.CustomRating = reader.ReadNormalizedString();
 1405                    break;
 406                case "runtime":
 4407                    var runtimeText = reader.ReadElementContentAsString();
 4408                    if (int.TryParse(runtimeText.AsSpan().LeftPart(' '), NumberStyles.Integer, CultureInfo.InvariantCult
 409                    {
 4410                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
 411                    }
 412
 4413                    break;
 414                case "aspectratio":
 1415                    var aspectRatio = reader.ReadNormalizedString();
 1416                    if (!string.IsNullOrEmpty(aspectRatio) && item is IHasAspectRatio hasAspectRatio)
 417                    {
 1418                        hasAspectRatio.AspectRatio = aspectRatio;
 419                    }
 420
 1421                    break;
 422                case "lockdata":
 1423                    item.IsLocked = string.Equals(reader.ReadElementContentAsString(), "true", StringComparison.OrdinalI
 1424                    break;
 425                case "studio":
 4426                    var studio = reader.ReadNormalizedString();
 4427                    if (!string.IsNullOrEmpty(studio))
 428                    {
 4429                        item.AddStudio(studio);
 430                    }
 431
 4432                    break;
 433                case "director":
 12434                    foreach (var director in reader.GetPersonArray(PersonKind.Director))
 435                    {
 3436                        itemResult.AddPerson(director);
 437                    }
 438
 439                    break;
 440                case "credits":
 441                    {
 4442                        var val = reader.ReadElementContentAsString();
 443
 4444                        if (!string.IsNullOrWhiteSpace(val))
 445                        {
 4446                            var parts = val.Split('/').Select(i => i.Trim())
 4447                                .Where(i => !string.IsNullOrEmpty(i));
 448
 16449                            foreach (var p in parts.Select(v => new PersonInfo { Name = v.Trim(), Type = PersonKind.Writ
 450                            {
 4451                                if (string.IsNullOrWhiteSpace(p.Name))
 452                                {
 453                                    continue;
 454                                }
 455
 4456                                itemResult.AddPerson(p);
 457                            }
 458                        }
 459
 460                        break;
 461                    }
 462
 463                case "writer":
 4464                    foreach (var writer in reader.GetPersonArray(PersonKind.Writer))
 465                    {
 1466                        itemResult.AddPerson(writer);
 467                    }
 468
 469                    break;
 470                case "actor":
 55471                    var person = reader.GetPersonFromXmlNode();
 55472                    if (person is not null)
 473                    {
 55474                        itemResult.AddPerson(person);
 475                    }
 476
 55477                    break;
 478                case "trailer":
 4479                    var trailer = reader.ReadNormalizedString();
 4480                    if (!string.IsNullOrEmpty(trailer))
 481                    {
 1482                        if (trailer.StartsWith("plugin://plugin.video.youtube/?action=play_video&videoid=", StringCompar
 483                        {
 484                            // Deprecated format
 1485                            item.AddTrailerUrl(trailer.Replace(
 1486                                "plugin://plugin.video.youtube/?action=play_video&videoid=",
 1487                                BaseNfoSaver.YouTubeWatchUrl,
 1488                                StringComparison.OrdinalIgnoreCase));
 489
 1490                            var suggestedUrl = trailer.Replace(
 1491                                "plugin://plugin.video.youtube/?action=play_video&videoid=",
 1492                                "plugin://plugin.video.youtube/play/?video_id=",
 1493                                StringComparison.OrdinalIgnoreCase);
 1494                            Logger.LogWarning("Trailer URL uses a deprecated format : {Url}. Using {NewUrl} instead is a
 495                        }
 0496                        else if (trailer.StartsWith("plugin://plugin.video.youtube/play/?video_id=", StringComparison.Or
 497                        {
 498                            // Proper format
 0499                            item.AddTrailerUrl(trailer.Replace(
 0500                                "plugin://plugin.video.youtube/play/?video_id=",
 0501                                BaseNfoSaver.YouTubeWatchUrl,
 0502                                StringComparison.OrdinalIgnoreCase));
 503                        }
 504                    }
 505
 0506                    break;
 507                case "displayorder":
 0508                    var displayOrder = reader.ReadNormalizedString();
 0509                    if (!string.IsNullOrEmpty(displayOrder) && item is IHasDisplayOrder hasDisplayOrder)
 510                    {
 0511                        hasDisplayOrder.DisplayOrder = displayOrder;
 512                    }
 513
 0514                    break;
 515                case "year":
 6516                    if (reader.TryReadInt(out var productionYear) && productionYear > 1850)
 517                    {
 6518                        item.ProductionYear = productionYear;
 519                    }
 520
 6521                    break;
 522                case "rating":
 7523                    var rating = reader.ReadElementContentAsString().Replace(',', '.');
 524                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
 7525                    if (float.TryParse(rating, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var com
 526                    {
 6527                        item.CommunityRating = communityRating;
 528                    }
 529
 6530                    break;
 531                case "ratings":
 3532                    FetchFromRatingsNode(reader, item);
 3533                    break;
 534                case "aired":
 535                case "formed":
 536                case "premiered":
 537                case "releasedate":
 19538                    if (reader.TryReadDateTimeExact(nfoConfiguration.ReleaseDateFormat, out var releaseDate))
 539                    {
 14540                        item.PremiereDate = releaseDate;
 541
 542                        // Production year can already be set by the year tag
 14543                        item.ProductionYear ??= releaseDate.Year;
 544                    }
 545
 546                    break;
 547                case "enddate":
 1548                    if (reader.TryReadDateTimeExact(nfoConfiguration.ReleaseDateFormat, out var endDate))
 549                    {
 1550                        item.EndDate = endDate;
 551                    }
 552
 1553                    break;
 554                case "genre":
 555                    {
 13556                        var val = reader.ReadElementContentAsString();
 557
 13558                        if (!string.IsNullOrWhiteSpace(val))
 559                        {
 13560                            var parts = val.Split('/')
 13561                                .Select(i => i.Trim())
 13562                                .Where(i => !string.IsNullOrWhiteSpace(i));
 563
 52564                            foreach (var p in parts)
 565                            {
 13566                                item.AddGenre(p);
 567                            }
 568                        }
 569
 570                        break;
 571                    }
 572
 573                case "style":
 574                case "tag":
 2575                    var tag = reader.ReadNormalizedString();
 2576                    if (!string.IsNullOrEmpty(tag))
 577                    {
 2578                        item.AddTag(tag);
 579                    }
 580
 2581                    break;
 582                case "fileinfo":
 3583                    FetchFromFileInfoNode(reader, item);
 3584                    break;
 585                case "uniqueid":
 8586                    if (reader.IsEmptyElement)
 587                    {
 0588                        reader.Read();
 0589                        break;
 590                    }
 591
 8592                    var provider = reader.GetAttribute("type");
 8593                    var providerId = reader.ReadElementContentAsString();
 594
 8595                    if (!string.IsNullOrEmpty(provider))
 596                    {
 8597                        if (_validProviderIds.TryGetValue(provider, out string? normalizedProvider))
 598                        {
 2599                            item.TrySetProviderId(normalizedProvider, providerId);
 600                        }
 601                        else
 602                        {
 6603                            item.TrySetProviderId(provider, providerId);
 604                        }
 605                    }
 606
 6607                    break;
 608                case "thumb":
 166609                    FetchThumbNode(reader, itemResult, "thumb");
 166610                    break;
 611                case "fanart":
 612                    {
 4613                        if (reader.IsEmptyElement)
 614                        {
 0615                            reader.Read();
 0616                            break;
 617                        }
 618
 4619                        using var subtree = reader.ReadSubtree();
 4620                        if (!subtree.ReadToDescendant("thumb"))
 621                        {
 0622                            break;
 623                        }
 624
 4625                        FetchThumbNode(subtree, itemResult, "fanart");
 4626                        break;
 627                    }
 628
 629                default:
 66630                    string readerName = reader.Name;
 66631                    if (_validProviderIds.TryGetValue(readerName, out string? providerIdValue))
 632                    {
 3633                        var id = reader.ReadElementContentAsString();
 3634                        item.TrySetProviderId(providerIdValue, id);
 635                    }
 636                    else
 637                    {
 63638                        reader.Skip();
 639                    }
 640
 641                    break;
 642            }
 113643        }
 644
 645        private void FetchThumbNode(XmlReader reader, MetadataResult<T> itemResult, string parentNode)
 646        {
 170647            var artType = reader.GetAttribute("aspect");
 170648            var val = reader.ReadElementContentAsString();
 649
 650            // artType is null if the thumb node is a child of the fanart tag
 651            // -> set image type to fanart
 170652            if (string.IsNullOrWhiteSpace(artType) && parentNode.Equals("fanart", StringComparison.Ordinal))
 653            {
 4654                artType = "fanart";
 655            }
 166656            else if (string.IsNullOrWhiteSpace(artType))
 657            {
 658                // Sonarr writes thumb tags for posters without aspect property
 14659                artType = "poster";
 660            }
 661
 662            // skip:
 663            // - empty uri
 664            // - tag containing '.' because we can't set images for seasons, episodes or movie sets within series or mov
 170665            if (string.IsNullOrEmpty(val) || artType.Contains('.', StringComparison.Ordinal))
 666            {
 11667                return;
 668            }
 669
 159670            ImageType imageType = GetImageType(artType);
 671
 159672            if (!Uri.TryCreate(val, UriKind.Absolute, out var uri))
 673            {
 1674                Logger.LogError("Image location {Path} specified in nfo file for {ItemName} is not a valid URL or file p
 1675                return;
 676            }
 677
 158678            if (uri.IsFile)
 679            {
 680                // only allow one item of each type
 2681                if (itemResult.Images.Any(x => x.Type == imageType))
 682                {
 0683                    return;
 684                }
 685
 2686                var fileSystemMetadata = _directoryService.GetFile(val);
 687                // nonexistent file returns null
 2688                if (fileSystemMetadata is null || !fileSystemMetadata.Exists)
 689                {
 1690                    Logger.LogWarning("Artwork file {Path} specified in nfo file for {ItemName} does not exist.", uri, i
 1691                    return;
 692                }
 693
 1694                itemResult.Images.Add(new LocalImageInfo()
 1695                {
 1696                    FileInfo = fileSystemMetadata,
 1697                    Type = imageType
 1698                });
 699            }
 700            else
 701            {
 702                // only allow one item of each type
 156703                if (itemResult.RemoteImages.Any(x => x.Type == imageType))
 704                {
 121705                    return;
 706                }
 707
 35708                itemResult.RemoteImages.Add((uri.ToString(), imageType));
 709            }
 35710        }
 711
 712        private void FetchFromFileInfoNode(XmlReader parentReader, T item)
 713        {
 3714            if (parentReader.IsEmptyElement)
 715            {
 0716                parentReader.Read();
 0717                return;
 718            }
 719
 3720            using var reader = parentReader.ReadSubtree();
 3721            reader.MoveToContent();
 3722            reader.Read();
 723
 724            // Loop through each element
 18725            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 726            {
 15727                if (reader.NodeType != XmlNodeType.Element)
 728                {
 12729                    reader.Read();
 12730                    continue;
 731                }
 732
 3733                switch (reader.Name)
 734                {
 735                    case "streamdetails":
 3736                        FetchFromStreamDetailsNode(reader, item);
 3737                        break;
 738                    default:
 0739                        reader.Skip();
 740                        break;
 741                }
 742            }
 6743        }
 744
 745        private void FetchFromStreamDetailsNode(XmlReader parentReader, T item)
 746        {
 3747            if (parentReader.IsEmptyElement)
 748            {
 0749                parentReader.Read();
 0750                return;
 751            }
 752
 3753            using var reader = parentReader.ReadSubtree();
 3754            reader.MoveToContent();
 3755            reader.Read();
 756
 757            // Loop through each element
 32758            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 759            {
 29760                if (reader.NodeType != XmlNodeType.Element)
 761                {
 20762                    reader.Read();
 20763                    continue;
 764                }
 765
 9766                switch (reader.Name)
 767                {
 768                    case "video":
 3769                        FetchFromVideoNode(reader, item);
 3770                        break;
 771                    case "subtitle":
 2772                        FetchFromSubtitleNode(reader, item);
 2773                        break;
 774                    default:
 4775                        reader.Skip();
 776                        break;
 777                }
 778            }
 6779        }
 780
 781        private void FetchFromVideoNode(XmlReader parentReader, T item)
 782        {
 3783            if (parentReader.IsEmptyElement)
 784            {
 0785                parentReader.Read();
 0786                return;
 787            }
 788
 3789            using var reader = parentReader.ReadSubtree();
 3790            reader.MoveToContent();
 3791            reader.Read();
 792
 793            // Loop through each element
 53794            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 795            {
 50796                if (reader.NodeType != XmlNodeType.Element || item is not Video video)
 797                {
 28798                    reader.Read();
 28799                    continue;
 800                }
 801
 22802                switch (reader.Name)
 803                {
 804                    case "format3d":
 1805                        var format = reader.ReadElementContentAsString();
 1806                        if (string.Equals("HSBS", format, StringComparison.OrdinalIgnoreCase))
 807                        {
 1808                            video.Video3DFormat = Video3DFormat.HalfSideBySide;
 809                        }
 0810                        else if (string.Equals("HTAB", format, StringComparison.OrdinalIgnoreCase))
 811                        {
 0812                            video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
 813                        }
 0814                        else if (string.Equals("FTAB", format, StringComparison.OrdinalIgnoreCase))
 815                        {
 0816                            video.Video3DFormat = Video3DFormat.FullTopAndBottom;
 817                        }
 0818                        else if (string.Equals("FSBS", format, StringComparison.OrdinalIgnoreCase))
 819                        {
 0820                            video.Video3DFormat = Video3DFormat.FullSideBySide;
 821                        }
 0822                        else if (string.Equals("MVC", format, StringComparison.OrdinalIgnoreCase))
 823                        {
 0824                            video.Video3DFormat = Video3DFormat.MVC;
 825                        }
 826
 0827                        break;
 828                    case "aspect":
 3829                        video.AspectRatio = reader.ReadNormalizedString();
 3830                        break;
 831                    case "width":
 3832                        video.Width = reader.ReadElementContentAsInt();
 3833                        break;
 834                    case "height":
 3835                        video.Height = reader.ReadElementContentAsInt();
 3836                        break;
 837                    case "durationinseconds":
 3838                        video.RunTimeTicks = new TimeSpan(0, 0, reader.ReadElementContentAsInt()).Ticks;
 3839                        break;
 840                    default:
 9841                        reader.Skip();
 842                        break;
 843                }
 844            }
 6845        }
 846
 847        private void FetchFromSubtitleNode(XmlReader parentReader, T item)
 848        {
 2849            if (parentReader.IsEmptyElement)
 850            {
 0851                parentReader.Read();
 0852                return;
 853            }
 854
 2855            using var reader = parentReader.ReadSubtree();
 2856            reader.MoveToContent();
 2857            reader.Read();
 858
 859            // Loop through each element
 10860            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 861            {
 8862                if (reader.NodeType != XmlNodeType.Element)
 863                {
 6864                    reader.Read();
 6865                    continue;
 866                }
 867
 2868                switch (reader.Name)
 869                {
 870                    case "language":
 2871                        _ = reader.ReadElementContentAsString();
 2872                        if (item is Video video)
 873                        {
 2874                            video.HasSubtitles = true;
 875                        }
 876
 2877                        break;
 878                    default:
 0879                        reader.Skip();
 880                        break;
 881                }
 882            }
 4883        }
 884
 885        private void FetchFromRatingsNode(XmlReader parentReader, T item)
 886        {
 3887            if (parentReader.IsEmptyElement)
 888            {
 0889                parentReader.Read();
 0890                return;
 891            }
 892
 3893            using var reader = parentReader.ReadSubtree();
 3894            reader.MoveToContent();
 3895            reader.Read();
 896
 897            // Loop through each element
 42898            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 899            {
 39900                if (reader.NodeType == XmlNodeType.Element)
 901                {
 11902                    switch (reader.Name)
 903                    {
 904                        case "rating":
 905                            {
 11906                                if (reader.IsEmptyElement)
 907                                {
 0908                                    reader.Read();
 0909                                    continue;
 910                                }
 911
 11912                                var ratingName = reader.GetAttribute("name");
 913
 11914                                using var subtree = reader.ReadSubtree();
 11915                                FetchFromRatingNode(subtree, item, ratingName);
 916
 11917                                break;
 918                            }
 919
 920                        default:
 0921                            reader.Skip();
 0922                            break;
 923                    }
 924                }
 925                else
 926                {
 28927                    reader.Read();
 928                }
 929            }
 6930        }
 931
 932        private void FetchFromRatingNode(XmlReader reader, T item, string? ratingName)
 933        {
 11934            reader.MoveToContent();
 11935            reader.Read();
 936
 937            // Loop through each element
 77938            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 939            {
 66940                if (reader.NodeType == XmlNodeType.Element)
 941                {
 22942                    switch (reader.Name)
 943                    {
 944                        case "value":
 11945                            var val = reader.ReadElementContentAsString();
 946
 11947                            if (float.TryParse(val, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out va
 948                            {
 949                                // if ratingName contains tomato --> assume critic rating
 11950                                if (ratingName is not null
 11951                                    && ratingName.Contains("tomato", StringComparison.OrdinalIgnoreCase)
 11952                                    && !ratingName.Contains("audience", StringComparison.OrdinalIgnoreCase))
 953                                {
 2954                                    if (!ratingName.Contains("avg", StringComparison.OrdinalIgnoreCase))
 955                                    {
 2956                                        item.CriticRating = ratingValue;
 957                                    }
 958                                }
 959                                else
 960                                {
 9961                                    item.CommunityRating = ratingValue;
 962                                }
 963                            }
 964
 9965                            break;
 966                        default:
 11967                            reader.Skip();
 11968                            break;
 969                    }
 970                }
 971                else
 972                {
 44973                    reader.Read();
 974                }
 975            }
 11976        }
 977
 978        internal XmlReaderSettings GetXmlReaderSettings()
 20979            => new XmlReaderSettings()
 20980            {
 20981                ValidationType = ValidationType.None,
 20982                CheckCharacters = false,
 20983                IgnoreProcessingInstructions = true,
 20984                IgnoreComments = true
 20985            };
 986
 987        /// <summary>
 988        /// Parses the <see cref="ImageType"/> from the NFO aspect property.
 989        /// </summary>
 990        /// <param name="aspect">The NFO aspect property.</param>
 991        /// <returns>The <see cref="ImageType"/>.</returns>
 992        private static ImageType GetImageType(string aspect)
 993        {
 159994            return aspect switch
 159995            {
 23996                "banner" => ImageType.Banner,
 23997                "clearlogo" => ImageType.Logo,
 12998                "discart" => ImageType.Disc,
 18999                "landscape" => ImageType.Thumb,
 81000                "clearart" => ImageType.Art,
 61001                "fanart" => ImageType.Backdrop,
 1591002                // unknown type (including "poster") --> primary
 691003                _ => ImageType.Primary,
 1591004            };
 1005        }
 1006    }
 1007}