add new filter

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

@@ -1,21 +1,35 @@
 package net.pokeranalytics.android.filter
 
+import io.realm.RealmList
 import net.pokeranalytics.android.RealmInstrumentedUnitTest
-import net.pokeranalytics.android.model.realm.Bankroll
+import net.pokeranalytics.android.model.realm.*
-import net.pokeranalytics.android.model.realm.Session
 import java.util.*
 
 open class BaseFilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
 
     // convenience extension
     fun Session.Companion.testInstance(
-        netResult: Double,
+        netResult: Double = 0.0,
-        isTournament: Boolean,
+        isTournament: Boolean = false,
-        startDate: Date,
+        startDate: Date = Date(),
         endDate: Int = 1,
-        bankroll: Bankroll? = null
+        bankroll: Bankroll? = null,
-    ): Session {
+        game: Game? = null,
+        location : Location? = null,
+        tournamentName: TournamentName? = null,
+        tournamentFeatures: RealmList<TournamentFeature> = RealmList(),
+        numberOfTable: Int = 1,
+        limit: Int? = null,
+        tableSize: Int? = null
+        ): Session {
         val session: Session = Session.newInstance(super.mockRealm, isTournament, bankroll)
+        session.game = game
+        session.location = location
+        session.tournamentFeatures = tournamentFeatures
+        session.tournamentName = tournamentName
+        session.limit = limit
+        session.numberOfTables = numberOfTable
+        session.tableSize = tableSize
         session.result?.netResult = netResult
         session.startDate = startDate
         val cal = Calendar.getInstance() // creates calendar

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

@@ -0,0 +1,205 @@
+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 org.junit.Assert
+import org.junit.Test
+import java.util.*
+
+class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
+    @Test
+    fun testSingleBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        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 sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun testSingleBlindNoSmallBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "sb" to null,
+            "bb" to 1.0,
+            "code" to null
+        )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun testSingleBlindCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        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 sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions.map {
+            Assert.assertEquals(s3.id, (it as Session).id)
+        }
+    }
+
+    @Test
+    fun testMultiBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 2.0
+        s2.cgSmallBlind = 1.0
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        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(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        }
+    }
+}

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

@@ -3,8 +3,7 @@ package net.pokeranalytics.android.filter
 import androidx.test.ext.junit.runners.AndroidJUnit4
 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.*
-import net.pokeranalytics.android.model.realm.Session
 import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -111,39 +110,19 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
     }
 
     @Test
-    fun testSingleBlindNoCurrencyFilter() {
+    fun testBankrollFilter() {
-
         val realm = this.mockRealm
         realm.beginTransaction()
-
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
-        currency.code = "AUD"
-
         val b1 = realm.createObject(Bankroll::class.java, "1")
         val b2 = realm.createObject(Bankroll::class.java, "2")
-        b2.currency = currency
+        b1.live = false
-
+        b2.live = true
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Session.testInstance(bankroll = b1)
-        s1.cgBigBlind = 1.0
+        Session.testInstance(bankroll = b2)
-        s1.cgSmallBlind = 0.5
-
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
-        s2.cgBigBlind = 1.0
-        s2.cgSmallBlind = 0.5
-
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
-        s3.cgBigBlind = 2.0
-        s3.cgSmallBlind = 1.0
-
         realm.commitTransaction()
 
-
+        val filter = SessionFilterable.BANKROLL
-        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("ids" to arrayOf(b1.id))
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
-            "sb" to 0.5,
-            "bb" to 1.0,
-            "code" to null
-        )))
 
         val sessions = FilterManager().filter(
             realm,
@@ -151,46 +130,60 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             arrayListOf(filter)
         )
 
-        Assert.assertEquals(2, sessions.size)
+        Assert.assertEquals(1, sessions.size)
-        sessions.map {
+        (sessions[0] as Session).bankroll?.run {
-            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+            Assert.assertEquals(b1.id, this.id)
         }
     }
 
     @Test
-    fun testSingleBlindNoSmallBlindNoCurrencyFilter() {
+    fun testMultipleBankrollFilter() {
-
         val realm = this.mockRealm
         realm.beginTransaction()
-
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
-        currency.code = "AUD"
-
         val b1 = realm.createObject(Bankroll::class.java, "1")
         val b2 = realm.createObject(Bankroll::class.java, "2")
-        b2.currency = currency
+        val b3 = realm.createObject(Bankroll::class.java, "3")
+        Session.testInstance(bankroll = b1)
+        Session.testInstance(bankroll = b2)
+        Session.testInstance(bankroll = b3)
+        Session.testInstance(bankroll = b1)
+        Session.testInstance(bankroll = b2)
+        Session.testInstance(bankroll = b3)
+        Session.testInstance(bankroll = b1)
+        Session.testInstance(bankroll = b2)
+        Session.testInstance(bankroll = b3)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.BANKROLL
+        filter.valueMap = mapOf("ids" to arrayOf(b1.id, b2.id))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Assert.assertEquals(6, sessions.size)
-        s1.cgBigBlind = 1.0
-        s1.cgSmallBlind = 0.5
 
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val result = arrayListOf(b1.id, b2.id)
-        s2.cgBigBlind = 1.0
-        s2.cgSmallBlind = 0.5
 
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        sessions.forEach {
-        s3.cgBigBlind = 2.0
+            Assert.assertTrue(result.contains((it as Session).bankroll?.id))
-        s3.cgSmallBlind = 1.0
+        }
+    }
 
+    @Test
+    fun testGameFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val g1 = realm.createObject(Game::class.java, "1")
+        val g2 = realm.createObject(Game::class.java, "2")
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
         realm.commitTransaction()
 
-
+        val filter = SessionFilterable.GAME
-        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("ids" to arrayOf(g2.id))
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
-            "sb" to null,
-            "bb" to 1.0,
-            "code" to null
-        )))
 
         val sessions = FilterManager().filter(
             realm,
@@ -198,46 +191,60 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             arrayListOf(filter)
         )
 
