private List <Episode> GetEpisodes(LocalEpisode localEpisode)
{
var bestEpisodeInfoForEpisodes = GetBestEpisodeInfo(localEpisode);
var isMediaFile = MediaFileExtensions.Extensions.Contains(Path.GetExtension(localEpisode.Path));
if (bestEpisodeInfoForEpisodes == null)
{
return(new List <Episode>());
}
if (ValidateParsedEpisodeInfo.ValidateForSeriesType(bestEpisodeInfoForEpisodes, localEpisode.Series, isMediaFile))
{
var episodes = _parsingService.GetEpisodes(bestEpisodeInfoForEpisodes, localEpisode.Series, localEpisode.SceneSource);
if (episodes.Empty() && bestEpisodeInfoForEpisodes.IsPossibleSpecialEpisode)
{
var parsedSpecialEpisodeInfo = GetSpecialEpisodeInfo(localEpisode, bestEpisodeInfoForEpisodes);
if (parsedSpecialEpisodeInfo != null)
{
episodes = _parsingService.GetEpisodes(parsedSpecialEpisodeInfo, localEpisode.Series, localEpisode.SceneSource);
}
}
return(episodes);
}
return(new List <Episode>());
}
private List <PendingRelease> IncludeRemoteEpisodes(List <PendingRelease> releases)
{
var result = new List <PendingRelease>();
var seriesMap = _seriesService.GetSeries(releases.Select(v => v.SeriesId).Distinct())
.ToDictionary(v => v.Id);
foreach (var release in releases)
{
var series = seriesMap.GetValueOrDefault(release.SeriesId);
// Just in case the series was removed, but wasn't cleaned up yet (housekeeper will clean it up)
if (series == null)
{
return(null);
}
var episodes = _parsingService.GetEpisodes(release.ParsedEpisodeInfo, series, true);
release.RemoteEpisode = new RemoteEpisode
{
Series = series,
Episodes = episodes,
ParsedEpisodeInfo = release.ParsedEpisodeInfo,
Release = release.Release
};
result.Add(release);
}
return(result);
}
private IEnumerable <ImportDecision> GetDecisions(IEnumerable <String> videoFiles, Series series, bool sceneSource)
{
foreach (var file in videoFiles)
{
ImportDecision decision = null;
try
{
var parsedEpisode = _parsingService.GetEpisodes(file, series, sceneSource);
if (parsedEpisode != null)
{
parsedEpisode.Size = _diskProvider.GetFileSize(file);
decision = GetDecision(parsedEpisode);
}
else
{
parsedEpisode = new LocalEpisode();
parsedEpisode.Path = file;
decision = new ImportDecision(parsedEpisode, "Unable to parse file");
}
}
catch (Exception e)
{
_logger.ErrorException("Couldn't import file." + file, e);
}
if (decision != null)
{
yield return(decision);
}
}
}
private List <Episode> GetEpisodes(LocalEpisode localEpisode, bool otherFiles)
{
var bestEpisodeInfoForEpisodes = GetBestEpisodeInfo(localEpisode, otherFiles);
var isMediaFile = MediaFileExtensions.Extensions.Contains(Path.GetExtension(localEpisode.Path));
if (bestEpisodeInfoForEpisodes == null)
{
return(new List <Episode>());
}
if (ValidateParsedEpisodeInfo.ValidateForSeriesType(bestEpisodeInfoForEpisodes, localEpisode.Series, isMediaFile))
{
return(_parsingService.GetEpisodes(bestEpisodeInfoForEpisodes, localEpisode.Series, localEpisode.SceneSource));
}
return(new List <Episode>());
}
private RemoteEpisode GetRemoteEpisode(PendingRelease release)
{
var series = _seriesService.GetSeries(release.SeriesId);
//Just in case the series was removed, but wasn't cleaned up yet (housekeeper will clean it up)
if (series == null)
{
return(null);
}
var episodes = _parsingService.GetEpisodes(release.ParsedEpisodeInfo, series, true);
return(new RemoteEpisode
{
Series = series,
Episodes = episodes,
ParsedEpisodeInfo = release.ParsedEpisodeInfo,
Release = release.Release
});
}
private object DownloadRelease(ReleaseResource release)
{
var remoteEpisode = _remoteEpisodeCache.Find(GetCacheKey(release));
if (remoteEpisode == null)
{
_logger.Debug("Couldn't find requested release in cache, cache timeout probably expired.");
throw new NzbDroneClientException(HttpStatusCode.NotFound, "Couldn't find requested release in cache, try searching again");
}
try
{
if (remoteEpisode.Series == null)
{
if (release.EpisodeId.HasValue)
{
var episode = _episodeService.GetEpisode(release.EpisodeId.Value);
remoteEpisode.Series = _seriesService.GetSeries(episode.SeriesId);
remoteEpisode.Episodes = new List <Episode> {
episode
};
}
else if (release.SeriesId.HasValue)
{
var series = _seriesService.GetSeries(release.SeriesId.Value);
var episodes = _parsingService.GetEpisodes(remoteEpisode.ParsedEpisodeInfo, series, true);
if (episodes.Empty())
{
throw new NzbDroneClientException(HttpStatusCode.NotFound, "Unable to parse episodes in the release");
}
remoteEpisode.Series = series;
remoteEpisode.Episodes = episodes;
}
else
{
throw new NzbDroneClientException(HttpStatusCode.NotFound, "Unable to find matching series and episodes");
}
}
else if (remoteEpisode.Episodes.Empty())
{
var episodes = _parsingService.GetEpisodes(remoteEpisode.ParsedEpisodeInfo, remoteEpisode.Series, true);
if (episodes.Empty() && release.EpisodeId.HasValue)
{
var episode = _episodeService.GetEpisode(release.EpisodeId.Value);
episodes = new List <Episode> {
episode
};
}
remoteEpisode.Episodes = episodes;
}
if (remoteEpisode.Episodes.Empty())
{
throw new NzbDroneClientException(HttpStatusCode.NotFound, "Unable to parse episodes in the release");
}
_downloadService.DownloadReport(remoteEpisode);
}
catch (ReleaseDownloadException ex)
{
_logger.Error(ex, ex.Message);
throw new NzbDroneClientException(HttpStatusCode.Conflict, "Getting release from indexer failed");
}
return(release);
}
private List <PendingRelease> IncludeRemoteEpisodes(List <PendingRelease> releases, Dictionary <string, RemoteEpisode> knownRemoteEpisodes = null)
{
var result = new List <PendingRelease>();
var seriesMap = new Dictionary <int, Series>();
if (knownRemoteEpisodes != null)
{
foreach (var series in knownRemoteEpisodes.Values.Select(v => v.Series))
{
if (!seriesMap.ContainsKey(series.Id))
{
seriesMap[series.Id] = series;
}
}
}
foreach (var series in _seriesService.GetSeries(releases.Select(v => v.SeriesId).Distinct().Where(v => !seriesMap.ContainsKey(v))))
{
seriesMap[series.Id] = series;
}
foreach (var release in releases)
{
var series = seriesMap.GetValueOrDefault(release.SeriesId);
// Just in case the series was removed, but wasn't cleaned up yet (housekeeper will clean it up)
if (series == null)
{
return(null);
}
List <Episode> episodes;
RemoteEpisode knownRemoteEpisode;
if (knownRemoteEpisodes != null && knownRemoteEpisodes.TryGetValue(release.Release.Title, out knownRemoteEpisode))
{
episodes = knownRemoteEpisode.Episodes;
}
else
{
if (ValidateParsedEpisodeInfo.ValidateForSeriesType(release.ParsedEpisodeInfo, series))
{
episodes = _parsingService.GetEpisodes(release.ParsedEpisodeInfo, series, true);
}
else
{
episodes = new List <Episode>();
}
}
release.RemoteEpisode = new RemoteEpisode
{
Series = series,
Episodes = episodes,
ParsedEpisodeInfo = release.ParsedEpisodeInfo,
Release = release.Release
};
result.Add(release);
}
return(result);
}
public Decision IsSatisfiedBy(LocalEpisode localEpisode, DownloadClientItem downloadClientItem)
{
if (localEpisode.ExistingFile)
{
return(Decision.Accept());
}
var fileInfo = localEpisode.FileEpisodeInfo;
var folderInfo = localEpisode.FolderEpisodeInfo;
if (fileInfo != null && fileInfo.IsPossibleSceneSeasonSpecial)
{
fileInfo = _parsingService.ParseSpecialEpisodeTitle(fileInfo, fileInfo.ReleaseTitle, localEpisode.Series.TvdbId, 0);
}
if (folderInfo != null && folderInfo.IsPossibleSceneSeasonSpecial)
{
folderInfo = _parsingService.ParseSpecialEpisodeTitle(folderInfo, folderInfo.ReleaseTitle, localEpisode.Series.TvdbId, 0);
}
if (folderInfo == null)
{
_logger.Debug("No folder ParsedEpisodeInfo, skipping check");
return(Decision.Accept());
}
if (fileInfo == null)
{
_logger.Debug("No file ParsedEpisodeInfo, skipping check");
return(Decision.Accept());
}
var folderEpisodes = _parsingService.GetEpisodes(folderInfo, localEpisode.Series, true);
var fileEpisodes = _parsingService.GetEpisodes(fileInfo, localEpisode.Series, true);
if (folderEpisodes.Empty())
{
_logger.Debug("No episode numbers in folder ParsedEpisodeInfo, skipping check");
return(Decision.Accept());
}
if (folderEpisodes.First().SeasonNumber != fileEpisodes.FirstOrDefault()?.SeasonNumber)
{
return(Decision.Reject("Season number {0} was unexpected considering the folder name {1}", fileInfo.SeasonNumber, folderInfo.ReleaseTitle));
}
var unexpected = fileEpisodes.Where(e => folderEpisodes.All(o => o.Id != e.Id)).ToList();
if (unexpected.Any())
{
_logger.Debug("Unexpected episode(s) in file: {0}", FormatEpisode(unexpected));
if (unexpected.Count == 1)
{
return(Decision.Reject("Episode {0} was unexpected considering the {1} folder name", FormatEpisode(unexpected), folderInfo.ReleaseTitle));
}
return(Decision.Reject("Episodes {0} were unexpected considering the {1} folder name", FormatEpisode(unexpected), folderInfo.ReleaseTitle));
}
return(Decision.Accept());
}
