How to use

RangeFacetExpression

in

io.sphere.sdk.search

public RangeFacetResult getFacetResult(final RangeFacetExpression<T> facetExpression) {
  return getRangeFacetResult(facetExpression.resultPath());
}

public SimpleRangeStats getRangeStatsOfAllRanges(final RangeFacetExpression<T> facetExpression) {
  final String facetResultPath = facetExpression.resultPath();
  final boolean facetIsOfTypeAllRanges = Optional.ofNullable(facetExpression.value())
      .map(v -> v.trim().equals(":range(* to \"0\"),(\"0\" to *)"))
      .orElse(false);
  if (facetIsOfTypeAllRanges) {
    final RangeFacetResult facetResult = getRangeFacetResult(facetResultPath);
    return getSimpleRangeStats(facetResult.getRanges());
  } else {
    throw new IllegalArgumentException("Facet result is not of type RangeFacetResult for all ranges, i.e. (* to \"0\"),(\"0\" to *): " + facetResultPath);
  }
}

public RangeFacetExpression<T, V> onlyWithin(final Iterable<FacetRange<V>> ranges) {
  return new RangeFacetExpression<>(this, typeSerializer, ranges, alias);
}

@Test
public void buildsRangeFacetExpressionWithAlias() throws Exception {
  final RangeFacetExpression<Object> facet = RangeFacetExpression.of(ATTRIBUTE_PATH + RANGE_VALUE + AS_ALIAS);
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + RANGE_VALUE + AS_ALIAS);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isEqualTo(RANGE_VALUE);
  assertThat(facet.alias()).isEqualTo(ALIAS);
  assertThat(facet.resultPath()).isEqualTo(ALIAS);
}

private void testPagedSearchResultWithAllRanges(final List<RangeStats> rangeStats, final Consumer<SimpleRangeStats> test) {
  final RangeFacetExpression<Object> facetExpression = RangeFacetExpression.of("foo:range(* to \"0\"),(\"0\" to *)  as allRangesFacet");
  final Map<String, FacetResult> facets = new HashMap<>();
  facets.put(facetExpression.resultPath(), RangeFacetResult.of(rangeStats));
  final PagedSearchResult<Object> result = pagedSearchResult(facets);
  test.accept(result.getRangeStatsOfAllRanges(facetExpression));
}

@Test
public void usesAlias() throws Exception {
  final RangeTermFacetSearchModel<ProductProjection, BigDecimal> path = FACET_ATTR.ofNumber("size");
  assertThat(path.withAlias("my-facet").allTerms().expression()).isEqualTo("variants.attributes.size as my-facet");
  assertThat(path.withAlias("my-facet").onlyTerm(valueOf(38)).expression()).isEqualTo("variants.attributes.size:38 as my-facet");
  assertThat(path.withAlias("my-facet").onlyLessThan(valueOf(38)).expression()).isEqualTo("variants.attributes.size:range(* to 38) as my-facet");
}

@SuppressWarnings("unchecked")
public <V extends Comparable<? super V>> Optional<RangeFacetResult<V>> getRangeFacetResult(final RangeFacetExpression<T, V> facetExpression) {
  return getFacetResult(facetExpression.buildResultPath()).map(facetResult -> {
    if (facetResult instanceof RangeFacetResult) {
      return (RangeFacetResult) facetResult;
    } else {
      // TODO Use another type of exception once exception task is finished
      throw new RuntimeException("Facet result is not of type RangeFacetResult: " + facetResult);
    }
  });
}

  @Override
  public boolean equals(Object o) {
    return o != null && o instanceof FacetExpression && toSphereFacet().equals(((FacetExpression) o).toSphereFacet());
  }
}

@Test
public void buildsRangeFacetExpression() throws Exception {
  final RangeFacetExpression<Object> facet = RangeFacetExpression.of(ATTRIBUTE_PATH + RANGE_VALUE);
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + RANGE_VALUE);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isEqualTo(RANGE_VALUE);
  assertThat(facet.alias()).isNull();
  assertThat(facet.resultPath()).isEqualTo(ATTRIBUTE_PATH);
}

