public IActionResult UpdateReview([FromBody] ReviewForUpdateDto review)
{
try
{
if (review == null)
{
_logger.LogError("Review object sent from client is null.");
return(BadRequest("Review object is null"));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid Review object sent from client.");
return(BadRequest("Invalid model object"));
}
bool succes = _reviewLogic.Update(review);
if (!succes)
{
return(NotFound());
}
return(Ok("Review is updated"));
}
catch (Exception ex)
{
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> UpdateReviewStatus(int id, [FromQuery] ReviewForUpdateDto reviewForUpdateDto)
{
var reviewFromRepo = await _repo.GetReview(id);
if (reviewFromRepo == null)
{
return(BadRequest("No file has been found."));
}
reviewForUpdateDto.IsApproved = true;
_mapper.Map(reviewForUpdateDto, reviewFromRepo);
/* IMPORTANT
* Be careful here. Make sure no await, no task.
* Just classes or else mapping exception eventhough
* you have already did automapper mapping
*/
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating review status {id} failed on save");
}
public async Task <IActionResult> UpdateReview(int id, [FromBody] ReviewForUpdateDto review)
{
if (review == null)
{
return(BadRequest());
}
if (!await _reviewRepository.ReviewExists(id))
{
return(NotFound());
}
var reviewForGameFromRepo = await _reviewRepository.GetReviewById(id);
if (reviewForGameFromRepo == null)
{
return(NotFound());
}
Mapper.Map(review, reviewForGameFromRepo);
await _reviewRepository.UpdateReview(reviewForGameFromRepo);
if (!await _reviewRepository.Save())
{
throw new Exception($"Updating game {id} failed on save!");
}
return(NoContent());
}
public bool Update(ReviewForUpdateDto reviewForUpdate)
{
try
{
var reviewDto = GetById(reviewForUpdate.id);
if (reviewDto == null)
{
return(false);
}
Review DataEntity = _mapper.Map <Review>(reviewDto);
_mapper.Map(reviewForUpdate, DataEntity);
_repository.Update(DataEntity);
_repository.Save();
_logger.LogError($"Updated Review with id: {DataEntity.id}");
return(true);
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside UpdateReview action: {ex.Message}");
throw new Exception();
}
}
public async Task <IActionResult> UpdateReviewForRestaurant(Guid restaurantId, Guid reviewId, ReviewForUpdateDto review)
{
// optimize function
await DeletePutOptimize(restaurantId, reviewId);
// get reviews
var reviewFromRepo = await _knockRepository.GetReviewAsync(restaurantId, reviewId);
if (reviewFromRepo == null)
{
return(NotFound());
}
// map
_mapper.Map(review, reviewFromRepo);
// call update function
_knockRepository.UpdateReview(reviewFromRepo);
await _knockRepository.SaveChangesAsync();
return(NoContent());
}
public async Task <IActionResult> UpdateReviewForProduct(Guid productId, Guid id, [FromBody] ReviewForUpdateDto review)
{
var reviewEntity = HttpContext.Items["entity"] as Review;
_mapper.Map(review, reviewEntity);
await _repository.SaveAsync();
return(NoContent());
}
public async Task <IActionResult> PartiallyUpdateReviewForAlbum([FromRoute] Guid albumId, [FromRoute] Guid reviewId, [FromBody] JsonPatchDocument <ReviewForUpdateDto> patchDoc)
{
if (patchDoc == null)
{
return(BadRequest());
}
// TODO: check if artist/album exist first
var reviewFromRepo = await _reviewRepository.GetReviewForAlbumAsync(albumId, reviewId);
// upserting
if (reviewFromRepo == null)
{
var reviewForUpdateDto = new ReviewForUpdateDto();
patchDoc.ApplyTo(reviewForUpdateDto, ModelState);
TryValidateModel(reviewForUpdateDto);
if (!ModelState.IsValid)
{
return(new ErrorProcessingEntityObjectResult(ModelState));
}
var reviewToAdd = Mapper.Map <Review>(reviewForUpdateDto);
reviewToAdd.Id = reviewId;
reviewToAdd.AlbumId = albumId;
_reviewRepository.Create(reviewToAdd);
if (!await _reviewRepository.SaveChangesAsync())
{
throw new Exception($"upserting review {reviewId} for album {albumId} failed on save");
}
var reviewToReturn = Mapper.Map <ReviewDto>(reviewToAdd);
return(CreatedAtRoute("GetReviewForAlbum", new { albumId, reviewId = reviewToReturn.Id }, reviewToReturn));
}
var reviewToPatch = Mapper.Map <ReviewForUpdateDto>(reviewFromRepo);
patchDoc.ApplyTo(reviewToPatch, ModelState);
TryValidateModel(reviewToPatch);
if (!ModelState.IsValid)
{
return(new ErrorProcessingEntityObjectResult(ModelState));
}
Mapper.Map(reviewToPatch, reviewFromRepo);
if (reviewFromRepo.AlbumId == null)
{
reviewFromRepo.Id = albumId;
}
_reviewRepository.Update(reviewFromRepo);
if (!await _reviewRepository.SaveChangesAsync())
{
throw new Exception($"Updating review {reviewId} for album {albumId} failed on save");
}
return(NoContent());
}
public async Task <IActionResult> UpdateReviewForAlbum([FromRoute] Guid albumId, [FromRoute] Guid reviewId, [FromBody] ReviewForUpdateDto reviewToUpdate)
{
if (reviewToUpdate == null)
{
return(BadRequest());
}
var reviewFromRepo = await _reviewRepository.GetReviewForAlbumAsync(albumId, reviewId);
// upserting
if (reviewFromRepo == null)
{
var reviewEntity = Mapper.Map <Review>(reviewToUpdate);
reviewEntity.Id = reviewId;
reviewEntity.AlbumId = albumId;
_reviewRepository.Create(reviewEntity);
if (!await _reviewRepository.SaveChangesAsync())
{
throw new Exception($"upserting review {reviewId} for album {albumId} failed on save");
}
var reviewToReturn = Mapper.Map <ReviewDto>(reviewEntity);
return(CreatedAtRoute("GetReviewForAlbum", new { albumId, reviewId = reviewToReturn.Id }, reviewToReturn));
}
Mapper.Map(reviewToUpdate, reviewFromRepo);
if (reviewFromRepo.AlbumId == null)
{
reviewFromRepo.Id = albumId;
}
_reviewRepository.Update(reviewFromRepo);
if (!await _reviewRepository.SaveChangesAsync())
{
throw new Exception($"Updating review {reviewId} for album {albumId} failed on save");
}
return(NoContent());
}
