private List <Episode> GetEpisodes(LocalEpisode localEpisode)
        {
            var bestEpisodeInfoForEpisodes = GetBestEpisodeInfo(localEpisode);
            var isMediaFile = MediaFileExtensions.Extensions.Contains(Path.GetExtension(localEpisode.Path));

            if (bestEpisodeInfoForEpisodes == null)
            {
                return(new List <Episode>());
            }

            if (ValidateParsedEpisodeInfo.ValidateForSeriesType(bestEpisodeInfoForEpisodes, localEpisode.Series, isMediaFile))
            {
                var episodes = _parsingService.GetEpisodes(bestEpisodeInfoForEpisodes, localEpisode.Series, localEpisode.SceneSource);

                if (episodes.Empty() && bestEpisodeInfoForEpisodes.IsPossibleSpecialEpisode)
                {
                    var parsedSpecialEpisodeInfo = GetSpecialEpisodeInfo(localEpisode, bestEpisodeInfoForEpisodes);

                    if (parsedSpecialEpisodeInfo != null)
                    {
                        episodes = _parsingService.GetEpisodes(parsedSpecialEpisodeInfo, localEpisode.Series, localEpisode.SceneSource);
                    }
                }

                return(episodes);
            }

            return(new List <Episode>());
        }
        public void should_not_log_warning_if_warnIfInvalid_is_false()
        {
            GivenDailyParsedEpisodeInfo();

            ValidateParsedEpisodeInfo.ValidateForSeriesType(_parsedEpisodeInfo, _series, false);
            ExceptionVerification.ExpectedWarns(0);
        }
        public void should_return_false_if_episode_info_is_daily_for_standard_series()
        {
            GivenDailyParsedEpisodeInfo();

            ValidateParsedEpisodeInfo.ValidateForSeriesType(_parsedEpisodeInfo, _series).Should().BeFalse();
            ExceptionVerification.ExpectedWarns(1);
        }
        public void should_return_true_if_episode_info_is_daily_for_daily_series()
        {
            GivenDailyParsedEpisodeInfo();
            GivenDailySeries();

            ValidateParsedEpisodeInfo.ValidateForSeriesType(_parsedEpisodeInfo, _series).Should().BeTrue();
        }
        private List <Episode> GetEpisodes(LocalEpisode localEpisode, bool otherFiles)
        {
            var bestEpisodeInfoForEpisodes = GetBestEpisodeInfo(localEpisode, otherFiles);
            var isMediaFile = MediaFileExtensions.Extensions.Contains(Path.GetExtension(localEpisode.Path));

            if (bestEpisodeInfoForEpisodes == null)
            {
                return(new List <Episode>());
            }

            if (ValidateParsedEpisodeInfo.ValidateForSeriesType(bestEpisodeInfoForEpisodes, localEpisode.Series, isMediaFile))
            {
                return(_parsingService.GetEpisodes(bestEpisodeInfoForEpisodes, localEpisode.Series, localEpisode.SceneSource));
            }

            return(new List <Episode>());
        }
Exemple #6
0
        private List <PendingRelease> IncludeRemoteEpisodes(List <PendingRelease> releases, Dictionary <string, RemoteEpisode> knownRemoteEpisodes = null)
        {
            var result = new List <PendingRelease>();

            var seriesMap = new Dictionary <int, Series>();

            if (knownRemoteEpisodes != null)
            {
                foreach (var series in knownRemoteEpisodes.Values.Select(v => v.Series))
                {
                    if (!seriesMap.ContainsKey(series.Id))
                    {
                        seriesMap[series.Id] = series;
                    }
                }
            }

            foreach (var series in _seriesService.GetSeries(releases.Select(v => v.SeriesId).Distinct().Where(v => !seriesMap.ContainsKey(v))))
            {
                seriesMap[series.Id] = series;
            }

            foreach (var release in releases)
            {
                var series = seriesMap.GetValueOrDefault(release.SeriesId);

                // Just in case the series was removed, but wasn't cleaned up yet (housekeeper will clean it up)
                if (series == null)
                {
                    return(null);
                }

                List <Episode> episodes;

                RemoteEpisode knownRemoteEpisode;
                if (knownRemoteEpisodes != null && knownRemoteEpisodes.TryGetValue(release.Release.Title, out knownRemoteEpisode))
                {
                    episodes = knownRemoteEpisode.Episodes;
                }
                else
                {
                    if (ValidateParsedEpisodeInfo.ValidateForSeriesType(release.ParsedEpisodeInfo, series))
                    {
                        episodes = _parsingService.GetEpisodes(release.ParsedEpisodeInfo, series, true);
                    }
                    else
                    {
                        episodes = new List <Episode>();
                    }
                }

                release.RemoteEpisode = new RemoteEpisode
                {
                    Series            = series,
                    Episodes          = episodes,
                    ParsedEpisodeInfo = release.ParsedEpisodeInfo,
                    Release           = release.Release
                };

                result.Add(release);
            }

            return(result);
        }
 public void should_return_true_if_episode_info_is_not_daily()
 {
     ValidateParsedEpisodeInfo.ValidateForSeriesType(_parsedEpisodeInfo, _series).Should().BeTrue();
 }