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

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

@@ -0,0 +1,90 @@
+package net.pokeranalytics.android.model
+
+import io.realm.Realm
+import io.realm.RealmResults
+import io.realm.Sort
+import io.realm.kotlin.where
+import net.pokeranalytics.android.exceptions.PokerAnalyticsException
+import net.pokeranalytics.android.model.filter.FilterHelper
+import net.pokeranalytics.android.model.filter.QueryCondition
+import net.pokeranalytics.android.model.interfaces.Identifiable
+import net.pokeranalytics.android.model.realm.*
+
+sealed class Criteria {
+    abstract class RealmCriteria : Criteria() {
+        inline fun <reified T:Identifiable> comparison(): List<QueryCondition> {
+            return compare < QueryCondition.QueryDataCondition<Identifiable>, T >()
+        }
+    }
+
+    abstract class SimpleCriteria(private val condition:QueryCondition): Criteria() {
+        fun comparison(): List<QueryCondition> {
+            return listOf(condition)
+        }
+    }
+
+    abstract class StaticCriteria : Criteria() {
+        inline fun <reified T:QueryCondition.SingleValueQueryCondition> comparison(): List<QueryCondition> {
+            QueryCondition.distinct<Session, T>()?.let {
+                val values = it.mapNotNull { session ->
+                    when (this) {
+                        is Limits -> session.limit
+                        else -> null
+                    }
+                }
+                return compare<T>(values)
+            }
+            return listOf<T>()
+        }
+    }
+
+    object Bankrolls: RealmCriteria()
+    object Games: RealmCriteria()
+    object TournamentNames: RealmCriteria()
+    object Locations: RealmCriteria()
+    object TournamentFeatures: RealmCriteria()
+    object Limits: StaticCriteria()
+    object TournamentTypes : StaticCriteria()
+
+    object Tournament : SimpleCriteria(QueryCondition.TOURNAMENT)
+
+    val queryConditions: List<QueryCondition>
+        get() {
+            return when (this) {
+                is Bankrolls -> comparison<Bankroll>()
+                is Games -> comparison<Game>()
+                is TournamentFeatures-> comparison<TournamentFeature>()
+                is TournamentNames-> comparison<TournamentName>()
+                is Locations -> comparison<Location>()
+                is SimpleCriteria -> comparison()
+                is Limits -> comparison<QueryCondition.LIMIT>()
+                is TournamentTypes -> comparison<QueryCondition.TOURNAMENT_TYPE>()
+                else -> throw PokerAnalyticsException.QueryTypeUnhandled
+            }
+        }
+
+    companion object {
+        inline fun < reified  S : QueryCondition.QueryDataCondition<Identifiable>, reified T : Identifiable > compare(): List<S> {
+            val objects = arrayListOf<S>()
+            val realm = Realm.getDefaultInstance()
+            realm.where<T>().findAll().forEach {
+                objects.add((QueryCondition.getInstance<T>() as S).apply {
+                    setObject(it)
+                })
+            }
+            realm.close()
+            return objects
+        }
+
+        inline fun < reified  S : QueryCondition.SingleValueQueryCondition > compare(values:List<Int>): List<S> {
+            val objects = arrayListOf<S>()
+            values.forEach {
+                objects.add((S::class.java.newInstance()).apply {
+                    setValue(it)
+                })
+            }
+            return objects
+        }
+    }
+
+}

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

@@ -4,6 +4,8 @@ import io.realm.Realm
 import io.realm.Sort
 import io.realm.kotlin.where
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
+import net.pokeranalytics.android.model.Criteria
+import net.pokeranalytics.android.model.filter.Filterable
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.realm.*
 import java.util.*
@@ -36,7 +38,7 @@ enum class Comparator {
                 TOURNAMENT_ENTRY_FEE -> {
                     val fees = arrayListOf<QueryCondition.BETWEEN_TOURNAMENT_FEE>()
                     val realm = Realm.getDefaultInstance()
-                    val fieldName = Session.fieldNameForQueryType(QueryCondition.BETWEEN_TOURNAMENT_FEE())
+                    val fieldName = Session.fieldNameForQueryType(QueryCondition.BETWEEN_TOURNAMENT_FEE::class.java)!!
                     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) })
@@ -77,51 +79,11 @@ enum class Comparator {
                     realm.close()
                     blinds
                 }
