public void Compare_CompareTwoDtoThatHasDifferentTypeButSameId_DtoAreNotEquals() { var user = new UserDto() { Id = 1 }; var book = new BookDto() { Id = 1 }; var comparer = new BaseDtoComparer<int>(); Assert.IsFalse(comparer.Equals(user, book)); }
public void ValidateObject_ValidationOfDto_ValidationWorks() { var book = new BookDto() { Pages = 1, //Should have at least 10 pages Title = string.Empty, //Shouldn't be String.Empty }; Console.WriteLine(book["Pages"]); Console.WriteLine(book["Title"]); Assert.IsNotNull(book["Pages"]); Assert.IsNotNull(book["Title"]); }
public async Task VerifyRemoveItemGetsCalledOnServiceWhenRemovingItem() { var shoppingCartService = new Mock <IShoppingCartService>(); var viewModel = new ShoppingCartViewModel(shoppingCartService.Object); var book = new BookDto { Id = 5, Title = "Some book" }; var cartItem = new CartItemModel { Book = book }; await viewModel.RemoveOne(cartItem); shoppingCartService.Verify(s => s.RemoveFromCart(book), Times.Once); }
public async Task <IHttpActionResult> PatchBook2(int id) { BookDto book = await db.Books.Include(b => b.Author) .Where(b => b.BookId == id) .Select(AsBookDto) .FirstOrDefaultAsync(); if (book == null) { return(NotFound()); } find(); drop(); return(Ok(book)); }
public void UpdateBook(int id, BookDto bookDto) { if (!ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } var bookInDb = _context.Books.SingleOrDefault(b => b.Id == id); if (bookInDb == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } Mapper.Map(bookDto, bookInDb); _context.SaveChanges(); }
public BookDto GetBookDetail(int isbn) { var pageDto = new BookDto(); var book = UnitOfWork.CurrentSession.Books.AsQueryable() .FirstOrDefault(p => p.Isbn == isbn); if (book != null) { pageDto.Author = book.Author; pageDto.Isbn = book.Isbn; pageDto.Title = book.Title; } return(pageDto); }
public async Task Update(BookDto book, CancellationToken cancellationToken = default) { var bookDomain = await _bookStoreDbContext.Books.FirstOrDefaultAsync(x => x.Id == book.Id, cancellationToken); bookDomain.Id = book.Id; bookDomain.Name = book.Name; bookDomain.Author = book.Author; bookDomain.Description = book.Description; bookDomain.Price = book.Price; bookDomain.Currrency = book.Currrency; bookDomain.Image = book.Image; bookDomain.Quantity = book.Quantity; _bookStoreDbContext.Books.Update(bookDomain); await _bookStoreDbContext.SaveChangesAsync(cancellationToken); }
public void UserAction(ClientDto currentClient, BookDto book) { _outputEnvironment.WriteLine($"{Resource.YourChoice}:"); var isWished = currentClient.WishedBooksId.Contains(book.Id); var isCommented = (from commentId in book.UserCommentsId where currentClient.CommentsId.Contains(commentId) select true).FirstOrDefault(); var userMenu = _menuVisualizer.FactoryMethod(); userMenu.Add(isWished ? Resource.RemoveFromWishList : Resource.AddToWishList, () => AddRemoveWishlist(book, isWished)) .Add(isCommented ? Resource.RemoveComment : Resource.AddComment, () => AddRemoveComment(book, isCommented)) .Add(Resource.ReturnBack, () => { }) .Display(); }
//PUT /api/books public IHttpActionResult Update(int id, BookDto bookDto) { if (!ModelState.IsValid) { return(BadRequest()); } var bookInDb = _booksContext.Books.SingleOrDefault(c => c.Id == id); if (bookInDb == null) { return(NotFound()); } Mapper.Map(bookDto, bookInDb); _booksContext.SaveChanges(); return(Ok()); }
public async Task <IHttpActionResult> GetBook(int id) { BookDto book = await db.Books.Include(b => b.Author) .Where(b => b.BookId == id) .Select(AsBookDto) .FirstOrDefaultAsync(); if (book == null) { return(NotFound()); } string result = JsonConvert.SerializeObject(book, Formatting.Indented); return(Ok(result)); }
public IHttpActionResult UpdateBook(int id, BookDto bookDto) { if (!ModelState.IsValid) { return(BadRequest()); } var bookInDb = _context.Books.SingleOrDefault(b => b.Id == id); if (bookInDb == null) { return(NotFound()); } Mapper.Map(bookDto, bookInDb); _context.SaveChanges(); return(StatusCode(HttpStatusCode.NoContent)); }
public async Task VerifyAddingToCartAddsItToTheCollection() { var cachingRegionFactory = new Mock <ICachingRegionFactory>(); var cachingRegion = new Mock <ICachingRegion <IEnumerable <CartItemModel> > >(); cachingRegionFactory.Setup(f => f.CreateRegion <IEnumerable <CartItemModel> >("ShoppingCart")).Returns(cachingRegion.Object); var service = new ShoppingCartService(cachingRegionFactory.Object); var book = new BookDto { Id = 2 }; await service.AddToCart(book); service.CartItems.Count.ShouldBe(1); service.CartItems[0].Book.ShouldBe(book); }
/// <summary> /// Removes the book from the cart. /// </summary> /// <param name="book">The book.</param> /// <returns></returns> /// <exception cref="ArgumentNullException"> /// The specified Book was not found as an item in the shopping cart! /// </exception> public async Task RemoveFromCart(BookDto book) { if (book == null) { throw new ArgumentNullException(nameof(book)); } var oldItem = this.CartItems.FirstOrDefault(m => m.Book == book); if (oldItem == null) { throw new ArgumentNullException(nameof(book), "The specified Book was not found as an item in the shopping cart!"); } this.CartItems.Remove(oldItem); await this.cachingRegion.UpdateItem(this.CartItems); }
public async Task <IActionResult> NewBook(BookDto bookDto) { if (ModelState.IsValid) { var book = _mapper.Map <Book>(bookDto); await _db.Books.AddAsync(book); await _db.SaveChangesAsync(); return(Json(new { data = _mapper.Map <BookDto>(book) })); } else { return(BadRequest()); } }
public void Update(BookDto bookDto) { var dbBook = booksRepository.GetById(bookDto.Id); if (dbBook != null) { dbBook.Title = bookDto.Title; dbBook.Description = bookDto.Description; dbBook.Author = bookDto.Author; dbBook.Genre = bookDto.Genre; dbBook.Price = bookDto.Price; dbBook.Quantity = bookDto.Quantity; booksRepository.Update(dbBook); } }
public async Task <IActionResult> Post(BookDto book) { if (!await _subscriptionsService.DoesBookExists(book.BookId)) { return(BadRequest("Book subscription doesn't exist")); } if (await _subscriptionsService.IsSubscriptionAlreadyPurchased(book.BookId)) { return(BadRequest("Book subscription is already purchased")); } var result = await _subscriptionsService.PurchaseSubscription(book); return(Ok(result)); }
public async Task <IActionResult> PutBook([FromBody] BookDto bookDto, int id) { if (!ModelState.IsValid) { return(BadRequest("Invalid Params!")); } var book = await _repo.PutBook(bookDto, id); if (book != null) { return(Ok(book)); } return(BadRequest("Error while updaing book")); }
public async Task <IEnumerable <BookDto> > Create([FromBody] CreateBookRequest newBook) { var book = new BookDto() { NoVolumen = newBook.NoVolumen, Descripcion = newBook.Descripcion }; await bookService.Create(book); var result = new List <BookDto>(); result.Add(book); return(result); }
public IActionResult Post(BookDto bookDto) { if (bookDto is null) { return(BadRequest("Book object is null")); } if (!ModelState.IsValid) { return(BadRequest("Model is not valid")); } Book book = repository.AddAuthorToBook(bookDto); return(CreatedAtAction(nameof(Post), new { id = book.Id }, book)); // return Ok(book); }
public async Task Setup() { _categories = CategoryBuilder.WithLibrary(LibraryId).Build(2); var books = BookBuilder.WithLibrary(LibraryId) .HavingSeries() .WithCategories(_categories) .WithContents(2) .WithPages() .Build(4); _expected = books.PickRandom(); _response = await Client.GetAsync($"/libraries/{LibraryId}/books/{_expected.Id}"); _assert = BookAssert.WithResponse(_response).InLibrary(LibraryId); }
///<inheritdoc/> public bool TryCreateNewBook(BookDto book) { if (book == null) { return(false); } using (var db = new SaleContext()) { var dbBook = new Book(); Mapping.BookDtoToBookMapping(book, ref dbBook); db.Books.Add(dbBook); db.SaveChanges(); return(true); } }
public IHttpActionResult CreateBook(BookDto bookDto) { if (!ModelState.IsValid) { return(BadRequest()); } var book = Mapper.Map <BookDto, Book>(bookDto); _context.Books.Add(book); _context.SaveChanges(); bookDto.Id = book.Id; return(Created(new Uri(Request.RequestUri + "/" + book.Id), bookDto)); }
public async Task <ActionResult <BookDto> > Create(BookDto BookDto) { var Book = new Book { InStock = BookDto.InStock, Name = BookDto.Name }; _context.Books.Add(Book); await _context.SaveChangesAsync(); return(CreatedAtAction( nameof(Get), new { id = Book.Id }, ItemToDTO(Book))); }
public async Task <IActionResult> AddBook(BookDto newbook) { Book book = new Book() { Name = newbook.Name, Author = newbook.Author, Janre = newbook.Janre, Year = newbook.Year, Price = newbook.Price }; await this._context.Books.AddAsync(book); await this._context.SaveChangesAsync(); return(View()); }
public async Task <IActionResult> Add(BookDto bookDto) { Lesson lesson = await _lessonService.GetById(bookDto.LessonId); bookDto.ExamType = lesson.ExamType; try { await _bookService.Add(bookDto); return(Ok("Kitap Başarıyla Kaydedildi")); } catch { return(BadRequest("Kitap Ekleme İşlemi Başarısız")); } }
public async Task <IActionResult> CreateBook([FromBody] BookDto newBook) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var book = mapper.Map <BookDto, Book>(newBook); repository.Add(book); await unitOfWork.CompleteAsync(); var result = mapper.Map <Book, BookDto>(book); return(Ok(result)); }
private IMapper GetMockedAutomapper() { var mockedAutomapper = new Mock <IMapper>(); var mockedBook = new Book(); var mockedBookDto = new BookDto(); mockedAutomapper.Setup(_ => _.Map <BookDto>(It.IsNotNull <Book>())) .Returns(mockedBookDto); mockedAutomapper.Setup(_ => _.Map <Book>(It.IsNotNull <BookDto>())) .Returns(mockedBook); return(mockedAutomapper.Object); }
public async Task Setup() { _category = CategoryBuilder.WithLibrary(LibraryId).Build(); var books = BookBuilder.WithLibrary(LibraryId).WithCategory(_category).Build(1); _bookToUpdate = books.PickRandom(); var book = new BookView { Title = RandomData.Text, Categories = new[] { new CategoryView { Id = -RandomData.Number } } }; _response = await Client.PutObject($"/libraries/{LibraryId}/books/{_bookToUpdate.Id}", book); }
public async Task <ActionResult <BookDto> > Update(Guid id, BookDto bookDto) { if (id != bookDto.Id) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest()); } await _bookService.Update(_mapper.Map <Book>(bookDto)); return(Ok(bookDto)); }
private void downloadBtn_Click(object sender, RoutedEventArgs e) { List <ChapterDto> selectedChapters = chapterList.SelectedItems.OfType <ChapterDto>().ToList(); BookDto selectedBook = (BookDto)bookList.SelectedItem; string dt = selectedBook?.Name + DateTime.Now.Millisecond; if (selectedBook == null) { selectedBook = new BookDto { IndexUrl = findBook.Text, Name = "Custom" } } ; if (selectedChapters.Count > 0) { BackgroundWorker worker = new BackgroundWorker(); downloads.Add(new LabeledProgressBar() { HorizontalContentAlignment = HorizontalAlignment.Stretch, HorizontalAlignment = HorizontalAlignment.Stretch, Tag = dt, ToolTip = new ToolTip() { Content = selectedBook.Name + ", " + selectedChapters.First().DisplayName + "-" + selectedChapters.Last().DisplayName + " -> Count: " + selectedChapters.Count } }); downloadList.Items.Refresh(); if (downloadList.Visibility == Visibility.Hidden) { downloadListBtn_Click(new { }, new RoutedEventArgs()); } worker.WorkerReportsProgress = true; try { worker.DoWork += downloadChapter; worker.ProgressChanged += worker_ProgressChanged; worker.RunWorkerAsync(new List <object> { selectedChapters, selectedBook, dt }); } catch (WebException we) { txtNotificator.Text = we.Message; } } }
public void Map_Always_AllPropertiesMapped() { // Arrange var mapper = new BookDtoMapper(); var authorModel = new AuthorModel() { Id = 234, BirthDate = new DateTime(1967, 3, 2), FirstName = "John", LastName = "Doe" }; var bookModel = new BookModel() { Id = 123, Title = "My book", ReleaseDate = new DateTime(2017, 8, 9), Author = authorModel }; var expected = new BookDto() { Id = bookModel.Id, Title = bookModel.Title, ReleaseDate = bookModel.ReleaseDate, AuthorName = authorModel.FirstName + " - " + authorModel.LastName }; // Act var actual = mapper.Map(bookModel); // Assert try { CheckIfEqual(nameof(BookDto.Id), actual.Id, expected.Id); CheckIfEqual(nameof(BookDto.Title), actual.Title, expected.Title); CheckIfEqual(nameof(BookDto.ReleaseDate), actual.ReleaseDate, expected.ReleaseDate); CheckIfEqual(nameof(BookDto.AuthorName), actual.AuthorName, expected.AuthorName); Console.WriteLine($"{nameof(Map_Always_AllPropertiesMapped)} - test passed"); } catch (Exception ex) { Console.WriteLine($"{nameof(Map_Always_AllPropertiesMapped)} - test failed: {ex.Message}"); } }
public IActionResult GetReviewById(int reviewid) { var review = _reviewRepositoryGUI.GetReviewByID(reviewid); if (review == null) { ModelState.AddModelError(string.Empty, "Some kind of error while Getting the review"); ViewBag.reviewMsg = $"There was an error while getting the review from the database or Review of {reviewid} does not exist"; review = new ReviewDto(); } var reviewer = _reviewerRepositoryGUI.GetReviewerOfAReview(reviewid); if (reviewer == null) { ModelState.AddModelError(string.Empty, "Some kind of error while Getting the reviewer"); ViewBag.reviewMsg += $"There was an error while getting the reviewer from the database or Review of {reviewid} does not exist"; reviewer = new ReviewerDto(); } // var book= _bookRepositoryGUI.get var book = _reviewRepositoryGUI.GetBookOfAReview(reviewid); if (book == null) { ModelState.AddModelError(string.Empty, "Some kind of error while Getting the reviewer"); ViewBag.reviewMsg += $"There was an error while getting the reviewer from the database or Review of {reviewid} does not exist"; book = new BookDto(); } var reviewReviewerBook = new ReviewReviewerBookViewModel() { Book = book, Review = review, Reviewer = reviewer }; return (View(reviewReviewerBook)); }
public IHttpActionResult GetBook(int id) { Book book = _db.Books.Find(id); if (book == null) { return NotFound(); } BookDto bookDto = new BookDto() { AgeRestriction = book.AgeRestriction, Copies = book.Copies, Description = book.Description, EditionType = book.EditionType, Price = book.Price, ReleaseDate = book.ReleaseDate, Title = book.Title, Id = book.Id, Categories = book.Categories.Select(c => c.Name).ToList() }; return Ok(bookDto); }