private static void UpdateParticipantRole(ReviewPackageRawData reviewPackageRawData, AssignParticipantRoleParameter content, IList <ReviewChangeItemsError> resultErrors)
{
int nonIntersecCount = 0;
if (content.SelectionType == SelectionType.Selected)
{
foreach (var reviewer in reviewPackageRawData.Reviewers)
{
if (content.ItemIds.Contains(reviewer.UserId))
{
reviewer.Permission = content.Role;
}
}
nonIntersecCount = content.ItemIds.Count() - content.ItemIds.Intersect(reviewPackageRawData.Reviewers.Select(r => r.UserId)).Count();
}
else
{
if (content.ItemIds != null && content.ItemIds.Any())
{
foreach (var reviewer in reviewPackageRawData.Reviewers)
{
if (!content.ItemIds.Contains(reviewer.UserId))
{
reviewer.Permission = content.Role;
}
}
}
else
{
foreach (var reviewer in reviewPackageRawData.Reviewers)
{
reviewer.Permission = content.Role;
}
}
}
if (nonIntersecCount > 0)
{
resultErrors.Add(
new ReviewChangeItemsError
{
ItemsCount = nonIntersecCount,
ErrorCode = ErrorCodes.UserNotInReview,
ErrorMessage = "Some users are not in the review."
});
}
}
public async Task <ReviewChangeParticipantsStatusResult> AssignRoleToParticipantsAsync(int reviewId, AssignParticipantRoleParameter content, int userId)
{
if ((content.ItemIds == null || !content.ItemIds.Any()) && content.SelectionType == SelectionType.Selected)
{
throw new BadRequestException("Incorrect input parameters", ErrorCodes.OutOfRangeParameter);
}
if (!await _permissionsRepository.HasEditPermissions(reviewId, userId))
{
throw ReviewsExceptionHelper.UserCannotModifyReviewException(reviewId);
}
var reviewInfo = await GetReviewInfoAsync(reviewId, userId);
if (reviewInfo.LockedByUserId.GetValueOrDefault() != userId)
{
throw ExceptionHelper.ArtifactNotLockedException(reviewId, userId);
}
var reviewData = await _reviewsRepository.GetReviewAsync(reviewId, userId);
if (reviewData.ReviewStatus == ReviewPackageStatus.Closed)
{
const string errorMessage = "The approval status could not be updated because another user has changed the Review status.";
throw new ConflictException(errorMessage, ErrorCodes.ApprovalRequiredIsReadonlyForReview);
}
if (reviewData.ReviewPackageRawData.Reviewers == null ||
!reviewData.ReviewPackageRawData.Reviewers.Any())
{
throw ExceptionHelper.ArtifactDoesNotSupportOperation(reviewId);
}
if (reviewData.ReviewStatus == ReviewPackageStatus.Active)
{
if (content.Role == ReviewParticipantRole.Approver)
{
var hasApproversAlready = reviewData.ReviewPackageRawData.Reviewers.FirstOrDefault(
r => r.Permission == ReviewParticipantRole.Approver) != null;
// If we have approvers before current action, it means that review already was converted to formal
if (!hasApproversAlready)
{
var artifactRequredApproval =
reviewData.Contents.Artifacts?.FirstOrDefault(a => !a.ApprovalNotRequested ?? true);
if (artifactRequredApproval != null)
{
throw new ConflictException(
"Could not update review participants because review needs to be converted to Formal.",
ErrorCodes.ReviewNeedsToMoveBackToDraftState);
}
}
}
else // If new role is reviewer
{
ReviewsExceptionHelper.VerifyNotLastApproverInFormalReview(content, reviewData);
}
}
var resultErrors = new List <ReviewChangeItemsError>();
UpdateParticipantRole(reviewData.ReviewPackageRawData, content, resultErrors);
await UpdateMeaningOfSignatureWhenAssignApprovalRoles(reviewId, userId, content, reviewData.ReviewPackageRawData);
await _reviewsRepository.UpdateReviewPackageRawDataAsync(reviewId, reviewData.ReviewPackageRawData, userId);
var changeResult = new ReviewChangeParticipantsStatusResult
{
ReviewType = await _reviewsRepository.GetReviewTypeAsync(reviewId, userId)
};
if (content.Role == ReviewParticipantRole.Approver)
{
await EnableRequireESignatureWhenProjectESignatureEnabledByDefaultAsync(reviewId, userId, reviewInfo.ProjectId, reviewData.ReviewPackageRawData);
if (reviewData.ReviewPackageRawData.IsMoSEnabled && content.SelectionType == SelectionType.Selected && content.ItemIds.Count() == 1)
{
changeResult.DropdownItems = reviewData.ReviewPackageRawData.Reviewers
.First(r => r.UserId == content.ItemIds.FirstOrDefault())
.SelectedRoleMoSAssignments.Select(mos => new DropdownItem(mos.GetMeaningOfSignatureDisplayValue(), mos.RoleId));
}
}
if (resultErrors.Any())
{
changeResult.ReviewChangeItemErrors = resultErrors;
}
return(changeResult);
}
private async Task UpdateMeaningOfSignatureWhenAssignApprovalRoles(int reviewId, int userId, AssignParticipantRoleParameter content,
ReviewPackageRawData reviewRawData)
{
if (reviewRawData.IsMoSEnabled && content.Role == ReviewParticipantRole.Approver)
{
IEnumerable <MeaningOfSignatureParameter> meaningOfSignatureParameter;
if (content.SelectionType == SelectionType.Selected)
{
meaningOfSignatureParameter = content.ItemIds
.Select(i => new MeaningOfSignatureParameter {
ParticipantId = i
});
}
else
{
if (!content.ItemIds.Any())
{
meaningOfSignatureParameter =
reviewRawData.Reviewers.Select(
reviewer => new MeaningOfSignatureParameter {
ParticipantId = reviewer.UserId
});
}
else
{
var meaningOfSignaturelist = new List <MeaningOfSignatureParameter>();
foreach (var reviewer in reviewRawData.Reviewers)
{
if (!content.ItemIds.Contains(reviewer.UserId))
{
meaningOfSignaturelist.Add(new MeaningOfSignatureParameter
{
ParticipantId = reviewer.UserId
});
}
}
meaningOfSignatureParameter = meaningOfSignaturelist;
}
}
await
UpdateMeaningOfSignaturesInternalAsync(reviewId, userId, reviewRawData, meaningOfSignatureParameter,
new MeaningOfSignatureUpdateSetDefaultsStrategy());
}
}
public Task <ReviewChangeParticipantsStatusResult> AssignRoleToParticipantAsync(int reviewId, [FromBody] AssignParticipantRoleParameter content)
{
return(_reviewsService.AssignRoleToParticipantsAsync(reviewId, content, Session.UserId));
}
