public async void Reviews_UpdateAsync_PositiveAndNegative_Test()
{
var options = new DbContextOptionsBuilder <DreamFoodDeliveryContext>()
.UseInMemoryDatabase(databaseName: "Reviews_UpdateAsync_PositiveAndNegative_Test")
.Options;
using (var context = new DreamFoodDeliveryContext(options))
{
context.AddRange(_reviews);
int sum = 0;
for (int i = 0; i < _reviews.Count; i++)
{
sum += _reviews[i].Rating.Value;
}
RatingDB rating = new RatingDB()
{
Sum = sum,
Count = _reviews.Count
};
context.Add(rating);
await context.SaveChangesAsync();
}
using (var context = new DreamFoodDeliveryContext(options))
{
var review = await context.Reviews.AsNoTracking().FirstOrDefaultAsync();
var rating = await context.Rating.AsNoTracking().FirstOrDefaultAsync();
var service = new ReviewService(_mapper, context);
ReviewToUpdate updateReview = new ReviewToUpdate()
{
Id = review.Id.ToString(),
Headline = "Headline",
Content = "Content",
Rating = 1
};
ReviewToUpdate failReview = new ReviewToUpdate()
{
Id = new Guid().ToString(),
Headline = "Headline",
Content = "Content",
Rating = 0
};
var resultPositive = await service.UpdateAsync(updateReview);
var resultNegative = await service.UpdateAsync(failReview);
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Headline.Should().BeEquivalentTo(updateReview.Headline);
resultPositive.Data.Headline.Should().NotBeEquivalentTo(review.Headline);
resultNegative.IsSuccess.Should().BeFalse();
}
}
public async Task <Result <ReviewView> > UpdateAsync(ReviewToUpdate review, CancellationToken cancellationToken = default)
{
ReviewDB reviewForUpdate = _mapper.Map <ReviewDB>(review);
ReviewDB reviewOld = await _context.Reviews.AsNoTracking().FirstOrDefaultAsync(_ => _.Id == Guid.Parse(review.Id));
if (reviewOld is null)
{
return(Result <ReviewView> .Quite <ReviewView>(ExceptionConstants.REVIEW_WAS_NOT_FOUND));
}
var rating = await _context.Rating.AsNoTracking().FirstOrDefaultAsync(cancellationToken);
if (rating is null)
{
rating = new RatingDB()
{
Count = 0, Sum = 0
};
_context.Rating.Add(rating);
}
rating.Sum = rating.Sum.Value - reviewOld.Rating + reviewForUpdate.Rating;
_context.Entry(rating).Property(c => c.Sum).IsModified = true;
reviewForUpdate.Id = Guid.Parse(review.Id);
reviewForUpdate.ModificationTime = DateTime.Now;
_context.Entry(reviewForUpdate).Property(c => c.Headline).IsModified = true;
_context.Entry(reviewForUpdate).Property(c => c.Rating).IsModified = true;
_context.Entry(reviewForUpdate).Property(c => c.Content).IsModified = true;
_context.Entry(reviewForUpdate).Property(c => c.ModificationTime).IsModified = true;
try
{
await _context.SaveChangesAsync();
var reviewAfterUpdate = await _context.Reviews.Where(_ => _.Id == Guid.Parse(review.Id)).AsNoTracking().FirstOrDefaultAsync(cancellationToken);
return(reviewAfterUpdate is null
? Result <ReviewView> .Quite <ReviewView>(ExceptionConstants.REVIEW_WAS_NOT_FOUND)
: Result <ReviewView> .Ok(_mapper.Map <ReviewView>(reviewAfterUpdate)));
}
catch (DbUpdateConcurrencyException ex)
{
return(Result <ReviewView> .Fail <ReviewView>(ExceptionConstants.CANNOT_UPDATE_MODEL + ex.Message));
}
catch (DbUpdateException ex)
{
return(Result <ReviewView> .Fail <ReviewView>(ExceptionConstants.CANNOT_UPDATE_MODEL + ex.Message));
}
}
public async Task <IActionResult> Update([FromBody, CustomizeValidator] ReviewToUpdate review, CancellationToken cancellationToken = default)
{
if (review is null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _reviewService.UpdateAsync(review, cancellationToken);
return(result.IsError ? throw new InvalidOperationException(result.Message) : (IActionResult)Ok(result.Data));
}
catch (InvalidOperationException ex)
{
Log.Error(ex, ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, new CustumResult()
{
Status = StatusCodes.Status500InternalServerError, Message = ex.Message
}));
}
}
