jellyfin/MediaBrowser.LocalMetadata/Savers/XmlSaverHelpers.cs

765 lines
27 KiB
C#
Raw Normal View History

using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
2015-06-21 03:35:22 +00:00
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Persistence;
using MediaBrowser.Controller.Playlists;
using MediaBrowser.Model.Entities;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using System.Xml;
2015-10-04 04:23:11 +00:00
using CommonIO;
namespace MediaBrowser.LocalMetadata.Savers
{
/// <summary>
/// Class XmlHelpers
/// </summary>
2013-06-23 18:55:30 +00:00
public static class XmlSaverHelpers
{
private static readonly Dictionary<string, string> CommonTags = new[] {
"Added",
"AspectRatio",
2014-02-19 05:21:03 +00:00
"AudioDbAlbumId",
"AudioDbArtistId",
2014-01-15 05:01:58 +00:00
"AwardSummary",
"BirthDate",
"Budget",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"certification",
2014-03-25 05:25:03 +00:00
"Chapters",
"ContentRating",
2014-05-16 19:16:29 +00:00
"Countries",
"CustomRating",
"CriticRating",
"CriticRatingSummary",
"DeathDate",
"DisplayOrder",
"EndDate",
"Genres",
"Genre",
"GamesDbId",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"IMDB_ID",
2014-03-25 05:25:03 +00:00
"IMDB",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"IMDbId",
2014-03-25 05:25:03 +00:00
"Language",
"LocalTitle",
2015-03-10 01:30:20 +00:00
"OriginalTitle",
"LockData",
"LockedFields",
2013-12-15 01:17:57 +00:00
"Format3D",
2014-01-15 05:01:58 +00:00
"Metascore",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"MPAARating",
2014-03-25 05:25:03 +00:00
2014-07-22 01:29:06 +00:00
"MPAADescription",
2014-02-09 17:44:25 +00:00
"MusicBrainzArtistId",
"MusicBrainzAlbumArtistId",
"MusicBrainzAlbumId",
"MusicBrainzReleaseGroupId",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"MusicbrainzId",
"Overview",
2014-06-25 15:12:39 +00:00
"ShortOverview",
"Persons",
2014-01-15 05:01:58 +00:00
"PlotKeywords",
"PremiereDate",
"ProductionYear",
"Rating",
"Revenue",
"RottenTomatoesId",
"RunningTime",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"Runtime",
2014-03-25 05:25:03 +00:00
"SortTitle",
"Studios",
"Tags",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"TagLine",
2014-03-25 05:25:03 +00:00
"Taglines",
"TMDbCollectionId",
"TMDbId",
2014-03-25 05:25:03 +00:00
// Deprecated. No longer saving in this field.
"Trailer",
2014-03-25 05:25:03 +00:00
2013-12-01 20:17:40 +00:00
"Trailers",
"TVcomId",
"TvDbId",
"Type",
2014-02-19 05:21:03 +00:00
"TVRageId",
2013-10-13 13:32:53 +00:00
"VoteCount",
"Website",
"Zap2ItId",
"CollectionItems",
2015-01-02 05:36:27 +00:00
"PlaylistItems",
"Shares"
}.ToDictionary(i => i, StringComparer.OrdinalIgnoreCase);
/// <summary>
/// The us culture
/// </summary>
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
/// <summary>
/// Saves the specified XML.
/// </summary>
/// <param name="xml">The XML.</param>
/// <param name="path">The path.</param>
/// <param name="xmlTagsUsed">The XML tags used.</param>
2015-09-13 21:32:02 +00:00
public static void Save(StringBuilder xml, string path, List<string> xmlTagsUsed, IServerConfigurationManager config, IFileSystem fileSystem)
{
2015-09-13 21:32:02 +00:00
if (fileSystem.FileExists(path))
{
var position = xml.ToString().LastIndexOf("</", StringComparison.OrdinalIgnoreCase);
2013-09-25 15:11:23 +00:00
xml.Insert(position, GetCustomTags(path, xmlTagsUsed));
}
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml.ToString());
//Add the new node to the document.
xmlDocument.InsertBefore(xmlDocument.CreateXmlDeclaration("1.0", "UTF-8", "yes"), xmlDocument.DocumentElement);
2015-09-13 21:32:02 +00:00
fileSystem.CreateDirectory(Path.GetDirectoryName(path));
2013-06-23 18:55:30 +00:00
var wasHidden = false;
var file = new FileInfo(path);
// This will fail if the file is hidden
if (file.Exists)
{
if ((file.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
{
file.Attributes &= ~FileAttributes.Hidden;
wasHidden = true;
}
}
using (var filestream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read))
{
using (var streamWriter = new StreamWriter(filestream, Encoding.UTF8))
{
xmlDocument.Save(streamWriter);
}
}
if (wasHidden || config.Configuration.SaveMetadataHidden)
{
file.Refresh();
// Add back the attribute
file.Attributes |= FileAttributes.Hidden;
}
}
/// <summary>
/// Gets the custom tags.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="xmlTagsUsed">The XML tags used.</param>
/// <returns>System.String.</returns>
private static string GetCustomTags(string path, List<string> xmlTagsUsed)
{
2013-09-25 15:11:23 +00:00
var settings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
2013-09-25 15:11:23 +00:00
var builder = new StringBuilder();
using (var streamReader = new StreamReader(path, Encoding.UTF8))
{
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))
{
reader.MoveToContent();
// 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))
2013-09-25 15:11:23 +00:00
{
builder.AppendLine(reader.ReadOuterXml());
}
else
{
reader.Skip();
}
}
}
}
}
2013-12-01 20:17:40 +00:00
2013-09-25 15:11:23 +00:00
return builder.ToString();
}
/// <summary>
/// Adds the common nodes.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="builder">The builder.</param>
2015-06-21 03:35:22 +00:00
public static void AddCommonNodes(BaseItem item, ILibraryManager libraryManager, StringBuilder builder)
{
if (!string.IsNullOrEmpty(item.OfficialRating))
{
builder.Append("<ContentRating>" + SecurityElement.Escape(item.OfficialRating) + "</ContentRating>");
}
2014-07-22 01:29:06 +00:00
if (!string.IsNullOrEmpty(item.OfficialRatingDescription))
{
builder.Append("<MPAADescription>" + SecurityElement.Escape(item.OfficialRatingDescription) + "</MPAADescription>");
}
2013-07-17 15:19:28 +00:00
builder.Append("<Added>" + SecurityElement.Escape(item.DateCreated.ToLocalTime().ToString("G")) + "</Added>");
2014-03-22 16:16:43 +00:00
builder.Append("<LockData>" + item.IsLocked.ToString().ToLower() + "</LockData>");
2013-06-27 16:58:28 +00:00
2013-08-04 00:59:23 +00:00
if (item.LockedFields.Count > 0)
{
builder.Append("<LockedFields>" + string.Join("|", item.LockedFields.Select(i => i.ToString()).ToArray()) + "</LockedFields>");
}
if (!string.IsNullOrEmpty(item.DisplayMediaType))
{
builder.Append("<Type>" + SecurityElement.Escape(item.DisplayMediaType) + "</Type>");
}
2013-11-06 16:06:16 +00:00
var hasCriticRating = item as IHasCriticRating;
if (hasCriticRating != null)
{
2013-11-06 16:06:16 +00:00
if (hasCriticRating.CriticRating.HasValue)
{
builder.Append("<CriticRating>" + SecurityElement.Escape(hasCriticRating.CriticRating.Value.ToString(UsCulture)) + "</CriticRating>");
}
2013-11-06 16:06:16 +00:00
if (!string.IsNullOrEmpty(hasCriticRating.CriticRatingSummary))
{
builder.Append("<CriticRatingSummary><![CDATA[" + hasCriticRating.CriticRatingSummary + "]]></CriticRatingSummary>");
}
}
2014-06-25 15:12:39 +00:00
if (!string.IsNullOrEmpty(item.Overview))
{
builder.Append("<Overview><![CDATA[" + item.Overview + "]]></Overview>");
}
2015-03-10 01:30:20 +00:00
var hasOriginalTitle = item as IHasOriginalTitle;
if (hasOriginalTitle != null)
{
if (!string.IsNullOrEmpty(hasOriginalTitle.OriginalTitle))
{
builder.Append("<OriginalTitle>" + SecurityElement.Escape(hasOriginalTitle.OriginalTitle) + "</OriginalTitle>");
}
}
2014-06-25 15:12:39 +00:00
2014-06-24 04:18:02 +00:00
var hasShortOverview = item as IHasShortOverview;
if (hasShortOverview != null)
{
2014-06-24 04:18:02 +00:00
if (!string.IsNullOrEmpty(hasShortOverview.ShortOverview))
{
builder.Append("<ShortOverview><![CDATA[" + hasShortOverview.ShortOverview + "]]></ShortOverview>");
}
}
if (!string.IsNullOrEmpty(item.CustomRating))
{
builder.Append("<CustomRating>" + SecurityElement.Escape(item.CustomRating) + "</CustomRating>");
}
if (!string.IsNullOrEmpty(item.Name) && !(item is Episode))
{
builder.Append("<LocalTitle>" + SecurityElement.Escape(item.Name) + "</LocalTitle>");
}
if (!string.IsNullOrEmpty(item.ForcedSortName))
{
builder.Append("<SortTitle>" + SecurityElement.Escape(item.ForcedSortName) + "</SortTitle>");
}
2013-06-23 18:55:30 +00:00
2013-07-20 21:36:59 +00:00
if (item.PremiereDate.HasValue)
2013-06-23 18:55:30 +00:00
{
2013-07-20 21:36:59 +00:00
if (item is Person)
{
builder.Append("<BirthDate>" + SecurityElement.Escape(item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd")) + "</BirthDate>");
2013-07-20 21:36:59 +00:00
}
else if (!(item is Episode))
{
builder.Append("<PremiereDate>" + SecurityElement.Escape(item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd")) + "</PremiereDate>");
2013-07-20 21:36:59 +00:00
}
2013-06-23 18:55:30 +00:00
}
2013-06-27 16:58:28 +00:00
if (item.EndDate.HasValue)
{
if (item is Person)
{
builder.Append("<DeathDate>" + SecurityElement.Escape(item.EndDate.Value.ToString("yyyy-MM-dd")) + "</DeathDate>");
}
else if (!(item is Episode))
{
builder.Append("<EndDate>" + SecurityElement.Escape(item.EndDate.Value.ToString("yyyy-MM-dd")) + "</EndDate>");
}
}
2013-12-02 16:46:25 +00:00
var hasTrailers = item as IHasTrailers;
if (hasTrailers != null)
2013-06-27 16:58:28 +00:00
{
2013-12-02 16:46:25 +00:00
if (hasTrailers.RemoteTrailers.Count > 0)
2013-12-01 20:17:40 +00:00
{
2013-12-02 16:46:25 +00:00
builder.Append("<Trailers>");
foreach (var trailer in hasTrailers.RemoteTrailers)
{
builder.Append("<Trailer>" + SecurityElement.Escape(trailer.Url) + "</Trailer>");
}
2013-12-01 20:17:40 +00:00
2013-12-02 16:46:25 +00:00
builder.Append("</Trailers>");
}
2013-06-27 16:58:28 +00:00
}
2014-05-16 19:16:29 +00:00
var hasProductionLocations = item as IHasProductionLocations;
if (hasProductionLocations != null)
{
if (hasProductionLocations.ProductionLocations.Count > 0)
{
builder.Append("<Countries>");
foreach (var name in hasProductionLocations.ProductionLocations)
{
builder.Append("<Country>" + SecurityElement.Escape(name) + "</Country>");
}
builder.Append("</Countries>");
}
}
var hasDisplayOrder = item as IHasDisplayOrder;
if (hasDisplayOrder != null && !string.IsNullOrEmpty(hasDisplayOrder.DisplayOrder))
{
builder.Append("<DisplayOrder>" + SecurityElement.Escape(hasDisplayOrder.DisplayOrder) + "</DisplayOrder>");
}
2014-01-15 05:01:58 +00:00
var hasMetascore = item as IHasMetascore;
if (hasMetascore != null && hasMetascore.Metascore.HasValue)
{
builder.Append("<Metascore>" + SecurityElement.Escape(hasMetascore.Metascore.Value.ToString(UsCulture)) + "</Metascore>");
}
var hasAwards = item as IHasAwards;
if (hasAwards != null && !string.IsNullOrEmpty(hasAwards.AwardSummary))
{
builder.Append("<AwardSummary>" + SecurityElement.Escape(hasAwards.AwardSummary) + "</AwardSummary>");
}
2014-02-09 21:11:11 +00:00
2013-12-02 16:16:03 +00:00
var hasBudget = item as IHasBudget;
if (hasBudget != null)
{
2013-12-02 16:16:03 +00:00
if (hasBudget.Budget.HasValue)
{
builder.Append("<Budget>" + SecurityElement.Escape(hasBudget.Budget.Value.ToString(UsCulture)) + "</Budget>");
}
2013-12-02 16:16:03 +00:00
if (hasBudget.Revenue.HasValue)
{
builder.Append("<Revenue>" + SecurityElement.Escape(hasBudget.Revenue.Value.ToString(UsCulture)) + "</Revenue>");
}
}
if (item.CommunityRating.HasValue)
{
builder.Append("<Rating>" + SecurityElement.Escape(item.CommunityRating.Value.ToString(UsCulture)) + "</Rating>");
}
2013-10-13 13:32:53 +00:00
if (item.VoteCount.HasValue)
{
builder.Append("<VoteCount>" + SecurityElement.Escape(item.VoteCount.Value.ToString(UsCulture)) + "</VoteCount>");
}
if (item.ProductionYear.HasValue && !(item is Person))
{
builder.Append("<ProductionYear>" + SecurityElement.Escape(item.ProductionYear.Value.ToString(UsCulture)) + "</ProductionYear>");
}
if (!string.IsNullOrEmpty(item.HomePageUrl))
{
builder.Append("<Website>" + SecurityElement.Escape(item.HomePageUrl) + "</Website>");
}
var hasAspectRatio = item as IHasAspectRatio;
if (hasAspectRatio != null)
{
if (!string.IsNullOrEmpty(hasAspectRatio.AspectRatio))
{
builder.Append("<AspectRatio>" + SecurityElement.Escape(hasAspectRatio.AspectRatio) + "</AspectRatio>");
}
}
2015-09-29 17:35:23 +00:00
if (!string.IsNullOrEmpty(item.PreferredMetadataLanguage))
{
2015-09-29 17:35:23 +00:00
builder.Append("<Language>" + SecurityElement.Escape(item.PreferredMetadataLanguage) + "</Language>");
}
if (!string.IsNullOrEmpty(item.PreferredMetadataCountryCode))
{
builder.Append("<CountryCode>" + SecurityElement.Escape(item.PreferredMetadataCountryCode) + "</CountryCode>");
}
// Use original runtime here, actual file runtime later in MediaInfo
var runTimeTicks = item.RunTimeTicks;
if (runTimeTicks.HasValue)
{
var timespan = TimeSpan.FromTicks(runTimeTicks.Value);
builder.Append("<RunningTime>" + Convert.ToInt32(timespan.TotalMinutes).ToString(UsCulture) + "</RunningTime>");
}
var imdb = item.GetProviderId(MetadataProviders.Imdb);
if (!string.IsNullOrEmpty(imdb))
{
builder.Append("<IMDB>" + SecurityElement.Escape(imdb) + "</IMDB>");
}
var tmdb = item.GetProviderId(MetadataProviders.Tmdb);
if (!string.IsNullOrEmpty(tmdb))
{
builder.Append("<TMDbId>" + SecurityElement.Escape(tmdb) + "</TMDbId>");
}
2013-07-16 17:18:32 +00:00
if (!(item is Series))
{
var tvdb = item.GetProviderId(MetadataProviders.Tvdb);
if (!string.IsNullOrEmpty(tvdb))
{
builder.Append("<TvDbId>" + SecurityElement.Escape(tvdb) + "</TvDbId>");
}
}
2014-02-09 21:11:11 +00:00
var externalId = item.GetProviderId(MetadataProviders.Tvcom);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<TVcomId>" + SecurityElement.Escape(externalId) + "</TVcomId>");
}
externalId = item.GetProviderId(MetadataProviders.RottenTomatoes);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<RottenTomatoesId>" + SecurityElement.Escape(externalId) + "</RottenTomatoesId>");
}
externalId = item.GetProviderId(MetadataProviders.Zap2It);
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
{
2014-02-09 21:11:11 +00:00
builder.Append("<Zap2ItId>" + SecurityElement.Escape(externalId) + "</Zap2ItId>");
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.MusicBrainzAlbum);
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
{
2014-02-09 21:11:11 +00:00
builder.Append("<MusicBrainzAlbumId>" + SecurityElement.Escape(externalId) + "</MusicBrainzAlbumId>");
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.MusicBrainzAlbumArtist);
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
{
2014-02-09 21:11:11 +00:00
builder.Append("<MusicBrainzAlbumArtistId>" + SecurityElement.Escape(externalId) + "</MusicBrainzAlbumArtistId>");
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.MusicBrainzArtist);
2013-06-23 18:55:30 +00:00
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
2013-06-23 18:55:30 +00:00
{
2014-02-09 21:11:11 +00:00
builder.Append("<MusicBrainzArtistId>" + SecurityElement.Escape(externalId) + "</MusicBrainzArtistId>");
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.MusicBrainzReleaseGroup);
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
{
2014-02-09 21:11:11 +00:00
builder.Append("<MusicBrainzReleaseGroupId>" + SecurityElement.Escape(externalId) + "</MusicBrainzReleaseGroupId>");
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.Gamesdb);
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
{
2014-02-09 21:11:11 +00:00
builder.Append("<GamesDbId>" + SecurityElement.Escape(externalId) + "</GamesDbId>");
2013-06-23 18:55:30 +00:00
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.TmdbCollection);
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
{
2014-02-09 21:11:11 +00:00
builder.Append("<TMDbCollectionId>" + SecurityElement.Escape(externalId) + "</TMDbCollectionId>");
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.AudioDbArtist);
2013-07-16 17:18:32 +00:00
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
2013-07-16 17:18:32 +00:00
{
2014-02-09 21:11:11 +00:00
builder.Append("<AudioDbArtistId>" + SecurityElement.Escape(externalId) + "</AudioDbArtistId>");
2013-07-16 17:18:32 +00:00
}
2014-02-09 21:13:17 +00:00
externalId = item.GetProviderId(MetadataProviders.AudioDbAlbum);
if (!string.IsNullOrEmpty(externalId))
{
builder.Append("<AudioDbAlbumId>" + SecurityElement.Escape(externalId) + "</AudioDbAlbumId>");
}
2014-02-09 21:11:11 +00:00
externalId = item.GetProviderId(MetadataProviders.TvRage);
2014-02-09 21:11:11 +00:00
if (!string.IsNullOrEmpty(externalId))
{
2014-02-19 05:21:03 +00:00
builder.Append("<TVRageId>" + SecurityElement.Escape(externalId) + "</TVRageId>");
}
var hasTagline = item as IHasTaglines;
if (hasTagline != null)
{
if (hasTagline.Taglines.Count > 0)
{
builder.Append("<Taglines>");
foreach (var tagline in hasTagline.Taglines)
{
builder.Append("<Tagline>" + SecurityElement.Escape(tagline) + "</Tagline>");
}
builder.Append("</Taglines>");
}
}
if (item.Genres.Count > 0)
{
builder.Append("<Genres>");
foreach (var genre in item.Genres)
{
builder.Append("<Genre>" + SecurityElement.Escape(genre) + "</Genre>");
}
builder.Append("</Genres>");
}
if (item.Studios.Count > 0)
{
builder.Append("<Studios>");
foreach (var studio in item.Studios)
{
builder.Append("<Studio>" + SecurityElement.Escape(studio) + "</Studio>");
}
builder.Append("</Studios>");
}
2016-06-02 17:43:29 +00:00
if (item.Tags.Count > 0)
2013-06-23 18:55:30 +00:00
{
2016-06-02 17:43:29 +00:00
builder.Append("<Tags>");
2016-06-02 17:43:29 +00:00
foreach (var tag in item.Tags)
{
builder.Append("<Tag>" + SecurityElement.Escape(tag) + "</Tag>");
}
2016-06-02 17:43:29 +00:00
builder.Append("</Tags>");
2013-06-23 18:55:30 +00:00
}
if (item.Keywords.Count > 0)
2014-01-14 15:50:39 +00:00
{
builder.Append("<PlotKeywords>");
2014-01-14 15:50:39 +00:00
foreach (var tag in item.Keywords)
{
builder.Append("<PlotKeyword>" + SecurityElement.Escape(tag) + "</PlotKeyword>");
2014-01-14 15:50:39 +00:00
}
builder.Append("</PlotKeywords>");
2014-01-14 15:50:39 +00:00
}
2015-06-21 03:35:22 +00:00
var people = libraryManager.GetPeople(item);
if (people.Count > 0)
{
builder.Append("<Persons>");
2015-06-21 03:35:22 +00:00
foreach (var person in people)
{
builder.Append("<Person>");
builder.Append("<Name>" + SecurityElement.Escape(person.Name) + "</Name>");
builder.Append("<Type>" + SecurityElement.Escape(person.Type) + "</Type>");
builder.Append("<Role>" + SecurityElement.Escape(person.Role) + "</Role>");
2013-11-20 03:47:29 +00:00
if (person.SortOrder.HasValue)
{
builder.Append("<SortOrder>" + SecurityElement.Escape(person.SortOrder.Value.ToString(UsCulture)) + "</SortOrder>");
}
builder.Append("</Person>");
}
builder.Append("</Persons>");
}
var boxset = item as BoxSet;
if (boxset != null)
{
AddLinkedChildren(boxset, builder, "CollectionItems", "CollectionItem");
}
var playlist = item as Playlist;
if (playlist != null)
{
AddLinkedChildren(playlist, builder, "PlaylistItems", "PlaylistItem");
}
2014-12-13 03:56:30 +00:00
var hasShares = item as IHasShares;
if (hasShares != null)
{
2014-12-24 06:28:40 +00:00
AddShares(hasShares, builder);
2014-12-13 03:56:30 +00:00
}
}
public static void AddShares(IHasShares item, StringBuilder builder)
{
builder.Append("<Shares>");
foreach (var share in item.Shares)
{
builder.Append("<Share>");
builder.Append("<UserId>" + SecurityElement.Escape(share.UserId) + "</UserId>");
builder.Append("<CanEdit>" + SecurityElement.Escape(share.CanEdit.ToString().ToLower()) + "</CanEdit>");
builder.Append("</Share>");
}
builder.Append("</Shares>");
2013-08-12 19:18:31 +00:00
}
public static void AddChapters(Video item, StringBuilder builder, IItemRepository repository)
{
var chapters = repository.GetChapters(item.Id);
builder.Append("<Chapters>");
foreach (var chapter in chapters)
{
builder.Append("<Chapter>");
builder.Append("<Name>" + SecurityElement.Escape(chapter.Name) + "</Name>");
var time = TimeSpan.FromTicks(chapter.StartPositionTicks);
var ms = Convert.ToInt64(time.TotalMilliseconds);
builder.Append("<StartPositionMs>" + SecurityElement.Escape(ms.ToString(UsCulture)) + "</StartPositionMs>");
builder.Append("</Chapter>");
}
2013-08-12 19:18:31 +00:00
builder.Append("</Chapters>");
}
/// <summary>
/// Appends the media info.
/// </summary>
/// <typeparam name="T"></typeparam>
2013-08-30 23:55:17 +00:00
public static void AddMediaInfo<T>(T item, StringBuilder builder, IItemRepository itemRepository)
2014-06-03 02:01:30 +00:00
where T : BaseItem
{
2013-08-30 23:55:17 +00:00
var video = item as Video;
2014-05-14 20:43:31 +00:00
if (video != null)
2013-12-06 03:39:44 +00:00
{
2014-06-24 04:18:02 +00:00
//AddChapters(video, builder, itemRepository);
2014-05-14 20:43:31 +00:00
if (video.Video3DFormat.HasValue)
2013-07-01 16:00:20 +00:00
{
2014-05-14 20:43:31 +00:00
switch (video.Video3DFormat.Value)
{
case Video3DFormat.FullSideBySide:
builder.Append("<Format3D>FSBS</Format3D>");
break;
case Video3DFormat.FullTopAndBottom:
builder.Append("<Format3D>FTAB</Format3D>");
break;
case Video3DFormat.HalfSideBySide:
builder.Append("<Format3D>HSBS</Format3D>");
break;
case Video3DFormat.HalfTopAndBottom:
builder.Append("<Format3D>HTAB</Format3D>");
break;
2016-02-11 19:11:28 +00:00
case Video3DFormat.MVC:
builder.Append("<Format3D>MVC</Format3D>");
break;
2014-05-14 20:43:31 +00:00
}
}
}
}
public static void AddLinkedChildren(Folder item, StringBuilder builder, string pluralNodeName, string singularNodeName)
{
var items = item.LinkedChildren
.Where(i => i.Type == LinkedChildType.Manual)
.ToList();
if (items.Count == 0)
{
return;
}
builder.Append("<" + pluralNodeName + ">");
foreach (var link in items)
{
builder.Append("<" + singularNodeName + ">");
if (!string.IsNullOrWhiteSpace(link.Path))
{
builder.Append("<Path>" + SecurityElement.Escape((link.Path)) + "</Path>");
}
builder.Append("</" + singularNodeName + ">");
}
builder.Append("</" + pluralNodeName + ">");
}
}
}