Search in Elasticsearch by criteria

doc/endpoints/backoffice_frontend.http

@@ -5,7 +5,33 @@ Content-Type: application/json
 {
  "query": {
  "term": {
- "name": "Pepe"
+ "name": "git avanzado"
+ }
+ }
+}
+
+###
+
+# ELASTIC - debug
+POST localhost:9200/backoffice_courses/_search
+Content-Type: application/json
+
+{
+ "from": 0,
+ "size": 1000,
+ "query": {
+ "bool": {
+ "must": [
+ {
+ "term": {
+ "name": {
+ "value": "pepe2"
+ }
+ }
+ }
+ ],
+ "adjust_pure_negative": true,
+ "boost": 1.0
  }
  }
 }

src/backoffice/main/resources/database/backoffice/courses.json

@@ -7,8 +7,8 @@
  "index": true
  },
  "name": {
- "type": "text",
- "index": true
+ "type": "string",
+ "index": "not_analyzed"
  },
  "duration": {
  "type": "text",

src/backoffice/main/tv/codely/backoffice/courses/infrastructure/persistence/ElasticsearchBackofficeCourseRepository.java

@@ -29,7 +29,7 @@ public List<BackofficeCourse> searchAll() {
 
  @Override
  public List<BackofficeCourse> matching(Criteria criteria) {
- return searchAllInElastic(BackofficeCourse::fromPrimitives);
+ return searchByCriteria(criteria, BackofficeCourse::fromPrimitives);
  }
 
  @Override

src/shared/main/tv/codely/shared/domain/criteria/Criteria.java

@@ -31,4 +31,8 @@ public Optional<Integer> limit() {
  public Optional<Integer> offset() {
  return offset;
  }
+
+ public boolean hasFilters() {
+ return filters.filters().size() > 0;
+ }
 }

src/shared/main/tv/codely/shared/domain/criteria/FilterOperator.java

@@ -25,4 +25,8 @@ public static FilterOperator fromValue(String value) {
  default: return null;
  }
  }
+
+ public boolean isPositive() {
+ return this != NOT_EQUAL && this != NOT_CONTAINS;
+ }
 }

src/shared/main/tv/codely/shared/domain/criteria/OrderType.java

@@ -18,5 +18,9 @@ public boolean isNone() {
  public boolean isAsc() {
  return this == ASC;
  }
+
+ public String value() {
+ return type;
+ }
 }
 

src/shared/main/tv/codely/shared/infrastructure/elasticsearch/ElasticsearchCriteriaConverter.java

