public async Task <IActionResult> Delete(Guid id)
{
var deleteCommand = new DeleteBookCommand(id);
var result = await _mediator.Send(deleteCommand);
return(result != null ? (IActionResult)Ok(result) : NotFound());
}
public async Task <IActionResult> DeleteBook([FromRoute] Guid bookId)
{
var deleteBookCommand = new DeleteBookCommand(new BookId(bookId));
await _executionContext.ExecuteAsync(deleteBookCommand, CancellationToken.None);
return(StatusCode((int)HttpStatusCode.OK));
}
public async Task <IActionResult> DeleteConfirmed(Book book)
{
var request = new DeleteBookCommand(book.ID);
var result = await _mediator.Send(request);
return(Result(request, result));
}
public async Task <IActionResult> DeleteBook(int id)
{
var command = new DeleteBookCommand(id);
var result = await _mediator.Send(command);
return(Ok(result));
}
public void HandleCommand(DeleteBookCommand command)
{
Book book = DomainRepository.Get <Book>(command.AggregateRootId);
book.DeleteBook(command.AggregateRootId);
DomainRepository.Save(book);
DomainRepository.Commit();
}
public async Task <Unit> Handle(DeleteBookCommand request, CancellationToken cancellationToken)
{
var book = _context.Books.Single(x => x.Id == request.Id);
_context.Books.Remove(book);
await _context.SaveChangesAsync();
return(Unit.Value);
}
public async Task <BookDTO> Handle(DeleteBookCommand request, CancellationToken cancellationToken)
{
var book = _unitOfWork.GetRepository <Book>().Find(request.Id);
var category = _unitOfWork.GetRepository <Category>().Find(book.categoryId);
_unitOfWork.GetRepository <Book>().Delete(book);
_unitOfWork.SaveChanges();
return(_mapper.Map <BookDTO>(book));
}
public void DeleteBook(Guid bookAggregateRootId)
{
DeleteBookCommand command = new DeleteBookCommand
{
BookAggregateRootId = bookAggregateRootId
};
CommitCommand(command);
}
public ResponseResult Handle(DeleteBookCommand command)
{
var book = _bookRepository.Get(command.Id);
book.Desativar();
_unitOfWork.Commit();
return(new ResponseResult("Livro excluído com sucesso", true, book));
}
public async Task <ActionResult> DeleteBook(int id)
{
var deleteBookCommand = new DeleteBookCommand()
{
Id = id
};
await _mediator.Send(deleteBookCommand);
return(NoContent());
}
public IActionResult Delete(DeleteBookCommand command)
{
var result = _deleteBookCommandHandler.Handle(command);
if (result.Success)
{
return(Ok(command));
}
return(BadRequest(result.Errors));
}
public void Should_Not_Remove_When_Command_Is_Invalid()
{
//Arrange
var deleteBookCommand = new DeleteBookCommand {
Id = Guid.NewGuid()
};
//Act
_deleteBookCommandHandler.Handle(deleteBookCommand);
//Assert
_bookRepository.Verify(r => r.Delete(It.IsAny <Guid>()), Times.Never);
_eventPublisher.Verify(p => p.Publish(It.IsAny <DeleteBookEvent>()), Times.Never);
}
public void Should_Remove_When_Command_Is_Valid()
{
//Arrange
var deleteBookCommand = new DeleteBookCommand {
Id = _bookId
};
//Act
_deleteBookCommandHandler.Handle(deleteBookCommand);
//Assert
_bookRepository.Verify(r => r.Delete(_bookId), Times.Once);
_eventPublisher.Verify(p => p.Publish(It.IsAny <DeleteBookEvent>()), Times.Once);
}
public async Task Delete_Book()
{
using (var context = GetContextWithData())
{
var handler = new DeleteBookCommandHandler(context);
var command = new DeleteBookCommand
{
Id = (await context.Books.FirstOrDefaultAsync()).Id
};
await handler.Handle(command, CancellationToken.None);
Assert.Null(await context.Books.FindAsync(command.Id));
}
}
public ActionResult Delete(int id)
{
if (id == 0)
{
return(NotFound());
}
var command = new DeleteBookCommand {
Id = id
};
_commandAdapter.Dispatch(command);
return(Ok());
}
public async Task Handle_ValidCommand_BookDeleted()
{
var bookId = 1;
var command = new DeleteBookCommand()
{
BookId = bookId
};
_bookRepositoryMock.Setup(x => x.GetAsync(bookId))
.ReturnsAsync(new Book("Title", new Author("FirstName", "LastName"), 2020, "Description"));
await _sut.Handle(command, CancellationToken.None);
_bookRepositoryMock.Verify(x => x.DeleteAsync(It.IsAny <int>()), Times.Once);
}
public BooksViewModel()
{
updateBookCommand = new UpdateBookCommand(this);
addBookCommand = new AddBookCommand(this);
deleteBookCommand = new DeleteBookCommand(this);
booksList = new ObservableCollection <BookModel> {
};
typeBookList = new ObservableCollection <string> {
};
authorsList = new ObservableCollection <string> {
};
titleList = new ObservableCollection <string> {
};
readAuthors();
readTitles();
readTypes();
DataGrid_Loaded();
}
public BookSearchVM(IBookManager _bookManager, IValidation _validation)
{
bookManager = _bookManager;
validation = _validation;
SearchBooksCommand = new SearchBookCommand(this);
DeleteBookCommand = new DeleteBookCommand(this);
OpenUpdateCommand = new OpenBookUpdateWindowCommand(this);
UpdateBookCommand = new UpdateBookCommand(this);
EnableCheckOutCommand = new EnableBookCheckOutCommand(this);
EnableCheckInCommand = new EnableBookCheckInCommand(this);
CheckOutCommand = new BookCheckOutCommand(this);
CheckInCommand = new BookCheckInCommand(this);
ViewBookHistoryCommand = new ViewBookHistoryCommand(this);
Books = new ObservableCollection <Book>();
BookHistory = new List <BookTransaction>();
}
public void Book_Must_Exist(Domain.Entities.Book book, bool result)
{
//Assert
var deleteBookCommand = new DeleteBookCommand {
Id = _bookId
};
var bookRepository = new Mock <IBookRepository>();
bookRepository.Setup(r => r.GetById(_bookId)).Returns(book);
_deleteBookCommandValidator = new DeleteBookCommandValidator(bookRepository.Object);
//Act
var validationResult = _deleteBookCommandValidator.Validate(deleteBookCommand);
//Assert
validationResult.IsValid.Should().Be(result);
}
public IActionResult DeleteBook(Guid id)
{
if (ModelState.IsValid)
{
DeleteBookCommand deleteBookCommand = new DeleteBookCommand(id);
try
{
var result = _messages.Dispatch(deleteBookCommand);
return(Ok(result));
}
catch (DomainException ex)
{
_logger.LogError(ex.Message);
return(Error(ex.Message));
}
catch (Exception ex)
{
_logger.LogCritical(ex.Message);
return(StatusCode(500));
}
}
return(BadRequest());
}
public Task <IActionResult> DeleteAsync(
[FromServices] DeleteBookCommand command,
long bookId,
CancellationToken cancellationToken) => command.ExecuteAsync(bookId, cancellationToken);
public async Task <IActionResult> DeleteBook(DeleteBookCommand deleteBookCommand)
{
var isSuccess = await mediator.Send(deleteBookCommand, HttpContext.RequestAborted).ConfigureAwait(false);
return(isSuccess ? Ok() : (IActionResult)NotFound());
}
public async Task <ActionResult <Unit> > DeleteBook([FromRoute] Guid id, [FromBody] DeleteBookCommand data)
{
data.Id = id;
return(await Mediator.Send(data));
}
public async Task <IActionResult> DeleteBook([FromBody] DeleteBookCommand command)
{
await _mediator.Send(command, HttpContext.RequestAborted);
return(Ok());
}
public async Task <ActionResult> Delete(
[FromRoute] DeleteBookCommand command)
=> await this.Send(command);
