@Test public void should_return_tag_list() { Map<String, Long> tags = ImmutableMap.<String, Long>builder() .put("convention", 2771L) .put("brain-overload", 998L) .put("cwe", 89L) .put("bug", 32L) .put("cert", 2L) .build(); ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class); when(issueQueryFactory.create(captor.capture())).thenReturn(mock(IssueQuery.class)); when(service.countTags(any(IssueQuery.class), eq(5))).thenReturn(tags); TestResponse response = tester.newRequest() .setParam("componentUuid", "polop") .setParam("ps", "5") .execute(); assertJson(response.getInput()).isSimilarTo(getClass().getResource("ComponentTagsActionTest/component-tags.json")); assertThat(captor.getValue().getComponentUuids()).containsOnly("polop"); assertThat(captor.getValue().getResolved()).isFalse(); assertThat(captor.getValue().getCreatedAfter()).isNull(); }
/** * Execute the search request and return the document ids of results. */ private List<String> searchAndReturnKeys(IssueQuery.Builder query) { return Arrays.stream(underTest.search(query.build(), new SearchOptions()).getHits().getHits()) .map(SearchHit::getId) .collect(Collectors.toList()); }
@Test public void searchBranchStatistics_on_empty_list() { ComponentDto project = db.components().insertMainBranch(); assertThat(underTest.searchBranchStatistics(project.uuid(), emptyList())).isEmpty(); assertThat(underTest.searchBranchStatistics(project.uuid(), singletonList("unknown"))).isEmpty(); }
private void configureStickyFacets(IssueQuery query, SearchOptions options, Map<String, QueryBuilder> filters, QueryBuilder esQuery, SearchRequestBuilder esSearch) { if (!options.getFacets().isEmpty()) { StickyFacetBuilder stickyFacetBuilder = newStickyFacetBuilder(query, filters, esQuery); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, SEVERITIES); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, STATUSES); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PROJECT_UUIDS, query.projectUuids().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, MODULE_UUIDS, query.moduleUuids().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, DIRECTORIES, query.directories().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, FILE_UUIDS, query.fileUuids().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, LANGUAGES, query.languages().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, RULES, query.rules().stream().map(RuleDefinitionDto::getId).toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, AUTHORS, query.authors().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, TAGS, query.tags().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, TYPES, query.types().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, OWASP_TOP_10, query.owaspTop10().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, SANS_TOP_25, query.sansTop25().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, CWE, query.cwe().toArray()); if (options.getFacets().contains(PARAM_RESOLUTIONS)) { esSearch.addAggregation(createResolutionFacet(query, filters, esQuery)); } if (options.getFacets().contains(PARAM_ASSIGNEES)) { esSearch.addAggregation(createAssigneesFacet(query, filters, esQuery)); } if (options.getFacets().contains(PARAM_CREATED_AT)) { getCreatedAtFacet(query, filters, esQuery).ifPresent(esSearch::addAggregation); } addAssignedToMeFacetIfNeeded(esSearch, options, query, filters, esQuery); } }
private Map<String, QueryBuilder> createFilters(IssueQuery query) { Map<String, QueryBuilder> filters = new HashMap<>(); filters.put("__authorization", createAuthorizationFilter()); filters.put(FIELD_ISSUE_KEY, createTermsFilter(FIELD_ISSUE_KEY, query.issueKeys())); filters.put(FIELD_ISSUE_ASSIGNEE_UUID, createTermsFilter(FIELD_ISSUE_ASSIGNEE_UUID, query.assignees())); filters.put(FIELD_ISSUE_LANGUAGE, createTermsFilter(FIELD_ISSUE_LANGUAGE, query.languages())); filters.put(FIELD_ISSUE_TAGS, createTermsFilter(FIELD_ISSUE_TAGS, query.tags())); filters.put(FIELD_ISSUE_TYPE, createTermsFilter(FIELD_ISSUE_TYPE, query.types())); filters.put(FIELD_ISSUE_RESOLUTION, createTermsFilter(FIELD_ISSUE_RESOLUTION, query.resolutions())); filters.put(FIELD_ISSUE_AUTHOR_LOGIN, createTermsFilter(FIELD_ISSUE_AUTHOR_LOGIN, query.authors())); filters.put(FIELD_ISSUE_RULE_ID, createTermsFilter( FIELD_ISSUE_RULE_ID, query.rules().stream().map(RuleDefinitionDto::getId).collect(Collectors.toList()))); filters.put(FIELD_ISSUE_SEVERITY, createTermsFilter(FIELD_ISSUE_SEVERITY, query.severities())); filters.put(FIELD_ISSUE_STATUS, createTermsFilter(FIELD_ISSUE_STATUS, query.statuses())); filters.put(FIELD_ISSUE_ORGANIZATION_UUID, createTermFilter(FIELD_ISSUE_ORGANIZATION_UUID, query.organizationUuid())); filters.put(FIELD_ISSUE_OWASP_TOP_10, createTermsFilter(FIELD_ISSUE_OWASP_TOP_10, query.owaspTop10())); filters.put(FIELD_ISSUE_SANS_TOP_25, createTermsFilter(FIELD_ISSUE_SANS_TOP_25, query.sansTop25())); filters.put(FIELD_ISSUE_CWE, createTermsFilter(FIELD_ISSUE_CWE, query.cwe())); addComponentRelatedFilters(query, filters); addDatesFilter(filters, query); addCreatedAfterByProjectsFilter(filters, query); return filters;
public SearchResponse search(IssueQuery query, SearchOptions options) { SearchRequestBuilder requestBuilder = client.prepareSearch(INDEX_TYPE_ISSUE); configureSorting(query, requestBuilder); configurePagination(options, requestBuilder); configureRouting(query, options, requestBuilder); QueryBuilder esQuery = matchAllQuery(); BoolQueryBuilder esFilter = boolQuery(); Map<String, QueryBuilder> filters = createFilters(query); for (QueryBuilder filter : filters.values()) { if (filter != null) { esFilter.must(filter); } } if (esFilter.hasClauses()) { requestBuilder.setQuery(boolQuery().must(esQuery).filter(esFilter)); } else { requestBuilder.setQuery(esQuery); } configureStickyFacets(query, options, filters, esQuery, requestBuilder); requestBuilder.addAggregation(EFFORT_AGGREGATION); requestBuilder.setFetchSource(false); return requestBuilder.get(); }
private static AggregationBuilder createResolutionFacet(IssueQuery query, Map<String, QueryBuilder> filters, QueryBuilder esQuery) { String fieldName = RESOLUTIONS.getFieldName(); String facetName = RESOLUTIONS.getName(); // Same as in super.stickyFacetBuilder Map<String, QueryBuilder> resolutionFilters = Maps.newHashMap(filters); resolutionFilters.remove("__isResolved"); resolutionFilters.remove(fieldName); StickyFacetBuilder assigneeFacetBuilder = newStickyFacetBuilder(query, resolutionFilters, esQuery); BoolQueryBuilder facetFilter = assigneeFacetBuilder.getStickyFacetFilter(fieldName); FilterAggregationBuilder facetTopAggregation = assigneeFacetBuilder.buildTopFacetAggregation(fieldName, facetName, facetFilter, RESOLUTIONS.getSize()); facetTopAggregation = assigneeFacetBuilder.addSelectedItemsToFacet(fieldName, facetName, facetTopAggregation, t -> t); // Add missing facet for unresolved issues facetTopAggregation.subAggregation( addEffortAggregationIfNeeded(query, AggregationBuilders .missing(facetName + FACET_SUFFIX_MISSING) .field(fieldName))); return AggregationBuilders .global(facetName) .subAggregation(facetTopAggregation); }
private static AggregationBuilder createAssigneesFacet(IssueQuery query, Map<String, QueryBuilder> filters, QueryBuilder queryBuilder) { String fieldName = IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE_UUID; String facetName = PARAM_ASSIGNEES; // Same as in super.stickyFacetBuilder Map<String, QueryBuilder> assigneeFilters = Maps.newHashMap(filters); assigneeFilters.remove(IS_ASSIGNED_FILTER); assigneeFilters.remove(fieldName); StickyFacetBuilder assigneeFacetBuilder = newStickyFacetBuilder(query, assigneeFilters, queryBuilder); BoolQueryBuilder facetFilter = assigneeFacetBuilder.getStickyFacetFilter(fieldName); FilterAggregationBuilder facetTopAggregation = assigneeFacetBuilder.buildTopFacetAggregation(fieldName, facetName, facetFilter, DEFAULT_FACET_SIZE); Collection<String> assigneesEscaped = escapeValuesForFacetInclusion(query.assignees()); if (!assigneesEscaped.isEmpty()) { facetTopAggregation = assigneeFacetBuilder.addSelectedItemsToFacet(fieldName, facetName, facetTopAggregation, t -> t, assigneesEscaped.toArray()); } // Add missing facet for unassigned issues facetTopAggregation.subAggregation( addEffortAggregationIfNeeded(query, AggregationBuilders .missing(facetName + FACET_SUFFIX_MISSING) .field(fieldName))); return AggregationBuilders .global(facetName) .subAggregation(facetTopAggregation); }
PeriodStart createdAfter = query.createdAfter(); if (createdAfter == null) { OptionalLong minDate = getMinCreatedAt(filters, esQuery); if (!minDate.isPresent()) { return Optional.empty(); addEffortAggregationIfNeeded(query, dateHistogram); return Optional.of(dateHistogram);
private void configureStickyFacets(IssueQuery query, SearchOptions options, Map<String, QueryBuilder> filters, QueryBuilder esQuery, SearchRequestBuilder esSearch) { if (!options.getFacets().isEmpty()) { StickyFacetBuilder stickyFacetBuilder = newStickyFacetBuilder(query, filters, esQuery); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_SEVERITIES, IssueIndexDefinition.FIELD_ISSUE_SEVERITY); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_STATUSES, IssueIndexDefinition.FIELD_ISSUE_STATUS); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_PROJECT_UUIDS, IssueIndexDefinition.FIELD_ISSUE_PROJECT_UUID, query.projectUuids().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_MODULE_UUIDS, IssueIndexDefinition.FIELD_ISSUE_MODULE_UUID, query.moduleUuids().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_DIRECTORIES, IssueIndexDefinition.FIELD_ISSUE_DIRECTORY_PATH, query.directories().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_FILE_UUIDS, IssueIndexDefinition.FIELD_ISSUE_COMPONENT_UUID, query.fileUuids().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_LANGUAGES, IssueIndexDefinition.FIELD_ISSUE_LANGUAGE, query.languages().toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_RULES, IssueIndexDefinition.FIELD_ISSUE_RULE_ID, query.rules().stream().map(RuleDefinitionDto::getId).toArray()); addSimpleStickyFacetIfNeeded(options, stickyFacetBuilder, esSearch, PARAM_AUTHORS, IssueIndexDefinition.FIELD_ISSUE_AUTHOR_LOGIN, query.authors().toArray()); esSearch.addAggregation(createResolutionFacet(query, filters, esQuery)); esSearch.addAggregation(createAssigneesFacet(query, filters, esQuery)); addAssignedToMeFacetIfNeeded(esSearch, options, query, filters, esQuery); if (options.getFacets().contains(PARAM_CREATED_AT)) {
private Map<String, QueryBuilder> createFilters(IssueQuery query) { Map<String, QueryBuilder> filters = new HashMap<>(); filters.put("__authorization", createAuthorizationFilter(query.checkAuthorization())); filters.put(IssueIndexDefinition.FIELD_ISSUE_KEY, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_KEY, query.issueKeys())); filters.put(IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE_UUID, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE_UUID, query.assignees())); addComponentRelatedFilters(query, filters); filters.put(IssueIndexDefinition.FIELD_ISSUE_LANGUAGE, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_LANGUAGE, query.languages())); filters.put(IssueIndexDefinition.FIELD_ISSUE_TAGS, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_TAGS, query.tags())); filters.put(IssueIndexDefinition.FIELD_ISSUE_TYPE, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_TYPE, query.types())); filters.put(IssueIndexDefinition.FIELD_ISSUE_RESOLUTION, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_RESOLUTION, query.resolutions())); filters.put(IssueIndexDefinition.FIELD_ISSUE_AUTHOR_LOGIN, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_AUTHOR_LOGIN, query.authors())); filters.put(IssueIndexDefinition.FIELD_ISSUE_RULE_ID, createTermsFilter( IssueIndexDefinition.FIELD_ISSUE_RULE_ID, query.rules().stream().map(RuleDefinitionDto::getId).collect(Collectors.toList()))); filters.put(IssueIndexDefinition.FIELD_ISSUE_SEVERITY, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_SEVERITY, query.severities())); filters.put(IssueIndexDefinition.FIELD_ISSUE_STATUS, createTermsFilter(IssueIndexDefinition.FIELD_ISSUE_STATUS, query.statuses())); filters.put(IssueIndexDefinition.FIELD_ISSUE_ORGANIZATION_UUID, createTermFilter(IssueIndexDefinition.FIELD_ISSUE_ORGANIZATION_UUID, query.organizationUuid())); addDatesFilter(filters, query); addCreatedAfterByProjectsFilter(filters, query); return filters;
public SearchResponse search(IssueQuery query, SearchOptions options) { SearchRequestBuilder requestBuilder = client.prepareSearch(INDEX_TYPE_ISSUE); configureSorting(query, requestBuilder); configurePagination(options, requestBuilder); configureRouting(query, options, requestBuilder); QueryBuilder esQuery = matchAllQuery(); BoolQueryBuilder esFilter = boolQuery(); Map<String, QueryBuilder> filters = createFilters(query); for (QueryBuilder filter : filters.values()) { if (filter != null) { esFilter.must(filter); } } if (esFilter.hasClauses()) { requestBuilder.setQuery(boolQuery().must(esQuery).filter(esFilter)); } else { requestBuilder.setQuery(esQuery); } configureStickyFacets(query, options, filters, esQuery, requestBuilder); requestBuilder.setFetchSource(false); return requestBuilder.get(); }
private static AggregationBuilder createAssigneesFacet(IssueQuery query, Map<String, QueryBuilder> filters, QueryBuilder queryBuilder) { String fieldName = ASSIGNEES.getFieldName(); String facetName = ASSIGNEES.getName(); // Same as in super.stickyFacetBuilder Map<String, QueryBuilder> assigneeFilters = Maps.newHashMap(filters); assigneeFilters.remove(IS_ASSIGNED_FILTER); assigneeFilters.remove(fieldName); StickyFacetBuilder assigneeFacetBuilder = newStickyFacetBuilder(query, assigneeFilters, queryBuilder); BoolQueryBuilder facetFilter = assigneeFacetBuilder.getStickyFacetFilter(fieldName); FilterAggregationBuilder facetTopAggregation = assigneeFacetBuilder.buildTopFacetAggregation(fieldName, facetName, facetFilter, ASSIGNEES.getSize()); if (!query.assignees().isEmpty()) { facetTopAggregation = assigneeFacetBuilder.addSelectedItemsToFacet(fieldName, facetName, facetTopAggregation, t -> t, query.assignees().toArray()); } // Add missing facet for unassigned issues facetTopAggregation.subAggregation( addEffortAggregationIfNeeded(query, AggregationBuilders .missing(facetName + FACET_SUFFIX_MISSING) .field(fieldName))); return AggregationBuilders .global(facetName) .subAggregation(facetTopAggregation); }
PeriodStart createdAfter = query.createdAfter(); if (createdAfter == null) { Optional<Long> minDate = getMinCreatedAt(filters, esQuery); if (!minDate.isPresent()) { return Optional.empty(); addEffortAggregationIfNeeded(query, dateHistogram); return Optional.of(dateHistogram);
/** * Execute the search request and return the document ids of results. */ private List<String> searchAndReturnKeys(IssueQuery.Builder query) { return Arrays.stream(underTest.search(query.build(), new SearchOptions()).getHits().getHits()) .map(SearchHit::getId) .collect(Collectors.toList()); }
private void addAssignedToMeFacetIfNeeded(SearchRequestBuilder builder, SearchOptions options, IssueQuery query, Map<String, QueryBuilder> filters, QueryBuilder queryBuilder) { String uuid = userSession.getUuid(); if (!options.getFacets().contains(ASSIGNED_TO_ME.getName()) || StringUtils.isEmpty(uuid)) { return; } String fieldName = ASSIGNED_TO_ME.getFieldName(); String facetName = ASSIGNED_TO_ME.getName(); // Same as in super.stickyFacetBuilder StickyFacetBuilder assignedToMeFacetBuilder = newStickyFacetBuilder(query, filters, queryBuilder); BoolQueryBuilder facetFilter = assignedToMeFacetBuilder.getStickyFacetFilter(IS_ASSIGNED_FILTER, fieldName); FilterAggregationBuilder facetTopAggregation = AggregationBuilders .filter(facetName + "__filter", facetFilter) .subAggregation(addEffortAggregationIfNeeded(query, AggregationBuilders.terms(facetName + "__terms") .field(fieldName) .includeExclude(new IncludeExclude(escapeSpecialRegexChars(uuid), null)))); builder.addAggregation( AggregationBuilders.global(facetName) .subAggregation(facetTopAggregation)); }
@Override public void handle(Request request, Response response) throws Exception { String projectKey = request.mandatoryParam(PARAM_PROJECT); try (DbSession dbSession = dbClient.openSession(false)) { ComponentDto project = componentFinder.getByKey(dbSession, projectKey); checkPermission(project); checkArgument(ALLOWED_QUALIFIERS.contains(project.qualifier()), "Invalid project"); Collection<BranchDto> branches = dbClient.branchDao().selectByComponent(dbSession, project).stream() .filter(b -> b.getBranchType() == SHORT || b.getBranchType() == LONG) .collect(toList()); List<String> branchUuids = branches.stream().map(BranchDto::getUuid).collect(toList()); Map<String, BranchDto> mergeBranchesByUuid = dbClient.branchDao() .selectByUuids(dbSession, branches.stream().map(BranchDto::getMergeBranchUuid).filter(Objects::nonNull).collect(toList())) .stream().collect(uniqueIndex(BranchDto::getUuid)); Map<String, LiveMeasureDto> qualityGateMeasuresByComponentUuids = dbClient.liveMeasureDao() .selectByComponentUuidsAndMetricKeys(dbSession, branchUuids, singletonList(ALERT_STATUS_KEY)).stream() .collect(uniqueIndex(LiveMeasureDto::getComponentUuid)); Map<String, BranchStatistics> branchStatisticsByBranchUuid = issueIndex.searchBranchStatistics(project.uuid(), branches.stream() .filter(b -> b.getBranchType().equals(SHORT)) .map(BranchDto::getUuid).collect(toList())).stream() .collect(uniqueIndex(BranchStatistics::getBranchUuid, Function.identity())); Map<String, String> analysisDateByBranchUuid = dbClient.snapshotDao() .selectLastAnalysesByRootComponentUuids(dbSession, branchUuids).stream() .collect(uniqueIndex(SnapshotDto::getComponentUuid, s -> formatDateTime(s.getCreatedAt()))); ProjectBranches.ListWsResponse.Builder protobufResponse = ProjectBranches.ListWsResponse.newBuilder(); branches.forEach(b -> addBranch(protobufResponse, b, mergeBranchesByUuid, qualityGateMeasuresByComponentUuids.get(b.getUuid()), branchStatisticsByBranchUuid.get(b.getUuid()), analysisDateByBranchUuid.get(b.getUuid()))); WsUtils.writeProtobuf(protobufResponse.build(), request, response); } }
@Test public void should_return_tag_list_with_created_after() { Map<String, Long> tags = ImmutableMap.<String, Long>builder() .put("convention", 2771L) .put("brain-overload", 998L) .put("cwe", 89L) .put("bug", 32L) .put("cert", 2L) .build(); ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class); when(issueQueryFactory.create(captor.capture())).thenReturn(mock(IssueQuery.class)); when(service.countTags(any(IssueQuery.class), eq(5))).thenReturn(tags); String componentUuid = "polop"; String createdAfter = "2011-04-25"; TestResponse response = tester.newRequest() .setParam("componentUuid", componentUuid) .setParam("createdAfter", createdAfter) .setParam("ps", "5") .execute(); assertJson(response.getInput()).isSimilarTo(getClass().getResource("ComponentTagsActionTest/component-tags.json")); assertThat(captor.getValue().getComponentUuids()).containsOnly(componentUuid); assertThat(captor.getValue().getResolved()).isFalse(); assertThat(captor.getValue().getCreatedAfter()).isEqualTo(createdAfter); } }
/** * Execute the search request and return the document ids of results. */ private List<String> searchAndReturnKeys(IssueQuery.Builder query) { return Arrays.stream(underTest.search(query.build(), new SearchOptions()).getHits().getHits()) .map(SearchHit::getId) .collect(Collectors.toList()); }
private static AggregationBuilder createResolutionFacet(IssueQuery query, Map<String, QueryBuilder> filters, QueryBuilder esQuery) { String fieldName = IssueIndexDefinition.FIELD_ISSUE_RESOLUTION; String facetName = PARAM_RESOLUTIONS; // Same as in super.stickyFacetBuilder Map<String, QueryBuilder> resolutionFilters = Maps.newHashMap(filters); resolutionFilters.remove("__isResolved"); resolutionFilters.remove(fieldName); StickyFacetBuilder assigneeFacetBuilder = newStickyFacetBuilder(query, resolutionFilters, esQuery); BoolQueryBuilder facetFilter = assigneeFacetBuilder.getStickyFacetFilter(fieldName); FilterAggregationBuilder facetTopAggregation = assigneeFacetBuilder.buildTopFacetAggregation(fieldName, facetName, facetFilter, DEFAULT_FACET_SIZE); facetTopAggregation = assigneeFacetBuilder.addSelectedItemsToFacet(fieldName, facetName, facetTopAggregation, t -> t); // Add missing facet for unresolved issues facetTopAggregation.subAggregation( addEffortAggregationIfNeeded(query, AggregationBuilders .missing(facetName + FACET_SUFFIX_MISSING) .field(fieldName))); return AggregationBuilders .global(facetName) .subAggregation(facetTopAggregation); }