staxriver
/
poker-analytics
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update blind management, blind is now called stake throughout the project

Browse Source
feature/top10
Razmig Sarkissian 7 years ago
parent 68304b806b
commit 345e6d7304
10 changed files with 190 additions and 252 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 34
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt
  2. 287
      app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt
  3. 11
      app/src/main/java/net/pokeranalytics/android/model/realm/Bankroll.kt
  4. 11
      app/src/main/java/net/pokeranalytics/android/model/realm/Currency.kt
  5. 22
      app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt
  6. 8
      app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt
  7. 22
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  8. 2
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt
  9. 16
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt
  10. 29
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt

34
app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt
Unescape View File

@ -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<Session>(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)

287
app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt
Unescape View File

@ -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 <reified T : Filterable> filter(realmQuery: RealmQuery<T>): RealmQuery<T> {
when {
this == BLINDS -> {
val smallBlindFieldName = FilterHelper.fieldNameForQueryType<T>(SMALL_BLIND)
val bigBlindFieldName = FilterHelper.fieldNameForQueryType<T>(BIG_BLIND)
val currencyCodeFieldName = FilterHelper.fieldNameForQueryType<T>(CURRENCY_CODE)
smallBlindFieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
bigBlindFieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
currencyCodeFieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
val blinds: RealmList<FilterElementBlind> 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<T>(this)
fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
when (operator) {
Operator.LESS -> {
val value: Double by valueMap
return realmQuery.lessThanOrEqualTo(fieldName, value)
}
else -> {
val fieldName = FilterHelper.fieldNameForQueryType<T>(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<String> 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<String> by valueMap
ids.forEach {
realmQuery.equalTo(fieldName, it)
}
realmQuery
}
ANY_TOURNAMENT_FEATURES -> {
val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
val values: Array<Int?>? 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<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
STAKE -> {
val stakes: Array<String> by valueMap
realmQuery.`in`(fieldName, stakes)
}
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
val values: Array<Int?>? 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)

11
app/src/main/java/net/pokeranalytics/android/model/realm/Bankroll.kt
Unescape View File

@ -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<Session>? = 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
}

11
app/src/main/java/net/pokeranalytics/android/model/realm/Currency.kt
Unescape View File

@ -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<Bankroll>? = 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

22
app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt
Unescape View File

@ -37,13 +37,6 @@ open class FilterCondition() : RealmObject() {
})
}
}
is FilterElementBlind -> {
this.blindValues = RealmList<FilterElementBlind>().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<Double>? = null
private var dateValue: Date? = null
private var stringValues: RealmList<String>? = null
private var blindValues: RealmList<FilterElementBlind>? = null
val ids: Array<String>
get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val blinds: RealmList<FilterElementBlind>
get() {
blindValues?.let {
if (it.isNotEmpty()) {
return it
} else {
throw PokerAnalyticsException.FilterElementExpectedValueMissing
}
}
throw PokerAnalyticsException.FilterElementExpectedValueMissing
}
val stakes: Array<String>
get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val date: Date
get() = dateValue ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing

8
app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt
Unescape View File

@ -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()

22
app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
Unescape View File

@ -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<TournamentFeature> = RealmList()
fun bankrollHasBeenUpdated() {
this.stake = getBlinds()
}
/**
* Manages impacts on SessionSets
* Should be called when the start / end date are changed

2
app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt
Unescape View File

@ -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(

16
app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt
Unescape View File

@ -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()
}
}

29
app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt
Unescape View File

@ -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<FilterElementRow.Blind>()
STAKE -> {
val stakes = arrayListOf<FilterElementRow.Stake>()
val realm = Realm.getDefaultInstance()
val sessions = realm.where<Session>().findAll().sort("cgSmallBlind", Sort.ASCENDING)
val distinctBlinds: ArrayList<Session> = ArrayList()
val blindsHashMap: ArrayList<String> = 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<Session>().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)

Write Preview
Loading…
Cancel
Save