2018-03-14 20:41:36 +00:00
|
|
|
using System;
|
2013-04-07 07:30:37 +00:00
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Linq;
|
2013-04-29 00:39:17 +00:00
|
|
|
using NLog;
|
2014-12-02 06:26:25 +00:00
|
|
|
using NzbDrone.Common.Extensions;
|
2014-07-23 23:43:54 +00:00
|
|
|
using NzbDrone.Common.Instrumentation.Extensions;
|
2014-07-15 19:03:53 +00:00
|
|
|
using NzbDrone.Common.Serializer;
|
2017-04-10 09:17:31 +00:00
|
|
|
using NzbDrone.Core.Configuration;
|
2020-01-22 21:47:33 +00:00
|
|
|
using NzbDrone.Core.CustomFormats;
|
2019-12-22 22:08:53 +00:00
|
|
|
using NzbDrone.Core.DecisionEngine.Specifications;
|
2013-04-07 07:30:37 +00:00
|
|
|
using NzbDrone.Core.IndexerSearch.Definitions;
|
2019-06-14 03:54:25 +00:00
|
|
|
using NzbDrone.Core.Languages;
|
2019-12-22 22:08:53 +00:00
|
|
|
using NzbDrone.Core.Parser;
|
2013-04-15 01:41:39 +00:00
|
|
|
using NzbDrone.Core.Parser.Model;
|
2017-06-18 21:12:14 +00:00
|
|
|
using NzbDrone.Core.Qualities;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
|
|
|
namespace NzbDrone.Core.DecisionEngine
|
|
|
|
{
|
|
|
|
public interface IMakeDownloadDecision
|
|
|
|
{
|
2013-09-13 23:25:30 +00:00
|
|
|
List<DownloadDecision> GetRssDecision(List<ReleaseInfo> reports);
|
|
|
|
List<DownloadDecision> GetSearchDecision(List<ReleaseInfo> reports, SearchCriteriaBase searchCriteriaBase);
|
2013-04-07 07:30:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public class DownloadDecisionMaker : IMakeDownloadDecision
|
|
|
|
{
|
2014-10-27 05:51:50 +00:00
|
|
|
private readonly IEnumerable<IDecisionEngineSpecification> _specifications;
|
2013-04-15 01:41:39 +00:00
|
|
|
private readonly IParsingService _parsingService;
|
2019-12-22 21:24:10 +00:00
|
|
|
private readonly IConfigService _configService;
|
2020-01-22 21:47:33 +00:00
|
|
|
private readonly ICustomFormatCalculationService _formatCalculator;
|
2013-04-29 00:39:17 +00:00
|
|
|
private readonly Logger _logger;
|
2013-04-07 07:30:37 +00:00
|
|
|
|
2018-08-05 14:28:05 +00:00
|
|
|
public DownloadDecisionMaker(IEnumerable<IDecisionEngineSpecification> specifications,
|
2020-01-22 21:47:33 +00:00
|
|
|
IParsingService parsingService,
|
|
|
|
IConfigService configService,
|
|
|
|
ICustomFormatCalculationService formatCalculator,
|
|
|
|
Logger logger)
|
2013-04-07 07:30:37 +00:00
|
|
|
{
|
|
|
|
_specifications = specifications;
|
2013-04-15 01:41:39 +00:00
|
|
|
_parsingService = parsingService;
|
2019-12-22 21:24:10 +00:00
|
|
|
_configService = configService;
|
2020-01-22 21:47:33 +00:00
|
|
|
_formatCalculator = formatCalculator;
|
2013-04-29 00:39:17 +00:00
|
|
|
_logger = logger;
|
2013-04-07 07:30:37 +00:00
|
|
|
}
|
|
|
|
|
2013-09-13 23:25:30 +00:00
|
|
|
public List<DownloadDecision> GetRssDecision(List<ReleaseInfo> reports)
|
2013-04-07 07:30:37 +00:00
|
|
|
{
|
2019-10-31 03:46:40 +00:00
|
|
|
return GetDecisions(reports).ToList();
|
2013-04-07 07:30:37 +00:00
|
|
|
}
|
|
|
|
|
2013-09-13 23:25:30 +00:00
|
|
|
public List<DownloadDecision> GetSearchDecision(List<ReleaseInfo> reports, SearchCriteriaBase searchCriteriaBase)
|
2013-04-07 07:30:37 +00:00
|
|
|
{
|
2019-10-31 03:46:40 +00:00
|
|
|
return GetDecisions(reports, searchCriteriaBase).ToList();
|
2013-04-07 07:30:37 +00:00
|
|
|
}
|
|
|
|
|
2019-10-31 03:46:40 +00:00
|
|
|
private IEnumerable<DownloadDecision> GetDecisions(List<ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
|
2017-01-02 17:05:55 +00:00
|
|
|
{
|
|
|
|
if (reports.Any())
|
|
|
|
{
|
|
|
|
_logger.ProgressInfo("Processing {0} releases", reports.Count);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_logger.ProgressInfo("No results found");
|
|
|
|
}
|
|
|
|
|
|
|
|
var reportNumber = 1;
|
|
|
|
|
|
|
|
foreach (var report in reports)
|
|
|
|
{
|
|
|
|
DownloadDecision decision = null;
|
|
|
|
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
|
2022-10-18 01:10:23 +00:00
|
|
|
_logger.Debug("Processing release '{0}' from '{1}'", report.Title, report.Indexer);
|
2017-01-02 17:05:55 +00:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2019-12-22 22:08:53 +00:00
|
|
|
var parsedMovieInfo = _parsingService.ParseMovieInfo(report.Title, new List<object> { report });
|
2017-01-02 17:05:55 +00:00
|
|
|
|
2017-06-18 21:12:14 +00:00
|
|
|
MappingResult result = null;
|
|
|
|
|
2020-10-16 03:08:08 +00:00
|
|
|
if (parsedMovieInfo == null || parsedMovieInfo.PrimaryMovieTitle.IsNullOrWhiteSpace())
|
2017-06-18 21:12:14 +00:00
|
|
|
{
|
|
|
|
_logger.Debug("{0} could not be parsed :(.", report.Title);
|
|
|
|
parsedMovieInfo = new ParsedMovieInfo
|
|
|
|
{
|
2020-10-16 03:08:08 +00:00
|
|
|
MovieTitles = new List<string>() { report.Title },
|
2020-04-08 01:21:22 +00:00
|
|
|
SimpleReleaseTitle = report.Title.SimplifyReleaseTitle(),
|
2017-06-18 21:12:14 +00:00
|
|
|
Year = 1290,
|
2019-12-22 22:08:53 +00:00
|
|
|
Languages = new List<Language> { Language.Unknown },
|
2017-06-18 21:12:14 +00:00
|
|
|
Quality = new QualityModel(),
|
|
|
|
};
|
|
|
|
|
2020-04-08 16:54:05 +00:00
|
|
|
if (result == null)
|
2017-06-18 21:12:14 +00:00
|
|
|
{
|
2019-12-22 22:08:53 +00:00
|
|
|
result = new MappingResult { MappingResultType = MappingResultType.NotParsable };
|
2022-11-20 18:27:45 +00:00
|
|
|
result.Movie = null; // To ensure we have a remote movie, else null exception on next line!
|
2017-06-18 21:12:14 +00:00
|
|
|
result.RemoteMovie.ParsedMovieInfo = parsedMovieInfo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
result = _parsingService.Map(parsedMovieInfo, report.ImdbId.ToString(), searchCriteria);
|
|
|
|
}
|
2018-08-05 14:28:05 +00:00
|
|
|
|
2017-06-18 21:12:14 +00:00
|
|
|
result.ReleaseName = report.Title;
|
|
|
|
var remoteMovie = result.RemoteMovie;
|
2022-04-06 20:32:49 +00:00
|
|
|
remoteMovie.CustomFormats = _formatCalculator.ParseCustomFormat(parsedMovieInfo, result?.Movie);
|
2020-02-25 22:10:52 +00:00
|
|
|
remoteMovie.CustomFormatScore = remoteMovie?.Movie?.Profile?.CalculateCustomFormatScore(remoteMovie.CustomFormats) ?? 0;
|
2017-06-18 21:12:14 +00:00
|
|
|
remoteMovie.Release = report;
|
2017-08-09 20:14:01 +00:00
|
|
|
remoteMovie.MappingResult = result.MappingResultType;
|
2017-06-18 21:12:14 +00:00
|
|
|
|
2020-04-08 16:54:05 +00:00
|
|
|
if (result.MappingResultType != MappingResultType.Success)
|
2017-06-18 21:12:14 +00:00
|
|
|
{
|
|
|
|
var rejection = result.ToRejection();
|
|
|
|
decision = new DownloadDecision(remoteMovie, rejection);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (parsedMovieInfo.Quality.HardcodedSubs.IsNotNullOrWhiteSpace())
|
|
|
|
{
|
2022-11-20 18:27:45 +00:00
|
|
|
// remoteMovie.DownloadAllowed = true;
|
2017-06-18 21:12:14 +00:00
|
|
|
if (_configService.AllowHardcodedSubs)
|
|
|
|
{
|
|
|
|
decision = GetDecisionForReport(remoteMovie, searchCriteria);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
var whitelisted = _configService.WhitelistedHardcodedSubs.Split(',');
|
|
|
|
_logger.Debug("Testing: {0}", whitelisted);
|
|
|
|
if (whitelisted != null && whitelisted.Any(t => (parsedMovieInfo.Quality.HardcodedSubs.ToLower().Contains(t.ToLower()) && t.IsNotNullOrWhiteSpace())))
|
|
|
|
{
|
|
|
|
decision = GetDecisionForReport(remoteMovie, searchCriteria);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
decision = new DownloadDecision(remoteMovie, new Rejection("Hardcoded subs found: " + parsedMovieInfo.Quality.HardcodedSubs));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-10-31 03:46:40 +00:00
|
|
|
// _aggregationService.Augment(remoteMovie);
|
|
|
|
remoteMovie.DownloadAllowed = remoteMovie.Movie != null;
|
2017-06-18 21:12:14 +00:00
|
|
|
decision = GetDecisionForReport(remoteMovie, searchCriteria);
|
|
|
|
}
|
|
|
|
}
|
2017-01-02 17:05:55 +00:00
|
|
|
}
|
|
|
|
catch (Exception e)
|
|
|
|
{
|
|
|
|
_logger.Error(e, "Couldn't process release.");
|
|
|
|
|
2017-03-07 23:29:02 +00:00
|
|
|
var remoteMovie = new RemoteMovie { Release = report };
|
|
|
|
decision = new DownloadDecision(remoteMovie, new Rejection("Unexpected error processing release"));
|
2017-01-02 17:05:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
reportNumber++;
|
|
|
|
|
|
|
|
if (decision != null)
|
|
|
|
{
|
|
|
|
if (decision.Rejections.Any())
|
|
|
|
{
|
|
|
|
_logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_logger.Debug("Release accepted");
|
|
|
|
}
|
|
|
|
|
|
|
|
yield return decision;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-14 20:41:36 +00:00
|
|
|
private DownloadDecision GetDecisionForReport(RemoteMovie remoteMovie, SearchCriteriaBase searchCriteria = null)
|
2013-04-07 07:30:37 +00:00
|
|
|
{
|
2018-03-14 20:41:36 +00:00
|
|
|
var reasons = _specifications.Select(c => EvaluateSpec(c, remoteMovie, searchCriteria))
|
2014-06-08 08:22:55 +00:00
|
|
|
.Where(c => c != null);
|
2013-04-29 00:39:17 +00:00
|
|
|
|
2018-03-14 20:41:36 +00:00
|
|
|
return new DownloadDecision(remoteMovie, reasons.ToArray());
|
2013-04-07 07:30:37 +00:00
|
|
|
}
|
2017-01-06 14:05:30 +00:00
|
|
|
|
2017-03-07 23:29:02 +00:00
|
|
|
private Rejection EvaluateSpec(IDecisionEngineSpecification spec, RemoteMovie remoteMovie, SearchCriteriaBase searchCriteriaBase = null)
|
2017-01-06 14:05:30 +00:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2017-03-07 23:29:02 +00:00
|
|
|
var result = spec.IsSatisfiedBy(remoteMovie, searchCriteriaBase);
|
2017-01-06 14:05:30 +00:00
|
|
|
|
|
|
|
if (!result.Accepted)
|
|
|
|
{
|
|
|
|
return new Rejection(result.Reason, spec.Type);
|
|
|
|
}
|
|
|
|
}
|
2019-06-14 03:54:25 +00:00
|
|
|
catch (NotImplementedException)
|
2017-01-06 14:05:30 +00:00
|
|
|
{
|
2017-01-10 20:25:36 +00:00
|
|
|
_logger.Trace("Spec " + spec.GetType().Name + " does not care about movies.");
|
2017-01-06 14:05:30 +00:00
|
|
|
}
|
|
|
|
catch (Exception e)
|
|
|
|
{
|
2017-03-07 23:29:02 +00:00
|
|
|
e.Data.Add("report", remoteMovie.Release.ToJson());
|
|
|
|
e.Data.Add("parsed", remoteMovie.ParsedMovieInfo.ToJson());
|
2019-09-27 01:41:52 +00:00
|
|
|
_logger.Error(e, "Couldn't evaluate decision on {0}, with spec: {1}", remoteMovie.Release.Title, spec.GetType().Name);
|
|
|
|
return new Rejection($"{spec.GetType().Name}: {e.Message}");
|
2017-01-06 14:05:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
2013-04-07 07:30:37 +00:00
|
|
|
}
|
2013-09-13 23:17:58 +00:00
|
|
|
}
|