public BaseResponse <BookOutputDto> CreateBook(BookInputDto bookInputDto)
{
if (Contains(x => x.Name.Equals(bookInputDto.Name, StringComparison.InvariantCultureIgnoreCase)))
{
throw new BadRequestException($"Tác phẩm {bookInputDto.Name} đã tồn tại");
}
var book = Mapper.Map <Book>(bookInputDto);
book = Create(book, out var isSaved);
if (!isSaved)
{
throw new BadRequestException($"Không thể tạo tác phẩm {book.Name}");
}
var bookCategories = _bookCategoryService.CreateMany(bookInputDto.CategoryIds.Select(categoryId =>
new BookCategory
{
BookId = book.Id,
CategoryId = Guid.Parse(categoryId)
}), out isSaved);
if (!isSaved)
{
throw new BadRequestException($"Không thể set category cho tác phẩm {book.Name}");
}
book.BookCategories = bookCategories as ICollection <BookCategory>;
return(new BaseResponse <BookOutputDto>(HttpStatusCode.OK, data: Mapper.Map <BookOutputDto>(book)));
}
public IActionResult CreateBookForAuthor(Guid authorId, [FromBody] BookInputDto bookInputDto)
{
if (bookInputDto == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
// return 422
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!_authorAppService.AuthorExists(authorId))
{
return(NotFound());
}
var result = _bookAppService.AddBookForAuthor(authorId, bookInputDto);
if (!result.sucess)
{
throw new Exception($"Creating a book for author {authorId} failed on save.");
}
var bookToReturn = _mapper.Map <BookOutputDto>(bookInputDto);
bookToReturn.Id = result.id;
bookToReturn.AuthorId = authorId;
return(CreatedAtRoute("GetBookForAuthor",
new { authorId = bookToReturn.AuthorId, id = bookToReturn.Id },
CreateLinksForBook(bookToReturn)));
}
public ActionResult <BookOutputDto> Post([FromBody] BookInputDto bookInputDto)
{
var bookToBeAdded = _mapper.Map <Book>(bookInputDto);
var bookAdded = _booksRepository.Insert(bookToBeAdded);
var bookAddedOutputDto = _mapper.Map <BookOutputDto>(bookAdded);
return(StatusCode((int)HttpStatusCode.Created, bookAddedOutputDto));
}
public void WhenAddBook_ReturnsSuccess(BookInputDto input)
{
_userRepository.Setup(m => m.GetOne(It.IsAny <int>())).Returns(new EUser());
_bookRepository.Setup(m => m.CreateEntity(It.IsAny <EBook>())).Returns(new EBook());
_bookServiceApplication = new BookServiceApplication(_bookRepository.Object, _userRepository.Object);
bool result = _bookServiceApplication.AddBook(input);
Assert.True(result);
}
public bool Add(BookInputDto book)
{
try
{
_bookService.Add(_mapper.Map <BookInputDto, Book>(book));
return(Commit());
}
catch (Exception)
{
throw;
}
}
public ActionResult <BookOutputDto> Put(long id, [FromBody] BookInputDto bookInputDto)
{
var bookToBeUpdated = _booksRepository.Get(id);
bookToBeUpdated.Author = bookInputDto.Author;
bookToBeUpdated.Description = bookInputDto.Description;
bookToBeUpdated.Title = bookInputDto.Title;
var updatedBook = _booksRepository.Update(bookToBeUpdated);
var updatedBookDto = _mapper.Map <BookOutputDto>(updatedBook);
return(Ok(updatedBookDto));
}
public (bool sucess, Guid id) AddBookForAuthor(Guid authorId, BookInputDto book)
{
try
{
var bookEntity = _mapper.Map <BookInputDto, Book>(book);
_bookService.AddBookForAuthor(authorId, bookEntity);
return(Commit(), bookEntity.Id);
}
catch (Exception)
{
throw;
}
}
public void Map_Book_Input()
{
//Arrange
var sut = _mapperConfiguration.CreateMapper();
var bookInputDto = new BookInputDto
{
Title = "Harry Potter",
Description = "He is a wizard!",
Author = "J.K. Rowling"
};
//Act
var book = sut.Map <Book>(bookInputDto);
//Assert
Assert.That(book.Id, Is.EqualTo(0));
Assert.That(book.Title, Is.EqualTo(bookInputDto.Title));
Assert.That(book.Description, Is.EqualTo(bookInputDto.Description));
Assert.That(book.Author, Is.EqualTo(bookInputDto.Author));
}
public BaseResponse <bool> UpdateBook(Guid id, BookInputDto bookInputDto)
{
var oldBook = Find(id);
var newBook = Mapper.Map <Book>(bookInputDto);
if (oldBook == null)
{
throw new BadRequestException($"Không tìm thấy tác phẩm {id}");
}
oldBook = UpdateBookInformation(oldBook, newBook, out var isSaved);
oldBook = UpdateBookCategories(oldBook, bookInputDto.CategoryIds.Select(Guid.Parse).ToList(), ref isSaved);
if (!isSaved)
{
throw new InternalServerErrorException($"Không thể update cho tác phẩm {oldBook.Name}");
}
return(new BaseResponse <bool>(HttpStatusCode.OK, data: true));
}
public IActionResult CreateBookForAuthor(Guid authorId,
[FromBody] BookInputDto book)
{
if (book == null)
{
return(BadRequest());
}
if (book.Description == book.Title)
{
ModelState.AddModelError(nameof(BookInputDto),
"The provided description should be different from the title.");
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!_libraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var newBook = AutoMapper.Mapper.Map <Book>(book);
_libraryRepository.AddBookForAuthor(authorId, newBook);
if (!_libraryRepository.Save())
{
throw new Exception($"Creating a book for auhtor {authorId} failed on save.");
}
var bookToReturn = AutoMapper.Mapper.Map <BookDto>(newBook);
return(CreatedAtRoute("GetBookForAuthor",
new { authorId = authorId, id = bookToReturn.Id },
bookToReturn));
}
/// <summary>
/// Adds the book.
/// </summary>
/// <param name="input">The input.</param>
/// <returns>boolean</returns>
public bool AddBook(BookInputDto input)
{
var user = _userRepository.GetOne(input.UserId);
var book = new EBook
{
SkinType = input.SkinType == 0 ? SkinType.Ciltli : SkinType.Ciltsiz,
Name = input.Name.Trim(),
SeriesId = input.Serie == 0 ? (int?)null : input.Serie,
AuthorId = input.Author,
CreatedDateTime = DateTime.Now,
PublishDate = input.PublishDate,
PublisherId = input.Publisher,
GenreId = input.Genre,
ShelfId = input.Shelf,
RackId = input.Rack
};
if (!String.IsNullOrEmpty(input.No))
{
book.No = int.TryParse(input.No, out int no) ? no : input.No.RomanToInteger();
}
else
{
book.No = null;
}
book.Users.Add(user);
var newRecord = _bookRepository.CreateEntity(book);
return(newRecord != null);
}
public async Task CreateBook([FromBody] BookInputDto input)
{
var book = _mapper.Map <Book>(input);
await _bookManager.InsertAsync(book);
}
public BaseResponse <bool> UpdateBook(Guid id, [FromBody] BookInputDto bookInputDto)
{
return(_bookService.UpdateBook(id, bookInputDto));
}
public BaseResponse <BookOutputDto> CreateBook([FromBody] BookInputDto bookInputDto)
{
return(_bookService.CreateBook(bookInputDto));
}
