diff --git a/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt
index 45faaaef..b5be8a04 100644
--- a/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt
+++ b/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt
@@ -32,16 +32,14 @@ open class RealmInstrumentedUnitTest {
         val testConfig = RealmConfiguration.Builder().inMemory().name("test-realm").build()
         Realm.setDefaultConfiguration(testConfig)
         this.mockRealm = Realm.getDefaultInstance()
-
-        this.mockRealm.executeTransaction {
-            this.mockRealm.deleteAll()
-        }
-
+        this.mockRealm.beginTransaction()
+        this.mockRealm.deleteAll()
+        this.mockRealm.commitTransaction()
     }
 
     @After
     @Throws(Exception::class)
-    public fun tearDown() {
+    fun tearDown() {
         this.mockRealm.close()
     }
 
diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt
index a3ffd4a9..91ec0cb2 100644
--- a/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt
+++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt
@@ -1,9 +1,9 @@
 package net.pokeranalytics.android.filter
 
-import net.pokeranalytics.android.model.filter.FilterManager
-import net.pokeranalytics.android.model.filter.SessionFilterable
-import net.pokeranalytics.android.model.realm.Bankroll
-import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.model.filter.QueryType
+import net.pokeranalytics.android.model.realm.*
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import org.junit.Assert
 import org.junit.Test
 import java.util.*
@@ -37,16 +37,15 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        val filter = SessionFilterable.BLINDS
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
-            "sb" to 0.5,
-            "bb" to 1.0,
-            "code" to null
-        )))
+        val filter = QueryType.BLINDS
+        val blind = FilterElementRow.Blind(0.5, 1.0, null)
+        blind.filterSectionRow = FilterSectionRow.BLINDS
+        val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
+        filter.updateValueMap(filterElement)
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -84,16 +83,16 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        val filter = SessionFilterable.BLINDS
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
-            "sb" to null,
-            "bb" to 1.0,
-            "code" to null
-        )))
+        val filter = QueryType.BLINDS
+        val blind = FilterElementRow.Blind(null, 1.0, null)
+        blind.filterSectionRow = FilterSectionRow.BLINDS
 
-        val sessions = FilterManager().filter(
+        val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
+        filter.updateValueMap(filterElement)
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -131,16 +130,16 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        val filter = SessionFilterable.BLINDS
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
-            "sb" to 1.0,
-            "bb" to 2.0,
-            "code" to "AUD"
-        )))
+        val filter = QueryType.BLINDS
+        val blind = FilterElementRow.Blind(1.0, 2.0, "AUD")
+        blind.filterSectionRow = FilterSectionRow.BLINDS
+
+        val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
+        filter.updateValueMap(filterElement)
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -178,22 +177,18 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        val filter = SessionFilterable.BLINDS
-        filter.valueMap = mapOf("map" to arrayOf(
-            mapOf(
-                "sb" to 1.0,
-                "bb" to 2.0,
-                "code" to null
-            ),
-            mapOf(
-                "sb" to 0.5,
-                "bb" to 1.0,
-                "code" to null
-            )))
-
-        val sessions = FilterManager().filter(
+        val filter = QueryType.BLINDS
+        val blind1 = FilterElementRow.Blind(1.0, 2.0, null)
+        blind1.filterSectionRow = FilterSectionRow.BLINDS
+
+        val blind2 = FilterElementRow.Blind(0.5, 1.0, null)
+        blind2.filterSectionRow = FilterSectionRow.BLINDS
+        val filterElement = FilterElement(filterElementRows = arrayListOf(blind1, blind2))
+        filter.updateValueMap(filterElement)
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt
index 700856ab..3f506258 100644
--- a/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt
+++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt
@@ -1,9 +1,13 @@
 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 io.realm.RealmList
+import net.pokeranalytics.android.model.filter.QueryType
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.model.realm.FilterElement
 import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -25,13 +29,17 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
 
-        val filter = DateFilterable.DAY_OF_WEEK
+        val filter = QueryType.DAY_OF_WEEK
         cal.time = s1.startDate
-        filter.valueMap = mapOf("dayOfWeek" to cal.get(Calendar.DAY_OF_WEEK))
 
-        val sessions = FilterManager().filter(
+        val filterElementRow = FilterElementRow.Day(cal.get(Calendar.DAY_OF_WEEK))
+        filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
+        val filterElement = FilterElement(filterElementRow)
+        filter.updateValueMap(filterElement)
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -54,13 +62,17 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
 
-        val filter = DateFilterable.MONTH
+        val filter = QueryType.MONTH
         cal.time = s1.startDate
-        filter.valueMap = mapOf("month" to cal.get(Calendar.MONTH))
 
-        val sessions = FilterManager().filter(
+        val filterElementRow = FilterElementRow.Month(cal.get(Calendar.MONTH))
+        filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
+        val filterElement = FilterElement(filterElementRow)
+        filter.updateValueMap(filterElement)
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -83,13 +95,16 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
 
-        val filter = DateFilterable.YEAR
+        val filter = QueryType.YEAR
         cal.time = s1.startDate
-        filter.valueMap = mapOf("year" to cal.get(Calendar.YEAR))
+        val filterElementRow = FilterElementRow.Year(cal.get(Calendar.YEAR))
+        filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
+        val filterElement = FilterElement(filterElementRow)
+        filter.updateValueMap(filterElement)
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -113,10 +128,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         
         Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
-            arrayListOf(DateFilterable.WEEK_END)
+            Session,
+            arrayListOf(QueryType.WEEK_END)
         )
 
         Assert.assertEquals(1, sessions.size)
@@ -138,10 +153,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         
         Session.testInstance(100.0, true, cal.time)
         realm.commitTransaction()
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
-            arrayListOf(DateFilterable.WEEK_DAY)
+            Session,
+            arrayListOf(QueryType.WEEK_DAY)
         )
 
         Assert.assertEquals(1, sessions.size)
@@ -165,12 +180,15 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         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 filter = QueryType.STARTED_FROM_DATE
+        val filterElementRow = FilterElementRow.From(s2.startDate!!)
+        filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
+        filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = FilterManager().filter(
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -195,12 +213,14 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         realm.commitTransaction()
 
-        val filter = DateFilterable.STARTED_TO_DATE
-        filter.valueMap = mapOf("date" to s1.startDate)
+        val filter = QueryType.STARTED_TO_DATE
+        val filterElementRow = FilterElementRow.From(s1.startDate!!)
+        filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
+        filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -226,12 +246,14 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         realm.commitTransaction()
 
-        val filter = DateFilterable.ENDED_FROM_DATE
-        filter.valueMap = mapOf("date" to s2.endDate)
+        val filter = QueryType.ENDED_FROM_DATE
+        val filterElementRow = FilterElementRow.From(s2.endDate())
+        filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
+        filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -257,12 +279,15 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        val filter = DateFilterable.ENDED_TO_DATE
-        filter.valueMap = mapOf("date" to s1.endDate)
+        val filter = QueryType.ENDED_TO_DATE
+        val filterElementRow = FilterElementRow.From(s1.endDate())
+        filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
+        filter.updateValueMap(FilterElement(filterElementRow))
+
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt
index bc453c26..b484a920 100644
--- a/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt
+++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt
@@ -1,11 +1,14 @@
 package net.pokeranalytics.android.filter
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.realm.RealmList
 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.filter.QueryType
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.model.realm.FilterElement
 import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import org.junit.Test
 import org.junit.runner.RunWith
 import java.util.*
@@ -13,42 +16,28 @@ 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 filter = QueryType.STARTED_FROM_DATE
+        val filterElement = FilterElement()
+        filter.updateValueMap(filterElement)
 
         val realm = this.mockRealm
-        FilterManager().filter(
+        Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             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
-        )))
-
+    fun testFilterException() {
         val realm = this.mockRealm
-        FilterManager().filter(
+        val filter = QueryType.BLINDS
+        filter.updateValueMap(FilterElement())
+        Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
     }
diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt
new file mode 100644
index 00000000..107433a3
--- /dev/null
+++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt
@@ -0,0 +1,64 @@
+package net.pokeranalytics.android.filter
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import net.pokeranalytics.android.model.filter.QueryType
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.*
+
+@RunWith(AndroidJUnit4::class)
+class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
+
+    @Test
+    fun testSaveLoadCashFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val filter = Filter()
+        filter.name = "testSaveLoadCashFilter"
+
+        val filterElement = FilterElementRow.Cash
+        filterElement.filterSectionRow = FilterSectionRow.CASH_TOURNAMENT
+        filter.createOrUpdateFilterElements(arrayListOf(filterElement))
+
+        val useCount = filter.countBy(FilterCategoryRow.GENERAL)
+        Assert.assertEquals(1, useCount)
+
+        val isCash = filter.contains(filterElement)
+        Assert.assertEquals(true, isCash)
+
+        val filterComponent = filter.filterElements.first()
+
+        filterComponent?.let {
+            Assert.assertEquals(QueryType.CASH, QueryType.valueOf(it.filterName))
+        } ?: run {
+            Assert.fail()
+        }
+
+        Session.testInstance(100.0, false, Date(), 1)
+        Session.testInstance(100.0, true, Date(), 1)
+
+        realm.copyToRealm(filter)
+        realm.commitTransaction()
+
+        val newRealm = this.mockRealm
+        newRealm.where(Filter::class.java).equalTo("name", "testSaveLoadCashFilter").findFirst()?.let { foundFilter ->
+            val sessions = foundFilter.queryOn(Session)
+
+            Assert.assertEquals(1, sessions.size)
+            sessions[0]?.run {
+                Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type)
+            } ?: run {
+                Assert.fail()
+            }
+        } ?: run {
+            Assert.fail()
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
index e2112c36..0c125b6c 100644
--- a/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
+++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
@@ -2,9 +2,11 @@ package net.pokeranalytics.android.filter
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.realm.RealmList
-import net.pokeranalytics.android.model.filter.FilterManager
-import net.pokeranalytics.android.model.filter.SessionFilterable
+import net.pokeranalytics.android.model.TableSize
+import net.pokeranalytics.android.model.filter.QueryType
 import net.pokeranalytics.android.model.realm.*
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -23,10 +25,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1)
         realm.commitTransaction()
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
-            arrayListOf(SessionFilterable.CASH)
+            Session,
+            arrayListOf(QueryType.CASH)
         )
 
         Assert.assertEquals(1, sessions.size)
@@ -45,10 +47,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1)
         realm.commitTransaction()
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
-            arrayListOf(SessionFilterable.TOURNAMENT)
+            Session,
+            arrayListOf(QueryType.TOURNAMENT)
         )
 
         Assert.assertEquals(1, sessions.size)
@@ -72,10 +74,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1, b2)
         realm.commitTransaction()
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
-            arrayListOf(SessionFilterable.LIVE)
+            Session,
+            arrayListOf(QueryType.LIVE)
         )
 
         Assert.assertEquals(1, sessions.size)
@@ -98,10 +100,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(100.0, true, Date(), 1, b2)
         realm.commitTransaction()
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
-            arrayListOf(SessionFilterable.ONLINE)
+            Session,
+            arrayListOf(QueryType.ONLINE)
         )
 
         Assert.assertEquals(1, sessions.size)
@@ -122,12 +124,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(bankroll = b2)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.BANKROLL
-        filter.valueMap = mapOf("ids" to arrayOf(b1.id))
+        val filter = QueryType.BANKROLL
+        val filterElementRow = FilterElementRow.Bankroll(b1)
+        filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -155,12 +159,17 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(bankroll = b3)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.BANKROLL
-        filter.valueMap = mapOf("ids" to arrayOf(b1.id, b2.id))
+        val filter = QueryType.BANKROLL
+        val filterElementRow = FilterElementRow.Bankroll(b1)
+        filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
 
