public virtual bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { _logger.Debug("Checking if release contains any restricted terms: {0}", subject); var restrictionsString = _configService.ReleaseRestrictions; if (String.IsNullOrWhiteSpace(restrictionsString)) { _logger.Debug("No restrictions configured, allowing: {0}", subject); return true; } var restrictions = restrictionsString.Split(new []{ '\n' }, StringSplitOptions.RemoveEmptyEntries); foreach (var restriction in restrictions) { if (subject.Release.Title.ToLowerInvariant().Contains(restriction.ToLowerInvariant())) { _logger.Debug("{0} is restricted: {1}", subject, restriction); return false; } } _logger.Debug("No restrictions apply, allowing: {0}", subject); return true; }
private DownloadDecision GetDecisionForReport(RemoteEpisode remoteEpisode, SearchCriteriaBase searchCriteria = null) { var reasons = _specifications.Select(c => EvaluateSpec(c, remoteEpisode, searchCriteria)) .Where(c => c != null); return new DownloadDecision(remoteEpisode, reasons.ToArray()); }
public virtual bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (searchCriteria != null) { return true; } foreach (var file in subject.Episodes.Where(c => c.EpisodeFileId != 0).Select(c => c.EpisodeFile.Value)) { if (_qualityUpgradableSpecification.IsProperUpgrade(file.Quality, subject.ParsedEpisodeInfo.Quality)) { if (file.DateAdded < DateTime.Today.AddDays(-7)) { _logger.Trace("Proper for old file, rejecting: {0}", subject); return false; } if (!_configService.AutoDownloadPropers) { _logger.Trace("Auto downloading of propers is disabled"); return false; } } } return true; }
public List<Episode> GetEpisodes(ParsedEpisodeInfo parsedEpisodeInfo, Series series, bool sceneSource, SearchCriteriaBase searchCriteria = null) { if (parsedEpisodeInfo.FullSeason) { return _episodeService.GetEpisodesBySeason(series.Id, parsedEpisodeInfo.SeasonNumber); } if (parsedEpisodeInfo.IsDaily) { if (series.SeriesType == SeriesTypes.Standard) { _logger.Warn("Found daily-style episode for non-daily series: {0}.", series); return new List<Episode>(); } var episodeInfo = GetDailyEpisode(series, parsedEpisodeInfo.AirDate, searchCriteria); if (episodeInfo != null) { return new List<Episode> { episodeInfo }; } return new List<Episode>(); } if (parsedEpisodeInfo.IsAbsoluteNumbering) { return GetAnimeEpisodes(series, parsedEpisodeInfo, sceneSource); } return GetStandardEpisodes(series, parsedEpisodeInfo, sceneSource, searchCriteria); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var releaseGroup = subject.ParsedEpisodeInfo.ReleaseGroup; if (subject.Series.SeriesType != SeriesTypes.Anime) { return Decision.Accept(); } foreach (var file in subject.Episodes.Where(c => c.EpisodeFileId != 0).Select(c => c.EpisodeFile.Value)) { if (_qualityUpgradableSpecification.IsRevisionUpgrade(file.Quality, subject.ParsedEpisodeInfo.Quality)) { if (file.ReleaseGroup.IsNullOrWhiteSpace()) { _logger.Debug("Unable to compare release group, existing file's release group is unknown"); return Decision.Reject("Existing release group is unknown"); } if (releaseGroup.IsNullOrWhiteSpace()) { _logger.Debug("Unable to compare release group, release's release group is unknown"); return Decision.Reject("Release group is unknown"); } if (file.ReleaseGroup != releaseGroup) { _logger.Debug("Existing Release group is: {0} - release's release group is: {1}", file.ReleaseGroup, releaseGroup); return Decision.Reject("{0} does not match existing release group {1}", releaseGroup, file.ReleaseGroup); } } } return Decision.Accept(); }
public Decision IsSatisfiedBy(RemoteEpisode remoteEpisode, SearchCriteriaBase searchCriteria) { if (searchCriteria == null) { return Decision.Accept(); } var singleEpisodeSpec = searchCriteria as SingleEpisodeSearchCriteria; if (singleEpisodeSpec == null) return Decision.Accept(); if (singleEpisodeSpec.SeasonNumber != remoteEpisode.ParsedEpisodeInfo.SeasonNumber) { _logger.Debug("Season number does not match searched season number, skipping."); return Decision.Reject("Wrong season"); } if (!remoteEpisode.ParsedEpisodeInfo.EpisodeNumbers.Any()) { _logger.Debug("Full season result during single episode search, skipping."); return Decision.Reject("Full season pack"); } if (!remoteEpisode.ParsedEpisodeInfo.EpisodeNumbers.Contains(singleEpisodeSpec.EpisodeNumber)) { _logger.Debug("Episode number does not match searched episode number, skipping."); return Decision.Reject("Wrong episode"); } return Decision.Accept(); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (searchCriteria != null) { if (!searchCriteria.MonitoredEpisodesOnly) { _logger.Debug("Skipping monitored check during search"); return Decision.Accept(); } } if (!subject.Series.Monitored) { _logger.Debug("{0} is present in the DB but not tracked. skipping.", subject.Series); return Decision.Reject("Series is not monitored"); } var monitoredCount = subject.Episodes.Count(episode => episode.Monitored); if (monitoredCount == subject.Episodes.Count) { return Decision.Accept(); } _logger.Debug("Only {0}/{1} episodes are monitored. skipping.", monitoredCount, subject.Episodes.Count); return Decision.Reject("Episode is not monitored"); }
private string EvaluateSpec(IRejectWithReason spec, RemoteEpisode remoteEpisode, SearchCriteriaBase searchCriteriaBase = null) { try { if (string.IsNullOrWhiteSpace(spec.RejectionReason)) { throw new InvalidOperationException("[Need Rejection Text]"); } var generalSpecification = spec as IDecisionEngineSpecification; if (generalSpecification != null && !generalSpecification.IsSatisfiedBy(remoteEpisode, searchCriteriaBase)) { return spec.RejectionReason; } } catch (Exception e) { e.Data.Add("report", remoteEpisode.Release.ToJson()); e.Data.Add("parsed", remoteEpisode.ParsedEpisodeInfo.ToJson()); _logger.ErrorException("Couldn't evaluate decision on " + remoteEpisode.Release.Title, e); return string.Format("{0}: {1}", spec.GetType().Name, e.Message); } return null; }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (subject.Release.DownloadProtocol != Indexers.DownloadProtocol.Usenet) { _logger.Debug("Not checking minimum age requirement for non-usenet report"); return Decision.Accept(); } var age = subject.Release.AgeMinutes; var minimumAge = _configService.MinimumAge; if (minimumAge == 0) { _logger.Debug("Minimum age is not set."); return Decision.Accept(); } _logger.Debug("Checking if report meets minimum age requirements. {0}", age); if (age < minimumAge) { _logger.Debug("Only {0} minutes old, minimum age is {1} minutes", age, minimumAge); return Decision.Reject("Only {0} minutes old, minimum age is {1} minutes", age, minimumAge); } _logger.Debug("Release is {0} minutes old, greater than minimum age of {1} minutes", age, minimumAge); return Decision.Accept(); }
public Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var queue = _queueService.GetQueue() .Select(q => q.RemoteEpisode).ToList(); var matchingSeries = queue.Where(q => q.Series.Id == subject.Series.Id); var matchingEpisode = matchingSeries.Where(q => q.Episodes.Select(e => e.Id).Intersect(subject.Episodes.Select(e => e.Id)).Any()); foreach (var remoteEpisode in matchingEpisode) { _logger.Debug("Checking if existing release in queue meets cutoff. Queued quality is: {0}", remoteEpisode.ParsedEpisodeInfo.Quality); if (!_qualityUpgradableSpecification.CutoffNotMet(subject.Series.Profile, remoteEpisode.ParsedEpisodeInfo.Quality, subject.ParsedEpisodeInfo.Quality)) { return Decision.Reject("Quality for release in queue already meets cutoff: {0}", remoteEpisode.ParsedEpisodeInfo.Quality); } _logger.Debug("Checking if release is higher quality than queued release. Queued quality is: {0}", remoteEpisode.ParsedEpisodeInfo.Quality); if (!_qualityUpgradableSpecification.IsUpgradable(subject.Series.Profile, remoteEpisode.ParsedEpisodeInfo.Quality, subject.ParsedEpisodeInfo.Quality)) { return Decision.Reject("Quality for release in queue is of equal or higher preference: {0}", remoteEpisode.ParsedEpisodeInfo.Quality); } } return Decision.Accept(); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { _logger.Debug("Checking if release meets restrictions: {0}", subject); var title = subject.Release.Title; var restrictions = _restrictionService.AllForTags(subject.Series.Tags); var required = restrictions.Where(r => r.Required.IsNotNullOrWhiteSpace()); var ignored = restrictions.Where(r => r.Ignored.IsNotNullOrWhiteSpace()); foreach (var r in required) { var split = r.Required.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries).ToList(); if (!ContainsAny(split, title)) { _logger.Debug("[{0}] does not contain one of the required terms: {1}", title, r.Required); return Decision.Reject("Does not contain one of the required terms: {0}", r.Required.Replace(",", ", ")); } } foreach (var r in ignored) { var split = r.Ignored.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList(); if (ContainsAny(split, title)) { _logger.Debug("[{0}] contains one or more ignored terms: {1}", title, r.Ignored); return Decision.Reject("Contains one or more ignored terms: {0}", r.Ignored.Replace(",", ", ")); } } _logger.Debug("[{0}] No restrictions apply, allowing", subject); return Decision.Accept(); }
public virtual bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { _logger.Debug("Beginning size check for: {0}", subject); var quality = subject.ParsedEpisodeInfo.Quality.Quality; if (quality == Quality.RAWHD) { _logger.Debug("Raw-HD release found, skipping size check."); return true; } if (quality == Quality.Unknown) { _logger.Debug("Unknown quality. skipping size check."); return false; } var qualityDefinition = _qualityDefinitionService.Get(quality); var minSize = qualityDefinition.MinSize.Megabytes(); //Multiply maxSize by Series.Runtime minSize = minSize * subject.Series.Runtime * subject.Episodes.Count; //If the parsed size is smaller than minSize we don't want it if (subject.Release.Size < minSize) { _logger.Debug("Item: {0}, Size: {1} is smaller than minimum allowed size ({2}), rejecting.", subject, subject.Release.Size, minSize); return false; } if (qualityDefinition.MaxSize == 0) { _logger.Debug("Max size is 0 (unlimited) - skipping check."); } else { var maxSize = qualityDefinition.MaxSize.Megabytes(); //Multiply maxSize by Series.Runtime maxSize = maxSize * subject.Series.Runtime * subject.Episodes.Count; //Check if there was only one episode parsed and it is the first if (subject.Episodes.Count == 1 && _episodeService.IsFirstOrLastEpisodeOfSeason(subject.Episodes.First().Id)) { maxSize = maxSize * 2; } //If the parsed size is greater than maxSize we don't want it if (subject.Release.Size > maxSize) { _logger.Debug("Item: {0}, Size: {1} is greater than maximum allowed size ({2}), rejecting.", subject, subject.Release.Size, maxSize); return false; } } _logger.Debug("Item: {0}, meets size constraints.", subject); return true; }
public bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (subject.Release.Title.ToLower().Contains("sample") && subject.Release.Size < 70.Megabytes()) { return false; } return true; }
public Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (_blacklistService.Blacklisted(subject.Series.Id, subject.Release)) { _logger.Debug("{0} is blacklisted, rejecting.", subject.Release.Title); return Decision.Reject("Release is blacklisted"); } return Decision.Accept(); }
public Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (subject.Release.Title.ToLower().Contains("sample") && subject.Release.Size < 70.Megabytes()) { _logger.Debug("Sample release, rejecting."); return Decision.Reject("Sample"); } return Decision.Accept(); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (_sameEpisodesSpecification.IsSatisfiedBy(subject.Episodes)) { return Decision.Accept(); } _logger.Debug("Episode file on disk contains more episodes than this release contains"); return Decision.Reject("Episode file on disk contains more episodes than this release contains"); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { _logger.Debug("Checking if report meets quality requirements. {0}", subject.ParsedEpisodeInfo.Quality); if (!subject.Series.Profile.Value.Items.Exists(v => v.Allowed && v.Quality == subject.ParsedEpisodeInfo.Quality.Quality)) { _logger.Debug("Quality {0} rejected by Series' quality profile", subject.ParsedEpisodeInfo.Quality); return Decision.Reject("{0} is not wanted in profile", subject.ParsedEpisodeInfo.Quality.Quality); } return Decision.Accept(); }
public virtual bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { _logger.Trace("Checking if report meets quality requirements. {0}", subject.ParsedEpisodeInfo.Quality); if (!subject.Series.QualityProfile.Value.Allowed.Contains(subject.ParsedEpisodeInfo.Quality.Quality)) { _logger.Trace("Quality {0} rejected by Series' quality profile", subject.ParsedEpisodeInfo.Quality); return false; } return true; }
public virtual bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { _logger.Debug("Checking if report meets language requirements. {0}", subject.ParsedEpisodeInfo.Language); if (subject.ParsedEpisodeInfo.Language != Language.English) { _logger.Debug("Report Language: {0} rejected because it is not English", subject.ParsedEpisodeInfo.Language); return false; } return true; }
private IEnumerable<DownloadDecision> GetDecisions(List<ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null) { if (reports.Any()) { _logger.ProgressInfo("Processing {0} reports", reports.Count); } else { _logger.ProgressInfo("No reports found"); } var reportNumber = 1; foreach (var report in reports) { DownloadDecision decision = null; _logger.ProgressTrace("Processing report {0}/{1}", reportNumber, reports.Count); try { var parsedEpisodeInfo = Parser.Parser.ParseTitle(report.Title); if (parsedEpisodeInfo != null && !string.IsNullOrWhiteSpace(parsedEpisodeInfo.SeriesTitle)) { var remoteEpisode = _parsingService.Map(parsedEpisodeInfo, report.TvRageId, searchCriteria); remoteEpisode.Release = report; if (remoteEpisode.Series != null) { remoteEpisode.DownloadAllowed = true; decision = GetDecisionForReport(remoteEpisode, searchCriteria); } else { decision = new DownloadDecision(remoteEpisode, "Unknown Series"); } } } catch (Exception e) { _logger.ErrorException("Couldn't process report.", e); } reportNumber++; if (decision != null) { yield return decision; } } }
public bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var queue = _queueService.GetQueue().Select(q => q.RemoteEpisode); if (IsInQueue(subject, queue)) { _logger.Debug("Already in queue, rejecting."); return false; } return true; }
public virtual bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var age = subject.Release.Age; _logger.Trace("Checking if report meets retention requirements. {0}", age); if (_configService.Retention > 0 && age > _configService.Retention) { _logger.Trace("Report age: {0} rejected by user's retention limit", age); return false; } return true; }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (searchCriteria != null) { _logger.Debug("Skipping history check during search"); return Decision.Accept(); } var cdhEnabled = _configService.EnableCompletedDownloadHandling; _logger.Debug("Performing history status check on report"); foreach (var episode in subject.Episodes) { _logger.Debug("Checking current status of episode [{0}] in history", episode.Id); var mostRecent = _historyService.MostRecentForEpisode(episode.Id); if (mostRecent != null && mostRecent.EventType == HistoryEventType.Grabbed) { var recent = mostRecent.Date.After(DateTime.UtcNow.AddHours(-12)); var cutoffUnmet = _qualityUpgradableSpecification.CutoffNotMet(subject.Series.Profile, mostRecent.Quality, subject.ParsedEpisodeInfo.Quality); var upgradeable = _qualityUpgradableSpecification.IsUpgradable(subject.Series.Profile, mostRecent.Quality, subject.ParsedEpisodeInfo.Quality); if (!recent && cdhEnabled) { continue; } if (!cutoffUnmet) { if (recent) { return Decision.Reject("Recent grab event in history already meets cutoff: {0}", mostRecent.Quality); } return Decision.Reject("CDH is disabled and grab event in history already meets cutoff: {0}", mostRecent.Quality); } if (!upgradeable) { if (recent) { return Decision.Reject("Recent grab event in history is of equal or higher quality: {0}", mostRecent.Quality); } return Decision.Reject("CDH is disabled and grab event in history is of equal or higher quality: {0}", mostRecent.Quality); } } } return Decision.Accept(); }
public bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var downloadClient = _downloadClientProvider.GetDownloadClient(); if (!downloadClient.IsConfigured) { _logger.Warn("Download client {0} isn't configured yet.", downloadClient.GetType().Name); return true; } var queue = downloadClient.GetQueue().Select(q => q.RemoteEpisode); return !IsInQueue(subject, queue); }
public virtual bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { foreach (var file in subject.Episodes.Where(c => c.EpisodeFileId != 0).Select(c => c.EpisodeFile.Value)) { _logger.Trace("Comparing file quality with report. Existing file is {0}", file.Quality); if (!_qualityUpgradableSpecification.IsUpgradable(file.Quality, subject.ParsedEpisodeInfo.Quality)) { return false; } } return true; }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { foreach (var file in subject.Episodes.Where(c => c.EpisodeFileId != 0).Select(c => c.EpisodeFile.Value)) { _logger.Debug("Comparing file quality with report. Existing file is {0}", file.Quality); if (!_qualityUpgradableSpecification.IsUpgradable(subject.Series.Profile, file.Quality, subject.ParsedEpisodeInfo.Quality)) { return Decision.Reject("Quality for existing file on disk is of equal or higher preference: {0}", file.Quality); } } return Decision.Accept(); }
public bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var queue = _downloadTrackingService.GetQueuedDownloads() .Where(v => v.State == TrackedDownloadState.Downloading) .Select(q => q.DownloadItem.RemoteEpisode).ToList(); if (IsInQueue(subject, queue)) { _logger.Debug("Already in queue, rejecting."); return false; } return true; }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var wantedLanguage = subject.Series.Profile.Value.Language; _logger.Debug("Checking if report meets language requirements. {0}", subject.ParsedEpisodeInfo.Language); if (subject.ParsedEpisodeInfo.Language != wantedLanguage) { _logger.Debug("Report Language: {0} rejected because it is not wanted, wanted {1}", subject.ParsedEpisodeInfo.Language, wantedLanguage); return Decision.Reject("{0} is wanted, but found {1}", wantedLanguage, subject.ParsedEpisodeInfo.Language); } return Decision.Accept(); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (subject.ParsedEpisodeInfo.FullSeason) { _logger.Debug("Checking if all episodes in full season release have aired. {0}", subject.Release.Title); if (subject.Episodes.Any(e => !e.AirDateUtc.HasValue || e.AirDateUtc.Value.After(DateTime.UtcNow))) { _logger.Debug("Full season release {0} rejected. All episodes haven't aired yet.", subject.Release.Title); return Decision.Reject("Full season release rejected. All episodes haven't aired yet."); } } return Decision.Accept(); }
public bool IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (!_configService.EnableFailedDownloadHandling) { _logger.Debug("Failed Download Handling is not enabled"); return true; } if (_blacklistService.Blacklisted(subject.Series.Id, subject.Release.Title, subject.Release.PublishDate)) { _logger.Debug("{0} is blacklisted, rejecting.", subject.Release.Title); return false; } return true; }