Fixing most tests

app/build.gradle

@@ -47,7 +47,12 @@ android {
 
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
+
+    // Kotlin
     implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1'
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"
+    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
 
     // Android
     implementation 'androidx.appcompat:appcompat:1.0.2'
@@ -72,10 +77,6 @@ dependencies {
     // Crashlytics
     implementation 'com.crashlytics.sdk.android:crashlytics:2.9.9'
 
-    // Kotlin
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1'
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"
-
     // Logs
     implementation 'com.jakewharton.timber:timber:4.7.1'
 

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt

@@ -2,7 +2,10 @@ package net.pokeranalytics.android.unitTests.filter
 
 import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
 import net.pokeranalytics.android.model.filter.QueryType
-import net.pokeranalytics.android.model.realm.*
+import net.pokeranalytics.android.model.realm.Bankroll
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.model.realm.FilterElement
+import net.pokeranalytics.android.model.realm.Session
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import org.junit.Assert
@@ -45,11 +48,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
         filter.updateValueMap(filterElement)
 
-        val sessions = Filter.queryOn(
+
-            realm,
+
-            Session,
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(2, sessions.size)
         sessions.map {
@@ -92,11 +93,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
         filter.updateValueMap(filterElement)
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(2, sessions.size)
         sessions.map {
@@ -139,11 +136,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
         filter.updateValueMap(filterElement)
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions.map {
@@ -188,11 +181,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         val filterElement = FilterElement(filterElementRows = arrayListOf(blind1, blind2))
         filter.updateValueMap(filterElement)
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(2, sessions.size)
         sessions.map {

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt

@@ -37,11 +37,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val filterElement = FilterElement(filterElementRow)
         filter.updateValueMap(filterElement)
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -70,11 +66,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val filterElement = FilterElement(filterElementRow)
         filter.updateValueMap(filterElement)
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -102,11 +94,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val filterElement = FilterElement(filterElementRow)
         filter.updateValueMap(filterElement)
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -128,11 +116,8 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         
         Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
-        val sessions = Filter.queryOn(
+
-            realm,
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.WEEK_END))
-            Session,
-            arrayListOf(QueryType.WEEK_END)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -145,19 +130,19 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val realm = this.mockRealm
         realm.beginTransaction()
+
         val cal = Calendar.getInstance()
         cal.time = Date()
+
         cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY)
         val s1 = Session.testInstance(100.0, false, cal.time)
+
         cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY)
-        
         Session.testInstance(100.0, true, cal.time)
+
         realm.commitTransaction()
-        val sessions = Filter.queryOn(
+
-            realm,
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.WEEK_DAY))
-            Session,
-            arrayListOf(QueryType.WEEK_DAY)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -185,12 +170,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
         filter.updateValueMap(FilterElement(filterElementRow))
 
-
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-        val sessions = Filter.queryOn(
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -218,11 +198,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
         filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -251,11 +227,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
         filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -284,12 +256,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
         filter.updateValueMap(FilterElement(filterElementRow))
 
-
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-        val sessions = Filter.queryOn(
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/ExceptionFilterInstrumentedTest.kt

@@ -20,11 +20,8 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
         filter.updateValueMap(filterElement)
 
         val realm = this.mockRealm
-        Filter.queryOn(
+        Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
+
-            Session,
-            arrayListOf(filter)
-        )
     }
 
     @Test(expected = PokerAnalyticsException.FilterElementUnknownName::class)

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt

@@ -51,7 +51,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val newRealm = this.mockRealm
         newRealm.where(Filter::class.java).equalTo("name", "testSaveLoadCashFilter").findFirst()?.let { foundFilter ->
-            val sessions = foundFilter.results()
+            val sessions = foundFilter.results<Session>()
 
             Assert.assertEquals(1, sessions.size)
             sessions[0]?.run {

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

@@ -26,11 +26,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1)
         realm.commitTransaction()
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.CASH))
-            realm,
-            Session,
-            arrayListOf(QueryType.CASH)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -48,11 +44,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1)
         realm.commitTransaction()
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.TOURNAMENT))
-            realm,
-            Session,
-            arrayListOf(QueryType.TOURNAMENT)
-        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
@@ -75,11 +67,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1, b2)
         realm.commitTransaction()
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.LIVE))
-            realm,
-            Session,
-            arrayListOf(QueryType.LIVE)
-        )
 
         Assert.assertEquals(1, sessions.size)
         (sessions[0] as Session).bankroll?.run {
@@ -101,11 +89,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1, b2)
         realm.commitTransaction()
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.ONLINE))
-            realm,
-            Session,
-            arrayListOf(QueryType.ONLINE)
-        )
 
         Assert.assertEquals(1, sessions.size)
         (sessions[0] as Session).bankroll?.run {
@@ -130,11 +114,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         (sessions[0] as Session).bankroll?.run {
@@ -168,11 +148,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(6, sessions.size)
 
@@ -198,11 +174,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.GAME
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         (sessions[0] as Session).game?.run {
@@ -236,11 +208,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow2.filterSectionRow = FilterSectionRow.GAME
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(6, sessions.size)
 
@@ -266,11 +234,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         (sessions[0] as Session).location?.run {
@@ -305,11 +269,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(6, sessions.size)
 
@@ -336,11 +296,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         (sessions[0] as Session).tournamentName?.run {
@@ -373,11 +329,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(6, sessions.size)
 
@@ -415,11 +367,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(1, sessions.size)
         (sessions[0] as Session).run {
@@ -456,11 +404,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(8, sessions.size)
     }
@@ -488,11 +432,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         val result = arrayListOf(s1.id, s2.id, s3.id, s4.id)
 
@@ -519,11 +459,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
         filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(2, sessions.size)
 
@@ -548,11 +484,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.VALUE
         filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(2, sessions.size)
 
@@ -577,11 +509,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow.filterSectionRow = FilterSectionRow.VALUE
         filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
-            realm,
-            Session,
-            arrayListOf(filter)
-        )
 
         Assert.assertEquals(3, sessions.size)
 
@@ -611,11 +539,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filterElementRow2.filterSectionRow = FilterSectionRow.VALUE
         filterLess.updateValueMap(FilterElement(filterElementRow2))
 
-        val sessions = Filter.queryOn(
+        val sessions = Filter.queryOn<Session>(realm, arrayListOf(filterMore, filterLess))
-            realm,
-            Session,
-            arrayListOf(filterMore, filterLess)
-        )
 
         Assert.assertEquals(1, sessions.size)
 

app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt

@@ -64,8 +64,8 @@ class Calculator {
 			var computableGroups: MutableList<ComputableGroup> = mutableListOf()
 			filters.forEach { filter ->
 
-				val results = filter.realm.where(ComputableResult::class.java).findAll()
+				val results = filter.results<ComputableResult>()
-				val sets = filter.realm.where(SessionSet::class.java).findAll()
+				val sets = filter.results<SessionSet>()
 				val group = ComputableGroup(filter.name, results, sets)
 				computableGroups.add(group)
 
@@ -104,21 +104,6 @@ class Calculator {
 			return computedResults
 		}
 
-//		fun compute(sessionGroup: ComputableGroup, options: Options): ComputedResults {
-//
-//			var sum: Double = sessionGroup.computables.sum("ratedNet").toDouble()
-//			val results: ComputedResults = ComputedResults(sessionGroup)
-//
-//			results.addStats(
-//				setOf(
-//					ComputedStat(NETRESULT, sum)
-//				)
-//			)
-//
-//			return results
-//		}
-
-
 		/**
 		 * Computes stats for a SessionSet
 		 */

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

@@ -1,6 +1,7 @@
 package net.pokeranalytics.android.model.filter
 
 import io.realm.RealmModel
+import net.pokeranalytics.android.model.realm.ComputableResult
 import net.pokeranalytics.android.model.realm.Session
 
 /**
@@ -37,11 +38,11 @@ class UnmanagedFilterField(message: String) : Exception(message) {
  * Companion-level Interface to indicate an RealmObject class can be filtered and to provide all the fieldNames (eg: parameter's path) needed to be query on.
  */
 interface Filterable : RealmModel {
-    /**
-     * return the path of the parameter used in the [QueryType] related to this entity
-     */
-    fun fieldNameForQueryType(queryType: QueryType) : String?
 
+	/**
+	 * return the path of the parameter used in the [QueryType] related to this entity
+	 */
+//    fun fieldNameForQueryType(queryType: QueryType) : String?
 
 }
 
@@ -49,13 +50,19 @@ class FilterHelper {
 
 	companion object {
 
-		inline fun <reified T : Filterable> fieldNameForQueryType(queryType: QueryType) : String? {
+		inline fun <reified T : Filterable> fieldNameForQueryType(queryType: QueryType): String? {
-			when (T::class) {
+			val clazz = T::class.java
-				is Session -> {
+
+			return when (clazz) {
+				Session::class.java -> {
 					Session.fieldNameForQueryType(queryType)
 				}
+				ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryType)
+//				is SessionSet -> SessionSet.fieldNameForQueryType(queryType)
+				else -> {
+					throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}")
+				}
 			}
-			throw UnmanagedFilterField("Filterable type fields are not defined")
 		}
 
 	}

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

@@ -5,6 +5,8 @@ import io.realm.RealmQuery
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.realm.FilterElement
 import net.pokeranalytics.android.model.realm.FilterElementBlind
+import net.pokeranalytics.android.model.realm.Session
+import timber.log.Timber
 import java.util.*
 
 
@@ -140,6 +142,7 @@ enum class QueryType(var subType:SubType? = null) {
 
                 val fieldName = FilterHelper.fieldNameForQueryType<T>(this)
                 fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
+	            Timber.d(">>>> fi = ${fieldName}")
 
                 this.subType?.let { subType ->
                     return when (subType) {
@@ -161,7 +164,8 @@ enum class QueryType(var subType:SubType? = null) {
 
                 return when (this) {
                     LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE)
-                    CASH, TOURNAMENT -> realmQuery.equalTo(fieldName, this.ordinal)
+                    CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal)
+	                TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal)
                     ALL_TOURNAMENT_FEATURES -> {
                         val ids: Array<String> by valueMap
                         ids.forEach {
@@ -210,9 +214,11 @@ enum class QueryType(var subType:SubType? = null) {
                         realmQuery.equalTo(fieldName, year)
                     }
                     WEEK_END, WEEK_DAY -> {
-	                    var query = realmQuery.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY))
+	                    var query = realmQuery
-	                    if (this == WEEK_DAY) { query.not() }
+	                    if (this == WEEK_DAY) {
-	                    query
+		                    query = realmQuery.not()
+	                    }
+	                    query.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY))
                     }
                     else -> {
                         throw PokerAnalyticsException.QueryTypeUnhandled

app/src/main/java/net/pokeranalytics/android/model/realm/ComputableResult.kt

@@ -2,8 +2,10 @@ package net.pokeranalytics.android.model.realm
 
 import io.realm.RealmObject
 import net.pokeranalytics.android.calculus.interfaces.Computable
+import net.pokeranalytics.android.model.filter.Filterable
+import net.pokeranalytics.android.model.filter.QueryType
 
-open class ComputableResult : RealmObject(), Computable {
+open class ComputableResult : RealmObject(), Computable, Filterable {
 
 	override var ratedNet: Double = 0.0
 
@@ -52,4 +54,13 @@ open class ComputableResult : RealmObject(), Computable {
 		BB_PER100HANDS("bbPer100Hands")
 	}
 
+	companion object : Filterable {
+
+		fun fieldNameForQueryType(queryType: QueryType): String? {
+			return "session." + Session.fieldNameForQueryType(queryType)
+		}
+
+	}
+
+
 }

app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt

@@ -2,15 +2,15 @@ package net.pokeranalytics.android.model.realm
 
 import io.realm.*
 import io.realm.annotations.PrimaryKey
-import net.pokeranalytics.android.exceptions.PokerAnalyticsException
-
 import io.realm.kotlin.where
+import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.filter.Filterable
 import net.pokeranalytics.android.model.filter.QueryType
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import org.jetbrains.annotations.TestOnly
+import timber.log.Timber
 import java.util.*
 
 /**
@@ -18,7 +18,7 @@ import java.util.*
  * It contains a list of [FilterElement] describing the complete query to launch
  * The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on
  */
-open class Filter(entity:Filterable) : RealmObject() {
+open class Filter(entity: Filterable) : RealmObject() {
 
     constructor() : this(entity = Session)
 
@@ -44,23 +44,6 @@ open class Filter(entity:Filterable) : RealmObject() {
             }
         }
 
-        val relatedEntity: Class < out RealmObject >
-            get() {
-                return when (this) {
-                    SESSION -> Session::class.java
-//                    else -> throw FilterUnhandledEntityException("this entity is not filterable")
-                }
-            }
-
-
-        val filterable : Filterable
-            get() {
-                return when (this) {
-                    SESSION -> Session.Companion
-//                    else -> throw FilterUnhandledEntityException("this entity is not filterable")
-                }
-            }
-
     }
 
     companion object {
@@ -68,8 +51,9 @@ open class Filter(entity:Filterable) : RealmObject() {
         inline fun <reified T : Filterable> queryOn(realm: Realm, queries: List<QueryType>): RealmResults<T> {
             var realmQuery = realm.where<T>()
             queries.forEach {
-                realmQuery = (it.filter<T>(realmQuery))
+                realmQuery = it.filter<T>(realmQuery)
             }
+	        Timber.d(">>>>> query = ${realmQuery.description}")
             return realmQuery.findAll()
         }
     }

app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt

@@ -41,7 +41,7 @@ import java.util.Currency
 import kotlin.collections.ArrayList
 
 open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDataSource, RowRepresentable, Timed,
-    TimeFilterable {
+    TimeFilterable, Filterable {
 
 	enum class Type {
 		CASH_GAME,
@@ -61,10 +61,10 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
 			return realm.copyToRealm(session)
 		}
 
-		override fun fieldNameForQueryType(queryType: QueryType): String? {
+		fun fieldNameForQueryType(queryType: QueryType): String? {
 			return when (queryType) {
-				LIVE -> "bankroll.live"
+				LIVE, ONLINE -> "bankroll.live"
-				CASH -> "type"
+				CASH, TOURNAMENT -> "type"
 				BANKROLL -> "bankroll.id"
 				GAME -> "game.id"
 				TOURNAMENT_NAME -> "tournamentName.id"
@@ -87,7 +87,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
 				MORE_THAN_TOURNAMENT_FEE, LESS_THAN_TOURNAMENT_FEE, BETWEEN_TOURNAMENT_FEE -> "tournamentEntryFee"
 				STARTED_FROM_DATE, STARTED_TO_DATE -> "startDate"
 				ENDED_FROM_DATE, ENDED_TO_DATE -> "endDate"
-				DAY_OF_WEEK, WEEK_END -> "dayOfWeek"
+				DAY_OF_WEEK, WEEK_END, WEEK_DAY -> "dayOfWeek"
 				MONTH -> "month"
 				YEAR -> "year"
 				else -> null

app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt

@@ -5,11 +5,12 @@ import io.realm.RealmObject
 import io.realm.RealmResults
 import io.realm.annotations.Ignore
 import io.realm.annotations.LinkingObjects
+import net.pokeranalytics.android.model.filter.Filterable
 import net.pokeranalytics.android.model.interfaces.Timed
 import java.util.*
 
 
-open class SessionSet : RealmObject(), Timed {
+open class SessionSet : RealmObject(), Timed, Filterable {
 
 	var startDate: Date = Date()
         set(value) {