From 345e6d73040e8b3e5f182e04739ad310b0370585 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Thu, 11 Apr 2019 13:58:06 +0200 Subject: [PATCH] update blind management, blind is now called stake throughout the project --- .../filter/BlindFilterInstrumentedTest.kt | 34 ++- .../android/model/filter/QueryCondition.kt | 287 ++++++++---------- .../android/model/realm/Bankroll.kt | 11 + .../android/model/realm/Currency.kt | 11 +- .../android/model/realm/FilterCondition.kt | 22 +- .../android/model/realm/FilterElementBlind.kt | 8 - .../android/model/realm/Session.kt | 22 +- .../rowrepresentable/FilterCategoryRow.kt | 2 +- .../view/rowrepresentable/FilterElementRow.kt | 16 +- .../view/rowrepresentable/FilterSectionRow.kt | 29 +- 10 files changed, 190 insertions(+), 252 deletions(-) delete mode 100644 app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt index d19cee4a..c4cf68aa 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt @@ -42,9 +42,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLINDS - val blind = FilterElementRow.Blind(0.5, 1.0, null) - blind.filterSectionRow = FilterSectionRow.BLINDS + val filter = QueryCondition.STAKE + val blind = FilterElementRow.Stake(s1.getBlinds()) + blind.filterSectionRow = FilterSectionRow.STAKE val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) @@ -86,12 +86,14 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLINDS - val blind = FilterElementRow.Blind(null, 1.0, null) - blind.filterSectionRow = FilterSectionRow.BLINDS + val filter = QueryCondition.STAKE + val blind1 = FilterElementRow.Stake(s1.getBlinds()) + val blind2 = FilterElementRow.Stake(s2.getBlinds()) + blind1.filterSectionRow = FilterSectionRow.STAKE + blind2.filterSectionRow = FilterSectionRow.STAKE - val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) - filter.updateValueMap(filterElement) + val filterElements = FilterCondition(filterElementRows = arrayListOf(blind1, blind2)) + filter.updateValueMap(filterElements) val sessions = Filter.queryOn(realm, arrayListOf(filter)) @@ -129,9 +131,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLINDS - val blind = FilterElementRow.Blind(1.0, 2.0, "AUD") - blind.filterSectionRow = FilterSectionRow.BLINDS + val filter = QueryCondition.STAKE + val blind = FilterElementRow.Stake(s3.getBlinds()) + blind.filterSectionRow = FilterSectionRow.STAKE val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) @@ -172,12 +174,12 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLINDS - val blind1 = FilterElementRow.Blind(1.0, 2.0, null) - blind1.filterSectionRow = FilterSectionRow.BLINDS + val filter = QueryCondition.STAKE + val blind1 = FilterElementRow.Stake(s1.getBlinds()) + blind1.filterSectionRow = FilterSectionRow.STAKE - val blind2 = FilterElementRow.Blind(0.5, 1.0, null) - blind2.filterSectionRow = FilterSectionRow.BLINDS + val blind2 = FilterElementRow.Stake(s2.getBlinds()) + blind2.filterSectionRow = FilterSectionRow.STAKE val filterElement = FilterCondition(filterElementRows = arrayListOf(blind1, blind2)) filter.updateValueMap(filterElement) 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 077c866c..53ff2a7f 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,10 +1,8 @@ package net.pokeranalytics.android.model.filter -import io.realm.RealmList import io.realm.RealmQuery import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.realm.FilterCondition -import net.pokeranalytics.android.model.realm.FilterElementBlind import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.util.extensions.endOfDay import net.pokeranalytics.android.util.extensions.startOfDay @@ -31,7 +29,7 @@ enum class QueryCondition(var operator: Operator? = null) { LIMIT, TABLE_SIZE, TOURNAMENT_TYPE, - BLINDS, + STAKE, LAST_GAMES, LAST_SESSIONS, MORE_NUMBER_OF_TABLE(Operator.MORE), @@ -74,10 +72,6 @@ enum class QueryCondition(var operator: Operator? = null) { MORE_THAN_DURATION(Operator.MORE), LESS_THAN_DURATION(Operator.LESS), - CURRENCY, - CURRENCY_CODE, - BIG_BLIND, - SMALL_BLIND, COMMENT, ; @@ -115,7 +109,7 @@ enum class QueryCondition(var operator: Operator? = null) { 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") + STAKE -> arrayOf("stakes") STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date") DAY_OF_WEEK -> arrayOf("dayOfWeek") MONTH -> arrayOf("month") @@ -129,169 +123,128 @@ enum class QueryCondition(var operator: Operator? = null) { * providing a base RealmQuery [realmQuery], the method is able to attached the corresponding query and returns the newly formed [RealmQuery] */ inline fun filter(realmQuery: RealmQuery): RealmQuery { - when { - this == BLINDS -> { - - val smallBlindFieldName = FilterHelper.fieldNameForQueryType(SMALL_BLIND) - val bigBlindFieldName = FilterHelper.fieldNameForQueryType(BIG_BLIND) - val currencyCodeFieldName = FilterHelper.fieldNameForQueryType(CURRENCY_CODE) - smallBlindFieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown - bigBlindFieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown - currencyCodeFieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown - - val blinds: RealmList by valueMap - blinds.forEachIndexed { index, blind -> - realmQuery - .beginGroup() - - blind.sb?.let { - realmQuery - .equalTo(smallBlindFieldName, it) - .and() - } - - realmQuery - .equalTo(bigBlindFieldName, blind.bb) - .and() - - blind.currencyCode?.let { - realmQuery.equalTo(currencyCodeFieldName, it) - } ?: run { - realmQuery.isNull(currencyCodeFieldName) - } - - realmQuery.endGroup() - - if (index < blinds.size - 1) { - realmQuery.or() - } - } - return realmQuery + val fieldName = FilterHelper.fieldNameForQueryType(this) + fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown + when (operator) { + Operator.LESS -> { + val value: Double by valueMap + return realmQuery.lessThanOrEqualTo(fieldName, value) } - else -> { - - val fieldName = FilterHelper.fieldNameForQueryType(this) - fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown + Operator.MORE -> { + val value: Double by valueMap + return realmQuery.greaterThanOrEqualTo(fieldName, value) + } + Operator.BETWEEN -> { + val leftValue: Double by valueMap + val rightValue: Double by valueMap + return realmQuery.between(fieldName, leftValue, rightValue) + } + } - when (operator) { - Operator.LESS -> { - val value: Double by valueMap - return realmQuery.lessThanOrEqualTo(fieldName, value) - } - Operator.MORE -> { - val value: Double by valueMap - return realmQuery.greaterThanOrEqualTo(fieldName, value) - } - Operator.BETWEEN -> { - val leftValue: Double by valueMap - val rightValue: Double by valueMap - return realmQuery.between(fieldName, leftValue, rightValue) - } + return when (this) { + LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE) + CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) + TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal) + ALL_TOURNAMENT_FEATURES -> { + val ids: Array by valueMap + ids.forEach { + realmQuery.equalTo(fieldName, it) } - - return when (this) { - LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE) - CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) - TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal) - ALL_TOURNAMENT_FEATURES -> { - val ids: Array by valueMap - ids.forEach { - realmQuery.equalTo(fieldName, it) - } - realmQuery - } - ANY_TOURNAMENT_FEATURES -> { - val ids: Array by valueMap - realmQuery.`in`(fieldName, ids) - } - BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { - val ids: Array by valueMap - realmQuery.`in`(fieldName, ids) - } - LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { - val values: Array? 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, WEEK_DAY -> { - var query = realmQuery - if (this == WEEK_DAY) { - query = realmQuery.not() - } - query.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY)) - } - TODAY -> { - val startDate = Date() - realmQuery.between(fieldName, startDate.startOfDay(), startDate.endOfDay()) - } - TODAY_AND_YESTERDAY-> { - val startDate = Date() - val calendar = Calendar.getInstance() - calendar.time = startDate - calendar.add(Calendar.HOUR_OF_DAY, -24) - realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) - } - YESTERDAY -> { - val calendar = Calendar.getInstance() - calendar.time = Date() - calendar.add(Calendar.HOUR_OF_DAY, -24) - realmQuery.between(fieldName, calendar.time.startOfDay(), calendar.time.endOfDay()) - } - THIS_WEEK -> { - val startDate = Date() - val calendar = Calendar.getInstance() - calendar.time = startDate - calendar.set(Calendar.DAY_OF_WEEK_IN_MONTH, Calendar.SUNDAY) - realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) - } - THIS_MONTH -> { - val startDate = Date() - val calendar = Calendar.getInstance() - calendar.time = startDate - calendar.set(Calendar.DAY_OF_MONTH, 1) - realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) - } - THIS_YEAR -> { - val startDate = Date() - val calendar = Calendar.getInstance() - calendar.time = startDate - calendar.set(Calendar.DAY_OF_YEAR, 1) - realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) - } - else -> { - throw PokerAnalyticsException.QueryTypeUnhandled - } + realmQuery + } + ANY_TOURNAMENT_FEATURES -> { + val ids: Array by valueMap + realmQuery.`in`(fieldName, ids) + } + STAKE -> { + val stakes: Array by valueMap + realmQuery.`in`(fieldName, stakes) + } + BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { + val ids: Array by valueMap + realmQuery.`in`(fieldName, ids) + } + LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { + val values: Array? 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, WEEK_DAY -> { + var query = realmQuery + if (this == WEEK_DAY) { + query = realmQuery.not() } + query.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY)) + } + TODAY -> { + val startDate = Date() + realmQuery.between(fieldName, startDate.startOfDay(), startDate.endOfDay()) + } + TODAY_AND_YESTERDAY-> { + val startDate = Date() + val calendar = Calendar.getInstance() + calendar.time = startDate + calendar.add(Calendar.HOUR_OF_DAY, -24) + realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) + } + YESTERDAY -> { + val calendar = Calendar.getInstance() + calendar.time = Date() + calendar.add(Calendar.HOUR_OF_DAY, -24) + realmQuery.between(fieldName, calendar.time.startOfDay(), calendar.time.endOfDay()) + } + THIS_WEEK -> { + val startDate = Date() + val calendar = Calendar.getInstance() + calendar.time = startDate + calendar.set(Calendar.DAY_OF_WEEK_IN_MONTH, Calendar.SUNDAY) + realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) + } + THIS_MONTH -> { + val startDate = Date() + val calendar = Calendar.getInstance() + calendar.time = startDate + calendar.set(Calendar.DAY_OF_MONTH, 1) + realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) + } + THIS_YEAR -> { + val startDate = Date() + val calendar = Calendar.getInstance() + calendar.time = startDate + calendar.set(Calendar.DAY_OF_YEAR, 1) + realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) + } + else -> { + throw PokerAnalyticsException.QueryTypeUnhandled } } - } fun updateValueMap(filterCondition: FilterCondition) { @@ -311,8 +264,8 @@ enum class QueryCondition(var operator: Operator? = null) { LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { valueMap = mapOf("values" to filterCondition.values) } - BLINDS -> { - valueMap = mapOf("blinds" to filterCondition.blinds) + STAKE -> { + valueMap = mapOf("stakes" to filterCondition.stakes) } STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> { valueMap = mapOf("date" to filterCondition.date) diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Bankroll.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Bankroll.kt index c5a3df93..55f0d897 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/Bankroll.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Bankroll.kt @@ -3,6 +3,8 @@ package net.pokeranalytics.android.model.realm import io.realm.Realm import io.realm.RealmList import io.realm.RealmObject +import io.realm.RealmResults +import io.realm.annotations.LinkingObjects import io.realm.annotations.PrimaryKey import io.realm.kotlin.where import net.pokeranalytics.android.R @@ -32,6 +34,9 @@ open class Bankroll() : RealmObject(), NameManageable, StaticRowRepresentableDat } } + @LinkingObjects("bankroll") + private val sessions: RealmResults? = null + @PrimaryKey override var id = UUID.randomUUID().toString() @@ -46,6 +51,12 @@ open class Bankroll() : RealmObject(), NameManageable, StaticRowRepresentableDat // The currency of the bankroll var currency: Currency? = null + fun currencyCodeHasBeenUpdated() { + sessions?.forEach { + it.bankrollHasBeenUpdated() + } + } + override fun getDisplayName(): String { return this.name } 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 e6b96fca..39463454 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 @@ -1,7 +1,9 @@ package net.pokeranalytics.android.model.realm import io.realm.RealmObject +import io.realm.RealmResults import io.realm.annotations.Ignore +import io.realm.annotations.LinkingObjects import io.realm.annotations.PrimaryKey import java.util.* @@ -13,10 +15,17 @@ open class Currency : RealmObject() { @PrimaryKey var id = UUID.randomUUID().toString() - /** + @LinkingObjects("currency") + private val bankrolls: RealmResults? = null + + /** * The currency code of the currency, i.e. USD, EUR... */ var code: String? = null + set(value) { + field = value + bankrolls?.first()?.currencyCodeHasBeenUpdated() + } /** * The rate of the currency with the main currency diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt index afada902..aa7e6b01 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt @@ -37,13 +37,6 @@ open class FilterCondition() : RealmObject() { }) } } - is FilterElementBlind -> { - this.blindValues = RealmList().apply { - this.addAll(filterElementRows.map { - FilterElementBlind((it as FilterElementRow.Blind).sb, it.bb, it.code) - }) - } - } } } @@ -59,23 +52,12 @@ open class FilterCondition() : RealmObject() { private var numericValues: RealmList? = null private var dateValue: Date? = null private var stringValues: RealmList? = null - private var blindValues: RealmList? = null val ids: Array get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - val blinds: RealmList - get() { - blindValues?.let { - if (it.isNotEmpty()) { - return it - } else { - throw PokerAnalyticsException.FilterElementExpectedValueMissing - } - } - throw PokerAnalyticsException.FilterElementExpectedValueMissing - } - + val stakes: Array + get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing val date: Date get() = dateValue ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing 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 deleted file mode 100644 index ebde6cad..00000000 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt +++ /dev/null @@ -1,8 +0,0 @@ -package net.pokeranalytics.android.model.realm - -import io.realm.RealmObject - -open class FilterElementBlind(var sb : Double? = null, - var bb : Double? = null, - var currencyCode : String? = null -) : RealmObject() \ No newline at end of file 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 8bf81de2..12125fac 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 @@ -78,10 +78,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat LIMIT -> "limit" TABLE_SIZE -> "tableSize" TOURNAMENT_TYPE -> "tournamentType" - CURRENCY -> "bankroll.currency" - CURRENCY_CODE -> "bankroll.currency.code" - BIG_BLIND -> "cgBigBlind" - SMALL_BLIND -> "cgSmallBlind" + STAKE -> "stake" 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" @@ -220,14 +217,27 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat // The small blind value var cgSmallBlind: Double? = null + set(value) { + field = value + this.stake = getBlinds() + } // The big blind value var cgBigBlind: Double? = null set(value) { field = value this.computeStats() + this.stake = getBlinds() } + private var stake: String? = null + get() { + if (field == null) { + field = getBlinds() + } + return field + } + // Tournament // The entry fee of the tournament @@ -245,6 +255,10 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat // The features of the tournament, like Knockout, Shootout, Turbo... var tournamentFeatures: RealmList = RealmList() + fun bankrollHasBeenUpdated() { + this.stake = getBlinds() + } + /** * Manages impacts on SessionSets * Should be called when the start / end date are changed 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 index e9ac2482..4ba5534f 100644 --- 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 @@ -54,7 +54,7 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In BANKROLL ) CASH -> arrayListOf( - BLINDS, + STAKE, CASH_RE_BUY_COUNT ) TOURNAMENT -> 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 index d1c6a567..8c39c4ec 100644 --- 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 @@ -11,9 +11,6 @@ import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheet import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor import net.pokeranalytics.android.ui.view.RowViewType -import net.pokeranalytics.android.util.NULL_TEXT -import net.pokeranalytics.android.util.extensions.formatted -import net.pokeranalytics.android.util.extensions.round import java.text.DateFormatSymbols import java.util.* @@ -100,14 +97,7 @@ sealed class FilterElementRow : RowRepresentable { data class Month(val month: Int) : SingleValueFilterElementRow(month) data class Day(val day: Int) : SingleValueFilterElementRow(day) - data class Blind(var sb: Double? = null, var bb: Double? = null, var code: String? = null) : FilterElementRow() { - val name: String - get() { - val currencyCode = code ?: Currency.getInstance(Locale.getDefault()).currencyCode - val currencySymbol = Currency.getInstance(currencyCode).symbol - return if (sb == null) NULL_TEXT else "$currencySymbol ${sb?.formatted()}/${bb?.round()}" - } - } + data class Stake(val stake : String) : StringFilterElementRow(stake) //TODO: Refactor? data class PastDays(var lastDays: Int = 0) : SingleValueFilterElementRow(lastDays) { @@ -150,7 +140,7 @@ sealed class FilterElementRow : RowRepresentable { return when (this) { is Cash -> QueryCondition.CASH is Tournament -> QueryCondition.TOURNAMENT - is Blind -> QueryCondition.BLINDS + is Stake -> QueryCondition.STAKE is From -> QueryCondition.STARTED_FROM_DATE is To -> QueryCondition.ENDED_TO_DATE is Month -> QueryCondition.MONTH @@ -302,7 +292,7 @@ sealed class FilterElementRow : RowRepresentable { } is DataFilterElementRow -> this.name is StaticDataFilterElementRow -> this.name - is Blind -> this.name + is Stake -> this.stake else -> super.getDisplayName() } } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt index 1c2006be..918d8db2 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt @@ -28,7 +28,7 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { SESSION_DURATION(net.pokeranalytics.android.R.string.session_duration), RANGE(net.pokeranalytics.android.R.string.hour_slot), SESSIONS(R.string.sessions), - BLINDS(net.pokeranalytics.android.R.string.blinds), + STAKE(net.pokeranalytics.android.R.string.stakes), CASH_RE_BUY_COUNT(net.pokeranalytics.android.R.string.rebuy_count), TOURNAMENT_TYPE(net.pokeranalytics.android.R.string.tournament_types), TOURNAMENT_NAME(net.pokeranalytics.android.R.string.tournament_name), @@ -147,29 +147,14 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { SESSIONS -> arrayListOf(LastGames(0), LastSessions(0)) // Cash - BLINDS -> { - - // TODO: Improve the way we get the blinds distinctly - val blinds = arrayListOf() + STAKE -> { + val stakes = arrayListOf() val realm = Realm.getDefaultInstance() - val sessions = realm.where().findAll().sort("cgSmallBlind", Sort.ASCENDING) - - val distinctBlinds: ArrayList = ArrayList() - val blindsHashMap: ArrayList = ArrayList() - sessions.forEach { - if (!blindsHashMap.contains(it.getBlinds())) { - blindsHashMap.add(it.getBlinds()) - distinctBlinds.add(it) - } - } - - distinctBlinds.forEach { session -> - blinds.add(Blind(session.cgSmallBlind, session.cgBigBlind, session.bankroll?.currency?.code)) - session.getBlinds() - } + realm.where().distinct("stake").findAll().sort("cgSmallBlind", Sort.ASCENDING).map { + stakes.add(Stake(it.getBlinds())) + } realm.close() - - blinds + stakes } CASH_RE_BUY_COUNT -> arrayListOf(ReBuyMoreThan as FilterElementRow, ReBuyLessThan as FilterElementRow)