remove warning and clean up files

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

@@ -1,7 +1,6 @@
 package net.pokeranalytics.android.filter
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import io.realm.RealmResults
 import net.pokeranalytics.android.model.filter.DateFilterable
 import net.pokeranalytics.android.model.filter.FilterManager
 import net.pokeranalytics.android.model.realm.Session
@@ -23,10 +22,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         cal.time = Date() // sets calendar time/date
         val s1 = Session.testInstance(100.0, false, cal.time)
         cal.add(Calendar.DAY_OF_MONTH, 1) // adds one hour
-        val s2 = Session.testInstance(100.0, true, cal.time)
+        Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
 
-        var filter = DateFilterable.DAY_OF_WEEK
+        val filter = DateFilterable.DAY_OF_WEEK
         cal.time = s1.startDate
         filter.valueMap = mapOf("dayOfWeek" to cal.get(Calendar.DAY_OF_WEEK))
 
@@ -34,11 +33,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s1.id, this.id)
+            Assert.assertEquals(s1.id, (this as Session).id)
         }
     }
 
@@ -51,10 +50,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         cal.time = Date()
         val s1 = Session.testInstance(100.0, false, cal.time)
         cal.add(Calendar.MONTH, 1)
-        val s2 = Session.testInstance(100.0, true, cal.time)
+        
+        Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
 
-        var filter = DateFilterable.MONTH
+        val filter = DateFilterable.MONTH
         cal.time = s1.startDate
         filter.valueMap = mapOf("month" to cal.get(Calendar.MONTH))
 
@@ -62,11 +62,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s1.id, this.id)
+            Assert.assertEquals(s1.id, (this as Session).id)
         }
     }
 
@@ -79,10 +79,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         cal.time = Date()
         val s1 = Session.testInstance(100.0, false, cal.time)
         cal.add(Calendar.YEAR, 1)
-        val s2 = Session.testInstance(100.0, true, cal.time)
+        
+        Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
 
-        var filter = DateFilterable.YEAR
+        val filter = DateFilterable.YEAR
         cal.time = s1.startDate
         filter.valueMap = mapOf("year" to cal.get(Calendar.YEAR))
 
@@ -90,11 +91,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s1.id, this.id)
+            Assert.assertEquals(s1.id, (this as Session).id)
         }
     }
 
@@ -109,17 +110,18 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         cal.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY)
         val s1 = Session.testInstance(100.0, false, cal.time)
         cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY)
-        val s2 = Session.testInstance(100.0, true, cal.time)
+        
+        Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(DateFilterable.WEEK_END)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s1.id, this.id)
+            Assert.assertEquals(s1.id, (this as Session).id)
         }
     }
 
@@ -133,17 +135,18 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         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)
-        val s2 = Session.testInstance(100.0, true, cal.time)
+        
+        Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(DateFilterable.WEEK_DAY)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s1.id, this.id)
+            Assert.assertEquals(s1.id, (this as Session).id)
         }
     }
 
@@ -155,24 +158,25 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val cal = Calendar.getInstance() // creates calendar
         cal.time = Date() // sets calendar time/date
-        val s1 = Session.testInstance(100.0, false, cal.time, 1)
+        
+        Session.testInstance(100.0, false, cal.time, 1)
 
         cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
         val s2 = Session.testInstance(100.0, true, cal.time, 1)
         realm.commitTransaction()
 
-        var filter = DateFilterable.STARTED_FROM_DATE
+        val filter = DateFilterable.STARTED_FROM_DATE
         filter.valueMap = mapOf("date" to s2.startDate)
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s2.id, this.id)
+            Assert.assertEquals(s2.id, (this as Session).id)
         }
     }
 
@@ -187,22 +191,22 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val s1 = Session.testInstance(100.0, false, cal.time, 1)
 
         cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
-        val s2 = Session.testInstance(100.0, true, cal.time, 1)
+        Session.testInstance(100.0, true, cal.time, 1)
 
         realm.commitTransaction()
 
-        var filter = DateFilterable.STARTED_TO_DATE
+        val filter = DateFilterable.STARTED_TO_DATE
         filter.valueMap = mapOf("date" to s1.startDate)
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s1.id, this.id)
+            Assert.assertEquals(s1.id, (this as Session).id)
         }
     }
 
@@ -214,25 +218,26 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val cal = Calendar.getInstance() // creates calendar
         cal.time = Date() // sets calendar time/date
