public async Task <Response <bool> > Handle(AddBookCommand request, CancellationToken cancellationToken)
{
var uploadedBookPhotosData = await fileManager.AddMultipleFileAsync(request.BookPhotos, FileTypeEnum.BookPhoto);
var uploadedBookFileData = await fileManager.AddFileAsync(request.BookFile, FileTypeEnum.BookFile);
var book = new Book
{
publishDate = request.PublishedDate,
BookName = request.BookName,
AuthorId = request.Userid,
Price = request.Price,
Category = (BookCategoryEnum)request.Category,
Description = request.Description,
File = new File {
Url = uploadedBookFileData.Url,
Path = uploadedBookFileData.Path
},
Imgs = uploadedBookPhotosData.Select(u => new Img {
Url = u.Url,
Path = u.Path
}).ToList()
};
await bookRepo.AddAsync(book);
return(Response.Ok());
}
public async void HandleAddBookCommand_WithCorrectParameters_ShouldReturnNoErrors()
{
//Arrange
TestBaseArrangements baseArrangements = new TestBaseArrangements();
#region .:: Objects build ::.
AddBookCommand addBookCommand = new AddBookCommand("Pet Sematary", 2013, 1, "9788581050393", Guid.NewGuid().ToString());
Author author = new Author(Guid.NewGuid(), "Stephen King");
Book book = new Book(Guid.NewGuid(), "Pet Sematary", 2013, 1, "9788581050393", author);
#endregion
#region .:: Mocks ::.
baseArrangements.Mocker.GetMock <IAuthorRepository>()
.Setup(b => b.GetAuthorById(It.IsAny <Guid>()))
.Returns(() => Task.FromResult <Author>(author));
baseArrangements.Mocker.GetMock <IBookRepository>()
.Setup(b => b.AddBook(It.IsAny <Book>()))
.Returns(() => Task.FromResult(book));
#endregion
var sut = baseArrangements.Mocker.CreateInstance <AddBookCommandHandler>();
//Act
AddBookCommandResponseViewModel result = await sut.Handle(addBookCommand, new CancellationToken());
//Assert
baseArrangements.DomainNotifications.GetAll().Should().BeEmpty();
baseArrangements.Mocker.GetMock <IAuthorRepository>().Verify(x => x.GetAuthorById(It.IsAny <Guid>()), Times.Once());
baseArrangements.Mocker.GetMock <IBookRepository>().Verify(x => x.AddBook(It.IsAny <Book>()), Times.Once());
}
public Book AddBook(AddBookCommand newBook)
{
using (var db = new SqlConnection(_connectionString))
{
db.Open();
var sql = @"insert into [dbo].[Book]
([Title]
,[Author]
,[ImageURL]
,[GoodReadsBookId]
,[UserId]
,[DateCompleted]
)
output inserted.*
values (
@title
,@author
,@imageURL
,@goodReadsBookId
,@userId
,@dateCompleted)";
return(db.QueryFirst <Book>(sql, newBook));
}
}
public async Task <IActionResult> AddBook(AddBookModel vm)
{
var command = new AddBookCommand(vm.AuthorId, vm.Title);
var result = await _mediator.Send(command);
return(result.Match <IActionResult>(data => RedirectToAction("Book", new { bookId = data }),
errors => RedirectToAction("AddBook", new { message = "There were errors" })));
}
public BookCreationVM(IBookManager _bookManager, IValidation _validation)
{
bookManager = _bookManager;
validation = _validation;
NewBook = new Book();
CreateBookCommand = new AddBookCommand(this);
}
public async Task <IActionResult> AddBookCommand([FromBody] AddBookCommand command)
{
_logger.LogInformation("Adding book {0}", command.Name);
await _mediator.DispatchAsync(command);
_logger.LogInformation("Book {0} successfully added", command.Name);
return(Ok());
}
public async Task <ActionResult <BookModel> > AddBook([FromBody] AddBookCommand command)
{
var book = await _mediator.Send(command);
var bookUrl = Url.Action(nameof(GetBook), new { bookId = book.Id });
return(Created(bookUrl, book));
}
public BookListViewModel()
{
AddBookCommand = new AddBookCommand(Storage.Logger);
CloseCommand = new CloseBookListCommand(this, Storage.Logger);
RefreshCorrectCommand = new RefreshBookListCorrectCommand(this, Storage.Logger);
RefreshErrorCommand = new RefreshBookListErrorCommand(this, Storage.Logger);
RefreshCriticalFailCommand = new RefreshBookListCriticalFailCommand(this, Storage.Logger);
Books = new ObservableCollection<Book>();
}
public IActionResult AddBook(AddBookCommand newBook)
{
var repo = new BookRepository();
var bookAdded = repo.AddBook(newBook);
if (bookAdded != null)
{
return(Ok(newBook));
}
return(BadRequest($"Unable to add book with title: {newBook.Title}."));
}
private async void LoadBooks()
{
var books = await _booksService.GetBooksAsync();
_books.Clear();
foreach (var book in books)
{
_books.Add(book);
}
_booksLoaded = true;
AddBookCommand.OnExecuteChanged();
}
public async Task <ActionResult <RegBookResponseObj> > Create([FromBody] AddBookRequestObj requestObj)
{
AddBookCommand command = _mapper.Map <AddBookCommand>(requestObj);
var response = await _mediator.Send(command);
if (response.BookId < 1 || !response.Status.IsSuccessful)
{
return(BadRequest(response));
}
var locatioUri = _uriService.GetBookUri(response.BookId.ToString());
return(Created(locatioUri, response));
}
private async void LoadBooks()
{
var books = await _booksService.GetBooksAsync();
_books.Clear();
foreach (var book in books)
{
_books.Add(book);
}
SelectedBook = Books.FirstOrDefault();
_booksLoaded = true;
AddBookCommand.RaiseCanExecuteChanged();
}
public void Throw_If_ParamethersCount_IsInvalid()
{
var parameters = new List <string>()
{
"title", "author", "genre"
};
var genreServiceMock = new Mock <IGenreServices>();
var authorServiceMock = new Mock <IAuthorServices>();
var bookServiceMock = new Mock <IBooksServices>();
var command = new AddBookCommand(bookServiceMock.Object, genreServiceMock.Object, authorServiceMock.Object);
command.Execute(parameters);
}
private AddBookCommand GetBookCommandObject()
{
var uniqueKey = Guid.NewGuid();
var command = new AddBookCommand {
BookName = "جنگو صلح" + uniqueKey,
PageNumber = 392,
Description = "کتاب جنگو صلح اثر لئون تولستوی",
Category = new Random().Next(0, 5),
PublishedDate = DateTime.Now,
Price = new Random().Next(10)
};
return(command);
}
public Guid AddBook([FromBody] BookDTO dto)
{
var command = new AddBookCommand
{
BookId = Guid.NewGuid(),
BookName = dto.BookName,
ISBN = dto.ISBN,
DateIssued = dto.IssueDate,
Description = dto.Description
};
_commandPublisher.Publish(command);
return(command.CommandUniqueId);
}
public async void AddBookFailForNegativePurchasePrice()
{
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(a => a.SaveAsync());
var addBookCommandHandler = new AddBookCommandHandler(_repositoryMock, mockUnitOfWork.Object);
var addBookCommand = new AddBookCommand
{
Name = "test1",
Text = "Test Author",
PurchasePrice = -5
};
await Assert.ThrowsAsync <ValidateException>(() => addBookCommandHandler.HandleAsync(addBookCommand));
}
public async void HandleAddBookCommand_WithInvalidGuid_ShouldReturnInvalidAuthorGuid(string authorId, string outputError)
{
//Arrange
AddBookCommand addBookCommand = new AddBookCommand("Pet Sematary", 2013, 1, "9788581050393", authorId);
var sut = Mocker.CreateInstance <AddBookCommandHandler>();
//Act
AddBookCommandResponseViewModel result = await sut.Handle(addBookCommand, new CancellationToken());
//Assert
DomainNotifications.GetAll().Should().NotBeNullOrEmpty()
.And.Contain(x => x == outputError);
Mocker.GetMock <IAuthorRepository>().Verify(x => x.GetAuthorById(It.IsAny <Guid>()), Times.Never());
}
public async Task AddNewBooksAsync()
{
//Arrange
var mediator = new Mock <IMediator>();
var unitOfWork = new Mock <IUnitOfWork>();
var request = new Mock <IRequest <BookItemDto> >();
AddBookCommand addBookCommand = new AddBookCommand(new BookItemDto());
AddBookCommandHandler addBookCommandHandler = new AddBookCommandHandler(unitOfWork.Object);
//Act
var x = await addBookCommandHandler.Handle(addBookCommand, new System.Threading.CancellationToken());
//Assert
//mediator.Verify(x => x.Send(request));
}
public void ShouldBorrowBookToRepository()
{
var userRepository = new UserRepository();
var firstName = "Kinga";
var surName = "Sadowska";
var bookRepository = new BookRepository();
var title = "A Game of Thrones";
var author = "George R. R. Martin";
var quantity = 1;
var consoleOperator = new Mock <IConsoleOperator>();
consoleOperator.Setup(x => x.GetUser()).Returns((firstName, surName, true));
consoleOperator.Setup(x => x.WriteLine(It.IsAny <string>()));
consoleOperator.Setup(x => x.GetBookDescription()).Returns((title, author, true));
consoleOperator.Setup(x => x.GetBookDescriptionWithQuantity()).Returns((title, author, (uint)quantity, true));
var addUserCommand = new AddUserCommand(userRepository, consoleOperator.Object);
addUserCommand.Execute();
var addBookCommand = new AddBookCommand(bookRepository, consoleOperator.Object);
addBookCommand.Execute();
Assert.Single(userRepository.Users);
Assert.Single(bookRepository.Book);
var borrowBookCommand = new BorrowBookCommand(bookRepository, userRepository, consoleOperator.Object);
borrowBookCommand.Execute();
Book first = null;
foreach (var book in bookRepository.Book)
{
first = book;
break;
}
Assert.Equal(first.CurrentBorrowing.User.FirstName, firstName);
Assert.Equal(bookRepository.Book.FirstOrDefault().CurrentBorrowing.User.LastName, surName);
Assert.True(bookRepository.Book.FirstOrDefault().IsCurrentBorrowed);
}
public async Task <BookModel> AddBook(AddBookCommand command)
{
using var response = await _httpClient.PostAsJsonAsync("books", command);
var book = await SafelyReadFromJsonAsync <BookModel>(response, HttpStatusCode.Created);
var expectedBook = new BookModel
{
Title = book.Title?.Trim(),
Author = book.Author?.Trim(),
Price = command.Price,
Genre = command.Genre
};
book.Should()
.BeEquivalentTo(expectedBook, o => o.Excluding(x => x.Id));
return(book);
}
public BooksViewModel()
{
updateBookCommand = new UpdateBookCommand(this);
addBookCommand = new AddBookCommand(this);
deleteBookCommand = new DeleteBookCommand(this);
booksList = new ObservableCollection <BookModel> {
};
typeBookList = new ObservableCollection <string> {
};
authorsList = new ObservableCollection <string> {
};
titleList = new ObservableCollection <string> {
};
readAuthors();
readTitles();
readTypes();
DataGrid_Loaded();
}
public async void AddBookSuccess()
{
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(a => a.SaveAsync());
var addBookCommandHandler = new AddBookCommandHandler(_repositoryMock, mockUnitOfWork.Object);
var addBookCommand = new AddBookCommand
{
Name = "test1",
Text = "Test Author",
PurchasePrice = 5
};
await addBookCommandHandler.HandleAsync(addBookCommand);
var dbCheck = _repositoryMock as MockBookRepository <Book>;
Assert.Single(dbCheck.Table);
Assert.Contains(dbCheck.Table.Values, a => a.Name == addBookCommand.Name && a.Text == addBookCommand.Text && a.PurchasePrice == addBookCommand.PurchasePrice);
}
public void ShouldAddBookrToRepository()
{
var bookRepository = new BookRepository();
uint quantity = 1;
var title = "A Game of Thrones";
var author = "George R. R. Martin";
var consoleOperator = new Mock <IConsoleOperator>();
consoleOperator.Setup(x => x.GetBookDescriptionWithQuantity()).Returns((title, author, quantity, true));
var addBookCommand = new AddBookCommand(bookRepository, consoleOperator.Object);
addBookCommand.Execute();
Assert.Single(bookRepository.Book);
Assert.Equal(bookRepository.Book.Count, (int)quantity);
Assert.Contains(bookRepository.Book.FirstOrDefault().BookDescription.Title, title);
Assert.Contains(bookRepository.Book.FirstOrDefault().BookDescription.Author, author);
}
public async void HandleAddBookCommand_WitInvalidAuthor_ShouldReturnInvalidAuthor()
{
//Arrange
AddBookCommand addBookCommand = new AddBookCommand("Pet Sematary", 2013, 1, "9788581050393", Guid.NewGuid().ToString());
var sut = Mocker.CreateInstance <AddBookCommandHandler>();
Mocker.GetMock <IAuthorRepository>()
.Setup(b => b.GetAuthorById(It.IsAny <Guid>()))
.Returns(() => Task.FromResult <Author>(null));
//Act
AddBookCommandResponseViewModel result = await sut.Handle(addBookCommand, new CancellationToken());
//Assert
Mocker.GetMock <IAuthorRepository>().Verify(x => x.GetAuthorById(It.IsAny <Guid>()), Times.Once());
Mocker.GetMock <IBookRepository>().Verify(x => x.AddBook(It.IsAny <Book>()), Times.Never());
DomainNotifications.GetAll().Should().NotBeEmpty()
.And.Contain(x => x == Messages.Book_AuthorShouldNotBeNull);
}
private async void LoadBooks()
{
try
{
var books = await _booksService.GetBooksAsync();
_books.Clear();
foreach (var book in books)
{
_books.Add(book);
}
SelectedBook = Books.FirstOrDefault();
_booksLoaded = true;
AddBookCommand.RaiseCanExecuteChanged();
}
catch (Exception ex)
{
// handling - write to log, inform user
}
}
public void Return_SuccessMessage()
{
var parameters = new List <string>()
{
"title", "genre", "author", "1"
};
var genreServiceMock = new Mock <IGenreServices>();
var authorServiceMock = new Mock <IAuthorServices>();
var bookServiceMock = new Mock <IBooksServices>();
var command = new AddBookCommand(bookServiceMock.Object, genreServiceMock.Object, authorServiceMock.Object);
genreServiceMock.Setup(x => x.AddGenre(It.IsAny <string>())).Returns(1);
authorServiceMock.Setup(x => x.AddAuthor(It.IsAny <string>())).Returns(1);
bookServiceMock.Setup(x => x.AddBook(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>())).Returns(new BookViewModel()
{
Title = parameters[0]
});
var message = command.Execute(parameters);
Assert.AreEqual($"New book {parameters[0]} was added.", message);
}
public void Call_BookService_AddBook_Once()
{
var parameters = new List <string>()
{
"title", "genre", "author", "1"
};
var genreServiceMock = new Mock <IGenreServices>();
var authorServiceMock = new Mock <IAuthorServices>();
var bookServiceMock = new Mock <IBooksServices>();
var command = new AddBookCommand(bookServiceMock.Object, genreServiceMock.Object, authorServiceMock.Object);
genreServiceMock.Setup(x => x.AddGenre(It.IsAny <string>())).Returns(1);
authorServiceMock.Setup(x => x.AddAuthor(It.IsAny <string>())).Returns(1);
bookServiceMock.Setup(x => x.AddBook(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>())).Returns(new BookViewModel()
{
Title = parameters[0]
});
command.Execute(parameters);
bookServiceMock.Verify(b => b.AddBook(parameters[0], 1, 1, parameters[3]), Times.Once());
}
public IActionResult AddBook([FromBody] AddBookDTO addBookDTO)
{
if (ModelState.IsValid)
{
AddBookCommand addBookCommand = new AddBookCommand(addBookDTO.Title, addBookDTO.AuthorId,
addBookDTO.ReleaseYear);
try
{
var result = _messages.Dispatch(addBookCommand);
return(FromResult(result));
}
catch (DomainException ex)
{
_logger.LogError(ex.Message);
return(Error(ex.Message));
}
catch (Exception ex)
{
_logger.LogCritical(ex.Message);
return(StatusCode(500));
}
}
return(BadRequest());
}
public async Task <IActionResult> AddBook([FromBody] AddBookCommand command)
{
RequestResult requestResult = await _orquestrator.SendCommand(command);
return(await ReturnRequestResult(requestResult));
}
public async Task <IActionResult> AddBook(AddBookCommand command)
{
var bookId = await Mediator.Send(command);
return(CreatedAtAction(nameof(GetBook), new { id = bookId }, new { bookId }));
}
public void AddBook([FromBody] AddBookCommand command) => actorService.ActorRef.Tell(command);
