jellyfin-server/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs

744 lines
25 KiB
C#
Raw Normal View History

2016-10-27 05:11:31 +00:00
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
2016-10-30 07:02:23 +00:00
using System.Security;
2016-10-27 05:11:31 +00:00
using System.Text;
using System.Threading;
using System.Xml;
using MediaBrowser.Common.Extensions;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Persistence;
2016-10-30 07:02:23 +00:00
using MediaBrowser.Controller.Playlists;
2016-10-27 05:11:31 +00:00
using MediaBrowser.Model.Configuration;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Extensions;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Xml;
namespace MediaBrowser.LocalMetadata.Savers
{
2016-10-28 18:45:56 +00:00
public abstract class BaseXmlSaver : IMetadataFileSaver
2016-10-27 05:11:31 +00:00
{
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
private static readonly Dictionary<string, string> CommonTags = new[] {
2016-10-28 18:45:56 +00:00
"Added",
"AspectRatio",
"AudioDbAlbumId",
"AudioDbArtistId",
"AwardSummary",
"BirthDate",
"Budget",
// Deprecated. No longer saving in this field.
"certification",
"Chapters",
"ContentRating",
"Countries",
"CustomRating",
"CriticRating",
"CriticRatingSummary",
"DeathDate",
"DisplayOrder",
"EndDate",
"Genres",
"Genre",
"GamesDbId",
// Deprecated. No longer saving in this field.
"IMDB_ID",
"IMDB",
// Deprecated. No longer saving in this field.
"IMDbId",
"Language",
"LocalTitle",
"OriginalTitle",
"LockData",
"LockedFields",
"Format3D",
"Metascore",
// Deprecated. No longer saving in this field.
"MPAARating",
"MPAADescription",
"MusicBrainzArtistId",
"MusicBrainzAlbumArtistId",
"MusicBrainzAlbumId",
"MusicBrainzReleaseGroupId",
// Deprecated. No longer saving in this field.
"MusicbrainzId",
"Overview",
"ShortOverview",
"Persons",
"PlotKeywords",
"PremiereDate",
"ProductionYear",
"Rating",
"Revenue",
"RottenTomatoesId",
"RunningTime",
// Deprecated. No longer saving in this field.
"Runtime",
"SortTitle",
"Studios",
"Tags",
// Deprecated. No longer saving in this field.
"TagLine",
"Taglines",
"TMDbCollectionId",
"TMDbId",
// Deprecated. No longer saving in this field.
"Trailer",
"Trailers",
"TVcomId",
"TvDbId",
"Type",
"TVRageId",
"VoteCount",
"Website",
"Zap2ItId",
"CollectionItems",
"PlaylistItems",
"Shares"
2016-10-27 05:11:31 +00:00
}.ToDictionary(i => i, StringComparer.OrdinalIgnoreCase);
2016-10-28 18:45:56 +00:00
public BaseXmlSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager, ILogger logger, IXmlReaderSettingsFactory xmlReaderSettingsFactory)
2016-10-27 05:11:31 +00:00
{
2016-10-28 18:45:56 +00:00
FileSystem = fileSystem;
ConfigurationManager = configurationManager;
LibraryManager = libraryManager;
UserManager = userManager;
UserDataManager = userDataManager;
2016-10-27 05:11:31 +00:00
Logger = logger;
XmlReaderSettingsFactory = xmlReaderSettingsFactory;
}
protected IFileSystem FileSystem { get; private set; }
protected IServerConfigurationManager ConfigurationManager { get; private set; }
protected ILibraryManager LibraryManager { get; private set; }
protected IUserManager UserManager { get; private set; }
protected IUserDataManager UserDataManager { get; private set; }
protected ILogger Logger { get; private set; }
protected IXmlReaderSettingsFactory XmlReaderSettingsFactory { get; private set; }
protected ItemUpdateType MinimumUpdateType
{
get
{
return ItemUpdateType.MetadataDownload;
}
}
public string Name
{
get
{
2016-10-28 18:45:56 +00:00
return XmlProviderUtils.Name;
2016-10-27 05:11:31 +00:00
}
}
public string GetSavePath(IHasMetadata item)
{
return GetLocalSavePath(item);
}
/// <summary>
/// Gets the save path.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>System.String.</returns>
protected abstract string GetLocalSavePath(IHasMetadata item);
/// <summary>
/// Gets the name of the root element.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>System.String.</returns>
2016-10-30 07:02:23 +00:00
protected virtual string GetRootElementName(IHasMetadata item)
{
return "Item";
}
2016-10-27 05:11:31 +00:00
/// <summary>
/// Determines whether [is enabled for] [the specified item].
/// </summary>
/// <param name="item">The item.</param>
/// <param name="updateType">Type of the update.</param>
/// <returns><c>true</c> if [is enabled for] [the specified item]; otherwise, <c>false</c>.</returns>
public abstract bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType);
protected virtual List<string> GetTagsUsed()
{
return new List<string>();
}
public void Save(IHasMetadata item, CancellationToken cancellationToken)
{
var path = GetSavePath(item);
using (var memoryStream = new MemoryStream())
{
Save(item, memoryStream, path);
memoryStream.Position = 0;
cancellationToken.ThrowIfCancellationRequested();
SaveToFile(memoryStream, path);
}
}
private void SaveToFile(Stream stream, string path)
{
FileSystem.CreateDirectory(Path.GetDirectoryName(path));
var file = FileSystem.GetFileInfo(path);
var wasHidden = false;
// This will fail if the file is hidden
if (file.Exists)
{
if (file.IsHidden)
{
FileSystem.SetHidden(path, false);
wasHidden = true;
}
}
using (var filestream = FileSystem.GetFileStream(path, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read))
{
stream.CopyTo(filestream);
}
if (wasHidden || ConfigurationManager.Configuration.SaveMetadataHidden)
{
FileSystem.SetHidden(path, true);
}
}
private void Save(IHasMetadata item, Stream stream, string xmlPath)
{
var settings = new XmlWriterSettings
{
Indent = true,
Encoding = Encoding.UTF8,
CloseOutput = false
};
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
var root = GetRootElementName(item);
writer.WriteStartDocument(true);
writer.WriteStartElement(root);
var baseItem = item as BaseItem;
if (baseItem != null)
{
AddCommonNodes(baseItem, writer, LibraryManager, UserManager, UserDataManager, FileSystem, ConfigurationManager);
}
WriteCustomElements(item, writer);
var tagsUsed = GetTagsUsed();
try
{
AddCustomTags(xmlPath, tagsUsed, writer, Logger, FileSystem);
}
catch (FileNotFoundException)
{
}
catch (IOException)
{
}
catch (XmlException ex)
{
Logger.ErrorException("Error reading existng xml", ex);
}
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
protected abstract void WriteCustomElements(IHasMetadata item, XmlWriter writer);
public const string DateAddedFormat = "yyyy-MM-dd HH:mm:ss";
/// <summary>
/// Adds the common nodes.
/// </summary>
/// <returns>Task.</returns>
public static void AddCommonNodes(BaseItem item, XmlWriter writer, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem, IServerConfigurationManager config)
{
var writtenProviderIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
2016-10-30 07:02:23 +00:00
if (!string.IsNullOrEmpty(item.OfficialRating))
{
writer.WriteElementString("ContentRating", item.OfficialRating);
}
2016-10-30 07:48:34 +00:00
if (!string.IsNullOrEmpty(item.OfficialRatingDescription))
{
writer.WriteElementString("MPAADescription", item.OfficialRatingDescription);
}
2016-10-30 07:02:23 +00:00
2016-10-30 07:48:34 +00:00
writer.WriteElementString("Added", item.DateCreated.ToLocalTime().ToString("G"));
2016-10-30 07:02:23 +00:00
2016-10-30 07:48:34 +00:00
writer.WriteElementString("LockData", item.IsLocked.ToString().ToLower());
2016-10-30 07:02:23 +00:00
2016-10-30 07:48:34 +00:00
if (item.LockedFields.Count > 0)
{
writer.WriteElementString("LockedFields", string.Join("|", item.LockedFields.Select(i => i.ToString()).ToArray()));
}
2016-10-30 07:02:23 +00:00
2016-10-30 07:48:34 +00:00
if (!string.IsNullOrEmpty(item.DisplayMediaType))
{
writer.WriteElementString("Type", item.DisplayMediaType);
}
2016-10-30 07:02:23 +00:00
2016-10-30 18:42:45 +00:00
if (item.CriticRating.HasValue)
{
writer.WriteElementString("CriticRating", item.CriticRating.Value.ToString(UsCulture));
}
2016-10-30 07:02:23 +00:00
2016-10-30 18:42:45 +00:00
if (!string.IsNullOrEmpty(item.CriticRatingSummary))
{
writer.WriteElementString("CriticRatingSummary", item.CriticRatingSummary);
}
2016-10-30 07:02:23 +00:00
2016-10-30 18:42:45 +00:00
if (!string.IsNullOrEmpty(item.Overview))
{
writer.WriteElementString("Overview", item.Overview);
}
2016-10-30 07:02:23 +00:00
2016-10-31 04:28:23 +00:00
if (!string.IsNullOrEmpty(item.OriginalTitle))
{
writer.WriteElementString("OriginalTitle", item.OriginalTitle);
}
if (!string.IsNullOrEmpty(item.ShortOverview))
{
writer.WriteElementString("ShortOverview", item.ShortOverview);
}
if (!string.IsNullOrEmpty(item.CustomRating))
{
writer.WriteElementString("CustomRating", item.CustomRating);
}
2016-10-30 07:02:23 +00:00
2016-10-31 04:28:23 +00:00
if (!string.IsNullOrEmpty(item.Name) && !(item is Episode))
{
writer.WriteElementString("LocalTitle", item.Name);
}
2016-10-30 07:02:23 +00:00
2016-10-31 04:28:23 +00:00
if (!string.IsNullOrEmpty(item.ForcedSortName))
{
writer.WriteElementString("SortTitle", item.ForcedSortName);
}
2016-10-30 07:02:23 +00:00
2016-10-31 04:28:23 +00:00
if (item.PremiereDate.HasValue)
{
if (item is Person)
{
writer.WriteElementString("BirthDate", item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
}
else if (!(item is Episode))
{
writer.WriteElementString("PremiereDate", item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
}
}
2016-10-30 07:02:23 +00:00
2016-10-31 04:28:23 +00:00
if (item.EndDate.HasValue)
{
if (item is Person)
{
writer.WriteElementString("DeathDate", item.EndDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
}
else if (!(item is Episode))
{
writer.WriteElementString("EndDate", item.EndDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
}
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
var hasTrailers = item as IHasTrailers;
if (hasTrailers != null)
{
if (hasTrailers.RemoteTrailers.Count > 0)
{
writer.WriteStartElement("Trailers");
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
foreach (var trailer in hasTrailers.RemoteTrailers)
{
writer.WriteElementString("Trailer", trailer.Url);
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
writer.WriteEndElement();
}
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
if (item.ProductionLocations.Count > 0)
{
writer.WriteStartElement("Countries");
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
foreach (var name in item.ProductionLocations)
{
writer.WriteElementString("Country", name);
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
writer.WriteEndElement();
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
var hasDisplayOrder = item as IHasDisplayOrder;
if (hasDisplayOrder != null && !string.IsNullOrEmpty(hasDisplayOrder.DisplayOrder))
{
writer.WriteElementString("DisplayOrder", hasDisplayOrder.DisplayOrder);
}
2016-11-01 15:30:15 +00:00
var hasMetascore = item as IHasMetascore;
if (hasMetascore != null && hasMetascore.Metascore.HasValue)
{
writer.WriteElementString("Metascore", hasMetascore.Metascore.Value.ToString(UsCulture));
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
var hasAwards = item as IHasAwards;
if (hasAwards != null && !string.IsNullOrEmpty(hasAwards.AwardSummary))
{
writer.WriteElementString("AwardSummary", hasAwards.AwardSummary);
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
var hasBudget = item as IHasBudget;
if (hasBudget != null)
{
if (hasBudget.Budget.HasValue)
{
writer.WriteElementString("Budget", hasBudget.Budget.Value.ToString(UsCulture));
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
if (hasBudget.Revenue.HasValue)
{
writer.WriteElementString("Revenue", hasBudget.Revenue.Value.ToString(UsCulture));
}
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
if (item.CommunityRating.HasValue)
{
writer.WriteElementString("Rating", item.CommunityRating.Value.ToString(UsCulture));
}
if (item.VoteCount.HasValue)
{
writer.WriteElementString("VoteCount", item.VoteCount.Value.ToString(UsCulture));
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
if (item.ProductionYear.HasValue && !(item is Person))
{
writer.WriteElementString("ProductionYear", item.ProductionYear.Value.ToString(UsCulture));
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
if (!string.IsNullOrEmpty(item.HomePageUrl))
{
writer.WriteElementString("Website", item.HomePageUrl);
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
var hasAspectRatio = item as IHasAspectRatio;
if (hasAspectRatio != null)
{
if (!string.IsNullOrEmpty(hasAspectRatio.AspectRatio))
{
writer.WriteElementString("AspectRatio", hasAspectRatio.AspectRatio);
}
}
if (!string.IsNullOrEmpty(item.PreferredMetadataLanguage))
{
writer.WriteElementString("Language", item.PreferredMetadataLanguage);
}
if (!string.IsNullOrEmpty(item.PreferredMetadataCountryCode))
{
writer.WriteElementString("CountryCode", item.PreferredMetadataCountryCode);
}
// Use original runtime here, actual file runtime later in MediaInfo
var runTimeTicks = item.RunTimeTicks;
if (runTimeTicks.HasValue)
{
var timespan = TimeSpan.FromTicks(runTimeTicks.Value);
writer.WriteElementString("RunningTime", Convert.ToInt32(timespan.TotalMinutes).ToString(UsCulture));
}
if (item.ProviderIds != null)
{
foreach (var providerKey in item.ProviderIds.Keys)
{
var providerId = item.ProviderIds[providerKey];
if (!string.IsNullOrEmpty(providerId))
{
writer.WriteElementString(providerKey + "Id", providerId);
}
}
}
if (!string.IsNullOrWhiteSpace(item.Tagline))
{
writer.WriteStartElement("Taglines");
writer.WriteElementString("Tagline", item.Tagline);
writer.WriteEndElement();
}
if (item.Genres.Count > 0)
{
writer.WriteStartElement("Genres");
foreach (var genre in item.Genres)
{
writer.WriteElementString("Genre", genre);
}
writer.WriteEndElement();
}
if (item.Studios.Count > 0)
{
writer.WriteStartElement("Studios");
foreach (var studio in item.Studios)
{
writer.WriteElementString("Studio", studio);
}
writer.WriteEndElement();
}
2016-10-30 07:02:23 +00:00
2016-10-31 19:09:18 +00:00
if (item.Tags.Count > 0)
{
writer.WriteStartElement("Tags");
2016-10-30 07:02:23 +00:00
2016-10-31 19:09:18 +00:00
foreach (var tag in item.Tags)
{
writer.WriteElementString("Tag", tag);
}
2016-10-30 07:02:23 +00:00
2016-10-31 19:09:18 +00:00
writer.WriteEndElement();
}
2016-10-30 07:02:23 +00:00
2016-10-31 19:09:18 +00:00
if (item.Keywords.Count > 0)
{
writer.WriteStartElement("PlotKeywords");
2016-10-30 07:02:23 +00:00
2016-10-31 19:09:18 +00:00
foreach (var tag in item.Keywords)
{
writer.WriteElementString("PlotKeyword", tag);
}
2016-10-30 07:02:23 +00:00
2016-10-31 19:09:18 +00:00
writer.WriteEndElement();
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
var people = libraryManager.GetPeople(item);
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
if (people.Count > 0)
{
writer.WriteStartElement("Persons");
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
foreach (var person in people)
{
writer.WriteStartElement("Person");
writer.WriteElementString("Name", person.Name);
writer.WriteElementString("Type", person.Type);
writer.WriteElementString("Role", person.Role);
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
if (person.SortOrder.HasValue)
{
writer.WriteElementString("SortOrder", person.SortOrder.Value.ToString(UsCulture));
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
writer.WriteEndElement();
}
2016-10-30 07:02:23 +00:00
2016-11-01 15:30:15 +00:00
writer.WriteEndElement();
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
var boxset = item as BoxSet;
if (boxset != null)
{
AddLinkedChildren(boxset, writer, "CollectionItems", "CollectionItem");
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
var playlist = item as Playlist;
if (playlist != null)
{
AddLinkedChildren(playlist, writer, "PlaylistItems", "PlaylistItem");
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
var hasShares = item as IHasShares;
if (hasShares != null)
{
AddShares(hasShares, writer);
}
2016-10-31 04:28:23 +00:00
AddMediaInfo(item, writer);
2016-10-30 07:02:23 +00:00
}
2016-10-31 17:53:06 +00:00
public static void AddShares(IHasShares item, XmlWriter writer)
2016-10-30 07:02:23 +00:00
{
2016-10-31 17:53:06 +00:00
writer.WriteStartElement("Shares");
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
foreach (var share in item.Shares)
{
writer.WriteStartElement("Share");
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
writer.WriteElementString("UserId", share.UserId);
writer.WriteElementString("CanEdit", share.CanEdit.ToString().ToLower());
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
writer.WriteEndElement();
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
writer.WriteEndElement();
2016-10-30 07:02:23 +00:00
}
/// <summary>
/// Appends the media info.
/// </summary>
/// <typeparam name="T"></typeparam>
2016-10-31 04:28:23 +00:00
public static void AddMediaInfo<T>(T item, XmlWriter writer)
2016-10-30 07:02:23 +00:00
where T : BaseItem
{
var video = item as Video;
if (video != null)
{
if (video.Video3DFormat.HasValue)
{
switch (video.Video3DFormat.Value)
{
case Video3DFormat.FullSideBySide:
2016-10-31 04:28:23 +00:00
writer.WriteElementString("Format3D", "FSBS");
2016-10-30 07:02:23 +00:00
break;
case Video3DFormat.FullTopAndBottom:
2016-10-31 04:28:23 +00:00
writer.WriteElementString("Format3D", "FTAB");
2016-10-30 07:02:23 +00:00
break;
case Video3DFormat.HalfSideBySide:
2016-10-31 04:28:23 +00:00
writer.WriteElementString("Format3D", "HSBS");
2016-10-30 07:02:23 +00:00
break;
case Video3DFormat.HalfTopAndBottom:
2016-10-31 04:28:23 +00:00
writer.WriteElementString("Format3D", "HTAB");
2016-10-30 07:02:23 +00:00
break;
case Video3DFormat.MVC:
2016-10-31 04:28:23 +00:00
writer.WriteElementString("Format3D", "MVC");
2016-10-30 07:02:23 +00:00
break;
}
}
}
}
2016-10-31 17:53:06 +00:00
public static void AddLinkedChildren(Folder item, XmlWriter writer, string pluralNodeName, string singularNodeName)
2016-10-30 07:02:23 +00:00
{
2016-10-31 17:53:06 +00:00
var items = item.LinkedChildren
.Where(i => i.Type == LinkedChildType.Manual)
.ToList();
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
if (items.Count == 0)
{
return;
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
writer.WriteStartElement(pluralNodeName);
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
foreach (var link in items)
{
if (!string.IsNullOrWhiteSpace(link.Path))
{
writer.WriteStartElement(singularNodeName);
writer.WriteElementString("Path", link.Path);
writer.WriteEndElement();
}
}
2016-10-30 07:02:23 +00:00
2016-10-31 17:53:06 +00:00
writer.WriteEndElement();
2016-10-27 05:11:31 +00:00
}
private static bool IsPersonType(PersonInfo person, string type)
{
return string.Equals(person.Type, type, StringComparison.OrdinalIgnoreCase) || string.Equals(person.Role, type, StringComparison.OrdinalIgnoreCase);
}
private void AddCustomTags(string path, List<string> xmlTagsUsed, XmlWriter writer, ILogger logger, IFileSystem fileSystem)
{
var settings = XmlReaderSettingsFactory.Create(false);
settings.CheckCharacters = false;
settings.IgnoreProcessingInstructions = true;
settings.IgnoreComments = true;
using (var fileStream = fileSystem.OpenRead(path))
{
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))
{
try
{
reader.MoveToContent();
}
catch (Exception ex)
{
logger.ErrorException("Error reading existing xml tags from {0}.", ex, path);
return;
}
// Loop through each element
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
var name = reader.Name;
if (!CommonTags.ContainsKey(name) && !xmlTagsUsed.Contains(name, StringComparer.OrdinalIgnoreCase))
{
writer.WriteNode(reader, false);
}
else
{
reader.Skip();
}
}
}
}
}
}
}
}
}