private void EnsureAllGenres(ApiQueryResponse <Genre> response)
{
if (response.Error != null)
{
return;
}
if (response.Item == null)
{
return;
}
if (_allGenres.Contains(response.Item) == false)
{
_allGenres.Add(response.Item);
}
}
public static async Task <List <Film> > PopulateMovieListAsync(IApiMovieRequest movieApi, ApiSearchResponse <MovieInfo> apiResponse)
{
List <Film> movies = new List <Film>();
if (apiResponse == null)
{
return(movies);
}
foreach (MovieInfo info in apiResponse.Results)
{
ApiQueryResponse <MovieCredit> castResponse = await movieApi.GetCreditsAsync(info.Id);
ApiQueryResponse <Movie> infoResponse = await movieApi.FindByIdAsync(info.Id);
Film movie = new Film()
{
Title = info.Title,
ReleaseYear = infoResponse.Item.ReleaseDate.Year,
Runtime = infoResponse.Item.Runtime.ToString(),
Genre = new List <string>(),
Actors = new List <string>(),
Description = infoResponse.Item.Overview,
PosterPath = infoResponse.Item.PosterPath
};
if (infoResponse.Item.Genres.Count != 0)
{
for (int i = 0; i < infoResponse.Item.Genres.Count; i++)
{
movie.Genre.Add(infoResponse.Item.Genres[i].Name);
}
}
if (castResponse.Item.CastMembers.Count != 0)
{
for (int i = 0; i < castResponse.Item.CastMembers.Count && i < 3; i++)
{
movie.Actors.Add(castResponse.Item.CastMembers[i].Name);
}
}
movies.Add(movie);
}
return(movies);
}
public async Task <ApiQueryResponse <Person> > FindByIdAsync(int personId, string language = "en", bool includeImages = false)
{
var param = new Dictionary <string, string>
{
{ "language", language }
};
if (includeImages)
{
param.Add("append_to_response", "images");
}
string command = $"person/{personId}";
ApiQueryResponse <Person> response = await base.QueryAsync <Person>(command, param);
return(response);
}
public async Task <ApiQueryResponse <Movie> > FindByIdAsync(int movieId, string language = "en")
{
var param = new Dictionary <string, string>
{
{ "language", language },
{ "append_to_response", "keywords" },
};
string command = $"movie/{movieId}";
ApiQueryResponse <Movie> response = await base.QueryAsync <Movie>(command, param);
//var config = await GetConfiguration(_settings);
//var baseImageUrl = string.Format("{0}{1}", config.Images.SecureRootUrl, config.Images.Posters.Last());
//response.Item.PosterPath = baseImageUrl + response.Item.PosterPath;
return(response);
}
public async Task ResourceNotFound_MovieById()
{
const int validId = 104;
const int invalidId = 0;
// Step 1: Ensure there is a valid result
ApiQueryResponse <Movie> validResult = await _api.QueryAsync <Movie>($"movie/{validId}");
Assert.IsNull(validResult.Error);
Assert.AreEqual(validId, validResult.Item.Id);
Assert.AreEqual("Run Lola Run", validResult.Item.Title);
// Step 2: Ensure there is an invalid result
ApiQueryResponse <Movie> invalidResult = await _api.QueryAsync <Movie>($"movie/{invalidId}");
AssertErrorCode(invalidResult, TmdbStatusCode.ResourceNotFound);
}
public async Task <ApiQueryResponse <Movie> > FindByIdAsync(int movieId, string language = "en", bool includeImages = false)
{
var param = new Dictionary <string, string>
{
{ "language", language },
{ "append_to_response", "keywords" },
};
if (includeImages)
{
param["append_to_response"] += ",images";
}
string command = $"movie/{movieId}";
ApiQueryResponse <Movie> response = await base.QueryAsync <Movie>(command, param);
return(response);
}
public async Task FindByIdAsync_Pixar_IncludesParentCompany()
{
const int id = 3;
const string expectedName = "Pixar";
const string expectedParentName = "Walt Disney Pictures";
const int expectedParentId = 2;
ApiQueryResponse <ProductionCompany> response = await _api.FindByIdAsync(id);
ApiResponseUtil.AssertErrorIsNull(response);
Assert.AreEqual(id, response.Item.Id);
Assert.AreEqual(expectedName, response.Item.Name);
Assert.IsNotNull(response.Item.ParentCompany);
Assert.AreEqual(expectedParentId, response.Item.ParentCompany.Id);
Assert.AreEqual(expectedParentName, response.Item.ParentCompany.Name);
ApiResponseUtil.AssertImagePath(response.Item.ParentCompany.LogoPath);
}
public async Task FindByIdAsync_Lucasfilm_WithResults_NoParentCompany()
{
const int id = 1;
const string expectedName = "Lucasfilm Ltd.";
const string expectedHeadquarters = "San Francisco, California";
const string expectedHomepage = "https://www.lucasfilm.com";
ApiQueryResponse <ProductionCompany> response = await _api.FindByIdAsync(id);
ApiResponseUtil.AssertErrorIsNull(response);
Assert.AreEqual(id, response.Item.Id);
Assert.AreEqual(expectedName, response.Item.Name);
Assert.AreEqual(expectedHeadquarters, response.Item.Headquarters);
Assert.AreEqual(new Uri(expectedHomepage), new Uri(response.Item.Homepage));
ApiResponseUtil.AssertImagePath(response.Item.LogoPath);
Assert.IsNull(response.Item.ParentCompany);
}
public async Task FindById_Returns_Foreign_Genre_NotInGetAll()
{
const int id = 10769;
const string name = "Foreign";
CollectionAssert.DoesNotContain(_api.AllGenres.ToList(), new Genre(id, name));
// FindById will add to AllGenres when it does not exist
ApiQueryResponse <Genre> response = await _api.FindByIdAsync(id);
ApiResponseUtil.AssertErrorIsNull(response);
Genre genre = response.Item;
Assert.AreEqual(id, genre.Id);
Assert.AreEqual(name, genre.Name);
CollectionAssert.Contains(_api.AllGenres.ToList(), new Genre(id, name));
CollectionAssert.Contains(_api.AllGenres.ToList(), genre);
}
public async Task <MovieDetails> GetMovieDetail(int id)
{
ApiQueryResponse <Movie> movieInfo = await _api.FindByIdAsync(id);
MovieDetails movie = new MovieDetails()
{
title = movieInfo.Item.Title,
runtime = movieInfo.Item.Runtime.ToString(),
description = movieInfo.Item.Overview,
tagLine = movieInfo.Item.Tagline,
budget = movieInfo.Item.Budget,
genres = new List <String>()
};
for (int i = 0; i < movieInfo.Item.Genres.Count; i++)
{
movie.genres.Add(movieInfo.Item.Genres[i].ToString());
}
return(movie);
}
public async Task RegisterSettings_CanUse_RawStrings()
{
try
{
MovieDbFactory.ResetFactory();
MovieDbFactory.RegisterSettings(AssemblyInit.Settings.ApiKey, AssemblyInit.Settings.ApiUrl);
var api = MovieDbFactory.Create <IApiMovieRequest>().Value;
ApiQueryResponse <Movie> response = await api.GetLatestAsync();
Assert.IsNull(response.Error);
Assert.IsNotNull(response.Item);
Assert.IsTrue(response.Item.Id > 391000);
}
finally
{
// keeps all other tests running since the settings are registered in AssemblyInit for all tests.
AssemblyInit.RegisterFactorySettings();
}
}
// Extract three starring actors from MovieCredit object by movie ID
public async System.Threading.Tasks.Task <string> GetThreeCastMembersAsync(int id)
{
ApiQueryResponse <MovieCredit> responseCast = await _movieApi.GetCreditsAsync(id);
string movieCast = "";
for (int i = 0; i < 3; i++)
{
if (i == responseCast.Item.CastMembers.Count)
{
break;
}
if (i != 0)
{
movieCast = movieCast + ", ";
}
movieCast = movieCast + responseCast.Item.CastMembers[i].Name;
}
return(movieCast);
}
public async Task GetAllAsync_Returns_ValidResults()
{
const int expectedCount = 12;
ApiQueryResponse <IReadOnlyList <Profession> > response = await _api.GetAllAsync();
ApiResponseUtil.AssertErrorIsNull(response);
Assert.AreEqual(expectedCount, response.Item.Count);
foreach (Profession pro in response.Item)
{
Assert.IsTrue(pro.Department.Length >= 3, pro.Department); // Art
Assert.IsNotNull(pro.Jobs, $"Job Dept: {pro.Department}");
Assert.IsTrue(pro.Jobs.Count >= 5, $"Actual Count: {pro.Jobs.Count}");
foreach (string job in pro.Jobs)
{
Assert.IsTrue(job.Length >= 4, job); // Idea
}
}
}
public async Task <String> GetActorsAndRoles(MovieDetail movie)
{
ApiQueryResponse <MovieCredit> cast = await _api.GetCreditsAsync(movie.id);
var actors = "";
if (cast.Item != null)
{
for (int i = 0; i < cast.Item.CastMembers.Count && i < 3; i++)
{
if (i + 1 == cast.Item.CastMembers.Count && i < 7)
{
actors += cast.Item.CastMembers[i].Name + " - " + cast.Item.CastMembers[i].Character;
}
else
{
actors += cast.Item.CastMembers[i].Name + " - " + cast.Item.CastMembers[i].Character + "\n";
}
}
}
return(actors);
}
private async Task populateInfoHelper(Movies movies, ApiSearchResponse <MovieInfo> res)
{
movies.ClearList();
foreach (var m in res.Results)
{
ApiQueryResponse <MovieCredit> movieCreditsResponse = await _movieApi.GetCreditsAsync(m.Id);
var localFilePath = _imageDl.LocalPathForFilename(m.PosterPath);
if (localFilePath != string.Empty)
{
if (!File.Exists(localFilePath))
{
await _imageDl.DownloadImage(m.PosterPath, localFilePath, CancellationToken.None);
}
}
m.PosterPath = localFilePath;
movies.ExtractInfo(m, movieCreditsResponse);
}
return;
}
public async Task FindByIdAsync_CourteneyCox_Returns_ExpectedValues()
{
const string expectedName = "Courteney Cox";
const string expectedBiography = "Courteney Bass Cox (born June 15, 1964) is an American actress"; // truncated
DateTime expectedBirthday = DateTime.Parse("1964-06-15");
const Gender expectedGender = Gender.Female;
const string expectedHomepage = null;
const string expectedImdbId = "nm0001073";
const string expectedPlaceOfBirth = "Birmingham, Alabama, USA";
string[] alsoKnownAs =
{
"CeCe",
"Coco",
"Courtney Cox",
};
ApiQueryResponse <Person> response = await _api.FindByIdAsync(PersonId_CourteneyCox);
ApiResponseUtil.AssertErrorIsNull(response);
Person person = response.Item;
Assert.AreEqual(expectedName, person.Name);
Assert.IsTrue(person.Biography.StartsWith(expectedBiography));
Assert.IsFalse(person.IsAdultFilmStar);
Assert.AreEqual(expectedBirthday, person.Birthday);
Assert.AreEqual(expectedGender, person.Gender);
Assert.AreEqual(null, person.Deathday);
Assert.AreEqual(expectedHomepage, person.Homepage);
Assert.AreEqual(expectedImdbId, person.ImdbId);
Assert.AreEqual(expectedPlaceOfBirth, person.PlaceOfBirth);
Assert.IsTrue(person.Popularity > 3);
Assert.IsNotNull(person.ProfilePath);
CollectionAssert.IsSubsetOf(alsoKnownAs, person.AlsoKnownAs.ToArray(),
"actual:\r\n" + string.Join("\r\n", person.AlsoKnownAs));
}
public static async Task FindMovieActorsAsync(IApiMovieRequest movieApi, Film movie)
{
if (movie == null)
{
return;
}
List <string> actors = new List <string>();
ApiQueryResponse <MovieCredit> castResponse = await movieApi.GetCreditsAsync(movie.Id);
if (castResponse.Item.CastMembers.Count != 0)
{
for (int i = 0; i < castResponse.Item.CastMembers.Count && i < 3; i++)
{
if (castResponse.Item.CastMembers[i].Name != "")
{
actors.Add(castResponse.Item.CastMembers[i].Name);
}
}
movie.Actors = String.Join(", ", actors);
actors.Clear();
}
}
public async Task <List <Movie> > getListOfMoviesMatchingSearch(string nameField)
{
List <Movie> responseMovieList = new List <Movie>();
if (nameField.Length == 0)
{
return(responseMovieList);
}
else
{
this._response = await _movieApi.SearchByTitleAsync(nameField);
foreach (MovieInfo info in _response.Results)
{
ApiQueryResponse <MovieCredit> cast = await _movieApi.GetCreditsAsync(info.Id);
List <string> actors = new List <string>();
int number = 3;
if (cast.Item.CastMembers.Count < 3)
{
number = cast.Item.CastMembers.Count;
}
for (int i = 0; i < number; i++)
{
actors.Add(cast.Item.CastMembers[i].Name);
}
responseMovieList.Add(new Movie()
{
Title = info.Title, Year = info.ReleaseDate, Actors = actors, ImageUrl = info.PosterPath
});
}
}
return(responseMovieList);
}
public async Task FindByIdAsync_KevinBacon_Returns_ExpectedValues()
{
const string expectedName = "Kevin Bacon";
const string expectedBiography = "Kevin Norwood Bacon (born July 8, 1958) is an American film and theater actor"; // truncated
DateTime expectedBirthday = DateTime.Parse("1958-07-08");
const Gender expectedGender = Gender.Male;
const string expectedHomepage = "http://www.baconbros.com";
const string expectedImdbId = "nm0000102";
const string expectedPlaceOfBirth = "Philadelphia, Pennsylvania, USA";
string[] alsoKnownAs =
{
"Kevin Norwood Bacon",
};
ApiQueryResponse <Person> response = await _api.FindByIdAsync(PersonId_KevinBacon);
ApiResponseUtil.AssertErrorIsNull(response);
Person person = response.Item;
Assert.AreEqual(expectedName, person.Name);
Assert.IsTrue(person.Biography.StartsWith(expectedBiography), $"Actual Biography: {person.Biography}");
Assert.IsFalse(person.IsAdultFilmStar);
Assert.AreEqual(expectedBirthday, person.Birthday);
Assert.AreEqual(expectedGender, person.Gender);
Assert.AreEqual(null, person.Deathday);
Assert.AreEqual(expectedHomepage, person.Homepage);
Assert.AreEqual(expectedImdbId, person.ImdbId);
Assert.AreEqual(expectedPlaceOfBirth, person.PlaceOfBirth);
Assert.IsTrue(person.Popularity > 2);
Assert.IsNotNull(person.ProfilePath);
CollectionAssert.AreEquivalent(alsoKnownAs, person.AlsoKnownAs.ToArray());
Assert.IsNull(person.Profiles);
}
public async Task <string> GetActors(Movie movie)
{
ApiQueryResponse <MovieCredit> cast = await _movieApi.GetCreditsAsync(movie.Id);
string actors = "";
int number = 3;
if (cast.Item.CastMembers.Count < 3)
{
number = cast.Item.CastMembers.Count;
}
for (int i = 0; i < number; i++)
{
if (i == number - 1)
{
actors += cast.Item.CastMembers[i].Name;
}
else
{
actors += cast.Item.CastMembers[i].Name + ", ";
}
}
return(actors);
}
public async Task GetCreditsAsync_ReturnsCastMembers()
{
const int tvShowRunLolaRun = 106159;
ApiQueryResponse <TVShowEpisodeCredit> response = await _api.GetCreditsAsync(tvShowRunLolaRun, 1, 1);
ApiResponseUtil.AssertErrorIsNull(response);
TVShowEpisodeCredit credit = response.Item;
TVShowEpisodeCastMember member = credit.CastMembers.Single(x => x.Character == "Bryan Beneventi");
Assert.AreEqual(17243, member.PersonId);
Assert.AreEqual("5f131fbeb87aec00361e2ebd", member.CreditId);
Assert.AreEqual("Jonathan Tucker", member.Name);
foreach (TVShowEpisodeCastMember castMember in credit.CastMembers)
{
Assert.IsTrue(castMember.PersonId > 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(castMember.CreditId));
Assert.IsFalse(string.IsNullOrWhiteSpace(castMember.Name));
Assert.IsFalse(string.IsNullOrWhiteSpace(castMember.Character));
}
}
public async Task FetchTopRatedMovies()
{
counter++;
if (counter == 1)
{
MovieDbFactory.RegisterSettings("7d9a7734361d93c55e7b4691d91e1197", "http://api.themoviedb.org/3/");
IApiMovieRequest movieApi = MovieDbFactory.Create <IApiMovieRequest>().Value;
this.storageClient = new StorageClient();
this.imageDownloader = new ImageDownloader(this.storageClient);
this._moviesmodel.Clear();
//if (movieNameEditText.Text == "")
//{
//}
// else
// {
responseTopRated = await movieApi.GetTopRatedAsync();
var topRated = responseTopRated.Results;
for (int i = 0; i < topRated.Count; i++)
{
ApiQueryResponse <MovieCredit> responseTopRatedCast = await movieApi.GetCreditsAsync(topRated[i].Id);
ApiQueryResponse <Movie> responseTopRatedGenre = await movieApi.FindByIdAsync(topRated[i].Id);
var topRatedGenresList = responseTopRatedGenre.Item.Genres;
var topRatedCastList = responseTopRatedCast.Item.CastMembers;
var topRatedTime = responseTopRatedGenre.Item.Runtime;
string path = "Not check";
if (topRated[i].PosterPath == null)
{
// await
//imageDownloader.DownloadImage(topRated[i].PosterPath, imageDownloader.LocalPathForFilename(topRated[i].PosterPath),
// CancellationToken.None);
path = "Empty";
}
else
{
path = topRated[i].PosterPath;
}
string genreList = topRatedTime + " | ";
if (topRatedGenresList.Count == 0)
{
genreList += "";
}
else
{
genreList += topRatedGenresList[0].Name;
}
for (var j = 1; j < topRatedGenresList.Count; j++)
{
if (!topRatedGenresList[j].Equals(null))
{
genreList += ", " + topRatedGenresList[j].Name;
}
}
switch (topRatedCastList.Count)
{
case 0:
this._moviesmodel.Add(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
string.Empty, path,
genreList, topRated[i].Overview));
break;
case 1:
this._moviesmodel.Add(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
topRatedCastList[0].Name, path,
genreList, topRated[i].Overview));
break;
case 2:
this._moviesmodel.Add(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
topRatedCastList[0].Name + ", " + topRatedCastList[1].Name, path,
genreList, topRated[i].Overview));
break;
default:
this._moviesmodel.Add(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
topRatedCastList[0].Name + ", " + topRatedCastList[1].Name + ", " + topRatedCastList[2].Name, path,
genreList, topRated[i].Overview));
break;
}
}
var intent = new Intent(this.Context, typeof(MovieListActivity));
// intent.PutStringArrayListExtra("movieList", this.movies);
intent.PutExtra("movieList", JsonConvert.SerializeObject(this._moviesmodel));
StartActivity(intent);
}
else
{
var intent = new Intent(this.Context, typeof(MovieListActivity));
// intent.PutStringArrayListExtra("movieList", this.movies);
intent.PutExtra("movieList", JsonConvert.SerializeObject(this._moviesmodel));
StartActivity(intent);
}
spinner.Visibility = ViewStates.Gone;
}
private async Task <List <FilmInfo> > formatResponse(ApiSearchResponse <MovieInfo> response)
{
List <FilmInfo> result = new List <FilmInfo>();
try
{
if (response.Results != null)
{
foreach (MovieInfo info in response.Results)
{
FilmInfo film = new FilmInfo();
film.title = info.Title;
film.year = info.ReleaseDate.Year.ToString();
film.rating = info.VoteAverage.ToString().Equals("0") ? "-" : info.VoteAverage.ToString();
film.description = info.Overview;
film.imageName = "http://image.tmdb.org/t/p/w92" + info.PosterPath;
List <string> genres = new List <string>();
if (info.Genres != null)
{
foreach (var genre in info.Genres)
{
if (genre != null)
{
genres.Add(genre.Name);
}
}
}
film.genres = genres;
//Get the movie duration
ApiQueryResponse <Movie> movie = await _movieApi.FindByIdAsync(info.Id);
if (movie != null && movie.Item != null)
{
film.duration = "";
if (movie.Item.Runtime != null)
{
film.duration = movie.Item.Runtime.ToString();
}
}
ApiQueryResponse <MovieCredit> credits = null;
//Get the cast of a movie
try
{
credits = await _movieApi.GetCreditsAsync(info.Id);
}
catch (Exception)
{
}
List <string> cast = new List <string>();
if (credits != null && credits.Item != null)
{
if (credits.Item.CastMembers != null)
{
foreach (var actor in credits.Item.CastMembers)
{
cast.Add(actor.Name);
}
}
}
film.cast = cast;
result.Add(film);
}
}
}
catch (Exception)
{
}
return(result);
}
public async Task GetMovieCreditsAsync_KevinBacon_Returns_ExpectedValues()
{
ApiQueryResponse <PersonMovieCredit> response = await _api.GetMovieCreditsAsync(PersonId_KevinBacon);
ApiResponseUtil.AssertErrorIsNull(response);
PersonMovieCredit credits = response.Item;
Assert.AreEqual(PersonId_KevinBacon, credits.PersonId);
Assert.IsTrue(credits.CastRoles.Count > 70, $"Actual Count: {credits.CastRoles.Count}");
Assert.IsTrue(credits.CrewRoles.Count >= 5, $"Actual Count: {credits.CrewRoles.Count}");
PersonMovieCastMember castMember = credits.CastRoles.SingleOrDefault(x => x.Title == "Footloose");
Assert.IsNotNull(castMember);
Assert.AreEqual(1788, castMember.MovieId);
Assert.IsFalse(castMember.IsAdultThemed);
Assert.AreEqual("Footloose", castMember.Title);
Assert.AreEqual("Footloose", castMember.OriginalTitle);
Assert.AreEqual("Ren McCormack", castMember.Character);
Assert.AreEqual("52fe4315c3a36847f8038fc3", castMember.CreditId);
Assert.AreEqual(DateTime.Parse("1984-02-17"), castMember.ReleaseDate);
Assert.IsNotNull(castMember.PosterPath);
PersonMovieCrewMember crewMember = credits.CrewRoles.SingleOrDefault(x => x.Title == "Wild Things");
Assert.IsNotNull(crewMember);
Assert.AreEqual(617, crewMember.MovieId);
Assert.IsFalse(crewMember.IsAdultThemed);
Assert.AreEqual("Wild Things", crewMember.Title);
Assert.AreEqual("Wild Things", crewMember.OriginalTitle);
Assert.AreEqual("Production", crewMember.Department);
Assert.AreEqual("Executive Producer", crewMember.Job);
Assert.AreEqual("52fe425ec3a36847f8018f2d", crewMember.CreditId);
Assert.IsNotNull(crewMember.PosterPath);
Assert.AreEqual(DateTime.Parse("1998-03-20"), crewMember.ReleaseDate);
var expectedCastRoles = new Dictionary <string, string>
{
{ "Footloose", "Ren McCormack" },
{ "Animal House", "Chip Diller" },
{ "Hollow Man", "Sebastian Caine" },
{ "Wild Things", "Sergeant Ray Duquette" },
};
foreach (KeyValuePair <string, string> role in expectedCastRoles)
{
PersonMovieCastMember cast = credits
.CastRoles
.SingleOrDefault(x => x.Title == role.Key && x.Character == role.Value);
Assert.IsNotNull(cast);
}
var expectedCrewRoles = new Dictionary <string, string>
{
{ "Losing Chase", "Director" },
{ "Loverboy", "Director" },
{ "Wild Things", "Executive Producer" },
{ "The Woodsman", "Executive Producer" },
{ "Cop Car", "Executive Producer" },
};
foreach (KeyValuePair <string, string> role in expectedCrewRoles)
{
PersonMovieCrewMember cast = credits
.CrewRoles
.SingleOrDefault(x => x.Title == role.Key && x.Job == role.Value);
Assert.IsNotNull(cast);
}
}
public async Task GetTVCreditsAsync_CourteneyCox_Returns_ExpectedValues()
{
ApiQueryResponse <PersonTVCredit> response = await _api.GetTVCreditsAsync(PersonId_CourteneyCox);
ApiResponseUtil.AssertErrorIsNull(response);
PersonTVCredit credits = response.Item;
Assert.AreEqual(PersonId_CourteneyCox, credits.PersonId);
Assert.IsTrue(credits.CastRoles.Count > 20, $"Actual Count: {credits.CastRoles.Count}");
Assert.IsTrue(credits.CrewRoles.Count >= 3, $"Actual Count: {credits.CrewRoles.Count}");
PersonTVCastMember castMember = credits.CastRoles.SingleOrDefault(x => x.Name == "Friends");
Assert.IsNotNull(castMember);
Assert.AreEqual(1668, castMember.TVShowId);
Assert.AreEqual("525710bc19c295731c032341", castMember.CreditId);
Assert.AreEqual(236, castMember.EpisodeCount);
Assert.AreEqual(DateTime.Parse("1994-09-22"), castMember.FirstAirDate);
Assert.AreEqual("Friends", castMember.Name);
Assert.AreEqual("Friends", castMember.OriginalName);
Assert.AreEqual("Monica Geller", castMember.Character);
Assert.IsNotNull(castMember.PosterPath);
PersonTVCrewMember crewMember = credits.CrewRoles.SingleOrDefault(x => x.Name == "Dirt");
Assert.IsNotNull(crewMember);
Assert.AreEqual(284, crewMember.TVShowId);
Assert.AreEqual("Production", crewMember.Department);
Assert.AreEqual(20, crewMember.EpisodeCount);
Assert.AreEqual(DateTime.Parse("2007-01-02"), crewMember.FirstAirDate);
Assert.AreEqual("Producer", crewMember.Job);
Assert.AreEqual("Dirt", crewMember.Name);
Assert.AreEqual("Dirt", crewMember.OriginalName);
Assert.AreEqual("52534b4119c29579400f66b9", crewMember.CreditId);
Assert.IsNotNull(crewMember.PosterPath);
var expectedCastRoles = new Dictionary <string, string>
{
{ "Friends", "Monica Geller" },
{ "The Trouble with Larry", "Gabriella Easden" },
{ "Misfits of Science", "Gloria Dinallo" },
{ "Cougar Town", "Jules Cobb" },
};
foreach (KeyValuePair <string, string> role in expectedCastRoles)
{
PersonTVCastMember cast = credits
.CastRoles
.SingleOrDefault(x => x.Name == role.Key && x.Character == role.Value);
Assert.IsNotNull(cast);
}
var expectedCrewRoles = new Dictionary <string, string>
{
{ "Cougar Town", "Producer" },
{ "Dirt", "Producer" },
{ "Daisy Does America", "Producer" },
};
foreach (KeyValuePair <string, string> role in expectedCrewRoles)
{
PersonTVCrewMember cast = credits
.CrewRoles
.SingleOrDefault(x => x.Name == role.Key && x.Job == role.Value);
Assert.IsNotNull(cast);
}
}
public async Task FindById_GameOfThrones_ReturnsAllValuesIncludingImages()
{
var expFirstAirDate = new DateTime(2011, 04, 17);
const string expHomepage = "http://www.hbo.com/game-of-thrones";
const string expName = "Game of Thrones";
const string expOriginalLanguage = "en";
ApiQueryResponse <TVShow> response = await _api.FindByIdAsync(1399, includeImages : true);
ApiResponseUtil.AssertErrorIsNull(response);
TVShow show = response.Item;
TVShowCreator[] expCreatedBy =
{
new TVShowCreator(9813, "David Benioff", "/8CuuNIKMzMUL1NKOPv9AqEwM7og.jpg"),
new TVShowCreator(228068, "D. B. Weiss", "/caUAtilEe06OwOjoQY3B7BgpARi.jpg"),
};
CollectionAssert.AreEquivalent(expCreatedBy, show.CreatedBy.ToArray());
var expRunTime = new[] { 60 };
CollectionAssert.AreEquivalent(expRunTime, show.EpisodeRunTime.ToArray());
Assert.AreEqual(expFirstAirDate.Date, show.FirstAirDate.Date);
Genre[] expGenres =
{
GenreFactory.SciFiAndFantasy(),
GenreFactory.ActionAndAdventure(),
GenreFactory.Drama(),
};
CollectionAssert.AreEquivalent(expGenres, show.Genres.ToArray());
Assert.AreEqual(expHomepage, show.Homepage);
var expLanguages = new[] { "es", "en", "de" };
CollectionAssert.AreEquivalent(expLanguages, show.Languages.ToArray());
Assert.AreEqual(expName, show.Name);
Network[] expNetworks =
{
new Network(49, "HBO")
};
CollectionAssert.AreEquivalent(expNetworks, show.Networks.ToArray());
var expCountryCodes = new[] { "US" };
CollectionAssert.AreEquivalent(expCountryCodes, show.OriginCountry.ToArray());
Assert.AreEqual(expOriginalLanguage, show.OriginalLanguage);
ApiResponseUtil.AssertImagePath(show.BackdropPath);
ApiResponseUtil.AssertImagePath(show.PosterPath);
ProductionCompanyInfo[] expProductionCompanies =
{
new ProductionCompanyInfo(3268, "Home Box Office (HBO)"),
new ProductionCompanyInfo(5820, "Generator Entertainment"),
new ProductionCompanyInfo(12525, "Television 360"),
new ProductionCompanyInfo(12526, "Bighead Littlehead"),
new ProductionCompanyInfo(76043, "Revolution Sun Studios")
};
CollectionAssert.AreEquivalent(expProductionCompanies, show.ProductionCompanies.ToArray());
Keyword[] expKeywords =
{
new Keyword(6091, "war"),
new Keyword(818, "based on novel"),
new Keyword(4152, "kingdom"),
new Keyword(12554, "dragon"),
new Keyword(13084, "king"),
new Keyword(34038, "intrigue"),
new Keyword(170362, "fantasy world"),
};
CollectionAssert.AreEquivalent(expKeywords, show.Keywords.ToArray());
Assert.IsNotNull(show.Backdrops);
Assert.IsNotNull(show.Posters);
Assert.AreNotEqual(0, show.Backdrops.Count);
Assert.AreNotEqual(0, show.Posters);
var backdrop = show.Backdrops[0];
Assert.AreNotEqual(0, backdrop.AspectRatio);
ApiResponseUtil.AssertImagePath(backdrop.FilePath);
Assert.AreNotEqual(0, backdrop.Height);
Assert.AreNotEqual(0, backdrop.Width);
}
public async Task FindByIdAsync_StarWarsTheForceAwakens_Returns_AllValues()
{
const int id = 140607;
const string expectedImdbId = "tt2488496";
const string expectedTitle = "Star Wars: The Force Awakens";
const string expectedOriginalTitle = "Star Wars: The Force Awakens";
const string expectedTagline = "Every generation has a story.";
const string expetedOverview = "Thirty years after defeating the Galactic Empire"; // truncated
const string expectedOriginalLanguage = "en";
const string expectedHomepage = "http://www.starwars.com/films/star-wars-episode-vii";
const string expectedStatus = "Released";
const int expectedBudget = 200000000;
const int expectedRuntime = 136;
var expectedReleaseDate = new DateTime(2015, 12, 15);
ApiQueryResponse <Movie> response = await _api.FindByIdAsync(id);
ApiResponseUtil.AssertErrorIsNull(response);
Movie movie = response.Item;
Assert.AreEqual(id, movie.Id);
Assert.AreEqual(expectedImdbId, movie.ImdbId);
Assert.AreEqual(expectedTitle, movie.Title);
Assert.AreEqual(expectedOriginalTitle, movie.OriginalTitle);
Assert.AreEqual(expectedTagline, movie.Tagline);
Assert.AreEqual(expectedOriginalLanguage, movie.OriginalLanguage);
Assert.AreEqual(expectedHomepage, movie.Homepage);
Assert.AreEqual(expectedStatus, movie.Status);
Assert.AreEqual(expectedBudget, movie.Budget);
Assert.AreEqual(expectedRuntime, movie.Runtime);
Assert.AreEqual(expectedReleaseDate, movie.ReleaseDate);
ApiResponseUtil.AssertImagePath(movie.BackdropPath);
ApiResponseUtil.AssertImagePath(movie.PosterPath);
Assert.IsTrue(movie.Overview.StartsWith(expetedOverview));
Assert.IsTrue(movie.Popularity > 7, $"Actual: {movie.Popularity}");
Assert.IsTrue(movie.VoteAverage > 5);
Assert.IsTrue(movie.VoteCount > 1500);
// Spoken Languages
var languages = new[]
{
new Language("en", "English"),
};
CollectionAssert.AreEqual(languages, movie.SpokenLanguages.ToArray());
// Production Companies
var companies = new[]
{
new ProductionCompanyInfo(1, "Lucasfilm"),
new ProductionCompanyInfo(1634, "Truenorth Productions"),
new ProductionCompanyInfo(11461, "Bad Robot"),
};
CollectionAssert.AreEquivalent(companies, movie.ProductionCompanies.ToArray());
// Production Countries
var countries = new[]
{
new Country("US", "United States of America"),
};
CollectionAssert.AreEqual(countries, movie.ProductionCountries.ToArray());
// Movie Collection
Assert.IsNotNull(movie.MovieCollectionInfo);
Assert.AreEqual(10, movie.MovieCollectionInfo.Id);
Assert.AreEqual("Star Wars Collection", movie.MovieCollectionInfo.Name);
ApiResponseUtil.AssertImagePath(movie.MovieCollectionInfo.BackdropPath);
ApiResponseUtil.AssertImagePath(movie.MovieCollectionInfo.PosterPath);
// Genres
var expectedGenres = new List <Genre>
{
GenreFactory.Action(),
GenreFactory.Adventure(),
GenreFactory.ScienceFiction(),
GenreFactory.Fantasy(),
};
CollectionAssert.AreEquivalent(expectedGenres, movie.Genres.ToList());
// Keywords
var expectedKeywords = new List <Keyword>
{
new Keyword(803, "android"),
new Keyword(9831, "spaceship"),
new Keyword(10527, "jedi"),
new Keyword(161176, "space opera"),
new Keyword(209714, "3d"),
new Keyword(229031, "shot on imax cameras"),
};
CollectionAssert.AreEquivalent(expectedKeywords, movie.Keywords.ToList());
}
private async Task LoadMovies(ApiSearchResponse <MovieInfo> responseMovieInfos)
{
this._movies = new List <Movie>();
var movieApi = MovieDbFactory.Create <IApiMovieRequest>().Value;
int runtime = 0;
if (responseMovieInfos != null && responseMovieInfos.Results != null && responseMovieInfos.Results.Count != 0)
{
foreach (MovieInfo info in responseMovieInfos.Results)
{
// Get movie id
int movieId = info.Id;
// Get Movie object - to get runtime
ApiQueryResponse <DM.MovieApi.MovieDb.Movies.Movie> responseMovies = await movieApi.FindByIdAsync(movieId);
DM.MovieApi.MovieDb.Movies.Movie movie = responseMovies.Item;
if (movie != null)
{
runtime = movie.Runtime;
}
// Get MovieCredit object - to get list of actors
ApiQueryResponse <MovieCredit> responseCredits = await movieApi.GetCreditsAsync(movieId);
MovieCredit credit = responseCredits.Item;
string actors = "";
// Take first 3 actors
if (credit != null && credit.CastMembers != null && credit.CastMembers.Count != 0)
{
int actorsListSize = credit.CastMembers.Count > 3 ? 3 : credit.CastMembers.Count;
for (int i = 0; i < actorsListSize; i++)
{
actors += credit.CastMembers[i].Name;
if (i != actorsListSize - 1)
{
actors += ", ";
}
}
}
// Put genre to list
string genres = "";
for (int i = 0; i < info.Genres.Count; i++)
{
genres += info.Genres[i].Name;
if (i != info.Genres.Count - 1)
{
genres += ", ";
}
}
string title = info.Title == null ? "" : info.Title;
string year = info.ReleaseDate.Year.ToString() == null ? "" : info.ReleaseDate.Year.ToString();
string overview = info.Overview == null ? "" : info.Overview;
string posterPath = info.PosterPath;
this.AddMovie(title, year, overview, posterPath, actors, genres, runtime);
}
}
}
public async void AddFilm(UITextField titleField)
{
ApiSearchResponse <MovieInfo> response = await movieApi.SearchByTitleAsync(titleField.Text);
foreach (MovieInfo info in response.Results)
{
ApiQueryResponse <MovieCredit> responeCast = await movieApi.GetCreditsAsync(info.Id);
ApiQueryResponse <Movie> responeGenre = await movieApi.FindByIdAsync(info.Id);
var movie = responeGenre.Item;
var movieGenres = responeGenre.Item;
var genresList = movieGenres.Genres;
var movieCredit = responeCast.Item;
var castList = movieCredit.CastMembers;
var local = imageDownloader.LocalPathForFilename(info.PosterPath);
if (local.Length <= 0)
{
//catch empty local path
}
else
{
await
imageDownloader.DownloadImage(info.PosterPath, imageDownloader.LocalPathForFilename(info.PosterPath),
CancellationToken.None);
}
if (castList.Count < 3)
{
this._moviesmodel.Add(new MoviesModel(info.Title, "(" + info.ReleaseDate.Year.ToString() + ")",
string.Empty, imageDownloader.LocalPathForFilename(info.PosterPath), string.Empty, info.Overview));
}
else
{
imageDownloader.LocalPathForFilename(info.PosterPath);
if (genresList.Count < 1)
{
this._moviesmodel.Add(new MoviesModel(info.Title, "(" + info.ReleaseDate.Year.ToString() + ")",
castList[0].Name + ", " + castList[1].Name + ", " + castList[2].Name, imageDownloader.LocalPathForFilename(info.PosterPath),
movie.Runtime.ToString() + " min", info.Overview));
}
else if (genresList.Count >= 1 && genresList.Count < 2)
{
this._moviesmodel.Add(new MoviesModel(info.Title, "(" + info.ReleaseDate.Year.ToString() + ")",
castList[0].Name + ", " + castList[1].Name + ", " + castList[2].Name, imageDownloader.LocalPathForFilename(info.PosterPath),
movie.Runtime.ToString() + " min" + " I " + genresList[0].Name, info.Overview));
}
else if (genresList.Count >= 2 && genresList.Count < 3)
{
this._moviesmodel.Add(new MoviesModel(info.Title, "(" + info.ReleaseDate.Year.ToString() + ")",
castList[0].Name + ", " + castList[1].Name + ", " + castList[2].Name, imageDownloader.LocalPathForFilename(info.PosterPath),
movie.Runtime.ToString() + " min" + " I " + genresList[0].Name + ", " + genresList[1].Name, info.Overview));
}
else
{
this._moviesmodel.Add(new MoviesModel(info.Title, "(" + info.ReleaseDate.Year.ToString() + ")",
castList[0].Name + ", " + castList[1].Name + ", " + castList[2].Name, imageDownloader.LocalPathForFilename(info.PosterPath),
movie.Runtime.ToString() + " min" + " I " + genresList[0].Name + ", " + genresList[1].Name + ", " + genresList[2].Name, info.Overview));
}
}
}
navigateButton.Enabled = true;
spinner.StopAnimating();
this.NavigationController.PushViewController(new MovieListController(this._moviesmodel), true);
}
private async void AddTopRated()
{
ApiSearchResponse <MovieInfo> responeTopRated = await movieApi.GetTopRatedAsync();
var topRated = responeTopRated.Results;
for (int i = 0; i < topRated.Count; i++)
{
ApiQueryResponse <MovieCredit> responeTopRatedCast = await movieApi.GetCreditsAsync(topRated[i].Id);
ApiQueryResponse <Movie> responeTopRatedGenre = await movieApi.FindByIdAsync(topRated[i].Id);
var topRatedGenres = responeTopRatedGenre.Item;
var topRatedGenresList = topRatedGenres.Genres;
var topRatedCast = responeTopRatedCast.Item;
var topRatedCastList = topRatedCast.CastMembers;
var localTop = imageDownloader.LocalPathForFilename(topRated[i].PosterPath);
if (localTop.Length <= 0)
{
//catch empty local path
}
else
{
await
imageDownloader.DownloadImage(topRated[i].PosterPath, imageDownloader.LocalPathForFilename(topRated[i].PosterPath),
CancellationToken.None);
}
if (topRatedCastList.Count < 3)
{
this.moviesObjects.AddToMoviesModelList(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
string.Empty, imageDownloader.LocalPathForFilename(topRated[i].PosterPath),
topRatedGenres.Runtime + " min", topRated[i].Overview));
}
else
{
if (topRatedGenresList.Count < 1)
{
this.moviesObjects.AddToMoviesModelList(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
topRatedCastList[0].Name + ", " + topRatedCastList[1].Name + ", " + topRatedCastList[2].Name, imageDownloader.LocalPathForFilename(topRated[i].PosterPath),
topRatedGenres.Runtime + " min", topRated[i].Overview));
}
else if (topRatedGenresList.Count == 1)
{
this.moviesObjects.AddToMoviesModelList(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
topRatedCastList[0].Name + ", " + topRatedCastList[1].Name + ", " + topRatedCastList[2].Name, imageDownloader.LocalPathForFilename(topRated[i].PosterPath),
topRatedGenres.Runtime + " min" + " I " + topRatedGenresList[0].Name, topRated[i].Overview));
}
else if (topRatedGenresList.Count == 2)
{
this.moviesObjects.AddToMoviesModelList(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
topRatedCastList[0].Name + ", " + topRatedCastList[1].Name + ", " + topRatedCastList[2].Name, imageDownloader.LocalPathForFilename(topRated[i].PosterPath),
topRatedGenres.Runtime + " min" + " I " + topRatedGenresList[0].Name + ", " + topRatedGenresList[1].Name, topRated[i].Overview));
}
else
{
this.moviesObjects.AddToMoviesModelList(new MoviesModel(topRated[i].Title, "(" + topRated[i].ReleaseDate.Year.ToString() + ")",
topRatedCastList[0].Name + ", " + topRatedCastList[1].Name + ", " + topRatedCastList[2].Name, imageDownloader.LocalPathForFilename(topRated[i].PosterPath),
topRatedGenres.Runtime + " min" + " I " + topRatedGenresList[0].Name + ", " + topRatedGenresList[1].Name + ", " + topRatedGenresList[2].Name, topRated[i].Overview));
}
}
}
}
