public void Create(CreateBookDto dto)
{
if (string.Equals(dto?.Author, "lemon", StringComparison.Ordinal))
{
DataState?.Errors?.Add(new DataValidationError("Author", "lemon向阁下问好！"));
}
}
public async Task Test2()
{
// arrange
Seeder.SeedDatabase(_context);
var bookToCreate = new CreateBookDto
{
Title = "test title",
Author = "test author",
Category = "test category"
};
// act
var result = await _bookRepository.CreateBook(bookToCreate);
// assert
result.ShouldNotBeNull();
result.BookId.ShouldBePositive();
result.Author.ShouldNotBeNull();
result.Author.ShouldBe(bookToCreate.Author);
result.Title.ShouldNotBeNull();
result.Title.ShouldBe(bookToCreate.Title);
result.Category.ShouldNotBeNull();
result.Category.ShouldBe(bookToCreate.Category);
await _context.Database.EnsureDeletedAsync();
}
public ActionResult <Book> AddBook([FromBody] CreateBookDto createBookDto)
{
Book book = _mapper.Map <Book>(createBookDto);
_bookRepository.AddBook(book);
return(CreatedAtRoute(nameof(GetBookById), new { book.Id }, book));
}
public IActionResult CreateBooksForAuthor(Guid authorId, [FromBody] CreateBookDto book)
{
if (book == null)
{
return(NotFound());
}
if (string.Equals(book.Description, book.Description, StringComparison.InvariantCultureIgnoreCase))
{
ModelState.AddModelError(nameof(CreateBookDto), "The provider description should be different from the title");
}
if (!ModelState.IsValid)
{
return(new Helpers.UnprocessableEntityObjectResult(ModelState));
}
if (!libraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var bookEntity = Mapper.Map <Book>(book);
libraryRepository.AddBookForAuthor(authorId, bookEntity);
if (!libraryRepository.Save())
{
throw new Exception($"Creating a book for author {authorId} faild on save");
}
var bookToReturn = Mapper.Map <BookDto>(bookEntity);
return(CreatedAtRoute("GetBookForAuthor", new { authorId, id = bookToReturn.Id }, bookToReturn));
}
public void Execute(CreateBookDto request)
{
_validator.ValidateAndThrow(request);
var book = new Book
{
Description = request.Description,
Price = request.Price,
Title = request.Title,
GenreId = request.GenreId,
PublisherId = request.PublisherId,
Year = request.Year
};
//add into AuthorBook
foreach (var item in request.BookAuthors)
{
book.BookAuthors.Add(new BookAuthor
{
AuthorId = item.Id,
BookId = book.Id
});
}
_context.Books.Add(book);
_context.SaveChanges();
}
public async Task AddBook(CreateBookDto model)
{
try
{
_unitOfWork.BeginTransaction();
var bookEntity = new Book
{
Isbn = model.Isbn,
Author = model.Author,
Title = model.Title,
Year = model.Year,
Publisher = model.Publisher,
CreationTime = DateTime.UtcNow,
LastModifiedTime = DateTime.UtcNow
};
await _bookRepository.InsertAsync(bookEntity);
_unitOfWork.Commit();
}
catch (Exception e)
{
_unitOfWork.Rollback();
throw new Exception(e.Message);
}
}
public async Task <ReadBookDto> CreateBook(CreateBookDto request)
{
Book book = _mapper.Map <Book>(request);
var task = await _context.Books.AddAsync(book);
ReadBookDto response = _mapper.Map <ReadBookDto>(task.Entity);
return(response);
}
public async Task <ActionResult> CreateBook([FromBody] CreateBookDto createBookDto, CancellationToken ct)
{
var bookToReturn = await _bookService.CreateBookAsync(createBookDto, ct);
if (bookToReturn == null)
{
return(BadRequest());
}
return(CreatedAtRoute("GetBook", new { id = bookToReturn.Id }, bookToReturn));
}
public async Task <IActionResult> Create(CreateBookDto request)
{
if (!ModelState.IsValid)
{
return(View(request));
}
var response = await _bookService.CreateBook(request);
await _bookService.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Put([FromBody] CreateBookViewModel model, long id)
{
var createBookDto = new CreateBookDto
{
Isbn = model.Isbn,
Author = model.Author,
Title = model.Title,
Year = model.Year,
Publisher = model.Publisher
};
await _bookService.UpdateBook(createBookDto, id);
return(Ok("Updated successfully"));
}
