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; }