From b96291de033b0b9ffdba752f320991e703b52e4a Mon Sep 17 00:00:00 2001
From: Razmig Sarkissian <razmig@thomasbutton.com>
Date: Wed, 17 Apr 2019 10:34:06 +0200
Subject: [PATCH] add entry fee comparator

---
 .../android/model/comparison/Comparator.kt    | 15 ++++++++++-
 .../android/model/filter/QueryCondition.kt    | 27 +++++++++++++++++--
 2 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt b/app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt
index 961ede8f..de02cb45 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt
@@ -29,12 +29,25 @@ enum class Comparator {
     LIMIT_TYPE,
     TABLE_SIZE,
     TOURNAMENT_TYPE,
+    TOURNAMENT_ENTRY_FEE,
 	;
 
 	val queryConditions: List<QueryCondition>
 		get() {
 			return when (this) {
-				MONTH_OF_YEAR -> List(12) { index -> QueryCondition.MONTH().apply { setMonth(index) } }
+                TOURNAMENT_ENTRY_FEE -> {
+                    val fees = arrayListOf<QueryCondition.BETWEEN_TOURNAMENT_FEE>()
+                    val realm = Realm.getDefaultInstance()
+                    val fieldName = Session.fieldNameForQueryType(QueryCondition.BETWEEN_TOURNAMENT_FEE())
+                    realm.where<Session>().distinct(fieldName).findAll().sort(fieldName, Sort.ASCENDING).map {
+                        it.tournamentEntryFee?.let { fee ->
+                            fees.add(QueryCondition.BETWEEN_TOURNAMENT_FEE().apply { between(fee, fee) })
+                        }
+                    }
+                    realm.close()
+                    fees
+                }
+                MONTH_OF_YEAR -> List(12) { index -> QueryCondition.MONTH().apply { setMonth(index) } }
 				DAY_OF_WEEK -> List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { setDay(index) } }
 				YEAR -> {
 					val years = arrayListOf<QueryCondition.YEAR>()
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 9cc307e5..cf5dac46 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
@@ -29,6 +29,9 @@ sealed class QueryCondition(var operator: Operator? = null) {
             this.valueMap = mapOf("ids" to id)
         }
 
+    class MoreQueryCondition : QueryCondition(Operator.MORE)
+    class LessQueryCondition : QueryCondition(Operator.LESS)
+
     companion object {
         fun valueOf(name:String) : QueryCondition {
             val kClass = Class.forName("${QueryCondition::class.qualifiedName}$$name").kotlin
@@ -42,7 +45,10 @@ sealed class QueryCondition(var operator: Operator? = null) {
     enum class Operator {
         BETWEEN,
         MORE,
-        LESS;
+        LESS,
+        BETWEEN_RIGHT_EXCLUSIVE,
+        BETWEEN_LEFT_EXCLUSIVE,
+        ;
     }
 
     object LIVE : QueryCondition()
@@ -98,7 +104,14 @@ sealed class QueryCondition(var operator: Operator? = null) {
     class BETWEEN_NUMBER_OF_PLAYER: QueryCondition(Operator.BETWEEN)
     class MORE_THAN_TOURNAMENT_FEE: QueryCondition(Operator.MORE)
     class LESS_THAN_TOURNAMENT_FEE: QueryCondition(Operator.LESS)
-    class BETWEEN_TOURNAMENT_FEE: QueryCondition(Operator.BETWEEN)
+    class BETWEEN_TOURNAMENT_FEE: QueryCondition(Operator.BETWEEN_RIGHT_EXCLUSIVE) {
+        fun between(leftValue:Double, rightValue:Double) {
+            this.valueMap = mapOf(
+                "leftValue" to leftValue,
+                "rightValue" to rightValue
+                )
+        }
+    }
     class MIN_RE_BUY: QueryCondition(Operator.MORE)
     class MAX_RE_BUY: QueryCondition(Operator.LESS)
 
@@ -198,6 +211,16 @@ sealed class QueryCondition(var operator: Operator? = null) {
                 val rightValue: Double by valueMap
                 return realmQuery.between(fieldName, leftValue, rightValue)
             }
+            Operator.BETWEEN_LEFT_EXCLUSIVE -> {
+                val leftValue: Double by valueMap
+                val rightValue: Double by valueMap
+                return realmQuery.greaterThan(fieldName, leftValue).and().lessThanOrEqualTo(fieldName, rightValue)
+            }
+            Operator.BETWEEN_RIGHT_EXCLUSIVE-> {
+                val leftValue: Double by valueMap
+                val rightValue: Double by valueMap
+                return realmQuery.greaterThanOrEqualTo(fieldName, leftValue).and().lessThan(fieldName, rightValue)
+            }
         }
 
         return when (this) {