-        val s1 = Session.testInstance(100.0, false, cal.time, 1)
+        
+        Session.testInstance(100.0, false, cal.time, 1)
 
         cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
         val s2 = Session.testInstance(100.0, true, cal.time, 1)
 
         realm.commitTransaction()
 
-        var filter = DateFilterable.ENDED_FROM_DATE
+        val filter = DateFilterable.ENDED_FROM_DATE
         filter.valueMap = mapOf("date" to s2.endDate)
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s2.id, this.id)
+            Assert.assertEquals(s2.id, (this as Session).id)
         }
     }
 
@@ -247,22 +252,23 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val s1 = Session.testInstance(100.0, false, cal.time, 1)
 
         cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
-        val s2 = Session.testInstance(100.0, true, cal.time, 1)
+        
+        Session.testInstance(100.0, true, cal.time, 1)
         realm.commitTransaction()
 
 
-        var filter = DateFilterable.ENDED_TO_DATE
+        val filter = DateFilterable.ENDED_TO_DATE
         filter.valueMap = mapOf("date" to s1.endDate)
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(s1.id, this.id)
+            Assert.assertEquals(s1.id, (this as Session).id)
         }
     }
 }

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

@@ -1,7 +1,6 @@
 package net.pokeranalytics.android.filter
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import io.realm.RealmResults
 import net.pokeranalytics.android.exceptions.FilterValueMapException
 import net.pokeranalytics.android.model.filter.DateFilterable
 import net.pokeranalytics.android.model.filter.FilterManager
@@ -17,29 +16,29 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
     @Test(expected = FilterValueMapException::class)
     fun testFilterException() {
         val realm = this.mockRealm
-        val sessions = FilterManager().filter(
+         FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(SessionFilterable.BLINDS)
-        ) as RealmResults<Session>
+        )
     }
 
     @Test(expected = FilterValueMapException::class)
     fun testValueKeyFilterException() {
-        var filter = DateFilterable.STARTED_FROM_DATE
+        val filter = DateFilterable.STARTED_FROM_DATE
         filter.valueMap = mapOf("bob" to Date())
 
         val realm = this.mockRealm
-        val sessions = FilterManager().filter(
+        FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
     }
 
     @Test(expected = FilterValueMapException::class)
     fun testSubValueKeyFilterException() {
-        var filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.BLINDS
         filter.valueMap = mapOf("map" to arrayOf(mapOf(
             "bob" to 0.5,
             "bb" to 1.0,
@@ -47,10 +46,10 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
         )))
 
         val realm = this.mockRealm
-        val sessions = FilterManager().filter(
+        FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
     }
 }

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

@@ -1,7 +1,6 @@
 package net.pokeranalytics.android.filter
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import io.realm.RealmResults
 import net.pokeranalytics.android.model.filter.FilterManager
 import net.pokeranalytics.android.model.filter.SessionFilterable
 import net.pokeranalytics.android.model.realm.Bankroll
@@ -20,19 +19,19 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val realm = this.mockRealm
         realm.beginTransaction()
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1)
+        Session.testInstance(100.0, false, Date(), 1)
-        val s2 = Session.testInstance(100.0, true, Date(), 1)
+        Session.testInstance(100.0, true, Date(), 1)
         realm.commitTransaction()
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(SessionFilterable.CASH)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(Session.Type.CASH_GAME.ordinal, this.type)
+            Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type)
         }
     }
 
@@ -42,19 +41,19 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val realm = this.mockRealm
         realm.beginTransaction()
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1)
+        Session.testInstance(100.0, false, Date(), 1)
-        val s2 = Session.testInstance(100.0, true, Date(), 1)
+        Session.testInstance(100.0, true, Date(), 1)
         realm.commitTransaction()
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(SessionFilterable.TOURNAMENT)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions[0]?.run {
-            Assert.assertEquals(Session.Type.TOURNAMENT.ordinal, this.type)
+            Assert.assertEquals(Session.Type.TOURNAMENT.ordinal, (this as Session).type)
         }
     }
 
@@ -69,18 +68,18 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         b1.live = true
         b2.live = false
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Session.testInstance(100.0, false, Date(), 1, b1)
-        val s2 = Session.testInstance(100.0, true, Date(), 1, b2)
+        Session.testInstance(100.0, true, Date(), 1, b2)
         realm.commitTransaction()
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(SessionFilterable.LIVE)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
-        sessions[0]?.bankroll?.run {
+        (sessions[0] as Session).bankroll?.run {
             Assert.assertEquals(true, this.live)
         }
     }
