Merge branch 'release/v1.24.0'

Author: bot

.circleci/config.yml

@@ -2,6 +2,15 @@
 
 Note: version releases in the 0.x.y range may introduce breaking changes.
 
+## [1.24.0]
+ ### Added 
+- Added client support for managing compositions trough contributions ([#406](https://github.com/ehrbase/openEHR_SDK/pull/406))
+- Added null verification and change gson to jackson ([#416](https://github.com/ehrbase/openEHR_SDK/pull/416))
+ ### Changed
+- Update libraries ([#422](https://github.com/ehrbase/openEHR_SDK/pull/422))
+
+ ### Fixed 
+
 ## [1.23.0]
  ### Added 
    - Added handling of stored AQL query requests ([#384](https://github.com/ehrbase/openEHR_SDK/pull/384))
@@ -211,3 +220,4 @@ Note: version releases in the 0.x.y range may introduce breaking changes.
 [1.21.0]: https://github.com/ehrbase/openEHR_SDK/compare/v1.20.0...v1.21.0
 [1.22.0]: https://github.com/ehrbase/openEHR_SDK/compare/v1.21.0...v1.22.0
 [1.23.0]: https://github.com/ehrbase/openEHR_SDK/compare/v1.22.0...v1.23.0
+[1.24.0]: https://github.com/ehrbase/openEHR_SDK/compare/v1.23.0...v1.24.0

CHANGELOG.md

@@ -25,7 +25,7 @@
     <parent>
         <groupId>org.ehrbase.openehr.sdk</groupId>
         <artifactId>root</artifactId>
-        <version>1.23.0</version>
+        <version>1.24.0</version>
     </parent>
 
     <artifactId>aql</artifactId>

aql/pom.xml

@@ -135,11 +135,10 @@ identifiedEquality
         : OPEN_PAR* NOT? identifiedOperand COMPARABLEOPERATOR identifiedOperand CLOSE_PAR*
         | OPEN_PAR* NOT? identifiedOperand MATCHES OPEN_CURLY matchesOperand CLOSE_CURLY CLOSE_PAR*
         | OPEN_PAR* NOT? identifiedOperand MATCHES REGEXPATTERN CLOSE_PAR*
-        | OPEN_PAR* NOT? identifiedOperand LIKE STRING CLOSE_PAR*
-        | OPEN_PAR* NOT? identifiedOperand ILIKE STRING CLOSE_PAR*
+        | OPEN_PAR* NOT? identifiedOperand LIKE likeOperand CLOSE_PAR*
         | OPEN_PAR* NOT? identifiedOperand SIMILARTO STRING CLOSE_PAR*
         | OPEN_PAR* identifiedOperand NOT? IN OPEN_PAR  (identifiedOperand|matchesOperand) CLOSE_PAR CLOSE_PAR*
-        | OPEN_PAR* NOT? identifiedOperand (COMPARABLEOPERATOR|LIKE|ILIKE) (ANY|ALL|SOME) OPEN_PAR (identifiedOperand|matchesOperand) CLOSE_PAR CLOSE_PAR*
+        | OPEN_PAR* NOT? identifiedOperand (COMPARABLEOPERATOR|LIKE) (ANY|ALL|SOME) OPEN_PAR (identifiedOperand|matchesOperand) CLOSE_PAR CLOSE_PAR*
         | OPEN_PAR* identifiedOperand NOT? BETWEEN identifiedOperand AND identifiedOperand CLOSE_PAR*
         | OPEN_PAR* identifiedOperand IS NOT? NULL CLOSE_PAR*
         | OPEN_PAR* identifiedOperand IS NOT? UNKNOWN CLOSE_PAR*
@@ -149,6 +148,8 @@ identifiedEquality
         | OPEN_PAR* NOT? EXISTS identifiedPath CLOSE_PAR*
         | OPEN_PAR* NOT? EXISTS identifiedExpr CLOSE_PAR*;
 
+likeOperand: STRING|PARAMETER;
+
 identifiedOperand
         : operand
         | identifiedPath
@@ -289,7 +290,6 @@ IN : I N ;
 MATCHES : M A T C H E S ;
 TERMINOLOGY : T E R M I N O L O G Y ;
 LIKE : L I K E ;
-ILIKE : I L I K E ;
 SIMILARTO: S I M I L A R ' ' T O;
 SELECT : S E L E C T ;
 TOP : T O P ;

aql/src/main/antlr4/org/ehrbase/aql/parser/Aql.g4

@@ -17,22 +17,24 @@
  */
 package org.ehrbase.aql.binder;
 
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 import org.ehrbase.aql.dto.condition.ConditionComparisonOperatorDto;
 import org.ehrbase.aql.dto.condition.ConditionDto;
 import org.ehrbase.aql.dto.condition.ConditionLogicalOperatorDto;
 import org.ehrbase.aql.dto.condition.ConditionLogicalOperatorSymbol;
 import org.ehrbase.aql.dto.condition.ExistsConditionOperatorDto;
+import org.ehrbase.aql.dto.condition.LikeOperatorDto;
 import org.ehrbase.aql.dto.condition.MatchesOperatorDto;
 import org.ehrbase.aql.dto.condition.NotConditionOperatorDto;
 import org.ehrbase.aql.dto.condition.ParameterValue;
 import org.ehrbase.aql.dto.condition.SimpleValue;
+import org.ehrbase.aql.dto.select.SelectStatementDto;
+import org.ehrbase.client.aql.condition.ComparisonOperator;
 import org.ehrbase.client.aql.condition.Condition;
 import org.ehrbase.client.aql.containment.Containment;
 import org.ehrbase.client.aql.field.SelectAqlField;
@@ -46,22 +48,22 @@ public Pair<Condition, List<ParameterValue>> bind(ConditionDto dto, Map<Integer,
         Condition condition;
         List<ParameterValue> parameterList = new ArrayList<>();
         if (dto instanceof ConditionComparisonOperatorDto) {
-
             Pair<Condition, List<ParameterValue>> pair =
                     handleComparisonOperator((ConditionComparisonOperatorDto) dto, containmentMap);
             condition = pair.getLeft();
             parameterList.addAll(pair.getRight());
-        } else if (dto instanceof ConditionLogicalOperatorDto) {
 
+        } else if (dto instanceof ConditionLogicalOperatorDto) {
             Pair<Condition, List<ParameterValue>> pair =
                     handleConditionLogicalOperator((ConditionLogicalOperatorDto) dto, containmentMap);
             condition = pair.getLeft();
             parameterList.addAll(pair.getRight());
+
         } else if (dto instanceof MatchesOperatorDto) {
             Object[] value = ((MatchesOperatorDto) dto)
                     .getValues().stream()
                             .filter(f -> f.getClass().equals(SimpleValue.class))
-                            .map(v -> (SimpleValue) v)
+                            .map(SimpleValue.class::cast)
                             .map(SimpleValue::getValue)
                             .toArray();
             if (value.length != ((MatchesOperatorDto) dto).getValues().size()) {
@@ -73,12 +75,19 @@ public Pair<Condition, List<ParameterValue>> bind(ConditionDto dto, Map<Integer,
         } else if (dto instanceof ExistsConditionOperatorDto) {
             condition =
                     Condition.exists(selectBinder.bind(((ExistsConditionOperatorDto) dto).getValue(), containmentMap));
+
         } else if (dto instanceof NotConditionOperatorDto) {
             condition = Condition.not(bind(((NotConditionOperatorDto) dto).getConditionDto(), containmentMap)
                     .getLeft());
+
+        } else if (dto instanceof LikeOperatorDto) {
+            Pair<Condition, List<ParameterValue>> pair = handleLikeOperator((LikeOperatorDto) dto, containmentMap);
+            condition = pair.getLeft();
+            parameterList.addAll(pair.getRight());
+
         } else {
             throw new SdkException(
-                    String.format("Unexpected class: %s", dto.getClass().getSimpleName()));
+                    String.format("Unexpected class: %s", dto.getClass().getName()));
         }
 
         return new ImmutablePair<>(condition, parameterList);
@@ -97,39 +106,50 @@ private Pair<Condition, List<ParameterValue>> handleConditionLogicalOperator(
             parameterList = subPair.getRight();
         }
 
-        return new ImmutablePair<>(condition, parameterList);
+        return Pair.of(condition, parameterList);
     }
 
-    public Pair<Condition, List<ParameterValue>> handleComparisonOperator(
+    private Pair<Condition, List<ParameterValue>> handleComparisonOperator(
             ConditionComparisonOperatorDto dto, Map<Integer, Containment> containmentMap) {
+        return handleComparisonOperator(
+                dto.getValue(), dto.getSymbol().getSymbol(), dto.getStatement(), dto.getClass(), containmentMap);
+    }
+
+    private Pair<Condition, List<ParameterValue>> handleLikeOperator(
+            LikeOperatorDto dto, Map<Integer, Containment> containmentMap) {
+        return handleComparisonOperator(
+                dto.getValue(), LikeOperatorDto.SYMBOL, dto.getStatement(), dto.getClass(), containmentMap);
+    }
+
+    private Pair<Condition, List<ParameterValue>> handleComparisonOperator(
+            Object value,
+            String operatorSymbol,
+            SelectStatementDto statement,
+            Class<?> dtoClass,
+            Map<Integer, Containment> containmentMap) {
+
+        final Condition condition;
+        final List<ParameterValue> parameterList = new ArrayList<>();
+
+        SelectAqlField<Object> field = selectBinder.bind(statement, containmentMap);
+        if (value instanceof SimpleValue) {
+            SimpleValue simpleValue = (SimpleValue) value;
+            Object conditionValue = simpleValue.getValue();
+            condition = ComparisonOperator.valueComparison(field, operatorSymbol, conditionValue);
+
+        } else if (value instanceof ParameterValue) {
+            ParameterValue parameterValue = (ParameterValue) value;
+            Parameter<Object> conditionValue = new Parameter<>(parameterValue.getName());
+            condition = ComparisonOperator.parameterComparison(field, operatorSymbol, conditionValue);
+            parameterList.add(parameterValue);
 
-        Condition condition;
-        final Class<?> valueClass;
-        final Object value;
-        List<ParameterValue> parameterList = new ArrayList<>();
-        if (dto.getValue() instanceof SimpleValue) {
-            valueClass = Object.class;
-            value = ((SimpleValue) dto.getValue()).getValue();
-        } else if (dto.getValue() instanceof ParameterValue) {
-            valueClass = Parameter.class;
-            value = new Parameter<>(((ParameterValue) dto.getValue()).getName());
-            parameterList.add(((ParameterValue) dto.getValue()));
         } else {
-            throw new SdkException(
-                    String.format("Unexpected class %s", dto.getClass().getSimpleName()));
-        }
-        Method method = null;
-        try {
-            method = Condition.class.getMethod(dto.getSymbol().getJavaName(), SelectAqlField.class, valueClass);
-        } catch (NoSuchMethodException e) {
-            throw new SdkException(e.getMessage(), e);
+            throw new SdkException(String.format(
+                    "Unexpected value type %s in %s",
+                    Optional.of(value).map(Object::getClass).map(Class::getName).orElse("null"), dtoClass.getName()));
         }
-        try {
-            condition = (Condition) method.invoke(null, selectBinder.bind(dto.getStatement(), containmentMap), value);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new SdkException(e.getMessage(), e);
-        }
-        return new ImmutablePair<>(condition, parameterList);
+
+        return Pair.of(condition, parameterList);
     }
 
     private Pair<Condition, List<ParameterValue>> buildLogicalOperator(

aql/src/main/java/org/ehrbase/aql/binder/WhereBinder.java

@@ -20,32 +20,25 @@
 import java.util.NoSuchElementException;
 
 public enum ConditionComparisonOperatorSymbol {
-    EQ("equal", "="),
-    NEQ("notEqual", "!="),
-    GT_EQ("greaterOrEqual", ">="),
-    GT("greaterThan", ">"),
-    LT_EQ("lessOrEqual", "<="),
-    LT("lessThan", "<");
+    EQ("="),
+    NEQ("!="),
+    GT_EQ(">="),
+    GT(">"),
+    LT_EQ("<="),
+    LT("<");
+    private final String symbol;
 
-    private final String javaName;
-    private final String symbole;
-
-    ConditionComparisonOperatorSymbol(String javaName, String symbole) {
-        this.javaName = javaName;
-        this.symbole = symbole;
-    }
-
-    public String getJavaName() {
-        return javaName;
+    ConditionComparisonOperatorSymbol(String symbol) {
+        this.symbol = symbol;
     }
 
-    public String getSymbole() {
-        return symbole;
+    public String getSymbol() {
+        return symbol;
     }
 
     public static ConditionComparisonOperatorSymbol fromSymbol(CharSequence symbol) {
         for (ConditionComparisonOperatorSymbol s : values()) {
-            if (s.getSymbole().contentEquals(symbol)) {
+            if (s.getSymbol().contentEquals(symbol)) {
                 return s;
             }
         }

aql/src/main/java/org/ehrbase/aql/dto/condition/ConditionComparisonOperatorSymbol.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020 vitasystems GmbH and Hannover Medical School.
+ *
+ * This file is part of project openEHR_SDK
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.ehrbase.aql.dto.condition;
+
+import org.ehrbase.aql.dto.select.SelectStatementDto;
+
+public class LikeOperatorDto implements ConditionDto {
+
+    public static final String SYMBOL = "like";
+
+    private SelectStatementDto statement;
+
+    private Value value;
+
+    public SelectStatementDto getStatement() {
+        return this.statement;
+    }
+
+    public Value getValue() {
+        return this.value;
+    }
+
+    public void setStatement(SelectStatementDto statement) {
+        this.statement = statement;
+    }
+
+    public void setValue(Value value) {
+        this.value = value;
+    }
+
+    public boolean equals(final Object o) {
+        if (o == this) return true;
+        if (!(o instanceof LikeOperatorDto)) return false;
+        final LikeOperatorDto other = (LikeOperatorDto) o;
+        if (!other.canEqual((Object) this)) return false;
+        final Object this$statement = this.getStatement();
+        final Object other$statement = other.getStatement();
+        if (this$statement == null ? other$statement != null : !this$statement.equals(other$statement)) return false;
+        final Object this$value = this.getValue();
+        final Object other$value = other.getValue();
+        if (this$value == null ? other$value != null : !this$value.equals(other$value)) return false;
+        return true;
+    }
+
+    protected boolean canEqual(final Object other) {
+        return other instanceof LikeOperatorDto;
+    }
+
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final Object $statement = this.getStatement();
+        result = result * PRIME + ($statement == null ? 43 : $statement.hashCode());
+        final Object $value = this.getValue();
+        result = result * PRIME + ($value == null ? 43 : $value.hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "LikeOperatorDto(statement=" + this.getStatement() + ", value=" + this.getValue() + ")";
+    }
+}

aql/src/main/java/org/ehrbase/aql/dto/condition/LikeOperatorDto.java

@@ -52,7 +52,7 @@ public class PredicateHelper {
 
     private static final AqlPathHelper.PrefixMatcher OPERATOR_SYMBOLS =
             AqlPathHelper.PrefixMatcher.forStrings(Arrays.stream(ConditionComparisonOperatorSymbol.values())
-                    .map(ConditionComparisonOperatorSymbol::getSymbole)
+                    .map(ConditionComparisonOperatorSymbol::getSymbol)
                     .toArray(String[]::new));
 
     private static final PredicateComparisonOperatorDto NO_PREDICATE =
@@ -265,7 +265,7 @@ private static void formatPredicateComparisonOperatorDto(
             format(predicateDto.getStatement(), sb, predicateDto.getValue());
         } else if (!isNone(predicateDto, otherPredicatesFormat)) {
             sb.append(predicateDto.getStatement())
-                    .append(predicateDto.getSymbol().getSymbole());
+                    .append(predicateDto.getSymbol().getSymbol());
             format(predicateDto.getStatement(), sb, predicateDto.getValue());
         }
     }