From 792ef5d9b6f9b9ba520592b9998486bcd7c84109 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Tue, 16 Apr 2019 15:26:49 +0200 Subject: [PATCH] add some comparators --- .../android/model/comparison/Comparator.kt | 118 +++++++++++++++++- .../android/model/filter/QueryCondition.kt | 43 ++++++- 2 files changed, 151 insertions(+), 10 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt b/app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt index 5b570fd8..961ede8f 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt +++ b/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 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() val calendar = Calendar.getInstance() @@ -40,10 +50,108 @@ enum class Comparator { realm.close() years } + DAY_PERIOD -> listOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END) CASH -> listOf(QueryCondition.CASH) TOURNAMENT -> listOf(QueryCondition.TOURNAMENT) - else -> throw PokerAnalyticsException.QueryTypeUnhandled - } + LIVE -> listOf(QueryCondition.LIVE) + ONLINE -> listOf(QueryCondition.ONLINE) + BLIND -> { + val blinds = arrayListOf() + val realm = Realm.getDefaultInstance() + realm.where().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() + val realm = Realm.getDefaultInstance() + realm.where().findAll().forEach { + objects.add(QueryCondition.GAME().apply { setObjectId(it.id)}) + } + realm.close() + objects + } + BANKROLL -> { + val objects = arrayListOf() + val realm = Realm.getDefaultInstance() + realm.where().findAll().forEach { + objects.add(QueryCondition.BANKROLL().apply { setObjectId(it.id)}) + } + realm.close() + objects + } + LOCATION -> { + val objects = arrayListOf() + val realm = Realm.getDefaultInstance() + realm.where().findAll().forEach { + objects.add(QueryCondition.LOCATION().apply { setObjectId(it.id)}) + } + realm.close() + objects + } + TOURNAMENT_NAME -> { + val objects = arrayListOf() + val realm = Realm.getDefaultInstance() + realm.where().findAll().forEach { + objects.add(QueryCondition.TOURNAMENT_NAME().apply { setObjectId(it.id)}) + } + realm.close() + objects + } + TOURNAMENT_FEATURE -> { + val objects = arrayListOf() + val realm = Realm.getDefaultInstance() + realm.where().findAll().forEach { + objects.add(QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObjectId(it.id)}) + } + realm.close() + objects + } + LIMIT_TYPE -> { + val limits = arrayListOf() + val realm = Realm.getDefaultInstance() + val distinctLimitTypes = realm.where().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() + val realm = Realm.getDefaultInstance() + val distinctTableSizes = + realm.where().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() + val realm = Realm.getDefaultInstance() + val distinctTournamentTypes = + realm.where().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 + } } } diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt index e7573c23..9cc307e5 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt +++ b/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.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 TABLE_SIZE: QueryCondition() - class TOURNAMENT_TYPE: QueryCondition() - class BLIND: QueryCondition() + class LIMIT: QueryCondition() { + fun setLimitType(limitType: Int) { + this.valueMap = mapOf("values" to limitType) + } + } + + 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)