2017-01-03 23:33:16 +00:00
|
|
|
|
using System;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
using System.Collections.Generic;
|
2013-07-26 03:25:24 +00:00
|
|
|
|
using System.Globalization;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
using System.Threading.Tasks;
|
|
|
|
|
using NLog;
|
2014-07-23 23:43:54 +00:00
|
|
|
|
using NzbDrone.Common.Instrumentation.Extensions;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
using NzbDrone.Core.DataAugmentation.Scene;
|
|
|
|
|
using NzbDrone.Core.DecisionEngine;
|
|
|
|
|
using NzbDrone.Core.IndexerSearch.Definitions;
|
|
|
|
|
using NzbDrone.Core.Indexers;
|
2013-04-15 01:41:39 +00:00
|
|
|
|
using NzbDrone.Core.Parser.Model;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
using NzbDrone.Core.Tv;
|
|
|
|
|
using System.Linq;
|
2013-07-12 06:10:34 +00:00
|
|
|
|
using NzbDrone.Common.TPL;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
|
|
|
|
namespace NzbDrone.Core.IndexerSearch
|
|
|
|
|
{
|
|
|
|
|
public interface ISearchForNzb
|
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
List<DownloadDecision> EpisodeSearch(int episodeId, bool userInvokedSearch);
|
|
|
|
|
List<DownloadDecision> EpisodeSearch(Episode episode, bool userInvokedSearch);
|
2017-01-02 17:05:55 +00:00
|
|
|
|
List<DownloadDecision> MovieSearch(int movieId, bool userInvokedSearch);
|
|
|
|
|
List<DownloadDecision> MovieSearch(Movie movie, bool userInvokedSearch);
|
2016-05-13 04:02:57 +00:00
|
|
|
|
List<DownloadDecision> SeasonSearch(int seriesId, int seasonNumber, bool missingOnly, bool userInvokedSearch);
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class NzbSearchService : ISearchForNzb
|
|
|
|
|
{
|
2013-09-24 23:42:55 +00:00
|
|
|
|
private readonly IIndexerFactory _indexerFactory;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
private readonly ISceneMappingService _sceneMapping;
|
|
|
|
|
private readonly ISeriesService _seriesService;
|
|
|
|
|
private readonly IEpisodeService _episodeService;
|
|
|
|
|
private readonly IMakeDownloadDecision _makeDownloadDecision;
|
2017-01-02 17:05:55 +00:00
|
|
|
|
private readonly IMovieService _movieService;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
private readonly Logger _logger;
|
|
|
|
|
|
2013-09-24 23:42:55 +00:00
|
|
|
|
public NzbSearchService(IIndexerFactory indexerFactory,
|
2013-06-19 02:08:29 +00:00
|
|
|
|
ISceneMappingService sceneMapping,
|
|
|
|
|
ISeriesService seriesService,
|
|
|
|
|
IEpisodeService episodeService,
|
|
|
|
|
IMakeDownloadDecision makeDownloadDecision,
|
2017-01-02 17:05:55 +00:00
|
|
|
|
IMovieService movieService,
|
2013-06-19 02:08:29 +00:00
|
|
|
|
Logger logger)
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2013-09-24 23:42:55 +00:00
|
|
|
|
_indexerFactory = indexerFactory;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
_sceneMapping = sceneMapping;
|
|
|
|
|
_seriesService = seriesService;
|
|
|
|
|
_episodeService = episodeService;
|
|
|
|
|
_makeDownloadDecision = makeDownloadDecision;
|
2017-01-02 17:05:55 +00:00
|
|
|
|
_movieService = movieService;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
_logger = logger;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
public List<DownloadDecision> EpisodeSearch(int episodeId, bool userInvokedSearch)
|
2013-06-07 00:17:57 +00:00
|
|
|
|
{
|
|
|
|
|
var episode = _episodeService.GetEpisode(episodeId);
|
2014-03-20 23:41:28 +00:00
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
return EpisodeSearch(episode, userInvokedSearch);
|
2014-03-20 23:41:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-02 17:05:55 +00:00
|
|
|
|
public List<DownloadDecision> MovieSearch(int movieId, bool userInvokedSearch)
|
|
|
|
|
{
|
|
|
|
|
var movie = _movieService.GetMovie(movieId);
|
|
|
|
|
|
|
|
|
|
return MovieSearch(movie, userInvokedSearch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public List<DownloadDecision> MovieSearch(Movie movie, bool userInvokedSearch)
|
|
|
|
|
{
|
|
|
|
|
var searchSpec = Get<MovieSearchCriteria>(movie, userInvokedSearch);
|
|
|
|
|
|
|
|
|
|
return Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
public List<DownloadDecision> EpisodeSearch(Episode episode, bool userInvokedSearch)
|
2014-03-20 23:41:28 +00:00
|
|
|
|
{
|
2013-06-07 00:17:57 +00:00
|
|
|
|
var series = _seriesService.GetSeries(episode.SeriesId);
|
|
|
|
|
|
|
|
|
|
if (series.SeriesType == SeriesTypes.Daily)
|
|
|
|
|
{
|
2013-07-30 20:30:34 +00:00
|
|
|
|
if (string.IsNullOrWhiteSpace(episode.AirDate))
|
|
|
|
|
{
|
|
|
|
|
throw new InvalidOperationException("Daily episode is missing AirDate. Try to refresh series info.");
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
return SearchDaily(series, episode, userInvokedSearch);
|
2013-06-07 00:17:57 +00:00
|
|
|
|
}
|
2014-04-21 22:50:43 +00:00
|
|
|
|
if (series.SeriesType == SeriesTypes.Anime)
|
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
return SearchAnime(series, episode, userInvokedSearch);
|
2014-04-21 22:50:43 +00:00
|
|
|
|
}
|
2013-06-07 00:17:57 +00:00
|
|
|
|
|
2014-01-07 08:21:05 +00:00
|
|
|
|
if (episode.SeasonNumber == 0)
|
|
|
|
|
{
|
|
|
|
|
// search for special episodes in season 0
|
2016-05-13 04:02:57 +00:00
|
|
|
|
return SearchSpecial(series, new List<Episode> { episode }, userInvokedSearch);
|
2014-01-07 08:21:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
return SearchSingle(series, episode, userInvokedSearch);
|
2013-06-07 00:17:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
public List<DownloadDecision> SeasonSearch(int seriesId, int seasonNumber, bool missingOnly, bool userInvokedSearch)
|
2014-05-19 19:14:41 +00:00
|
|
|
|
{
|
|
|
|
|
var series = _seriesService.GetSeries(seriesId);
|
|
|
|
|
var episodes = _episodeService.GetEpisodesBySeason(seriesId, seasonNumber);
|
|
|
|
|
|
2015-04-07 00:05:12 +00:00
|
|
|
|
if (missingOnly)
|
|
|
|
|
{
|
|
|
|
|
episodes = episodes.Where(e => e.Monitored && !e.HasFile).ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-19 19:14:41 +00:00
|
|
|
|
if (series.SeriesType == SeriesTypes.Anime)
|
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
return SearchAnimeSeason(series, episodes, userInvokedSearch);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (seasonNumber == 0)
|
|
|
|
|
{
|
|
|
|
|
// search for special episodes in season 0
|
2016-05-13 04:02:57 +00:00
|
|
|
|
return SearchSpecial(series, episodes, userInvokedSearch);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var downloadDecisions = new List<DownloadDecision>();
|
|
|
|
|
|
|
|
|
|
if (series.UseSceneNumbering)
|
|
|
|
|
{
|
|
|
|
|
var sceneSeasonGroups = episodes.GroupBy(v =>
|
|
|
|
|
{
|
2014-10-14 22:19:35 +00:00
|
|
|
|
if (v.SceneSeasonNumber.HasValue && v.SceneEpisodeNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
return v.SceneSeasonNumber.Value;
|
|
|
|
|
}
|
2014-12-07 07:23:11 +00:00
|
|
|
|
return v.SeasonNumber;
|
2014-05-19 19:14:41 +00:00
|
|
|
|
}).Distinct();
|
|
|
|
|
|
|
|
|
|
foreach (var sceneSeasonEpisodes in sceneSeasonGroups)
|
|
|
|
|
{
|
|
|
|
|
if (sceneSeasonEpisodes.Count() == 1)
|
|
|
|
|
{
|
|
|
|
|
var episode = sceneSeasonEpisodes.First();
|
2016-05-13 04:02:57 +00:00
|
|
|
|
var searchSpec = Get<SingleEpisodeSearchCriteria>(series, sceneSeasonEpisodes.ToList(), userInvokedSearch);
|
2015-03-25 00:11:46 +00:00
|
|
|
|
|
2014-05-19 19:14:41 +00:00
|
|
|
|
searchSpec.SeasonNumber = sceneSeasonEpisodes.Key;
|
2015-03-25 00:11:46 +00:00
|
|
|
|
searchSpec.MonitoredEpisodesOnly = true;
|
|
|
|
|
|
2014-10-14 22:19:35 +00:00
|
|
|
|
if (episode.SceneSeasonNumber.HasValue && episode.SceneEpisodeNumber.HasValue)
|
2015-03-25 00:11:46 +00:00
|
|
|
|
{
|
2014-10-14 22:19:35 +00:00
|
|
|
|
searchSpec.EpisodeNumber = episode.SceneEpisodeNumber.Value;
|
2015-03-25 00:11:46 +00:00
|
|
|
|
}
|
2014-05-19 19:14:41 +00:00
|
|
|
|
else
|
2015-03-25 00:11:46 +00:00
|
|
|
|
{
|
2014-10-14 22:19:35 +00:00
|
|
|
|
searchSpec.EpisodeNumber = episode.EpisodeNumber;
|
2015-03-25 00:11:46 +00:00
|
|
|
|
}
|
2014-05-19 19:14:41 +00:00
|
|
|
|
|
2014-09-07 11:44:24 +00:00
|
|
|
|
var decisions = Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
downloadDecisions.AddRange(decisions);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
var searchSpec = Get<SeasonSearchCriteria>(series, sceneSeasonEpisodes.ToList(), userInvokedSearch);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
searchSpec.SeasonNumber = sceneSeasonEpisodes.Key;
|
|
|
|
|
|
2014-09-07 11:44:24 +00:00
|
|
|
|
var decisions = Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
downloadDecisions.AddRange(decisions);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
var searchSpec = Get<SeasonSearchCriteria>(series, episodes, userInvokedSearch);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
searchSpec.SeasonNumber = seasonNumber;
|
|
|
|
|
|
2014-09-07 11:44:24 +00:00
|
|
|
|
var decisions = Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
downloadDecisions.AddRange(decisions);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return downloadDecisions;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
private List<DownloadDecision> SearchSingle(Series series, Episode episode, bool userInvokedSearch)
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
var searchSpec = Get<SingleEpisodeSearchCriteria>(series, new List<Episode>{episode}, userInvokedSearch);
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
2014-10-14 22:19:35 +00:00
|
|
|
|
if (series.UseSceneNumbering && episode.SceneSeasonNumber.HasValue && episode.SceneEpisodeNumber.HasValue)
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2014-10-14 22:19:35 +00:00
|
|
|
|
searchSpec.EpisodeNumber = episode.SceneEpisodeNumber.Value;
|
|
|
|
|
searchSpec.SeasonNumber = episode.SceneSeasonNumber.Value;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2013-07-23 05:50:32 +00:00
|
|
|
|
searchSpec.EpisodeNumber = episode.EpisodeNumber;
|
|
|
|
|
searchSpec.SeasonNumber = episode.SeasonNumber;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-09-07 11:44:24 +00:00
|
|
|
|
return Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
private List<DownloadDecision> SearchDaily(Series series, Episode episode, bool userInvokedSearch)
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2013-09-15 03:49:58 +00:00
|
|
|
|
var airDate = DateTime.ParseExact(episode.AirDate, Episode.AIR_DATE_FORMAT, CultureInfo.InvariantCulture);
|
2016-05-13 04:02:57 +00:00
|
|
|
|
var searchSpec = Get<DailyEpisodeSearchCriteria>(series, new List<Episode>{ episode }, userInvokedSearch);
|
2013-10-23 05:17:02 +00:00
|
|
|
|
searchSpec.AirDate = airDate;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
2014-09-07 11:44:24 +00:00
|
|
|
|
return Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
private List<DownloadDecision> SearchAnime(Series series, Episode episode, bool userInvokedSearch)
|
2014-04-21 22:50:43 +00:00
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
var searchSpec = Get<AnimeEpisodeSearchCriteria>(series, new List<Episode> { episode }, userInvokedSearch);
|
2014-05-19 19:14:41 +00:00
|
|
|
|
|
2014-10-14 22:19:35 +00:00
|
|
|
|
if (episode.SceneAbsoluteEpisodeNumber.HasValue)
|
2014-05-19 19:14:41 +00:00
|
|
|
|
{
|
2014-10-14 22:19:35 +00:00
|
|
|
|
searchSpec.AbsoluteEpisodeNumber = episode.SceneAbsoluteEpisodeNumber.Value;
|
2014-05-19 19:14:41 +00:00
|
|
|
|
}
|
2014-10-14 22:19:35 +00:00
|
|
|
|
else if (episode.AbsoluteEpisodeNumber.HasValue)
|
|
|
|
|
{
|
|
|
|
|
searchSpec.AbsoluteEpisodeNumber = episode.AbsoluteEpisodeNumber.Value;
|
|
|
|
|
}
|
|
|
|
|
else
|
2014-05-19 19:14:41 +00:00
|
|
|
|
{
|
2014-10-14 22:19:35 +00:00
|
|
|
|
throw new ArgumentOutOfRangeException("AbsoluteEpisodeNumber", "Can not search for an episode without an absolute episode number");
|
2014-05-19 19:14:41 +00:00
|
|
|
|
}
|
2014-04-21 22:50:43 +00:00
|
|
|
|
|
2014-09-07 11:44:24 +00:00
|
|
|
|
return Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
2014-04-21 22:50:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
private List<DownloadDecision> SearchSpecial(Series series, List<Episode> episodes, bool userInvokedSearch)
|
2014-01-07 08:21:05 +00:00
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
var searchSpec = Get<SpecialEpisodeSearchCriteria>(series, episodes, userInvokedSearch);
|
2014-01-07 08:21:05 +00:00
|
|
|
|
// build list of queries for each episode in the form: "<series> <episode-title>"
|
2015-10-03 17:45:26 +00:00
|
|
|
|
searchSpec.EpisodeQueryTitles = episodes.Where(e => !string.IsNullOrWhiteSpace(e.Title))
|
2014-05-19 19:14:41 +00:00
|
|
|
|
.SelectMany(e => searchSpec.QueryTitles.Select(title => title + " " + SearchCriteriaBase.GetQueryTitle(e.Title)))
|
2014-01-07 08:21:05 +00:00
|
|
|
|
.ToArray();
|
|
|
|
|
|
2014-09-07 11:44:24 +00:00
|
|
|
|
return Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
2014-01-07 08:21:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
private List<DownloadDecision> SearchAnimeSeason(Series series, List<Episode> episodes, bool userInvokedSearch)
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2014-05-19 19:14:41 +00:00
|
|
|
|
var downloadDecisions = new List<DownloadDecision>();
|
2014-03-30 11:50:17 +00:00
|
|
|
|
|
2016-03-11 04:24:07 +00:00
|
|
|
|
foreach (var episode in episodes.Where(e => e.Monitored))
|
2014-03-30 11:50:17 +00:00
|
|
|
|
{
|
2016-05-13 04:02:57 +00:00
|
|
|
|
downloadDecisions.AddRange(SearchAnime(series, episode, userInvokedSearch));
|
2014-03-30 11:50:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return downloadDecisions;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 04:02:57 +00:00
|
|
|
|
private TSpec Get<TSpec>(Series series, List<Episode> episodes, bool userInvokedSearch) where TSpec : SearchCriteriaBase, new()
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2017-01-03 23:33:16 +00:00
|
|
|
|
var spec = new TSpec()
|
|
|
|
|
{
|
|
|
|
|
Series = series,
|
|
|
|
|
SceneTitles = _sceneMapping.GetSceneNames(series.TvdbId,
|
2016-07-14 18:48:14 +00:00
|
|
|
|
episodes.Select(e => e.SeasonNumber).Distinct().ToList(),
|
2017-01-03 23:33:16 +00:00
|
|
|
|
episodes.Select(e => e.SceneSeasonNumber ?? e.SeasonNumber).Distinct().ToList()),
|
2013-06-07 00:17:57 +00:00
|
|
|
|
|
2017-01-03 23:33:16 +00:00
|
|
|
|
Episodes = episodes
|
|
|
|
|
};
|
2014-05-19 19:14:41 +00:00
|
|
|
|
spec.SceneTitles.Add(series.Title);
|
2016-05-13 04:02:57 +00:00
|
|
|
|
spec.UserInvokedSearch = userInvokedSearch;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
|
|
|
|
return spec;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-02 17:05:55 +00:00
|
|
|
|
private TSpec Get<TSpec>(Movie movie, bool userInvokedSearch) where TSpec : SearchCriteriaBase, new()
|
|
|
|
|
{
|
2017-01-03 23:33:16 +00:00
|
|
|
|
var spec = new TSpec()
|
|
|
|
|
{
|
|
|
|
|
Movie = movie,
|
|
|
|
|
/*spec.SceneTitles = _sceneMapping.GetSceneNames(series.TvdbId,
|
|
|
|
|
episodes.Select(e => e.SeasonNumber).Distinct().ToList(),
|
|
|
|
|
episodes.Select(e => e.SceneSeasonNumber ?? e.SeasonNumber).Distinct().ToList());
|
2017-01-02 17:05:55 +00:00
|
|
|
|
|
2017-01-03 23:33:16 +00:00
|
|
|
|
spec.Episodes = episodes;
|
2017-01-02 17:05:55 +00:00
|
|
|
|
|
2017-01-03 23:33:16 +00:00
|
|
|
|
spec.SceneTitles.Add(series.Title);*/
|
|
|
|
|
UserInvokedSearch = userInvokedSearch
|
|
|
|
|
};
|
2017-01-02 17:05:55 +00:00
|
|
|
|
return spec;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-13 23:17:58 +00:00
|
|
|
|
private List<DownloadDecision> Dispatch(Func<IIndexer, IEnumerable<ReleaseInfo>> searchAction, SearchCriteriaBase criteriaBase)
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2015-06-27 09:43:17 +00:00
|
|
|
|
var indexers = _indexerFactory.SearchEnabled();
|
2013-09-13 23:17:58 +00:00
|
|
|
|
var reports = new List<ReleaseInfo>();
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
2013-09-11 06:33:47 +00:00
|
|
|
|
_logger.ProgressInfo("Searching {0} indexers for {1}", indexers.Count, criteriaBase);
|
2013-05-30 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
var taskList = new List<Task>();
|
|
|
|
|
var taskFactory = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.None);
|
|
|
|
|
|
|
|
|
|
foreach (var indexer in indexers)
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2013-05-30 01:35:26 +00:00
|
|
|
|
var indexerLocal = indexer;
|
|
|
|
|
|
|
|
|
|
taskList.Add(taskFactory.StartNew(() =>
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2013-05-30 01:35:26 +00:00
|
|
|
|
try
|
2013-04-07 07:30:37 +00:00
|
|
|
|
{
|
2013-05-30 01:35:26 +00:00
|
|
|
|
var indexerReports = searchAction(indexerLocal);
|
|
|
|
|
|
|
|
|
|
lock (reports)
|
|
|
|
|
{
|
|
|
|
|
reports.AddRange(indexerReports);
|
|
|
|
|
}
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
2013-05-30 01:35:26 +00:00
|
|
|
|
catch (Exception e)
|
|
|
|
|
{
|
2016-02-11 21:13:42 +00:00
|
|
|
|
_logger.Error(e, "Error while searching for " + criteriaBase);
|
2013-05-30 01:35:26 +00:00
|
|
|
|
}
|
2013-07-12 06:10:34 +00:00
|
|
|
|
}).LogExceptions());
|
2013-05-30 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Task.WaitAll(taskList.ToArray());
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
2013-09-04 05:01:28 +00:00
|
|
|
|
_logger.Debug("Total of {0} reports were found for {1} from {2} indexers", reports.Count, criteriaBase, indexers.Count);
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
2013-06-06 14:42:23 +00:00
|
|
|
|
return _makeDownloadDecision.GetSearchDecision(reports, criteriaBase).ToList();
|
2013-04-07 07:30:37 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2013-09-13 23:17:58 +00:00
|
|
|
|
}
|