public MovieDetailsView()
{
InitializeComponent();
_movieDetailsViewModel = new MovieDetailsViewModel();
DataContext = _movieDetailsViewModel;
}
public ViewResult Details(string Slug)
{
var movie = _context.Movies.Include(mg => mg.FilmItemGenres).ThenInclude(g => g.Genre)
.Include(mc => mc.FilmItemCredits).ThenInclude(p => p.Person)
.Include(v => v.Videos)
.Include(p => p.Photos)
.Include(t => t.Trivia)
.Include(m => m.Media)
.Include(mr => mr.UserRatings)
.Include(r => r.Reviews)
.Include(l => l.ListItems).ThenInclude(l => l.List)
.FirstOrDefault(m => m.Slug == Slug);
MovieDetailsViewModel movieDetailsViewModel = new MovieDetailsViewModel
{
Movie = movie,
Genres = movie.FilmItemGenres.Select(g => g.Genre.Name).OrderBy(g => g).ToArray(),
ReleaseYear = (movie.ReleaseDate.HasValue ? movie.ReleaseDate.Value.ToString("yyyy") : "Unknown"),
ReleaseDate = (movie.ReleaseDate.HasValue ? movie.ReleaseDate.Value.ToString("dd MMMM, yyyy") : "Unknown"),
Directors = movie.FilmItemCredits.Where(p => p.PartType == PartType.Director).OrderBy(x => x.Person.Surname).ToList(),
Producers = movie.FilmItemCredits.Where(p => p.PartType == PartType.Producer).ToList(),
Writers = movie.FilmItemCredits.Where(p => p.PartType == PartType.Writer).ToList(),
CommentCount = movie.Reviews.Count,
Lists = _context.Lists.Where(l => l.ApplicationUserId == _userManager.GetUserId(User)).ToList(),
ListCount = movie.ListItems.Select(l => l.List).ToList().Count
};
if (movie == null)
{
return(View(nameof(Index)));
}
return(View(movieDetailsViewModel));
}
public MovieDetailsViewModel GetMovieById(int id)
{
var model = new MovieDetailsViewModel();
var movieDb = DbContext.Movies
.Include(m => m.Genres).ThenInclude(mg => mg.Genre)
.Include(m => m.Actors).ThenInclude(ma => ma.Person)
.Include(m => m.Directors).ThenInclude(md => md.Person)
.Include(m => m.Producers).ThenInclude(mp => mp.Person)
.Include(m => m.ScriptWriters).ThenInclude(mw => mw.Person)
.Include(m => m.MovieVotes)
.FirstOrDefault(p => p.Id == id);
if (movieDb == null)
{
model.SetError("No such movie in database");
return(model);
}
model = Mapper.Map <MovieDetailsViewModel>(movieDb);
if (model.VotesCount == default(int))
{
model.AverageRating = default(int);
}
return(model);
}
public async Task Movie_Is_Correct_When_Returned_From_Service()
{
//Arrange
var mockMovie = new MovieDetails
{
BackdropPath = "testpath",
Genres = new string[] { "Action", "Adventure" },
Overview = "This is a test movie",
PosterPath = "testpath",
ReleaseDate = DateTime.Today,
Title = "Test Movie"
};
var navigationService = new Mock <INavigationService>();
var movieDetailsService = new Mock <IMovieDetailsService>();
movieDetailsService.Setup
(m => m.GetMovieDetails(It.IsAny <int>()))
.Returns(Task.FromResult(mockMovie));
var vm = new MovieDetailsViewModel(movieDetailsService.Object, navigationService.Object);
//Act
await vm.InitializeAsync(1);
//Assert
Assert.AreEqual(mockMovie.BackdropPath, vm.Movie.BackdropPath);
Assert.AreEqual(mockMovie.Overview, vm.Movie.Overview);
Assert.AreEqual(mockMovie.PosterPath, vm.Movie.PosterPath);
Assert.AreEqual(mockMovie.ReleaseDate, vm.Movie.ReleaseDate);
Assert.AreEqual(mockMovie.Title, vm.Movie.Title);
}
public IActionResult Details(int id)
{
var movie = movieRepository.GetMovieById(id);
if (movie == null)
{
return(NotFound());
}
bool?liked = null;
if (User.Identity.IsAuthenticated)
{
var userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
liked = movieRepository.IsLiked(movie.MovieId, userId);
}
var addMovieViewModel = new MovieDetailsViewModel
{
MovieId = movie.MovieId,
Title = movie.Title,
Description = movie.Description,
PosterPath = movie.PosterPath,
ReleaseDate = movie.ReleaseDate,
Country = movie.Country,
Liked = liked
};
return(View(addMovieViewModel));
}
public IActionResult Details(int id)
{
Movie movie = this.Context
.Movies
.Include(x => x.Director)
.FirstOrDefault(x => x.Id == id);
if (movie == default(Movie))
{
return(RedirectToPage(IndexPage));
}
MovieDetailsViewModel model = new MovieDetailsViewModel()
{
Title = movie.Title,
MovieId = movie.Id,
Description = movie.Description,
PosterImageURL = movie.PosterImage,
DirectorId = movie.DirectorId,
Director = movie.Director.Name,
Status = movie.Status,
IsBorrowed = movie.IsBorrowed
};
return(this.View(model));
}
public async Task <MovieDetailsViewModel> GetMovieById(int id)
{
ApiQueryResponse <Movie> response = await _movieDbApi.FindByIdAsync(id);
if (response.Item == null)
{
return(new MovieDetailsViewModel());
}
var movie = new MovieDetailsViewModel()
{
Id = response.Item.Id,
Title = response.Item.Title,
ReleaseDate = response.Item.ReleaseDate,
ReleaseYear = response.Item.ReleaseDate.Year,
RemoteImageUrl = response.Item.PosterPath,
LocalImageUrl = "",
Genres = new List <String>(),
Description = response.Item.Overview,
Rating = response.Item.VoteAverage,
Runtime = response.Item.Runtime,
Caption = response.Item.Tagline
};
movie.Actors = await GetCastByMovieId(movie.Id);
foreach (Genre genre in response.Item.Genres)
{
movie.Genres.Add(genre.Name);
}
return(movie);
}
// GET: Movies/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var movie = await _context.Movies
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return(NotFound());
}
var thisMovieShows = from m in _context.Shows orderby m.StartTime where m.Movie.Id == id && m.StartTime > DateTime.Now select m;
var rooms = from m in _context.Rooms select m;
var movieDvm = new MovieDetailsViewModel()
{
Film = movie,
ShowTimes = await thisMovieShows.ToListAsync(),
Rooms = await rooms.ToListAsync()
};
return(View(movieDvm));
}
public async Task <MovieDetailsViewModel> FetchMovieDetails(int id)
{
using var context = _contextFactory.CreateDbContext();
var movie = context.Movies.Include(p => p.Rates).FirstOrDefault(x => x.Id == id);
var rate = movie.Rates?.Select(x => x.Value).Average();
var httpReponse = await _client.GetAsync(movie.Address);
var content = await httpReponse.Content.ReadAsStringAsync();
var movieDetails = JsonConvert.DeserializeObject <MovieSWAPI>(content);
var details = new MovieDetailsViewModel
{
Id = id,
Created = movieDetails.Created,
Director = movieDetails.Director,
Edited = movieDetails.Edited,
Opening_crawl = movieDetails.Opening_crawl,
Producer = movieDetails.Producer,
Release_date = movieDetails.Release_date,
Title = movieDetails.Title,
Rate = rate ?? 0
};
return(details);
}
public ActionResult Details(int?id)
{
if (!id.HasValue)
{
return(RedirectToAction("Index"));
}
if (id.Value == 1)
{
var movie = new MovieDetailsViewModel()
{
Id = 1, Name = "Shrek"
};
return(View(movie));
}
if (id.Value == 2)
{
var movie = new MovieDetailsViewModel()
{
Id = 2, Name = "Wall-e"
};
return(View(movie));
}
return(HttpNotFound());
}
// GET: Movie/Details/5
public ActionResult Details(int id)
{
var post = ctx.Posts.Find(id);
var movie = ctx.Movies.Include(m => m.FilmCrewMembers).FirstOrDefault(m => m.Id == id);
var filmCrew = movie.FilmCrewMembers;
int?reviewId = null;
var userId = User.Identity.GetUserId();
if (User.Identity.GetUserId() != null)
{
var review = ctx.Reviews.FirstOrDefault(r => r.AuthorId == userId && r.MovieId == movie.Id);
if (review != null)
{
reviewId = review.Id;
}
}
var model = new MovieDetailsViewModel
{
PostId = post.Id,
Movie = movie,
Directors = filmCrew.Where(c => c.Role == MovieRole.Director).ToList(),
Actors = filmCrew.Where(c => c.Role == MovieRole.Actor).ToList(),
ReviewId = reviewId,
};
return(View(model));
}
public async Task <HttpResponseMessage> GetMovieByIdAsync(int movieId)
{
var movie = await _movieApiService.FindByIdAsync(movieId);
var movieCredits = await _movieApiService.SearchCreditsAsync(movieId);
var posterSizes = await _movieApiService.SearchAllPosterSizesAsync();
var profileSizes = await _movieApiService.SearchAllMovieProfileSizesAsync();
var backDropSizes = await _movieApiService.SearchAllBackDropSizesAsync();
if (movie.Error == null)
{
//movie.Item.PosterPath = posterSizes.Last() + movie.Item.PosterPath;
MovieDetailsViewModel movieDetailsModel = new MovieDetailsViewModel()
{
Movie = movie.Item,
MovieCredit = movieCredits.Item,
PosterSizes = posterSizes,
ProfileSizes = profileSizes,
BackDropSizes = backDropSizes
};
return(Request.CreateResponse(HttpStatusCode.OK, movieDetailsModel));
}
else
{
var message = string.Format("Error {0}: {1}", movie.Error.StatusCode, movie.Error.Message);
return(new HttpResponseMessage()
{
Content = new StringContent(message)
});
}
}
public MovieDetailPage(MovieDto movie)
{
InitializeComponent();
BindingContext = model = new MovieDetailsViewModel {
Movie = movie
};
}
public async Task <IActionResult> MovieDetails(int id)
{
var movie = await db.Movies.Include(f => f.MovieGenres).ThenInclude(f => f.Genre).FirstOrDefaultAsync(p => p.Id == id);
if (movie != null)
{
var result = new MovieDetailsViewModel
{
Id = movie.Id,
Name = movie.Name,
RealeaseDate = movie.ReleaseDate,
MovieGenres = movie.MovieGenres.Select(f => f.Genre.Name).ToList(),
Actors = movie.Actors,
Country = movie.Country,
Director = movie.Director,
Image = movie.Image,
Price = movie.Price,
Summary = movie.Summary
};
ViewData["Title"] = result.Name;
var userName = this.HttpContext.User.Identity.Name;
ViewBag.ReservationsCount = await this.db.Reservations.Where(f => f.User.Email == userName).SumAsync(f => f.Amount);
return(View(result));
}
return(NotFound());
}
// GET: Movies/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var movie = await _context.Movies
.FirstOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return(NotFound());
}
var mID = movie.GenreID;
var genre = await _context.Genres
.FirstOrDefaultAsync(g => g.ID == mID);
MovieDetailsViewModel mDetailsModel = new MovieDetailsViewModel();
mDetailsModel.Movie = movie;
mDetailsModel.Genre = genre;
return(View(mDetailsModel));
/*
* Im still pretty unsure about what exactly the '=>' operator means but it may be similar function to 'this'
*
* Here is an example i saw on the internet...
*
* var departments = _context.Departments.Include(d => d.Courses);
*
* the Include() function is used when you are pulling together related data (creates a join query).
* Notice that it is used and within its params it looks like that statement is basically declaring a
* variable to represent the 'Departments' then specifying what 'thing' in departments you want.
*
* Just some thoughts
*/
// 3/20/18 10:21pm today is monumental. I just realized I can access the ID property from the frickin obj i pulled from my db. Astounding it took me practically 2 weeks
// 3/20/18 10:27pm HOW THE F**K DO I RETURN 2 FICKIN MODELSSSSSSSSSSSSSS i knew this would happen to me. Taking a quick break to calm down
// you bastard im hot on your trail. I found some answers online and I will use them! First up to bat... View Model
// Im doing this because the article i read said that View models are "Strongly Typed" which i think is a good rule of thumb (If i remember that correctly)
// I assume its a good idea to go with something strongly typed because it leaves less room for error. It only takes what is defined in its class so everything that
// it does is expected. At least that is the logic I will go with. What do you think person reading this? Also im def commiting this before I mess everything up. Not that Im
// very far :Shrug:
// 3/20/19 11:30pm
// Im back, and as you can obviously tell, i won. View model = Great success
// I honestly got so excited I ran around my house 2 times and im still #pumped.
// I guess the next logical step is to update the index page to look lit afffff. Then we can do whatever else idc.
// Id like to thank my mother, and my father, and microsoft, and of course my cat.
}
/// <inheritdoc />
/// <summary>
/// Initializes a new instance of the <see cref="T:MovieLibraryApp.Views.MovieDetailsPage" /> class.
/// </summary>
public MovieDetailsPage()
{
InitializeComponent();
NavigationCacheMode = NavigationCacheMode.Enabled;
_mdvm = new MovieDetailsViewModel();
_serializationService = SerializationService.Json;
}
// GET: Movies/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var view = new MovieDetailsViewModel
{
Movie = await _context.Movie
.FirstOrDefaultAsync(m => m.MovieID == id),
Screenings = await _context.Screening
.Include(m => m.Movie)
.Include(m => m.Salon)
.Include(m => m.Tickets)
.Where(m => m.MovieID == id)
.ToListAsync()
};
if (view.Movie == null)
{
return(NotFound());
}
return(View(view));
}
public IActionResult SaveUpdate(MovieDetailsViewModel movieUpdate)
{
if (ModelState.IsValid)
{
_movieRepository.Update(movieUpdate.MovieMovie);
}
return(RedirectToAction("Movie", "Movie"));
}
public MovieDetailsPage(Result movie)
{
InitializeComponent();
BindingContext = new MovieDetailsViewModel(Navigation, movie);
ViewModel.MovieDetailsCommand.Execute(null);
}
public IActionResult EditMovie(int id)
{
MovieDetailsViewModel moviDetailsVM = GetAll();
moviDetailsVM.MovieMovie = GetAllMovieDetailsJoined().Where(m => m.MovieMovie.MovieId == id).SingleOrDefault().MovieMovie;
return(View(moviDetailsVM));
}
private async void ShowMovieDetails(int position)
{
MovieDetailsViewModel movie = await _movieService.GetMovieById(_movies[position].Id);
var intent = new Intent(this, typeof(MovieDetailActivity));
intent.PutExtra("movieDetails", JsonConvert.SerializeObject(movie));
this.StartActivity(intent);
}
private async void GetAdditionalMovieDetails()
{
var localImagePath = this._movie.LocalImageUrl;
this._movie = await _movieService.GetMovieById(this._movie.Id);
this._movie.LocalImageUrl = localImagePath;
this.ViewDidLoad();
}
public ActionResult Details(int id)
{
var model = new MovieDetailsViewModel
{
MovieDetails = _context.Movies.Include(m => m.Genre).Where(m => m.Id == id).Select(m => m).FirstOrDefault()
};
return(View(model));
}
public ActionResult MovieDetails(Guid movieId)
{
var model = new MovieDetailsViewModel
{
Movie = _moviefileService.GetSingleMovie(movieId),
Actors = _moviefileService.GetActorCollection(movieId)
};
return(View("../Movie/MovieDetails", model));
}
public IActionResult Delete(int?Id)
{
MovieDetailsViewModel movieDetailsViewModel = new MovieDetailsViewModel()
{
Movie = _movieRepository.Delete(Id ?? 1),
PageTitle = "Employee Details"
};
return(RedirectToAction("Index", movieDetailsViewModel));
}
public ViewResult Details(int?id)
{
MovieDetailsViewModel movieDetailsViewModel = new MovieDetailsViewModel()
{
Movie = _movieRepository.GetMovie(id ?? 1),
PageTitle = _movieRepository.GetMovie(id ?? 1).Name
};
return(View(movieDetailsViewModel));
}
public async Task <MovieDetailsViewModel> GetSummarySingleMovie(string imdbId)
{
var ratings = await GetMovieRatings(imdbId);
var movie = await GetMovieDetails(imdbId);
MovieDetailsViewModel movieSummaryViewModel = new MovieDetailsViewModel(movie, ratings);
return(movieSummaryViewModel);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (!string.IsNullOrEmpty(App.movieId))
{
var movieId = App.movieId;
MovieDetailsViewModel vm = new MovieDetailsViewModel(movieId);
this.DataContext = vm;
}
}
public MovieDetailPage(Movie movie)
{
if (movie == null)
{
throw new ArgumentNullException();
}
_movie = movie;
InitializeComponent();
BindingContext = new MovieDetailsViewModel(new PageService());
}
public void CallGetMovie_OnActivation()
{
// Arrange
_target = new MovieDetailsViewModel(1, _schedulerService, _viewStackService.Object, _moviesService.Object);
// Act
_target.Activator.Activate();
// Assert
_moviesService.Verify(x => x.GetMovie(1), Times.Once);
}
