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);
}
