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