public void Add_add_book_properly()
{
//Arrange
BookCategory category = new BookCategory()
{
Title = "dummy-title",
};
context.Manipulate(_ => _.BookCategories.Add(category));
AddBookDto dto = new AddBookDto()
{
Title = "dummy-title",
AgeRange = AgeRange.oneToTen,
CategoryId = category.Id,
};
//Act
int actualReturnedId = sut.Add(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 async Task <IActionResult> AddBook([FromForm] AddBookDto inputModel)
{
var bookAlreadyExisting = await dbContext.Books.Where(b => b.Title == inputModel.Title).SingleOrDefaultAsync();
if (!ModelState.IsValid || bookAlreadyExisting != null)
{
return(StatusCode(StatusCodes.Status406NotAcceptable));
}
var user = await userManager.GetUserAsync(User);
var book = new Book
{
UserId = user.Id,
Title = inputModel.Title,
Description = inputModel.Description,
Year = inputModel.Year
};
using (Stream imageFileStream = inputModel.Cover.OpenReadStream())
{
book.CoverUrl = await imagesService.UploadImageAsync(imageFileStream);
}
dbContext.Books.Add(book);
await dbContext.SaveChangesAsync();
return(StatusCode(StatusCodes.Status201Created));
}
public async Task <Guid> AddBookAsync(AddBookDto dto)
{
using (var unitOfWork = this._unitOfWorkFactory.Create())
{
var newBook = _mapper.Map <Book>(dto);
/*var newBook = new Book
* {
* Isbn = dto.Isbn,
* Isbn13 = dto.Isbn13,
* Title = dto.Title,
* OriginalTitle = dto.OriginalTitle,
* Description = dto.Description,
* Authors = dto.Authors,
* Edition = dto.Edition,
* Publisher = dto.Publisher,
* PublicationDate = dto.PublicationDate,
* Language = dto.Language,
* ImageUrl = dto.ImageUrl,
* LargeImageUrl = dto.LargeImageUrl,
* Pages = dto.Pages,
* GoodreadId = dto.GoodreadId,
* Url = dto.Url,
* EntryDate = dto.EntryDate
* };*/
unitOfWork.BookRepository.Add(newBook);
await unitOfWork.CommitAsync();
return(newBook.Id);
}
}
public async Task <IActionResult> Create([FromBody] AddBookDto payload)
{
ApiResponse <AddBookDto> response = new ApiResponse <AddBookDto>();
try
{
if (!response.Errors.Any())
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
(List <ValidationResult> Result, AddBookDto Book)errorResult = await _bookServ.CreateBook(payload);
if (errorResult.Result.Any())
{
return(BadRequest(new { errorList = $"{errorResult.Result.FirstOrDefault().ErrorMessage}" }));
}
else
{
response.Code = ApiResponseCodes.OK;
response.Description = $"Book creation successful.";
}
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok(response));
}
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 async Task AddBookAsync(AddBookDto addBookDto)
{
Directory.CreateDirectory(ImagesPath);
Directory.CreateDirectory(BookFilesPath);
var imageSaveResult = await SaveAsync(addBookDto.Image, ImagesPath);
var fileSaveResult = await SaveAsync(addBookDto.BookFile, BookFilesPath);
var author = new Author(addBookDto.Author);
_authorRepository.Add(author);
await _unitOfWork.CommitAsync();
var book = new Book(
addBookDto.Name,
author.Id,
addBookDto.GenreId,
imageSaveResult.RelativePath,
fileSaveResult.RelativePath
);
_bookRepository.Add(book);
await _unitOfWork.CommitAsync();
var userBook = new UserBook(book.Id, addBookDto.UserId);
_userBookRepository.Add(userBook);
await _unitOfWork.CommitAsync();
}
public async Task <IActionResult> Create(AddBookDto model)
{
_logger.LogDebug("Attempting to create book resource from @{model}", model);
if (model == null)
{
_logger.LogError("Could not create book resource because the @{model} was null", model);
return(RedirectToAction("Error", "Errors"));
}
if (!ModelState.IsValid)
{
return(View());
}
var book = new Book()
{
Title = model.Title,
Author = model.Author,
Rating = model.Rating,
DateRead = model.DateRead,
Description = model.Description,
ImagePath = null,
DateCreated = DateTime.Now
};
if (model.Image != null)
{
book.ImagePath = _imageService.GenerateImagePath(Path.GetFileName(model.Image.FileName));
}
try
{
if (book.ImagePath != null)
{
if (_imageService.TrySaveAndResizeImage(model.Image, BookImageSize, book))
{
_logger.LogDebug("The @{model.Image} for @{book} was successfully saved and resized", model.Image, book);
}
else
{
_logger.LogError("Failed to create @{book} because the @{model.Image} image was not created", book, model.Image);
ViewBag.CreateImageError = "We were not able to create the book image due to an error, please try again or submit your book entry without the image";
return(View());
}
}
await _bookRepository.CreateAsync(book);
}
catch (Exception ex)
{
_logger.LogError(ex, "Something went wrong while trying to create @{book} resource from @{model}", book, model);
return(RedirectToAction("Error", "Errors"));
}
_logger.LogDebug("Successfully created @{book} resource created from @{model}", book, model);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddBook(AddBookDto book)
{
ServiceResponse <GetBookDto> response = await _bookService.AddBook(book);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public IActionResult Add(AddBookDto dto)
{
if (dto == null || !ModelState.IsValid)
{
return(View());
}
_bookDAL.AddBook(dto);
return(RedirectToAction("Books", "BookInventory", new { Area = ModuleDefiniation.MODULE_NAME }));
}
// When[("یک کتاب با عنوان شازده کوچولو با، دسته سنی بیست به بالا
// و دسته بندی کتاب های رمان تعریف میکنم")]
private void When()
{
AddBookDto dto = new AddBookDto()
{
Title = "شازده کوچولو",
AgeRange = AgeRange.twentyToOlder,
CategoryId = bookCategory.Id
};
actualRecordId = sut.Add(dto);
}
public IActionResult Add(AddBookDto dto)
{
if (dto == null || !ModelState.IsValid)
{
return(View());
}
_bookDAL.AddBook(dto);
return(RedirectToAction("Books", "BookInventory"));
}
public void AddBook_NewBook_ReturnsOk()
{
mockService.Setup(s => s.AddBook(It.IsAny <AddBookDto>()))
.Returns(BookTestData.AddBookServiceResponse());
BookController bookController = new BookController(mockService.Object);
AddBookDto newBook = BookTestData.AddBookDto();
var result = bookController.AddBook(newBook);
Assert.That(result, Is.InstanceOf <OkObjectResult>());
}
public ServiceResponse <List <GetBookDto> > AddBook(AddBookDto book)
{
ServiceResponse <List <GetBookDto> > serviceResponse = new ServiceResponse <List <GetBookDto> >();
Book newBook = mapper.Map <Book>(book);
dataContext.Books.Add(newBook);
dataContext.SaveChanges();
serviceResponse.Data = dataContext.Books.Select(b => mapper.Map <GetBookDto>(b)).ToList();
return(serviceResponse);
}
public int Add(AddBookDto dto)
{
Book book = new Book()
{
Title = dto.Title,
AgeRange = dto.AgeRange,
CategoryId = dto.CategoryId,
};
_bookRepository.Add(book);
_unitOfWork.Complete();
return(book.Id);
}
public async Task <IActionResult> Add(AddBookDto bookDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await bookService.AddBook(bookDto, new CancellationToken());
if (result.Status == ActionStatus.Success)
{
return(Ok(result.Book));
}
return(BadRequest(result.ErrorMessage));
}
public async Task <IActionResult> AddAsync([FromBody] AddBookDto addItem, CancellationToken cancellationToken)
{
if (await this._bookService.CheckExistsAsync(addItem.Isbn))
{
return(StatusCode(StatusCodes.Status409Conflict, new ErrorDetailDto("Duplicate book detected")));
}
if (await this._bookService.AddAsync(addItem, cancellationToken))
{
return(StatusCode(StatusCodes.Status200OK));
}
return(StatusCode(StatusCodes.Status400BadRequest, new ErrorDetailDto("Cannot add book")));
}
public void GetAllBooks_ReturnsOk()
{
mockService.Setup(s => s.GetAllBooks())
.Returns(BookTestData.GetAllBooksServiceResponse());
BookController bookController = new BookController(mockService.Object);
AddBookDto newBook = BookTestData.AddBookDto();
bookController.AddBook(newBook);
var result = bookController.Get();
Assert.That(result, Is.InstanceOf <OkObjectResult>());
}
public void AddBook(AddBookDto dto)
{
var sql = @"INSERT INTO Book(BookId, BookName, ISBN, DateIssued, Description)
VALUES(@id, @bookName, @isbn, @dateIssued, @description)";
_dbConnection.Execute(sql, new
{
id = Guid.NewGuid(),
bookName = dto.BookName,
isbn = dto.ISBN,
dateIssued = dto.DateIssued,
description = dto.Description
});
}
public void AddBook_NewBook_ReturnsOk()
{
dbContext.Database.EnsureDeleted();
dbContext.Database.EnsureCreated();
AddBookDto newBook = GetAddBookDto();
BookService bookService = new BookService(mapper, dbContext);
BookController bookController = new BookController(bookService);
var result = bookController.AddBook(newBook);
Assert.That(result, Is.InstanceOf <OkObjectResult>());
}
public async Task <int> AddBook(AddBookDto dto)
{
Book book = new Book
{
Name = dto.Name,
MinAgeNeed = dto.MinAgeNeed,
Author = dto.Author,
BookCategoryId = dto.CategoryId,
};
_repository.Add(book);
await _unitOfWork.Complete();
return(book.Id);
}
public void GetBookById_ExistingBook_ReturnsOk()
{
mockService.Setup(s => s.AddBook(It.IsAny <AddBookDto>()))
.Returns(BookTestData.AddBookServiceResponse());
mockService.Setup(s => s.GetBookById(It.IsAny <int>()))
.Returns(BookTestData.GetSingleBookServiceResponse());
BookController bookController = new BookController(mockService.Object);
AddBookDto newBook = BookTestData.AddBookDto();
bookController.AddBook(newBook);
var result = bookController.GetSingleBook(1);
Assert.That(result, Is.InstanceOf <OkObjectResult>());
}
public async Task AddBookAsync()
{
IFormFileCollection files = Request.Form.Files;
AddBookDto draftDddBookDto = JsonConvert.DeserializeObject <AddBookDto>(Request.Form["data"]);
var addBookDto = new Application.AppServices.Dtos.AddBookDto
{
Author = draftDddBookDto.Author,
GenreId = draftDddBookDto.GenreId,
Name = draftDddBookDto.Name,
BookFile = await FormFileAdapter.CreateAsync(files[0]),
Image = await FormFileAdapter.CreateAsync(files[1]),
UserId = UserId
};
await _bookService.AddBookAsync(addBookDto);
}
public void DeleteBook_ExistingBook_ReturnsGetBookDtoList()
{
AddBookDto newBook = BookTestData.AddBookDto();
mapperMock.Setup(m => m.Map <Book>(It.IsAny <AddBookDto>())).Returns(BookTestData.Book());
mapperMock.Setup(m => m.Map <GetBookDto>(It.IsAny <Book>())).Returns(BookTestData.BookMapping());
BookService bookService = new BookService(mapperMock.Object, dbContextMock.Object);
ServiceResponse <List <GetBookDto> > addBookResponse = bookService.AddBook(newBook);
GetBookDto addedBook = addBookResponse.Data.First();
ServiceResponse <List <GetBookDto> > deleteBookResponse = bookService.DeleteBook(addedBook.Id);
Assert.That(deleteBookResponse.Success, Is.EqualTo(true));
Assert.That(deleteBookResponse, Is.InstanceOf <ServiceResponse <List <GetBookDto> > >());
Assert.That(deleteBookResponse.Data, Is.InstanceOf <List <GetBookDto> >());
}
public async Task <ServiceResponse <GetBookDto> > AddBook(AddBookDto newBook)
{
ServiceResponse <GetBookDto> serviceResponse = new ServiceResponse <GetBookDto>();
try
{
var entity = _mapper.Map <Book>(newBook);
_context.Books.Add(entity);
_context.SaveChanges();
serviceResponse.Data = _mapper.Map <GetBookDto>(entity);
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = (ex.InnerException != null) ? ex.InnerException.Message : ex.Message;
}
return(serviceResponse);
}
public async Task <ServiceResponse <List <GetBookDto> > > AddBook(AddBookDto newBook)
{
ServiceResponse <List <GetBookDto> > response = new ServiceResponse <List <GetBookDto> >();
Book dbBook = _mapper.Map <Book>(newBook);
dbBook.ElementCategory = await _context.Categories.FirstOrDefaultAsync(c => c.Id == dbBook.CategoryId);
await _context.Books.AddAsync(dbBook);
await _context.SaveChangesAsync();
response.Data = _context.Books
.Include(c => c.ElementCategory)
.Select(b => _mapper.Map <GetBookDto>(b))
.ToList();
return(response);
}
public async Task <IActionResult> CreateBook([FromBody] AddBookDto model)
{
var book = _mapper.Map <Book>(model);
try
{
if (!await _manager.CreateBook(book))
{
return(Ok(new JsonMessageResult("Fail", 0, null)));
}
return(CreatedAtAction(nameof(GetBook), new { book.Id }, book));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(Ok(new JsonMessageResult("Fail", 0, null)));
}
}
public void DeleteBook_ExistingBook_ReturnsGetBookDtoList()
{
dbContext.Database.EnsureDeleted();
dbContext.Database.EnsureCreated();
AddBookDto newBook = GetAddBookDto();
BookService bookService = new BookService(mapper, dbContext);
ServiceResponse <List <GetBookDto> > addBookResponse = bookService.AddBook(newBook);
GetBookDto addedBook = addBookResponse.Data.First();
ServiceResponse <List <GetBookDto> > deleteBookResponse = bookService.DeleteBook(addedBook.Id);
Assert.That(deleteBookResponse.Success, Is.EqualTo(true));
Assert.That(deleteBookResponse, Is.InstanceOf <ServiceResponse <List <GetBookDto> > >());
Assert.That(deleteBookResponse.Data, Is.InstanceOf <List <GetBookDto> >());
Assert.That(deleteBookResponse.Data.Count, Is.EqualTo(0));
}
public void AddBook_NewBook_ReturnsGetBookDtoList()
{
mapperMock.Setup(m => m.Map <Book>(It.IsAny <AddBookDto>())).Returns(BookTestData.Book());
mapperMock.Setup(m => m.Map <GetBookDto>(It.IsAny <Book>())).Returns(BookTestData.GetBookDto());
AddBookDto newBook = BookTestData.AddBookDto();
BookService bookService = new BookService(mapperMock.Object, dbContextMock.Object);
ServiceResponse <List <GetBookDto> > addBookResponse = bookService.AddBook(newBook);
GetBookDto savedBook = addBookResponse.Data.First();
Assert.That(addBookResponse.Success, Is.EqualTo(true));
Assert.That(addBookResponse, Is.InstanceOf <ServiceResponse <List <GetBookDto> > >());
Assert.That(addBookResponse.Data, Is.InstanceOf <List <GetBookDto> >());
Assert.That(addBookResponse.Data.Count, Is.EqualTo(2));
Assert.That(savedBook, Is.InstanceOf <GetBookDto>());
Assert.That(savedBook.Name, Is.EqualTo(newBook.Name));
Assert.That(savedBook.Author, Is.EqualTo(newBook.Author));
}
public void GetAllBooks_GetAll_ReturnsGetBookDtoList()
{
dbContext.Database.EnsureDeleted();
dbContext.Database.EnsureCreated();
AddBookDto firstBook = GetAddBookDto();
AddBookDto secondBook = GetAnotherAddBookDto();
BookService bookService = new BookService(mapper, dbContext);
bookService.AddBook(firstBook);
bookService.AddBook(secondBook);
ServiceResponse <List <GetBookDto> > getAllBooksResponse = bookService.GetAllBooks();
Assert.That(getAllBooksResponse.Success, Is.EqualTo(true));
Assert.That(getAllBooksResponse, Is.InstanceOf <ServiceResponse <List <GetBookDto> > >());
Assert.That(getAllBooksResponse.Data, Is.InstanceOf <List <GetBookDto> >());
Assert.That(getAllBooksResponse.Data.Count, Is.EqualTo(2));
}
public async Task <BookDto> AddBookAsync(AddBookDto addBook)
{
var bookEntity = _unitOfWork.Books.Add(_mapper.Map <AddBookDto, Book>(addBook));
string uploadsFolder = @"E:\me\epam\EpamBookShop\src\BookShopClient\src\assets\images\";
string uniqueFileName = Guid.NewGuid().ToString() + "_" + addBook.Image.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
addBook.Image.CopyTo(fileStream);
}
bookEntity.ImageUrl = "~/images/" + uniqueFileName;
var bookAuthors = new List <BookAuthor>()
{
new BookAuthor()
{
AuthorId = addBook.AuthorId,
Book = bookEntity
}
};
_unitOfWork.BookAuthors.AddRange(bookAuthors);
var bookCategories = new List <BookCategory>()
{
new BookCategory()
{
CategoryId = addBook.CategoryId,
Book = bookEntity
}
};
_unitOfWork.BookCategories.AddRange(bookCategories);
await _unitOfWork.CommitAsync();
return(_mapper.Map <Book, BookDto>(bookEntity));
}
