Sorting first draft

blinds
Laurent 3 years ago
parent 8f7e25ee6b
commit a34ec49f0d
  1. 8
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt
  2. 2
      app/src/main/java/net/pokeranalytics/android/calculus/optimalduration/CashGameOptimalDurationCalculator.kt
  3. 13
      app/src/main/java/net/pokeranalytics/android/model/Criteria.kt
  4. 2
      app/src/main/java/net/pokeranalytics/android/model/extensions/SessionExtensions.kt
  5. 8
      app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt
  6. 146
      app/src/main/java/net/pokeranalytics/android/model/interfaces/StakesHolder.kt
  7. 32
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  8. 2
      app/src/main/java/net/pokeranalytics/android/ui/view/rows/FilterCategoryRow.kt
  9. 4
      app/src/main/java/net/pokeranalytics/android/ui/view/rows/FilterSectionRow.kt
  10. 2
      app/src/main/java/net/pokeranalytics/android/ui/view/rows/ReportRow.kt

@ -46,7 +46,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
// blind.filterSectionRow = FilterSectionRow.Blind
val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Blind)
val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Stakes)
filter.updateValueBy(filterElement)
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -91,7 +91,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
listOfValues = arrayListOf(s2.blinds!!)
}
val filterElements = FilterCondition(arrayListOf(blind1, blind2), FilterSectionRow.Blind)
val filterElements = FilterCondition(arrayListOf(blind1, blind2), FilterSectionRow.Stakes)
filter.updateValueBy(filterElements)
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -133,7 +133,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
listOfValues = arrayListOf(s3.blinds!!)
}
val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Blind)
val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Stakes)
filter.updateValueBy(filterElement)
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -177,7 +177,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
listOfValues = arrayListOf(s2.cgStakes!!)
}
val filterElement = FilterCondition(arrayListOf(stake1, stake2), FilterSectionRow.Blind)
val filterElement = FilterCondition(arrayListOf(stake1, stake2), FilterSectionRow.Stakes)
filter.updateValueBy(filterElement)
val sessions = Filter.queryOn<Session>(realm, Query(filter))

@ -41,7 +41,7 @@ class CashGameOptimalDurationCalculator {
val query = Query().add(QueryCondition.IsCash) // cash game
query.add(if (isLive) { QueryCondition.IsLive } else { QueryCondition.IsOnline }) // live / online
query.add(QueryCondition.EndDateNotNull) // ended
query.add(QueryCondition.BigBlindNotNull) // has BB value
query.add(QueryCondition.BiggestBetNotNull) // has BB value
val sessions = query.queryWith(realm.where(Session::class.java)).findAll()
val sessionsByDuration = sessions.groupBy {

@ -7,10 +7,10 @@ import net.pokeranalytics.android.R
import net.pokeranalytics.android.exceptions.PAIllegalStateException
import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.Criteria.Bankrolls.comparison
import net.pokeranalytics.android.model.Criteria.Blinds.comparison
import net.pokeranalytics.android.model.Criteria.Games.comparison
import net.pokeranalytics.android.model.Criteria.Limits.comparison
import net.pokeranalytics.android.model.Criteria.Locations.comparison
import net.pokeranalytics.android.model.Criteria.Stakes.comparison
import net.pokeranalytics.android.model.Criteria.TableSizes.comparison
import net.pokeranalytics.android.model.Criteria.TournamentFeatures.comparison
import net.pokeranalytics.android.model.Criteria.TournamentFees.comparison
@ -123,7 +123,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
is TournamentFees -> if (session.tournamentEntryFee is S) {
session.tournamentEntryFee as S
} else throw PokerAnalyticsException.QueryValueMapUnexpectedValue
is Blinds -> if (session.cgStakes is S) {
is Stakes -> if (session.cgStakes is S) {
session.cgStakes as S
} else throw PokerAnalyticsException.QueryValueMapUnexpectedValue
else -> null
@ -158,7 +158,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
object DayPeriods : SimpleCriteria(listOf(QueryCondition.IsWeekDay, QueryCondition.IsWeekEnd), 14)
object Years : ListCriteria(15)
object AllMonthsUpToNow : ListCriteria(16)
object Blinds : ListCriteria(17)
object Stakes : ListCriteria(17)
object TournamentFees : ListCriteria(18)
object Cash : SimpleCriteria(listOf(QueryCondition.IsCash), 19)
object Tournament : SimpleCriteria(listOf(QueryCondition.IsTournament), 20)
@ -236,7 +236,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
realm.close()
years
}
is Blinds -> comparison<QueryCondition.AnyStake, String>()
is Stakes -> comparison<QueryCondition.AnyStake, String>()
is ListCustomFields -> comparison<CustomFieldEntry>()
is ValueCustomFields -> {
val realm = Realm.getDefaultInstance()
@ -270,7 +270,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
DayPeriods -> R.string.weekdays_or_weekend
Years -> R.string.year
AllMonthsUpToNow -> R.string.month
Blinds -> R.string.blind
Stakes -> R.string.blind
TournamentFees -> R.string.entry_fees
// is ListCustomFields -> this.customField.resId
// is ValueCustomFields -> this.customField.resId
@ -318,7 +318,8 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
TournamentFeatures, Limits, TableSizes, TournamentTypes,
MonthsOfYear, DaysOfWeek, SessionTypes,
BankrollTypes, DayPeriods, Years,
AllMonthsUpToNow, Blinds, TournamentFees
AllMonthsUpToNow,
Stakes, TournamentFees
)
}
}