-        val sessions = FilterManager().filter(
+        val filterElementRow2 = FilterElementRow.Bankroll(b2)
+        filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -183,12 +192,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(game = g2)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.GAME
-        filter.valueMap = mapOf("ids" to arrayOf(g2.id))
+        val filter = QueryType.GAME
+        val filterElementRow = FilterElementRow.Game(g2)
+        filterElementRow.filterSectionRow = FilterSectionRow.GAME
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -216,12 +227,17 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(game = g3)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.GAME
-        filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id))
+        val filter = QueryType.GAME
+
+        val filterElementRow = FilterElementRow.Game(g2)
+        filterElementRow.filterSectionRow = FilterSectionRow.GAME
+        val filterElementRow2 = FilterElementRow.Game(g3)
+        filterElementRow2.filterSectionRow = FilterSectionRow.GAME
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -244,12 +260,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(location = l2)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.LOCATION
-        filter.valueMap = mapOf("ids" to arrayOf(l1.id))
+        val filter = QueryType.LOCATION
+        val filterElementRow = FilterElementRow.Location(l1)
+        filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -277,12 +295,18 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(location = l3)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.LOCATION
-        filter.valueMap = mapOf("ids" to arrayOf(l1.id, l3.id))
+        val filter = QueryType.LOCATION
+
+        val filterElementRow = FilterElementRow.Location(l1)
+        filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
+        val filterElementRow2 = FilterElementRow.Location(l3)
+        filterElementRow2.filterSectionRow = FilterSectionRow.LOCATION
 
-        val sessions = FilterManager().filter(
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -305,12 +329,15 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(tournamentName = t2)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.TOURNAMENT_NAME
-        filter.valueMap = mapOf("ids" to arrayOf(t1.id))
+        val filter = QueryType.TOURNAMENT_NAME
+
+        val filterElementRow = FilterElementRow.TournamentName(t1)
+        filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -338,12 +365,16 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(tournamentName = t3)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.TOURNAMENT_NAME
-        filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id))
+        val filter = QueryType.TOURNAMENT_NAME
+        val filterElementRow = FilterElementRow.TournamentName(t1)
+        filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
+        val filterElementRow2 = FilterElementRow.TournamentName(t2)
+        filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -374,12 +405,18 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(tournamentFeatures = RealmList(t1))
         realm.commitTransaction()
 
-        val filter = SessionFilterable.ALL_TOURNAMENT_FEATURES
-        filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
+        val filter = QueryType.ALL_TOURNAMENT_FEATURES
+        val filterElementRow = FilterElementRow.AllTournamentFeature(t1)
+        filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        val filterElementRow2 = FilterElementRow.AllTournamentFeature(t2)
+        filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        val filterElementRow3 = FilterElementRow.AllTournamentFeature(t4)
+        filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -407,12 +444,20 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(tournamentFeatures = RealmList(t1))
         realm.commitTransaction()
 
-        val filter = SessionFilterable.ANY_TOURNAMENT_FEATURES
-        filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
-
-        val sessions = FilterManager().filter(
+        val filter = QueryType.ANY_TOURNAMENT_FEATURES
+        val filterElementRow = FilterElementRow.AnyTournamentFeature(t1)
+        filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        val filterElementRow2 = FilterElementRow.AnyTournamentFeature(t2)
+        filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        val filterElementRow3 = FilterElementRow.AnyTournamentFeature(t3)
+        filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        val filterElementRow4 = FilterElementRow.AnyTournamentFeature(t4)
+        filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4)))
+
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -437,12 +482,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(tournamentFeatures = RealmList(t1))
         realm.commitTransaction()
 
-        val filter = SessionFilterable.ANY_TOURNAMENT_FEATURES
-        filter.valueMap = mapOf("ids" to arrayOf(t2.id))
+        val filter = QueryType.ANY_TOURNAMENT_FEATURES
+        val filterElementRow = FilterElementRow.AnyTournamentFeature(t2)
+        filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -464,12 +511,16 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(tableSize = 10)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.TABLE_SIZE
-        filter.valueMap = mapOf("values" to arrayOf(2,4))
+        val filter = QueryType.TABLE_SIZE
+        val filterElementRow = FilterElementRow.TableSize(TableSize(2))
+        filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
+        val filterElementRow2 = FilterElementRow.TableSize(TableSize(4))
+        filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
+        filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -491,12 +542,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val s2 = Session.testInstance(netResult = 570.0)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.MORE_THAN_NET_RESULT
-        filter.valueMap = mapOf("value" to 204.0)
+        val filter = QueryType.MORE_THAN_NET_RESULT
+        val filterElementRow = FilterElementRow.ResultMoreThan(204.0)
+        filterElementRow.filterSectionRow = FilterSectionRow.VALUE
+        filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -518,12 +571,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(netResult = 570.0)
         realm.commitTransaction()
 
-        val filter = SessionFilterable.LESS_THAN_NET_RESULT
-        filter.valueMap = mapOf("value" to 540.0)
+        val filter = QueryType.LESS_THAN_NET_RESULT
+        val filterElementRow = FilterElementRow.ResultLessThan(540.0)
+        filterElementRow.filterSectionRow = FilterSectionRow.VALUE
+        filter.updateValueMap(FilterElement(filterElementRow))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filter)
         )
 
@@ -545,15 +600,19 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         Session.testInstance(netResult = 570.0)
         realm.commitTransaction()
 
-        val filterMore = SessionFilterable.MORE_THAN_NET_RESULT
-        filterMore.valueMap = mapOf("value" to 200.0)
+        val filterMore = QueryType.MORE_THAN_NET_RESULT
+        val filterElementRow = FilterElementRow.ResultMoreThan(200.0)
+        filterElementRow.filterSectionRow = FilterSectionRow.VALUE
+        filterMore.updateValueMap(FilterElement(filterElementRow))
 
-        val filterLess = SessionFilterable.LESS_THAN_NET_RESULT
-        filterLess.valueMap = mapOf("value" to 400.0)
+        val filterLess = QueryType.LESS_THAN_NET_RESULT
+        val filterElementRow2 = FilterElementRow.ResultLessThan(400.0)
+        filterElementRow2.filterSectionRow = FilterSectionRow.VALUE
+        filterLess.updateValueMap(FilterElement(filterElementRow2))
 