@@ -0,0 +1,89 @@
+package tv.codely.shared.infrastructure.elasticsearch;
+
+import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.builder.SearchSourceBuilder;
+import org.elasticsearch.search.sort.SortOrder;
+import tv.codely.shared.domain.criteria.Criteria;
+import tv.codely.shared.domain.criteria.Filter;
+import tv.codely.shared.domain.criteria.FilterOperator;
+import tv.codely.shared.domain.criteria.Filters;
+
+import java.util.HashMap;
+import java.util.function.Function;
+
+public final class ElasticsearchCriteriaConverter {
+ private final HashMap<FilterOperator, Function<Filter, QueryBuilder>> queryTransformers = new HashMap<FilterOperator, Function<Filter, QueryBuilder>>() {{
+ put(FilterOperator.EQUAL, ElasticsearchCriteriaConverter.this::termQuery);
+ put(FilterOperator.NOT_EQUAL, ElasticsearchCriteriaConverter.this::termQuery);
+ put(FilterOperator.GT, ElasticsearchCriteriaConverter.this::greaterThanQueryTransformer);
+ put(FilterOperator.LT, ElasticsearchCriteriaConverter.this::lowerThanQueryTransformer);
+ put(FilterOperator.CONTAINS, ElasticsearchCriteriaConverter.this::wildcardTransformer);
+ put(FilterOperator.NOT_CONTAINS, ElasticsearchCriteriaConverter.this::wildcardTransformer);
+ }};
+
+ public SearchSourceBuilder convert(Criteria criteria) {
+ SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
+
+ sourceBuilder.from(criteria.offset().orElse(0));
+ sourceBuilder.size(criteria.limit().orElse(1000));
+
+ if (criteria.order().hasOrder()) {
+ sourceBuilder.sort(
+ criteria.order().orderBy().value(),
+ SortOrder.fromString(criteria.order().orderType().value())
+ );
+ }
+
+ if (criteria.hasFilters()) {
+ QueryBuilder queryBuilder = generateQueryBuilder(criteria.filters());
+
+ sourceBuilder.query(queryBuilder);
+ }
+
+ return sourceBuilder;
+ }
+
+ private QueryBuilder generateQueryBuilder(Filters filters) {
+ BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
+
+ for (Filter filter : filters.filters()) {
+ QueryBuilder query = queryForFilter(filter);
+
+ if (isPositiveOperator(filter.operator())) {
+ boolQueryBuilder.must(query);
+ } else {
+ boolQueryBuilder.mustNot(query);
+ }
+ }
+
+ return boolQueryBuilder;
+ }
+
+ private boolean isPositiveOperator(FilterOperator operator) {
+ return operator.isPositive();
+ }
+
+ private QueryBuilder queryForFilter(Filter filter) {
+ Function<Filter, QueryBuilder> transformer = queryTransformers.get(filter.operator());
+
+ return transformer.apply(filter);
+ }
+
+ private QueryBuilder termQuery(Filter filter) {
+ return QueryBuilders.termQuery(filter.field().value(), filter.value().value().toLowerCase());
+ }
+
+ private QueryBuilder greaterThanQueryTransformer(Filter filter) {
+ return QueryBuilders.rangeQuery(filter.field().value()).gt(filter.value().value().toLowerCase());
+ }
+
+ private QueryBuilder lowerThanQueryTransformer(Filter filter) {
+ return QueryBuilders.rangeQuery(filter.field().value()).lt(filter.value().value().toLowerCase());
+ }
+
+ private QueryBuilder wildcardTransformer(Filter filter) {
+ return QueryBuilders.wildcardQuery(filter.field().value(), String.format("*%s*", filter.value().value().toLowerCase()));
+ }
+}

src/shared/main/tv/codely/shared/infrastructure/elasticsearch/ElasticsearchRepository.java

@@ -3,6 +3,8 @@
 import org.elasticsearch.action.search.SearchRequest;
 import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.client.RequestOptions;
+import org.elasticsearch.search.builder.SearchSourceBuilder;
+import tv.codely.shared.domain.criteria.Criteria;
 
 import java.io.IOException;
 import java.io.Serializable;
@@ -12,15 +14,24 @@
 
 public abstract class ElasticsearchRepository<T> {
  private final ElasticsearchClient client;
+ private final ElasticsearchCriteriaConverter criteriaConverter;
 
  public ElasticsearchRepository(ElasticsearchClient client) {
  this.client = client;
+ this.criteriaConverter = new ElasticsearchCriteriaConverter();
  }
 
  abstract protected String moduleName();
 
  protected List<T> searchAllInElastic(Function<Map<String, Object>, T> unserializer) {
- SearchRequest request = new SearchRequest(client.indexFor(moduleName()));
+ return searchAllInElastic(unserializer, new SearchSourceBuilder());
+ }
+
+ protected List<T> searchAllInElastic(
+ Function<Map<String, Object>, T> unserializer,
+ SearchSourceBuilder sourceBuilder
+ ) {
+ SearchRequest request = new SearchRequest(client.indexFor(moduleName())).source(sourceBuilder);
  try {
  SearchResponse response = client.highLevelClient().search(request, RequestOptions.DEFAULT);
 
@@ -34,6 +45,10 @@ protected List<T> searchAllInElastic(Function<Map<String, Object>, T> unserializ
  return Collections.emptyList();
  }
 
+ protected List<T> searchByCriteria(Criteria criteria, Function<Map<String, Object>, T> unserializer) {
+ return searchAllInElastic(unserializer, criteriaConverter.convert(criteria));
+ }
+
  protected void persist(String id, HashMap<String, Serializable> plainBody) {
  try {
  client.persist(moduleName(), id, plainBody);