public async Task <UserDTO> DenyPermission([FromBody] DenyUserPermissionRequestDTO input)
{
var command = new DenyUserPermissionRequestCommand(input);
var result = await _commandDispatcher.Execute(command);
return(result);
}
public async void given_DenyUserPermissionRequestCommand_handler_should_call_session_Get_and_Commit_when_permission_was_requested()
{
// Assemble
var mockAgg = new DenyUserPermissionRequestCommandHandlerMockAggregate();
var testAgg = mockAgg.SetupAdminUser();
var testPermissionAgg = mockAgg.SetupTestPermission();
var denyHandler = mockAgg.DenyUserPermissionRequestHandlerFactory();
var requestHandler = mockAgg.UserPermissionsRequestedHandlerFactory();
mockAgg.setup_session_to_return_correct_aggregate(testAgg, testPermissionAgg);
var denyInput = new DenyUserPermissionRequestDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
PermissionsToDeny = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testDenyReason"
}
}
}
};
var requestInput = new RequestUserPermissionsDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testRequestReason"
}
}
}
};
var requestCommand = new UserPermissionsRequestedCommand(requestInput);
var result = await requestHandler.Handle(requestCommand);
var denyCommand = new DenyUserPermissionRequestCommand(denyInput);
// Apply
var denyResult = await denyHandler.Handle(denyCommand);
// Assert
Assert.True(mockAgg.SessionGetWasCalled);
Assert.True(mockAgg.SessionCommitWasCalled);
Assert.True(mockAgg.SessionGetPermisisonWasCalled);
}
public void user_permission_list_should_have_permission_request_denied_after_UserPermissionRequestDeniedEvent()
{
// Assemble
var agg = UserAggregateMockAggregate.SetupAdminUser();
var permissionAgg = UserAggregateMockAggregate.SetupTestPermission();
DenyUserPermissionRequestDTO input = new DenyUserPermissionRequestDTO
{
ForId = agg.Id,
ById = agg.Id,
PermissionsToDeny = new Dictionary <Guid, PermissionDetails>
{
{
permissionAgg.Id, new PermissionDetails
{
Reason = "test reason"
}
}
}
};
// Apply
agg.DenyPermissionRequest(agg, new List <PermissionAggregate> {
permissionAgg
}, input);
// Assert
var changes = agg.FlushUncommitedChanges();
Assert.Equal(2, changes.Length);
Assert.Collection(changes,
(e) =>
{
Assert.IsType <UserCreatedEvent>(e);
},
(e) =>
{
Assert.IsType <UserPermissionRequestDeniedEvent>(e);
var @event = (UserPermissionRequestDeniedEvent)e;
Assert.NotEqual(Guid.Empty, @event.Id);
Assert.Equal(2, @event.Version);
Assert.Equal(agg.Id, @event.ForId);
Assert.Equal(agg.Id, @event.ById);
Assert.True(@event.PermissionsToDeny.ContainsKey(permissionAgg.Id));
Assert.Equal(@event.PermissionsToDeny[permissionAgg.Id].EventType, JsonConvert.SerializeObject(typeof(UserPermissionRequestDeniedEvent).FullName));
}
);
Assert.Equal(agg.PermissionList[permissionAgg.Id].EventType, JsonConvert.SerializeObject(typeof(UserPermissionRequestDeniedEvent).FullName));
}
public async void given_denyuserpermissionscommand_command_dispatcher_should_get_same_command_created_in_controller()
{
//Assemble
var mockAgg = new UserControllerMockAggregate();
var id = new Guid();
var userId = new Guid();
var requests = new Dictionary <Guid, PermissionDetails>
{
{
new Guid(), new PermissionDetails
{
EventType = "testEvent",
IsPending = true,
Reason = "testReason",
RequestedBy = id,
RequestedFor = userId,
RequestDate = new DateTime()
}
}
};
var input = new DenyUserPermissionRequestDTO
{
ById = id,
ForId = userId,
PermissionsToDeny = requests
};
var command = new DenyUserPermissionRequestCommand(input);
mockAgg.setup_dispatcher_to_verify_denyUserPermissionRequestCommands_are_the_same(command);
var controller = mockAgg.CreateUserController();
//Apply
var result = await controller.DenyPermission(input);
//Assert
Assert.IsType <UserDTO>(result);
Assert.Equal(result.Id, input.ForId);
Assert.Equal(result.PermissionList, input.PermissionsToDeny);
}
public UserPermissionRequestDeniedEvent(DenyUserPermissionRequestDTO dto)
{
ForId = dto.ForId;
ById = dto.ById;
foreach (var permission in dto.PermissionsToDeny)
{
var reason = String.IsNullOrWhiteSpace(permission.Value.Reason) ? "Reason Not Specified" : permission.Value.Reason;
var p = new PermissionDetails
{
EventType = JsonConvert.SerializeObject(GetType().FullName),
IsPending = false,
Reason = reason,
RequestDate = TimeStamp,
RequestedBy = dto.ById,
RequestedFor = dto.ForId
};
PermissionsToDeny[permission.Key] = p;
}
}
public void DenyPermissionRequest(UserAggregate byAgg, List <PermissionAggregate> permissions, DenyUserPermissionRequestDTO dto)
{
//business Logic here!
if (byAgg.IsAdmin) // cant deny permissions if the byAgg is not an admin
{
ApplyChange(new UserPermissionRequestDeniedEvent(dto));
}
}
public DenyUserPermissionRequestCommand(DenyUserPermissionRequestDTO input)
{
this.Input = input;
}
