add new filters

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

@@ -452,6 +452,116 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         sessions.forEach {
             Assert.assertTrue(result.contains((it as Session).id))
         }
+    }
+
+    @Test
+    fun testTableSizeFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val s1 = Session.testInstance(tableSize = 2)
+        val s2 = Session.testInstance(tableSize = 4)
+        Session.testInstance(tableSize = 9)
+        Session.testInstance(tableSize = 10)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.TABLE_SIZE
+        filter.valueMap = mapOf("values" to arrayOf(2,4))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+
+        val result = arrayListOf(s1.id, s2.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun testMoreThanNetResultFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        Session.testInstance(netResult = 200.0)
+        val s1 = Session.testInstance(netResult = 500.0)
+        Session.testInstance(netResult = 50.0)
+        val s2 = Session.testInstance(netResult = 570.0)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.MORE_THAN_NET_RESULT
+        filter.valueMap = mapOf("net" to 204.0)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+
+        val result = arrayListOf(s1.id, s2.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun testLessThanNetResultFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val s1 = Session.testInstance(netResult = 200.0)
+        val s2 = Session.testInstance(netResult = 500.0)
+        val s3 = Session.testInstance(netResult = 50.0)
+        Session.testInstance(netResult = 570.0)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.LESS_THAN_NET_RESULT
+        filter.valueMap = mapOf("net" to 540.0)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(3, sessions.size)
+
+        val result = arrayListOf(s1.id, s2.id, s3.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun tesNetResultFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val s1 = Session.testInstance(netResult = 200.0)
+        val s2 = Session.testInstance(netResult = 500.0)
+        val s3 = 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)
+
+        val filterLess = SessionFilterable.LESS_THAN_NET_RESULT
+        filterLess.valueMap = mapOf("net" to 400.0)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filterLess, filterMore)
+        )
 
+        Assert.assertEquals(1, sessions.size)
+
+        val result = arrayListOf(s1.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
     }
 }

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

@@ -22,6 +22,8 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
     NUMBER_OF_TABLE("numberOfTable"),
     TOURNAMENT_TYPE("tournamentType"),
     BLINDS,
+    LESS_THAN_NET_RESULT,
+    MORE_THAN_NET_RESULT,
     ;
 
     private enum class Field(var fieldName:String) {
@@ -50,10 +52,16 @@ enum class SessionFilterable(private var fieldName:String? = null): Filterable {
                 BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> arrayOf("ids")
                 LIMIT, TOURNAMENT_TYPE, TABLE_SIZE, NUMBER_OF_TABLE -> 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> {
         return when (this) {
             LIVE -> realmQuery.equalTo(Field.LIVE.fieldName, true)
@@ -87,6 +95,13 @@ 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")