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);