public async Task <Either <ActionResult, Unit> > AddUserReleaseRole(Guid userId,
UserReleaseRoleRequest userReleaseRole)
{
return(await _userService
.CheckCanManageAllUsers()
.OnSuccess(async() =>
{
return await _persistenceHelper
.CheckEntityExists <Release>(
userReleaseRole.ReleaseId,
q => q.Include(r => r.Publication)
)
.OnSuccess(release =>
{
return ValidateUserReleaseRoleCanBeAdded(userId, userReleaseRole)
.OnSuccessVoid(async() =>
{
await ValidateUserReleaseRoleCanBeAdded(userId, userReleaseRole);
var newReleaseRole = new UserReleaseRole
{
ReleaseId = userReleaseRole.ReleaseId,
Role = userReleaseRole.ReleaseRole,
UserId = userId
};
await _contentDbContext.AddAsync(newReleaseRole);
await _contentDbContext.SaveChangesAsync();
SendNewReleaseRoleEmail(userId, release, newReleaseRole.Role);
});
});
}));
}
public async Task <ActionResult <Unit> > AddUserReleaseRole(Guid userId,
UserReleaseRoleRequest releaseRole)
{
return(await _userManagementService
.AddUserReleaseRole(userId, releaseRole)
.HandleFailuresOrOk());
}
private async Task <Either <ActionResult, bool> > ValidateUserReleaseRoleCanBeAdded(Guid userId,
UserReleaseRoleRequest userReleaseRole)
{
var existing = await _contentDbContext.UserReleaseRoles.FirstOrDefaultAsync(r =>
r.UserId == userId && r.ReleaseId == userReleaseRole.ReleaseId &&
r.Role == userReleaseRole.ReleaseRole);
if (existing != null)
{
return(ValidationActionResult(UserAlreadyHasReleaseRole));
}
return(true);
}
public void AddUserReleaseRole()
{
PolicyCheckBuilder()
.ExpectCheck(SecurityPolicies.CanManageUsersOnSystem)
.AssertSuccess(async userService =>
{
var contentDbContextId = Guid.NewGuid().ToString();
var publication = new Publication
{
Id = Guid.NewGuid(),
Title = "Test Publication"
};
var release = new Release
{
Id = Guid.NewGuid(),
TimePeriodCoverage = TimeIdentifier.CalendarYear,
ReleaseName = "2000",
PublicationId = publication.Id,
Publication = publication
};
var user = new User
{
Id = Guid.NewGuid(),
FirstName = "TestFirstName",
LastName = "TestLastName",
Email = "*****@*****.**"
};
var userReleaseRoleRequest = new UserReleaseRoleRequest
{
ReleaseId = release.Id,
ReleaseRole = ReleaseRole.Approver
};
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
{
await contentDbContext.AddAsync(publication);
await contentDbContext.AddAsync(release);
await contentDbContext.AddAsync(user);
await contentDbContext.SaveChangesAsync();
}
var userAndRolesContextId = Guid.NewGuid().ToString();
var appUser = new ApplicationUser
{
Id = user.Id.ToString(),
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email
};
await using (var userAndRolesDbContext =
InMemoryUserAndRolesDbContext(userAndRolesContextId))
{
await userAndRolesDbContext.AddAsync(appUser);
await userAndRolesDbContext.SaveChangesAsync();
}
await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
await using (var usersAndRolesDbContext = InMemoryUserAndRolesDbContext(userAndRolesContextId))
{
var persistenceHelper = MockPersistenceHelper <ContentDbContext>();
SetupCall(persistenceHelper, release.Id, release);
var userManagementService = BuildUserManagementService(
usersAndRolesDbContext,
userService.Object,
contentDbContext,
persistenceHelper: persistenceHelper.Object
);
return(await userManagementService.AddUserReleaseRole(user.Id, userReleaseRoleRequest));
}
});
}
