add some comparators

app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt

@@ -7,25 +7,35 @@ import io.realm.kotlin.where
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.filter.Filterable
 import net.pokeranalytics.android.model.filter.QueryCondition
-import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.model.realm.*
 import java.util.*
 import kotlin.collections.ArrayList
 
 enum class Comparator {
 	DAY_OF_WEEK,
 	MONTH_OF_YEAR,
-	MONTH,
 	YEAR,
 	BLIND,
 	CASH,
 	TOURNAMENT,
+    LIVE,
+    ONLINE,
+    GAME,
+    BANKROLL,
+    LOCATION,
+    TOURNAMENT_FEATURE,
+    TOURNAMENT_NAME,
+    DAY_PERIOD,
+    LIMIT_TYPE,
+    TABLE_SIZE,
+    TOURNAMENT_TYPE,
 	;
 
 	val queryConditions: List<QueryCondition>
 		get() {
 			return when (this) {
 				MONTH_OF_YEAR -> List(12) { index -> QueryCondition.MONTH().apply { setMonth(index) } }
-				DAY_OF_WEEK -> listOf()
+				DAY_OF_WEEK -> List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { setDay(index) } }
 				YEAR -> {
 					val years = arrayListOf<QueryCondition.YEAR>()
 					val calendar = Calendar.getInstance()
@@ -40,8 +50,106 @@ enum class Comparator {
 					realm.close()
 					years
 				}
+                DAY_PERIOD -> listOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END)
 				CASH -> listOf(QueryCondition.CASH)
 				TOURNAMENT -> listOf(QueryCondition.TOURNAMENT)
+                LIVE -> listOf(QueryCondition.LIVE)
+                ONLINE -> listOf(QueryCondition.ONLINE)
+                BLIND -> {
+                    val blinds = arrayListOf<QueryCondition.BLIND>()
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<Session>().distinct("blind", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map {
+                        it.blinds?.let { stake ->
+                            blinds.add(QueryCondition.BLIND().apply { setBlind(stake, it.hasDefaultCurrency)})
+                        }
+                    }
+                    realm.close()
+                    blinds
+                }
+                GAME -> {
+                    val objects = arrayListOf<QueryCondition.GAME>()
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<Game>().findAll().forEach {
+                        objects.add(QueryCondition.GAME().apply { setObjectId(it.id)})
+                    }
+                    realm.close()
+                    objects
+                }
+                BANKROLL -> {
+                    val objects = arrayListOf<QueryCondition.BANKROLL>()
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<Bankroll>().findAll().forEach {
+                        objects.add(QueryCondition.BANKROLL().apply { setObjectId(it.id)})
+                    }
+                    realm.close()
+                    objects
+                }
+                LOCATION -> {
+                    val objects = arrayListOf<QueryCondition.LOCATION>()
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<Location>().findAll().forEach {
+                        objects.add(QueryCondition.LOCATION().apply { setObjectId(it.id)})
+                    }
+                    realm.close()
+                    objects
+                }
+                TOURNAMENT_NAME -> {
+                    val objects = arrayListOf<QueryCondition.TOURNAMENT_NAME>()
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<TournamentName>().findAll().forEach {
+                        objects.add(QueryCondition.TOURNAMENT_NAME().apply { setObjectId(it.id)})
+                    }
+                    realm.close()
+                    objects
+                }
+                TOURNAMENT_FEATURE -> {
+                    val objects = arrayListOf<QueryCondition.ANY_TOURNAMENT_FEATURES>()
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<TournamentFeature>().findAll().forEach {
+                        objects.add(QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObjectId(it.id)})
+                    }
+                    realm.close()
+                    objects
+                }
+                LIMIT_TYPE -> {
+                    val limits = arrayListOf<QueryCondition.LIMIT>()
+                    val realm = Realm.getDefaultInstance()
+                    val distinctLimitTypes = realm.where<Session>().distinct("limit").findAll().sort("limit", Sort.ASCENDING)
+
+                    distinctLimitTypes.forEach { session ->
+                        session.limit?.let { limitType->
+                            limits.add(QueryCondition.LIMIT().apply { setLimitType(limitType) })
+                        }
+                    }
+                    realm.close()
+                    limits
+                }
+                TABLE_SIZE -> {
+                    val tableSizes = arrayListOf<QueryCondition.TABLE_SIZE>()
+                    val realm = Realm.getDefaultInstance()
+                    val distinctTableSizes =
+                        realm.where<Session>().distinct("tableSize").findAll().sort("tableSize", Sort.ASCENDING)
+                    distinctTableSizes.forEach { session ->
+                        session.tableSize?.let { tableSize ->
+                            tableSizes.add(QueryCondition.TABLE_SIZE().apply { setNumberOfPlayer(tableSize) })
+                        }
+                    }
+                    realm.close()
+                    tableSizes
+                }
+                TOURNAMENT_TYPE -> {
+                    val tableSizes = arrayListOf<QueryCondition.TOURNAMENT_TYPE>()
+                    val realm = Realm.getDefaultInstance()
+                    val distinctTournamentTypes =
+                        realm.where<Session>().distinct("tournamentType").findAll().sort("tournamentType", Sort.ASCENDING)
+                    distinctTournamentTypes.forEach { session ->
+                        session.tournamentType?.let { tournamentType ->
+                            tableSizes.add(QueryCondition.TOURNAMENT_TYPE().apply { setTournamentType(tournamentType) })
+                        }
+                    }
+                    realm.close()
+                    tableSizes
+                }
                 else -> throw PokerAnalyticsException.QueryTypeUnhandled
             }
 		}

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

