You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
563 lines
25 KiB
563 lines
25 KiB
6 years ago
|
using System;
|
||
12 years ago
|
using System.Collections.Generic;
|
||
11 years ago
|
using System.Globalization;
|
||
12 years ago
|
using System.Threading.Tasks;
|
||
|
using NLog;
|
||
10 years ago
|
using NzbDrone.Common.Instrumentation.Extensions;
|
||
12 years ago
|
using NzbDrone.Core.DataAugmentation.Scene;
|
||
|
using NzbDrone.Core.DecisionEngine;
|
||
|
using NzbDrone.Core.IndexerSearch.Definitions;
|
||
|
using NzbDrone.Core.Indexers;
|
||
12 years ago
|
using NzbDrone.Core.Parser.Model;
|
||
12 years ago
|
using NzbDrone.Core.Tv;
|
||
|
using System.Linq;
|
||
11 years ago
|
using NzbDrone.Common.TPL;
|
||
7 years ago
|
using NzbDrone.Common.Extensions;
|
||
6 years ago
|
using NzbDrone.Core.Exceptions;
|
||
3 years ago
|
using NzbDrone.Core.Parser;
|
||
12 years ago
|
|
||
|
namespace NzbDrone.Core.IndexerSearch
|
||
|
{
|
||
3 years ago
|
public interface ISearchForReleases
|
||
12 years ago
|
{
|
||
7 years ago
|
List<DownloadDecision> EpisodeSearch(int episodeId, bool userInvokedSearch, bool interactiveSearch);
|
||
|
List<DownloadDecision> EpisodeSearch(Episode episode, bool userInvokedSearch, bool interactiveSearch);
|
||
5 years ago
|
List<DownloadDecision> SeasonSearch(int seriesId, int seasonNumber, bool missingOnly, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch);
|
||
|
List<DownloadDecision> SeasonSearch(int seriesId, int seasonNumber, List<Episode> episodes, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch);
|
||
12 years ago
|
}
|
||
|
|
||
3 years ago
|
public class ReleaseSearchService : ISearchForReleases
|
||
12 years ago
|
{
|
||
11 years ago
|
private readonly IIndexerFactory _indexerFactory;
|
||
12 years ago
|
private readonly ISceneMappingService _sceneMapping;
|
||
|
private readonly ISeriesService _seriesService;
|
||
|
private readonly IEpisodeService _episodeService;
|
||
|
private readonly IMakeDownloadDecision _makeDownloadDecision;
|
||
|
private readonly Logger _logger;
|
||
|
|
||
3 years ago
|
public ReleaseSearchService(IIndexerFactory indexerFactory,
|
||
11 years ago
|
ISceneMappingService sceneMapping,
|
||
|
ISeriesService seriesService,
|
||
|
IEpisodeService episodeService,
|
||
|
IMakeDownloadDecision makeDownloadDecision,
|
||
|
Logger logger)
|
||
12 years ago
|
{
|
||
11 years ago
|
_indexerFactory = indexerFactory;
|
||
12 years ago
|
_sceneMapping = sceneMapping;
|
||
|
_seriesService = seriesService;
|
||
|
_episodeService = episodeService;
|
||
|
_makeDownloadDecision = makeDownloadDecision;
|
||
|
_logger = logger;
|
||
|
}
|
||
|
|
||
7 years ago
|
public List<DownloadDecision> EpisodeSearch(int episodeId, bool userInvokedSearch, bool interactiveSearch)
|
||
11 years ago
|
{
|
||
|
var episode = _episodeService.GetEpisode(episodeId);
|
||
11 years ago
|
|
||
7 years ago
|
return EpisodeSearch(episode, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
}
|
||
|
|
||
7 years ago
|
public List<DownloadDecision> EpisodeSearch(Episode episode, bool userInvokedSearch, bool interactiveSearch)
|
||
11 years ago
|
{
|
||
11 years ago
|
var series = _seriesService.GetSeries(episode.SeriesId);
|
||
|
|
||
|
if (series.SeriesType == SeriesTypes.Daily)
|
||
|
{
|
||
11 years ago
|
if (string.IsNullOrWhiteSpace(episode.AirDate))
|
||
|
{
|
||
6 years ago
|
_logger.Error("Daily episode is missing an air date. Try refreshing the series info.");
|
||
|
throw new SearchFailedException("Air date is missing");
|
||
11 years ago
|
}
|
||
|
|
||
4 years ago
|
return SearchDaily(series, episode, false, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
}
|
||
4 years ago
|
|
||
11 years ago
|
if (series.SeriesType == SeriesTypes.Anime)
|
||
|
{
|
||
4 years ago
|
if (episode.SeasonNumber == 0 &&
|
||
|
episode.SceneAbsoluteEpisodeNumber == null &&
|
||
|
episode.AbsoluteEpisodeNumber == null)
|
||
|
{
|
||
|
// Search for special episodes in season 0 that don't have absolute episode numbers
|
||
4 years ago
|
return SearchSpecial(series, new List<Episode> { episode }, false, userInvokedSearch, interactiveSearch);
|
||
4 years ago
|
}
|
||
|
|
||
4 years ago
|
return SearchAnime(series, episode, false, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
}
|
||
11 years ago
|
|
||
11 years ago
|
if (episode.SeasonNumber == 0)
|
||
|
{
|
||
4 years ago
|
// Search for special episodes in season 0
|
||
4 years ago
|
return SearchSpecial(series, new List<Episode> { episode }, false, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
}
|
||
|
|
||
4 years ago
|
return SearchSingle(series, episode, false, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
}
|
||
|
|
||
5 years ago
|
public List<DownloadDecision> SeasonSearch(int seriesId, int seasonNumber, bool missingOnly, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch)
|
||
11 years ago
|
{
|
||
|
var episodes = _episodeService.GetEpisodesBySeason(seriesId, seasonNumber);
|
||
|
|
||
10 years ago
|
if (missingOnly)
|
||
|
{
|
||
5 years ago
|
episodes = episodes.Where(e => !e.HasFile).ToList();
|
||
10 years ago
|
}
|
||
|
|
||
5 years ago
|
return SeasonSearch(seriesId, seasonNumber, episodes, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
|
}
|
||
4 years ago
|
|
||
5 years ago
|
public List<DownloadDecision> SeasonSearch(int seriesId, int seasonNumber, List<Episode> episodes, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch)
|
||
|
{
|
||
|
var series = _seriesService.GetSeries(seriesId);
|
||
|
|
||
11 years ago
|
if (series.SeriesType == SeriesTypes.Anime)
|
||
|
{
|
||
4 years ago
|
return SearchAnimeSeason(series, episodes, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
}
|
||
|
|
||
7 years ago
|
if (series.SeriesType == SeriesTypes.Daily)
|
||
|
{
|
||
4 years ago
|
return SearchDailySeason(series, episodes, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
7 years ago
|
}
|
||
|
|
||
4 years ago
|
var mappings = GetSceneSeasonMappings(series, episodes);
|
||
11 years ago
|
|
||
|
var downloadDecisions = new List<DownloadDecision>();
|
||
|
|
||
4 years ago
|
foreach (var mapping in mappings)
|
||
11 years ago
|
{
|
||
4 years ago
|
if (mapping.SeasonNumber == 0)
|
||
11 years ago
|
{
|
||
4 years ago
|
// search for special episodes in season 0
|
||
|
downloadDecisions.AddRange(SearchSpecial(series, mapping.Episodes, monitoredOnly, userInvokedSearch, interactiveSearch));
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
if (mapping.Episodes.Count == 1)
|
||
|
{
|
||
|
var searchSpec = Get<SingleEpisodeSearchCriteria>(series, mapping, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
|
searchSpec.SeasonNumber = mapping.SeasonNumber;
|
||
|
searchSpec.EpisodeNumber = mapping.EpisodeMapping.EpisodeNumber;
|
||
|
|
||
|
var decisions = Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
||
|
downloadDecisions.AddRange(decisions);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
var searchSpec = Get<SeasonSearchCriteria>(series, mapping, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
|
searchSpec.SeasonNumber = mapping.SeasonNumber;
|
||
|
|
||
|
var decisions = Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
||
|
downloadDecisions.AddRange(decisions);
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
return DeDupeDecisions(downloadDecisions);
|
||
4 years ago
|
}
|
||
|
|
||
|
private List<SceneSeasonMapping> GetSceneSeasonMappings(Series series, List<Episode> episodes)
|
||
|
{
|
||
|
var dict = new Dictionary<SceneSeasonMapping, SceneSeasonMapping>();
|
||
|
|
||
|
var sceneMappings = _sceneMapping.FindByTvdbId(series.TvdbId);
|
||
11 years ago
|
|
||
4 years ago
|
// Group the episode by SceneSeasonNumber/SeasonNumber, in 99% of cases this will result in 1 groupedEpisode
|
||
|
var groupedEpisodes = episodes.ToLookup(v => (v.SceneSeasonNumber ?? v.SeasonNumber) * 100000 + v.SeasonNumber);
|
||
|
|
||
|
foreach (var groupedEpisode in groupedEpisodes)
|
||
|
{
|
||
|
var episodeMappings = GetSceneEpisodeMappings(series, groupedEpisode.First(), sceneMappings);
|
||
|
|
||
|
foreach (var episodeMapping in episodeMappings)
|
||
11 years ago
|
{
|
||
4 years ago
|
var seasonMapping = new SceneSeasonMapping
|
||
|
{
|
||
|
Episodes = groupedEpisode.ToList(),
|
||
|
EpisodeMapping = episodeMapping,
|
||
|
SceneTitles = episodeMapping.SceneTitles,
|
||
|
SearchMode = episodeMapping.SearchMode,
|
||
|
SeasonNumber = episodeMapping.SeasonNumber
|
||
|
};
|
||
|
|
||
|
if (dict.TryGetValue(seasonMapping, out var existing))
|
||
11 years ago
|
{
|
||
4 years ago
|
existing.Episodes.AddRange(seasonMapping.Episodes);
|
||
|
existing.SceneTitles.AddRange(seasonMapping.SceneTitles);
|
||
11 years ago
|
}
|
||
|
else
|
||
|
{
|
||
4 years ago
|
dict[seasonMapping] = seasonMapping;
|
||
11 years ago
|
}
|
||
|
}
|
||
|
}
|
||
4 years ago
|
|
||
|
foreach (var item in dict)
|
||
11 years ago
|
{
|
||
4 years ago
|
item.Value.Episodes = item.Value.Episodes.Distinct().ToList();
|
||
|
item.Value.SceneTitles = item.Value.SceneTitles.Distinct().ToList();
|
||
|
}
|
||
11 years ago
|
|
||
4 years ago
|
return dict.Values.ToList();
|
||
|
}
|
||
|
|
||
|
private List<SceneEpisodeMapping> GetSceneEpisodeMappings(Series series, Episode episode)
|
||
|
{
|
||
|
var dict = new Dictionary<SceneEpisodeMapping, SceneEpisodeMapping>();
|
||
|
|
||
|
var sceneMappings = _sceneMapping.FindByTvdbId(series.TvdbId);
|
||
|
|
||
|
var episodeMappings = GetSceneEpisodeMappings(series, episode, sceneMappings);
|
||
|
|
||
|
foreach (var episodeMapping in episodeMappings)
|
||
|
{
|
||
|
if (dict.TryGetValue(episodeMapping, out var existing))
|
||
|
{
|
||
|
existing.SceneTitles.AddRange(episodeMapping.SceneTitles);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
dict[episodeMapping] = episodeMapping;
|
||
|
}
|
||
11 years ago
|
}
|
||
|
|
||
4 years ago
|
foreach (var item in dict)
|
||
|
{
|
||
|
item.Value.SceneTitles = item.Value.SceneTitles.Distinct().ToList();
|
||
|
}
|
||
|
|
||
|
return dict.Values.ToList();
|
||
11 years ago
|
}
|
||
|
|
||
4 years ago
|
private IEnumerable<SceneEpisodeMapping> GetSceneEpisodeMappings(Series series, Episode episode, List<SceneMapping> sceneMappings)
|
||
12 years ago
|
{
|
||
4 years ago
|
var includeGlobal = true;
|
||
12 years ago
|
|
||
4 years ago
|
foreach (var sceneMapping in sceneMappings)
|
||
12 years ago
|
{
|
||
3 years ago
|
// There are two kinds of mappings:
|
||
|
// - Mapped on Release Season Number with sceneMapping.SceneSeasonNumber specified and optionally sceneMapping.SeasonNumber. This translates via episode.SceneSeasonNumber/SeasonNumber to specific episodes.
|
||
|
// - Mapped on Episode Season Number with optionally sceneMapping.SeasonNumber. This translates from episode.SceneSeasonNumber/SeasonNumber to specific releases. (Filter by episode.SeasonNumber or globally)
|
||
|
|
||
|
var ignoreSceneNumbering = (sceneMapping.SceneOrigin == "tvdb" || sceneMapping.SceneOrigin == "unknown:tvdb");
|
||
|
var mappingSceneSeasonNumber = sceneMapping.SceneSeasonNumber.NonNegative();
|
||
|
var mappingSeasonNumber = sceneMapping.SeasonNumber.NonNegative();
|
||
|
|
||
|
// Select scene or tvdb on the episode
|
||
|
var mappedSeasonNumber = ignoreSceneNumbering ? episode.SeasonNumber : (episode.SceneSeasonNumber ?? episode.SeasonNumber);
|
||
|
var releaseSeasonNumber = sceneMapping.SceneSeasonNumber.NonNegative() ?? mappedSeasonNumber;
|
||
|
|
||
|
if (mappingSceneSeasonNumber.HasValue)
|
||
4 years ago
|
{
|
||
3 years ago
|
// Apply the alternative mapping (release to scene/tvdb)
|
||
|
var mappedAltSeasonNumber = sceneMapping.SeasonNumber.NonNegative() ?? sceneMapping.SceneSeasonNumber.NonNegative() ?? mappedSeasonNumber;
|
||
|
|
||
|
// Check if the mapping applies to the current season
|
||
|
if (mappedAltSeasonNumber != mappedSeasonNumber)
|
||
|
{
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Check if the mapping applies to the current season
|
||
|
if (mappingSeasonNumber.HasValue && mappingSeasonNumber.Value != episode.SeasonNumber)
|
||
|
{
|
||
|
continue;
|
||
|
}
|
||
4 years ago
|
}
|
||
|
|
||
4 years ago
|
if (sceneMapping.ParseTerm == series.CleanTitle && sceneMapping.FilterRegex.IsNotNullOrWhiteSpace())
|
||
|
{
|
||
|
// Disable the implied mapping if we have an explicit mapping by the same name
|
||
|
includeGlobal = false;
|
||
|
}
|
||
|
|
||
|
// By default we do a alt title search in case indexers don't have the release properly indexed. Services can override this behavior.
|
||
3 years ago
|
var searchMode = sceneMapping.SearchMode ?? ((mappingSceneSeasonNumber.HasValue && series.CleanTitle != sceneMapping.SearchTerm.CleanSeriesTitle()) ? SearchMode.SearchTitle : SearchMode.Default);
|
||
4 years ago
|
|
||
3 years ago
|
if (ignoreSceneNumbering)
|
||
4 years ago
|
{
|
||
|
yield return new SceneEpisodeMapping
|
||
|
{
|
||
|
Episode = episode,
|
||
|
SearchMode = searchMode,
|
||
|
SceneTitles = new List<string> { sceneMapping.SearchTerm },
|
||
3 years ago
|
SeasonNumber = releaseSeasonNumber,
|
||
4 years ago
|
EpisodeNumber = episode.EpisodeNumber,
|
||
|
AbsoluteEpisodeNumber = episode.AbsoluteEpisodeNumber
|
||
|
};
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
yield return new SceneEpisodeMapping
|
||
|
{
|
||
|
Episode = episode,
|
||
|
SearchMode = searchMode,
|
||
|
SceneTitles = new List<string> { sceneMapping.SearchTerm },
|
||
3 years ago
|
SeasonNumber = releaseSeasonNumber,
|
||
4 years ago
|
EpisodeNumber = episode.SceneEpisodeNumber ?? episode.EpisodeNumber,
|
||
|
AbsoluteEpisodeNumber = episode.SceneAbsoluteEpisodeNumber ?? episode.AbsoluteEpisodeNumber
|
||
|
};
|
||
|
}
|
||
12 years ago
|
}
|
||
4 years ago
|
|
||
|
if (includeGlobal)
|
||
12 years ago
|
{
|
||
4 years ago
|
yield return new SceneEpisodeMapping
|
||
|
{
|
||
|
Episode = episode,
|
||
|
SearchMode = SearchMode.Default,
|
||
|
SceneTitles = new List<string> { series.Title },
|
||
|
SeasonNumber = episode.SceneSeasonNumber ?? episode.SeasonNumber,
|
||
|
EpisodeNumber = episode.SceneEpisodeNumber ?? episode.EpisodeNumber,
|
||
|
AbsoluteEpisodeNumber = episode.SceneSeasonNumber ?? episode.AbsoluteEpisodeNumber
|
||
|
};
|
||
12 years ago
|
}
|
||
4 years ago
|
}
|
||
12 years ago
|
|
||
4 years ago
|
private List<DownloadDecision> SearchSingle(Series series, Episode episode, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch)
|
||
|
{
|
||
|
var mappings = GetSceneEpisodeMappings(series, episode);
|
||
|
|
||
|
var downloadDecisions = new List<DownloadDecision>();
|
||
|
|
||
|
foreach (var mapping in mappings)
|
||
|
{
|
||
|
var searchSpec = Get<SingleEpisodeSearchCriteria>(series, mapping, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
|
searchSpec.SeasonNumber = mapping.SeasonNumber;
|
||
|
searchSpec.EpisodeNumber = mapping.EpisodeNumber;
|
||
|
|
||
|
var decisions = Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
||
|
downloadDecisions.AddRange(decisions);
|
||
|
}
|
||
|
|
||
4 years ago
|
return DeDupeDecisions(downloadDecisions);
|
||
12 years ago
|
}
|
||
|
|
||
4 years ago
|
private List<DownloadDecision> SearchDaily(Series series, Episode episode, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch)
|
||
12 years ago
|
{
|
||
11 years ago
|
var airDate = DateTime.ParseExact(episode.AirDate, Episode.AIR_DATE_FORMAT, CultureInfo.InvariantCulture);
|
||
4 years ago
|
var searchSpec = Get<DailyEpisodeSearchCriteria>(series, new List<Episode> { episode }, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
searchSpec.AirDate = airDate;
|
||
12 years ago
|
|
||
10 years ago
|
return Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
||
12 years ago
|
}
|
||
|
|
||
4 years ago
|
private List<DownloadDecision> SearchAnime(Series series, Episode episode, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch, bool isSeasonSearch = false)
|
||
11 years ago
|
{
|
||
4 years ago
|
var searchSpec = Get<AnimeEpisodeSearchCriteria>(series, new List<Episode> { episode }, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
|
||
5 years ago
|
searchSpec.IsSeasonSearch = isSeasonSearch;
|
||
|
|
||
10 years ago
|
if (episode.SceneAbsoluteEpisodeNumber.HasValue)
|
||
11 years ago
|
{
|
||
10 years ago
|
searchSpec.AbsoluteEpisodeNumber = episode.SceneAbsoluteEpisodeNumber.Value;
|
||
11 years ago
|
}
|
||
10 years ago
|
else if (episode.AbsoluteEpisodeNumber.HasValue)
|
||
|
{
|
||
|
searchSpec.AbsoluteEpisodeNumber = episode.AbsoluteEpisodeNumber.Value;
|
||
|
}
|
||
|
else
|
||
11 years ago
|
{
|
||
6 years ago
|
_logger.Error($"Can not search for {series.Title} - S{episode.SeasonNumber:00}E{episode.EpisodeNumber:00} it does not have an absolute episode number");
|
||
|
throw new SearchFailedException("Absolute episode number is missing");
|
||
11 years ago
|
}
|
||
11 years ago
|
|
||
10 years ago
|
return Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec);
|
||
11 years ago
|
}
|
||
|
|
||
4 years ago
|
private List<DownloadDecision> SearchSpecial(Series series, List<Episode> episodes,bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch)
|
||
11 years ago
|
{
|
||
4 years ago
|
var downloadDecisions = new List<DownloadDecision>();
|
||
|
|
||
4 years ago
|
var searchSpec = Get<SpecialEpisodeSearchCriteria>(series, episodes, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
11 years ago
|
// build list of queries for each episode in the form: "<series> <episode-title>"
|
||
9 years ago
|
searchSpec.EpisodeQueryTitles = episodes.Where(e => !string.IsNullOrWhiteSpace(e.Title))
|
||
3 years ago
|
.SelectMany(e => searchSpec.CleanSceneTitles.Select(title => title + " " + SearchCriteriaBase.GetCleanSceneTitle(e.Title)))
|
||
11 years ago
|
.ToArray();
|
||
|
|
||
4 years ago
|
downloadDecisions.AddRange(Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec));
|
||
|
|
||
|
// Search for each episode by season/episode number as well
|
||
|
foreach (var episode in episodes)
|
||
|
{
|
||
4 years ago
|
// Episode needs to be monitored if it's not an interactive search
|
||
|
if (!interactiveSearch && monitoredOnly && !episode.Monitored)
|
||
|
{
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
downloadDecisions.AddRange(SearchSingle(series, episode, monitoredOnly, userInvokedSearch, interactiveSearch));
|
||
4 years ago
|
}
|
||
|
|
||
4 years ago
|
return DeDupeDecisions(downloadDecisions);
|
||
11 years ago
|
}
|
||
|
|
||
4 years ago
|
private List<DownloadDecision> SearchAnimeSeason(Series series, List<Episode> episodes, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch)
|
||
12 years ago
|
{
|
||
11 years ago
|
var downloadDecisions = new List<DownloadDecision>();
|
||
11 years ago
|
|
||
4 years ago
|
// Episode needs to be monitored if it's not an interactive search
|
||
|
// and Ensure episode has an airdate and has already aired
|
||
|
var episodesToSearch = episodes
|
||
|
.Where(ep => interactiveSearch || !monitoredOnly || ep.Monitored)
|
||
|
.Where(ep => ep.AirDateUtc.HasValue && ep.AirDateUtc.Value.Before(DateTime.UtcNow))
|
||
|
.ToList();
|
||
4 years ago
|
|
||
|
foreach (var episode in episodesToSearch)
|
||
11 years ago
|
{
|
||
4 years ago
|
downloadDecisions.AddRange(SearchAnime(series, episode, monitoredOnly, userInvokedSearch, interactiveSearch, true));
|
||
11 years ago
|
}
|
||
|
|
||
4 years ago
|
return DeDupeDecisions(downloadDecisions);
|
||
12 years ago
|
}
|
||
|
|
||
4 years ago
|
private List<DownloadDecision> SearchDailySeason(Series series, List<Episode> episodes, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch)
|
||
7 years ago
|
{
|
||
|
var downloadDecisions = new List<DownloadDecision>();
|
||
4 years ago
|
|
||
|
// Episode needs to be monitored if it's not an interactive search
|
||
|
// and Ensure episode has an airdate
|
||
|
var episodesToSearch = episodes
|
||
|
.Where(ep => interactiveSearch || !monitoredOnly || ep.Monitored)
|
||
|
.Where(ep => ep.AirDate.IsNotNullOrWhiteSpace())
|
||
|
.ToList();
|
||
|
|
||
|
foreach (var yearGroup in episodesToSearch.GroupBy(v => DateTime.ParseExact(v.AirDate, Episode.AIR_DATE_FORMAT, CultureInfo.InvariantCulture).Year))
|
||
7 years ago
|
{
|
||
|
var yearEpisodes = yearGroup.ToList();
|
||
|
|
||
|
if (yearEpisodes.Count > 1)
|
||
|
{
|
||
4 years ago
|
var searchSpec = Get<DailySeasonSearchCriteria>(series, yearEpisodes, monitoredOnly, userInvokedSearch, interactiveSearch);
|
||
7 years ago
|
searchSpec.Year = yearGroup.Key;
|
||
|
|
||
|
downloadDecisions.AddRange(Dispatch(indexer => indexer.Fetch(searchSpec), searchSpec));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
4 years ago
|
downloadDecisions.AddRange(SearchDaily(series, yearEpisodes.First(), monitoredOnly, userInvokedSearch, interactiveSearch));
|
||
7 years ago
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
return DeDupeDecisions(downloadDecisions);
|
||
7 years ago
|
}
|
||
|
|
||
4 years ago
|
private TSpec Get<TSpec>(Series series, List<Episode> episodes, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch) where TSpec : SearchCriteriaBase, new()
|
||
12 years ago
|
{
|
||
|
var spec = new TSpec();
|
||
|
|
||
11 years ago
|
spec.Series = series;
|
||
8 years ago
|
spec.SceneTitles = _sceneMapping.GetSceneNames(series.TvdbId,
|
||
|
episodes.Select(e => e.SeasonNumber).Distinct().ToList(),
|
||
|
episodes.Select(e => e.SceneSeasonNumber ?? e.SeasonNumber).Distinct().ToList());
|
||
4 years ago
|
|
||
|
spec.Episodes = episodes;
|
||
|
spec.MonitoredEpisodesOnly = monitoredOnly;
|
||
|
spec.UserInvokedSearch = userInvokedSearch;
|
||
|
spec.InteractiveSearch = interactiveSearch;
|
||
5 years ago
|
|
||
4 years ago
|
if (!spec.SceneTitles.Contains(series.Title))
|
||
|
{
|
||
|
spec.SceneTitles.Add(series.Title);
|
||
|
}
|
||
|
|
||
4 years ago
|
return spec;
|
||
|
}
|
||
11 years ago
|
|
||
4 years ago
|
private TSpec Get<TSpec>(Series series, SceneEpisodeMapping mapping, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch) where TSpec : SearchCriteriaBase, new()
|
||
|
{
|
||
|
var spec = new TSpec();
|
||
11 years ago
|
|
||
4 years ago
|
spec.Series = series;
|
||
|
spec.SceneTitles = mapping.SceneTitles;
|
||
|
spec.SearchMode = mapping.SearchMode;
|
||
|
|
||
|
spec.Episodes = new List<Episode> { mapping.Episode };
|
||
|
spec.MonitoredEpisodesOnly = monitoredOnly;
|
||
|
spec.UserInvokedSearch = userInvokedSearch;
|
||
|
spec.InteractiveSearch = interactiveSearch;
|
||
|
|
||
|
return spec;
|
||
|
}
|
||
|
|
||
|
private TSpec Get<TSpec>(Series series, SceneSeasonMapping mapping, bool monitoredOnly, bool userInvokedSearch, bool interactiveSearch) where TSpec : SearchCriteriaBase, new()
|
||
|
{
|
||
|
var spec = new TSpec();
|
||
|
|
||
|
spec.Series = series;
|
||
|
spec.SceneTitles = mapping.SceneTitles;
|
||
|
spec.SearchMode = mapping.SearchMode;
|
||
|
|
||
|
spec.Episodes = mapping.Episodes;
|
||
|
spec.MonitoredEpisodesOnly = monitoredOnly;
|
||
9 years ago
|
spec.UserInvokedSearch = userInvokedSearch;
|
||
7 years ago
|
spec.InteractiveSearch = interactiveSearch;
|
||
12 years ago
|
|
||
|
return spec;
|
||
|
}
|
||
|
|
||
11 years ago
|
private List<DownloadDecision> Dispatch(Func<IIndexer, IEnumerable<ReleaseInfo>> searchAction, SearchCriteriaBase criteriaBase)
|
||
12 years ago
|
{
|
||
7 years ago
|
var indexers = criteriaBase.InteractiveSearch ?
|
||
|
_indexerFactory.InteractiveSearchEnabled() :
|
||
|
_indexerFactory.AutomaticSearchEnabled();
|
||
|
|
||
4 years ago
|
// Filter indexers to untagged indexers and indexers with intersecting tags
|
||
|
indexers = indexers.Where(i => i.Definition.Tags.Empty() || i.Definition.Tags.Intersect(criteriaBase.Series.Tags).Any()).ToList();
|
||
|
|
||
11 years ago
|
var reports = new List<ReleaseInfo>();
|
||
12 years ago
|
|
||
3 years ago
|
_logger.ProgressInfo("Searching indexers for {0}. {1} active indexers", criteriaBase, indexers.Count);
|
||
12 years ago
|
|
||
|
var taskList = new List<Task>();
|
||
|
var taskFactory = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.None);
|
||
|
|
||
|
foreach (var indexer in indexers)
|
||
12 years ago
|
{
|
||
12 years ago
|
var indexerLocal = indexer;
|
||
|
|
||
|
taskList.Add(taskFactory.StartNew(() =>
|
||
12 years ago
|
{
|
||
12 years ago
|
try
|
||
12 years ago
|
{
|
||
12 years ago
|
var indexerReports = searchAction(indexerLocal);
|
||
|
|
||
|
lock (reports)
|
||
|
{
|
||
|
reports.AddRange(indexerReports);
|
||
|
}
|
||
12 years ago
|
}
|
||
12 years ago
|
catch (Exception e)
|
||
|
{
|
||
8 years ago
|
_logger.Error(e, "Error while searching for {0}", criteriaBase);
|
||
12 years ago
|
}
|
||
11 years ago
|
}).LogExceptions());
|
||
12 years ago
|
}
|
||
|
|
||
|
Task.WaitAll(taskList.ToArray());
|
||
12 years ago
|
|
||
11 years ago
|
_logger.Debug("Total of {0} reports were found for {1} from {2} indexers", reports.Count, criteriaBase, indexers.Count);
|
||
12 years ago
|
|
||
6 years ago
|
// Update the last search time for all episodes if at least 1 indexer was searched.
|
||
|
if (indexers.Any())
|
||
|
{
|
||
|
var lastSearchTime = DateTime.UtcNow;
|
||
|
_logger.Debug("Setting last search time to: {0}", lastSearchTime);
|
||
|
|
||
|
criteriaBase.Episodes.ForEach(e => e.LastSearchTime = lastSearchTime);
|
||
|
_episodeService.UpdateEpisodes(criteriaBase.Episodes);
|
||
|
}
|
||
|
|
||
11 years ago
|
return _makeDownloadDecision.GetSearchDecision(reports, criteriaBase).ToList();
|
||
12 years ago
|
}
|
||
4 years ago
|
|
||
|
private List<DownloadDecision> DeDupeDecisions(List<DownloadDecision> decisions)
|
||
|
{
|
||
4 years ago
|
// De-dupe reports by guid so duplicate results aren't returned. Pick the one with the least rejections.
|
||
4 years ago
|
|
||
4 years ago
|
return decisions.GroupBy(d => d.RemoteEpisode.Release.Guid).Select(d => d.OrderBy(v => v.Rejections.Count()).First()).ToList();
|
||
4 years ago
|
}
|
||
12 years ago
|
}
|
||
11 years ago
|
}
|