-        Assert.assertEquals(2, sessions.size)
+        Assert.assertEquals(1, sessions.size)
-        sessions.map {
+        (sessions[0] as Session).game?.run {
-            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+            Assert.assertEquals(g2.id, this.id)
         }
     }
 
     @Test
-    fun testSingleBlindCurrencyFilter() {
+    fun testMultipleGameFilter() {
-
         val realm = this.mockRealm
         realm.beginTransaction()
+        val g1 = realm.createObject(Game::class.java, "1")
+        val g2 = realm.createObject(Game::class.java, "2")
+        val g3 = realm.createObject(Game::class.java, "3")
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
+        Session.testInstance(game = g3)
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
+        Session.testInstance(game = g3)
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
+        Session.testInstance(game = g3)
+        realm.commitTransaction()
 
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        val filter = SessionFilterable.GAME
-        currency.code = "AUD"
+        filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id))
 
-        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val sessions = FilterManager().filter(
-        val b2 = realm.createObject(Bankroll::class.java, "2")
+            realm,
-        b2.currency = currency
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Assert.assertEquals(6, sessions.size)
-        s1.cgBigBlind = 1.0
-        s1.cgSmallBlind = 0.5
 
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val result = arrayListOf(g2.id, g3.id)
-        s2.cgBigBlind = 1.0
-        s2.cgSmallBlind = 0.5
 
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        sessions.forEach {
-        s3.cgBigBlind = 2.0
+            Assert.assertTrue(result.contains((it as Session).game?.id))
-        s3.cgSmallBlind = 1.0
+        }
+    }
 
+    @Test
+    fun testLocationFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val l1 = realm.createObject(Location::class.java, "1")
+        val l2 = realm.createObject(Location::class.java, "2")
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
         realm.commitTransaction()
 
-
+        val filter = SessionFilterable.LOCATION
-        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("ids" to arrayOf(l1.id))
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
-            "sb" to 1.0,
-            "bb" to 2.0,
-            "code" to "AUD"
-        )))
 
         val sessions = FilterManager().filter(
             realm,
@@ -246,51 +253,92 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         )
 
         Assert.assertEquals(1, sessions.size)
-        sessions.map {
+        (sessions[0] as Session).location?.run {
-            Assert.assertEquals(s3.id, (it as Session).id)
+            Assert.assertEquals(l1.id, this.id)
         }
     }
 
     @Test
-    fun testMultiBlindNoCurrencyFilter() {
+    fun testMultipleLocationFilter() {
-
         val realm = this.mockRealm
         realm.beginTransaction()
+        val l1 = realm.createObject(Location::class.java, "1")
+        val l2 = realm.createObject(Location::class.java, "2")
+        val l3 = realm.createObject(Location::class.java, "3")
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
+        Session.testInstance(location = l3)
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
+        Session.testInstance(location = l3)
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
+        Session.testInstance(location = l3)
+        realm.commitTransaction()
 
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        val filter = SessionFilterable.LOCATION
-        currency.code = "AUD"
+        filter.valueMap = mapOf("ids" to arrayOf(l1.id, l3.id))
 
-        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val sessions = FilterManager().filter(
-        val b2 = realm.createObject(Bankroll::class.java, "2")
+            realm,
-        b2.currency = currency
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Assert.assertEquals(6, sessions.size)
-        s1.cgBigBlind = 1.0
-        s1.cgSmallBlind = 0.5
 
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val result = arrayListOf(l2.id, l3.id)
-        s2.cgBigBlind = 2.0
-        s2.cgSmallBlind = 1.0
 
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        sessions.forEach {
-        s3.cgBigBlind = 2.0
+            Assert.assertTrue(result.contains((it as Session).location?.id))
-        s3.cgSmallBlind = 1.0
+        }
+    }
 
+    @Test
+    fun testTournamentNameFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val t1 = realm.createObject(TournamentName::class.java, "1")
+        val t2 = realm.createObject(TournamentName::class.java, "2")
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
         realm.commitTransaction()
 
+        val filter = SessionFilterable.TOURNAMENT_NAME
+        filter.valueMap = mapOf("ids" to arrayOf(t1.id))
 
-        val filter = SessionFilterable.BLINDS
+        val sessions = FilterManager().filter(
-        filter.valueMap = mapOf("map" to arrayOf(
+            realm,
-            mapOf(
+            Session::class.java,
-            "sb" to 1.0,
+            arrayListOf(filter)
-            "bb" to 2.0,
+        )
-            "code" to null
+
-            ),
+        Assert.assertEquals(1, sessions.size)
-            mapOf(
+        (sessions[0] as Session).tournamentName?.run {
-            "sb" to 0.5,
+            Assert.assertEquals(t1.id, this.id)
-            "bb" to 1.0,
+        }
-            "code" to null
+    }
-            )))
+
+    @Test
+    fun testMultipleTournamentNameFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val t1 = realm.createObject(TournamentName::class.java, "1")
+        val t2 = realm.createObject(TournamentName::class.java, "2")
+        val t3 = realm.createObject(TournamentName::class.java, "3")
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
+        Session.testInstance(tournamentName = t3)
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
+        Session.testInstance(tournamentName = t3)
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
+        Session.testInstance(tournamentName = t3)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.TOURNAMENT_NAME
+        filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id))
 
         val sessions = FilterManager().filter(
             realm,
@@ -298,9 +346,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             arrayListOf(filter)
         )
 
