private async Task <Collection> GetCollectionAsync(
int collectionId, int userId, IDbTransaction transaction = null)
{
var basicDetails = await _artifactRepository.GetArtifactBasicDetails(collectionId, userId, transaction);
if (basicDetails == null || basicDetails.DraftDeleted || basicDetails.LatestDeleted)
{
throw CollectionsExceptionHelper.NotFoundException(collectionId);
}
if (basicDetails.PrimitiveItemTypePredefined != (int)ItemTypePredefined.ArtifactCollection)
{
throw CollectionsExceptionHelper.InvalidTypeException(collectionId);
}
var permissions = await _artifactPermissionsRepository.GetArtifactPermissions(
collectionId, userId, transaction : transaction);
RolePermissions collectionPermissions;
if (!permissions.TryGetValue(collectionId, out collectionPermissions) ||
!collectionPermissions.HasFlag(RolePermissions.Read))
{
throw CollectionsExceptionHelper.NoAccessException(collectionId);
}
return(new Collection(
basicDetails.ArtifactId,
basicDetails.ProjectId,
basicDetails.LockedByUserId,
collectionPermissions));
}
private async Task <Dictionary <int, string> > GetProjectNamesForUserMapping(HashSet <int> projectIds, int?userId)
{
var projectNameIdDictionary = (await _artifactRepository.GetProjectNameByIdsAsync(projectIds)).ToDictionary(x => x.ItemId, x => x.Name);
if (!userId.HasValue)
{
return(projectNameIdDictionary);
}
var projectIdPermissions = new List <KeyValuePair <int, RolePermissions> >();
int iterations = (int)Math.Ceiling((double)projectIds.Count / 50);
for (int i = 0; i < iterations; i++)
{
var chunkProjectIds = projectIds.Skip(i * 50).Take(50);
var newDictionary = await _artifactPermissionsRepository.GetArtifactPermissions(chunkProjectIds, userId.Value);
projectIdPermissions.AddRange(newDictionary.ToList());
}
var projectIdPermissionsDictionary = projectIdPermissions.ToDictionary(x => x.Key, x => x.Value);
foreach (int projectId in projectIds)
{
if (!projectIdPermissionsDictionary.ContainsKey(projectId) || !projectIdPermissionsDictionary[projectId].HasFlag(RolePermissions.Read))
{
projectNameIdDictionary[projectId] = ServiceConstants.NoPermissions;
}
}
return(projectNameIdDictionary);
}
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));
}
public async Task <FilesInfo> GetAttachmentsAndDocumentReferences(
int artifactId,
int?versionId = null,
int?subArtifactId = null,
bool addDrafts = true,
int?baselineId = null)
{
if (artifactId < 1 || (subArtifactId.HasValue && subArtifactId.Value < 1) || (versionId != null && baselineId != null))
{
throw new BadRequestException();
}
if (addDrafts && versionId != null)
{
addDrafts = false;
}
var userId = Session.UserId;
var itemId = subArtifactId.HasValue ? subArtifactId.Value : artifactId;
var isDeleted = await ArtifactVersionsRepository.IsItemDeleted(itemId);
var itemInfo = isDeleted && (versionId != null || baselineId != null) ?
(await ArtifactVersionsRepository.GetDeletedItemInfo(itemId)) :
(await ArtifactPermissionsRepository.GetItemInfo(itemId, userId, addDrafts));
if (itemInfo == null)
{
throw new ResourceNotFoundException("You have attempted to access an item that does not exist or you do not have permission to view.",
subArtifactId.HasValue ? ErrorCodes.SubartifactNotFound : ErrorCodes.ArtifactNotFound);
}
if (subArtifactId.HasValue && itemInfo.ArtifactId != artifactId)
{
throw new BadRequestException("Please provide a proper subartifact Id");
}
var result = await AttachmentsRepository.GetAttachmentsAndDocumentReferences(artifactId, userId, versionId, subArtifactId, addDrafts, baselineId);
var artifactIds = new List <int> {
artifactId
};
foreach (var documentReference in result.DocumentReferences)
{
artifactIds.Add(documentReference.ArtifactId);
}
var permissions = await ArtifactPermissionsRepository.GetArtifactPermissions(artifactIds, userId);
if (!SqlArtifactPermissionsRepository.HasPermissions(artifactId, permissions, RolePermissions.Read))
{
throw new AuthorizationException("You do not have permission to access the artifact");
}
var docRef = result.DocumentReferences.ToList();
foreach (var documentReference in docRef)
{
if (!SqlArtifactPermissionsRepository.HasPermissions(documentReference.ArtifactId, permissions, RolePermissions.Read))
{
result.DocumentReferences.Remove(documentReference);
}
}
return(result);
}
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 async Task <List <SubArtifact> > GetSubArtifactTreeAsync(int artifactId)
{
var userId = Session.UserId;
var artifactIds = new[] { artifactId };
var permissions = await _artifactPermissionsRepository.GetArtifactPermissions(artifactIds, userId, false);
RolePermissions permission;
if (!permissions.TryGetValue(artifactId, out permission) || !permission.HasFlag(RolePermissions.Read))
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
return((await _artifactRepository.GetSubArtifactTreeAsync(artifactId, userId)).ToList());
}
public async Task <List <string> > GetProjectNavigationPathAsync(int projectId, bool includeProjectItself = true)
{
var result = await _instanceRepository.GetProjectNavigationPathAsync(projectId, Session.UserId, includeProjectItself);
var artifactIds = new[] { projectId };
var permissions = await _artifactPermissionsRepository.GetArtifactPermissions(artifactIds, Session.UserId);
RolePermissions permission;
if (!permissions.TryGetValue(projectId, out permission) || !permission.HasFlag(RolePermissions.Read))
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
return(result);
}
/// <summary>
/// Checks whether the user has permission for this artifact.
/// if a revision Id is provided, the artifact's revision has to be less than the current revision.
/// For SqlWorkflowRepository - If the artifact is not a regular artifact type then we throw a non-supported exception.
/// </summary>
/// <param name="userId"></param>
/// <param name="artifactId"></param>
/// <param name="revisionId"></param>
/// <param name="permissions"></param>
/// <returns></returns>
protected async Task CheckForArtifactPermissions(int userId, int artifactId, int revisionId = int.MaxValue, RolePermissions permissions = RolePermissions.Read)
{
var artifactBasicDetails = await GetArtifactBasicDetails(ConnectionWrapper, artifactId, userId);
if (artifactBasicDetails == null)
{
throw ExceptionHelper.ArtifactNotFoundException(artifactId);
}
// TODO: Move out to derived class.
InternalCheckForOperationSupport(artifactBasicDetails);
var artifactsPermissions =
await ArtifactPermissionsRepository.GetArtifactPermissions(new List <int> {
artifactId
}, userId);
if (!artifactsPermissions.ContainsKey(artifactId) ||
!artifactsPermissions[artifactId].HasFlag(permissions))
{
throw ExceptionHelper.ArtifactForbiddenException(artifactId);
}
}
public async Task <ArtifactHistoryResultSet> GetArtifactHistory(int artifactId, int limit = DEFAULT_LIMIT, int offset = DEFAULT_OFFSET, int?userId = null, bool asc = false, bool includeDrafts = true)
{
var sessionUserId = Session.UserId;
if (limit < MIN_LIMIT || offset < 0 || userId < 1)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
if (limit > MAX_LIMIT)
{
limit = MAX_LIMIT;
}
var revisionId = int.MaxValue;
var isDeleted = await ArtifactVersionsRepository.IsItemDeleted(artifactId);
if (isDeleted)
{
var deletedInfo = await ArtifactVersionsRepository.GetDeletedItemInfo(artifactId);
revisionId = deletedInfo.VersionId;
}
var artifactIds = new[] { artifactId };
var permissions = await ArtifactPermissionsRepository.GetArtifactPermissions(artifactIds, sessionUserId, false, revisionId);
RolePermissions permission = RolePermissions.None;
if (!permissions.TryGetValue(artifactId, out permission) || !permission.HasFlag(RolePermissions.Read))
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
var result = await ArtifactVersionsRepository.GetArtifactVersions(artifactId, limit, offset, userId, asc, sessionUserId, includeDrafts);
return(result);
}
/// <summary>
/// Perform an Item search by SearchName
/// </summary>
/// <param name="userId"></param>
/// <param name="searchCriteria">SearchCriteria object</param>
/// <param name="startOffset">Search start offset</param>
/// <param name="pageSize">Page Size</param>
/// <returns></returns>
public async Task <ItemNameSearchResultSet> SearchName(
int userId,
ItemNameSearchCriteria searchCriteria,
int startOffset,
int pageSize)
{
var param = new DynamicParameters();
param.Add("@userId", userId);
param.Add("@query", searchCriteria.Query);
param.Add("@projectIds", SqlConnectionWrapper.ToDataTable(searchCriteria.ProjectIds));
if (searchCriteria.PredefinedTypeIds != null && searchCriteria.PredefinedTypeIds.Any())
{
param.Add("@predefinedTypeIds", SqlConnectionWrapper.ToDataTable(searchCriteria.PredefinedTypeIds));
}
if (searchCriteria.ItemTypeIds != null && searchCriteria.ItemTypeIds.Any())
{
param.Add("@itemTypeIds", SqlConnectionWrapper.ToDataTable(searchCriteria.ItemTypeIds));
}
param.Add("@excludedPredefineds", SqlConnectionWrapper.ToDataTable(GetExcludedPredefineds(searchCriteria)));
param.Add("@startOffset", startOffset);
param.Add("@pageSize", pageSize);
param.Add("@maxSearchableValueStringSize", _searchConfigurationProvider.MaxSearchableValueStringSize);
List <ItemNameSearchResult> items;
try
{
items = (await _connectionWrapper.QueryAsync <ItemNameSearchResult>("SearchItemNameByItemTypes",
param,
commandType: CommandType.StoredProcedure,
commandTimeout: _searchConfigurationProvider.SearchTimeout)).ToList();
}
catch (SqlException sqlException)
{
switch (sqlException.Number)
{
// Sql timeout error
case ErrorCodes.SqlTimeoutNumber:
throw new SqlTimeoutException("Server did not respond with a response in the allocated time. Please try again later.", ErrorCodes.Timeout);
}
throw;
}
var itemIds = items.Select(i => i.ItemId).ToList();
var itemIdsPermissions =
// Always getting permissions for the Head version of an artifact.
await _artifactPermissionsRepository.GetArtifactPermissions(itemIds, userId);
IDictionary <int, IEnumerable <Artifact> > itemsNavigationPaths;
if (searchCriteria.IncludeArtifactPath)
{
itemsNavigationPaths =
await
_artifactRepository.GetArtifactsNavigationPathsAsync(userId, itemIds, false);
}
else
{
itemsNavigationPaths = new Dictionary <int, IEnumerable <Artifact> >();
}
// items without permission should be removed
items.RemoveAll(item => !itemIdsPermissions.ContainsKey(item.ItemId) || !itemIdsPermissions[item.ItemId].HasFlag(RolePermissions.Read));
var joinedResult = from item in items
join permission in itemIdsPermissions.AsEnumerable()
on item.ItemId equals permission.Key
join path in itemsNavigationPaths
on item.Id equals path.Key into paths
from lpath in paths.DefaultIfEmpty()
select new { item, permission, lpath };
foreach (var result in joinedResult)
{
result.item.Permissions = result.permission.Value;
if (searchCriteria.IncludeArtifactPath)
{
result.item.ArtifactPath = result.lpath.Value.Select(a => a.Name).ToList();
result.item.IdPath = result.lpath.Value.Select(a => a.Id).ToList();
result.item.ParentPredefinedType = result.lpath.Value.Select(a => a.PredefinedType).FirstOrDefault();
}
}
return(new ItemNameSearchResultSet
{
Items = items,
PageItemCount = items.Count
});
}
public async Task <RelationshipResultSet> GetRelationships(
int artifactId,
int?subArtifactId = null,
bool addDrafts = true,
int?versionId = null,
int?baselineId = null,
bool?allLinks = null)
{
var userId = Session.UserId;
if (artifactId < 1 || (subArtifactId.HasValue && subArtifactId.Value < 1) ||
versionId.HasValue && versionId.Value < 1 || (versionId != null && baselineId != null))
{
throw new BadRequestException();
}
if (addDrafts && versionId != null)
{
addDrafts = false;
}
var itemId = subArtifactId ?? artifactId;
var isDeleted = await _artifactVersionsRepository.IsItemDeleted(itemId);
var itemInfo = isDeleted && (versionId != null || baselineId != null) ?
await _artifactVersionsRepository.GetDeletedItemInfo(itemId) :
await _artifactPermissionsRepository.GetItemInfo(itemId, userId, addDrafts);
if (itemInfo == null)
{
throw new ResourceNotFoundException("You have attempted to access an item that does not exist or you do not have permission to view.",
subArtifactId.HasValue ? ErrorCodes.SubartifactNotFound : ErrorCodes.ArtifactNotFound);
}
if (subArtifactId.HasValue && itemInfo.ArtifactId != artifactId)
{
throw new BadRequestException("Please provide a proper subartifact Id");
}
// We do not need drafts for historical artifacts
var effectiveAddDraft = !versionId.HasValue && addDrafts;
var result = await _relationshipsRepository.GetRelationships(artifactId, userId, subArtifactId, effectiveAddDraft, allLinks.GetValueOrDefault(), versionId, baselineId);
var artifactIds = new List <int> {
artifactId
};
artifactIds = artifactIds.Union(result.ManualTraces.Select(a => a.ArtifactId)).Union(result.OtherTraces.Select(a => a.ArtifactId)).Distinct().ToList();
var permissions = await _artifactPermissionsRepository.GetArtifactPermissions(artifactIds, userId);
if (!SqlArtifactPermissionsRepository.HasPermissions(artifactId, permissions, RolePermissions.Read))
{
throw new AuthorizationException("You do not have permission to access the artifact");
}
ApplyRelationshipPermissions(permissions, result.ManualTraces);
ApplyRelationshipPermissions(permissions, result.OtherTraces);
result.CanEdit = SqlArtifactPermissionsRepository.HasPermissions(artifactId, permissions, RolePermissions.Trace) && SqlArtifactPermissionsRepository.HasPermissions(artifactId, permissions, RolePermissions.Edit);
return(result);
}
public async Task <DiscussionResultSet> GetDiscussions(int artifactId, int?subArtifactId = null)
{
ValidateRequestParameters(artifactId, subArtifactId);
var userId = Session.UserId;
var itemId = subArtifactId.HasValue ? subArtifactId.Value : artifactId;
var revisionId = int.MaxValue;
var isDeleted = await _artifactVersionsRepository.IsItemDeleted(itemId);
var itemInfo = isDeleted ?
await _artifactVersionsRepository.GetDeletedItemInfo(itemId) :
await _artifactPermissionsRepository.GetItemInfo(itemId, userId, false);
if (itemInfo == null)
{
throw new ResourceNotFoundException("You have attempted to access an item that does not exist or you do not have permission to view.",
subArtifactId.HasValue ? ErrorCodes.SubartifactNotFound : ErrorCodes.ArtifactNotFound);
}
if (subArtifactId.HasValue && itemInfo.ArtifactId != artifactId)
{
throw new BadRequestException("Please provide a proper subartifact Id");
}
if (isDeleted)
{
revisionId = ((DeletedItemInfo)itemInfo).VersionId;
}
var permissions = await _artifactPermissionsRepository.GetArtifactPermissions(new[] { artifactId }, userId, false, revisionId);
var projectPermissions = await _artifactPermissionsRepository.GetProjectPermissions(itemInfo.ProjectId);
RolePermissions permission = RolePermissions.None;
if (!permissions.TryGetValue(artifactId, out permission) || !permission.HasFlag(RolePermissions.Read))
{
throw new AuthorizationException("You do not have permission to access the artifact");
}
var discussions = await _discussionsRepository.GetDiscussions(itemId, itemInfo.ProjectId);
foreach (var discussion in discussions)
{
discussion.CanDelete = !projectPermissions.HasFlag(ProjectPermissions.CommentsDeletionDisabled) &&
permissions.TryGetValue(artifactId, out permission) &&
(permission.HasFlag(RolePermissions.DeleteAnyComment) || (permission.HasFlag(RolePermissions.Comment) && discussion.UserId == userId));
discussion.CanEdit = !projectPermissions.HasFlag(ProjectPermissions.CommentsModificationDisabled) &&
permissions.TryGetValue(artifactId, out permission) && (permission.HasFlag(RolePermissions.Comment) && discussion.UserId == userId);
}
var availableStatuses = await _discussionsRepository.GetThreadStatusCollection(itemInfo.ProjectId);
var result = new DiscussionResultSet
{
CanDelete = !projectPermissions.HasFlag(ProjectPermissions.CommentsDeletionDisabled) &&
permission.HasFlag(RolePermissions.DeleteAnyComment) && revisionId == int.MaxValue,
CanCreate = permission.HasFlag(RolePermissions.Comment) && revisionId == int.MaxValue,
Discussions = discussions,
EmailDiscussionsEnabled = await _discussionsRepository.AreEmailDiscussionsEnabled(itemInfo.ProjectId),
ThreadStatuses = availableStatuses
};
return(result);
}
public async Task <SuggestionsSearchResult> GetSemanticSearchSuggestions(
SemanticSearchSuggestionParameters parameters,
GetSemanticSearchSuggestionsAsyncDelegate getSuggestionsAsyncDelegate)
{
var artifactId = parameters.ArtifactId;
var userId = parameters.UserId;
if (artifactId <= 0)
{
throw new BadRequestException("Please specify a valid artifact id");
}
var artifactDetails = await _artifactRepository.GetArtifactBasicDetails(artifactId, userId);
if (artifactDetails == null)
{
throw new ResourceNotFoundException(
I18NHelper.FormatInvariant("Artifact Id {0} is not found", artifactId), ErrorCodes.ArtifactNotFound);
}
if (artifactDetails.LatestDeleted || artifactDetails.DraftDeleted)
{
throw new ResourceNotFoundException(
I18NHelper.FormatInvariant("Artifact Id {0} is deleted", artifactId), ErrorCodes.ArtifactNotFound);
}
var itemTypePredefined = (ItemTypePredefined)artifactDetails.PrimitiveItemTypePredefined;
if (isInvalidSemanticSearchArtifactType(itemTypePredefined))
{
throw new BadRequestException(
I18NHelper.FormatInvariant(
$"Artifact type '{itemTypePredefined}' is not supported for semantic search"));
}
if (artifactDetails.ArtifactId != artifactId && artifactDetails.ItemId == artifactId)
{
throw new BadRequestException("Subartifacts are not supported for semantic search");
}
var currentProject =
(await _artifactRepository.GetProjectNameByIdsAsync(new[] { artifactDetails.ProjectId }))
.FirstOrDefault();
var permissions = await _artifactPermissionsRepository.GetArtifactPermissions(new[] { artifactId }, userId);
RolePermissions permission;
if (!permissions.TryGetValue(artifactId, out permission) || !permission.HasFlag(RolePermissions.Read))
{
throw new AuthorizationException("User is not authorized to view artifact");
}
var suggestionsSearchResult = new SuggestionsSearchResult();
suggestionsSearchResult.SourceId = artifactId;
suggestionsSearchResult.SourceProjectName = currentProject?.Name;
var isInstanceAdmin = await _usersRepository.IsInstanceAdmin(false, userId);
var accessibleProjectIds = isInstanceAdmin
? new List <int>()
: await _semanticSearchRepository.GetAccessibleProjectIds(userId);
var searchEngineParameters = new SearchEngineParameters(artifactId, userId, isInstanceAdmin,
accessibleProjectIds.ToHashSet());
var suggestedArtifactResults = await getSuggestionsAsyncDelegate(searchEngineParameters);
var artifactIds = suggestedArtifactResults.Select(s => s.Id);
var resultArtifactPermissions = await _artifactPermissionsRepository.GetArtifactPermissions(artifactIds, userId);
suggestedArtifactResults.ForEach((artifact) =>
{
if (resultArtifactPermissions.ContainsKey(artifact.Id))
{
artifact.HasReadPermission = resultArtifactPermissions[artifact.Id].HasFlag(RolePermissions.Read);
}
});
// Get list of some basic artifact details from the list of returned ids.
suggestionsSearchResult.Items = suggestedArtifactResults;
return(suggestionsSearchResult);
}
public async Task <VersionControlArtifactInfo> GetVersionControlArtifactInfoAsync(int itemId, int?baselineId, int userId)
{
var artifactBasicDetails = await _artifactRepository.GetArtifactBasicDetails(itemId, userId);
if (artifactBasicDetails == null)
{
var errorMessage = I18NHelper.FormatInvariant("Item (Id:{0}) is not found.", itemId);
throw new ResourceNotFoundException(errorMessage, ErrorCodes.ResourceNotFound);
}
// Always getting permissions for the Head version of an artifact.
// But, just in case, RevisionId and AddDrafts are available in ArtifactBasicDetails.
var itemIdsPermissions = await _artifactPermissionsRepository.GetArtifactPermissions(Enumerable.Repeat(artifactBasicDetails.ArtifactId, 1), userId);
if (!itemIdsPermissions.ContainsKey(artifactBasicDetails.ArtifactId) || !itemIdsPermissions[artifactBasicDetails.ArtifactId].HasFlag(RolePermissions.Read))
{
var errorMessage = I18NHelper.FormatInvariant("User does not have permissions for Artifact (Id:{0}).", artifactBasicDetails.ArtifactId);
throw new AuthorizationException(errorMessage, ErrorCodes.UnauthorizedAccess);
}
var artifactInfo = new VersionControlArtifactInfo
{
Id = artifactBasicDetails.ArtifactId,
SubArtifactId = artifactBasicDetails.ArtifactId != artifactBasicDetails.ItemId
? (int?)artifactBasicDetails.ItemId
: null,
Name = artifactBasicDetails.Name,
ProjectId = artifactBasicDetails.ProjectId,
ParentId = artifactBasicDetails.ParentId,
OrderIndex = artifactBasicDetails.OrderIndex,
ItemTypeId = artifactBasicDetails.ItemTypeId,
Prefix = artifactBasicDetails.Prefix,
PredefinedType = (ItemTypePredefined)artifactBasicDetails.PrimitiveItemTypePredefined,
Version = artifactBasicDetails.VersionIndex != null && artifactBasicDetails.VersionIndex.Value <= 0 ? -1 : artifactBasicDetails.VersionIndex,
VersionCount = artifactBasicDetails.VersionsCount,
IsDeleted = artifactBasicDetails.DraftDeleted || artifactBasicDetails.LatestDeleted,
HasChanges = artifactBasicDetails.LockedByUserId != null && artifactBasicDetails.LockedByUserId.Value == userId ||
artifactBasicDetails.HasDraftRelationships,
LockedByUser = artifactBasicDetails.LockedByUserId != null
? new UserGroup {
Id = artifactBasicDetails.LockedByUserId.Value, DisplayName = artifactBasicDetails.LockedByUserName
}
: null,
LockedDateTime = artifactBasicDetails.LockedByUserTime != null
? (DateTime?)DateTime.SpecifyKind(artifactBasicDetails.LockedByUserTime.Value, DateTimeKind.Utc)
: null
};
if (artifactBasicDetails.DraftDeleted)
{
artifactInfo.DeletedByUser = artifactBasicDetails.UserId != null
? new UserGroup {
Id = artifactBasicDetails.UserId.Value, DisplayName = artifactBasicDetails.UserName
}
: null;
artifactInfo.DeletedDateTime = artifactBasicDetails.LastSaveTimestamp != null
? (DateTime?)DateTime.SpecifyKind(artifactBasicDetails.LastSaveTimestamp.Value, DateTimeKind.Utc)
: null;
}
else if (artifactBasicDetails.LatestDeleted)
{
artifactInfo.DeletedByUser = artifactBasicDetails.LatestDeletedByUserId != null
? new UserGroup {
Id = artifactBasicDetails.LatestDeletedByUserId.Value, DisplayName = artifactBasicDetails.LatestDeletedByUserName
}
: null;
artifactInfo.DeletedDateTime = artifactBasicDetails.LatestDeletedByUserTime != null
? (DateTime?)DateTime.SpecifyKind(artifactBasicDetails.LatestDeletedByUserTime.Value, DateTimeKind.Utc)
: null;
}
artifactInfo.Permissions = itemIdsPermissions[artifactBasicDetails.ArtifactId];
if (baselineId != null)
{
var baselineRevisionId = await _itemInfoRepository.GetRevisionId(itemId, userId, null, baselineId.Value);
var itemInfo = await _artifactPermissionsRepository.GetItemInfo(itemId, userId, false, baselineRevisionId);
if (itemInfo == null)
{
artifactInfo.IsNotExistsInBaseline = true;
}
artifactInfo.IsIncludedInBaseline = await IsArtifactInBaseline(artifactBasicDetails.ArtifactId, baselineId.Value, userId);
}
return(artifactInfo);
}