-                GAME -> {
+                BANKROLL -> Criteria.Bankrolls.queryConditions
-                    val objects = arrayListOf<QueryCondition.GAME>()
+                GAME -> Criteria.Games.queryConditions
-                    val realm = Realm.getDefaultInstance()
+                TOURNAMENT_NAME-> Criteria.TournamentNames.queryConditions
-                    realm.where<Game>().findAll().forEach {
+                TOURNAMENT_FEATURE-> Criteria.TournamentFeatures.queryConditions
-                        objects.add(QueryCondition.GAME().apply { setObjectId(it.id)})
+                LOCATION-> Criteria.Locations.queryConditions
-                    }
-                    realm.close()
-                    objects
-                }
-                BANKROLL -> {
-                    val objects = arrayListOf<QueryCondition.BANKROLL>()
-                    val realm = Realm.getDefaultInstance()
-                    realm.where<Bankroll>().findAll().forEach {
-                        objects.add(QueryCondition.BANKROLL().apply { setObjectId(it.id)})
-                    }
-                    realm.close()
-                    objects
-                }
-                LOCATION -> {
-                    val objects = arrayListOf<QueryCondition.LOCATION>()
-                    val realm = Realm.getDefaultInstance()
-                    realm.where<Location>().findAll().forEach {
-                        objects.add(QueryCondition.LOCATION().apply { setObjectId(it.id)})
-                    }
-                    realm.close()
-                    objects
-                }
-                TOURNAMENT_NAME -> {
-                    val objects = arrayListOf<QueryCondition.TOURNAMENT_NAME>()
-                    val realm = Realm.getDefaultInstance()
-                    realm.where<TournamentName>().findAll().forEach {
-                        objects.add(QueryCondition.TOURNAMENT_NAME().apply { setObjectId(it.id)})
-                    }
-                    realm.close()
-                    objects
-                }
-                TOURNAMENT_FEATURE -> {
-                    val objects = arrayListOf<QueryCondition.ANY_TOURNAMENT_FEATURES>()
-                    val realm = Realm.getDefaultInstance()
-                    realm.where<TournamentFeature>().findAll().forEach {
-                        objects.add(QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObjectId(it.id)})
-                    }
-                    realm.close()
-                    objects
-                }
                 LIMIT_TYPE -> {
                     val limits = arrayListOf<QueryCondition.LIMIT>()
                     val realm = Realm.getDefaultInstance()

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

@@ -56,7 +56,7 @@ class FilterHelper {
 
 	companion object {
 
-		inline fun <reified T : Filterable> fieldNameForQueryType(queryCondition: QueryCondition): String? {
+		inline fun <reified T : Filterable > fieldNameForQueryType(queryCondition: Class< out QueryCondition>): String? {
 
 			return when (T::class.java) {
 				Session::class.java -> Session.fieldNameForQueryType(queryCondition)

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

@@ -1,9 +1,12 @@
 package net.pokeranalytics.android.model.filter
 
+import io.realm.*
+import io.realm.internal.Table
+import io.realm.kotlin.where
 import io.realm.RealmQuery
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
-import net.pokeranalytics.android.model.realm.FilterCondition
+import net.pokeranalytics.android.model.interfaces.Identifiable
-import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.model.realm.*
 import net.pokeranalytics.android.util.extensions.endOfDay
 import net.pokeranalytics.android.util.extensions.startOfDay
 import java.util.*
@@ -33,10 +36,12 @@ inline fun <reified T : Filterable> List<QueryCondition>.queryWith(query: RealmQ
 
 sealed class QueryCondition(var operator: Operator? = null) {
 
-    abstract class QueryDataCondition : QueryCondition()
+    abstract class QueryDataCondition < T: Identifiable> : QueryCondition() {
-        fun setObjectId(id:String) {
+        fun setObject(dataObject:T) {
-            this.valueMap = mapOf("ids" to id)
+            this.valueMap = mapOf("ids" to arrayListOf(dataObject.id))
         }
+    }
+
 
     class MoreQueryCondition : QueryCondition(Operator.MORE)
     class LessQueryCondition : QueryCondition(Operator.LESS)
@@ -47,6 +52,25 @@ sealed class QueryCondition(var operator: Operator? = null) {
             val instance = kClass.objectInstance ?: kClass.java.newInstance()
             return instance as QueryCondition
         }
+
+        inline fun <reified T:Identifiable>getInstance(): QueryCondition {
+            return when (T::class.java) {
+                is Bankroll -> BANKROLL()
+                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
+        }
+
+
     }
 
     val name: String = this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName
@@ -60,29 +84,35 @@ sealed class QueryCondition(var operator: Operator? = null) {
         ;
     }
 
+    open class SingleValueQueryCondition : QueryCondition() {
+        fun setValue(value:Int) {
+            this.valueMap = mapOf("values" to arrayListOf(value))
+        }
+    }
+
     object LIVE : QueryCondition()
     object CASH : QueryCondition()
     object ONLINE : QueryCondition()
     object TOURNAMENT: QueryCondition()
-    class BANKROLL: QueryDataCondition()
+    class BANKROLL: QueryDataCondition<Bankroll>()
-    class GAME: QueryCondition()
+    class GAME: QueryDataCondition<Game>()
-    class TOURNAMENT_NAME: QueryCondition()
+    class TOURNAMENT_NAME: QueryDataCondition<TournamentName>()
-    class ANY_TOURNAMENT_FEATURES: QueryCondition()
+    class ANY_TOURNAMENT_FEATURES: QueryDataCondition<TournamentFeature>()
-    class ALL_TOURNAMENT_FEATURES: QueryCondition()
+    class ALL_TOURNAMENT_FEATURES: QueryDataCondition<TournamentFeature>()
-    class LOCATION: QueryCondition()
+    class LOCATION: QueryDataCondition<Location>()
-    class LIMIT: QueryCondition() {
+    class LIMIT: SingleValueQueryCondition() {
         fun setLimitType(limitType: Int) {
             this.valueMap = mapOf("values" to limitType)
         }
     }
 
-    class TABLE_SIZE: QueryCondition() {
+    class TABLE_SIZE: SingleValueQueryCondition() {
         fun setNumberOfPlayer(numberOfPlayer: Int) {
             this.valueMap = mapOf("values" to numberOfPlayer)
         }
     }
 
-    class TOURNAMENT_TYPE: QueryCondition() {
+    class TOURNAMENT_TYPE: SingleValueQueryCondition() {
         fun setTournamentType(tournamentType:Int) {
             this.valueMap = mapOf("values" to tournamentType)
         }
@@ -204,7 +234,7 @@ sealed 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> queryWith(realmQuery: RealmQuery<T>): RealmQuery<T> {
-        val fieldName = FilterHelper.fieldNameForQueryType<T>(this)
+        val fieldName = FilterHelper.fieldNameForQueryType<T>(this::class.java)
         fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
         when (operator) {
             Operator.LESS -> {

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

@@ -56,8 +56,11 @@ open class ComputableResult() : RealmObject(), Computable, Filterable {
 
 	companion object {
 
-		fun fieldNameForQueryType(queryCondition: QueryCondition): String? {
+		fun fieldNameForQueryType(queryCondition: Class < out QueryCondition >): String? {
-			return "session." + Session.fieldNameForQueryType(queryCondition)
+            Session.fieldNameForQueryType(queryCondition)?.let {
+                return "session.$it"
+            }
+            return null
 		}
 
 	}

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

@@ -63,33 +63,33 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
 			return realm.copyToRealm(session)
 		}
 
-		fun fieldNameForQueryType(queryCondition: QueryCondition): String? {
+		fun fieldNameForQueryType(queryCondition: Class < out QueryCondition >): String? {
-			return when (queryCondition) {
+            return when (queryCondition) {
-				LIVE, ONLINE -> "bankroll.live"
+				LIVE::class.java, ONLINE::class.java -> "bankroll.live"
-				CASH, TOURNAMENT -> "type"
+				CASH::class.java, TOURNAMENT::class.java -> "type"
-				is BANKROLL -> "bankroll.id"
+				BANKROLL::class.java -> "bankroll.id"
-				is GAME -> "game.id"
+                GAME::class.java -> "game.id"
-				is TOURNAMENT_NAME -> "tournamentName.id"
+                TOURNAMENT_NAME::class.java -> "tournamentName.id"
-				is ANY_TOURNAMENT_FEATURES, is ALL_TOURNAMENT_FEATURES -> "tournamentFeatures.id"
+                ANY_TOURNAMENT_FEATURES::class.java, ALL_TOURNAMENT_FEATURES::class.java -> "tournamentFeatures.id"
-				is LOCATION -> "location.id"
+                LOCATION::class.java -> "location.id"
-				is LIMIT -> "limit"
+                LIMIT::class.java -> "limit"
-				is TABLE_SIZE -> "tableSize"
+                TABLE_SIZE::class.java -> "tableSize"
-				is TOURNAMENT_TYPE -> "tournamentType"
+                TOURNAMENT_TYPE::class.java -> "tournamentType"
-				is BLIND -> "blinds"
+                BLIND::class.java -> "blinds"
-				is COMMENT -> "comment"
+                COMMENT::class.java -> "comment"
-				is BETWEEN_NUMBER_OF_TABLE, is MORE_NUMBER_OF_TABLE, is LESS_NUMBER_OF_TABLE -> "numberOfTable"
+                BETWEEN_NUMBER_OF_TABLE::class.java, MORE_NUMBER_OF_TABLE::class.java, LESS_NUMBER_OF_TABLE::class.java -> "numberOfTable"
-				is MORE_THAN_NET_RESULT, is LESS_THAN_NET_RESULT -> "computableResults.ratedNet"
+                MORE_THAN_NET_RESULT::class.java, LESS_THAN_NET_RESULT::class.java -> "computableResults.ratedNet"
-				is MORE_THAN_BUY_IN, is LESS_THAN_BUY_IN -> "result.buyin"
+                MORE_THAN_BUY_IN::class.java, LESS_THAN_BUY_IN::class.java -> "result.buyin"
-				is MORE_THAN_CASH_OUT, is LESS_THAN_CASH_OUT -> "result.cashout"
+                MORE_THAN_CASH_OUT::class.java, LESS_THAN_CASH_OUT::class.java -> "result.cashout"
-				is MORE_THAN_TIPS, is LESS_THAN_TIPS -> "result.tips"
+                MORE_THAN_TIPS::class.java, LESS_THAN_TIPS::class.java -> "result.tips"
-				is MORE_THAN_NUMBER_OF_PLAYER, is LESS_THAN_NUMBER_OF_PLAYER, is BETWEEN_NUMBER_OF_PLAYER -> "tournamentNumberOfPlayers"
+                MORE_THAN_NUMBER_OF_PLAYER::class.java, LESS_THAN_NUMBER_OF_PLAYER::class.java, BETWEEN_NUMBER_OF_PLAYER::class.java -> "tournamentNumberOfPlayers"
-				is MORE_THAN_TOURNAMENT_FEE, is LESS_THAN_TOURNAMENT_FEE, is BETWEEN_TOURNAMENT_FEE -> "tournamentEntryFee"
+                MORE_THAN_TOURNAMENT_FEE::class.java, LESS_THAN_TOURNAMENT_FEE::class.java, BETWEEN_TOURNAMENT_FEE::class.java -> "tournamentEntryFee"
-				is STARTED_FROM_DATE, is STARTED_TO_DATE -> "startDate"
+                STARTED_FROM_DATE::class.java, STARTED_TO_DATE::class.java -> "startDate"
-				is ENDED_FROM_DATE, is ENDED_TO_DATE -> "endDate"
+                ENDED_FROM_DATE::class.java, ENDED_TO_DATE::class.java -> "endDate"
-				is DAY_OF_WEEK, is WEEK_END, is WEEK_DAY -> "dayOfWeek"
+                DAY_OF_WEEK::class.java, WEEK_END::class.java, WEEK_DAY::class.java -> "dayOfWeek"
-				is MONTH -> "month"
+                MONTH::class.java -> "month"
-				is YEAR -> "year"
+                YEAR::class.java -> "year"
-				TODAY, YESTERDAY, TODAY_AND_YESTERDAY, THIS_YEAR, THIS_MONTH, THIS_WEEK -> "startDate"
+				TODAY::class.java, YESTERDAY::class.java, TODAY_AND_YESTERDAY::class.java, THIS_YEAR::class.java, THIS_MONTH::class.java, THIS_WEEK::class.java -> "startDate"
 				else -> null
 			}
 		}

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

@@ -102,8 +102,11 @@ open class SessionSet() : RealmObject(), Timed, Filterable {
 			return realm.copyToRealm(sessionSet)
 		}
 
-		fun fieldNameForQueryType(queryCondition: QueryCondition): String? {
+		fun fieldNameForQueryType(queryCondition: Class < out QueryCondition >): String? {
-			return "sessions." + Session.fieldNameForQueryType(queryCondition)
+            Session.fieldNameForQueryType(queryCondition)?.let {
+                return "sessions.$it"
+            }
+            return null
 		}
 
 	}