Moved DecisionEngine to root of core.

NzbDrone.Core/DecisionEngine/AcceptableSizeSpecification.cs

@@ -0,0 +1,76 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Providers;
+using NzbDrone.Core.Repository.Quality;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class AcceptableSizeSpecification
+    {
+        private readonly QualityTypeProvider _qualityTypeProvider;
+        private readonly EpisodeProvider _episodeProvider;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public AcceptableSizeSpecification(QualityTypeProvider qualityTypeProvider, EpisodeProvider episodeProvider)
+        {
+            _qualityTypeProvider = qualityTypeProvider;
+            _episodeProvider = episodeProvider;
+        }
+
+        public AcceptableSizeSpecification()
+        {
+            
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            logger.Trace("Beginning size check for: {0}", subject);
+
+            if(subject.Quality.Quality == QualityTypes.RAWHD)
+            {
+                logger.Trace("Raw-HD release found, skipping size check.");
+                return true;
+            }
+
+            var qualityType = _qualityTypeProvider.Get((int)subject.Quality.Quality);
+
+            if (qualityType.MaxSize == 0)
+            {
+                logger.Trace("Max size is 0 (unlimited) - skipping check.");
+                return true;
+            }
+
+            var maxSize = qualityType.MaxSize.Megabytes();
+            var series = subject.Series;
+
+            //Multiply maxSize by Series.Runtime
+            maxSize = maxSize * series.Runtime;
+
+            //Multiply maxSize by the number of episodes parsed (if EpisodeNumbers is null it will be treated as a single episode)
+            //TODO: is this check really necessary? shouldn't we blowup?
+            if (subject.EpisodeNumbers != null)
+                maxSize = maxSize * subject.EpisodeNumbers.Count;
+
+            //Check if there was only one episode parsed
+            //and it is the first or last episode of the season
+            if (subject.EpisodeNumbers != null && subject.EpisodeNumbers.Count == 1 &&
+                _episodeProvider.IsFirstOrLastEpisodeOfSeason(series.SeriesId,
+                subject.SeasonNumber, subject.EpisodeNumbers[0]))
+            {
+                maxSize = maxSize * 2;
+            }
+
+            //If the parsed size is greater than maxSize we don't want it
+            if (subject.Size > maxSize)
+            {
+                logger.Trace("Item: {0}, Size: {1} is greater than maximum allowed size ({2}), rejecting.", subject, subject.Size, maxSize);
+                return false;
+            }
+                
+            logger.Trace("Item: {0}, meets size contraints.", subject);
+            return true;
+        }
+       
+    }
+}

NzbDrone.Core/DecisionEngine/AllowedDownloadSpecification.cs

