public async Task <IActionResult> Create(int id)
{
bool isSupplementExisting = await this.supplementService.IsSupplementExistingById(id, false);
if (!isSupplementExisting)
{
TempData.AddErrorMessage(string.Format(EntityNotFound, SupplementEntity));
return(this.RedirectToHomeIndex());
}
string username = User.Identity.Name;
bool isUserRestricted = await this.userService.IsUserRestricted(username);
if (isUserRestricted)
{
TempData.AddErrorMessage(UserRestrictedErrorMessage);
return(this.RedirectToHomeIndex());
}
ReviewFormViewModel model = new ReviewFormViewModel()
{
Ratings = this.GetRatingsSelectListItems()
};
ViewData["SupplementId"] = id;
return(View(model));
}
public IActionResult AddReview(ReviewFormViewModel vm)
{
return(vm.ReviewType switch
{
nameof(Song) => RedirectToAction("AddSongReview", vm),
nameof(Album) => RedirectToAction("AddAlbumReview", vm),
nameof(PodcastEpisode) => RedirectToAction("AddPodcastEpisodeReview", vm),
_ => RedirectToAction("Index", "Music"),
});
public ActionResult New()
{
var viewModel = new ReviewFormViewModel()
{
Id = 0,
};
return(View("Form", viewModel));
}
public ReviewFormViewModel NewReview()
{
var employees = _context.Employees.ToList();
var viewModel = new ReviewFormViewModel
{
Review = new Review(),
Employees = employees
};
return(viewModel);
}
public async Task <IActionResult> Edit(int id, ReviewFormViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await this._reviews.EditAsync(id, model.Text, (int)(model.Stars * 2));
return(Redirect("/Reviews/List/DateDescending"));
}
public ReviewFormViewModel EditReview(int id)
{
var employees = _context.Employees.ToList();
var review = _context.Reviews.SingleOrDefault(r => r.Id == id);
var viewModel = new ReviewFormViewModel
{
Employees = employees,
Review = review
};
return(viewModel);
}
public ActionResult Save(ReviewFormViewModel model)
{
if (!ModelState.IsValid)
{
var viewModel = _reviewRepo.NewReview();
return(View("ReviewForm", viewModel));
}
_reviewRepo.SaveReview(model);
return(RedirectToAction("Index", "Review"));
}
public ReviewFormViewModel SaveReview(ReviewFormViewModel model)
{
if (model.Review.Id == 0)
{
_context.Reviews.Add(model.Review);
}
else
{
_context.Entry(model.Review).State = EntityState.Modified;
}
_context.SaveChanges();
return(model);
}
public async Task <IActionResult> Post(ReviewFormViewModel model)
{
if (model == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(model));
}
await this._reviews.CreateAsync(model.Text, (int)Math.Round(model.Stars * 2), this._userManager.GetUserId(HttpContext.User));
return(Redirect("List/DateDescending"));
}
public async Task <IActionResult> Create(int id, ReviewFormViewModel model)
{
if (!ModelState.IsValid)
{
model.Ratings = this.GetRatingsSelectListItems();
ViewData["SupplementId"] = id;
return(View(model));
}
bool isSupplementExisting = await this.supplementService.IsSupplementExistingById(id, false);
if (!isSupplementExisting)
{
TempData.AddErrorMessage(string.Format(EntityNotFound, SupplementEntity));
return(this.RedirectToHomeIndex());
}
string username = User.Identity.Name;
bool isUserRestricted = await this.userService.IsUserRestricted(username);
if (isUserRestricted)
{
TempData.AddErrorMessage(UserRestrictedErrorMessage);
return(this.RedirectToHomeIndex());
}
string userId = this.userManager.GetUserId(User);
await this.reviewService.CreateAsync(model.Content, model.Rating, userId, id);
TempData.AddSuccessMessage(string.Format(EntityCreated, ReviewEntity));
bool isUserModerator = User.IsInRole(ModeratorRole);
if (isUserModerator)
{
return(RedirectToAction(nameof(ReviewsController.Index), Reviews, new { area = ModeratorArea }));
}
return(this.RedirectToAction(nameof(Index)));
}
public ActionResult Create(ReviewFormViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.Review.ItemId == null)
{
return(BadRequest());
}
if (model.Review.Page == null ||
model.Review.Page < 1)
{
model.Review.Page = 1;
}
int authorId = User.Identity.GetUserId <int>();
bool success = this.reviewService.Create(
model.Review.Content,
model.Mark,
model.Review.ItemId.Value,
authorId);
if (!success)
{
return(BadRequest());
}
TempData.AddSuccessMessage(string.Format(
WebConstants.SuccessfullEntityOperation,
Review,
WebConstants.Added));
return(RedirectToAction(
nameof(ItemsController.Details),
Items,
new
{
id = model.Review.ItemId,
page = model.Review.Page
}));
}
public async Task <IActionResult> Rate(ReviewFormViewModel model, string id)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var authorId = this.userManager.GetUserId(User);
var userId = model.SelectedPassenger == null ? id : model.SelectedPassenger;
await this.reviews.CreateAsync(userId, model.SelectedRating, model.Comment, authorId);
var user = await this.userManager.FindByIdAsync(userId);
TempData["Success"] = $"{user.Name} was succcessfully rated.";
return(RedirectToAction(nameof(Rate), new { id = model.TravelId }));
}
public async Task <IActionResult> Edit(int id)
{
bool isReviewExistingById = await this.reviewService.IsReviewExistingById(id, false);
if (!isReviewExistingById)
{
TempData.AddErrorMessage(string.Format(EntityNotFound, ReviewEntity));
return(this.RedirectToHomeIndex());
}
string username = User.Identity.Name;
bool isUserRestricted = await this.userService.IsUserRestricted(username);
if (isUserRestricted)
{
TempData.AddErrorMessage(UserRestrictedErrorMessage);
return(this.RedirectToHomeIndex());
}
string userId = this.userManager.GetUserId(User);
bool isUserAuthor = await this.reviewService.IsUserAuthor(id, userId);
bool isUserModerator = User.IsInRole(ModeratorRole);
if (!isUserAuthor && !isUserModerator)
{
return(this.RedirectToHomeIndex());
}
ReviewBasicServiceModel review = await this.reviewService.GetEditModelAsync(id);
ReviewFormViewModel model = new ReviewFormViewModel()
{
Content = review.Content,
Rating = review.Rating,
Ratings = this.GetRatingsSelectListItems()
};
return(View(model));
}
public ActionResult Edit(int id)
{
var review = _context.Reviews.SingleOrDefault(c => c.Id == id);
if (review == null || (review.UserId != User.Identity.GetUserId() && User.IsInRole(RoleName.User)))
{
return(HttpNotFound());
}
else
{
var viewModel = new ReviewFormViewModel
{
Id = review.Id,
Comment = review.Comment,
Rating = review.Rating,
};
return(View("Form", viewModel));
}
}
public ActionResult Save(ReviewFormViewModel vm)
{
ApplicationDbContext db = new ApplicationDbContext();
if (!ModelState.IsValid)
{
//foreach (ModelState modelState in ViewData.ModelState.Values)
//{
// foreach (ModelError error in modelState.Errors)
// {
// return Content(error.ErrorMessage);
// }
//}
return(View("Form", vm));
}
if (vm.Id == 0)
{
var currentUserId = User.Identity.GetUserId();
var review = new Review
{
Id = vm.Id,
Comment = vm.Comment,
Rating = vm.Rating,
UserId = currentUserId,
DateWritten = DateTime.Now,
};
_context.Reviews.Add(review);
}
else
{
var reviewInDb = _context.Reviews.Single(c => c.Id == vm.Id);
reviewInDb.Comment = vm.Comment;
reviewInDb.Rating = vm.Rating;
}
_context.SaveChanges();
return(RedirectToAction("Index", "Review"));
}
public ActionResult Create(int?itemId, int?page)
{
if (itemId == null)
{
return(BadRequest());
}
if (page == null || page < 1)
{
page = 1;
}
ReviewFormViewModel model = new ReviewFormViewModel()
{
Review = new ReviewFormServiceModel
{
ItemId = itemId,
Page = page
}
};
return(View(model));
}
public void ReviewSaveShouldSaveReviewModel()
{
//Arrange
var mock = new Mock <IReviewRepository>();
var controller = new ReviewController(mock.Object);
var review = new Review
{
Id = 2,
EmployeeId = 5
};
var model = new ReviewFormViewModel
{
Review = review
};
//Act
var result = controller.Save(model);
//Assert
Assert.IsNotNull(result);
Assert.AreEqual("Index", ((RedirectToRouteResult)result).RouteValues["action"]);
}
public async Task <IActionResult> Edit(int id, ReviewFormViewModel model)
{
if (!ModelState.IsValid)
{
model.Ratings = this.GetRatingsSelectListItems();
return(View(model));
}
bool isReviewExistingById = await this.reviewService.IsReviewExistingById(id, false);
if (!isReviewExistingById)
{
TempData.AddErrorMessage(string.Format(EntityNotFound, ReviewEntity));
return(this.RedirectToHomeIndex());
}
string username = User.Identity.Name;
bool isUserRestricted = await this.userService.IsUserRestricted(username);
if (isUserRestricted)
{
TempData.AddErrorMessage(UserRestrictedErrorMessage);
return(this.RedirectToHomeIndex());
}
string userId = this.userManager.GetUserId(User);
bool isUserAuthor = await this.reviewService.IsUserAuthor(id, userId);
bool isUserModerator = User.IsInRole(ModeratorRole);
if (!isUserAuthor && !isUserModerator)
{
return(this.RedirectToHomeIndex());
}
bool isReviewModified = await this.reviewService.IsReviewModified(id, model.Content, model.Rating);
if (!isReviewModified)
{
model.Ratings = this.GetRatingsSelectListItems();
TempData.AddWarningMessage(EntityNotModified);
return(View(model));
}
await this.reviewService.EditAsync(id, model.Content, model.Rating);
TempData.AddSuccessMessage(string.Format(EntityModified, ReviewEntity));
if (isUserModerator)
{
return(RedirectToAction(nameof(ReviewsController.Index), Reviews, new { area = ModeratorArea }));
}
return(this.RedirectToAction(nameof(Index)));
}
