fix issues with query condition names

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

@@ -6,13 +6,14 @@ import io.realm.kotlin.where
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.interfaces.Identifiable
+import net.pokeranalytics.android.model.interfaces.NameManageable
 import net.pokeranalytics.android.model.realm.*
 import java.util.*
 
 sealed class Criteria {
     abstract class RealmCriteria : Criteria() {
-        inline fun <reified T:Identifiable> comparison(): List<QueryCondition> {
+        inline fun <reified T: NameManageable> comparison(): List<QueryCondition> {
-            return compare < QueryCondition.QueryDataCondition<Identifiable>, T >()
+            return compare < QueryCondition.QueryDataCondition<NameManageable >, T >()
         }
     }
 
@@ -48,8 +49,8 @@ sealed class Criteria {
     object Limits: StaticCriteria()
     object TableSizes: StaticCriteria()
     object TournamentTypes: StaticCriteria()
-    object monthOfYear:  SimpleCriteria(List(12) { index -> QueryCondition.MONTH().apply { intValue = index } })
+    object monthOfYear:  SimpleCriteria(List(12) { index -> QueryCondition.MONTH().apply { intValues = arrayListOf(index)} })
-    object dayOfWeek: SimpleCriteria(List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { intValue = index } })
+    object dayOfWeek: SimpleCriteria(List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { intValues = arrayListOf(index + 1) } })
     object SessionType: SimpleCriteria(listOf(QueryCondition.CASH, QueryCondition.TOURNAMENT))
     object BankrollType: SimpleCriteria(listOf(QueryCondition.LIVE, QueryCondition.ONLINE))
     object dayPeriod: SimpleCriteria(listOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END))
