public Review Create(EditReviewViewModel editVm)
{
Review review = null;
if (editVm.GetType() == typeof(EditRestaurantReviewViewModel))
{
review = new RestaurantReview
{
Body = editVm.Body,
Rating = editVm.Rating,
ReviewerName = editVm.ReviewerName,
RestaurantId = editVm.HorecaId
};
}
else if (editVm.GetType() == typeof(EditCafeReviewViewModel))
{
review = new CafeReview
{
Body = editVm.Body,
Rating = editVm.Rating,
ReviewerName = editVm.ReviewerName,
CafeId = editVm.HorecaId
};
}
return(review);
}
private bool IsUserAuthorizedToEdit(EditReviewViewModel reviewViewModel)
{
bool isAdmin = this.User.IsInRole("Admin");
bool isAuthor = reviewViewModel.IsAuthor();
return(isAdmin || isAuthor);
}
public void UpdateReviewByReviewId(Guid reviewId, EditReviewViewModel review)
{
try
{
var result = FilmHausDbContext.Reviews.Find(reviewId);
if (result == null)
{
throw new ArgumentNullException();
}
result.Body = review.Body;
if (!result.Flagged)
{
result.Shared = review.Shared;
}
FilmHausDbContext.Entry(result).State = EntityState.Modified;
FilmHausDbContext.SaveChanges();
}
catch (InvalidOperationException ex)
{
throw ex;
}
}
public void UpdateReview(EditReviewViewModel rvm)
{
var config = new MapperConfiguration(cfg => { cfg.CreateMap <EditReviewViewModel, Reviews>(); cfg.IgnoreUnmapped(); });
IMapper mapper = config.CreateMapper();
Reviews rev = mapper.Map <EditReviewViewModel, Reviews>(rvm);
revr.UpdateReview(rev);
}
public ActionResult Edit(EditReviewViewModel model, int reviewId)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
this.reviewService.EditReview(model);
return(this.RedirectToAction("Details", "Item", new { @itemId = model.ItemId }));
}
public void EditReview(EditReviewViewModel model)
{
using (var context = new HardwareShopContext())
{
var review = this.GetReviewById(model.ReviewId, context);
review.Content = model.Content;
review.Score = model.Score;
context.SaveChanges();
}
}
public void ToString_OnCall_ReturnsCorrectFormat()
{
var viewModel = new EditReviewViewModel
{
Comment = "Some Comment",
Rating = 5.5,
ReviewerName = "Some Name",
ReviewPublicId = Guid.Empty
};
Approvals.Verify(viewModel);
}
public ActionResult Edit([Bind(Exclude = "ReviewerName")] EditReviewViewModel review)
{
if (ModelState.IsValid)
{
var editable_review = _db.Reviews.Find(review.Id);
editable_review.Body = review.Body;
editable_review.Rating = review.Rating;
_db.Entry(editable_review).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index", new { id = editable_review.RestaurantId }));
}
return(View(review));
}
public ActionResult Edit(int id)
{
var review = _venueService.GetReviewById(id);
var model = new EditReviewViewModel();
model.VenueId = review.VenueId;
model.Comments = review.Comments;
model.Rating = review.Rating;
model.ReviewId = review.ReviewId;
model.VenueName = _venueService.GetVenueNameById(review.VenueId);
return(View(model));
}
public ActionResult EditReview(EditReviewViewModel postViewModel)
{
if (!ModelState.IsValid)
{
return(View("EditReview", postViewModel));
}
var review = _reviewService.Get(postViewModel.ReviewPublicId);
var reviewToUpdate = _mapper.Map <Review>(new Tuple <EditReviewViewModel, Review>(postViewModel, review));
_reviewService.UpdateReview(reviewToUpdate);
return(RedirectToAction("ListRestaurants", "Restaurant"));
}
public async Task <IActionResult> Edit(EditReviewViewModel model)
{
if (ModelState.IsValid)
{
var review = await _appContext.Reviews.FirstOrDefaultAsync(r => r.Id == model.Id);
review.Decsription = model.Description;
review.Rating = model.Rating;
_appContext.Update(review);
await _appContext.SaveChangesAsync();
return(RedirectToAction("ArticleProfile", "Articles", new { id = review.ArticleId }));
}
return(View(model));
}
public async Task <IActionResult> AddReview(int restaurantId, EditReviewViewModel vm)
{
try
{
RestaurantReview review = (RestaurantReview)_reviewFactory.Create(vm);
var createdReview = await _restaurantReviewsRepo.AddAsync(review);
// TODO: Add insert logic here
return(RedirectToAction(nameof(Index)));
}
catch (Exception)
{
return(View());
}
}
public async Task <IActionResult> Edit(int id)
{
var review = await _appContext.Reviews.FirstOrDefaultAsync(r => r.Id == id);
if (review != null)
{
var model = new EditReviewViewModel {
Rating = review.Rating, Description = review.Decsription, Id = id
};
return(View(model));
}
else
{
return(NotFound());
}
}
/// <summary>
/// Edit the Review (the base class)
/// </summary>
/// <param name="model"></param>
/// <param name="userId"></param>
public async Task EditReview(EditReviewViewModel model, string userId)
{
var review = await unitOfWork.ReviewsRepository.GetAll()
.FirstOrDefaultAsync(r => r.ReviewId == model.ReviewId)
?? throw new ContentNotFoundException("Не е намерено ревюто!");
if (!await IsOwnerOrAdministratorAsync(userId, review))
{
throw new NotAuthorizedUserException("Не сте оторизиран да извършвате това действие");
}
review.ReviewScore = model.ReviewScore;
review.ReviewText = model.ReviewText;
unitOfWork.ReviewsRepository.Edit(review);
await unitOfWork.SaveAsync();
}
public ActionResult Edit(EditReviewViewModel model)
{
var existingReview = _venueService.GetReviewById(model.ReviewId);
// Get logged in user
var email = User.Identity.Name;
// Get review author
var contact = _contactService.GetContactById(existingReview.ContactId);
// Return error if users are not same
if (!email.Equals(contact.Email))
{
ViewData.ModelState.AddModelError("Not Author", "You are not authorized to edit this review.");
return(View(model));
}
existingReview.Comments = model.Comments;
existingReview.Rating = model.Rating;
_venueService.EditVenueReview(existingReview);
return(RedirectToAction("Details", "Venue", new { id = model.VenueId }));
}
public ActionResult Edit(EditReviewViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
try
{
if (viewModel.Id == this.User.Identity.GetUserId())
{
ReviewService.UpdateReviewByReviewId(viewModel.ReviewId, viewModel);
return(RedirectToAction("Details", new { mediaId = viewModel.MediaId }));
}
else
{
return(RedirectToAction("MyReviews", "Reviews"));
}
}
catch (Exception)
{
throw;
}
}
public virtual async Task OnGetAsync()
{
var dto = await _service.GetAsync(Id);
ViewModel = ObjectMapper.Map <ReviewDto, EditReviewViewModel>(dto);
}
