public void Fetch(LocalMetadataResult <Episode> item,
List <LocalImageInfo> images,
string metadataFile,
CancellationToken cancellationToken)
{
Fetch(item, metadataFile, cancellationToken);
}
/// <summary>
/// Fetches the data from XML node.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="itemResult">The item result.</param>
protected override void FetchDataFromXmlNode(XmlReader reader, LocalMetadataResult <Season> itemResult)
{
var item = itemResult.Item;
switch (reader.Name)
{
case "seasonnumber":
{
var number = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(number))
{
int num;
if (int.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out num))
{
item.IndexNumber = num;
}
}
break;
}
default:
base.FetchDataFromXmlNode(reader, itemResult);
break;
}
}
public async Task <LocalMetadataResult <T> > GetMetadata(ItemInfo info,
IDirectoryService directoryService,
CancellationToken cancellationToken)
{
var result = new LocalMetadataResult <T>();
var file = GetXmlFile(info, directoryService);
if (file == null)
{
return(result);
}
var path = file.FullName;
try
{
result.Item = new T();
Fetch(result, path, cancellationToken);
result.HasMetadata = true;
}
catch (FileNotFoundException)
{
result.HasMetadata = false;
}
catch (DirectoryNotFoundException)
{
result.HasMetadata = false;
}
return(result);
}
protected override void Fetch(LocalMetadataResult <Trailer> result, string path, CancellationToken cancellationToken)
{
var chapters = new List <ChapterInfo>();
new MovieXmlParser(_logger).Fetch(result.Item, chapters, path, cancellationToken);
result.Chapters = chapters;
}
protected override void Fetch(LocalMetadataResult <Episode> result, string path, CancellationToken cancellationToken)
{
var images = new List <LocalImageInfo>();
new EpisodeNfoParser(_logger, _config).Fetch(result, images, path, cancellationToken);
result.Images = images;
}
protected override void Fetch(LocalMetadataResult <T> result, string path, CancellationToken cancellationToken)
{
var chapters = new List <ChapterInfo>();
new MovieNfoParser(_logger, _config).Fetch(result.Item, result.UserDataLIst, chapters, path, cancellationToken);
result.Chapters = chapters;
}
/// <summary>
/// Fetches the data from XML node.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="itemResult">The item result.</param>
protected override void FetchDataFromXmlNode(XmlReader reader, LocalMetadataResult <Video> itemResult)
{
var item = itemResult.Item;
switch (reader.Name)
{
case "id":
var id = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(id))
{
item.SetProviderId(MetadataProviders.Imdb, id);
}
break;
case "set":
{
var val = reader.ReadElementContentAsString();
var movie = item as Movie;
if (!string.IsNullOrWhiteSpace(val) && movie != null)
{
movie.TmdbCollectionName = val;
}
break;
}
case "artist":
{
var val = reader.ReadElementContentAsString();
var movie = item as MusicVideo;
if (!string.IsNullOrWhiteSpace(val) && movie != null)
{
movie.Artists.Add(val);
}
break;
}
case "album":
{
var val = reader.ReadElementContentAsString();
var movie = item as MusicVideo;
if (!string.IsNullOrWhiteSpace(val) && movie != null)
{
movie.Album = val;
}
break;
}
default:
base.FetchDataFromXmlNode(reader, itemResult);
break;
}
}
protected override void Fetch(LocalMetadataResult <Episode> result, string path, CancellationToken cancellationToken)
{
var images = new List <LocalImageInfo>();
var chapters = new List <ChapterInfo>();
new EpisodeXmlParser(_logger).Fetch(result.Item, images, chapters, path, cancellationToken);
result.Images = images;
result.Chapters = chapters;
}
protected override void Fetch(LocalMetadataResult <T> result, string path, CancellationToken cancellationToken)
{
var tmpItem = new LocalMetadataResult <Video>
{
Item = result.Item
};
new MovieNfoParser(_logger, _config).Fetch(tmpItem, path, cancellationToken);
result.Item = (T)tmpItem.Item;
result.People = tmpItem.People;
result.UserDataLIst = tmpItem.UserDataLIst;
}
public Task <LocalMetadataResult <Book> > GetMetadata(ItemInfo info, IDirectoryService directoryService, CancellationToken cancellationToken)
{
var path = GetXmlFile(info.Path, info.IsInMixedFolder).FullName;
var result = new LocalMetadataResult <Book>();
try
{
var item = new Book();
ReadXmlData(item, path, cancellationToken);
result.HasMetadata = true;
result.Item = item;
}
catch (FileNotFoundException)
{
result.HasMetadata = false;
}
return(Task.FromResult(result));
}
public async Task <LocalMetadataResult <T> > GetMetadata(ItemInfo info,
IDirectoryService directoryService,
CancellationToken cancellationToken)
{
var result = new LocalMetadataResult <T>();
var file = GetXmlFile(info, directoryService);
if (file == null)
{
return(result);
}
var path = file.FullName;
//await XmlProviderUtils.XmlParsingResourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
result.Item = new T();
Fetch(result, path, cancellationToken);
result.HasMetadata = true;
}
catch (FileNotFoundException)
{
result.HasMetadata = false;
}
catch (DirectoryNotFoundException)
{
result.HasMetadata = false;
}
finally
{
//XmlProviderUtils.XmlParsingResourcePool.Release();
}
return(result);
}
/// <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(LocalMetadataResult <T> item, string metadataFile, CancellationToken cancellationToken)
{
if (item == null)
{
throw new ArgumentNullException();
}
if (string.IsNullOrEmpty(metadataFile))
{
throw new ArgumentNullException();
}
var settings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
Fetch(item, metadataFile, settings, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <BoxSet> result, string path, CancellationToken cancellationToken)
{
new BoxSetXmlParser(_logger).Fetch(result.Item, path, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <MusicAlbum> result, string path, CancellationToken cancellationToken)
{
new BaseNfoParser <MusicAlbum>(_logger, _config).Fetch(result, path, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <Playlist> result, string path, CancellationToken cancellationToken)
{
new PlaylistXmlParser(_logger).Fetch(result, path, 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="cancellationToken">The cancellation token.</param>
private void Fetch(LocalMetadataResult <T> item, string metadataFile, XmlReaderSettings settings, CancellationToken cancellationToken)
{
if (!SupportsUrlAfterClosingXmlTag)
{
using (var streamReader = BaseNfoSaver.GetStreamReader(metadataFile))
{
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))
{
reader.MoveToContent();
// Loop through each element
while (reader.Read())
{
cancellationToken.ThrowIfCancellationRequested();
if (reader.NodeType == XmlNodeType.Element)
{
FetchDataFromXmlNode(reader, item);
}
}
}
}
return;
}
using (var streamReader = BaseNfoSaver.GetStreamReader(metadataFile))
{
// Need to handle a url after the xml data
// http://kodi.wiki/view/NFO_files/movies
var xml = streamReader.ReadToEnd();
var index = xml.LastIndexOf('>');
if (index != -1)
{
var endingXml = xml.Substring(index);
ParseProviderLinks(item.Item, endingXml);
// If the file is just an imdb url, don't go any further
if (index == 0)
{
return;
}
xml = xml.Substring(0, index + 1);
}
else
{
// If the file is just an Imdb url, handle that
ParseProviderLinks(item.Item, xml);
return;
}
using (var ms = new MemoryStream())
{
var bytes = Encoding.UTF8.GetBytes(xml);
ms.Write(bytes, 0, bytes.Length);
ms.Position = 0;
// Use XmlReader for best performance
using (var reader = XmlReader.Create(ms, settings))
{
reader.MoveToContent();
// Loop through each element
while (reader.Read())
{
cancellationToken.ThrowIfCancellationRequested();
if (reader.NodeType == XmlNodeType.Element)
{
FetchDataFromXmlNode(reader, item);
}
}
}
}
}
}
protected abstract void Fetch(LocalMetadataResult <T> result, string path, CancellationToken cancellationToken);
protected virtual void FetchDataFromXmlNode(XmlReader reader, LocalMetadataResult <T> itemResult)
{
var item = itemResult.Item;
var userDataUserId = _config.GetNfoConfiguration().UserId;
switch (reader.Name)
{
// DateCreated
case "dateadded":
{
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;
}
case "originaltitle":
{
var val = reader.ReadElementContentAsString();
var hasOriginalTitle = item as IHasOriginalTitle;
if (hasOriginalTitle != null)
{
if (!string.IsNullOrEmpty(hasOriginalTitle.OriginalTitle))
{
hasOriginalTitle.OriginalTitle = val;
}
}
break;
}
case "type":
item.DisplayMediaType = reader.ReadElementContentAsString();
break;
case "title":
case "localtitle":
item.Name = reader.ReadElementContentAsString();
break;
case "criticrating":
{
var text = reader.ReadElementContentAsString();
var hasCriticRating = item as IHasCriticRating;
if (hasCriticRating != null && !string.IsNullOrEmpty(text))
{
float value;
if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
{
hasCriticRating.CriticRating = value;
}
}
break;
}
case "budget":
{
var text = reader.ReadElementContentAsString();
var hasBudget = item as IHasBudget;
if (hasBudget != null)
{
double value;
if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
{
hasBudget.Budget = value;
}
}
break;
}
case "revenue":
{
var text = reader.ReadElementContentAsString();
var hasBudget = item as IHasBudget;
if (hasBudget != null)
{
double value;
if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
{
hasBudget.Revenue = value;
}
}
break;
}
case "metascore":
{
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;
}
case "awardsummary":
{
var text = reader.ReadElementContentAsString();
var hasAwards = item as IHasAwards;
if (hasAwards != null)
{
if (!string.IsNullOrWhiteSpace(text))
{
hasAwards.AwardSummary = text;
}
}
break;
}
case "sorttitle":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.ForcedSortName = val;
}
break;
}
case "outline":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var hasShortOverview = item as IHasShortOverview;
if (hasShortOverview != null)
{
hasShortOverview.ShortOverview = val;
}
}
break;
}
case "biography":
case "plot":
case "review":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.Overview = val;
}
break;
}
case "criticratingsummary":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var hasCriticRating = item as IHasCriticRating;
if (hasCriticRating != null)
{
hasCriticRating.CriticRatingSummary = val;
}
}
break;
}
case "language":
{
var val = reader.ReadElementContentAsString();
var hasLanguage = item as IHasPreferredMetadataLanguage;
if (hasLanguage != null)
{
hasLanguage.PreferredMetadataLanguage = val;
}
break;
}
case "countrycode":
{
var val = reader.ReadElementContentAsString();
var hasLanguage = item as IHasPreferredMetadataLanguage;
if (hasLanguage != null)
{
hasLanguage.PreferredMetadataCountryCode = val;
}
break;
}
case "website":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.HomePageUrl = val;
}
break;
}
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;
}
case "tagline":
{
var val = reader.ReadElementContentAsString();
var hasTagline = item as IHasTaglines;
if (hasTagline != null)
{
if (!string.IsNullOrWhiteSpace(val))
{
hasTagline.AddTagline(val);
}
}
break;
}
case "country":
{
var val = reader.ReadElementContentAsString();
var hasProductionLocations = item as IHasProductionLocations;
if (hasProductionLocations != null)
{
if (!string.IsNullOrWhiteSpace(val))
{
var parts = val.Split('/')
.Select(i => i.Trim())
.Where(i => !string.IsNullOrWhiteSpace(i));
foreach (var p in parts)
{
hasProductionLocations.AddProductionLocation(p);
}
}
}
break;
}
case "mpaa":
{
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;
}
case "customrating":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.CustomRating = val;
}
break;
}
case "runtime":
{
var text = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(text))
{
int runtime;
if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out runtime))
{
item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
}
}
break;
}
case "aspectratio":
{
var val = reader.ReadElementContentAsString();
var hasAspectRatio = item as IHasAspectRatio;
if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
{
hasAspectRatio.AspectRatio = val;
}
break;
}
case "lockdata":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
}
break;
}
case "studio":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var parts = val.Split('/')
.Select(i => i.Trim())
.Where(i => !string.IsNullOrWhiteSpace(i));
foreach (var p in parts)
{
item.AddStudio(p);
}
}
break;
}
case "director":
{
foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
Name = v.Trim(), Type = PersonType.Director
}))
{
if (string.IsNullOrWhiteSpace(p.Name))
{
continue;
}
PeopleHelper.AddPerson(itemResult.People, p);
}
break;
}
case "credits":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var parts = val.Split('/').Select(i => i.Trim())
.Where(i => !string.IsNullOrEmpty(i));
foreach (var p in parts.Select(v => new PersonInfo {
Name = v.Trim(), Type = PersonType.Writer
}))
{
if (string.IsNullOrWhiteSpace(p.Name))
{
continue;
}
PeopleHelper.AddPerson(itemResult.People, p);
}
}
break;
}
case "writer":
{
foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
Name = v.Trim(), Type = PersonType.Writer
}))
{
if (string.IsNullOrWhiteSpace(p.Name))
{
continue;
}
PeopleHelper.AddPerson(itemResult.People, p);
}
break;
}
case "actor":
{
using (var subtree = reader.ReadSubtree())
{
var person = GetPersonFromXmlNode(subtree);
PeopleHelper.AddPerson(itemResult.People, person);
}
break;
}
case "trailer":
{
var val = reader.ReadElementContentAsString();
var hasTrailer = item as IHasTrailers;
if (hasTrailer != null)
{
if (!string.IsNullOrWhiteSpace(val))
{
val = val.Replace("plugin://plugin.video.youtube/?action=play_video&videoid=", "http://www.youtube.com/watch?v=", StringComparison.OrdinalIgnoreCase);
hasTrailer.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;
}
}
break;
}
case "year":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int productionYear;
if (int.TryParse(val, out productionYear) && productionYear > 1850)
{
item.ProductionYear = productionYear;
}
}
break;
}
case "rating":
{
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))
{
item.CommunityRating = val;
}
}
break;
}
case "aired":
case "formed":
case "premiered":
case "releasedate":
{
var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
DateTime date;
if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
{
item.PremiereDate = date.ToUniversalTime();
item.ProductionYear = date.Year;
}
}
break;
}
case "enddate":
{
var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
DateTime date;
if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
{
item.EndDate = date.ToUniversalTime();
}
}
break;
}
case "tvdbid":
var tvdbId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tvdbId))
{
item.SetProviderId(MetadataProviders.Tvdb, tvdbId);
}
break;
case "votes":
{
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":
{
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;
}
case "tvrageid":
{
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;
}
case "audiodbalbumid":
{
var id = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(id))
{
item.SetProviderId(MetadataProviders.AudioDbAlbum, id);
}
break;
}
case "rottentomatoesid":
var rtId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(rtId))
{
item.SetProviderId(MetadataProviders.RottenTomatoes, rtId);
}
break;
case "tmdbid":
var tmdb = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tmdb))
{
item.SetProviderId(MetadataProviders.Tmdb, tmdb);
}
break;
case "collectionnumber":
var tmdbCollection = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tmdbCollection))
{
item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
}
break;
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;
case "imdb_id":
case "imdbid":
var imDbId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(imDbId))
{
item.SetProviderId(MetadataProviders.Imdb, imDbId);
}
break;
case "genre":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var parts = val.Split('/')
.Select(i => i.Trim())
.Where(i => !string.IsNullOrWhiteSpace(i));
foreach (var p in parts)
{
item.AddGenre(p);
}
}
break;
}
case "style":
case "tag":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
var hasTags = item as IHasTags;
if (hasTags != null)
{
hasTags.AddTag(val);
}
}
break;
}
case "plotkeyword":
{
var val = reader.ReadElementContentAsString();
var hasKeywords = item as IHasKeywords;
if (hasKeywords != null)
{
if (!string.IsNullOrWhiteSpace(val))
{
hasKeywords.AddKeyword(val);
}
}
break;
}
case "fileinfo":
{
using (var subtree = reader.ReadSubtree())
{
FetchFromFileInfoNode(subtree, item);
}
break;
}
case "watched":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
bool parsedValue;
if (bool.TryParse(val, out parsedValue))
{
if (!string.IsNullOrWhiteSpace(userDataUserId))
{
var userData = GetOrAdd(itemResult.UserDataLIst, userDataUserId);
userData.Played = parsedValue;
}
}
}
break;
}
case "playcount":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int parsedValue;
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out parsedValue))
{
if (!string.IsNullOrWhiteSpace(userDataUserId))
{
var userData = GetOrAdd(itemResult.UserDataLIst, userDataUserId);
userData.PlayCount = parsedValue;
if (parsedValue > 0)
{
userData.Played = true;
}
}
}
}
break;
}
case "lastplayed":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
DateTime parsedValue;
if (DateTime.TryParseExact(val, "yyyy-MM-dd HH:mm:ss", _usCulture, DateTimeStyles.None, out parsedValue))
{
if (!string.IsNullOrWhiteSpace(userDataUserId))
{
var userData = GetOrAdd(itemResult.UserDataLIst, userDataUserId);
userData.LastPlayedDate = parsedValue;
}
}
}
break;
}
case "resume":
{
using (var subtree = reader.ReadSubtree())
{
if (!string.IsNullOrWhiteSpace(userDataUserId))
{
var userData = GetOrAdd(itemResult.UserDataLIst, userDataUserId);
FetchFromResumeNode(subtree, item, userData);
}
}
break;
}
case "isuserfavorite":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
bool parsedValue;
if (bool.TryParse(val, out parsedValue))
{
if (!string.IsNullOrWhiteSpace(userDataUserId))
{
var userData = GetOrAdd(itemResult.UserDataLIst, userDataUserId);
userData.IsFavorite = parsedValue;
}
}
}
break;
}
case "userrating":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
double parsedValue;
if (double.TryParse(val, NumberStyles.Any, _usCulture, out parsedValue))
{
if (!string.IsNullOrWhiteSpace(userDataUserId))
{
var userData = GetOrAdd(itemResult.UserDataLIst, userDataUserId);
userData.Rating = parsedValue;
}
}
}
break;
}
default:
reader.Skip();
break;
}
}
protected override void Fetch(LocalMetadataResult <MusicArtist> result, string path, CancellationToken cancellationToken)
{
new BaseItemXmlParser <MusicArtist>(_logger).Fetch(result.Item, path, cancellationToken);
}
/// <summary>
/// Fetches the data from XML node.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="itemResult">The item result.</param>
protected override void FetchDataFromXmlNode(XmlReader reader, LocalMetadataResult <Series> itemResult)
{
var item = itemResult.Item;
switch (reader.Name)
{
case "id":
string id = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(id))
{
item.SetProviderId(MetadataProviders.Tvdb, id);
}
break;
case "airs_dayofweek":
{
item.AirDays = TVUtils.GetAirDays(reader.ReadElementContentAsString());
break;
}
case "airs_time":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.AirTime = val;
}
break;
}
case "animeseriesindex":
{
var number = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(number))
{
int num;
if (int.TryParse(number, out num))
{
item.AnimeSeriesIndex = num;
}
}
break;
}
case "status":
{
var status = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(status))
{
SeriesStatus seriesStatus;
if (Enum.TryParse(status, true, out seriesStatus))
{
item.Status = seriesStatus;
}
else
{
Logger.Info("Unrecognized series status: " + status);
}
}
break;
}
default:
base.FetchDataFromXmlNode(reader, itemResult);
break;
}
}
/// <summary>
/// Fetches the data from XML node.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="itemResult">The item result.</param>
protected override void FetchDataFromXmlNode(XmlReader reader, LocalMetadataResult <Episode> itemResult)
{
var item = itemResult.Item;
switch (reader.Name)
{
case "season":
{
var number = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(number))
{
int num;
if (int.TryParse(number, out num))
{
item.ParentIndexNumber = num;
}
}
break;
}
case "episode":
{
var number = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(number))
{
int num;
if (int.TryParse(number, out num))
{
item.IndexNumber = num;
}
}
break;
}
case "episodenumberend":
{
var number = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(number))
{
int num;
if (int.TryParse(number, out num))
{
item.IndexNumberEnd = num;
}
}
break;
}
case "absolute_number":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int rval;
// int.TryParse is local aware, so it can be probamatic, force us culture
if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
{
item.AbsoluteEpisodeNumber = rval;
}
}
break;
}
case "DVD_episodenumber":
{
var number = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(number))
{
float num;
if (float.TryParse(number, NumberStyles.Any, UsCulture, out num))
{
item.DvdEpisodeNumber = num;
}
}
break;
}
case "DVD_season":
{
var number = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(number))
{
float num;
if (float.TryParse(number, NumberStyles.Any, UsCulture, out num))
{
item.DvdSeasonNumber = Convert.ToInt32(num);
}
}
break;
}
case "airsbefore_episode":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int rval;
// int.TryParse is local aware, so it can be probamatic, force us culture
if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
{
item.AirsBeforeEpisodeNumber = rval;
}
}
break;
}
case "airsafter_season":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int rval;
// int.TryParse is local aware, so it can be probamatic, force us culture
if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
{
item.AirsAfterSeasonNumber = rval;
}
}
break;
}
case "airsbefore_season":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int rval;
// int.TryParse is local aware, so it can be probamatic, force us culture
if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
{
item.AirsBeforeSeasonNumber = rval;
}
}
break;
}
default:
base.FetchDataFromXmlNode(reader, itemResult);
break;
}
}
protected override void Fetch(LocalMetadataResult <MusicArtist> result, string path, CancellationToken cancellationToken)
{
new BaseNfoParser <MusicArtist>(_logger, _config).Fetch(result.Item, result.UserDataLIst, path, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <GameSystem> result, string path, CancellationToken cancellationToken)
{
new GameSystemXmlParser(_logger).Fetch(result, path, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <Folder> result, string path, CancellationToken cancellationToken)
{
new BaseItemXmlParser <Folder>(_logger).Fetch(result, path, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <MusicVideo> result, string path, CancellationToken cancellationToken)
{
new MusicVideoXmlParser(_logger).Fetch(result, path, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <Season> result, string path, CancellationToken cancellationToken)
{
new SeasonNfoParser(_logger, _config).Fetch(result.Item, path, cancellationToken);
}
protected override void Fetch(LocalMetadataResult <LiveTvChannel> result, string path, CancellationToken cancellationToken)
{
new BaseItemXmlParser <LiveTvChannel>(_logger).Fetch(result.Item, path, cancellationToken);
}
