public async Task <IActionResult> UpdateAuthor(int bookId, [FromBody] SaveBookResource sbResource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var book = await bookRepository.GetBookByIdAsync(bookId);
if (book == null)
{
return(NotFound());
}
mapper.Map <SaveBookResource, Book>(sbResource, book);
book.LastUpdate = DateTime.Now;
await unitOfWork.CompleteAsync();
book = await bookRepository.GetBookByIdAsync(book.Id);
var result = mapper.Map <Book, BookResource>(book);
return(Ok(result));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <BookResource> > UpdateBook(int id, [FromBody] SaveBookResource saveBookResource)
{
var validator = new SaveBookResourceValidator();
var validationResult = await validator.ValidateAsync(saveBookResource);
var requestIsInvalid = id == 0 || !validationResult.IsValid;
if (requestIsInvalid)
{
return(BadRequest(validationResult.Errors));
}
var bookToBeUpdate = await _bookService.GetBookById(id);
if (bookToBeUpdate == null)
{
return(NotFound());
}
var book = _mapper.Map <SaveBookResource, Book>(saveBookResource);
await _bookService.UpdateBook(bookToBeUpdate, book);
var updatedBook = await _bookService.GetBookById(id);
var updatedBookResource = _mapper.Map <Book, BookResource>(updatedBook);
return(Ok(updatedBookResource));
}
public async Task <ActionResult <BookResource> > UpdateBook(SaveBookResource saveBookResource)
{
var validator = new SaveBookResourceValidator();
var validationResult = await validator.ValidateAsync(saveBookResource);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var bookToCreate = _mapper.Map <SaveBookResource, Book>(saveBookResource);
await _bookService.UpdateBook(bookToCreate, bookToCreate);
// Delete from reference table all Book-Authors
var bookAuthorsToDelete = await _bookAuhtorService.GetBookAuthorById(saveBookResource.Id);
foreach (var authorToDelete in bookAuthorsToDelete)
{
await _bookAuhtorService.DeleteBookAuthor(authorToDelete);
}
// Add to reference table all Book-Authors
foreach (var author in saveBookResource.Authors)
{
BookAuthorResource bookAuthorResource = new BookAuthorResource();
bookAuthorResource.AuthorId = author.Id;
bookAuthorResource.BookId = saveBookResource.Id;
var bookAuthorToAdd = _mapper.Map <BookAuthorResource, BookAuthor>(bookAuthorResource);
var newBookAuthor = await _bookAuhtorService.CreateBookAuthor(bookAuthorToAdd);
}
// Delete from reference table all Book-Categories
var bookCategoryToDelete = await _bookCategoryService.GetBookCategoryById(saveBookResource.Id);
foreach (var categoryToDelete in bookCategoryToDelete)
{
await _bookCategoryService.DeleteBookCategory(categoryToDelete);
}
// Add to reference table all Book-Categories
foreach (var category in saveBookResource.Categories)
{
BookCategoryResource bookCategoryResource = new BookCategoryResource();
bookCategoryResource.CategoryId = category.Id;
bookCategoryResource.BookId = saveBookResource.Id;
var bookCategoryToCreate = _mapper.Map <BookCategoryResource, BookCategory>(bookCategoryResource);
var newBookCategory = await _bookCategoryService.CreateBookCategory(bookCategoryToCreate);
}
var databaseBooks = await _bookService.GetWithCategoriesAndAuthorById(saveBookResource.Id);
return(Ok(_mapper.Map <Book, BookResource>(databaseBooks)));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveBookResource resource)
{
if (string.IsNullOrEmpty(resource.Publisher) && !string.IsNullOrEmpty(resource.City))
{
ModelState.AddModelError("Publisher", "The Publisher field is required.");
}
if (string.IsNullOrEmpty(resource.City) && !string.IsNullOrEmpty(resource.Publisher))
{
ModelState.AddModelError("City", "The City field is required.");
}
if (resource.Authors != null)
{
foreach (var author in resource.Authors)
{
if (string.IsNullOrEmpty(author.FirstName) || string.IsNullOrEmpty(author.LastName))
{
ModelState.AddModelError("Author", "The Author field is required.");
}
}
}
if (!ModelState.IsValid)
{
var badresult = new ResponseData
{
Data = null,
Message = string.Join(" ", ModelState.GetErrorMessages().ToArray()),
Success = false
};
return(Ok(badresult));
}
var book = mapper.Map <SaveBookResource, Book>(resource);
var bookResponse = await bookService.UpdateAsync(id, book);
var bookResource = mapper.Map <Book, BookResource>(bookResponse.Book);
var result = new ResponseData
{
Data = bookResource,
Message = bookResponse.Message,
Success = bookResponse.Success
};
return(Ok(result));
}
public IActionResult Post([FromBody] SaveBookResource form)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = _mapper.Map <SaveBookResource, Book>(form);
_repository.Add(model);
_unitOfWork.Complete();
var book = _repository.GetBook(model.Id);
var result = _mapper.Map <Book, BookResource>(book);
return(Ok(result));
}
public async Task <IActionResult> CreateBook([FromBody] SaveBookResource bookResource)
{
if (!ModelState.IsValid &&
(bookResource.Guests.Count <= 0 || bookResource.NewGuests.Count <= 0))
{
return(BadRequest(ModelState));
}
if (bookResource.NewGuests != null && bookResource.NewGuests.Count > 0)
{
var newGuest = mapper.Map <IEnumerable <GuestResource>, IEnumerable <Guest> >(bookResource.NewGuests);
unitOfWork.Guests.AddRange(newGuest);
foreach (var item in newGuest)
{
bookResource.Guests.Add(item.Id);
}
}
var book = mapper.Map <SaveBookResource, Book>(bookResource);
book.DayRooms.Add(new DayRoom
{
RoomId = book.RoomId,
GuestsQty = book.GuestNumber,
DayRoomDate = book.CheckIn,
DayRoomPrice = book.RoomRate,
PaymentFlag = false
});
unitOfWork.Books.Add(book);
var room = await unitOfWork.Rooms.Get(book.RoomId);
room.CurrentBookId = book.Id;
room.RoomStateId = (int)RoomStateEnum.Occupied;
await unitOfWork.CompleteAsync();
var result = await unitOfWork.Books.GetBook(book.Id);
return(Ok(mapper.Map <Book, BookResource>(result)));
}
public async Task <IActionResult> PostAsync([FromBody] SaveBookResource saveBookResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var book = _mapper.Map <Book>(saveBookResource);
var result = await _bookService.SaveAsync(book);
if (!result.Success)
{
return(BadRequest());
}
var bookResource = _mapper.Map <BookCheckoutResource>(result.Book);
return(Ok(bookResource));
}
public async Task <ActionResult <BookResource> > CreateBook([FromBody] SaveBookResource saveBookResource)
{
var validator = new SaveBookResourceValidator();
var validationResult = await validator.ValidateAsync(saveBookResource);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var bookToCreate = _mapper.Map <SaveBookResource, Book>(saveBookResource);
var newBook = await _bookService.CreateBook(bookToCreate);
var book = await _bookService.GetBookById(newBook.Id);
var bookResource = _mapper.Map <Book, BookResource>(book);
return(Ok(bookResource));
}
public async Task <ActionResult <BookResource> > CreateBook(SaveBookResource saveBookResource)
{
var validator = new SaveBookResourceValidator();
var validationResult = await validator.ValidateAsync(saveBookResource);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var bookToCreate = _mapper.Map <SaveBookResource, Book>(saveBookResource);
var newBook = await _bookService.CreateBook(bookToCreate);
foreach (var author in saveBookResource.Authors)
{
BookAuthorResource bookAuthorResource = new BookAuthorResource();
bookAuthorResource.AuthorId = author.Id;
bookAuthorResource.BookId = newBook.Id;
var bookAuthorToCreate = _mapper.Map <BookAuthorResource, BookAuthor>(bookAuthorResource);
var newBookAuhtor = await _bookAuhtorService.CreateBookAuthor(bookAuthorToCreate);
}
foreach (var category in saveBookResource.Categories)
{
BookCategoryResource bookCategoryResource = new BookCategoryResource();
bookCategoryResource.CategoryId = category.Id;
bookCategoryResource.BookId = newBook.Id;
var bookCategoryToCreate = _mapper.Map <BookCategoryResource, BookCategory>(bookCategoryResource);
var newBookCategory = await _bookCategoryService.CreateBookCategory(bookCategoryToCreate);
}
var databaseBooks = await _bookService.GetWithCategoriesAndAuthorById(newBook.Id);
return(Ok(_mapper.Map <Book, BookResource>(databaseBooks)));
}
public async Task <IActionResult> UpdateBook(int bookId, [FromBody] SaveBookResource bookResource)
{
var book = await unitOfWork.Books.GetBook(bookId);
var room = await unitOfWork.Rooms.Get(bookResource.RoomId);
if (book == null || room == null)
{
return(NotFound());
}
if (book.RoomId != bookResource.RoomId)
{
await ChangeRoom(book, room);
}
book.GuestNumber = bookResource.GuestNumber;
book.RoomRate = bookResource.RoomRate;
book.CheckOut = ParseString.ParseStringToDateTime(bookResource.CheckOut);
await unitOfWork.CompleteAsync();
return(Ok(mapper.Map <Book, BookResource>(book)));
}
public async Task <IActionResult> AddBook([FromBody] SaveBookResource sbResource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var book = mapper.Map <SaveBookResource, Book>(sbResource);
book.LastUpdate = DateTime.Now;
bookRepository.AddBookAsync(book);
await unitOfWork.CompleteAsync();
var newBook = await bookRepository.GetBookByIdAsync(book.Id);
_logger.LogInformation(new EventId(), null, newBook, null);
return(Ok(mapper.Map <Book, BookResource>(newBook)));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult Put(int id, [FromBody] SaveBookResource form)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = _repository.GetBook(id);
if (model == null)
{
return(NotFound());
}
_mapper.Map <SaveBookResource, Book>(form, model);
_unitOfWork.Complete();
var book = _repository.GetBook(model.Id);
var result = _mapper.Map <Book, BookResource>(book);
return(Ok(result));
}