@@ -95,18 +94,18 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         b1.live = false
         b2.live = true
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Session.testInstance(100.0, false, Date(), 1, b1)
-        val s2 = Session.testInstance(100.0, true, Date(), 1, b2)
+        Session.testInstance(100.0, true, Date(), 1, b2)
         realm.commitTransaction()
 
         val sessions = FilterManager().filter(
             realm,
             Session::class.java,
             arrayListOf(SessionFilterable.ONLINE)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
-        sessions[0]?.bankroll?.run {
+        (sessions[0] as Session).bankroll?.run {
             Assert.assertEquals(false, this.live)
         }
     }
@@ -139,7 +138,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        var filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.BLINDS
         filter.valueMap = mapOf("map" to arrayOf(mapOf(
             "sb" to 0.5,
             "bb" to 1.0,
@@ -150,11 +149,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             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))
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
         }
     }
 
@@ -186,7 +185,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        var filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.BLINDS
         filter.valueMap = mapOf("map" to arrayOf(mapOf(
             "sb" to null,
             "bb" to 1.0,
@@ -197,11 +196,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             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))
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
         }
     }
 
@@ -233,7 +232,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        var filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.BLINDS
         filter.valueMap = mapOf("map" to arrayOf(mapOf(
             "sb" to 1.0,
             "bb" to 2.0,
@@ -244,11 +243,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             realm,
             Session::class.java,
             arrayListOf(filter)
-        ) as RealmResults<Session>
+        )
 
         Assert.assertEquals(1, sessions.size)
         sessions.map {
-            Assert.assertEquals(s3.id, it.id)
+            Assert.assertEquals(s3.id, (it as Session).id)
         }
     }
 
@@ -280,7 +279,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        var filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.BLINDS
         filter.valueMap = mapOf("map" to arrayOf(
             mapOf(
             "sb" to 1.0,
@@ -297,11 +296,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             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))
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
         }
     }
 }

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

@@ -0,0 +1,76 @@
+package net.pokeranalytics.android.model.filter
+
+import io.realm.RealmQuery
+import net.pokeranalytics.android.model.filter.interfaces.Filterable
+import java.util.*
+
+enum class DateFilterable : Filterable {
+    STARTED_FROM_DATE,
+    STARTED_TO_DATE,
+    ENDED_FROM_DATE,
+    ENDED_TO_DATE,
+    DAY_OF_WEEK,
+    MONTH,
+    YEAR,
+    WEEK_DAY,
+    WEEK_END,
+    ;
+
+    private enum class Field(var fieldName:String) {
+        START_DATE("startDate"),
+        END_DATE("endDate"),
+        DAY("dayOfWeek"),
+        MONTH("month"),
+        YEAR("year"),
+    }
+
+    override var valueMap : Map<String, Any?>? = null
+
+    override val filterValuesExceptedKeys : Array<String>?
+        get() {
+            return when (this) {
+                STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date")
+                DAY_OF_WEEK -> arrayOf("dayOfWeek")
+                MONTH -> arrayOf("month")
+                YEAR -> arrayOf("year")
+                else -> null
+            }
+        }
+
+    override fun filter(realmQuery: RealmQuery<*>): RealmQuery<*> {
+        return when (this) {
+            STARTED_FROM_DATE -> {
+                val date : Date by filterValues
+                realmQuery.greaterThanOrEqualTo(Field.START_DATE.fieldName, date)
+            }
+            STARTED_TO_DATE -> {
+                val date : Date by filterValues
+                realmQuery.lessThanOrEqualTo(Field.START_DATE.fieldName, date)
+            }
+            ENDED_FROM_DATE -> {
+                val date : Date by filterValues
+                realmQuery.greaterThanOrEqualTo(Field.END_DATE.fieldName, date)
+            }
+            ENDED_TO_DATE -> {
+                val date : Date by filterValues
+                realmQuery.lessThanOrEqualTo(Field.END_DATE.fieldName, date)
+            }
+            DAY_OF_WEEK -> {
+                val dayOfWeek : Int by filterValues
+                realmQuery.equalTo(Field.DAY.fieldName, dayOfWeek)
+            }
+            MONTH -> {
+                val month: Int by filterValues
+                realmQuery.equalTo(Field.MONTH.fieldName, month)
+            }
+            YEAR -> {
+                val year: Int by filterValues
+                realmQuery.equalTo(Field.YEAR.fieldName, year)
+            }
+            WEEK_END -> {
+                realmQuery.`in`(Field.DAY.fieldName, arrayOf(Calendar.SATURDAY,Calendar.SUNDAY))
+            }
+            WEEK_DAY -> WEEK_END.filter(realmQuery.not())
+        }
+    }
+}

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

