update filters

app/src/androidTest/java/net/pokeranalytics/android/FilterInstrumentedUnitTest.kt

@@ -11,6 +11,7 @@ import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
 import java.util.*
+import java.util.prefs.Preferences
 
 @RunWith(AndroidJUnit4::class)
 class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
@@ -242,4 +243,198 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
             Assert.assertEquals(s1.id, this.id)
         }
     }
+
+    @Test
+    fun testSingleBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        var filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "sb" to 0.5,
+            "bb" to 1.0,
+            "code" to null
+        )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains(it.id))
+        }
+    }
+
+    @Test
+    fun testSingleBlindNoSmallBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        var filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "sb" to null,
+            "bb" to 1.0,
+            "code" to null
+        )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains(it.id))
+        }
+    }
+
+    @Test
+    fun testSingleBlindCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        var filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "sb" to 1.0,
+            "bb" to 2.0,
+            "code" to "AUD"
+        )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(1, sessions.size)
+        sessions.map {
+            Assert.assertEquals(s3.id, it.id)
+        }
+    }
+
+    @Test
+    fun testMultiBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 2.0
+        s2.cgSmallBlind = 1.0
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        var filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(
+            mapOf(
+            "sb" to 1.0,
+            "bb" to 2.0,
+            "code" to null
+            ),
+            mapOf(
+            "sb" to 0.5,
+            "bb" to 1.0,
+            "code" to null
+            )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains(it.id))
+        }
+    }
 }

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

@@ -1,11 +1,8 @@
 package net.pokeranalytics.android.model.filter
 
-import io.realm.Realm
 import io.realm.RealmObject
 import io.realm.RealmQuery
-import io.realm.RealmResults
 import net.pokeranalytics.android.model.realm.Session
-import com.google.android.libraries.places.internal.`in`
 import java.util.*
 
 
@@ -41,10 +38,11 @@ enum class SessionFilterable(var fieldName:String? = null) : Filterable {
     BLINDS,
     ;
 
-    private enum class Field(var fieldName:String? = null) {
+    private enum class Field(var fieldName:String) {
         START_DATE("startDate"),
         END_DATE("endDate"),
-        CURRENCY("bankroll.currency.code"),
+        CURRENCY("bankroll.currency"),
+        CURRENCY_CODE("bankroll.currency.code"),
         BIG_BLIND("cgBigBlind"),
         SMALL_BLIND("cgSmallBlind");
     }
@@ -81,22 +79,35 @@ enum class SessionFilterable(var fieldName:String? = null) : Filterable {
             BLINDS -> {
                 val map : Array<Map<String,Any?>> by valueMap
                 var finalQuery = realmQuery
-                map.forEach {
+                map.forEachIndexed { index, it ->
-                    val sb : Double by it
-                    val bb : Double by it
-                    val code : String by it
 
-                    finalQuery = finalQuery
+                    val sb : Double? by it
+                    val bb : Double? by it
+                    val code : String? by it
+
+                    finalQuery
                         .beginGroup()
-                        .equalTo(Field.SMALL_BLIND.fieldName, sb)
+
-                        .and()
+                    sb?.let {
+                        finalQuery
+                            .equalTo(Field.SMALL_BLIND.fieldName, sb)
+                            .and()
+                    }
+
+                    finalQuery
                         .equalTo(Field.BIG_BLIND.fieldName, bb)
                         .and()
-                        .equalTo(Field.CURRENCY.fieldName, code)
-                        .endGroup()
 
-                    if (map.last() != it) {
+                    code?.let {
-                        finalQuery = finalQuery.or()
+                        finalQuery.equalTo(Field.CURRENCY_CODE.fieldName, code)
+                    } ?: run {
+                        finalQuery.isNull(Field.CURRENCY_CODE.fieldName)
+                    }
+
+                    finalQuery.endGroup()
+
+                    if (index < map.size - 1) {
+                        finalQuery.or()
                     }
                 }
                 finalQuery