-        val sessions = FilterManager().filter(
+        val sessions = Filter.queryOn(
             realm,
-            Session::class.java,
+            Session,
             arrayListOf(filterMore, filterLess)
         )
 
diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
index b8173952..f657b5d3 100644
--- a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
+++ b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
@@ -28,7 +28,7 @@ class Calculator {
 		}
 
 		/**
-		 * The type of evolution values
+		 * The type of evolution numericValues
 		 */
 		enum class EvolutionValues {
 			NONE,
@@ -82,7 +82,7 @@ class Calculator {
 					results.computeStatVariations(comparedResults)
 				}
 
-				results.finalize(options) // later treatment, such as evolution values sorting
+				results.finalize(options) // later treatment, such as evolution numericValues sorting
 				computedResults.add(results)
 
 				val e = Date()
diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/ComputableGroup.kt b/app/src/main/java/net/pokeranalytics/android/calculus/ComputableGroup.kt
index 211af750..d0653c92 100644
--- a/app/src/main/java/net/pokeranalytics/android/calculus/ComputableGroup.kt
+++ b/app/src/main/java/net/pokeranalytics/android/calculus/ComputableGroup.kt
@@ -51,7 +51,7 @@ class ComputedResults(group: ComputableGroup) {
     // The computed stats of the sessionGroup
     private var _computedStats: MutableMap<Stat, ComputedStat> = mutableMapOf()
 
-    // The map containing all evolution values for all stats
+    // The map containing all evolution numericValues for all stats
     private var _evolutionValues: MutableMap<Stat, MutableList<Point>> = mutableMapOf()
 
     fun allStats() : Collection<ComputedStat> {
diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt
index 7765025e..e3f557c9 100644
--- a/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt
+++ b/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt
@@ -35,7 +35,7 @@ enum class Stat : RowRepresentable {
     HANDS_PLAYED;
 
     /**
-     * Returns whether the stat evolution values requires a distribution sorting
+     * Returns whether the stat evolution numericValues requires a distribution sorting
      */
     fun hasDistributionSorting() : Boolean {
         return when (this) {
@@ -124,12 +124,17 @@ class ComputedStat(var stat: Stat, var value: Double, var currency: Currency? =
 
         when (this.stat) {
             // Amounts + red/green
-            Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE, Stat.NET_BB_PER_100_HANDS, Stat.HOURLY_RATE_BB,
-            Stat.AVERAGE_NET_BB -> {
+            Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE -> {
                 val numberFormat= CurrencyUtils.getCurrencyFormatter(context, currency)
                 val color = if (this.value >= this.stat.threshold) R.color.green else R.color.red
                 return TextFormat(numberFormat.format(this.value), color)
-            } // white integers
+            }
+            // Red/green numericValues
+            Stat.HOURLY_RATE_BB, Stat.AVERAGE_NET_BB, Stat.NET_BB_PER_100_HANDS -> {
+                val color = if (this.value >= this.stat.threshold) R.color.green else R.color.red
+                return TextFormat(this.value.formatted(), color)
+            }
+            // white integers
             Stat.NUMBER_OF_SETS, Stat.NUMBER_OF_GAMES, Stat.HANDS_PLAYED -> {
                 return TextFormat("${value.toInt()}")
             } // white durations
diff --git a/app/src/main/java/net/pokeranalytics/android/exceptions/Exceptions.kt b/app/src/main/java/net/pokeranalytics/android/exceptions/Exceptions.kt
index deefbc3c..5a4ae6cf 100644
--- a/app/src/main/java/net/pokeranalytics/android/exceptions/Exceptions.kt
+++ b/app/src/main/java/net/pokeranalytics/android/exceptions/Exceptions.kt
@@ -13,5 +13,7 @@ class RowRepresentableEditDescriptorException(message: String) : Exception(messa
 }
 
 class FilterValueMapException(message: String) : Exception(message) {
-
+    init {
+        println("FilterValueMapException(): $message")
+    }
 }
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/model/Limit.kt b/app/src/main/java/net/pokeranalytics/android/model/Limit.kt
index 024fdcfd..d99031d8 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/Limit.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/Limit.kt
@@ -1,7 +1,6 @@
 package net.pokeranalytics.android.model
 
 import net.pokeranalytics.android.ui.view.RowRepresentable
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSection
 
 enum class Limit : RowRepresentable {
 	NO,
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/DateFilterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/DateFilterable.kt
deleted file mode 100644
index 3693d10c..00000000
--- a/app/src/main/java/net/pokeranalytics/android/model/filter/DateFilterable.kt
+++ /dev/null
@@ -1,77 +0,0 @@
-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 filterValuesExpectedKeys : 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())
-        }
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/FilterComponent.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/FilterComponent.kt
deleted file mode 100644
index d647bfa1..00000000
--- a/app/src/main/java/net/pokeranalytics/android/model/filter/FilterComponent.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package net.pokeranalytics.android.model.filter
-
-enum class FilterComponent {
-
-}
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt
index aa6510af..8d19eb7e 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt
@@ -1,10 +1,6 @@
 package net.pokeranalytics.android.model.filter
 
-import io.realm.Realm
 import io.realm.RealmObject
-import io.realm.RealmQuery
-import io.realm.RealmResults
-import net.pokeranalytics.android.model.filter.interfaces.Filterable
 
 /**
  * We want to be able to store filters in the database:
@@ -25,24 +21,29 @@ import net.pokeranalytics.android.model.filter.interfaces.Filterable
  * - multiple field filters should be handled as 'AND'
  * - multiple '=' filters as 'OR'
  * - multiple 'Greater than', 'less than' as 'AND'
- * - multiple values as 'OR'
+ * - multiple numericValues as 'OR'
  *
  * Also:
  * A filter should be able to be converted into a Realm query
  *
  */
 
-class FilterManager {
-    fun filter(realm:Realm, relatedEntity: Class<out RealmObject>, queries:List<Filterable>): RealmResults<*> {
-        var realmQuery : RealmQuery<out RealmObject> = realm.where(relatedEntity)
-        queries.forEach {
-            realmQuery = (it.filter(realmQuery))
-        }
-        return realmQuery.findAll()
-    }
+
+/**
+ * Interface to set at companion object level of a realm object to provide the entity and the fieldName (eg: parameter's path)
+ */
+interface Filterable {
+
+    val relatedEntity: Class<out RealmObject>
+
+    /**
+     * return the path of the parameter used in the [QueryType] related to this entity
+     */
+    fun fieldNameForQueryType(queryType: QueryType) : String?
 }
+
 //
-//fun MutableList<Filterable>.filter(filter: FilterComponent) : List<Filterable> {
+//fun MutableList<Filterable>.filter(filter: FilterElement) : List<Filterable> {
 //
 //    return this.filter { f ->
 //        return@filter true
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt
new file mode 100644
index 00000000..34641b73
--- /dev/null
+++ b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt
@@ -0,0 +1,292 @@
+package net.pokeranalytics.android.model.filter
+
+import io.realm.RealmList
+import io.realm.RealmObject
+import io.realm.RealmQuery
+import net.pokeranalytics.android.exceptions.FilterValueMapException
+import net.pokeranalytics.android.model.realm.FilterElementBlind
+import net.pokeranalytics.android.model.realm.FilterElement
+import net.pokeranalytics.android.model.realm.Session
+import java.util.*
+
+
+/**
+ * Enum describing the way a query should be handled
+ * Some queries requires a value to be checked upon through equals, in, more, less, between
+ * To handle that, the enum has a public [valueMap] variable
+ * A new type should also set the expected numericValues required in the [filterValuesExpectedKeys]
+ */
+enum class QueryType(private var subType:SubType? = null) {
+    LIVE,
+    CASH,
+    ONLINE,
+    TOURNAMENT,
+    BANKROLL,
+    GAME,
+    TOURNAMENT_NAME,
+    ANY_TOURNAMENT_FEATURES,
+    ALL_TOURNAMENT_FEATURES,
+    LOCATION,
+    LIMIT,
+    TABLE_SIZE,
+    TOURNAMENT_TYPE,
+    BLINDS,
+    MORE_NUMBER_OF_TABLE(SubType.MORE),
+    LESS_NUMBER_OF_TABLE(SubType.LESS),
+    BETWEEN_NUMBER_OF_TABLE(SubType.BETWEEN),
+    MORE_THAN_NET_RESULT(SubType.MORE),
+    LESS_THAN_NET_RESULT(SubType.LESS),
+    MORE_THAN_BUY_IN(SubType.MORE),
+    LESS_THAN_BUY_IN(SubType.LESS),
+    MORE_THAN_CASH_OUT(SubType.MORE),
+    LESS_THAN_CASH_OUT(SubType.LESS),
+    MORE_THAN_TIPS(SubType.MORE),
+    LESS_THAN_TIPS(SubType.LESS),
+    MORE_THAN_NUMBER_OF_PLAYER(SubType.MORE),
+    LESS_THAN_NUMBER_OF_PLAYER(SubType.LESS),
+    BETWEEN_NUMBER_OF_PLAYER(SubType.BETWEEN),
+    MORE_THAN_TOURNAMENT_FEE(SubType.MORE),
+    LESS_THAN_TOURNAMENT_FEE(SubType.LESS),
+    BETWEEN_TOURNAMENT_FEE(SubType.BETWEEN),
+
+    // Dates
+    STARTED_FROM_DATE,
+    STARTED_TO_DATE,
+    ENDED_FROM_DATE,
+    ENDED_TO_DATE,
+    DAY_OF_WEEK,
+    MONTH,
+    YEAR,
+    WEEK_DAY,
+    WEEK_END,
+
+    CURRENCY,
+    CURRENCY_CODE,
+    BIG_BLIND,
+    SMALL_BLIND,
+    COMMENT,
+
+    ;
+
+    private enum class SubType {
+        BETWEEN,
+        MORE,
+        LESS;
+    }
+
+    private val filterValuesExpectedKeys : Array<String>?
+        get() {
+            this.subType?.let {
+                return when (it) {
+                    SubType.BETWEEN -> arrayOf("leftValue", "rightValue")
+                    else -> arrayOf("value")
+                }
+            }
+            return when (this) {
+                BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES, TOURNAMENT_NAME -> arrayOf("ids")
+                LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> arrayOf("values")
+                BLINDS -> arrayOf("blinds")
+                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
+            }
+        }
+
+    /**
+     * main method of the enum
+     * providing a base RealmQuery [realmQuery], the method is able to attached the corresponding query and returns the newly formed [RealmQuery]
+     */
+    fun filter(realmQuery: RealmQuery<out RealmObject>, filterable: Filterable): RealmQuery<out RealmObject> {
+        when {
+            this == BLINDS -> {
+                val smallBlindFieldName = filterable.fieldNameForQueryType(SMALL_BLIND)
+                val bigBlindFieldName = filterable.fieldNameForQueryType(BIG_BLIND)
+                val currencyCodeFieldName = filterable.fieldNameForQueryType(CURRENCY_CODE)
+                smallBlindFieldName ?: throw FilterValueMapException("fieldName is missing")
+                bigBlindFieldName ?: throw FilterValueMapException("fieldName is missing")
+                currencyCodeFieldName ?: throw FilterValueMapException("fieldName is missing")
+
+                val blinds: RealmList<FilterElementBlind> by valueMap
+                blinds.forEachIndexed {index, blind ->
+                    realmQuery
+                        .beginGroup()
+
+                    blind.sb?.let {
+                        realmQuery
+                            .equalTo(smallBlindFieldName, it)
+                            .and()
+                    }
+
+                    realmQuery
+                        .equalTo(bigBlindFieldName, blind.bb)
+                        .and()
+
+                    blind.code?.let {
+                        realmQuery.equalTo(currencyCodeFieldName, it)
+                    } ?: run {
+                        realmQuery.isNull(currencyCodeFieldName)
+                    }
+
+                    realmQuery.endGroup()
+
+                    if (index < blinds.size - 1) {
+                        realmQuery.or()
+                    }
+                }
+                return realmQuery
+            }
+            this == ONLINE -> return LIVE.filter(realmQuery.not(), filterable)
+            this == TOURNAMENT -> return CASH.filter(realmQuery.not(), filterable)
+            this == WEEK_DAY -> return WEEK_END.filter(realmQuery.not(), filterable)
+            else -> {
+                val fieldName = filterable.fieldNameForQueryType(this)
+                fieldName ?: throw FilterValueMapException("fieldName is missing")
+
+                this.subType?.let { subType ->
+                    return when (subType) {
+                        SubType.LESS -> {
+                            val value: Double by valueMap
+                            realmQuery.lessThanOrEqualTo(fieldName, value)
+                        }
+                        SubType.MORE -> {
+                            val value: Double by valueMap
+                            realmQuery.greaterThanOrEqualTo(fieldName, value)
+                        }
+                        SubType.BETWEEN -> {
+                            val leftValue: Double by valueMap
+                            val rightValue: Double by valueMap
+                            realmQuery.between(fieldName, leftValue, rightValue)
+                        }
+                    }
+                }
+
+                return when (this) {
+                    LIVE -> realmQuery.equalTo(fieldName, true)
+                    CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal)
+                    ALL_TOURNAMENT_FEATURES -> {
+                        val ids: Array<String> by valueMap
+                        ids.forEach {
+                            realmQuery.equalTo(fieldName, it)
+                        }
+                        realmQuery
+                    }
+                    ANY_TOURNAMENT_FEATURES -> {
+                        val ids: Array<String> by valueMap
+                        realmQuery.`in`(fieldName, ids)
+                    }
+                    BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
+                        val ids: Array<String> by valueMap
+                        realmQuery.`in`(fieldName, ids)
+                    }
+                    LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
+                        val values: Array<Int?>? by valueMap
+                        realmQuery.`in`(fieldName, values)
+                    }
+                    STARTED_FROM_DATE -> {
+                        val date: Date by valueMap
+                        realmQuery.greaterThanOrEqualTo(fieldName, date)
+                    }
+                    STARTED_TO_DATE -> {
+                        val date: Date by valueMap
+                        realmQuery.lessThanOrEqualTo(fieldName, date)
+                    }
+                    ENDED_FROM_DATE -> {
+                        val date: Date by valueMap
+                        realmQuery.greaterThanOrEqualTo(fieldName, date)
+                    }
+                    ENDED_TO_DATE -> {
+                        val date: Date by valueMap
+                        realmQuery.lessThanOrEqualTo(fieldName, date)
+                    }
+                    DAY_OF_WEEK -> {
+                        val dayOfWeek: Int by valueMap
+                        realmQuery.equalTo(fieldName, dayOfWeek)
+                    }
+                    MONTH -> {
+                        val month: Int by valueMap
+                        realmQuery.equalTo(fieldName, month)
+                    }
+                    YEAR -> {
+                        val year: Int by valueMap
+                        realmQuery.equalTo(fieldName, year)
+                    }
+                    WEEK_END -> {
+                        realmQuery.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY))
+                    }
+                    else -> {
+                        throw FilterValueMapException("filter type not handled")
+                    }
+                }
+            }
+        }
+
+    }
+
+    fun updateValueMap(filterElement: FilterElement) {
+        if (filterValuesExpectedKeys == null) {
+            return
+        }
+
+        this.subType?.let { subType ->
+            valueMap = when (subType) {
+                SubType.LESS, SubType.MORE -> {
+                    mapOf("value" to filterElement.value)
+                }
+                SubType.BETWEEN -> {
+                    mapOf(
+                        "leftValue" to filterElement.leftValue,
+                        "rightValue" to filterElement.rightValue
+                    )
+                }
+            }
+            return
+        }
+
+        when (this) {
+            ALL_TOURNAMENT_FEATURES, ANY_TOURNAMENT_FEATURES, BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
+                valueMap = mapOf("ids" to filterElement.ids)
+            }
+            LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
+                valueMap = mapOf("values" to filterElement.values)
+            }
+            BLINDS -> {
+                valueMap = mapOf("blinds" to filterElement.blinds)
+            }
+            STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> {
+                valueMap = mapOf("date" to filterElement.date)
+            }
+            DAY_OF_WEEK -> {
+                valueMap = mapOf("dayOfWeek" to filterElement.dayOfWeek)
+            }
+            MONTH -> {
+                valueMap = mapOf("month" to filterElement.month)
+            }
+            YEAR -> {
+                valueMap = mapOf("year" to filterElement.year)
+            }
+            else -> {
+                throw FilterValueMapException("filter type not handled")
+            }
+        }
+    }
+
+    var valueMap : Map<String, Any?>? = null
+        get() {
+            this.filterValuesExpectedKeys?.let { valueMapExceptedKeys ->
+                field?.let { map ->
+                    val 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 field
+        }
+        private set
+
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt
deleted file mode 100644
index a4520966..00000000
--- a/app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt
+++ /dev/null
@@ -1,189 +0,0 @@
-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(private var fieldName:String? = null, private var subType:SubType? = null): Filterable {
-    LIVE,
-    CASH,
-    ONLINE,
-    TOURNAMENT,
-    BANKROLL("bankroll.id"),
-    GAME("game.id"),
-    TOURNAMENT_NAME("tournamentName.id"),
-    ANY_TOURNAMENT_FEATURES,
-    ALL_TOURNAMENT_FEATURES,
-    LOCATION("location.id"),
-    LIMIT("limit"),
-    TABLE_SIZE("tableSize"),
-    TOURNAMENT_TYPE("tournamentType"),
-    BLINDS,
-    MORE_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.MORE),
-    LESS_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.LESS),
-    BETWEEN_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.BETWEEN),
-    MORE_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.MORE),
-    LESS_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.LESS),
-    MORE_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.MORE),
-    LESS_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.LESS),
-    MORE_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.MORE),
-    LESS_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.LESS),
-    MORE_THAN_TIPS(Field.TIPS.fieldName, SubType.MORE),
-    LESS_THAN_TIPS(Field.TIPS.fieldName, SubType.LESS),
-    MORE_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.MORE),
-    LESS_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.LESS),
-    BETWEEN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.BETWEEN),
-    MORE_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.MORE),
-    LESS_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.LESS),
-    BETWEEN_TOURNAMENT_FEE(Field.TOURNAMENT_FEE.fieldName, SubType.BETWEEN),
-    ;
-
-    enum class SubType {
-        BETWEEN,
-        MORE,
-        LESS;
-    }
-
-    private enum class Field(var fieldName:String) {
-        LIVE("bankroll.live"),
-        CASH("type"),
-        CURRENCY("bankroll.currency"),
-        CURRENCY_CODE("bankroll.currency.code"),
-        BIG_BLIND("cgBigBlind"),
-        SMALL_BLIND("cgSmallBlind"),
-        COMMENT("comment"),
-        TOURNAMENT_FEATURES("tournamentFeatures.id"),
-        NET_RESULT("computableResults.ratedNet"),
-        BUY_IN("result.buyin"),
-        CASH_OUT("result.cashout"),
-        TIPS("result.tips"),
-        NUMBER_OF_TABLE("numberOfTable"),
-        NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
-        TOURNAMENT_FEE("tournamentEntryFee"),
-        ;
-    }
-
-    override var valueMap : Map<String, Any?>? = null
-
-    override val filterValuesExpectedKeys : Array<String>?
-        get() {
-            this.subType?.let {
-                return when (it) {
-                    SubType.BETWEEN -> arrayOf("leftValue", "rightValue")
-                    else -> arrayOf("value")
-                }
-            }
-            return when (this) {
-                BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> arrayOf("ids")
-                LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> arrayOf("values")
-                BLINDS -> arrayOf("map")
-                else -> null
-            }
-        }
-
-    override fun filter(realmQuery: RealmQuery<out RealmObject>): RealmQuery<out RealmObject> {
-
-        this.subType?.let {subType ->
-            this.fieldName?.let {
-                return when (subType) {
-                    SubType.LESS -> {
-                        val value: Double by filterValues
-                        println("filter test less")
-                        realmQuery.lessThanOrEqualTo(it, value)
-                    }
-                    SubType.MORE -> {
-                        println("filter test more")
-                        val value: Double by filterValues
-                        realmQuery.greaterThanOrEqualTo(it, value)
-                    }
-                    SubType.BETWEEN -> {
-                        val leftValue: Double by filterValues
-                        val rightValue: Double by filterValues
-                        realmQuery.between(it, leftValue, rightValue)
-                    }
-                }
-            } ?: run {
-                throw FilterValueMapException("fieldName is missing")
-            }
-        }
-
-        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())
-            ALL_TOURNAMENT_FEATURES -> {
-                val ids : Array<String> by filterValues
-                ids.forEach {
-                    realmQuery.equalTo(Field.TOURNAMENT_FEATURES.fieldName, it)
-                }
-                realmQuery
-            }
-            ANY_TOURNAMENT_FEATURES -> {
-                val ids : Array<String> by filterValues
-                realmQuery.`in`(Field.TOURNAMENT_FEATURES.fieldName, ids)
-            }
-            BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
-                val ids : Array<String> by filterValues
-                this.fieldName?.let {
-                    realmQuery.`in`(it, ids)
-                } ?: run {
-                    throw FilterValueMapException("fieldName is missing")
-                }
-            }
-            LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
-                val values : Array<Int?>? by filterValues
-                this.fieldName?.let {
-                    realmQuery.`in`(it, values)
-                } ?: run {
-                    throw FilterValueMapException("fieldName is missing")
-                }
-            }
-            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
-            }
-            else -> {
-                realmQuery
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt
deleted file mode 100644
index 509ee118..00000000
--- a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-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>
-}
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt
deleted file mode 100644
index 729cee60..00000000
--- a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt
+++ /dev/null
@@ -1,28 +0,0 @@
-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.filterValuesExpectedKeys?.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 filterValuesExpectedKeys : Array<String>?
-}
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/TimeFilterable.kt b/app/src/main/java/net/pokeranalytics/android/model/interfaces/TimeFilterable.kt
similarity index 69%
rename from app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/TimeFilterable.kt
rename to app/src/main/java/net/pokeranalytics/android/model/interfaces/TimeFilterable.kt
index f4713e4b..a83cc2e1 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/TimeFilterable.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/interfaces/TimeFilterable.kt
@@ -1,7 +1,10 @@
-package net.pokeranalytics.android.model.filter.interfaces
+package net.pokeranalytics.android.model.interfaces
 
 import java.util.*
 
