/** * Generate the field name term for the field name for filters */ private NestedFilterBuilder fieldNameTerm( final String fieldName, final FilterBuilder fieldValueBuilder ) { final BoolFilterBuilder booleanQuery = FilterBuilders.boolFilter(); booleanQuery.must( FilterBuilders.termFilter( IndexingUtils.FIELD_NAME_NESTED, fieldName ) ); booleanQuery.must( fieldValueBuilder ); return FilterBuilders.nestedFilter( IndexingUtils.ENTITY_FIELDS, booleanQuery ); }
BoolFilterBuilder elementIsNotHiddenQuery = FilterBuilders.boolFilter(); for (String hiddenVertexPropertyName : hiddenVertexPropertyNames) { elementIsNotHiddenQuery.mustNot(FilterBuilders.existsFilter(hiddenVertexPropertyName));
boolFilterBuilder.must(idsFilterBuilder); List labels = (List) value; if(labels.size() == 1) boolFilterBuilder.must(FilterBuilders.typeFilter(labels.get(0).toString())); else { FilterBuilder[] filters = new FilterBuilder[labels.size()]; for(int i = 0; i < labels.size(); i++) filters[i] = FilterBuilders.typeFilter(labels.get(i).toString()); boolFilterBuilder.must(FilterBuilders.orFilter(filters)); else boolFilterBuilder.must(FilterBuilders.typeFilter(value.toString())); switch (predicateString) { case ("eq"): boolFilterBuilder.must(FilterBuilders.termFilter(key, value)); break; case ("neq"): boolFilterBuilder.mustNot(FilterBuilders.termFilter(key, value)); break; case ("gt"): boolFilterBuilder.must(FilterBuilders.rangeFilter(key).gt(value)); break; case ("gte"): boolFilterBuilder.must(FilterBuilders.rangeFilter(key).gte(value)); break; case ("lt"): boolFilterBuilder.must(FilterBuilders.rangeFilter(key).lt(value)); break;
/** * Add a filter that check for authorizations on resources * Takes also in account the ALL_USER group */ public static FilterBuilder getResourceAuthorizationFilters() { final Authentication auth = SecurityContextHolder.getContext().getAuthentication(); if (auth.getAuthorities().contains(new SimpleGrantedAuthority(Role.ADMIN.toString()))) { return null; } FilterBuilder filterBuilder; User user = (User) auth.getPrincipal(); if (user.getGroups() != null && !user.getGroups().isEmpty()) { filterBuilder = FilterBuilders.boolFilter() .should(FilterBuilders.nestedFilter("userRoles", FilterBuilders.termFilter("userRoles.key", auth.getName()))) .should(FilterBuilders.nestedFilter("groupRoles", FilterBuilders.inFilter("groupRoles.key", user.getGroups().toArray()))); } else { filterBuilder = FilterBuilders.nestedFilter("userRoles", FilterBuilders.termFilter("userRoles.key", auth.getName())); } Group group = getAllUsersGroup(); if (group != null) { String groupId = group.getId(); // add ALL_USERS group as OR filter filterBuilder = FilterBuilders.orFilter(filterBuilder, FilterBuilders.nestedFilter("groupRoles", FilterBuilders.inFilter("groupRoles.key", groupId))); } return filterBuilder; }
@Override public void buildSearchForIndexedDocumentsNotUpdatedAfter(SearchRequestBuilder srb, String jiraProjectKey, Date date) { FilterBuilder filterTime = FilterBuilders.rangeFilter("_timestamp").lt(date); FilterBuilder filterProject = FilterBuilders.termFilter(indexFieldForProjectKey, jiraProjectKey); FilterBuilder filterSource = FilterBuilders.termFilter(indexFieldForRiverName, riverName); FilterBuilder filter = FilterBuilders.boolFilter().must(filterTime).must(filterProject).must(filterSource); srb.setQuery(QueryBuilders.matchAllQuery()).addField("_id").setPostFilter(filter); Set<String> st = new LinkedHashSet<String>(); st.add(issueTypeName); if (commentIndexingMode.isExtraDocumentIndexed()) st.add(commentTypeName); if (changelogIndexingMode.isExtraDocumentIndexed()) st.add(changelogTypeName); srb.setTypes(st.toArray(new String[st.size()])); }
@Override public Iterator<Edge> edges(Predicates predicates) { BoolFilterBuilder boolFilter = ElasticHelper.createFilterBuilder(predicates.hasContainers); boolFilter.must(FilterBuilders.existsFilter(DocEdge.InId)); return new QueryIterator<>(boolFilter, 0, scrollSize, predicates.limitHigh - predicates.limitLow, client, this::createEdge, refresh, timing, indexName); }
@Override public Iterator<Vertex> vertices(Predicates predicates) { BoolFilterBuilder boolFilter = ElasticHelper.createFilterBuilder(predicates.hasContainers); boolFilter.must(FilterBuilders.missingFilter(DocEdge.InId)); return new QueryIterator<>(boolFilter, 0, scrollSize, predicates.limitHigh - predicates.limitLow, client, this::createVertex, refresh, timing, indexName); }
@Override public <P extends ParaObject> List<P> findTagged(String appid, String type, String[] tags, Pager... pager) { if (tags == null || tags.length == 0 || StringUtils.isBlank(appid)) { return Collections.emptyList(); } BoolFilterBuilder tagFilter = FilterBuilders.boolFilter(); //assuming clean & safe tags here for (String tag : tags) { tagFilter.must(FilterBuilders.termFilter(Config._TAGS, tag)); } QueryBuilder qb = QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), tagFilter); // The filter looks like this: ("tag1" OR "tag2" OR "tag3") AND "type" return searchQuery(appid, type, qb, pager); }
@Override public Map<Object, Set<Edge>> edges(Iterator<BaseVertex> vertices, Direction direction, String[] edgeLabels, Predicates predicates) { Map<Object, Vertex> idToVertex = new HashMap<>(); vertices.forEachRemaining(singleVertex -> idToVertex.put(singleVertex.id(), singleVertex)); if (edgeLabels != null && edgeLabels.length > 0) predicates.hasContainers.add(new HasContainer(T.label.getAccessor(), P.within(edgeLabels))); Object[] vertexIds = idToVertex.keySet().toArray(); BoolFilterBuilder boolFilter = ElasticHelper.createFilterBuilder(predicates.hasContainers); if (direction == Direction.IN) boolFilter.must(FilterBuilders.termsFilter(DocEdge.InId, vertexIds)); else if (direction == Direction.OUT) boolFilter.must(FilterBuilders.termsFilter(DocEdge.OutId, vertexIds)); else if (direction == Direction.BOTH) boolFilter.must(FilterBuilders.orFilter( FilterBuilders.termsFilter(DocEdge.InId, vertexIds), FilterBuilders.termsFilter(DocEdge.OutId, vertexIds))); QueryIterator<Edge> edgeQueryIterator = new QueryIterator<>(boolFilter, 0, scrollSize, predicates.limitHigh - predicates.limitLow, client, this::createEdge , refresh, timing, indexName); Map<Object, Set<Edge>> results = new HashMap<>(); edgeQueryIterator.forEachRemaining(edge -> edge.vertices(direction).forEachRemaining(vertex -> { Set<Edge> resultEdges = results.get(vertex.id()); if (resultEdges == null) { resultEdges = new HashSet<>(); results.put(vertex.id(), resultEdges); } resultEdges.add(edge); })); return results; }
@Override public Map<Object, Set<Edge>> edges(Iterator<BaseVertex> vertices, Direction direction, String[] edgeLabels, Predicates predicates) { List<Object> vertexIds = new ArrayList<>(); vertices.forEachRemaining(singleVertex -> vertexIds.add(singleVertex.id())); BoolFilterBuilder boolFilter = ElasticHelper.createFilterBuilder(predicates.hasContainers); OrFilterBuilder mappingFilter = FilterBuilders.orFilter(); boolean empty = true; for (EdgeMapping mapping : edgeMappings) { if (edgeLabels != null && edgeLabels.length > 0 && !contains(edgeLabels, mapping.getLabel())) continue; mappingFilter.add(FilterBuilders.termsFilter(mapping.getExternalVertexField(), vertexIds.toArray())); empty = false; } if (!empty) { boolFilter.must(mappingFilter); } QueryIterator<Vertex> vertexSearchQuery = new QueryIterator<>(boolFilter, 0, scrollSize, predicates.limitHigh - predicates.limitLow, client, this::createVertex, refresh, timing, indices); Map<Object, Set<Edge>> results = new HashMap<>(); vertexSearchQuery.forEachRemaining(otherVertex -> otherVertex.edges(direction, edgeLabels).forEachRemaining(edge -> { Vertex vertex = BaseVertex.vertexToVertex(otherVertex, edge, direction); Set<Edge> resultEdges = results.get(vertex.id()); if (resultEdges == null) { resultEdges = new HashSet<>(); results.put(vertex.id(), resultEdges); } resultEdges.add(edge); })); return results; }
boundaryFilter.must( FilterBuilders.rangeFilter(this.xField) termsList.add((String)termsMap.get(key)); boundaryFilter.must(FilterBuilders.termsFilter(filterPath, termsList).execution("or")); break; case "range": rangeFilterBuilder.to(filter.get("to")); boundaryFilter.must(rangeFilterBuilder); break; case "UDF": boundaryFilter.must(FilterBuilders.queryFilter(boolQuery)); break; default: