private async Task UploadPicture(BookCreateDto bookDto, Book bookToUpdate)
{
if (bookDto.CoverImage != null)
{
var rootpath = env.WebRootPath;
var fileName = Guid.NewGuid().ToString() + Path.GetExtension(bookDto.CoverImage.FileName);;
var projectFolder = Path.Combine(@"images", fileName);
var fullPath = Path.Combine(rootpath, projectFolder);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
await bookDto.CoverImage.CopyToAsync(stream);
using (var ms = new MemoryStream())
{
stream.Position = 0;
await stream.CopyToAsync(ms);
bookToUpdate.CoverImageContent = ms.ToArray();
}
}
bookToUpdate.CoverImage = projectFolder;
}
else
{
bookToUpdate.CoverImage = config["AppSettings:DefaultImagePath"];
bookToUpdate.CoverImageContent = null;
}
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
BookCreateDto bookDto = (BookCreateDto)context.ActionArguments["bookCreateDto"];
IAuthorRepository authoRepository = (IAuthorRepository)context.HttpContext.RequestServices.GetService(typeof(IAuthorRepository));
if (ErrorOnAuthors(bookDto) && ErrorOnAuthorsId(bookDto))
{
context.ModelState
.AddModelError("AuthorsIds", "You need to pass the ids of that authors that wrote this book, if they are already register, or create the authors if they are not register");
context.ModelState
.AddModelError("Authors", "You need to create the authors that wrote this book if they are not register, or pass the ids of the authors if they are already register");
context.Result = new BadRequestObjectResult(context.ModelState);
}
else if (!ErrorOnAuthorsId(bookDto))
{
if (await NotFoundedAuthorsIdAsync(bookDto, authoRepository))
{
context.ModelState.AddModelError("AuthorsIds", "The passed ids does not match with any author");
context.Result = new BadRequestObjectResult(context.ModelState);
}
else
{
await next();
}
}
else
{
await next();
}
}
public ActionResult <BookDto> Add([FromBody] BookCreateDto bookCreateDto)
{
if (bookCreateDto == null)
{
return(BadRequest());
}
//Book toAdd = _mapper.Map<Book>(bookCreateDto);
Book toAdd = new Book {
Author = bookCreateDto.Author, Description = bookCreateDto.Description, Genre = bookCreateDto.Genre, Read = bookCreateDto.Read, Title = bookCreateDto.Title
};
_bookServices.Add(toAdd);
if (!_bookServices.Save())
{
throw new Exception("Creating an item failed on save.");
}
Book newItem = _bookServices.GetSingle(toAdd.Id);
return(CreatedAtRoute(nameof(GetSingle), new { id = newItem.Id },
_mapper.Map <BookDto>(newItem)));
}
//public bool CreateBook(List<int> authorsId, List<int> genresId, List<int> reviewersId, List<int> librariansId, List<int> readersId, Book book)
//{
// var authors = _bookContext.Authors.Where(a => authorsId.Contains(a.Id)).ToList();
// var genres = _bookContext.Genres.Where(g => genresId.Contains(g.Id)).ToList();
// var reviewers = _bookContext.Reviewers.Where(rev => reviewersId.Contains(rev.Id)).ToList();
// var librarians = _bookContext.Librarians.Where(l => librariansId.Contains(l.Id)).ToList();
// var readers = _bookContext.Readers.Where(r => readersId.Contains(r.Id)).ToList();
// foreach (var author in authors)
// {
// var bookAuthor = new BookAuthor()
// {
// Author = author,
// Book = book
// };
// _bookContext.Add(bookAuthor);
// }
// foreach (var genre in genres)
// {
// var bookGenre = new BookGenre()
// {
// Genre = genre,
// Book = book
// };
// _bookContext.Add(bookGenre);
// }
// foreach (var reviewer in reviewers)
// {
// var bookReviewer = new BookReviewer()
// {
// Reviewer = reviewer,
// Book = book
// };
// _bookContext.Add(bookReviewer);
// }
// foreach (var librarian in librarians)
// {
// var librarianBook = new LibrarianBook()
// {
// Book = book,
// Librarian = librarian
// };
// _bookContext.Add(librarianBook);
// }
// foreach (var reader in readers)
// {
// var readerBook = new ReaderBook()
// {
// Book = book,
// Reader = reader
// };
// _bookContext.Add(readerBook);
// }
// _bookContext.Add(book);
// return Save();
//}
public bool CreateBook(BookCreateDto bookToCreateDto)
{
var bookToCreate = MapConfig.Mapper.Map <Book>(bookToCreateDto);
_bookContext.Add(bookToCreate);
return(Save());
}
public async Task <ActionResult <BookReadDto> > Post([FromBody] BookCreateDto bookCreateDto)
{
if (!string.IsNullOrEmpty(bookCreateDto.NewAuthorName))
{
bookCreateDto.AuthorId = await _authorService.SaveAsync(bookCreateDto.NewAuthorName);
}
if (!string.IsNullOrEmpty(bookCreateDto.NewGenreName))
{
bookCreateDto.GenreId = await _genreService.SaveAsync(bookCreateDto.NewGenreName);
}
bookCreateDto.IsAvailable = true;
BookReadDto newBook = _mapper.Map <BookReadDto>(
await _bookService.AddAsync(_mapper.Map <Book>(bookCreateDto))
);
await _notificationsService.AddBook(new BookDto
{
Author = newBook.Author,
Title = newBook.Title
});
return(CreatedAtAction("Get", new { id = newBook.Id }, newBook));
}
public async Task <IActionResult> PutBook(long id, [FromForm] BookCreateDto bookDto)
{
var isSaved = await bookService.SaveBook(bookDto);
if (isSaved)
{
return(Ok(isSaved));
}
return(BadRequest(ModelState));
}
public async Task <Book> FilledBookOnCreateAsync(BookCreateDto bookDto)
{
Book book = _mapper.Map <Book>(bookDto);
book.RegisterDate = DateTime.Now;
List <Author> authors = await GetAuthorsOnCreateAsync(bookDto);
book = FilledAuthorBooksOnCreateProperty(book, bookDto, authors);
return(book);
}
public async Task <ActionResult> Create([FromBody] BookCreateDto bookCreateDto)
{
Book book = await _services.FilledBookOnCreateAsync(bookCreateDto);
await _bookRepository.CreateAsync(book);
BookReadDto bookReadDto = _services.GetBookReadDto(book);
return(CreatedAtRoute("GetBookById", new { bookReadDto.Id }, bookReadDto));
}
public ActionResult <BookReadDto> CreateBook(BookCreateDto bookCreateDto)
{
var bookModel = _mapper.Map <Book>(bookCreateDto);
_bookRepository.CreateBook(bookModel);
_bookRepository.SaveChanges();
var bookReadDto = _mapper.Map <BookReadDto>(bookModel);
return(CreatedAtRoute(nameof(GetBookByISBN), new { ISBN = bookReadDto.ISBN }, bookReadDto));
//return Ok(bookReadDto);
}
private async Task <List <Author> > GetAuthorsOnCreateAsync(BookCreateDto bookDto)
{
List <Author> authors = new List <Author>();
if (AreAuthorsNewOnCreate(bookDto))
{
authors = _mapper.Map <List <Author> >(bookDto.Authors);
}
else
{
authors = await _authorRepository.FindAllWithFilterAsync(a => bookDto.AuthorsIds.Any(id => id == a.Id));
}
return(authors);
}
public async Task <ActionResult <BookDto> > PostBook(int authorId, BookCreateDto bookDto)
{
if (!_context.Authors.Any(a => a.Id == authorId))
{
return(NotFound());
}
var book = _mapper.Map <Book>(bookDto);
book.AuthorId = authorId;
_context.Books.Add(book);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBook", new { authorId = authorId, id = book.Id }, _mapper.Map <BookDto>(book)));
}
public ActionResult <BookReadDto> CreateBook(BookCreateDto bcd)
{
var bookModel = _mapper.Map <Book>(bcd);
_repository.CreateBook(bookModel);
_repository.SaveChanges();
var bookReadDto = _mapper.Map <BookReadDto>(bookModel);
// return Ok(bookReadDto);
// This will generate an additional header to show the route to access the
// newly created resource
return(CreatedAtRoute(nameof(GetBookById), new { Id = bookReadDto.Id }, bcd));
}
public IActionResult AddBookByAuthor(int authorId, BookCreateDto bookCreateDto)
{
if (_repository.GetAuthorById(authorId) == null)
{
return(NotFound());
}
var book = _mapper.Map <Book>(bookCreateDto);
_repository.AddBookByAuthor(authorId, book);
_repository.SaveChanges();
var bookDto = _mapper.Map <BookDto>(book);
return(CreatedAtRoute(nameof(GetBookById), new { authorId = bookDto.AuthorId, bookId = bookDto.Id }, bookDto));
}
public async Task <ActionResult <Book> > CreateAsync([FromForm] BookCreateDto BookCreateDto)
{
try
{
var url = await _photoService.AddPhotoAsync(BookCreateDto.Image);
return(service.Create(BookCreateDto, url));
}
catch (ArgumentException error) {
return(NotFound(error.Message));
}
catch (Exception error)
{
return(Conflict(error.Message));
}
}
private Book FilledAuthorBooksOnCreateProperty(Book book, BookCreateDto bookDto, List <Author> authors)
{
List <AuthorBook> authorBooks = new List <AuthorBook>();
foreach (Author author in authors)
{
if (AreAuthorsNewOnCreate(bookDto))
{
author.RegisterDate = DateTime.Now;
}
authorBooks.Add(new AuthorBook()
{
Author = author, Book = book
});
}
book.AuthorsBooks = authorBooks;
return(book);
}
public ActionResult <BookReadDto> CreateBook(BookCreateDto bookCreateDto)
{
if (_repository.IsbnExists(bookCreateDto.ISBN))
{
return(Conflict(new {
message = $"An existing record with the ISBN '{bookCreateDto.ISBN}' was already found.",
type = "https://tools.ietf.org/html/rfc7231#section-6.5.8",
status = 409
}));
}
Book bookModel = _mapper.Map <Book>(bookCreateDto);
_repository.CreateBook(bookModel);
_repository.SaveChanges();
BookReadDto bookReadDto = _mapper.Map <BookReadDto>(_repository.GetBookById(bookModel.BookId));
return(CreatedAtRoute(nameof(GetBookById), new { id = bookModel.BookId }, bookReadDto));
}
public Book Create(BookCreateDto dto, ImageUploadResult url)
{
if (!categoryService.Exist(dto.CategoryId))
{
throw new ArgumentException("One/Some of categories not existed");
}
if (!authorService.Exist(dto.AuthorId))
{
throw new ArgumentException("One/Some of authors not existed");
}
dto.Title = FormatString.Trim_MultiSpaces_Title(dto.Title, true);
var isExist = GetDetail(dto.Title);
if (isExist != null)
{
throw new Exception(dto.Title + " existed");
}
if (publisherService.GetDetail(dto.PublisherId) == null)
{
throw new ArgumentException("Publisher not existed");
}
var entity = new Book
{
ISBN = FormatString.Trim_MultiSpaces_Title(dto.ISBN),
Title = dto.Title,
Image = url.SecureUrl.AbsoluteUri,
// Image = FormatString.Trim_MultiSpaces_Title(dto.Image),
Summary = dto.Summary,
PublicationDate = dto.PublicationDate,
QuantityInStock = dto.QuantityInStock,
Price = dto.Price,
Sold = dto.Sold,
Discount = dto.Discount,
PublisherId = dto.PublisherId
};
var book = repository.Add(entity);
bookCategoryService.Create(book, dto.CategoryId);
authorBookService.Create(book, dto.AuthorId);
return(book);
}
public IActionResult CreateBookForAuthor(Guid authorId, [FromBody] BookCreateDto book)
{
if (book == null)
{
return(BadRequest());
}
if (book.Description == book.Title)
{
ModelState.AddModelError(nameof(BookCreateDto), "A book's description cannot be the same as the title!");
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!_libraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var bookEntity = AutoMapper.Mapper.Map <Book>(book);
_libraryRepository.AddBookForAuthor(authorId, bookEntity);
if (!_libraryRepository.Save())
{
throw new Exception($"Creating a book for author {authorId} failed on save");
}
var bookToReturn = AutoMapper.Mapper.Map <BookDto>(bookEntity);
return(CreatedAtRoute("GetBookForAuthor",
new
{
authorId = authorId,
bookId = bookToReturn.Id
},
CreateLinksForBook(bookToReturn)));
}
public ActionResult<BookDto> Add([FromBody] BookCreateDto bookCreateDto)
{
if (bookCreateDto == null)
{
return BadRequest();
}
Book toAdd = Mapper.Map<Book>(bookCreateDto);
_bookRepository.Add(toAdd);
if (!_bookRepository.Save())
{
throw new Exception("Creating an item failed on save.");
}
Book newItem = _bookRepository.GetSingle(toAdd.Id);
return CreatedAtRoute(nameof(GetSingle), new { id = newItem.Id },
Mapper.Map<BookDto>(newItem));
}
public IActionResult CreateBookForAuthor(Guid authorId, [FromBody] BookCreateDto book)
{
if (book == null)
{
return(BadRequest());
}
if (book.Description == book.Title)
{
ModelState.AddModelError(nameof(BookCreateDto), "Title and Description must be different");
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!_libraryRepository.AuthorExists(authorId))
{
return(NotFound("Author not found!"));
}
var bookEntity = _mapper.Map <Book>(book);
_libraryRepository.AddBookForAuthor(authorId, bookEntity);
if (!_libraryRepository.Save())
{
throw new Exception("Book creation failure!");
}
var bookToReturn = _mapper.Map <BookDto>(bookEntity);
return(CreatedAtRoute(ApiNames.GetBookForAuthor,
new
{
authorId,
id = bookEntity.Id
},
CreateLinksForBook(bookToReturn)));
}
public async Task <IActionResult> Create([FromBody] BookCreateDto bookDto)
{
var location = GetControllerActionNames();
try
{
_logger.LogInfo($"{location}: Create Attempted");
if (bookDto == null)
{
_logger.LogWarn($"{location}: Empty Request was submited.");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
_logger.LogWarn($"{location}: Data was Incomplete.");
return(BadRequest(ModelState));
}
var book = _mapper.Map <Book>(bookDto);
var isSuccess = await _bookRepository.Create(book);
if (!isSuccess)
{
return(InternalError($"{location}: Creation failed."));
}
if (!string.IsNullOrEmpty(bookDto.File))
{
var imgPath = GetImagePath(bookDto.Image);
byte[] imageBytes = Convert.FromBase64String(bookDto.File);
System.IO.File.WriteAllBytes(imgPath, imageBytes);
}
_logger.LogInfo("Created successfully");
_logger.LogInfo($"{location}: {book} ");
return(Created("Create", new { book }));
}
catch (Exception e)
{
return(InternalError($"{location}: {e.Message} - {e.InnerException}"));
}
}
public ActionResult <BookDto> AddBook(ApiVersion version, [FromBody] BookCreateDto bookCreateDto)
{
if (bookCreateDto == null)
{
return(BadRequest());
}
BookEntity toAdd = _mapper.Map <BookEntity>(bookCreateDto);
_bookRepository.Add(toAdd);
if (!_bookRepository.Save())
{
throw new Exception("Creating a bookitem failed on save.");
}
BookEntity newBookItem = _bookRepository.GetSingle(toAdd.Id);
return(CreatedAtRoute(nameof(GetSingleBook),
new { version = version.ToString(), id = newBookItem.Id },
_mapper.Map <BookDto>(newBookItem)));
}
public IActionResult CreateBook([FromBody] BookCreateDto newBook)
{
if (newBook == null)
{
BadRequest(ModelState);
}
if (_unitOfWork.BookRepository.BookExistsById(newBook.Id))
{
ModelState.AddModelError("", "Such book Exists!");
StatusCode(404, ModelState);
}
if (!_unitOfWork.BookRepository.CreateBook(newBook))
{
ModelState.AddModelError("", $"Something went wrong saving the book " + $"{newBook.BookTitle}");
StatusCode(500, ModelState);
}
_unitOfWork.Commit();
return(CreatedAtRoute("GetBookById", new { bookId = newBook.Id }, newBook));
}
public async Task <bool> SaveBook(BookCreateDto bookDto)
{
try
{
if (bookDto.BookId == 0)
{
//Add new book
var book = mapper.Map <Book>(bookDto);
book.CategoryName = (await db.Categories.FindAsync(book.CategoryId)).Name;
await UploadPicture(bookDto, book);
await db.Books.AddAsync(book);
return(await SaveChangesAsync());
}
else
{
//Update the book
var bookToUpdate = await db.Books.FindAsync(bookDto.BookId);
bookToUpdate.CategoryName = db.Categories.SingleOrDefault(x => x.Id == bookDto.CategoryId).Name;
bookToUpdate.Price = bookDto.Price;
bookToUpdate.Title = bookDto.Title;
bookToUpdate.Author = bookDto.Author;
await UploadPicture(bookDto, bookToUpdate);
bookToUpdate.CategoryId = bookDto.CategoryId;
db.Entry(bookToUpdate).State = EntityState.Modified;
return(await SaveChangesAsync());
}
}
catch (Exception)
{
throw;
}
}
public IActionResult Post(Guid authorId, [FromBody] BookCreateDto createDto)
{
if (createDto == null)
{
return(BadRequest());
}
if (createDto.Description == createDto.Title)
{
ModelState.AddModelError(nameof(createDto), "The title and description must be different.");
}
if (!ModelState.IsValid)
{
//return StatusCode(422, ModelState.ErrorCount);
//return new StatusCodeResult(StatusCodes.Status422UnprocessableEntity);
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!Repository.AuthorExists(authorId))
{
return(NotFound());
}
var book = Mapper.Map <Book>(createDto);
Repository.CreateBook(authorId, book);
if (!Repository.Save())
{
throw new Exception($"Creating book for author {authorId} was unsuccessful.");
}
var bookDto = Mapper.Map <BookDto>(book);
return(CreatedAtRoute("GetBook", new { authorId, id = bookDto.Id }, CreateBookLinks(bookDto)));
}
private async Task <bool> NotFoundedAuthorsIdAsync(BookCreateDto bookDto, IAuthorRepository authorRepository)
{
List <Models.Author> authors = await authorRepository.FindAllWithFilterAsync(b => bookDto.AuthorsIds.Any(id => id == b.Id));
return(authors.Count == 0);
}
private bool AreAuthorsNewOnCreate(BookCreateDto bookDto) => !(bookDto.Authors is null) && bookDto.Authors.Length > 0;
public async Task <IActionResult> CreateNewBook([FromBody] BookCreateDto book)
{
var newBook = await _appService.AddNewBookAsync(_mapper.Map <Book>(book));
return(Ok());
}
private bool ErrorOnAuthors(BookCreateDto bookDto) => bookDto.Authors == null || bookDto.Authors.Length == 0;
public virtual Task <BookDto> CreateAsync(BookCreateDto input)
{
return(_bookAppService.CreateAsync(input));
}
