< 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: 358
Uncovered lines: 57
Coverable lines: 415
Total lines: 986
Line coverage: 86.2%
Branch coverage
91%
Covered branches: 419
Total branches: 456
Branch coverage: 91.8%
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%20.162092.68%
ParseProviderLinks(...)91.66%12.111290.9%
FetchDataFromXmlNode(...)94.17%605.2329284.57%
FetchThumbNode(...)95.45%22.022296.42%
FetchFromFileInfoNode(...)80%10.81080%
FetchFromStreamDetailsNode(...)91.66%12.231288.23%
FetchFromVideoNode(...)70%63.353066.66%
FetchFromSubtitleNode(...)83.33%12.791282.35%
FetchFromRatingsNode(...)75%15.891270%
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        {
 2956            Logger = logger;
 2957            _config = config;
 2958            ProviderManager = providerManager;
 2959            _validProviderIds = new Dictionary<string, string>();
 2960            _userManager = userManager;
 2961            _userDataManager = userDataManager;
 2962            _directoryService = directoryService;
 2963        }
 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 supporrted.
 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        {
 2990            if (item.Item is null)
 91            {
 792                throw new ArgumentException("Item can't be null.", nameof(item));
 93            }
 94
 2295            ArgumentException.ThrowIfNullOrEmpty(metadataFile);
 96
 1597            _validProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 98
 1599            var idInfos = ProviderManager.GetExternalIdInfos(item.Item);
 100
 52101            foreach (var info in idInfos)
 102            {
 11103                var id = info.Key + "Id";
 11104                _validProviderIds.TryAdd(id, info.Key);
 105            }
 106
 107            // Additional Mappings
 15108            _validProviderIds.Add("collectionnumber", "TmdbCollection");
 15109            _validProviderIds.Add("tmdbcolid", "TmdbCollection");
 15110            _validProviderIds.Add("imdb_id", "Imdb");
 111
 15112            Fetch(item, metadataFile, GetXmlReaderSettings(), cancellationToken);
 15113        }
 114
 115        /// <summary>
 116        /// Fetches the specified item.
 117        /// </summary>
 118        /// <param name="item">The <see cref="MetadataResult{T}"/>.</param>
 119        /// <param name="metadataFile">The metadata file.</param>
 120        /// <param name="settings">The <see cref="XmlReaderSettings"/>.</param>
 121        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
 122        protected virtual void Fetch(MetadataResult<T> item, string metadataFile, XmlReaderSettings settings, Cancellati
 123        {
 11124            if (!SupportsUrlAfterClosingXmlTag)
 125            {
 3126                using (var fileStream = File.OpenRead(metadataFile))
 3127                using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
 3128                using (var reader = XmlReader.Create(streamReader, settings))
 129                {
 3130                    item.ResetPeople();
 131
 3132                    reader.MoveToContent();
 3133                    reader.Read();
 134
 135                    // Loop through each element
 187136                    while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 137                    {
 184138                        cancellationToken.ThrowIfCancellationRequested();
 139
 184140                        if (reader.NodeType == XmlNodeType.Element)
 141                        {
 82142                            FetchDataFromXmlNode(reader, item);
 143                        }
 144                        else
 145                        {
 102146                            reader.Read();
 147                        }
 148                    }
 3149                }
 150
 3151                return;
 152            }
 153
 8154            item.ResetPeople();
 155
 156            // Need to handle a url after the xml data
 157            // http://kodi.wiki/view/NFO_files/movies
 158
 8159            var xml = File.ReadAllText(metadataFile);
 160
 161            // Find last closing Tag
 162            // Need to do this in two steps to account for random > characters after the closing xml
 8163            var index = xml.LastIndexOf("</", StringComparison.Ordinal);
 164
 165            // If closing tag exists, move to end of Tag
 8166            if (index != -1)
 167            {
 4168                index = xml.IndexOf('>', index);
 169            }
 170
 8171            if (index != -1)
 172            {
 4173                var endingXml = xml.AsSpan().Slice(index);
 174
 4175                ParseProviderLinks(item.Item, endingXml);
 176
 177                // If the file is just an IMDb url, don't go any further
 4178                if (index == 0)
 179                {
 0180                    return;
 181                }
 182
 4183                xml = xml.Substring(0, index + 1);
 184            }
 185            else
 186            {
 187                // If the file is just provider urls, handle that
 4188                ParseProviderLinks(item.Item, xml);
 189
 4190                return;
 191            }
 192
 193            // These are not going to be valid xml so no sense in causing the provider to fail and spamming the log with
 194            try
 195            {
 4196                using (var stringReader = new StringReader(xml))
 4197                using (var reader = XmlReader.Create(stringReader, settings))
 198                {
 4199                    reader.MoveToContent();
 4200                    reader.Read();
 201
 202                    // Loop through each element
 591203                    while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 204                    {
 587205                        cancellationToken.ThrowIfCancellationRequested();
 206
 587207                        if (reader.NodeType == XmlNodeType.Element)
 208                        {
 275209                            FetchDataFromXmlNode(reader, item);
 210                        }
 211                        else
 212                        {
 312213                            reader.Read();
 214                        }
 215                    }
 4216                }
 4217            }
 0218            catch (XmlException)
 219            {
 0220            }
 4221        }
 222
 223        /// <summary>
 224        /// Parses a XML tag to a provider id.
 225        /// </summary>
 226        /// <param name="item">The item.</param>
 227        /// <param name="xml">The xml tag.</param>
 228        protected void ParseProviderLinks(T item, ReadOnlySpan<char> xml)
 229        {
 8230            if (ProviderIdParsers.TryFindImdbId(xml, out var imdbId))
 231            {
 2232                item.SetProviderId(MetadataProvider.Imdb, imdbId.ToString());
 233            }
 234
 8235            if (item is Movie)
 236            {
 5237                if (ProviderIdParsers.TryFindTmdbMovieId(xml, out var tmdbId))
 238                {
 2239                    item.SetProviderId(MetadataProvider.Tmdb, tmdbId.ToString());
 240                }
 241            }
 242
 8243            if (item is Series)
 244            {
 2245                if (ProviderIdParsers.TryFindTmdbSeriesId(xml, out var tmdbId))
 246                {
 0247                    item.SetProviderId(MetadataProvider.Tmdb, tmdbId.ToString());
 248                }
 249
 2250                if (ProviderIdParsers.TryFindTvdbId(xml, out var tvdbId))
 251                {
 1252                    item.SetProviderId(MetadataProvider.Tvdb, tvdbId.ToString());
 253                }
 254            }
 8255        }
 256
 257        /// <summary>
 258        /// Fetches metadata from an XML node.
 259        /// </summary>
 260        /// <param name="reader">The <see cref="XmlReader"/>.</param>
 261        /// <param name="itemResult">The <see cref="MetadataResult{T}"/>.</param>
 262        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult<T> itemResult)
 263        {
 441264            var item = itemResult.Item;
 441265            var nfoConfiguration = _config.GetNfoConfiguration();
 266            UserItemData? userData;
 267
 441268            switch (reader.Name)
 269            {
 270                case "dateadded":
 5271                    if (reader.TryReadDateTime(out var dateCreated))
 272                    {
 5273                        item.DateCreated = dateCreated;
 274                    }
 275
 5276                    break;
 277                case "originaltitle":
 6278                    item.OriginalTitle = reader.ReadNormalizedString();
 6279                    break;
 280                case "name":
 281                case "title":
 282                case "localtitle":
 13283                    item.Name = reader.ReadNormalizedString();
 13284                    break;
 285                case "sortname":
 1286                    item.SortName = reader.ReadNormalizedString();
 1287                    break;
 288                case "criticrating":
 1289                    var criticRatingText = reader.ReadElementContentAsString();
 1290                    if (float.TryParse(criticRatingText, CultureInfo.InvariantCulture, out var value))
 291                    {
 1292                        item.CriticRating = value;
 293                    }
 294
 1295                    break;
 296                case "sorttitle":
 1297                    item.ForcedSortName = reader.ReadNormalizedString();
 1298                    break;
 299                case "biography":
 300                case "plot":
 301                case "review":
 11302                    item.Overview = reader.ReadNormalizedString();
 11303                    break;
 304                case "language":
 1305                    item.PreferredMetadataLanguage = reader.ReadNormalizedString();
 1306                    break;
 307                case "watched":
 8308                    var played = reader.ReadElementContentAsBoolean();
 8309                    if (Guid.TryParse(nfoConfiguration.UserId, out var userId))
 310                    {
 1311                        var user = _userManager.GetUserById(userId);
 1312                        if (user is not null)
 313                        {
 1314                            userData = _userDataManager.GetUserData(user, item);
 1315                            userData.Played = played;
 1316                            _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, CancellationT
 317                        }
 318                    }
 319
 1320                    break;
 321                case "playcount":
 4322                    if (reader.TryReadInt(out var count)
 4323                        && Guid.TryParse(nfoConfiguration.UserId, out var playCountUserId))
 324                    {
 1325                        var user = _userManager.GetUserById(playCountUserId);
 1326                        if (user is not null)
 327                        {
 1328                            userData = _userDataManager.GetUserData(user, item);
 1329                            userData.PlayCount = count;
 1330                            _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, CancellationT
 331                        }
 332                    }
 333
 1334                    break;
 335                case "lastplayed":
 4336                    if (reader.TryReadDateTime(out var lastPlayed)
 4337                        && Guid.TryParse(nfoConfiguration.UserId, out var lastPlayedUserId))
 338                    {
 1339                        var user = _userManager.GetUserById(lastPlayedUserId);
 1340                        if (user is not null)
 341                        {
 1342                            userData = _userDataManager.GetUserData(user, item);
 1343                            userData.LastPlayedDate = lastPlayed;
 1344                            _userDataManager.SaveUserData(user, item, userData, UserDataSaveReason.Import, CancellationT
 345                        }
 346                    }
 347
 1348                    break;
 349                case "countrycode":
 1350                    item.PreferredMetadataCountryCode = reader.ReadNormalizedString();
 1351                    break;
 352                case "lockedfields":
 353                    {
 0354                        var val = reader.ReadElementContentAsString();
 355
 0356                        if (!string.IsNullOrWhiteSpace(val))
 357                        {
 0358                            item.LockedFields = val.Split('|').Select(i =>
 0359                            {
 0360                                if (Enum.TryParse(i, true, out MetadataField field))
 0361                                {
 0362                                    return (MetadataField?)field;
 0363                                }
 0364
 0365                                return null;
 0366                            }).OfType<MetadataField>().ToArray();
 367                        }
 368
 0369                        break;
 370                    }
 371
 372                case "tagline":
 4373                    item.Tagline = reader.ReadNormalizedString();
 4374                    break;
 375                case "country":
 376                    {
 3377                        var val = reader.ReadElementContentAsString();
 378
 3379                        if (!string.IsNullOrWhiteSpace(val))
 380                        {
 3381                            item.ProductionLocations = val.Split('/')
 3382                                .Select(i => i.Trim())
 3383                                .Where(i => !string.IsNullOrWhiteSpace(i))
 3384                                .ToArray();
 385                        }
 386
 3387                        break;
 388                    }
 389
 390                case "mpaa":
 4391                    item.OfficialRating = reader.ReadNormalizedString();
 4392                    break;
 393                case "customrating":
 1394                    item.CustomRating = reader.ReadNormalizedString();
 1395                    break;
 396                case "runtime":
 4397                    var runtimeText = reader.ReadElementContentAsString();
 4398                    if (int.TryParse(runtimeText.AsSpan().LeftPart(' '), NumberStyles.Integer, CultureInfo.InvariantCult
 399                    {
 4400                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
 401                    }
 402
 4403                    break;
 404                case "aspectratio":
 1405                    var aspectRatio = reader.ReadNormalizedString();
 1406                    if (!string.IsNullOrEmpty(aspectRatio) && item is IHasAspectRatio hasAspectRatio)
 407                    {
 1408                        hasAspectRatio.AspectRatio = aspectRatio;
 409                    }
 410
 1411                    break;
 412                case "lockdata":
 1413                    item.IsLocked = string.Equals(reader.ReadElementContentAsString(), "true", StringComparison.OrdinalI
 1414                    break;
 415                case "studio":
 4416                    var studio = reader.ReadNormalizedString();
 4417                    if (!string.IsNullOrEmpty(studio))
 418                    {
 4419                        item.AddStudio(studio);
 420                    }
 421
 4422                    break;
 423                case "director":
 12424                    foreach (var director in reader.GetPersonArray(PersonKind.Director))
 425                    {
 3426                        itemResult.AddPerson(director);
 427                    }
 428
 429                    break;
 430                case "credits":
 431                    {
 4432                        var val = reader.ReadElementContentAsString();
 433
 4434                        if (!string.IsNullOrWhiteSpace(val))
 435                        {
 4436                            var parts = val.Split('/').Select(i => i.Trim())
 4437                                .Where(i => !string.IsNullOrEmpty(i));
 438
 16439                            foreach (var p in parts.Select(v => new PersonInfo { Name = v.Trim(), Type = PersonKind.Writ
 440                            {
 4441                                if (string.IsNullOrWhiteSpace(p.Name))
 442                                {
 443                                    continue;
 444                                }
 445
 4446                                itemResult.AddPerson(p);
 447                            }
 448                        }
 449
 450                        break;
 451                    }
 452
 453                case "writer":
 4454                    foreach (var writer in reader.GetPersonArray(PersonKind.Writer))
 455                    {
 1456                        itemResult.AddPerson(writer);
 457                    }
 458
 459                    break;
 460                case "actor":
 55461                    var person = reader.GetPersonFromXmlNode();
 55462                    if (person is not null)
 463                    {
 55464                        itemResult.AddPerson(person);
 465                    }
 466
 55467                    break;
 468                case "trailer":
 4469                    var trailer = reader.ReadNormalizedString();
 4470                    if (!string.IsNullOrEmpty(trailer))
 471                    {
 1472                        if (trailer.StartsWith("plugin://plugin.video.youtube/?action=play_video&videoid=", StringCompar
 473                        {
 474                            // Deprecated format
 1475                            item.AddTrailerUrl(trailer.Replace(
 1476                                "plugin://plugin.video.youtube/?action=play_video&videoid=",
 1477                                BaseNfoSaver.YouTubeWatchUrl,
 1478                                StringComparison.OrdinalIgnoreCase));
 479
 1480                            var suggestedUrl = trailer.Replace(
 1481                                "plugin://plugin.video.youtube/?action=play_video&videoid=",
 1482                                "plugin://plugin.video.youtube/play/?video_id=",
 1483                                StringComparison.OrdinalIgnoreCase);
 1484                            Logger.LogWarning("Trailer URL uses a deprecated format : {Url}. Using {NewUrl} instead is a
 485                        }
 0486                        else if (trailer.StartsWith("plugin://plugin.video.youtube/play/?video_id=", StringComparison.Or
 487                        {
 488                            // Proper format
 0489                            item.AddTrailerUrl(trailer.Replace(
 0490                                "plugin://plugin.video.youtube/play/?video_id=",
 0491                                BaseNfoSaver.YouTubeWatchUrl,
 0492                                StringComparison.OrdinalIgnoreCase));
 493                        }
 494                    }
 495
 0496                    break;
 497                case "displayorder":
 0498                    var displayOrder = reader.ReadNormalizedString();
 0499                    if (!string.IsNullOrEmpty(displayOrder) && item is IHasDisplayOrder hasDisplayOrder)
 500                    {
 0501                        hasDisplayOrder.DisplayOrder = displayOrder;
 502                    }
 503
 0504                    break;
 505                case "year":
 6506                    if (reader.TryReadInt(out var productionYear) && productionYear > 1850)
 507                    {
 6508                        item.ProductionYear = productionYear;
 509                    }
 510
 6511                    break;
 512                case "rating":
 7513                    var rating = reader.ReadElementContentAsString().Replace(',', '.');
 514                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
 7515                    if (float.TryParse(rating, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var com
 516                    {
 6517                        item.CommunityRating = communityRating;
 518                    }
 519
 6520                    break;
 521                case "ratings":
 3522                    FetchFromRatingsNode(reader, item);
 3523                    break;
 524                case "aired":
 525                case "formed":
 526                case "premiered":
 527                case "releasedate":
 19528                    if (reader.TryReadDateTimeExact(nfoConfiguration.ReleaseDateFormat, out var releaseDate))
 529                    {
 14530                        item.PremiereDate = releaseDate;
 531
 532                        // Production year can already be set by the year tag
 14533                        item.ProductionYear ??= releaseDate.Year;
 534                    }
 535
 536                    break;
 537                case "enddate":
 1538                    if (reader.TryReadDateTimeExact(nfoConfiguration.ReleaseDateFormat, out var endDate))
 539                    {
 1540                        item.EndDate = endDate;
 541                    }
 542
 1543                    break;
 544                case "genre":
 545                    {
 13546                        var val = reader.ReadElementContentAsString();
 547
 13548                        if (!string.IsNullOrWhiteSpace(val))
 549                        {
 13550                            var parts = val.Split('/')
 13551                                .Select(i => i.Trim())
 13552                                .Where(i => !string.IsNullOrWhiteSpace(i));
 553
 52554                            foreach (var p in parts)
 555                            {
 13556                                item.AddGenre(p);
 557                            }
 558                        }
 559
 560                        break;
 561                    }
 562
 563                case "style":
 564                case "tag":
 2565                    var tag = reader.ReadNormalizedString();
 2566                    if (!string.IsNullOrEmpty(tag))
 567                    {
 2568                        item.AddTag(tag);
 569                    }
 570
 2571                    break;
 572                case "fileinfo":
 3573                    FetchFromFileInfoNode(reader, item);
 3574                    break;
 575                case "uniqueid":
 6576                    if (reader.IsEmptyElement)
 577                    {
 0578                        reader.Read();
 0579                        break;
 580                    }
 581
 6582                    var provider = reader.GetAttribute("type");
 6583                    var providerId = reader.ReadElementContentAsString();
 6584                    item.TrySetProviderId(provider, providerId);
 585
 6586                    break;
 587                case "thumb":
 166588                    FetchThumbNode(reader, itemResult, "thumb");
 166589                    break;
 590                case "fanart":
 591                    {
 4592                        if (reader.IsEmptyElement)
 593                        {
 0594                            reader.Read();
 0595                            break;
 596                        }
 597
 4598                        using var subtree = reader.ReadSubtree();
 4599                        if (!subtree.ReadToDescendant("thumb"))
 600                        {
 0601                            break;
 602                        }
 603
 4604                        FetchThumbNode(subtree, itemResult, "fanart");
 4605                        break;
 606                    }
 607
 608                default:
 66609                    string readerName = reader.Name;
 66610                    if (_validProviderIds.TryGetValue(readerName, out string? providerIdValue))
 611                    {
 3612                        var id = reader.ReadElementContentAsString();
 3613                        item.TrySetProviderId(providerIdValue, id);
 614                    }
 615                    else
 616                    {
 63617                        reader.Skip();
 618                    }
 619
 620                    break;
 621            }
 113622        }
 623
 624        private void FetchThumbNode(XmlReader reader, MetadataResult<T> itemResult, string parentNode)
 625        {
 170626            var artType = reader.GetAttribute("aspect");
 170627            var val = reader.ReadElementContentAsString();
 628
 629            // artType is null if the thumb node is a child of the fanart tag
 630            // -> set image type to fanart
 170631            if (string.IsNullOrWhiteSpace(artType) && parentNode.Equals("fanart", StringComparison.Ordinal))
 632            {
 4633                artType = "fanart";
 634            }
 166635            else if (string.IsNullOrWhiteSpace(artType))
 636            {
 637                // Sonarr writes thumb tags for posters without aspect property
 14638                artType = "poster";
 639            }
 640
 641            // skip:
 642            // - empty uri
 643            // - tag containing '.' because we can't set images for seasons, episodes or movie sets within series or mov
 170644            if (string.IsNullOrEmpty(val) || artType.Contains('.', StringComparison.Ordinal))
 645            {
 11646                return;
 647            }
 648
 159649            ImageType imageType = GetImageType(artType);
 650
 159651            if (!Uri.TryCreate(val, UriKind.Absolute, out var uri))
 652            {
 1653                Logger.LogError("Image location {Path} specified in nfo file for {ItemName} is not a valid URL or file p
 1654                return;
 655            }
 656
 158657            if (uri.IsFile)
 658            {
 659                // only allow one item of each type
 2660                if (itemResult.Images.Any(x => x.Type == imageType))
 661                {
 0662                    return;
 663                }
 664
 2665                var fileSystemMetadata = _directoryService.GetFile(val);
 666                // non existing file returns null
 2667                if (fileSystemMetadata is null || !fileSystemMetadata.Exists)
 668                {
 1669                    Logger.LogWarning("Artwork file {Path} specified in nfo file for {ItemName} does not exist.", uri, i
 1670                    return;
 671                }
 672
 1673                itemResult.Images.Add(new LocalImageInfo()
 1674                {
 1675                    FileInfo = fileSystemMetadata,
 1676                    Type = imageType
 1677                });
 678            }
 679            else
 680            {
 681                // only allow one item of each type
 156682                if (itemResult.RemoteImages.Any(x => x.Type == imageType))
 683                {
 121684                    return;
 685                }
 686
 35687                itemResult.RemoteImages.Add((uri.ToString(), imageType));
 688            }
 35689        }
 690
 691        private void FetchFromFileInfoNode(XmlReader parentReader, T item)
 692        {
 3693            if (parentReader.IsEmptyElement)
 694            {
 0695                parentReader.Read();
 0696                return;
 697            }
 698
 3699            using var reader = parentReader.ReadSubtree();
 3700            reader.MoveToContent();
 3701            reader.Read();
 702
 703            // Loop through each element
 18704            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 705            {
 15706                if (reader.NodeType != XmlNodeType.Element)
 707                {
 12708                    reader.Read();
 12709                    continue;
 710                }
 711
 3712                switch (reader.Name)
 713                {
 714                    case "streamdetails":
 3715                        FetchFromStreamDetailsNode(reader, item);
 3716                        break;
 717                    default:
 0718                        reader.Skip();
 719                        break;
 720                }
 721            }
 6722        }
 723
 724        private void FetchFromStreamDetailsNode(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
 32737            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 738            {
 29739                if (reader.NodeType != XmlNodeType.Element)
 740                {
 20741                    reader.Read();
 20742                    continue;
 743                }
 744
 9745                switch (reader.Name)
 746                {
 747                    case "video":
 3748                        FetchFromVideoNode(reader, item);
 3749                        break;
 750                    case "subtitle":
 2751                        FetchFromSubtitleNode(reader, item);
 2752                        break;
 753                    default:
 4754                        reader.Skip();
 755                        break;
 756                }
 757            }
 6758        }
 759
 760        private void FetchFromVideoNode(XmlReader parentReader, T item)
 761        {
 3762            if (parentReader.IsEmptyElement)
 763            {
 0764                parentReader.Read();
 0765                return;
 766            }
 767
 3768            using var reader = parentReader.ReadSubtree();
 3769            reader.MoveToContent();
 3770            reader.Read();
 771
 772            // Loop through each element
 53773            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 774            {
 50775                if (reader.NodeType != XmlNodeType.Element || item is not Video video)
 776                {
 28777                    reader.Read();
 28778                    continue;
 779                }
 780
 22781                switch (reader.Name)
 782                {
 783                    case "format3d":
 1784                        var format = reader.ReadElementContentAsString();
 1785                        if (string.Equals("HSBS", format, StringComparison.OrdinalIgnoreCase))
 786                        {
 1787                            video.Video3DFormat = Video3DFormat.HalfSideBySide;
 788                        }
 0789                        else if (string.Equals("HTAB", format, StringComparison.OrdinalIgnoreCase))
 790                        {
 0791                            video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
 792                        }
 0793                        else if (string.Equals("FTAB", format, StringComparison.OrdinalIgnoreCase))
 794                        {
 0795                            video.Video3DFormat = Video3DFormat.FullTopAndBottom;
 796                        }
 0797                        else if (string.Equals("FSBS", format, StringComparison.OrdinalIgnoreCase))
 798                        {
 0799                            video.Video3DFormat = Video3DFormat.FullSideBySide;
 800                        }
 0801                        else if (string.Equals("MVC", format, StringComparison.OrdinalIgnoreCase))
 802                        {
 0803                            video.Video3DFormat = Video3DFormat.MVC;
 804                        }
 805
 0806                        break;
 807                    case "aspect":
 3808                        video.AspectRatio = reader.ReadNormalizedString();
 3809                        break;
 810                    case "width":
 3811                        video.Width = reader.ReadElementContentAsInt();
 3812                        break;
 813                    case "height":
 3814                        video.Height = reader.ReadElementContentAsInt();
 3815                        break;
 816                    case "durationinseconds":
 3817                        video.RunTimeTicks = new TimeSpan(0, 0, reader.ReadElementContentAsInt()).Ticks;
 3818                        break;
 819                    default:
 9820                        reader.Skip();
 821                        break;
 822                }
 823            }
 6824        }
 825
 826        private void FetchFromSubtitleNode(XmlReader parentReader, T item)
 827        {
 2828            if (parentReader.IsEmptyElement)
 829            {
 0830                parentReader.Read();
 0831                return;
 832            }
 833
 2834            using var reader = parentReader.ReadSubtree();
 2835            reader.MoveToContent();
 2836            reader.Read();
 837
 838            // Loop through each element
 10839            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 840            {
 8841                if (reader.NodeType != XmlNodeType.Element)
 842                {
 6843                    reader.Read();
 6844                    continue;
 845                }
 846
 2847                switch (reader.Name)
 848                {
 849                    case "language":
 2850                        _ = reader.ReadElementContentAsString();
 2851                        if (item is Video video)
 852                        {
 2853                            video.HasSubtitles = true;
 854                        }
 855
 2856                        break;
 857                    default:
 0858                        reader.Skip();
 859                        break;
 860                }
 861            }
 4862        }
 863
 864        private void FetchFromRatingsNode(XmlReader parentReader, T item)
 865        {
 3866            if (parentReader.IsEmptyElement)
 867            {
 0868                parentReader.Read();
 0869                return;
 870            }
 871
 3872            using var reader = parentReader.ReadSubtree();
 3873            reader.MoveToContent();
 3874            reader.Read();
 875
 876            // Loop through each element
 42877            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 878            {
 39879                if (reader.NodeType == XmlNodeType.Element)
 880                {
 11881                    switch (reader.Name)
 882                    {
 883                        case "rating":
 884                            {
 11885                                if (reader.IsEmptyElement)
 886                                {
 0887                                    reader.Read();
 0888                                    continue;
 889                                }
 890
 11891                                var ratingName = reader.GetAttribute("name");
 892
 11893                                using var subtree = reader.ReadSubtree();
 11894                                FetchFromRatingNode(subtree, item, ratingName);
 895
 11896                                break;
 897                            }
 898
 899                        default:
 0900                            reader.Skip();
 0901                            break;
 902                    }
 903                }
 904                else
 905                {
 28906                    reader.Read();
 907                }
 908            }
 6909        }
 910
 911        private void FetchFromRatingNode(XmlReader reader, T item, string? ratingName)
 912        {
 11913            reader.MoveToContent();
 11914            reader.Read();
 915
 916            // Loop through each element
 77917            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
 918            {
 66919                if (reader.NodeType == XmlNodeType.Element)
 920                {
 22921                    switch (reader.Name)
 922                    {
 923                        case "value":
 11924                            var val = reader.ReadElementContentAsString();
 925
 11926                            if (float.TryParse(val, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out va
 927                            {
 928                                // if ratingName contains tomato --> assume critic rating
 11929                                if (ratingName is not null
 11930                                    && ratingName.Contains("tomato", StringComparison.OrdinalIgnoreCase)
 11931                                    && !ratingName.Contains("audience", StringComparison.OrdinalIgnoreCase))
 932                                {
 2933                                    if (!ratingName.Contains("avg", StringComparison.OrdinalIgnoreCase))
 934                                    {
 2935                                        item.CriticRating = ratingValue;
 936                                    }
 937                                }
 938                                else
 939                                {
 9940                                    item.CommunityRating = ratingValue;
 941                                }
 942                            }
 943
 9944                            break;
 945                        default:
 11946                            reader.Skip();
 11947                            break;
 948                    }
 949                }
 950                else
 951                {
 44952                    reader.Read();
 953                }
 954            }
 11955        }
 956
 957        internal XmlReaderSettings GetXmlReaderSettings()
 16958            => new XmlReaderSettings()
 16959            {
 16960                ValidationType = ValidationType.None,
 16961                CheckCharacters = false,
 16962                IgnoreProcessingInstructions = true,
 16963                IgnoreComments = true
 16964            };
 965
 966        /// <summary>
 967        /// Parses the <see cref="ImageType"/> from the NFO aspect property.
 968        /// </summary>
 969        /// <param name="aspect">The NFO aspect property.</param>
 970        /// <returns>The <see cref="ImageType"/>.</returns>
 971        private static ImageType GetImageType(string aspect)
 972        {
 159973            return aspect switch
 159974            {
 23975                "banner" => ImageType.Banner,
 23976                "clearlogo" => ImageType.Logo,
 12977                "discart" => ImageType.Disc,
 18978                "landscape" => ImageType.Thumb,
 8979                "clearart" => ImageType.Art,
 6980                "fanart" => ImageType.Backdrop,
 159981                // unknown type (including "poster") --> primary
 69982                _ => ImageType.Primary,
 159983            };
 984        }
 985    }
 986}
Generated by: ReportGenerator 5.3.8.0
9/19/2024 - 12:16:38 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.Extensions.Logging.ILogger,MediaBrowser.Common.Configuration.IConfigurationManager,MediaBrowser.Controller.Providers.IProviderManager,MediaBrowser.Controller.Library.IUserManager,MediaBrowser.Controller.Library.IUserDataManager,MediaBrowser.Controller.Providers.IDirectoryService)
get_SupportsUrlAfterClosingXmlTag()
Fetch(MediaBrowser.Controller.Providers.MetadataResult`1<T>,System.String,System.Threading.CancellationToken)
Fetch(MediaBrowser.Controller.Providers.MetadataResult`1<T>,System.String,System.Xml.XmlReaderSettings,System.Threading.CancellationToken)
ParseProviderLinks(T,System.ReadOnlySpan`1<System.Char>)
FetchDataFromXmlNode(System.Xml.XmlReader,MediaBrowser.Controller.Providers.MetadataResult`1<T>)
FetchThumbNode(System.Xml.XmlReader,MediaBrowser.Controller.Providers.MetadataResult`1<T>,System.String)
FetchFromFileInfoNode(System.Xml.XmlReader,T)
FetchFromStreamDetailsNode(System.Xml.XmlReader,T)
FetchFromVideoNode(System.Xml.XmlReader,T)
FetchFromSubtitleNode(System.Xml.XmlReader,T)
FetchFromRatingsNode(System.Xml.XmlReader,T)
FetchFromRatingNode(System.Xml.XmlReader,T,System.String)
GetXmlReaderSettings()
GetImageType(System.String)