Merge branch 'master' of gitlab.com:stax-river/poker-analytics

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,274 @@
+package net.pokeranalytics.android.filter
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+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
+        Session.testInstance(100.0, true, cal.time)
+        realm.commitTransaction()
+
+        val 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)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s1.id, (this as Session).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)
+        
+        Session.testInstance(100.0, true, cal.time)
+        realm.commitTransaction()
+
+        val 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)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s1.id, (this as Session).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)
+        
+        Session.testInstance(100.0, true, cal.time)
+        realm.commitTransaction()
+
+        val 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)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s1.id, (this as Session).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)
+        
+        Session.testInstance(100.0, true, cal.time)
+        realm.commitTransaction()
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(DateFilterable.WEEK_END)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s1.id, (this as Session).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)
+        
+        Session.testInstance(100.0, true, cal.time)
+        realm.commitTransaction()
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(DateFilterable.WEEK_DAY)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s1.id, (this as Session).id)
+        }
+    }
+
+    @Test
+    fun testStartedFomDateFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        
+        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()
+
+        val filter = DateFilterable.STARTED_FROM_DATE
+        filter.valueMap = mapOf("date" to s2.startDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s2.id, (this as Session).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
+        Session.testInstance(100.0, true, cal.time, 1)
+
+        realm.commitTransaction()
+
+        val filter = DateFilterable.STARTED_TO_DATE
+        filter.valueMap = mapOf("date" to s1.startDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s1.id, (this as Session).id)
+        }
+    }
+
+    @Test
+    fun testEndedFomDateFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val cal = Calendar.getInstance() // creates calendar
+        cal.time = Date() // sets calendar time/date
+        
+        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()
+
+        val filter = DateFilterable.ENDED_FROM_DATE
+        filter.valueMap = mapOf("date" to s2.endDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s2.id, (this as Session).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
+        
+        Session.testInstance(100.0, true, cal.time, 1)
+        realm.commitTransaction()
+
+
+        val filter = DateFilterable.ENDED_TO_DATE
+        filter.valueMap = mapOf("date" to s1.endDate)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions[0]?.run {
+            Assert.assertEquals(s1.id, (this as Session).id)
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+package net.pokeranalytics.android.filter
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+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
+         FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(SessionFilterable.BLINDS)
+        )
+    }
+
+    @Test(expected = FilterValueMapException::class)
+    fun testValueKeyFilterException() {
+        val filter = DateFilterable.STARTED_FROM_DATE
+        filter.valueMap = mapOf("bob" to Date())
+
+        val realm = this.mockRealm
+        FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+    }
+
+    @Test(expected = FilterValueMapException::class)
+    fun testSubValueKeyFilterException() {
+        val 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
+        FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+    }
+}

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

@@ -1,8 +1,6 @@
-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 +11,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() {
@@ -73,19 +19,19 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         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)
         }
     }
 
@@ -95,19 +41,19 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         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)
         }
     }
 
@@ -122,18 +68,18 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         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)
         }
     }
@@ -148,141 +94,22 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         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)
         }
     }
 
-    @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() {
 
@@ -311,7 +138,7 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         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,
@@ -322,11 +149,11 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
             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))
         }
     }
 
@@ -358,7 +185,7 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        var filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.BLINDS
         filter.valueMap = mapOf("map" to arrayOf(mapOf(
             "sb" to null,
             "bb" to 1.0,
@@ -369,11 +196,11 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
             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))
         }
     }
 
@@ -405,7 +232,7 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         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,
@@ -416,11 +243,11 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
             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)
         }
     }
 
@@ -452,7 +279,7 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        var filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.BLINDS
         filter.valueMap = mapOf("map" to arrayOf(
             mapOf(
             "sb" to 1.0,
@@ -469,11 +296,11 @@ class FilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
             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,77 @@
+package net.pokeranalytics.android.model.filter
+
+import io.realm.RealmObject
+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<out RealmObject>): 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(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,154 +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.util.*
-
-
 enum class FilterComponent {
 
-}
-
-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"),
-    NUMBEROFTABLE("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_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,
-    ;
-
-    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");
-    }
-
-    private var _valueMap: Map<String, Any?>? = null
-    var valueMap : Map<String, Any?>?
-        get() {
-            this.valueMapExceptedKeys?.let { valueMapExceptedKeys ->
-                _valueMap?.let { map ->
-                    println("valueMapExceptedKeys $valueMapExceptedKeys")
-                    println("map.keys $map.keys")
-                    var missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) }
-                    println("missingKeys $missingKeys")
-                    if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) {
-                        throw FilterValueMapException("valueMap does not contain ${missingKeys}")
-                    }
-                } ?: run {
-                    throw FilterValueMapException("valueMap null not expected")
-                }
-            }
-            return _valueMap
-        }
-        set(value) {
-            _valueMap = value
-        }
-
-    private val valueMapExceptedKeys : Array<String>?
-        get() {
-            return when (this) {
-                BANKROLL -> arrayOf("ids")
-                STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date")
-                BLINDS -> arrayOf("map")
-                else -> null
-            }
-        }
-
-    override fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject> {
-        return when (this) {
-            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 valueMap
-                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
-                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,8 +4,7 @@ import io.realm.Realm
 import io.realm.RealmObject
 import io.realm.RealmQuery
 import io.realm.RealmResults
-import net.pokeranalytics.android.model.LiveData
+import net.pokeranalytics.android.model.filter.interfaces.Filterable
-import net.pokeranalytics.android.model.realm.*
 
 /**
  * We want to be able to store filters in the database:
@@ -33,20 +32,11 @@ import net.pokeranalytics.android.model.realm.*
  *
  */
 
-interface Filterable {
-    fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject>
-}
-
 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)
+        var realmQuery : RealmQuery<out RealmObject> = realm.where(relatedEntity)
         queries.forEach {
-            realmQuery = it.filter(realmQuery).and()
+            realmQuery = (it.filter(realmQuery)).and()
         }
         return realmQuery.findAll()
     }

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

@@ -0,0 +1,109 @@
+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.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<out RealmObject>): RealmQuery<out RealmObject> {
+        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,8 @@
+package net.pokeranalytics.android.model.filter.interfaces
+
+import io.realm.RealmObject
+import io.realm.RealmQuery
+
+interface Filterable : ValueFilterable {
+    fun filter(realmQuery: RealmQuery<out RealmObject>): RealmQuery<out RealmObject>
+}

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/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.interfaces.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,8 @@ 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 +71,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

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())