コード例 #1
0
        private async Task <IReadOnlyList <EpisodeRecord> > GetAllEpisodes(int tvdbId, string acceptedLanguage, EpisodeQuery?episodeQuery = null)
        {
            try
            {
                // Fetch all episodes for the series
                var allEpisodes = new List <EpisodeRecord>();
                var page        = 1;
                while (true)
                {
                    episodeQuery ??= new EpisodeQuery();
                    var episodes = await _tvdbClientManager.GetEpisodesPageAsync(
                        tvdbId,
                        page,
                        episodeQuery,
                        acceptedLanguage,
                        CancellationToken.None).ConfigureAwait(false);

                    allEpisodes.AddRange(episodes.Data);
                    if (!episodes.Links.Next.HasValue)
                    {
                        break;
                    }

                    page = episodes.Links.Next.Value;
                }

                return(allEpisodes);
            }
            catch (TvDbServerException ex)
            {
                _logger.LogWarning(ex, "Unable to get episodes from TVDB");
                return(Array.Empty <EpisodeRecord>());
            }
        }
コード例 #2
0
        private async Task <IReadOnlyList <EpisodeRecord> > GetAllEpisodes(int tvdbId, string acceptedLanguage, EpisodeQuery?episodeQuery = null)
        {
            // Fetch all episodes for the series
            var allEpisodes = new List <EpisodeRecord>();
            var page        = 1;

            while (true)
            {
                episodeQuery ??= new EpisodeQuery();
                var episodes = await _tvdbClientManager.GetEpisodesPageAsync(
                    tvdbId,
                    page,
                    episodeQuery,
                    acceptedLanguage,
                    CancellationToken.None).ConfigureAwait(false);

                allEpisodes.AddRange(episodes.Data);
                if (!episodes.Links.Next.HasValue)
                {
                    break;
                }

                page = episodes.Links.Next.Value;
            }

            return(allEpisodes);
        }
コード例 #3
0
        private async Task MapSeriesToResult(MetadataResult <Series> result, TvDbSharper.Dto.Series tvdbSeries, string metadataLanguage)
        {
            Series series = result.Item;

            series.SetProviderId(TvdbPlugin.ProviderId, tvdbSeries.Id.ToString(CultureInfo.InvariantCulture));
            series.Name            = tvdbSeries.SeriesName;
            series.Overview        = (tvdbSeries.Overview ?? string.Empty).Trim();
            result.ResultLanguage  = metadataLanguage;
            series.AirDays         = TVUtils.GetAirDays(tvdbSeries.AirsDayOfWeek);
            series.AirTime         = tvdbSeries.AirsTime;
            series.CommunityRating = (float?)tvdbSeries.SiteRating;
            series.SetProviderId(MetadataProvider.Imdb, tvdbSeries.ImdbId);
            series.SetProviderId(MetadataProvider.Zap2It, tvdbSeries.Zap2itId);
            if (Enum.TryParse(tvdbSeries.Status, true, out SeriesStatus seriesStatus))
            {
                series.Status = seriesStatus;
            }

            if (DateTime.TryParse(tvdbSeries.FirstAired, out var date))
            {
                // dates from tvdb are UTC but without offset or Z
                series.PremiereDate   = date;
                series.ProductionYear = date.Year;
            }

            if (!string.IsNullOrEmpty(tvdbSeries.Runtime) && double.TryParse(tvdbSeries.Runtime, out double runtime))
            {
                series.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
            }

            foreach (var genre in tvdbSeries.Genre)
            {
                series.AddGenre(genre);
            }

            if (!string.IsNullOrEmpty(tvdbSeries.Network))
            {
                series.AddStudio(tvdbSeries.Network);
            }

            if (result.Item.Status.HasValue && result.Item.Status.Value == SeriesStatus.Ended)
            {
                try
                {
                    var episodeSummary = await _tvdbClientManager.GetSeriesEpisodeSummaryAsync(tvdbSeries.Id, metadataLanguage, CancellationToken.None).ConfigureAwait(false);

                    if (episodeSummary.Data.AiredSeasons.Length != 0)
                    {
                        var maxSeasonNumber = episodeSummary.Data.AiredSeasons.Max(s => Convert.ToInt32(s, CultureInfo.InvariantCulture));
                        var episodeQuery    = new EpisodeQuery
                        {
                            AiredSeason = maxSeasonNumber
                        };
                        var episodesPage = await _tvdbClientManager.GetEpisodesPageAsync(tvdbSeries.Id, episodeQuery, metadataLanguage, CancellationToken.None).ConfigureAwait(false);

                        result.Item.EndDate = episodesPage.Data
                                              .Select(e => DateTime.TryParse(e.FirstAired, out var firstAired) ? firstAired : (DateTime?)null)
                                              .Max();
                    }
                }
                catch (TvDbServerException e)
                {
                    _logger.LogError(e, "Failed to find series end date for series {TvdbId}", tvdbSeries.Id);
                }
            }
        }