public async Task EnableField_should_create_events_and_update_state_for_array()
{
var command = new EnableField {
ParentFieldId = 1, FieldId = 2
};
await ExecuteCreateAsync();
await ExecuteAddArrayFieldAsync();
await ExecuteAddFieldAsync(fieldName, 1);
await ExecuteDisableFieldAsync(2, 1);
var result = await sut.ExecuteAsync(CreateCommand(command));
result.ShouldBeEquivalent(new EntitySavedResult(4));
Assert.False(GetField(1).IsDisabled);
Assert.False(GetNestedField(1, 2).IsDisabled);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new FieldEnabled {
ParentFieldId = arrayId, FieldId = nestedId
})
);
}
public void CanEnable_should_throw_exception_if_not_found()
{
var command = new EnableField {
FieldId = 3
};
Assert.Throws <DomainObjectNotFoundException>(() => GuardSchemaField.CanEnable(schema_0, command));
}
public void CanEnable_should_throw_exception_if_ui_field()
{
var command = new EnableField {
FieldId = 4
};
Assert.Throws <DomainException>(() => GuardSchemaField.CanEnable(command, schema_0));
}
public SchemaDomainObject EnableField(EnableField command)
{
VerifyCreatedAndNotDeleted();
RaiseEvent(command, new FieldEnabled());
return(this);
}
public void CanEnable_should_throw_exception_if_already_enabled()
{
var command = new EnableField {
FieldId = 1
};
Assert.Throws <DomainException>(() => GuardSchemaField.CanEnable(schema_0, command));
}
public static void CanEnable(Schema schema, EnableField command)
{
var field = GetFieldOrThrow(schema, command.FieldId);
if (!field.IsDisabled)
{
throw new DomainException("Schema field is already enabled.");
}
}
protected Task On(EnableField command, CommandContext context)
{
return(handler.UpdateSyncedAsync <SchemaDomainObject>(context, s =>
{
GuardSchemaField.CanEnable(s.Snapshot.SchemaDef, command);
s.EnableField(command);
}));
}
public async Task <IActionResult> EnableNestedField(string app, string name, long parentId, long id)
{
var command = new EnableField {
ParentFieldId = parentId, FieldId = id
};
var response = await InvokeCommandAsync(app, command);
return(Ok(response));
}
public void CanEnable_should_not_throw_exception_if_disabled()
{
var command = new EnableField {
FieldId = 1
};
var schema_1 = schema_0.DisableField(1);
GuardSchemaField.CanEnable(schema_1, command);
}
public void CanEnable_should_throw_exception_if_locked()
{
var command = new EnableField {
FieldId = 1
};
var schema_1 = schema_0.UpdateField(1, f => f.Lock());
Assert.Throws <DomainException>(() => GuardSchemaField.CanEnable(command, schema_1));
}
public async Task <IActionResult> EnableField(string app, string name, long id)
{
var command = new EnableField {
FieldId = id
};
var response = await InvokeCommandAsync(command);
return(Ok(response));
}
public void CanShow_should_not_throw_exception_if_already_shown()
{
var command = new EnableField {
FieldId = 1
};
var schema_1 = schema_0.UpdateField(1, f => f.Show());
GuardSchemaField.CanEnable(command, schema_1);
}
public async Task <IActionResult> EnableField(string app, string name, long id)
{
var command = new EnableField {
FieldId = id
};
await CommandBus.PublishAsync(command);
return(NoContent());
}
public void CanEnable_should_not_throw_exception_if_disabled()
{
var command = new EnableField {
FieldId = 1
};
schema.FieldsById[1].Disable();
GuardSchemaField.CanEnable(schema, command);
}
public static void CanEnable(EnableField command, Schema schema)
{
Guard.NotNull(command, nameof(command));
var field = GuardHelper.GetFieldOrThrow(schema, command.FieldId, command.ParentFieldId, false);
if (!field.IsForApi(true))
{
throw new DomainException(T.Get("schemas.uiFieldCannotBeEnabled"));
}
}
public static void CanEnable(EnableField command, Schema schema)
{
Guard.NotNull(command);
var field = GuardHelper.GetFieldOrThrow(schema, command.FieldId, command.ParentFieldId, false);
if (!field.IsForApi(true))
{
throw new DomainException("UI field cannot be enabled.");
}
}
public static void CanEnable(Schema schema, EnableField command)
{
Guard.NotNull(command, nameof(command));
var field = GuardHelper.GetFieldOrThrow(schema, command.FieldId, command.ParentFieldId, false);
if (!field.IsDisabled)
{
throw new DomainException("Schema field is already enabled.");
}
}
public SchemaDomainObject EnableField(EnableField command)
{
Guard.NotNull(command, nameof(command));
VerifyCreatedAndNotDeleted();
SchemaFieldGuard.GuardCanEnable(schema, command.FieldId);
RaiseEvent(command, new FieldEnabled());
return(this);
}
public async Task EnableField_should_create_events_and_update_state()
{
var command = new EnableField { FieldId = 1 };
await ExecuteCreateAsync();
await ExecuteAddFieldAsync(fieldName);
await ExecuteDisableFieldAsync(1);
var result = await sut.ExecuteAsync(CreateCommand(command));
result.ShouldBeEquivalent(sut.Snapshot);
Assert.False(GetField(1).IsDisabled);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new FieldEnabled { FieldId = fieldId })
);
}
public async Task EnableField_should_create_events_and_update_nested_field_disabled_flag()
{
var command = new EnableField {
ParentFieldId = 1, FieldId = 2
};
await ExecuteCreateAsync();
await ExecuteAddArrayFieldAsync();
await ExecuteAddFieldAsync(fieldName, 1);
await ExecuteDisableFieldAsync(2, 1);
var result = await PublishAsync(command);
result.ShouldBeEquivalent(sut.Snapshot);
Assert.False(GetNestedField(1, 2).IsDisabled);
LastEvents
.ShouldHaveSameEvents(
CreateEvent(new FieldEnabled {
ParentFieldId = arrayId, FieldId = nestedId
})
);
}
public void EnableField(EnableField command)
{
RaiseEvent(command, new FieldEnabled());
}
private void EnableField(EnableField command)
{
Raise(command, new FieldEnabled());
}
protected Task On(EnableField command, CommandContext context)
{
return(handler.UpdateAsync <SchemaDomainObject>(context, s => s.EnableField(command)));
}