private void SaveTraktAuthorization(ITraktAuthorization authorization, string path)
{
string serializedAuthorization = TraktSerializationService.SerializeAsync(authorization).Result;
string authorizationFilePath = Path.Combine(path, FileName.Authorization.Value);
_fileOperations.FileWriteAllText(authorizationFilePath, serializedAuthorization, Encoding.UTF8);
}
private void SaveLastSyncActivities(ITraktSyncLastActivities syncLastActivities)
{
string lastSyncActivitiesPath = Path.Combine(_mediaPortalServices.GetTraktUserHomePath(), FileName.LastActivity.Value);
string lastSyncActivitiesJson = TraktSerializationService.SerializeAsync(syncLastActivities).Result;
_fileOperations.FileWriteAllText(lastSyncActivitiesPath, lastSyncActivitiesJson, Encoding.UTF8);
}
private void SaveLastSyncActivities(ITraktSyncLastActivities traktSyncLastActivities, string path)
{
string serializedSyncActivities = TraktSerializationService.SerializeAsync(traktSyncLastActivities).Result;
string syncActivitiesFilePath = Path.Combine(path, FileName.LastActivity.Value);
_fileOperations.FileWriteAllText(syncActivitiesFilePath, serializedSyncActivities, Encoding.UTF8);
}
public void TestTraktSerializationServiceSerializeTraktDevice()
{
var jsonDevice = TraktSerializationService.Serialize(DEVICE);
jsonDevice.Should().NotBeNullOrEmpty();
jsonDevice.Should().Be(DEVICE_JSON);
}
public void TestTraktSerializationServiceSerializeTraktAuthorization()
{
var jsonAuthorization = TraktSerializationService.Serialize(AUTHORIZATION);
jsonAuthorization.Should().NotBeNullOrEmpty();
jsonAuthorization.Should().Be(AUTHORIZATION_JSON);
}
private void SaveTraktUserSettings(ITraktUserSettings traktUserSettings, string path)
{
string serializedSettings = TraktSerializationService.SerializeAsync(traktUserSettings).Result;
string settingsFilePath = Path.Combine(path, FileName.UserSettings.Value);
_fileOperations.FileWriteAllText(settingsFilePath, serializedSettings, Encoding.UTF8);
}
public async Task Test_TraktSerializationService_SerializeAsync_ITraktAuthorization_8()
{
string json = await TraktSerializationService.SerializeAsync(Authorization8);
json.Should().NotBeNullOrEmpty();
json.Should().Be(Authorization8Json);
}
public void EnterModelContext(NavigationContext oldContext, NavigationContext newContext)
{
// clear the PIN code text box, necessary when entering the plugin
PinCode = string.Empty;
string authFilePath = Path.Combine(_mediaPortalServices.GetTraktUserHomePath(), FileName.Authorization.Value);
bool savedAuthFileExists = _fileOperations.FileExists(authFilePath);
if (!savedAuthFileExists)
{
TestStatus = "[Trakt.NotAuthorized]";
IsUserAuthorized = false;
}
else
{
string savedAuthorization = _fileOperations.FileReadAllText(authFilePath);
ITraktAuthorization savedAuthFile = TraktSerializationService.DeserializeAsync <ITraktAuthorization>(savedAuthorization).Result;
if (savedAuthFile.IsRefreshPossible)
{
TestStatus = "[Trakt.AlreadyAuthorized]";
IsUserAuthorized = true;
}
else
{
TestStatus = "[Trakt.SavedAuthIsNotValid]";
IsUserAuthorized = false;
}
}
}
public async Task Test_TraktSerializationService_DeserializeAsync_ITraktAuthorization_ArgumentExceptions()
{
Func <Task <ITraktAuthorization> > act = () => TraktSerializationService.DeserializeAsync(null);
await act.Should().ThrowAsync <ArgumentNullException>();
act = () => TraktSerializationService.DeserializeAsync(string.Empty);
await act.Should().ThrowAsync <ArgumentException>();
}
static void Main(string[] args)
{
TraktClient client = new TraktClient(CLIENT_ID, CLIENT_SECRET);
TraktAuthorization fakeAuthorization = new TraktAuthorization
{
AccessToken = "FakeAccessToken",
RefreshToken = "FakeRefreshToken",
ExpiresInSeconds = 90 * 24 * 3600,
AccessScope = TraktAccessScope.Public,
TokenType = TraktAccessTokenType.Bearer
};
Console.WriteLine("Fake Authorization:");
Console.WriteLine($"Created (UTC): {fakeAuthorization.Created}");
Console.WriteLine($"Access Scope: {fakeAuthorization.AccessScope.DisplayName}");
Console.WriteLine($"Refresh Possible: {fakeAuthorization.IsRefreshPossible}");
Console.WriteLine($"Valid: {fakeAuthorization.IsValid}");
Console.WriteLine($"Token Type: {fakeAuthorization.TokenType.DisplayName}");
Console.WriteLine($"Access Token: {fakeAuthorization.AccessToken}");
Console.WriteLine($"Refresh Token: {fakeAuthorization.RefreshToken}");
Console.WriteLine($"Token Expired: {fakeAuthorization.IsExpired}");
Console.WriteLine($"Expires in {fakeAuthorization.ExpiresInSeconds / 3600 / 24} days");
Console.WriteLine("-------------------------------------------------------------");
//string fakeAuthorizationJson = TraktSerializationService.Serialize(client.Authorization);
string fakeAuthorizationJson = TraktSerializationService.Serialize(fakeAuthorization);
if (!string.IsNullOrEmpty(fakeAuthorizationJson))
{
Console.WriteLine("Serialized Fake Authorization:");
Console.WriteLine(fakeAuthorizationJson);
Console.WriteLine("-------------------------------------------------------------");
TraktAuthorization deserializedFakeAuthorization = TraktSerializationService.DeserializeAuthorization(fakeAuthorizationJson);
if (deserializedFakeAuthorization != null)
{
client.Authorization = deserializedFakeAuthorization;
Console.WriteLine("Deserialized Fake Authorization:");
Console.WriteLine($"Created (UTC): {deserializedFakeAuthorization.Created}");
Console.WriteLine($"Access Scope: {deserializedFakeAuthorization.AccessScope.DisplayName}");
Console.WriteLine($"Refresh Possible: {deserializedFakeAuthorization.IsRefreshPossible}");
Console.WriteLine($"Valid: {deserializedFakeAuthorization.IsValid}");
Console.WriteLine($"Token Type: {deserializedFakeAuthorization.TokenType.DisplayName}");
Console.WriteLine($"Access Token: {deserializedFakeAuthorization.AccessToken}");
Console.WriteLine($"Refresh Token: {deserializedFakeAuthorization.RefreshToken}");
Console.WriteLine($"Token Expired: {deserializedFakeAuthorization.IsExpired}");
Console.WriteLine($"Expires in {deserializedFakeAuthorization.ExpiresInSeconds / 3600 / 24} days");
}
}
Console.ReadLine();
}
public void TestTraktSerializationServiceDeserializeTraktDeviceArgumentExceptions()
{
Action act = () => TraktSerializationService.DeserializeDevice(null);
act.ShouldThrow <ArgumentException>();
act = () => TraktSerializationService.DeserializeDevice(string.Empty);
act.ShouldThrow <ArgumentException>();
}
public void TestTraktSerializationServiceDeserializeTraktDeviceInvalidJson()
{
Action act = () => TraktSerializationService.DeserializeDevice("{ \"invalid\": \"json\" }");
act.ShouldNotThrow();
var result = TraktSerializationService.DeserializeDevice("{ \"invalid\": \"json\" }");
result.Should().BeNull();
}
private IList <MovieCollected> GetCollectedMoviesFromOnlineAndSaveItToCache()
{
IEnumerable <ITraktCollectionMovie> collectedMovies = _traktClient.GetCollectedMovies();
string collectedMoviesPath = Path.Combine(_mediaPortalServices.GetTraktUserHomePath(), FileName.CollectedMovies.Value);
IList <ITraktCollectionMovie> traktCollectionMovies = collectedMovies.ToList();
string collectedMoviesJson = TraktSerializationService.SerializeCollectionAsync(traktCollectionMovies).Result;
_fileOperations.FileWriteAllText(collectedMoviesPath, collectedMoviesJson, Encoding.UTF8);
return(ConvertCollectionMoviesToMovieCollections(traktCollectionMovies));
}
private IList <EpisodeWatched> GetWatchedEpisodesFromOnlineAndSaveItToCache()
{
IEnumerable <ITraktWatchedShow> watchedShows = _traktClient.GetWatchedShows();
string watchedEpisodesFilePath = Path.Combine(_mediaPortalServices.GetTraktUserHomePath(), FileName.WatchedEpisodes.Value);
IList <ITraktWatchedShow> traktWatchedShows = watchedShows.ToList();
string watchedEpisodesJson = TraktSerializationService.SerializeCollectionAsync(traktWatchedShows).Result;
_fileOperations.FileWriteAllText(watchedEpisodesFilePath, watchedEpisodesJson, Encoding.UTF8);
return(ConvertWatchedShowsToWatchedEpisodes(traktWatchedShows));
}
public void TestTraktSerializationServiceDeserializeTraktDevice()
{
var device = TraktSerializationService.DeserializeDevice(DEVICE_JSON);
device.Should().NotBeNull();
device.UserCode.Should().Be(DEVICE.UserCode);
device.DeviceCode.Should().Be(DEVICE.DeviceCode);
device.VerificationUrl.Should().Be(DEVICE.VerificationUrl);
device.ExpiresInSeconds.Should().Be(DEVICE.ExpiresInSeconds);
device.IntervalInSeconds.Should().Be(DEVICE.IntervalInSeconds);
device.Created.Should().Be(DEVICE.Created);
}
public async Task Test_TraktSerializationService_DeserializeAsync_ITraktAuthorization_1()
{
ITraktAuthorization authorization = await TraktSerializationService.DeserializeAsync(Authorization1Json);
authorization.Should().NotBeNull();
authorization.AccessToken.Should().Be(TestConstants.MOCK_ACCESS_TOKEN);
authorization.RefreshToken.Should().BeNull();
authorization.Scope.Should().Be(TraktAccessScope.Public);
authorization.TokenType.Should().Be(TraktAccessTokenType.Bearer);
authorization.ExpiresInSeconds.Should().Be(7776000U);
authorization.IgnoreExpiration.Should().BeTrue();
authorization.CreatedAtTimestamp.Should().Be(Authorization1.CreatedAtTimestamp);
}
private IList <MovieCollected> CachedCollectedMovies()
{
IEnumerable <ITraktCollectionMovie> collectedMovies = new List <ITraktCollectionMovie>();
string collectedMoviesPath = Path.Combine(_mediaPortalServices.GetTraktUserHomePath(), FileName.CollectedMovies.Value);
if (_fileOperations.FileExists(collectedMoviesPath))
{
string collectedMoviesJson = _fileOperations.FileReadAllText(collectedMoviesPath);
collectedMovies = TraktSerializationService.DeserializeCollectionAsync <ITraktCollectionMovie>(collectedMoviesJson).Result;
}
return(ConvertCollectionMoviesToMovieCollections(collectedMovies));
}
public async Task Test_TraktSerializationService_DeserializeAsync_ITraktAuthorization_8()
{
ITraktAuthorization authorization = await TraktSerializationService.DeserializeAsync(Authorization8Json);
authorization.Should().NotBeNull();
authorization.AccessToken.Should().Be(TestConstants.MOCK_ACCESS_TOKEN);
authorization.RefreshToken.Should().Be(TestConstants.MOCK_REFRESH_TOKEN);
authorization.Scope.Should().Be(TraktAccessScope.Public);
authorization.TokenType.Should().Be(TraktAccessTokenType.Bearer);
authorization.ExpiresInSeconds.Should().Be(EXPIRES_IN_SECONDS);
authorization.IgnoreExpiration.Should().BeFalse();
authorization.CreatedAtTimestamp.Should().Be(s_createdAtTimestamp);
}
public void TestTraktSerializationServiceDeserializeTraktAuthorization()
{
var authorization = TraktSerializationService.DeserializeAuthorization(AUTHORIZATION_JSON);
authorization.Should().NotBeNull();
authorization.AccessToken.Should().Be(AUTHORIZATION.AccessToken);
authorization.RefreshToken.Should().Be(AUTHORIZATION.RefreshToken);
authorization.ExpiresInSeconds.Should().Be(AUTHORIZATION.ExpiresInSeconds);
authorization.AccessScope.Should().Be(AUTHORIZATION.AccessScope);
authorization.TokenType.Should().Be(AUTHORIZATION.TokenType);
authorization.Created.Should().Be(AUTHORIZATION.Created);
authorization.IgnoreExpiration.Should().Be(AUTHORIZATION.IgnoreExpiration);
}
private IEnumerable <EpisodeWatched> GetWatchedEpisodesFromCache()
{
IEnumerable <ITraktWatchedShow> traktWatchedShows = new List <ITraktWatchedShow>();
string watchedEpisodesPath = Path.Combine(_mediaPortalServices.GetTraktUserHomePath(), FileName.WatchedEpisodes.Value);
if (_fileOperations.FileExists(watchedEpisodesPath))
{
string watchedEpisodesJson = _fileOperations.FileReadAllText(watchedEpisodesPath);
traktWatchedShows = TraktSerializationService.DeserializeCollectionAsync <ITraktWatchedShow>(watchedEpisodesJson).Result;
}
return(ConvertWatchedShowsToWatchedEpisodes(traktWatchedShows));
}
private void ValidateAuthorization(ITraktClient _traktClient, IFileOperations _fileOperations)
{
if (!_traktClient.TraktAuthorization.IsValid)
{
string authFilePath = Path.Combine(HomeUserPath, FileName.Authorization.Value);
string savedAuthorization = _fileOperations.FileReadAllText(authFilePath);
ITraktAuthorization savedAuth = TraktSerializationService.DeserializeAsync <ITraktAuthorization>(savedAuthorization).Result;
if (!savedAuth.IsRefreshPossible)
{
throw new Exception("Saved authorization is not valid.");
}
ITraktAuthorization refreshedAuth = _traktClient.RefreshAuthorization(savedAuth.RefreshToken);
string serializedAuth = TraktSerializationService.SerializeAsync(refreshedAuth).Result;
_fileOperations.FileWriteAllText(authFilePath, serializedAuth, Encoding.UTF8);
}
}
private ITraktSyncLastActivities SavedLastSyncActivities()
{
string traktUserHomePath = _mediaPortalServices.GetTraktUserHomePath();
string savedSyncActivitiesFilePath = Path.Combine(traktUserHomePath, FileName.LastActivity.Value);
if (!_fileOperations.FileExists(savedSyncActivitiesFilePath))
{
return(new TraktSyncLastActivities
{
Movies = new TraktSyncMoviesLastActivities(),
Shows = new TraktSyncShowsLastActivities(),
Episodes = new TraktSyncEpisodesLastActivities()
});
}
string savedSyncActivitiesJson = _fileOperations.FileReadAllText(savedSyncActivitiesFilePath);
return(TraktSerializationService.DeserializeAsync <ITraktSyncLastActivities>(savedSyncActivitiesJson).Result);
}
public void TestTraktSerializationServiceDeserializeTraktAuthorizationInvalidJson()
{
Action act = () => TraktSerializationService.DeserializeAuthorization("{ \"invalid\": \"json\" }");
act.ShouldNotThrow();
var result = TraktSerializationService.DeserializeAuthorization("{ \"invalid\": \"json\" }");
result.Should().BeNull();
act = () => TraktSerializationService.DeserializeAuthorization("invalid\": \"json\" }");
act.ShouldThrow <ArgumentException>();
string invalidAuthorizationJson =
"{" +
$"\"AccessToken\":\"\"," +
$"\"RefreshToken\":\"\"," +
$"\"ExpiresIn\":\"stringvalue\"," +
$"\"Scope\":\"public\"," +
$"\"TokenType\":\"bearer\"," +
$"\"CreatedAtTicks\":0," +
$"\"IgnoreExpiration\":false" +
"}";
act = () => TraktSerializationService.DeserializeAuthorization(invalidAuthorizationJson);
act.ShouldThrow <ArgumentException>();
invalidAuthorizationJson =
"{" +
$"\"AccessToken\":\"\"," +
$"\"RefreshToken\":\"\"," +
$"\"ExpiresIn\":0," +
$"\"Scope\":\"public\"," +
$"\"TokenType\":\"bearer\"," +
$"\"CreatedAtTicks\":\"stringvalue\"," +
$"\"IgnoreExpiration\":false" +
"}";
act = () => TraktSerializationService.DeserializeAuthorization(invalidAuthorizationJson);
act.ShouldThrow <ArgumentException>();
}
public void TestTraktSerializationServiceSerializeEmptyTraktDevice()
{
var emptyDevice = new TraktDevice();
string emptyDeviceJson =
"{" +
$"\"UserCode\":\"\"," +
$"\"DeviceCode\":\"\"," +
$"\"VerificationUrl\":\"\"," +
$"\"ExpiresInSeconds\":0," +
$"\"IntervalInSeconds\":0," +
$"\"CreatedAtTicks\":{emptyDevice.Created.Ticks}" +
"}";
Action act = () => TraktSerializationService.Serialize(emptyDevice);
act.ShouldNotThrow();
var jsonDevice = TraktSerializationService.Serialize(emptyDevice);
jsonDevice.Should().NotBeNullOrEmpty();
jsonDevice.Should().Be(emptyDeviceJson);
}
public void TestTraktSerializationServiceSerializeEmptyTraktAuthorization()
{
var emptyAuthorization = new TraktAuthorization();
string emptyAuthorizationJson =
"{" +
$"\"AccessToken\":\"\"," +
$"\"RefreshToken\":\"\"," +
$"\"ExpiresIn\":0," +
$"\"Scope\":\"public\"," +
$"\"TokenType\":\"bearer\"," +
$"\"CreatedAtTicks\":{emptyAuthorization.Created.Ticks}," +
$"\"IgnoreExpiration\":false" +
"}";
Action act = () => TraktSerializationService.Serialize(emptyAuthorization);
act.ShouldNotThrow();
var jsonAuthorization = TraktSerializationService.Serialize(emptyAuthorization);
jsonAuthorization.Should().NotBeNullOrEmpty();
jsonAuthorization.Should().Be(emptyAuthorizationJson);
}
public void TestTraktSerializationServiceSerializeTraktAuthorizationArgumentExceptions()
{
Action act = () => TraktSerializationService.Serialize(default(TraktAuthorization));
act.ShouldThrow <ArgumentNullException>();
}
public void Test_TraktSerializationService_SerializeAsync_ITraktAuthorization_ArgumentExceptions()
{
Func <Task <string> > act = () => TraktSerializationService.SerializeAsync(null);
act.Should().Throw <ArgumentNullException>();
}
