public async Task <ServiceResponse <GetBookDto> > UpdateBook(UpdateBookDto updatedBook)
{
ServiceResponse <GetBookDto> response = new ServiceResponse <GetBookDto>();
try
{
Book dbBook = await _context.Books.FirstOrDefaultAsync(b => b.Id == updatedBook.Id);
dbBook.ElementName = updatedBook.ElementName;
dbBook.Description = updatedBook.Description;
dbBook.Finished = updatedBook.Finished;
dbBook.PublishedDate = updatedBook.PublishedDate;
dbBook.PagesNumber = updatedBook.PagesNumber;
dbBook.Publisher = updatedBook.Publisher;
dbBook.CategoryId = updatedBook.CategoryId;
dbBook.Author = updatedBook.Author;
dbBook.ElementCategory = await _context.Categories.FirstOrDefaultAsync(c => c.Id == dbBook.CategoryId);
_context.Books.Update(dbBook);
await _context.SaveChangesAsync();
response.Data = _mapper.Map <GetBookDto>(dbBook);
}
catch (Exception ex)
{
response.Sucess = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <IActionResult> UpdateBook(Guid id, UpdateBookDto dto)
{
if (id != dto.Id)
{
return(BadRequest("The ID in the url doesn't match the ID in the request"));
}
var book = _dbContext.Books.FirstOrDefault(book => book.Id == id);
if (book == null)
{
return(BadRequest($"Book with ID {id} doesn't exist in the database"));
}
_mapper.Map(dto, book);
try
{
await _dbContext.SaveChangesAsync();
}
catch (Exception)
{
throw;
}
return(NoContent());
}
public async Task GivenValidData_WhenUpdateBook_ThenReturnUpdatedRecord()
{
// arrange
const int bookId = 1;
var updateBook = new UpdateBookDto
{
Title = "Updated book",
Author = "John Doe",
Category = "Fantasy"
};
// act
var result = await _controller.UpdateBook(bookId, updateBook);
// assert
result.ShouldNotBeNull();
result.BookId.ShouldBe(1);
result.Author.ShouldNotBeNull();
result.Author.ShouldBe("John Doe");
result.Title.ShouldNotBeNull();
result.Title.ShouldBe("Updated book");
result.Category.ShouldNotBeNull();
result.Category.ShouldBe("Fantasy");
_mockService.Verify(x => x.UpdateBook(It.IsAny <int>(), It.IsAny <UpdateBookDto>()), Times.Once());
}
public void Update_update_book_properly()
{
//Arrange
BookCategory category = new BookCategory()
{
Title = "dummy-category-title",
};
context.Manipulate(_ => _.BookCategories.Add(category));
Book book = new Book()
{
Title = "dummy-title",
AgeRange = AgeRange.oneToTen,
CategoryId = category.Id,
};
context.Manipulate(_ => _.Books.Add(book));
UpdateBookDto dto = new UpdateBookDto()
{
Title = "dummy-book-title",
AgeRange = AgeRange.oneToTen,
CategoryId = category.Id,
};
//Act
int actualReturnedId = sut.Update(book.Id, dto);
//Assert
var expected = readContext.Books.Single(_ => _.Id == actualReturnedId);
expected.Title.Should().Be(dto.Title);
expected.AgeRange.Should().Be(dto.AgeRange);
expected.CategoryId.Should().Be(dto.CategoryId);
}
public ActionResult UpdateBook(int id, UpdateBookDto updateBook)
{
var bookFromRepo = _repository.GetBookById(id);
if (bookFromRepo is null)
{
return(NotFound());
}
//refatorar em um atualizador de livros
var bookByTitle = _repository.GetBookByTitle(updateBook.Title);
if (!(bookByTitle is null))
{
if (!bookByTitle.Equals(bookFromRepo))
{
ModelState.AddModelError("duplicate", $"{updateBook.Title} already exists");
return(ValidationProblem(ModelState));
}
}
bookFromRepo.Title = updateBook.Title;
_repository.UpdateBook(bookFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public ServiceResponse <GetBookDto> UpdateBook(UpdateBookDto updateBook)
{
ServiceResponse <GetBookDto> serviceResponse = new ServiceResponse <GetBookDto>();
try
{
Book foundBook = dataContext.Books.FirstOrDefault(b => b.Id == updateBook.Id);
foundBook.Name = updateBook.Name;
foundBook.Description = updateBook.Description;
foundBook.Author = updateBook.Author;
foundBook.Price = updateBook.Price;
foundBook.CategoryId = updateBook.CategoryId;
dataContext.Books.Update(foundBook);
dataContext.SaveChanges();
serviceResponse.Data = mapper.Map <GetBookDto>(foundBook);
serviceResponse.Message = "Book updated successfully";
}
catch (Exception)
{
serviceResponse.Success = false;
serviceResponse.Message = "Requested book not found";
}
return(serviceResponse);
}
public IActionResult UpdateBookForAuthor(Guid authorId, Guid id, [FromBody] UpdateBookDto book)
{
if (book == null)
{
return(BadRequest());
}
if (!this.repository.AuthorExists(authorId))
{
return(NotFound());
}
var bookEntity = this.repository.GetBookForAuthor(authorId, id);
if (bookEntity == null)
{
return(NotFound());
}
Mapper.Map(book, bookEntity);
this.repository.UpdateBookForAuthor(bookEntity);
if (!this.repository.Save())
{
throw new Exception($"Updating book {id} for author {authorId} failed");
}
return(NoContent());
}
public async Task Test3()
{
// arrange
Seeder.SeedDatabase(_context);
const int firstBookId = 1;
var bookToUpdate = new UpdateBookDto()
{
Title = "title updated",
Author = "author updated",
Category = "category updated"
};
// act
var result = await _bookRepository.UpdateBook(firstBookId, bookToUpdate);
// assert
result.ShouldNotBeNull();
result.BookId.ShouldBe(firstBookId);
result.Author.ShouldNotBeNull();
result.Author.ShouldBe(bookToUpdate.Author);
result.Title.ShouldNotBeNull();
result.Title.ShouldBe(bookToUpdate.Title);
result.Category.ShouldNotBeNull();
result.Category.ShouldBe(bookToUpdate.Category);
await _context.Database.EnsureDeletedAsync();
}
public async Task <bool> UpdateBook(Guid id, UpdateBookDto model, string fields)
{
var book = await _service.Query(id, false);
book.UpdateTime = DateTime.Now;
return(await _service.Update(CommonClass.SetModelValue(model, book, fields)));
}
public async void UpdateBook_ShouldReturnNoContent()
{
var getAllBooksResponse = await _httpClient.GetAsync("api/Book");
var books = await DeserializeJson <ViewBookDto[]>(getAllBooksResponse);
var oldBook = books[2];
var dto = new UpdateBookDto
{
Id = oldBook.Id,
//Title = oldBook.Title,
Author = "J.R. Tolkien",
//Edition = oldBook.Edition,
//Price = oldBook.Price,
//YearWritten = oldBook.YearWritten
};
var content = SerializeJson(dto);
var response = await _httpClient.PutAsync($"api/Book/{oldBook.Id}", content);
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
var getBookResponse = await _httpClient.GetAsync($"api/Book/{oldBook.Id}");
var book = await DeserializeJson <ViewBookDto>(getBookResponse);
book.Author.Should().Be("J.R. Tolkien");
}
public async Task <ServiceResult> Update(UpdateBookDto book)
{
try
{
var storedBook = await _unitOfWork.Repository <Book>().GetById(book.Id);
if (storedBook == null)
{
return(Error("There is not such book"));
}
var newBook = new Book
{
Id = storedBook.Id,
Title = book.Title,
Description = book.Description,
Year = book.Year,
Pages = book.Pages
};
_unitOfWork.Repository <Book>().Update(newBook);
await _unitOfWork.SaveAsync();
return(Success());
}
catch
{
return(Error <Book>("Can't update book"));
}
}
public void UpdateBook_ExistingBook_ReturnsGetBookDto()
{
AddBookDto newBook = BookTestData.AddBookDto();
mapperMock.Setup(m => m.Map <Book>(It.IsAny <AddBookDto>())).Returns(BookTestData.Book());
mapperMock.Setup(m => m.Map <UpdateBookDto>(It.IsAny <GetBookDto>())).Returns(BookTestData.AddBookDtoToUpdateBookDtoMapping());
mapperMock.Setup(m => m.Map <GetBookDto>(It.IsAny <Book>())).Returns(BookTestData.AddBookDtoToGetBookDtoMapping());
BookService bookService = new BookService(mapperMock.Object, dbContextMock.Object);
ServiceResponse <List <GetBookDto> > addBookResponse = bookService.AddBook(newBook);
GetBookDto addedBook = addBookResponse.Data.First();
UpdateBookDto updatedBook = mapperMock.Object.Map <UpdateBookDto>(addedBook);
updatedBook.Price = 900;
ServiceResponse <GetBookDto> updatedBookResponse = bookService.UpdateBook(updatedBook);
GetBookDto savedBook = updatedBookResponse.Data;
Assert.That(updatedBookResponse.Success, Is.EqualTo(true));
Assert.That(updatedBookResponse, Is.InstanceOf <ServiceResponse <GetBookDto> >());
Assert.That(savedBook, Is.InstanceOf <GetBookDto>());
Assert.That(savedBook.Price, Is.EqualTo(updatedBook.Price));
}
public IActionResult Put(int id,
[FromBody] UpdateBookDto dto,
[FromServices] IUpdateBookCommand command)
{
dto.Id = id;
_executor.ExecuteCommand(command, dto);
return(NoContent());
}
// When[("مشخصات کتاب با عنوان جنگ جهانی دوم را به، عنوان خلاصه جنگ جهانی دوم تغییر میدهم")]
private void When()
{
UpdateBookDto dto = new UpdateBookDto()
{
Title = "خلاصه جنگ جهانی دوم",
};
actualRecordId = sut.Update(book.Id, dto);
}
public int Update(int id, UpdateBookDto dto)
{
Book theBook = _bookRepository.FindById(id);
theBook.Title = dto.Title;
theBook.AgeRange = dto.AgeRange;
_unitOfWork.Complete();
return(theBook.Id);
}
public async Task <IActionResult> UpdateBook(UpdateBookDto book)
{
ServiceResponse <GetBookDto> response = await _bookService.UpdateBook(book);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public IActionResult UpdateBook(UpdateBookDto updatedBook)
{
ServiceResponse <GetBookDto> response = bookService.UpdateBook(updatedBook);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public void Update(int bookShopId, int bookId, UpdateBookDto updateBookDto)
{
var bookShop = GetBookShopIncludeBooksById(bookShopId);
var book = GetBookFromBookShopById(bookShop, bookId);
book.Description = updateBookDto.Description;
book.Price = updateBookDto.Price;
_dbContext.SaveChanges();
}
public IActionResult UpdateBookForAuthor(Guid authorId, Guid id, [FromBody] UpdateBookDto model)
{
if (model == null)
{
return(BadRequest());
}
if (model.Description == model.Title)
{
ModelState.AddModelError(nameof(UpdateBookDto), "Description should be different from Title.");
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!_libraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var book = _libraryRepository.GetBookForAuthor(authorId, id);
if (book == null)
{
var bookToAdd = Mapper.Map <Book>(model);
bookToAdd.Id = id;
_libraryRepository.AddBookForAuthor(authorId, bookToAdd);
if (!_libraryRepository.Save())
{
throw new Exception($"Upserting book {id} for author {authorId} failed on save.");
}
var addedBook = Mapper.Map <BookDto>(bookToAdd);
return(CreatedAtRoute("GetBookForAuthor", new
{
authorId, id = addedBook.Id
}, addedBook));
}
Mapper.Map(model, book);
_libraryRepository.UpdateBookForAuthor(book);
if (!_libraryRepository.Save())
{
throw new Exception($"Update book {id} for author {authorId} failed on save.");
}
return(NoContent());
}
public IActionResult UpdateBook([FromBody] UpdateBookDto updateBookDto)
{
var updatedBook = _bookService.UpdateBook(updateBookDto);
if (updatedBook == null)
{
return(NotFound("Book or Author with those credentials does not exists, please try again."));
}
return(Ok(updatedBook));
}
/// <inheritdoc />
public async Task <Book> UpdateBook(int id, UpdateBookDto bookToUpdate)
{
var foundBook = await GetBookById(id);
foundBook.Title = bookToUpdate.Title;
foundBook.Author = bookToUpdate.Author;
foundBook.Category = bookToUpdate.Category;
await _context.SaveChangesAsync();
return(foundBook);
}
public async void Update_failed_update_when_book_not_exists()
{
BookCategory bookCategory = BookCategoryFactory.GenerateBookCategory();
_context.Manipulate(_ => _.BookCategories.Add(bookCategory));
UpdateBookDto dto = BookDtoFactory.GenerateUpdateBookDto(bookCategory.Id,
20, "dummy-author", "dummy-name");
Func <Task> expected = () => _sut.UpdateBook(1, dto);
expected.Should().ThrowExactly <FailedBookUpdateWhenBookNotExistsException>();
}
public void UpdateBook_NonExistingBook_ReturnsNotFound()
{
mockService.Setup(s => s.UpdateBook(It.IsAny <UpdateBookDto>()))
.Returns(BookTestData.UpdateBookServiceResponseNullData());
BookController bookController = new BookController(mockService.Object);
UpdateBookDto updatedBook = BookTestData.UpdateBookDto();
var result = bookController.UpdateBook(updatedBook);
Assert.That(result, Is.InstanceOf <NotFoundObjectResult>());
}
public void UpdateBook_NonExistingBook_ReturnsNotFound()
{
dbContext.Database.EnsureDeleted();
dbContext.Database.EnsureCreated();
BookService bookService = new BookService(mapper, dbContext);
BookController bookController = new BookController(bookService);
UpdateBookDto updatedBook = GetUpdateBookDto();
var result = bookController.UpdateBook(updatedBook);
Assert.That(result, Is.InstanceOf <NotFoundObjectResult>());
}
public void UpdateBook_NonExistingBook_ReturnsError()
{
UpdateBookDto updatedBook = BookTestData.UpdateBookDto();
BookService bookService = new BookService(mapperMock.Object, dbContextMock.Object);
ServiceResponse <GetBookDto> updatedBookResponse = bookService.UpdateBook(updatedBook);
GetBookDto savedBook = updatedBookResponse.Data;
Assert.That(updatedBookResponse.Success, Is.EqualTo(false));
Assert.That(updatedBookResponse, Is.InstanceOf <ServiceResponse <GetBookDto> >());
Assert.That(updatedBookResponse.Data, Is.EqualTo(null));
}
public async Task <IActionResult> CreateBookAsybc(int authorId, UpdateBookDto bookDto)
{
var book = mapper.Map <Book>(bookDto);
book.AuthorId = authorId;
repositoryWrapper.Book.Create(book);
if (await repositoryWrapper.Book.SaveAsync())
{
var bookCreate = mapper.Map <BookDto>(book);
return(CreatedAtRoute(nameof(GetBookAsync), new { authorId = bookCreate.AuthorId, bookId = bookCreate.BookId }, bookCreate));
}
return(BadRequest());
}
public async Task <IActionResult> Update(UpdateBookDto updateBookDto)
{
try
{
var updatedBook = await bookService.UpdateAsync(updateBookDto);
return(Ok(updatedBook));
}
catch (NotFoundException)
{
return(NotFound());
}
}
public void UpdateBook(Guid bookId, UpdateBookDto dto)
{
var sql = "UPDATE Book SET BookName=@bookName, ISBN=@isbn, DateIssued=@dateIssued, Description=@description WHERE BookId=@id";
_dbConnection.Execute(sql, new
{
id = bookId,
bookName = dto.BookName,
isbn = dto.ISBN,
dateIssued = dto.DateIssued,
description = dto.Description
});
}
public async Task <BookDto> UpdateBookAsync(int id, UpdateBookDto updateBook)
{
var bookEntity = await _unitOfWork.Books.FindAsync(id);
_mapper.Map(updateBook, bookEntity);
if (updateBook.Image != null)
{
string uploadsFolder = @"E:\me\epam\EpamBookShop\src\BookShopClient\src\assets\images";
System.IO.File.Delete(String.Concat(uploadsFolder, updateBook.ExistingImagePath.Substring(10)));
string uniqueFileName = Guid.NewGuid().ToString() + "_" + updateBook.Image.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
updateBook.Image.CopyTo(fileStream);
}
bookEntity.ImageUrl = "~/images/" + uniqueFileName;
}
else
{
bookEntity.ImageUrl = updateBook.ExistingImagePath;
}
var bookAuthors = new List <BookAuthor>()
{
new BookAuthor()
{
AuthorId = updateBook.AuthorId,
Book = bookEntity
}
};
_unitOfWork.BookAuthors.AddRange(bookAuthors);
var bookCategories = new List <BookCategory>()
{
new BookCategory()
{
CategoryId = updateBook.CategoryId,
Book = bookEntity
}
};
_unitOfWork.BookCategories.AddRange(bookCategories);
await _unitOfWork.CommitAsync();
return(_mapper.Map <Book, BookDto>(bookEntity));
}
public async Task <IActionResult> Update(long id, [FromBody] UpdateBookDto bookDto)
{
var location = GetControllerActionNames();
try
{
_logger.LogInfo(GenerateLogMessage(location, MESSAGE_UPDATE_ATTEMPTED, id));
if (id < 0 || bookDto == null)
{
_logger.LogError(GenerateLogMessage(location, MESSAGE_UPDATE_BAD_DATA, id));
return(BadRequest());
}
if (!ModelState.IsValid)
{
_logger.LogError(GenerateLogMessage(location, MESSAGE_UPDATE_BAD_DATA, id));
return(BadRequest());
}
if (!await _bookRepository.IsInDatabase(id))
{
_logger.LogError(GenerateLogMessage(location, MESSAGE_UPDATE_ID_NOT_FOUND, id));
return(BadRequest());
}
//var book = _mapper.Map<Book>(bookDto);
// Update values passed to objects dto, null properties are replaced by the current value of each property
var book = await _bookRepository.FindById(id);
book.Image = bookDto.Image ?? book.Image;
book.Title = bookDto.Title ?? book.Title;
book.Price = bookDto.Price ?? book.Price;
book.Summary = bookDto.Summary ?? book.Summary;
var isSuccess = await _bookRepository.Update(book);
if (isSuccess)
{
_logger.LogInfo(GenerateLogMessage(location, MESSAGE_UPDATE_SUCCESSFUL, id));
return(NoContent());
}
_logger.LogError(GenerateLogMessage(location, MESSAGE_UPDATE_FAILED));
return(BadRequest());
}
catch (Exception e)
{
return(InternalError(GenerateLogMessage(location, e)));
}
}