@@ -1,198 +1,5 @@
 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.time.DayOfWeek
-import java.util.*
-
-
 enum class FilterComponent {
 
 }
-
-interface TimeFilterable {
-
-    var dayOfWeek : Int?
-    var month : Int?
-    var year : Int?
-
-    fun updateTimeParameter(startDate:Date?) {
-        startDate?.let {
-            val cal = Calendar.getInstance()
-            cal.time = it
-            dayOfWeek = cal.get(Calendar.DAY_OF_WEEK)
-            month = cal.get(Calendar.MONTH)
-            year = cal.get(Calendar.YEAR)
-        }
-    }
-}
-
-enum class DateFilterable(var fieldName:String? = null) : Filterable {
-    STARTED_FROM_DATE,
-    STARTED_TO_DATE,
-    ENDED_FROM_DATE,
-    ENDED_TO_DATE,
-    DAY_OF_WEEK("dayOfWeek"),
-    MONTH("month"),
-    YEAR("year"),
-    WEEK_DAY,
-    WEEK_END,
-    ;
-
-    private enum class Field(var fieldName:String) {
-        START_DATE("startDate"),
-        END_DATE("endDate"),
-    }
-
-    override var valueMap : Map<String, Any?>? = null
-
-    override val filterValuesExceptedKeys : Array<String>?
-        get() {
-            return when (this) {
-                STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date")
-                DAY_OF_WEEK -> arrayOf("dayOfWeek")
-                MONTH -> arrayOf("month")
-                YEAR -> arrayOf("year")
-                else -> null
-            }
-        }
-
-    override fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject> {
-        return when (this) {
-            STARTED_FROM_DATE -> {
-                val date : Date by filterValues
-                realmQuery.greaterThanOrEqualTo(Field.START_DATE.fieldName, date)
-            }
-            STARTED_TO_DATE -> {
-                val date : Date by filterValues
-                realmQuery.lessThanOrEqualTo(Field.START_DATE.fieldName, date)
-            }
-            ENDED_FROM_DATE -> {
-                val date : Date by filterValues
-                realmQuery.greaterThanOrEqualTo(Field.END_DATE.fieldName, date)
-            }
-            ENDED_TO_DATE -> {
-                val date : Date by filterValues
-                realmQuery.lessThanOrEqualTo(Field.END_DATE.fieldName, date)
-            }
-            DAY_OF_WEEK -> {
-                val dayOfWeek : Int by filterValues
-                realmQuery.equalTo(this.fieldName, dayOfWeek)
-            }
-            MONTH -> {
-                val month: Int by filterValues
-                realmQuery.equalTo(this.fieldName, month)
-            }
-            YEAR -> {
-                val year: Int by filterValues
-                realmQuery.equalTo(this.fieldName, year)
-            }
-            WEEK_END -> {
-                realmQuery.equalTo(DAY_OF_WEEK.fieldName, Calendar.SATURDAY).or().equalTo(DAY_OF_WEEK.fieldName, Calendar.SUNDAY)
-            }
-            WEEK_DAY -> WEEK_END.filter(realmQuery.not())
-        } as RealmQuery<out RealmObject>
-    }
-}
-
-enum class SessionFilterable(var fieldName:String? = null) : Filterable {
-    LIVE("bankroll.live"),
-    CASH("type"),
-    ONLINE,
-    TOURNAMENT,
-    BANKROLL("bankroll.id"),
-    GAME("game.id"),
-    LIMIT("limit"),
-    TABLE_SIZE("tableSize"),
-    LOCATION("location.id"),
-    NUMBER_OF_TABLE("numberOfTable"),
-    COMMENT("comment"),
-    TOURNAMENT_TYPE("tournamentType"),
-    TOURNAMENT_NAME("tournamentName.id"),
-    TOURNAMENT_FEATURES("tournamentFeature.id"),
-    TOURNAMENT_NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
-    TOURNAMENT_ENTRY_FEE("tournamentEntryFee"),
-    RESULT_BUY_IN("result.buyin"),
-    RESULT_CASHED_OUT("result.cashout"),
-    RESULT_NET("result.ratedNet"),
-    RESULT_TIPS("result.tips"),
-    BLINDS,
-    ;
-
-    private enum class Field(var fieldName:String) {
-        START_DATE("startDate"),
-        END_DATE("endDate"),
-        CURRENCY("bankroll.currency"),
-        CURRENCY_CODE("bankroll.currency.code"),
-        BIG_BLIND("cgBigBlind"),
-        SMALL_BLIND("cgSmallBlind");
-    }
-
-    override var valueMap : Map<String, Any?>? = null
-
-    override val filterValuesExceptedKeys : Array<String>?
-        get() {
-            return when (this) {
-                BANKROLL -> arrayOf("ids")
-                BLINDS -> arrayOf("map")
-                else -> null
-            }
-        }
-
-    override fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject> {
-        return when (this) {
-            LIVE -> realmQuery.equalTo(this.fieldName, true)
-            CASH -> realmQuery.equalTo(this.fieldName, Session.Type.CASH_GAME.ordinal)
-            ONLINE -> LIVE.filter(realmQuery.not())
-            TOURNAMENT -> CASH.filter(realmQuery.not())
-            BANKROLL -> {
-                val ids : Array<String> by filterValues
-                realmQuery.`in`(this.fieldName, ids)
-            }
-            BLINDS -> {
-                val map : Array<Map<String,Any?>> by filterValues
-                var finalQuery = realmQuery
-                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 subMap
-                    val bb : Double? by subMap
-                    val code : String? by subMap
-
-                    finalQuery
-                        .beginGroup()
-
-                    sb?.let {
-                        finalQuery
-                            .equalTo(Field.SMALL_BLIND.fieldName, sb)
-                            .and()
-                    }
-
-                    finalQuery
-                        .equalTo(Field.BIG_BLIND.fieldName, bb)
-                        .and()
-
-                    code?.let {
-                        finalQuery.equalTo(Field.CURRENCY_CODE.fieldName, code)
-                    } ?: run {
-                        finalQuery.isNull(Field.CURRENCY_CODE.fieldName)
-                    }
-
-                    finalQuery.endGroup()
-
-                    if (index < map.size - 1) {
-                        finalQuery.or()
-                    }
-                }
-                finalQuery
-            }
-            else -> realmQuery
-        } as RealmQuery<out RealmObject>
-    }
-}

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

