private static List <RDArtifact> GetReviewArtifacts(AssignArtifactsApprovalParameter content, ICollection <ReviewChangeItemsError> resultErrors, RDReviewContents rdReviewContents)
{
if (content.SelectionType != SelectionType.Selected)
{
return(rdReviewContents.Artifacts
.Where(a => a.ApprovalNotRequested == content.ApprovalRequired && !content.ItemIds.Contains(a.Id))
.ToList());
}
var updatingArtifacts = rdReviewContents.Artifacts.Where(a => content.ItemIds.Contains(a.Id)).ToList();
var foundArtifactsCount = updatingArtifacts.Count;
var requestedArtifactsCount = content.ItemIds.Count();
if (foundArtifactsCount != requestedArtifactsCount)
{
resultErrors.Add(
new ReviewChangeItemsError
{
ItemsCount = requestedArtifactsCount - foundArtifactsCount,
ErrorCode = ErrorCodes.ApprovalRequiredArtifactNotInReview,
ErrorMessage = "Some of the artifacts are not in the review."
});
}
updatingArtifacts = updatingArtifacts.Where(a => a.ApprovalNotRequested == content.ApprovalRequired).ToList();
return(updatingArtifacts);
}
private async Task ExcludeArtifactsWithoutReadPermissions(AssignArtifactsApprovalParameter content, int userId, ICollection <ReviewChangeItemsError> resultErrors, List <RDArtifact> updatingArtifacts)
{
var updatingArtifactIds = updatingArtifacts.Select(ua => ua.Id).ToList();
var artifactPermissionsDictionary = await _permissionsRepository.GetArtifactPermissions(updatingArtifactIds, userId);
var artifactsWithReadPermissions = artifactPermissionsDictionary
.Where(p => p.Value.HasFlag(RolePermissions.Read))
.Select(p => p.Key);
var updatingArtifactIdsWithReadPermissions = artifactsWithReadPermissions.Intersect(updatingArtifactIds).ToList();
var artifactsWithReadPermissionsCount = updatingArtifactIdsWithReadPermissions.Count;
var updatingArtifactsCount = updatingArtifactIds.Count;
// Only show error message if on client side user have an outdated data about deleted artifacts from review
if (content.SelectionType == SelectionType.Selected && artifactsWithReadPermissionsCount != updatingArtifactsCount)
{
resultErrors.Add(
new ReviewChangeItemsError
{
ItemsCount = updatingArtifactsCount - artifactsWithReadPermissionsCount,
ErrorCode = ErrorCodes.UnauthorizedAccess,
ErrorMessage = "There is no read permissions for some artifacts."
});
}
// Remove deleted items from the result
updatingArtifacts.RemoveAll(ua => !updatingArtifactIdsWithReadPermissions.Contains(ua.Id));
}
private async Task ExcludeDeletedAndNotInProjectArtifacts(AssignArtifactsApprovalParameter content, Review review, int projectId, ICollection <ReviewChangeItemsError> resultErrors, List <RDArtifact> updatingArtifacts)
{
if (review.BaselineId == null || review.BaselineId < 1)
{
var updatingArtifactIdsOnly = updatingArtifacts.Select(ua => ua.Id);
var deletedAndNotInProjectItemIds = await _artifactVersionsRepository.GetDeletedAndNotInProjectItems(updatingArtifactIdsOnly, projectId);
// Only show error message if on client side user have an outdated data about deleted artifacts from review
if (content.SelectionType == SelectionType.Selected && deletedAndNotInProjectItemIds != null && deletedAndNotInProjectItemIds.Any())
{
resultErrors.Add(
new ReviewChangeItemsError
{
ItemsCount = deletedAndNotInProjectItemIds.Count(),
ErrorCode = ErrorCodes.ArtifactNotFound,
ErrorMessage = "Some artifacts are deleted from the project."
});
}
// Remove deleted items from the result
updatingArtifacts.RemoveAll(ua => deletedAndNotInProjectItemIds.Contains(ua.Id));
}
}
public async Task <ReviewChangeItemsStatusResult> AssignApprovalRequiredToArtifactsAsync(int reviewId, AssignArtifactsApprovalParameter 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 review = await _reviewsRepository.GetReviewAsync(reviewId, userId);
if (review.ReviewStatus == ReviewPackageStatus.Closed)
{
throw ReviewsExceptionHelper.ReviewClosedException();
}
if (review.Contents.Artifacts == null ||
!review.Contents.Artifacts.Any())
{
throw ExceptionHelper.ArtifactDoesNotSupportOperation(reviewId);
}
// If review is active and formal we throw conflict exception. No changes allowed
if (review.ReviewStatus == ReviewPackageStatus.Active &&
review.ReviewType == ReviewType.Formal)
{
throw ReviewsExceptionHelper.ReviewActiveFormalException();
}
foreach (var artifact in review.Contents.Artifacts)
{
if (artifact.ApprovalNotRequested == null)
{
artifact.ApprovalNotRequested = (review.BaselineId == null);
}
}
var resultErrors = new List <ReviewChangeItemsError>();
var updatingArtifacts = GetReviewArtifacts(content, resultErrors, review.Contents);
if (updatingArtifacts.Any())
{
// For Informal review
await ExcludeDeletedAndNotInProjectArtifacts(content, review, reviewInfo.ProjectId, resultErrors, updatingArtifacts);
await ExcludeArtifactsWithoutReadPermissions(content, userId, resultErrors, updatingArtifacts);
var reviewRawData = review.ReviewPackageRawData;
if (review.ReviewStatus == ReviewPackageStatus.Active &&
updatingArtifacts.Any() &&
content.ApprovalRequired)
{
var hasArtifactsRequireApproval = review.Contents.Artifacts.FirstOrDefault(a => a.ApprovalNotRequested == false) != null;
// if Review has already artifacts require approval before current action it means that it is already converted to formal
if (!hasArtifactsRequireApproval)
{
var approver =
reviewRawData.Reviewers?.FirstOrDefault(r => r.Permission == ReviewParticipantRole.Approver);
if (approver != null)
{
throw new ConflictException(
"Could not update review artifacts because review needs to be converted to Formal.",
ErrorCodes.ReviewNeedsToMoveBackToDraftState);
}
}
}
foreach (var updatingArtifact in updatingArtifacts)
{
updatingArtifact.ApprovalNotRequested = !content.ApprovalRequired;
}
var resultArtifactsXml = ReviewRawDataHelper.GetStoreData(review.Contents);
await _reviewsRepository.UpdateReviewArtifactsAsync(reviewId, userId, resultArtifactsXml, null, false);
if (content.ApprovalRequired)
{
await EnableRequireESignatureWhenProjectESignatureEnabledByDefaultAsync(reviewId, userId, reviewInfo.ProjectId, reviewRawData);
}
}
var result = new ReviewChangeItemsStatusResult();
result.ReviewType = await _reviewsRepository.GetReviewTypeAsync(reviewId, userId);
if (resultErrors.Any())
{
result.ReviewChangeItemErrors = resultErrors;
}
return(result);
}
public Task <ReviewChangeItemsStatusResult> AssignApprovalRequiredToArtifactsAsync(int reviewId, [FromBody] AssignArtifactsApprovalParameter content)
{
return(_reviewsService.AssignApprovalRequiredToArtifactsAsync(reviewId, content, Session.UserId));
}
