2019-01-13 21:02:23 +01:00
|
|
|
using System;
|
2013-02-21 02:33:05 +01:00
|
|
|
using System.Collections.Generic;
|
2013-06-13 21:01:28 +02:00
|
|
|
using System.Globalization;
|
|
|
|
using System.IO;
|
2013-02-21 02:33:05 +01:00
|
|
|
using System.Linq;
|
2013-06-13 21:01:28 +02:00
|
|
|
using System.Text;
|
2013-02-21 02:33:05 +01:00
|
|
|
using System.Threading;
|
|
|
|
using System.Xml;
|
2023-03-25 18:52:02 +01:00
|
|
|
using Jellyfin.Data.Enums;
|
2021-09-19 20:53:31 +02:00
|
|
|
using Jellyfin.Extensions;
|
2016-10-25 21:02:04 +02:00
|
|
|
using MediaBrowser.Controller.Entities;
|
2023-10-06 18:46:35 +02:00
|
|
|
using MediaBrowser.Controller.Extensions;
|
2023-03-10 17:46:59 +01:00
|
|
|
using MediaBrowser.Controller.Playlists;
|
2016-10-25 21:02:04 +02:00
|
|
|
using MediaBrowser.Controller.Providers;
|
|
|
|
using MediaBrowser.Model.Entities;
|
2019-01-13 20:25:45 +01:00
|
|
|
using Microsoft.Extensions.Logging;
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2016-10-25 21:02:04 +02:00
|
|
|
namespace MediaBrowser.LocalMetadata.Parsers
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
/// <summary>
|
2020-06-14 04:04:53 +02:00
|
|
|
/// Provides a base class for parsing metadata xml.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
2020-06-14 04:04:53 +02:00
|
|
|
/// <typeparam name="T">Type of item xml parser.</typeparam>
|
2013-02-21 02:33:05 +01:00
|
|
|
public class BaseItemXmlParser<T>
|
2014-02-06 05:39:16 +01:00
|
|
|
where T : BaseItem
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
private Dictionary<string, string>? _validProviderIds;
|
2013-02-21 21:26:35 +01:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Initializes a new instance of the <see cref="BaseItemXmlParser{T}" /> class.
|
|
|
|
/// </summary>
|
2020-06-14 04:04:53 +02:00
|
|
|
/// <param name="logger">Instance of the <see cref="ILogger{BaseItemXmlParser}"/> interface.</param>
|
|
|
|
/// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
|
2020-06-06 02:15:56 +02:00
|
|
|
public BaseItemXmlParser(ILogger<BaseItemXmlParser<T>> logger, IProviderManager providerManager)
|
2013-02-21 21:26:35 +01:00
|
|
|
{
|
|
|
|
Logger = logger;
|
2016-08-27 06:33:18 +02:00
|
|
|
ProviderManager = providerManager;
|
2013-02-21 21:26:35 +01:00
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
2020-06-14 04:04:53 +02:00
|
|
|
/// Gets the logger.
|
|
|
|
/// </summary>
|
|
|
|
protected ILogger<BaseItemXmlParser<T>> Logger { get; private set; }
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the provider manager.
|
|
|
|
/// </summary>
|
|
|
|
protected IProviderManager ProviderManager { get; private set; }
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Fetches metadata for an item from one xml file.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
/// <param name="metadataFile">The metadata file.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
2020-06-14 04:04:53 +02:00
|
|
|
/// <exception cref="ArgumentNullException">Item is null.</exception>
|
2015-06-29 03:10:45 +02:00
|
|
|
public void Fetch(MetadataResult<T> item, string metadataFile, CancellationToken cancellationToken)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2022-10-06 20:21:23 +02:00
|
|
|
ArgumentNullException.ThrowIfNull(item);
|
2022-10-13 19:08:00 +02:00
|
|
|
ArgumentException.ThrowIfNullOrEmpty(metadataFile);
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
var settings = new XmlReaderSettings
|
2019-02-01 17:43:31 +01:00
|
|
|
{
|
|
|
|
ValidationType = ValidationType.None,
|
|
|
|
CheckCharacters = false,
|
|
|
|
IgnoreProcessingInstructions = true,
|
|
|
|
IgnoreComments = true
|
|
|
|
};
|
2016-10-30 08:02:23 +01:00
|
|
|
|
2022-11-01 11:46:29 +01:00
|
|
|
_validProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
2016-08-27 06:33:18 +02:00
|
|
|
|
|
|
|
var idInfos = ProviderManager.GetExternalIdInfos(item.Item);
|
|
|
|
|
|
|
|
foreach (var info in idInfos)
|
|
|
|
{
|
|
|
|
var id = info.Key + "Id";
|
2023-04-06 19:16:12 +02:00
|
|
|
_validProviderIds.TryAdd(id, info.Key);
|
2016-08-27 06:33:18 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
// Additional Mappings
|
2016-08-27 06:33:18 +02:00
|
|
|
_validProviderIds.Add("IMDB", "Imdb");
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
// Fetch(item, metadataFile, settings, Encoding.GetEncoding("ISO-8859-1"), cancellationToken);
|
2016-04-20 06:30:06 +02:00
|
|
|
Fetch(item, metadataFile, settings, Encoding.UTF8, cancellationToken);
|
2013-06-25 04:02:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Fetches the specified item.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
/// <param name="metadataFile">The metadata file.</param>
|
|
|
|
/// <param name="settings">The settings.</param>
|
|
|
|
/// <param name="encoding">The encoding.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
2015-06-29 03:10:45 +02:00
|
|
|
private void Fetch(MetadataResult<T> item, string metadataFile, XmlReaderSettings settings, Encoding encoding, CancellationToken cancellationToken)
|
2013-06-25 04:02:52 +02:00
|
|
|
{
|
2015-07-24 04:48:10 +02:00
|
|
|
item.ResetPeople();
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
using var fileStream = File.OpenRead(metadataFile);
|
|
|
|
using var streamReader = new StreamReader(fileStream, encoding);
|
|
|
|
using var reader = XmlReader.Create(streamReader, settings);
|
|
|
|
reader.MoveToContent();
|
|
|
|
reader.Read();
|
|
|
|
|
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
2019-02-02 16:12:16 +01:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
FetchDataFromXmlNode(reader, item);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
2020-06-14 04:04:53 +02:00
|
|
|
/// Fetches metadata from one Xml Element.
|
2013-02-21 02:33:05 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="reader">The reader.</param>
|
2015-06-29 03:10:45 +02:00
|
|
|
/// <param name="itemResult">The item result.</param>
|
|
|
|
protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult<T> itemResult)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2015-06-29 03:10:45 +02:00
|
|
|
var item = itemResult.Item;
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Added":
|
2023-10-06 22:56:50 +02:00
|
|
|
if (reader.TryReadDateTime(out var dateCreated))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 20:18:56 +02:00
|
|
|
item.DateCreated = dateCreated;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2015-03-10 02:30:20 +01:00
|
|
|
case "OriginalTitle":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.OriginalTitle = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "LocalTitle":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.Name = reader.ReadNormalizedString();
|
2013-02-21 02:33:05 +01:00
|
|
|
break;
|
2013-06-25 03:22:21 +02:00
|
|
|
case "CriticRating":
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
var text = reader.ReadElementContentAsString();
|
2013-11-06 17:06:16 +01:00
|
|
|
|
2023-02-19 16:52:29 +01:00
|
|
|
if (float.TryParse(text, CultureInfo.InvariantCulture, out var value))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-02-19 16:52:29 +01:00
|
|
|
item.CriticRating = value;
|
2013-04-22 19:35:42 +02:00
|
|
|
}
|
2013-09-23 00:42:21 +02:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-01-15 06:01:58 +01:00
|
|
|
case "SortTitle":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.ForcedSortName = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "Overview":
|
|
|
|
case "Description":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.Overview = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-12-05 17:50:21 +01:00
|
|
|
case "Language":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.PreferredMetadataLanguage = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2015-02-15 04:36:07 +01:00
|
|
|
case "CountryCode":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.PreferredMetadataCountryCode = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-07-29 20:33:48 +02:00
|
|
|
case "PlaceOfBirth":
|
2023-10-06 20:53:05 +02:00
|
|
|
var placeOfBirth = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(placeOfBirth) && item is Person person)
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 20:53:05 +02:00
|
|
|
person.ProductionLocations = new[] { placeOfBirth };
|
2013-07-29 20:33:48 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-08-04 02:59:23 +02:00
|
|
|
case "LockedFields":
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
var val = reader.ReadElementContentAsString();
|
2013-08-04 02:59:23 +02:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
if (!string.IsNullOrWhiteSpace(val))
|
|
|
|
{
|
|
|
|
item.LockedFields = val.Split('|').Select(i =>
|
2013-08-04 02:59:23 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
if (Enum.TryParse(i, true, out MetadataField field))
|
2013-08-04 02:59:23 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
return (MetadataField?)field;
|
|
|
|
}
|
2013-08-04 02:59:23 +02:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
return null;
|
|
|
|
}).Where(i => i.HasValue).Select(i => i!.Value).ToArray();
|
2013-08-04 02:59:23 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
case "TagLines":
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
using (var subtree = reader.ReadSubtree())
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
FetchFromTaglinesNode(subtree, item);
|
2016-12-04 00:57:34 +01:00
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2014-05-16 21:16:29 +02:00
|
|
|
case "Countries":
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
2014-05-16 21:16:29 +02:00
|
|
|
{
|
2023-10-06 20:53:05 +02:00
|
|
|
reader.Skip();
|
2020-06-14 04:04:53 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
2014-05-16 21:16:29 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
case "ContentRating":
|
|
|
|
case "MPAARating":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.OfficialRating = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "CustomRating":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.CustomRating = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "RunningTime":
|
2023-10-06 21:35:26 +02:00
|
|
|
var runtimeText = reader.ReadElementContentAsString();
|
|
|
|
if (!string.IsNullOrWhiteSpace(runtimeText))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 21:35:26 +02:00
|
|
|
if (int.TryParse(runtimeText.AsSpan().LeftPart(' '), NumberStyles.Integer, CultureInfo.InvariantCulture, out var runtime))
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "AspectRatio":
|
2023-10-06 20:53:05 +02:00
|
|
|
var aspectRatio = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(aspectRatio) && item is IHasAspectRatio hasAspectRatio)
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 20:53:05 +02:00
|
|
|
hasAspectRatio.AspectRatio = aspectRatio;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-06-27 15:31:49 +02:00
|
|
|
case "LockData":
|
2023-10-06 22:18:33 +02:00
|
|
|
item.IsLocked = string.Equals(reader.ReadElementContentAsString(), "true", StringComparison.OrdinalIgnoreCase);
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "Network":
|
2023-10-06 19:40:08 +02:00
|
|
|
foreach (var name in reader.GetStringArray())
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
item.AddStudio(name);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "Director":
|
2023-10-06 19:40:08 +02:00
|
|
|
foreach (var director in reader.GetPersonArray(PersonKind.Director))
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2023-10-06 19:40:08 +02:00
|
|
|
itemResult.AddPerson(director);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
|
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "Writer":
|
2023-10-06 19:40:08 +02:00
|
|
|
foreach (var writer in reader.GetPersonArray(PersonKind.Writer))
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2023-10-06 19:40:08 +02:00
|
|
|
itemResult.AddPerson(writer);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
case "Actors":
|
2023-10-06 19:40:08 +02:00
|
|
|
foreach (var actor in reader.GetPersonArray(PersonKind.Actor))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 19:40:08 +02:00
|
|
|
itemResult.AddPerson(actor);
|
2013-04-14 01:43:41 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
case "GuestStars":
|
2023-10-06 19:40:08 +02:00
|
|
|
foreach (var guestStar in reader.GetPersonArray(PersonKind.GuestStar))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 19:40:08 +02:00
|
|
|
itemResult.AddPerson(guestStar);
|
2014-01-03 21:32:27 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
case "Trailer":
|
2023-10-06 20:53:05 +02:00
|
|
|
var trailer = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(trailer))
|
2014-01-03 21:32:27 +01:00
|
|
|
{
|
2023-10-06 20:53:05 +02:00
|
|
|
item.AddTrailerUrl(trailer);
|
2020-06-14 04:04:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
case "DisplayOrder":
|
2023-10-06 20:53:05 +02:00
|
|
|
var displayOrder = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(displayOrder) && item is IHasDisplayOrder hasDisplayOrder)
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 20:53:05 +02:00
|
|
|
hasDisplayOrder.DisplayOrder = displayOrder;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-12-01 21:17:40 +01:00
|
|
|
case "Trailers":
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
2013-12-01 21:17:40 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
using var subtree = reader.ReadSubtree();
|
|
|
|
FetchDataFromTrailersNode(subtree, item);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
2013-12-01 21:17:40 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
case "ProductionYear":
|
2023-10-06 21:35:26 +02:00
|
|
|
if (reader.TryReadInt(out var productionYear) && productionYear > 1850)
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 21:35:26 +02:00
|
|
|
item.ProductionYear = productionYear;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
case "Rating":
|
|
|
|
case "IMDBrating":
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
var rating = reader.ReadElementContentAsString();
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
if (!string.IsNullOrWhiteSpace(rating))
|
|
|
|
{
|
|
|
|
// All external meta is saving this as '.' for decimal I believe...but just to be sure
|
|
|
|
if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
item.CommunityRating = val;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-07-20 23:36:59 +02:00
|
|
|
case "BirthDate":
|
2013-06-23 20:55:30 +02:00
|
|
|
case "PremiereDate":
|
2013-02-21 02:33:05 +01:00
|
|
|
case "FirstAired":
|
2023-10-06 20:18:56 +02:00
|
|
|
if (reader.TryReadDateTimeExact("yyyy-MM-dd", out var firstAired))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 20:18:56 +02:00
|
|
|
item.PremiereDate = firstAired;
|
|
|
|
item.ProductionYear = firstAired.Year;
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-07-29 20:33:48 +02:00
|
|
|
case "DeathDate":
|
|
|
|
case "EndDate":
|
2023-10-06 20:18:56 +02:00
|
|
|
if (reader.TryReadDateTimeExact("yyyy-MM-dd", out var endDate))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 20:18:56 +02:00
|
|
|
item.EndDate = endDate;
|
2013-07-29 20:33:48 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2016-08-31 16:01:07 +02:00
|
|
|
case "CollectionNumber":
|
2023-10-06 20:53:05 +02:00
|
|
|
var tmdbCollection = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(tmdbCollection))
|
2013-06-23 19:48:30 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
item.SetProviderId(MetadataProvider.TmdbCollection, tmdbCollection);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case "Genres":
|
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
|
|
|
{
|
|
|
|
using var subtree = reader.ReadSubtree();
|
|
|
|
FetchFromGenresNode(subtree, item);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case "Tags":
|
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
|
|
|
{
|
|
|
|
using var subtree = reader.ReadSubtree();
|
|
|
|
FetchFromTagsNode(subtree, item);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case "Persons":
|
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
|
|
|
{
|
|
|
|
using var subtree = reader.ReadSubtree();
|
|
|
|
FetchDataFromPersonsNode(subtree, itemResult);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case "Studios":
|
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
|
|
|
{
|
|
|
|
using var subtree = reader.ReadSubtree();
|
|
|
|
FetchFromStudiosNode(subtree, item);
|
2013-06-23 19:48:30 +02:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
reader.Read();
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case "Shares":
|
|
|
|
{
|
|
|
|
if (!reader.IsEmptyElement)
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
using var subtree = reader.ReadSubtree();
|
|
|
|
if (item is IHasShares hasShares)
|
2016-12-04 00:57:34 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
FetchFromSharesNode(subtree, hasShares);
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
reader.Read();
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-03-10 17:46:59 +01:00
|
|
|
case "OwnerUserId":
|
|
|
|
{
|
|
|
|
var val = reader.ReadElementContentAsString();
|
|
|
|
|
|
|
|
if (Guid.TryParse(val, out var guid) && !guid.Equals(Guid.Empty))
|
|
|
|
{
|
|
|
|
if (item is Playlist playlist)
|
|
|
|
{
|
|
|
|
playlist.OwnerUserId = guid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
case "Format3D":
|
|
|
|
{
|
|
|
|
var val = reader.ReadElementContentAsString();
|
|
|
|
|
|
|
|
if (item is Video video)
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
video.Video3DFormat = Video3DFormat.HalfSideBySide;
|
2016-12-04 00:57:34 +01:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
|
2016-12-04 00:57:34 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
|
2014-12-13 04:56:30 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
video.Video3DFormat = Video3DFormat.FullTopAndBottom;
|
2014-12-13 04:56:30 +01:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
|
2016-12-04 00:57:34 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
video.Video3DFormat = Video3DFormat.FullSideBySide;
|
2016-12-04 00:57:34 +01:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
video.Video3DFormat = Video3DFormat.MVC;
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
|
|
|
}
|
2013-06-26 18:08:16 +02:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
default:
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
string readerName = reader.Name;
|
2020-11-13 16:31:02 +01:00
|
|
|
if (_validProviderIds!.TryGetValue(readerName, out string? providerIdValue))
|
2016-10-09 09:18:43 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
var id = reader.ReadElementContentAsString();
|
|
|
|
if (!string.IsNullOrWhiteSpace(id))
|
2016-08-27 06:33:18 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
item.SetProviderId(providerIdValue, id);
|
2016-08-27 06:33:18 +02:00
|
|
|
}
|
2016-09-05 22:07:36 +02:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Skip();
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
2014-05-16 21:16:29 +02:00
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
|
2014-12-13 04:56:30 +01:00
|
|
|
private void FetchFromSharesNode(XmlReader reader, IHasShares item)
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var list = new List<Share>();
|
|
|
|
|
2014-12-13 04:56:30 +01:00
|
|
|
reader.MoveToContent();
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.Read();
|
2014-12-13 04:56:30 +01:00
|
|
|
|
2016-12-03 22:46:06 +01:00
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2014-12-13 04:56:30 +01:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Share":
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
if (reader.IsEmptyElement)
|
2014-12-13 04:56:30 +01:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
reader.Read();
|
|
|
|
continue;
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
using (var subReader = reader.ReadSubtree())
|
|
|
|
{
|
|
|
|
var child = GetShare(subReader);
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2022-12-05 15:01:13 +01:00
|
|
|
if (child is not null)
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
list.Add(child);
|
2014-12-13 04:56:30 +01:00
|
|
|
}
|
|
|
|
}
|
2020-06-14 04:04:53 +02:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-12-13 04:56:30 +01:00
|
|
|
default:
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
2014-12-13 04:56:30 +01:00
|
|
|
}
|
|
|
|
}
|
2016-12-03 22:46:06 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2014-12-13 04:56:30 +01:00
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
item.Shares = list.ToArray();
|
2014-12-13 04:56:30 +01:00
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Fetches from taglines node.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="reader">The reader.</param>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
private void FetchFromTaglinesNode(XmlReader reader, T item)
|
|
|
|
{
|
|
|
|
reader.MoveToContent();
|
2016-11-02 18:08:20 +01:00
|
|
|
reader.Read();
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2016-11-02 18:08:20 +01:00
|
|
|
// Loop through each element
|
2016-12-03 22:46:06 +01:00
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Tagline":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.Tagline = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
default:
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-11-02 18:08:20 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Fetches from genres node.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="reader">The reader.</param>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
private void FetchFromGenresNode(XmlReader reader, T item)
|
|
|
|
{
|
|
|
|
reader.MoveToContent();
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.Read();
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2016-12-03 22:46:06 +01:00
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Genre":
|
2023-10-06 20:53:05 +02:00
|
|
|
var genre = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(genre))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
item.AddGenre(genre);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
default:
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-12-03 22:46:06 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-02 19:43:29 +02:00
|
|
|
private void FetchFromTagsNode(XmlReader reader, BaseItem item)
|
2013-06-23 20:55:30 +02:00
|
|
|
{
|
|
|
|
reader.MoveToContent();
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.Read();
|
2013-06-23 20:55:30 +02:00
|
|
|
|
2017-08-09 21:56:38 +02:00
|
|
|
var tags = new List<string>();
|
|
|
|
|
2016-12-03 22:46:06 +01:00
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2013-06-23 20:55:30 +02:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Tag":
|
2023-10-06 20:53:05 +02:00
|
|
|
var tag = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(tag))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
tags.Add(tag);
|
2014-01-14 16:50:39 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2014-01-14 16:50:39 +01:00
|
|
|
default:
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-12-03 22:46:06 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2013-06-23 20:55:30 +02:00
|
|
|
}
|
2017-08-09 21:56:38 +02:00
|
|
|
|
|
|
|
item.Tags = tags.Distinct(StringComparer.Ordinal).ToArray();
|
2013-06-23 20:55:30 +02:00
|
|
|
}
|
|
|
|
|
2013-02-21 02:33:05 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Fetches the data from persons node.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="reader">The reader.</param>
|
|
|
|
/// <param name="item">The item.</param>
|
2015-06-29 03:10:45 +02:00
|
|
|
private void FetchDataFromPersonsNode(XmlReader reader, MetadataResult<T> item)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
reader.MoveToContent();
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.Read();
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2016-12-03 22:46:06 +01:00
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Person":
|
2013-04-30 17:25:30 +02:00
|
|
|
case "Actor":
|
2023-10-06 18:46:35 +02:00
|
|
|
var person = reader.GetPersonFromXmlNode();
|
|
|
|
if (person is not null)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
2023-10-06 18:46:35 +02:00
|
|
|
item.AddPerson(person);
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-08-12 21:18:31 +02:00
|
|
|
default:
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-12-03 22:46:06 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private void FetchDataFromTrailersNode(XmlReader reader, T item)
|
2013-12-01 21:17:40 +01:00
|
|
|
{
|
|
|
|
reader.MoveToContent();
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.Read();
|
2013-12-01 21:17:40 +01:00
|
|
|
|
2016-12-03 22:46:06 +01:00
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2013-12-01 21:17:40 +01:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Trailer":
|
2023-10-06 20:53:05 +02:00
|
|
|
var trailer = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(trailer))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
2023-10-06 20:53:05 +02:00
|
|
|
item.AddTrailerUrl(trailer);
|
2013-12-01 21:17:40 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-12-01 21:17:40 +01:00
|
|
|
default:
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-12-03 22:46:06 +01:00
|
|
|
else
|
2013-08-12 21:18:31 +02:00
|
|
|
{
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.Read();
|
2013-08-12 21:18:31 +02:00
|
|
|
}
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Fetches from studios node.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="reader">The reader.</param>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
private void FetchFromStudiosNode(XmlReader reader, T item)
|
|
|
|
{
|
|
|
|
reader.MoveToContent();
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.Read();
|
2013-02-21 02:33:05 +01:00
|
|
|
|
2016-12-03 22:46:06 +01:00
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2013-02-21 02:33:05 +01:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "Studio":
|
2023-10-06 20:53:05 +02:00
|
|
|
var studio = reader.ReadNormalizedString();
|
|
|
|
if (!string.IsNullOrEmpty(studio))
|
2020-06-14 04:04:53 +02:00
|
|
|
{
|
|
|
|
item.AddStudio(studio);
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2013-02-21 02:33:05 +01:00
|
|
|
default:
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-12-03 22:46:06 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Get linked child.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="reader">The xml reader.</param>
|
|
|
|
/// <returns>The linked child.</returns>
|
|
|
|
protected LinkedChild? GetLinkedChild(XmlReader reader)
|
2014-08-03 04:16:37 +02:00
|
|
|
{
|
2020-06-14 04:04:53 +02:00
|
|
|
var linkedItem = new LinkedChild { Type = LinkedChildType.Manual };
|
2014-08-03 04:16:37 +02:00
|
|
|
|
2016-12-03 22:46:06 +01:00
|
|
|
reader.MoveToContent();
|
|
|
|
reader.Read();
|
|
|
|
|
|
|
|
// Loop through each element
|
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2014-08-03 04:16:37 +02:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
2014-08-05 05:41:56 +02:00
|
|
|
case "Path":
|
2023-10-06 20:53:05 +02:00
|
|
|
linkedItem.Path = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2018-09-12 19:26:21 +02:00
|
|
|
case "ItemId":
|
2023-10-06 20:53:05 +02:00
|
|
|
linkedItem.LibraryItemId = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2014-08-03 04:16:37 +02:00
|
|
|
default:
|
|
|
|
reader.Skip();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-12-03 22:46:06 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2014-08-03 04:16:37 +02:00
|
|
|
}
|
|
|
|
|
2014-12-09 05:57:18 +01:00
|
|
|
// This is valid
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!string.IsNullOrWhiteSpace(linkedItem.Path) || !string.IsNullOrWhiteSpace(linkedItem.LibraryItemId))
|
2014-12-09 05:57:18 +01:00
|
|
|
{
|
|
|
|
return linkedItem;
|
|
|
|
}
|
|
|
|
|
2015-04-01 06:23:34 +02:00
|
|
|
return null;
|
2014-08-03 04:16:37 +02:00
|
|
|
}
|
|
|
|
|
2020-06-14 04:04:53 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Get share.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="reader">The xml reader.</param>
|
|
|
|
/// <returns>The share.</returns>
|
|
|
|
protected Share? GetShare(XmlReader reader)
|
2015-04-26 06:39:40 +02:00
|
|
|
{
|
|
|
|
var item = new Share();
|
|
|
|
|
2016-11-02 18:29:06 +01:00
|
|
|
reader.MoveToContent();
|
|
|
|
reader.Read();
|
|
|
|
|
|
|
|
// Loop through each element
|
2016-12-03 22:46:06 +01:00
|
|
|
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
|
2015-04-26 06:39:40 +02:00
|
|
|
{
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
|
|
{
|
|
|
|
switch (reader.Name)
|
|
|
|
{
|
|
|
|
case "UserId":
|
2023-10-06 20:53:05 +02:00
|
|
|
item.UserId = reader.ReadNormalizedString();
|
2020-06-14 04:04:53 +02:00
|
|
|
break;
|
2015-04-26 06:39:40 +02:00
|
|
|
case "CanEdit":
|
2020-06-14 04:04:53 +02:00
|
|
|
item.CanEdit = string.Equals(reader.ReadElementContentAsString(), "true", StringComparison.OrdinalIgnoreCase);
|
|
|
|
break;
|
2015-04-26 06:39:40 +02:00
|
|
|
default:
|
2020-06-14 04:04:53 +02:00
|
|
|
reader.Skip();
|
|
|
|
break;
|
2015-04-26 06:39:40 +02:00
|
|
|
}
|
|
|
|
}
|
2016-11-02 18:29:06 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
reader.Read();
|
|
|
|
}
|
2015-04-26 06:39:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// This is valid
|
|
|
|
if (!string.IsNullOrWhiteSpace(item.UserId))
|
|
|
|
{
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
2013-02-21 02:33:05 +01:00
|
|
|
}
|
|
|
|
}
|