@@ -4,9 +4,7 @@ import io.realm.Realm
 import io.realm.RealmObject
 import io.realm.RealmQuery
 import io.realm.RealmResults
-import net.pokeranalytics.android.exceptions.FilterValueMapException
+import net.pokeranalytics.android.model.filter.interfaces.Filterable
-import net.pokeranalytics.android.model.LiveData
-import net.pokeranalytics.android.model.realm.*
 
 /**
  * We want to be able to store filters in the database:
@@ -34,45 +32,11 @@ import net.pokeranalytics.android.model.realm.*
  *
  */
 
-interface Filterable : ValueFilterable {
-    fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject>
-}
-
-interface ValueFilterable {
-
-    var valueMap: Map<String, Any?>?
-
-    var filterValues : Map<String, Any?>?
-        get() {
-            this.filterValuesExceptedKeys?.let { valueMapExceptedKeys ->
-                valueMap?.let { map ->
-                    var missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) }
-                    if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) {
-                        throw FilterValueMapException("valueMap does not contain ${missingKeys}")
-                    }
-                } ?: run {
-                    throw FilterValueMapException("valueMap null not expected")
-                }
-            }
-            return this.valueMap
-        }
-        set(value) {
-            valueMap = value
-        }
-
-    val filterValuesExceptedKeys : Array<String>?
-}
-
 class FilterManager {
-
-    fun test(realmResults: RealmResults<RealmObject>) {
-        realmResults.where().greaterThan("test", 5).findAll()
-    }
-
     fun filter(realm:Realm, relatedEntity: Class<out RealmObject>, queries:List<Filterable>): RealmResults<*> {
         var realmQuery = realm.where(relatedEntity)
         queries.forEach {
-            realmQuery = it.filter(realmQuery).and()
+            realmQuery = (it.filter(realmQuery) as RealmQuery<out RealmObject>).and()
         }
         return realmQuery.findAll()
     }

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

@@ -0,0 +1,108 @@
+package net.pokeranalytics.android.model.filter
+
+import io.realm.RealmQuery
+import net.pokeranalytics.android.exceptions.FilterValueMapException
+import net.pokeranalytics.android.model.filter.interfaces.Filterable
+import net.pokeranalytics.android.model.realm.Session
+
+enum class SessionFilterable: Filterable {
+    LIVE,
+    CASH,
+    ONLINE,
+    TOURNAMENT,
+    BANKROLL,
+    BLINDS,
+    ;
+
+    private enum class Field(var fieldName:String) {
+        LIVE("bankroll.live"),
+        CASH("type"),
+        BANKROLL("bankroll.id"),
+        START_DATE("startDate"),
+        END_DATE("endDate"),
+        CURRENCY("bankroll.currency"),
+        CURRENCY_CODE("bankroll.currency.code"),
+        BIG_BLIND("cgBigBlind"),
+        SMALL_BLIND("cgSmallBlind"),
+        GAME("game.id"),
+        LIMIT("limit"),
+        TABLE_SIZE("tableSize"),
+        LOCATION("location.id"),
+        NUMBER_OF_TABLE("numberOfTable"),
+        COMMENT("comment"),
+        TOURNAMENT_TYPE("tournamentType"),
+        TOURNAMENT_NAME("tournamentName.id"),
+        TOURNAMENT_FEATURES("tournamentFeature.id"),
+        TOURNAMENT_NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
+        TOURNAMENT_ENTRY_FEE("tournamentEntryFee"),
+        RESULT_BUY_IN("result.buyin"),
+        RESULT_CASHED_OUT("result.cashout"),
+        RESULT_NET("result.ratedNet"),
+        RESULT_TIPS("result.tips"),
+        ;
+    }
+
+    override var valueMap : Map<String, Any?>? = null
+
+    override val filterValuesExceptedKeys : Array<String>?
+        get() {
+            return when (this) {
+                BANKROLL -> arrayOf("ids")
+                BLINDS -> arrayOf("map")
+                else -> null
+            }
+        }
+
+    override fun filter(realmQuery: RealmQuery<*>): RealmQuery<*> {
+        return when (this) {
+            LIVE -> realmQuery.equalTo(Field.LIVE.fieldName, true)
+            CASH -> realmQuery.equalTo(Field.CASH.fieldName, Session.Type.CASH_GAME.ordinal)
+            ONLINE -> LIVE.filter(realmQuery.not())
+            TOURNAMENT -> CASH.filter(realmQuery.not())
+            BANKROLL -> {
+                val ids : Array<String> by filterValues
+                realmQuery.`in`(Field.BANKROLL.fieldName, ids)
+            }
+            BLINDS -> {
+                val map : Array<Map<String,Any?>> by filterValues
+                val expectedSubKeys = arrayOf("sb", "bb", "code")
+                map.forEachIndexed { index, subMap ->
+                    val 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 subMap
+                    val bb : Double? by subMap
+                    val code : String? by subMap
+
+                    realmQuery
+                        .beginGroup()
+
+                    sb?.let {
+                        realmQuery
+                            .equalTo(Field.SMALL_BLIND.fieldName, sb)
+                            .and()
+                    }
+
+                    realmQuery
+                        .equalTo(Field.BIG_BLIND.fieldName, bb)
+                        .and()
+
+                    code?.let {
+                        realmQuery.equalTo(Field.CURRENCY_CODE.fieldName, code)
+                    } ?: run {
+                        realmQuery.isNull(Field.CURRENCY_CODE.fieldName)
+                    }
+
+                    realmQuery.endGroup()
+
+                    if (index < map.size - 1) {
+                        realmQuery.or()
+                    }
+                }
+                realmQuery
+            }
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+package net.pokeranalytics.android.model.filter.interfaces
+
+import io.realm.RealmQuery
+
+interface Filterable : ValueFilterable {
+    fun filter(realmQuery: RealmQuery<*>): RealmQuery<*>
+}

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

@@ -0,0 +1,20 @@
+package net.pokeranalytics.android.model.filter.interfaces
+
+import java.util.*
+
+interface TimeFilterable {
+
+    var dayOfWeek : Int?
+    var month : Int?
+    var year : Int?
+
+    fun updateTimeParameter(startDate: Date?) {
+        startDate?.let {
+            val cal = Calendar.getInstance()
+            cal.time = it
+            dayOfWeek = cal.get(Calendar.DAY_OF_WEEK)
+            month = cal.get(Calendar.MONTH)
+            year = cal.get(Calendar.YEAR)
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+package net.pokeranalytics.android.model.filter.interfaces
+
+import net.pokeranalytics.android.exceptions.FilterValueMapException
+
+interface ValueFilterable {
+
+    var valueMap: Map<String, Any?>?
+
+    var filterValues : Map<String, Any?>?
+        get() {
+            this.filterValuesExceptedKeys?.let { valueMapExceptedKeys ->
+                valueMap?.let { map ->
+                    var missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) }
+                    if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) {
+                        throw FilterValueMapException("valueMap does not contain ${missingKeys}")
+                    }
+                } ?: run {
+                    throw FilterValueMapException("valueMap null not expected")
+                }
+            }
+            return this.valueMap
+        }
+        set(value) {
+            valueMap = value
+        }
+
+    val filterValuesExceptedKeys : Array<String>?
+}

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

@@ -17,7 +17,7 @@ import net.pokeranalytics.android.model.TableSize
 import net.pokeranalytics.android.model.TournamentType
 import net.pokeranalytics.android.model.extensions.SessionState
 import net.pokeranalytics.android.model.extensions.getState
-import net.pokeranalytics.android.model.filter.TimeFilterable
+import net.pokeranalytics.android.model.filter.interfaces.TimeFilterable
 import net.pokeranalytics.android.model.interfaces.Manageable
 import net.pokeranalytics.android.model.interfaces.Timed
 import net.pokeranalytics.android.model.utils.SessionSetManager
@@ -36,7 +36,8 @@ import java.util.*
 import java.util.Currency
 import kotlin.collections.ArrayList
 
-open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource, RowRepresentable, Timed, TimeFilterable {
+open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource, RowRepresentable, Timed,
+	TimeFilterable {
 
 	enum class Type {
 		CASH_GAME,

app/src/main/java/net/pokeranalytics/android/ui/fragment/HistoryFragment.kt

@@ -5,7 +5,6 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.core.view.isVisible
-import androidx.lifecycle.LiveData
 import androidx.recyclerview.widget.DiffUtil
 import io.realm.RealmResults
 import io.realm.Sort
@@ -14,11 +13,7 @@ import kotlinx.android.synthetic.main.fragment_history.*
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import net.pokeranalytics.android.R
-import net.pokeranalytics.android.model.filter.FilterManager
-import net.pokeranalytics.android.model.filter.Filterable
-import net.pokeranalytics.android.model.filter.SessionFilterable
 import net.pokeranalytics.android.model.interfaces.Manageable
-import net.pokeranalytics.android.model.realm.Bankroll
 import net.pokeranalytics.android.model.realm.Session
 import net.pokeranalytics.android.ui.activity.SessionActivity
 import net.pokeranalytics.android.ui.adapter.LiveRowRepresentableDataSource
@@ -97,20 +92,6 @@ class HistoryFragment : PokerAnalyticsFragment(), LiveRowRepresentableDataSource
 	 * Init data
 	 */
 	private fun initData() {
-
-/*
-		var brs = (net.pokeranalytics.android.model.LiveData.BANKROLL.items(getRealm()) as RealmResults<Bankroll>).toArray().map{
-			(it as Bankroll).id
-		}
-
-		var br = SessionFilterable.BANKROLL
-		br.valueMap = mapOf("ids" to arrayOf(brs.last()))
-
-		realmSessions = FilterManager().filter(getRealm(), Session::class.java, arrayListOf<Filterable>(br))
-			.sort("creationDate", Sort.DESCENDING) as RealmResults<Session>
-
-//		realmSessions = FilterManager().filter(getRealm(), Session::class.java, arrayListOf<Filterable>(SessionFilterable.ONLINE, SessionFilterable.CASH)).sort("creationDate", Sort.DESCENDING) as RealmResults<Session>
-*/
 		realmSessions = getRealm().where<Session>().findAll().sort("creationDate", Sort.DESCENDING)
 
 		val viewManager = SmoothScrollLinearLayoutManager(requireContext())