public IActionResult UpdateBook(int id)
{
var model = new UpdateBookModel();
model.Load(id);
return(View(model));
}
public IActionResult UpdateBook(
[Bind(nameof(UpdateBookModel.Id),
nameof(UpdateBookModel.Title),
nameof(UpdateBookModel.Author),
nameof(UpdateBookModel.Edition))] UpdateBookModel model)
{
if (ModelState.IsValid)
{
try
{
model.Edit();
model.Response = new ResponseModel("Book creation successful.", ResponseType.Success);
return(RedirectToAction("Index"));
}
catch (DuplicationException ex)
{
model.Response = new ResponseModel(ex.Message, ResponseType.Failure);
// error logger code
}
catch (Exception ex)
{
model.Response = new ResponseModel("Book creation failued.", ResponseType.Failure);
// error logger code
}
}
return(View(model));
}
public async Task <RedirectToActionResult> EditBook([FromRoute] Guid guid, [FromForm] UpdateBookModel bookModel)
{
bookModel.BookGuid = guid;
await _booksService.Update(bookModel);
return(RedirectToAction(nameof(ReadAll)));
}
public async Task <IActionResult> Put(int id, [FromBody] UpdateBookModel model)
{
string error = "";
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var oldBook = _repository.GetBook(id);
if (oldBook == null)
{
return(NotFound($"Couldn't find a book of {id}"));
}
model.category = oldBook.Category;
_mapper.Map(model, oldBook);
if (await _repository.SaveAllAsync())
{
return(Ok(_mapper.Map <UpdateBookModel>(oldBook)));
}
}
catch (Exception e)
{
error = e.Message;
}
return(BadRequest(string.Format("Could not update book: {0}", error)));
}
public IActionResult UpdateBookPrice(UpdateBookModel updateBookModel)
{
try
{
if (updateBookModel.BookId > 0 && updateBookModel.Price > 0)
{
var data = this.bookBL.UpdateBookPrice(updateBookModel);
if (data != null)
{
return(this.Ok(new { status = "True", message = "Book Updated Successfully", data }));
}
else
{
return(this.BadRequest(new { status = "False", message = "Failed To Upate Book" }));
}
}
else
{
return(this.BadRequest(new { status = "false", message = "Book Id Must Be Greater Than 0" }));
}
}
catch (Exception exception)
{
return(BadRequest(new { message = exception.Message }));
}
}
public void UpdateBook(Guid authorId, Guid bookId, UpdateBookModel model)
{
var child = _repository.Get(authorId).Books.SingleOrDefault(book => book.Id == bookId);
Debug.Assert(child != null, nameof(child) + " != null");
child.Summary = model.Summary;
child.Title = model.Title;
child.Genre = model.Genre;
}
public IActionResult EditBook(UpdateBookModel book)
{
if (ModelState.IsValid)
{
DataStore.Books.UpdateBook(book);
return(RedirectToAction("Index", "Home"));
}
return(View(book));
}
public BookAddModel UpdateBookPrice(UpdateBookModel updateBookModel)
{
try
{
return(this.bookRL.UpdateBookPrice(updateBookModel));
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public void Update_Book_By_Price_Return_OkResult()
{
var data = new UpdateBookModel()
{
BookId = 9,
Price = 240
};
var response = bookController.UpdateBookPrice(data);
Assert.IsType <OkObjectResult>(response);
}
public void Update_Book_By_Price_Price_LessThan_Zero_Return_BadObjectResult()
{
var data = new UpdateBookModel()
{
BookId = 13,
Price = 0
};
var response = bookController.UpdateBookPrice(data);
Assert.IsType <BadRequestObjectResult>(response);
}
public bool Update([FromBody] UpdateBookModel model)
{
var entity = Context.BookRepos.Where(o => o.Id == model.Id).FirstOrDefault();
if (entity == null)
{
throw new Exception();
}
entity.Name = model.Name;
entity.Price = model.Price;
entity.PublishDate = model.PublishDate;
entity.Description = model.Description;
return(Context.SaveChanges() > 0);
}
public IActionResult EditBook(int bookId)
{
if (!IsLoged)
{
return(RedirectToAction("Index", "Home"));
}
if (bookId >= 0)
{
try
{
var book = new UpdateBookModel(DataStore.Books.GetBook(bookId));
book.ID = bookId;
return(View(book));
}
catch (Exception) { }
}
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// update book by book price
/// </summary>
/// <param name="updateBookModel"></param>
/// <returns></returns>
public BookAddModel UpdateBookPrice(UpdateBookModel updateBookModel)
{
try
{
DatabaseConnection databaseConnection = new DatabaseConnection(this.configuration);
SqlConnection sqlConnection = databaseConnection.GetConnection();
SqlCommand sqlCommand = databaseConnection.GetCommand("UpdateBookPrice", sqlConnection);
sqlCommand.Parameters.AddWithValue("@BookId", updateBookModel.BookId);
sqlCommand.Parameters.AddWithValue("@Price", updateBookModel.Price);
sqlConnection.Open();
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
BookAddModel bookAddModel = new BookAddModel();
while (sqlDataReader.Read())
{
bookAddModel = new BookAddModel();
bookAddModel.Id = (int)sqlDataReader["Id"];
bookAddModel.BooKTitle = sqlDataReader["Book_Title"].ToString();
bookAddModel.Author = sqlDataReader["Author"].ToString();
bookAddModel.Language = sqlDataReader["Language"].ToString();
bookAddModel.Category = sqlDataReader["Category"].ToString();
bookAddModel.ISBN = (int)sqlDataReader["ISBN_No"];
bookAddModel.Price = (int)sqlDataReader["Price"];
bookAddModel.Pages = (int)sqlDataReader["Pages"];
bookAddModel.CreatedDate = Convert.ToDateTime(sqlDataReader["CreatedDate"]);
bookAddModel.ModifiedDate = DateTime.Now;
if (bookAddModel.Id == updateBookModel.BookId)
{
return(bookAddModel);
}
}
sqlConnection.Close();
return(null);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <inheritdoc />
public async Task Update(UpdateBookModel model)
{
var book = await _context.Books.FindAsync(model.BookGuid);
book.BuyUri = model.BuyUri;
book.Annotation = model.Annotation;
book.Cost = model.Cost;
book.Cover = model.Cover;
book.Format = model.Format;
book.Title = model.Title;
book.Year = model.Year;
book.AuthorGuid = model.AuthorGuid;
book.BookGuid = model.BookGuid;
book.ImageUri = model.ImageUri;
book.PublishingGuid = model.PublishingGuid;
book.TechnologyGuid = model.TechnologyGuid;
book.NumberOfPages = model.NumberOfPages;
book.CreationDateTimeOffset = DateTimeOffset.Now;
_context.Books.Update(book);
await _context.SaveChangesAsync();
}
public Task <Response <Book> > UpdateBook(UpdateBookModel bookViewModel)
{
throw new NotImplementedException();
}
public IActionResult Update(Guid authorId, Guid bookId, [FromBody] UpdateBookModel model)
{
BookService.UpdateBook(authorId, bookId, model);
return(Ok());
}
