public ActionResult UpdateBook(int id)
{
GetAuthorAndCategories();
using (var context = new DataContext())
{
var book = context.Books.Include("Author").Include("Categories").Include("Author.Country").FirstOrDefault(b => b.Id == id);
var updateBook = new UpdateBook
{
Id = book.Id,
Name = book.Name,
Year = book.Year,
NumberPages = book.NumberPages,
Description = book.Description,
TodayBestChoice = book.TodayBestChoice,
Rating = book.Rating,
ForAuthorize = book.ForAuthorize,
AuthorId = book.Author.Id,
CategoryId = book.Categories.FirstOrDefault().Id,
ImageName = book.Image
};
return(View(updateBook));
}
}
public async Task <IActionResult> EditBook(int bookId)
{
var bookDto = _mapper.Map <BookDto>(await _bookService.GetByIdAsync(bookId));
var command = new UpdateBook(bookDto);
return(View(command));
}
public async Task <IActionResult> Put(Guid id, [FromBody] UpdateBook command)
{
var book = await _context.Books.FindAsync(id);
if (book == null)
{
return(NotFound());
}
book.Title = command.Title;
book.Author = command.Author;
book.Cost = command.Cost;
book.InventoryAmount = command.InventoryAmount;
_context.Books.Update(book);
await _context.SaveChangesAsync();
var @event = new BookUpdated
{
Id = book.Id,
Author = book.Author,
Cost = book.Cost,
Title = book.Title,
InventoryAmount = book.InventoryAmount,
UserId = command.UserId,
Timestamp = DateTime.UtcNow
};
await _messageProducer.PublishAsync(@event);
return(Ok());
}
public async Task <IActionResult> Put([FromBody] UpdateBook command)
{
if (command == null)
{
return(BadRequest());
}
await CommandDispatcher.DispatchAsync(command);
return(NoContent());
}
public UpdateBookShould()
{
_bookServiceMock = new Mock <IBookService>();
_loggerMock = new Mock <ILogger <UpdateBook> >();
_mapperMock = new Mock <IMapper>();
_httpRequestMock = new Mock <HttpRequest>();
_func = new UpdateBook(
_bookServiceMock.Object,
_loggerMock.Object,
_mapperMock.Object);
}
public async Task <IActionResult> Patch(Guid id, [FromBody] UpdateBookRequest request)
{
if (id == Guid.Empty || !ModelState.IsValid)
{
return(BadRequest());
}
var command = new UpdateBook(request.ToBook(id), UserId);
await Mediator.Send(command);
return(Ok());
}
public async Task <Books> Update(UpdateBook input)
{
var updateBook = await Get(input.Id);
updateBook.Name = input.Name;
updateBook.Author = input.Author;
updateBook.Description = input.Description;
_context.Books.Update(updateBook);
await _context.SaveChangesAsync();
return(updateBook);
}
public async Task <ActionResult> Update(int id)
{
var model = await _booksService.Get(id);
UpdateBook updateModel = new UpdateBook
{
Id = model.Id,
CreatorUserId = model.CreatorUserId,
Description = model.Description,
Name = model.Name,
Author = model.Author
};
return(View(updateModel));
}
public async Task <IActionResult> UpdateBook(UpdateBook command)
{
if (!ModelState.IsValid)
{
return(View("EditBook", command));
}
var success = await _bookService.UpdateAsync(command);
if (!success)
{
return(View("EditBook", command));
}
return(RedirectToAction("Books"));
}
public IActionResult Update(UpdateBook model)
{
if (ModelState.IsValid)
{
var result = new UpdateBookResult();
result = Helper.ApiHelper <UpdateBookResult> .HttpPostAsync("api/Book/update", "POST", model);
if (result.BookId > 0)
{
return(RedirectToAction("index"));
}
ModelState.AddModelError("", result.Message);
return(View(model));
}
return(View(model));
}
public IActionResult UpdateBookForAuthor(Guid id, Guid authorId,
[FromBody] UpdateBook book)
{
if (book == null)
{
return(BadRequest());
}
if (book.Description == book.Title)
{
ModelState.AddModelError(nameof(UpdateBook), "The description should differ from the title.");
}
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
var existingBook = _libraryRepository.GetBookForAuthor(authorId, id);
if (existingBook == null)
{
var bookToAdd = Mapper.Map <Entities.Book>(book);
bookToAdd.Id = id;
_libraryRepository.AddBookForAuthor(authorId, bookToAdd);
if (!_libraryRepository.Save())
{
throw new Exception($"Upserting couldn't save the book {id}");
}
var bookToReturn = Mapper.Map <Book>(bookToAdd);
return(CreatedAtRoute(nameof(GetBookForAuthor), new { authorId, id }, bookToReturn));
}
Mapper.Map(book, existingBook);
_libraryRepository.UpdateBookForAuthor(existingBook);
if (!_libraryRepository.Save())
{
throw new Exception($"Cound't save the updated book {id}");
}
return(NoContent());
}
public ActionResult UpdateBook(UpdateBook book)
{
if (!ModelState.IsValid)
{
GetAuthorAndCategories();
return(View(book));
}
using (var context = new DataContext())
{
var updateBook = context.Books.Include("Categories").Include("Author").Include("Author.Country").FirstOrDefault(b => b.Id == book.Id);
if (book.BookCover != null)
{
string bookCover = Guid.NewGuid().ToString().Substring(0, 10) + "_" + System.IO.Path.GetFileName(book.BookCover.FileName);
WebImage img = new WebImage(book.BookCover.InputStream);
img.Resize(380, 600);
img.Save(Server.MapPath("~/Content/images/book/" + bookCover));
updateBook.Image = bookCover;
}
if (book.BookFile != null)
{
string bookPath = Guid.NewGuid().ToString().Substring(0, 10) + "_" + System.IO.Path.GetFileName(book.BookFile.FileName);
book.BookFile.SaveAs(Server.MapPath("~/Content/books/" + bookPath));
updateBook.BookPath = bookPath;
}
updateBook.Name = book.Name;
updateBook.Slug = book.Name.GenerateSlug();
updateBook.Year = book.Year;
updateBook.NumberPages = book.NumberPages;
updateBook.Author = context.Authors.FirstOrDefault(a => a.Id == book.AuthorId);
updateBook.Description = book.Description;
updateBook.View = 0;
updateBook.Rating = book.Rating;
updateBook.ForAuthorize = book.ForAuthorize;
updateBook.TodayBestChoice = book.TodayBestChoice;
updateBook.Create = DateTime.Now;
updateBook.Categories = context.Categories.Where(c => c.Id == book.CategoryId).ToList();
context.SaveChanges();
}
return(Redirect("/admin/books"));
}
public async Task <ActionResult> Update(UpdateBook model)
{
if (ModelState.IsValid)
{
var updatedBook = await _booksService.Update(model);
UpdateBook updateModel = new UpdateBook
{
Id = updatedBook.Id,
CreatorUserId = updatedBook.CreatorUserId,
Description = updatedBook.Description,
Name = updatedBook.Name,
Author = updatedBook.Author
};
return(View(updateModel));
}
return(View(model));
}
public async Task Handle(UpdateBook message, CancellationToken cancellationToken)
{
var oldBook = await BookEntityHandler.Get(message.Book.Id);
if (oldBook == null)
{
throw new EntityNotFoundException <Book>(message.Book);
}
await CheckAndAddAuthors(message.Book, message.UserId);
var newBook = oldBook.Update(message.Book, DateTime.UtcNow);
BookEntityHandler.Update(newBook);
await Mediator.Send(new SaveChanges());
await Mediator.Publish(new BookUpdated(newBook, oldBook, message.UserId));
}
public BookViewModel(MainViewModel mainViewModel)
{
Books = new ObservableCollection <BookEntity>();
filials = new List <FilialEntity>();
BuyBookCMD = new BuyBook(mainViewModel, this);
RentCMD = new Rent(mainViewModel, this);
addBook = new AddBook(this);
DeleteBook = new DeleteBook(this);
UpdateBook = new UpdateBook(this);
currentbook = new BookEntity();
selectbook = new BookEntity();
//if (File.Exists("Filials.json"))
//{
// string jsonFilial = File.ReadAllText("Filials.json");
// this.filials = JsonConvert.DeserializeObject<List<FilialEntity>>(jsonFilial);
//}
//if (File.Exists("Books.json"))
//{
// string jsonBook = File.ReadAllText("Books.json");
// this.Books = JsonConvert.DeserializeObject<ObservableCollection<BookEntity>>(jsonBook);
//}
}
public async Task <bool> UpdateAsync(UpdateBook command)
{
try
{
var isSuccess = false;
var book = await GetByIdAsync(command.Id);
if (book != null)
{
book.Update(command.Title, command.Author, command.Description, command.ReleaseDate);
_context.Books.Update(book);
await _context.SaveChangesAsync();
isSuccess = true;
}
return(isSuccess);
}
catch (Exception)
{
return(false);
}
}
public IActionResult PartiallyUpdateBookForAuthor(Guid id, Guid authorId, [FromBody] JsonPatchDocument <UpdateBook> patchDocument)
{
if (patchDocument == null)
{
return(BadRequest());
}
var existingBook = _libraryRepository.GetBookForAuthor(authorId, id);
if (existingBook == null)
{
var bookDto = new UpdateBook();
patchDocument.ApplyTo(bookDto, ModelState);
TryValidateModel(bookDto);
if (ModelState.IsValid && bookDto.Description == bookDto.Title)
{
ModelState.AddModelError(nameof(CreateBook), "The description should differ from the title.");
}
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
var bookToAdd = Mapper.Map <Entities.Book>(bookDto);
bookToAdd.Id = id;
_libraryRepository.AddBookForAuthor(authorId, bookToAdd);
if (!_libraryRepository.Save())
{
throw new Exception($"Upserting couldn't save the book {id}");
}
var bookToReturn = Mapper.Map <Book>(bookToAdd);
return(CreatedAtRoute(nameof(GetBookForAuthor), new { authorId, id }, bookToReturn));
}
var bookToPatch = Mapper.Map <UpdateBook>(existingBook);
patchDocument.ApplyTo(bookToPatch, ModelState);
TryValidateModel(bookToPatch);
if (ModelState.IsValid && bookToPatch.Description == bookToPatch.Title)
{
ModelState.AddModelError(nameof(CreateBook), "The description should differ from the title.");
}
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
Mapper.Map(bookToPatch, existingBook);
_libraryRepository.UpdateBookForAuthor(existingBook);
if (!_libraryRepository.Save())
{
throw new Exception($"Patching book {id} for author {authorId} failed to save");
}
return(NoContent());
}
