update filters

app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt

@@ -288,7 +288,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         Assert.assertEquals(6, sessions.size)
 
-        val result = arrayListOf(l2.id, l3.id)
+        val result = arrayListOf(l1.id, l3.id)
 
         sessions.forEach {
             Assert.assertTrue(result.contains((it as Session).location?.id))
@@ -384,7 +384,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         )
 
         Assert.assertEquals(1, sessions.size)
-        (sessions[0] as Session)?.run {
+        (sessions[0] as Session).run {
             Assert.assertEquals(s.id, this.id)
         }
     }
@@ -492,7 +492,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
         val filter = SessionFilterable.MORE_THAN_NET_RESULT
-        filter.valueMap = mapOf("net" to 204.0)
+        filter.valueMap = mapOf("value" to 204.0)
 
         val sessions = FilterManager().filter(
             realm,
@@ -519,7 +519,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
         val filter = SessionFilterable.LESS_THAN_NET_RESULT
-        filter.valueMap = mapOf("net" to 540.0)
+        filter.valueMap = mapOf("value" to 540.0)
 
         val sessions = FilterManager().filter(
             realm,
@@ -540,21 +540,21 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val realm = this.mockRealm
         realm.beginTransaction()
         val s1 = Session.testInstance(netResult = 200.0)
-        val s2 = Session.testInstance(netResult = 500.0)
+        Session.testInstance(netResult = 500.0)
-        val s3 = Session.testInstance(netResult = 50.0)
+        val s2 = Session.testInstance(netResult = 50.0)
         Session.testInstance(netResult = 570.0)
         realm.commitTransaction()
 
         val filterMore = SessionFilterable.MORE_THAN_NET_RESULT
-        filterMore.valueMap = mapOf("net" to 200.0)
+        filterMore.valueMap = mapOf("value" to 200.0)
 
         val filterLess = SessionFilterable.LESS_THAN_NET_RESULT
-        filterLess.valueMap = mapOf("net" to 400.0)
+        filterLess.valueMap = mapOf("value" to 400.0)
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
-            arrayListOf(filterLess, filterMore)
+            arrayListOf(filterMore, filterLess)
         )
 
         Assert.assertEquals(1, sessions.size)

app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt

@@ -36,7 +36,7 @@ class FilterManager {
     fun filter(realm:Realm, relatedEntity: Class<out RealmObject>, queries:List<Filterable>): RealmResults<*> {
         var realmQuery : RealmQuery<out RealmObject> = realm.where(relatedEntity)
         queries.forEach {
-            realmQuery = (it.filter(realmQuery)).and()
+            realmQuery = (it.filter(realmQuery))
         }
         return realmQuery.findAll()
     }

app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt

@@ -6,7 +6,7 @@ import net.pokeranalytics.android.exceptions.FilterValueMapException
 import net.pokeranalytics.android.model.filter.interfaces.Filterable
 import net.pokeranalytics.android.model.realm.Session
 
-enum class SessionFilterable(private var fieldName:String? = null): Filterable {
+enum class SessionFilterable(private var fieldName:String? = null, private var subType:SubType? = null): Filterable {
     LIVE,
     CASH,
     ONLINE,
@@ -19,13 +19,33 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
     LOCATION("location.id"),
     LIMIT("limit"),
     TABLE_SIZE("tableSize"),
-    NUMBER_OF_TABLE("numberOfTable"),
     TOURNAMENT_TYPE("tournamentType"),
     BLINDS,
-    LESS_THAN_NET_RESULT,
+    MORE_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.MORE),
-    MORE_THAN_NET_RESULT,
+    LESS_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.LESS),
+    BETWEEN_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.BETWEEN),
+    MORE_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.MORE),
+    LESS_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.LESS),
+    MORE_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.MORE),
+    LESS_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.LESS),
+    MORE_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.MORE),
+    LESS_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.LESS),
+    MORE_THAN_TIPS(Field.TIPS.fieldName, SubType.MORE),
+    LESS_THAN_TIPS(Field.TIPS.fieldName, SubType.LESS),
+    MORE_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.MORE),
+    LESS_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.LESS),
+    BETWEEN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.BETWEEN),
+    MORE_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.MORE),
+    LESS_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.LESS),
+    BETWEEN_TOURNAMENT_FEE(Field.TOURNAMENT_FEE.fieldName, SubType.BETWEEN),
     ;
 
