public async Task AddBookAsyncTest() { // Act var result = await _bookRepository.AddAsync(_bookBuilder.CreateValidBook()); // Assert result.Id.Should().BePositive(); }
public async Task HandleAysnc(BookChangeEvent domainEvent, CancellationToken cancellationToken = default) { await _repo.AddAsync(new Aggregates.Book("xx", "x", "x1"), cancellationToken); await _repo.AddAsync(new Aggregates.Book("xx", "x", "x1"), cancellationToken); await _repo.AddAsync(new Aggregates.Book("xx", "x", "x1"), cancellationToken); }
public async Task AddBookAsync(BookDTO bookDTO) { Category category = await _categoryRepository.GetByNameAsync(bookDTO.CategoryName); if (category == null) { category = new Category(bookDTO.CategoryName); } Author author = await _authorRepository.GetByNameAsync(bookDTO.AuthorFirstname, bookDTO.AuthorSurname); if (author == null) { author = new Author(bookDTO.AuthorFirstname, bookDTO.AuthorSurname); } Book book = new Book( title: bookDTO.Title, price: bookDTO.Price, inStock: bookDTO.InStock, numberOfPages: bookDTO.NumberOfPages, descriptions: bookDTO.Descriptions, img: new Img(bookDTO.ImgPath), author: author, category: category ); await _bookRepository.AddAsync(book); }
/// <summary> /// Dodaj novu knjigu sa random kategorijom /// </summary> public async Task <bool> AddBokk(Book book) { int count = await _categoryrepo.CountAsync(); Random rand = new Random(); book.CategoryID = rand.Next(0, count); Book result = await _bookrepo.AddAsync(book); if (result != null) { List <BookCopy> copies = new List <BookCopy>(); for (int i = 0; i < 20; i++) { BookCopy copy = new BookCopy() { Borrowed = false, BookId = result.Id }; copies.Add(copy); } return(await _copyrepo.AddRangeAsync(copies)); } return(false); }
public async Task <BookVm> Handle(CreateBook request, CancellationToken cancellationToken) { var book = new Book(Guid.NewGuid(), request.Name, request.ReleaseYear, request.Pages, request.Summary, request.Publisher, request.ArtistId); string imageUrl; if (request.Poster?.HasValue() == true) { if (!string.IsNullOrEmpty(book.Poster)) { await _fileUtils.RemoveByUrlAsync(book.Poster); } var fileName = $"books/{Guid.NewGuid()}{request.Poster.Name.GetExtension()}"; imageUrl = await _fileUtils.UploadAsync(request.Poster, fileName); if (imageUrl.IsNull()) { throw new Exception("Erro ao Importar o poster"); } } else { imageUrl = book.Poster; } book.Poster = imageUrl; await _bookRepository.AddAsync(book); return(book.ToVm()); }
/// <summary> /// Add or Update Book Async /// </summary> /// <param name="model"></param> /// <returns></returns> public async Task <ApiResponse <bool> > AddorUpdateBookAsync(BookModel model) { try { var result = _mapper.Map <BookModel, Book>(model); result.DateOfPublication = DateTime.Now; if (result.Id > 0) { await _bookRepository.UpdateAsync(result); } else { await _bookRepository.AddAsync(result); } var testResult = await Task.FromResult(true); return(ApiResponse <bool> .SuccessResult(testResult)); } catch (Exception ex) when(ex is FailException || ex is ValidationException || ex is ArgumentException) { return(ApiResponse <bool> .ErrorResult(message : ex.Message, statusCode : HttpStatusCode.BadRequest)); } catch (Exception ex) when(ex is ErrorException) { //LoggingManager.Error(ex.ToString()); return(ApiResponse <bool> .ErrorResult(message : ex.Message)); } catch (Exception ex) { //LoggingManager.Error(ex.ToString()); return(ApiResponse <bool> .ErrorResult(message : ex.Message)); } }
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 Task AddAsync(Book book) { if (!RunValidation(new BookValidation(), book)) { return; } await _bookRepository.AddAsync(book); }
public async Task <Response> Handle(CreateBookCommand request, CancellationToken cancellationToken) { var book = new Book(request.Title); await _bookRepository.AddAsync(book); return(new Response("Book criado com sucesso")); }
public async Task <BookId> Handle(CreateBookCommand request, CancellationToken cancellationToken) { var product = Book.Create(request.BookName, request.AuthorName); IBookRepository bookRepository = _productDbContext.BookRepository; await bookRepository.AddAsync(product, cancellationToken); return(product.Id); }
public async Task AddBookAsync(Book newBook) { try { await _bookRepository.AddAsync(newBook); } catch (MemberRelationException e) { throw; } }
public async Task CreateAuthorAsync(Book book) { if (book.Quantity <= 0) { throw new Exception("No elo cos sie nie zgadza gościu. "); } await _bookRepository.AddAsync(book); await _unitOfWork.CompleteAsync(); }
public async Task AddBookAsync(string name, Author author, string genre, DateTime relasedAt) { var book = await _bookRepository.GetAsync(name); if (book != null) { throw new Exception($"Book with name '{name}' already exist."); } book = new Book(name, author, genre, relasedAt); await _bookRepository.AddAsync(book); }
public async Task <ActionResult <Book> > Create([FromBody] BookApiModel model) { if (!_authorRepository.Exists(model.AuthorId)) { return(BadRequest()); } var newBook = await _bookRepository.AddAsync(ApiModelToBook(model)); return(CreatedAtAction(nameof(Create), BookToApiModel(newBook))); }
public async Task SaveAsync(BookEdit bookEdit) { Book book = bookEdit.Id == null ? new Book() : await bookRepository.GetEntityAsync(bookEdit.Id.Value, true); mapper.Map(bookEdit, book); if (bookEdit.Id == null) { await bookRepository.AddAsync(book); } await bookRepository.SaveChangesAsync(); }
public async Task CreateAsync(string title, string description, string image, string writer, string publisher, byte numberOfSets) { var book = new Book(title, description, image, writer, publisher, numberOfSets); for (int i = 0; i < book.NumberOfSets; i++) { Set set = new Set(book, true); book.Sets.Add(set); } await _bookRepository.AddAsync(book); }
public async Task <Result <Book> > CreateBook(Book newBook) { ValidationResult validationResult = _validator.Validate(newBook); if (!validationResult.IsValid) { return(Result.Failure(newBook, validationResult.Errors.Select(s => s.ErrorMessage).ToList())); } var bookFromEF = await _bookRepository.AddAsync(newBook); return(Result.Success(bookFromEF)); }
public async Task <DbChangeResponse> AddAsync(Book book) { try { await _bookRepository.AddAsync(book); return(new DbChangeResponse(true, "Book succesfully added.", book)); } catch (Exception ex) { Console.WriteLine($"An error occurred while creating the book: { ex.Message}"); return(new DbChangeResponse(false, $"An error occurred while creatting the book: {ex.Message}", book)); } }
[HttpPost] // PostMapping public async Task <IActionResult> AddAsync([FromBody] Book dto) { if (!ModelState.IsValid) { return(BadRequest()); } // <> var temp = new Book(); temp.Title = dto.Title; temp.Description = dto.Description; temp.Created = DateTime.Now; // </> try { var model = await _repository.AddAsync(temp); if (model == null) { return(BadRequest()); } //[!] 다음 항목 중 원하는 방식 사용 if (DateTime.Now.Second % 60 == 0) { return(Ok(model)); // 200 OK } else if (DateTime.Now.Second % 3 == 0) { return(CreatedAtRoute("GetBookById", new { id = model.Id }, model)); // Status: 201 Created } else if (DateTime.Now.Second % 2 == 0) { var uri = Url.Link("GetBookById", new { id = model.Id }); return(Created(uri, model)); // 201 Created } else { // GetById 액션 이름 사용해서 입력된 데이터 반환 return(CreatedAtAction(nameof(GetById), new { id = model.Id }, model)); } } catch (Exception e) { _logger.LogError(e.Message); return(BadRequest()); } }
public async Task <BookSaveResponse> SaveAsync(Book book) { try { await _bookRepository.AddAsync(book); await _transaction.CompleteAsync(); return(new BookSaveResponse(book)); } catch (Exception ex) { return(new BookSaveResponse($"An error occurred while attempting to save the book: {ex.Message}")); } }
public async Task <BookResponse> SaveAsync(Book book) { try { await _bookRepository.AddAsync(book); await _unitOfWork.CompleteAsync(); return(new BookResponse(book)); } catch (Exception ex) { return(new BookResponse($"An error occurred when saving the book:{ex.Message}")); } }
public async Task <ActionResult> BookShip(CreateBookInput input) { Book order = new Book { BookNo = input.BookNo, Author = input.Author, BookName = input.BookName, Category = input.Category, Price = input.Price }; await _bookRepository.AddAsync(order); return(Ok()); }
public async Task <BookResponse> AddAsync(Book book) { try { Book createdBook = await _bookRepository.AddAsync(book); return(new BookResponse(createdBook)); } catch (System.Exception ex) { Console.WriteLine(ex.Message); return(new BookResponse($"An error occurred when saving the book: {ex.Message}")); } }
public async Task <IdResponse> CreateBookAsync(BookProxy book) { Validate(book); await _authorModel.ValidateExistingAuthorAsync(book.AuthorId); await ValidateUniqueness(book.Title, null); var entity = new Book(); MapToEntity(book, entity); var id = await _repository.AddAsync(entity); return(new IdResponse(id)); }
public async Task <BookModel> Handle(CreateBookCommand request, CancellationToken cancellationToken) { IList <Author> authors = new List <Author>(); if (request.AuthorIds != null && request.AuthorIds.Any()) { authors = await authorRepository.FindWhereInAsync(request.AuthorIds); } var book = new Book(request.Title, authors); await bookRepository.AddAsync(book); await bookRepository.UnitOfWork.SaveChangesAsync(cancellationToken); return(mapper.MapEntityToModel <Book, BookModel>(book)); }
public async Task AddBookAsync(BookDetails book) { List <Language> languages = new List <Language>(); foreach (var abbriviation in book.Languages) { Language entity = languageRepository.GetByAbbriviation(abbriviation); if (entity == null) { entity = await languageRepository.AddLanguageAsync(new Language() { Abbriviation = abbriviation, Name = GetLanguageNameByAbbriviation(abbriviation) }); } languages.Add(entity); } await bookRepository.AddAsync(book); }
public async Task <IActionResult> Create(CreateViewModel model) { model.BookId = Guid.NewGuid(); model.CreatedByUserId = userManager.GetUserId(User); if (ModelState.IsValid) { try { await bookRepository.AddAsync(model); return(RedirectToAction(nameof(Index))); } catch { return(View()); } } return(View(model)); }
public async Task <IActionResult> Post([FromBody] CreationBookDto book) { if (book == null) { return(NotFound("Book cannot be null")); } var bookExist = await _bookRepository.GetByIsbnAsync(book.Isbn); if (bookExist != null) { return(Conflict($"Book with isbn '{book.Isbn}' already exist")); } var finalBook = _mapper.Map <Book>(book); await _bookRepository.AddAsync(finalBook); return(CreatedAtRoute("GetBookByIsbn", new { isbn = book.Isbn }, finalBook)); }
public async Task <Book> AddOrUpdateBookAsync(Book book) { Book updated = null; if (book.BookId == 0) { updated = await _booksRespository.AddAsync(book); _books.Add(updated); } else { updated = await _booksRespository.UpdateAsync(book); Book old = _books.Where(c => c.BookId == updated.BookId).Single(); int inx = _books.IndexOf(old); _books.RemoveAt(inx); _books.Insert(inx, updated); } return(updated); }
public async Task <BookViewModel> AddAsync(BookInputModel bookInputModel) { var book = mapper.Map <Book>(bookInputModel); book.PublishingCompany = await publishingCompanyRepository.GetAsync(bookInputModel.PublishingCompanyId); /* * var authors = new List<Author>(); * * foreach (var authorId in bookInputModel.AuthorIds) * { * authors.Add(await authorRepository.GetAsync(authorId)); * } */ var authors = await Task.WhenAll(bookInputModel.AuthorIds.Select(async a => await authorRepository.GetAsync(a))); /* * book.AuthorsLink = new List<BookAuthor>(); * * foreach (var author in authors) * { * book.AuthorsLink.Add(new BookAuthor() { Book = book, Author = author }); * } */ //book.AuthorsLink = new List<BookAuthor> { new BookAuthor { Book = book, Author = authors[0]} }; book.AuthorsLink = new List <BookAuthor>(); book.AuthorsLink.AddRange(authors.Select(a => new BookAuthor { Book = book, Author = a })); var result = await repository.AddAsync(book); var bookViewModel = mapper.Map <BookViewModel>(result); return(bookViewModel); }