fix issues with filters

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt

@@ -150,7 +150,6 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
 
         val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
         filter.updateValueBy(filterElement)
-        println("<<<< ${filter.listOfValues}")
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
         Assert.assertEquals(1, sessions.size)

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

@@ -64,15 +64,20 @@ class FilterHelper {
 				Transaction::class.java -> Transaction.fieldNameForQueryType(queryCondition)
 				Result::class.java -> Result.fieldNameForQueryType(queryCondition)
 				else -> {
-					throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}")
+                    null
+//					throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}")
 				}
 			}
 
+            return fieldName
+
+/*
 			fieldName?.let {
 				return fieldName
 			} ?: run {
 				throw PokerAnalyticsException.MissingFieldNameForQueryCondition(queryCondition.name)
 			}
+*/
 
 		}
 

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

@@ -7,6 +7,7 @@ import io.realm.RealmQuery
 import io.realm.RealmResults
 import io.realm.Sort
 import io.realm.kotlin.where
+import net.pokeranalytics.android.BuildConfig
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.Limit
@@ -52,7 +53,7 @@ sealed class QueryCondition : FilterElementRow {
                 Location::class.java -> AnyLocation()
                 TransactionType::class.java -> AnyTransactionType()
                 TournamentName::class.java -> AnyTournamentName()
-                TournamentFeature::class.java -> AnyTournamentFeature()
+                TournamentFeature::class.java -> AllTournamentFeature()
                 else -> throw PokerAnalyticsException.QueryTypeUnhandled
             }
         }
