using correct validation

Author: dcrissman

lightblue-ldap-crud/src/main/java/com/redhat/lightblue/crud/ldap/FilterTranslator.java

@@ -11,6 +11,7 @@
 import com.redhat.lightblue.query.QueryExpression;
 import com.redhat.lightblue.query.RegexMatchExpression;
 import com.redhat.lightblue.query.UnaryLogicalExpression;
+import com.redhat.lightblue.query.Value;
 import com.redhat.lightblue.query.ValueComparisonExpression;
 import com.unboundid.ldap.sdk.Filter;
 
@@ -43,35 +44,37 @@ else if (query instanceof ValueComparisonExpression){
             filter = translate((ValueComparisonExpression) query);
         }
         else{
-            throw new IllegalArgumentException("Unsupported QueryExpression type: " + query.getClass());
+            throw new UnsupportedOperationException("Unsupported QueryExpression type: " + query.getClass());
         }
         return filter;
     }
 
     private Filter translate(ArrayContainsExpression query){
-        return null;
+        String field = query.getArray().toString();
+
+        List<Filter> filters = new ArrayList<Filter>();
+        for(Value value : query.getValues()){
+            filters.add(Filter.createEqualityFilter(field, value.getValue().toString()));
+        }
+
+        switch(query.getOp()){
+            case _all:
+                return Filter.createANDFilter(filters);
+            case _any:
+                return Filter.createORFilter(filters);
+            case _none:
+                return Filter.createNOTFilter(Filter.createANDFilter(filters));
+            default:
+                throw new UnsupportedOperationException("Unsupported operation: " + query.getOp());
+        }
     }
 
     private Filter translate(ArrayMatchExpression query){
-        return null;
+        throw new UnsupportedOperationException("Operation not yet supported");
     }
 
     private Filter translate(FieldComparisonExpression query){
-        String field = query.getField().toString();
-        String rfield = query.getRfield().toString();
-
-        switch(query.getOp()){
-            case _eq:
-                return Filter.createEqualityFilter(field, rfield);
-            case _neq:
-                return Filter.createNOTFilter(Filter.createEqualityFilter(field, rfield));
-            case _gte:
-                return Filter.createGreaterOrEqualFilter(field, rfield);
-            case _lte:
-                return Filter.createLessOrEqualFilter(field, rfield);
-            default: //TODO gt, lt
-                throw new IllegalArgumentException("Unsupported operation: " + query.getOp());
-        }
+        throw new UnsupportedOperationException("Operation not yet supported");
     }
 
     private Filter translate(NaryLogicalExpression query){
@@ -85,28 +88,50 @@ private Filter translate(NaryLogicalExpression query){
             case _or:
                 return Filter.createORFilter(filters);
             default:
-                throw new IllegalArgumentException("Unsupported operation: " + query.getOp());
+                throw new UnsupportedOperationException("Unsupported operation: " + query.getOp());
         }
     }
 
     private Filter translate(NaryRelationalExpression query){
-        return null;
+        String field = query.getField().toString();
+        List<Filter> filters = new ArrayList<Filter>();
+        for(Value value : query.getValues()){
+            filters.add(Filter.createEqualityFilter(field, value.getValue().toString()));
+        }
+
+        switch (query.getOp()){
+            case _in:
+                return Filter.createORFilter(filters);
+            case _not_in:
+                return Filter.createNOTFilter(Filter.createORFilter(filters));
+            default:
+                throw new UnsupportedOperationException("Unsupported operation: " + query.getOp());
+        }
     }
 
     private Filter translate(RegexMatchExpression query){
-        return null;
+        throw new UnsupportedOperationException("Operation not yet supported");
     }
 
     private Filter translate(UnaryLogicalExpression query){
         return null;
     }
 
     private Filter translate(ValueComparisonExpression query){
+        String field = query.getField().toString();
+        String rValue = query.getRvalue().getValue().toString();
+
         switch(query.getOp()){
             case _eq:
-                return Filter.createEqualityFilter(query.getField().toString(), query.getRvalue().toString());
-            default:
-                throw new IllegalArgumentException("Unsupported operation: " + query.getOp());
+                return Filter.createEqualityFilter(field, rValue);
+            case _neq:
+                return Filter.createNOTFilter(Filter.createEqualityFilter(field, rValue));
+            case _gte:
+                return Filter.createGreaterOrEqualFilter(field, rValue);
+            case _lte:
+                return Filter.createLessOrEqualFilter(field, rValue);
+            default: //TODO gt, lt
+                throw new UnsupportedOperationException("Unsupported operation: " + query.getOp());
         }
     }
 

lightblue-ldap-test/src/main/resources/crud/find/person-find-simple.json

@@ -7,7 +7,7 @@
         "query": {
             "field": "uid",
             "op": "$eq",
-            "rfield": "john.doe"
+            "rvalue": "john.doe"
         },
         "range": [
             0,