@Test
public void buildsRangeFacetExpressionWithAlias() throws Exception {
  final RangeFacetExpression<Object> facet = RangeTermFacetSearchModel.of(ATTRIBUTE_PATH, ofNumber()).withAlias(ALIAS).onlyRange(FACET_RANGES);
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + RANGE_VALUE + AS_ALIAS);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isEqualTo(RANGE_VALUE);
  assertThat(facet.alias()).isEqualTo(ALIAS);
  assertThat(facet.resultPath()).isEqualTo(ALIAS);
}

private <T> void testPagedSearchResult(final Consumer<PagedSearchResult<T>> test) {
  final Map<String, FacetResult> facets = new HashMap<>();
  facets.put(TERM_FACET_EXPR.resultPath(), TERM_FACET_RESULT);
  facets.put(RANGE_FACET_EXPR.resultPath(), RANGE_FACET_RESULT);
  facets.put(FILTERED_FACET_EXPR.resultPath(), FILTERED_FACET_RESULT);
  final PagedSearchResult<T> result = pagedSearchResult(facets);
  test.accept(result);
}

@Test
public void buildsRangeFacetExpression() throws Exception {
  final RangeFacetExpression<Object> facet = RangeTermFacetSearchModel.of(ATTRIBUTE_PATH, ofNumber()).onlyRange(FACET_RANGES);
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + RANGE_VALUE);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isEqualTo(RANGE_VALUE);
  assertThat(facet.alias()).isNull();
  assertThat(facet.resultPath()).isEqualTo(ATTRIBUTE_PATH);
}

@Test
public void termFacetResult() throws Exception {
  testPagedSearchResult(result -> {
    assertThat(result.getFacetResult(TERM_FACET_EXPR)).isEqualTo(TERM_FACET_RESULT);
    assertThat(result.getTermFacetResult("non-existent")).isNull();
    assertThatThrownBy(() -> result.getTermFacetResult(RANGE_FACET_EXPR.resultPath()))
        .isInstanceOf(IllegalArgumentException.class);
    assertThatThrownBy(() -> result.getTermFacetResult(FILTERED_FACET_EXPR.resultPath()))
        .isInstanceOf(IllegalArgumentException.class);
  });
}

@Test
public void filteredFacetResult() throws Exception {
  testPagedSearchResult(result -> {
    assertThat(result.getFacetResult(FILTERED_FACET_EXPR)).isEqualTo(FILTERED_FACET_RESULT);
    assertThat(result.getFilteredFacetResult("non-existent")).isNull();
    assertThatThrownBy(() -> result.getFilteredFacetResult(TERM_FACET_EXPR.resultPath()))
        .isInstanceOf(IllegalArgumentException.class);
    assertThatThrownBy(() -> result.getFilteredFacetResult(RANGE_FACET_EXPR.resultPath()))
        .isInstanceOf(IllegalArgumentException.class);
  });
}

@Test
public void rangeFacetsSupportsAlias() throws Exception {
  final String alias = "my-facet";
  final RangeFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().attribute().ofNumber(ATTR_NAME_SIZE).withAlias(alias).onlyGreaterThanOrEqualTo(ZERO);
  final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr);
  testResult(search, result -> {
    assertThat(facetExpr.resultPath()).isEqualTo(alias);
    final RangeStats rangeStats = result.getFacetResult(facetExpr).getRanges().get(0);
    assertThat(rangeStats.getLowerEndpoint()).isEqualTo("0.0");
    assertThat(rangeStats.getUpperEndpoint()).isNull();
    assertThat(rangeStats.getCount()).isEqualTo(6L);
    assertThat(rangeStats.getMin()).isEqualTo("36.0");
    assertThat(rangeStats.getMax()).isEqualTo("46.0");
    assertThat(rangeStats.getSum()).isEqualTo("246.0");
    assertThat(rangeStats.getMean()).isEqualTo(41.0);
  });
}