public void DeleteQuestionnaire() { var questionnaireCreator = new User() { Name = "User 1" }; context.Users.Add(questionnaireCreator); context.SaveChanges(); var questionnaire = new Questionnaire { Name = "Questionnaire Name", CreatedByUser = questionnaireCreator, CreatedDate = DateTime.Now.AddDays(-2) }; context.Questionnaires.Add(questionnaire); context.SaveChanges(); Assert.Equal(1, context.Questionnaires.Count()); var deleteQuestionnaireCommand = new DeleteEntityCommand(context); deleteQuestionnaireCommand.Execute <Questionnaire>(questionnaire); Assert.Equal(0, context.Questionnaires.Count()); }
public bool Delete(int id) { DeleteEntityCommand command = new DeleteEntityCommand(id, TABLE_NAME); bool isDeleted = deleteStudentHandler.Handle(command); return(isDeleted); }
public async Task Hanlde_DeleteEntityCommand_RemovesEntityDefinitionFromProjectAsync() { // arrange var project = CreateProject(); var entityId = project.Schema.Entities.First().Id; var command = new DeleteEntityCommand { Id = project.Id, EntityId = entityId }; var session = new Mock <ISession>(); session.Setup(s => s.Get <Project>(project.Id, command.ExpectedVersion, It.IsAny <CancellationToken>())).Returns(Task.FromResult(project)); var target = new ProjectCommandHandler(session.Object); // act await target.Handle(command); // assert var entityDefinition = project.Schema.Entities.FirstOrDefault(e => e.Id == entityId); Assert.Null(entityDefinition); session.Verify(s => s.Commit(It.IsAny <CancellationToken>())); }
public async Task <IActionResult> Delete(int id) { DeleteEntityCommand command = new DeleteEntityCommand(id); await partnerCommandHandler.ExecuteAsync(command); return(this.HandleNotification(partnerCommandHandler, null)); }
public async Task ExecuteAsync(DeleteEntityCommand command) { if (!command.Validate()) { AddNotification(command.GetNotifications()); return; } AddNotification(partnerRepository.Get().Any(x => x.Id == command.Id), "Partner Id Not Found"); if (!IsValid) { return; } try { await partnerRepository.DeleteAsync(partnerRepository.Get(x => x.Id == command.Id).FirstOrDefault()); } catch (Exception ex) { logger.LogError(ex.Message, ex); AddNotification(ex.Message, System.Net.HttpStatusCode.InternalServerError); } }
public async Task <IActionResult> DeleteEntity(Guid projectId, Guid id) { if (!this.ModelState.IsValid) { return(this.BadRequest(this.ModelState)); } var currentProject = await this.dbContext.Projects .Include(p => p.Entities) .SingleOrDefaultAsync(p => p.Id == projectId); if (currentProject == null) { return(this.NoContent()); } var currentEntity = await this.dbContext.Entities.FirstOrDefaultAsync(p => p.Id == id); if (currentEntity == null) { return(this.NotFound()); } var command = new DeleteEntityCommand { Id = projectId, ExpectedVersion = currentProject.Version, EntityId = id }; await this.commandSender.Send(command); return(this.NoContent()); }
public virtual async Task <EntityResponse <T> > DeleteAsync <T>(DeleteEntityCommand <T> cmd) where T : class { Ensure.That(cmd, "cmd").IsNotNull(); var req = CreateRequest(cmd); var res = SendAsync(req); return(ProcessEntityResponse(cmd, await res.ForAwait())); }
/// <summary> /// c'tor /// </summary> /// <param name="persistEntityCommand">commerceCommander</param> /// <param name="composerTemplateService">Composer Template Service</param> /// <param name="deleteEntityCommand">Delete Entity Command</param> public OverrideComposerTemplatesBlock( PersistEntityCommand persistEntityCommand, IComposerTemplateService composerTemplateService, DeleteEntityCommand deleteEntityCommand) { _persistEntityCommand = persistEntityCommand; _composerTemplateService = composerTemplateService; _deleteEntityCommand = deleteEntityCommand; }
public async Task <ActionResult <Guid> > DeleteExpense([FromRoute] Guid id, [FromBody] DeleteEntityCommand deleteEntityCommand, CancellationToken cancellationToken) { deleteEntityCommand.Id = id; var result = await _mediator.Send(deleteEntityCommand, cancellationToken); return(Ok(result)); }
public async override Task <Guid> HandleAsync(DeleteEntityCommand <T> request, CancellationToken cancellationToken) { var dbSet = dbContextProvider.GetDBSet <T>(); var entity = await dbSet.QueryByIdAsync(request.Id, cancellationToken); await dbSet.DeleteAsync(entity, cancellationToken); return(request.Id); }
protected virtual HttpRequestMessage CreateRequest <T>(DeleteEntityCommand <T> cmd) where T : class { var id = Reflector.IdMember.GetValueFrom(cmd.Entity); var rev = Reflector.RevMember.GetValueFrom(cmd.Entity); var req = new HttpRequest(HttpMethod.Delete, GenerateRequestUrl(id, rev)); req.SetIfMatch(rev); return(req); }
public ActionResult Delete(int Id) { var cmd = new DeleteEntityCommand <CustomerDTO>(new CustomerDTO { Id = Id }, User.Identity.Name); CommandProcessor.ExecuteCommand(cmd, Container); return(RedirectToAction("Index")); }
protected virtual EntityResponse <T> ProcessEntityResponse <T>(DeleteEntityCommand <T> cmd, HttpResponseMessage response) where T : class { var entityResponse = EntityResponseFactory.Create <T>(response); entityResponse.Entity = cmd.Entity; if (entityResponse.IsSuccess) { Reflector.RevMember.SetValueTo(entityResponse.Entity, entityResponse.Rev); } return(entityResponse); }
public HttpResponseMessage Delete(Guid identity) { _logWriter.Info(String.Format("Deletion request for Entity: {0}", identity)); var current = _readService.FindByIdentity(identity); return(current.Fold(_ => { var command = new DeleteEntityCommand(identity); _dispatcher.Dispatch(command); _logWriter.Info(String.Format("Deletion request for Entity: {0} completed.", identity)); return Request.CreateResponse(HttpStatusCode.OK); }, () => Request.CreateErrorResponse(HttpStatusCode.NotFound, "Entity Resource Not Found"))); }
public IEnumerable <ValidationResult> Validate(DeleteEntityCommand <SubCategoryModel> instance) { var subcategory = this.subcategoryRepository.FindById(instance.Id); var gameItems = subcategory.GameItems; if (gameItems.Any()) { var items = string.Join(Environment.NewLine, from item in gameItems select $" - {item.Name}"); yield return(new ValidationResult( $"Cannot delete the subcategory '{subcategory.Name}', " + "because the following gameitems are attached to it:" + Environment.NewLine + items)); } }
/// <summary> /// c'tor /// </summary> /// <param name="findEntitiesInListCommand">findEntitiesInListCommand</param> public CommerceEntityService( CommerceCommander commerceCommander, PersistEntityCommand persistEntityCommand, DeleteEntityCommand deleteEntityCommand, FindEntityCommand findEntityCommand, AssociateCategoryToParentCommand associateCategoryToParentCommand, AssociateSellableItemToParentCommand associateSellableItemToParentCommand, FindEntitiesInListCommand findEntitiesInListCommand) { _findEntitiesInListCommand = findEntitiesInListCommand; _commerceCommander = commerceCommander; _persistEntityCommand = persistEntityCommand; _deleteEntityCommand = deleteEntityCommand; _findEntityCommand = findEntityCommand; _associateCategoryToParentCommand = associateCategoryToParentCommand; _associateSellableItemToParentCommand = associateSellableItemToParentCommand; }
public bool Execute(DeleteEntityCommand <T> Command, ICommandProcessor CommandProcessor) { IDTOConverter <T> converter = null; try { converter = (IDTOConverter <T>)CommandProcessor.UnityContainer.Resolve(typeof(IDTOConverter <T>)); } catch (Exception) { throw new ApplicationException("A Converter has not been found for this DTO, please make sure it was registered in the Unity Container Configuration"); } var converted = converter.Convert(Command.Entity); var dapperRepository = CommandProcessor.UnityContainer.Resolve <IDefaultDomainRepository>(); dapperRepository.Delete(converted); return(true); }
public Response <bool> HardDelete <T>(IdRequest request) where T : AuditableEntity { Logger.LogTrace($"Hard delete of {typeof(T).Name} by id: {request.Id}. By user {Username}"); var response = new Response <bool>(); if (request.IsRequestInvalid(response, ContextInfo)) { return(response); } var command = new DeleteEntityCommand <T> { WrappedRequest = WrapRequest(request) }; var result = Repository.ExecuteCommand(command); response.Merge(result); return(response); }
public abstract void Handle(DeleteEntityCommand <TModel> command);
public async Task <IActionResult> DeleteAsync(Guid id, CancellationToken cancellationToken) { var deleteRequest = new DeleteEntityCommand <T>(accountId, id); return(this.Ok(await mediator.Send(deleteRequest, cancellationToken))); }
// Run 'CanExecute' for all buttons private void RunAllCanExecute() { NewEntityCommand.RaiseCanExecuteChanged(); UpdateEntityCommand.RaiseCanExecuteChanged(); DeleteEntityCommand.RaiseCanExecuteChanged(); }
public WorkResult Delete(Guid id) { var command = new DeleteEntityCommand <TModel>(id); return(this.Handle(this.deleteHandler, command)); }
public Task <T> Handle(DeleteEntityCommand <T> request, CancellationToken cancellationToken) { return(repository.Delete(request.Id)); }
public void Handle(DeleteEntityCommand command) { _repository.Delete(command.Id); }
public void Handle(DeleteEntityCommand <SubCategoryModel> command) { this.subCategoryRepository.RemoveById(command.Id); }
public void Handle(DeleteEntityCommand <SkillModel> command) { this.skillRepository.RemoveById(command.Id); }
public IActionResult Delete(DeleteEntityCommand command) { _handler.Handle(command); return(Response(command, "Entidade removida com sucesso!", "Falha ao registrar", _handler.Notifications)); }
public void Handle(DeleteEntityCommand <TierModel> command) { this.tierRepository.RemoveById(command.Id); }
public override void Handle(DeleteEntityCommand <EquipmentModel> command) { this.itemRepository.RemoveById(command.Id); }