public void Test_TraktPost_SyncHistoryPostBuilder_AddWatchedEpisode()
{
ITraktEpisode episode = new TraktEpisode
{
Ids = new TraktEpisodeIds
{
Trakt = 1,
Imdb = "ttepisodetitle",
Tmdb = 1,
Tvdb = 1,
TvRage = 1
}
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.AddWatchedEpisode(episode).WatchedAt(WATCHED_AT)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Episodes.Should().NotBeNull().And.HaveCount(1);
ITraktSyncHistoryPostEpisode postEpisode = syncHistoryPost.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.WatchedAt.Should().Be(WATCHED_AT);
syncHistoryPost.Movies.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Shows.Should().NotBeNull().And.BeEmpty();
}
public void Test_TraktPost_SyncHistoryPostBuilder_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
}
}
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.WithMovies(movies)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Movies.Should().NotBeNull().And.HaveCount(2);
ITraktSyncHistoryPostMovie[] postMovies = syncHistoryPost.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].WatchedAt.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].WatchedAt.Should().BeNull();
syncHistoryPost.Shows.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Episodes.Should().NotBeNull().And.BeEmpty();
}
public void Test_TraktPost_SyncHistoryPostBuilder_Empty_Build()
{
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost().Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Movies.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Shows.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Episodes.Should().NotBeNull().And.BeEmpty();
}
public void Test_TraktPost_SyncHistoryPostBuilder_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
}
}
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.WithEpisodes(episodes)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Episodes.Should().NotBeNull().And.HaveCount(2);
ITraktSyncHistoryPostEpisode[] postEpisodes = syncHistoryPost.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].WatchedAt.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].WatchedAt.Should().BeNull();
syncHistoryPost.Movies.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Shows.Should().NotBeNull().And.BeEmpty();
}
public void Test_TraktPost_SyncHistoryPostBuilder_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
}
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.AddShowAndSeasons(show).WithSeasons(1, 2, 3)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Shows.Should().NotBeNull().And.HaveCount(1);
ITraktSyncHistoryPostShow postShow = syncHistoryPost.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.WatchedAt.Should().BeNull();
postShow.Seasons.Should().NotBeNull().And.HaveCount(3);
ITraktSyncHistoryPostShowSeason[] 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();
syncHistoryPost.Movies.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Episodes.Should().NotBeNull().And.BeEmpty();
}
public ITraktSyncHistoryPostResponse AddWatchedHistoryItems(ITraktSyncHistoryPost historyPost)
{
ITraktResponse <ITraktSyncHistoryPostResponse> response = new TraktResponse <ITraktSyncHistoryPostResponse>();
try
{
response = Task.Run(() => base.Sync.AddWatchedHistoryItemsAsync(historyPost)).Result;
}
catch (AggregateException aggregateException)
{
UnwrapAggregateException(aggregateException);
}
return(response.Value);
}
private void AddEpisodes(ITraktSyncHistoryPost syncHistoryPost)
{
if (syncHistoryPost.Episodes == null)
{
syncHistoryPost.Episodes = new List <ITraktSyncHistoryPostEpisode>();
}
foreach (ITraktEpisode episode in _episodes)
{
(syncHistoryPost.Episodes as List <ITraktSyncHistoryPostEpisode>).Add(CreateSyncHistoryPostEpisode(episode));
}
foreach (PostBuilderWatchedObject <ITraktEpisode> episodeEntry in _watchedEpisodes.WatchedEpisodes)
{
(syncHistoryPost.Episodes as List <ITraktSyncHistoryPostEpisode>).Add(CreateSyncHistoryPostEpisode(episodeEntry.Object, episodeEntry.WatchedAt));
}
}
private void AddMovies(ITraktSyncHistoryPost syncHistoryPost)
{
if (syncHistoryPost.Movies == null)
{
syncHistoryPost.Movies = new List <ITraktSyncHistoryPostMovie>();
}
foreach (ITraktMovie movie in _movies)
{
(syncHistoryPost.Movies as List <ITraktSyncHistoryPostMovie>).Add(CreateSyncHistoryPostMovie(movie));
}
foreach (PostBuilderWatchedObject <ITraktMovie> movieEntry in _watchedMovies.WatchedMovies)
{
(syncHistoryPost.Movies as List <ITraktSyncHistoryPostMovie>).Add(CreateSyncHistoryPostMovie(movieEntry.Object, movieEntry.WatchedAt));
}
}
private void ValidateHistoryPost(ITraktSyncHistoryPost historyPost)
{
if (historyPost == null)
{
throw new ArgumentNullException(nameof(historyPost), "history post must not be null");
}
IEnumerable <ITraktSyncHistoryPostMovie> movies = historyPost.Movies;
IEnumerable <ITraktSyncHistoryPostShow> shows = historyPost.Shows;
IEnumerable <ITraktSyncHistoryPostEpisode> episodes = historyPost.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 watched history items set");
}
}
public void Test_TraktPost_SyncHistoryPostBuilder_AddWatchedShow()
{
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
}
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.AddWatchedShow(show).WatchedAt(WATCHED_AT)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Shows.Should().NotBeNull().And.HaveCount(1);
ITraktSyncHistoryPostShow postShow = syncHistoryPost.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.WatchedAt.Should().Be(WATCHED_AT);
postShow.Seasons.Should().BeNull();
syncHistoryPost.Movies.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Episodes.Should().NotBeNull().And.BeEmpty();
}
private void AddShows(ITraktSyncHistoryPost syncHistoryPost)
{
if (syncHistoryPost.Shows == null)
{
syncHistoryPost.Shows = new List <ITraktSyncHistoryPostShow>();
}
foreach (ITraktShow show in _shows)
{
(syncHistoryPost.Shows as List <ITraktSyncHistoryPostShow>).Add(CreateSyncHistoryPostShow(show));
}
foreach (PostBuilderWatchedObject <ITraktShow> showEntry in _watchedShows.WatchedShows)
{
(syncHistoryPost.Shows as List <ITraktSyncHistoryPostShow>).Add(CreateSyncHistoryPostShow(showEntry.Object, showEntry.WatchedAt));
}
foreach (PostBuilderWatchedObjectWithSeasons <ITraktShow, IEnumerable <int> > showEntry in _watchedShowsWithSeasons.WatchedShowsWithSeasons)
{
(syncHistoryPost.Shows as List <ITraktSyncHistoryPostShow>).Add(CreateSyncHistoryPostShowWithSeasons(showEntry.Object, showEntry.WatchedAt, showEntry.Seasons));
}
foreach (PostBuilderWatchedObjectWithSeasons <ITraktShow, PostHistorySeasons> showEntry in _watchedShowsWithSeasonsCollection.WatchedShowsWithSeasonsCollection)
{
(syncHistoryPost.Shows as List <ITraktSyncHistoryPostShow>).Add(CreateSyncHistoryPostShowWithSeasonsCollection(showEntry.Object, showEntry.WatchedAt, showEntry.Seasons));
}
foreach (PostBuilderObjectWithSeasons <ITraktShow, IEnumerable <int> > showEntry in _showsWithSeasons.ShowsWithSeasons)
{
(syncHistoryPost.Shows as List <ITraktSyncHistoryPostShow>).Add(CreateSyncHistoryPostShowWithSeasons(showEntry.Object, null, showEntry.Seasons));
}
foreach (PostBuilderObjectWithSeasons <ITraktShow, PostHistorySeasons> showEntry in _showsWithSeasonsCollection.ShowsWithSeasonsCollection)
{
(syncHistoryPost.Shows as List <ITraktSyncHistoryPostShow>).Add(CreateSyncHistoryPostShowWithSeasonsCollection(showEntry.Object, null, showEntry.Seasons));
}
}
public void Test_TraktPost_SyncHistoryPostBuilder_WithMovie()
{
ITraktMovie movie = new TraktMovie
{
Title = "movie title",
Year = 2020,
Ids = new TraktMovieIds
{
Trakt = 1,
Slug = "movie-title",
Imdb = "ttmovietitle",
Tmdb = 1
}
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.WithMovie(movie)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Movies.Should().NotBeNull().And.HaveCount(1);
ITraktSyncHistoryPostMovie postMovie = syncHistoryPost.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.WatchedAt.Should().BeNull();
syncHistoryPost.Shows.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Episodes.Should().NotBeNull().And.BeEmpty();
}
/// <summary>Initializes a new instance of the <see cref="TraktSyncHistoryPostBuilder" /> class.</summary>
public TraktSyncHistoryPostBuilder()
{
_historyPost = new TraktSyncHistoryPost();
}
public TraktSyncEpisodesResult SyncSeries()
{
_mediaPortalServices.GetLogger().Info("Trakt: start sync series");
ValidateAuthorization();
TraktSyncEpisodesResult syncEpisodesResult = new TraktSyncEpisodesResult();
TraktEpisodes traktEpisodes = _traktCache.RefreshSeriesCache();
IList <Episode> traktUnWatchedEpisodes = traktEpisodes.UnWatched;
IList <EpisodeWatched> traktWatchedEpisodes = traktEpisodes.Watched;
IList <EpisodeCollected> traktCollectedEpisodes = traktEpisodes.Collected;
Guid[] types =
{
MediaAspect.ASPECT_ID, EpisodeAspect.ASPECT_ID, VideoAspect.ASPECT_ID, ImporterAspect.ASPECT_ID,
ProviderResourceAspect.ASPECT_ID, ExternalIdentifierAspect.ASPECT_ID
};
var contentDirectory = _mediaPortalServices.GetServerConnectionManager().ContentDirectory;
if (contentDirectory == null)
{
throw new MediaLibraryNotConnectedException("ML not connected");
}
Guid? userProfile = null;
IUserManagement userProfileDataManagement = _mediaPortalServices.GetUserManagement();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
#region Get data from local database
IList <MediaItem> localEpisodes = contentDirectory.SearchAsync(new MediaItemQuery(types, null, null), true, userProfile, false).Result;
if (localEpisodes.Any())
{
syncEpisodesResult.CollectedInLibrary = localEpisodes.Count;
_mediaPortalServices.GetLogger().Info("Trakt: found {0} total episodes in library", localEpisodes.Count);
}
List <MediaItem> localWatchedEpisodes = localEpisodes.Where(MediaItemAspectsUtl.IsWatched).ToList();
if (localWatchedEpisodes.Any())
{
syncEpisodesResult.WatchedInLibrary = localWatchedEpisodes.Count;
_mediaPortalServices.GetLogger().Info("Trakt: found {0} episodes watched in library", localWatchedEpisodes.Count);
}
#endregion
#region Mark episodes as unwatched in local database
_mediaPortalServices.GetLogger().Info("Trakt: start marking series episodes as unwatched in media library");
if (traktUnWatchedEpisodes.Any())
{
// create a unique key to lookup and search for faster
ILookup <string, MediaItem> localLookupEpisodes = localWatchedEpisodes.ToLookup(twe => CreateLookupKey(twe), twe => twe);
foreach (var episode in traktUnWatchedEpisodes)
{
string tvdbKey = CreateLookupKey(episode);
var watchedEpisode = localLookupEpisodes[tvdbKey].FirstOrDefault();
if (watchedEpisode != null)
{
_mediaPortalServices.GetLogger().Info(
"Marking episode as unwatched in library, episode is not watched on trakt. Title = '{0}', Year = '{1}', Season = '{2}', Episode = '{3}', Show TVDb ID = '{4}', Show IMDb ID = '{5}'",
episode.ShowTitle, episode.ShowYear.HasValue ? episode.ShowYear.ToString() : "<empty>", episode.Season,
episode.Number, episode.ShowTvdbId.HasValue ? episode.ShowTvdbId.ToString() : "<empty>",
episode.ShowImdbId ?? "<empty>");
if (_mediaPortalServices.MarkAsUnWatched(watchedEpisode).Result)
{
syncEpisodesResult.MarkedAsUnWatchedInLibrary++;
}
// update watched episodes
localWatchedEpisodes.Remove(watchedEpisode);
}
}
}
#endregion
#region Mark episodes as watched in local database
_mediaPortalServices.GetLogger().Info("Trakt: start marking series episodes as watched in media library");
if (traktWatchedEpisodes.Any())
{
// create a unique key to lookup and search for faster
ILookup <string, EpisodeWatched> onlineEpisodes = traktWatchedEpisodes.ToLookup(twe => CreateLookupKey(twe), twe => twe);
List <MediaItem> localUnWatchedEpisodes = localEpisodes.Except(localWatchedEpisodes).ToList();
foreach (var episode in localUnWatchedEpisodes)
{
string tvdbKey = CreateLookupKey(episode);
var traktEpisode = onlineEpisodes[tvdbKey].FirstOrDefault();
if (traktEpisode != null)
{
_mediaPortalServices.GetLogger().Info(
"Marking episode as watched in library, episode is watched on trakt. Plays = '{0}', Title = '{1}', Year = '{2}', Season = '{3}', Episode = '{4}', Show TVDb ID = '{5}', Show IMDb ID = '{6}', Last Watched = '{7}'",
traktEpisode.Plays, traktEpisode.ShowTitle,
traktEpisode.ShowYear.HasValue ? traktEpisode.ShowYear.ToString() : "<empty>", traktEpisode.Season,
traktEpisode.Number, traktEpisode.ShowTvdbId.HasValue ? traktEpisode.ShowTvdbId.ToString() : "<empty>",
traktEpisode.ShowImdbId ?? "<empty>", traktEpisode.WatchedAt);
if (_mediaPortalServices.MarkAsWatched(episode).Result)
{
syncEpisodesResult.MarkedAsWatchedInLibrary++;
}
}
}
}
#endregion
#region Add episodes to watched history at trakt.tv
ITraktSyncHistoryPost syncHistoryPost = GetWatchedShowsForSync(localWatchedEpisodes, traktWatchedEpisodes);
if (syncHistoryPost.Shows != null && syncHistoryPost.Shows.Any())
{
_mediaPortalServices.GetLogger().Info("Trakt: trying to add {0} watched episodes to trakt watched history", syncHistoryPost.Shows.Count());
ITraktSyncHistoryPostResponse response = _traktClient.AddWatchedHistoryItems(syncHistoryPost);
syncEpisodesResult.AddedToTraktWatchedHistory = response.Added?.Episodes;
_traktCache.ClearLastActivity(FileName.WatchedEpisodes.Value);
if (response.Added?.Episodes != null)
{
_mediaPortalServices.GetLogger().Info("Trakt: successfully added {0} watched episodes to trakt watched history", response.Added.Episodes.Value);
}
}
#endregion
#region Add episodes to collection at trakt.tv
ITraktSyncCollectionPost syncCollectionPost = GetCollectedShowsForSync(localEpisodes, traktCollectedEpisodes);
if (syncCollectionPost.Shows != null && syncCollectionPost.Shows.Any())
{
_mediaPortalServices.GetLogger().Info("Trakt: trying to add {0} collected episodes to trakt collection", syncCollectionPost.Shows.Count());
ITraktSyncCollectionPostResponse response = _traktClient.AddCollectionItems(syncCollectionPost);
syncEpisodesResult.AddedToTraktCollection = response.Added?.Episodes;
_traktCache.ClearLastActivity(FileName.CollectedEpisodes.Value);
if (response.Added?.Episodes != null)
{
_mediaPortalServices.GetLogger().Info("Trakt: successfully added {0} collected episodes to trakt collection", response.Added.Episodes.Value);
}
}
#endregion
return(syncEpisodesResult);
}
public void Test_TraktPost_SyncHistoryPostBuilder_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
}
}
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.WithShows(shows)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Shows.Should().NotBeNull().And.HaveCount(2);
ITraktSyncHistoryPostShow[] postShows = syncHistoryPost.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].WatchedAt.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].WatchedAt.Should().BeNull();
postShows[1].Seasons.Should().BeNull();
syncHistoryPost.Movies.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Episodes.Should().NotBeNull().And.BeEmpty();
}
public void Test_TraktPost_SyncHistoryPostBuilder_AddWatchedShowAndSeasonsCollection()
{
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 PostHistorySeasons
{
1,
{ 2, new PostHistoryEpisodes {
1, 2
} }
};
ITraktSyncHistoryPost syncHistoryPost = TraktPost.NewSyncHistoryPost()
.AddWatchedShowAndSeasonsCollection(show).WatchedAt(WATCHED_AT, seasons)
.Build();
syncHistoryPost.Should().NotBeNull();
syncHistoryPost.Shows.Should().NotBeNull().And.HaveCount(1);
ITraktSyncHistoryPostShow postShow = syncHistoryPost.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.WatchedAt.Should().Be(WATCHED_AT);
postShow.Seasons.Should().NotBeNull().And.HaveCount(2);
ITraktSyncHistoryPostShowSeason[] 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);
ITraktSyncHistoryPostShowEpisode[] showSeasonEpisodes = showSeasons[1].Episodes.ToArray();
showSeasonEpisodes[0].Number.Should().Be(1);
showSeasonEpisodes[1].Number.Should().Be(2);
syncHistoryPost.Movies.Should().NotBeNull().And.BeEmpty();
syncHistoryPost.Episodes.Should().NotBeNull().And.BeEmpty();
}
/// <summary>
/// Adds items to the user's watch history. Accepts shows, seasons, episodes and movies.
/// <para>OAuth authorization required.</para>
/// <para>
/// See <a href="http://docs.trakt.apiary.io/#reference/sync/add-to-history/add-items-to-watched-history">"Trakt API Doc - Sync: Add to History"</a> for more information.
/// </para>
/// <para>
/// It is recommended to use the <see cref="ITraktSyncHistoryPostBuilder" /> to create an instance
/// of the required <see cref="ITraktSyncHistoryPost" />.
/// See also <seealso cref="TraktPost.NewSyncHistoryPost()" />.
/// </para>
/// </summary>
/// <param name="historyPost">An <see cref="ITraktSyncHistoryPost" /> 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="ITraktSyncHistoryPostResponse" /> 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 history post is null.</exception>
/// <exception cref="ArgumentException">Thrown, if the given history post is empty.</exception>
public Task <TraktResponse <ITraktSyncHistoryPostResponse> > AddWatchedHistoryItemsAsync(ITraktSyncHistoryPost historyPost,
CancellationToken cancellationToken = default)
{
ValidateHistoryPost(historyPost);
var requestHandler = new RequestHandler(Client);
return(requestHandler.ExecuteSingleItemRequestAsync(new SyncWatchedHistoryAddRequest
{
RequestBody = historyPost
},
cancellationToken));
}
