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."
});
}
}
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());
}
}
private async Task EnableRequireESignatureWhenProjectESignatureEnabledByDefaultAsync(int reviewId, int userId, int projectId, ReviewPackageRawData reviewRawData)
{
if (reviewRawData.IsESignatureEnabled.HasValue)
{
return;
}
var reviewType = await _reviewsRepository.GetReviewTypeAsync(reviewId, userId);
if (reviewType != ReviewType.Formal)
{
return;
}
var projectPermissions = await _permissionsRepository.GetProjectPermissions(projectId);
if (projectPermissions.HasFlag(ProjectPermissions.IsReviewESignatureEnabled))
{
reviewRawData.IsESignatureEnabled = true;
await _reviewsRepository.UpdateReviewPackageRawDataAsync(reviewId, reviewRawData, userId);
}
}
private async Task UpdateMeaningOfSignaturesInternalAsync(int reviewId, int userId, ReviewPackageRawData reviewRawData,
IEnumerable <MeaningOfSignatureParameter> meaningOfSignatureParameters, IMeaningOfSignatureUpdateStrategy updateStrategy)
{
var meaningOfSignatureParamList = meaningOfSignatureParameters.ToList();
var participantIds = meaningOfSignatureParamList.Select(mos => mos.ParticipantId).ToList();
var possibleMeaningOfSignatures = await _reviewsRepository.GetPossibleMeaningOfSignaturesForParticipantsAsync(reviewId, userId, participantIds);
if (reviewRawData.Reviewers == null)
{
throw new BadRequestException("Could not update meaning of signature because participant is not in review.", ErrorCodes.UserNotInReview);
}
foreach (var participantId in participantIds)
{
var participant = reviewRawData.Reviewers.FirstOrDefault(r => r.UserId == participantId);
if (participant == null)
{
throw new BadRequestException("Could not update meaning of signature because participant is not in review.", ErrorCodes.UserNotInReview);
}
if (participant.Permission != ReviewParticipantRole.Approver)
{
throw new BadRequestException("Could not update meaning of signature because participant is not an approver.", ErrorCodes.ParticipantIsNotAnApprover);
}
var meaningOfSignatureUpdates = updateStrategy.GetMeaningOfSignatureUpdates(participantId, possibleMeaningOfSignatures, meaningOfSignatureParamList).ToList();
if (!meaningOfSignatureUpdates.Any())
{
participant.SelectedRoleMoSAssignments = new List <ParticipantMeaningOfSignature>();
return;
}
if (participant.SelectedRoleMoSAssignments == null)
{
participant.SelectedRoleMoSAssignments = new List <ParticipantMeaningOfSignature>();
}
foreach (var meaningOfSignatureUpdate in meaningOfSignatureUpdates)
{
var meaningOfSignature = meaningOfSignatureUpdate.MeaningOfSignature;
var participantMeaningOfSignature = participant.SelectedRoleMoSAssignments.FirstOrDefault(pmos => pmos.RoleId == meaningOfSignature.RoleId);
if (participantMeaningOfSignature == null)
{
if (!meaningOfSignatureUpdate.Adding)
{
continue;
}
participantMeaningOfSignature = new ParticipantMeaningOfSignature();
participant.SelectedRoleMoSAssignments.Add(participantMeaningOfSignature);
}
else if (!meaningOfSignatureUpdate.Adding)
{
participant.SelectedRoleMoSAssignments.Remove(participantMeaningOfSignature);
continue;
}
participantMeaningOfSignature.ParticipantId = participantId;
participantMeaningOfSignature.ReviewId = reviewId;
participantMeaningOfSignature.MeaningOfSignatureId = meaningOfSignature.MeaningOfSignatureId;
participantMeaningOfSignature.MeaningOfSignatureValue = meaningOfSignature.MeaningOfSignatureValue;
participantMeaningOfSignature.RoleId = meaningOfSignature.RoleId;
participantMeaningOfSignature.RoleName = meaningOfSignature.RoleName;
participantMeaningOfSignature.RoleAssignmentId = meaningOfSignature.RoleAssignmentId;
participantMeaningOfSignature.GroupId = meaningOfSignature.GroupId;
}
}
}
private async Task UpdateRequireMeaningOfSignatureAsync(int reviewId, int userId, int projectId, ReviewType reviewType, ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
var settingChanged = reviewRawData.IsMoSEnabled != updatedReviewSettings.RequireMeaningOfSignature;
if (!settingChanged)
{
return;
}
if (reviewType == ReviewType.Formal && reviewRawData.Status == ReviewPackageStatus.Active)
{
throw ReviewsExceptionHelper.ReviewActiveFormalException();
}
if (updatedReviewSettings.RequireMeaningOfSignature && (!reviewRawData.IsESignatureEnabled.HasValue || !reviewRawData.IsESignatureEnabled.Value))
{
throw ReviewsExceptionHelper.RequireESignatureDisabledException(reviewId);
}
var projectPermissions = await _permissionsRepository.GetProjectPermissions(projectId);
if (!projectPermissions.HasFlag(ProjectPermissions.IsMeaningOfSignatureEnabled))
{
throw ReviewsExceptionHelper.MeaningOfSignatureIsDisabledInProjectException();
}
reviewRawData.IsMoSEnabled = updatedReviewSettings.RequireMeaningOfSignature;
if (reviewRawData.IsMoSEnabled && reviewRawData.Reviewers != null)
{
var meaningOfSignatureParameters = reviewRawData.Reviewers
.Where(r => r.Permission == ReviewParticipantRole.Approver)
.Select(r => new MeaningOfSignatureParameter {
ParticipantId = r.UserId
});
await UpdateMeaningOfSignaturesInternalAsync(reviewId, userId, reviewRawData, meaningOfSignatureParameters, new MeaningOfSignatureUpdateSetDefaultsStrategy());
}
}
private static void UpdateRequireESignature(ReviewType reviewType, ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
var settingChanged = (!reviewRawData.IsESignatureEnabled.HasValue && updatedReviewSettings.RequireESignature) ||
(reviewRawData.IsESignatureEnabled.HasValue && reviewRawData.IsESignatureEnabled.Value != updatedReviewSettings.RequireESignature);
if (!settingChanged)
{
return;
}
if (reviewType == ReviewType.Formal && reviewRawData.Status == ReviewPackageStatus.Active)
{
throw ReviewsExceptionHelper.ReviewActiveFormalException();
}
reviewRawData.IsESignatureEnabled = updatedReviewSettings.RequireESignature;
}
private static void UpdateCanMarkAsComplete(int reviewId, ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
var settingChanged =
reviewRawData.IsAllowToMarkReviewAsCompleteWhenAllArtifactsReviewed != updatedReviewSettings.CanMarkAsComplete;
if (!settingChanged)
{
return;
}
if (reviewRawData.Status != ReviewPackageStatus.Draft)
{
var errorMessage = I18NHelper.FormatInvariant(ErrorMessages.ReviewIsNotDraft, reviewId);
throw new ConflictException(errorMessage, ErrorCodes.Conflict);
}
reviewRawData.IsAllowToMarkReviewAsCompleteWhenAllArtifactsReviewed = updatedReviewSettings.CanMarkAsComplete;
}
private static void UpdateShowOnlyDescription(ReviewSettings updatedReviewSettings, ReviewPackageRawData reviewRawData)
{
reviewRawData.ShowOnlyDescription = updatedReviewSettings.ShowOnlyDescription;
}
private void UpdateEndDate(ReviewSettings updatedReviewSettings, bool autoSave, ReviewPackageRawData reviewRawData)
{
if (!autoSave && updatedReviewSettings.EndDate.HasValue && updatedReviewSettings.EndDate <= _currentDateTimeService.GetUtcNow())
{
throw new BadRequestException("The settings could not be updated because the review has expired.", ErrorCodes.ReviewExpired);
}
reviewRawData.EndDate = updatedReviewSettings.EndDate;
}
