public async Task <IActionResult> Details(int movieScheduleId)
{
var model = new MovieDetailsModel
{
Movie = _movieScheduleRepository.Find(movieScheduleId)
};
var imdbData = await _imdbService.GetMovie(model.Movie.Movie.ImdbId);
if (!string.IsNullOrEmpty(imdbData.Error))
{
return(RedirectToAction("Error", "Public"));
}
model.Rate = float.Parse(imdbData.ImdbRating);
model.Categories = imdbData.Genre.Split(',');
model.Duration = TimeSpan.FromMinutes(int.Parse(imdbData.RunTime.Replace("min", string.Empty).Trim()));
model.ImageSource = imdbData.Poster;
model.Reviews = model.Movie.Movie.Reviews.OrderByDescending(mr => mr.CreatedAt).ToArray();
var searcher = new VideoSearch();
var video = searcher.SearchQuery(model.Movie.Movie.Name, 1).FirstOrDefault();
if (video != null)
{
model.Trailer = TransformUrlToEmbed(video.Url);
}
return(View(model));
}
public MovieDetailsModel GetMovieDetails(int id)
{
//Include("TitleGenres").Include("Genres")
var t = db.Titles.Include("Storylines").Include("TitleGenres.Genre").Include("TitleParticipants.Participant").Where(f => f.TitleId == id).FirstOrDefault();
MovieDetailsModel m = new MovieDetailsModel();
m.TitleId = t.TitleId;
m.TitleName = t.TitleName;
m.ReleaseYear = t.ReleaseYear;
m.Storylines = new List <StorylineModel>();
t.StoryLines.ToList().ForEach(sl => m.Storylines.Add(new StorylineModel {
slid = sl.Id, StoryType = sl.Type
}));
m.Genres = new List <MovieGenre>();
t.TitleGenres.ToList().ForEach(tg => m.Genres.Add(new MovieGenre {
id = tg.Genre.Id, Name = tg.Genre.Name
}));
m.Actors = new List <ActorModel>();
t.TitleParticipants.Where(f => f.RoleType == "Actor").ToList().ForEach(tp => m.Actors.Add(new ActorModel {
Name = tp.Participant.Name, RoleType = tp.RoleType
}));
m.Participants = new List <ParticipantModel>();
t.TitleParticipants.Where(f => f.RoleType != "Actor").ToList().ForEach(tp => m.Participants.Add(new ParticipantModel {
Name = tp.Participant.Name, RoleType = tp.RoleType
}));
m.Actors = m.Actors.OrderBy(s => s.Name).ToList();
m.Participants = m.Participants.OrderBy(s => s.Name).ToList();
return(m);
}
public async Task <IActionResult> Details(string imdbId)
{
if (imdbId == null)
{
return(RedirectToAction("Search", "Movie"));
}
MovieDetailsModel movie = _context
.MovieDetailsModels
.Where(movie => movie.imdbID == imdbId)
.Include(movie => movie.Ratings)
.FirstOrDefault();
if (movie == null)
{
string response = await _client.QueryByImdbIdAsync(imdbId);
movie = JsonSerializer.Deserialize <MovieDetailsModel>(response);
if (movie.Response == "False")
{
return(RedirectToAction("MovieNotFound", "Movie"));
}
await _context.AddAsync(movie);
await _context.SaveChangesAsync();
}
return(View(movie));
}
/// <summary>
/// Writes a Json file to the local storage.
/// </summary>
/// <param name="movieDetails"></param>
/// <param name="fileName"></param>
/// <returns></returns>
public async Task SaveFavoritesFile(MovieDetailsModel movieDetails, string fileName)
{
IFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
var fileString = JsonConvert.SerializeObject(movieDetails);
await file.WriteAllTextAsync(fileString);
}
public IActionResult Details(int id)
{
Movie movie = MovieService.GetMovieDetails(id);
MovieDetailsModel model = ModelConverter.DetailsModelConvert(movie);
model.SideBarData = MovieService.GetSideBarData();
if (User.Identity.IsAuthenticated)
{
MovieLikeModel movieLike = model.MovieLikes.FirstOrDefault(x => x.UserId == Convert.ToInt32(User.FindFirst("Id").Value));
if (movieLike != null)
{
if (movieLike.Status)
{
model.MovieStatus = MovieLikeStatus.Liked;
}
else
{
model.MovieStatus = MovieLikeStatus.Disliked;
}
}
}
return(View(model));
}
public async Task <IActionResult> Details(int id)
{
var movie = await _movieService.GetMovieById(id);
var userClaim = HttpContext.User.Claims.
FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
bool purchased = false;
bool favorited = false;
if (userClaim != null && !string.IsNullOrWhiteSpace(userClaim.Value))
{
purchased = await _userService.CheckPurchase(Int32.Parse(userClaim.Value), id);
favorited = await _userService.CheckFavorite(Int32.Parse(userClaim.Value), id);
}
var checkedMovie = new MovieDetailsModel
{
Movie = movie,
PurchaseFlag = purchased,
FavoriteFlag = favorited
};
return(View(checkedMovie));
}
public IActionResult Details(int id)
{
using (this.db)
{
var movie = db.Movies.Include(m => m.Director).FirstOrDefault(m => m.Id == id);
if (movie == null)
{
return(this.RedirectToPage("Message", new { msgId = 3 }));
}
string status = db.Statuses.Find(movie.StatusId).Name;
var movieDetails = new MovieDetailsModel()
{
Id = movie.Id,
Title = movie.Title,
DirectorName = movie.Director.Name,
Description = movie.Description,
CoverImageUrl = movie.CoverImageUrl,
Status = status
};
return(this.View(movieDetails));
}
}
public ActionResult MovieDetails(int id)
{
var movieInDb = this.db.Movies.Find(id);
MovieDetailsModel movieModel = new MovieDetailsModel(movieInDb);
return(View(movieModel));
}
public async Task <IActionResult> Favorite(FavoriteRequestModel favoriteRequestModel)
{
var movie = await _movieService.GetMovieById(favoriteRequestModel.MovieId);
favoriteRequestModel.UserId = Convert.ToInt32(HttpContext.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value);
//var checkfavorited = await _userService.CheckFavorited(favoriteRequestModel);
var movieDetails = new MovieDetailsModel();
movieDetails.Movie = movie;
movieDetails.UserId = favoriteRequestModel.UserId;
//if hasn't purchased
//if (checkfavorited == false)
//{
await _userService.LikeMovie(favoriteRequestModel.UserId, favoriteRequestModel.MovieId);
// movieDetails.CheckFavorited = !checkfavorited;
// return View("Views/Movies/Details.cshtml", movieDetails);
//}//if has purchased
//else
//{
// movieDetails.CheckFavorited = !checkfavorited;
// //之后改!!!!!!!!!!!!!!!!!
//return LocalRedirect($"/Movies/Details/{movie.Id}");
//return View("Views/Movies/Details.cshtml", movieDetails);
return(RedirectToAction("Details", "Movies", new { movieid = movieDetails.Movie.Id }));
//}
}
public static Movie ToModel(this MovieDetailsModel movie)
{
return(new Movie()
{
Title = movie.Title,
Description = movie.Description,
ImageURL = movie.ImageURL,
Duration = movie.Duration,
Views = movie.Views
});
}
/// <summary>
/// Check to see if there is a favorited movie saved.
/// </summary>
/// <returns></returns>
private async Task CheckIfMovieIsFavorite()
{
var fileName = movieId.ToString();
MovieDetailsModel returedFile = await _iDataManager.OpenFavoritesFile(fileName);
if (returedFile != null)
{
Movie = returedFile;
await UpdateFavoriteButton();
}
}
/// <summary>
/// Search for favorited movies and gets movie details.
/// </summary>
/// <returns></returns>
private async Task GetFavoritedMovieListAsync()
{
IList <IFile> listOfFileNames = await _iDataManager.GetListOfFiles();
foreach (var item in listOfFileNames)
{
var fileName = item.Name;
MovieDetailsModel movieDetail = await _iDataManager.OpenFavoritesFile(fileName);
var favoriteMovie = await _iMovieExplorerAPIService.GetMovieByIdAsync(movieDetail.id);
FavoriteList.Add(favoriteMovie);
}
}
// GET: Movie/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(RedirectToAction("Index", "Error"));
}
Movie movie = db.Movies.Find(id);
if (movie == null)
{
return(RedirectToAction("Index", "Error", new { message = "Movie not found!" }));
}
MovieDetailsModel detailsModel = new MovieDetailsModel();
detailsModel.movie = movie;
detailsModel.movieReviews = db.Ratings.Where(review => review.MovieID == movie.ID).ToList();
return(View(detailsModel));
}
//[Route("Movies/Details/{movieId}")]
public async Task <IActionResult> Details(int movieId)
{
//var purchaseRequestModel = new PurchaseRequestModel();
//var favoriteRequestModel = new FavoriteRequestModel();
var movieDetails = new MovieDetailsModel();
if (User.Identity.IsAuthenticated)
{
var userId = Convert.ToInt32(HttpContext.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value);
movieDetails.UserId = userId;
movieDetails.MovieId = movieId;
movieDetails.CheckPurchased = await _userService.CheckPurchased(userId, movieId);
movieDetails.CheckFavorited = await _userService.CheckFavorited(userId, movieId);
movieDetails.CheckReviewed = await _userService.CheckReviewed(userId, movieId);
}
var movie = await _movieService.GetMovieById(movieId);
movieDetails.Movie = movie;
return(View(movieDetails));
}
/// <summary>
/// Reads a file from local storage.
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public async Task <MovieDetailsModel> OpenFavoritesFile(string fileName)
{
MovieDetailsModel movieDetails = new MovieDetailsModel();
if ((await folder.CheckExistsAsync(fileName)) == ExistenceCheckResult.NotFound)
{
return(null);
}
else
{
IFile file = await folder.GetFileAsync(fileName);
var jsonFile = await file.ReadAllTextAsync();
if (!string.IsNullOrEmpty(jsonFile))
{
movieDetails = JsonConvert.DeserializeObject <MovieDetailsModel>(jsonFile);
return(movieDetails);
}
return(null);
}
}
// GET: Movies/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var review = from m in _context.Review
select m;
review = review.Where(x => x.MovieID == id);
var movie = await _context.Movie
.SingleOrDefaultAsync(m => m.ID == id);
var movieDetails = new MovieDetailsModel();
movieDetails.reviews = await review.ToListAsync();
movieDetails.movie = movie;
return(View(movieDetails));
}
public ActionResult ViewPartial(int id)
{
MovieDetailsModel m = th.GetMovieDetails(id);
return(PartialView("_MovieDetailsPartial", m));
}
public ActionResult View(int id)
{
MovieDetailsModel m = th.GetMovieDetails(id);
return(View(m));
}
