public async Task <IActionResult> Review(ReviewViewModel reviewViewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
// create an ImageForUpdate instance
var movieReview = new MovieReview()
{
Text = reviewViewModel.ReviewText
};
// serialize it
var serializedreviewForUpdate = JsonConvert.SerializeObject(movieReview);
var httpClient = _httpClientFactory.CreateClient("APIClient");
var request = new HttpRequestMessage(
HttpMethod.Put,
$"/api/movies/{reviewViewModel.Id}");
request.Content = new StringContent(
serializedreviewForUpdate,
System.Text.Encoding.Unicode,
"application/json");
var response = await httpClient.SendAsync(
request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
return(RedirectToAction("Index"));
}
public int Post([FromBody] MovieReview review)
{
review.MovieId = Guid.NewGuid().ToString();
movieReviewsRepository.Add(review);
return(Response.StatusCode = (int)HttpStatusCode.Created);
}
public ActionResult Create([Bind(Include = "MovieReviewID,Rating,Review")] MovieReview movieReview, Int32 SelectedMovie)
{
if ((SelectedMovie != 0))
{
Movie m = db.Movies.Find(SelectedMovie);
movieReview.Movie = m;
String UserID = User.Identity.GetUserId();
AppUser user = db.Users.Find(UserID);
movieReview.User = user;
movieReview.Status = ReviewStatus.Pending;
if (ModelState.IsValid)
{
db.MovieReviews.Add(movieReview);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
ViewBag.AllMovies = GetUserMovies();
return(View(movieReview));
}
public MovieReview SaveReview(MovieReview movieReview, string reviewerEmailAddress)
{
int reviewId;
//Validate
if (IsValidEmailFormat(reviewerEmailAddress) == false)
{
throw new ArgumentException(nameof(reviewerEmailAddress), "Email Address is missing or invalid");
}
if (movieReview is null)
{
throw new ArgumentNullException(nameof(movieReview), "Review is required");
}
//Save review
// GetrReviewSaveMode- If movie review id is 0, that means new review. If not, update to existing review.
reviewId = _movieDataServices.SaveReviewtoDatabase(movieReview, reviewerEmailAddress, GetReviewSaveMode(movieReview.ReviewId));
if (reviewId > 0)
{
movieReview.MostRecentReviewerEmailAddress = reviewerEmailAddress;
movieReview.ReviewId = reviewId;
}
return(movieReview);
}
public MovieReview(MovieReview movieReview)
{
Title = movieReview.Title;
Review = movieReview.Review;
Rating = movieReview.Rating;
Attachment = movieReview.Attachment;
}
public HttpResponseMessage Put([FromBody] MovieReview review)
{
//review.Id = Id;
_uOW.MovieReviews.Update(review);
_uOW.Commit();
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
public List <MovieReview> GetAllMovieReviewByUserId(int id)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand("Select * From [dbo].[MovieReview], [dbo].[Movie] WHERE MovieReview.userId = @id AND MovieReview.movieId = Movie.id", connection);
connection.Open();
cmd.Parameters.AddWithValue("id", id);
var reader = cmd.ExecuteReader();
List <MovieReview> movieReviews = new List <MovieReview>();
while (reader.Read())
{
MovieReview mr = new MovieReview()
{
ReviewId = reader.GetInt32(0),
Thoughts = reader.GetString(1),
Score = reader.GetInt32(2),
Movie = new Movie()
{
ItemID = reader.GetInt32(3),
ItemName = reader.GetString(6),
Picture = reader.GetString(7),
Genre = reader.GetString(8),
MovieLength = reader.GetInt32(9)
}
};
movieReviews.Add(mr);
}
return(movieReviews);
};
}
public async Task <IActionResult> ApproveReview(int id, MovieReview movieReview)
{
if (id != movieReview.MovieReviewID)
{
return(View("Error", new String[] { "There was a problem editing this review. Try again!" }));
}
if (movieReview.Approved == false)
{
return(View("Error", new String[] { "You did not choose to approve this review." }));
}
try
{
MovieReview dbmovieReview = _context.MovieReviews.Find(movieReview.MovieReviewID);
dbmovieReview.Approved = movieReview.Approved;
_context.Update(dbmovieReview);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(View("Error", new String[] { "There was an error updating this review!", ex.Message }));
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Upvote(int?id)
{
MovieReview movieReview = db.MovieReviews.Find(id);
AppUser user = db.Users.Find(User.Identity.GetUserId());
if (ModelState.IsValid)
{
if (!movieReview.UsersThatUpVoted.Contains(user) && !movieReview.UsersThatDownVoted.Contains(user)) // user never voted for this
{
movieReview.Votes += 1;
movieReview.UsersThatUpVoted.Add(user);
db.Entry(movieReview).State = EntityState.Modified;
db.SaveChanges();
return(View("VoteSuccess", movieReview));
}
else if (movieReview.UsersThatUpVoted.Contains(user)) // user previously upvoted this
{
return(View("VoteFailure", movieReview));
}
else // user previously downvoted this
{
movieReview.Votes += 2; // aded 2 because undo downvote and do upvote
movieReview.UsersThatDownVoted.Remove(user);
movieReview.UsersThatUpVoted.Add(user);
db.Entry(movieReview).State = EntityState.Modified;
db.SaveChanges();
return(View("VoteSuccess", movieReview));
}
}
return(View(movieReview));
}
// GET: MovieReview/Edit/5
public IActionResult Edit(int?id)
{
if (id == null)
{
return(View("Error2", new String[] { "Could not find this movie review. Please Try Again." }));
}
MovieReview movieReview = _context.MovieReview
.Include(mr => mr.Movie)
.Include(mr => mr.User)
.FirstOrDefault(o => o.MovieReviewID == id);
if (movieReview == null)
{
return(View("Error2", new String[] { "Could not find this movie review. Please Try Again." }));
}
if (User.IsInRole("Manager") == false && User.IsInRole("Employee") == false && movieReview.User.UserName != User.Identity.Name)
{
return(View("Error", new string[] { "You are not authorized to edit this order!" }));
}
ViewBag.AllMovies = GetTicketMovies();
return(View(movieReview));
}
public IActionResult Review(int movieScheduleId, [FromQuery] string review)
{
var action = RedirectToAction("Details", new { movieScheduleId });
if (string.IsNullOrWhiteSpace(review))
{
return(action);
}
var movie = _movieScheduleRepository.Find(movieScheduleId);
if (movie == null)
{
return(action);
}
var mReview = new MovieReview
{
MovieId = movie.MovieId,
UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value,
Review = review,
CreatedAt = DateTime.Now
};
_movieReviewRepository.Add(mReview);
_movieReviewRepository.Save();
return(action);
}
public ActionResult Create(Vote vote)
{
MovieReview mr = db.MovieReviews.Find(vote.MovieReview.MovieReviewID);
vote.MovieReview = mr;
List <Vote> MovieVotes = mr.Votes;
AppUser CurrentUser = db.Users.Find(User.Identity.GetUserId());
foreach (Vote v in MovieVotes)
{
if (v.User == CurrentUser)
{
return(RedirectToAction("Edit", "Votes", new { id = v.VoteID }));
}
}
String UserID = User.Identity.GetUserId();
AppUser user = db.Users.Find(UserID);
vote.User = user;
if (ModelState.IsValid)
{
db.Votes.Add(vote);
db.SaveChanges();
return(RedirectToAction("Details", "Home", new { id = vote.MovieReview.Movie.MovieID }));
}
return(View(vote));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Review,ReviewDate")] MovieReview movieReview)
{
if (id != movieReview.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieReview);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieReviewExists(movieReview.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movieReview));
}
public async Task <IActionResult> Details(int?id)
{
IQueryable <int> movieReviewQuery = from m in _context.Movie
orderby m.ID
select m.ID;
var movie = await _context.Movie
.SingleOrDefaultAsync(m => m.ID == id);
var reviews = from m in _context.Reviews
select m;
if (id == null)
{
return(NotFound());
}
if (movie == null)
{
return(NotFound());
}
var movieReviewVM = new MovieReview();
movieReviewVM.movie = movie;
movieReviewVM.mReview = new SelectList(await movieReviewQuery.Distinct().ToListAsync());
movieReviewVM.review = await reviews.ToListAsync();
ViewData["mID"] = movie.ID;
return(View(movieReviewVM));
}
public async Task CreateMovieReviewShouldReturnFalseIfReviewAlreadyExists()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movieReview1 = new MovieReview
{
Movie = movie1,
User = user1,
Content = "content1",
Rating = 8,
Date = DateTime.Parse("27 July 2019"),
};
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieReviews.AddAsync(movieReview1);
await dbContext.SaveChangesAsync();
var movieId = movie1.Id;
var userId = user1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var input = new CreateReviewInputModel
{
Id = movieId,
Content = "content1",
Rating = 8,
};
var actualResult = await reviewService.CreateMovieReviewAsync(userId, input);
Assert.False(actualResult);
Assert.True(dbContext.MovieReviews.Count() == 1);
}
public IActionResult Post(int Id, [FromBody] MovieReview review)
{
review.MovieId = Id;
_uOW.MovieReviews.Add(review);
_uOW.Commit();
return(Ok(review));
}
public ActionResult DeleteReview(int movieId, int id, MovieReview model)
{
var review = db.MovieReviews.Find(id);
db.MovieReviews.Remove(review);
db.SaveChanges();
return(RedirectToAction("Details", "Movies", new { id = movieId }));
}
public IActionResult Create(int id, [FromBody] MovieReview review)
{
review.MovieId = id;
_repo.Add(review);
_repo.Commit();
return(CreatedAtAction(nameof(Get), new { id = review.Id }, review));
}
public ActionResult DeleteConfirmed(int id)
{
MovieReview moviereview = db.MovieReviews.Find(id);
db.MovieReviews.Remove(moviereview);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create([Bind("MovieReviewID,MovieRating,ReviewDescription,SelectedMovieID")] MovieReview movieReview, int SelectedMovieID)
{
List <Order> pastorders = _context.Orders.Include(o => o.Tickets).ThenInclude(o => o.Showing).ThenInclude(o => o.Movie).ToList();
bool check = false;
foreach (Order order in pastorders)
{
foreach (Ticket ticket in order.Tickets)
{
if (ticket.Showing.Movie.MovieID == SelectedMovieID && ticket.Showing.EndDateTime < DateTime.Now)
{
check = true;
break;
}
}
if (check == true)
{
break;
}
}
if (check == false)
{
return(View("Error", new String[] { "You have not watched this movie yet, or have not watched this movie with us; please do that first!" }));
}
List <MovieReview> userreviews;
userreviews = _context.MovieReviews.Include(mr => mr.Movie).Where(m => m.User.UserName == User.Identity.Name).ToList();
if (userreviews.Count() != 0)
{
foreach (MovieReview review in userreviews)
{
if (review.Movie.MovieID == SelectedMovieID)
{
return(View("Error", new String[] { "You have already created a review for this movie!!" }));
}
}
}
if (ModelState.IsValid == false)
{
return(View(movieReview));
}
Movie dbMovie = _context.Movies.Find(SelectedMovieID);
movieReview.Movie = dbMovie;
movieReview.Status = MRStatus.WIP;
movieReview.User = _userManager.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
_context.Add(movieReview);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "MovieReviews", new { id = movieReview.MovieReviewID }));
}
public ActionResult AddReview(int movieId)
{
MovieReview review = new MovieReview()
{
MovieId = movieId
};
return(View(review));
}
public void BuildArrange()
{
//Set up connection strings, or anything required for integ test
var _movieDataServices = new MovieDataServices();
_movieServices = new MovieServices(_movieDataServices);
_movieReview = new MovieReview();
_reviewerEmailAddress = "*****@*****.**";
}
public async Task InsertAsync(MovieReview review)
{
await Reviews.InsertWithInt32IdentityAsync(() => new MovieReview()
{
user_login = review.user_login,
review = review.review,
date = review.date,
movie_id = review.movie_id
});
}
public ActionResult Edit(MovieReview review)
{
if (ModelState.IsValid)
{
_db.Entry(review).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index", new { id = review.MovieId }));
}
return(View(review));
}
public async Task SendMessage(string message, string user_login, string movie_id)
{
using (var scope = _serviceProvider.CreateScope())
{
var unitOfWork = scope.ServiceProvider.GetRequiredService <UnitOfWork>();
var review = new MovieReview(user_login, int.Parse(movie_id), message, DateTime.Now);
await unitOfWork.MovieReviewRepository.InsertAsync(review);
await InvokeClientMethodToAllAsync("pingMessage", message, user_login, review.date);
}
}
// GET: Votes/Create
public ActionResult Create(Int32 id)
{
Vote vote = new Vote();
MovieReview mr = db.MovieReviews.Find(id);
vote.MovieReview = mr;
return(View(vote));
}
public ActionResult Edit([Bind(Include = "MovieReviewID,UserID,Review,MovieID,Posted")] MovieReview moviereview)
{
if (ModelState.IsValid)
{
db.Entry(moviereview).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserID = new SelectList(db.Users, "UserID", "UserName", moviereview.UserID);
return(View(moviereview));
}
public async Task <IActionResult> Create([Bind("Id,Name,Review,ReviewDate")] MovieReview movieReview)
{
if (ModelState.IsValid)
{
_context.Add(movieReview);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movieReview));
}
public async Task <IActionResult> AddMovieReview(int id, string user, string review)
{
MovieReview movieReview = new MovieReview();
movieReview.MovieReviewID = id;
movieReview.User = user;
movieReview.Review = review;
await _context.SaveChangesAsync();
return(RedirectToAction("Detail"));
}
public ActionResult DeleteReview(int movieId, int id, MovieReview model)
{
var review = db.MovieReviews.Find(id);
if (review.Author.UserName != User.Identity.Name)
{
return(new HttpUnauthorizedResult("Unauthorized"));
}
db.MovieReviews.Remove(review);
db.SaveChanges();
return(RedirectToAction("Details", "Movies", new { id = movieId }));
}
public ActionResult Create([Bind(Include="MovieReviewID,Rating,Review,MovieID,Posted")] MovieReview moviereview)
{
var moviereviews = new MovieReview();
TryUpdateModel(moviereviews);
if (ModelState.IsValid)
{
moviereview.UserID = User.Identity.GetUserId();
moviereview.UserName = User.Identity.GetUserName();
moviereview.Posted = DateTime.Now.Date + DateTime.Now.TimeOfDay;
db.MovieReviews.Add(moviereview);
db.SaveChanges();
return RedirectToAction("Index");
}
isAdminUser();
return View(moviereview);
}
