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)));
}
/**
* @param spaceKey to get info for
* @return spaces indexing info or null if not found.
*/
protected SpaceIndexingInfo getLastSpaceIndexingInfo(String spaceKey) {
SpaceIndexingInfo lastIndexing = lastSpaceIndexingInfo.get(spaceKey);
if (lastIndexing == null && activityLogIndexName != null) {
try {
refreshSearchIndex(activityLogIndexName);
SearchResponse sr =
client
.prepareSearch(activityLogIndexName)
.setTypes(activityLogTypeName)
.setPostFilter(
FilterBuilders.andFilter(
FilterBuilders.termFilter(SpaceIndexingInfo.DOCFIELD_SPACE_KEY, spaceKey),
FilterBuilders.termFilter(
SpaceIndexingInfo.DOCFIELD_RIVER_NAME, riverName().getName())))
.setQuery(QueryBuilders.matchAllQuery())
.addSort(SpaceIndexingInfo.DOCFIELD_START_DATE, SortOrder.DESC)
.addField("_source")
.setSize(1)
.execute()
.actionGet();
if (sr.getHits().getTotalHits() > 0) {
SearchHit hit = sr.getHits().getAt(0);
lastIndexing = SpaceIndexingInfo.readFromDocument(hit.sourceAsMap());
} else {
logger.debug("No last indexing info found in activity log for space {}", spaceKey);
}
} catch (Exception e) {
logger.warn(
"Error during LastSpaceIndexingInfo reading from activity log ES index: {} {}",
e.getClass().getName(),
e.getMessage());
}
}
return lastIndexing;
}
/*
* 创建过滤条件
* */
public static QueryBuilder createFilterBuilder(
SearchLogic searchLogic,
QueryBuilder queryBuilder,
HashMap<String, Object[]> searchContentMap,
HashMap<String, Object[]> filterContentMap)
throws Exception {
try {
Iterator<Entry<String, Object[]>> iterator = searchContentMap.entrySet().iterator();
AndFilterBuilder andFilterBuilder = null;
while (iterator.hasNext()) {
Entry<String, Object[]> entry = iterator.next();
Object[] values = entry.getValue();
/*排除非法的搜索值*/
if (!checkValue(values)) {
continue;
}
MySearchOption mySearchOption = getSearchOption(values);
if (mySearchOption.getDataFilter() == DataFilter.exists) {
/*被搜索的条件必须有值*/
ExistsFilterBuilder existsFilterBuilder = FilterBuilders.existsFilter(entry.getKey());
if (andFilterBuilder == null) {
andFilterBuilder = FilterBuilders.andFilter(existsFilterBuilder);
} else {
andFilterBuilder = andFilterBuilder.add(existsFilterBuilder);
}
}
}
if (filterContentMap == null || filterContentMap.isEmpty()) {
/*如果没有其它过滤条件，返回*/
return QueryBuilders.filteredQuery(queryBuilder, andFilterBuilder);
}
/*构造过滤条件*/
QueryFilterBuilder queryFilterBuilder =
FilterBuilders.queryFilter(createQueryBuilder(filterContentMap, searchLogic));
/*构造not过滤条件，表示搜索结果不包含这些内容，而不是不过滤*/
NotFilterBuilder notFilterBuilder = FilterBuilders.notFilter(queryFilterBuilder);
return QueryBuilders.filteredQuery(
queryBuilder, FilterBuilders.andFilter(andFilterBuilder, notFilterBuilder));
} catch (Exception e) {
logger.error(e.getMessage());
}
return null;
}
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 List<SearchRequestBuilder> makeRequestBuilders() {
List<SearchRequestBuilder> builders = new ArrayList<>();
ZonedDateTime currentDate = config.getFrom();
ZonedDateTime maxDate = up(TimeUnit.HOURS, config.getTo());
do {
builders.add(
client
.prepareSearch(
appendForEach(INDEXES_PREFIXES, ELASTIC_INDEX_DATE_FORMAT.format(currentDate)))
.setTypes(TYPES)
.setSize(config.getBucketSize())
.setPostFilter(FilterBuilders.andFilter(makeFilters(currentDate))));
currentDate = currentDate.plusDays(1);
} while (currentDate.isBefore(maxDate));
return builders;
}