-        Assert.assertEquals(2, sessions.size)
+        Assert.assertEquals(6, sessions.size)
-        sessions.map {
+
-            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        val result = arrayListOf(t1.id, t2.id)
+
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).tournamentName?.id))
         }
     }
 }

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

@@ -6,34 +6,32 @@ import net.pokeranalytics.android.exceptions.FilterValueMapException
 import net.pokeranalytics.android.model.filter.interfaces.Filterable
 import net.pokeranalytics.android.model.realm.Session
 
-enum class SessionFilterable: Filterable {
+enum class SessionFilterable(private var fieldName:String? = null): Filterable {
     LIVE,
     CASH,
     ONLINE,
     TOURNAMENT,
-    BANKROLL,
+    BANKROLL("bankroll.id"),
+    GAME("game.id"),
+    TOURNAMENT_NAME("tournamentName.id"),
+    ANY_TOURNAMENT_FEATURES("tournamentFeature.id"),
+    ALL_TOURNAMENT_FEATURES("tournamentFeature.id"),
+    LOCATION("location.id"),
+    LIMIT("limit"),
+    TABLE_SIZE("tableSize"),
+    NUMBER_OF_TABLE("numberOfTable"),
+    TOURNAMENT_TYPE("tournamentType"),
     BLINDS,
     ;
 
     private enum class Field(var fieldName:String) {
         LIVE("bankroll.live"),
         CASH("type"),
-        BANKROLL("bankroll.id"),
-        START_DATE("startDate"),
-        END_DATE("endDate"),
         CURRENCY("bankroll.currency"),
         CURRENCY_CODE("bankroll.currency.code"),
         BIG_BLIND("cgBigBlind"),
         SMALL_BLIND("cgSmallBlind"),
-        GAME("game.id"),
-        LIMIT("limit"),
-        TABLE_SIZE("tableSize"),
-        LOCATION("location.id"),
-        NUMBER_OF_TABLE("numberOfTable"),
         COMMENT("comment"),
-        TOURNAMENT_TYPE("tournamentType"),
-        TOURNAMENT_NAME("tournamentName.id"),
-        TOURNAMENT_FEATURES("tournamentFeature.id"),
         TOURNAMENT_NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
         TOURNAMENT_ENTRY_FEE("tournamentEntryFee"),
         RESULT_BUY_IN("result.buyin"),
@@ -48,7 +46,8 @@ enum class SessionFilterable: Filterable {
     override val filterValuesExceptedKeys : Array<String>?
         get() {
             return when (this) {
-                BANKROLL -> arrayOf("ids")
+                BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> arrayOf("ids")
+                LIMIT, TOURNAMENT_TYPE, TABLE_SIZE, NUMBER_OF_TABLE -> arrayOf("values")
                 BLINDS -> arrayOf("map")
                 else -> null
             }
@@ -60,9 +59,40 @@ enum class SessionFilterable: Filterable {
             CASH -> realmQuery.equalTo(Field.CASH.fieldName, Session.Type.CASH_GAME.ordinal)
             ONLINE -> LIVE.filter(realmQuery.not())
             TOURNAMENT -> CASH.filter(realmQuery.not())
-            BANKROLL -> {
+            ALL_TOURNAMENT_FEATURES -> {
                 val ids : Array<String> by filterValues
-                realmQuery.`in`(Field.BANKROLL.fieldName, ids)
+                this.fieldName?.let {fieldName ->
+                    ids.forEachIndexed { index, id ->
+                        if (index == 0) {
+                            realmQuery.beginGroup()
+                        }
+                        realmQuery.`in`(fieldName, arrayOf(id))
+                        if (index == ids.size - 1) {
+                            realmQuery.endGroup()
+                        } else {
+                            realmQuery.and()
+                        }
+                    }
+                    realmQuery
+                } ?: run {
+                    throw FilterValueMapException("fieldName is missing")
+                }
+            }
+            BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, 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, NUMBER_OF_TABLE -> {
+                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