@@ -116,7 +117,7 @@ sealed class QueryCondition : FilterElementRow {
         abstract fun labelForValue(value:T, context: Context): String
 
         open fun entityName(context: Context): String {
-            return baseId
+            return getDisplayName(context)
         }
 
         override fun getDisplayName(context: Context): String {
@@ -374,11 +375,11 @@ sealed class QueryCondition : FilterElementRow {
 
     class NumberOfTable: ListOfInt() {
         override fun labelForValue(value: Int, context: Context): String {
-            return value.toString()
+            return value.toString()+" "+context.getString(R.string.tables)
         }
 
         override fun entityName(context: Context): String {
-            return context.getString(R.string.number_of_tables)
+            return ""
         }
     }
 
@@ -401,7 +402,11 @@ sealed class QueryCondition : FilterElementRow {
 
         override fun labelForValue(value: Int, context: Context): String {
             val nf = RuleBasedNumberFormat(Locale.getDefault(), RuleBasedNumberFormat.ORDINAL)
-            return nf.format(value)
+            return nf.format(value)+" "+context.getString(R.string.position)
+        }
+
+        override fun entityName(context: Context): String {
+            return ""
         }
     }
 
@@ -412,11 +417,11 @@ sealed class QueryCondition : FilterElementRow {
 
     class TournamentNumberOfPlayer: ListOfInt() {
         override fun labelForValue(value: Int, context: Context): String {
-            return value.toString()
+            return value.toString()+" "+context.getString(R.string.number_of_players)
         }
 
         override fun entityName(context: Context): String {
-            return context.getString(R.string.number_of_players)
+            return ""
         }
     }
 
@@ -427,13 +432,13 @@ sealed class QueryCondition : FilterElementRow {
 
     class AnyDayOfWeek: ListOfInt() {
         override fun labelForValue(value: Int, context: Context): String {
-            return DateFormatSymbols.getInstance(Locale.getDefault()).weekdays[value]
+            return DateFormatSymbols.getInstance(Locale.getDefault()).weekdays[value].capitalize()
         }
     }
 
     class AnyMonthOfYear(): ListOfInt() {
         override fun labelForValue(value: Int, context: Context): String {
-           return DateFormatSymbols.getInstance(Locale.getDefault()).months[value]
+           return DateFormatSymbols.getInstance(Locale.getDefault()).months[value].capitalize()
         }
 
         constructor(month:Int) : this() {
@@ -487,12 +492,19 @@ sealed class QueryCondition : FilterElementRow {
             get() { return singleValue }
             set(value) { singleValue = value }
 
+        val netDuration: Long?
+            get() {
+                minutes?.let {
+                    return (it*60*1000).toLong()
+                }
+                return null
+            }
+
         override val viewType: Int = RowViewType.TITLE_VALUE_CHECK.ordinal
         override val bottomSheetType: BottomSheetType = BottomSheetType.DOUBLE_EDIT_TEXT
 
         override fun labelForValue(value: Int, context: Context): String {
-            val nf = RuleBasedNumberFormat(Locale.getDefault(), RuleBasedNumberFormat.DURATION)
+            return value.toMinutes(context)
-            return nf.format(value.toDouble())
         }
     }
 
@@ -600,7 +612,10 @@ sealed class QueryCondition : FilterElementRow {
      */
     inline fun <reified T : Filterable> queryWith(realmQuery: RealmQuery<T>, otherQueryCondition:QueryCondition? = null): RealmQuery<T> {
         val fieldName = FilterHelper.fieldNameForQueryType<T>(this::class.java)
+        if (BuildConfig.DEBUG) {
             fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
+        }
+        fieldName ?: return realmQuery
 
         when (this) {
             //is Between -> realmQuery.between(fieldName, leftValue, rightValue)
@@ -666,22 +681,30 @@ sealed class QueryCondition : FilterElementRow {
             }
             is StartedFromTime -> {
                 val calendar = Calendar.getInstance()
-                calendar.time = singleValue
+                singleValue?.let {
+                    calendar.time = it
                     realmQuery.greaterThanOrEqualTo(fieldName, calendar.hourMinute())
                     if (otherQueryCondition is EndedToTime) {
-                    calendar.time = otherQueryCondition.singleValue
+                        otherQueryCondition.singleValue?.let {endTime ->
+                            calendar.time = endTime
                             realmQuery.lessThanOrEqualTo(fieldName, calendar.hourMinute())
                         }
+                    }
+                }
                 return realmQuery
             }
             is EndedToTime -> {
                 val calendar = Calendar.getInstance()
+                singleValue?.let {
                     calendar.time = singleValue
                     realmQuery.lessThanOrEqualTo(fieldName, calendar.hourMinute())
                     if (otherQueryCondition is StartedFromTime) {
-                    calendar.time = otherQueryCondition.singleValue
+                        otherQueryCondition.singleValue?.let { startTime ->
+                            calendar.time = startTime
                             realmQuery.greaterThanOrEqualTo(fieldName, calendar.hourMinute())
                         }
+                    }
+                }
                 return realmQuery
             }
         }
@@ -693,7 +716,12 @@ sealed class QueryCondition : FilterElementRow {
         }
 
         if (this is ListOfValues<*>) {
-            if (this.listOfValues.isEmpty()) return realmQuery
+            if (this.listOfValues.isEmpty()) {
+                if (BuildConfig.DEBUG) {
+                    throw PokerAnalyticsException.FilterElementExpectedValueMissing
+                }
+                return realmQuery
+            }
         }
 
         return when (operator) {
@@ -710,6 +738,7 @@ sealed class QueryCondition : FilterElementRow {
             Operator.MORE -> {
                 when (this) {
                     is SingleDate -> realmQuery.greaterThanOrEqualTo(fieldName, singleValue?.startOfDay()?:throw PokerAnalyticsException.FilterElementExpectedValueMissing)
+                    is Duration -> realmQuery.greaterThanOrEqualTo(fieldName, netDuration?:throw PokerAnalyticsException.FilterElementExpectedValueMissing)
                     is SingleInt -> realmQuery.greaterThanOrEqualTo(fieldName, singleValue?:throw PokerAnalyticsException.FilterElementExpectedValueMissing)
                     is ListOfInt -> realmQuery.greaterThanOrEqualTo(fieldName, listOfValues.first())
                     is NetAmountLost -> realmQuery.lessThanOrEqualTo(fieldName, listOfValues.first() * -1)
@@ -720,6 +749,7 @@ sealed class QueryCondition : FilterElementRow {
             Operator.LESS -> {
                 when (this) {
                     is SingleDate -> realmQuery.lessThanOrEqualTo(fieldName, singleValue?.endOfDay()?:throw PokerAnalyticsException.FilterElementExpectedValueMissing)
+                    is Duration -> realmQuery.lessThanOrEqualTo(fieldName, netDuration?:throw PokerAnalyticsException.FilterElementExpectedValueMissing)
                     is SingleInt -> realmQuery.lessThanOrEqualTo(fieldName, singleValue?:throw PokerAnalyticsException.FilterElementExpectedValueMissing)
                     is ListOfInt -> realmQuery.lessThanOrEqualTo(fieldName, listOfValues.first())
                     is NetAmountLost -> {
@@ -808,13 +838,22 @@ sealed class QueryCondition : FilterElementRow {
                 is DuringThisWeek -> R.string.current_week
                 is DuringThisMonth -> R.string.current_month
                 is DuringThisYear -> R.string.current_year
-                is StartedFromTime, is StartedFromDate -> R.string.from
+                is StartedFromDate -> R.string.from
-                is EndedToDate, is EndedToTime-> R.string.to
+                is StartedFromTime -> R.string.from_hour_
+                is EndedToDate -> R.string.to
+                is EndedToTime -> R.string.to_hour_
                 is IsLive -> R.string.live
                 is IsOnline -> R.string.online
                 is IsWeekDay -> R.string.week_days
                 is IsWeekEnd -> R.string.weekend
                 is PastDay -> R.string.period_in_days
+                is TournamentNumberOfPlayer -> {
+                    when (this.operator) {
+                        Operator.MORE -> R.string.minimum
+                        Operator.LESS -> R.string.maximum
+                        else -> null
+                    }
+                }
                 is NetAmountWon -> {
                     when (this.operator) {
                         Operator.MORE -> R.string.won_amount_more_than
@@ -829,6 +868,13 @@ sealed class QueryCondition : FilterElementRow {
                         else -> null
                     }
                 }
+                is TournamentFinalPosition -> {
+                    when (this.operator) {
+                        Operator.MORE -> R.string.minimum
+                        Operator.LESS -> R.string.maximum
+                        else -> null
+                    }
+                }
                 else -> {
                     when (this.operator) {
                         Operator.MORE -> R.string.more_than

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

@@ -49,7 +49,6 @@ open class FilterCondition() : RealmObject() {
     var operator: Int? = null
 
     inline fun <reified T:Any > getValues(): ArrayList < T > {
-        println("<<<< r $stringValues")
         return when (T::class) {
             Int::class -> ArrayList<T>().apply { intValues?.map { add(it as T) } }
             Double::class -> ArrayList<T>().apply { doubleValues?.map { add(it as T) } }

app/src/main/java/net/pokeranalytics/android/ui/interfaces/FilterHandler.kt

@@ -37,13 +37,10 @@ interface FilterHandler {
         Preferences.setActiveFilterId(filterId, context)
 
 
-        println("<<<< save filter")
         val realm = Realm.getDefaultInstance()
         realm.beginTransaction()
         currentFilter(context, realm)?.let {
-            println("<<<< old ${it.useCount}")
             it.useCount++
-            println("<<<< new ${it.useCount}")
         }
         realm.commitTransaction()
         realm.close()

app/src/main/java/net/pokeranalytics/android/util/extensions/RealmExtensions.kt

@@ -46,17 +46,14 @@ fun < T : RealmModel> Realm.sorted(clazz: Class<T>) : RealmResults<T> {
 
     when (items.firstOrNull()) {
         is Transaction -> {
-            println("<<<< is transaction")
             sortField = arrayOf("date")
             resultSort = arrayOf(Sort.DESCENDING)
         }
         is Filter -> {
-            println("<<<< is filter")
             sortField = arrayOf("useCount", "name")
             resultSort = arrayOf(Sort.DESCENDING, Sort.ASCENDING)
         }
         is CountableUsage -> {
-            println("<<<< is countable")
             this.updateUsageCount(clazz)
             sortField = arrayOf("useCount")
             resultSort = arrayOf(Sort.DESCENDING)