public override async Task <ITraktSyncHistoryPostMovie> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktSyncHistoryPostMovie)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var movieIdsReader = new MovieIdsObjectJsonReader();
ITraktSyncHistoryPostMovie syncHistoryPostMovie = new TraktSyncHistoryPostMovie();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.SYNC_HISTORY_POST_MOVIE_PROPERTY_NAME_WATCHED_AT:
{
Pair <bool, DateTime> value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncHistoryPostMovie.WatchedAt = value.Second;
}
break;
}
case JsonProperties.SYNC_HISTORY_POST_MOVIE_PROPERTY_NAME_TITLE:
syncHistoryPostMovie.Title = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.SYNC_HISTORY_POST_MOVIE_PROPERTY_NAME_YEAR:
syncHistoryPostMovie.Year = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SYNC_HISTORY_POST_MOVIE_PROPERTY_NAME_IDS:
syncHistoryPostMovie.Ids = await movieIdsReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(syncHistoryPostMovie);
}
return(await Task.FromResult(default(ITraktSyncHistoryPostMovie)));
}
public override async Task <ITraktUserFollowRequest> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var userReader = new UserObjectJsonReader();
ITraktUserFollowRequest traktUserFollowRequest = new TraktUserFollowRequest();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_ID:
{
var value = await JsonReaderHelper.ReadUnsignedIntegerValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktUserFollowRequest.Id = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_REQUESTED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktUserFollowRequest.RequestedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_USER:
traktUserFollowRequest.User = await userReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktUserFollowRequest);
}
return(await Task.FromResult(default(ITraktUserFollowRequest)));
}
public override async Task <ITraktSyncHistoryPostShowSeason> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var episodeArrayJsonReader = new ArrayJsonReader <ITraktSyncHistoryPostShowEpisode>();
ITraktSyncHistoryPostShowSeason syncHistoryPostShowSeason = new TraktSyncHistoryPostShowSeason();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_WATCHED_AT:
{
Pair <bool, DateTime> value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncHistoryPostShowSeason.WatchedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_NUMBER:
{
Pair <bool, int> value = await JsonReaderHelper.ReadIntegerValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncHistoryPostShowSeason.Number = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_EPISODES:
syncHistoryPostShowSeason.Episodes = await episodeArrayJsonReader.ReadArrayAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(syncHistoryPostShowSeason);
}
return(await Task.FromResult(default(ITraktSyncHistoryPostShowSeason)));
}
public override async Task <ITraktSyncRatingsPostShowEpisode> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktSyncRatingsPostShowEpisode syncRatingsPostShowEpisode = new TraktSyncRatingsPostShowEpisode();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_RATED_AT:
{
Pair <bool, DateTime> value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncRatingsPostShowEpisode.RatedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_RATING:
syncRatingsPostShowEpisode.Rating = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_NUMBER:
{
Pair <bool, int> value = await JsonReaderHelper.ReadIntegerValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncRatingsPostShowEpisode.Number = value.Second;
}
break;
}
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(syncRatingsPostShowEpisode);
}
return(await Task.FromResult(default(ITraktSyncRatingsPostShowEpisode)));
}
public override async Task <ITraktUserLikeItem> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var commentReader = new CommentObjectJsonReader();
var listReader = new ListObjectJsonReader();
ITraktUserLikeItem traktUserLikeItem = new TraktUserLikeItem();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_LIKED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktUserLikeItem.LikedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_TYPE:
traktUserLikeItem.Type = await JsonReaderHelper.ReadEnumerationValueAsync <TraktUserLikeType>(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_COMMENT:
traktUserLikeItem.Comment = await commentReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_LIST:
traktUserLikeItem.List = await listReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktUserLikeItem);
}
return(await Task.FromResult(default(ITraktUserLikeItem)));
}
public override async Task <ITraktCalendarShow> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktCalendarShow)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var showObjectReader = new ShowObjectJsonReader();
var episodeObjectReader = new EpisodeObjectJsonReader();
ITraktCalendarShow traktCalendarShow = new TraktCalendarShow();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.CALENDAR_SHOW_PROPERTY_NAME_FIRST_AIRED:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktCalendarShow.FirstAiredInCalendar = value.Second;
}
break;
}
case JsonProperties.CALENDAR_SHOW_PROPERTY_NAME_SHOW:
traktCalendarShow.Show = await showObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.CALENDAR_SHOW_PROPERTY_NAME_EPISODE:
traktCalendarShow.Episode = await episodeObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktCalendarShow);
}
return(await Task.FromResult(default(ITraktCalendarShow)));
}
public override async Task <ITraktCollectionMovie> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktCollectionMovie)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var movieObjectReader = new MovieObjectJsonReader();
var metadataObjectReader = new MetadataObjectJsonReader();
ITraktCollectionMovie traktCollectionMovie = new TraktCollectionMovie();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.COLLECTION_MOVIE_PROPERTY_NAME_COLLECTED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktCollectionMovie.CollectedAt = value.Second;
}
break;
}
case JsonProperties.COLLECTION_MOVIE_PROPERTY_NAME_MOVIE:
traktCollectionMovie.Movie = await movieObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.COLLECTION_MOVIE_PROPERTY_NAME_METADATA:
traktCollectionMovie.Metadata = await metadataObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktCollectionMovie);
}
return(await Task.FromResult(default(ITraktCollectionMovie)));
}
public override async Task <ITraktCollectionShow> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktCollectionShow)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var showObjectReader = new ShowObjectJsonReader();
var showSeasonsArrayReader = new CollectionShowSeasonArrayJsonReader();
ITraktCollectionShow traktCollectionShow = new TraktCollectionShow();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.COLLECTION_SHOW_PROPERTY_NAME_LAST_COLLECTED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktCollectionShow.LastCollectedAt = value.Second;
}
break;
}
case JsonProperties.COLLECTION_SHOW_PROPERTY_NAME_SHOW:
traktCollectionShow.Show = await showObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.COLLECTION_SHOW_PROPERTY_NAME_SEASONS:
traktCollectionShow.CollectionSeasons = await showSeasonsArrayReader.ReadArrayAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktCollectionShow);
}
return(await Task.FromResult(default(ITraktCollectionShow)));
}
public override async Task <ITraktSyncHistoryPostShowEpisode> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktSyncHistoryPostShowEpisode)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktSyncHistoryPostShowEpisode syncHistoryPostShowEpisode = new TraktSyncHistoryPostShowEpisode();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.SYNC_HISTORY_POST_SHOW_EPISODE_PROPERTY_NAME_WATCHED_AT:
{
Pair <bool, DateTime> value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncHistoryPostShowEpisode.WatchedAt = value.Second;
}
break;
}
case JsonProperties.SYNC_HISTORY_POST_SHOW_EPISODE_PROPERTY_NAME_NUMBER:
{
Pair <bool, int> value = await JsonReaderHelper.ReadIntegerValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncHistoryPostShowEpisode.Number = value.Second;
}
break;
}
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(syncHistoryPostShowEpisode);
}
return(await Task.FromResult(default(ITraktSyncHistoryPostShowEpisode)));
}
public override async Task <ITraktWatchedMovie> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktWatchedMovie)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var movieObjectReader = new MovieObjectJsonReader();
ITraktWatchedMovie traktWatchedMovie = new TraktWatchedMovie();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.WATCHED_MOVIE_PROPERTY_NAME_PLAYS:
traktWatchedMovie.Plays = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.WATCHED_MOVIE_PROPERTY_NAME_LAST_WATCHED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktWatchedMovie.LastWatchedAt = value.Second;
}
break;
}
case JsonProperties.WATCHED_MOVIE_PROPERTY_NAME_MOVIE:
traktWatchedMovie.Movie = await movieObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktWatchedMovie);
}
return(await Task.FromResult(default(ITraktWatchedMovie)));
}
public override async Task <ITraktSyncRatingsPostEpisode> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktSyncRatingsPostEpisode)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var episodeIdsObjectJsonReader = new EpisodeIdsObjectJsonReader();
ITraktSyncRatingsPostEpisode syncRatingsPostEpisode = new TraktSyncRatingsPostEpisode();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.SYNC_RATINGS_POST_EPISODE_PROPERTY_NAME_RATED_AT:
{
Pair <bool, DateTime> value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncRatingsPostEpisode.RatedAt = value.Second;
}
break;
}
case JsonProperties.SYNC_RATINGS_POST_EPISODE_PROPERTY_NAME_RATING:
syncRatingsPostEpisode.Rating = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SYNC_RATINGS_POST_EPISODE_PROPERTY_NAME_IDS:
syncRatingsPostEpisode.Ids = await episodeIdsObjectJsonReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(syncRatingsPostEpisode);
}
return(await Task.FromResult(default(ITraktSyncRatingsPostEpisode)));
}
public override async Task <ITraktEpisodeCollectionProgress> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktEpisodeCollectionProgress)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktEpisodeCollectionProgress traktEpisodeCollectionProgress = new TraktEpisodeCollectionProgress();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.EPISODE_COLLECTION_PROGRESS_PROPERTY_NAME_NUMBER:
traktEpisodeCollectionProgress.Number = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.EPISODE_COLLECTION_PROGRESS_PROPERTY_NAME_COMPLETED:
traktEpisodeCollectionProgress.Completed = await jsonReader.ReadAsBooleanAsync(cancellationToken);
break;
case JsonProperties.EPISODE_COLLECTION_PROGRESS_PROPERTY_NAME_COLLECTED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktEpisodeCollectionProgress.CollectedAt = value.Second;
}
break;
}
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktEpisodeCollectionProgress);
}
return(await Task.FromResult(default(ITraktEpisodeCollectionProgress)));
}
public override async Task <ITraktWatchedShowEpisode> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktWatchedShowEpisode traktWatchedShowEpisode = new TraktWatchedShowEpisode();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_NUMBER:
traktWatchedShowEpisode.Number = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_PLAYS:
traktWatchedShowEpisode.Plays = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_LAST_WATCHED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktWatchedShowEpisode.LastWatchedAt = value.Second;
}
break;
}
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktWatchedShowEpisode);
}
return(await Task.FromResult(default(ITraktWatchedShowEpisode)));
}
public override async Task <ITraktCommentLike> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktCommentLike)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktCommentLike traktCommentLike = new TraktCommentLike();
var userObjectJsonReader = new UserObjectJsonReader();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.COMMENT_LIKE_PROPERTY_NAME_LIKED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken).ConfigureAwait(false);
if (value.First)
{
traktCommentLike.LikedAt = value.Second;
}
break;
}
case JsonProperties.COMMENT_LIKE_PROPERTY_NAME_USER:
traktCommentLike.User = await userObjectJsonReader.ReadObjectAsync(jsonReader, cancellationToken).ConfigureAwait(false);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken).ConfigureAwait(false);
break;
}
}
return(traktCommentLike);
}
return(await Task.FromResult(default(ITraktCommentLike)));
}
public override async Task <ITraktRecentlyUpdatedShow> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktRecentlyUpdatedShow)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var showObjectReader = new ShowObjectJsonReader();
ITraktRecentlyUpdatedShow traktRecentlyUpdatedShow = new TraktRecentlyUpdatedShow();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.RECENTLY_UPDATED_SHOW_PROPERTY_NAME_UPDATED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktRecentlyUpdatedShow.RecentlyUpdatedAt = value.Second;
}
break;
}
case JsonProperties.RECENTLY_UPDATED_SHOW_PROPERTY_NAME_SHOW:
traktRecentlyUpdatedShow.Show = await showObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktRecentlyUpdatedShow);
}
return(await Task.FromResult(default(ITraktRecentlyUpdatedShow)));
}
public override async Task <ITraktUserFollower> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktUserFollower)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var userReader = new UserObjectJsonReader();
ITraktUserFollower traktUserFollower = new TraktUserFollower();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.USER_FOLLOWER_PROPERTY_NAME_FOLLOWED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktUserFollower.FollowedAt = value.Second;
}
break;
}
case JsonProperties.USER_FOLLOWER_PROPERTY_NAME_USER:
traktUserFollower.User = await userReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktUserFollower);
}
return(await Task.FromResult(default(ITraktUserFollower)));
}
public override async Task <ITraktUserFollowUserPostResponse> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var userObjectReader = new UserObjectJsonReader();
ITraktUserFollowUserPostResponse userFollowUserPostResponse = new TraktUserFollowUserPostResponse();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_APPROVED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
userFollowUserPostResponse.ApprovedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_USER:
userFollowUserPostResponse.User = await userObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(userFollowUserPostResponse);
}
return(await Task.FromResult(default(ITraktUserFollowUserPostResponse)));
}
public override async Task <ITraktCalendarMovie> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var movieObjectReader = new MovieObjectJsonReader();
ITraktCalendarMovie traktCalendarMovie = new TraktCalendarMovie();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_RELEASED:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktCalendarMovie.CalendarRelease = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_MOVIE:
traktCalendarMovie.Movie = await movieObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktCalendarMovie);
}
return(await Task.FromResult(default(ITraktCalendarMovie)));
}
public override async Task <ITraktSyncHistoryPostEpisode> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var episodeIdsReader = new EpisodeIdsObjectJsonReader();
ITraktSyncHistoryPostEpisode syncHistoryPostEpisode = new TraktSyncHistoryPostEpisode();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_WATCHED_AT:
{
Pair <bool, DateTime> value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
syncHistoryPostEpisode.WatchedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_IDS:
syncHistoryPostEpisode.Ids = await episodeIdsReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(syncHistoryPostEpisode);
}
return(await Task.FromResult(default(ITraktSyncHistoryPostEpisode)));
}
public override async Task <ITraktSyncCommentsLastActivities> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktSyncCommentsLastActivities)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktSyncCommentsLastActivities commentsLastActivities = new TraktSyncCommentsLastActivities();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.SYNC_COMMENTS_LAST_ACTIVITIES_PROPERTY_NAME_LIKED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
commentsLastActivities.LikedAt = value.Second;
}
break;
}
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(commentsLastActivities);
}
return(await Task.FromResult(default(ITraktSyncCommentsLastActivities)));
}
public override async Task <ITraktCheckinPostErrorResponse> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktCheckinPostErrorResponse)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktCheckinPostErrorResponse checkinErrorResponse = new TraktCheckinPostErrorResponse();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.CHECKIN_POST_ERROR_RESPONSE_PROPERTY_NAME_EXPIRES_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
checkinErrorResponse.ExpiresAt = value.Second;
}
break;
}
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(checkinErrorResponse);
}
return(await Task.FromResult(default(ITraktCheckinPostErrorResponse)));
}
public override async Task <ITraktShowResetWatchedProgressPost> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
ITraktShowResetWatchedProgressPost traktShowResetWatchedProgressPost = new TraktShowResetWatchedProgressPost();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_RESET_AT:
{
Pair <bool, System.DateTime> value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktShowResetWatchedProgressPost.ResetAt = value.Second;
}
break;
}
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktShowResetWatchedProgressPost);
}
return(await Task.FromResult(default(ITraktShowResetWatchedProgressPost)));
}
public override async Task <ITraktShowCollectionProgress> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktShowCollectionProgress)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var seasonsArrayReader = new SeasonArrayJsonReader();
var seasonCollectionProgressArrayReader = new SeasonCollectionProgressArrayJsonReader();
var episodeObjectReader = new EpisodeObjectJsonReader();
ITraktShowCollectionProgress traktShowCollectionProgress = new TraktShowCollectionProgress();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.SHOW_COLLECTION_PROGRESS_PROPERTY_NAME_AIRED:
traktShowCollectionProgress.Aired = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SHOW_COLLECTION_PROGRESS_PROPERTY_NAME_COMPLETED:
traktShowCollectionProgress.Completed = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SHOW_COLLECTION_PROGRESS_PROPERTY_NAME_LAST_COLLECTED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktShowCollectionProgress.LastCollectedAt = value.Second;
}
break;
}
case JsonProperties.SHOW_COLLECTION_PROGRESS_PROPERTY_NAME_SEASONS:
traktShowCollectionProgress.Seasons = await seasonCollectionProgressArrayReader.ReadArrayAsync(jsonReader, cancellationToken);
break;
case JsonProperties.SHOW_COLLECTION_PROGRESS_PROPERTY_NAME_HIDDEN_SEASONS:
traktShowCollectionProgress.HiddenSeasons = await seasonsArrayReader.ReadArrayAsync(jsonReader, cancellationToken);
break;
case JsonProperties.SHOW_COLLECTION_PROGRESS_PROPERTY_NAME_NEXT_EPISODE:
traktShowCollectionProgress.NextEpisode = await episodeObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.SHOW_COLLECTION_PROGRESS_PROPERTY_NAME_LAST_EPISODE:
traktShowCollectionProgress.LastEpisode = await episodeObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktShowCollectionProgress);
}
return(await Task.FromResult(default(ITraktShowCollectionProgress)));
}
public override async Task <ITraktPerson> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktPerson)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var idsObjectReader = new PersonIdsObjectJsonReader();
ITraktPerson traktPerson = new TraktPerson();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PERSON_PROPERTY_NAME_NAME:
traktPerson.Name = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PERSON_PROPERTY_NAME_IDS:
traktPerson.Ids = await idsObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PERSON_PROPERTY_NAME_BIOGRAPHY:
traktPerson.Biography = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PERSON_PROPERTY_NAME_BIRTHDAY:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktPerson.Birthday = value.Second;
}
break;
}
case JsonProperties.PERSON_PROPERTY_NAME_DEATH:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktPerson.Death = value.Second;
}
break;
}
case JsonProperties.PERSON_PROPERTY_NAME_BIRTHPLACE:
traktPerson.Birthplace = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PERSON_PROPERTY_NAME_HOMEPAGE:
traktPerson.Homepage = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktPerson);
}
return(await Task.FromResult(default(ITraktPerson)));
}
public override async Task <ITraktMovie> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var idsObjectReader = new MovieIdsObjectJsonReader();
ITraktMovie traktMovie = new TraktMovie();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_TITLE:
traktMovie.Title = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_YEAR:
traktMovie.Year = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_IDS:
traktMovie.Ids = await idsObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_TAGLINE:
traktMovie.Tagline = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_OVERVIEW:
traktMovie.Overview = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_RELEASED:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktMovie.Released = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_RUNTIME:
traktMovie.Runtime = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_TRAILER:
traktMovie.Trailer = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_HOMEPAGE:
traktMovie.Homepage = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_RATING:
traktMovie.Rating = (float?)await jsonReader.ReadAsDoubleAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_VOTES:
traktMovie.Votes = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_UPDATED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktMovie.UpdatedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_LANGUAGE:
traktMovie.LanguageCode = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_AVAILABLE_TRANSLATIONS:
traktMovie.AvailableTranslationLanguageCodes = await JsonReaderHelper.ReadStringArrayAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_GENRES:
traktMovie.Genres = await JsonReaderHelper.ReadStringArrayAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_CERTIFICATION:
traktMovie.Certification = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_COUNTRY:
traktMovie.CountryCode = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_COMMENT_COUNT:
traktMovie.CommentCount = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_STATUS:
traktMovie.Status = await JsonReaderHelper.ReadEnumerationValueAsync <TraktMovieStatus>(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktMovie);
}
return(await Task.FromResult(default(ITraktMovie)));
}
public override async Task <ITraktSyncPlaybackProgressItem> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var movieObjectReader = new MovieObjectJsonReader();
var showObjectReader = new ShowObjectJsonReader();
var episodeObjectReader = new EpisodeObjectJsonReader();
ITraktSyncPlaybackProgressItem traktPlaybackProgressItem = new TraktSyncPlaybackProgressItem();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_ID:
{
var value = await JsonReaderHelper.ReadUnsignedIntegerValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktPlaybackProgressItem.Id = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_PROGRESS:
{
var value = await JsonReaderHelper.ReadFloatValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktPlaybackProgressItem.Progress = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_PAUSED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktPlaybackProgressItem.PausedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_TYPE:
traktPlaybackProgressItem.Type = await JsonReaderHelper.ReadEnumerationValueAsync <TraktSyncType>(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_MOVIE:
traktPlaybackProgressItem.Movie = await movieObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_SHOW:
traktPlaybackProgressItem.Show = await showObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_EPISODE:
traktPlaybackProgressItem.Episode = await episodeObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktPlaybackProgressItem);
}
return(await Task.FromResult(default(ITraktSyncPlaybackProgressItem)));
}
public override async Task <ITraktSeason> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
if (jsonReader == null)
{
return(await Task.FromResult(default(ITraktSeason)));
}
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var idsObjectReader = new SeasonIdsObjectJsonReader();
var episodesArrayReader = new EpisodeArrayJsonReader();
ITraktSeason traktSeason = new TraktSeason();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.SEASON_PROPERTY_NAME_NUMBER:
traktSeason.Number = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_TITLE:
traktSeason.Title = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_IDS:
traktSeason.Ids = await idsObjectReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_RATING:
traktSeason.Rating = (float?)await jsonReader.ReadAsDoubleAsync(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_VOTES:
traktSeason.Votes = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_EPISODE_COUNT:
traktSeason.TotalEpisodesCount = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_AIRED_EPISODES:
traktSeason.AiredEpisodesCount = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_OVERVIEW:
traktSeason.Overview = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_FIRST_AIRED:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
traktSeason.FirstAired = value.Second;
}
break;
}
case JsonProperties.SEASON_PROPERTY_NAME_NETWORK:
traktSeason.Network = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_EPISODES:
traktSeason.Episodes = await episodesArrayReader.ReadArrayAsync(jsonReader, cancellationToken);
break;
case JsonProperties.SEASON_PROPERTY_NAME_COMMENT_COUNT:
traktSeason.CommentCount = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(traktSeason);
}
return(await Task.FromResult(default(ITraktSeason)));
}
public override async Task <ITraktEpisodeCheckinPostResponse> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var sharingReader = new SharingObjectJsonReader();
var episodeReader = new EpisodeObjectJsonReader();
var showReader = new ShowObjectJsonReader();
ITraktEpisodeCheckinPostResponse checkinEpisodeResponse = new TraktEpisodeCheckinPostResponse();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_ID:
{
var value = await JsonReaderHelper.ReadUnsignedLongValueAsync(jsonReader, cancellationToken);
if (value.First)
{
checkinEpisodeResponse.Id = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_WATCHED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
{
checkinEpisodeResponse.WatchedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_SHARING:
checkinEpisodeResponse.Sharing = await sharingReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_EPISODE:
checkinEpisodeResponse.Episode = await episodeReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_SHOW:
checkinEpisodeResponse.Show = await showReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return(checkinEpisodeResponse);
}
return(await Task.FromResult(default(ITraktEpisodeCheckinPostResponse)));
}
public override async Task <ITraktRecommendation> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var movieObjectReader = new MovieObjectJsonReader();
var showObjectReader = new ShowObjectJsonReader();
ITraktRecommendation traktRecommendation = new TraktRecommendation();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_RANK:
traktRecommendation.Rank = await jsonReader.ReadAsInt32Async(cancellationToken).ConfigureAwait(false);
break;
case JsonProperties.PROPERTY_NAME_LISTED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken).ConfigureAwait(false);
if (value.First)
{
traktRecommendation.ListedAt = value.Second;
}
break;
}
case JsonProperties.PROPERTY_NAME_TYPE:
traktRecommendation.Type = await JsonReaderHelper.ReadEnumerationValueAsync <TraktRecommendationObjectType>(jsonReader, cancellationToken).ConfigureAwait(false);
break;
case JsonProperties.PROPERTY_NAME_NOTES:
traktRecommendation.Notes = await jsonReader.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
break;
case JsonProperties.PROPERTY_NAME_MOVIE:
traktRecommendation.Movie = await movieObjectReader.ReadObjectAsync(jsonReader, cancellationToken).ConfigureAwait(false);
break;
case JsonProperties.PROPERTY_NAME_SHOW:
traktRecommendation.Show = await showObjectReader.ReadObjectAsync(jsonReader, cancellationToken).ConfigureAwait(false);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken).ConfigureAwait(false);
break;
}
}
return(traktRecommendation);
}
return(await Task.FromResult(default(ITraktRecommendation)));
}
public override async Task<ITraktComment> ReadObjectAsync(JsonTextReader jsonReader, CancellationToken cancellationToken = default)
{
CheckJsonTextReader(jsonReader);
if (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.StartObject)
{
var userReader = new UserObjectJsonReader();
ITraktComment traktComment = new TraktComment();
while (await jsonReader.ReadAsync(cancellationToken) && jsonReader.TokenType == JsonToken.PropertyName)
{
var propertyName = jsonReader.Value.ToString();
switch (propertyName)
{
case JsonProperties.PROPERTY_NAME_ID:
{
var value = await JsonReaderHelper.ReadUnsignedIntegerValueAsync(jsonReader, cancellationToken);
if (value.First)
traktComment.Id = value.Second;
break;
}
case JsonProperties.PROPERTY_NAME_PARENT_ID:
{
var value = await JsonReaderHelper.ReadUnsignedIntegerValueAsync(jsonReader, cancellationToken);
if (value.First)
traktComment.ParentId = value.Second;
break;
}
case JsonProperties.PROPERTY_NAME_CREATED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
traktComment.CreatedAt = value.Second;
break;
}
case JsonProperties.PROPERTY_NAME_UPDATED_AT:
{
var value = await JsonReaderHelper.ReadDateTimeValueAsync(jsonReader, cancellationToken);
if (value.First)
traktComment.UpdatedAt = value.Second;
break;
}
case JsonProperties.PROPERTY_NAME_COMMENT:
traktComment.Comment = await jsonReader.ReadAsStringAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_SPOILER:
traktComment.Spoiler = (bool)await jsonReader.ReadAsBooleanAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_REVIEW:
traktComment.Review = (bool)await jsonReader.ReadAsBooleanAsync(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_REPLIES:
traktComment.Replies = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_LIKES:
traktComment.Likes = await jsonReader.ReadAsInt32Async(cancellationToken);
break;
case JsonProperties.PROPERTY_NAME_USER_RATING:
{
var value = await JsonReaderHelper.ReadFloatValueAsync(jsonReader, cancellationToken);
if (value.First)
traktComment.UserRating = value.Second;
break;
}
case JsonProperties.PROPERTY_NAME_USER:
traktComment.User = await userReader.ReadObjectAsync(jsonReader, cancellationToken);
break;
default:
await JsonReaderHelper.ReadAndIgnoreInvalidContentAsync(jsonReader, cancellationToken);
break;
}
}
return traktComment;
}
return await Task.FromResult(default(ITraktComment));
}