add new filters

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

@@ -0,0 +1,27 @@
+package net.pokeranalytics.android.filter
+
+import net.pokeranalytics.android.RealmInstrumentedUnitTest
+import net.pokeranalytics.android.model.realm.Bankroll
+import net.pokeranalytics.android.model.realm.Session
+import java.util.*
+
+open class BaseFilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
+
+    // convenience extension
+    fun Session.Companion.testInstance(
+        netResult: Double,
+        isTournament: Boolean,
+        startDate: Date,
+        endDate: Int = 1,
+        bankroll: Bankroll? = null
+    ): Session {
+        val session: Session = Session.newInstance(super.mockRealm, isTournament, bankroll)
+        session.result?.netResult = netResult
+        session.startDate = startDate
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = startDate // sets calendar time/date
+        cal.add(Calendar.HOUR_OF_DAY, endDate) // adds one hour
+        session.endDate = cal.time // returns new date object, one hour in the future
+        return session
+    }
+}

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

@@ -0,0 +1,268 @@
+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
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.*
+
+@RunWith(AndroidJUnit4::class)
+class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
+
+    @Test
+    fun testDayOfWeekFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val cal = Calendar.getInstance() // creates calendar
+        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)
+        realm.commitTransaction()
+
+        var filter = DateFilterable.DAY_OF_WEEK
+        cal.time = s1.startDate
+        filter.valueMap = mapOf("dayOfWeek" to cal.get(Calendar.DAY_OF_WEEK))
+
+        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)
+        }
+    }
+
+    @Test
+    fun testMonthFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val cal = Calendar.getInstance()
+        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)
+        realm.commitTransaction()
+
+        var filter = DateFilterable.MONTH
+        cal.time = s1.startDate
+        filter.valueMap = mapOf("month" to cal.get(Calendar.MONTH))
+
+        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)
+        }
+    }
+
+    @Test
+    fun testYearFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val cal = Calendar.getInstance()
+        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)
+        realm.commitTransaction()
+
+        var filter = DateFilterable.YEAR
+        cal.time = s1.startDate
+        filter.valueMap = mapOf("year" to cal.get(Calendar.YEAR))
+
+        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)
+        }
+    }
+
+
+    @Test
+    fun testWeekEndFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val cal = Calendar.getInstance()
+        cal.time = Date()
+        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)
+        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)
+        }
+    }
+
+    @Test
+    fun testWeekDayFilter() {
+
+        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)
+        val s2 = 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)
+        }
+    }
+
+    @Test
+    fun testStartedFomDateFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        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)
+        realm.commitTransaction()
+
+        var 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)
+        }
+    }
+
+    @Test
+    fun testStartedToDateFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        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)
+
+        realm.commitTransaction()
+
+        var 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)
+        }
+    }
+
+    @Test
+    fun testEndedFomDateFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        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)
+
+        realm.commitTransaction()
+
+        var 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)
+        }
+    }
+
+    @Test
+    fun testEndedToDateFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        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)
+        realm.commitTransaction()
+
+
+        var 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)
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+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
+import net.pokeranalytics.android.model.filter.SessionFilterable
+import net.pokeranalytics.android.model.realm.Session
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.*
+
+@RunWith(AndroidJUnit4::class)
+class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
+
+    @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 = DateFilterable.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>
+    }
+}

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

@@ -1,8 +1,7 @@
-package net.pokeranalytics.android
+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.FilterManager
 import net.pokeranalytics.android.model.filter.SessionFilterable
 import net.pokeranalytics.android.model.realm.Bankroll
@@ -13,59 +12,7 @@ import org.junit.runner.RunWith
 import java.util.*
 
 @RunWith(AndroidJUnit4::class)
-class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
+class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
-
-    // convenience extension
-    fun Session.Companion.testInstance(netResult: Double, isTournament: Boolean, startDate: Date, endDate: Int, bankroll:Bankroll? = null): Session {
-        val session: Session = Session.newInstance(super.mockRealm, isTournament, bankroll)
-        session.result?.netResult = netResult
-        session.startDate = startDate
-        val cal = Calendar.getInstance() // creates calendar
-        cal.time = startDate // sets calendar time/date
-        cal.add(Calendar.HOUR_OF_DAY, endDate) // adds one hour
-        session.endDate = cal.time // returns new date object, one hour in the future
-        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() {
@@ -164,125 +111,6 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         }
     }
 
