filter update

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

@@ -2,16 +2,15 @@ package net.pokeranalytics.android
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.realm.RealmResults
+import net.pokeranalytics.android.exceptions.FilterValueMapException
 import net.pokeranalytics.android.model.filter.FilterManager
 import net.pokeranalytics.android.model.filter.SessionFilterable
 import net.pokeranalytics.android.model.realm.Bankroll
-import net.pokeranalytics.android.model.realm.Result
 import net.pokeranalytics.android.model.realm.Session
 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() {
@@ -28,6 +27,46 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         return session
     }
 
+    @Test(expected = FilterValueMapException::class)
+    fun testFilterException() {
+        val realm = this.mockRealm
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(SessionFilterable.BLINDS)
+        ) as RealmResults<Session>
+    }
+
+    @Test(expected = FilterValueMapException::class)
+    fun testValueKeyFilterException() {
+        var filter = SessionFilterable.STARTED_FROM_DATE
+        filter.valueMap = mapOf("bob" to Date())
+
+        val realm = this.mockRealm
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+    }
+
+    @Test(expected = FilterValueMapException::class)
+    fun testSubValueKeyFilterException() {
+        var filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "bob" to 0.5,
+            "bb" to 1.0,
+            "code" to null
+        )))
+
+        val realm = this.mockRealm
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        ) as RealmResults<Session>
+    }
+
     @Test
     fun testCashFilter() {
 

app/src/main/java/net/pokeranalytics/android/exceptions/Exceptions.kt

@@ -10,4 +10,8 @@ class FormattingException(message: String) : Exception(message) {
 
 class RowRepresentableEditDescriptorException(message: String) : Exception(message) {
 
+}
+
+class FilterValueMapException(message: String) : Exception(message) {
+
 }

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

@@ -2,6 +2,7 @@ package net.pokeranalytics.android.model.filter
 
 import io.realm.RealmObject
 import io.realm.RealmQuery
+import net.pokeranalytics.android.exceptions.FilterValueMapException
 import net.pokeranalytics.android.model.realm.Session
 import java.util.*
 
@@ -47,7 +48,37 @@ enum class SessionFilterable(var fieldName:String? = null) : Filterable {
         SMALL_BLIND("cgSmallBlind");
     }
 
-    var valueMap : Map<String, Any?>? = null
+    private var _valueMap: Map<String, Any?>? = null
+    var valueMap : Map<String, Any?>?
+        get() {
+            this.valueMapExceptedKeys?.let { valueMapExceptedKeys ->
+                _valueMap?.let { map ->
+                    println("valueMapExceptedKeys $valueMapExceptedKeys")
+                    println("map.keys $map.keys")
+                    var missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) }
+                    println("missingKeys $missingKeys")
+                    if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) {
+                        throw FilterValueMapException("valueMap does not contain ${missingKeys}")
+                    }
+                } ?: run {
+                    throw FilterValueMapException("valueMap null not expected")
+                }
+            }
+            return _valueMap
+        }
+        set(value) {
+            _valueMap = value
+        }
+
+    private val valueMapExceptedKeys : Array<String>?
+        get() {
+            return when (this) {
+                BANKROLL -> arrayOf("ids")
+                STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date")
+                BLINDS -> arrayOf("map")
+                else -> null
+            }
+        }
 
     override fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject> {
         return when (this) {
@@ -79,11 +110,16 @@ enum class SessionFilterable(var fieldName:String? = null) : Filterable {
             BLINDS -> {
                 val map : Array<Map<String,Any?>> by valueMap
                 var finalQuery = realmQuery
-                map.forEachIndexed { index, it ->
+                val expectedSubKeys = arrayOf("sb", "bb", "code") as Array<String>
+                map.forEachIndexed { index, subMap ->
+                    var missingKeys = subMap.keys.filter { !expectedSubKeys.contains(it) }
+                    if (subMap.keys.size == expectedSubKeys.size && missingKeys.isNotEmpty()) {
+                        throw FilterValueMapException("subValueMap does not contain ${missingKeys}")
+                    }
 
-                    val sb : Double? by it
-                    val bb : Double? by it
-                    val code : String? by it
+                    val sb : Double? by subMap
+                    val bb : Double? by subMap
+                    val code : String? by subMap
 
                     finalQuery
                         .beginGroup()