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);
}
}
}
private IEnumerable <DownloadDecision> GetDecisions(List <ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
{
if (reports.Any())
{
_logger.ProgressInfo("Processing {0} releases", reports.Count);
}
else
{
_logger.ProgressInfo("No results found");
}
var reportNumber = 1;
foreach (var report in reports)
{
DownloadDecision decision = null;
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
_logger.Debug("Processing release '{0}' from '{1}'", report.Title, report.Indexer);
try
{
var parsedEpisodeInfo = Parser.Parser.ParseTitle(report.Title);
if (parsedEpisodeInfo == null || parsedEpisodeInfo.IsPossibleSpecialEpisode)
{
var specialEpisodeInfo = _parsingService.ParseSpecialEpisodeTitle(parsedEpisodeInfo, report.Title, report.TvdbId, report.TvRageId, searchCriteria);
if (specialEpisodeInfo != null)
{
parsedEpisodeInfo = specialEpisodeInfo;
}
}
if (parsedEpisodeInfo != null && !parsedEpisodeInfo.SeriesTitle.IsNullOrWhiteSpace())
{
var remoteEpisode = _parsingService.Map(parsedEpisodeInfo, report.TvdbId, report.TvRageId, searchCriteria);
remoteEpisode.Release = report;
if (remoteEpisode.Series == null)
{
var reason = "Unknown Series";
var matchingTvdbId = _sceneMappingService.FindTvdbId(parsedEpisodeInfo.SeriesTitle, parsedEpisodeInfo.ReleaseTitle, parsedEpisodeInfo.SeasonNumber);
if (matchingTvdbId.HasValue)
{
reason = $"{parsedEpisodeInfo.SeriesTitle} matches an alias for series with TVDB ID: {matchingTvdbId}";
}
decision = new DownloadDecision(remoteEpisode, new Rejection(reason));
}
else if (remoteEpisode.Episodes.Empty())
{
decision = new DownloadDecision(remoteEpisode, new Rejection("Unable to identify correct episode(s) using release name and scene mappings"));
}
else
{
_aggregationService.Augment(remoteEpisode);
remoteEpisode.DownloadAllowed = remoteEpisode.Episodes.Any();
decision = GetDecisionForReport(remoteEpisode, searchCriteria);
}
}
if (searchCriteria != null)
{
if (parsedEpisodeInfo == null)
{
parsedEpisodeInfo = new ParsedEpisodeInfo
{
Language = LanguageParser.ParseLanguage(report.Title),
Quality = QualityParser.ParseQuality(report.Title)
};
}
if (parsedEpisodeInfo.SeriesTitle.IsNullOrWhiteSpace())
{
var remoteEpisode = new RemoteEpisode
{
Release = report,
ParsedEpisodeInfo = parsedEpisodeInfo
};
decision = new DownloadDecision(remoteEpisode, new Rejection("Unable to parse release"));
}
}
}
catch (Exception e)
{
_logger.Error(e, "Couldn't process release.");
var remoteEpisode = new RemoteEpisode {
Release = report
};
decision = new DownloadDecision(remoteEpisode, new Rejection("Unexpected error processing release"));
}
reportNumber++;
if (decision != null)
{
if (decision.Rejections.Any())
{
_logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections));
}
else
{
_logger.Debug("Release accepted");
}
yield return(decision);
}
}
}
private IEnumerable <DownloadDecision> GetAlbumDecisions(List <ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
{
if (reports.Any())
{
_logger.ProgressInfo("Processing {0} releases", reports.Count);
}
else
{
_logger.ProgressInfo("No results found");
}
var reportNumber = 1;
foreach (var report in reports)
{
DownloadDecision decision = null;
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
_logger.Debug("Processing release '{0}' from '{1}'", report.Title, report.Indexer);
try
{
var parsedAlbumInfo = Parser.Parser.ParseAlbumTitle(report.Title);
if (parsedAlbumInfo == null && searchCriteria != null)
{
parsedAlbumInfo = Parser.Parser.ParseAlbumTitleWithSearchCriteria(report.Title,
searchCriteria.Artist, searchCriteria.Albums);
}
if (parsedAlbumInfo != null)
{
// TODO: Artist Data Augment without calling to parse title again
//if (!report.Artist.IsNullOrWhiteSpace())
//{
// if (parsedAlbumInfo.ArtistName.IsNullOrWhiteSpace() || _parsingService.GetArtist(parsedAlbumInfo.ArtistName) == null)
// {
// parsedAlbumInfo.ArtistName = report.Artist;
// }
//}
// TODO: Replace Parsed AlbumTitle with metadata Title if Parsed AlbumTitle not a valid match
//if (!report.Album.IsNullOrWhiteSpace())
//{
// parsedAlbumInfo.AlbumTitle = report.Album;
//}
if (!parsedAlbumInfo.ArtistName.IsNullOrWhiteSpace())
{
var remoteAlbum = _parsingService.Map(parsedAlbumInfo, searchCriteria);
// try parsing again using the search criteria, in case it parsed but parsed incorrectly
if ((remoteAlbum.Artist == null || remoteAlbum.Albums.Empty()) && searchCriteria != null)
{
_logger.Debug("Artist/Album null for {0}, reparsing with search criteria", report.Title);
var parsedAlbumInfoWithCriteria = Parser.Parser.ParseAlbumTitleWithSearchCriteria(report.Title,
searchCriteria.Artist,
searchCriteria.Albums);
if (parsedAlbumInfoWithCriteria != null && parsedAlbumInfoWithCriteria.ArtistName.IsNotNullOrWhiteSpace())
{
remoteAlbum = _parsingService.Map(parsedAlbumInfoWithCriteria, searchCriteria);
}
}
remoteAlbum.Release = report;
if (remoteAlbum.Artist == null)
{
decision = new DownloadDecision(remoteAlbum, new Rejection("Unknown Artist"));
// shove in the searched artist in case of forced download in interactive search
if (searchCriteria != null)
{
remoteAlbum.Artist = searchCriteria.Artist;
remoteAlbum.Albums = searchCriteria.Albums;
}
}
else if (remoteAlbum.Albums.Empty())
{
decision = new DownloadDecision(remoteAlbum, new Rejection("Unable to parse albums from release name"));
if (searchCriteria != null)
{
remoteAlbum.Albums = searchCriteria.Albums;
}
}
else
{
_aggregationService.Augment(remoteAlbum);
remoteAlbum.DownloadAllowed = remoteAlbum.Albums.Any();
decision = GetDecisionForReport(remoteAlbum, searchCriteria);
}
}
}
}
catch (Exception e)
{
_logger.Error(e, "Couldn't process release.");
var remoteAlbum = new RemoteAlbum {
Release = report
};
decision = new DownloadDecision(remoteAlbum, new Rejection("Unexpected error processing release"));
}
reportNumber++;
if (decision != null)
{
if (decision.Rejections.Any())
{
_logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections));
}
else
{
_logger.Debug("Release accepted");
}
yield return(decision);
}
}
}
private IEnumerable <DownloadDecision> GetDecisions(List <ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
{
if (reports.Any())
{
_logger.ProgressInfo("Processing {0} releases", reports.Count);
}
else
{
_logger.ProgressInfo("No results found");
}
var reportNumber = 1;
foreach (var report in reports)
{
DownloadDecision decision = null;
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
try
{
var parsedEpisodeInfo = Parser.Parser.ParseTitle(report.Title);
if (parsedEpisodeInfo == null || parsedEpisodeInfo.IsPossibleSpecialEpisode)
{
var specialEpisodeInfo = _parsingService.ParseSpecialEpisodeTitle(report.Title, report.TvRageId, searchCriteria);
if (specialEpisodeInfo != null)
{
parsedEpisodeInfo = specialEpisodeInfo;
}
}
if (parsedEpisodeInfo != null && !parsedEpisodeInfo.SeriesTitle.IsNullOrWhiteSpace())
{
var remoteEpisode = _parsingService.Map(parsedEpisodeInfo, report.TvRageId, searchCriteria);
remoteEpisode.Release = report;
if (remoteEpisode.Series != null)
{
remoteEpisode.DownloadAllowed = remoteEpisode.Episodes.Any();
decision = GetDecisionForReport(remoteEpisode, searchCriteria);
}
else
{
decision = new DownloadDecision(remoteEpisode, new Rejection("Unknown Series"));
}
}
}
catch (Exception e)
{
_logger.ErrorException("Couldn't process release.", e);
}
reportNumber++;
if (decision != null)
{
if (decision.Rejections.Any())
{
_logger.Debug("Release rejected for the following reasons: {0}", String.Join(", ", decision.Rejections));
}
yield return(decision);
}
}
}
protected override ReleaseResource MapDecision(DownloadDecision decision, int initialWeight)
{
_remoteEpisodeCache.Set(decision.RemoteEpisode.Release.Guid, decision.RemoteEpisode, TimeSpan.FromMinutes(30));
return base.MapDecision(decision, initialWeight);
}
private IEnumerable <DownloadDecision> GetMovieDecisions(List <ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
{
if (reports.Any())
{
_logger.ProgressInfo("Processing {0} releases", reports.Count);
}
else
{
_logger.ProgressInfo("No results found");
}
var reportNumber = 1;
foreach (var report in reports)
{
DownloadDecision decision = null;
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
try
{
var parsedMovieInfo = _parsingService.ParseMovieInfo(report.Title, new List <object> {
report
});
MappingResult result = null;
if (parsedMovieInfo == null || parsedMovieInfo.MovieTitle.IsNullOrWhiteSpace())
{
_logger.Debug("{0} could not be parsed :(.", report.Title);
parsedMovieInfo = new ParsedMovieInfo
{
MovieTitle = report.Title,
Year = 1290,
Languages = new List <Language> {
Language.Unknown
},
Quality = new QualityModel(),
};
if (_configService.ParsingLeniency == ParsingLeniencyType.MappingLenient)
{
result = _parsingService.Map(parsedMovieInfo, report.ImdbId.ToString(), searchCriteria);
}
if (result == null || result.MappingResultType != MappingResultType.SuccessLenientMapping)
{
result = new MappingResult {
MappingResultType = MappingResultType.NotParsable
};
result.Movie = null; //To ensure we have a remote movie, else null exception on next line!
result.RemoteMovie.ParsedMovieInfo = parsedMovieInfo;
}
else
{
//Enhance Parsed Movie Info!
result.RemoteMovie.ParsedMovieInfo = Parser.Parser.ParseMinimalMovieTitle(parsedMovieInfo.MovieTitle,
result.RemoteMovie.Movie.Title, parsedMovieInfo.Year);
}
}
else
{
result = _parsingService.Map(parsedMovieInfo, report.ImdbId.ToString(), searchCriteria);
}
result.ReleaseName = report.Title;
var remoteMovie = result.RemoteMovie;
remoteMovie.Release = report;
remoteMovie.MappingResult = result.MappingResultType;
if (result.MappingResultType != MappingResultType.Success && result.MappingResultType != MappingResultType.SuccessLenientMapping)
{
var rejection = result.ToRejection();
decision = new DownloadDecision(remoteMovie, rejection);
}
else
{
if (parsedMovieInfo.Quality.HardcodedSubs.IsNotNullOrWhiteSpace())
{
//remoteMovie.DownloadAllowed = true;
if (_configService.AllowHardcodedSubs)
{
decision = GetDecisionForReport(remoteMovie, searchCriteria);
}
else
{
var whitelisted = _configService.WhitelistedHardcodedSubs.Split(',');
_logger.Debug("Testing: {0}", whitelisted);
if (whitelisted != null && whitelisted.Any(t => (parsedMovieInfo.Quality.HardcodedSubs.ToLower().Contains(t.ToLower()) && t.IsNotNullOrWhiteSpace())))
{
decision = GetDecisionForReport(remoteMovie, searchCriteria);
}
else
{
decision = new DownloadDecision(remoteMovie, new Rejection("Hardcoded subs found: " + parsedMovieInfo.Quality.HardcodedSubs));
}
}
}
else
{
//remoteMovie.DownloadAllowed = true;
decision = GetDecisionForReport(remoteMovie, searchCriteria);
}
}
}
catch (Exception e)
{
_logger.Error(e, "Couldn't process release.");
var remoteMovie = new RemoteMovie {
Release = report
};
decision = new DownloadDecision(remoteMovie, new Rejection("Unexpected error processing release"));
}
reportNumber++;
if (decision != null)
{
if (decision.Rejections.Any())
{
_logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections));
}
else
{
_logger.Debug("Release accepted");
}
yield return(decision);
}
}
}
private IEnumerable <DownloadDecision> GetBookDecisions(List <ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
{
if (reports.Any())
{
_logger.ProgressInfo("Processing {0} releases", reports.Count);
}
else
{
_logger.ProgressInfo("No results found");
}
var reportNumber = 1;
foreach (var report in reports)
{
DownloadDecision decision = null;
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
_logger.Debug("Processing release '{0}' from '{1}'", report.Title, report.Indexer);
try
{
var parsedBookInfo = Parser.Parser.ParseBookTitle(report.Title);
if (parsedBookInfo == null)
{
if (searchCriteria != null)
{
parsedBookInfo = Parser.Parser.ParseBookTitleWithSearchCriteria(report.Title,
searchCriteria.Author,
searchCriteria.Books);
}
else
{
// try parsing fuzzy
parsedBookInfo = _parsingService.ParseAlbumTitleFuzzy(report.Title);
}
}
if (parsedBookInfo != null && !parsedBookInfo.AuthorName.IsNullOrWhiteSpace())
{
var remoteBook = _parsingService.Map(parsedBookInfo, searchCriteria);
// try parsing again using the search criteria, in case it parsed but parsed incorrectly
if ((remoteBook.Author == null || remoteBook.Books.Empty()) && searchCriteria != null)
{
_logger.Debug("Author/Book null for {0}, reparsing with search criteria", report.Title);
var parsedBookInfoWithCriteria = Parser.Parser.ParseBookTitleWithSearchCriteria(report.Title,
searchCriteria.Author,
searchCriteria.Books);
if (parsedBookInfoWithCriteria != null && parsedBookInfoWithCriteria.AuthorName.IsNotNullOrWhiteSpace())
{
remoteBook = _parsingService.Map(parsedBookInfoWithCriteria, searchCriteria);
}
}
remoteBook.Release = report;
if (remoteBook.Author == null)
{
decision = new DownloadDecision(remoteBook, new Rejection("Unknown Author"));
// shove in the searched author in case of forced download in interactive search
if (searchCriteria != null)
{
remoteBook.Author = searchCriteria.Author;
remoteBook.Books = searchCriteria.Books;
}
}
else if (remoteBook.Books.Empty())
{
decision = new DownloadDecision(remoteBook, new Rejection("Unable to parse books from release name"));
if (searchCriteria != null)
{
remoteBook.Books = searchCriteria.Books;
}
}
else
{
_aggregationService.Augment(remoteBook);
remoteBook.DownloadAllowed = remoteBook.Books.Any();
decision = GetDecisionForReport(remoteBook, searchCriteria);
}
}
if (searchCriteria != null)
{
if (parsedBookInfo == null)
{
parsedBookInfo = new ParsedBookInfo
{
Quality = QualityParser.ParseQuality(report.Title)
};
}
if (parsedBookInfo.AuthorName.IsNullOrWhiteSpace())
{
var remoteBook = new RemoteBook
{
Release = report,
ParsedBookInfo = parsedBookInfo
};
decision = new DownloadDecision(remoteBook, new Rejection("Unable to parse release"));
}
}
}
catch (Exception e)
{
_logger.Error(e, "Couldn't process release.");
var remoteBook = new RemoteBook {
Release = report
};
decision = new DownloadDecision(remoteBook, new Rejection("Unexpected error processing release"));
}
reportNumber++;
if (decision != null)
{
if (decision.Rejections.Any())
{
_logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections));
}
else
{
_logger.Debug("Release accepted");
}
yield return(decision);
}
}
}
private IEnumerable<DownloadDecision> GetDecisions(List<ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null)
{
if (reports.Any())
{
_logger.ProgressInfo("Processing {0} releases", reports.Count);
}
else
{
_logger.ProgressInfo("No results found");
}
var reportNumber = 1;
foreach (var report in reports)
{
DownloadDecision decision = null;
_logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count);
try
{
var parsedEpisodeInfo = Parser.Parser.ParseTitle(report.Title);
if (parsedEpisodeInfo == null || parsedEpisodeInfo.IsPossibleSpecialEpisode)
{
var specialEpisodeInfo = _parsingService.ParseSpecialEpisodeTitle(report.Title, report.TvdbId, report.TvRageId, searchCriteria);
if (specialEpisodeInfo != null)
{
parsedEpisodeInfo = specialEpisodeInfo;
}
}
if (parsedEpisodeInfo != null && !parsedEpisodeInfo.SeriesTitle.IsNullOrWhiteSpace())
{
var remoteEpisode = _parsingService.Map(parsedEpisodeInfo, report.TvdbId, report.TvRageId, searchCriteria);
remoteEpisode.Release = report;
if (remoteEpisode.Series == null)
{
decision = new DownloadDecision(remoteEpisode, new Rejection("Unknown Series"));
}
else if (remoteEpisode.Episodes.Empty())
{
decision = new DownloadDecision(remoteEpisode, new Rejection("Unable to parse episodes from release name"));
}
else
{
remoteEpisode.DownloadAllowed = remoteEpisode.Episodes.Any();
decision = GetDecisionForReport(remoteEpisode, searchCriteria);
}
}
}
catch (Exception e)
{
_logger.ErrorException("Couldn't process release.", e);
}
reportNumber++;
if (decision != null)
{
if (decision.Rejections.Any())
{
_logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections));
}
else
{
_logger.Debug("Release accepted");
}
yield return decision;
}
}
}