private FilterBuilder createFilterFromTerm(Terms selection) {
FilterBuilder[] includes = new FilterBuilder[selection.getValues().size()];
int i = 0;
for (String value : selection.getValues()) {
includes[i] = FilterBuilders.termFilter(selection.getField(), value);
i++;
}
FilterBuilder[] excludes = new FilterBuilder[selection.getExcludes().size()];
i = 0;
for (String value : selection.getExcludes()) {
excludes[i] = FilterBuilders.termFilter(selection.getField(), value);
i++;
}
if (includes.length == 0) {
return FilterBuilders.notFilter(FilterBuilders.orFilter(excludes));
}
FilterBuilder include = null;
if (selection.getOperator() == Operator.or) {
include = FilterBuilders.orFilter(includes);
} else {
include = FilterBuilders.andFilter(includes);
}
if (excludes.length == 0) {
return include;
}
return FilterBuilders.andFilter(
include, FilterBuilders.notFilter(FilterBuilders.orFilter(excludes)));
}
public SearchResponse doSearch(ActivityQuery query, SearchOptions options) {
SearchRequestBuilder requestBuilder =
getClient()
.prepareSearch(ActivityIndexDefinition.INDEX)
.setTypes(ActivityIndexDefinition.TYPE);
requestBuilder.setFrom(options.getOffset());
requestBuilder.setSize(options.getLimit());
requestBuilder.addSort(ActivityIndexDefinition.FIELD_CREATED_AT, SortOrder.DESC);
AndFilterBuilder filter = FilterBuilders.andFilter();
if (!query.getTypes().isEmpty()) {
OrFilterBuilder typeFilter = FilterBuilders.orFilter();
for (String type : query.getTypes()) {
typeFilter.add(FilterBuilders.termFilter(ActivityIndexDefinition.FIELD_TYPE, type));
}
filter.add(typeFilter);
}
if (!query.getDataOrFilters().isEmpty()) {
for (Map.Entry<String, Object> entry : query.getDataOrFilters().entrySet()) {
OrFilterBuilder orFilter = FilterBuilders.orFilter();
orFilter.add(
FilterBuilders.nestedFilter(
ActivityIndexDefinition.FIELD_DETAILS,
FilterBuilders.termFilter(
ActivityIndexDefinition.FIELD_DETAILS + "." + entry.getKey(),
entry.getValue())));
filter.add(orFilter);
}
}
Date since = query.getSince();
if (since != null) {
filter.add(
FilterBuilders.rangeFilter(ActivityIndexDefinition.FIELD_CREATED_AT)
.gt(since)
.cache(false));
}
Date to = query.getTo();
if (to != null) {
filter.add(
FilterBuilders.rangeFilter(ActivityIndexDefinition.FIELD_CREATED_AT).lt(to).cache(false));
}
requestBuilder.setQuery(QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), filter));
return requestBuilder.get();
}
private OrFilterBuilder buildAndFilter(String name, List<String> values) {
OrFilterBuilder filterBuilder = FilterBuilders.orFilter();
values.forEach(
e -> {
TermFilterBuilder termFilterBuilder = FilterBuilders.termFilter(name, e);
filterBuilder.add(termFilterBuilder);
});
return filterBuilder;
}
public String createQuery(
boolean includeFacets, int simpleSelections, int rangeSelections, int pathSelections) {
SenseiClientRequest clientRequest =
senseiQueryProducer.createQuery(
includeFacets, simpleSelections, rangeSelections, pathSelections);
FilterBuilder[] filters = new FilterBuilder[clientRequest.getSelections().size()];
for (int i = 0; i < filters.length; i++) {
Selection selection = clientRequest.getSelections().get(i);
if (selection instanceof Terms) {
filters[i] = createFilterFromTerm((Terms) selection);
}
if (selection instanceof Range) {
Range range = (Range) selection;
RangeFilterBuilder rangeFilter = FilterBuilders.rangeFilter(range.getField());
filters[i] = rangeFilter;
if (!"*".equals(range.getFrom())) rangeFilter.from(range.getFrom());
if (!"*".equals(range.getTo())) rangeFilter.to(range.getTo());
}
if (selection instanceof Path) {
Path path = (Path) selection;
filters[i] = FilterBuilders.prefixFilter(path.getField(), path.getValue());
}
}
FilterBuilder selections = FilterBuilders.orFilter(filters);
SearchRequestBuilder requestBuilder = new SearchRequestBuilder(new MockClient());
requestBuilder.setFilter(selections);
try {
JSONObject request = new JSONObject(requestBuilder.toString());
JSONObject facets = new JSONObject();
for (Selection selection : clientRequest.getSelections()) {
if (selection instanceof Terms) {
String field = selection.getField();
facets.put(
field, new JSONObject("{\"terms\": {\"field\":\"" + field + "\", \"size\" : 300}}"));
}
}
request.put("facets", facets);
return request.toString();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
