public async Task GetSemanticSearchSuggestions_WhenNotInstanceAdmin_QueriesAccessibleProjects()
        {
            // arrange
            var parameters = new SemanticSearchSuggestionParameters(1, 1);

            _artifactRepository.Setup(a => a.GetArtifactBasicDetails(It.IsAny <int>(), It.IsAny <int>(), null))
            .ReturnsAsync(new ArtifactBasicDetails()
            {
                PrimitiveItemTypePredefined = (int)ItemTypePredefined.Actor
            });
            _artifactPermissionsRepository.Setup(
                a =>
                a.GetArtifactPermissions(It.IsAny <IEnumerable <int> >(), It.IsAny <int>(), It.IsAny <bool>(),
                                         It.IsAny <int>(), It.IsAny <bool>(), null))
            .ReturnsAsync(new Dictionary <int, RolePermissions>()
            {
                { 1, RolePermissions.Read }
            });

            _usersRepository.Setup(u => u.IsInstanceAdmin(It.IsAny <bool>(), It.IsAny <int>())).ReturnsAsync(false);

            _semanticSearchRepository.Setup(s => s.GetAccessibleProjectIds(It.IsAny <int>()))
            .ReturnsAsync(new List <int>());

            GetSemanticSearchSuggestionsAsyncDelegate searchDelegate = async(searchEngineParameters) => await Task.FromResult(new List <ArtifactSearchResult>() { new ArtifactSearchResult()
                                                                                                                                                                  {
                                                                                                                                                                      ItemId = 1
                                                                                                                                                                  } });

            // act
            await _semanticSearchService.GetSemanticSearchSuggestions(parameters, searchDelegate);

            // assert
            _semanticSearchRepository.Verify(s => s.GetAccessibleProjectIds(It.IsAny <int>()), Times.Once);
        }
        public async Task GetSemanticSearchSuggestions_WhenArtifactNotFound_ThrowsNotFoundException()
        {
            // arrange
            var parameters = new SemanticSearchSuggestionParameters(1, 1);

            _artifactRepository.Setup(a => a.GetArtifactBasicDetails(It.IsAny <int>(), It.IsAny <int>(), null))
            .ReturnsAsync((ArtifactBasicDetails)null);

            // act
            await _semanticSearchService.GetSemanticSearchSuggestions(parameters, null);
        }
        private async Task ExecuteItemTypeTests(ItemTypePredefined itemTypePredefined)
        {
            // arrange
            var parameters = new SemanticSearchSuggestionParameters(1, 1);

            _artifactRepository.Setup(a => a.GetArtifactBasicDetails(It.IsAny <int>(), It.IsAny <int>(), null))
            .ReturnsAsync(new ArtifactBasicDetails()
            {
                PrimitiveItemTypePredefined = (int)itemTypePredefined
            });

            // act
            await _semanticSearchService.GetSemanticSearchSuggestions(parameters, null);
        }
        public async Task GetSemanticSearchSuggestions_WhenDoesNotHavePermissionToResult_ReturnsArtifactWithNoReadPermissions()
        {
            // arrange
            var parameters = new SemanticSearchSuggestionParameters(1, 1);

            _artifactRepository.Setup(a => a.GetArtifactBasicDetails(It.IsAny <int>(), It.IsAny <int>(), null))
            .ReturnsAsync(new ArtifactBasicDetails()
            {
                PrimitiveItemTypePredefined = (int)ItemTypePredefined.Actor
            });
            _artifactPermissionsRepository.Setup(
                a =>
                a.GetArtifactPermissions(It.IsAny <IEnumerable <int> >(), It.IsAny <int>(), It.IsAny <bool>(),
                                         It.IsAny <int>(), It.IsAny <bool>(), null))
            .ReturnsAsync(new Dictionary <int, RolePermissions>()
            {
                { 1, RolePermissions.Read }
            });

            _usersRepository.Setup(u => u.IsInstanceAdmin(It.IsAny <bool>(), It.IsAny <int>())).ReturnsAsync(false);

            _semanticSearchRepository.Setup(s => s.GetAccessibleProjectIds(It.IsAny <int>()))
            .ReturnsAsync(new List <int>());

            _artifactPermissionsRepository.Setup(
                s =>
                s.GetArtifactPermissions(It.IsIn(new List <int>()
            {
                2
            }), It.IsAny <int>(), It.IsAny <bool>(),
                                         It.IsAny <int>(), It.IsAny <bool>(), null))
            .ReturnsAsync(new Dictionary <int, RolePermissions>()
            {
                { 2, RolePermissions.None }
            });

            GetSemanticSearchSuggestionsAsyncDelegate searchDelegate = async(searchEngineParameters) => await Task.FromResult(new List <ArtifactSearchResult>() { new ArtifactSearchResult()
                                                                                                                                                                  {
                                                                                                                                                                      ItemId = 2
                                                                                                                                                                  } });

            // act
            var result = await _semanticSearchService.GetSemanticSearchSuggestions(parameters, searchDelegate);

            // assert
            Assert.IsTrue(result.Items.Count() == 1);
            Assert.IsFalse(result.Items.First().HasReadPermission);
        }
        public async Task GetSemanticSearchSuggestions_WhenSubartifactId_ThrowsBadRequestException()
        {
            // arrange
            var parameters = new SemanticSearchSuggestionParameters(1, 1);


            _artifactRepository.Setup(a => a.GetArtifactBasicDetails(It.IsAny <int>(), It.IsAny <int>(), null))
            .ReturnsAsync(new ArtifactBasicDetails()
            {
                PrimitiveItemTypePredefined = (int)ItemTypePredefined.Actor,
                ArtifactId = 2,
                ItemId     = parameters.ArtifactId
            });

            // act
            await _semanticSearchService.GetSemanticSearchSuggestions(parameters, null);
        }
        public async Task GetSemanticSearchSuggestions_WhenNoPermissions_ThrowsAuthorizationException()
        {
            // arrange
            var parameters = new SemanticSearchSuggestionParameters(1, 1);

            _artifactRepository.Setup(a => a.GetArtifactBasicDetails(It.IsAny <int>(), It.IsAny <int>(), null))
            .ReturnsAsync(new ArtifactBasicDetails()
            {
                PrimitiveItemTypePredefined = (int)ItemTypePredefined.Actor
            });
            _artifactPermissionsRepository.Setup(
                a =>
                a.GetArtifactPermissions(It.IsAny <IEnumerable <int> >(), It.IsAny <int>(), It.IsAny <bool>(),
                                         It.IsAny <int>(), It.IsAny <bool>(), null))
            .ReturnsAsync(new Dictionary <int, RolePermissions>()
            {
                { 1, RolePermissions.None }
            });

            // act
            await _semanticSearchService.GetSemanticSearchSuggestions(parameters, null);
        }
        public async Task GetSemanticSearchSuggestions_WhenArtifactIdInvalid_ThrowsBadRequestException()
        {
            var parameters = new SemanticSearchSuggestionParameters(0, 1);

            await _semanticSearchService.GetSemanticSearchSuggestions(parameters, null);
        }
        public async Task <SuggestionsSearchResult> GetSuggestions([FromUri] SuggestionsSearchCriteria searchCriteria)
        {
            var suggestionParameters = new SemanticSearchSuggestionParameters(searchCriteria.ArtifactId, Session.UserId);

            return(await _semanticSearchService.GetSemanticSearchSuggestions(suggestionParameters, SemanticSearchExecutor.GetSemanticSearchSuggestionsAsyncDelegate));
        }
Пример #9
0
        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);
        }