public void AddTestReviews()
{
if (_reviewRepo.GetAll().Count() > 0)
{
return;
}
var john = _userManager.FindByNameAsync("*****@*****.**").Result;
var jane = _userManager.FindByNameAsync("*****@*****.**").Result;
var johnReview1 = CreateTestReview(1, john, 1, "Green Apple", 100, "Super delicious!");
var janeReview1 = CreateTestReview(2, jane, 2, "Coca-cola", 0, "Everything about this product sucks...");
_reviewRepo.Add(johnReview1);
_reviewRepo.Add(janeReview1);
}
public ActionResult ReviewUniversity(Review model, int id)
{
model.UniversityId = id;
if (model.Value > 5 || model.Value < 1)
{
model.Value = 5;
}
model.UserId = User.Identity.GetUserId();
_reviewRepository.Add(model);
Task task = Task.Run(async() => await _reviewRepository.Commit());
task.Wait();
return(RedirectToAction("Details", "Universities", new { id = id }));
}
public async Task <IActionResult> AddReview(ReviewForm model)
{
if (ModelState.IsValid)
{
var user = await _workContext.GetCurrentUser();
model.ReviewerName = user.FullName; // Otherwise ReviewerName is null
var review = new Review
{
Rating = model.Rating,
Title = model.Title,
Comment = model.Comment,
ReviewerName = user.FullName,
EntityId = model.EntityId,
EntityTypeId = model.EntityTypeId,
UserId = user.Id,
};
_reviewRepository.Add(review);
_reviewRepository.SaveChanges();
return(PartialView("_ReviewFormSuccess", model));
}
return(PartialView("_ReviewForm", model));
}
public Review Create(Review review, Guid idOfReserveAssociated)
{
try
{
Reserve reserveAssociated = reserveManagementLogic.GetById(idOfReserveAssociated);
VerifyIfExistReviewForReserve(idOfReserveAssociated);
review.IdOfReserve = idOfReserveAssociated;
review.NameOfWhoComments = reserveAssociated.Name;
review.LastNameOfWhoComments = reserveAssociated.LastName;
Lodging lodgingOfReview = reserveAssociated.LodgingOfReserve;
review.LodgingOfReview = lodgingOfReview;
review.VerifyFormat();
reviewRepository.Add(review);
double averageReviewScoreUpdated = reviewRepository.GetAverageReviewScoreByLodging(lodgingOfReview.Id);
lodgingManagementLogic.UpdateAverageReviewScore(lodgingOfReview, averageReviewScoreUpdated);
return(review);
}
catch (ReviewException e)
{
throw new DomainBusinessLogicException(e.Message);
}
catch (ClientBusinessLogicException e)
{
throw new ClientBusinessLogicException(MessageExceptionBusinessLogic.ErrorCreatingReview, e);
}
catch (DomainBusinessLogicException e)
{
throw new DomainBusinessLogicException(e.Message);
}
catch (ServerException e)
{
throw new ServerBusinessLogicException("No se puede crear la review debido a que ha ocurrido un error.", e);
}
}
public Review Add(Review review)
{
var addedEntity = _reviewRepository.Add(review);
_sub.OnNext(review);
return(review);
}
public IActionResult Post(int companyId, [FromBody] ReviewDto dto)
{
try
{
var customerExtarnalId = User.GetExternalId();
if (customerExtarnalId != dto.CustomerId)
{
return(Forbid());
}
var customer = _customerRepository.GetByExternalId(customerExtarnalId);
if (customer == null)
{
return(Forbid());
}
if (dto.Rating < 1 || dto.Rating > 5)
{
return(BadRequest("rating cannot be less than 1 and greater than 5"));
}
dto.Date = DateTime.Now;
var model = new Core.Entities.Review();
DtoToReviewMapper.Map(dto, model);
_reviewRepository.Add(model);
_unitOfWork.Save();
dto.Id = model.Id;
return(Created($"api/companies/{companyId}/reviews/{model.Id}", dto));
}
catch (Exception ex)
{
Log.Error(ex, $"unhandled exception");
return(StatusCode(500, ex));
}
}
public ActionResult Add(ReviewDTO reviewDTO)
{
TempData["ActivePanel"] = "review";
var product = _productRepo.FindById(reviewDTO.ProductId);
if (product == null)
{
return(View("Error"));
}
if (!ModelState.IsValid)
{
TempData["SaveSuccess"] = "false";
return(RedirectToAction("detail", "product", new { metaTitle = product.MetaTitle }));
}
reviewDTO.UserId = User.Identity.GetUserId();
var result = _reviewRepo.Add(reviewDTO);
if (!result)
{
TempData["SaveSuccess"] = "false";
return(RedirectToAction("detail", "product", new { metaTitle = product.MetaTitle }));
}
TempData["SaveSuccess"] = "true";
return(RedirectToAction("detail", "product", new { metaTitle = product.MetaTitle }));
}
public async Task <ActionResult <Review> > PostReview(Review review)
{
reviewRepo.Add(review);
await reviewRepo.SaveChangesAsync();
return(CreatedAtAction("GetReview", new { id = review.ReviewId }, review));
}
public ActionResult Review(int id, ReviewAddViewModel viewModel)
{
if (ModelState.IsValid)
{
var review = new Review()
{
BenchId = id,
Description = viewModel.Description,
Rating = viewModel.Rating,
UserId = ((CustomPrincipal)User).Id,
Date = DateTimeOffset.Now
};
if (reviewRepo.Add(review))
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Unable to add review.");
}
}
else
{
ModelState.AddModelError("", "All fields are required.");
}
return(View(viewModel));
}
public void Execute()
{
ValidateRequest();
if (Match)
{
var review = _reviewRepository.Find(Request.UserId, Request.MovieId);
if (review != null)
{
review.MovieId = Request.MovieId;
review.UserId = Request.UserId;
review.Rating = Request.Rating;
_reviewRepository.Edit(review);
}
else
{
var newReview = new Review()
{
MovieId = Request.MovieId,
UserId = Request.UserId,
Rating = Request.Rating
};
_reviewRepository.Add(newReview);
}
_reviewRepository.Commit();
}
}
public async Task <bool> Add(ZabotaReview review)
{
review.Date = DateTimeOffset.UtcNow;
await _reviewRepository.Add(review);
return(true);
}
public IActionResult AddReview(Review ReviewIn, string movieItems)
{
User currentUser = _customerList.GetUserByUsername(HttpContext.Session.GetString("Username"));
if (currentUser != null)
{
ReviewIn.Author = currentUser;
ReviewIn.Movie = _movieList.GetMovie(int.Parse(movieItems));
ReviewIn.MovieTitle = ReviewIn.Movie.MovieTitle;
if (ReviewIn.Movie == null)
{
TempData["Failure"] = "The name: " + ReviewIn.MovieTitle + "was not found, please re-enter";
return(RedirectToAction("AddReview"));
}
_reviewList.Add(ReviewIn);
IEnumerable <Review> movieReviews = _reviewList.GetMovieReviews(ReviewIn.Movie);
ReviewIn.Movie.MovieRating = Math.Round((decimal)movieReviews.Average(m => m.StarRating));
ReviewIn.Movie.NumberOfReviews = movieReviews.Count();
_context.SaveChanges();
return(RedirectToAction("ReviewList"));
}
else
{
return(View("Login"));
}
}
public IActionResult Add(int id, HomeDetailsViewModel model)
{
var book = bookRepository.GetBook(id);
if (ModelState.IsValid)
{
Review newReview = new Review
{
BookId = book.Id,
ReviewComments = model.Review.ReviewComments,
Rating = model.Review.Rating,
Book = model.Book,
Id = model.ReviewId,
};
reviewRepository.Add(newReview);
reviewRepository.GetAllReviews().Where(a => a.BookId == book.Id).ToList();
var book5 = bookRepository.GetBook(id).Reviews.Where(p => p.Rating == 5).Count();
var book4 = bookRepository.GetBook(id).Reviews.Where(p => p.Rating == 4).Count();
var book3 = bookRepository.GetBook(id).Reviews.Where(p => p.Rating == 3).Count();
var book2 = bookRepository.GetBook(id).Reviews.Where(p => p.Rating == 2).Count();
var book1 = bookRepository.GetBook(id).Reviews.Where(p => p.Rating == 1).Count();
float total = ((book1 * 1) + (book2 * 2) + (book3 * 3) + (book4 * 4) + (book5 * 5));
var totalReviews = bookRepository.GetBook(id).Reviews.Count();
float average = total / totalReviews;
BookAverageRating AvgRating = new BookAverageRating
{
AverageRating = average,
BookId = book.Id
};
var avgRating = bookAverageRatingRepository.GetAllAverageRating().Where(a => a.BookId == id).Count();
/*BookAverageRating newAvgRating = new BookAverageRating
* {
* Id = book.BookAverageRating.Id
* };*/
if (avgRating == 0)
{
bookAverageRatingRepository.Add(AvgRating);
}
else
{
bookAverageRatingRepository.Delete(AvgRating.Id);
bookAverageRatingRepository.Add(AvgRating);
}
return(RedirectToAction("List", new { id = newReview.BookId }));
}
return(View());
}
public void Add(Review review)
{
review.ReviewDate = DateTime.Now;
var game = _gameRepository.Find(review.GameId);
review.IsVerifiedOwner = _steamApi.CheckAppOwnershipAsync(review.UserId, game.SteamAppId).Result;
_reviewRepository.Add(review);
_reviewRepository.Save();
}
public void ReportAbuse(string reviewId, string authorId, string authorName, string authorLocation)
{
// Validate Incoming parameters
if (string.IsNullOrEmpty(reviewId))
{
throw new ArgumentNullException("reviewId");
}
if (string.IsNullOrEmpty(authorId))
{
throw new ArgumentNullException("authorId");
}
if (string.IsNullOrEmpty(authorName))
{
throw new ArgumentNullException("authorName");
}
if (string.IsNullOrEmpty(authorLocation))
{
throw new ArgumentNullException("authorLocation");
}
var review = FindReviewById(reviewId);
if (review != null)
{
// Skip duplicated Abuse
var abuseElement = FindReportAbuseByAuthor(reviewId, authorId);
if (abuseElement != null)
{
return;
}
// Post Abuse
var newAbuseElement = new ReportAbuseElement();
newAbuseElement.ReviewId = reviewId;
//newAbuseElement.ReportAbuseElementId = Guid.NewGuid().ToString();
newAbuseElement.AuthorId = authorId;
//newAbuseElement.AuthorFN = authorName;
//newAbuseElement.AuthorLocation = authorLocation;
//newAbuseElement.Status = "Pending";
_repository.Add(newAbuseElement);
_repository.UnitOfWork.Commit();
}
}
public void AddReview(string rating, string title, string text)
{
reviewRepository.Add(new Review()
{
Id = Guid.NewGuid(),
Rating = rating,
Title = title,
Text = text
});
}
public void Add(NewReviewDto review)
{
ValidateRating(review.Rating);
var newReview = new Review
{
Content = review.Content, Title = review.Title, Rating = review.Rating,
EscapeRoomId = review.EscapeRoomId, UserId = review.UserId
};
_reviewRepository.Add(newReview);
}
public void AddReview(Guid ownerId, string message)
{
GetOwnerByGuid(ownerId);
reviewRepository.Add(new Review()
{
Id = Guid.NewGuid(),
Message = message,
UserId = ownerId
});;
}
public ActionResult Addnew(ReviewModel model)
{
//if (ModelState.IsValid)
//{
Review tintuc = new Review()
{
Sdate = DateTime.Now,
TieuDe = RejectMarks(model.TieuDe),
Mota = model.Mota,
HinhAnh = (model.HinhAnh).Replace("/files/", ""),
ChiTiet = ChangeImageSEO(model.ChiTiet, model.TieuDe, ConvertFont(model.TieuDe)),
//ChiTiet = model.ChiTiet,
Ok = false,
Sapxep = model.Sapxep,
Link = ConvertFont(model.TieuDe),
SEODescription = model.SEODescription,
SEOtitle = model.SEOtitle,
NguoiTao = User.Identity.Name
};
_reviewRepository.Add(tintuc);
_unitOfWork.Commit();
if (model.mySingleField != null)
{
#region thêm mới tag
string[] separators = { "," };
var taglist = model.mySingleField.Split(separators, StringSplitOptions.RemoveEmptyEntries);
//check null: nếu tồn tại thêm mới bình thường
if (taglist.Any())
{
foreach (var tag in taglist)
{
TagTinTuc _tag = new TagTinTuc()
{
NgayTao = DateTime.Now,
IdMenu = tintuc.id_, // id cua tin moi vua them
TenTag = tag.Trim(),
Link = ConvertFont(tag.Trim()),
Code = RejectMarks(tag.Trim())
};
_tagTinTucRepository.Add(_tag);
_unitOfWork.Commit();
}
}
#endregion
}
//}
//else
//{
// return View("Create", model);
//}
return(RedirectToAction("Index"));
}
public void AddReview(string bookName, string authorName, string text, string Title, User user)
{
var book = bookRepository.GetBookByName(bookName);
var author = authorRepository.GetAuthorByName(authorName);
reviewRepository.Add(new Review()
{
Id = Guid.NewGuid(), Text = text, Book = book, Author = author, Title = Title, User = user
});
nrReview++;
}
public IActionResult Post([FromBody] Review review)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
_reviewRepo.Add(review);
if (_reviewRepo.SaveAll())
{
return(Created("", review));
}
return(BadRequest($"failed to add new review"));
}
public async Task <IActionResult> AddReview(string review)
{
if (!string.IsNullOrWhiteSpace(review))
{
Review rev = new Review()
{
Text = review,
User = await _userManager.GetUserAsync(HttpContext.User)
};
_reviewRepository.Add(rev);
_reviewRepository.Commit();
}
return(RedirectToAction("Reviews"));
}
public async Task <ActionResult <ReviewModel> > Post(ReviewModel model)
{
try
{
model.Service.ServiceId = 1;
var review = _mapper.Map <Review>(model);
if (model.RatingType == null)
{
return(BadRequest("RatingTypeId is required"));
}
var ratingType = await _repository.GetRatingTypeAsync(model.RatingType.RatingTypeId);
if (ratingType == null)
{
return(BadRequest("RatingType could not be found"));
}
review.RatingType = ratingType;
var service = await _repository.GetServiceAsync(model.Service.ServiceId);
if (service == null)
{
return(BadRequest("Service could not be found"));
}
review.Service = service;
_repository.Add(review);
if (await _repository.SaveChangesAsync())
{
var url = _linkGenerator.GetPathByAction(HttpContext,
controller: "Review", action: "Get",
values: new { reviewId = review.ReviewId, version = "1" });
return(Created(url, _mapper.Map <ReviewModel>(review)));
}
else
{
return(BadRequest("Failed to save new Review"));
}
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Failed to create Review"));
}
}
public IActionResult Post([FromBody] AddReview review)
{
if (review == null)
{
return(BadRequest("Review is null."));
}
int id = _dataRepository.Add(review);
if (id == -1)
{
return(BadRequest());
}
return(CreatedAtRoute(
"ReviewGet",
new { Id = id },
review));
}
public async Task <HttpResponseMessage> Put()
{
var requestContent = Request.Content;
var jsonContent = await requestContent.ReadAsStringAsync();
var review = JsonConvert.DeserializeObject <Reviews>(jsonContent);
try
{
await _reviewRepository.Add(review);
return(JsonResponse.JsonHttpResponse <object>(true));
}
catch (Exception)
{
return(JsonResponse.JsonHttpResponse <object>(false));
}
}
public async Task <ActionResult <ReviewViewModel> > PostReview(ReviewViewModel viewModel)
{
try
{
var entity = GetMapperReviewViewModelToReview(viewModel);
var model = await _reviewRepository.Add(entity);
return(GetMapperReviewToReviewViewModel(model));
}
catch (InvalidDataException e)
{
return(BadRequest(new { message = e.Message }));
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = e.Message }));
}
}
public async Task <IActionResult> AddReview([FromBody] SaveReviewResource reviewResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var review = mapper.Map <SaveReviewResource, Review>(reviewResource);
repository.Add(review);
repository.SetRating(review, onAdd: true);
await unitOfWork.CompleteAsync();
review = await repository.GetReview(reviewResource.Id);
var result = mapper.Map <Review, ReviewResource>(review);
return(Ok(result));
}
public IActionResult LeaveReview(int recipeId, string recipeTitle, string username, string comment)
{
if (ModelState.IsValid)
{
reviewRepository.Add(new Review
{
RecipeId = recipeId, RecipeTitle = recipeTitle, Username = username, Comment = comment
});
return(RedirectToAction("ViewRecipe", new { recipeId = recipeId }));
}
else
{
return(View("ViewRecipe", new RecipeDetailsViewModel
{
Recipe = repository.Recipes.Where(r => r.RecipeId == recipeId).FirstOrDefault(),
Reviews = reviewRepository.Reviews.Where(r => r.RecipeId == recipeId)
}));
}
}
public void Execute(CreateReviewModel createReviewModel)
{
var from = _userRepository.Get(createReviewModel.From);
var to = _userRepository.Get(createReviewModel.To);
var ratings = _reviewRepository
.GetAll()
.Where(x => x.To.Id.Equals(to.Id))
.Select(x => x.Rating)
.ToList();
ratings.Add(createReviewModel.Rating);
to.UpdateRating(ratings.Average());
var review = new Review(from, to, createReviewModel.Body, createReviewModel.Rating);
_reviewRepository.Add(review);
_unitOfWork.Save();
}
public IActionResult Details(ProductDetailsViewModel viewModel, int id)
{
if (ModelState.IsValid)
{
var newReview = CreateReview(viewModel, id);
_reviewRepository.Add(newReview);
return(RedirectToAction("Index", "Review", new { prodId = id, catId = viewModel.ReviewCategoryId, subCatId = viewModel.ReviewSubCategoryId }));
}
viewModel.Product = DetailsGetProductById(id);
viewModel.SubCategory = DetailsGetSubCategoryByProductId(id);
viewModel.Category = DetailsGetCategoryByProductId(id);
viewModel.Reviews = DetailsGetReviewsByProductId(id);
viewModel.RelatedProducts = DetailsGetRelatedProductsById(id);
viewModel.ProductId = id;
viewModel.ReviewCategoryId = _categoryRepository.GetByProductId(id).Id;
viewModel.ReviewSubCategoryId = _subCategoryRepository.GetByProductId(id).Id;
return(View(viewModel));
}