refactor ranges

commercetools · Jan 23, 2024 · a5f0481 · a5f0481
1 parent 8b154cf
commit a5f0481
Show file tree

Hide file tree

Showing 5 changed files with 106 additions and 38 deletions.
diff --git a/...pi/src/main/java/com/commercetools/api/search/products/ProductFacetExpressionBuilder.java b/...pi/src/main/java/com/commercetools/api/search/products/ProductFacetExpressionBuilder.java
@@ -145,28 +145,28 @@ public TermFacetExpression<String> ofText(final String name) {
             return TermFacetExpression.of(expression.add(name), TermFormatter::format);
         }
 
-        public TermFacetExpression<LocalDate> ofDate(final String name) {
-            return TermFacetExpression.of(expression.add(name), TermFormatter::format);
+        public RangeFacetExpressionBuilder<LocalDate> ofDate(final String name) {
+            return RangeFacetExpressionBuilder.of(expression.add(name), TermFormatter::format);
         }
 
-        public TermFacetExpression<LocalTime> ofTime(final String name) {
-            return TermFacetExpression.of(expression.add(name), TermFormatter::format);
+        public RangeFacetExpressionBuilder<LocalTime> ofTime(final String name) {
+            return RangeFacetExpressionBuilder.of(expression.add(name), TermFormatter::format);
         }
 
-        public TermFacetExpression<ZonedDateTime> ofDatetime(final String name) {
-            return TermFacetExpression.of(expression.add(name), TermFormatter::format);
+        public RangeFacetExpressionBuilder<ZonedDateTime> ofDatetime(final String name) {
+            return RangeFacetExpressionBuilder.of(expression.add(name), TermFormatter::format);
         }
 
         public TermFacetExpression<Boolean> ofBool(final String name) {
             return TermFacetExpression.of(expression.add(name), TermFormatter::format);
         }
 
-        public TermFacetExpression<Double> ofNumber(final String name) {
-            return TermFacetExpression.of(expression.add(name), TermFormatter::format);
+        public RangeFacetExpressionBuilder<Double> ofNumber(final String name) {
+            return RangeFacetExpressionBuilder.of(expression.add(name), TermFormatter::format);
         }
 
-        public TermFacetExpression<Long> ofLong(final String name) {
-            return TermFacetExpression.of(expression.add(name), TermFormatter::format);
+        public RangeFacetExpressionBuilder<Long> ofLong(final String name) {
+            return RangeFacetExpressionBuilder.of(expression.add(name), TermFormatter::format);
         }
 
         public TermFacetExpression<String> ofLocalizedString(final String name, final String language) {
@@ -213,8 +213,8 @@ public AttributesMoneyFacetExpressionBuilder(final PathExpression expression) {
             this.expression = expression;
         }
 
-        public TermFacetExpression<Long> centAmount() {
-            return TermFacetExpression.of(expression.add("centAmount"), TermFormatter::format);
+        public RangeFacetExpressionBuilder<Long> centAmount() {
+            return RangeFacetExpressionBuilder.of(expression.add("centAmount"), TermFormatter::format);
         }
 
         public TermFacetExpression<String> currencyCode() {

diff --git a/...i/src/main/java/com/commercetools/api/search/products/ProductFilterExpressionBuilder.java b/...i/src/main/java/com/commercetools/api/search/products/ProductFilterExpressionBuilder.java
@@ -159,20 +159,20 @@ public ReviewRatingStatisticsFilterExpressionBuilder() {
             this.expression = PathExpression.of("reviewRatingStatistics");
         }
 
-        public TermFilterExpressionBuilder<Long> averageRating() {
-            return TermFilterExpressionBuilder.of(expression.add("averageRating"), TermFormatter::format);
+        public RangeFilterExpressionBuilder<Long> averageRating() {
+            return RangeFilterExpressionBuilder.of(expression.add("averageRating"), TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<Long> highestRating() {
-            return TermFilterExpressionBuilder.of(expression.add("highestRating"), TermFormatter::format);
+        public RangeFilterExpressionBuilder<Long> highestRating() {
+            return RangeFilterExpressionBuilder.of(expression.add("highestRating"), TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<Long> lowestRating() {
-            return TermFilterExpressionBuilder.of(expression.add("lowestRating"), TermFormatter::format);
+        public RangeFilterExpressionBuilder<Long> lowestRating() {
+            return RangeFilterExpressionBuilder.of(expression.add("lowestRating"), TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<Long> count() {
-            return TermFilterExpressionBuilder.of(expression.add("count"), TermFormatter::format);
+        public RangeFilterExpressionBuilder<Long> count() {
+            return RangeFilterExpressionBuilder.of(expression.add("count"), TermFormatter::format);
         }
     }
 
@@ -347,28 +347,28 @@ public TermFilterExpressionBuilder<Boolean> asBoolean() {
             return new TermFilterExpressionBuilder<>(expression, TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<Long> asLong() {
-            return new TermFilterExpressionBuilder<>(expression, TermFormatter::format);
+        public RangeFilterExpressionBuilder<Long> asLong() {
+            return new RangeFilterExpressionBuilder<>(expression, TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<Double> asDouble() {
-            return new TermFilterExpressionBuilder<>(expression, TermFormatter::format);
+        public RangeFilterExpressionBuilder<Double> asDouble() {
+            return new RangeFilterExpressionBuilder<>(expression, TermFormatter::format);
         }
 
         public TermFilterExpressionBuilder<String> asString() {
             return new TermFilterExpressionBuilder<>(expression, TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<ZonedDateTime> asDateTime() {
-            return new TermFilterExpressionBuilder<>(expression, TermFormatter::format);
+        public RangeFilterExpressionBuilder<ZonedDateTime> asDateTime() {
+            return new RangeFilterExpressionBuilder<>(expression, TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<LocalDate> asDate() {
-            return new TermFilterExpressionBuilder<>(expression, TermFormatter::format);
+        public RangeFilterExpressionBuilder<LocalDate> asDate() {
+            return new RangeFilterExpressionBuilder<>(expression, TermFormatter::format);
         }
 
-        public TermFilterExpressionBuilder<LocalTime> asTime() {
-            return new TermFilterExpressionBuilder<>(expression, TermFormatter::format);
+        public RangeFilterExpressionBuilder<LocalTime> asTime() {
+            return new RangeFilterExpressionBuilder<>(expression, TermFormatter::format);
         }
 
         public PriceFilterExpressionBuilder asMoney() {

diff --git a/...-api/src/main/java/com/commercetools/api/search/products/RangeFacetExpressionBuilder.java b/...-api/src/main/java/com/commercetools/api/search/products/RangeFacetExpressionBuilder.java
@@ -0,0 +1,51 @@
+
+package com.commercetools.api.search.products;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+public class RangeFacetExpressionBuilder<T> implements FilterExpression {
+    private final PathExpression expression;
+    private final Function<T, FilterExpression> formatter;
+
+    public RangeFacetExpressionBuilder() {
+        this.expression = null;
+        this.formatter = null;
+    }
+
+    public RangeFacetExpressionBuilder(PathExpression expression, Function<T, FilterExpression> formatter) {
+        this.expression = expression;
+        this.formatter = formatter;
+    }
+
+    public TermFacetExpression<T> is(T value) {
+        return TermFacetExpression.of(expression, formatter).is(value);
+    }
+
+    public TermFacetExpression<T> isIn(Iterable<T> values) {
+        return TermFacetExpression.of(expression, formatter).isIn(values);
+    }
+
+    public RangeFacetExpression<T> rangeFrom(T from) {
+        return RangeFacetExpression.of(expression, formatter).rangeFrom(from);
+    }
+
+    public RangeFacetExpression<T> rangeTo(T to) {
+        return RangeFacetExpression.of(expression, formatter).rangeTo(to);
+    }
+
+    public RangeFacetExpression<T> range(T from, T to) {
+        return RangeFacetExpression.of(expression, formatter).range(from, to);
+    }
+
+    @Override
+    public String render() {
+        Objects.requireNonNull(expression);
+        return expression.render();
+    }
+
+    public static <T> RangeFacetExpressionBuilder<T> of(PathExpression expression,
+            Function<T, FilterExpression> formatter) {
+        return new RangeFacetExpressionBuilder<>(expression, formatter);
+    }
+}
diff --git a/...-api/src/main/java/com/commercetools/api/search/products/TermFilterExpressionBuilder.java b/...-api/src/main/java/com/commercetools/api/search/products/TermFilterExpressionBuilder.java
@@ -33,6 +33,10 @@ public FilterExpression missing() {
         return new ExistsTermFilterExpression(expression).missing();
     }
 
+    public RangeFilterExpression<T> ranges() {
+        return new RangeFilterExpression<>(expression, null, formatter);
+    }
+
     public static <T> TermFilterExpressionBuilder<T> of(PathExpression expression,
             Function<T, FilterExpression> formatter) {
         return new TermFilterExpressionBuilder<>(expression, formatter);

diff --git a/...ls/commercetools-sdk-java-api/src/test/java/com/commercetools/api/search/SearchTests.java b/...ls/commercetools-sdk-java-api/src/test/java/com/commercetools/api/search/SearchTests.java
@@ -156,6 +156,9 @@ public static Object[][] filterExpressions() {
                 new Object[] { ProductFilterExpressionBuilder.of().state().missing(), "state: missing" },
                 new Object[] { ProductFilterExpressionBuilder.of().reviewRatingStatistics().averageRating().is(100L),
                         "reviewRatingStatistics.averageRating: 100" },
+                new Object[] {
+                        ProductFilterExpressionBuilder.of().reviewRatingStatistics().averageRating().range(0L, 100L),
+                        "reviewRatingStatistics.averageRating: range (0 to 100)" },
                 new Object[] { ProductFilterExpressionBuilder.of().reviewRatingStatistics().lowestRating().is(100L),
                         "reviewRatingStatistics.lowestRating: 100" },
                 new Object[] { ProductFilterExpressionBuilder.of().reviewRatingStatistics().highestRating().is(100L),
@@ -233,6 +236,8 @@ public static Object[][] filterExpressions() {
                         "variants.attributes.foo: true" },
                 new Object[] { ProductFilterExpressionBuilder.of().variants().attribute("foo").asLong().is(100L),
                         "variants.attributes.foo: 100" },
+                new Object[] { ProductFilterExpressionBuilder.of().variants().attribute("foo").asLong().range(0L, 100L),
+                        "variants.attributes.foo: range (0 to 100)" },
                 new Object[] { ProductFilterExpressionBuilder.of().variants().attribute("foo").asDouble().is(100.0),
                         "variants.attributes.foo: 100.0" },
                 new Object[] { ProductFilterExpressionBuilder.of().variants().attribute("foo").asDouble().is(100.0),
@@ -309,15 +314,16 @@ public static Object[][] facetExpressions() {
                         "categories.id: \"foo\", subTree(\"bar\")" },
                 new Object[] { ProductFacetExpressionBuilder.of().categories().id().is("foo").subTree("bar").is("baz"),
                         "categories.id: \"foo\", subTree(\"bar\"), \"baz\"" },
-                new Object[] { ProductFacetExpressionBuilder.of().variants().attribute().ofText("test"),
-                        "variants.attributes.test" },
-                new Object[] { ProductFacetExpressionBuilder.of().variants().attribute().ofText("test").is("foo"),
-                        "variants.attributes.test: \"foo\"" },
+                new Object[] { ProductFacetExpressionBuilder.of().variants().attribute().ofText("test-text"),
+                        "variants.attributes.test-text" },
+                new Object[] {
+                        ProductFacetExpressionBuilder.of().variants().attribute().ofText("test-text-foo").is("foo"),
+                        "variants.attributes.test-text-foo: \"foo\"" },
                 new Object[] {
                         ProductFacetExpressionBuilder.of().variants().attribute().ofText("test").is("foo").is("bar"),
                         "variants.attributes.test: \"foo\", \"bar\"" },
-                new Object[] { ProductFacetExpressionBuilder.of().variants().attribute().ofDate("test"),
-                        "variants.attributes.test" },
+                new Object[] { ProductFacetExpressionBuilder.of().variants().attribute().ofDate("test-date"),
+                        "variants.attributes.test-date" },
                 new Object[] { ProductFacetExpressionBuilder.of()
                         .variants()
                         .attribute()
@@ -365,6 +371,15 @@ public static Object[][] facetExpressions() {
                 new Object[] {
                         ProductFacetExpressionBuilder.of().variants().attribute().ofMoney("test").centAmount().is(100L),
                         "variants.attributes.test.centAmount: 100" },
+                new Object[] {
+                        ProductFacetExpressionBuilder.of()
+                                .variants()
+                                .attribute()
+                                .ofMoney("test")
+                                .centAmount()
+                                .range(0L, 100L)
+                                .range(101L, 200L),
+                        "variants.attributes.test.centAmount: range (0 to 100), (101 to 200)" },
                 new Object[] { ProductFacetExpressionBuilder.of().variants().attribute().ofMoney("test").currencyCode(),
                         "variants.attributes.test.currencyCode" },
                 new Object[] { ProductFacetExpressionBuilder.of()
@@ -383,15 +398,13 @@ public static Object[][] facetExpressions() {
                         .variants()
                         .attribute()
                         .ofLong("test")
-                        .ranges()
                         .range(0L, 100L)
                         .rangeFrom(100L), "variants.attributes.test: range (0 to 100), (100 to *)" },
                 new Object[] {
                         ProductFacetExpressionBuilder.of()
                                 .variants()
                                 .attribute()
                                 .ofLong("test")
-                                .ranges()
                                 .range(0L, 100L)
                                 .rangeFrom(100L)
                                 .alias("range_test")