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

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

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,50 +123,8 @@ 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
-            }
-            else -> {
-
         val fieldName = FilterHelper.fieldNameForQueryType<T>(this)
         fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
-
         when (operator) {
             Operator.LESS -> {
                 val value: Double by valueMap
@@ -204,6 +156,10 @@ enum class QueryCondition(var operator: Operator? = null) {
                 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)
@@ -290,9 +246,6 @@ enum class QueryCondition(var operator: Operator? = null) {
             }
         }
     }
-        }
-
-    }
 
     fun updateValueMap(filterCondition: FilterCondition) {
         if (filterValuesExpectedKeys == null) {
@@ -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)

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<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
     }

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

app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt

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

app/src/main/java/net/pokeranalytics/android/model/realm/FilterElementBlind.kt

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

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,12 +217,25 @@ 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
@@ -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

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(

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

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