public async Task <IActionResult> DeleteBook(int libraryId, int bookId, CancellationToken token)
{
var request = new DeleteBookRequest(libraryId, bookId, _userHelper.Account?.Id);
await _commandProcessor.SendAsync(request, cancellationToken : token);
return(new NoContentResult());
}
public async Task delete_should_returns_no_content_when_called_with_right_id(DeleteBookRequest request)
{
var client = _factory.CreateClient();
var response = await client.DeleteAsync($"/api/books/{request.Id}");
response.StatusCode.ShouldBe(HttpStatusCode.NoContent);
}
public async Task <BaseResponse <bool> > Handle(DeleteBookRequest request, CancellationToken cancellationToken)
{
BaseResponse <Boolean> response = new BaseResponse <bool>();
try
{
var book = await _repository.GetBookById(request.Id);
if (book == null)
{
response.Errors.Add("Böyle bir kitap bulunamadı.");
response.Data = false;
}
else
{
await _repository.Delete(request.Id);
await _bus.Publish(request.Adapt <BookDeletedEvent>(), cancellationToken);
response.Data = true;
}
}
catch (Exception e)
{
Console.WriteLine(e);
response.Errors.Add(e.Message);
response.Data = false;
}
return(response);
}
public async Task <IActionResult> DeleteBook([FromBody] DeleteBookRequest request)
{
Book book = await _bookService.GetById(request.Id);
book.IsActive = false;
_bookService.Update(book);
return(Ok());
}
public async Task <IActionResult> Delete(Guid id)
{
var request = new DeleteBookRequest {
Id = id
};
await _bookService.DeleteBookAsync(request);
return(NoContent());
}
public async Task <IActionResult> Delete(Guid id)
{
var request = new DeleteBookRequest()
{
Id = id
};
await HandleUseCase <DeleteBookRequest, DeleteBookResponse>(request);
return(NoContent());
}
public HttpResponseMessage DeleteBooks([FromUri] DeleteBookRequest bookReq)
{
try
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public async Task <IActionResult> DeleteBookAsync(string id)
{
DeleteBookRequest deleteBookRequest = new DeleteBookRequest();
deleteBookRequest.Id = id;
(bool succeed, string message, DeleteBookResponse deleteBookResponse) = await Mediator.Send(deleteBookRequest);
if (succeed)
{
return(Ok(deleteBookResponse.ToResponse()));
}
return(BadRequest(message.ToResponse(false, message)));
}
public async Task <bool> Handle(DeleteBookRequest message, IOutputPort <DeleteBookResponse> outputPort)
{
Book book = await _bookRepository.GetById(message.Id);
if (book == null)
{
outputPort.Handle(new DeleteBookResponse(message: $"The book with id:{message.Id} does not exist"));
return(false);
}
//TODO:Handle Foreign Key integrity
await _bookRepository.Delete(book);
return(true);
}
public DeleteBookResponse DeleteBook(DeleteBookRequest request)
{
DeleteBookResponse response = new DeleteBookResponse();
try
{
_bookRepository.Delete(request.BookId);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <DeleteBookResult> DeleteBook(DeleteBookRequest request)
{
try
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@BookId", request.BookId);
return(await SqlMapper.QueryFirstOrDefaultAsync <DeleteBookResult>(cnn : connect,
sql : "sp_DeleteBook",
param : parameters,
commandType : CommandType.StoredProcedure));
}
catch (Exception ex)
{
throw;
}
}
public override async Task <DeleteBookResponse> DeleteBook(DeleteBookRequest request, ServerCallContext context)
{
Book book = await _bookContext.Books.FindAsync(request.BookId);
if (book == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Book with Id = {request.BookId} is not found."));
}
_bookContext.Books.Remove(book);
int deleteCount = await _bookContext.SaveChangesAsync();
return(new DeleteBookResponse
{
Success = deleteCount > 0
});
}
public ActionResult Delete(int id)
{
DeleteBookRequest request = new DeleteBookRequest()
{
BookId = id
};
DeleteBookResponse response = _bookService.DeleteBook(request);
if (response.Success)
{
return(RedirectToAction("Index"));
}
else
{
BookListPageViewModel model = new BookListPageViewModel();
model.Success = false;
model.Message = response.Message;
return(View("Index", model));
}
}
public async Task <BookResponse> DeleteBookAsync(DeleteBookRequest request)
{
if (request?.Id == null)
{
throw new ArgumentNullException();
}
var result = await _bookRepository.GetAsync(request.Id);
result.IsInactive = true;
_bookRepository.Update(result);
await _bookRepository.UnitOfWork.SaveChangesAsync();
_eventBus.Publish(new BookDeleteIntegrationEvent(request.Id.ToString()));
SendDeleteMessage(new ItemSoldOutEvent {
Id = request.Id.ToString()
});
return(_bookMapper.Map(result));
}
public ResponseBase DeleteBook(DeleteBookRequest request)
{
var response = new ResponseBase();
try
{
var book = _bookRepository.GetById(request.Id);
_bookRepository.Delete(book);
_bookUnitOfWork.Commit();
response.TransactionMessage = "Book deleted Successfully";
response.TransactionStatus = true;
}
catch (InvalidBookException ex)
{
response.TransactionMessage = "Book deletion failed";
response.TransactionStatus = false;
LoggingFactory.GetLogger().Log(ex.Message.ToString());
}
return(response);
}
public async Task <BaseResponse <bool> > Handle(DeleteBookRequest request, CancellationToken cancellationToken)
{
BaseResponse <Boolean> response = new BaseResponse <bool>();
try
{
var deleteObject = (await _repository.SearchAsyncWithBookId <Book, int>(request.Id)).FirstOrDefault(p => p.Id == request.Id);
if (deleteObject != null)
{
var deleteBook = await _repository.DeleteAsync <Book, int>(deleteObject);
if (deleteBook)
{
response.Data = true;
}
else
{
response.Errors.Add("Kitap silinirken hata oluştu.");
response.Data = true;
}
}
else
{
response.Errors.Add("Silinecek kitap null geldi.");
response.Data = false;
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
response.Errors.Add(exception.Message);
response.Data = false;
}
return(response);
}
public async Task <BaseResponse <Boolean> > DeleteBookAsync(DeleteBookRequest deleteBookRequest)
{
BaseResponse <Boolean> response = await _mediator.Send(deleteBookRequest);
return(response);
}
// delete book
public override Task <Empty> DeleteBook(DeleteBookRequest request, ServerCallContext context)
{
_shelfBookRepository.DeleteBook(request.Shelf, request.Book);
return(Task.FromResult(new Empty()));
}
public async Task <IActionResult> DeleteBook([FromRoute] DeleteBookRequest request)
{
await _bookRepository.DeleteBook(request.Id.ToString());
return(NoContent());
}
public async Task <DeleteBookResult> DeleteBook(DeleteBookRequest request)
{
return(await bookRepository.DeleteBook(request));
}
public async Task <OkObjectResult> Delete(DeleteBookRequest request)
{
return(Ok(await bookService.DeleteBook(request)));
}
