public virtual Decision IsSatisfiedBy(RemoteBook subject, SearchCriteriaBase searchCriteria) { var qualityProfile = subject.Author.QualityProfile.Value; foreach (var file in subject.Books.SelectMany(b => b.BookFiles.Value)) { // Get a distinct list of all current track qualities for a given book var currentQualities = new List <QualityModel> { file.Quality }; _logger.Debug("Comparing file quality with report. Existing files contain {0}", currentQualities.ConcatToString()); if (!_upgradableSpecification.CutoffNotMet(qualityProfile, currentQualities, _preferredWordServiceCalculator.Calculate(subject.Author, file.GetSceneOrFileName()), subject.ParsedBookInfo.Quality, subject.PreferredWordScore)) { _logger.Debug("Cutoff already met by existing files, rejecting."); var qualityCutoffIndex = qualityProfile.GetIndex(qualityProfile.Cutoff); var qualityCutoff = qualityProfile.Items[qualityCutoffIndex.Index]; return(Decision.Reject("Existing files meets cutoff: {0}", qualityCutoff)); } } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (searchCriteria != null) { if ((searchCriteria as SeasonSearchCriteria) == null) { _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); return(Decision.Reject("Episode is not monitored")); }
public Decision IsSatisfiedBy(LocalAlbumRelease localAlbumRelease) { var artist = localAlbumRelease.AlbumRelease.Album.Value.Artist.Value; var qualityComparer = new QualityModelComparer(artist.QualityProfile); // check if we are changing release var currentRelease = localAlbumRelease.AlbumRelease.Album.Value.AlbumReleases.Value.Single(x => x.Monitored); var newRelease = localAlbumRelease.AlbumRelease; // if we are, check we are upgrading if (newRelease.Id != currentRelease.Id) { // min quality of all new tracks var newMinQuality = localAlbumRelease.LocalTracks.Select(x => x.Quality).OrderBy(x => x, qualityComparer).First(); _logger.Debug("Min quality of new files: {0}", newMinQuality); // get minimum quality of existing release var existingQualities = currentRelease.Tracks.Value.Where(x => x.TrackFileId != 0).Select(x => x.TrackFile.Value.Quality); if (existingQualities.Any()) { var existingMinQuality = existingQualities.OrderBy(x => x, qualityComparer).First(); _logger.Debug("Min quality of existing files: {0}", existingMinQuality); if (qualityComparer.Compare(existingMinQuality, newMinQuality) > 0) { _logger.Debug("This album isn't a quality upgrade for all tracks. Skipping {0}", localAlbumRelease); return(Decision.Reject("Not an upgrade for existing album file(s)")); } } } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria) { if (subject.Release == null) { return(Decision.Accept()); } foreach (var regex in DiscRegex) { if (regex.IsMatch(subject.Release.Title)) { _logger.Debug("Release contains raw Bluray, rejecting."); return(Decision.Reject("Raw Bluray release")); } } if (subject.Release.Container.IsNullOrWhiteSpace()) { return(Decision.Accept()); } if (_dvdContainerTypes.Contains(subject.Release.Container.ToLower())) { _logger.Debug("Release contains raw DVD, rejecting."); return(Decision.Reject("Raw DVD release")); } if (_blurayContainerTypes.Contains(subject.Release.Container.ToLower())) { _logger.Debug("Release contains raw Bluray, rejecting."); return(Decision.Reject("Raw Bluray release")); } return(Decision.Accept()); }
public Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria) { var queue = _queueService.GetQueue() .Select(q => q.RemoteMovie).ToList(); var matchingSeries = queue.Where(q => q.Movie.Id == subject.Movie.Id); foreach (var remoteEpisode in matchingSeries) { _logger.Debug("Checking if existing release in queue meets cutoff. Queued quality is: {0}", remoteEpisode.ParsedMovieInfo.Quality); if (!_qualityUpgradableSpecification.CutoffNotMet(subject.Movie.Profile, remoteEpisode.ParsedMovieInfo.Quality, subject.ParsedMovieInfo.Quality)) { return(Decision.Reject("Quality for release in queue already meets cutoff: {0}", remoteEpisode.ParsedMovieInfo.Quality)); } _logger.Debug("Checking if release is higher quality than queued release. Queued quality is: {0}", remoteEpisode.ParsedMovieInfo.Quality); if (!_qualityUpgradableSpecification.IsUpgradable(subject.Movie.Profile, remoteEpisode.ParsedMovieInfo.Quality, subject.ParsedMovieInfo.Quality)) { return(Decision.Reject("Quality for release in queue is of equal or higher preference: {0}", remoteEpisode.ParsedMovieInfo.Quality)); } } return(Decision.Accept()); }
public Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria) { var torrentInfo = subject.Release as TorrentInfo; IIndexerSettings indexerSettings = null; try { indexerSettings = _indexerFactory.Get(subject.Release.IndexerId)?.Settings as IIndexerSettings; } catch (Exception e) { _logger.Debug("Indexer with id {0} does not exist, skipping minimum seeder checks.", subject.Release.IndexerId); } if (torrentInfo == null || indexerSettings == null) { return(Decision.Accept()); } if (indexerSettings is ITorrentIndexerSettings torrentIndexerSettings) { var minimumSeeders = torrentIndexerSettings.MinimumSeeders; if (torrentInfo.Seeders.HasValue && torrentInfo.Seeders.Value < minimumSeeders) { _logger.Debug("Not enough seeders: {0}. Minimum seeders: {1}", torrentInfo.Seeders, minimumSeeders); return(Decision.Reject("Not enough seeders: {0}. Minimum seeders: {1}", torrentInfo.Seeders, minimumSeeders)); } } return(Decision.Accept()); }
public Decision IsSatisfiedBy(LocalEpisode localEpisode, DownloadClientItem downloadClientItem) { if (downloadClientItem == null) { _logger.Debug("No download client item provided, skipping."); return(Decision.Accept()); } var grabbedHistory = _historyService.FindByDownloadId(downloadClientItem.DownloadId) .Where(h => h.EventType == HistoryEventType.Grabbed) .ToList(); if (grabbedHistory.Empty()) { _logger.Debug("No grabbed history for this download client item"); return(Decision.Accept()); } foreach (var item in grabbedHistory) { if (item.Quality != localEpisode.Quality) { _logger.Debug("Quality for grabbed release ({0}) does not match the quality of the file ({1})", item.Quality, localEpisode.Quality); return(Decision.Reject("File quality does not match quality of the grabbed release")); } } return(Decision.Accept()); }
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 virtual Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria) { var profile = subject.Movie.Profile; var file = subject.Movie.MovieFile; if (file != null) { file.Movie = subject.Movie; _logger.Debug("Comparing file quality with report. Existing file is {0}", file.Quality); var customFormats = _formatService.ParseCustomFormat(file); if (!_upgradableSpecification.CutoffNotMet(profile, file.Quality, customFormats, subject.ParsedMovieInfo.Quality)) { _logger.Debug("Existing custom formats {0} meet cutoff", customFormats.ConcatToString()); var qualityCutoffIndex = profile.GetIndex(profile.Cutoff); var qualityCutoff = profile.Items[qualityCutoffIndex.Index]; return(Decision.Reject("Existing file meets cutoff: {0}", qualityCutoff)); } } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria) { if (subject.Release == null || subject.Movie?.Tags == null || subject.Release.IndexerId == 0) { return(Decision.Accept()); } IndexerDefinition indexer; try { indexer = _indexerFactory.Get(subject.Release.IndexerId); } catch (ModelNotFoundException) { _logger.Debug("Indexer with id {0} does not exist, skipping indexer tags check", subject.Release.IndexerId); return(Decision.Accept()); } // If indexer has tags, check that at least one of them is present on the series var indexerTags = indexer.Tags; if (indexerTags.Any() && indexerTags.Intersect(subject.Movie.Tags).Empty()) { _logger.Debug("Indexer {0} has tags. None of these are present on movie {1}. Rejecting", subject.Release.Indexer, subject.Movie); return(Decision.Reject("Movie tags do not match any of the indexer tags")); } return(Decision.Accept()); }
public Decision IsSatisfiedBy(LocalMovie localMovie, DownloadClientItem downloadClientItem) { if (localMovie.ExistingFile) { return(Decision.Accept()); } var dirInfo = new FileInfo(localMovie.Path).Directory; if (dirInfo == null) { return(Decision.Accept()); } //TODO: Actually implement this!!!! /*var folderInfo = Parser.Parser.ParseMovieTitle(dirInfo.Name, false); * * if (folderInfo == null) * { * return Decision.Accept(); * }*/ return(Decision.Accept()); }
public Decision IsSatisfiedBy(LocalMovie localMovie, DownloadClientItem downloadClientItem) { if (localMovie.ExistingFile) { _logger.Debug("{0} is in movie folder, skipping unpacking check", localMovie.Path); return(Decision.Accept()); } foreach (var workingFolder in _configService.DownloadClientWorkingFolders.Split('|')) { DirectoryInfo parent = Directory.GetParent(localMovie.Path); while (parent != null) { if (parent.Name.StartsWith(workingFolder)) { if (OsInfo.IsNotWindows) { _logger.Debug("{0} is still being unpacked", localMovie.Path); return(Decision.Reject("File is still being unpacked")); } if (_diskProvider.FileGetLastWrite(localMovie.Path) > DateTime.UtcNow.AddMinutes(-5)) { _logger.Debug("{0} appears to be unpacking still", localMovie.Path); return(Decision.Reject("File is still being unpacked")); } } parent = parent.Parent; } } return(Decision.Accept()); }
public Decision IsSatisfiedBy(LocalEpisode localEpisode, DownloadClientItem downloadClientItem) { var episodeFiles = localEpisode.Episodes.Where(e => e.EpisodeFileId != 0).Select(e => e.EpisodeFile).ToList(); if (episodeFiles.Count == 0) { _logger.Debug("No existing episode file, skipping"); return(Decision.Accept()); } if (episodeFiles.Count > 1) { _logger.Debug("More than one existing episode file, skipping."); return(Decision.Accept()); } var episodeFile = episodeFiles.First().Value; if (episodeFile == null) { var episode = localEpisode.Episodes.First(); _logger.Trace("Unable to get episode file details from the DB. EpisodeId: {0} EpisodeFileId: {1}", episode.Id, episode.EpisodeFileId); return(Decision.Accept()); } if (episodeFiles.First().Value.Size == localEpisode.Size) { _logger.Debug("'{0}' Has the same filesize as existing file", localEpisode.Path); return(Decision.Reject("Has the same filesize as existing file")); } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteBook subject, SearchCriteriaBase searchCriteria) { var qualityProfile = subject.Author.QualityProfile.Value; foreach (var file in subject.Books.SelectMany(b => b.BookFiles.Value)) { if (file == null) { _logger.Debug("File is no longer available, skipping this file."); continue; } _logger.Debug("Comparing file quality with report. Existing files contain {0}", file.Quality); if (!_upgradableSpecification.IsUpgradeAllowed(qualityProfile, file.Quality, subject.ParsedBookInfo.Quality)) { _logger.Debug("Upgrading is not allowed by the quality profile"); return(Decision.Reject("Existing files and the Quality profile does not allow upgrades")); } } return(Decision.Accept()); }
public Decision IsSatisfiedBy(LocalTrack localTrack, DownloadClientItem downloadClientItem) { var trackFiles = localTrack.Tracks.Where(e => e.TrackFileId != 0).Select(e => e.TrackFile).ToList(); if (trackFiles.Count == 0) { _logger.Debug("No existing track file, skipping"); return(Decision.Accept()); } if (trackFiles.Count > 1) { _logger.Debug("More than one existing track file, skipping."); return(Decision.Accept()); } var trackFile = trackFiles.First().Value; if (trackFile == null) { var track = localTrack.Tracks.First(); _logger.Trace("Unable to get track file details from the DB. TrackId: {0} TrackFileId: {1}", track.Id, track.TrackFileId); return(Decision.Accept()); } if (trackFiles.First().Value.Size == localTrack.Size) { _logger.Debug("'{0}' Has the same filesize as existing file", localTrack.Path); return(Decision.Reject("Has the same filesize as existing file")); } return(Decision.Accept()); }
public Decision IsSatisfiedBy(LocalMovie localMovie) { if (localMovie.ExistingFile) { return(Decision.Accept()); } var dirInfo = new FileInfo(localMovie.Path).Directory; if (dirInfo == null) { return(Decision.Accept()); } var folderInfo = Parser.Parser.ParseTitle(dirInfo.Name); if (folderInfo == null) { return(Decision.Accept()); } if (folderInfo.FullSeason) { return(Decision.Accept()); } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteAlbum subject, SearchCriteriaBase searchCriteria) { var qualityProfile = subject.Artist.QualityProfile.Value; foreach (var album in subject.Albums) { var tracksMissing = _missingFilesCache.Get(album.Id.ToString(), () => _trackService.TracksWithoutFiles(album.Id).Any(), TimeSpan.FromSeconds(30)); var trackFiles = _mediaFileService.GetFilesByAlbum(album.Id); if (!tracksMissing && trackFiles.Any()) { // Get a distinct list of all current track qualities for a given album var currentQualities = trackFiles.Select(c => c.Quality).Distinct().ToList(); _logger.Debug("Comparing file quality with report. Existing files contain {0}", currentQualities.ConcatToString()); if (!_upgradableSpecification.CutoffNotMet(qualityProfile, currentQualities, _preferredWordServiceCalculator.Calculate(subject.Artist, trackFiles[0].GetSceneOrFileName()), subject.ParsedAlbumInfo.Quality, subject.PreferredWordScore)) { _logger.Debug("Cutoff already met by existing files, rejecting."); var qualityCutoffIndex = qualityProfile.GetIndex(qualityProfile.Cutoff); var qualityCutoff = qualityProfile.Items[qualityCutoffIndex.Index]; return(Decision.Reject("Existing files meets cutoff: {0}", qualityCutoff)); } } } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteBook subject, SearchCriteriaBase searchCriteria) { if (!_configService.AutoUnmonitorPreviouslyDownloadedBooks) { return(Decision.Accept()); } if (searchCriteria != null) { _logger.Debug("Skipping deleted bookfile check during search"); return(Decision.Accept()); } var missingTrackFiles = subject.Books .SelectMany(v => _bookService.GetFilesByBook(v.Id)) .DistinctBy(v => v.Id) .Where(v => IsTrackFileMissing(subject.Author, v)) .ToArray(); if (missingTrackFiles.Any()) { foreach (var missingTrackFile in missingTrackFiles) { _logger.Trace("Book file {0} is missing from disk.", missingTrackFile.Path); } _logger.Debug("Files for this book exist in the database but not on disk, will be unmonitored on next diskscan. skipping."); return(Decision.Reject("Author is not monitored")); } 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)); } } 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)); } } _logger.Debug("[{0}] No restrictions apply, allowing", subject); return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria) { if (subject.Movie.MovieFile == null) { return(Decision.Accept()); } var profile = subject.Movie.Profile; var file = subject.Movie.MovieFile; file.Movie = subject.Movie; var customFormats = _formatService.ParseCustomFormat(file); _logger.Debug("Comparing file quality with report. Existing file is {0} [{1}]", file.Quality, customFormats.ConcatToString()); if (!_qualityUpgradableSpecification.IsUpgradable(profile, file.Quality, customFormats, subject.ParsedMovieInfo.Quality, subject.CustomFormats)) { return(Decision.Reject("Quality for existing file on disk is of equal or higher preference: {0} [{1}]", file.Quality, customFormats.ConcatToString())); } return(Decision.Accept()); }
public Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var size = subject.Release.Size; var maximumSize = _configService.MaximumSize.Megabytes(); if (maximumSize == 0) { _logger.Debug("Maximum size is not set."); return(Decision.Accept()); } if (size == 0) { _logger.Debug("Release has unknown size, skipping size check."); return(Decision.Accept()); } _logger.Debug("Checking if release meets maximum size requirements. {0}", size.SizeSuffix()); if (size > maximumSize) { var message = $"{size.SizeSuffix()} is too big, maximum size is {maximumSize.SizeSuffix()}"; _logger.Debug(message); return(Decision.Reject(message)); } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var qualityProfile = subject.Series.QualityProfile.Value; var languageProfile = subject.Series.LanguageProfile.Value; foreach (var file in subject.Episodes.Where(c => c.EpisodeFileId != 0).Select(c => c.EpisodeFile.Value)) { if (file == null) { _logger.Debug("File is no longer available, skipping this file."); continue; } _logger.Debug("Comparing file quality and language with report. Existing file is {0} - {1}", file.Quality, file.Language); if (!_upgradableSpecification.CutoffNotMet(qualityProfile, languageProfile, file.Quality, file.Language, _episodeFilePreferredWordCalculator.Calculate(subject.Series, file), subject.ParsedEpisodeInfo.Quality, subject.PreferredWordScore)) { _logger.Debug("Cutoff already met, rejecting."); var qualityCutoffIndex = qualityProfile.GetIndex(qualityProfile.Cutoff); var qualityCutoff = qualityProfile.Items[qualityCutoffIndex.Index]; return(Decision.Reject("Existing file meets cutoff: {0} - {1}", qualityCutoff, languageProfile.Cutoff)); } } return(Decision.Accept()); }
public Decision IsSatisfiedBy(RemoteEpisode remoteEpisode, SearchCriteriaBase searchCriteria) { if (searchCriteria == null) { return(Decision.Accept()); } var criteriaEpisodes = searchCriteria.Episodes.Select(v => v.Id).ToList(); var remoteEpisodes = remoteEpisode.Episodes.Select(v => v.Id).ToList(); if (!criteriaEpisodes.Intersect(remoteEpisodes).Any()) { _logger.Debug("Release rejected since the episode wasn't requested: {0}", remoteEpisode.ParsedEpisodeInfo); if (remoteEpisodes.Any()) { var episodes = remoteEpisode.Episodes.OrderBy(v => v.SeasonNumber).ThenBy(v => v.EpisodeNumber).ToList(); if (episodes.Count > 1) { return(Decision.Reject($"Episode wasn't requested: {episodes.First().SeasonNumber}x{episodes.First().EpisodeNumber}-{episodes.Last().EpisodeNumber}")); } else { return(Decision.Reject($"Episode wasn't requested: {episodes.First().SeasonNumber}x{episodes.First().EpisodeNumber}")); } } else { return(Decision.Reject("Episode wasn't requested")); } } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { if (searchCriteria != null) { 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.DateAdded < DateTime.Today.AddDays(-7)) { _logger.Debug("Proper for old file, rejecting: {0}", subject); return(Decision.Reject("Proper for old file")); } if (!_configService.AutoDownloadPropers) { _logger.Debug("Auto downloading of propers is disabled"); return(Decision.Reject("Proper downloading is disabled")); } } } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteAlbum remoteAlbum, SearchCriteriaBase searchCriteria) { if (searchCriteria == null) { return(Decision.Accept()); } var singleAlbumSpec = searchCriteria as AlbumSearchCriteria; if (singleAlbumSpec == null) { return(Decision.Accept()); } if (Parser.Parser.CleanArtistName(singleAlbumSpec.AlbumTitle) != Parser.Parser.CleanArtistName(remoteAlbum.ParsedAlbumInfo.AlbumTitle)) { _logger.Debug("Album does not match searched album title, skipping."); return(Decision.Reject("Wrong album")); } if (!remoteAlbum.ParsedAlbumInfo.AlbumTitle.Any()) { _logger.Debug("Full discography result during single album search, skipping."); return(Decision.Reject("Full artist pack")); } 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(RemoteAlbum subject, SearchCriteriaBase searchCriteria) { foreach (var album in subject.Albums) { var tracksMissing = _missingFilesCache.Get(album.Id.ToString(), () => _trackService.TracksWithoutFiles(album.Id).Any(), TimeSpan.FromSeconds(30)); var trackFiles = _mediaFileService.GetFilesByAlbum(album.Id); if (!tracksMissing && trackFiles.Any()) { var currentQualities = trackFiles.Select(c => c.Quality).Distinct().ToList(); if (!_upgradableSpecification.IsUpgradable(subject.Artist.QualityProfile, currentQualities, _preferredWordServiceCalculator.Calculate(subject.Artist, trackFiles[0].GetSceneOrFileName(), subject.Release?.IndexerId ?? 0), subject.ParsedAlbumInfo.Quality, subject.PreferredWordScore)) { return(Decision.Reject("Existing files on disk is of equal or higher preference: {0}", currentQualities.ConcatToString())); } } } return(Decision.Accept()); }
public Decision IsSatisfiedBy(LocalBook item, DownloadClientItem downloadClientItem) { var files = item.Book?.BookFiles?.Value; if (files == null || !files.Any()) { // No existing books, skip. This guards against new authors not having a QualityProfile. return(Decision.Accept()); } var downloadPropersAndRepacks = _configService.DownloadPropersAndRepacks; var qualityComparer = new QualityModelComparer(item.Author.QualityProfile); foreach (var bookFile in files) { var qualityCompare = qualityComparer.Compare(item.Quality.Quality, bookFile.Quality.Quality); if (qualityCompare < 0) { _logger.Debug("This file isn't a quality upgrade for all books. Skipping {0}", item.Path); return(Decision.Reject("Not an upgrade for existing book file(s)")); } if (qualityCompare == 0 && downloadPropersAndRepacks != ProperDownloadTypes.DoNotPrefer && item.Quality.Revision.CompareTo(bookFile.Quality.Revision) < 0) { _logger.Debug("This file isn't a quality upgrade for all books. Skipping {0}", item.Path); return(Decision.Reject("Not an upgrade for existing book file(s)")); } } return(Decision.Accept()); }
public virtual Decision IsSatisfiedBy(RemoteMovie 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 virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria) { var qualityProfile = subject.Series.QualityProfile.Value; var languageProfile = subject.Series.LanguageProfile.Value; foreach (var file in subject.Episodes.Where(c => c.EpisodeFileId != 0).Select(c => c.EpisodeFile.Value)) { if (file == null) { _logger.Debug("File is no longer available, skipping this file."); continue; } _logger.Debug("Comparing file quality and language with report. Existing file is {0} - {1}", file.Quality, file.Language); if (!_upgradableSpecification.IsUpgradeAllowed(qualityProfile, languageProfile, file.Quality, file.Language, subject.ParsedEpisodeInfo.Quality, subject.ParsedEpisodeInfo.Language)) { _logger.Debug("Upgrading is not allowed by the quality or language profile"); return(Decision.Reject("Existing file and the Quality or Language profile does not allow upgrades")); } } return(Decision.Accept()); }