Merge branch 'dev' of gitlab.com:stax-river/poker-analytics into dev

app/src/main/java/net/pokeranalytics/android/model/Criteria.kt

@@ -89,7 +89,8 @@ sealed class Criteria {
                 is Blinds -> {
                     val blinds = arrayListOf<QueryCondition.BLIND>()
                     val realm = Realm.getDefaultInstance()
-                    realm.where<Session>().distinct("blinds", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map {
+                    val query = realm.where<Session>().distinct("blinds").findAll().sort("cgSmallBlind", Sort.ASCENDING)
+                    query.map {
                         it.blinds?.let { stake ->
                             blinds.add(QueryCondition.BLIND().apply {
                                 blind = stake

app/src/main/java/net/pokeranalytics/android/model/TableSize.kt

@@ -14,6 +14,14 @@ class TableSize(var numberOfPlayer: Int, var rowViewType: Int = RowViewType.TITL
 		 }
 	}
 
+    override fun getDisplayName(): String {
+        return if (this.numberOfPlayer == 2) {
+            return "HU"
+        } else {
+            "${this.numberOfPlayer}-max"
+        }
+    }
+
 	override val resId: Int?
 		get() {
 			return if (this.numberOfPlayer == 2) {

app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt

@@ -50,23 +50,12 @@ enum class Comparator {
                 MONTH_OF_YEAR -> Criteria.monthOfYear.queryConditions
 				DAY_OF_WEEK -> Criteria.dayOfWeek.queryConditions
 				YEAR -> Criteria.Year.queryConditions
-                DAY_PERIOD -> listOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END)
+                DAY_PERIOD -> Criteria.dayPeriod.queryConditions
 				CASH -> listOf(QueryCondition.CASH)
 				TOURNAMENT -> listOf(QueryCondition.TOURNAMENT)
                 LIVE -> listOf(QueryCondition.LIVE)
                 ONLINE -> listOf(QueryCondition.ONLINE)
-                BLIND -> {
+                BLIND -> Criteria.Blinds.queryConditions
-                    val blinds = arrayListOf<QueryCondition.BLIND>()
-                    val realm = Realm.getDefaultInstance()
-                    realm.where<Session>().distinct("blinds", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map {
-                        it.blinds?.let { stake ->
-                            blinds.add(QueryCondition.BLIND().apply { blind = stake
-                                                                        hasDefaultCurrency = it.hasDefaultCurrency })
-                        }
-                    }
-                    realm.close()
-                    blinds
-                }
                 BANKROLL -> Criteria.Bankrolls.queryConditions
                 GAME -> Criteria.Games.queryConditions
                 TOURNAMENT_NAME-> Criteria.TournamentNames.queryConditions

app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt

@@ -50,6 +50,37 @@ inline fun <reified T : Filterable> List<QueryCondition>.queryWith(query: RealmQ
 
 sealed class QueryCondition : FilterElementRow {
 
+    companion object {
+        fun valueOf(name:String) : QueryCondition {
+            val kClass = Class.forName("${QueryCondition::class.qualifiedName}$$name").kotlin
+            val instance = kClass.objectInstance ?: kClass.java.newInstance()
+            return instance as QueryCondition
+        }
+
+        inline fun <reified T:Identifiable>getInstance(): QueryCondition {
+            return when (T::class.java) {
+                Bankroll::class.java -> BANKROLL()
+                Game::class.java -> GAME()
+                Location::class.java -> LOCATION()
+                TournamentName::class.java -> TOURNAMENT_NAME()
+                TournamentFeature::class.java -> ANY_TOURNAMENT_FEATURES()
+                else -> throw PokerAnalyticsException.QueryTypeUnhandled
+            }
+        }
+
+        inline fun < reified T: Filterable, reified S: QueryCondition>distinct(): RealmResults<T>? {
+            FilterHelper.fieldNameForQueryType<T>(S::class.java)?.let {
+                val realm = Realm.getDefaultInstance()
+                val distincts = realm.where<T>().distinct(it).findAll().sort(it, Sort.ASCENDING)
+                realm.close()
+                return distincts
+            }
+            return null
+        }
+
+
+    }
+
     interface Valuable <T : ArrayList<T>> {
         var values: ArrayList<T>?
     }
@@ -123,14 +154,6 @@ sealed class QueryCondition : FilterElementRow {
 
     override var filterSectionRow: FilterSectionRow = FilterSectionRow.CASH_TOURNAMENT
 
-    open class OperationQueryCondition : QueryCondition(), asDoubleValue {
-        override var doubleValues = ArrayList<Double>()
-    }
-
-    open class BetweenQueryCondition : QueryCondition(), asListOfDouble {
-        override var doubleValues = ArrayList<Double>()
-    }
-
     abstract class QueryDataCondition < T: NameManageable > : QueryCondition(), asListOfString {
         fun setObject(dataObject: T) {
             this.dataObject = dataObject
@@ -161,39 +184,6 @@ sealed class QueryCondition : FilterElementRow {
         }
     }
 
-    companion object {
-        fun valueOf(name:String) : QueryCondition {
-            val kClass = Class.forName("${QueryCondition::class.qualifiedName}$$name").kotlin
-            val instance = kClass.objectInstance ?: kClass.java.newInstance()
-            return instance as QueryCondition
-        }
-
-        inline fun <reified T:Identifiable>getInstance(): QueryCondition {
-            return when (T::class.java) {
-                Bankroll::class.java -> BANKROLL()
-                Game::class.java -> GAME()
-                Location::class.java -> LOCATION()
-                TournamentName::class.java -> TOURNAMENT_NAME()
-                TournamentFeature::class.java -> ANY_TOURNAMENT_FEATURES()
-                else -> throw PokerAnalyticsException.QueryTypeUnhandled
-            }
-        }
-
-        inline fun < reified T: Filterable, reified S: QueryCondition>distinct(): RealmResults<T>? {
-            FilterHelper.fieldNameForQueryType<T>(S::class.java)?.let {
-                val realm = Realm.getDefaultInstance()
-                val distincts = realm.where<T>().distinct(it).findAll().sort(it, Sort.ASCENDING)
-                realm.close()
-                return distincts
-            }
-            return null
-        }
-
-
-    }
-
-    //open val name: String = this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName
-
     abstract class SingleValueQueryCondition : QueryCondition(), asIntValue {
         override var doubleValues = ArrayList<Double>()
     }
@@ -201,7 +191,7 @@ sealed class QueryCondition : FilterElementRow {
     abstract class StaticDataQueryCondition : QueryCondition(), asListOfInt {
         var data : RowRepresentable? = null
         override var doubleValues = ArrayList<Double>()
-        abstract fun labelForValue(value:Int): String?
+        abstract fun labelForValue(value:Int): String
 
         fun label(): String {
             return when (intValues.size) {
@@ -212,6 +202,23 @@ sealed class QueryCondition : FilterElementRow {
         }
     }
 
+    open class OperationQueryCondition : QueryCondition(), asDoubleValue {
+        override var doubleValues = ArrayList<Double>()
+    }
+
+    open class BetweenQueryCondition : QueryCondition(), asListOfDouble {
+        override var doubleValues = ArrayList<Double>()
+    }
+
+    open class DateQuery: QueryCondition(), asDateValue {
+        override var dateValue: Date = Date()
+        override val showTime: Boolean = false
+    }
+
+    open class TimeQuery: DateQuery() {
+        override val showTime: Boolean = true
+    }
+
     object LIVE : QueryCondition()
     object CASH : QueryCondition()
     object ONLINE : QueryCondition()
@@ -224,22 +231,14 @@ sealed class QueryCondition : FilterElementRow {
     class LOCATION: QueryDataCondition<Location>() { override val entity: Class<Location> = Location::class.java }
 
     class LIMIT: StaticDataQueryCondition() {
-        override fun labelForValue(value: Int): String? {
+        override fun labelForValue(value: Int): String {
-            return Limit.values()[value].longName
+            return Limit.values()[value].getDisplayName()
         }
     }
 
     class TABLE_SIZE: StaticDataQueryCondition() {
-        val tableSize: TableSize get() { return TableSize(intValues.first()) }
+        override fun labelForValue(value: Int): String {
-        //TODO dynamize this
+            return TableSize(value).getDisplayName()
-        override val resId: Int? = R.string.max
-
-        override fun localizedTitle(context: Context): String {
-            return this.tableSize.localizedTitle(context)
-        }
-
-        override fun labelForValue(value: Int): String? {
-            return null
         }
     }
 
@@ -287,18 +286,8 @@ sealed class QueryCondition : FilterElementRow {
             doubleValues.add(rightValue)
         }
     }
-    class MIN_RE_BUY: OperationQueryCondition(), More
+    class MIN_RE_BUY: OperationQueryCondition(), More, Amount
-    class MAX_RE_BUY: OperationQueryCondition(), Less
+    class MAX_RE_BUY: OperationQueryCondition(), Less, Amount
-
-    // Dates
-    open class DateQuery: QueryCondition(), asDateValue {
-        override var dateValue: Date = Date()
-        override val showTime: Boolean = false
-    }
-
-    open class TimeQuery: DateQuery() {
-        override val showTime: Boolean = true
-    }
 
     class STARTED_FROM_DATE: DateQuery()
     class STARTED_TO_DATE: DateQuery(), Less

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt

@@ -60,11 +60,8 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In
 				)
 				TOURNAMENT -> arrayListOf(
 					TOURNAMENT_TYPE,
-					COMPLETION_PERCENTAGE,
+                    TOURNAMENT_NAME,
-					PLACE,
+                    TOURNAMENT_FEATURE
-					PLAYERS_COUNT,
-					TOURNAMENT_RE_BUY_COUNT,
-					BUY_IN
 				)
 				ONLINE -> arrayListOf(
 					MULTI_TABLING

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt

@@ -49,7 +49,7 @@ interface FilterElementRow : RowRepresentable {
                 is QueryCondition.MAX_RE_BUY -> R.string.maximum
                 is QueryCondition.More -> R.string.more_than
                 is QueryCondition.Less -> R.string.less_than
-                else -> super.resId
+                else -> null
             }
         }
 

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt

@@ -104,21 +104,10 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 						SESSIONS -> arrayListOf(QueryCondition.LAST_GAMES(), QueryCondition.LAST_SESSIONS())
 
 						// Cash
-                        /*
+                        BLIND -> Criteria.Blinds.queryConditions
-						BLIND -> {
-							val blinds = arrayListOf<Blind>()
-							val realm = Realm.getDefaultInstance()
-							realm.where<Session>().distinct("blind", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map {
-                                it.blinds?.let { stake ->
-                                    blinds.add(Blind(stake, it.hasDefaultCurrency))
-                                }
-                            }
-							realm.close()
-                            blinds
-                        }*/
 						CASH_RE_BUY_COUNT -> arrayListOf(
 							QueryCondition.MAX_RE_BUY(),
-							QueryCondition.MIN_RE_BUY()
+							QueryCondition.MIN_RE_BUY() as QueryCondition
 						)
 
 						// Tournament