public async Task <ReviewRelationshipsResultSet> GetReviewRelationships(int artifactId, int userId, bool addDrafts = true, int?versionId = null)
{
var revisionId = await _itemInfoRepository.GetRevisionId(artifactId, userId, versionId);
var reviewType = new List <int> {
(int)LinkType.ReviewPackageReference
};
var reviewLinks = (await GetLinkInfo(artifactId, userId, addDrafts, revisionId, reviewType)).ToList();
var result = new ReviewRelationshipsResultSet {
};
if (reviewLinks != null)
{
var distinctReviewIds = reviewLinks.Select(a => a.SourceItemId).Distinct().ToList();
var reviewIdsWithAccess = new List <int>();
var reviewPermissions = await _artifactPermissionsRepository.GetArtifactPermissions(distinctReviewIds, userId);
foreach (var reviewId in distinctReviewIds)
{
if (SqlArtifactPermissionsRepository.HasPermissions(reviewId, reviewPermissions, RolePermissions.Read))
{
reviewIdsWithAccess.Add(reviewId);
}
}
var itemDetailsDictionary = (await _itemInfoRepository.GetItemsDetails(userId, reviewIdsWithAccess, true, revisionId))
.ToDictionary(a => a.HolderId);
var itemRawDataDictionary = (await _itemInfoRepository.GetItemsRawDataCreatedDate(userId, reviewIdsWithAccess, true, revisionId))
.ToDictionary(a => a.ItemId);
var referencedReviewArtifacts = new List <ReferencedReviewArtifact>();
ItemRawDataCreatedDate itemRawDataCreatedDate;
ItemDetails itemDetails;
foreach (var reviewId in reviewIdsWithAccess)
{
if ((itemRawDataDictionary.TryGetValue(reviewId, out itemRawDataCreatedDate)) && (itemDetailsDictionary.TryGetValue(reviewId, out itemDetails)))
{
var status = ReviewRawDataHelper.ExtractReviewStatus(itemRawDataCreatedDate.RawData);
referencedReviewArtifacts.Add(new ReferencedReviewArtifact
{
ItemId = reviewId,
Status = status,
CreatedDate = itemRawDataCreatedDate.CreatedDateTime,
ItemName = itemDetails.Name,
ItemTypePrefix = itemDetails.Prefix
});
}
}
result.ReviewArtifacts = referencedReviewArtifacts;
}
return(result);
}
public Review(ReviewData reviewData)
{
if (reviewData == null)
{
throw new ArgumentNullException(nameof(reviewData));
}
Id = reviewData.Id;
BaselineId = reviewData.BaselineId;
if (!ReviewRawDataHelper.TryRestoreData(reviewData.ReviewContentsXml, out _contents))
{
_contents = new RDReviewContents();
}
if (!ReviewRawDataHelper.TryRestoreData(reviewData.ReviewPackageRawDataXml, out _reviewPackageRawData))
{
_reviewPackageRawData = new ReviewPackageRawData();
}
}
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);
}