@@ -0,0 +1,55 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Repository.Search;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class AllowedDownloadSpecification
+    {
+        private readonly QualityAllowedByProfileSpecification _qualityAllowedByProfileSpecification;
+        private readonly UpgradeDiskSpecification _upgradeDiskSpecification;
+        private readonly AcceptableSizeSpecification _acceptableSizeSpecification;
+        private readonly AlreadyInQueueSpecification _alreadyInQueueSpecification;
+        private readonly RetentionSpecification _retentionSpecification;
+        private readonly AllowedReleaseGroupSpecification _allowedReleaseGroupSpecification;
+        private readonly CustomStartDateSpecification _customStartDateSpecification;
+        private readonly LanguageSpecification _languageSpecification;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public AllowedDownloadSpecification(QualityAllowedByProfileSpecification qualityAllowedByProfileSpecification,
+            UpgradeDiskSpecification upgradeDiskSpecification, AcceptableSizeSpecification acceptableSizeSpecification,
+            AlreadyInQueueSpecification alreadyInQueueSpecification, RetentionSpecification retentionSpecification,
+            AllowedReleaseGroupSpecification allowedReleaseGroupSpecification, CustomStartDateSpecification customStartDateSpecification,
+            LanguageSpecification languageSpecification)
+        {
+            _qualityAllowedByProfileSpecification = qualityAllowedByProfileSpecification;
+            _upgradeDiskSpecification = upgradeDiskSpecification;
+            _acceptableSizeSpecification = acceptableSizeSpecification;
+            _alreadyInQueueSpecification = alreadyInQueueSpecification;
+            _retentionSpecification = retentionSpecification;
+            _allowedReleaseGroupSpecification = allowedReleaseGroupSpecification;
+            _customStartDateSpecification = customStartDateSpecification;
+            _languageSpecification = languageSpecification;
+        }
+
+        public AllowedDownloadSpecification()
+        {
+        }
+
+        public virtual ReportRejectionType IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            if (!_qualityAllowedByProfileSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.QualityNotWanted;
+            if (!_customStartDateSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.AiredAfterCustomStartDate;
+            if (!_upgradeDiskSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.ExistingQualityIsEqualOrBetter;
+            if (!_languageSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.LanguageNotWanted;
+            if (!_retentionSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.Retention;
+            if (!_acceptableSizeSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.Size;
+            if (!_allowedReleaseGroupSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.ReleaseGroupNotWanted;
+            if (_alreadyInQueueSpecification.IsSatisfiedBy(subject)) return ReportRejectionType.AlreadyInQueue;
+            
+            logger.Debug("Episode {0} is needed", subject);
+            return ReportRejectionType.None;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/AllowedReleaseGroupSpecification.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Providers.Core;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class AllowedReleaseGroupSpecification
+    {
+        private readonly ConfigProvider _configProvider;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public AllowedReleaseGroupSpecification(ConfigProvider configProvider)
+        {
+            _configProvider = configProvider;
+        }
+
+        public AllowedReleaseGroupSpecification()
+        {
+            
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            logger.Trace("Beginning release group check for: {0}", subject);
+
+            var allowed = _configProvider.AllowedReleaseGroups;
+
+            if (string.IsNullOrWhiteSpace(allowed))
+                return true;
+
+            foreach(var group in allowed.Trim(',', ' ').Split(','))
+            {
+                if (subject.ReleaseGroup.Equals(group.Trim(' '), StringComparison.CurrentCultureIgnoreCase))
+                {
+                    logger.Trace("Item: {0}'s release group is wanted: {1}", subject, subject.ReleaseGroup);
+                    return true;
+                }
+            }
+            
+            logger.Trace("Item: {0}'s release group is not wanted: {1}", subject, subject.ReleaseGroup);
+            return false;
+        }    
+    }
+}

NzbDrone.Core/DecisionEngine/AlreadyInQueueSpecification.cs

@@ -0,0 +1,31 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Providers;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class AlreadyInQueueSpecification
+    {
+        private readonly DownloadProvider _downloadProvider;
+
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public AlreadyInQueueSpecification(DownloadProvider downloadProvider)
+        {
+            _downloadProvider = downloadProvider;
+
+        }
+
+        public AlreadyInQueueSpecification()
+        {
+            
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            return _downloadProvider.GetActiveDownloadClient().IsInQueue(subject);
+        }
+       
+    }
+}

NzbDrone.Core/DecisionEngine/CustomStartDateSpecification.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class CustomStartDateSpecification
+    {
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            if (!subject.Series.CustomStartDate.HasValue)
+            {
+                logger.Debug("{0} does not restrict downloads before date.", subject.Series.Title);
+                return true;
+            }
+
+            if (subject.Episodes.Any(episode => episode.AirDate >= subject.Series.CustomStartDate.Value))
+            {
+                logger.Debug("One or more episodes aired after cutoff, downloading.");
+                return true;
+            }
+
+            logger.Debug("Episodes aired before cutoff date: {0}", subject.Series.CustomStartDate);
+            return false;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/LanguageSpecification.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Providers.Core;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class LanguageSpecification
+    {
+        private readonly ConfigProvider _configProvider;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public LanguageSpecification(ConfigProvider configProvider)
+        {
+            _configProvider = configProvider;
+        }
+
+        public LanguageSpecification()
+        {
+            
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            logger.Trace("Checking if report meets language requirements. {0}", subject.Language);
+            if (subject.Language != LanguageType.English)
+            {
+                logger.Trace("Report Language: {0} rejected because it is not english", subject.Language);
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/MonitoredEpisodeSpecification.cs

@@ -0,0 +1,56 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Providers;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class MonitoredEpisodeSpecification
+    {
+        private readonly SeriesProvider _seriesProvider;
+        private readonly EpisodeProvider _episodeProvider;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public MonitoredEpisodeSpecification(SeriesProvider seriesProvider, EpisodeProvider episodeProvider)
+        {
+            _seriesProvider = seriesProvider;
+            _episodeProvider = episodeProvider;
+        }
+
+        public MonitoredEpisodeSpecification()
+        {
+            
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            var series = _seriesProvider.FindSeries(subject.CleanTitle);
+
+            if (series == null)
+            {
+                logger.Trace("{0} is not mapped to any series in DB. skipping", subject.CleanTitle);
+                return false;
+            }
+
+            subject.Series = series;
+
+            if (!series.Monitored)
+            {
+                logger.Debug("{0} is present in the DB but not tracked. skipping.", subject.CleanTitle);
+                return false;
+            }
+
+            var episodes = _episodeProvider.GetEpisodesByParseResult(subject);
+            subject.Episodes = episodes;
+
+            //return monitored if any of the episodes are monitored
+            if (episodes.Any(episode => !episode.Ignored))
+            {
+                return true;
+            }
+
+            logger.Debug("All episodes are ignored. skipping.");
+            return false;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/QualityAllowedByProfileSpecification.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class QualityAllowedByProfileSpecification
+    {
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            logger.Trace("Checking if report meets quality requirements. {0}", subject.Quality);
+            if (!subject.Series.QualityProfile.Allowed.Contains(subject.Quality.Quality))
+            {
+                logger.Trace("Quality {0} rejected by Series' quality profile", subject.Quality);
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/QualityUpgradeSpecification.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Repository.Quality;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class QualityUpgradeSpecification
+    {
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public virtual bool IsSatisfiedBy(QualityModel currentQuality, QualityModel newQuality, QualityTypes cutOff)
+        {
+            if (currentQuality >= newQuality)
+            {
+                logger.Trace("existing item has better or equal quality. skipping");
+                return false;
+            }
+
+            if (currentQuality.Quality == newQuality.Quality && newQuality.Proper)
+            {
+                logger.Trace("Upgrading existing item to proper.");
+                return true;
+            }
+
+            if (currentQuality.Quality >= cutOff)
+            {
+                logger.Trace("Existing item meets cut-off. skipping.");
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/RetentionSpecification.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Providers.Core;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class RetentionSpecification
+    {
+        private readonly ConfigProvider _configProvider;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public RetentionSpecification(ConfigProvider configProvider)
+        {
+            _configProvider = configProvider;
+        }
+
+        public RetentionSpecification()
+        {
+            
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            logger.Trace("Checking if report meets retention requirements. {0}", subject.Age);
+            if (_configProvider.Retention > 0 && subject.Age > _configProvider.Retention)
+            {
+                logger.Trace("Report age: {0} rejected by user's retention limit", subject.Age);
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/UpgradeDiskSpecification.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class UpgradeDiskSpecification
+    {
+        private readonly QualityUpgradeSpecification _qualityUpgradeSpecification;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public UpgradeDiskSpecification(QualityUpgradeSpecification qualityUpgradeSpecification)
+        {
+            _qualityUpgradeSpecification = qualityUpgradeSpecification;
+        }
+
+        public UpgradeDiskSpecification()
+        {
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            foreach (var file in subject.Episodes.Select(c => c.EpisodeFile).Where(c => c != null))
+            {
+                logger.Trace("Comparing file quality with report. Existing file is {0} proper:{1}", file.Quality, file.Proper);
+                if (!_qualityUpgradeSpecification.IsSatisfiedBy(new QualityModel { Quality = file.Quality, Proper = file.Proper }, subject.Quality, subject.Series.QualityProfile.Cutoff))
+                    return false;
+
+                if(subject.Quality.Proper && file.DateAdded < DateTime.Today.AddDays(-7))
+                {
+                    logger.Trace("Proper for old file, skipping: {0}", subject);
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/UpgradeHistorySpecification.cs

@@ -0,0 +1,43 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Providers;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class UpgradeHistorySpecification
+    {
+        private readonly EpisodeProvider _episodeProvider;
+        private readonly HistoryProvider _historyProvider;
+        private readonly QualityUpgradeSpecification _qualityUpgradeSpecification;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public UpgradeHistorySpecification(EpisodeProvider episodeProvider, HistoryProvider historyProvider, QualityUpgradeSpecification qualityUpgradeSpecification)
+        {
+            _episodeProvider = episodeProvider;
+            _historyProvider = historyProvider;
+            _qualityUpgradeSpecification = qualityUpgradeSpecification;
+        }
+
+        public UpgradeHistorySpecification()
+        {
+
+        }
+
+        public virtual bool IsSatisfiedBy(EpisodeParseResult subject)
+        {
+            foreach (var episode in subject.Episodes)
+            {
+                var bestQualityInHistory = _historyProvider.GetBestQualityInHistory(subject.Series.SeriesId, episode.SeasonNumber, episode.EpisodeNumber);
+                if (bestQualityInHistory != null)
+                {
+                    logger.Trace("Comparing history quality with report. History is {0}", bestQualityInHistory);
+                    if (!_qualityUpgradeSpecification.IsSatisfiedBy(bestQualityInHistory, subject.Quality, subject.Series.QualityProfile.Cutoff))
+                        return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

NzbDrone.Core/DecisionEngine/UpgradePossibleSpecification.cs

@@ -0,0 +1,39 @@
+using System.Linq;
+using NLog;
+using NzbDrone.Core.Providers;
+using NzbDrone.Core.Repository;
+
+namespace NzbDrone.Core.DecisionEngine
+{
+    public class UpgradePossibleSpecification
+    {
+        private readonly QualityProvider _qualityProvider;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public UpgradePossibleSpecification(QualityProvider qualityProvider)
+        {
+            _qualityProvider = qualityProvider;
+        }
+
+        public UpgradePossibleSpecification()
+        {
+            
+        }
+
+        public virtual bool IsSatisfiedBy(Episode subject)
+        {
+            //Used to check if the existing episode can be upgraded by searching (Before we search)
+            if (subject.EpisodeFileId == 0)
+                return true;
+
+            var profile = _qualityProvider.Get(subject.Series.QualityProfileId);
+
+
+            //TODO:How about proper?
+            if (subject.EpisodeFile.Quality >= profile.Cutoff)
+                return false;
+
+            return true; ;
+        }
+    }
+}