public async Task <ActionResult <Danhgia> > CreateReviewAsync(ReviewCreateDto review)
{
Danhgia reviewModel = _mapper.Map <Danhgia>(review);
await _reviewService.CreateReviewAsync(reviewModel);
return(CreatedAtRoute(nameof(GetReviewByIdAsync), new { id = reviewModel.MaDanhGia }, reviewModel));
}
public bool CreateReview(ReviewCreateDto reviewToCreateDto)
{
var reviewToCreate = MapConfig.Mapper.Map <Review>(reviewToCreateDto);
_reviewContext.Add(reviewToCreate);
return(Save());
}
public async Task <ActionResult> PostReview(int productId, ReviewCreateDto reviewDto)
{
var product = await _unitOfWork.ProductRepository.GetProductByIdAsync(productId);
if (product == null)
{
return(NotFound());
}
if (await _unitOfWork.ReviewRepository.GetProductReview(productId, User.GetUserId()) != null)
{
return(BadRequest("You have already posted a review"));
}
var review = _mapper.Map <Review>(reviewDto);
review.ProductId = productId;
review.UserId = User.GetUserId();
var count = (await _unitOfWork.ReviewRepository.GetProductReviews(productId)).Count();
product.AverageRating = ((product.AverageRating * count) + reviewDto.Rate) / (count + 1);
_unitOfWork.ReviewRepository.AddReview(review);
_unitOfWork.ProductRepository.UpdateProduct(product);
if (await _unitOfWork.Complete())
{
return(NoContent());
}
return(BadRequest("Failed to post review"));
}
public ActionResult <ReviewReadDto> CreateReview(ReviewCreateDto reviewCreateDto)
{
var reviewModel = mapper.Map <Review>(reviewCreateDto);
reviewRepo.CreateReview(reviewModel);
reviewRepo.SaveChanges();
var reviewReadDto = mapper.Map <ReviewReadDto>(reviewModel);
return(CreatedAtRoute(nameof(GetReviewById), new { Id = reviewReadDto.FacultyId }, reviewReadDto));
}
public ActionResult <ReviewCreateDto> CreateReviewByItem([FromBody] ReviewCreateDto rvw)
{
var reviewModel = _mapper.Map <Review>(rvw);
_repository.CreateReviewByItem(reviewModel);
_repository.SaveChanges();
var reviewCreateDto = _mapper.Map <ReviewCreateDto>(reviewModel);
return(Ok(reviewCreateDto));
}
public ActionResult <ReviewCreateDto> CreateReview(ReviewCreateDto reviewCreateDto)
{
var ReviewModel = _reviewMappper.Map <Reviews>(reviewCreateDto);
_reviewsRepo.CreateReview(ReviewModel);
_reviewsRepo.SaveChanges();
var reviewRead = _reviewMappper.Map <ReviewReadDto>(ReviewModel);
return(CreatedAtRoute(nameof(GetById), new { Id = reviewRead.ReviewId }, reviewRead));
}
public async Task <ActionResult> createReview(ReviewCreateDto reviewCreateDto)
{
var UserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var Review = _mapper.Map <Review>(reviewCreateDto);
Review.Name = await _clientservice.AddUserName(UserId);
_reviewRepo.CreateProductReview(UserId, Review);
_reviewRepo.saveChanges();
return(Ok());
}
public async Task <IActionResult> CreateReview(ReviewCreateDto reviewCreateDto)
{
if (ModelState.IsValid)
{
_logger.LogInformation("POST api/review => OK");
var review = _mapper.Map <Review>(reviewCreateDto);
await _unitOfWork.Review.Create(review);
await _unitOfWork.Save();
return(Ok());
}
else
{
_logger.LogInformation("POST api/review => NOT OK");
return(NotFound());
}
}
public ActionResult Create(ReviewCreateDto reviewCreateDto)
{
var review = _mapper.Map <Review>(reviewCreateDto);
//check if the user has permission
var user = HttpContext.User;
int userId = int.Parse(user.Claims.FirstOrDefault(c => c.Type == "Id").Value);
if (userId != reviewCreateDto.FromUserId)
{
return(Forbid());
}
_unitOfWork.Reviews.Add(review);
_unitOfWork.SaveChanges();
return(NoContent());
}
public async Task <ReviewDto> CreateAsync(ReviewCreateDto reviewDto)
{
if (!await _userRepository.AnyUserAsync(x => x.Id == reviewDto.ClientId))
{
throw new NotFoundLogicException($"Client with id {reviewDto.ClientId} not found!", nameof(reviewDto.ClientId));
}
if (!await _employeeRepository.AnyEmployeeAsync(x => x.Id == reviewDto.EmployeeId))
{
throw new NotFoundLogicException($"Employee with id {reviewDto.EmployeeId} not found!", nameof(reviewDto.EmployeeId));
}
var review = Mapper.Map <Review>(reviewDto);
review.Date = DateTime.Now;
_reviewRepository.Create(review);
await SaveProvider.SaveAsync();
return(Mapper.Map <ReviewDto>(review));
}
public IActionResult CreateReview([FromBody] ReviewCreateDto newReview)
{
if (newReview == null)
{
return(BadRequest(ModelState));
}
if (_unitOfWork.ReviewRepository.ReviewExists(newReview.Id))
{
ModelState.AddModelError("", "Such review Exists!");
return(StatusCode(404, ModelState));
}
if (!_unitOfWork.ReviewRepository.CreateReview(newReview))
{
ModelState.AddModelError("", $"Something went wrong saving the review " + $"{newReview.HeadLine}{newReview.Rating}");
return(StatusCode(500, ModelState));
}
_unitOfWork.Commit();
return(CreatedAtRoute("GetReviewById", new { reviewId = newReview.Id }, newReview));
}
