public void Test_TraktPost_SyncRatingsPostBuilder_AddRatedEpisode_And_RatedAt()
        {
            ITraktEpisode episode = new TraktEpisode
            {
                Ids = new TraktEpisodeIds
                {
                    Trakt  = 1,
                    Imdb   = "ttepisodetitle",
                    Tmdb   = 1,
                    Tvdb   = 1,
                    TvRage = 1
                }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .AddRatedEpisode(episode).WithRating(RATING, RATED_AT)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Episodes.Should().NotBeNull().And.HaveCount(1);

            ITraktSyncRatingsPostEpisode postEpisode = syncRatingsPost.Episodes.ToArray()[0];

            postEpisode.Ids.Should().NotBeNull();
            postEpisode.Ids.Trakt.Should().Be(1U);
            postEpisode.Ids.Imdb.Should().Be("ttepisodetitle");
            postEpisode.Ids.Tmdb.Should().Be(1U);
            postEpisode.Ids.Tvdb.Should().Be(1U);
            postEpisode.Ids.TvRage.Should().Be(1U);
            postEpisode.Rating.Should().Be(RATING);
            postEpisode.RatedAt.Should().Be(RATED_AT);

            syncRatingsPost.Movies.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Shows.Should().NotBeNull().And.BeEmpty();
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_WithEpisodes()
        {
            var episodes = new List <ITraktEpisode>
            {
                new TraktEpisode
                {
                    Ids = new TraktEpisodeIds
                    {
                        Trakt  = 1,
                        Imdb   = "ttepisode1title",
                        Tmdb   = 1,
                        Tvdb   = 1,
                        TvRage = 1
                    }
                },
                new TraktEpisode
                {
                    Ids = new TraktEpisodeIds
                    {
                        Trakt  = 2,
                        Imdb   = "ttepisode2title",
                        Tmdb   = 2,
                        Tvdb   = 2,
                        TvRage = 2
                    }
                }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .WithEpisodes(episodes)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Episodes.Should().NotBeNull().And.HaveCount(2);

            ITraktSyncRatingsPostEpisode[] postEpisodes = syncRatingsPost.Episodes.ToArray();

            postEpisodes[0].Ids.Should().NotBeNull();
            postEpisodes[0].Ids.Trakt.Should().Be(1U);
            postEpisodes[0].Ids.Imdb.Should().Be("ttepisode1title");
            postEpisodes[0].Ids.Tmdb.Should().Be(1U);
            postEpisodes[0].Ids.Tvdb.Should().Be(1U);
            postEpisodes[0].Ids.TvRage.Should().Be(1U);
            postEpisodes[0].Rating.Should().BeNull();
            postEpisodes[0].RatedAt.Should().BeNull();

            postEpisodes[1].Ids.Should().NotBeNull();
            postEpisodes[1].Ids.Trakt.Should().Be(2U);
            postEpisodes[1].Ids.Imdb.Should().Be("ttepisode2title");
            postEpisodes[1].Ids.Tmdb.Should().Be(2U);
            postEpisodes[1].Ids.Tvdb.Should().Be(2U);
            postEpisodes[1].Ids.TvRage.Should().Be(2U);
            postEpisodes[1].Rating.Should().BeNull();
            postEpisodes[1].RatedAt.Should().BeNull();

            syncRatingsPost.Movies.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Shows.Should().NotBeNull().And.BeEmpty();
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_Empty_Build()
        {
            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost().Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Movies.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Shows.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Episodes.Should().NotBeNull().And.BeEmpty();
        }
コード例 #4
0
        /// <summary>
        /// Adds items to the user's ratings. Accepts shows, seasons, episodes and movies.
        /// <para>OAuth authorization required.</para>
        /// <para>
        /// See <a href="http://docs.trakt.apiary.io/#reference/sync/add-ratings/add-new-ratings">"Trakt API Doc - Sync: Add Ratings"</a> for more information.
        /// </para>
        /// <para>
        /// It is recommended to use the <see cref="ITraktSyncRatingsPostBuilder" /> to create an instance
        /// of the required <see cref="ITraktSyncRatingsPost" />.
        /// See also <seealso cref="TraktPost.NewSyncRatingsPost()" />.
        /// </para>
        /// </summary>
        /// <param name="ratingsPost">An <see cref="ITraktSyncRatingsPost" /> instance containing all shows, seasons, episodes and movies, which should be added.</param>
        /// <param name="cancellationToken">
        /// Propagates notification that the request should be canceled.<para/>
        /// If provided, the exception <see cref="OperationCanceledException" /> should be catched.
        /// </param>
        /// <returns>An <see cref="ITraktSyncRatingsPostResponse" /> instance, which contains information about which items were added and not found.</returns>
        /// <exception cref="TraktException">Thrown, if the request fails.</exception>
        /// <exception cref="ArgumentNullException">Thrown if the given ratings post is null.</exception>
        /// <exception cref="ArgumentException">Thrown, if the given ratings post is empty.</exception>
        public Task <TraktResponse <ITraktSyncRatingsPostResponse> > AddRatingsAsync(ITraktSyncRatingsPost ratingsPost,
                                                                                     CancellationToken cancellationToken = default)
        {
            ValidateRatingsPost(ratingsPost);
            var requestHandler = new RequestHandler(Client);

            return(requestHandler.ExecuteSingleItemRequestAsync(new SyncRatingsAddRequest
            {
                RequestBody = ratingsPost
            },
                                                                cancellationToken));
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_AddShowAndSeasons()
        {
            ITraktShow show = new TraktShow
            {
                Title = "show title",
                Year  = 2020,
                Ids   = new TraktShowIds
                {
                    Trakt  = 1,
                    Slug   = "show-title",
                    Imdb   = "ttshowtitle",
                    Tmdb   = 1,
                    Tvdb   = 1,
                    TvRage = 1
                }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .AddShowAndSeasons(show).WithSeasons(1, 2, 3)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Shows.Should().NotBeNull().And.HaveCount(1);

            ITraktSyncRatingsPostShow postShow = syncRatingsPost.Shows.ToArray()[0];

            postShow.Title = "show title";
            postShow.Year  = 2020;
            postShow.Ids.Should().NotBeNull();
            postShow.Ids.Trakt.Should().Be(1U);
            postShow.Ids.Slug.Should().Be("show-title");
            postShow.Ids.Imdb.Should().Be("ttshowtitle");
            postShow.Ids.Tmdb.Should().Be(1U);
            postShow.Ids.Tvdb.Should().Be(1U);
            postShow.Ids.TvRage.Should().Be(1U);
            postShow.Rating.Should().BeNull();
            postShow.RatedAt.Should().BeNull();
            postShow.Seasons.Should().NotBeNull().And.HaveCount(3);

            ITraktSyncRatingsPostShowSeason[] seasons = postShow.Seasons.ToArray();

            seasons[0].Number.Should().Be(1);
            seasons[0].Episodes.Should().BeNull();

            seasons[1].Number.Should().Be(2);
            seasons[1].Episodes.Should().BeNull();

            seasons[2].Number.Should().Be(3);
            seasons[2].Episodes.Should().BeNull();

            syncRatingsPost.Movies.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Episodes.Should().NotBeNull().And.BeEmpty();
        }
コード例 #6
0
        private void AddEpisodes(ITraktSyncRatingsPost syncRatingsPost)
        {
            if (syncRatingsPost.Episodes == null)
            {
                syncRatingsPost.Episodes = new List <ITraktSyncRatingsPostEpisode>();
            }

            foreach (ITraktEpisode episode in _episodes)
            {
                (syncRatingsPost.Episodes as List <ITraktSyncRatingsPostEpisode>).Add(CreateSyncRatingsPostEpisode(episode));
            }

            foreach (PostBuilderRatedObject <ITraktEpisode> episodeEntry in _ratedEpisodes.EpisodesAndRating)
            {
                (syncRatingsPost.Episodes as List <ITraktSyncRatingsPostEpisode>).Add(CreateSyncRatingsPostEpisode(episodeEntry.Object, episodeEntry.Rating, episodeEntry.RatedAt));
            }
        }
コード例 #7
0
        private void AddMovies(ITraktSyncRatingsPost syncRatingsPost)
        {
            if (syncRatingsPost.Movies == null)
            {
                syncRatingsPost.Movies = new List <ITraktSyncRatingsPostMovie>();
            }

            foreach (ITraktMovie movie in _movies)
            {
                (syncRatingsPost.Movies as List <ITraktSyncRatingsPostMovie>).Add(CreateSyncRatingsPostMovie(movie));
            }

            foreach (PostBuilderRatedObject <ITraktMovie> movieEntry in _ratedMovies.MoviesAndRating)
            {
                (syncRatingsPost.Movies as List <ITraktSyncRatingsPostMovie>).Add(CreateSyncRatingsPostMovie(movieEntry.Object, movieEntry.Rating, movieEntry.RatedAt));
            }
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_AddRatedShow_And_RatedAt()
        {
            ITraktShow show = new TraktShow
            {
                Title = "show title",
                Year  = 2020,
                Ids   = new TraktShowIds
                {
                    Trakt  = 1,
                    Slug   = "show-title",
                    Imdb   = "ttshowtitle",
                    Tmdb   = 1,
                    Tvdb   = 1,
                    TvRage = 1
                }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .AddRatedShow(show).WithRating(RATING, RATED_AT)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Shows.Should().NotBeNull().And.HaveCount(1);

            ITraktSyncRatingsPostShow postShow = syncRatingsPost.Shows.ToArray()[0];

            postShow.Title = "show title";
            postShow.Year  = 2020;
            postShow.Ids.Should().NotBeNull();
            postShow.Ids.Trakt.Should().Be(1U);
            postShow.Ids.Slug.Should().Be("show-title");
            postShow.Ids.Imdb.Should().Be("ttshowtitle");
            postShow.Ids.Tmdb.Should().Be(1U);
            postShow.Ids.Tvdb.Should().Be(1U);
            postShow.Ids.TvRage.Should().Be(1U);
            postShow.Rating.Should().Be(RATING);
            postShow.RatedAt.Should().Be(RATED_AT);
            postShow.Seasons.Should().BeNull();

            syncRatingsPost.Movies.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Episodes.Should().NotBeNull().And.BeEmpty();
        }
コード例 #9
0
        private void ValidateRatingsPost(ITraktSyncRatingsPost ratingsPost)
        {
            if (ratingsPost == null)
            {
                throw new ArgumentNullException(nameof(ratingsPost), "ratings post must not be null");
            }

            IEnumerable <ITraktSyncRatingsPostMovie>   movies   = ratingsPost.Movies;
            IEnumerable <ITraktSyncRatingsPostShow>    shows    = ratingsPost.Shows;
            IEnumerable <ITraktSyncRatingsPostEpisode> episodes = ratingsPost.Episodes;

            bool bHasNoMovies   = movies == null || !movies.Any();
            bool bHasNoShows    = shows == null || !shows.Any();
            bool bHasNoEpisodes = episodes == null || !episodes.Any();

            if (bHasNoMovies && bHasNoShows && bHasNoEpisodes)
            {
                throw new ArgumentException("no ratings items set");
            }
        }
コード例 #10
0
        private void AddShows(ITraktSyncRatingsPost syncRatingsPost)
        {
            if (syncRatingsPost.Shows == null)
            {
                syncRatingsPost.Shows = new List <ITraktSyncRatingsPostShow>();
            }

            foreach (ITraktShow show in _shows)
            {
                (syncRatingsPost.Shows as List <ITraktSyncRatingsPostShow>).Add(CreateSyncRatingsPostShow(show));
            }

            foreach (PostBuilderRatedObject <ITraktShow> showEntry in _ratedShows.ShowsAndRating)
            {
                (syncRatingsPost.Shows as List <ITraktSyncRatingsPostShow>).Add(CreateSyncRatingsPostShow(showEntry.Object, showEntry.Rating, showEntry.RatedAt));
            }

            foreach (PostBuilderRatedObjectWithSeasons <ITraktShow, IEnumerable <int> > showEntry in _ratedShowsWithSeasons.ShowsAndRatingWithSeasons)
            {
                (syncRatingsPost.Shows as List <ITraktSyncRatingsPostShow>).Add(CreateSyncRatingsPostShowWithSeasons(showEntry.Object, showEntry.Rating, showEntry.RatedAt, showEntry.Seasons));
            }

            foreach (PostBuilderRatedObjectWithSeasons <ITraktShow, PostRatingsSeasons> showEntry in _ratedShowsWithSeasonsCollection.ShowsAndRatingWithSeasonsCollection)
            {
                (syncRatingsPost.Shows as List <ITraktSyncRatingsPostShow>).Add(CreateSyncRatingsPostShowWithSeasonsCollection(showEntry.Object, showEntry.Rating, showEntry.RatedAt, showEntry.Seasons));
            }

            foreach (PostBuilderObjectWithSeasons <ITraktShow, IEnumerable <int> > showEntry in _showsWithSeasons.ShowsWithSeasons)
            {
                (syncRatingsPost.Shows as List <ITraktSyncRatingsPostShow>).Add(CreateSyncRatingsPostShowWithSeasons(showEntry.Object, null, null, showEntry.Seasons));
            }

            foreach (PostBuilderObjectWithSeasons <ITraktShow, PostRatingsSeasons> showEntry in _showsWithSeasonsCollection.ShowsWithSeasonsCollection)
            {
                (syncRatingsPost.Shows as List <ITraktSyncRatingsPostShow>).Add(CreateSyncRatingsPostShowWithSeasonsCollection(showEntry.Object, null, null, showEntry.Seasons));
            }
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_WithMovie()
        {
            ITraktMovie movie = new TraktMovie
            {
                Title = "movie title",
                Year  = 2020,
                Ids   = new TraktMovieIds
                {
                    Trakt = 1,
                    Slug  = "movie-title",
                    Imdb  = "ttmovietitle",
                    Tmdb  = 1
                }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .WithMovie(movie)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Movies.Should().NotBeNull().And.HaveCount(1);

            ITraktSyncRatingsPostMovie postMovie = syncRatingsPost.Movies.ToArray()[0];

            postMovie.Title = "movie title";
            postMovie.Year  = 2020;
            postMovie.Ids.Should().NotBeNull();
            postMovie.Ids.Trakt.Should().Be(1U);
            postMovie.Ids.Slug.Should().Be("movie-title");
            postMovie.Ids.Imdb.Should().Be("ttmovietitle");
            postMovie.Ids.Tmdb.Should().Be(1U);
            postMovie.Rating.Should().BeNull();
            postMovie.RatedAt.Should().BeNull();

            syncRatingsPost.Shows.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Episodes.Should().NotBeNull().And.BeEmpty();
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_WithMovies()
        {
            var movies = new List <ITraktMovie>
            {
                new TraktMovie
                {
                    Title = "movie 1 title",
                    Year  = 2020,
                    Ids   = new TraktMovieIds
                    {
                        Trakt = 1,
                        Slug  = "movie-1-title",
                        Imdb  = "ttmovie1title",
                        Tmdb  = 1
                    }
                },
                new TraktMovie
                {
                    Title = "movie 2 title",
                    Year  = 2020,
                    Ids   = new TraktMovieIds
                    {
                        Trakt = 2,
                        Slug  = "movie-2-title",
                        Imdb  = "ttmovie2title",
                        Tmdb  = 2
                    }
                }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .WithMovies(movies)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Movies.Should().NotBeNull().And.HaveCount(2);

            ITraktSyncRatingsPostMovie[] postMovies = syncRatingsPost.Movies.ToArray();

            postMovies[0].Title = "movie 1 title";
            postMovies[0].Year  = 2020;
            postMovies[0].Ids.Should().NotBeNull();
            postMovies[0].Ids.Trakt.Should().Be(1U);
            postMovies[0].Ids.Slug.Should().Be("movie-1-title");
            postMovies[0].Ids.Imdb.Should().Be("ttmovie1title");
            postMovies[0].Ids.Tmdb.Should().Be(1U);
            postMovies[0].Rating.Should().BeNull();
            postMovies[0].RatedAt.Should().BeNull();

            postMovies[1].Title = "movie 2 title";
            postMovies[1].Year  = 2020;
            postMovies[1].Ids.Should().NotBeNull();
            postMovies[1].Ids.Trakt.Should().Be(2U);
            postMovies[1].Ids.Slug.Should().Be("movie-2-title");
            postMovies[1].Ids.Imdb.Should().Be("ttmovie2title");
            postMovies[1].Ids.Tmdb.Should().Be(2U);
            postMovies[1].Rating.Should().BeNull();
            postMovies[1].RatedAt.Should().BeNull();

            syncRatingsPost.Shows.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Episodes.Should().NotBeNull().And.BeEmpty();
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_AddRatedShowAndSeasonsCollection_And_RatedAt()
        {
            ITraktShow show = new TraktShow
            {
                Title = "show title",
                Year  = 2020,
                Ids   = new TraktShowIds
                {
                    Trakt  = 1,
                    Slug   = "show-title",
                    Imdb   = "ttshowtitle",
                    Tmdb   = 1,
                    Tvdb   = 1,
                    TvRage = 1
                }
            };

            var seasons = new PostRatingsSeasons
            {
                1,
                { 2, new PostRatingsEpisodes {
                      1, 2
                  } }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .AddRatedShowAndSeasonsCollection(show).WithRating(RATING, RATED_AT, seasons)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Shows.Should().NotBeNull().And.HaveCount(1);

            ITraktSyncRatingsPostShow postShow = syncRatingsPost.Shows.ToArray()[0];

            postShow.Title = "show title";
            postShow.Year  = 2020;
            postShow.Ids.Should().NotBeNull();
            postShow.Ids.Trakt.Should().Be(1U);
            postShow.Ids.Slug.Should().Be("show-title");
            postShow.Ids.Imdb.Should().Be("ttshowtitle");
            postShow.Ids.Tmdb.Should().Be(1U);
            postShow.Ids.Tvdb.Should().Be(1U);
            postShow.Ids.TvRage.Should().Be(1U);
            postShow.Rating.Should().Be(RATING);
            postShow.RatedAt.Should().Be(RATED_AT);
            postShow.Seasons.Should().NotBeNull().And.HaveCount(2);

            ITraktSyncRatingsPostShowSeason[] showSeasons = postShow.Seasons.ToArray();

            showSeasons[0].Number.Should().Be(1);
            showSeasons[0].Episodes.Should().BeNull();

            showSeasons[1].Number.Should().Be(2);
            showSeasons[1].Episodes.Should().NotBeNull().And.HaveCount(2);

            ITraktSyncRatingsPostShowEpisode[] showSeasonEpisodes = showSeasons[1].Episodes.ToArray();

            showSeasonEpisodes[0].Number.Should().Be(1);
            showSeasonEpisodes[1].Number.Should().Be(2);

            syncRatingsPost.Movies.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Episodes.Should().NotBeNull().And.BeEmpty();
        }
        public void Test_TraktPost_SyncRatingsPostBuilder_WithShows()
        {
            var shows = new List <ITraktShow>
            {
                new TraktShow
                {
                    Title = "show 1 title",
                    Year  = 2020,
                    Ids   = new TraktShowIds
                    {
                        Trakt  = 1,
                        Slug   = "show-1-title",
                        Imdb   = "ttshow1title",
                        Tmdb   = 1,
                        Tvdb   = 1,
                        TvRage = 1
                    }
                },
                new TraktShow
                {
                    Title = "show 2 title",
                    Year  = 2020,
                    Ids   = new TraktShowIds
                    {
                        Trakt  = 2,
                        Slug   = "show-2-title",
                        Imdb   = "ttshow2title",
                        Tmdb   = 2,
                        Tvdb   = 2,
                        TvRage = 2
                    }
                }
            };

            ITraktSyncRatingsPost syncRatingsPost = TraktPost.NewSyncRatingsPost()
                                                    .WithShows(shows)
                                                    .Build();

            syncRatingsPost.Should().NotBeNull();
            syncRatingsPost.Shows.Should().NotBeNull().And.HaveCount(2);

            ITraktSyncRatingsPostShow[] postShows = syncRatingsPost.Shows.ToArray();

            postShows[0].Title = "show 1 title";
            postShows[0].Year  = 2020;
            postShows[0].Ids.Should().NotBeNull();
            postShows[0].Ids.Trakt.Should().Be(1U);
            postShows[0].Ids.Slug.Should().Be("show-1-title");
            postShows[0].Ids.Imdb.Should().Be("ttshow1title");
            postShows[0].Ids.Tmdb.Should().Be(1U);
            postShows[0].Ids.Tvdb.Should().Be(1U);
            postShows[0].Ids.TvRage.Should().Be(1U);
            postShows[0].Rating.Should().BeNull();
            postShows[0].RatedAt.Should().BeNull();
            postShows[0].Seasons.Should().BeNull();

            postShows[1].Title = "show 2 title";
            postShows[1].Year  = 2020;
            postShows[1].Ids.Should().NotBeNull();
            postShows[1].Ids.Trakt.Should().Be(2U);
            postShows[1].Ids.Slug.Should().Be("show-2-title");
            postShows[1].Ids.Imdb.Should().Be("ttshow2title");
            postShows[1].Ids.Tmdb.Should().Be(2U);
            postShows[1].Ids.Tvdb.Should().Be(2U);
            postShows[1].Ids.TvRage.Should().Be(2U);
            postShows[1].Rating.Should().BeNull();
            postShows[1].RatedAt.Should().BeNull();
            postShows[1].Seasons.Should().BeNull();

            syncRatingsPost.Movies.Should().NotBeNull().And.BeEmpty();
            syncRatingsPost.Episodes.Should().NotBeNull().And.BeEmpty();
        }
コード例 #15
0
 /// <summary>Initializes a new instance of the <see cref="TraktSyncRatingsPostBuilder" /> class.</summary>
 public TraktSyncRatingsPostBuilder()
 {
     _ratingsPost = new TraktSyncRatingsPost();
 }