public async Task <IActionResult> BookPatch([FromBody]
JsonPatchDocument <PatchBookViewModel> patchDoc)
{
if (patchDoc != null)
{
var originalBooks = await _bookService.GetBooks();
var originalBooksCopy = originalBooks.ConvertAll(x => new BookViewModel(x));
var patchOriginalBooksCopy = new PatchBookViewModel()
{
books = originalBooksCopy
};
patchDoc.ApplyTo(patchOriginalBooksCopy, ModelState);
await _bookService.ApplyPatching(patchOriginalBooksCopy);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(new ObjectResult(patchOriginalBooksCopy));
}
else
{
return(BadRequest(ModelState));
}
}
public void UpdateBookEmpty()
{
// Arrange
int bookID = 1;
var patchViewModel = new PatchBookViewModel();
var viewModel = MockDataGenerator.CreateBookViewModel(bookID);
var oldDTO = MockDataGenerator.CreateBook(bookID);
var mockBookRepo = new Mock <IBookRepository>();
var mockLoanRepo = new Mock <ILoanRepository>();
var mockMapper = new Mock <IMapper>();
mockBookRepo.Setup(f => f.GetBookByID(bookID)).Returns(oldDTO);
mockBookRepo.Setup(f => f.UpdateBook(bookID, viewModel));
mockMapper.Setup(x => x.Map <PatchBookViewModel, BookViewModel>(patchViewModel)).Returns(viewModel);
var service = new BookService(mockBookRepo.Object, mockLoanRepo.Object, mockMapper.Object);
// Act
service.UpdateBook(bookID, patchViewModel);
// Assert
mockBookRepo.Verify(f => f.GetBookByID(bookID), Times.Once());
mockBookRepo.Verify(f => f.UpdateBook(bookID, viewModel), Times.Once());
mockMapper.Verify(f => f.Map <PatchBookViewModel, BookViewModel>(patchViewModel), Times.Once());
}
/// <summary>
/// ApplyPatching()
/// </summary>
/// <param name="vm"></param>
/// <returns></returns>
public async Task ApplyPatching(PatchBookViewModel vm)
{
BookLoanComparer bookLoanComparer = new BookLoanComparer();
if (vm.books.Count > 0)
{
foreach (BookViewModel book in vm.books)
{
BookLoan.Models.BookViewModel bookoriginal = await _db.Books.
Where(m => m.ID == book.ID).SingleOrDefaultAsync();
if (bookoriginal != null)
{
// If different record then update
if (!bookLoanComparer.Equals(bookoriginal, book))
{
await this.UpdateBook(book.ID, book);
}
}
else
{
// If a new record then insert
if (book.ID == 0)
{
await this.SaveBook(book);
}
}
}
}
}
public IActionResult PartiallyUpdateBook(int bookID, [FromBody] PatchBookViewModel book)
{
if (!ModelState.IsValid)
{
var error = new ErrorDTO
{
Code = 412,
Message = "Validation error. Invalid input"
};
return(StatusCode(error.Code, error));
}
try
{
bookService.UpdateBook(bookID, book);
return(NoContent());
}
catch (NotFoundException ex)
{
var error = new ErrorDTO
{
Code = 404,
Message = ex.Message
};
return(StatusCode(error.Code, error));
}
catch (AlreadyExistsException ex)
{
var error = new ErrorDTO
{
Code = 409,
Message = ex.Message
};
return(StatusCode(error.Code, error));
}
catch (Exception ex)
{
var error = new ErrorDTO
{
Code = 500,
Message = ex.Message
};
return(StatusCode(error.Code, error));
}
}
public void UpdateBook(int bookID, PatchBookViewModel book)
{
try
{
var oldBook = bookRepository.GetBookByID(bookID);
MergeBooksForPatch(book, oldBook);
var newBook = mapper.Map <PatchBookViewModel, BookViewModel>(book);
bookRepository.UpdateBook(bookID, newBook);
}
catch (Exception ex)
{
throw ex;
}
}
private void MergeBooksForPatch(PatchBookViewModel book, BookDTO oldBook)
{
if (string.IsNullOrEmpty(book.Title))
{
book.Title = oldBook.Title;
}
if (string.IsNullOrEmpty(book.Author))
{
book.Author = oldBook.Author;
}
if (string.IsNullOrEmpty(book.ISBN))
{
book.ISBN = oldBook.ISBN;
}
if (!book.PublishDate.HasValue)
{
book.PublishDate = oldBook.PublishDate;
}
}