+/**
+ * Interface to let an object be filtered through specific time parameters
+ */
 interface TimeFilterable {
 
     var dayOfWeek : Int?
@@ -9,6 +12,9 @@ interface TimeFilterable {
     var month : Int?
     var year : Int?
 
+    /**
+     * Call this method whenever the date of the object is modified
+     */
     fun updateTimeParameter(startDate: Date?) {
         startDate?.let {
             val cal = Calendar.getInstance()
diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Currency.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Currency.kt
index 5f18c933..dd60d670 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/realm/Currency.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Currency.kt
@@ -24,22 +24,26 @@ open class Currency : RealmObject() {
 
             val rate = value ?: 1.0
 
-            // could be async
+            // could be async?
 
-            val query = this.realm.where(ComputableResult::class.java)
-	        query.`in`("session.bankroll.currency.id", arrayOf(this.id))
-	        val cResults = query.findAll()
+	        if (this.isManaged && this.realm != null) {
 
-            cResults.forEach { computable ->
+		        val query = this.realm.where(ComputableResult::class.java)
+		        query.`in`("session.bankroll.currency.id", arrayOf(this.id))
+		        val cResults = query.findAll()
 
-                computable.session?.result?.net?.let {
-                    computable.ratedNet = it * rate
-                }
-                computable.session?.result?.buyin?.let {
-                    computable.ratedBuyin = it * rate
-                }
+		        cResults.forEach { computable ->
+
+			        computable.session?.result?.net?.let {
+				        computable.ratedNet = it * rate
+			        }
+			        computable.session?.result?.buyin?.let {
+				        computable.ratedBuyin = it * rate
+			        }
+
+		        }
+	        }
 
-            }
         }
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
index 26ed01d6..37481aaf 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
@@ -1,15 +1,33 @@
 package net.pokeranalytics.android.model.realm
 
-import io.realm.MutableRealmInteger
-import io.realm.RealmObject
+import io.realm.*
 import io.realm.annotations.PrimaryKey
+import net.pokeranalytics.android.model.filter.Filterable
+import net.pokeranalytics.android.model.filter.QueryType
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
+import org.jetbrains.annotations.TestOnly
 import java.util.*
 
-//import net.pokeranalytics.android.FilterComponent
-
-
+/**
+ * A [Filter] is the top level representation of the filtering system
+ * It contains a list of [FilterElement] describing the complete query to launch
+ * The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on
+ */
 open class Filter : RealmObject() {
 
+    companion object {
+        @TestOnly
+        fun queryOn(realm: Realm, entity: Filterable, queries:List<QueryType>): RealmResults<*> {
+            var realmQuery : RealmQuery<out RealmObject> = realm.where(entity.relatedEntity)
+            queries.forEach {
+                realmQuery = (it.filter(realmQuery, entity))
+            }
+            return realmQuery.findAll()
+        }
+    }
+
     @PrimaryKey
     var id = UUID.randomUUID().toString()
 
@@ -20,6 +38,60 @@ open class Filter : RealmObject() {
     // for MutableRealmInteger, see https://realm.io/docs/java/latest/#counters
     val usageCount: MutableRealmInteger = MutableRealmInteger.valueOf(0)
 
-//    var components: List<FilterComponent> = listOf()
+    var filterElements: RealmList<FilterElement> = RealmList()
+        private set
+
+    fun createOrUpdateFilterElements(filterElementRows: ArrayList<FilterElementRow>) {
+        filterElements.clear()
+        filterElementRows
+            .map {
+                it.filterSectionRow
+            }
+            .distinct()
+            .forEach { section ->
+                filterElementRows
+                    .filter {
+                        it.filterSectionRow == section
+                    }
+                    .apply {
+
+                        if (this.size == 1) {
+                            filterElements.add(FilterElement(this.first()))
+                        } else {
+                            val casted = arrayListOf<FilterElementRow>()
+                            casted.addAll(this)
+                            filterElements.add(FilterElement(casted))
+                        }
+
+                    }
+            }
+    }
+
+    fun countBy(filterCategoryRow: FilterCategoryRow) : Int {
+        val sections = filterCategoryRow.filterSectionRows
+        return filterElements.count {
+            sections.contains(FilterSectionRow.valueOf(it.sectionName))
+        }
+    }
+
+    fun contains(filterElementRow:FilterElementRow) : Boolean {
+        val filtered = filterElements.filter {
+            it.filterName == filterElementRow.filterName
+        }
+        if (filtered.isEmpty()) {
+            return false
+        }
+        return filterElementRow.contains(filtered)
+    }
+
+    fun queryOn(entity: Filterable) : RealmResults<*> {
+        var realmQuery : RealmQuery<out RealmObject> = realm.where(entity.relatedEntity)
+        this.filterElements.map {
+            it.queryType
+        }.forEach {
+            realmQuery = (it.filter(realmQuery, entity))
+        }
 
+        return realmQuery.findAll()
+    }
 }
diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/FilterElement.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterElement.kt
new file mode 100644
index 00000000..be590588
--- /dev/null
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterElement.kt
@@ -0,0 +1,144 @@
+package net.pokeranalytics.android.model.realm
+
+import io.realm.RealmList
+import io.realm.RealmObject
+import net.pokeranalytics.android.exceptions.FilterValueMapException
+import net.pokeranalytics.android.model.filter.QueryType
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.*
+import java.util.*
+import kotlin.collections.ArrayList
+
+open class FilterElement(var filterName : String = "", var sectionName: String = "") : RealmObject() {
+
+    constructor(filterElementRows: ArrayList<FilterElementRow>) : this(filterElementRows.first().filterName, filterElementRows.first().filterSectionRow.name) {
+        this.stringValues = when (QueryType.valueOf(this.filterName)) {
+            QueryType.GAME, QueryType.BANKROLL, QueryType.TOURNAMENT_NAME, QueryType.ALL_TOURNAMENT_FEATURES, QueryType.ANY_TOURNAMENT_FEATURES, QueryType.LOCATION -> {
+                RealmList<String>().apply {
+                    this.addAll(filterElementRows.map {
+                        (it as DataFilterElementRow).id
+                    })
+                }
+            }
+            else -> null
+        }
+
+        this.numericValues = when (QueryType.valueOf(filterName)) {
+            QueryType.LIMIT -> {
+                RealmList<Double>().apply {
+                    this.addAll(filterElementRows.map {
+                        (it as FilterElementRow.Limit).limit.ordinal.toDouble()
+                    })
+                }
+            }
+            QueryType.TABLE_SIZE -> {
+                RealmList<Double>().apply {
+                    this.addAll(filterElementRows.map {
+                        (it as FilterElementRow.TableSize).tableSize.numberOfPlayer.toDouble()
+                    })
+                }
+            }
+            QueryType.YEAR, QueryType.MONTH, QueryType.DAY_OF_WEEK -> {
+                RealmList<Double>().apply {
+                    this.addAll(filterElementRows.map {
+                        (it as SingleValueFilterElementRow).value.toDouble()
+                    })
+                }
+            }
+            QueryType.LESS_THAN_NET_RESULT -> {
+                RealmList<Double>().apply {
+                    this.addAll(filterElementRows.map {
+                        (it as ResultLessThan).value
+                    })
+                }
+            }
+            QueryType.MORE_THAN_NET_RESULT -> {
+                RealmList<Double>().apply {
+                    this.addAll(filterElementRows.map {
+                        (it as ResultMoreThan).value
+                    })
+                }
+            }
+            else -> null
+        }
+
+        this.blindValues = when (QueryType.valueOf(filterName)) {
+            QueryType.BLINDS -> {
+                RealmList<FilterElementBlind>().apply {
+                    this.addAll(filterElementRows.map {
+                        FilterElementBlind((it as FilterElementRow.Blind).sb, it.bb, it.code)
+                    })
+                }
+            }
+            else -> null
+        }
+    }
+
+    constructor(filterElementRow:FilterElementRow) : this(arrayListOf(filterElementRow)) {
+        when (filterElementRow) {
+            is From -> dateValue = filterElementRow.date
+            is To -> dateValue= filterElementRow.date
+        }
+    }
+
+    val queryType : QueryType
+        get() = QueryType.valueOf(filterName)
+            .apply {
+                this.updateValueMap(this@FilterElement)
+            }
+
+    private var numericValues: RealmList<Double>? = null
+    private var dateValue : Date? = null
+    private var stringValues : RealmList<String>? = null
+    private var blindValues : RealmList<FilterElementBlind>? = null
+
+    val ids : Array<String>
+        get() = stringValues?.toTypedArray()?:                throw FilterValueMapException("filter type not handled")
+
+    val blinds : RealmList<FilterElementBlind>
+        get() {
+            blindValues?.let {
+                if (it.isNotEmpty()) {
+                    return it
+                } else {
+                    throw FilterValueMapException("filter is empty or null")
+                }
+            }
+            throw FilterValueMapException("filter is empty or null")
+        }
+
+
+    val date : Date
+        get() = dateValue?:                throw FilterValueMapException("filter type not handled")
+
+
+    val values : Array<Int>
+        get() = numericValues?.map {
+            it.toInt()
+        }?.toTypedArray()?:                throw FilterValueMapException("filter type not handled")
+
+
+    val value : Double
+        get() = numericValues?.first()?:                throw FilterValueMapException("filter type not handled")
+
+
+    val leftValue : Double
+        get() = numericValues?.first()?:                throw FilterValueMapException("filter type not handled")
+
+
+    val rightValue : Double
+        get() = numericValues?.last()?:                throw FilterValueMapException("filter type not handled")
+
+
+    val dayOfWeek : Int
+        get() = numericValues?.first()?.toInt()?:                throw FilterValueMapException("filter type not handled")
+
+
+    val month : Int
+        get() = numericValues?.first()?.toInt()?:                throw FilterValueMapException("filter type not handled")
+
+
+    val year : Int
+        get() = numericValues?.first()?.toInt()?:                throw FilterValueMapException("filter type not handled")
+
+}
diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt
new file mode 100644
index 00000000..fb615cbb
--- /dev/null
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt
@@ -0,0 +1,8 @@
+package net.pokeranalytics.android.model.realm
+
+import io.realm.RealmObject
+
+open class FilterElementBlind(var sb : Double? = null,
+                              var bb : Double? = null,
+                              var code : String? = null
+) : RealmObject()
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Game.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Game.kt
index 1d2dece9..bbb5e3fe 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/realm/Game.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Game.kt
@@ -8,7 +8,6 @@ import net.pokeranalytics.android.model.interfaces.Manageable
 import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource
 import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSection
 import net.pokeranalytics.android.ui.view.rowrepresentable.GameRow
 import net.pokeranalytics.android.ui.view.rowrepresentable.SimpleRow
 import net.pokeranalytics.android.util.NULL_TEXT
diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
index 1690abaf..b70e7c67 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
@@ -20,7 +20,10 @@ 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.filter.Filterable
+import net.pokeranalytics.android.model.filter.QueryType
+import net.pokeranalytics.android.model.filter.QueryType.*
+import net.pokeranalytics.android.model.interfaces.TimeFilterable
 import net.pokeranalytics.android.model.interfaces.Manageable
 import net.pokeranalytics.android.model.interfaces.Timed
 import net.pokeranalytics.android.model.utils.SessionSetManager
@@ -40,18 +43,17 @@ import java.util.Currency
 import kotlin.collections.ArrayList
 
 open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource, RowRepresentable, Timed,
-	TimeFilterable {
+    TimeFilterable {
 
 	enum class Type {
 		CASH_GAME,
 		TOURNAMENT
 	}
 
-	companion object {
+	companion object : Filterable {
 		fun newInstance(realm: Realm, isTournament: Boolean, bankroll: Bankroll? = null): Session {
 			val session = Session()
 			session.result = Result()
-
 			if (bankroll != null) {
 				session.bankroll = bankroll
 			} else {
@@ -60,6 +62,41 @@ open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource
 			session.type = if (isTournament) Session.Type.TOURNAMENT.ordinal else Session.Type.CASH_GAME.ordinal
 			return realm.copyToRealm(session)
 		}
+
+		override val relatedEntity: Class<out RealmObject> = Session::class.java
+
+		override fun fieldNameForQueryType(queryType: QueryType): String? {
+			return when (queryType) {
+				LIVE -> "bankroll.live"
+				CASH -> "type"
+				BANKROLL -> "bankroll.id"
+				GAME -> "game.id"
+				TOURNAMENT_NAME -> "tournamentName.id"
+				ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> "tournamentFeatures.id"
+				LOCATION -> "location.id"
+				LIMIT -> "limit"
+				TABLE_SIZE -> "tableSize"
+				TOURNAMENT_TYPE -> "tournamentType"
+				CURRENCY -> "bankroll.currency"
+				CURRENCY_CODE -> "bankroll.currency.code"
+				BIG_BLIND -> "cgBigBlind"
+				SMALL_BLIND -> "cgSmallBlind"
+				COMMENT -> "comment"
+				BETWEEN_NUMBER_OF_TABLE, MORE_NUMBER_OF_TABLE, LESS_NUMBER_OF_TABLE -> "numberOfTable"
+				MORE_THAN_NET_RESULT, LESS_THAN_NET_RESULT -> "computableResults.ratedNet"
+				MORE_THAN_BUY_IN, LESS_THAN_BUY_IN -> "result.buyin"
+				MORE_THAN_CASH_OUT, LESS_THAN_CASH_OUT -> "result.cashout"
+				MORE_THAN_TIPS, LESS_THAN_TIPS -> "result.tips"
+				MORE_THAN_NUMBER_OF_PLAYER, LESS_THAN_NUMBER_OF_PLAYER, BETWEEN_NUMBER_OF_PLAYER -> "tournamentNumberOfPlayers"
+				MORE_THAN_TOURNAMENT_FEE, LESS_THAN_TOURNAMENT_FEE, BETWEEN_TOURNAMENT_FEE -> "tournamentEntryFee"
+				STARTED_FROM_DATE, STARTED_TO_DATE -> "startDate"
+				ENDED_FROM_DATE, ENDED_TO_DATE -> "endDate"
+				DAY_OF_WEEK, WEEK_END -> "dayOfWeek"
+				MONTH -> "month"
+				YEAR -> "year"
+				else -> null
+			}
+		}
 	}
 
 	@PrimaryKey
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/adapter/RowRepresentableDataSource.kt b/app/src/main/java/net/pokeranalytics/android/ui/adapter/RowRepresentableDataSource.kt
index e313e0cd..ca6b308e 100644
--- a/app/src/main/java/net/pokeranalytics/android/ui/adapter/RowRepresentableDataSource.kt
+++ b/app/src/main/java/net/pokeranalytics/android/ui/adapter/RowRepresentableDataSource.kt
@@ -102,7 +102,7 @@ class UnmanagedRowRepresentableException(message: String) : Exception(message) {
  * - string
  * - booleans
  * - actionIcon
- * to display the appropriate values in graphical components, such as labels, textfields, switchs...
+ * to display the appropriate numericValues in graphical filterElements, such as labels, textfields, switchs...
  */
 interface DisplayableDataSource {
 
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt
index 528bc30a..1542a281 100644
--- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt
+++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt
@@ -15,13 +15,11 @@ import net.pokeranalytics.android.ui.adapter.RowRepresentableAdapter
 import net.pokeranalytics.android.ui.adapter.RowRepresentableDelegate
 import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource
 import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment
-import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetFragment
-import net.pokeranalytics.android.ui.helpers.DateTimePickerManager
 import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.RowViewType
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategory
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElement
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSection
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import timber.log.Timber
 import java.util.*
 
@@ -32,13 +30,13 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresenta
 	lateinit var rowRepresentableAdapter: RowRepresentableAdapter
 
 	private var rows: ArrayList<RowRepresentable> = ArrayList()
-	private var rowsForFilterSubcategory: HashMap<FilterSection, ArrayList<RowRepresentable>> = HashMap()
+	private var rowsForFilterSubcategoryRow: HashMap<FilterSectionRow, ArrayList<RowRepresentable>> = HashMap()
 
 	private var filterMenu: Menu? = null
-	private var filterCategory: FilterCategory? = null
+	private var filterCategoryRow: FilterCategoryRow? = null
 
 
-	val selectedRows = ArrayList<FilterElement>()
+	val selectedRows = ArrayList<FilterElementRow>()
 
 
 	var isUpdating = false
@@ -67,10 +65,10 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresenta
 		if (selectedRows.contains(row)) {
 			selectedRows.remove(row)
 		} else {
-			if (row is FilterElement) {
+			if (row is FilterElementRow) {
 				row.sectionToExclude?.let { filterSectionToExclude ->
 					val excludedFilters = selectedRows.filter {
-						filterSectionToExclude.contains(it.filterSection)
+						filterSectionToExclude.contains(it.filterSectionRow)
 					}
 					excludedFilters .forEach {
 						selectedRows.remove(it)
@@ -105,7 +103,7 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresenta
 
 	override fun onRowValueChanged(value: Any?, row: RowRepresentable) {
 		super.onRowValueChanged(value, row)
-		selectedRows.add(row as FilterElement)
+		selectedRows.add(row as FilterElementRow)
 		rowRepresentableAdapter.refreshRow(row)
 	}
 
@@ -144,13 +142,23 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresenta
 
 		this.appBar.toolbar.title = getString(R.string.filter)
 
-		filterCategory?.let {
+		filterCategoryRow?.let {
 
 			this.appBar.toolbar.title = it.localizedTitle(requireContext())
 
 			this.rows.clear()
-			this.rowsForFilterSubcategory.clear()
+			this.rowsForFilterSubcategoryRow.clear()
 			this.rows.addAll(it.filterElements)
+
+			//TODO
+			/*
+			var filter = Filter()
+			this.rows.forEach {element ->
+				if (filter.isFilterElementExists(element as FilterElementRow)) {
+					this.selectedRows.add(element)
+				}
+			}
+			*/
 			this.rowRepresentableAdapter = RowRepresentableAdapter(this, this)
 			this.recyclerView.adapter = rowRepresentableAdapter
 		}
@@ -187,11 +195,11 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresenta
 	 */
 	fun setData(filterCategory: Int) {
 
-		this.filterCategory = FilterCategory.values()[filterCategory]
+		this.filterCategoryRow = FilterCategoryRow.values()[filterCategory]
 
 		/*
 		this.dataType = dataType
-		this.liveDataType = LiveData.values()[dataType]
+		this.liveDataType = LiveData.numericValues()[dataType]
 		this.primaryKey = primaryKey
 		*/
 	}
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/FiltersFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/FiltersFragment.kt
index 4f859d0f..cab37b3d 100644
--- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/FiltersFragment.kt
+++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/FiltersFragment.kt
@@ -8,6 +8,7 @@ import io.realm.RealmObject
 import kotlinx.android.synthetic.main.fragment_editable_data.*
 import kotlinx.android.synthetic.main.fragment_filters.view.*
 import net.pokeranalytics.android.R
+import net.pokeranalytics.android.model.realm.Filter
 import net.pokeranalytics.android.ui.activity.FilterDetailsActivity
 import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity
 import net.pokeranalytics.android.ui.adapter.RowRepresentableAdapter
@@ -15,7 +16,7 @@ import net.pokeranalytics.android.ui.adapter.RowRepresentableDelegate
 import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource
 import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment
 import net.pokeranalytics.android.ui.view.RowRepresentable
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategory
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
 import timber.log.Timber
 
 
@@ -34,6 +35,8 @@ open class FiltersFragment : PokerAnalyticsFragment(), StaticRowRepresentableDat
 	private var primaryKey: String? = null
 	private var selectedRow: RowRepresentable? = null
 
+	private var filter: Filter? = null
+
 	var isUpdating = false
 
 	override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
@@ -90,13 +93,20 @@ open class FiltersFragment : PokerAnalyticsFragment(), StaticRowRepresentableDat
 	override fun onRowSelected(position: Int, row: RowRepresentable, fromAction: Boolean) {
 		super.onRowSelected(position, row, fromAction)
 
-		if (row is FilterCategory) {
+		if (row is FilterCategoryRow) {
 			selectedRow = row
 			FilterDetailsActivity.newInstanceForResult(this, row.ordinal, REQUEST_CODE_FILTER_DETAILS)
 		}
 
 	}
 
+	//TODO
+	/*
+	override fun stringForRow(row: RowRepresentable): String {
+		return this.filter?.numberOfElementIn(row as FilterCategoryRow).toString()
+	}
+	*/
+
 	override fun onRowValueChanged(value: Any?, row: RowRepresentable) {
 		super.onRowValueChanged(value, row)
 	}
@@ -125,7 +135,7 @@ open class FiltersFragment : PokerAnalyticsFragment(), StaticRowRepresentableDat
 
 		this.appBar.toolbar.title = getString(R.string.filter)
 
-		rows.addAll(FilterCategory.values())
+		rows.addAll(FilterCategoryRow.values())
 
 		this.rowRepresentableAdapter = RowRepresentableAdapter(this, this)
 		this.recyclerView.adapter = rowRepresentableAdapter
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/RowRepresentable.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/RowRepresentable.kt
index ca2c818e..866bb937 100644
--- a/app/src/main/java/net/pokeranalytics/android/ui/view/RowRepresentable.kt
+++ b/app/src/main/java/net/pokeranalytics/android/ui/view/RowRepresentable.kt
@@ -29,7 +29,7 @@ interface DefaultEditable : Editable, Localizable {
 }
 
 /**
- * An interface used so that enums values can be represented visually
+ * An interface used so that enums numericValues can be represented visually
  *  as rows in RecyclerViews
  */
 interface Displayable : Localizable {
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategory.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategory.kt
deleted file mode 100644
index e7be8433..00000000
--- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategory.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package net.pokeranalytics.android.ui.view.rowrepresentable
-
-import net.pokeranalytics.android.R
-import net.pokeranalytics.android.ui.view.RowRepresentable
-import net.pokeranalytics.android.ui.view.RowViewType
-
-enum class FilterCategory(override val resId: Int?, override val viewType: Int = RowViewType.TITLE_VALUE_ARROW.ordinal) : RowRepresentable {
-	GENERAL(R.string.general),
-	DATE(R.string.date),
-	TIME_FRAME(R.string.duration),
-	SESSION(R.string.session),
-	CASH(R.string.cash),
-	TOURNAMENT(R.string.tournament),
-	ONLINE(R.string.online),
-	RESULT(R.string.result),
-	TRANSACTION_TYPES(R.string.operation_types),
-	LOCATIONS(R.string.locations),
-	BANKROLLS(R.string.bankrolls),
-	PLAYERS(R.string.players),
-	;
-
-	val filterElements : List < RowRepresentable >
-		get() {
-			return filterSections.flatMap {
-				it.filterElements
-			}
-		}
-
-	private val filterSections : List < FilterSectionDataSource >
-		get() {
-			return FilterSection.filterSectionsFor(this)
-		}
-}
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt
new file mode 100644
index 00000000..f24f7979
--- /dev/null
+++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt
@@ -0,0 +1,82 @@
+package net.pokeranalytics.android.ui.view.rowrepresentable
+
+import net.pokeranalytics.android.R
+import net.pokeranalytics.android.ui.view.RowRepresentable
+import net.pokeranalytics.android.ui.view.RowViewType
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow.*
+
+enum class FilterCategoryRow(override val resId: Int?, override val viewType: Int = RowViewType.TITLE_VALUE_ARROW.ordinal) : RowRepresentable {
+	GENERAL(R.string.general),
+	DATE(R.string.date),
+	TIME_FRAME(R.string.duration),
+	SESSION(R.string.session),
+	CASH(R.string.cash),
+	TOURNAMENT(R.string.tournament),
+	ONLINE(R.string.online),
+	RESULT(R.string.result),
+	TRANSACTION_TYPES(R.string.operation_types),
+	LOCATIONS(R.string.locations),
+	BANKROLLS(R.string.bankrolls),
+	PLAYERS(R.string.players),
+	;
+
+	val filterElements : List < RowRepresentable >
+		get() {
+			return filterSectionRows.flatMap {
+				it.filterElements
+			}
+		}
+
+	val filterSectionRows : List < FilterSectionRow >
+		get() {
+			return when (this) {
+				GENERAL -> arrayListOf(
+					CASH_TOURNAMENT,
+					LIVE_ONLINE,
+					GAME, LIMIT_TYPE,
+					TABLE_SIZE
+				)
+				DATE -> arrayListOf(
+					DYNAMIC_DATE,
+					FIXED_DATE,
+					DURATION,
+					YEAR,
+					WEEKDAYS_OR_WEEKEND,
+					DAY_OF_WEEK,
+					MONTH_OF_YEAR
+				)
+				BANKROLLS -> arrayListOf(
+					BANKROLL
+				)
+				CASH -> arrayListOf(
+					BLINDS,
+					CASH_RE_BUY_COUNT
+				)
+				TOURNAMENT -> arrayListOf(
+					TOURNAMENT_TYPE,
+					COMPLETION_PERCENTAGE,
+					PLACE,
+					PLAYERS_COUNT,
+					TOURNAMENT_RE_BUY_COUNT,
+					BUY_IN
+				)
+				ONLINE -> arrayListOf(
+					MULTI_TABLING
+				)
+				LOCATIONS -> arrayListOf(
+					LOCATION
+				)
+				PLAYERS -> arrayListOf(
+					NUMBER_OF_PLAYERS,
+					MULTI_PLAYER
+				)
+				RESULT -> arrayListOf(
+					VALUE
+				)
+
+				TIME_FRAME -> arrayListOf()
+				SESSION -> arrayListOf()
+				TRANSACTION_TYPES -> arrayListOf()
+			}
+		}
+}
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt
new file mode 100644
index 00000000..7a899662
--- /dev/null
+++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt
@@ -0,0 +1,178 @@
+package net.pokeranalytics.android.ui.view.rowrepresentable
+
+import net.pokeranalytics.android.R
+import net.pokeranalytics.android.exceptions.FilterValueMapException
+import net.pokeranalytics.android.model.filter.QueryType
+import net.pokeranalytics.android.model.interfaces.Manageable
+import net.pokeranalytics.android.model.realm.FilterElement
+import net.pokeranalytics.android.ui.view.RowRepresentable
+import net.pokeranalytics.android.ui.view.RowViewType
+
+import java.util.*
+
+sealed class FilterElementRow : RowRepresentable {
+
+	object Cash : FilterElementRow()
+	object Tournament : FilterElementRow()
+	object Live : FilterElementRow()
+	object Online : FilterElementRow()
+	object Today : FilterElementRow()
+	object Yesterday : FilterElementRow()
+	object TodayAndYesterday : FilterElementRow()
+	object CurrentWeek : FilterElementRow()
+	object CurrentMonth : FilterElementRow()
+	object CurrentYear: FilterElementRow()
+	object Weekday: FilterElementRow()
+	object Weekend : FilterElementRow()
+
+	open class DataFilterElementRow(data:Manageable) : FilterElementRow() {
+		val id : String = data.id
+		val name : String = (data as RowRepresentable).getDisplayName()
+	}
+
+	open class SingleValueFilterElementRow(val value:Int) : FilterElementRow()
+
+	data class Blind(var sb: Double? = null, var bb: Double? = null, var code: String? = null) : FilterElementRow()
+	data class From(var date: Date = Date()) : FilterElementRow()
+	data class To(var date: Date = Date()) : FilterElementRow()
+	data class Year(val year: Int) : SingleValueFilterElementRow(year)
+	data class Month(val month: Int) : SingleValueFilterElementRow(month)
+	data class Day(val day: Int) : SingleValueFilterElementRow(day)
+	data class PastDays(var lastDays : Int = 0) : FilterElementRow()
+	data class Limit(val limit : net.pokeranalytics.android.model.Limit) : FilterElementRow()
+	data class TableSize(val tableSize : net.pokeranalytics.android.model.TableSize) : FilterElementRow()
+	data class Bankroll(val bankroll: Manageable) : DataFilterElementRow(bankroll)
+	data class Game(val game: Manageable) : DataFilterElementRow(game)
+	data class Location(val location: Manageable) : DataFilterElementRow(location)
+	data class TournamentName(val tournamentName: Manageable) : DataFilterElementRow(tournamentName)
+	data class AllTournamentFeature(val tournamentFeature: Manageable) : DataFilterElementRow(tournamentFeature)
+	data class AnyTournamentFeature(val tournamentFeature: Manageable) : DataFilterElementRow(tournamentFeature)
+	data class ResultMoreThan(var value:Double) : FilterElementRow()
+	data class ResultLessThan(var value:Double) : FilterElementRow()
+
+	lateinit var filterSectionRow: FilterSectionRow
+
+	val filterName : String = this.queryType.name
+
+	private val queryType : QueryType
+		get() {
+			return when (this) {
+				is Cash -> QueryType.CASH
+				is Tournament -> QueryType.TOURNAMENT
+				is Blind -> QueryType.BLINDS
+				is From -> QueryType.STARTED_FROM_DATE
+				is To -> QueryType.ENDED_TO_DATE
+				is Month -> QueryType.MONTH
+				is Day -> QueryType.DAY_OF_WEEK
+				is Year -> QueryType.YEAR
+				is Live -> QueryType.LIVE
+				is Online -> QueryType.ONLINE
+				is Weekday -> QueryType.WEEK_DAY
+				is Weekend-> QueryType.WEEK_END
+
+/*				is Today -> QueryType.
+				is Yesterday -> R.string.yesterday
+				is TodayAndYesterday -> R.string.yesterday_and_today
+				is CurrentWeek -> R.string.current_week
+				is CurrentMonth -> R.string.current_month
+				is CurrentYear -> R.string.current_year
+				is PastDays -> R.string.period_in_days
+				is Limit -> R.string.limit
+				*/
+				is TableSize -> QueryType.TABLE_SIZE
+				is Game -> QueryType.GAME
+				is Bankroll -> QueryType.BANKROLL
+				is Location -> QueryType.LOCATION
+				is TournamentName -> QueryType.TOURNAMENT_NAME
+				is AnyTournamentFeature -> QueryType.ANY_TOURNAMENT_FEATURES
+				is AllTournamentFeature -> QueryType.ALL_TOURNAMENT_FEATURES
+				is ResultMoreThan -> QueryType.MORE_THAN_NET_RESULT
+				is ResultLessThan -> QueryType.LESS_THAN_NET_RESULT
+				else -> throw FilterValueMapException("no filter type for $this") //TODO create exception
+			}
+		}
+
+	fun contains(filterElements: List<FilterElement>) : Boolean {
+		return when (this) {
+			is DataFilterElementRow -> filterElements.any {
+				it.ids.contains(this.id)
+			}
+			else -> return true
+		}
+	}
+
+
+	override val resId: Int?
+		get() {
+			return when (this) {
+				is Cash -> R.string.cash_game
+				is Tournament -> R.string.tournament
+				is Today -> R.string.today
+				is Yesterday -> R.string.yesterday
+				is TodayAndYesterday -> R.string.yesterday_and_today
+				is CurrentWeek -> R.string.current_week
+				is CurrentMonth -> R.string.current_month
+				is CurrentYear -> R.string.current_year
+				is From -> R.string.from
+				is To -> R.string.to
+				is Live -> R.string.live
+				is Online -> R.string.online
+				is Weekday -> R.string.week_days
+				is Weekend-> R.string.weekend
+				is Year-> R.string.year
+				is Month-> R.string.month_of_the_year
+				is Day -> R.string.day_of_the_week
+				is PastDays -> R.string.period_in_days
+				is Limit -> R.string.limit
+				is TableSize -> R.string.table_size
+				is Blind -> TODO()
+				is ResultMoreThan -> TODO()
+				is ResultLessThan -> TODO()
+				else -> null
+			}
+		}
+
+	override fun getDisplayName(): String {
+		return when (this) {
+			is DataFilterElementRow -> this.name
+			else -> return super.getDisplayName()
+		}
+	}
+
+	override val viewType: Int = RowViewType.TITLE_CHECK.ordinal
+
+	val sectionToExclude : List < FilterSectionRow > ?
+		get() {
+			val excluded = arrayListOf<FilterSectionRow>()
+			if (!this.filterSectionRow.allowMultiSelection) {
+				excluded.add(this.filterSectionRow)
+			}
+			this.filterSectionRow.exclusiveWith?.let { exclusives ->
+				excluded.addAll(exclusives)
+			}
+
+			if (excluded.size > 0) {
+				return excluded
+			}
+			return null
+		}
+
+	/*
+	override fun editingDescriptors(map: Map<String, Any?>): ArrayList<RowRepresentableEditDescriptor>? {
+		when (this) {
+			PAST_DAYS -> {
+				val defaultValue: String? by map
+				val data = arrayListOf<RowRepresentableEditDescriptor>()
+				data.add(
+					RowRepresentableEditDescriptor(
+						defaultValue,
+						inputType = InputType.TYPE_CLASS_NUMBER
+					)
+				)
+			}
+		}
+
+		return super.editingDescriptors(map)
+	}
+	*/
+}
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterRow.kt
deleted file mode 100644
index f57c2b64..00000000
--- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterRow.kt
+++ /dev/null
@@ -1,189 +0,0 @@
-package net.pokeranalytics.android.ui.view.rowrepresentable
-
-import io.realm.Realm
-import net.pokeranalytics.android.R
-import net.pokeranalytics.android.model.LiveData
-import net.pokeranalytics.android.ui.view.RowRepresentable
-import net.pokeranalytics.android.ui.view.RowViewType
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSection.*
-import java.lang.Exception
-import java.util.*
-
-sealed class FilterElement : RowRepresentable {
-
-	companion object {
-	    fun filterElementsFor(filterSection: FilterSectionDataSource) : List<FilterElement> {
-			return when (filterSection) {
-				CASH_TOURNAMENT -> arrayListOf(Cash, Tournament)
-				LIVE_ONLINE -> arrayListOf(Live, Online)
-				LIMIT_TYPE -> {
-					val limits = arrayListOf<Limit>()
-					net.pokeranalytics.android.model.Limit.values().forEach {
-						limits.add(FilterElement.Limit(it))
-					}
-					limits
-				}
-				TABLE_SIZE -> {
-					val tableSizes = arrayListOf<TableSize>()
-					net.pokeranalytics.android.model.TableSize.all.forEach {
-						tableSizes.add(FilterElement.TableSize(it))
-					}
-					tableSizes
-				}
-
-				DYNAMIC_DATE -> arrayListOf(Today, Yesterday, TodayAndYesterday, CurrentWeek, CurrentMonth, CurrentYear)
-				FIXED_DATE -> arrayListOf(From(), To())
-				DURATION -> arrayListOf()
-				WEEKDAYS_OR_WEEKEND -> arrayListOf(Weekday, Weekend)
-				DAY_OF_WEEK -> arrayListOf()
-				MONTH_OF_YEAR -> arrayListOf()
-				YEAR -> arrayListOf()
-
-				GAME -> {
-					val games = arrayListOf<Game>()
-					val realm = Realm.getDefaultInstance()
-					LiveData.GAME.items(realm).forEach {
-						val game = FilterElement.Game(it as net.pokeranalytics.android.model.realm.Game)
-						games.add(game)
-					}
-					realm.close()
-					games
-				}
-
-				LOCATION -> arrayListOf()
-				BANKROLL -> arrayListOf()
-
-				MULTI_TABLING -> arrayListOf()
-
-				BLINDS -> arrayListOf()
-				CASH_RE_BUY_COUNT -> arrayListOf()
-				BUY_IN -> arrayListOf()
-
-				COMPLETION_PERCENTAGE -> arrayListOf()
-				NUMBER_OF_PLAYERS -> arrayListOf()
-				TOURNAMENT_TYPE -> arrayListOf()
-				PLAYERS_COUNT -> arrayListOf()
-				PLACE -> arrayListOf()
-				TOURNAMENT_RE_BUY_COUNT -> arrayListOf()
-
-				MULTI_PLAYER -> arrayListOf()
-
-				RANGE -> arrayListOf()
-
-				SESSION_DURATION -> arrayListOf()
-
-				VALUE -> arrayListOf()
-
-				else -> throw Exception("unknown filtersection") //TODO create exception
-			}
-		}
-	}
-
-	object Cash : FilterElement()
-	object Tournament : FilterElement()
-	object Live : FilterElement()
-	object Online : FilterElement()
-	object Today : FilterElement()
-	object Yesterday : FilterElement()
-	object TodayAndYesterday : FilterElement()
-	object CurrentWeek : FilterElement()
-	object CurrentMonth : FilterElement()
-	object CurrentYear: FilterElement()
-	data class From(var date: Date = Date()) : FilterElement()
-	data class To(var date: Date = Date()) : FilterElement()
-	object Weekday: FilterElement()
-	object Weekend : FilterElement()
-	data class Year(val day: Int) : FilterElement()
-	data class Month(val day: Int) : FilterElement()
-	data class Day(val day: Int) : FilterElement()
-	data class PastDays(var lastDays : Int = 0) : FilterElement()
-	data class Limit(val limit : net.pokeranalytics.android.model.Limit) : FilterElement()
-	data class TableSize(val tableSize : net.pokeranalytics.android.model.TableSize) : FilterElement()
-	data class Bankroll(val bankroll: net.pokeranalytics.android.model.realm.Bankroll) : FilterElement()
-	data class Game(val game: net.pokeranalytics.android.model.realm.Game) : FilterElement()
-	data class Location(val location: net.pokeranalytics.android.model.realm.Location) : FilterElement()
-	data class TournamentName(val tournamentName: net.pokeranalytics.android.model.realm.TournamentName) : FilterElement()
-	data class TournamentFeature(val tournamentFeature: net.pokeranalytics.android.model.realm.TournamentFeature) : FilterElement()
-
-	var filterSection: FilterSectionDataSource? = null
-
-	override val resId: Int?
-		get() {
-			return when (this) {
-				is Cash -> R.string.cash_game
-				is Tournament -> R.string.tournament
-				is Today -> R.string.today
-				is Yesterday -> R.string.yesterday
-				is TodayAndYesterday -> R.string.yesterday_and_today
-				is CurrentWeek -> R.string.current_week
-				is CurrentMonth -> R.string.current_month
-				is CurrentYear -> R.string.current_year
-				is From -> R.string.from
-				is To -> R.string.to
-				is Live -> R.string.live
-				is Online -> R.string.online
-				is Weekday -> R.string.week_days
-				is Weekend-> R.string.weekend
-				is Year-> R.string.year
-				is Month-> R.string.month_of_the_year
-				is Day -> R.string.day_of_the_week
-				is PastDays -> R.string.period_in_days
-				is Limit -> R.string.limit
-				is TableSize -> R.string.table_size
-				is Bankroll -> R.string.bankroll
-				is Game -> R.string.game
-				is Location -> R.string.location
-				is TournamentName -> R.string.tournament_name
-				is TournamentFeature -> R.string.tournament_feature
-			}
-		}
-
-	override fun getDisplayName(): String {
-		return when (this) {
-			is Game -> game.getDisplayName()
-			else -> return super.getDisplayName()
-		}
-	}
-
-	override val viewType: Int = RowViewType.TITLE_CHECK.ordinal
-
-	val sectionToExclude : List < FilterSectionDataSource > ?
-		get() {
-			val excluded = arrayListOf<FilterSectionDataSource>()
-			this.filterSection?.let {
-				if (!it.allowMultiSelection) {
-					excluded.add(it)
-				}
-				it.exclusiveWith?.let { exclusives ->
-					excluded.addAll(exclusives)
-				}
-
-				if (excluded.size > 0) {
-                    return excluded
-				}
-			} ?: run {
-				return null
-			}
-
-			return null
-		}
-
-	/*
-	override fun editingDescriptors(map: Map<String, Any?>): ArrayList<RowRepresentableEditDescriptor>? {
-		when (this) {
-			PAST_DAYS -> {
-				val defaultValue: String? by map
-				val data = arrayListOf<RowRepresentableEditDescriptor>()
-				data.add(
-					RowRepresentableEditDescriptor(
-						defaultValue,
-						inputType = InputType.TYPE_CLASS_NUMBER
-					)
-				)
-			}
-		}
-
-		return super.editingDescriptors(map)
-	}
-	*/
-}
\ No newline at end of file
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSection.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt
similarity index 64%
rename from app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSection.kt
rename to app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt
index 92ccbab1..084c5676 100644
--- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSection.kt
+++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt
@@ -1,50 +1,12 @@
 package net.pokeranalytics.android.ui.view.rowrepresentable
 
+import io.realm.Realm
+import net.pokeranalytics.android.model.LiveData
 import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.RowViewType
-import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategory.*
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.*
 
-interface FilterSectionDataSource : RowRepresentable {
-	enum class SelectionType {
-		SINGLE,
-		MULTIPLE,
-	}
-
-	val allowMultiSelection : Boolean
-	val exclusiveWith : List < FilterSectionDataSource > ?
-	val filterElementRows : List < FilterElement >
-	val filterElements : List < RowRepresentable >
-	val selectionType : SelectionType
-}
-
-private interface DefaultFilterSectionDataSource : FilterSectionDataSource {
-	override val viewType: Int
-		get() = RowViewType.HEADER_TITLE.ordinal
-
-	override val exclusiveWith: List<FilterSectionDataSource>?
-		get() = null
-
-	override val allowMultiSelection : Boolean
-		get() = (this.selectionType == FilterSectionDataSource.SelectionType.MULTIPLE)
-
-	override val selectionType: FilterSectionDataSource.SelectionType
-		get() = FilterSectionDataSource.SelectionType.MULTIPLE
-
-	override val filterElementRows: List < FilterElement >
-		get() = FilterElement.filterElementsFor(this)
-
-	override val filterElements : List < RowRepresentable >
-		get() {
-			val elements = arrayListOf<RowRepresentable>(this)
-			filterElementRows.forEach {
-				it.filterSection = this
-				elements.add(it)
-			}
-			return elements
-		}
-}
-
-enum class FilterSection(override val resId: Int?): DefaultFilterSectionDataSource, RowRepresentable {
+enum class FilterSectionRow(override val resId: Int?): RowRepresentable {
 	CASH_TOURNAMENT(net.pokeranalytics.android.R.string.cash_or_tournament),
     LIVE_ONLINE(net.pokeranalytics.android.R.string.live_or_online),
     GAME(net.pokeranalytics.android.R.string.games),
@@ -62,6 +24,8 @@ enum class FilterSection(override val resId: Int?): DefaultFilterSectionDataSour
 	BLINDS(net.pokeranalytics.android.R.string.blinds),
 	CASH_RE_BUY_COUNT(net.pokeranalytics.android.R.string.cash_game),
 	TOURNAMENT_TYPE(net.pokeranalytics.android.R.string.tournament_types),
+	TOURNAMENT_NAME(net.pokeranalytics.android.R.string.tournament_name),
+	TOURNAMENT_FEATURE(net.pokeranalytics.android.R.string.tournament_feature),
 	COMPLETION_PERCENTAGE(net.pokeranalytics.android.R.string.tournament_completion_percentage_interval),
 	PLACE(net.pokeranalytics.android.R.string.final_position),
 	PLAYERS_COUNT(net.pokeranalytics.android.R.string.players_count),
@@ -75,72 +39,106 @@ enum class FilterSection(override val resId: Int?): DefaultFilterSectionDataSour
 	MULTI_PLAYER(net.pokeranalytics.android.R.string.multiplayer),
 	;
 
+	private enum class SelectionType {
+		SINGLE,
+		MULTIPLE,
+	}
 
-	companion object {
-		fun filterSectionsFor(category: FilterCategory) : List < FilterSection > {
-			return when (category) {
-				GENERAL -> arrayListOf(
-					CASH_TOURNAMENT,
-					LIVE_ONLINE,
-					GAME, LIMIT_TYPE,
-					TABLE_SIZE
-				)
-				DATE -> arrayListOf(
-					DYNAMIC_DATE,
-					FIXED_DATE,
-					DURATION,
-					YEAR,
-					WEEKDAYS_OR_WEEKEND,
-					DAY_OF_WEEK,
-					MONTH_OF_YEAR
-				)
-				BANKROLLS -> arrayListOf(
-					BANKROLL
-				)
-				CASH -> arrayListOf(
-					BLINDS,
-					CASH_RE_BUY_COUNT
-				)
-				TOURNAMENT -> arrayListOf(
-					TOURNAMENT_TYPE,
-					COMPLETION_PERCENTAGE,
-					PLACE,
-					PLAYERS_COUNT,
-					TOURNAMENT_RE_BUY_COUNT,
-					BUY_IN
-				)
-				ONLINE -> arrayListOf(
-					MULTI_TABLING
-				)
-				LOCATIONS -> arrayListOf(
-					LOCATION
-				)
-				PLAYERS -> arrayListOf(
-					NUMBER_OF_PLAYERS,
-					MULTI_PLAYER
-				)
-				RESULT -> arrayListOf(
-					VALUE
-				)
+	override val viewType: Int = RowViewType.HEADER_TITLE.ordinal
 
-				TIME_FRAME -> arrayListOf()
-				SESSION -> arrayListOf()
-				TRANSACTION_TYPES -> arrayListOf()
-			}
+	val allowMultiSelection : Boolean
+		get() = (this.selectionType == SelectionType.MULTIPLE)
+
+	val filterElements : List < RowRepresentable > by lazy {
+		arrayListOf<RowRepresentable>(this).apply {
+			this.addAll(
+				when (this@FilterSectionRow) {
+					CASH_TOURNAMENT -> arrayListOf(Cash, Tournament)
+					LIVE_ONLINE -> arrayListOf(Live, Online)
+					LIMIT_TYPE -> {
+						val limits = arrayListOf<FilterElementRow.Limit>()
+						net.pokeranalytics.android.model.Limit.values().forEach {
+							limits.add(Limit(it))
+						}
+						limits
+					}
+					TABLE_SIZE -> {
+						val tableSizes = arrayListOf<FilterElementRow.TableSize>()
+						net.pokeranalytics.android.model.TableSize.all.forEach {
+							tableSizes.add(TableSize(it))
+						}
+						tableSizes
+					}
+					TOURNAMENT_NAME -> arrayListOf()
+					TOURNAMENT_FEATURE -> arrayListOf()
+					DYNAMIC_DATE -> arrayListOf(
+						Today,
+						Yesterday,
+						TodayAndYesterday,
+						CurrentWeek,
+						CurrentMonth,
+						CurrentYear
+					)
+					FIXED_DATE -> arrayListOf(From(), To())
+					DURATION -> arrayListOf()
+					WEEKDAYS_OR_WEEKEND -> arrayListOf(Weekday, Weekend)
+					DAY_OF_WEEK -> arrayListOf()
+					MONTH_OF_YEAR -> arrayListOf()
+					YEAR -> arrayListOf()
+
+					GAME -> {
+						val games = arrayListOf<FilterElementRow.Game>()
+						val realm = Realm.getDefaultInstance()
+						LiveData.GAME.items(realm).forEach {
+							val game = Game(it as net.pokeranalytics.android.model.realm.Game)
+							games.add(game)
+						}
+						realm.close()
+						games
+					}
+
+					LOCATION -> arrayListOf()
+					BANKROLL -> arrayListOf()
+
+					MULTI_TABLING -> arrayListOf()
+
+					BLINDS -> arrayListOf()
+					CASH_RE_BUY_COUNT -> arrayListOf()
+					BUY_IN -> arrayListOf()
+
+					COMPLETION_PERCENTAGE -> arrayListOf()
+					NUMBER_OF_PLAYERS -> arrayListOf()
+					TOURNAMENT_TYPE -> arrayListOf()
+					PLAYERS_COUNT -> arrayListOf()
+					PLACE -> arrayListOf()
+					TOURNAMENT_RE_BUY_COUNT -> arrayListOf()
+
+					MULTI_PLAYER -> arrayListOf()
+
+					RANGE -> arrayListOf()
+
+					SESSION_DURATION -> arrayListOf()
+
+					VALUE -> arrayListOf()
+
+				}.apply {
+					this.forEach {
+						it.filterSectionRow = this@FilterSectionRow
+					}
+				}
+			)
 		}
 	}
 
-	override val viewType: Int = RowViewType.HEADER_TITLE.ordinal
-
-	override val selectionType: FilterSectionDataSource.SelectionType
+	private val selectionType: SelectionType
 		get() {
 			return when (this) {
-				CASH_TOURNAMENT, DYNAMIC_DATE, LIVE_ONLINE -> FilterSectionDataSource.SelectionType.SINGLE
-				else -> FilterSectionDataSource.SelectionType.MULTIPLE
+				CASH_TOURNAMENT, DYNAMIC_DATE, LIVE_ONLINE -> SelectionType.SINGLE
+				else -> SelectionType.MULTIPLE
 			}
 		}
 
-	override val exclusiveWith: List<FilterSection>?
+	val exclusiveWith: List<FilterSectionRow>?
 		get() {
 			return when (this) {
 				DYNAMIC_DATE -> arrayListOf(FIXED_DATE)
@@ -180,7 +178,7 @@ enum class FilterSection(override val resId: Int?): DefaultFilterSectionDataSour
 				val games = realm.copyFromRealm(LiveData.GAME.items(realm) as RealmResults<Game>)
 				rows.addAll(games)
 			}
-			LIMIT_TYPE -> rows.addAll(Limit.values())
+			LIMIT_TYPE -> rows.addAll(Limit.numericValues())
 			TABLE_SIZE -> {
 				val sessions = realm.where<Session>().sort("tableSize").distinct("tableSize").findAll()
 				for (session in sessions) {
diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/SessionRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/SessionRow.kt
index c3aca78c..92c431a6 100644
--- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/SessionRow.kt
+++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/SessionRow.kt
@@ -160,7 +160,7 @@ enum class SessionRow : RowRepresentable {
 			BUY_IN -> {
 				val bb: Double? by map
 				val fee: Double? by map
-				val buyin: Double? by map
+				val ratedBuyin: Double? by map
 				val data = arrayListOf<RowRepresentableEditDescriptor>()
 				if (bb != null) {
 					data.add(RowRepresentableEditDescriptor(100.0 * (bb?: 0.0)))
@@ -173,7 +173,7 @@ enum class SessionRow : RowRepresentable {
 					data.add(RowRepresentableEditDescriptor(0))
 				}
 
-				data.add(RowRepresentableEditDescriptor(buyin))
+				data.add(RowRepresentableEditDescriptor(ratedBuyin))
 				data.add(
 					RowRepresentableEditDescriptor(
 						"",
diff --git a/app/src/main/java/net/pokeranalytics/android/util/extensions/DateExtension.kt b/app/src/main/java/net/pokeranalytics/android/util/extensions/DateExtension.kt
index d24c1712..6ef27c60 100644
--- a/app/src/main/java/net/pokeranalytics/android/util/extensions/DateExtension.kt
+++ b/app/src/main/java/net/pokeranalytics/android/util/extensions/DateExtension.kt
@@ -91,7 +91,7 @@ fun Date.getFormattedDuration(toDate: Date) : String {
     val hours = (difference / (1000 * 60 * 60))
     val minutes = (difference / (1000 * 60)) % 60
 
-    val hoursStr = if (hours < 10) "0$hours" else "$hours"
+    val hoursStr = "$hours"
     val minutesStr = if (minutes < 10) "0$minutes" else "$minutes"
 
     return "$hoursStr:$minutesStr"
diff --git a/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt b/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt
index d98df6b0..77287988 100644
--- a/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt
+++ b/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt
@@ -41,7 +41,7 @@ fun Long.toMinutes() : String {
     val hours = totalMinutes / 60
     val minutesLeft = totalMinutes % 60
     var duration = ""
-    duration += if (hours < 10) "0$hours" else hours.toString()
+    duration += hours.toString()
     duration += ":"
     duration += if (minutesLeft < 10) "0$minutesLeft" else minutesLeft.toString()
     return duration
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 1671c816..103e5626 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -13,7 +13,7 @@
 	<string name="number_of_groups">Number of sessions</string>
 	<string name="number_of_games">Number of games</string>
 	<string name="average_duration">Average duration</string>
-	<string name="net_bb_per_100_hands">Net(BB) per 100 hands</string>
+	<string name="net_bb_per_100_hands">Net per 100 hands (BB)</string>
 	<string name="hourly_rate_bb">Hourly rate (BB)</string>
 	<string name="average_net_bb">Average net (BB)</string>
 	<string name="roi">ROI</string>