public async Task <IActionResult> DeleteCategory(int id) { var command = new DeleteCategoryCommand(id); var result = await _mediator.Send(command); return(Ok(result)); }
public async Task Category_Delete() { var connection = TestHelper.GetConnection(); var options = TestHelper.GetMockDBOptions(connection); try { using (var context = new AppcentTodoContext(options)) { var service = new DeleteCategoryCommandHandler(context); var command = new DeleteCategoryCommand(); command.Data = new DeleteCategoryRequest { CategoryId = 1, UserName = "******" }; var result = await service.Execute(command); Assert.True(result.Result.IsSuccess); } using (var context = new AppcentTodoContext(options)) { var task = context.AcCategories.FirstOrDefault(e => e.CategoryId == 1); Assert.True(task.IsDeleted); } } finally { connection.Close(); } }
public async Task <BaseApiResponse> Delete(DeleteRequest request) { request.CheckNotNull(nameof(request)); //分类判断 var category = _categoryQueryService.Find(request.Id); if (category == null) { return(new BaseApiResponse { Code = 400, Message = "没找到该分类" }); } //判断是否有子分类 var children = _categoryQueryService.GetChildren(request.Id); if (children.Any()) { return(new BaseApiResponse { Code = 400, Message = "包含子分类,无法删除" }); } //删除 var command = new DeleteCategoryCommand(request.Id); var result = await ExecuteCommandAsync(command); if (!result.IsSuccess()) { return(new BaseApiResponse { Code = 400, Message = "命令没有执行成功:{0}".FormatWith(result.GetErrorMessage()) }); } return(new BaseApiResponse()); }
public async Task <ActionResult> DeleteCategory(int id) { var command = new DeleteCategoryCommand(id); await _commandHandler.HandleAsync(command); return(Ok()); }
public async override Task<string> Handle(DeleteCategoryCommand request, CancellationToken cancellationToken) { Entity = repo.Find(request); Result = repo.Delete(Entity); return Result; }
public Task <HttpResponseMessage> Delete(int id) { var command = new DeleteCategoryCommand(id: id); var category = _service.Delete(command); return(CreateResponse(HttpStatusCode.OK, category)); }
public async Task <IActionResult> Delete(DeleteCategoryCommand deleteCategoryCommand, CancellationToken cancellationToken) { var sucesso = await _mediator.Send(deleteCategoryCommand, cancellationToken) .ConfigureAwait(false); return(Ok(sucesso)); }
public async Task <CategoryDTO> Handle(DeleteCategoryCommand request, CancellationToken cancellationToken) { var category = await _unitOfWork.GetRepository <Category>().FindAsync(request.Id); _unitOfWork.GetRepository <Category>().Delete(category); await _unitOfWork.SaveChangesAsync(); return(_mapper.Map <CategoryDTO>(category)); }
public async Task <IActionResult> DeleteCategory([FromRoute] int id) { var command = new DeleteCategoryCommand() { Id = id }; return(Ok(await mediator.Send(command))); }
public async Task <APIResult> Delete([FromBody] DeleteCategoryCommand command) { var rs = await mediator.Send(command); return(new APIResult() { Result = rs }); }
public async Task <IActionResult> Delete([FromBody] DeleteCategoryCommand deleteCategory) { var result = await _mediator.Send(deleteCategory); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); }
public ActionResult Delete(int id) { var command = new DeleteCategoryCommand { CategoryId = id }; var result = commandBus.Submit(command); var categories = categoryRepository.GetAll(); return(PartialView("_CategoryList", categories)); }
public ResultDto DeleteCategory(long id) { return(Result(() => { var command = new DeleteCategoryCommand { CategoryId = id, }; CommandDispatcher.Send(command); })); }
public async Task <IHttpActionResult> Delete(Guid id) { var command = new DeleteCategoryCommand { Id = id }; var response = await Bus.Send <DeleteCategoryCommand, DeleteCategoryCommandResponse>(command); return(Ok(response)); }
public async Task <ActionResult <bool> > DeleteCategory(Guid id) { var deleteCategoryCommand = new DeleteCategoryCommand() { CategoryId = id }; var deletedSuccess = await _mediator.Send(deleteCategoryCommand); return(Ok(deletedSuccess)); }
public void ShouldRequireValidCategoryId() { var command = new DeleteCategoryCommand { Id = Guid.NewGuid() }; Func <Task> act = async() => await SendAsync(command); act.Should().ThrowAsync <NotFoundException>(); }
public ICommandResult Handle(DeleteCategoryCommand command) { bool result = _repository.Delete(command.Id); if (!result) { return(new CommandResult(false, "Falha ao deletar Categoria")); } return(new CommandResult(true, "Categoria deletada com sucesso!")); }
private void ConfirmDelete(int categoryID, string categoryTitle) { var command = new DeleteCategoryCommand(Repository, categoryID, categoryTitle) { ExecuteSuccessMessage = string.Format(CultureInfo.InvariantCulture, "Category \"{0}\" was deleted.", categoryTitle) }; Messages.ShowMessage(command.Execute()); BindList(); }
public async Task DeleteCategory(string accountName, string categoryName) { accountName = Uri.UnescapeDataString(accountName); var cmd = new DeleteCategoryCommand { AccountName = accountName, CategoryName = categoryName }; await this.mediator.Send(cmd); }
// Check the UserId public async Task <IActionResult> DeleteCategory(int id) { var deleteCommand = new DeleteCategoryCommand(id); var foundAndDeleted = await _mediator.Send(deleteCommand); if (!foundAndDeleted) { return(NotFound()); } return(Ok()); }
public async Task Handle_GivenValidIdAndCategoryNotEmpty_ThrowsDeleteFailureException() { var validId = 1; var command = new DeleteCategoryCommand() { Id = validId }; await ShouldThrowAsyncExtensions.ShouldThrowAsync <DeleteFailureException>(() => _handler.Handle(command, CancellationToken.None)); }
public async Task Handle_GivenInvalidId_ThrowsNotFoundException() { var invalidId = 10; var command = new DeleteCategoryCommand() { Id = invalidId }; await ShouldThrowAsyncExtensions.ShouldThrowAsync <NotFoundException>(() => _handler.Handle(command, CancellationToken.None)); }
public async Task HandleAsync(DeleteCategoryCommand message) { var category = await _uow.CategoryRepository.Get(message.Id); if (category == null) { throw new ArgumentNullException(); } _uow.CategoryRepository.Delete(category); await _uow.Commit(); }
public async Task <DeleteCategoryResponse> DeleteAsync(Guid id) { var command = new DeleteCategoryCommand(id); var response = await _mediator.Send(command); if (response.IsSuccess) { _uow.Commit(); } return(response.ProjectedAs <DeleteCategoryResponse>()); }
public void ShouldNotCallHandleIfCategoryNotExist() { dbSetCategory.Setup(x => x.FindAsync(id)).Returns(null); context.Setup(x => x.Categories).Returns(dbSetCategory.Object); DeleteCategoryCommandHandler deleteCategoryCommandHandler = new DeleteCategoryCommandHandler(context.Object, stringLocalizer.Object); DeleteCategoryCommand deleteCategoryCommand = new DeleteCategoryCommand(id); Func <Task> act = async() => await deleteCategoryCommandHandler.Handle(deleteCategoryCommand, new CancellationToken()); act.Should().ThrowAsync <NotFoundException>(); }
// DELETE /api/categories/5 public void Delete(int id) { var command = new DeleteCategoryCommand { CategoryId = id }; var result = commandBus.Submit(command); if (!result.Success) { throw new HttpResponseException(HttpStatusCode.BadRequest); } }
public void DeleteCategoryCommandHandler_NotExisting_NoChange() { //given var repository = LiteDbHelper.CreateMemoryDb(); var handler = new DeleteCategoryCommandHandler(repository); var command = new DeleteCategoryCommand(new Category()); //when handler.Execute(command); //then Assert.Empty(repository.Database.Query <Category>()); }
private void CorrectFlow() { Id = Builder <int> .CreateNew().Build(); okResult = Result.Ok(Id); errorResult = Result.Error <int>("Error"); Command = Builder <DeleteCategoryCommand> .CreateNew() .With(x => x.Id = Id).Build(); mediator.Setup(m => m.Send(It.IsAny <DeleteCategoryCommand>(), It.IsAny <CancellationToken>())) .ReturnsAsync(okResult); }