jellyfin-server/MediaBrowser.Controller/Providers/BaseItemXmlParser.cs

1379 lines
48 KiB
C#
Raw Normal View History

using MediaBrowser.Controller.Entities;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
2013-02-21 20:26:35 +00:00
using MediaBrowser.Model.Logging;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
2013-02-21 01:33:05 +00:00
using System.Linq;
using System.Text;
2013-02-21 01:33:05 +00:00
using System.Threading;
using System.Xml;
namespace MediaBrowser.Controller.Providers
{
/// <summary>
/// Provides a base class for parsing metadata xml
/// </summary>
/// <typeparam name="T"></typeparam>
public class BaseItemXmlParser<T>
where T : BaseItem
2013-02-21 01:33:05 +00:00
{
2013-02-21 20:26:35 +00:00
/// <summary>
/// The logger
/// </summary>
protected ILogger Logger { get; private set; }
/// <summary>
/// Initializes a new instance of the <see cref="BaseItemXmlParser{T}" /> class.
/// </summary>
/// <param name="logger">The logger.</param>
public BaseItemXmlParser(ILogger logger)
{
Logger = logger;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Fetches metadata for an item from one xml file
/// </summary>
/// <param name="item">The item.</param>
/// <param name="metadataFile">The metadata file.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void Fetch(T item, string metadataFile, CancellationToken cancellationToken)
{
if (item == null)
{
throw new ArgumentNullException();
}
if (string.IsNullOrEmpty(metadataFile))
{
throw new ArgumentNullException();
}
2013-04-15 18:45:58 +00:00
var settings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
//Fetch(item, metadataFile, settings, Encoding.GetEncoding("ISO-8859-1"), cancellationToken);
Fetch(item, metadataFile, settings, Encoding.UTF8, cancellationToken);
}
/// <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>
private void Fetch(T item, string metadataFile, XmlReaderSettings settings, Encoding encoding, CancellationToken cancellationToken)
{
using (var streamReader = new StreamReader(metadataFile, encoding))
2013-02-21 01:33:05 +00:00
{
2013-06-06 15:11:51 +00:00
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))
2013-02-21 01:33:05 +00:00
{
2013-06-06 15:11:51 +00:00
reader.MoveToContent();
2013-02-21 01:33:05 +00:00
2013-06-06 15:11:51 +00:00
// Loop through each element
while (reader.Read())
2013-02-21 01:33:05 +00:00
{
2013-06-06 15:11:51 +00:00
cancellationToken.ThrowIfCancellationRequested();
if (reader.NodeType == XmlNodeType.Element)
{
FetchDataFromXmlNode(reader, item);
}
2013-02-21 01:33:05 +00:00
}
}
}
}
2013-04-22 17:35:42 +00:00
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
2013-02-21 01:33:05 +00:00
/// <summary>
/// Fetches metadata from one Xml Element
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="item">The item.</param>
protected virtual void FetchDataFromXmlNode(XmlReader reader, T item)
{
switch (reader.Name)
{
// DateCreated
case "Added":
{
2014-05-02 02:54:33 +00:00
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
DateTime added;
if (DateTime.TryParse(val, out added))
{
item.DateCreated = added.ToUniversalTime();
}
else
{
Logger.Warn("Invalid Added value found: " + val);
}
}
break;
2013-02-21 01:33:05 +00:00
}
case "LocalTitle":
item.Name = reader.ReadElementContentAsString();
break;
case "Type":
{
var type = reader.ReadElementContentAsString();
2013-04-15 18:45:58 +00:00
if (!string.IsNullOrWhiteSpace(type) && !type.Equals("none", StringComparison.OrdinalIgnoreCase))
2013-02-21 01:33:05 +00:00
{
item.DisplayMediaType = type;
}
break;
}
2013-09-22 22:42:21 +00:00
case "CriticRating":
{
var text = reader.ReadElementContentAsString();
2013-11-06 16:06:16 +00:00
var hasCriticRating = item as IHasCriticRating;
if (hasCriticRating != null && !string.IsNullOrEmpty(text))
{
2013-11-06 16:06:16 +00:00
float value;
if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
{
hasCriticRating.CriticRating = value;
}
}
2013-04-22 17:35:42 +00:00
break;
}
2013-09-22 22:42:21 +00:00
2013-04-22 17:35:42 +00:00
case "Budget":
{
var text = reader.ReadElementContentAsString();
2013-12-02 16:16:03 +00:00
var hasBudget = item as IHasBudget;
if (hasBudget != null)
2013-04-22 17:35:42 +00:00
{
2013-12-02 16:16:03 +00:00
double value;
if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
{
hasBudget.Budget = value;
}
2013-04-22 17:35:42 +00:00
}
break;
}
2013-09-22 22:42:21 +00:00
2013-04-22 17:35:42 +00:00
case "Revenue":
{
var text = reader.ReadElementContentAsString();
2013-12-02 16:16:03 +00:00
var hasBudget = item as IHasBudget;
if (hasBudget != null)
2013-04-22 17:35:42 +00:00
{
2013-12-02 16:16:03 +00:00
double value;
if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
{
hasBudget.Revenue = value;
}
2013-04-22 17:35:42 +00:00
}
2013-02-21 01:33:05 +00:00
break;
}
2013-09-22 22:42:21 +00:00
2014-01-15 05:01:58 +00:00
case "Metascore":
2013-08-25 19:54:18 +00:00
{
2014-01-15 05:01:58 +00:00
var text = reader.ReadElementContentAsString();
var hasMetascore = item as IHasMetascore;
if (hasMetascore != null)
{
float value;
if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
{
hasMetascore.Metascore = value;
}
}
break;
}
2013-08-25 19:54:18 +00:00
2014-01-15 05:01:58 +00:00
case "AwardSummary":
{
var text = reader.ReadElementContentAsString();
var hasAwards = item as IHasAwards;
if (hasAwards != null)
2013-08-25 19:54:18 +00:00
{
2014-01-15 05:01:58 +00:00
if (!string.IsNullOrWhiteSpace(text))
{
hasAwards.AwardSummary = text;
}
2013-08-25 19:54:18 +00:00
}
2014-01-15 05:01:58 +00:00
break;
}
case "SortTitle":
{
var val = reader.ReadElementContentAsString();
2014-02-08 20:02:35 +00:00
if (!string.IsNullOrWhiteSpace(val))
{
item.ForcedSortName = val;
}
2013-08-25 19:54:18 +00:00
break;
}
2013-02-21 01:33:05 +00:00
case "Overview":
case "Description":
2013-05-26 19:43:29 +00:00
{
2013-06-01 01:19:38 +00:00
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.Overview = val;
}
break;
2013-05-26 19:43:29 +00:00
}
2013-02-21 01:33:05 +00:00
2014-06-24 04:18:02 +00:00
case "ShortOverview":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var hasShortOverview = item as IHasShortOverview;
if (hasShortOverview != null)
{
hasShortOverview.ShortOverview = val;
}
}
break;
}
case "CriticRatingSummary":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
2013-11-06 16:06:16 +00:00
var hasCriticRating = item as IHasCriticRating;
if (hasCriticRating != null)
{
hasCriticRating.CriticRatingSummary = val;
}
}
break;
}
case "Language":
{
var val = reader.ReadElementContentAsString();
2013-12-28 16:58:13 +00:00
var hasLanguage = item as IHasPreferredMetadataLanguage;
if (hasLanguage != null)
{
2013-12-28 16:58:13 +00:00
hasLanguage.PreferredMetadataLanguage = val;
2013-02-21 01:33:05 +00:00
}
break;
}
case "PlaceOfBirth":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var person = item as Person;
if (person != null)
{
person.PlaceOfBirth = val;
}
}
break;
}
case "Website":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.HomePageUrl = val;
}
break;
}
2013-08-04 00:59:23 +00:00
case "LockedFields":
{
var fields = new List<MetadataFields>();
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var list = val.Split('|').Select(i =>
{
MetadataFields field;
if (Enum.TryParse<MetadataFields>(i, true, out field))
{
return (MetadataFields?)field;
}
return null;
}).Where(i => i.HasValue).Select(i => i.Value);
fields.AddRange(list);
}
item.LockedFields = fields;
break;
}
2013-02-21 01:33:05 +00:00
case "TagLines":
{
2013-08-12 19:18:31 +00:00
using (var subtree = reader.ReadSubtree())
{
FetchFromTaglinesNode(subtree, item);
}
2013-02-21 01:33:05 +00:00
break;
}
2014-05-16 19:16:29 +00:00
case "Countries":
{
using (var subtree = reader.ReadSubtree())
{
FetchFromCountriesNode(subtree, item);
}
break;
}
2013-02-21 01:33:05 +00:00
case "ContentRating":
case "MPAARating":
{
var rating = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(rating))
{
item.OfficialRating = rating;
}
break;
}
case "MPAADescription":
{
var rating = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(rating))
{
item.OfficialRatingDescription = rating;
}
break;
}
2013-06-26 16:08:16 +00:00
2013-02-21 01:33:05 +00:00
case "CustomRating":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.CustomRating = val;
}
break;
}
case "RunningTime":
{
var text = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(text))
{
int runtime;
2013-06-16 13:57:26 +00:00
if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out runtime))
2013-02-21 01:33:05 +00:00
{
item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
2013-02-21 01:33:05 +00:00
}
}
break;
}
case "AspectRatio":
{
var val = reader.ReadElementContentAsString();
var hasAspectRatio = item as IHasAspectRatio;
if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
2013-02-21 01:33:05 +00:00
{
hasAspectRatio.AspectRatio = val;
2013-02-21 01:33:05 +00:00
}
break;
}
2013-06-27 13:31:49 +00:00
case "LockData":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
2014-04-27 03:42:05 +00:00
item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
2013-06-27 13:31:49 +00:00
}
break;
}
2013-02-21 01:33:05 +00:00
case "Network":
{
foreach (var name in SplitNames(reader.ReadElementContentAsString()))
{
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
item.AddStudio(name);
}
break;
}
case "Director":
{
2014-02-07 03:10:13 +00:00
foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new Entities.PersonInfo { Name = v.Trim(), Type = PersonType.Director }))
2013-02-21 01:33:05 +00:00
{
if (string.IsNullOrWhiteSpace(p.Name))
{
continue;
}
item.AddPerson(p);
}
break;
}
case "Writer":
{
2014-02-07 03:10:13 +00:00
foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new Entities.PersonInfo { Name = v.Trim(), Type = PersonType.Writer }))
2013-02-21 01:33:05 +00:00
{
if (string.IsNullOrWhiteSpace(p.Name))
{
continue;
}
item.AddPerson(p);
}
break;
}
case "Actors":
{
var actors = reader.ReadInnerXml();
if (actors.Contains("<"))
2013-02-21 01:33:05 +00:00
{
// This is one of the mis-named "Actors" full nodes created by MB2
// Create a reader and pass it to the persons node processor
FetchDataFromPersonsNode(new XmlTextReader(new StringReader("<Persons>" + actors + "</Persons>")), item);
}
else
{
// Old-style piped string
2014-02-07 03:10:13 +00:00
foreach (var p in SplitNames(actors).Select(v => new Entities.PersonInfo { Name = v.Trim(), Type = PersonType.Actor }))
2013-02-21 01:33:05 +00:00
{
if (string.IsNullOrWhiteSpace(p.Name))
{
continue;
}
item.AddPerson(p);
2013-02-21 01:33:05 +00:00
}
}
break;
}
2013-04-13 23:43:41 +00:00
case "GuestStars":
{
2014-02-07 03:10:13 +00:00
foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new Entities.PersonInfo { Name = v.Trim(), Type = PersonType.GuestStar }))
2013-04-13 23:43:41 +00:00
{
if (string.IsNullOrWhiteSpace(p.Name))
{
continue;
}
item.AddPerson(p);
}
break;
}
2013-02-21 01:33:05 +00:00
case "Trailer":
{
var val = reader.ReadElementContentAsString();
2013-12-02 16:46:25 +00:00
var hasTrailers = item as IHasTrailers;
if (hasTrailers != null)
2013-02-21 01:33:05 +00:00
{
2013-12-02 16:46:25 +00:00
if (!string.IsNullOrWhiteSpace(val))
{
hasTrailers.AddTrailerUrl(val, false);
}
}
break;
}
case "DisplayOrder":
{
var val = reader.ReadElementContentAsString();
var hasDisplayOrder = item as IHasDisplayOrder;
if (hasDisplayOrder != null)
{
if (!string.IsNullOrWhiteSpace(val))
{
hasDisplayOrder.DisplayOrder = val;
}
2013-02-21 01:33:05 +00:00
}
break;
}
2013-12-01 20:17:40 +00:00
case "Trailers":
{
using (var subtree = reader.ReadSubtree())
{
2013-12-02 16:46:25 +00:00
var hasTrailers = item as IHasTrailers;
if (hasTrailers != null)
{
FetchDataFromTrailersNode(subtree, hasTrailers);
}
2013-12-01 20:17:40 +00:00
}
break;
}
2013-02-21 01:33:05 +00:00
case "ProductionYear":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int productionYear;
if (int.TryParse(val, out productionYear) && productionYear > 1850)
2013-02-21 01:33:05 +00:00
{
item.ProductionYear = productionYear;
2013-02-21 01:33:05 +00:00
}
}
break;
}
case "Rating":
case "IMDBrating":
{
var rating = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(rating))
{
float val;
// 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 val))
2013-02-21 01:33:05 +00:00
{
item.CommunityRating = val;
}
}
break;
}
2013-07-20 21:36:59 +00:00
case "BirthDate":
2013-06-23 18:55:30 +00:00
case "PremiereDate":
2013-02-21 01:33:05 +00:00
case "FirstAired":
{
var firstAired = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(firstAired))
{
DateTime airDate;
2013-08-25 19:54:18 +00:00
if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out airDate) && airDate.Year > 1850)
2013-02-21 01:33:05 +00:00
{
item.PremiereDate = airDate.ToUniversalTime();
item.ProductionYear = airDate.Year;
}
}
break;
}
case "DeathDate":
case "EndDate":
{
var firstAired = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(firstAired))
{
DateTime airDate;
2013-08-25 19:54:18 +00:00
if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out airDate) && airDate.Year > 1850)
{
item.EndDate = airDate.ToUniversalTime();
}
}
break;
}
2013-07-16 17:18:32 +00:00
case "TvDbId":
var tvdbId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tvdbId))
{
item.SetProviderId(MetadataProviders.Tvdb, tvdbId);
}
break;
2013-10-13 13:32:53 +00:00
case "VoteCount":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int num;
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out num))
{
item.VoteCount = num;
}
}
break;
}
case "MusicBrainzAlbumId":
2013-06-24 14:12:56 +00:00
{
var mbz = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(mbz))
{
item.SetProviderId(MetadataProviders.MusicBrainzAlbum, mbz);
}
break;
}
case "MusicBrainzAlbumArtistId":
{
var mbz = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(mbz))
{
item.SetProviderId(MetadataProviders.MusicBrainzAlbumArtist, mbz);
}
break;
}
case "MusicBrainzArtistId":
{
var mbz = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(mbz))
{
item.SetProviderId(MetadataProviders.MusicBrainzArtist, mbz);
}
break;
}
case "MusicBrainzReleaseGroupId":
{
var mbz = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(mbz))
{
item.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, mbz);
}
break;
2013-06-24 14:12:56 +00:00
}
2014-02-19 05:21:03 +00:00
case "TVRageId":
2014-02-09 21:11:11 +00:00
{
var id = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(id))
{
item.SetProviderId(MetadataProviders.TvRage, id);
}
break;
}
case "AudioDbArtistId":
{
var id = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(id))
{
item.SetProviderId(MetadataProviders.AudioDbArtist, id);
}
break;
}
2014-02-09 21:13:17 +00:00
case "AudioDbAlbumId":
{
var id = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(id))
{
item.SetProviderId(MetadataProviders.AudioDbAlbum, id);
}
break;
}
2013-06-24 14:12:56 +00:00
case "RottenTomatoesId":
var rtId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(rtId))
{
item.SetProviderId(MetadataProviders.RottenTomatoes, rtId);
}
break;
2013-02-21 01:33:05 +00:00
case "TMDbId":
var tmdb = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tmdb))
{
item.SetProviderId(MetadataProviders.Tmdb, tmdb);
}
break;
2013-06-26 16:08:16 +00:00
2013-08-19 20:00:23 +00:00
case "TMDbCollectionId":
var tmdbCollection = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tmdbCollection))
{
item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
}
break;
2013-02-21 01:33:05 +00:00
case "TVcomId":
var TVcomId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(TVcomId))
{
item.SetProviderId(MetadataProviders.Tvcom, TVcomId);
}
break;
case "Zap2ItId":
var zap2ItId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(zap2ItId))
{
item.SetProviderId(MetadataProviders.Zap2It, zap2ItId);
}
break;
2013-02-21 01:33:05 +00:00
case "IMDB":
var imDbId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(imDbId))
2013-02-21 01:33:05 +00:00
{
item.SetProviderId(MetadataProviders.Imdb, imDbId);
2013-02-21 01:33:05 +00:00
}
break;
case "Genres":
2013-08-12 19:18:31 +00:00
{
using (var subtree = reader.ReadSubtree())
{
FetchFromGenresNode(subtree, item);
}
break;
}
2013-02-21 01:33:05 +00:00
2013-06-23 18:55:30 +00:00
case "Tags":
2013-08-12 19:18:31 +00:00
{
using (var subtree = reader.ReadSubtree())
{
var hasTags = item as IHasTags;
if (hasTags != null)
{
FetchFromTagsNode(subtree, hasTags);
}
2013-08-12 19:18:31 +00:00
}
break;
}
2013-06-23 18:55:30 +00:00
2014-01-14 15:50:39 +00:00
case "PlotKeywords":
{
using (var subtree = reader.ReadSubtree())
{
var hasTags = item as IHasKeywords;
if (hasTags != null)
{
FetchFromKeywordsNode(subtree, hasTags);
}
}
break;
}
2013-02-21 01:33:05 +00:00
case "Persons":
2013-08-12 19:18:31 +00:00
{
using (var subtree = reader.ReadSubtree())
{
FetchDataFromPersonsNode(subtree, item);
}
break;
}
2013-02-21 01:33:05 +00:00
case "Studios":
2013-08-12 19:18:31 +00:00
{
using (var subtree = reader.ReadSubtree())
{
FetchFromStudiosNode(subtree, item);
}
break;
}
2013-02-21 01:33:05 +00:00
2013-12-15 01:17:57 +00:00
case "Format3D":
2013-08-12 19:18:31 +00:00
{
2013-12-15 01:17:57 +00:00
var video = item as Video;
if (video != null)
2013-08-12 19:18:31 +00:00
{
2013-12-15 01:17:57 +00:00
var val = reader.ReadElementContentAsString();
2014-06-24 04:18:02 +00:00
if (string.Equals("HSBS", val, StringComparison.CurrentCulture))
2013-12-15 01:17:57 +00:00
{
video.Video3DFormat = Video3DFormat.HalfSideBySide;
}
2014-06-24 04:18:02 +00:00
else if (string.Equals("HTAB", val, StringComparison.CurrentCulture))
2013-12-15 01:17:57 +00:00
{
video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
}
2014-06-24 04:18:02 +00:00
else if (string.Equals("FTAB", val, StringComparison.CurrentCulture))
2013-12-15 01:17:57 +00:00
{
video.Video3DFormat = Video3DFormat.FullTopAndBottom;
}
2014-06-24 04:18:02 +00:00
else if (string.Equals("FSBS", val, StringComparison.CurrentCulture))
2013-12-15 01:17:57 +00:00
{
video.Video3DFormat = Video3DFormat.FullSideBySide;
}
2013-08-12 19:18:31 +00:00
}
break;
}
2013-06-26 16:08:16 +00:00
2013-02-21 01:33:05 +00:00
default:
reader.Skip();
break;
}
2014-05-16 19:16:29 +00:00
}
private void FetchFromCountriesNode(XmlReader reader, T item)
{
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Country":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var hasProductionLocations = item as IHasProductionLocations;
if (hasProductionLocations != null)
{
if (!string.IsNullOrWhiteSpace(val))
{
hasProductionLocations.AddProductionLocation(val);
}
}
}
break;
}
default:
reader.Skip();
break;
}
}
}
2013-02-21 01:33:05 +00: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();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Tagline":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var hasTaglines = item as IHasTaglines;
if (hasTaglines != null)
{
if (!string.IsNullOrWhiteSpace(val))
{
hasTaglines.AddTagline(val);
}
}
2013-02-21 01:33:05 +00:00
}
break;
}
default:
reader.Skip();
break;
}
}
}
}
/// <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();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Genre":
{
var genre = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(genre))
{
item.AddGenre(genre);
}
break;
}
default:
reader.Skip();
break;
}
}
}
}
private void FetchFromTagsNode(XmlReader reader, IHasTags item)
2013-06-23 18:55:30 +00:00
{
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Tag":
{
var tag = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tag))
{
item.AddTag(tag);
2013-06-23 18:55:30 +00:00
}
break;
2014-01-14 15:50:39 +00:00
}
default:
reader.Skip();
break;
}
}
}
}
private void FetchFromKeywordsNode(XmlReader reader, IHasKeywords item)
{
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "PlotKeyword":
{
var tag = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tag))
{
item.AddKeyword(tag);
}
break;
2013-06-23 18:55:30 +00:00
}
default:
reader.Skip();
break;
}
}
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Fetches the data from persons node.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="item">The item.</param>
private void FetchDataFromPersonsNode(XmlReader reader, T item)
{
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Person":
case "Actor":
2013-02-21 01:33:05 +00:00
{
2013-08-12 19:18:31 +00:00
using (var subtree = reader.ReadSubtree())
{
foreach (var person in GetPersonsFromXmlNode(subtree))
{
if (string.IsNullOrWhiteSpace(person.Name))
{
continue;
}
2013-08-12 19:18:31 +00:00
item.AddPerson(person);
}
}
break;
}
default:
reader.Skip();
break;
}
}
}
}
2013-12-02 16:46:25 +00:00
private void FetchDataFromTrailersNode(XmlReader reader, IHasTrailers item)
2013-12-01 20:17:40 +00:00
{
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Trailer":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.AddTrailerUrl(val, false);
}
break;
}
default:
reader.Skip();
break;
}
}
}
}
protected List<ChapterInfo> FetchChaptersFromXmlNode(BaseItem item, XmlReader reader)
2013-08-12 19:18:31 +00:00
{
using (reader)
{
return GetChaptersFromXmlNode(reader)
.Where(i => i.StartPositionTicks >= 0)
.ToList();
2013-08-12 19:18:31 +00:00
}
}
private IEnumerable<ChapterInfo> GetChaptersFromXmlNode(XmlReader reader)
{
var chapters = new List<ChapterInfo>();
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Chapter":
{
using (var subtree = reader.ReadSubtree())
{
2013-08-12 19:18:31 +00:00
chapters.Add(GetChapterInfoFromXmlNode(subtree));
}
2013-02-21 01:33:05 +00:00
break;
}
default:
reader.Skip();
break;
}
}
}
2013-08-12 19:18:31 +00:00
return chapters;
}
private ChapterInfo GetChapterInfoFromXmlNode(XmlReader reader)
{
var chapter = new ChapterInfo();
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "StartPositionMs":
{
var val = reader.ReadElementContentAsString();
var ms = long.Parse(val, _usCulture);
chapter.StartPositionTicks = TimeSpan.FromMilliseconds(ms).Ticks;
break;
}
case "Name":
{
chapter.Name = reader.ReadElementContentAsString();
break;
}
default:
reader.Skip();
break;
}
}
}
return chapter;
2013-02-21 01:33:05 +00: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();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Studio":
{
var studio = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(studio))
{
item.AddStudio(studio);
}
break;
}
default:
reader.Skip();
break;
}
}
}
}
/// <summary>
/// Gets the persons from XML node.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>IEnumerable{PersonInfo}.</returns>
2014-06-24 04:18:02 +00:00
private IEnumerable<PersonInfo> GetPersonsFromXmlNode(XmlReader reader)
2013-02-21 01:33:05 +00:00
{
var name = string.Empty;
2014-06-24 04:18:02 +00:00
var type = PersonType.Actor; // If type is not specified assume actor
2013-02-21 01:33:05 +00:00
var role = string.Empty;
2013-11-20 03:47:29 +00:00
int? sortOrder = null;
2013-02-21 01:33:05 +00:00
reader.MoveToContent();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Name":
name = reader.ReadElementContentAsString() ?? string.Empty;
2013-02-21 01:33:05 +00:00
break;
case "Type":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
type = val;
}
break;
}
case "Role":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
role = val;
}
break;
}
2013-11-20 03:47:29 +00:00
case "SortOrder":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int intVal;
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out intVal))
{
sortOrder = intVal;
}
}
break;
}
2013-02-21 01:33:05 +00:00
default:
reader.Skip();
break;
}
}
}
2014-06-24 04:18:02 +00:00
var personInfo = new PersonInfo
{
Name = name.Trim(),
Role = role,
Type = type,
SortOrder = sortOrder
};
return new[] { personInfo };
2013-02-21 01:33:05 +00:00
}
protected LinkedChild GetLinkedChild(XmlReader reader)
{
reader.MoveToContent();
var linkedItem = new LinkedChild
{
Type = LinkedChildType.Manual
};
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Name":
{
linkedItem.ItemName = reader.ReadElementContentAsString();
break;
}
2014-08-05 03:41:56 +00:00
case "Path":
{
2014-08-05 03:41:56 +00:00
linkedItem.Path = reader.ReadElementContentAsString();
break;
}
2014-08-05 03:41:56 +00:00
case "Type":
{
2014-08-05 03:41:56 +00:00
linkedItem.ItemType = reader.ReadElementContentAsString();
break;
}
2014-08-05 03:41:56 +00:00
case "Year":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int rval;
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
{
2014-08-05 03:41:56 +00:00
linkedItem.ItemYear = rval;
}
}
break;
}
default:
reader.Skip();
break;
}
}
}
return string.IsNullOrWhiteSpace(linkedItem.ItemName) || string.IsNullOrWhiteSpace(linkedItem.ItemType) ? null : linkedItem;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Used to split names of comma or pipe delimeted genres and people
/// </summary>
/// <param name="value">The value.</param>
/// <returns>IEnumerable{System.String}.</returns>
private IEnumerable<string> SplitNames(string value)
{
value = value ?? string.Empty;
// Only split by comma if there is no pipe in the string
// We have to be careful to not split names like Matthew, Jr.
var separator = value.IndexOf('|') == -1 && value.IndexOf(';') == -1 ? new[] { ',' } : new[] { '|', ';' };
2013-02-21 01:33:05 +00:00
value = value.Trim().Trim(separator);
return string.IsNullOrWhiteSpace(value) ? new string[] { } : Split(value, separator, StringSplitOptions.RemoveEmptyEntries);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Provides an additional overload for string.split
/// </summary>
/// <param name="val">The val.</param>
/// <param name="separators">The separators.</param>
/// <param name="options">The options.</param>
/// <returns>System.String[][].</returns>
private static string[] Split(string val, char[] separators, StringSplitOptions options)
{
return val.Split(separators, options);
}
2013-02-21 01:33:05 +00:00
}
}