@@ -1,7 +1,10 @@
 package net.pokeranalytics.android.model.filter
 
 import io.realm.RealmQuery
+import io.realm.internal.Table
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
+import net.pokeranalytics.android.model.Limit
+import net.pokeranalytics.android.model.TableSize
 import net.pokeranalytics.android.model.realm.FilterCondition
 import net.pokeranalytics.android.model.realm.Session
 import net.pokeranalytics.android.util.extensions.endOfDay
@@ -22,6 +25,9 @@ fun List<QueryCondition>.name() : String {
 sealed class QueryCondition(var operator: Operator? = null) {
 
     abstract class QueryDataCondition : QueryCondition()
+        fun setObjectId(id:String) {
+            this.valueMap = mapOf("ids" to id)
+        }
 
     companion object {
         fun valueOf(name:String) : QueryCondition {
@@ -49,10 +55,31 @@ sealed class QueryCondition(var operator: Operator? = null) {
     class ANY_TOURNAMENT_FEATURES: QueryCondition()
     class ALL_TOURNAMENT_FEATURES: QueryCondition()
     class LOCATION: QueryCondition()
-    class LIMIT: QueryCondition()
+    class LIMIT: QueryCondition() {
-    class TABLE_SIZE: QueryCondition()
+        fun setLimitType(limitType: Int) {
-    class TOURNAMENT_TYPE: QueryCondition()
+            this.valueMap = mapOf("values" to limitType)
-    class BLIND: QueryCondition()
+        }
+    }
+
+    class TABLE_SIZE: QueryCondition() {
+        fun setNumberOfPlayer(numberOfPlayer: Int) {
+            this.valueMap = mapOf("values" to numberOfPlayer)
+        }
+    }
+
+    class TOURNAMENT_TYPE: QueryCondition() {
+        fun setTournamentType(tournamentType:Int) {
+            this.valueMap = mapOf("values" to tournamentType)
+        }
+    }
+
+    class BLIND: QueryCondition() {
+        fun setBlind(blind:String, hasDefaultCurrency:Boolean) {
+            this.valueMap = mapOf(
+                "blinds" to blind,
+                "hasDefaultCurrency" to hasDefaultCurrency)
+        }
+    }
     class LAST_GAMES: QueryCondition()
     class LAST_SESSIONS: QueryCondition()
     class MORE_NUMBER_OF_TABLE: QueryCondition(Operator.MORE)
@@ -80,7 +107,13 @@ sealed class QueryCondition(var operator: Operator? = null) {
     class STARTED_TO_DATE: QueryCondition()
     class ENDED_FROM_DATE: QueryCondition()
     class ENDED_TO_DATE: QueryCondition()
-    class DAY_OF_WEEK: QueryCondition()
+
+    class DAY_OF_WEEK: QueryCondition() {
+        fun setDay(dayOfWeek:Int) {
+            this.valueMap = mapOf("dayOfWeek" to dayOfWeek)
+        }
+    }
+
     class MONTH: QueryCondition() {
         fun setMonth(month:Int) {
             this.valueMap = mapOf("month" to month)