public int Calculate(Series series, EpisodeFile episodeFile)
{
var scores = new List <int>();
if (episodeFile.SceneName.IsNotNullOrWhiteSpace())
{
scores.Add(_preferredWordService.Calculate(series, episodeFile.SceneName, 0));
}
else
{
_logger.Trace("No stored scene name for {0}", episodeFile);
}
// Calculate using RelativePath or Path, but not both
if (episodeFile.RelativePath.IsNotNullOrWhiteSpace())
{
scores.Add(_preferredWordService.Calculate(series, episodeFile.RelativePath, 0));
}
else if (episodeFile.Path.IsNotNullOrWhiteSpace())
{
scores.Add(_preferredWordService.Calculate(series, episodeFile.Path, 0));
}
// Return the highest score, this will allow media info in file names to be used to improve preferred word scoring.
// TODO: A full map of preferred words should be de-duped and used to create an aggregated score using the scene name and the file name.
return(scores.MaxOrDefault());
}
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(RemoteBook subject, SearchCriteriaBase searchCriteria)
{
foreach (var file in subject.Books.SelectMany(c => c.BookFiles.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}", file.Quality);
if (!_upgradableSpecification.IsUpgradable(subject.Author.QualityProfile,
new List <QualityModel> {
file.Quality
},
_preferredWordServiceCalculator.Calculate(subject.Author, file.GetSceneOrFileName()),
subject.ParsedBookInfo.Quality,
subject.PreferredWordScore))
{
return(Decision.Reject("Existing file on disk is of equal or higher preference: {0}", file.Quality));
}
}
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(RemoteEpisode subject, SearchCriteriaBase searchCriteria)
{
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.IsUpgradable(subject.Series.QualityProfile,
subject.Series.LanguageProfile,
file.Quality,
file.Language,
_preferredWordServiceCalculator.Calculate(subject.Series, file.GetSceneOrFileName()),
subject.ParsedEpisodeInfo.Quality,
subject.ParsedEpisodeInfo.Language,
subject.PreferredWordScore))
{
return(Decision.Reject("Existing file on disk is of equal or higher preference: {0} - {1}", file.Quality, file.Language));
}
}
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,
_preferredWordServiceCalculator.Calculate(subject.Series, file.GetSceneOrFileName()),
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 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(RemoteBook subject, SearchCriteriaBase searchCriteria)
{
var queue = _queueService.GetQueue();
var matchingBook = queue.Where(q => q.RemoteBook?.Author != null &&
q.RemoteBook.Author.Id == subject.Author.Id &&
q.RemoteBook.Books.Select(e => e.Id).Intersect(subject.Books.Select(e => e.Id)).Any())
.ToList();
foreach (var queueItem in matchingBook)
{
var remoteBook = queueItem.RemoteBook;
var qualityProfile = subject.Author.QualityProfile.Value;
// To avoid a race make sure it's not FailedPending (failed awaiting removal/search).
// Failed items (already searching for a replacement) won't be part of the queue since
// it's a copy, of the tracked download, not a reference.
if (queueItem.TrackedDownloadState == TrackedDownloadState.DownloadFailedPending)
{
continue;
}
_logger.Debug("Checking if existing release in queue meets cutoff. Queued quality is: {0}", remoteBook.ParsedBookInfo.Quality);
var queuedItemPreferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Author, queueItem.Title, subject.Release?.IndexerId ?? 0);
if (!_upgradableSpecification.CutoffNotMet(qualityProfile,
new List <QualityModel> {
remoteBook.ParsedBookInfo.Quality
},
queuedItemPreferredWordScore,
subject.ParsedBookInfo.Quality,
subject.PreferredWordScore))
{
return(Decision.Reject("Release in queue already meets cutoff: {0}", remoteBook.ParsedBookInfo.Quality));
}
_logger.Debug("Checking if release is higher quality than queued release. Queued: {0}", remoteBook.ParsedBookInfo.Quality);
if (!_upgradableSpecification.IsUpgradable(qualityProfile,
remoteBook.ParsedBookInfo.Quality,
queuedItemPreferredWordScore,
subject.ParsedBookInfo.Quality,
subject.PreferredWordScore))
{
return(Decision.Reject("Release in queue is of equal or higher preference: {0}", remoteBook.ParsedBookInfo.Quality));
}
_logger.Debug("Checking if profiles allow upgrading. Queued: {0}", remoteBook.ParsedBookInfo.Quality);
if (!_upgradableSpecification.IsUpgradeAllowed(qualityProfile,
remoteBook.ParsedBookInfo.Quality,
subject.ParsedBookInfo.Quality))
{
return(Decision.Reject("Another release is queued and the Quality profile does not allow upgrades"));
}
}
return(Decision.Accept());
}
public int Calculate(Series series, EpisodeFile episodeFile)
{
var scores = new List <int>();
if (episodeFile.SceneName.IsNotNullOrWhiteSpace())
{
scores.Add(_preferredWordService.Calculate(series, episodeFile.SceneName, 0));
}
else
{
_logger.Trace("No stored scene name for {0}", episodeFile);
}
// The file may not have a screen name if the file/folder name contained spaces, but the original path is still store and valuable.
if (episodeFile.OriginalFilePath.IsNotNullOrWhiteSpace())
{
var segments = episodeFile.OriginalFilePath.Split(Path.DirectorySeparatorChar).ToList();
for (int i = 0; i < segments.Count; i++)
{
var isLast = i == segments.Count - 1;
var segment = isLast ? Path.GetFileNameWithoutExtension(segments[i]) : segments[i];
scores.Add(_preferredWordService.Calculate(series, segment, 0));
}
}
else
{
_logger.Trace("No stored scene name for {0}", episodeFile);
}
// Calculate using RelativePath or Path, but not both
if (episodeFile.RelativePath.IsNotNullOrWhiteSpace())
{
scores.Add(_preferredWordService.Calculate(series, episodeFile.RelativePath, 0));
}
else if (episodeFile.Path.IsNotNullOrWhiteSpace())
{
scores.Add(_preferredWordService.Calculate(series, episodeFile.Path, 0));
}
// Return the highest score, this will allow media info in file names to be used to improve preferred word scoring.
// TODO: A full map of preferred words should be de-duped and used to create an aggregated score using the scene name and the file name.
return(scores.MaxOrDefault());
}
public Decision IsSatisfiedBy(RemoteAlbum subject, SearchCriteriaBase searchCriteria)
{
var queue = _queueService.GetQueue();
var matchingAlbum = queue.Where(q => q.RemoteAlbum != null &&
q.RemoteAlbum.Artist != null &&
q.RemoteAlbum.Artist.Id == subject.Artist.Id &&
q.RemoteAlbum.Albums.Select(e => e.Id).Intersect(subject.Albums.Select(e => e.Id)).Any())
.ToList();
foreach (var queueItem in matchingAlbum)
{
var remoteAlbum = queueItem.RemoteAlbum;
var qualityProfile = subject.Artist.QualityProfile.Value;
_logger.Debug("Checking if existing release in queue meets cutoff. Queued quality is: {0}", remoteAlbum.ParsedAlbumInfo.Quality);
var queuedItemPreferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Artist, queueItem.Title);
if (!_upgradableSpecification.CutoffNotMet(qualityProfile,
new List <QualityModel> {
remoteAlbum.ParsedAlbumInfo.Quality
},
queuedItemPreferredWordScore,
subject.ParsedAlbumInfo.Quality,
subject.PreferredWordScore))
{
return(Decision.Reject("Release in queue already meets cutoff: {0}", remoteAlbum.ParsedAlbumInfo.Quality));
}
_logger.Debug("Checking if release is higher quality than queued release. Queued: {0}", remoteAlbum.ParsedAlbumInfo.Quality);
if (!_upgradableSpecification.IsUpgradable(qualityProfile,
new List <QualityModel> {
remoteAlbum.ParsedAlbumInfo.Quality
},
queuedItemPreferredWordScore,
subject.ParsedAlbumInfo.Quality,
subject.PreferredWordScore))
{
return(Decision.Reject("Release in queue is of equal or higher preference: {0}", remoteAlbum.ParsedAlbumInfo.Quality));
}
_logger.Debug("Checking if profiles allow upgrading. Queued: {0}", remoteAlbum.ParsedAlbumInfo.Quality);
if (!_upgradableSpecification.IsUpgradeAllowed(qualityProfile,
new List <QualityModel> {
remoteAlbum.ParsedAlbumInfo.Quality
},
subject.ParsedAlbumInfo.Quality))
{
return(Decision.Reject("Another release is queued and the Quality profile does not allow upgrades"));
}
}
return(Decision.Accept());
}
public LocalEpisode Aggregate(LocalEpisode localEpisode, DownloadClientItem downloadClientItem)
{
var series = localEpisode.Series;
var scores = new List <int>();
if (localEpisode.FileEpisodeInfo != null)
{
scores.Add(_preferredWordService.Calculate(series, localEpisode.FileEpisodeInfo.ReleaseTitle, 0));
}
if (localEpisode.SceneName != null)
{
scores.Add(_preferredWordService.Calculate(series, localEpisode.SceneName, 0));
}
localEpisode.PreferredWordScore = scores.MaxOrDefault();
return(localEpisode);
}
private int GetPreferredWordScore(LocalEpisode localEpisode)
{
var series = localEpisode.Series;
var scores = new List <int>();
if (localEpisode.FileEpisodeInfo != null)
{
scores.Add(_preferredWordService.Calculate(series, localEpisode.FileEpisodeInfo.ReleaseTitle, 0));
}
if (localEpisode.FolderEpisodeInfo != null)
{
scores.Add(_preferredWordService.Calculate(series, localEpisode.FolderEpisodeInfo.ReleaseTitle, 0));
}
if (localEpisode.DownloadClientEpisodeInfo != null)
{
scores.Add(_preferredWordService.Calculate(series, localEpisode.DownloadClientEpisodeInfo.ReleaseTitle, 0));
}
return(scores.MaxOrDefault());
}
public virtual Decision IsSatisfiedBy(RemoteBook subject, SearchCriteriaBase searchCriteria)
{
foreach (var file in subject.Books.SelectMany(c => c.BookFiles.Value))
{
if (file == null)
{
return(Decision.Accept());
}
if (!_upgradableSpecification.IsUpgradable(subject.Author.QualityProfile,
file.Quality,
_preferredWordServiceCalculator.Calculate(subject.Author, file.GetSceneOrFileName(), subject.Release?.IndexerId ?? 0),
subject.ParsedBookInfo.Quality,
subject.PreferredWordScore))
{
return(Decision.Reject("Existing files on disk is of equal or higher preference: {0}", file.Quality));
}
}
return(Decision.Accept());
}
public RemoteBook Aggregate(RemoteBook remoteBook)
{
remoteBook.PreferredWordScore = _preferredWordServiceCalculator.Calculate(remoteBook.Author, remoteBook.Release.Title);
return(remoteBook);
}
public RemoteAlbum Aggregate(RemoteAlbum remoteAlbum)
{
remoteAlbum.PreferredWordScore = _preferredWordServiceCalculator.Calculate(remoteAlbum.Artist, remoteAlbum.Release.Title, remoteAlbum.Release.IndexerId);
return(remoteAlbum);
}
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 == EpisodeHistoryEventType.Grabbed)
{
var recent = mostRecent.Date.After(DateTime.UtcNow.AddHours(-12));
if (!recent && cdhEnabled)
{
continue;
}
// The series will be the same as the one in history since it's the same episode.
// Instead of fetching the series from the DB reuse the known series.
var preferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Series, mostRecent.SourceTitle, subject.Release?.IndexerId ?? 0);
var cutoffUnmet = _upgradableSpecification.CutoffNotMet(
subject.Series.QualityProfile,
subject.Series.LanguageProfile,
mostRecent.Quality,
mostRecent.Language,
preferredWordScore,
subject.ParsedEpisodeInfo.Quality,
subject.PreferredWordScore);
var upgradeable = _upgradableSpecification.IsUpgradable(
subject.Series.QualityProfile,
subject.Series.LanguageProfile,
mostRecent.Quality,
mostRecent.Language,
preferredWordScore,
subject.ParsedEpisodeInfo.Quality,
subject.ParsedEpisodeInfo.Language,
subject.PreferredWordScore);
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 virtual Decision IsSatisfiedBy(RemoteBook subject, SearchCriteriaBase searchCriteria)
{
if (searchCriteria != null && searchCriteria.UserInvokedSearch)
{
_logger.Debug("Ignoring delay for user invoked search");
return(Decision.Accept());
}
var qualityProfile = subject.Author.QualityProfile.Value;
var delayProfile = _delayProfileService.BestForTags(subject.Author.Tags);
var delay = delayProfile.GetProtocolDelay(subject.Release.DownloadProtocol);
var isPreferredProtocol = subject.Release.DownloadProtocol == delayProfile.PreferredProtocol;
if (delay == 0)
{
_logger.Debug("Profile does not require a waiting period before download for {0}.", subject.Release.DownloadProtocol);
return(Decision.Accept());
}
var qualityComparer = new QualityModelComparer(qualityProfile);
if (isPreferredProtocol)
{
foreach (var book in subject.Books)
{
var bookFiles = _mediaFileService.GetFilesByBook(book.Id);
if (bookFiles.Any())
{
var currentQualities = bookFiles.Select(c => c.Quality).Distinct().ToList();
var upgradable = _upgradableSpecification.IsUpgradable(qualityProfile,
currentQualities,
_preferredWordServiceCalculator.Calculate(subject.Author, bookFiles[0].GetSceneOrFileName()),
subject.ParsedBookInfo.Quality,
subject.PreferredWordScore);
if (upgradable)
{
_logger.Debug("New quality is a better revision for existing quality, skipping delay");
return(Decision.Accept());
}
}
}
}
// If quality meets or exceeds the best allowed quality in the profile accept it immediately
var bestQualityInProfile = qualityProfile.LastAllowedQuality();
var isBestInProfile = qualityComparer.Compare(subject.ParsedBookInfo.Quality.Quality, bestQualityInProfile) >= 0;
if (isBestInProfile && isPreferredProtocol)
{
_logger.Debug("Quality is highest in profile for preferred protocol, will not delay");
return(Decision.Accept());
}
var bookIds = subject.Books.Select(e => e.Id);
var oldest = _pendingReleaseService.OldestPendingRelease(subject.Author.Id, bookIds.ToArray());
if (oldest != null && oldest.Release.AgeMinutes > delay)
{
return(Decision.Accept());
}
if (subject.Release.AgeMinutes < delay)
{
_logger.Debug("Waiting for better quality release, There is a {0} minute delay on {1}", delay, subject.Release.DownloadProtocol);
return(Decision.Reject("Waiting for better quality release"));
}
return(Decision.Accept());
}
public RemoteEpisode Aggregate(RemoteEpisode remoteEpisode)
{
remoteEpisode.PreferredWordScore = _preferredWordServiceCalculator.Calculate(remoteEpisode.Series, remoteEpisode.Release.Title);
return(remoteEpisode);
}