-    @Test
-    fun testStartedFomDateFilter() {
-
-        val realm = this.mockRealm
-        realm.beginTransaction()
-
-        val cal = Calendar.getInstance() // creates calendar
-        cal.time = Date() // sets calendar time/date
-        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)
-        realm.commitTransaction()
-
-        var filter = SessionFilterable.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)
-        }
-    }
-
-    @Test
-    fun testStartedToDateFilter() {
-
-        val realm = this.mockRealm
-        realm.beginTransaction()
-
-        val cal = Calendar.getInstance() // creates calendar
-        cal.time = Date() // sets calendar time/date
-        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)
-
-        realm.commitTransaction()
-
-        var filter = SessionFilterable.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)
-        }
-    }
-
-    @Test
-    fun testEndedFomDateFilter() {
-
-        val realm = this.mockRealm
-        realm.beginTransaction()
-
-        val cal = Calendar.getInstance() // creates calendar
-        cal.time = Date() // sets calendar time/date
-        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)
-
-        realm.commitTransaction()
-
-        var filter = SessionFilterable.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)
-        }
-    }
-
-    @Test
-    fun testEndedToDateFilter() {
-
-        val realm = this.mockRealm
-        realm.beginTransaction()
-
-        val cal = Calendar.getInstance() // creates calendar
-        cal.time = Date() // sets calendar time/date
-        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)
-        realm.commitTransaction()
-
-
-        var filter = SessionFilterable.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)
-        }
-    }
-
     @Test
     fun testSingleBlindNoCurrencyFilter() {
 

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

@@ -4,6 +4,7 @@ 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.*
 
 
@@ -11,6 +12,91 @@ 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"),
@@ -21,21 +107,17 @@ enum class SessionFilterable(var fieldName:String? = null) : Filterable {
     LIMIT("limit"),
     TABLE_SIZE("tableSize"),
     LOCATION("location.id"),
-    NUMBEROFTABLE("numberOfTable"),
+    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_BUYIN("result.buyin"),
+    RESULT_BUY_IN("result.buyin"),
     RESULT_CASHED_OUT("result.cashout"),
     RESULT_NET("result.ratedNet"),
     RESULT_TIPS("result.tips"),
-    STARTED_FROM_DATE,
-    STARTED_TO_DATE,
-    ENDED_FROM_DATE,
-    ENDED_TO_DATE,
     BLINDS,
     ;
 
@@ -48,33 +130,12 @@ enum class SessionFilterable(var fieldName:String? = null) : Filterable {
         SMALL_BLIND("cgSmallBlind");
     }
 
-    private var _valueMap: Map<String, Any?>? = null
+    override 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>?
+    override val filterValuesExceptedKeys : 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
             }
@@ -87,28 +148,11 @@ enum class SessionFilterable(var fieldName:String? = null) : Filterable {
             ONLINE -> LIVE.filter(realmQuery.not())
             TOURNAMENT -> CASH.filter(realmQuery.not())
             BANKROLL -> {
-                val ids : Array<String> by valueMap
+                val ids : Array<String> by filterValues
                 realmQuery.`in`(this.fieldName, ids)
             }
-            STARTED_FROM_DATE -> {
-                val date : Date by valueMap
-                realmQuery.greaterThanOrEqualTo(Field.START_DATE.fieldName, date)
-            }
-            STARTED_TO_DATE -> {
-                val date : Date by valueMap
-                realmQuery.lessThanOrEqualTo(Field.START_DATE.fieldName, date)
-            }
-            ENDED_FROM_DATE -> {
-                val date : Date by valueMap
-                realmQuery.greaterThanOrEqualTo(Field.END_DATE.fieldName, date)
-            }
-            ENDED_TO_DATE -> {
-                val date : Date by valueMap
-                realmQuery.lessThanOrEqualTo(Field.END_DATE.fieldName, date)
-            }
-
             BLINDS -> {
-                val map : Array<Map<String,Any?>> by valueMap
+                val map : Array<Map<String,Any?>> by filterValues
                 var finalQuery = realmQuery
                 val expectedSubKeys = arrayOf("sb", "bb", "code") as Array<String>
                 map.forEachIndexed { index, subMap ->

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

@@ -4,6 +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.LiveData
 import net.pokeranalytics.android.model.realm.*
 
@@ -33,10 +34,35 @@ import net.pokeranalytics.android.model.realm.*
  *
  */
 
-interface Filterable {
+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>) {

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

@@ -14,7 +14,6 @@ interface Timed {
 
     var netDuration: Long
 
-
     /**
      * Computes the net netDuration of the session
      */

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

@@ -17,6 +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.interfaces.Manageable
 import net.pokeranalytics.android.model.interfaces.Timed
 import net.pokeranalytics.android.model.utils.SessionSetManager
@@ -35,7 +36,7 @@ import java.util.*
 import java.util.Currency
 import kotlin.collections.ArrayList
 
-open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource, RowRepresentable, Timed {
+open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource, RowRepresentable, Timed, TimeFilterable {
 
 	enum class Type {
 		CASH_GAME,
@@ -69,12 +70,18 @@ open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource
 
 	// Timed interface
 
+	override var dayOfWeek : Int? = null
+	override var month: Int? = null
+	override var year: Int? = null
+
 	/**
 	 * The start date of the session
 	 */
 	var startDate: Date? = null
 		set(value) {
 			field = value
+
+			this.updateTimeParameter(field)
 			this.computeNetDuration()
 			this.computeStats()
 			// nullifies endate when setting the start date after the end date