@ -75,7 +75,7 @@ fun Session.getFormattedGameType(context: Context): String {
parameters.add(context.getString(R.string.tournament).capitalize())
}
} else {
if (this.cgAnte != null && this.cgBlinds != null) {
if (this.cgAnte != null || this.cgBlinds != null) {
parameters.add(getFormattedStakes())
}
game?.let {

@ -12,6 +12,7 @@ import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.Limit
import net.pokeranalytics.android.model.TableSize
import net.pokeranalytics.android.model.TournamentType
import net.pokeranalytics.android.model.interfaces.CodedStake
import net.pokeranalytics.android.model.interfaces.Identifiable
import net.pokeranalytics.android.model.interfaces.NameManageable
import net.pokeranalytics.android.model.interfaces.StakesHolder
@ -468,6 +469,11 @@ sealed class QueryCondition : RowRepresentable {
override fun entityName(context: Context): String {
return context.getString(R.string.stakes)
}
override fun compareTo(other: ListOfValues<String>): Int {
return CodedStake(this.listOfValues.first()).compareTo(CodedStake(other.listOfValues.first()))
}
}
class NumberOfTable : ListOfInt() {
@ -621,7 +627,7 @@ sealed class QueryCondition : RowRepresentable {
object DateNotNull : NotNullQueryCondition()
object EndDateNotNull : NotNullQueryCondition()
object BigBlindNotNull : NotNullQueryCondition()
object BiggestBetNotNull : NotNullQueryCondition()
class StartedFromTime(date: Date) : TimeQuery(date) {
override var operator = Operator.MORE

@ -6,67 +6,129 @@ import net.pokeranalytics.android.util.NULL_TEXT
import net.pokeranalytics.android.util.UserDefaults
import net.pokeranalytics.android.util.extensions.formatted
import net.pokeranalytics.android.util.extensions.toCurrency
import java.lang.Integer.min
import java.text.NumberFormat
import java.text.ParseException
import java.util.*
interface StakesHolder {
data class CodedStake(var stakes: String) : Comparable<CodedStake> {
companion object {
var ante: Double? = null
var blinds: String? = null
var currency: Currency
private const val cbSeparator = ";"
private const val cbAnte = "A="
private const val cbBlinds = "B="
private const val cbCode = "C="
init {
fun readableStakes(value: String): String {
var currencyCode: String? = null
var ante: Double? = null; var blinds: String? = null; var currencyCode: String? = null
val parameters = value.split(cbSeparator)
parameters.forEach { param ->
when {
param.contains(cbAnte) -> ante = param.removePrefix(cbAnte).let { NumberFormat.getInstance().parse(it)?.toDouble() }
param.contains(cbBlinds) -> blinds = param.removePrefix(cbBlinds)
param.contains(cbCode) -> currencyCode = param.removePrefix(cbCode)
}
val parameters = this.stakes.split(StakesHolder.cbSeparator)
parameters.forEach { param ->
when {
param.contains(StakesHolder.cbAnte) -> ante = param.removePrefix(StakesHolder.cbAnte).let { NumberFormat.getInstance().parse(it)?.toDouble() }
param.contains(StakesHolder.cbBlinds) -> blinds = param.removePrefix(StakesHolder.cbBlinds)
param.contains(StakesHolder.cbCode) -> currencyCode = param.removePrefix(
StakesHolder.cbCode
)
}
}
val currency = currencyCode?.let { Currency.getInstance(it) }
?: run { UserDefaults.currency }
this.currency = currencyCode?.let { Currency.getInstance(it) }
?: run { UserDefaults.currency }
val formattedBlinds = formattedBlinds(blinds, currency)
val formattedAnte = formattedAnte(ante, currency)
return formattedStakes(formattedBlinds, formattedAnte)
}
override fun compareTo(other: CodedStake): Int {
if (this.currency == other.currency) {
this.blinds?.let { b1 ->
other.blinds?.let { b2 ->
if (b1 == b2) {
return this.compareAnte(other)
} else {
val bv1 = this.reversedBlindsArray(b1)
val bv2 = this.reversedBlindsArray(b2)
for (i in 0 until min(bv1.size, bv2.size)) {
if (bv1[i] != bv2[i]) {
return bv1[i].compareTo(bv2[i])
} else {
continue
}
}
return bv1.size.compareTo(bv2.size)
}
} ?: run {
return 1
}
} ?: run {
return this.compareAnte(other)
}
} else {
return this.currency.currencyCode.compareTo(other.currency.currencyCode)
}
private fun formattedStakes(formattedBlinds: String?, formattedAnte: String?): String {
val components = arrayListOf<String>()
formattedBlinds?.let { components.add(it) }
formattedAnte?.let { components.add("($it)") }
}
return if (components.isNotEmpty()) {
components.joinToString(" ")
} else {
NULL_TEXT
private fun compareAnte(other: CodedStake): Int {
this.ante?.let { a1 ->
other.ante?.let { a2 ->
return a1.compareTo(a2)
} ?: run {
return 1
}
} ?: run {
return -1
}
}
private fun formattedBlinds(blinds: String?, currency: Currency): String? {
blinds?.let {
val placeholder = 1.0
val regex = Regex("-?\\d+(\\.\\d+)?")
return placeholder.toCurrency(currency).replace(regex, blinds)
}
return null
private fun reversedBlindsArray(blinds: String): List<Double> {
return blinds.split(BLIND_SEPARATOR).mapNotNull { NumberFormat.getInstance().parse(it)?.toDouble() }.reversed()
}
fun formattedStakes(): String {
val components = arrayListOf<String>()
this.formattedBlinds()?.let { components.add(it) }
this.formattedAnte()?.let { components.add("($it)") }
return if (components.isNotEmpty()) {
components.joinToString(" ")
} else {
NULL_TEXT
}
}
private fun formattedAnte(antes: Double?, currency: Currency): String? {
antes?.let {
return it.toCurrency(currency)
}
return null
private fun formattedBlinds(): String? {
this.blinds?.let {
val placeholder = 1.0
val regex = Regex("-?\\d+(\\.\\d+)?")
return placeholder.toCurrency(currency).replace(regex, it)
}
return null
}
private fun formattedAnte(): String? {
this.ante?.let {
return it.toCurrency(this.currency)
}
return null
}
}
interface StakesHolder {
companion object {
const val cbSeparator = ";"
const val cbAnte = "A="
const val cbBlinds = "B="
const val cbCode = "C="
fun readableStakes(value: String): String {
return CodedStake(value).formattedStakes()
}
}
@ -98,7 +160,7 @@ interface StakesHolder {
fun generateStakes() {
if (this.ante == null && this.ante == null) {
if (this.ante == null && this.blinds == null) {
setHolderStakes(null)
return
}

@ -122,7 +122,7 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
CustomFieldQuery::class.java -> "customFieldEntries.customFields.id"
DateNotNull::class.java -> "startDate"
EndDateNotNull::class.java -> "endDate"
BigBlindNotNull::class.java -> "cgBigBlind"
BiggestBetNotNull::class.java -> "cgBiggestBet"
else -> null
}
}
@ -339,8 +339,6 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
var cgStakes: String? = null
// Tournament
// The entry fee of the tournament
@ -667,9 +665,13 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
fun getFormattedStakes(): String {
this.cgStakes?.let { return StakesHolder.readableStakes(it) }
return this.cgStakes?.let { StakesHolder.readableStakes(it) } ?: run { NULL_TEXT }
return NULL_TEXT
//
// val formattedBlinds = StakesHolder.formattedBlinds(this.cgBlinds, this.currency)
// val formattedAntes = StakesHolder.formattedAnte(this.cgAnte, this.currency)
//
// return StakesHolder.formattedStakes(formattedBlinds, formattedAntes)
//
//
@ -1105,9 +1107,6 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
override val stakes: String?
get() { return this.cgStakes }
// override val bankroll: Bankroll?
// get() { return this.bankroll }
override fun setHolderStakes(stakes: String?) {
this.cgStakes = stakes
}
@ -1116,21 +1115,4 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
this.cgBiggestBet = biggestBet
}
//
// private val blindValues: List<Double>
// get() {
// this.cgBlinds?.let { blinds ->
// val blindsSplit = blinds.split(BLIND_SEPARATOR)
// return blindsSplit.mapNotNull {
// try {
// NumberFormat.getInstance().parse(it)?.toDouble()
// } catch (e: ParseException) {
// null
// }
// }
// }
// return listOf()
// }
}

@ -101,7 +101,7 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In
Bankroll
)
CASH -> arrayListOf(
Blind
Stakes
)
TOURNAMENT -> arrayListOf(
TournamentType,

@ -26,7 +26,7 @@ sealed class FilterSectionRow(override val resId: Int?) : RowRepresentable {
object SessionDuration: FilterSectionRow(R.string.session_duration)
object TimeFrameRange: FilterSectionRow(R.string.hour_slot)
object Sessions: FilterSectionRow(R.string.sessions)
object Blind: FilterSectionRow(R.string.blinds)
object Stakes: FilterSectionRow(R.string.stakes)
object CashRebuyCount: FilterSectionRow(R.string.rebuy_count)
object TournamentType: FilterSectionRow(R.string.tournament_types)
object TournamentName: FilterSectionRow(R.string.tournament_name)
@ -134,7 +134,7 @@ sealed class FilterSectionRow(override val resId: Int?) : RowRepresentable {
//Sessions -> arrayListOf(QueryCondition.LastGame(), QueryCondition.LastSession())
// Cash
Blind -> Criteria.Blinds.queryConditions.mapFirstCondition()
Stakes -> Criteria.Stakes.queryConditions.mapFirstCondition()
// CashRebuyCount -> QueryCondition.moreOrLess<QueryCondition.Rebuy>()
// Tournament

@ -49,7 +49,7 @@ enum class ReportRow : RowRepresentable {
val criteria: List<Criteria>
get() {
return when (this) {
BLINDS -> listOf(Criteria.Blinds)
BLINDS -> listOf(Criteria.Stakes)
BUY_IN -> listOf(Criteria.TournamentFees)
DAY_OF_WEEKS -> listOf(Criteria.DaysOfWeek)
GENERAL -> listOf(Criteria.SessionTypes, Criteria.BankrollTypes)

Loading…
Cancel
Save