private RemoteMovie GetRemoteMovie(QualityModel quality, Movie movie = null)
{
if (movie == null)
{
movie = GetMovie(1);
}
movie.Profile = new Profile {
Items = Qualities.QualityFixture.GetDefaultQualities(), PreferredTags = new List <string>()
};
var remoteMovie = new RemoteMovie()
{
ParsedMovieInfo = new ParsedMovieInfo()
{
Quality = quality,
Year = 1998,
MovieTitle = "A Movie",
},
Movie = movie,
Release = new ReleaseInfo()
{
PublishDate = DateTime.UtcNow,
Title = "A.Movie.1998",
Size = 200
}
};
return(remoteMovie);
}
public void Setup()
{
_movie = Builder <Movie> .CreateNew().With(s => s.Id = 1).Build();
_remoteMovie = new RemoteMovie
{
Movie = _movie,
Release = new TorrentInfo
{
IndexerId = 1,
Title = "Series.Title.S01.720p.BluRay.X264-RlsGrp",
Seeders = 0,
//IndexerSettings = new TorrentRssIndexerSettings {MinimumSeeders = 5}
}
};
_indexerDefinition = new IndexerDefinition
{
Settings = new TorrentRssIndexerSettings {
MinimumSeeders = 5
}
};
Mocker.GetMock <IIndexerFactory>()
.Setup(v => v.Get(1))
.Returns(_indexerDefinition);
}
public void Setup()
{
_fakeIndexerDefinition = new IndexerDefinition
{
Tags = new HashSet <int>()
};
Mocker
.GetMock <IIndexerFactory>()
.Setup(m => m.Get(It.IsAny <int>()))
.Throws(new ModelNotFoundException(typeof(IndexerDefinition), -1));
Mocker
.GetMock <IIndexerFactory>()
.Setup(m => m.Get(1))
.Returns(_fakeIndexerDefinition);
_specification = Mocker.Resolve <IndexerTagSpecification>();
_fakeMovie = Builder <Movie> .CreateNew()
.With(c => c.Monitored = true)
.With(c => c.Tags = new HashSet <int>())
.Build();
_fakeRelease = new ReleaseInfo
{
IndexerId = 1
};
_parseResultMulti = new RemoteMovie
{
Movie = _fakeMovie,
Release = _fakeRelease
};
}
private void RemoveGrabbed(RemoteMovie remoteMovie)
{
var pendingReleases = GetPendingReleases(remoteMovie.Movie.Id);
var existingReports = pendingReleases.Where(r => r.RemoteMovie.Movie.Id == remoteMovie.Movie.Id)
.ToList();
if (existingReports.Empty())
{
return;
}
var profile = remoteMovie.Movie.Profile;
foreach (var existingReport in existingReports)
{
var compare = new QualityModelComparer(profile).Compare(remoteMovie.ParsedMovieInfo.Quality,
existingReport.RemoteMovie.ParsedMovieInfo.Quality);
//Only remove lower/equal quality pending releases
//It is safer to retry these releases on the next round than remove it and try to re-add it (if its still in the feed)
if (compare >= 0)
{
_logger.Debug("Removing previously pending release, as it was grabbed.");
Delete(existingReport);
}
}
}
private RemoteMovie GetRemoteMovie(QualityModel quality, Movie movie = null, DownloadProtocol downloadProtocol = DownloadProtocol.Usenet)
{
if (movie == null)
{
movie = GetMovie(1);
}
movie.Profile = new Profile {
Items = Qualities.QualityFixture.GetDefaultQualities()
};
var remoteMovie = new RemoteMovie()
{
ParsedMovieInfo = new ParsedMovieInfo()
{
Quality = quality,
Year = 1998,
MovieTitle = "A Movie",
},
Movie = movie,
Release = new ReleaseInfo()
{
PublishDate = DateTime.UtcNow,
Title = "A.Movie.1998",
Size = 200,
DownloadProtocol = downloadProtocol
}
};
return(remoteMovie);
}
public override string Download(RemoteMovie remoteMovie)
{
var url = remoteMovie.Release.DownloadUrl;
var title = remoteMovie.Release.Title;
// We don't have full seasons in movies.
//if (remoteMovie.ParsedEpisodeInfo.FullSeason)
//{
// throw new NotSupportedException("Full season releases are not supported with Pneumatic.");
//}
title = FileNameBuilder.CleanFileName(title);
//Save to the Pneumatic directory (The user will need to ensure its accessible by XBMC)
var nzbFile = Path.Combine(Settings.NzbFolder, title + ".nzb");
_logger.Debug("Downloading NZB from: {0} to: {1}", url, nzbFile);
_httpClient.DownloadFile(url, nzbFile);
_logger.Debug("NZB Download succeeded, saved to: {0}", nzbFile);
var strmFile = WriteStrmFile(title, nzbFile);
return(GetDownloadClientId(strmFile));
}
public void Setup()
{
Mocker.Resolve <UpgradableSpecification>();
_upgradeDisk = Mocker.Resolve <UpgradeDiskSpecification>();
CustomFormatsFixture.GivenCustomFormats();
_firstFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 2)), DateAdded = DateTime.Now
};
var fakeSeries = Builder <Movie> .CreateNew()
.With(c => c.Profile = new Profile
{
Cutoff = Quality.Bluray1080p.Id, Items = Qualities.QualityFixture.GetDefaultQualities(),
FormatItems = CustomFormatsFixture.GetSampleFormatItems(),
MinFormatScore = 0
})
.With(e => e.MovieFile = _firstFile)
.Build();
_parseResultSingle = new RemoteMovie
{
Movie = fakeSeries,
ParsedMovieInfo = new ParsedMovieInfo()
{
Quality = new QualityModel(Quality.DVD, new Revision(version: 2))
},
CustomFormats = new List <CustomFormat>()
};
Mocker.GetMock <ICustomFormatCalculationService>()
.Setup(x => x.ParseCustomFormat(It.IsAny <MovieFile>()))
.Returns(new List <CustomFormat>());
}
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 void Setup()
{
_movie = Builder <Movie> .CreateNew().Build();
_qualityType = Builder <QualityDefinition> .CreateNew()
.With(q => q.MinSize = 2)
.With(q => q.MaxSize = 10)
.With(q => q.Quality = Quality.SDTV)
.Build();
_remoteMovie = new RemoteMovie
{
Movie = _movie,
Release = new ReleaseInfo(),
ParsedMovieInfo = new ParsedMovieInfo {
Quality = new QualityModel(Quality.SDTV, new Revision(version: 2))
},
};
Mocker.GetMock <IQualityDefinitionService>()
.Setup(v => v.Get(It.IsAny <Quality>()))
.Returns <Quality>(v => Quality.DefaultQualityDefinitions.First(c => c.Quality == v));
Mocker.GetMock <IQualityDefinitionService>().Setup(s => s.Get(Quality.SDTV)).Returns(_qualityType);
}
public void Setup()
{
Mocker.Resolve <QualityUpgradableSpecification>();
_upgradeDisk = Mocker.Resolve <UpgradeDiskSpecification>();
_firstFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 2)), DateAdded = DateTime.Now
};
var fakeSeries = Builder <Movie> .CreateNew()
.With(c => c.Profile = new Profile {
Cutoff = Quality.Bluray1080p, Items = Qualities.QualityFixture.GetDefaultQualities()
})
.With(e => e.MovieFile = _firstFile)
.Build();
_parseResultSingle = new RemoteMovie
{
Movie = fakeSeries,
ParsedMovieInfo = new ParsedMovieInfo()
{
Quality = new QualityModel(Quality.DVD, new Revision(version: 2))
},
};
}
public void Setup()
{
Mocker.Resolve <QualityUpgradableSpecification>();
_firstFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 1)), DateAdded = DateTime.Now
};
_secondFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 1)), DateAdded = DateTime.Now
};
var fakeSeries = Builder <Movie> .CreateNew()
.With(c => c.Profile = new Profile {
Cutoff = Quality.Bluray1080p
})
.With(c => c.MovieFile = _firstFile)
.Build();
_parseResultSingle = new RemoteMovie
{
Movie = fakeSeries,
ParsedMovieInfo = new ParsedMovieInfo {
Quality = new QualityModel(Quality.DVD, new Revision(version: 2))
},
};
}
public override string Download(RemoteMovie remoteMovie)
{
var id = remoteMovie.Release.DownloadUrl;
_logger.Info("Adding report [{0}] to the queue.", remoteMovie.Release.Title);
return(AddFromId(id, remoteMovie.Release.Title));
}
public void Setup()
{
Mocker.Resolve <QualityUpgradableSpecification>();
_upgradeHistory = Mocker.Resolve <HistorySpecification>();
_fakeMovie = Builder <Movie> .CreateNew()
.With(c => c.Profile = new Profile {
Cutoff = Quality.Bluray1080p, Items = Qualities.QualityFixture.GetDefaultQualities()
})
.Build();
_parseResultSingle = new RemoteMovie
{
Movie = _fakeMovie,
ParsedMovieInfo = new ParsedMovieInfo {
Quality = new QualityModel(Quality.DVD, new Revision(version: 2))
}
};
_upgradableQuality = new QualityModel(Quality.SDTV, new Revision(version: 1));
_notupgradableQuality = new QualityModel(Quality.HDTV1080p, new Revision(version: 2));
Mocker.GetMock <IConfigService>()
.SetupGet(s => s.EnableCompletedDownloadHandling)
.Returns(true);
}
public virtual Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria)
{
if (searchCriteria != null)
{
return(Decision.Accept());
}
if (subject.Movie.MovieFile.Value == null)
{
return(Decision.Accept());
}
var file = subject.Movie.MovieFile.Value;
if (_qualityUpgradableSpecification.IsRevisionUpgrade(file.Quality, subject.ParsedMovieInfo.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 Decision IsSatisfiedBy(RemoteMovie 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()} (Settings->Indexers->Maximum Size)";
_logger.Debug(message);
return(Decision.Reject(message));
}
return(Decision.Accept());
}
private RemoteMovie GivenRemoteMovie(QualityModel quality, int age = 0, long size = 0, DownloadProtocol downloadProtocol = DownloadProtocol.Usenet)
{
var remoteMovie = new RemoteMovie();
remoteMovie.ParsedMovieInfo = new ParsedMovieInfo();
remoteMovie.ParsedMovieInfo.MovieTitle = "A Movie";
remoteMovie.ParsedMovieInfo.Year = 1998;
remoteMovie.ParsedMovieInfo.MovieTitleInfo = new SeriesTitleInfo {
Year = 1998
};
remoteMovie.ParsedMovieInfo.MovieTitleInfo.Year = 1998;
remoteMovie.ParsedMovieInfo.Quality = quality;
remoteMovie.Movie = Builder <Movie> .CreateNew().With(m => m.Profile = new Profile {
Items = Qualities.QualityFixture.GetDefaultQualities(),
PreferredTags = new List <string> {
"DTS-HD", "SPARKS"
}
})
.With(m => m.Title = "A Movie").Build();
remoteMovie.Release = new ReleaseInfo();
remoteMovie.Release.PublishDate = DateTime.Now.AddDays(-age);
remoteMovie.Release.Size = size;
remoteMovie.Release.DownloadProtocol = downloadProtocol;
remoteMovie.Release.Title = "A Movie 1998";
return(remoteMovie);
}
private string DownloadFromMagnetUrl(RemoteMovie remoteMovie, string magnetUrl)
{
string hash = null;
string actualHash = null;
try
{
hash = MagnetLink.Parse(magnetUrl).InfoHash.ToHex();
}
catch (FormatException ex)
{
_logger.Error(ex, "Failed to parse magnetlink for movie '{0}': '{1}'", remoteMovie.Release.Title, magnetUrl);
return(null);
}
if (hash != null)
{
actualHash = AddFromMagnetLink(remoteMovie, hash, magnetUrl);
}
if (actualHash.IsNotNullOrWhiteSpace() && hash != actualHash)
{
_logger.Debug(
"{0} did not return the expected InfoHash for '{1}', Radarr could potentially lose track of the download in progress.",
Definition.Implementation,
remoteMovie.Release.DownloadUrl);
}
return(actualHash);
}
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 void Setup()
{
var completed = Builder <DownloadClientItem> .CreateNew()
.With(h => h.Status = DownloadItemStatus.Completed)
.With(h => h.OutputPath = new OsPath(@"C:\DropFolder\MyDownload".AsOsAgnostic()))
.With(h => h.Title = "Drone.S01E01.HDTV")
.Build();
_grabHistory = Builder <History.History> .CreateListOfSize(2).BuildList();
var remoteEpisode = new RemoteMovie
{
Movie = new Movie(),
};
_trackedDownload = Builder <TrackedDownload> .CreateNew()
.With(c => c.State = TrackedDownloadStage.Downloading)
.With(c => c.DownloadItem = completed)
.With(c => c.RemoteMovie = remoteEpisode)
.Build();
Mocker.GetMock <IHistoryService>()
.Setup(s => s.Find(_trackedDownload.DownloadItem.DownloadId, HistoryEventType.Grabbed))
.Returns(_grabHistory);
}
protected override string AddFromTorrentFile(RemoteMovie remoteMovie, string hash, string filename, Byte[] fileContent)
{
_proxy.AddTorrentFromFile(filename, fileContent, Settings);
try
{
if (Settings.MovieCategory.IsNotNullOrWhiteSpace())
{
_proxy.SetTorrentLabel(hash.ToLower(), Settings.MovieCategory, Settings);
}
}
catch (Exception ex)
{
_logger.Warn(ex, "Failed to set the torrent label for {0}.", filename);
}
try
{
var isRecentMovie = remoteMovie.Movie.IsRecentMovie;
if (isRecentMovie && Settings.RecentMoviePriority == (int)QBittorrentPriority.First ||
!isRecentMovie && Settings.OlderMoviePriority == (int)QBittorrentPriority.First)
{
_proxy.MoveTorrentToTopInQueue(hash.ToLower(), Settings);
}
}
catch (Exception ex)
{
_logger.Warn(ex, "Failed to set the torrent priority for {0}.", filename);
}
SetInitialState(hash.ToLower());
return(hash);
}
public void Setup()
{
_movie = Builder <Movie> .CreateNew()
.With(m => m.Id = FIRST_MOVIE_ID)
.With(m => m.MovieFileId = 1)
.Build();
_hdtv720p = new QualityModel(Quality.HDTV720p, new Revision(version: 1));
_hdtv1080p = new QualityModel(Quality.HDTV1080p, new Revision(version: 1));
_remoteMovie = new RemoteMovie
{
Movie = _movie,
ParsedMovieInfo = new ParsedMovieInfo {
Quality = _hdtv720p
},
Release = Builder <ReleaseInfo> .CreateNew()
.Build()
};
_history = new List <MovieHistory>();
Mocker.GetMock <IConfigService>()
.SetupGet(s => s.EnableCompletedDownloadHandling)
.Returns(true);
Mocker.GetMock <IHistoryService>()
.Setup(s => s.GetByMovieId(It.IsAny <int>(), null))
.Returns(_history);
}
private DownloadDecision GetDecisionForReport(RemoteMovie remoteMovie, SearchCriteriaBase searchCriteria = null)
{
var reasons = _specifications.Select(c => EvaluateSpec(c, remoteMovie, searchCriteria))
.Where(c => c != null);
return(new DownloadDecision(remoteMovie, reasons.ToArray()));
}
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());
}
private Rejection EvaluateSpec(IDecisionEngineSpecification spec, RemoteMovie remoteMovie, SearchCriteriaBase searchCriteriaBase = null)
{
try
{
var result = spec.IsSatisfiedBy(remoteMovie, searchCriteriaBase);
if (!result.Accepted)
{
return(new Rejection(result.Reason, spec.Type));
}
}
catch (NotImplementedException e)
{
_logger.Trace("Spec " + spec.GetType().Name + " does not care about movies.");
}
catch (Exception e)
{
e.Data.Add("report", remoteMovie.Release.ToJson());
e.Data.Add("parsed", remoteMovie.ParsedMovieInfo.ToJson());
_logger.Error(e, "Couldn't evaluate decision on {0}, with spec: {1}", remoteMovie.Release.Title, spec.GetType().Name);
return(new Rejection(string.Format("{0}: {1}", spec.GetType().Name, e.Message)));//TODO UPDATE SPECS!
}
return(null);
}
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 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(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());
}
private RemoteMovie GivenRemoteMovie(QualityModel quality, int age = 0, long size = 0, DownloadProtocol downloadProtocol = DownloadProtocol.Usenet, int runtime = 150, int indexerPriority = 25)
{
var remoteMovie = new RemoteMovie();
remoteMovie.ParsedMovieInfo = new ParsedMovieInfo();
remoteMovie.ParsedMovieInfo.MovieTitles = new List <string> {
"A Movie"
};
remoteMovie.ParsedMovieInfo.Year = 1998;
remoteMovie.ParsedMovieInfo.Quality = quality;
remoteMovie.Movie = Builder <Movie> .CreateNew().With(m => m.Profile = new Profile
{
Items = Qualities.QualityFixture.GetDefaultQualities(),
FormatItems = CustomFormatsFixture.GetSampleFormatItems(_customFormat1.Name, _customFormat2.Name),
MinFormatScore = 0
})
.With(m => m.Title = "A Movie")
.With(m => m.Runtime = runtime).Build();
remoteMovie.Release = new ReleaseInfo();
remoteMovie.Release.PublishDate = DateTime.Now.AddDays(-age);
remoteMovie.Release.Size = size;
remoteMovie.Release.DownloadProtocol = downloadProtocol;
remoteMovie.Release.Title = "A Movie 1998";
remoteMovie.Release.IndexerPriority = indexerPriority;
remoteMovie.CustomFormats = new List <CustomFormat>();
remoteMovie.CustomFormatScore = 0;
return(remoteMovie);
}
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());
}
protected override string AddFromTorrentFile(RemoteMovie remoteMovie, string hash, string filename, byte[] fileContent)
{
var actualHash = _proxy.AddTorrentFromFile(filename, fileContent, Settings);
if (actualHash.IsNullOrWhiteSpace())
{
throw new DownloadClientException("Deluge failed to add torrent " + filename);
}
_proxy.SetTorrentSeedingConfiguration(actualHash, remoteMovie.SeedConfiguration, Settings);
if (Settings.MovieCategory.IsNotNullOrWhiteSpace())
{
_proxy.SetTorrentLabel(actualHash, Settings.MovieCategory, Settings);
}
var isRecentMovie = remoteMovie.Movie.IsRecentMovie;
if ((isRecentMovie && Settings.RecentMoviePriority == (int)DelugePriority.First) ||
(!isRecentMovie && Settings.OlderMoviePriority == (int)DelugePriority.First))
{
_proxy.MoveTorrentToTopInQueue(actualHash, Settings);
}
return(actualHash.ToUpper());
}
