diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/BaseFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/BaseFilterInstrumentedUnitTest.kt index 1611beb9..3b80c3c2 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/filter/BaseFilterInstrumentedUnitTest.kt +++ b/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.Session +import net.pokeranalytics.android.model.realm.* import java.util.* open class BaseFilterInstrumentedUnitTest : RealmInstrumentedUnitTest() { // convenience extension fun Session.Companion.testInstance( - netResult: Double, - isTournament: Boolean, - startDate: Date, + netResult: Double = 0.0, + isTournament: Boolean = false, + startDate: Date = Date(), endDate: Int = 1, - bankroll: Bankroll? = null - ): Session { + bankroll: Bankroll? = null, + game: Game? = null, + location : Location? = null, + tournamentName: TournamentName? = null, + tournamentFeatures: RealmList = 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 diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt new file mode 100644 index 00000000..a3ffd4a9 --- /dev/null +++ b/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)) + } + } +} \ 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 fe8263b1..35c6b3c7 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt +++ b/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.Session +import net.pokeranalytics.android.model.realm.* 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 - - 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 - + b1.live = false + b2.live = true + Session.testInstance(bankroll = b1) + Session.testInstance(bankroll = b2) 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 = SessionFilterable.BANKROLL + filter.valueMap = mapOf("ids" to arrayOf(b1.id)) val sessions = FilterManager().filter( realm, @@ -151,46 +130,60 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { arrayListOf(filter) ) - Assert.assertEquals(2, sessions.size) - sessions.map { - Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id)) + Assert.assertEquals(1, sessions.size) + (sessions[0] as Session).bankroll?.run { + 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) - s1.cgBigBlind = 1.0 - s1.cgSmallBlind = 0.5 + Assert.assertEquals(6, sessions.size) - val s2 = Session.testInstance(100.0, false, Date(), 1, b1) - s2.cgBigBlind = 1.0 - s2.cgSmallBlind = 0.5 + val result = arrayListOf(b1.id, b2.id) - val s3 = Session.testInstance(100.0, false, Date(), 1, b1) - s3.cgBigBlind = 2.0 - s3.cgSmallBlind = 1.0 + sessions.forEach { + Assert.assertTrue(result.contains((it as Session).bankroll?.id)) + } + } + @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.BLINDS - filter.valueMap = mapOf("map" to arrayOf(mapOf( - "sb" to null, - "bb" to 1.0, - "code" to null - ))) + val filter = SessionFilterable.GAME + filter.valueMap = mapOf("ids" to arrayOf(g2.id)) val sessions = FilterManager().filter( realm, @@ -198,46 +191,60 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { arrayListOf(filter) ) - Assert.assertEquals(2, sessions.size) - sessions.map { - Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id)) + Assert.assertEquals(1, sessions.size) + (sessions[0] as Session).game?.run { + 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") - currency.code = "AUD" + val filter = SessionFilterable.GAME + filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id)) - val b1 = realm.createObject(Bankroll::class.java, "1") - val b2 = realm.createObject(Bankroll::class.java, "2") - b2.currency = currency + val sessions = FilterManager().filter( + realm, + Session::class.java, + arrayListOf(filter) + ) - val s1 = Session.testInstance(100.0, false, Date(), 1, b1) - s1.cgBigBlind = 1.0 - s1.cgSmallBlind = 0.5 + Assert.assertEquals(6, sessions.size) - val s2 = Session.testInstance(100.0, false, Date(), 1, b1) - s2.cgBigBlind = 1.0 - s2.cgSmallBlind = 0.5 + val result = arrayListOf(g2.id, g3.id) - val s3 = Session.testInstance(100.0, false, Date(), 1, b2) - s3.cgBigBlind = 2.0 - s3.cgSmallBlind = 1.0 + sessions.forEach { + Assert.assertTrue(result.contains((it as Session).game?.id)) + } + } + @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.BLINDS - filter.valueMap = mapOf("map" to arrayOf(mapOf( - "sb" to 1.0, - "bb" to 2.0, - "code" to "AUD" - ))) + val filter = SessionFilterable.LOCATION + filter.valueMap = mapOf("ids" to arrayOf(l1.id)) val sessions = FilterManager().filter( realm, @@ -246,51 +253,92 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { ) Assert.assertEquals(1, sessions.size) - sessions.map { - Assert.assertEquals(s3.id, (it as Session).id) + (sessions[0] as Session).location?.run { + 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") - currency.code = "AUD" + val filter = SessionFilterable.LOCATION + filter.valueMap = mapOf("ids" to arrayOf(l1.id, l3.id)) - val b1 = realm.createObject(Bankroll::class.java, "1") - val b2 = realm.createObject(Bankroll::class.java, "2") - b2.currency = currency + val sessions = FilterManager().filter( + realm, + Session::class.java, + arrayListOf(filter) + ) - val s1 = Session.testInstance(100.0, false, Date(), 1, b1) - s1.cgBigBlind = 1.0 - s1.cgSmallBlind = 0.5 + Assert.assertEquals(6, sessions.size) - val s2 = Session.testInstance(100.0, false, Date(), 1, b1) - s2.cgBigBlind = 2.0 - s2.cgSmallBlind = 1.0 + val result = arrayListOf(l2.id, l3.id) - val s3 = Session.testInstance(100.0, false, Date(), 1, b2) - s3.cgBigBlind = 2.0 - s3.cgSmallBlind = 1.0 + sessions.forEach { + Assert.assertTrue(result.contains((it as Session).location?.id)) + } + } + @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 - 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(1, sessions.size) + (sessions[0] as Session).tournamentName?.run { + Assert.assertEquals(t1.id, this.id) + } + } + + @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) - sessions.map { - Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id)) + Assert.assertEquals(6, sessions.size) + + val result = arrayListOf(t1.id, t2.id) + + sessions.forEach { + Assert.assertTrue(result.contains((it as Session).tournamentName?.id)) } } } \ 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 index 332a8c0c..96deb0a0 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt +++ b/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? 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 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 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? by filterValues + this.fieldName?.let { + realmQuery.`in`(it, values) + } ?: run { + throw FilterValueMapException("fieldName is missing") + } } BLINDS -> { val map : Array> by filterValues