public IActionResult Delete(int id)
{
Books _booksDb = _booksRepository.GetSingle(id);
if (_booksDb == null)
{
return(new NotFoundResult());
}
else
{
IEnumerable <Order> _order = _orderRepository.FindBy(b => b.BookId == id);
foreach (var order in _order)
{
_orderRepository.Delete(order);
// _orders = _orderRepository.FindBy(o => o.BookId == books.Id);
}
_booksRepository.Delete(_booksDb);
_booksRepository.Commit();
return(new NoContentResult());
}
}
public async Task <Unit> Handle(DeleteBookCommand request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Deleting book with ID: {request.BookId}.");
await _repository.Delete(request.BookId);
return(Unit.Value);
}
public void Delete(int id)
{
var book = _booksRepository.GetById(id);
if (book != null)
{
_booksRepository.Delete(book);
}
}
public void Delete(int id)
{
var dbBook = booksRepository.GetById(id);
if (dbBook != null)
{
booksRepository.Delete(dbBook);
}
}
public async Task DeleteBookCommand_should_return_call_Delete_repository_method()
{
// Arrange
// Act
await _handler.Handle(new DeleteBookCommand(Guid.Empty), default);
// Assert
A.CallTo(() => _repository.Delete(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
}
public IActionResult Delete(int id)
{
var deleted = books.Delete(id);
if (!deleted)
{
return(StatusCode(500));
}
return(NoContent());
}
public async Task Delete(int id)
{
try
{
await _booksRepository.Delete(id);
}
catch (Exception c)
{
BadRequest($"Dont delete book with id {id}");
}
}
public virtual IActionResult Delete(Guid id)
{
Book book = booksRepository.Delete(id);
if (book == null)
{
return(this.NotFound());
}
else
{
return(this.Ok(book.ID));
}
}
public IActionResult Delete(int id)
{
try
{
_rep.Delete(id);
_rep.UnitOfWork.SaveChanges();
return(Ok(ApiResponse.Ok(id)));
}
catch (Exception e)
{
return(BadRequest(ApiResponse.Error(id, e.Message)));
}
}
public async Task <IActionResult> Delete(long isbn, Book book)
{
var bookToDelete = await _booksRepository.Get(isbn);
await _booksRepository.Delete(bookToDelete);
if (book == null)
{
return(NotFound("The Book record could not be found"));
}
return(NoContent());
}
public bool Delete(int id)
{
var deleted = repository.Delete(id);
if (deleted)
{
logger.LogDebug($"Clean cache: {GetAllCacheKey} and {GetSingleCacheKeyPrefix + id}");
cache.Remove(GetAllCacheKey);
cache.Remove(GetSingleCacheKeyPrefix + id);
}
return(deleted);
}
public IActionResult Delete(int bookId)
{
var bookToDelete = _booksRepository.GetById(bookId);
if (bookToDelete == null)
{
return(NotFound());
}
_booksRepository.Delete(bookId);
return(new NoContentResult());
}
public ActionResult DeleteConfirmed(int?id)
{
if (id == null)
{
return(View("Error"));
}
book book = db.books.SingleOrDefault(b => b.book_id == id);
if (book == null)
{
return(View("Error"));
}
db.Delete(book);
return(RedirectToAction("Index"));
}
public async Task Delete(int authorId, int bookId)
{
if (await authorsRepository.Exists(authorId))
{
throw new NotFoundException("Author", authorId);
}
var bookToUpdate = await booksRepository.GetById(bookId);
if (await booksRepository.Exists(bookId))
{
throw new NotFoundException("Book", bookId);
}
await booksRepository.Delete(bookId);
}
public IActionResult DeleteBook(int id)
{
var book = _booksRepository.GetBook(id);
if (book == null)
{
ViewBag.ErrorMessage = $"Book with Id = {id} cannot be found";
return(View("NotFound"));
}
else
{
_booksRepository.Delete(id);
return(RedirectToAction("index"));
}
}
public IActionResult Delete(int id)
{
Author _authorDb = _authorRepository.GetSingle(id);
if (_authorDb == null)
{
return(new NotFoundResult());
}
else
{
IEnumerable <Books> _books = _booksRepository.FindBy(b => b.AuthorId == id);
// IEnumerable<Order> _orders= _orderRepository.GetAll();
foreach (var books in _books)
{
_booksRepository.Delete(books);
IEnumerable <Order> _orders = _orderRepository.FindBy(o => o.BookId == books.Id);
foreach (var order in _orders)
{
_orderRepository.Delete(order);
}
}
//foreach (var order in _orders)
//{
// _orderRepository.Delete(order);
// //_orders = _orderRepository.FindBy(o => o.BookId == books.Id);
//}
_authorRepository.Delete(_authorDb);
_authorRepository.Commit();
return(new NoContentResult());
}
}
/// <summary>
/// Performs business logic while retrieving Deleting the specified book.
/// </summary>
/// <param name="id">The book identifier.</param>
/// <returns>booolean status in 1/0 format</returns>
public async Task <int> Delete(int id)
{
return(await _repository.Delete(id));
}
public IActionResult Delete(Book book)
{
_repository.Delete(book);
return(Redirect("Index"));
}
public void Delete(int id)
{
booksRepository.Delete(id);
}
public ActionResult Delete(int id)
{
repo.Delete(id);
return(RedirectToAction("ListOfBooks"));
}
public void Delete(int id)
{
repository.Delete(id);
}
public PageResult OnGet(int id)
{
_booksRepository.Delete(id);
return(Page());
}
public async Task <IActionResult> Delete(string id)
{
await booksRepository.Delete(id);
return(Ok("Book deleted"));
}
public IActionResult Delete(long id)
{
_booksRepository.Delete(id);
return(NoContent());
}
public ActionResult Delete(int id)
{
booksRepository.Delete(id);
return(Json(id));
}
public async Task DeleteAndSave(string Id)
{
_booksRepo.Delete(Id);
await _booksRepo.Save();
}
public void DeleteBook(string isbn)
{
booksRepository.Delete(isbn);
}
public virtual ActionResult DeleteConfirmed(int id)
{
_booksRepository.Delete(id);
return(RedirectToAction("Index"));
}
// DELETE: api/Books/5
public HttpResponseMessage Delete(int id)
{
bool deleted = _booksRepository.Delete(id);
return(Request.CreateResponse <bool>(HttpStatusCode.OK, deleted));
}