+    enum class SubType {
+        BETWEEN,
+        MORE,
+        LESS;
+    }
+
     private enum class Field(var fieldName:String) {
         LIVE("bankroll.live"),
         CASH("type"),
@@ -35,12 +55,13 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
         SMALL_BLIND("cgSmallBlind"),
         COMMENT("comment"),
         TOURNAMENT_FEATURES("tournamentFeatures.id"),
-        TOURNAMENT_NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
+        NET_RESULT("result.ratedNet"),
-        TOURNAMENT_ENTRY_FEE("tournamentEntryFee"),
+        BUY_IN("result.buyin"),
-        RESULT_BUY_IN("result.buyin"),
+        CASH_OUT("result.cashout"),
-        RESULT_CASHED_OUT("result.cashout"),
+        TIPS("result.tips"),
-        RESULT_NET("result.ratedNet"),
+        NUMBER_OF_TABLE("numberOfTable"),
-        RESULT_TIPS("result.tips"),
+        NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
+        TOURNAMENT_FEE("tournamentEntryFee"),
         ;
     }
 
@@ -48,21 +69,46 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
 
     override val filterValuesExceptedKeys : Array<String>?
         get() {
+            this.subType?.let {
+                return when (it) {
+                    SubType.BETWEEN -> arrayOf("leftValue", "rightValue")
+                    else -> arrayOf("value")
+                }
+            }
             return when (this) {
                 BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> arrayOf("ids")
-                LIMIT, TOURNAMENT_TYPE, TABLE_SIZE, NUMBER_OF_TABLE -> arrayOf("values")
+                LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> arrayOf("values")
                 BLINDS -> arrayOf("map")
-                MORE_THAN_NET_RESULT, LESS_THAN_NET_RESULT -> arrayOf("net")
                 else -> null
             }
         }
 
-    var between: Boolean = false
-    var moreThan: Boolean = false
-    var lessThan: Boolean = false
-    var strict: Boolean = false
-
     override fun filter(realmQuery: RealmQuery<out RealmObject>): RealmQuery<out RealmObject> {
+
+        this.subType?.let {subType ->
+            this.fieldName?.let {
+                return when (subType) {
+                    SubType.LESS -> {
+                        val value: Double by filterValues
+                        println("filter test less")
+                        realmQuery.lessThanOrEqualTo(it, value)
+                    }
+                    SubType.MORE -> {
+                        println("filter test more")
+                        val value: Double by filterValues
+                        realmQuery.greaterThanOrEqualTo(it, value)
+                    }
+                    SubType.BETWEEN -> {
+                        val leftValue: Double by filterValues
+                        val rightValue: Double by filterValues
+                        realmQuery.between(it, leftValue, rightValue)
+                    }
+                }
+            } ?: run {
+                throw FilterValueMapException("fieldName is missing")
+            }
+        }
+
         return when (this) {
             LIVE -> realmQuery.equalTo(Field.LIVE.fieldName, true)
             CASH -> realmQuery.equalTo(Field.CASH.fieldName, Session.Type.CASH_GAME.ordinal)
@@ -87,7 +133,7 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
                     throw FilterValueMapException("fieldName is missing")
                 }
             }
-            LIMIT, TOURNAMENT_TYPE, TABLE_SIZE, NUMBER_OF_TABLE -> {
+            LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
                 val values : Array<Int?>? by filterValues
                 this.fieldName?.let {
                     realmQuery.`in`(it, values)
@@ -95,13 +141,6 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
                     throw FilterValueMapException("fieldName is missing")
                 }
             }
-            MORE_THAN_NET_RESULT, LESS_THAN_NET_RESULT -> {
-                val net : Double by filterValues
-                if (this == LESS_THAN_NET_RESULT) {
-                    realmQuery.not()
-                }
-                realmQuery.greaterThanOrEqualTo(Field.RESULT_NET.fieldName, net)
-            }
             BLINDS -> {
                 val map : Array<Map<String,Any?>> by filterValues
                 val expectedSubKeys = arrayOf("sb", "bb", "code")
@@ -142,6 +181,9 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
                 }
                 realmQuery
             }
+            else -> {
+                realmQuery
+            }
         }
     }
 }