feat: Further filtering conditions

Author: frankfarrell

src/main/kotlin/com/github/frankfarrell/dynamodsl/Conditions.kt

@@ -10,15 +10,63 @@ interface DynamoComparator {
     fun toCondition(): Condition
 }
 
+interface SingleValueDynamoCompator: DynamoComparator {
+    val right: Any
+}
+
 interface ComparableBuilder {}
 
-class Equals(val right: Any): DynamoComparator{
+class Equals(override val right: Any): SingleValueDynamoCompator{
 
     override fun toCondition(): Condition {
         return Condition().withComparisonOperator(ComparisonOperator.EQ).withAttributeValueList(toAttributeValue(right))
     }
+}
+
+class NotEquals(override  val right: Any): SingleValueDynamoCompator{
+
+    override fun toCondition(): Condition {
+        return Condition().withComparisonOperator(ComparisonOperator.NE).withAttributeValueList(toAttributeValue(right))
+    }
+}
+
+class GreaterThan(override val right: Any): SingleValueDynamoCompator{
+
+    override fun toCondition(): Condition {
+        return Condition().withComparisonOperator(ComparisonOperator.GT).withAttributeValueList(toAttributeValue(right))
+    }
+
+}
+
+class LessThan(override val right: Any): SingleValueDynamoCompator{
+
+    override fun toCondition(): Condition {
+        return Condition().withComparisonOperator(ComparisonOperator.LT).withAttributeValueList(toAttributeValue(right))
+    }
+
+}
+
+class GreaterThanOrEquals(override val right: Any): SingleValueDynamoCompator{
+
+    override fun toCondition(): Condition {
+        return Condition().withComparisonOperator(ComparisonOperator.GE).withAttributeValueList(toAttributeValue(right))
+    }
+
+}
 
-    val value = ComparisonOperator.EQ
+class LessThanOrEquals(override val right: Any): SingleValueDynamoCompator{
+
+    override fun toCondition(): Condition {
+        return Condition().withComparisonOperator(ComparisonOperator.LE).withAttributeValueList(toAttributeValue(right))
+    }
+}
+
+class InList(val right: List<Any>): DynamoComparator{
+
+    override fun toCondition(): Condition {
+        //Is this right?
+        return Condition().withComparisonOperator(ComparisonOperator.IN).withAttributeValueList(toAttributeValue(right))
+    }
 }
 
 class Between(val left: Any, val right: Any): DynamoComparator{

src/main/kotlin/com/github/frankfarrell/dynamodsl/Filtering.kt

@@ -82,19 +82,39 @@ class ConcreteFilter(val dynamoFunction: DynamoFunction,
                 filterExpression += expressionAttributeName
                 expressionAttributeNames.put(expressionAttributeName, dynamoFunction.attributeName)
 
+                fun singleValueComparator(operator: String, comparator: SingleValueDynamoCompator){
+                    val expressionAttributeValue = toExpressionAttributeValue(dynamoFunction.attributeName)
+                    filterExpression += " $operator ${expressionAttributeValue}"
+                    expressionAttributeValues.put(expressionAttributeValue, toAttributeValue(comparator.right))
+                }
+
                 when(comparator){
-                    is Equals -> {
-                        val expressionAttributeValue = toExpressionAttributeValue(dynamoFunction.attributeName)
-                        filterExpression += " = ${expressionAttributeValue}"
-                        expressionAttributeValues.put(expressionAttributeValue, toAttributeValue(comparator.right))
-                    }
+                    is Equals -> singleValueComparator("=", comparator)
+                    is NotEquals -> singleValueComparator("<>", comparator)
+                    is GreaterThan -> singleValueComparator(">", comparator)
+                    is GreaterThanOrEquals -> singleValueComparator(">=", comparator)
+                    is LessThan -> singleValueComparator("<", comparator)
+                    is LessThanOrEquals -> singleValueComparator("<=", comparator)
                     is Between -> {
                         val leftExpressionAttributeValue = toExpressionAttributeValue(dynamoFunction.attributeName + "left")
                         val rightExpressionAttributeValue = toExpressionAttributeValue(dynamoFunction.attributeName + "right")
                         filterExpression += " BETWEEN ${leftExpressionAttributeValue} AND ${rightExpressionAttributeValue} "
                         expressionAttributeValues.put(leftExpressionAttributeValue, toAttributeValue(comparator.left))
                         expressionAttributeValues.put(rightExpressionAttributeValue, toAttributeValue(comparator.right))
                     }
+                    is InList -> {
+
+                       val listOfAttributeValues = comparator.right
+                                .map({
+                                    val expressionAttributeValue = toExpressionAttributeValue(dynamoFunction.attributeName)
+                                    expressionAttributeValues.put(expressionAttributeValue, toAttributeValue(it))
+                                    expressionAttributeValue
+                                })
+                               .joinToString()
+
+                        filterExpression += " IN (${listOfAttributeValues})"
+
+                    }
                 }
 
             }
@@ -167,6 +187,36 @@ fun ConcreteFilterBuilder.eq(value: Any){
     comparator = Equals(value)
 }
 
+@DynamoDSLMarker
+fun ConcreteFilterBuilder.noteq(value: Any){
+    comparator = NotEquals(value)
+}
+
+@DynamoDSLMarker
+fun ConcreteFilterBuilder.gt(value: Any){
+    comparator = GreaterThan(value)
+}
+
+@DynamoDSLMarker
+fun ConcreteFilterBuilder.lt(value: Any){
+    comparator = LessThan(value)
+}
+
+@DynamoDSLMarker
+fun ConcreteFilterBuilder.gteq(value: Any){
+    comparator = GreaterThanOrEquals(value)
+}
+
+@DynamoDSLMarker
+fun ConcreteFilterBuilder.lteq(value: Any){
+    comparator = LessThanOrEquals(value)
+}
+
+@DynamoDSLMarker
+fun ConcreteFilterBuilder.inList(value: List<Any>){
+    comparator = InList(value)
+}
+
 @DynamoDSLMarker
 class RootFilterBuilder: FilterQueryBuilder{
 

src/test/kotlin/com/github/frankfarrell/dynamodsl/DynamoDSLTest.kt

@@ -9,39 +9,39 @@ import org.junit.Test
  */
 
 class DynamoDSLTest {
-    @Test
+    //@Test
     fun `it should build nested filter queries correctly`(){
-//        val queryResult = DynamoDSL(AmazonDynamoDBClientBuilder.standard().withRegion(Regions.US_EAST_1).build())
-//                .query("mytable") {
-//                    hashKey("myHashKey") {
-//                        eq(2)
-//                    }
-//                    sortKey("mysortkey"){
-//                        eq (2)
-//                        between ( 2 AND 3)
-//                    }
-//                    filtering {
-//                        attribute("a") {
-//                            eq(1)
-//                        } and attribute("b"){
-//                            eq(2)
-//                        } or {
-//                            attribute("c"){
-//                                eq(3)
-//                            } and attributeExists("d") or {
-//                                attribute("e"){
-//                                    eq(4)
-//                                }
-//                            }
-//                        } or attributeExists("f")
-//
-//                    }
-//                }
-
-
-        //if(queryResult.hasNext()){
-        //    queryResult.next()
-        //}
+        val queryResult = DynamoDSL(AmazonDynamoDBClientBuilder.standard().withRegion(Regions.US_EAST_1).build())
+                .query("mytable") {
+                    hashKey("myHashKey") {
+                        eq(2)
+                    }
+                    sortKey("mysortkey"){
+                        eq (2)
+                        between ( 2 AND 3)
+                    }
+                    filtering {
+                        attribute("a") {
+                            lteq(1)
+                        } and attribute("b"){
+                            gt(2)
+                        } or {
+                            attribute("c"){
+                                eq(3)
+                            } and attributeExists("d") or {
+                                attribute("e"){
+                                    noteq(4)
+                                }
+                            }
+                        } or attributeExists("f")
+
+                    }
+                }
+
+
+        if(queryResult.hasNext()){
+            queryResult.next()
+        }
 
 
     }