From 345e6d73040e8b3e5f182e04739ad310b0370585 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Thu, 11 Apr 2019 13:58:06 +0200 Subject: [PATCH 01/10] 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) From ac75f5947a809551da6c53e1b8eef52c930c543b Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Thu, 11 Apr 2019 14:44:00 +0200 Subject: [PATCH 02/10] fix issue with filter conditions udpate --- .../pokeranalytics/android/model/realm/Filter.kt | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt index dbbba9bc..5184b586 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt @@ -65,8 +65,8 @@ open class Filter : RealmObject() { private set fun createOrUpdateFilterConditions(filterConditionRows: ArrayList) { - filterConditions.clear() - filterConditionRows + val casted = arrayListOf() + filterConditionRows .map { it.filterName } @@ -77,10 +77,14 @@ open class Filter : RealmObject() { it.filterName == filterName } .apply { - val casted = arrayListOf() casted.addAll(this) - filterConditions.add(FilterCondition(casted)) - } + val newFilterCondition = FilterCondition(casted) + val previousCondition = filterConditions.filter { + it.sectionName == newFilterCondition.filterName + } + filterConditions.removeAll(previousCondition) + filterConditions.add(newFilterCondition) + } } } From 5ea92f4cedf9b18f388fce855d4cd37e5ece01bd Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Thu, 11 Apr 2019 19:16:35 +0200 Subject: [PATCH 03/10] wip blind update --- .../filter/BlindFilterInstrumentedTest.kt | 16 +++--- .../android/model/filter/QueryCondition.kt | 29 +++++++++- .../android/model/realm/Currency.kt | 12 ++++ .../android/model/realm/FilterCondition.kt | 19 ++++++- .../android/model/realm/Session.kt | 56 ++++++++++++------- .../android/model/utils/Seed.kt | 16 +++++- .../android/ui/view/SessionRowView.kt | 2 +- .../view/rowrepresentable/FilterElementRow.kt | 17 +++++- .../view/rowrepresentable/FilterSectionRow.kt | 6 +- .../android/util/Preferences.kt | 2 +- 10 files changed, 135 insertions(+), 40 deletions(-) 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 c4cf68aa..99f8e6e2 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 @@ -21,7 +21,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.beginTransaction() val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1") - currency.code = "AUD" + currency.code = "USD" val b1 = realm.createObject(Bankroll::class.java, "1") val b2 = realm.createObject(Bankroll::class.java, "2") @@ -43,7 +43,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.STAKE - val blind = FilterElementRow.Stake(s1.getBlinds()) + val blind = FilterElementRow.Stake(s1.stake!!) blind.filterSectionRow = FilterSectionRow.STAKE val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) @@ -87,8 +87,8 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.STAKE - val blind1 = FilterElementRow.Stake(s1.getBlinds()) - val blind2 = FilterElementRow.Stake(s2.getBlinds()) + val blind1 = FilterElementRow.Stake(s1.stake!!) + val blind2 = FilterElementRow.Stake(s2.stake!!) blind1.filterSectionRow = FilterSectionRow.STAKE blind2.filterSectionRow = FilterSectionRow.STAKE @@ -110,7 +110,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.beginTransaction() val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1") - currency.code = "AUD" + currency.code = "USD" val b1 = realm.createObject(Bankroll::class.java, "1") val b2 = realm.createObject(Bankroll::class.java, "2") @@ -132,7 +132,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.STAKE - val blind = FilterElementRow.Stake(s3.getBlinds()) + val blind = FilterElementRow.Stake(s3.stake!!, "$") blind.filterSectionRow = FilterSectionRow.STAKE val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) @@ -175,10 +175,10 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.STAKE - val blind1 = FilterElementRow.Stake(s1.getBlinds()) + val blind1 = FilterElementRow.Stake(s1.stake!!) blind1.filterSectionRow = FilterSectionRow.STAKE - val blind2 = FilterElementRow.Stake(s2.getBlinds()) + val blind2 = FilterElementRow.Stake(s2.stake!!) 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 53ff2a7f..bc8c118b 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 @@ -109,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") - STAKE -> arrayOf("stakes") + STAKE -> arrayOf("stakes", "hasDefaultCurrency") STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date") DAY_OF_WEEK -> arrayOf("dayOfWeek") MONTH -> arrayOf("month") @@ -158,7 +158,28 @@ enum class QueryCondition(var operator: Operator? = null) { } STAKE -> { val stakes: Array by valueMap - realmQuery.`in`(fieldName, stakes) + val hasDefaultCurrency: Array by valueMap + //realmQuery.`in`(fieldName, stakes) + stakes.forEachIndexed { index, s -> + val isUsingDefaultCurrency = hasDefaultCurrency[index] + realmQuery.beginGroup() + if (isUsingDefaultCurrency) { + realmQuery.endsWith(fieldName, s) + .and() + .beginGroup() + .isNull("bankroll") + .or() + .isNull("bankroll.currency") + .or() + .isNull("bankroll.currency.code") + .endGroup() + } else { + realmQuery.equalTo(fieldName, s) + } + .endGroup() + .or() + } + realmQuery } BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { val ids: Array by valueMap @@ -265,7 +286,9 @@ enum class QueryCondition(var operator: Operator? = null) { valueMap = mapOf("values" to filterCondition.values) } STAKE -> { - valueMap = mapOf("stakes" to filterCondition.stakes) + valueMap = mapOf( + "stakes" to filterCondition.stakes, + "hasDefaultCurrency" to filterCondition.hasDefaultCurrency) } 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/Currency.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Currency.kt index 39463454..a0dcfdfb 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 @@ -5,10 +5,22 @@ import io.realm.RealmResults import io.realm.annotations.Ignore import io.realm.annotations.LinkingObjects import io.realm.annotations.PrimaryKey +import net.pokeranalytics.android.util.Preferences import java.util.* open class Currency : RealmObject() { + companion object { + val localeCurrency: java.util.Currency + get() { + return try { + java.util.Currency.getInstance(Locale.getDefault()) + } catch (e: Exception) { + java.util.Currency.getInstance(Locale("en", "US")) + } + } + } + @Ignore val DEFAULTRATE: Double = 1.0 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 aa7e6b01..6742969c 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 @@ -23,6 +23,19 @@ open class FilterCondition() : RealmObject() { is DateFilterElementRow -> { this.dateValue = row.dateValue } + is Stake -> { + //TODO refactor raz + this.stringValues = RealmList().apply { + this.addAll(filterElementRows.map { + (it as Stake).stake + }) + } + this.booleanValues = RealmList().apply { + this.addAll(filterElementRows.map { + ((it as Stake).currencySymbol == null) + }) + } + } is StringFilterElementRow -> { this.stringValues = RealmList().apply { this.addAll(filterElementRows.map { @@ -52,6 +65,7 @@ open class FilterCondition() : RealmObject() { private var numericValues: RealmList? = null private var dateValue: Date? = null private var stringValues: RealmList? = null + private var booleanValues: RealmList? = null val ids: Array get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing @@ -59,7 +73,10 @@ open class FilterCondition() : RealmObject() { val stakes: Array get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - val date: Date + val hasDefaultCurrency: Array + get() = booleanValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing + + val date: Date get() = dateValue ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing 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 12125fac..c18eb1d2 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 @@ -37,6 +37,7 @@ import net.pokeranalytics.android.ui.view.rowrepresentable.SeparatorRowRepresent import net.pokeranalytics.android.ui.view.rowrepresentable.SessionRow import net.pokeranalytics.android.util.CurrencyUtils import net.pokeranalytics.android.util.NULL_TEXT +import net.pokeranalytics.android.util.Preferences import net.pokeranalytics.android.util.extensions.* import java.util.* import java.util.Currency @@ -219,7 +220,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat var cgSmallBlind: Double? = null set(value) { field = value - this.stake = getBlinds() + computeStakeAsString() } // The big blind value @@ -227,16 +228,11 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat set(value) { field = value this.computeStats() - this.stake = getBlinds() + computeStakeAsString() } - private var stake: String? = null - get() { - if (field == null) { - field = getBlinds() - } - return field - } + var stake: String? = null + private set // Tournament @@ -256,7 +252,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat var tournamentFeatures: RealmList = RealmList() fun bankrollHasBeenUpdated() { - this.stake = getBlinds() + computeStakeAsString() } /** @@ -496,14 +492,19 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat return NULL_TEXT } - /** - * Return the formatted blinds - */ - fun getBlinds(): String { - val currencyCode = bankroll?.currency?.code ?: Currency.getInstance(Locale.getDefault()).currencyCode - val currencySymbol = Currency.getInstance(currencyCode).symbol - return if (cgSmallBlind == null) NULL_TEXT else "$currencySymbol ${cgSmallBlind?.formatted()}/${cgBigBlind?.round()}" - } + /** + * Return the formatted blinds + */ + fun getCurrencyFormattedStake(context:Context) : String { + val currency : Currency = Preferences.getCurrencyLocale(context)?.let { + Currency.getInstance(it) + } ?: run { + net.pokeranalytics.android.model.realm.Currency.localeCurrency + } + + val currencySymbol = currencySymbol ?: currency.symbol + return "$currencySymbol $stake" + } /** * Return the game title @@ -522,6 +523,23 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat return if (gameTitle.isNotBlank()) gameTitle else NULL_TEXT } + val currencySymbol : String? + get() { + bankroll?.currency?.code?.let { + return Currency.getInstance(it).symbol + } + return null + } + + private fun computeStakeAsString() { + stake = null + if (cgBigBlind == null) return + cgBigBlind?.let { bb -> + val sb = cgSmallBlind ?: bb / 2.0 + stake = "${sb.formatted()}/${bb.round()}" + } + } + // LifeCycle /** @@ -638,7 +656,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat override fun stringForRow(row: RowRepresentable, context: Context): String { return when (row) { SessionRow.BANKROLL -> bankroll?.name ?: NULL_TEXT - SessionRow.BLINDS -> getBlinds() + SessionRow.BLINDS -> getCurrencyFormattedStake(context) SessionRow.BREAK_TIME -> if (this.breakDuration > 0.0) this.breakDuration.toMinutes() else NULL_TEXT SessionRow.BUY_IN -> this.result?.buyin?.toCurrency(CurrencyUtils.getCurrency(bankroll)) ?: NULL_TEXT SessionRow.CASHED_OUT, SessionRow.PRIZE, SessionRow.NET_RESULT -> this.result?.cashout?.toCurrency(CurrencyUtils.getCurrency(bankroll)) ?: NULL_TEXT diff --git a/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt b/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt index 2604de61..274dbde6 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt @@ -6,9 +6,10 @@ import io.realm.kotlin.where import net.pokeranalytics.android.R import net.pokeranalytics.android.model.realm.* import net.pokeranalytics.android.model.realm.Currency -import net.pokeranalytics.android.util.Preferences import java.util.* + + class Seed(var context:Context) : Realm.Transaction { override fun execute(realm: Realm) { @@ -26,16 +27,25 @@ class Seed(var context:Context) : Realm.Transaction { } } + val localeCurrency: java.util.Currency + get() { + return try { + java.util.Currency.getInstance(Locale.getDefault()) + } catch (e: Exception) { + java.util.Currency.getInstance(Locale("en", "US")) + } + } + private fun createDefaultCurrencyAndBankroll(realm: Realm) { // Currency - val localeCurrency = java.util.Currency.getInstance(Locale.getDefault()) + val localeCurrency = localeCurrency val defaultCurrency = Currency() defaultCurrency.code = localeCurrency.currencyCode realm.insertOrUpdate(defaultCurrency) // Bankroll val bankroll = Bankroll() - bankroll.name = context.resources.getString(R.string.live) + bankroll.name = context.resources.getString(net.pokeranalytics.android.R.string.live) bankroll.live = true bankroll.currency = realm.where().equalTo("code", localeCurrency.currencyCode).findFirst() realm.insertOrUpdate(bankroll) diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt index 6cef22f9..b43a0403 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt @@ -85,7 +85,7 @@ class SessionRowView : FrameLayout { } } else { if (session.cgSmallBlind != null && session.cgBigBlind != null) { - parameters.add(session.getBlinds()) + parameters.add(session.getCurrencyFormattedStake(this.context)) } session.game?.let { parameters.add(session.getFormattedGame()) 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 8c39c4ec..1c715ed8 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 @@ -13,6 +13,7 @@ import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor import net.pokeranalytics.android.ui.view.RowViewType import java.text.DateFormatSymbols import java.util.* +import java.util.prefs.Preferences sealed class FilterElementRow : RowRepresentable { @@ -97,7 +98,7 @@ sealed class FilterElementRow : RowRepresentable { data class Month(val month: Int) : SingleValueFilterElementRow(month) data class Day(val day: Int) : SingleValueFilterElementRow(day) - data class Stake(val stake : String) : StringFilterElementRow(stake) + data class Stake(val stake : String, val currencySymbol:String? = null) : StringFilterElementRow(stake) //TODO: Refactor? data class PastDays(var lastDays: Int = 0) : SingleValueFilterElementRow(lastDays) { @@ -292,13 +293,25 @@ sealed class FilterElementRow : RowRepresentable { } is DataFilterElementRow -> this.name is StaticDataFilterElementRow -> this.name - is Stake -> this.stake else -> super.getDisplayName() } } override fun localizedTitle(context: Context): String { return when (this) { + is Stake -> { + currencySymbol?.let { + "$it $stake" + } + + val currency : Currency = net.pokeranalytics.android.util.Preferences.getCurrencyLocale(context)?.let { + Currency.getInstance(it) + } ?: run { + net.pokeranalytics.android.model.realm.Currency.localeCurrency + } + val currencySymbol = currencySymbol ?: currency.symbol + "$currencySymbol $stake" + } is StaticDataFilterElementRow -> this.getDataLocalizedTitle(context) else -> super.localizedTitle(context) } 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 918d8db2..d3542e8b 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 @@ -150,8 +150,10 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { STAKE -> { val stakes = arrayListOf() val realm = Realm.getDefaultInstance() - realm.where().distinct("stake").findAll().sort("cgSmallBlind", Sort.ASCENDING).map { - stakes.add(Stake(it.getBlinds())) + realm.where().distinct("stake", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map { + it.stake?.let { stake -> + stakes.add(Stake(stake, it.currencySymbol)) + } } realm.close() stakes diff --git a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt index adfe3790..c52bdb52 100644 --- a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt +++ b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt @@ -51,7 +51,7 @@ class Preferences { return Preferences.getString(Keys.CURRENCY_CODE, context) } - fun getCurrencyLocale(context : Context) : Locale { + fun getCurrencyLocale(context : Context) : Locale? { currencyLocale?. let { return it From 3eba82c81360472e2ff2aa972fb59634e7d6b38c Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Thu, 11 Apr 2019 20:21:38 +0200 Subject: [PATCH 04/10] wip stake & currency management refactoring --- .../unitTests/BankrollInstrumentedUnitTest.kt | 46 ------------------- .../filter/BlindFilterInstrumentedTest.kt | 1 + .../filter/DateFilterInstrumentedUnitTest.kt | 40 ++++++++-------- .../SessionFilterInstrumentedUnitTest.kt | 20 ++++---- .../android/model/filter/QueryCondition.kt | 10 ++-- .../android/model/realm/Currency.kt | 15 ++---- .../android/model/realm/Session.kt | 8 +--- .../android/model/utils/Seed.kt | 21 +-------- .../view/rowrepresentable/FilterElementRow.kt | 13 +----- .../android/util/Preferences.kt | 14 ++++-- 10 files changed, 52 insertions(+), 136 deletions(-) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/BankrollInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/BankrollInstrumentedUnitTest.kt index 7fe1fb99..b96a63d8 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/BankrollInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/BankrollInstrumentedUnitTest.kt @@ -28,53 +28,7 @@ class BankrollInstrumentedUnitTest : RealmInstrumentedUnitTest() { @Test fun testSessionStats() { - val realm = this.mockRealm - realm.beginTransaction() - val s1 = newSessionInstance(realm) - val s2 = newSessionInstance(realm) - - val br1 = realm.createObject(Bankroll::class.java, "1") - val br2 = realm.createObject(Bankroll::class.java, "2") - - val c1 = realm.createObject(Currency::class.java, "1") - val c2 = realm.createObject(Currency::class.java, "2") - c1.rate = 0.1 - c2.rate = 2.0 - br1.currency = c1 - br2.currency = c2 - - s1.bankroll = br1 - s2.bankroll = br2 - - s1.result?.netResult = 100.0 - s2.result?.netResult = 200.0 - - realm.commitTransaction() - - val computableResults = realm.where(ComputableResult::class.java).findAll() - val sets = realm.where(SessionSet::class.java).findAll() - val stats: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group = ComputableGroup("test", computableResults, sets, stats) - - val options = Calculator.Options() - - val results: ComputedResults = Calculator.compute(group, options) - val delta = 0.01 - - val sum = results.computedStat(Stat.NETRESULT) - if (sum != null) { - Assert.assertEquals(410.0, sum.value, delta) - } else { - Assert.fail("No Net result stat") - } - - val average = results.computedStat(Stat.AVERAGE) - if (average != null) { - Assert.assertEquals(205.0, average.value, delta) - } else { - Assert.fail("No AVERAGE stat") - } } 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 99f8e6e2..da1c1926 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 @@ -117,6 +117,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { b2.currency = currency val s1 = Session.testInstance(100.0, false, Date(), 1, b1) + s1.cgBigBlind = 1.0 s1.cgSmallBlind = 0.5 diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt index 2fd4b380..8ef9c845 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt @@ -35,14 +35,14 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filterElementRow = FilterElementRow.Day(cal.get(Calendar.DAY_OF_WEEK)) filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE - val filterElement = FilterCondition(filterElementRow) + val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s1.id, (this as Session).id) + Assert.assertEquals(s1.id, (this).id) } } @@ -64,14 +64,14 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filterElementRow = FilterElementRow.Month(cal.get(Calendar.MONTH)) filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE - val filterElement = FilterCondition(filterElementRow) + val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s1.id, (this as Session).id) + Assert.assertEquals(s1.id, (this).id) } } @@ -92,14 +92,14 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { cal.time = s1.startDate val filterElementRow = FilterElementRow.Year(cal.get(Calendar.YEAR)) filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE - val filterElement = FilterCondition(filterElementRow) + val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s1.id, (this as Session).id) + Assert.assertEquals(s1.id, (this).id) } } @@ -122,7 +122,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s1.id, (this as Session).id) + Assert.assertEquals(s1.id, (this).id) } } @@ -147,7 +147,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s1.id, (this as Session).id) + Assert.assertEquals(s1.id, (this).id) } } @@ -384,15 +384,15 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.STARTED_FROM_DATE - val filterElementRow = FilterElementRow.From(s2.startDate!!) + val filterElementRow = FilterElementRow.From.apply { dateValue = s2.startDate!!} filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE - filter.updateValueMap(FilterCondition(filterElementRow)) + filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s2.id, (this as Session).id) + Assert.assertEquals(s2.id, (this).id) } } @@ -412,15 +412,15 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.STARTED_TO_DATE - val filterElementRow = FilterElementRow.From(s1.startDate!!) + val filterElementRow = FilterElementRow.From.apply { dateValue = s1.startDate!! } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE - filter.updateValueMap(FilterCondition(filterElementRow)) + filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s1.id, (this as Session).id) + Assert.assertEquals(s1.id, (this).id) } } @@ -441,15 +441,15 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.ENDED_FROM_DATE - val filterElementRow = FilterElementRow.From(s2.endDate()) + val filterElementRow = FilterElementRow.From.apply { dateValue = s2.endDate() } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE - filter.updateValueMap(FilterCondition(filterElementRow)) + filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s2.id, (this as Session).id) + Assert.assertEquals(s2.id, (this).id) } } @@ -470,15 +470,15 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.ENDED_TO_DATE - val filterElementRow = FilterElementRow.From(s1.endDate()) + val filterElementRow = FilterElementRow.From.apply { dateValue = s1.endDate() } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE - filter.updateValueMap(FilterCondition(filterElementRow)) + filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(s1.id, (this as Session).id) + Assert.assertEquals(s1.id, (this).id) } } } \ No newline at end of file diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt index b4348fa2..1ad26832 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt @@ -30,7 +30,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type) + Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this).type) } } @@ -48,7 +48,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertEquals(1, sessions.size) sessions[0]?.run { - Assert.assertEquals(Session.Type.TOURNAMENT.ordinal, (this as Session).type) + Assert.assertEquals(Session.Type.TOURNAMENT.ordinal, (this).type) } } @@ -480,9 +480,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.MORE_THAN_NET_RESULT - val filterElementRow = FilterElementRow.ResultMoreThan(204.0) + val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 204.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE - filter.updateValueMap(FilterCondition(filterElementRow)) + filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val sessions = Filter.queryOn(realm, arrayListOf(filter)) @@ -505,9 +505,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.LESS_THAN_NET_RESULT - val filterElementRow = FilterElementRow.ResultLessThan(540.0) + val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 540.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE - filter.updateValueMap(FilterCondition(filterElementRow)) + filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val sessions = Filter.queryOn(realm, arrayListOf(filter)) @@ -530,14 +530,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filterMore = QueryCondition.MORE_THAN_NET_RESULT - val filterElementRow = FilterElementRow.ResultMoreThan(200.0) + val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 200.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE - filterMore.updateValueMap(FilterCondition(filterElementRow)) + filterMore.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val filterLess = QueryCondition.LESS_THAN_NET_RESULT - val filterElementRow2 = FilterElementRow.ResultLessThan(400.0) + val filterElementRow2 = FilterElementRow.ResultMoreThan.apply { this.amount = 400.0 } filterElementRow2.filterSectionRow = FilterSectionRow.VALUE - filterLess.updateValueMap(FilterCondition(filterElementRow2)) + filterLess.updateValueMap(FilterCondition(arrayListOf(filterElementRow2))) val sessions = Filter.queryOn(realm, arrayListOf(filterMore, filterLess)) 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 48f541d5..2a5ef662 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 @@ -169,18 +169,14 @@ enum class QueryCondition(var operator: Operator? = null) { if (isUsingDefaultCurrency) { realmQuery.endsWith(fieldName, s) .and() - .beginGroup() - .isNull("bankroll") - .or() - .isNull("bankroll.currency") - .or() .isNull("bankroll.currency.code") - .endGroup() } else { realmQuery.equalTo(fieldName, s) } .endGroup() - .or() + if (index < stakes.size - 1) { + realmQuery.or() + } } realmQuery } 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 a0dcfdfb..60e67d27 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 @@ -10,17 +10,6 @@ import java.util.* open class Currency : RealmObject() { - companion object { - val localeCurrency: java.util.Currency - get() { - return try { - java.util.Currency.getInstance(Locale.getDefault()) - } catch (e: Exception) { - java.util.Currency.getInstance(Locale("en", "US")) - } - } - } - @Ignore val DEFAULTRATE: Double = 1.0 @@ -36,7 +25,9 @@ open class Currency : RealmObject() { var code: String? = null set(value) { field = value - bankrolls?.first()?.currencyCodeHasBeenUpdated() + bankrolls?.forEach { + it.currencyCodeHasBeenUpdated() + } } /** 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 c18eb1d2..fdfc1c6f 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 @@ -496,13 +496,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat * Return the formatted blinds */ fun getCurrencyFormattedStake(context:Context) : String { - val currency : Currency = Preferences.getCurrencyLocale(context)?.let { - Currency.getInstance(it) - } ?: run { - net.pokeranalytics.android.model.realm.Currency.localeCurrency - } - - val currencySymbol = currencySymbol ?: currency.symbol + val currencySymbol = currencySymbol ?: Preferences.getDefaultCurrency(context).symbol return "$currencySymbol $stake" } diff --git a/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt b/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt index 9672f3fa..9dbe8458 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt @@ -5,14 +5,10 @@ import io.realm.Realm import io.realm.kotlin.where import net.pokeranalytics.android.model.realm.Bankroll import net.pokeranalytics.android.model.realm.Currency -<<<<<<< HEAD -======= -import net.pokeranalytics.android.model.realm.Game import net.pokeranalytics.android.model.realm.TournamentFeature -import net.pokeranalytics.android.util.CurrencyUtils ->>>>>>> 7fce9661594eb0faba91337d78c6cc1e880e49a1 import java.util.* - +import net.pokeranalytics.android.model.realm.Game +import net.pokeranalytics.android.util.CurrencyUtils class Seed(var context:Context) : Realm.Transaction { @@ -32,23 +28,10 @@ class Seed(var context:Context) : Realm.Transaction { } } - val localeCurrency: java.util.Currency - get() { - return try { - java.util.Currency.getInstance(Locale.getDefault()) - } catch (e: Exception) { - java.util.Currency.getInstance(Locale("en", "US")) - } - } - private fun createDefaultCurrencyAndBankroll(realm: Realm) { // Currency -<<<<<<< HEAD - val localeCurrency = localeCurrency -======= val localeCurrency = CurrencyUtils.getLocaleCurrency() ->>>>>>> 7fce9661594eb0faba91337d78c6cc1e880e49a1 val defaultCurrency = Currency() defaultCurrency.code = localeCurrency.currencyCode realm.insertOrUpdate(defaultCurrency) 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 5217f486..e1cb1e23 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 @@ -12,12 +12,9 @@ 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.CurrencyUtils -import net.pokeranalytics.android.util.NULL_TEXT -import net.pokeranalytics.android.util.extensions.formatted -import net.pokeranalytics.android.util.extensions.round +import net.pokeranalytics.android.util.Preferences import java.text.DateFormatSymbols import java.util.* -import java.util.prefs.Preferences sealed class FilterElementRow : RowRepresentable { @@ -312,13 +309,7 @@ sealed class FilterElementRow : RowRepresentable { currencySymbol?.let { "$it $stake" } - - val currency : Currency = net.pokeranalytics.android.util.Preferences.getCurrencyLocale(context)?.let { - Currency.getInstance(it) - } ?: run { - net.pokeranalytics.android.model.realm.Currency.localeCurrency - } - val currencySymbol = currencySymbol ?: currency.symbol + val currencySymbol = currencySymbol ?: Preferences.getDefaultCurrency(context).symbol "$currencySymbol $stake" } is StaticDataFilterElementRow -> this.getDataLocalizedTitle(context) diff --git a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt index c52bdb52..87e02595 100644 --- a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt +++ b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt @@ -16,7 +16,7 @@ class Preferences { companion object { - var currencyLocale : Locale? = null + private var currencyLocale : Locale? = null fun setString(key: Keys, value: String, context: Context) { val preferences = PreferenceManager.getDefaultSharedPreferences(context) @@ -52,7 +52,6 @@ class Preferences { } fun getCurrencyLocale(context : Context) : Locale? { - currencyLocale?. let { return it } @@ -69,8 +68,15 @@ class Preferences { return it } } - currencyLocale = Locale.getDefault() - return currencyLocale!! + return null + } + + fun getDefaultCurrency(context: Context) : Currency { + return Preferences.getCurrencyLocale(context)?.let { + Currency.getInstance(it) + } ?: run { + CurrencyUtils.getLocaleCurrency() + } } fun setStopShowingDisclaimer(context: Context) { From 2ae88a5491b89380148d4c0efd9e9d2935452129 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Fri, 12 Apr 2019 11:17:08 +0200 Subject: [PATCH 05/10] add a new userDefault singleton class with context init argument and default currency management --- .../android/PokerAnalyticsApplication.kt | 3 ++ .../android/util/Preferences.kt | 48 ++++++++++++++++--- 2 files changed, 45 insertions(+), 6 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/PokerAnalyticsApplication.kt b/app/src/main/java/net/pokeranalytics/android/PokerAnalyticsApplication.kt index be1d6117..a92e3af4 100644 --- a/app/src/main/java/net/pokeranalytics/android/PokerAnalyticsApplication.kt +++ b/app/src/main/java/net/pokeranalytics/android/PokerAnalyticsApplication.kt @@ -14,6 +14,7 @@ import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.utils.Seed import net.pokeranalytics.android.util.FakeDataManager import net.pokeranalytics.android.util.PokerAnalyticsLogs +import net.pokeranalytics.android.util.UserDefaults import timber.log.Timber @@ -22,6 +23,8 @@ class PokerAnalyticsApplication : Application() { override fun onCreate() { super.onCreate() + UserDefaults.init(this) + println("UserPreferences.defaultCurrency: ${UserDefaults.currency.symbol}") // Realm Realm.init(this) diff --git a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt index 87e02595..d3dbfc4f 100644 --- a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt +++ b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt @@ -43,12 +43,13 @@ class Preferences { } fun setCurrencyCode(currencyCode: String, context: Context) { - Preferences.setString(Keys.CURRENCY_CODE, currencyCode, context) + setString(Keys.CURRENCY_CODE, currencyCode, context) currencyLocale = null + UserDefaults.currency = getDefaultCurrency(context) } private fun getCurrencyCode(context: Context) : String? { - return Preferences.getString(Keys.CURRENCY_CODE, context) + return getString(Keys.CURRENCY_CODE, context) } fun getCurrencyLocale(context : Context) : Locale? { @@ -56,7 +57,7 @@ class Preferences { return it } - Preferences.getCurrencyCode(context)?.let { currencyCode -> + getCurrencyCode(context)?.let { currencyCode -> Locale.getAvailableLocales().filter{ try { Currency.getInstance(it).currencyCode == currencyCode @@ -72,7 +73,7 @@ class Preferences { } fun getDefaultCurrency(context: Context) : Currency { - return Preferences.getCurrencyLocale(context)?.let { + return getCurrencyLocale(context)?.let { Currency.getInstance(it) } ?: run { CurrencyUtils.getLocaleCurrency() @@ -80,13 +81,48 @@ class Preferences { } fun setStopShowingDisclaimer(context: Context) { - Preferences.setBoolean(Keys.STOP_SHOWING_DISCLAIMER, true, context) + setBoolean(Keys.STOP_SHOWING_DISCLAIMER, true, context) } fun shouldShowDisclaimer(context: Context) : Boolean { - return !Preferences.getBoolean(Keys.STOP_SHOWING_DISCLAIMER, context) + return !getBoolean(Keys.STOP_SHOWING_DISCLAIMER, context) } } +} + +class UserDefaults private constructor(context: Context) { + init { + currency = Preferences.getDefaultCurrency(context) + } + + companion object : SingletonHolder(::UserDefaults) { + lateinit var currency : Currency + } +} + + +open class SingletonHolder(creator: (A) -> T) { + private var creator: ((A) -> T)? = creator + @Volatile private var instance: T? = null + + fun init(context: A): T { + val i = instance + if (i != null) { + return i + } + + return synchronized(this) { + val i2 = instance + if (i2 != null) { + i2 + } else { + val created = creator!!(context) + instance = created + creator = null + created + } + } + } } \ No newline at end of file From bd187a49a4f7c36cc3319e5c27ab0cbc8f2fb73b Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Fri, 12 Apr 2019 11:27:08 +0200 Subject: [PATCH 06/10] revert stake to blind --- .../filter/BlindFilterInstrumentedTest.kt | 32 +++++++++---------- .../android/model/filter/QueryCondition.kt | 19 ++++++----- .../android/model/realm/FilterCondition.kt | 8 ++--- .../android/model/realm/Session.kt | 2 +- .../rowrepresentable/FilterCategoryRow.kt | 2 +- .../view/rowrepresentable/FilterElementRow.kt | 12 +++---- .../view/rowrepresentable/FilterSectionRow.kt | 14 ++++---- 7 files changed, 42 insertions(+), 47 deletions(-) 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 da1c1926..279b368d 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.STAKE - val blind = FilterElementRow.Stake(s1.stake!!) - blind.filterSectionRow = FilterSectionRow.STAKE + val filter = QueryCondition.BLIND + val blind = FilterElementRow.Blind(s1.stake!!) + blind.filterSectionRow = FilterSectionRow.BLIND val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) @@ -86,11 +86,11 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.STAKE - val blind1 = FilterElementRow.Stake(s1.stake!!) - val blind2 = FilterElementRow.Stake(s2.stake!!) - blind1.filterSectionRow = FilterSectionRow.STAKE - blind2.filterSectionRow = FilterSectionRow.STAKE + val filter = QueryCondition.BLIND + val blind1 = FilterElementRow.Blind(s1.stake!!) + val blind2 = FilterElementRow.Blind(s2.stake!!) + blind1.filterSectionRow = FilterSectionRow.BLIND + blind2.filterSectionRow = FilterSectionRow.BLIND val filterElements = FilterCondition(filterElementRows = arrayListOf(blind1, blind2)) filter.updateValueMap(filterElements) @@ -132,9 +132,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.STAKE - val blind = FilterElementRow.Stake(s3.stake!!, "$") - blind.filterSectionRow = FilterSectionRow.STAKE + val filter = QueryCondition.BLIND + val blind = FilterElementRow.Blind(s3.stake!!, "$") + blind.filterSectionRow = FilterSectionRow.BLIND val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) @@ -175,12 +175,12 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.STAKE - val blind1 = FilterElementRow.Stake(s1.stake!!) - blind1.filterSectionRow = FilterSectionRow.STAKE + val filter = QueryCondition.BLIND + val blind1 = FilterElementRow.Blind(s1.stake!!) + blind1.filterSectionRow = FilterSectionRow.BLIND - val blind2 = FilterElementRow.Stake(s2.stake!!) - blind2.filterSectionRow = FilterSectionRow.STAKE + val blind2 = FilterElementRow.Blind(s2.stake!!) + blind2.filterSectionRow = FilterSectionRow.BLIND 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 2a5ef662..b9f24f47 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 @@ -4,7 +4,6 @@ import io.realm.RealmQuery import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.realm.FilterCondition import net.pokeranalytics.android.model.realm.Session -import net.pokeranalytics.android.util.Preferences import net.pokeranalytics.android.util.extensions.endOfDay import net.pokeranalytics.android.util.extensions.startOfDay import java.util.* @@ -30,7 +29,7 @@ enum class QueryCondition(var operator: Operator? = null) { LIMIT, TABLE_SIZE, TOURNAMENT_TYPE, - STAKE, + BLIND, LAST_GAMES, LAST_SESSIONS, MORE_NUMBER_OF_TABLE(Operator.MORE), @@ -112,7 +111,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") - STAKE -> arrayOf("stakes", "hasDefaultCurrency") + BLIND -> arrayOf("blinds", "hasDefaultCurrency") STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date") DAY_OF_WEEK -> arrayOf("dayOfWeek") MONTH -> arrayOf("month") @@ -159,11 +158,11 @@ enum class QueryCondition(var operator: Operator? = null) { val ids: Array by valueMap realmQuery.`in`(fieldName, ids) } - STAKE -> { - val stakes: Array by valueMap + BLIND -> { + val blinds: Array by valueMap val hasDefaultCurrency: Array by valueMap - //realmQuery.`in`(fieldName, stakes) - stakes.forEachIndexed { index, s -> + //realmQuery.`in`(fieldName, blinds) + blinds.forEachIndexed { index, s -> val isUsingDefaultCurrency = hasDefaultCurrency[index] realmQuery.beginGroup() if (isUsingDefaultCurrency) { @@ -174,7 +173,7 @@ enum class QueryCondition(var operator: Operator? = null) { realmQuery.equalTo(fieldName, s) } .endGroup() - if (index < stakes.size - 1) { + if (index < blinds.size - 1) { realmQuery.or() } } @@ -284,9 +283,9 @@ enum class QueryCondition(var operator: Operator? = null) { LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { valueMap = mapOf("values" to filterCondition.values) } - STAKE -> { + BLIND -> { valueMap = mapOf( - "stakes" to filterCondition.stakes, + "blinds" to filterCondition.blinds, "hasDefaultCurrency" to filterCondition.hasDefaultCurrency) } STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> { 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 0aabc19c..388f2b38 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 @@ -23,16 +23,16 @@ open class FilterCondition() : RealmObject() { is DateFilterElementRow -> { this.dateValue = row.dateValue } - is Stake -> { + is Blind -> { //TODO refactor raz this.stringValues = RealmList().apply { this.addAll(filterElementRows.map { - (it as Stake).stake + (it as Blind).blind }) } this.booleanValues = RealmList().apply { this.addAll(filterElementRows.map { - ((it as Stake).currencySymbol == null) + ((it as Blind).currencySymbol == null) }) } } @@ -70,7 +70,7 @@ open class FilterCondition() : RealmObject() { val ids: Array get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - val stakes: Array + val blinds: Array get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing val hasDefaultCurrency: Array 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 fdfc1c6f..a9be28a6 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 @@ -79,7 +79,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat LIMIT -> "limit" TABLE_SIZE -> "tableSize" TOURNAMENT_TYPE -> "tournamentType" - STAKE -> "stake" + BLIND -> "blind" 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" 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 4ba5534f..d22bd4d0 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( - STAKE, + BLIND, 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 e1cb1e23..da69af74 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,7 +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.CurrencyUtils import net.pokeranalytics.android.util.Preferences import java.text.DateFormatSymbols import java.util.* @@ -103,7 +102,7 @@ sealed class FilterElementRow : RowRepresentable { data class Month(val month: Int) : SingleValueFilterElementRow(month) data class Day(val day: Int) : SingleValueFilterElementRow(day) - data class Stake(val stake : String, val currencySymbol:String? = null) : StringFilterElementRow(stake) + data class Blind(val blind : String, val currencySymbol:String? = null) : StringFilterElementRow(blind) //TODO: Refactor? data class PastDays(var lastDays: Int = 0) : SingleValueFilterElementRow(lastDays) { @@ -146,7 +145,7 @@ sealed class FilterElementRow : RowRepresentable { return when (this) { is Cash -> QueryCondition.CASH is Tournament -> QueryCondition.TOURNAMENT - is Stake -> QueryCondition.STAKE + is Blind -> QueryCondition.BLIND is From -> QueryCondition.STARTED_FROM_DATE is To -> QueryCondition.ENDED_TO_DATE is FromTime -> QueryCondition.STARTED_FROM_TIME @@ -305,12 +304,9 @@ sealed class FilterElementRow : RowRepresentable { override fun localizedTitle(context: Context): String { return when (this) { - is Stake -> { - currencySymbol?.let { - "$it $stake" - } + is Blind -> { val currencySymbol = currencySymbol ?: Preferences.getDefaultCurrency(context).symbol - "$currencySymbol $stake" + "$currencySymbol $blind" } is StaticDataFilterElementRow -> this.getDataLocalizedTitle(context) else -> super.localizedTitle(context) 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 4f634007..1f5e71e8 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 @@ -30,7 +30,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), - STAKE(net.pokeranalytics.android.R.string.stakes), + BLIND(net.pokeranalytics.android.R.string.blinds), 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), @@ -160,17 +160,17 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { SESSIONS -> arrayListOf(LastGames(0), LastSessions(0)) // Cash - STAKE -> { - val stakes = arrayListOf() + BLIND -> { + val blinds = arrayListOf() val realm = Realm.getDefaultInstance() - realm.where().distinct("stake", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map { + realm.where().distinct("blind", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map { it.stake?.let { stake -> - stakes.add(Stake(stake, it.currencySymbol)) + blinds.add(Blind(stake, it.currencySymbol)) } } realm.close() - stakes - } + blinds + } CASH_RE_BUY_COUNT -> arrayListOf( ReBuyMoreThan as FilterElementRow, ReBuyLessThan as FilterElementRow From 4afd8a71b9d98e0bf70dbdcdb56f30edd8740d49 Mon Sep 17 00:00:00 2001 From: Laurent Date: Fri, 12 Apr 2019 12:25:25 +0200 Subject: [PATCH 07/10] Adds selection and legend update on graphs --- .../android/calculus/Calculator.kt | 16 ++++++------ .../pokeranalytics/android/calculus/Report.kt | 13 +++++----- .../pokeranalytics/android/calculus/Stat.kt | 10 +++++--- .../android/model/interfaces/Timed.kt | 5 +++- .../android/model/realm/Session.kt | 11 ++++---- .../android/model/realm/SessionSet.kt | 6 +++++ .../android/ui/fragment/GraphFragment.kt | 25 ++++++------------- .../android/ui/view/LegendView.kt | 19 +++++++------- .../android/ui/view/RowViewType.kt | 11 +++++--- .../android/ui/view/SessionRowView.kt | 6 +++-- .../android/ui/view/TransactionRowView.kt | 6 +++-- .../android/ui/view/fields/FieldsExtension.kt | 10 ++++++++ 12 files changed, 79 insertions(+), 59 deletions(-) create mode 100644 app/src/main/java/net/pokeranalytics/android/ui/view/fields/FieldsExtension.kt diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt index 2617ae13..e8cd78ca 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt @@ -147,19 +147,19 @@ class Calculator { tHands += computable.estimatedHands val session = computable.session ?: throw IllegalStateException("Computing lone ComputableResult") - results.addEvolutionValue(tSum, NETRESULT, session) - results.addEvolutionValue(tSum / index, AVERAGE, session) - results.addEvolutionValue(index.toDouble(), NUMBER_OF_GAMES, session) - results.addEvolutionValue(tBBSum / tBBSessionCount, AVERAGE_NET_BB, session) - results.addEvolutionValue((tWinningSessionCount / index).toDouble(), WIN_RATIO, session) - results.addEvolutionValue(tBuyinSum / index, AVERAGE_BUYIN, session) + results.addEvolutionValue(tSum, stat = NETRESULT, data = session) + results.addEvolutionValue(tSum / index, stat = AVERAGE, data = session) + results.addEvolutionValue(index.toDouble(), stat = NUMBER_OF_GAMES, data = session) + results.addEvolutionValue(tBBSum / tBBSessionCount, stat = AVERAGE_NET_BB, data = session) + results.addEvolutionValue((tWinningSessionCount / index).toDouble(), stat = WIN_RATIO, data = session) + results.addEvolutionValue(tBuyinSum / index, stat = AVERAGE_BUYIN, data = session) Stat.netBBPer100Hands(tBBSum, tHands)?.let { netBB100 -> - results.addEvolutionValue(netBB100, NET_BB_PER_100_HANDS, session) + results.addEvolutionValue(netBB100, stat = NET_BB_PER_100_HANDS, data = session) } Stat.returnOnInvestment(tSum, tBuyinSum)?.let { roi -> - results.addEvolutionValue(roi, ROI, session) + results.addEvolutionValue(roi, stat = ROI, data = session) } } diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt index de8c329f..e97d56f9 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt @@ -158,13 +158,14 @@ class ComputedResults(group: ComputableGroup) { /** * Adds a value to the evolution values */ - fun addEvolutionValue(value: Double, stat: Stat, data: Any) { - this._addEvolutionValue(Point(value, data), stat = stat) - } + fun addEvolutionValue(value: Double, duration: Double? = null, stat: Stat, data: Timed) { - fun addEvolutionValue(value: Double, duration: Double, stat: Stat, data: Timed) { - stat.underlyingClass = data::class.java - this._addEvolutionValue(Point(value, y = duration, data = data.id), stat = stat) + val point = if (duration != null) { + Point(duration, y = value, data = data.objectIdentifier) + } else { + Point(value, data = data.objectIdentifier) + } + this._addEvolutionValue(point, stat = stat) } private fun _addEvolutionValue(point: Point, stat: Stat) { diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt index 1b111ecf..d4e89d06 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt @@ -1,9 +1,9 @@ package net.pokeranalytics.android.calculus import android.content.Context -import io.realm.RealmModel import net.pokeranalytics.android.R import net.pokeranalytics.android.exceptions.FormattingException +import net.pokeranalytics.android.model.interfaces.Identifiable import net.pokeranalytics.android.model.interfaces.Timed import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowViewType @@ -17,7 +17,11 @@ class StatFormattingException(message: String) : Exception(message) { } -interface StatBase : RealmModel { +class ObjectIdentifier(var id: String, var clazz: Class) { + +} + +interface StatBase : Identifiable { fun formattedValue(stat: Stat, context: Context): TextFormat @@ -48,7 +52,7 @@ enum class AggregationType { /** * An enum representing all the types of Session statistics */ -enum class Stat(var underlyingClass: Class? = null) : RowRepresentable { +enum class Stat : RowRepresentable { NETRESULT, HOURLY_RATE, diff --git a/app/src/main/java/net/pokeranalytics/android/model/interfaces/Timed.kt b/app/src/main/java/net/pokeranalytics/android/model/interfaces/Timed.kt index 01431a6e..49ba2542 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/interfaces/Timed.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/interfaces/Timed.kt @@ -1,9 +1,10 @@ package net.pokeranalytics.android.model.interfaces +import net.pokeranalytics.android.calculus.ObjectIdentifier import net.pokeranalytics.android.calculus.StatBase import java.util.* -interface Timed : StatBase, Identifiable { +interface Timed : StatBase { fun startDate() : Date? @@ -29,4 +30,6 @@ interface Timed : StatBase, Identifiable { val hourlyDuration: Double get() = this.netDuration / 3600000.0 + val objectIdentifier : ObjectIdentifier + } \ 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 486aca1b..f65c7fac 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 @@ -11,10 +11,7 @@ import io.realm.annotations.LinkingObjects import io.realm.annotations.PrimaryKey import io.realm.kotlin.where import net.pokeranalytics.android.R -import net.pokeranalytics.android.calculus.ComputedStat -import net.pokeranalytics.android.calculus.Stat -import net.pokeranalytics.android.calculus.StatFormattingException -import net.pokeranalytics.android.calculus.TextFormat +import net.pokeranalytics.android.calculus.* import net.pokeranalytics.android.exceptions.ModelException import net.pokeranalytics.android.model.Limit import net.pokeranalytics.android.model.LiveData @@ -47,7 +44,6 @@ typealias BB = Double open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDataSource, RowRepresentable, Timed, TimeFilterable, Filterable { - enum class Type { CASH_GAME, TOURNAMENT @@ -871,6 +867,11 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat } + // Timed + + override val objectIdentifier: ObjectIdentifier + get() = ObjectIdentifier(this.id, Session::class.java) + } diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt index 9774e1b7..4b3178e7 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt @@ -7,6 +7,7 @@ import io.realm.RealmResults import io.realm.annotations.Ignore import io.realm.annotations.LinkingObjects import io.realm.annotations.PrimaryKey +import net.pokeranalytics.android.calculus.ObjectIdentifier import net.pokeranalytics.android.calculus.Stat import net.pokeranalytics.android.calculus.StatFormattingException import net.pokeranalytics.android.calculus.TextFormat @@ -109,5 +110,10 @@ open class SessionSet() : RealmObject(), Timed, Filterable { } + // Timed + + override val objectIdentifier: ObjectIdentifier + get() = ObjectIdentifier(this.id, SessionSet::class.java) + } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt index 1293fc0a..6afffdbf 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt @@ -17,6 +17,7 @@ import com.google.android.material.chip.ChipGroup import kotlinx.android.synthetic.main.fragment_evograph.* import net.pokeranalytics.android.R import net.pokeranalytics.android.calculus.GraphType +import net.pokeranalytics.android.calculus.ObjectIdentifier import net.pokeranalytics.android.calculus.Stat import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment @@ -25,16 +26,11 @@ import net.pokeranalytics.android.ui.view.LegendView import net.pokeranalytics.android.util.extensions.ChipGroupExtension import net.pokeranalytics.android.util.extensions.px import net.pokeranalytics.android.util.extensions.toast - -interface GraphDataSource { - - -} +import java.text.DateFormat class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener { private lateinit var parentActivity: PokerAnalyticsActivity - lateinit var dataSource: GraphDataSource lateinit var stat: Stat lateinit var entries: List @@ -69,7 +65,7 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener { this.legendView = LegendView(requireContext()) this.legendContainer.addView(this.legendView) - this.legendView.prepareWithStat(this.stat) + this.legendView.prepareWithStat(this.stat, this.entries.size) // Avoid a bug during setting the title toolbar.title = "" @@ -133,23 +129,16 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener { e?.let { entry -> h?.let { highlight -> - val id = entry.data as String - val item = getRealm().where(this.stat.underlyingClass).equalTo("id", id).findAll().firstOrNull() + val identifier = entry.data as ObjectIdentifier + val item = getRealm().where(identifier.clazz).equalTo("id", identifier.id).findAll().firstOrNull() item?.let { - val date = it.startDate() - - val entryStatName = this.stat.localizedTitle(requireContext()) + val formattedDate = DateFormat.getDateInstance(DateFormat.SHORT).format(it.startDate()) val entryValue = it.formattedValue(this.stat, requireContext()) - - val totalStatName = this.stat.cumulativeLabelResId(requireContext()) val totalStatValue = this.stat.format(e.y.toDouble(), null, requireContext()) + this.legendView.setItemData(this.stat, formattedDate, entryValue, totalStatValue) } - -// this.text.text = "" - - } } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/LegendView.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/LegendView.kt index a5d4ad1b..03552cde 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/LegendView.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/LegendView.kt @@ -8,8 +8,8 @@ import androidx.constraintlayout.widget.ConstraintLayout import kotlinx.android.synthetic.main.layout_legend_default.view.* import net.pokeranalytics.android.R import net.pokeranalytics.android.calculus.Stat -import net.pokeranalytics.android.model.realm.Session - +import net.pokeranalytics.android.calculus.TextFormat +import net.pokeranalytics.android.ui.view.fields.setTextFormat /** * Display a row session @@ -46,23 +46,22 @@ class LegendView : FrameLayout { /** * Set the stat data to the view */ - fun prepareWithStat(stat: Stat) { + fun prepareWithStat(stat: Stat, counter: Int) { this.stat1Name.text = stat.localizedTitle(context) this.stat2Name.text = stat.cumulativeLabelResId(context) - - //TODO: Set real data - this.title.text = "11/04/2019" - this.stat1Value.text = "$521" - this.stat2Value.text = "$15,051" - this.counter.text = "21 Sessions" + this.counter.text = "$counter ${context.getString(R.string.sessions)}" } /** * */ - fun setData(session: Session) { + fun setItemData(stat: Stat, title: String, statFormat1: TextFormat, statFormat2: TextFormat) { + + this.title.text = title + this.stat1Value.setTextFormat(statFormat1, context) + this.stat2Value.setTextFormat(statFormat2, context) } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/RowViewType.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/RowViewType.kt index c887ff71..4e757885 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/RowViewType.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/RowViewType.kt @@ -16,6 +16,7 @@ import net.pokeranalytics.android.R import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.Transaction import net.pokeranalytics.android.ui.adapter.RowRepresentableAdapter +import net.pokeranalytics.android.ui.view.fields.setTextFormat import net.pokeranalytics.android.ui.view.rowrepresentable.CustomizableRowRepresentable /** @@ -120,8 +121,9 @@ enum class RowViewType(private var layoutRes: Int) { itemView.findViewById(R.id.value)?.let { if (row.computedStat != null) { val format = row.computedStat!!.format(itemView.context) - it.setTextColor(format.getColor(itemView.context)) - it.text = format.text + it.setTextFormat(format, itemView.context) +// it.setTextColor(format.getColor(itemView.context)) +// it.text = format.text } else if (row.value != null) { it.text = row.value } @@ -221,8 +223,9 @@ enum class RowViewType(private var layoutRes: Int) { // Value itemView.findViewById(R.id.value)?.let { view -> adapter.dataSource.contentDescriptorForRow(row)?.textFormat?.let { - view.text = it.text - view.setTextColor(it.getColor(itemView.context)) + view.setTextFormat(it, itemView.context) +// view.text = it.text +// view.setTextColor(it.getColor(itemView.context)) } } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt index 6cef22f9..45dc934e 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt @@ -15,6 +15,7 @@ import net.pokeranalytics.android.model.TournamentType import net.pokeranalytics.android.model.extensions.SessionState import net.pokeranalytics.android.model.extensions.getState import net.pokeranalytics.android.model.realm.Session +import net.pokeranalytics.android.ui.view.fields.setTextFormat import net.pokeranalytics.android.util.CurrencyUtils import net.pokeranalytics.android.util.extensions.getDayNumber import net.pokeranalytics.android.util.extensions.getShortDayName @@ -150,8 +151,9 @@ class SessionRowView : FrameLayout { val result = session.result?.net ?: 0.0 val formattedStat = ComputedStat(Stat.NETRESULT, result, currency = CurrencyUtils.getCurrency(session.bankroll)).format(context) - rowHistorySession.gameResult.setTextColor(formattedStat.getColor(context)) - rowHistorySession.gameResult.text = formattedStat.text + rowHistorySession.gameResult.setTextFormat(formattedStat, context) +// rowHistorySession.gameResult.setTextColor(formattedStat.getColor(context)) +// rowHistorySession.gameResult.text = formattedStat.text } } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/TransactionRowView.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/TransactionRowView.kt index ab45b09c..25f3b5a3 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/TransactionRowView.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/TransactionRowView.kt @@ -10,6 +10,7 @@ import net.pokeranalytics.android.R import net.pokeranalytics.android.calculus.ComputedStat import net.pokeranalytics.android.calculus.Stat import net.pokeranalytics.android.model.realm.Transaction +import net.pokeranalytics.android.ui.view.fields.setTextFormat import net.pokeranalytics.android.util.extensions.getDayNumber import net.pokeranalytics.android.util.extensions.getShortDayName @@ -63,8 +64,9 @@ class TransactionRowView : FrameLayout { // Amount val formattedStat = ComputedStat(Stat.NETRESULT, transaction.amount).format(context) - rowTransaction.transactionAmount.setTextColor(formattedStat.getColor(context)) - rowTransaction.transactionAmount.text = formattedStat.text + rowTransaction.transactionAmount.setTextFormat(formattedStat, context) +// rowTransaction.transactionAmount.setTextColor(formattedStat.getColor(context)) +// rowTransaction.transactionAmount.text = formattedStat.text } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/fields/FieldsExtension.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/fields/FieldsExtension.kt new file mode 100644 index 00000000..1a7b35c5 --- /dev/null +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/fields/FieldsExtension.kt @@ -0,0 +1,10 @@ +package net.pokeranalytics.android.ui.view.fields + +import android.content.Context +import androidx.appcompat.widget.AppCompatTextView +import net.pokeranalytics.android.calculus.TextFormat + +fun AppCompatTextView.setTextFormat(textFormat: TextFormat, context: Context) { + this.setTextColor(textFormat.getColor(context)) + this.text = textFormat.text +} \ No newline at end of file From 2782ad103b38ab0bb42110b0d0fbdc96ceaad9de Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Fri, 12 Apr 2019 13:02:33 +0200 Subject: [PATCH 08/10] refactor currency usage --- .../filter/BlindFilterInstrumentedTest.kt | 12 ++-- .../pokeranalytics/android/calculus/Stat.kt | 8 +-- .../android/model/realm/FilterCondition.kt | 2 +- .../android/model/realm/Session.kt | 67 ++++++++++--------- .../android/model/utils/Seed.kt | 4 +- .../ui/fragment/BankrollDataFragment.kt | 8 +-- .../android/ui/fragment/SessionFragment.kt | 5 +- .../android/ui/fragment/SettingsFragment.kt | 12 +++- .../android/ui/view/SessionRowView.kt | 7 +- .../view/rowrepresentable/FilterElementRow.kt | 10 ++- .../view/rowrepresentable/FilterSectionRow.kt | 4 +- .../android/util/CurrencyUtils.kt | 64 ------------------ .../android/util/Preferences.kt | 46 ++++++++----- .../util/extensions/NumbersExtension.kt | 11 ++- 14 files changed, 113 insertions(+), 147 deletions(-) delete mode 100644 app/src/main/java/net/pokeranalytics/android/util/CurrencyUtils.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 279b368d..9ace6e81 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 @@ -43,7 +43,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.BLIND - val blind = FilterElementRow.Blind(s1.stake!!) + val blind = FilterElementRow.Blind(s1.blinds!!, true) blind.filterSectionRow = FilterSectionRow.BLIND val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) @@ -87,8 +87,8 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.BLIND - val blind1 = FilterElementRow.Blind(s1.stake!!) - val blind2 = FilterElementRow.Blind(s2.stake!!) + val blind1 = FilterElementRow.Blind(s1.blinds!!, true) + val blind2 = FilterElementRow.Blind(s2.blinds!!, true) blind1.filterSectionRow = FilterSectionRow.BLIND blind2.filterSectionRow = FilterSectionRow.BLIND @@ -133,7 +133,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.BLIND - val blind = FilterElementRow.Blind(s3.stake!!, "$") + val blind = FilterElementRow.Blind(s3.blinds!!, false) blind.filterSectionRow = FilterSectionRow.BLIND val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) @@ -176,10 +176,10 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.BLIND - val blind1 = FilterElementRow.Blind(s1.stake!!) + val blind1 = FilterElementRow.Blind(s1.blinds!!, false) blind1.filterSectionRow = FilterSectionRow.BLIND - val blind2 = FilterElementRow.Blind(s2.stake!!) + val blind2 = FilterElementRow.Blind(s2.blinds!!, false) blind2.filterSectionRow = FilterSectionRow.BLIND val filterElement = FilterCondition(filterElementRows = arrayListOf(blind1, blind2)) filter.updateValueMap(filterElement) diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt index 1b111ecf..09335cbe 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt @@ -7,10 +7,10 @@ import net.pokeranalytics.android.exceptions.FormattingException import net.pokeranalytics.android.model.interfaces.Timed import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowViewType -import net.pokeranalytics.android.util.CurrencyUtils import net.pokeranalytics.android.util.NULL_TEXT import net.pokeranalytics.android.util.extensions.formatted import net.pokeranalytics.android.util.extensions.formattedHourlyDuration +import net.pokeranalytics.android.util.extensions.toCurrency import java.util.* class StatFormattingException(message: String) : Exception(message) { @@ -132,9 +132,8 @@ enum class Stat(var underlyingClass: Class? = null) : RowRepresentabl when (this) { // Amounts + red/green Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE -> { - val numberFormat = CurrencyUtils.getCurrencyFormatter(context, currency) val color = if (value >= this.threshold) R.color.green else R.color.red - return TextFormat(numberFormat.format(value), color) + return TextFormat(value.toCurrency(currency), color) } // Red/green numericValues Stat.HOURLY_RATE_BB, Stat.AVERAGE_NET_BB, Stat.NET_BB_PER_100_HANDS -> { @@ -154,8 +153,7 @@ enum class Stat(var underlyingClass: Class? = null) : RowRepresentabl } // white amountsr Stat.AVERAGE_BUYIN, Stat.STANDARD_DEVIATION, Stat.STANDARD_DEVIATION_HOURLY, Stat.STANDARD_DEVIATION_BB_PER_100_HANDS -> { - val numberFormat = CurrencyUtils.getCurrencyFormatter(context, currency) - return TextFormat(numberFormat.format(value)) + return TextFormat(value.toCurrency(currency)) } else -> throw FormattingException("Stat formatting of ${this.name} not handled") } 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 388f2b38..52851300 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 @@ -32,7 +32,7 @@ open class FilterCondition() : RealmObject() { } this.booleanValues = RealmList().apply { this.addAll(filterElementRows.map { - ((it as Blind).currencySymbol == null) + (it as Blind).hasDefaultCurrency }) } } 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 a9be28a6..dd126acd 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 @@ -35,9 +35,8 @@ import net.pokeranalytics.android.ui.view.RowViewType import net.pokeranalytics.android.ui.view.rowrepresentable.CustomizableRowRepresentable import net.pokeranalytics.android.ui.view.rowrepresentable.SeparatorRowRepresentable import net.pokeranalytics.android.ui.view.rowrepresentable.SessionRow -import net.pokeranalytics.android.util.CurrencyUtils import net.pokeranalytics.android.util.NULL_TEXT -import net.pokeranalytics.android.util.Preferences +import net.pokeranalytics.android.util.UserDefaults import net.pokeranalytics.android.util.extensions.* import java.util.* import java.util.Currency @@ -220,7 +219,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat var cgSmallBlind: Double? = null set(value) { field = value - computeStakeAsString() + formatBlinds() } // The big blind value @@ -228,10 +227,10 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat set(value) { field = value this.computeStats() - computeStakeAsString() + formatBlinds() } - var stake: String? = null + var blinds: String? = null private set // Tournament @@ -252,7 +251,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat var tournamentFeatures: RealmList = RealmList() fun bankrollHasBeenUpdated() { - computeStakeAsString() + formatBlinds() } /** @@ -492,13 +491,19 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat return NULL_TEXT } - /** - * Return the formatted blinds - */ - fun getCurrencyFormattedStake(context:Context) : String { - val currencySymbol = currencySymbol ?: Preferences.getDefaultCurrency(context).symbol - return "$currencySymbol $stake" - } + val hasDefaultCurrency: Boolean + get() { + return bankroll?.currency?.code == null + } + + val currency : Currency + get() { + return bankroll?.currency?.code?.let { + Currency.getInstance(it) + } ?: run { + UserDefaults.currency + } + } /** * Return the game title @@ -517,20 +522,16 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat return if (gameTitle.isNotBlank()) gameTitle else NULL_TEXT } - val currencySymbol : String? - get() { - bankroll?.currency?.code?.let { - return Currency.getInstance(it).symbol - } - return null - } + fun getFormattedBlinds(): String { + return blinds ?: NULL_TEXT + } - private fun computeStakeAsString() { - stake = null + private fun formatBlinds() { + blinds = null if (cgBigBlind == null) return cgBigBlind?.let { bb -> val sb = cgSmallBlind ?: bb / 2.0 - stake = "${sb.formatted()}/${bb.round()}" + blinds = "${currency.symbol} ${sb.formatted()}/${bb.round()}" } } @@ -584,7 +585,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat CustomizableRowRepresentable( RowViewType.HEADER_TITLE_AMOUNT_BIG, title = getFormattedDuration(), - computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, CurrencyUtils.getCurrency(bankroll)) + computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, currency) ) ) rows.add(SeparatorRowRepresentable()) @@ -594,7 +595,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat CustomizableRowRepresentable( RowViewType.HEADER_TITLE_AMOUNT_BIG, resId = R.string.pause, - computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, CurrencyUtils.getCurrency(bankroll)) + computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, currency) ) ) rows.add(SeparatorRowRepresentable()) @@ -604,14 +605,14 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat CustomizableRowRepresentable( RowViewType.HEADER_TITLE_AMOUNT_BIG, title = getFormattedDuration(), - computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, CurrencyUtils.getCurrency(bankroll)) + computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, currency) ) ) rows.add( CustomizableRowRepresentable( RowViewType.HEADER_TITLE_AMOUNT, resId = R.string.hour_rate_without_pauses, - computedStat = ComputedStat(Stat.HOURLY_RATE, this.hourlyRate, CurrencyUtils.getCurrency(bankroll)) + computedStat = ComputedStat(Stat.HOURLY_RATE, this.hourlyRate, currency) ) ) @@ -650,20 +651,20 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat override fun stringForRow(row: RowRepresentable, context: Context): String { return when (row) { SessionRow.BANKROLL -> bankroll?.name ?: NULL_TEXT - SessionRow.BLINDS -> getCurrencyFormattedStake(context) + SessionRow.BLINDS -> getFormattedBlinds() SessionRow.BREAK_TIME -> if (this.breakDuration > 0.0) this.breakDuration.toMinutes() else NULL_TEXT - SessionRow.BUY_IN -> this.result?.buyin?.toCurrency(CurrencyUtils.getCurrency(bankroll)) ?: NULL_TEXT - SessionRow.CASHED_OUT, SessionRow.PRIZE, SessionRow.NET_RESULT -> this.result?.cashout?.toCurrency(CurrencyUtils.getCurrency(bankroll)) ?: NULL_TEXT + SessionRow.BUY_IN -> this.result?.buyin?.toCurrency(currency) ?: NULL_TEXT + SessionRow.CASHED_OUT, SessionRow.PRIZE, SessionRow.NET_RESULT -> this.result?.cashout?.toCurrency(currency) ?: NULL_TEXT SessionRow.COMMENT -> if (this.comment.isNotEmpty()) this.comment else NULL_TEXT SessionRow.END_DATE -> this.endDate?.shortDateTime() ?: NULL_TEXT SessionRow.GAME -> getFormattedGame() - SessionRow.INITIAL_BUY_IN -> tournamentEntryFee?.toCurrency(CurrencyUtils.getCurrency(bankroll)) ?: NULL_TEXT + SessionRow.INITIAL_BUY_IN -> tournamentEntryFee?.toCurrency(currency) ?: NULL_TEXT SessionRow.LOCATION -> location?.name ?: NULL_TEXT SessionRow.PLAYERS -> tournamentNumberOfPlayers?.toString() ?: NULL_TEXT SessionRow.POSITION -> result?.tournamentFinalPosition?.toString() ?: NULL_TEXT SessionRow.START_DATE -> this.startDate?.shortDateTime() ?: NULL_TEXT SessionRow.TABLE_SIZE -> this.tableSize?.let { TableSize(it).localizedTitle(context) } ?: NULL_TEXT - SessionRow.TIPS -> result?.tips?.toCurrency(CurrencyUtils.getCurrency(bankroll)) ?: NULL_TEXT + SessionRow.TIPS -> result?.tips?.toCurrency(currency) ?: NULL_TEXT SessionRow.TOURNAMENT_TYPE -> this.tournamentType?.let { TournamentType.values()[it].localizedTitle(context) } ?: run { @@ -886,7 +887,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat } value?.let { - return stat.format(it, CurrencyUtils.getCurrency(this.bankroll), context) + return stat.format(it, currency, context) } ?: run { return TextFormat(NULL_TEXT) } diff --git a/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt b/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt index 9dbe8458..2bc66fc3 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/utils/Seed.kt @@ -8,7 +8,7 @@ import net.pokeranalytics.android.model.realm.Currency import net.pokeranalytics.android.model.realm.TournamentFeature import java.util.* import net.pokeranalytics.android.model.realm.Game -import net.pokeranalytics.android.util.CurrencyUtils +import net.pokeranalytics.android.util.UserDefaults class Seed(var context:Context) : Realm.Transaction { @@ -31,7 +31,7 @@ class Seed(var context:Context) : Realm.Transaction { private fun createDefaultCurrencyAndBankroll(realm: Realm) { // Currency - val localeCurrency = CurrencyUtils.getLocaleCurrency() + val localeCurrency = UserDefaults.getLocaleCurrency() val defaultCurrency = Currency() defaultCurrency.code = localeCurrency.currencyCode realm.insertOrUpdate(defaultCurrency) diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/BankrollDataFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/BankrollDataFragment.kt index 586888cb..1f02d4ec 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/BankrollDataFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/BankrollDataFragment.kt @@ -17,9 +17,9 @@ import net.pokeranalytics.android.ui.view.RowViewType import net.pokeranalytics.android.ui.view.rowrepresentable.BankrollRow import net.pokeranalytics.android.ui.view.rowrepresentable.CustomizableRowRepresentable import net.pokeranalytics.android.ui.view.rowrepresentable.SimpleRow -import net.pokeranalytics.android.util.CurrencyUtils import net.pokeranalytics.android.util.NULL_TEXT import net.pokeranalytics.android.util.Preferences +import net.pokeranalytics.android.util.extensions.toRate import retrofit2.Call import retrofit2.Response import java.util.* @@ -96,9 +96,9 @@ class BankrollDataFragment : EditableDataFragment(), StaticRowRepresentableDataS } BankrollRow.RATE -> { this.bankroll.currency?.rate?.let { rate -> - CurrencyUtils.getCurrencyRateFormatter().format(rate) + rate.toRate() } ?: run { - CurrencyUtils.getCurrencyRateFormatter().format(1.0) + 1.0.toRate() } } else -> super.stringForRow(row) @@ -119,7 +119,7 @@ class BankrollDataFragment : EditableDataFragment(), StaticRowRepresentableDataS BankrollRow.RATE -> { this.bankroll.currency?.rate?.let { rate -> - row.editingDescriptors(mapOf("defaultValue" to CurrencyUtils.getCurrencyRateFormatter().format(rate))) + row.editingDescriptors(mapOf("defaultValue" to rate.toRate())) } ?: run { row.editingDescriptors(mapOf()) } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/SessionFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/SessionFragment.kt index a0f6893a..2bf70668 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/SessionFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/SessionFragment.kt @@ -28,7 +28,6 @@ import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowRepresentableDiffCallback import net.pokeranalytics.android.ui.view.SmoothScrollLinearLayoutManager import net.pokeranalytics.android.ui.view.rowrepresentable.SessionRow -import net.pokeranalytics.android.util.CurrencyUtils import java.util.* @@ -105,9 +104,9 @@ class SessionFragment : PokerAnalyticsFragment(), RowRepresentableDelegate { } SessionRow.BANKROLL -> { - BottomSheetFragment.create(fragmentManager, row, this, data, false, CurrencyUtils.getCurrency(currentSession.bankroll)) + BottomSheetFragment.create(fragmentManager, row, this, data, false, currentSession.currency) } - else -> BottomSheetFragment.create(fragmentManager, row, this, data, currentCurrency = CurrencyUtils.getCurrency(currentSession.bankroll)) + else -> BottomSheetFragment.create(fragmentManager, row, this, data, currentCurrency = currentSession.currency) } } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/SettingsFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/SettingsFragment.kt index 8b6a3802..b276e9d9 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/SettingsFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/SettingsFragment.kt @@ -7,9 +7,11 @@ import android.view.LayoutInflater import android.view.View import android.view.ViewGroup import androidx.recyclerview.widget.LinearLayoutManager +import io.realm.Realm import kotlinx.android.synthetic.main.fragment_settings.* import net.pokeranalytics.android.BuildConfig import net.pokeranalytics.android.R +import net.pokeranalytics.android.model.realm.Bankroll import net.pokeranalytics.android.ui.activity.CurrenciesActivity import net.pokeranalytics.android.ui.activity.DataListActivity import net.pokeranalytics.android.ui.activity.GDPRActivity @@ -22,6 +24,7 @@ import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.rowrepresentable.SettingRow import net.pokeranalytics.android.util.Preferences import net.pokeranalytics.android.util.URL +import net.pokeranalytics.android.util.UserDefaults import net.pokeranalytics.android.util.extensions.openContactMail import net.pokeranalytics.android.util.extensions.openPlayStorePage import net.pokeranalytics.android.util.extensions.openUrl @@ -56,7 +59,7 @@ class SettingsFragment : PokerAnalyticsFragment(), RowRepresentableDelegate, Sta override fun stringForRow(row: RowRepresentable): String { return when (row) { SettingRow.VERSION -> BuildConfig.VERSION_NAME + if (BuildConfig.DEBUG) " (${BuildConfig.VERSION_CODE}) DEBUG" else "" - SettingRow.CURRENCY -> Currency.getInstance(Preferences.getCurrencyLocale(this.parentActivity)).symbol + SettingRow.CURRENCY -> UserDefaults.currency.symbol else -> "" } } @@ -77,6 +80,13 @@ class SettingsFragment : PokerAnalyticsFragment(), RowRepresentableDelegate, Sta if (requestCode == SettingsFragment.REQUEST_CODE_CURRENCY && resultCode == Activity.RESULT_OK) { data?.let { Preferences.setCurrencyCode(data.getStringExtra(CurrenciesFragment.INTENT_CURRENCY_CODE), requireContext()) + val realm = Realm.getDefaultInstance() + realm.executeTransaction { + it.where(Bankroll::class.java).isNull("currency.code").findAll().forEach { bankroll -> + bankroll.currencyCodeHasBeenUpdated() + } + } + realm.close() settingsAdapterRow.refreshRow(SettingRow.CURRENCY) } } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt index b43a0403..e44f7f64 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt @@ -15,7 +15,6 @@ import net.pokeranalytics.android.model.TournamentType import net.pokeranalytics.android.model.extensions.SessionState import net.pokeranalytics.android.model.extensions.getState import net.pokeranalytics.android.model.realm.Session -import net.pokeranalytics.android.util.CurrencyUtils import net.pokeranalytics.android.util.extensions.getDayNumber import net.pokeranalytics.android.util.extensions.getShortDayName import net.pokeranalytics.android.util.extensions.shortTime @@ -68,7 +67,7 @@ class SessionRowView : FrameLayout { if (session.isTournament()) { session.tournamentEntryFee?.let { - parameters.add(it.toCurrency(CurrencyUtils.getCurrency(session.bankroll))) + parameters.add(it.toCurrency(session.currency)) } session.tournamentName?.let { @@ -85,7 +84,7 @@ class SessionRowView : FrameLayout { } } else { if (session.cgSmallBlind != null && session.cgBigBlind != null) { - parameters.add(session.getCurrencyFormattedStake(this.context)) + parameters.add(session.getFormattedBlinds()) } session.game?.let { parameters.add(session.getFormattedGame()) @@ -149,7 +148,7 @@ class SessionRowView : FrameLayout { rowHistorySession.infoTitle.isVisible = false val result = session.result?.net ?: 0.0 - val formattedStat = ComputedStat(Stat.NETRESULT, result, currency = CurrencyUtils.getCurrency(session.bankroll)).format(context) + val formattedStat = ComputedStat(Stat.NETRESULT, result, currency = session.currency).format(context) rowHistorySession.gameResult.setTextColor(formattedStat.getColor(context)) rowHistorySession.gameResult.text = formattedStat.text } 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 da69af74..747a2db6 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 @@ -12,6 +12,7 @@ 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.Preferences +import net.pokeranalytics.android.util.UserDefaults import java.text.DateFormatSymbols import java.util.* @@ -102,7 +103,7 @@ sealed class FilterElementRow : RowRepresentable { data class Month(val month: Int) : SingleValueFilterElementRow(month) data class Day(val day: Int) : SingleValueFilterElementRow(day) - data class Blind(val blind : String, val currencySymbol:String? = null) : StringFilterElementRow(blind) + data class Blind(val blind: String, val hasDefaultCurrency: Boolean) : StringFilterElementRow(blind) //TODO: Refactor? data class PastDays(var lastDays: Int = 0) : SingleValueFilterElementRow(lastDays) { @@ -298,16 +299,13 @@ sealed class FilterElementRow : RowRepresentable { } is DataFilterElementRow -> this.name is StaticDataFilterElementRow -> this.name - else -> super.getDisplayName() + is Blind -> this.blind + else -> super.getDisplayName() } } override fun localizedTitle(context: Context): String { return when (this) { - is Blind -> { - val currencySymbol = currencySymbol ?: Preferences.getDefaultCurrency(context).symbol - "$currencySymbol $blind" - } is StaticDataFilterElementRow -> this.getDataLocalizedTitle(context) else -> super.localizedTitle(context) } 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 1f5e71e8..f64bc0ba 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 @@ -164,8 +164,8 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { val blinds = arrayListOf() val realm = Realm.getDefaultInstance() realm.where().distinct("blind", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map { - it.stake?.let { stake -> - blinds.add(Blind(stake, it.currencySymbol)) + it.blinds?.let { stake -> + blinds.add(Blind(stake, it.hasDefaultCurrency)) } } realm.close() diff --git a/app/src/main/java/net/pokeranalytics/android/util/CurrencyUtils.kt b/app/src/main/java/net/pokeranalytics/android/util/CurrencyUtils.kt deleted file mode 100644 index 2aa76778..00000000 --- a/app/src/main/java/net/pokeranalytics/android/util/CurrencyUtils.kt +++ /dev/null @@ -1,64 +0,0 @@ -package net.pokeranalytics.android.util - -import android.content.Context -import net.pokeranalytics.android.model.realm.Bankroll -import java.text.NumberFormat -import java.util.* - -class CurrencyUtils { - - companion object { - - /** - * return the currency associated with this bankroll - */ - fun getCurrency(bankroll: Bankroll? = null) : Currency { - val currencyCode = bankroll?.currency?.code ?: CurrencyUtils.getLocaleCurrency().currencyCode - return Currency.getInstance(currencyCode) - } - - /** - * Get a currency formatter - */ - fun getCurrencyFormatter(context: Context, currency: Currency? = null) : NumberFormat { - val currencyFormatter = NumberFormat.getCurrencyInstance(Preferences.getCurrencyLocale(context)) - currency?.let { - currencyFormatter.currency = it - } - currencyFormatter.minimumFractionDigits = 0 - currencyFormatter.maximumFractionDigits = 2 - return currencyFormatter - } - - /** - * Get a currency rate formatter - */ - fun getCurrencyRateFormatter() : NumberFormat { - val currencyFormatter = NumberFormat.getInstance() - currencyFormatter.minimumFractionDigits = 0 - currencyFormatter.maximumFractionDigits = 6 - return currencyFormatter - } - - /** - * Return the locale currency, or en_US if there - */ - fun getLocaleCurrency() : Currency { - return try { - Currency.getInstance(Locale.getDefault()) - } catch (ex: Exception) { - when (Locale.getDefault().language) { - "en" -> Currency.getInstance(Locale("en", "US")) - "fr" -> Currency.getInstance(Locale("fr", "FR")) - "es" -> Currency.getInstance(Locale("es", "ES")) - "de" -> Currency.getInstance(Locale("de", "DE")) - "ja" -> Currency.getInstance(Locale("ja", "JP")) - "zh" -> Currency.getInstance(Locale("zh", "CN")) - else -> Currency.getInstance(Locale("en", "US")) - } - } - } - - } - -} \ No newline at end of file diff --git a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt index d3dbfc4f..13a13beb 100644 --- a/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt +++ b/app/src/main/java/net/pokeranalytics/android/util/Preferences.kt @@ -16,8 +16,6 @@ class Preferences { companion object { - private var currencyLocale : Locale? = null - fun setString(key: Keys, value: String, context: Context) { val preferences = PreferenceManager.getDefaultSharedPreferences(context) val editor = preferences.edit() @@ -44,8 +42,7 @@ class Preferences { fun setCurrencyCode(currencyCode: String, context: Context) { setString(Keys.CURRENCY_CODE, currencyCode, context) - currencyLocale = null - UserDefaults.currency = getDefaultCurrency(context) + UserDefaults.setCurrencyValues(context) } private fun getCurrencyCode(context: Context) : String? { @@ -53,10 +50,6 @@ class Preferences { } fun getCurrencyLocale(context : Context) : Locale? { - currencyLocale?. let { - return it - } - getCurrencyCode(context)?.let { currencyCode -> Locale.getAvailableLocales().filter{ try { @@ -65,19 +58,17 @@ class Preferences { false } }.first().let { - currencyLocale = it return it } } return null } - fun getDefaultCurrency(context: Context) : Currency { - return getCurrencyLocale(context)?.let { - Currency.getInstance(it) - } ?: run { - CurrencyUtils.getLocaleCurrency() + fun getDefaultCurrency(context: Context) : Currency? { + getCurrencyLocale(context)?.let { + return Currency.getInstance(it) } + return null } fun setStopShowingDisclaimer(context: Context) { @@ -94,11 +85,36 @@ class Preferences { class UserDefaults private constructor(context: Context) { init { - currency = Preferences.getDefaultCurrency(context) + setCurrencyValues(context) } companion object : SingletonHolder(::UserDefaults) { lateinit var currency : Currency + lateinit var currencyLocale : Locale + + fun setCurrencyValues(context: Context) { + currency = Preferences.getDefaultCurrency(context) ?: getLocaleCurrency() + currencyLocale = Preferences.getCurrencyLocale(context) ?: Locale.getDefault() + } + + /** + * Return the locale currency, or en_US if there + */ + fun getLocaleCurrency() : Currency { + return try { + Currency.getInstance(Locale.getDefault()) + } catch (ex: Exception) { + when (Locale.getDefault().language) { + "en" -> Currency.getInstance(Locale("en", "US")) + "fr" -> Currency.getInstance(Locale("fr", "FR")) + "es" -> Currency.getInstance(Locale("es", "ES")) + "de" -> Currency.getInstance(Locale("de", "DE")) + "ja" -> Currency.getInstance(Locale("ja", "JP")) + "zh" -> Currency.getInstance(Locale("zh", "CN")) + else -> Currency.getInstance(Locale("en", "US")) + } + } + } } } diff --git a/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt b/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt index 88330925..5ee1d3cd 100644 --- a/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt +++ b/app/src/main/java/net/pokeranalytics/android/util/extensions/NumbersExtension.kt @@ -2,6 +2,7 @@ package net.pokeranalytics.android.util.extensions import android.content.Context import net.pokeranalytics.android.R +import net.pokeranalytics.android.util.UserDefaults import java.text.DecimalFormat import java.text.NumberFormat import java.util.* @@ -23,7 +24,7 @@ fun Double.formatted(): String { fun Double.toCurrency(currency: Currency? = null): String { - val currencyFormatter = NumberFormat.getCurrencyInstance() + val currencyFormatter = NumberFormat.getCurrencyInstance(UserDefaults.currencyLocale) currency?.let { currencyFormatter.currency = currency } @@ -33,6 +34,14 @@ fun Double.toCurrency(currency: Currency? = null): String { return currencyFormatter.format(this) } + +fun Double.toRate(): String { + val currencyFormatter = NumberFormat.getInstance() + currencyFormatter.minimumFractionDigits = 0 + currencyFormatter.maximumFractionDigits = 6 + return currencyFormatter.format(this) +} + fun Double.formattedHourlyDuration() : String { return (this * 1000 * 3600).toLong().toMinutes() } From 6959266774878f1a9c02c6c39f433788790aa943 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Fri, 12 Apr 2019 13:05:51 +0200 Subject: [PATCH 09/10] add a todo --- .../main/java/net/pokeranalytics/android/model/realm/Bankroll.kt | 1 + 1 file changed, 1 insertion(+) 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 55f0d897..9ceba9f5 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 @@ -97,6 +97,7 @@ open class Bankroll() : RealmObject(), NameManageable, StaticRowRepresentableDat this.live = if (value is Boolean) !value else false } BankrollRow.CURRENCY -> { + //TODO handle a use default currency option this.currency?.code = value as String? } BankrollRow.RATE -> { From 039088bbff7252ee5cb0e4adb8aa3f72efc833f2 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Fri, 12 Apr 2019 13:47:15 +0200 Subject: [PATCH 10/10] add migration schema for new blinds field in session --- .../android/model/migrations/PokerAnalyticsMigration.kt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt b/app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt index 29e15c3b..2d41451d 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt @@ -35,7 +35,9 @@ class PokerAnalyticsMigration : RealmMigration { // Migrate to version 2 if (currentVersion == 1) { Timber.d("*** Running migration ${currentVersion + 1}") - + schema.get("Session")?.let { + it.addField("blinds", String::class.java).setNullable("blinds", true) + } schema.rename("FilterElement", "FilterCondition") schema.get("Filter")?.let { it.renameField("filterElements", "filterConditions")