@@ -78,7 +79,7 @@ sealed class Criteria {
                     realm.where<Session>().sort("year", Sort.ASCENDING).findFirst()?.year?.let {
                         for (index in 0..(yearNow - it)) {
                             years.add(QueryCondition.YEAR().apply {
-                                intValue = yearNow - index
+                                intValues = arrayListOf(yearNow - index)
                             })
                         }
                     }
@@ -104,7 +105,7 @@ sealed class Criteria {
         }
 
     companion object {
-        inline fun < reified  S : QueryCondition.QueryDataCondition<Identifiable>, reified T : Identifiable > compare(): List<S> {
+        inline fun < reified  S : QueryCondition.QueryDataCondition<NameManageable >, reified T : NameManageable  > compare(): List<S> {
             val objects = arrayListOf<S>()
             val realm = Realm.getDefaultInstance()
             realm.where<T>().findAll().forEach {

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

@@ -47,22 +47,9 @@ enum class Comparator {
                     realm.close()
                     fees
                 }
-                MONTH_OF_YEAR -> List(12) { index -> QueryCondition.MONTH().apply { intValue = index } }
+                MONTH_OF_YEAR -> Criteria.monthOfYear.queryConditions
-				DAY_OF_WEEK -> List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { intValue = index } }
+				DAY_OF_WEEK -> Criteria.dayOfWeek.queryConditions
-				YEAR -> {
+				YEAR -> Criteria.Year.queryConditions
-					val years = arrayListOf<QueryCondition.YEAR>()
-					val calendar = Calendar.getInstance()
-					calendar.time = Date()
-					val yearNow = calendar.get(Calendar.YEAR)
-					val realm = Realm.getDefaultInstance()
-					realm.where<Session>().sort("year", Sort.ASCENDING).findFirst()?.year?.let {
-						for (index in 0..(yearNow - it)) {
-							years.add(QueryCondition.YEAR().apply { intValue = yearNow - index })
-						}
-					}
-					realm.close()
-					years
-				}
                 DAY_PERIOD -> listOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END)
 				CASH -> listOf(QueryCondition.CASH)
 				TOURNAMENT -> listOf(QueryCondition.TOURNAMENT)

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

@@ -5,16 +5,20 @@ import io.realm.*
 import io.realm.kotlin.where
 import io.realm.RealmQuery
 import io.realm.internal.Table
+import net.pokeranalytics.android.R
+import net.pokeranalytics.android.calculus.Stat
 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.Identifiable
 import net.pokeranalytics.android.model.interfaces.Manageable
+import net.pokeranalytics.android.model.interfaces.NameManageable
 import net.pokeranalytics.android.model.realm.*
 import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
+import net.pokeranalytics.android.util.NULL_TEXT
 import net.pokeranalytics.android.util.extensions.endOfDay
 import net.pokeranalytics.android.util.extensions.startOfDay
 import java.text.DateFormatSymbols
@@ -22,7 +26,7 @@ import java.util.*
 import kotlin.collections.ArrayList
 
 fun List<QueryCondition>.name() : String {
-    return this.map { it.label() }.joinToString(" / ")
+    return this.map { it.getDisplayName() }.joinToString(" / ")
 }
 
 //inline fun <reified T : Filterable> List<QueryCondition>.query(realm: Realm): RealmQuery<T> {
@@ -44,11 +48,7 @@ inline fun <reified T : Filterable> List<QueryCondition>.queryWith(query: RealmQ
  * A new type should also set the expected numericValues required in the [filterValuesExpectedKeys]
  */
 
-interface Labelable {
+sealed class QueryCondition : FilterElementRow {
-    fun label() : String
-}
-
-sealed class QueryCondition : FilterElementRow, Labelable {
 
     interface Valuable <T : ArrayList<T>> {
         var values: ArrayList<T>?
@@ -112,10 +112,11 @@ sealed class QueryCondition : FilterElementRow, Labelable {
         }
     }
 
-    override fun label(): String {
+    override fun getDisplayName(): String {
         return when (this) {
-            is YEAR -> "$intValue"
+            is StaticDataQueryCondition -> label()
-            is MONTH -> DateFormatSymbols.getInstance(Locale.getDefault()).months[intValue]
+            is QueryDataCondition<*> -> label()
+            is BLIND -> this.blind!!
             else -> baseId
         }
     }
@@ -130,22 +131,33 @@ sealed class QueryCondition : FilterElementRow, Labelable {
         override var doubleValues = ArrayList<Double>()
     }
 
-    abstract class QueryDataCondition < T: Identifiable> : QueryCondition(), asListOfString {
+    abstract class QueryDataCondition < T: NameManageable > : QueryCondition(), asListOfString {
         fun setObject(dataObject: T) {
             this.dataObject = dataObject
             this.stringValues.add(dataObject.id)
         }
-        var dataObject: Identifiable? = null
+
+        var dataObject: NameManageable? = null
         override var stringValues = ArrayList<String>()
 
-        val name: String
+        abstract val entity : Class<T>
-            get() {
+
-                if (stringValues.size > 1) {
+        fun label(): String {
-                    return "multiple"
+            val realm = Realm.getDefaultInstance()
-                } else {
+            val completeLabel = when (stringValues.size) {
-                    return (dataObject as RowRepresentable).getDisplayName()
+                0 -> return NULL_TEXT
+                1,2 -> {
+                    return stringValues.map { labelForValue(realm, it) }.joinToString(", ")
+                }
+                else -> "${stringValues.size} $baseId"
             }
-                return "todo"
+            realm.close()
+            return completeLabel
+        }
+
+        fun labelForValue(realm:Realm, value:String): String {
+            val query = realm.where(entity)
+            return query.equalTo("id", value).findFirst()?.name ?: NULL_TEXT
         }
     }
 
@@ -189,50 +201,51 @@ sealed class QueryCondition : FilterElementRow, Labelable {
     abstract class StaticDataQueryCondition : QueryCondition(), asListOfInt {
         var data : RowRepresentable? = null
         override var doubleValues = ArrayList<Double>()
+        abstract fun labelForValue(value:Int): String?
+
+        fun label(): String {
+            return when (intValues.size) {
+                0 -> return NULL_TEXT
+                1,2 -> intValues.map { labelForValue(it) }.joinToString(", ")
+                else -> "${intValues.size} $baseId"
+            }
+        }
     }
 
     object LIVE : QueryCondition()
     object CASH : QueryCondition()
     object ONLINE : QueryCondition()
     object TOURNAMENT: QueryCondition()
-    class BANKROLL: QueryDataCondition<Bankroll>()
+    class BANKROLL: QueryDataCondition<Bankroll>() { override val entity: Class<Bankroll> = Bankroll::class.java }
-    class GAME: QueryDataCondition<Game>()
+    class GAME: QueryDataCondition<Game>() { override val entity: Class<Game> = Game::class.java }
-    class TOURNAMENT_NAME: QueryDataCondition<TournamentName>()
+    class TOURNAMENT_NAME: QueryDataCondition<TournamentName>() { override val entity: Class<TournamentName> = TournamentName::class.java }
-    class ANY_TOURNAMENT_FEATURES: QueryDataCondition<TournamentFeature>()
+    class ANY_TOURNAMENT_FEATURES: QueryDataCondition<TournamentFeature>() { override val entity: Class<TournamentFeature> = TournamentFeature::class.java }
-    class ALL_TOURNAMENT_FEATURES: QueryDataCondition<TournamentFeature>()
+    class ALL_TOURNAMENT_FEATURES: QueryDataCondition<TournamentFeature>() { override val entity: Class<TournamentFeature> = TournamentFeature::class.java }
-    class LOCATION: QueryDataCondition<Location>()
+    class LOCATION: QueryDataCondition<Location>() { override val entity: Class<Location> = Location::class.java }
 
     class LIMIT: StaticDataQueryCondition() {
-        val limit : Limit get() { return Limit.values()[intValues.first()] }
+        override fun labelForValue(value: Int): String? {
-        val name: String
+            return Limit.values()[value].longName
-            get() {
-                if (intValues.size > 1) {
-                    return "multiple"
-                } else if (intValues.size > 0) {
-                    return Limit.values()[intValues.first()].longName
-                }
-                return "todo"
         }
     }
 
     class TABLE_SIZE: StaticDataQueryCondition() {
-        val tableSize: TableSize get() { return TableSize.all[intValues.first()] }
+        val tableSize: TableSize get() { return TableSize(intValues.first()) }
+        //TODO dynamize this
+        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
+        }
     }
 
     class TOURNAMENT_TYPE: StaticDataQueryCondition() {
-         val name: String
+        override fun labelForValue(value: Int): String {
-            get() {
+            return TournamentType.values()[value].getDisplayName()
-                if (intValues.size > 1) {
-                    return "multiple"
-                } else {
-                    return TournamentType.values()[intValues.first()].getDisplayName()
-                }
-                return "todo"
         }
     }
 
@@ -291,9 +304,25 @@ sealed class QueryCondition : FilterElementRow, Labelable {
     class STARTED_TO_DATE: DateQuery(), Less
     class ENDED_FROM_DATE: DateQuery()
     class ENDED_TO_DATE: DateQuery(), Less
-    class DAY_OF_WEEK: SingleValueQueryCondition()
+
-    class MONTH: SingleValueQueryCondition()
+    class DAY_OF_WEEK: StaticDataQueryCondition() {
-    class YEAR: SingleValueQueryCondition()
+        override fun labelForValue(value: Int): String {
+            return DateFormatSymbols.getInstance(Locale.getDefault()).weekdays[value]
+        }
+    }
+
+    class MONTH: StaticDataQueryCondition() {
+        override fun labelForValue(value: Int): String {
+           return DateFormatSymbols.getInstance(Locale.getDefault()).months[value]
+        }
+    }
+
+    class YEAR: StaticDataQueryCondition() {
+        override fun labelForValue(value: Int): String {
+            return "$value"
+        }
+    }
+
     object WEEK_DAY: QueryCondition()
     object WEEK_END: QueryCondition()
     object TODAY: QueryCondition()

app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt

@@ -256,8 +256,8 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep
 						// Set date data
 						conditions.forEach { condition ->
                             when (condition) {
-                                is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.intValue)
+                                is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.intValues.first())
-                                is QueryCondition.MONTH -> calendar.set(Calendar.MONTH, condition.intValue)
+                                is QueryCondition.MONTH -> calendar.set(Calendar.MONTH, condition.intValues.first())
                             }
 						}
 
@@ -282,7 +282,7 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep
 						// Set date data
 						conditions.forEach { condition ->
                             when (condition) {
-                                is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.intValue)
+                                is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.intValues.first())
                             }
 						}
 						yearlyReports[calendar.time] = computedResults

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

@@ -33,7 +33,8 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In
 				GENERAL -> arrayListOf(
 					CASH_TOURNAMENT,
 					LIVE_ONLINE,
-					GAME, LIMIT_TYPE,
+					GAME,
+                    LIMIT_TYPE,
 					TABLE_SIZE
 				)
 				DATE -> arrayListOf(

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 -> null
+                else -> super.resId
             }
         }
 
@@ -98,23 +98,6 @@ interface FilterElementRow : RowRepresentable {
         }
     }
 
-    override fun getDisplayName(): String {
-        return when (this) {
-            is QueryCondition.SingleValueQueryCondition -> {
-                when (this) {
-                    is QueryCondition.DAY_OF_WEEK -> DateFormatSymbols.getInstance(Locale.getDefault()).weekdays[this.intValue]
-                    is QueryCondition.MONTH -> DateFormatSymbols.getInstance(Locale.getDefault()).months[this.intValue]
-                    else -> "${this.intValue}"
-                }
-            }
-            is QueryCondition.QueryDataCondition<*> -> this.name
-            is QueryCondition.LIMIT -> this.name
-            is QueryCondition.TOURNAMENT_TYPE -> this.name
-            is QueryCondition.BLIND -> this.blind!!
-            else -> super.getDisplayName()
-        }
-    }
-
     var filterSectionRow: FilterSectionRow
 
     val sectionToExclude: List<FilterSectionRow>?

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

@@ -85,38 +85,9 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 						FIXED_DATE -> arrayListOf(QueryCondition.STARTED_FROM_DATE(), QueryCondition.ENDED_TO_DATE())
 						DURATION -> arrayListOf(QueryCondition.PAST_DAYS())
                         WEEKDAYS_OR_WEEKEND -> arrayListOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END)
-                        /*
+                        YEAR -> Criteria.Year.queryConditions
-                        YEAR -> {
+                        DAY_OF_WEEK -> Criteria.dayOfWeek.queryConditions
-							val years = arrayListOf<FilterElementRow.Year>()
+                        MONTH_OF_YEAR -> Criteria.monthOfYear.queryConditions
-							val realm = Realm.getDefaultInstance()
-							val distinctYears =
-								realm.where<Session>().distinct("year").findAll().sort("year", Sort.DESCENDING)
-							distinctYears.forEach { session ->
-								session.year?.let { year ->
-									years.add(Year(year))
-								}
-							}
-							realm.close()
-							years
-						}
-						DAY_OF_WEEK -> {
-							val daysOfWeek = arrayListOf<FilterElementRow.Day>()
-							DateFormatSymbols.getInstance(Locale.getDefault()).weekdays.forEachIndexed { index, day ->
-								if (day.isNotEmpty()) {
-									daysOfWeek.add(Day(index))
-								}
-							}
-							daysOfWeek
-						}
-						MONTH_OF_YEAR -> {
-							val months = arrayListOf<FilterElementRow.Month>()
-							DateFormatSymbols.getInstance(Locale.getDefault()).months.forEachIndexed { index, month ->
-								if (month.isNotEmpty()) {
-									months.add(Month(index))
-								}
-							}
-							months
-						}*/
 
 						// Duration
 						SESSION_DURATION -> arrayListOf(QueryCondition.MORE_THAN_DURATION(), QueryCondition.LESS_THAN_DURATION() as QueryCondition)