Sonarr/NzbDrone.Core/Providers/Indexer/IndexerProviderBase.cs

232 lines
8.2 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.ServiceModel.Syndication;
2011-04-04 03:50:12 +00:00
using NLog;
using NzbDrone.Core.Model;
using NzbDrone.Core.Providers.Core;
using NzbDrone.Core.Repository;
2011-04-04 03:50:12 +00:00
namespace NzbDrone.Core.Providers.Indexer
2011-04-04 03:50:12 +00:00
{
public abstract class IndexerProviderBase
2011-04-04 03:50:12 +00:00
{
2011-04-22 06:23:29 +00:00
protected readonly Logger _logger;
protected readonly ConfigProvider _configProvider;
2011-04-10 02:44:01 +00:00
protected readonly EpisodeProvider _episodeProvider;
2011-04-07 02:25:52 +00:00
private readonly HttpProvider _httpProvider;
private readonly IndexerProvider _indexerProvider;
private readonly HistoryProvider _historyProvider;
2011-04-10 02:44:01 +00:00
protected readonly SeasonProvider _seasonProvider;
protected readonly SeriesProvider _seriesProvider;
protected readonly SabProvider _sabProvider;
protected IndexerProviderBase(SeriesProvider seriesProvider, SeasonProvider seasonProvider,
2011-04-10 02:44:01 +00:00
EpisodeProvider episodeProvider, ConfigProvider configProvider,
HttpProvider httpProvider, IndexerProvider indexerProvider,
HistoryProvider historyProvider, SabProvider sabProvider)
2011-04-04 06:53:22 +00:00
{
_seriesProvider = seriesProvider;
_seasonProvider = seasonProvider;
_episodeProvider = episodeProvider;
_configProvider = configProvider;
2011-04-05 05:30:13 +00:00
_httpProvider = httpProvider;
_indexerProvider = indexerProvider;
_historyProvider = historyProvider;
_sabProvider = sabProvider;
2011-04-22 06:23:29 +00:00
_logger = LogManager.GetLogger(GetType().ToString());
2011-04-04 06:53:22 +00:00
}
2011-04-04 03:50:12 +00:00
/// <summary>
/// Gets the name for the feed
2011-04-04 03:50:12 +00:00
/// </summary>
public abstract string Name { get; }
2011-04-04 03:50:12 +00:00
2011-04-04 06:53:22 +00:00
/// <summary>
/// Gets the source URL for the feed
2011-04-04 06:53:22 +00:00
/// </summary>
protected abstract string[] Urls { get; }
2011-04-04 06:53:22 +00:00
/// <summary>
/// Gets the credential.
/// </summary>
protected virtual NetworkCredential Credentials
{
get { return null; }
}
public IndexerSetting Settings
2011-04-04 06:53:22 +00:00
{
get
2011-04-04 06:53:22 +00:00
{
return _indexerProvider.GetSettings(GetType());
2011-04-04 06:53:22 +00:00
}
}
/// <summary>
2011-04-10 02:44:01 +00:00
/// Fetches RSS feed and process each news item.
2011-04-04 06:53:22 +00:00
/// </summary>
public List<Exception> Fetch()
2011-04-04 03:50:12 +00:00
{
2011-04-25 04:15:23 +00:00
_logger.Debug("Fetching feeds from " + Settings.Name);
var exeptions = new List<Exception>();
2011-04-04 03:50:12 +00:00
foreach (var url in Urls)
2011-04-04 03:50:12 +00:00
{
2011-04-22 06:23:29 +00:00
try
{
2011-04-25 04:15:23 +00:00
_logger.Trace("Downloading RSS " + url);
2011-04-25 18:16:38 +00:00
var reader = new SyndicationFeedXmlReader(_httpProvider.DownloadStream(url, Credentials));
2011-04-25 18:16:38 +00:00
var feed = SyndicationFeed.Load(reader).Items;
2011-04-04 03:50:12 +00:00
2011-04-22 06:23:29 +00:00
foreach (var item in feed)
{
2011-04-22 20:14:02 +00:00
try
{
ProcessItem(item);
}
catch (Exception itemEx)
{
exeptions.Add(itemEx);
2011-04-22 20:14:02 +00:00
_logger.ErrorException("An error occurred while processing feed item", itemEx);
}
2011-04-22 06:23:29 +00:00
}
}
2011-04-22 20:14:02 +00:00
catch (Exception feedEx)
2011-04-04 03:50:12 +00:00
{
exeptions.Add(feedEx);
2011-04-22 20:14:02 +00:00
_logger.ErrorException("An error occurred while processing feed", feedEx);
2011-04-04 03:50:12 +00:00
}
}
2011-04-22 06:23:29 +00:00
_logger.Info("Finished processing feeds from " + Settings.Name);
return exeptions;
2011-04-04 03:50:12 +00:00
}
2011-04-22 19:16:52 +00:00
internal void ProcessItem(SyndicationItem feedItem)
2011-04-04 03:50:12 +00:00
{
2011-04-22 20:14:02 +00:00
_logger.Debug("Processing RSS feed item " + feedItem.Title.Text);
2011-04-04 06:53:22 +00:00
var parseResult = ParseFeed(feedItem);
2011-04-04 03:50:12 +00:00
2011-04-22 19:16:52 +00:00
if (parseResult != null && parseResult.SeriesId != 0)
2011-04-04 03:50:12 +00:00
{
if (!_seriesProvider.IsMonitored(parseResult.SeriesId))
{
2011-04-22 19:16:52 +00:00
_logger.Debug("{0} is present in the DB but not tracked. skipping.", parseResult.CleanTitle);
2011-04-19 06:37:34 +00:00
return;
}
2011-04-04 03:50:12 +00:00
if (!_seriesProvider.QualityWanted(parseResult.SeriesId, parseResult.Quality))
{
2011-04-22 06:23:29 +00:00
_logger.Debug("Post doesn't meet the quality requirements [{0}]. skipping.", parseResult.Quality);
2011-04-19 06:37:34 +00:00
return;
}
2011-04-04 03:50:12 +00:00
if (_seasonProvider.IsIgnored(parseResult.SeriesId, parseResult.SeasonNumber))
{
2011-04-22 06:23:29 +00:00
_logger.Debug("Season {0} is currently set to ignore. skipping.", parseResult.SeasonNumber);
2011-04-19 06:37:34 +00:00
return;
}
2011-04-04 03:50:12 +00:00
if (!_episodeProvider.IsNeeded(parseResult))
{
2011-04-22 06:23:29 +00:00
_logger.Debug("Episode {0} is not needed. skipping.", parseResult);
2011-04-19 06:37:34 +00:00
return;
}
2011-04-19 06:37:34 +00:00
var episodes = _episodeProvider.GetEpisodeByParseResult(parseResult);
if (InHistory(episodes, parseResult, feedItem))
{
return;
}
2011-04-25 04:15:23 +00:00
2011-04-25 18:16:38 +00:00
//var sabTitle = _sabProvider.GetSabTitle(parseResult);
2011-04-25 18:16:38 +00:00
//if (_sabProvider.IsInQueue(sabTitle))
//{
// return;
//}
2011-04-25 18:16:38 +00:00
//if (!_sabProvider.AddByUrl(NzbDownloadUrl(feedItem), sabTitle))
//{
// return;
//}
foreach (var episode in episodes)
{
_historyProvider.Add(new History
{
Date = DateTime.Now,
EpisodeId = episode.EpisodeId,
IsProper = parseResult.Proper,
NzbTitle = feedItem.Title.Text,
Quality = parseResult.Quality
});
}
2011-04-04 06:53:22 +00:00
}
2011-04-04 03:50:12 +00:00
}
/// <summary>
/// Parses the RSS feed item and.
/// </summary>
/// <param name = "item">RSS feed item to parse</param>
/// <returns>Detailed episode info</returns>
public EpisodeParseResult ParseFeed(SyndicationItem item)
{
var episodeParseResult = Parser.ParseEpisodeInfo(item.Title.Text);
if (episodeParseResult == null) return null;
2011-04-22 19:16:52 +00:00
var seriesInfo = _seriesProvider.FindSeries(episodeParseResult.CleanTitle);
if (seriesInfo != null)
{
episodeParseResult.SeriesId = seriesInfo.SeriesId;
episodeParseResult.FolderName = new DirectoryInfo(seriesInfo.Path).Name; ;
2011-04-22 19:16:52 +00:00
episodeParseResult.CleanTitle = seriesInfo.Title;
return CustomParser(item, episodeParseResult);
}
2011-04-22 19:16:52 +00:00
_logger.Debug("Unable to map {0} to any of series in database", episodeParseResult.CleanTitle);
return null;
}
/// <summary>
/// This method can be overwritten to provide indexer specific info parsing
/// </summary>
/// <param name="item">RSS item that needs to be parsed</param>
/// <param name="currentResult">Result of the built in parse function.</param>
/// <returns></returns>
protected virtual EpisodeParseResult CustomParser(SyndicationItem item, EpisodeParseResult currentResult)
{
return currentResult;
}
/// <summary>
/// Generates direct link to download an NZB
/// </summary>
/// <param name = "item">RSS Feed item to generate the link for</param>
/// <returns>Download link URL</returns>
protected abstract string NzbDownloadUrl(SyndicationItem item);
private bool InHistory(IList<Episode> episodes, EpisodeParseResult parseResult, SyndicationItem feedItem)
{
foreach (var episode in episodes)
{
if (_historyProvider.Exists(episode.EpisodeId, parseResult.Quality, parseResult.Proper))
{
_logger.Debug("Episode in history: {0}", feedItem.Title.Text);
return true;
}
}
return false;
}
2011-04-04 03:50:12 +00:00
}
2011-04-10 02:44:01 +00:00
}