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); }
private bool ValidateSeasonAndEpisodeNumbers(List<Episode> episodes, ParsedEpisodeInfo parsedEpisodeInfo) { if (parsedEpisodeInfo.SeasonNumber != episodes.First().SeasonNumber || !parsedEpisodeInfo.EpisodeNumbers.OrderBy(e => e).SequenceEqual(episodes.Select(e => e.EpisodeNumber).OrderBy(e => e))) { return false; } return true; }
public void should_return_true_when_episode_numbers_is_empty() { var parsedEpisodeInfo = new ParsedEpisodeInfo { SeasonNumber = 1, SeriesTitle = "" }; parsedEpisodeInfo.IsPossibleSpecialEpisode().Should().BeTrue(); }
public void should_not_treat_files_without_a_series_title_as_a_special() { var parsedEpisodeInfo = new ParsedEpisodeInfo { EpisodeNumbers = new[]{ 7 }, SeasonNumber = 1, SeriesTitle = "" }; parsedEpisodeInfo.IsPossibleSpecialEpisode().Should().BeFalse(); }
public List<ImportDecision> GetImportDecisions(List<string> videoFiles, Series series, ParsedEpisodeInfo folderInfo, bool sceneSource) { var newFiles = _mediaFileService.FilterExistingFiles(videoFiles.ToList(), series); _logger.Debug("Analyzing {0}/{1} files.", newFiles.Count, videoFiles.Count()); var shouldUseFolderName = ShouldUseFolderName(videoFiles, series, folderInfo); var decisions = new List<ImportDecision>(); foreach (var file in newFiles) { decisions.AddIfNotNull(GetDecision(file, series, folderInfo, sceneSource, shouldUseFolderName)); } return decisions; }
private ImportDecision GetDecision(string file, Series series, ParsedEpisodeInfo folderInfo, bool sceneSource, bool shouldUseFolderName) { ImportDecision decision = null; try { var localEpisode = _parsingService.GetLocalEpisode(file, series, shouldUseFolderName ? folderInfo : null, sceneSource); if (localEpisode != null) { localEpisode.Quality = GetQuality(folderInfo, localEpisode.Quality, series); localEpisode.Size = _diskProvider.GetFileSize(file); _logger.Debug("Size: {0}", localEpisode.Size); //TODO: make it so media info doesn't ruin the import process of a new series if (sceneSource) { localEpisode.MediaInfo = _videoFileInfoReader.GetMediaInfo(file); } if (localEpisode.Episodes.Empty()) { decision = new ImportDecision(localEpisode, new Rejection("Invalid season or episode")); } else { decision = GetDecision(localEpisode); } } else { localEpisode = new LocalEpisode(); localEpisode.Path = file; decision = new ImportDecision(localEpisode, new Rejection("Unable to parse file")); } } catch (Exception e) { _logger.ErrorException("Couldn't import file. " + file, e); } return decision; }
public LocalEpisode GetLocalEpisode(string filename, Series series, ParsedEpisodeInfo folderInfo, bool sceneSource) { ParsedEpisodeInfo parsedEpisodeInfo; if (folderInfo != null) { parsedEpisodeInfo = folderInfo.JsonClone(); parsedEpisodeInfo.Quality = QualityParser.ParseQuality(Path.GetFileName(filename)); } else { parsedEpisodeInfo = Parser.ParsePath(filename); } if (parsedEpisodeInfo == null || parsedEpisodeInfo.IsPossibleSpecialEpisode) { var title = Path.GetFileNameWithoutExtension(filename); var specialEpisodeInfo = ParseSpecialEpisodeTitle(title, series); if (specialEpisodeInfo != null) { parsedEpisodeInfo = specialEpisodeInfo; } } if (parsedEpisodeInfo == null) { return null; } var episodes = GetEpisodes(parsedEpisodeInfo, series, sceneSource); return new LocalEpisode { Series = series, Quality = parsedEpisodeInfo.Quality, Episodes = episodes, Path = filename, ParsedEpisodeInfo = parsedEpisodeInfo, ExistingFile = series.Path.IsParentPath(filename) }; }
public RemoteEpisode Map(ParsedEpisodeInfo parsedEpisodeInfo, int tvRageId, SearchCriteriaBase searchCriteria = null) { var remoteEpisode = new RemoteEpisode { ParsedEpisodeInfo = parsedEpisodeInfo, }; var series = searchCriteria == null ? GetSeries(parsedEpisodeInfo, tvRageId) : GetSeries(parsedEpisodeInfo, tvRageId, searchCriteria); if (series == null) { return remoteEpisode; } remoteEpisode.Series = series; remoteEpisode.Episodes = GetEpisodes(parsedEpisodeInfo, series, true, searchCriteria); return remoteEpisode; }
private ParsedEpisodeInfo ParseSpecialEpisodeTitle(string title, Series series) { // find special episode in series season 0 var episode = _episodeService.FindEpisodeByTitle(series.Id, 0, title); if (episode != null) { // create parsed info from tv episode var info = new ParsedEpisodeInfo(); info.SeriesTitle = series.Title; info.SeriesTitleInfo = new SeriesTitleInfo(); info.SeriesTitleInfo.Title = info.SeriesTitle; info.SeasonNumber = episode.SeasonNumber; info.EpisodeNumbers = new int[1] { episode.EpisodeNumber }; info.FullSeason = false; info.Quality = QualityParser.ParseQuality(title); info.ReleaseGroup = Parser.ParseReleaseGroup(title); info.Language = Parser.ParseLanguage(title); info.Special = true; _logger.Debug("Found special episode {0} for title '{1}'", info, title); return info; } return null; }
public RemoteEpisode Map(ParsedEpisodeInfo parsedEpisodeInfo, int seriesId, IEnumerable<int> episodeIds) { return new RemoteEpisode { ParsedEpisodeInfo = parsedEpisodeInfo, Series = _seriesService.GetSeries(seriesId), Episodes = _episodeService.GetEpisodes(episodeIds) }; }
public List<Episode> GetEpisodes(ParsedEpisodeInfo parsedEpisodeInfo, Series series, bool sceneSource, SearchCriteriaBase searchCriteria = null) { var result = new List<Episode>(); 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 result; } var episodeInfo = GetDailyEpisode(series, parsedEpisodeInfo.AirDate, searchCriteria); if (episodeInfo != null) { result.Add(episodeInfo); } return result; } if (parsedEpisodeInfo.IsAbsoluteNumbering) { var sceneSeasonNumber = _sceneMappingService.GetSeasonNumber(parsedEpisodeInfo.SeriesTitle); foreach (var absoluteEpisodeNumber in parsedEpisodeInfo.AbsoluteEpisodeNumbers) { Episode episode = null; if (parsedEpisodeInfo.Special) { episode = _episodeService.FindEpisode(series.Id, 0, absoluteEpisodeNumber); } else if (sceneSource) { // Is there a reason why we excluded season 1 from this handling before? // Might have something to do with the scene name to season number check // If this needs to be reverted tests will need to be added if (sceneSeasonNumber.HasValue) { var episodes = _episodeService.FindEpisodesBySceneNumbering(series.Id, sceneSeasonNumber.Value, absoluteEpisodeNumber); if (episodes.Count == 1) { episode = episodes.First(); } if (episode == null) { episode = _episodeService.FindEpisode(series.Id, sceneSeasonNumber.Value, absoluteEpisodeNumber); } } else { episode = _episodeService.FindEpisodeBySceneNumbering(series.Id, absoluteEpisodeNumber); } } if (episode == null) { episode = _episodeService.FindEpisode(series.Id, absoluteEpisodeNumber); } if (episode != null) { _logger.Debug("Using absolute episode number {0} for: {1} - TVDB: {2}x{3:00}", absoluteEpisodeNumber, series.Title, episode.SeasonNumber, episode.EpisodeNumber); result.Add(episode); } } return result; } if (parsedEpisodeInfo.EpisodeNumbers == null) return result; foreach (var episodeNumber in parsedEpisodeInfo.EpisodeNumbers) { if (series.UseSceneNumbering && sceneSource) { List<Episode> episodes = new List<Episode>(); if (searchCriteria != null) { episodes = searchCriteria.Episodes.Where(e => e.SceneSeasonNumber == parsedEpisodeInfo.SeasonNumber && e.SceneEpisodeNumber == episodeNumber).ToList(); } if (!episodes.Any()) { episodes = _episodeService.FindEpisodesBySceneNumbering(series.Id, parsedEpisodeInfo.SeasonNumber, episodeNumber); } if (episodes != null && episodes.Any()) { _logger.Debug("Using Scene to TVDB Mapping for: {0} - Scene: {1}x{2:00} - TVDB: {3}", series.Title, episodes.First().SceneSeasonNumber, episodes.First().SceneEpisodeNumber, string.Join(", ", episodes.Select(e => string.Format("{0}x{1:00}", e.SeasonNumber, e.EpisodeNumber)))); result.AddRange(episodes); continue; } } Episode episodeInfo = null; if (searchCriteria != null) { episodeInfo = searchCriteria.Episodes.SingleOrDefault(e => e.SeasonNumber == parsedEpisodeInfo.SeasonNumber && e.EpisodeNumber == episodeNumber); } if (episodeInfo == null) { episodeInfo = _episodeService.FindEpisode(series.Id, parsedEpisodeInfo.SeasonNumber, episodeNumber); } if (episodeInfo != null) { result.Add(episodeInfo); } else { _logger.Debug("Unable to find {0}", parsedEpisodeInfo); } } return result; }
public List<Episode> GetEpisodes(ParsedEpisodeInfo parsedEpisodeInfo, Series series, bool sceneSource, SearchCriteriaBase searchCriteria = null) { var result = new List<Episode>(); 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 result; } var episodeInfo = GetDailyEpisode(series, parsedEpisodeInfo.AirDate, searchCriteria); if (episodeInfo != null) { result.Add(episodeInfo); } return result; } if (parsedEpisodeInfo.IsAbsoluteNumbering()) { foreach (var absoluteEpisodeNumber in parsedEpisodeInfo.AbsoluteEpisodeNumbers) { var episodeInfo = _episodeService.FindEpisode(series.Id, absoluteEpisodeNumber); if (episodeInfo != null) { _logger.Info("Using absolute episode number {0} for: {1} - TVDB: {2}x{3:00}", absoluteEpisodeNumber, series.Title, episodeInfo.SeasonNumber, episodeInfo.EpisodeNumber); result.Add(episodeInfo); } } return result; } if (parsedEpisodeInfo.EpisodeNumbers == null) return result; foreach (var episodeNumber in parsedEpisodeInfo.EpisodeNumbers) { if (series.UseSceneNumbering && sceneSource) { List<Episode> episodes = new List<Episode>(); if (searchCriteria != null) { episodes = searchCriteria.Episodes.Where(e => e.SceneSeasonNumber == parsedEpisodeInfo.SeasonNumber && e.SceneEpisodeNumber == episodeNumber).ToList(); } if (!episodes.Any()) { episodes = _episodeService.FindEpisodesBySceneNumbering(series.Id, parsedEpisodeInfo.SeasonNumber, episodeNumber); } if (episodes != null && episodes.Any()) { _logger.Info("Using Scene to TVDB Mapping for: {0} - Scene: {1}x{2:00} - TVDB: {3}", series.Title, episodes.First().SceneSeasonNumber, episodes.First().SceneEpisodeNumber, String.Join(", ", episodes.Select(e => String.Format("{0}x{1:00}", e.SeasonNumber, e.EpisodeNumber)))); result.AddRange(episodes); continue; } } Episode episodeInfo = null; if (searchCriteria != null) { episodeInfo = searchCriteria.Episodes.SingleOrDefault(e => e.SeasonNumber == parsedEpisodeInfo.SeasonNumber && e.EpisodeNumber == episodeNumber); } if (episodeInfo == null) { episodeInfo = _episodeService.FindEpisode(series.Id, parsedEpisodeInfo.SeasonNumber, episodeNumber); } if (episodeInfo != null) { result.Add(episodeInfo); } else { _logger.Debug("Unable to find {0}", parsedEpisodeInfo); } } return result; }
private static ParsedEpisodeInfo ParseMatchCollection(MatchCollection matchCollection) { var seriesName = matchCollection[0].Groups["title"].Value.Replace('.', ' '); int airYear; Int32.TryParse(matchCollection[0].Groups["airyear"].Value, out airYear); ParsedEpisodeInfo result; if (airYear < 1900) { var seasons = new List<int>(); foreach (Capture seasonCapture in matchCollection[0].Groups["season"].Captures) { int parsedSeason; if (Int32.TryParse(seasonCapture.Value, out parsedSeason)) seasons.Add(parsedSeason); } //If no season was found it should be treated as a mini series and season 1 if (seasons.Count == 0) seasons.Add(1); //If more than 1 season was parsed go to the next REGEX (A multi-season release is unlikely) if (seasons.Distinct().Count() > 1) return null; result = new ParsedEpisodeInfo { SeasonNumber = seasons.First(), EpisodeNumbers = new int[0], AbsoluteEpisodeNumbers = new int[0] }; foreach (Match matchGroup in matchCollection) { var episodeCaptures = matchGroup.Groups["episode"].Captures.Cast<Capture>().ToList(); var absoluteEpisodeCaptures = matchGroup.Groups["absoluteepisode"].Captures.Cast<Capture>().ToList(); //Allows use to return a list of 0 episodes (We can handle that as a full season release) if (episodeCaptures.Any()) { var first = Convert.ToInt32(episodeCaptures.First().Value); var last = Convert.ToInt32(episodeCaptures.Last().Value); if (first > last) { return null; } var count = last - first + 1; result.EpisodeNumbers = Enumerable.Range(first, count).ToArray(); } if (absoluteEpisodeCaptures.Any()) { var first = Convert.ToInt32(absoluteEpisodeCaptures.First().Value); var last = Convert.ToInt32(absoluteEpisodeCaptures.Last().Value); if (first > last) { return null; } var count = last - first + 1; result.AbsoluteEpisodeNumbers = Enumerable.Range(first, count).ToArray(); } if (!episodeCaptures.Any() && !absoluteEpisodeCaptures.Any()) { //Check to see if this is an "Extras" or "SUBPACK" release, if it is, return NULL //Todo: Set a "Extras" flag in EpisodeParseResult if we want to download them ever if (!matchCollection[0].Groups["extras"].Value.IsNullOrWhiteSpace()) return null; result.FullSeason = true; } } if (result.AbsoluteEpisodeNumbers.Any() && !result.EpisodeNumbers.Any()) { result.SeasonNumber = 0; } } else { //Try to Parse as a daily show var airmonth = Convert.ToInt32(matchCollection[0].Groups["airmonth"].Value); var airday = Convert.ToInt32(matchCollection[0].Groups["airday"].Value); //Swap day and month if month is bigger than 12 (scene fail) if (airmonth > 12) { var tempDay = airday; airday = airmonth; airmonth = tempDay; } var airDate = new DateTime(airYear, airmonth, airday); //Check if episode is in the future (most likely a parse error) if (airDate > DateTime.Now.AddDays(1).Date || airDate < new DateTime(1970, 1, 1)) { throw new InvalidDateException("Invalid date found: {0}", airDate); } result = new ParsedEpisodeInfo { AirDate = airDate.ToString(Episode.AIR_DATE_FORMAT), }; } result.SeriesTitle = CleanSeriesTitle(seriesName); result.SeriesTitleInfo = GetSeriesTitleInfo(result.SeriesTitle); Logger.Debug("Episode Parsed. {0}", result); return result; }
private Series GetSeries(ParsedEpisodeInfo parsedEpisodeInfo, int tvRageId, SearchCriteriaBase searchCriteria) { var tvdbId = _sceneMappingService.GetTvDbId(parsedEpisodeInfo.SeriesTitle); if (tvdbId.HasValue) { if (searchCriteria.Series.TvdbId == tvdbId) { return searchCriteria.Series; } } if (parsedEpisodeInfo.SeriesTitle.CleanSeriesTitle() == searchCriteria.Series.CleanTitle) { return searchCriteria.Series; } if (tvRageId == searchCriteria.Series.TvRageId) { //TODO: If series is found by TvRageId, we should report it as a scene naming exception, since it will fail to import return searchCriteria.Series; } return GetSeries(parsedEpisodeInfo, tvRageId); }
private Series GetSeries(ParsedEpisodeInfo parsedEpisodeInfo, int tvRageId) { var series = _seriesService.FindByTitle(parsedEpisodeInfo.SeriesTitle); if (series == null && tvRageId > 0) { //TODO: If series is found by TvRageId, we should report it as a scene naming exception, since it will fail to import series = _seriesService.FindByTvRageId(tvRageId); } if (series == null) { _logger.Debug("No matching series {0}", parsedEpisodeInfo.SeriesTitle); return null; } return series; }
private bool ShouldUseFolderName(List<string> videoFiles, Series series, ParsedEpisodeInfo folderInfo) { if (folderInfo == null) { return false; } if (folderInfo.FullSeason) { return false; } return videoFiles.Count(file => { var size = _diskProvider.GetFileSize(file); var fileQuality = QualityParser.ParseQuality(file); var sample = _detectSample.IsSample(series, GetQuality(folderInfo, fileQuality, series), file, size, folderInfo.SeasonNumber); if (sample) { return false; } if (SceneChecker.IsSceneTitle(Path.GetFileName(file))) { return false; } return true; }) == 1; }
private List<Episode> GetAnimeEpisodes(Series series, ParsedEpisodeInfo parsedEpisodeInfo, bool sceneSource) { var result = new List<Episode>(); var sceneSeasonNumber = _sceneMappingService.GetSceneSeasonNumber(parsedEpisodeInfo.SeriesTitle); foreach (var absoluteEpisodeNumber in parsedEpisodeInfo.AbsoluteEpisodeNumbers) { Episode episode = null; if (parsedEpisodeInfo.Special) { episode = _episodeService.FindEpisode(series.Id, 0, absoluteEpisodeNumber); } else if (sceneSource) { // Is there a reason why we excluded season 1 from this handling before? // Might have something to do with the scene name to season number check // If this needs to be reverted tests will need to be added if (sceneSeasonNumber.HasValue) { var episodes = _episodeService.FindEpisodesBySceneNumbering(series.Id, sceneSeasonNumber.Value, absoluteEpisodeNumber); if (episodes.Count == 1) { episode = episodes.First(); } if (episode == null) { episode = _episodeService.FindEpisode(series.Id, sceneSeasonNumber.Value, absoluteEpisodeNumber); } } else { episode = _episodeService.FindEpisodeBySceneNumbering(series.Id, absoluteEpisodeNumber); } } if (episode == null) { episode = _episodeService.FindEpisode(series.Id, absoluteEpisodeNumber); } if (episode != null) { _logger.Debug("Using absolute episode number {0} for: {1} - TVDB: {2}x{3:00}", absoluteEpisodeNumber, series.Title, episode.SeasonNumber, episode.EpisodeNumber); result.Add(episode); } } return result; }
private List<Episode> GetStandardEpisodes(Series series, ParsedEpisodeInfo parsedEpisodeInfo, bool sceneSource, SearchCriteriaBase searchCriteria) { var result = new List<Episode>(); var seasonNumber = parsedEpisodeInfo.SeasonNumber; if (sceneSource) { var sceneMapping = _sceneMappingService.FindSceneMapping(parsedEpisodeInfo.SeriesTitle); if (sceneMapping != null && sceneMapping.SeasonNumber.HasValue && sceneMapping.SeasonNumber.Value >= 0 && sceneMapping.SceneSeasonNumber == seasonNumber) { seasonNumber = sceneMapping.SeasonNumber.Value; } } if (parsedEpisodeInfo.EpisodeNumbers == null) { return new List<Episode>(); } foreach (var episodeNumber in parsedEpisodeInfo.EpisodeNumbers) { if (series.UseSceneNumbering && sceneSource) { List<Episode> episodes = new List<Episode>(); if (searchCriteria != null) { episodes = searchCriteria.Episodes.Where(e => e.SceneSeasonNumber == parsedEpisodeInfo.SeasonNumber && e.SceneEpisodeNumber == episodeNumber).ToList(); } if (!episodes.Any()) { episodes = _episodeService.FindEpisodesBySceneNumbering(series.Id, seasonNumber, episodeNumber); } if (episodes != null && episodes.Any()) { _logger.Debug("Using Scene to TVDB Mapping for: {0} - Scene: {1}x{2:00} - TVDB: {3}", series.Title, episodes.First().SceneSeasonNumber, episodes.First().SceneEpisodeNumber, string.Join(", ", episodes.Select(e => string.Format("{0}x{1:00}", e.SeasonNumber, e.EpisodeNumber)))); result.AddRange(episodes); continue; } } Episode episodeInfo = null; if (searchCriteria != null) { episodeInfo = searchCriteria.Episodes.SingleOrDefault(e => e.SeasonNumber == seasonNumber && e.EpisodeNumber == episodeNumber); } if (episodeInfo == null) { episodeInfo = _episodeService.FindEpisode(series.Id, seasonNumber, episodeNumber); } if (episodeInfo != null) { result.Add(episodeInfo); } else { _logger.Debug("Unable to find {0}", parsedEpisodeInfo); } } return result; }
private Series GetSeries(ParsedEpisodeInfo parsedEpisodeInfo, int tvdbId, int tvRageId, SearchCriteriaBase searchCriteria) { Series series = null; var sceneMappingTvdbId = _sceneMappingService.FindTvdbId(parsedEpisodeInfo.SeriesTitle); if (sceneMappingTvdbId.HasValue) { if (searchCriteria != null && searchCriteria.Series.TvdbId == sceneMappingTvdbId.Value) { return searchCriteria.Series; } series = _seriesService.FindByTvdbId(sceneMappingTvdbId.Value); if (series == null) { _logger.Debug("No matching series {0}", parsedEpisodeInfo.SeriesTitle); return null; } return series; } if (searchCriteria != null) { if (searchCriteria.Series.CleanTitle == parsedEpisodeInfo.SeriesTitle.CleanSeriesTitle()) { return searchCriteria.Series; } if (tvdbId > 0 && tvdbId == searchCriteria.Series.TvdbId) { //TODO: If series is found by TvdbId, we should report it as a scene naming exception, since it will fail to import return searchCriteria.Series; } if (tvRageId > 0 && tvRageId == searchCriteria.Series.TvRageId) { //TODO: If series is found by TvRageId, we should report it as a scene naming exception, since it will fail to import return searchCriteria.Series; } } series = _seriesService.FindByTitle(parsedEpisodeInfo.SeriesTitle); if (series == null && tvdbId > 0) { //TODO: If series is found by TvdbId, we should report it as a scene naming exception, since it will fail to import series = _seriesService.FindByTvdbId(tvdbId); } if (series == null && tvRageId > 0) { //TODO: If series is found by TvRageId, we should report it as a scene naming exception, since it will fail to import series = _seriesService.FindByTvRageId(tvRageId); } if (series == null) { _logger.Debug("No matching series {0}", parsedEpisodeInfo.SeriesTitle); return null; } return series; }
public List<Episode> GetEpisodes(ParsedEpisodeInfo parsedEpisodeInfo, Series series, bool sceneSource, SearchCriteriaBase searchCriteria = null) { var result = new List<Episode>(); if (parsedEpisodeInfo.AirDate.HasValue) { if (series.SeriesType == SeriesTypes.Standard) { _logger.Warn("Found daily-style episode for non-daily series: {0}.", series); return null; } var episodeInfo = GetDailyEpisode(series, parsedEpisodeInfo.AirDate.Value, searchCriteria); if (episodeInfo != null) { result.Add(episodeInfo); } return result; } if (parsedEpisodeInfo.EpisodeNumbers == null) return result; foreach (var episodeNumber in parsedEpisodeInfo.EpisodeNumbers) { Episode episodeInfo = null; if (series.UseSceneNumbering && sceneSource) { if (searchCriteria != null) { episodeInfo = searchCriteria.Episodes.SingleOrDefault(e => e.SceneSeasonNumber == parsedEpisodeInfo.SeasonNumber && e.SceneEpisodeNumber == episodeNumber); } if (episodeInfo == null) { episodeInfo = _episodeService.FindEpisode(series.Id, parsedEpisodeInfo.SeasonNumber, episodeNumber, true); } if (episodeInfo != null) { _logger.Info("Using Scene to TVDB Mapping for: {0} - Scene: {1}x{2:00} - TVDB: {3}x{4:00}", series.Title, episodeInfo.SceneSeasonNumber, episodeInfo.SceneEpisodeNumber, episodeInfo.SeasonNumber, episodeInfo.EpisodeNumber); } } if (episodeInfo == null && searchCriteria != null) { episodeInfo = searchCriteria.Episodes.SingleOrDefault(e => e.SeasonNumber == parsedEpisodeInfo.SeasonNumber && e.EpisodeNumber == episodeNumber); } if (episodeInfo == null) { episodeInfo = _episodeService.FindEpisode(series.Id, parsedEpisodeInfo.SeasonNumber, episodeNumber); } if (episodeInfo != null) { result.Add(episodeInfo); } else { _logger.Debug("Unable to find {0}", parsedEpisodeInfo); } } return result; }
private bool UseFolderQuality(ParsedEpisodeInfo folderInfo, QualityModel fileQuality, Series series) { if (folderInfo == null) { return false; } if (folderInfo.Quality.Quality == Quality.Unknown) { return false; } if (fileQuality.QualitySource == QualitySource.Extension) { return true; } if (new QualityModelComparer(series.Profile).Compare(folderInfo.Quality, fileQuality) > 0) { return true; } return false; }
private QualityModel GetQuality(ParsedEpisodeInfo folderInfo, QualityModel fileQuality, Series series) { if (UseFolderQuality(folderInfo, fileQuality, series)) { _logger.Debug("Using quality from folder: {0}", folderInfo.Quality); return folderInfo.Quality; } return fileQuality; }
private QualityModel GetQuality(ParsedEpisodeInfo folderInfo, QualityModel fileQuality, Series series) { if (folderInfo != null && folderInfo.Quality.Quality != Quality.Unknown && new QualityModelComparer(series.Profile).Compare(folderInfo.Quality, fileQuality) > 0) { _logger.Debug("Using quality from folder: {0}", folderInfo.Quality); return folderInfo.Quality; } return fileQuality; }
private QualityModel GetQuality(ParsedEpisodeInfo folderInfo, QualityModel fileQuality, Series series) { if (folderInfo != null && folderInfo.Quality.Quality != Quality.Unknown && fileQuality.QualitySource == QualitySource.Extension) { _logger.Debug("Using quality from folder: {0}", folderInfo.Quality); return folderInfo.Quality; } return fileQuality; }