jellyfin-server/MediaBrowser.Providers/TV/TvdbSeriesProvider.cs

1293 lines
50 KiB
C#
Raw Normal View History

2013-09-15 19:33:23 +00:00
using MediaBrowser.Common.Configuration;
2013-10-10 16:55:07 +00:00
using MediaBrowser.Common.IO;
2013-02-25 00:13:45 +00:00
using MediaBrowser.Common.Net;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Controller.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
2013-06-09 16:47:28 +00:00
using MediaBrowser.Controller.Providers;
2015-01-18 05:45:10 +00:00
using MediaBrowser.Model.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.IO;
2013-03-02 17:59:15 +00:00
using MediaBrowser.Model.Logging;
2015-04-16 14:59:39 +00:00
using MediaBrowser.Model.Net;
using MediaBrowser.Model.Providers;
2013-02-21 01:33:05 +00:00
using System;
2013-09-15 19:33:23 +00:00
using System.Collections.Generic;
using System.Globalization;
2013-02-21 01:33:05 +00:00
using System.IO;
using System.Linq;
2013-02-21 01:33:05 +00:00
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
2013-06-09 16:47:28 +00:00
namespace MediaBrowser.Providers.TV
2013-02-21 01:33:05 +00:00
{
public class TvdbSeriesProvider : IRemoteMetadataProvider<Series, SeriesInfo>, IItemIdentityProvider<SeriesInfo, SeriesIdentity>, IHasOrder
2013-02-21 01:33:05 +00:00
{
private const string TvdbSeriesOffset = "TvdbSeriesOffset";
private const string TvdbSeriesOffsetFormat = "{0}-{1}";
2013-05-23 15:40:20 +00:00
internal readonly SemaphoreSlim TvDbResourcePool = new SemaphoreSlim(2, 2);
internal static TvdbSeriesProvider Current { get; private set; }
private readonly IZipClient _zipClient;
2014-02-03 20:51:28 +00:00
private readonly IHttpClient _httpClient;
private readonly IFileSystem _fileSystem;
2014-02-03 20:51:28 +00:00
private readonly IServerConfigurationManager _config;
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
private readonly ILogger _logger;
private readonly ISeriesOrderManager _seriesOrder;
2014-11-16 22:46:01 +00:00
private readonly ILibraryManager _libraryManager;
2014-11-16 22:46:01 +00:00
public TvdbSeriesProvider(IZipClient zipClient, IHttpClient httpClient, IFileSystem fileSystem, IServerConfigurationManager config, ILogger logger, ISeriesOrderManager seriesOrder, ILibraryManager libraryManager)
2013-02-25 00:13:45 +00:00
{
_zipClient = zipClient;
2014-02-03 20:51:28 +00:00
_httpClient = httpClient;
_fileSystem = fileSystem;
2014-02-03 20:51:28 +00:00
_config = config;
_logger = logger;
_seriesOrder = seriesOrder;
2014-11-16 22:46:01 +00:00
_libraryManager = libraryManager;
2013-03-04 05:43:06 +00:00
Current = this;
}
2015-02-20 18:27:01 +00:00
private const string SeriesSearchUrl = "http://www.thetvdb.com/api/GetSeries.php?seriesname={0}&language={1}";
private const string SeriesGetZip = "http://www.thetvdb.com/api/{0}/series/{1}/all/{2}.zip";
2013-02-21 01:33:05 +00:00
public async Task<IEnumerable<RemoteSearchResult>> GetSearchResults(SeriesInfo searchInfo, CancellationToken cancellationToken)
{
2014-03-02 15:42:21 +00:00
var seriesId = searchInfo.GetProviderId(MetadataProviders.Tvdb);
2015-02-20 18:27:01 +00:00
if (string.IsNullOrWhiteSpace(seriesId))
2014-03-02 15:42:21 +00:00
{
2015-02-20 18:27:01 +00:00
return await FindSeries(searchInfo.Name, searchInfo.MetadataLanguage, cancellationToken).ConfigureAwait(false);
2014-03-02 15:42:21 +00:00
}
2014-08-19 01:42:53 +00:00
var metadata = await GetMetadata(searchInfo, cancellationToken).ConfigureAwait(false);
var list = new List<RemoteSearchResult>();
if (metadata.HasMetadata)
{
var res = new RemoteSearchResult
{
Name = metadata.Item.Name,
PremiereDate = metadata.Item.PremiereDate,
ProductionYear = metadata.Item.ProductionYear,
ProviderIds = metadata.Item.ProviderIds,
SearchProviderName = Name
};
list.Add(res);
}
return list;
}
2014-02-07 03:10:13 +00:00
public async Task<MetadataResult<Series>> GetMetadata(SeriesInfo itemId, CancellationToken cancellationToken)
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
var result = new MetadataResult<Series>();
2014-02-03 20:51:28 +00:00
var seriesId = itemId.GetProviderId(MetadataProviders.Tvdb);
2015-02-20 18:27:01 +00:00
if (string.IsNullOrWhiteSpace(seriesId))
2013-02-21 01:33:05 +00:00
{
seriesId = itemId.Identities
.Where(id => id.Type == MetadataProviders.Tvdb.ToString())
.Select(id => id.Id)
.FirstOrDefault();
2015-02-20 18:27:01 +00:00
if (string.IsNullOrWhiteSpace(seriesId))
{
2014-08-19 01:42:53 +00:00
var srch = await GetSearchResults(itemId, cancellationToken).ConfigureAwait(false);
2014-02-14 04:00:13 +00:00
2014-08-19 01:42:53 +00:00
var entry = srch.FirstOrDefault();
2014-02-14 04:00:13 +00:00
2014-08-19 01:42:53 +00:00
if (entry != null)
2014-02-14 04:00:13 +00:00
{
2014-08-19 01:42:53 +00:00
seriesId = entry.GetProviderId(MetadataProviders.Tvdb);
2014-02-14 04:00:13 +00:00
}
}
}
2013-02-21 01:33:05 +00:00
cancellationToken.ThrowIfCancellationRequested();
2015-02-20 18:27:01 +00:00
if (!string.IsNullOrWhiteSpace(seriesId))
{
2014-02-03 20:51:28 +00:00
await EnsureSeriesInfo(seriesId, itemId.MetadataLanguage, cancellationToken).ConfigureAwait(false);
result.Item = new Series();
result.HasMetadata = true;
2014-02-03 20:51:28 +00:00
FetchSeriesData(result.Item, seriesId, cancellationToken);
await FindAnimeSeriesIndex(result.Item, itemId).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
}
2014-02-03 20:51:28 +00:00
return result;
2013-02-21 01:33:05 +00:00
}
private async Task FindAnimeSeriesIndex(Series series, SeriesInfo info)
{
var index = await _seriesOrder.FindSeriesIndex(SeriesOrderTypes.Anime, series.Name);
if (index == null)
return;
var offset = info.AnimeSeriesIndex - index;
var id = string.Format(TvdbSeriesOffsetFormat, series.GetProviderId(MetadataProviders.Tvdb), offset);
series.SetProviderId(TvdbSeriesOffset, id);
}
internal static int? GetSeriesOffset(Dictionary<string, string> seriesProviderIds)
{
string idString;
if (!seriesProviderIds.TryGetValue(TvdbSeriesOffset, out idString))
return null;
var parts = idString.Split('-');
if (parts.Length < 2)
return null;
int offset;
if (int.TryParse(parts[1], out offset))
return offset;
return null;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Fetches the series data.
/// </summary>
/// <param name="series">The series.</param>
/// <param name="seriesId">The series id.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{System.Boolean}.</returns>
2014-02-03 20:51:28 +00:00
private void FetchSeriesData(Series series, string seriesId, CancellationToken cancellationToken)
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
series.SetProviderId(MetadataProviders.Tvdb, seriesId);
2013-10-04 15:22:03 +00:00
2014-02-03 20:51:28 +00:00
var seriesDataPath = GetSeriesDataPath(_config.ApplicationPaths, seriesId);
var seriesXmlFilename = series.GetPreferredMetadataLanguage().ToLower() + ".xml";
2014-02-03 20:51:28 +00:00
var seriesXmlPath = Path.Combine(seriesDataPath, seriesXmlFilename);
var actorsXmlPath = Path.Combine(seriesDataPath, "actors.xml");
2014-02-03 20:51:28 +00:00
FetchSeriesInfo(series, seriesXmlPath, cancellationToken);
2013-09-16 17:52:14 +00:00
2014-02-03 20:51:28 +00:00
cancellationToken.ThrowIfCancellationRequested();
2013-10-16 01:44:23 +00:00
2014-02-03 20:51:28 +00:00
FetchActors(series, actorsXmlPath);
}
/// <summary>
/// Downloads the series zip.
/// </summary>
/// <param name="seriesId">The series id.</param>
/// <param name="seriesDataPath">The series data path.</param>
/// <param name="lastTvDbUpdateTime">The last tv database update time.</param>
/// <param name="preferredMetadataLanguage">The preferred metadata language.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
internal async Task DownloadSeriesZip(string seriesId, string seriesDataPath, long? lastTvDbUpdateTime, string preferredMetadataLanguage, CancellationToken cancellationToken)
2015-04-16 14:59:39 +00:00
{
try
{
await DownloadSeriesZip(seriesId, seriesDataPath, lastTvDbUpdateTime, preferredMetadataLanguage, preferredMetadataLanguage, cancellationToken).ConfigureAwait(false);
return;
}
catch (HttpException ex)
{
if (!ex.StatusCode.HasValue || ex.StatusCode.Value != HttpStatusCode.NotFound)
{
throw;
}
}
if (!string.Equals(preferredMetadataLanguage, "en", StringComparison.OrdinalIgnoreCase))
{
await DownloadSeriesZip(seriesId, seriesDataPath, lastTvDbUpdateTime, "en", preferredMetadataLanguage, cancellationToken).ConfigureAwait(false);
}
}
private async Task DownloadSeriesZip(string seriesId, string seriesDataPath, long? lastTvDbUpdateTime, string preferredMetadataLanguage, string saveAsMetadataLanguage, CancellationToken cancellationToken)
{
var url = string.Format(SeriesGetZip, TVUtils.TvdbApiKey, seriesId, preferredMetadataLanguage);
2014-02-03 20:51:28 +00:00
using (var zipStream = await _httpClient.Get(new HttpRequestOptions
{
Url = url,
ResourcePool = TvDbResourcePool,
CancellationToken = cancellationToken
2013-02-21 01:33:05 +00:00
}).ConfigureAwait(false))
{
2013-10-24 17:49:24 +00:00
// Delete existing files
DeleteXmlFiles(seriesDataPath);
// Copy to memory stream because we need a seekable stream
using (var ms = new MemoryStream())
{
await zipStream.CopyToAsync(ms).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
ms.Position = 0;
_zipClient.ExtractAllFromZip(ms, seriesDataPath, true);
}
}
2013-10-10 16:55:07 +00:00
// Sanitize all files, except for extracted episode files
foreach (var file in Directory.EnumerateFiles(seriesDataPath, "*.xml", SearchOption.AllDirectories).ToList()
.Where(i => !Path.GetFileName(i).StartsWith("episode-", StringComparison.OrdinalIgnoreCase)))
2013-10-10 16:55:07 +00:00
{
await SanitizeXmlFile(file).ConfigureAwait(false);
}
2015-04-19 03:35:17 +00:00
var downloadLangaugeXmlFile = Path.Combine(seriesDataPath, preferredMetadataLanguage + ".xml");
var saveAsLanguageXmlFile = Path.Combine(seriesDataPath, saveAsMetadataLanguage + ".xml");
if (!string.Equals(downloadLangaugeXmlFile, saveAsLanguageXmlFile, StringComparison.OrdinalIgnoreCase))
{
File.Copy(downloadLangaugeXmlFile, saveAsLanguageXmlFile, true);
}
await ExtractEpisodes(seriesDataPath, downloadLangaugeXmlFile, lastTvDbUpdateTime).ConfigureAwait(false);
2013-10-10 16:55:07 +00:00
}
2015-01-18 05:45:10 +00:00
public TvdbOptions GetTvDbOptions()
{
return _config.GetConfiguration<TvdbOptions>("tvdb");
}
private readonly Task _cachedTask = Task.FromResult(true);
internal Task EnsureSeriesInfo(string seriesId, string preferredMetadataLanguage, CancellationToken cancellationToken)
2014-02-03 05:35:43 +00:00
{
2014-02-03 20:51:28 +00:00
var seriesDataPath = GetSeriesDataPath(_config.ApplicationPaths, seriesId);
2014-02-03 05:35:43 +00:00
Directory.CreateDirectory(seriesDataPath);
var files = new DirectoryInfo(seriesDataPath).EnumerateFiles("*.xml", SearchOption.TopDirectoryOnly)
2014-02-03 05:35:43 +00:00
.ToList();
var seriesXmlFilename = preferredMetadataLanguage + ".xml";
var download = false;
2015-01-18 05:45:10 +00:00
var automaticUpdatesEnabled = GetTvDbOptions().EnableAutomaticUpdates;
const int cacheDays = 2;
var seriesFile = files.FirstOrDefault(i => string.Equals(seriesXmlFilename, i.Name, StringComparison.OrdinalIgnoreCase));
2014-02-09 07:27:44 +00:00
// No need to check age if automatic updates are enabled
if (seriesFile == null || !seriesFile.Exists || (!automaticUpdatesEnabled && (DateTime.UtcNow - _fileSystem.GetLastWriteTimeUtc(seriesFile)).TotalDays > cacheDays))
{
2014-02-09 07:27:44 +00:00
download = true;
}
var actorsXml = files.FirstOrDefault(i => string.Equals("actors.xml", i.Name, StringComparison.OrdinalIgnoreCase));
2014-02-09 07:27:44 +00:00
// No need to check age if automatic updates are enabled
if (actorsXml == null || !actorsXml.Exists || (!automaticUpdatesEnabled && (DateTime.UtcNow - _fileSystem.GetLastWriteTimeUtc(actorsXml)).TotalDays > cacheDays))
{
2014-02-09 07:27:44 +00:00
download = true;
}
var bannersXml = files.FirstOrDefault(i => string.Equals("banners.xml", i.Name, StringComparison.OrdinalIgnoreCase));
2014-02-09 07:27:44 +00:00
// No need to check age if automatic updates are enabled
if (bannersXml == null || !bannersXml.Exists || (!automaticUpdatesEnabled && (DateTime.UtcNow - _fileSystem.GetLastWriteTimeUtc(bannersXml)).TotalDays > cacheDays))
{
2014-02-09 07:27:44 +00:00
download = true;
}
2014-02-03 05:35:43 +00:00
// Only download if not already there
// The post-scan task will take care of updates so we don't need to re-download here
if (download)
2014-02-03 05:35:43 +00:00
{
return DownloadSeriesZip(seriesId, seriesDataPath, null, preferredMetadataLanguage, cancellationToken);
2014-02-03 05:35:43 +00:00
}
return _cachedTask;
2014-02-03 05:35:43 +00:00
}
2014-02-03 20:51:28 +00:00
/// <summary>
/// Finds the series.
/// </summary>
/// <param name="name">The name.</param>
2015-02-20 18:27:01 +00:00
/// <param name="language">The language.</param>
2014-02-03 20:51:28 +00:00
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{System.String}.</returns>
2015-02-20 18:27:01 +00:00
private async Task<IEnumerable<RemoteSearchResult>> FindSeries(string name, string language, CancellationToken cancellationToken)
2014-08-19 01:42:53 +00:00
{
2015-02-20 18:27:01 +00:00
var results = (await FindSeriesInternal(name, language, cancellationToken).ConfigureAwait(false)).ToList();
2014-08-19 01:42:53 +00:00
if (results.Count == 0)
{
2014-11-16 22:46:01 +00:00
var parsedName = _libraryManager.ParseName(name);
var nameWithoutYear = parsedName.Name;
2014-08-19 01:42:53 +00:00
2015-02-20 18:27:01 +00:00
if (!string.IsNullOrWhiteSpace(nameWithoutYear) && !string.Equals(nameWithoutYear, name, StringComparison.OrdinalIgnoreCase))
2014-08-19 01:42:53 +00:00
{
2015-02-20 18:27:01 +00:00
results = (await FindSeriesInternal(nameWithoutYear, language, cancellationToken).ConfigureAwait(false)).ToList();
2014-08-19 01:42:53 +00:00
}
}
return results;
}
2015-02-20 18:27:01 +00:00
private async Task<IEnumerable<RemoteSearchResult>> FindSeriesInternal(string name, string language, CancellationToken cancellationToken)
2013-10-24 17:49:24 +00:00
{
2015-02-20 18:27:01 +00:00
var url = string.Format(SeriesSearchUrl, WebUtility.UrlEncode(name), language.ToLower());
2014-02-03 20:51:28 +00:00
var doc = new XmlDocument();
using (var results = await _httpClient.Get(new HttpRequestOptions
2013-10-24 17:49:24 +00:00
{
2014-02-03 20:51:28 +00:00
Url = url,
ResourcePool = TvDbResourcePool,
CancellationToken = cancellationToken
}).ConfigureAwait(false))
2013-10-24 17:49:24 +00:00
{
2014-02-03 20:51:28 +00:00
doc.Load(results);
2013-10-24 17:49:24 +00:00
}
2013-10-10 16:55:07 +00:00
2014-08-19 01:42:53 +00:00
var searchResults = new List<RemoteSearchResult>();
2014-02-03 20:51:28 +00:00
if (doc.HasChildNodes)
2013-10-10 16:55:07 +00:00
{
2014-02-03 20:51:28 +00:00
var nodes = doc.SelectNodes("//Series");
var comparableName = GetComparableName(name);
if (nodes != null)
2013-10-10 16:55:07 +00:00
{
2014-02-03 20:51:28 +00:00
foreach (XmlNode node in nodes)
{
2015-01-27 06:50:40 +00:00
var searchResult = new RemoteSearchResult
{
SearchProviderName = Name
};
2014-02-03 20:51:28 +00:00
var titles = new List<string>();
2013-10-10 16:55:07 +00:00
2014-02-03 20:51:28 +00:00
var nameNode = node.SelectSingleNode("./SeriesName");
if (nameNode != null)
{
titles.Add(GetComparableName(nameNode.InnerText));
}
var aliasNode = node.SelectSingleNode("./AliasNames");
if (aliasNode != null)
{
var alias = aliasNode.InnerText.Split('|').Select(GetComparableName);
titles.AddRange(alias);
}
2015-01-27 06:50:40 +00:00
var imdbIdNode = node.SelectSingleNode("./IMDB_ID");
if (imdbIdNode != null)
{
var val = imdbIdNode.InnerText;
if (!string.IsNullOrWhiteSpace(val))
{
searchResult.SetProviderId(MetadataProviders.Imdb, val);
}
}
var bannerNode = node.SelectSingleNode("./banner");
if (bannerNode != null)
{
var val = bannerNode.InnerText;
if (!string.IsNullOrWhiteSpace(val))
{
searchResult.ImageUrl = TVUtils.BannerUrl + val;
}
}
2014-02-03 20:51:28 +00:00
if (titles.Any(t => string.Equals(t, comparableName, StringComparison.OrdinalIgnoreCase)))
{
2015-01-27 06:50:40 +00:00
var id = node.SelectSingleNode("./seriesid") ??
node.SelectSingleNode("./id");
2014-02-03 20:51:28 +00:00
if (id != null)
2014-08-19 01:42:53 +00:00
{
2015-01-27 06:50:40 +00:00
searchResult.Name = titles.FirstOrDefault();
2014-08-19 01:42:53 +00:00
searchResult.SetProviderId(MetadataProviders.Tvdb, id.InnerText);
searchResults.Add(searchResult);
}
2014-02-03 20:51:28 +00:00
}
foreach (var title in titles)
{
_logger.Info("TVDb Provider - " + title + " did not match " + comparableName);
}
}
2013-10-10 16:55:07 +00:00
}
}
2014-02-03 20:51:28 +00:00
_logger.Info("TVDb Provider - Could not find " + name + ". Check name on Thetvdb.org.");
2014-08-19 01:42:53 +00:00
return searchResults;
2013-10-10 16:55:07 +00:00
}
/// <summary>
2014-02-03 20:51:28 +00:00
/// The remove
2013-10-10 16:55:07 +00:00
/// </summary>
2014-02-03 20:51:28 +00:00
const string remove = "\"'!`?";
/// <summary>
/// The spacers
/// </summary>
const string spacers = "/,.:;\\(){}[]+-_=*"; // (there are not actually two - in the they are different char codes)
/// <summary>
/// Gets the name of the comparable.
/// </summary>
/// <param name="name">The name.</param>
2013-10-10 16:55:07 +00:00
/// <returns>System.String.</returns>
2014-02-03 20:51:28 +00:00
internal static string GetComparableName(string name)
2013-10-10 16:55:07 +00:00
{
2014-02-03 20:51:28 +00:00
name = name.ToLower();
name = name.Normalize(NormalizationForm.FormKD);
var sb = new StringBuilder();
foreach (var c in name)
2013-10-10 16:55:07 +00:00
{
2014-02-03 20:51:28 +00:00
if ((int)c >= 0x2B0 && (int)c <= 0x0333)
2013-10-10 16:55:07 +00:00
{
2014-02-03 20:51:28 +00:00
// skip char modifier and diacritics
}
else if (remove.IndexOf(c) > -1)
{
// skip chars we are removing
}
else if (spacers.IndexOf(c) > -1)
{
sb.Append(" ");
}
else if (c == '&')
{
sb.Append(" and ");
}
else
{
sb.Append(c);
2013-10-10 16:55:07 +00:00
}
}
2014-02-03 20:51:28 +00:00
name = sb.ToString();
name = name.Replace(", the", "");
name = name.Replace("the ", " ");
name = name.Replace(" the ", " ");
2014-02-03 20:51:28 +00:00
string prevName;
do
{
2014-02-03 20:51:28 +00:00
prevName = name;
name = name.Replace(" ", " ");
} while (name.Length != prevName.Length);
2014-02-03 20:51:28 +00:00
return name.Trim();
}
2014-02-03 20:51:28 +00:00
private void FetchSeriesInfo(Series item, string seriesXmlPath, CancellationToken cancellationToken)
{
var settings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
2014-02-03 20:51:28 +00:00
var episiodeAirDates = new List<DateTime>();
2014-02-03 20:51:28 +00:00
using (var streamReader = new StreamReader(seriesXmlPath, Encoding.UTF8))
{
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))
{
reader.MoveToContent();
// Loop through each element
while (reader.Read())
{
2014-02-03 20:51:28 +00:00
cancellationToken.ThrowIfCancellationRequested();
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
2014-02-03 20:51:28 +00:00
case "Series":
{
2014-02-03 20:51:28 +00:00
using (var subtree = reader.ReadSubtree())
{
2014-02-03 20:51:28 +00:00
FetchDataFromSeriesNode(item, subtree, cancellationToken);
}
break;
}
2014-02-03 20:51:28 +00:00
case "Episode":
{
2014-02-03 20:51:28 +00:00
using (var subtree = reader.ReadSubtree())
{
2014-02-03 20:51:28 +00:00
var date = GetFirstAiredDateFromEpisodeNode(subtree, cancellationToken);
2014-02-03 20:51:28 +00:00
if (date.HasValue)
{
2014-02-03 20:51:28 +00:00
episiodeAirDates.Add(date.Value);
}
}
break;
}
default:
reader.Skip();
break;
}
}
}
}
}
2014-02-03 20:51:28 +00:00
if (item.Status.HasValue && item.Status.Value == SeriesStatus.Ended && episiodeAirDates.Count > 0)
{
2014-02-03 20:51:28 +00:00
item.EndDate = episiodeAirDates.Max();
}
2014-02-03 20:51:28 +00:00
}
2014-02-03 20:51:28 +00:00
private DateTime? GetFirstAiredDateFromEpisodeNode(XmlReader reader, CancellationToken cancellationToken)
{
DateTime? airDate = null;
int? seasonNumber = null;
2014-02-03 20:51:28 +00:00
reader.MoveToContent();
2014-02-03 20:51:28 +00:00
// Loop through each element
while (reader.Read())
{
2014-02-03 20:51:28 +00:00
cancellationToken.ThrowIfCancellationRequested();
2014-02-03 20:51:28 +00:00
if (reader.NodeType == XmlNodeType.Element)
{
2014-02-03 20:51:28 +00:00
switch (reader.Name)
{
2014-02-03 20:51:28 +00:00
case "FirstAired":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
DateTime date;
if (DateTime.TryParse(val, out date))
{
airDate = date.ToUniversalTime();
}
}
break;
}
case "SeasonNumber":
{
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))
{
seasonNumber = rval;
}
}
break;
}
default:
reader.Skip();
break;
}
}
}
2014-02-03 20:51:28 +00:00
if (seasonNumber.HasValue && seasonNumber.Value != 0)
{
return airDate;
}
2014-02-03 20:51:28 +00:00
return null;
}
2013-02-21 01:33:05 +00:00
/// <summary>
2014-02-03 20:51:28 +00:00
/// Fetches the actors.
/// </summary>
2014-02-03 20:51:28 +00:00
/// <param name="series">The series.</param>
/// <param name="actorsXmlPath">The actors XML path.</param>
private void FetchActors(Series series, string actorsXmlPath)
2013-02-21 01:33:05 +00:00
{
var settings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
2014-02-03 20:51:28 +00:00
using (var streamReader = new StreamReader(actorsXmlPath, 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)
{
switch (reader.Name)
{
2014-02-03 20:51:28 +00:00
case "Actor":
{
using (var subtree = reader.ReadSubtree())
{
2014-02-03 20:51:28 +00:00
FetchDataFromActorNode(series, subtree);
}
break;
}
default:
reader.Skip();
break;
}
}
}
}
}
}
2013-02-21 01:33:05 +00:00
2014-02-03 20:51:28 +00:00
/// <summary>
/// Fetches the data from actor node.
/// </summary>
/// <param name="series">The series.</param>
/// <param name="reader">The reader.</param>
private void FetchDataFromActorNode(Series series, XmlReader reader)
{
reader.MoveToContent();
2014-02-03 20:51:28 +00:00
var personInfo = new PersonInfo();
while (reader.Read())
2013-02-21 01:33:05 +00:00
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
2014-02-03 20:51:28 +00:00
case "Name":
{
2014-02-03 20:51:28 +00:00
personInfo.Name = (reader.ReadElementContentAsString() ?? string.Empty).Trim();
break;
}
2014-02-03 20:51:28 +00:00
case "Role":
{
personInfo.Role = (reader.ReadElementContentAsString() ?? string.Empty).Trim();
break;
}
case "SortOrder":
{
2014-02-03 20:51:28 +00:00
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
2014-02-03 20:51:28 +00:00
int rval;
// int.TryParse is local aware, so it can be probamatic, force us culture
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
{
personInfo.SortOrder = rval;
}
}
break;
}
2014-02-03 20:51:28 +00:00
default:
reader.Skip();
break;
}
}
}
personInfo.Type = PersonType.Actor;
2015-02-20 18:27:01 +00:00
if (!string.IsNullOrWhiteSpace(personInfo.Name))
2014-02-03 20:51:28 +00:00
{
series.AddPerson(personInfo);
}
}
private void FetchDataFromSeriesNode(Series item, XmlReader reader, CancellationToken cancellationToken)
{
reader.MoveToContent();
// Loop through each element
while (reader.Read())
{
cancellationToken.ThrowIfCancellationRequested();
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "SeriesName":
{
item.Name = (reader.ReadElementContentAsString() ?? string.Empty).Trim();
break;
}
case "Overview":
{
item.Overview = (reader.ReadElementContentAsString() ?? string.Empty).Trim();
break;
}
case "Airs_DayOfWeek":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.AirDays = TVUtils.GetAirDays(val);
}
break;
}
case "Airs_Time":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.AirTime = val;
}
break;
}
case "ContentRating":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
2014-02-03 20:51:28 +00:00
item.OfficialRating = val;
}
break;
}
case "Rating":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
// Only fill this if it doesn't already have a value, since we get it from imdb which has better data
if (!item.CommunityRating.HasValue || string.IsNullOrWhiteSpace(item.GetProviderId(MetadataProviders.Imdb)))
{
float rval;
// float.TryParse is local aware, so it can be probamatic, force us culture
2014-02-03 20:51:28 +00:00
if (float.TryParse(val, NumberStyles.AllowDecimalPoint, _usCulture, out rval))
{
item.CommunityRating = rval;
}
}
}
break;
}
case "RatingCount":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int rval;
// int.TryParse is local aware, so it can be probamatic, force us culture
2014-02-03 20:51:28 +00:00
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
{
item.VoteCount = rval;
}
}
break;
}
case "IMDB_ID":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.SetProviderId(MetadataProviders.Imdb, val);
}
break;
}
case "zap2it_id":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
item.SetProviderId(MetadataProviders.Zap2It, val);
}
break;
}
case "Status":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
SeriesStatus seriesStatus;
if (Enum.TryParse(val, true, out seriesStatus))
item.Status = seriesStatus;
}
break;
}
case "FirstAired":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
DateTime date;
if (DateTime.TryParse(val, out date))
{
date = date.ToUniversalTime();
item.PremiereDate = date;
item.ProductionYear = date.Year;
}
}
break;
}
case "Runtime":
{
var val = reader.ReadElementContentAsString();
2014-02-03 20:51:28 +00:00
if (!string.IsNullOrWhiteSpace(val))
{
int rval;
// int.TryParse is local aware, so it can be probamatic, force us culture
2014-02-03 20:51:28 +00:00
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
{
item.RunTimeTicks = TimeSpan.FromMinutes(rval).Ticks;
}
}
break;
}
case "Genre":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
2014-02-03 20:51:28 +00:00
var vals = val
.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries)
.Select(i => i.Trim())
.Where(i => !string.IsNullOrWhiteSpace(i))
.ToList();
if (vals.Count > 0)
{
2014-02-03 20:51:28 +00:00
item.Genres.Clear();
2014-02-03 20:51:28 +00:00
foreach (var genre in vals)
{
2014-02-03 20:51:28 +00:00
item.AddGenre(genre);
}
}
}
break;
}
case "Network":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
2014-02-03 20:51:28 +00:00
var vals = val
.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries)
.Select(i => i.Trim())
.Where(i => !string.IsNullOrWhiteSpace(i))
.ToList();
if (vals.Count > 0)
{
2014-02-03 20:51:28 +00:00
item.Studios.Clear();
2014-02-03 20:51:28 +00:00
foreach (var genre in vals)
{
2014-02-03 20:51:28 +00:00
item.AddStudio(genre);
}
}
}
break;
}
default:
reader.Skip();
break;
}
}
2013-02-21 01:33:05 +00:00
}
}
2013-09-15 17:34:48 +00:00
2014-02-03 20:51:28 +00:00
/// <summary>
/// Extracts info for each episode into invididual xml files so that they can be easily accessed without having to step through the entire series xml
/// </summary>
/// <param name="seriesDataPath">The series data path.</param>
/// <param name="xmlFile">The XML file.</param>
/// <param name="lastTvDbUpdateTime">The last tv db update time.</param>
/// <returns>Task.</returns>
private async Task ExtractEpisodes(string seriesDataPath, string xmlFile, long? lastTvDbUpdateTime)
{
2014-02-03 20:51:28 +00:00
var settings = new XmlReaderSettings
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
2014-02-03 20:51:28 +00:00
using (var streamReader = new StreamReader(xmlFile, Encoding.UTF8))
{
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))
{
2014-02-03 20:51:28 +00:00
reader.MoveToContent();
// Loop through each element
while (reader.Read())
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
2014-02-03 20:51:28 +00:00
case "Episode":
{
2014-02-03 20:51:28 +00:00
var outerXml = reader.ReadOuterXml();
2014-02-03 20:51:28 +00:00
await SaveEpsiodeXml(seriesDataPath, outerXml, lastTvDbUpdateTime).ConfigureAwait(false);
break;
}
2014-02-03 20:51:28 +00:00
default:
reader.Skip();
break;
}
2014-02-03 20:51:28 +00:00
}
2013-02-21 01:33:05 +00:00
}
}
}
}
2013-02-21 01:33:05 +00:00
2014-02-03 20:51:28 +00:00
private async Task SaveEpsiodeXml(string seriesDataPath, string xml, long? lastTvDbUpdateTime)
{
2013-09-15 17:34:48 +00:00
var settings = new XmlReaderSettings
{
2013-09-15 17:34:48 +00:00
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
2014-02-03 20:51:28 +00:00
var seasonNumber = -1;
var episodeNumber = -1;
var absoluteNumber = -1;
var lastUpdateString = string.Empty;
using (var streamReader = new StringReader(xml))
2013-09-15 17:34:48 +00:00
{
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))
{
2013-09-15 17:34:48 +00:00
reader.MoveToContent();
2013-07-31 12:09:23 +00:00
2013-09-15 17:34:48 +00:00
// Loop through each element
while (reader.Read())
2013-02-21 01:33:05 +00:00
{
2013-09-15 17:34:48 +00:00
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
2014-02-03 20:51:28 +00:00
case "lastupdated":
2013-09-15 17:34:48 +00:00
{
2014-02-03 20:51:28 +00:00
lastUpdateString = reader.ReadElementContentAsString();
break;
}
case "EpisodeNumber":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
2013-09-15 17:34:48 +00:00
{
2014-02-03 20:51:28 +00:00
int num;
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out num))
{
episodeNumber = num;
}
}
break;
}
case "absolute_number":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int num;
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out num))
{
absoluteNumber = num;
}
}
break;
}
case "SeasonNumber":
{
var val = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(val))
{
int num;
if (int.TryParse(val, NumberStyles.Integer, _usCulture, out num))
{
seasonNumber = num;
}
2013-09-15 17:34:48 +00:00
}
break;
}
2014-02-03 20:51:28 +00:00
2013-09-15 17:34:48 +00:00
default:
reader.Skip();
break;
}
}
2013-02-21 01:33:05 +00:00
}
}
2013-02-21 01:33:05 +00:00
}
2013-09-15 17:34:48 +00:00
2014-02-03 20:51:28 +00:00
var hasEpisodeChanged = true;
2015-02-20 18:27:01 +00:00
if (!string.IsNullOrWhiteSpace(lastUpdateString) && lastTvDbUpdateTime.HasValue)
2013-09-15 17:34:48 +00:00
{
2014-02-03 20:51:28 +00:00
long num;
if (long.TryParse(lastUpdateString, NumberStyles.Any, _usCulture, out num))
2013-09-15 17:34:48 +00:00
{
2014-02-03 20:51:28 +00:00
hasEpisodeChanged = num >= lastTvDbUpdateTime.Value;
}
}
2014-02-03 20:51:28 +00:00
var file = Path.Combine(seriesDataPath, string.Format("episode-{0}-{1}.xml", seasonNumber, episodeNumber));
2014-02-03 20:51:28 +00:00
// Only save the file if not already there, or if the episode has changed
if (hasEpisodeChanged || !File.Exists(file))
{
using (var writer = XmlWriter.Create(file, new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Async = true
}))
{
await writer.WriteRawAsync(xml).ConfigureAwait(false);
2013-09-15 17:34:48 +00:00
}
}
2014-02-03 20:51:28 +00:00
if (absoluteNumber != -1)
2013-09-15 17:34:48 +00:00
{
2014-02-03 20:51:28 +00:00
file = Path.Combine(seriesDataPath, string.Format("episode-abs-{0}.xml", absoluteNumber));
// Only save the file if not already there, or if the episode has changed
if (hasEpisodeChanged || !File.Exists(file))
{
using (var writer = XmlWriter.Create(file, new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Async = true
}))
{
await writer.WriteRawAsync(xml).ConfigureAwait(false);
}
}
2013-09-15 17:34:48 +00:00
}
}
/// <summary>
2014-02-03 20:51:28 +00:00
/// Gets the series data path.
2013-02-21 01:33:05 +00:00
/// </summary>
2014-02-03 20:51:28 +00:00
/// <param name="appPaths">The app paths.</param>
/// <param name="seriesId">The series id.</param>
/// <returns>System.String.</returns>
internal static string GetSeriesDataPath(IApplicationPaths appPaths, string seriesId)
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
var seriesDataPath = Path.Combine(GetSeriesDataPath(appPaths), seriesId);
return seriesDataPath;
2013-02-21 01:33:05 +00:00
}
/// <summary>
2014-02-03 20:51:28 +00:00
/// Gets the series data path.
2013-02-21 01:33:05 +00:00
/// </summary>
2014-02-03 20:51:28 +00:00
/// <param name="appPaths">The app paths.</param>
/// <returns>System.String.</returns>
internal static string GetSeriesDataPath(IApplicationPaths appPaths)
2013-02-21 01:33:05 +00:00
{
2014-03-05 02:59:59 +00:00
var dataPath = Path.Combine(appPaths.CachePath, "tvdb");
2013-02-21 01:33:05 +00:00
2014-02-03 20:51:28 +00:00
return dataPath;
}
2014-02-03 20:51:28 +00:00
private void DeleteXmlFiles(string path)
{
try
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
foreach (var file in new DirectoryInfo(path)
.EnumerateFiles("*.xml", SearchOption.AllDirectories)
.ToList())
{
_fileSystem.DeleteFile(file.FullName);
2014-02-03 20:51:28 +00:00
}
2013-02-21 01:33:05 +00:00
}
2014-02-03 20:51:28 +00:00
catch (DirectoryNotFoundException)
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
// No biggie
}
}
2014-02-03 20:51:28 +00:00
/// <summary>
/// Sanitizes the XML file.
/// </summary>
/// <param name="file">The file.</param>
/// <returns>Task.</returns>
private async Task SanitizeXmlFile(string file)
{
string validXml;
2014-02-03 20:51:28 +00:00
using (var fileStream = _fileSystem.GetFileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read, true))
{
using (var reader = new StreamReader(fileStream))
{
var xml = await reader.ReadToEndAsync().ConfigureAwait(false);
2014-02-03 20:51:28 +00:00
validXml = StripInvalidXmlCharacters(xml);
}
2013-02-21 01:33:05 +00:00
}
2014-02-03 20:51:28 +00:00
using (var fileStream = _fileSystem.GetFileStream(file, FileMode.Create, FileAccess.Write, FileShare.Read, true))
{
2014-02-03 20:51:28 +00:00
using (var writer = new StreamWriter(fileStream))
{
await writer.WriteAsync(validXml).ConfigureAwait(false);
}
}
2013-02-21 01:33:05 +00:00
}
/// <summary>
2014-02-03 20:51:28 +00:00
/// Strips the invalid XML characters.
2013-02-21 01:33:05 +00:00
/// </summary>
2014-02-03 20:51:28 +00:00
/// <param name="inString">The in string.</param>
2013-02-21 01:33:05 +00:00
/// <returns>System.String.</returns>
2014-02-03 20:51:28 +00:00
public static string StripInvalidXmlCharacters(string inString)
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
if (inString == null) return null;
var sbOutput = new StringBuilder();
char ch;
for (int i = 0; i < inString.Length; i++)
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
ch = inString[i];
if ((ch >= 0x0020 && ch <= 0xD7FF) ||
(ch >= 0xE000 && ch <= 0xFFFD) ||
ch == 0x0009 ||
ch == 0x000A ||
ch == 0x000D)
2013-02-21 01:33:05 +00:00
{
2014-02-03 20:51:28 +00:00
sbOutput.Append(ch);
2013-02-21 01:33:05 +00:00
}
2014-02-03 20:51:28 +00:00
}
return sbOutput.ToString();
}
public string Name
{
get { return "TheTVDB"; }
}
2014-02-15 16:36:09 +00:00
public async Task<SeriesIdentity> FindIdentity(SeriesInfo info)
{
string tvdbId;
if (!info.ProviderIds.TryGetValue(MetadataProviders.Tvdb.ToString(), out tvdbId))
2014-08-19 01:42:53 +00:00
{
var srch = await GetSearchResults(info, CancellationToken.None).ConfigureAwait(false);
var entry = srch.FirstOrDefault();
if (entry != null)
{
tvdbId = entry.GetProviderId(MetadataProviders.Tvdb);
}
}
2015-02-20 18:27:01 +00:00
if (!string.IsNullOrWhiteSpace(tvdbId))
{
2014-08-19 01:42:53 +00:00
return new SeriesIdentity { Type = MetadataProviders.Tvdb.ToString(), Id = tvdbId };
}
return null;
}
2014-02-15 16:36:09 +00:00
public int Order
{
get
{
// After Omdb
return 1;
}
}
public Task<HttpResponseInfo> GetImageResponse(string url, CancellationToken cancellationToken)
{
2014-03-02 15:42:21 +00:00
return _httpClient.GetResponse(new HttpRequestOptions
{
CancellationToken = cancellationToken,
Url = url,
ResourcePool = TvDbResourcePool
});
}
2013-02-21 01:33:05 +00:00
}
2015-01-18 05:45:10 +00:00
public class TvdbConfigStore : IConfigurationFactory
{
public IEnumerable<ConfigurationStore> GetConfigurations()
{
return new List<ConfigurationStore>
{
new ConfigurationStore
{
Key = "tvdb",
ConfigurationType = typeof(TvdbOptions)
}
};
}
}
2013-02-21 01:33:05 +00:00
}