public IActionResult EditMovie(MovieResponse movie)
{
context.Movies.Update(movie);
context.SaveChanges();
return(RedirectToAction("Movies"));
}
public IActionResult SaveChanges(MovieResponse mr, int movieid)
{
//Identify which movie corresponds to the id passed in
var MovieToOverwrite = context.Movies.Where(mr => mr.MovieId == movieid).FirstOrDefault();
//Ensure form inputs are valid
if (ModelState.IsValid)
{
//Update the values of the movie corresponding with the movieid passed in
MovieToOverwrite.Title = mr.Title;
MovieToOverwrite.Category = mr.Category;
MovieToOverwrite.Year = mr.Year;
MovieToOverwrite.Director = mr.Director;
MovieToOverwrite.Rating = mr.Rating;
MovieToOverwrite.Edited = mr.Edited;
MovieToOverwrite.LentTo = mr.LentTo;
MovieToOverwrite.Notes = mr.Notes;
//Save changes to the DB
context.SaveChanges();
//Route to view movies page; exclude Independence Day from being displayed
return(View("ViewMovies", context.Movies.Where(m => m.Title != "Independence Day")));
}
//If model is invalid, return to same page - show validation violations
//Not sure how to repass original movie data...
return(View("EditMovie", mr));
}
public void Can_call_PostAsync_to_add_new_Movie_using_RestClientAsync()
{
var asyncClient = CreateAsyncRestClient();
var newMovie = new Movie
{
ImdbId = "tt0450259",
Title = "Blood Diamond",
Rating = 8.0m,
Director = "Edward Zwick",
ReleaseDate = new DateTime(2007, 1, 26),
TagLine = "A fisherman, a smuggler, and a syndicate of businessmen match wits over the possession of a priceless diamond.",
Genres = new List <string> {
"Adventure", "Drama", "Thriller"
},
};
MovieResponse response = null;
asyncClient.PostAsync <MovieResponse>("movies", newMovie,
r => response = r, FailOnAsyncError);
Thread.Sleep(1000);
Assert.That(response, Is.Not.Null, "No response received");
var createdMovie = response.Movie;
Assert.That(createdMovie.Id, Is.GreaterThan(0));
Assert.That(createdMovie.ImdbId, Is.EqualTo(newMovie.ImdbId));
}
public IActionResult MovieRemove(MovieResponse movie)
{
context.Movies.Remove(movie);
context.SaveChanges();
return(View("MovieList", context.Movies.Where(movie => movie.Title != "Independence Day")));
}
public async Task <MovieResponse> Search(string title)
{
var httpClient = new HttpClient();
var baseApiUrl = "http://www.omdbapi.com/";
var key = "dd0fa8bc";
var queryUri = baseApiUrl + "?s=&apiKey="; // "http://www.omdbapi.com/?s=&apiKey="
var uriBuilder = new UriBuilder(queryUri);
var queryString = HttpUtility.ParseQueryString(uriBuilder.Query);
queryString.Set("s", title); // s= => s=nameMovie
queryString.Set("apiKey", key); // apiKey= => apiKey=dd0fa8bc
uriBuilder.Query = queryString.ToString();
HttpResponseMessage httpResponse = await httpClient.GetAsync(uriBuilder.Uri);
MovieResponse response = new MovieResponse();
if (httpResponse.IsSuccessStatusCode)
{
var json = await httpResponse.Content.ReadAsStringAsync();
response = JsonConvert.DeserializeObject <MovieResponse>(json);
}
return(response);
}
public IActionResult UpdateConfirmation(MovieResponse response)
{
//Happens on post for updated response, finds the movie that matches the ID and changes each value to the values entered in the form, then loads the movie list
if (ModelState.IsValid)
{
MovieResponse movieResponse = _context.Movies.FirstOrDefault(x => x.MovieResponseId == _movieId);
movieResponse.Category = response.Category;
movieResponse.Title = response.Title;
movieResponse.Year = response.Year;
movieResponse.Director = response.Director;
movieResponse.Rating = response.Rating;
movieResponse.Edited = response.Edited;
movieResponse.LentTo = response.LentTo;
movieResponse.Notes = response.Notes;
_context.SaveChanges();
return(View("MovieList", new MovieListViewModel
{
Movies = _context.Movies
.Where(x => x.Title != "Independence Day")
}));
}
else
{
return(View("Update", response));
}
}
public Task Execute(IJobExecutionContext context)
{
try
{
int currentPage = 1;
var response = _movieService.GetMovieListPage(currentPage);
MovieResponse movieResponse = new MovieResponse();
movieResponse.total_pages = response.total_pages;
movieResponse.page = currentPage;
movieResponse.results = response.results;
for (int i = 2; i < response.total_pages; i++)
{
movieResponse.results.AddRange(_movieService.GetMovieListPage(i).results);
}
movieResponse.total_results = movieResponse.results.Count;
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
return(Task.CompletedTask);
}
public async Task <IActionResult> Edit(int id, [Bind("MovieID,Category,Title,Year,Director,Rating,Edited,LentTo,Notes")] MovieResponse movieResponse)
{
if (id != movieResponse.MovieID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieResponse);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieResponseExists(movieResponse.MovieID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movieResponse));
}
public IActionResult EditMovie(MovieResponse movieResponse)
{
if (ModelState.IsValid)
{
//update
var updateQuery = (from res in context.Responses
where res.MovieID == movieResponse.MovieID
select res).FirstOrDefault();
updateQuery.Title = movieResponse.Title;
updateQuery.Category = movieResponse.Category;
updateQuery.Year = movieResponse.Year;
updateQuery.Director = movieResponse.Director;
updateQuery.Rating = movieResponse.Rating;
updateQuery.Edited = movieResponse.Edited;
updateQuery.Lent = movieResponse.Lent;
updateQuery.Notes = movieResponse.Notes;
context.SaveChanges();
return(View("MovieList", context.Responses));
}
ViewBag.dbResponse = movieResponse;
ViewBag.error = "ERROR";
return(View());
}
public void MovieSearch_GetLastPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieResponse lastPageResponse = GetLastPageResposne(request);
Assert.AreEqual(lastPageResponse.total_pages, lastPageResponse.page);
}
public void Execute()
{
var movieResponse = new List <MovieResponse>();
var draw = new HashSet <double>();
var movies = _movieUserRepository.GetRatingByUser(this.UserId);
foreach (var movie in movies)
{
_ratingCommand.Reviews = movie.Reviews;
_ratingCommand.Execute();
var response = new MovieResponse()
{
Genre = movie.Genre,
Title = movie.Title,
RunningTime = movie.RunningTime,
YearOfRelease = movie.YearOfRelease,
AverageRating = _ratingCommand.AverageRating
};
movieResponse.Add(response);
draw.Add(movie.Reviews.FirstOrDefault() != null ? movie.Reviews.FirstOrDefault().Rating : 0);
}
if ((movieResponse.Count - draw.Count) >= 1)
{
Response = movieResponse.OrderBy(o => o.Title).Take(5).ToList();
}
else
{
Response = movieResponse.OrderByDescending(o => o.AverageRating).Take(5).ToList();
}
}
public IActionResult MovieForm(MovieResponse movieResponse)
{
//proof that the model is linking to the form, shows up in debug window
//Debug.WriteLine(movieResponse.Title + " has been added");
TempStorage.AddMovie(movieResponse);
return(View("Confirmation", movieResponse));
}
public void MovieSearch_NextPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieSearch search = new MovieSearch(request);
MovieResponse response = search.NextPage();
Assert.AreEqual(2, response.page);
}
public IActionResult DeleteMovie(MovieResponse yeet)
{
context.Movies.Remove(yeet);
context.SaveChanges();
IQueryable <MovieResponse> query = context.Movies;
return(View("MovieList", query));
}
public void MovieSearch_PreviousPageFromFirstPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieSearch search = new MovieSearch(request);
MovieResponse response = search.PreviousPage();
Assert.AreEqual(1, response.page);
}
public IActionResult Update(int movieId)
{
//Happens on update button post, finds the movie that matches the ID from the movie list and sends that object to the update page to populate the input fields there
_movieId = movieId;
MovieResponse response = _context.Movies.FirstOrDefault(x => x.MovieResponseId == _movieId);
return(View(response));
}
public void MovieSearch_NextPageFromLastPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieSearch lastPageSearch = GetLastPageSearch(request);
MovieResponse nextOnLastResponse = lastPageSearch.NextPage();
Assert.AreEqual(nextOnLastResponse.total_pages, nextOnLastResponse.page);
}
public async Task <MovieResponse> Get(string title)
{
var baseAddress = new Uri($"https://jsonmock.hackerrank.com/api/movies/");
//search /? Title ={ title}
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync(baseAddress))
{
var content = await response.Content.ReadAsStringAsync();
var objSerialize = JsonConvert.DeserializeObject <Movies>(content);
List <Movies> listMovies = new List <Movies>();
#if DEBUG
{
objSerialize.total_pages = 2;
}
#endif
//BUSCANDO FILMES EM TODAS AS PAGINAS
for (int i = 1; i <= objSerialize.total_pages; i++)
{
var movie = await Services.GetMoviesPage(title, i);
listMovies.Add(movie);
}
var listaMoviesByYearAux = new List <MoviesByYear>();
//PASSANDO PAGINA POR PAGINA
foreach (var itens in listMovies)
{
//AGRUPAMENTO POR PAGINA
foreach (var item in itens.data.GroupBy(x => x.Year).ToList())
{
listaMoviesByYearAux.Add(new MoviesByYear {
Year = item.Key, Movies = item.Count()
});
}
}
;
//RETORNO
var responseMovies = new MovieResponse();
responseMovies.MoviesByYear = listaMoviesByYearAux.GroupBy(x => x.Year)
.Select(p => new MoviesByYear
{
Year = p.Key,
Movies = p.Sum(x => x.Movies)
}).ToList();
//responseMovies.MoviesByYear = listaAgrupadaTotal;
responseMovies.Total = responseMovies.MoviesByYear.Sum(x => x.Movies);
return(responseMovies);
}
}
}
public async Task <MovieResponse> UpdateMovie(MovieResponse movie, string apiKey, string baseUrl)
{
var request = new Request($"/api/movie/", baseUrl, HttpMethod.Put);
AddHeaders(request, apiKey);
request.AddJsonBody(movie);
return(await Api.Request <MovieResponse>(request));
}
private MovieSearch GetLastPageSearch(MovieRequest request)
{
MovieSearch currentSearch = new MovieSearch(request);
MovieResponse currentResponse = currentSearch.CurrentPage();
request.Page = currentResponse.total_pages;
return(new MovieSearch(request));
}
public IActionResult SaveChange(MovieResponse mov)
{
//context.Movies.Where(t => t.MovieID == movieid).FirstOrDefault();
context.Movies.Update(mov);
context.SaveChanges();
IQueryable <MovieResponse> query = context.Movies;
return(View("MovieList", query));
}
public void Can_Serialize_MovieResponse_Dto()
{
var request = new MovieResponse {
Movie = ResetMoviesService.Top5Movies[0]
};
var csv = CsvSerializer.SerializeToString(request);
var csvRows = csv.Split('\n').Where(x => !x.IsNullOrEmpty()).ToArray();
Assert.That(csvRows.Length, Is.EqualTo(HeaderRowCount + 1));
}
public void MovieSearch_PreviousPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieSearch search = new MovieSearch(request);
search.NextPage(); //page 2
search.NextPage(); //page 3
MovieResponse response = search.PreviousPage(); //page 2
Assert.AreEqual(2, response.page);
}
public IActionResult AddMovie(MovieResponse movieResponse)
{
//access the database
if (ModelState.IsValid)
{
context.Responses.Add(movieResponse);
context.SaveChanges();
return(View("MovieList", context.Responses));
}
return(View());
}
private static MovieResponse MapToMovieResponse(IEnumerable <Movie> movies)
{
var movieResponse = new MovieResponse();
foreach (var movie in movies)
{
movieResponse.Movies.Add(MapToMovieResource(movie));
}
return(movieResponse);
}
public async Task <IActionResult> Create([Bind("MovieID,Category,Title,Year,Director,Rating,Edited,LentTo,Notes")] MovieResponse movieResponse)
{
if (ModelState.IsValid)
{
_context.Add(movieResponse);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movieResponse));
}
public IActionResult MovieForm(MovieResponse movie)
{
if (ModelState.IsValid)
{
_context.Movies.Add(movie);
_context.SaveChanges();
return(View("MovieList", _context.Movies));
}
return(View("MovieForm"));
}
public static MovieEntity MovieResponseToEntity(MovieResponse movieResponse)
{
MovieEntity movieEntity = new MovieEntity()
{
Name = movieResponse.Name,
Rating = movieResponse.Rating,
ReleaseDate = movieResponse.ReleaseDate
};
return(movieEntity);
}
public static MovieResponse MovieEntityToResponse(MovieEntity movieEntity)
{
MovieResponse movieResponse = new MovieResponse()
{
Name = movieEntity.Name,
Rating = movieEntity.Rating,
ReleaseDate = movieEntity.ReleaseDate
};
return(movieResponse);
}
public ActionResult <MovieResponse> GetMovie(int id)
{
MovieResponse movieResponse = movieServices.GetMovie(id);
if (movieResponse == null)
{
return(NotFound());
}
return(movieResponse);
}
public IEnumerable<Task> GetMovieInfo(string title, int? year, string language)
{
_manager.OutstandingOperations.Increment();
var response = new MovieResponse {title = title, language = language};
var imdbService = new ImdbAsync(title, year);
yield return imdbService.Task;
var imdbObj = imdbService.Result;
var bingService = new BingAsync(imdbObj.Plot, language);
yield return bingService.Task;
var flickrService = new FlickrAsync(title, imdbObj.Director);
yield return flickrService.Task;
var nytService = new NYTAsync(title, imdbObj.Year);
yield return nytService.Task;
var nytObj = nytService.Result;
var fillArticlesTask = nytObj.Results
.Where(a => !String.IsNullOrEmpty(a.Capsule_Review))
.TranslateFieldForAll(
(i) => i.Capsule_Review
, (i, s) => i.Capsule_Review = s
, language);
yield return fillArticlesTask;
var bingObj = bingService.Result;
var flickrObj = flickrService.Result;
response.status_code = HttpStatusCode.OK;
response.message = "OK";
response.movie = new Movie
{
title = imdbObj.Title,
year = imdbObj.Year,
director = imdbObj.Director,
synopsis =
bingObj.SearchResponse.Translation.Results.FirstOrDefault().TranslatedTerm,
poster = new Uri(imdbObj.Poster),
photos = flickrObj.Photos
.Photo
.Select(p => new Uri(
string.Format(
"http://farm{0}.static.flickr.com/{1}/{2}_{3}.jpg",
1, p.Server, p.Id, p.Secret))).ToArray(),
critics = nytObj.Results.Select(a => new Critic()
{
author = a.Seo_Name,
capsule_review = a.Capsule_Review,
reference = new Uri(a.Link.Url)
}).ToArray()
};
_manager.Parameters["movie"] = response;
_manager.OutstandingOperations.Decrement();
yield break;
}