From a3e4438b54e34043b071e5950851fd00daa4836b Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Thu, 18 Apr 2019 17:18:57 +0200 Subject: [PATCH] refactoring of FilterElementRow to an Interface followed by QueryCondition --- .../filter/BlindFilterInstrumentedTest.kt | 45 +- .../filter/DateFilterInstrumentedUnitTest.kt | 15 +- .../filter/RealmFilterInstrumentedUnitTest.kt | 2 +- .../SessionFilterInstrumentedUnitTest.kt | 60 ++- .../pokeranalytics/android/model/Criteria.kt | 11 +- .../android/model/comparison/Comparator.kt | 51 +- .../android/model/filter/QueryCondition.kt | 434 ++++++++-------- .../android/model/realm/Filter.kt | 29 +- .../android/model/realm/FilterCondition.kt | 61 +-- .../android/ui/fragment/CalendarFragment.kt | 16 +- .../ui/fragment/FilterDetailsFragment.kt | 54 +- .../view/rowrepresentable/FilterElementRow.kt | 488 +++++------------- .../view/rowrepresentable/FilterSectionRow.kt | 82 +-- 13 files changed, 494 insertions(+), 854 deletions(-) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt index 969c2e3b..c8a52b87 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt @@ -41,15 +41,18 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLIND() - val blind = FilterElementRow.Blind(s1.blinds!!, true) + + val blind = QueryCondition.BLIND().apply { + blind = s1.blinds!! + hasDefaultCurrency = false + } + blind.filterSectionRow = FilterSectionRow.BLIND + val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) - - val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(2, sessions.size) @@ -87,8 +90,16 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.BLIND() - val blind1 = FilterElementRow.Blind(s1.blinds!!, true) - val blind2 = FilterElementRow.Blind(s2.blinds!!, true) + + val blind1 = QueryCondition.BLIND().apply { + blind = s1.blinds!! + hasDefaultCurrency = true + } + val blind2 = QueryCondition.BLIND().apply { + blind = s2.blinds!! + hasDefaultCurrency = true + } + blind1.filterSectionRow = FilterSectionRow.BLIND blind2.filterSectionRow = FilterSectionRow.BLIND @@ -133,7 +144,12 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.BLIND() - val blind = FilterElementRow.Blind(s3.blinds!!, false) + + val blind = QueryCondition.BLIND().apply { + blind = s3.blinds!! + hasDefaultCurrency = false + } + blind.filterSectionRow = FilterSectionRow.BLIND val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) @@ -175,12 +191,21 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() + val filter = QueryCondition.BLIND() - val blind1 = FilterElementRow.Blind(s1.blinds!!, false) - blind1.filterSectionRow = FilterSectionRow.BLIND - val blind2 = FilterElementRow.Blind(s2.blinds!!, false) + val blind1 = QueryCondition.BLIND().apply { + blind = s1.blinds!! + hasDefaultCurrency = false + } + val blind2 = QueryCondition.BLIND().apply { + blind = s2.blinds!! + hasDefaultCurrency = false + } + + blind1.filterSectionRow = FilterSectionRow.BLIND blind2.filterSectionRow = FilterSectionRow.BLIND + val filterElement = FilterCondition(filterElementRows = arrayListOf(blind1, blind2)) filter.updateValueMap(filterElement) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt index 2ccb7ea5..4c07b937 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt @@ -33,7 +33,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.DAY_OF_WEEK() cal.time = s1.startDate - val filterElementRow = FilterElementRow.Day(cal.get(Calendar.DAY_OF_WEEK)) + val filterElementRow = QueryCondition.DAY_OF_WEEK().apply { intValue = cal.get(Calendar.DAY_OF_WEEK) } filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) @@ -61,8 +61,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.MONTH() cal.time = s1.startDate - - val filterElementRow = FilterElementRow.Month(cal.get(Calendar.MONTH)) + val filterElementRow = QueryCondition.MONTH().apply { intValue = cal.get(Calendar.MONTH) } filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) @@ -90,7 +89,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.YEAR() cal.time = s1.startDate - val filterElementRow = FilterElementRow.Year(cal.get(Calendar.YEAR)) + val filterElementRow = QueryCondition.YEAR().apply { intValue = cal.get(Calendar.YEAR) } filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) @@ -384,7 +383,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.STARTED_FROM_DATE() - val filterElementRow = FilterElementRow.From.apply { dateValue = s2.startDate!!} + val filterElementRow = QueryCondition.STARTED_FROM_DATE().apply { dateValue = s2.startDate!!} filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -412,7 +411,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.STARTED_TO_DATE() - val filterElementRow = FilterElementRow.From.apply { dateValue = s1.startDate!! } + val filterElementRow = QueryCondition.STARTED_TO_DATE().apply { dateValue = s1.startDate!! } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -441,7 +440,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.ENDED_FROM_DATE() - val filterElementRow = FilterElementRow.From.apply { dateValue = s2.endDate() } + val filterElementRow = QueryCondition.ENDED_FROM_DATE().apply { dateValue = s2.endDate() } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -470,7 +469,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.ENDED_TO_DATE() - val filterElementRow = FilterElementRow.From.apply { dateValue = s1.endDate() } + val filterElementRow = QueryCondition.ENDED_TO_DATE().apply { dateValue = s1.endDate() } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt index b60c96bd..9e55a620 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt @@ -25,7 +25,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = Filter() filter.name = "testSaveLoadCashFilter" - val filterElement = FilterElementRow.Cash + val filterElement = QueryCondition.CASH filterElement.filterSectionRow = FilterSectionRow.CASH_TOURNAMENT filter.createOrUpdateFilterConditions(arrayListOf(filterElement)) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt index 5bc1d2c7..5ef8f870 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt @@ -110,7 +110,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.BANKROLL() - val filterElementRow = FilterElementRow.Bankroll(b1) + val filterElementRow = QueryCondition.BANKROLL().apply { setObject(b1) } filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -141,10 +141,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.BANKROLL() - val filterElementRow = FilterElementRow.Bankroll(b1) + val filterElementRow = QueryCondition.BANKROLL().apply { setObject(b1) } filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL - val filterElementRow2 = FilterElementRow.Bankroll(b2) + val filterElementRow2 = QueryCondition.BANKROLL().apply { setObject(b2) } filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -170,7 +170,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.GAME() - val filterElementRow = FilterElementRow.Game(g2) + val filterElementRow = QueryCondition.GAME().apply { setObject(g2) } filterElementRow.filterSectionRow = FilterSectionRow.GAME filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -202,9 +202,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.GAME() - val filterElementRow = FilterElementRow.Game(g2) + val filterElementRow = QueryCondition.GAME().apply { setObject(g2) } filterElementRow.filterSectionRow = FilterSectionRow.GAME - val filterElementRow2 = FilterElementRow.Game(g3) + val filterElementRow2 = QueryCondition.GAME().apply { setObject(g3) } filterElementRow2.filterSectionRow = FilterSectionRow.GAME filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -230,7 +230,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.LOCATION() - val filterElementRow = FilterElementRow.Location(l1) + val filterElementRow = QueryCondition.LOCATION().apply { setObject(l1) } filterElementRow.filterSectionRow = FilterSectionRow.LOCATION filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -262,9 +262,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.LOCATION() - val filterElementRow = FilterElementRow.Location(l1) + val filterElementRow = QueryCondition.LOCATION().apply { setObject(l1) } filterElementRow.filterSectionRow = FilterSectionRow.LOCATION - val filterElementRow2 = FilterElementRow.Location(l3) + val filterElementRow2 = QueryCondition.LOCATION().apply { setObject(l3) } filterElementRow2.filterSectionRow = FilterSectionRow.LOCATION filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -292,7 +292,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = QueryCondition.TOURNAMENT_NAME() - val filterElementRow = FilterElementRow.TournamentName(t1) + val filterElementRow = QueryCondition.TOURNAMENT_NAME().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -323,9 +323,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.TOURNAMENT_NAME() - val filterElementRow = FilterElementRow.TournamentName(t1) + val filterElementRow = QueryCondition.TOURNAMENT_NAME().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME - val filterElementRow2 = FilterElementRow.TournamentName(t2) + val filterElementRow2 = QueryCondition.TOURNAMENT_NAME().apply { setObject(t2) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -359,11 +359,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.ALL_TOURNAMENT_FEATURES() - val filterElementRow = FilterElementRow.AllTournamentFeature(t1) + val filterElementRow = QueryCondition.ALL_TOURNAMENT_FEATURES().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow2 = FilterElementRow.AllTournamentFeature(t2) + val filterElementRow2 = QueryCondition.ALL_TOURNAMENT_FEATURES().apply { setObject(t2) } filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow3 = FilterElementRow.AllTournamentFeature(t4) + val filterElementRow3 = QueryCondition.ALL_TOURNAMENT_FEATURES().apply { setObject(t4) } filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3))) @@ -394,13 +394,13 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.ANY_TOURNAMENT_FEATURES() - val filterElementRow = FilterElementRow.AnyTournamentFeature(t1) + val filterElementRow = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow2 = FilterElementRow.AnyTournamentFeature(t2) + val filterElementRow2 = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t2) } filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow3 = FilterElementRow.AnyTournamentFeature(t3) + val filterElementRow3 = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t3) } filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow4 = FilterElementRow.AnyTournamentFeature(t4) + val filterElementRow4 = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t4) } filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4))) @@ -428,7 +428,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.ANY_TOURNAMENT_FEATURES() - val filterElementRow = FilterElementRow.AnyTournamentFeature(t2) + val filterElementRow = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t2) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -453,9 +453,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.TABLE_SIZE() - val filterElementRow = FilterElementRow.TableSize(TableSize(2)) + val filterElementRow = QueryCondition.TABLE_SIZE().apply { intValues = arrayListOf(2) } filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE - val filterElementRow2 = FilterElementRow.TableSize(TableSize(4)) + val filterElementRow2 = QueryCondition.TABLE_SIZE().apply { intValues = arrayListOf(4) } + println("filterelement : ${filterElementRow2.doubleValues}") filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -480,11 +481,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() val filter = QueryCondition.MORE_THAN_NET_RESULT() - val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 204.0 } + val filterElementRow = QueryCondition.MORE_THAN_NET_RESULT().apply { this.amount = 204.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) - val sessions = Filter.queryOn(realm, arrayListOf(filter)) + val sessions = Filter.queryOn(realm, arrayListOf(filterElementRow)) Assert.assertEquals(2, sessions.size) @@ -503,9 +504,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val s3 = Session.testInstance(netResult = 50.0) Session.testInstance(netResult = 570.0) realm.commitTransaction() + println("s1.computableResult?.ratedNet ${s1.computableResult?.ratedNet}") + println("s2.computableResult?.ratedNet ${s2.computableResult?.ratedNet}") + println("s3.computableResult?.ratedNet ${s3.computableResult?.ratedNet}") val filter = QueryCondition.LESS_THAN_NET_RESULT() - val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 540.0 } + val filterElementRow = QueryCondition.LESS_THAN_NET_RESULT().apply { this.amount = 540.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -529,13 +533,15 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(netResult = 570.0) realm.commitTransaction() + print("s1.computableResult?.ratedNet ${s1.computableResult?.ratedNet}") + val filterMore = QueryCondition.MORE_THAN_NET_RESULT() - val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 200.0 } + val filterElementRow = QueryCondition.MORE_THAN_NET_RESULT().apply { this.amount = 200.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterMore.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) val filterLess = QueryCondition.LESS_THAN_NET_RESULT() - val filterElementRow2 = FilterElementRow.ResultMoreThan.apply { this.amount = 400.0 } + val filterElementRow2 = QueryCondition.LESS_THAN_NET_RESULT().apply { this.amount = 400.0 } filterElementRow2.filterSectionRow = FilterSectionRow.VALUE filterLess.updateValueMap(FilterCondition(arrayListOf(filterElementRow2))) diff --git a/app/src/main/java/net/pokeranalytics/android/model/Criteria.kt b/app/src/main/java/net/pokeranalytics/android/model/Criteria.kt index 15b751e3..ba6fad56 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/Criteria.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/Criteria.kt @@ -3,6 +3,7 @@ package net.pokeranalytics.android.model import io.realm.Realm import io.realm.RealmResults import io.realm.Sort +import io.realm.internal.Table import io.realm.kotlin.where import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.filter.FilterHelper @@ -24,11 +25,13 @@ sealed class Criteria { } abstract class StaticCriteria : Criteria() { - inline fun comparison(): List { + inline fun comparison(): List { QueryCondition.distinct()?.let { val values = it.mapNotNull { session -> when (this) { is Limits -> session.limit + is TournamentTypes -> session.tournamentType + is TableSizes -> session.tableSize else -> null } } @@ -44,6 +47,7 @@ sealed class Criteria { object Locations: RealmCriteria() object TournamentFeatures: RealmCriteria() object Limits: StaticCriteria() + object TableSizes: StaticCriteria() object TournamentTypes : StaticCriteria() object Tournament : SimpleCriteria(QueryCondition.TOURNAMENT) @@ -59,6 +63,7 @@ sealed class Criteria { is SimpleCriteria -> comparison() is Limits -> comparison() is TournamentTypes -> comparison() + is TableSizes -> comparison() else -> throw PokerAnalyticsException.QueryTypeUnhandled } } @@ -76,11 +81,11 @@ sealed class Criteria { return objects } - inline fun < reified S : QueryCondition.SingleValueQueryCondition > compare(values:List): List { + inline fun < reified S : QueryCondition.StaticDataQueryCondition > compare(values:List): List { val objects = arrayListOf() values.forEach { objects.add((S::class.java.newInstance()).apply { - setValue(it) + intValues.add(it) }) } return objects 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 7501a1fc..1d03b614 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 @@ -47,8 +47,8 @@ enum class Comparator { 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) } } + MONTH_OF_YEAR -> List(12) { index -> QueryCondition.MONTH().apply { intValue = index } } + DAY_OF_WEEK -> List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { intValue = index } } YEAR -> { val years = arrayListOf() val calendar = Calendar.getInstance() @@ -57,7 +57,7 @@ enum class Comparator { val realm = Realm.getDefaultInstance() realm.where().sort("year", Sort.ASCENDING).findFirst()?.year?.let { for (index in 0..(yearNow - it)) { - years.add(QueryCondition.YEAR().apply { setYear(yearNow - index) }) + years.add(QueryCondition.YEAR().apply { intValue = yearNow - index }) } } realm.close() @@ -73,7 +73,8 @@ enum class Comparator { val realm = Realm.getDefaultInstance() realm.where().distinct("blinds", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map { it.blinds?.let { stake -> - blinds.add(QueryCondition.BLIND().apply { setBlind(stake, it.hasDefaultCurrency)}) + blinds.add(QueryCondition.BLIND().apply { blind = stake + hasDefaultCurrency = it.hasDefaultCurrency }) } } realm.close() @@ -84,45 +85,9 @@ enum class Comparator { TOURNAMENT_NAME-> Criteria.TournamentNames.queryConditions TOURNAMENT_FEATURE-> Criteria.TournamentFeatures.queryConditions LOCATION-> Criteria.Locations.queryConditions - LIMIT_TYPE -> { - val limits = arrayListOf() - val realm = Realm.getDefaultInstance() - val distinctLimitTypes = realm.where().distinct("limit").findAll().sort("limit", Sort.ASCENDING) - - distinctLimitTypes.forEach { session -> - session.limit?.let { limitType-> - limits.add(QueryCondition.LIMIT().apply { setLimitType(limitType) }) - } - } - realm.close() - limits - } - TABLE_SIZE -> { - val tableSizes = arrayListOf() - val realm = Realm.getDefaultInstance() - val distinctTableSizes = - realm.where().distinct("tableSize").findAll().sort("tableSize", Sort.ASCENDING) - distinctTableSizes.forEach { session -> - session.tableSize?.let { tableSize -> - tableSizes.add(QueryCondition.TABLE_SIZE().apply { setNumberOfPlayer(tableSize) }) - } - } - realm.close() - tableSizes - } - TOURNAMENT_TYPE -> { - val tableSizes = arrayListOf() - val realm = Realm.getDefaultInstance() - val distinctTournamentTypes = - realm.where().distinct("tournamentType").findAll().sort("tournamentType", Sort.ASCENDING) - distinctTournamentTypes.forEach { session -> - session.tournamentType?.let { tournamentType -> - tableSizes.add(QueryCondition.TOURNAMENT_TYPE().apply { setTournamentType(tournamentType) }) - } - } - realm.close() - tableSizes - } + LIMIT_TYPE -> Criteria.Limits.queryConditions + TABLE_SIZE -> Criteria.TableSizes.queryConditions + TOURNAMENT_TYPE -> Criteria.TournamentTypes.queryConditions else -> throw PokerAnalyticsException.QueryTypeUnhandled } } 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 503bf509..3c78df9a 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 @@ -1,18 +1,27 @@ package net.pokeranalytics.android.model.filter +import android.content.Context import io.realm.* -import io.realm.internal.Table import io.realm.kotlin.where import io.realm.RealmQuery +import io.realm.internal.Table 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.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.extensions.endOfDay import net.pokeranalytics.android.util.extensions.startOfDay import java.util.* +import kotlin.collections.ArrayList fun List.name() : String { - return this.map { it.name }.joinToString(" / ") + return this.map { it.id }.joinToString(" / ") } //inline fun List.query(realm: Realm): RealmQuery { @@ -34,17 +43,86 @@ inline fun List.queryWith(query: RealmQ * A new type should also set the expected numericValues required in the [filterValuesExpectedKeys] */ -sealed class QueryCondition(var operator: Operator? = null) { +sealed class QueryCondition : FilterElementRow { - abstract class QueryDataCondition < T: Identifiable> : QueryCondition() { - fun setObject(dataObject:T) { - this.valueMap = mapOf("ids" to arrayListOf(dataObject.id)) - } + interface asListOfDouble { var doubleValues : ArrayList } + interface asListOfBoolean { var booleanValues : ArrayList } + interface asListOfString { var stringValues : ArrayList } + interface asDateValue { + var dateValue: Date + var showTime: Boolean + } + + interface asListOfInt : asListOfDouble { + var intValues : ArrayList + get() { return ArrayList(doubleValues.map { it.toInt() }) } + set(value) { doubleValues = ArrayList(value.map { it.toDouble() })} + } + + interface asIntValue : asListOfInt { + var intValue: Int + get() { return intValues.first() } + set(value) { intValues = arrayListOf(value) } + } + + interface asDoubleValue : asListOfDouble { + var doubleValue : Double + get() { return doubleValues.first() } + set(value) { doubleValues = arrayListOf(value) } } + interface Duration: asDoubleValue { + var minutes: Int + get() { return doubleValue.toInt() } + set(value) { doubleValue = value.toDouble() } + } - class MoreQueryCondition : QueryCondition(Operator.MORE) - class LessQueryCondition : QueryCondition(Operator.LESS) + interface Amount: asDoubleValue { + var amount: Double + get() { return doubleValue } + set(value) { doubleValue = value } + } + + interface More + interface Less + interface Between : asListOfDouble { + val leftValue: Double get() { return doubleValues.first() } + val rightValue: Double get() { return doubleValues.last() } + } + + interface BetweenLeftExclusive : Between + interface BetweenRightExclusive : Between + + val id: String get() { return this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName } + + override var filterSectionRow: FilterSectionRow = FilterSectionRow.CASH_TOURNAMENT + + open class OperationQueryCondition : QueryCondition(), asDoubleValue { + override var doubleValues = ArrayList() + } + + open class BetweenQueryCondition : QueryCondition(), asListOfDouble { + override var doubleValues = ArrayList() + } + + abstract class QueryDataCondition < T: Identifiable> : QueryCondition(), asListOfString { + fun setObject(dataObject: T) { + this.dataObject = dataObject + this.stringValues.add(dataObject.id) + } + var dataObject: Identifiable? = null + override var stringValues = ArrayList() + + val name: String + get() { + if (stringValues.size > 1) { + return "multiple" + } else { + return (dataObject as RowRepresentable).getDisplayName() + } + return "todo" + } + } companion object { fun valueOf(name:String) : QueryCondition { @@ -55,7 +133,11 @@ sealed class QueryCondition(var operator: Operator? = null) { inline fun getInstance(): QueryCondition { return when (T::class.java) { - is Bankroll -> BANKROLL() + 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 } } @@ -73,21 +155,15 @@ sealed class QueryCondition(var operator: Operator? = null) { } - val name: String = this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName + //open val name: String = this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName - enum class Operator { - BETWEEN, - MORE, - LESS, - BETWEEN_RIGHT_EXCLUSIVE, - BETWEEN_LEFT_EXCLUSIVE, - ; + abstract class SingleValueQueryCondition : QueryCondition(), asIntValue { + override var doubleValues = ArrayList() } - open class SingleValueQueryCondition : QueryCondition() { - fun setValue(value:Int) { - this.valueMap = mapOf("values" to arrayListOf(value)) - } + abstract class StaticDataQueryCondition : QueryCondition(), asListOfInt { + var data : RowRepresentable? = null + override var doubleValues = ArrayList() } object LIVE : QueryCondition() @@ -100,82 +176,99 @@ sealed class QueryCondition(var operator: Operator? = null) { class ANY_TOURNAMENT_FEATURES: QueryDataCondition() class ALL_TOURNAMENT_FEATURES: QueryDataCondition() class LOCATION: QueryDataCondition() - class LIMIT: SingleValueQueryCondition() { - fun setLimitType(limitType: Int) { - this.valueMap = mapOf("values" to limitType) - } + + class LIMIT: StaticDataQueryCondition() { + val limit : Limit get() { return Limit.values()[intValues.first()] } + val name: String + get() { + if (intValues.size > 1) { + return "multiple" + } else { + return Limit.values()[intValues.first()].longName + } + return "todo" + } } - class TABLE_SIZE: SingleValueQueryCondition() { - fun setNumberOfPlayer(numberOfPlayer: Int) { - this.valueMap = mapOf("values" to numberOfPlayer) + class TABLE_SIZE: StaticDataQueryCondition() { + val tableSize: TableSize get() { return TableSize.all[intValues.first()] } + + override fun localizedTitle(context: Context): String { + return this.tableSize.localizedTitle(context) } + } - class TOURNAMENT_TYPE: SingleValueQueryCondition() { - fun setTournamentType(tournamentType:Int) { - this.valueMap = mapOf("values" to tournamentType) - } + class TOURNAMENT_TYPE: StaticDataQueryCondition() { + val name: String + get() { + if (intValues.size > 1) { + return "multiple" + } else { + return TournamentType.values()[intValues.first()].getDisplayName() + } + return "todo" + } } - class BLIND: QueryCondition() { - fun setBlind(blind:String, hasDefaultCurrency:Boolean) { - this.valueMap = mapOf( - "blinds" to blind, - "hasDefaultCurrency" to hasDefaultCurrency) - } + class BLIND: QueryCondition(), asListOfString, asListOfBoolean { + var blind: String? = null + var hasDefaultCurrency: Boolean = false + override var booleanValues = ArrayList() + override var stringValues = ArrayList() } - class LAST_GAMES: QueryCondition() - class LAST_SESSIONS: QueryCondition() - class MORE_NUMBER_OF_TABLE: QueryCondition(Operator.MORE) - class LESS_NUMBER_OF_TABLE: QueryCondition(Operator.LESS) - class BETWEEN_NUMBER_OF_TABLE: QueryCondition(Operator.BETWEEN) - class MORE_THAN_NET_RESULT: QueryCondition(Operator.MORE) - class LESS_THAN_NET_RESULT: QueryCondition(Operator.LESS) - class MORE_THAN_BUY_IN: QueryCondition(Operator.MORE) - class LESS_THAN_BUY_IN: QueryCondition(Operator.LESS) - class MORE_THAN_CASH_OUT: QueryCondition(Operator.MORE) - class LESS_THAN_CASH_OUT: QueryCondition(Operator.LESS) - class MORE_THAN_TIPS: QueryCondition(Operator.MORE) - class LESS_THAN_TIPS: QueryCondition(Operator.LESS) - class MORE_THAN_NUMBER_OF_PLAYER: QueryCondition(Operator.MORE) - class LESS_THAN_NUMBER_OF_PLAYER: QueryCondition(Operator.LESS) - 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_RIGHT_EXCLUSIVE) { + + class LAST_GAMES: SingleValueQueryCondition() + class LAST_SESSIONS: SingleValueQueryCondition() + + class MORE_NUMBER_OF_TABLE: OperationQueryCondition(), More + class LESS_NUMBER_OF_TABLE: OperationQueryCondition(), Less + class BETWEEN_NUMBER_OF_TABLE: BetweenQueryCondition(), Between + + class MORE_THAN_NET_RESULT: OperationQueryCondition(), More, Amount + class LESS_THAN_NET_RESULT: OperationQueryCondition(), Less, Amount + + class MORE_THAN_BUY_IN: OperationQueryCondition(), More, Amount + class LESS_THAN_BUY_IN: OperationQueryCondition(), Less, Amount + + class MORE_THAN_CASH_OUT: OperationQueryCondition(), More, Amount + class LESS_THAN_CASH_OUT: OperationQueryCondition(), Less, Amount + + class MORE_THAN_TIPS: OperationQueryCondition(), More, Amount + class LESS_THAN_TIPS: OperationQueryCondition(), Less, Amount + + class MORE_THAN_NUMBER_OF_PLAYER: OperationQueryCondition(), More + class LESS_THAN_NUMBER_OF_PLAYER: OperationQueryCondition(), Less + class BETWEEN_NUMBER_OF_PLAYER: BetweenQueryCondition(), Between + + class MORE_THAN_TOURNAMENT_FEE: OperationQueryCondition(), More + class LESS_THAN_TOURNAMENT_FEE: OperationQueryCondition(), Less + class BETWEEN_TOURNAMENT_FEE: BetweenQueryCondition(), BetweenRightExclusive { fun between(leftValue:Double, rightValue:Double) { - this.valueMap = mapOf( - "leftValue" to leftValue, - "rightValue" to rightValue - ) + doubleValues.add(leftValue) + doubleValues.add(rightValue) } } - class MIN_RE_BUY: QueryCondition(Operator.MORE) - class MAX_RE_BUY: QueryCondition(Operator.LESS) + class MIN_RE_BUY: OperationQueryCondition(), More + class MAX_RE_BUY: OperationQueryCondition(), Less // Dates - class STARTED_FROM_DATE: QueryCondition() - class STARTED_TO_DATE: QueryCondition() - class ENDED_FROM_DATE: QueryCondition() - class ENDED_TO_DATE: QueryCondition() - - class DAY_OF_WEEK: QueryCondition() { - fun setDay(dayOfWeek:Int) { - this.valueMap = mapOf("dayOfWeek" to dayOfWeek) - } + open class DateQuery: QueryCondition(), asDateValue { + override var dateValue: Date = Date() + override var showTime: Boolean = false } - class MONTH: QueryCondition() { - fun setMonth(month:Int) { - this.valueMap = mapOf("month" to month) - } - } - class YEAR: QueryCondition() { - fun setYear(year:Int) { - this.valueMap = mapOf("year" to year) - } + open class TimeQuery: DateQuery() { + override var showTime: Boolean = true } + + class STARTED_FROM_DATE: DateQuery() + 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 YEAR: SingleValueQueryCondition() object WEEK_DAY: QueryCondition() object WEEK_END: QueryCondition() object TODAY: QueryCondition() @@ -184,51 +277,14 @@ sealed class QueryCondition(var operator: Operator? = null) { object THIS_WEEK: QueryCondition() object THIS_MONTH: QueryCondition() object THIS_YEAR: QueryCondition() - class PAST_DAYS: QueryCondition() - class MORE_THAN_DURATION: QueryCondition(Operator.MORE) - class LESS_THAN_DURATION: QueryCondition(Operator.LESS) - class STARTED_FROM_TIME: QueryCondition() - class ENDED_TO_TIME: QueryCondition() + class PAST_DAYS: SingleValueQueryCondition() + class MORE_THAN_DURATION: OperationQueryCondition(), More, Duration + class LESS_THAN_DURATION: OperationQueryCondition(), Less, Duration + class STARTED_FROM_TIME: TimeQuery() + class ENDED_TO_TIME: TimeQuery(), Less class COMMENT: QueryCondition() - - var valueMap : Map? = null - get() { - this.filterValuesExpectedKeys?.let { valueMapExceptedKeys -> - field?.let { map -> - val missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) } - if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) { - throw PokerAnalyticsException.QueryValueMapMissingKeys(missingKeys) - } - } ?: run { - throw PokerAnalyticsException.QueryValueMapUnexpectedValue - } - } - return field - } - protected set - - private val filterValuesExpectedKeys : Array? - get() { - this.operator?.let { - return when (it) { - Operator.BETWEEN -> arrayOf("leftValue", "rightValue") - else -> arrayOf("value") - } - } - return when (this) { - is BANKROLL, is GAME, is LOCATION, is ANY_TOURNAMENT_FEATURES, is ALL_TOURNAMENT_FEATURES, is TOURNAMENT_NAME -> arrayOf("ids") - is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> arrayOf("values") - is BLIND -> arrayOf("blinds", "hasDefaultCurrency") - is STARTED_FROM_DATE, is STARTED_TO_DATE, is ENDED_FROM_DATE, is ENDED_TO_DATE -> arrayOf("date") - is DAY_OF_WEEK -> arrayOf("dayOfWeek") - is MONTH -> arrayOf("month") - is YEAR -> arrayOf("year") - else -> null - } - } - /** * main method of the enum * providing a base RealmQuery [realmQuery], the method is able to attached the corresponding query and returns the newly formed [RealmQuery] @@ -236,50 +292,29 @@ sealed class QueryCondition(var operator: Operator? = null) { inline fun queryWith(realmQuery: RealmQuery): RealmQuery { val fieldName = FilterHelper.fieldNameForQueryType(this::class.java) fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown - when (operator) { - Operator.LESS -> { - val value: Double by valueMap - return realmQuery.lessThanOrEqualTo(fieldName, value) - } - Operator.MORE -> { - val value: Double by valueMap - return realmQuery.greaterThanOrEqualTo(fieldName, value) - } - Operator.BETWEEN -> { - val leftValue: Double by valueMap - 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) { + is Amount -> { + if (this is Less) { + realmQuery.lessThanOrEqualTo(fieldName, amount) + } else { + realmQuery.greaterThanOrEqualTo(fieldName, amount) + } + } + is Between -> realmQuery.between(fieldName, leftValue, rightValue) + is BetweenLeftExclusive -> realmQuery.greaterThan(fieldName, leftValue).and().lessThanOrEqualTo(fieldName, rightValue) + is BetweenRightExclusive -> realmQuery.greaterThanOrEqualTo(fieldName, leftValue).and().lessThan(fieldName, rightValue) LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE) CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal) is ALL_TOURNAMENT_FEATURES -> { - val ids: Array by valueMap - ids.forEach { + stringValues.forEach { realmQuery.equalTo(fieldName, it) } realmQuery } - is ANY_TOURNAMENT_FEATURES -> { - val ids: Array by valueMap - realmQuery.`in`(fieldName, ids) - } is BLIND -> { - val blinds: Array by valueMap - val hasDefaultCurrency: Array by valueMap + val blinds: Array = stringValues.toTypedArray() + val hasDefaultCurrency: Array = booleanValues.toTypedArray() //realmQuery.`in`(fieldName, blinds) blinds.forEachIndexed { index, s -> val isUsingDefaultCurrency = hasDefaultCurrency[index] @@ -298,42 +333,18 @@ sealed class QueryCondition(var operator: Operator? = null) { } realmQuery } - is BANKROLL, is GAME, is LOCATION, is TOURNAMENT_NAME -> { - val ids: Array by valueMap - realmQuery.`in`(fieldName, ids) - } - is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> { - val values: Array? by valueMap - realmQuery.`in`(fieldName, values) - } - is STARTED_FROM_DATE -> { - val date: Date by valueMap - realmQuery.greaterThanOrEqualTo(fieldName, date) - } - is STARTED_TO_DATE -> { - val date: Date by valueMap - realmQuery.lessThanOrEqualTo(fieldName, date) - } - is ENDED_FROM_DATE -> { - val date: Date by valueMap - realmQuery.greaterThanOrEqualTo(fieldName, date) + is QueryDataCondition<*> -> realmQuery.`in`(fieldName, stringValues.toTypedArray()) + is StaticDataQueryCondition -> { + realmQuery.`in`(fieldName, intValues.toTypedArray()) } - is ENDED_TO_DATE -> { - val date: Date by valueMap - realmQuery.lessThanOrEqualTo(fieldName, date) - } - is DAY_OF_WEEK -> { - val dayOfWeek: Int by valueMap - realmQuery.equalTo(fieldName, dayOfWeek) - } - is MONTH -> { - val month: Int by valueMap - realmQuery.equalTo(fieldName, month) - } - is YEAR -> { - val year: Int by valueMap - realmQuery.equalTo(fieldName, year) + is DateQuery -> { + if (this is Less) { + realmQuery.lessThanOrEqualTo(fieldName, dateValue) + } else { + realmQuery.greaterThanOrEqualTo(fieldName, dateValue) + } } + is SingleValueQueryCondition -> realmQuery.equalTo(fieldName, intValue) WEEK_END, WEEK_DAY -> { var query = realmQuery if (this == WEEK_DAY) { @@ -386,42 +397,13 @@ sealed class QueryCondition(var operator: Operator? = null) { } fun updateValueMap(filterCondition: FilterCondition) { - if (filterValuesExpectedKeys == null) { - return - } - - this.operator?.let { - valueMap = mapOf("value" to filterCondition.value) - return - } - when (this) { - is BANKROLL -> valueMap = mapOf("ids" to filterCondition.ids) - is ALL_TOURNAMENT_FEATURES, is ANY_TOURNAMENT_FEATURES, is GAME, is LOCATION, is TOURNAMENT_NAME -> { - valueMap = mapOf("ids" to filterCondition.ids) - } - is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> { - valueMap = mapOf("values" to filterCondition.values) - } + is asListOfDouble -> filterCondition.doubleValues.map { doubleValues.add(it) } + is QueryDataCondition<*> -> filterCondition.ids.map { stringValues.add(it) } + is DateQuery -> dateValue = filterCondition.date is BLIND -> { - valueMap = mapOf( - "blinds" to filterCondition.blinds, - "hasDefaultCurrency" to filterCondition.hasDefaultCurrency) - } - is STARTED_FROM_DATE, is STARTED_TO_DATE, is ENDED_FROM_DATE, is ENDED_TO_DATE -> { - valueMap = mapOf("date" to filterCondition.date) - } - is DAY_OF_WEEK -> { - valueMap = mapOf("dayOfWeek" to filterCondition.dayOfWeek) - } - is MONTH -> { - valueMap = mapOf("month" to filterCondition.month) - } - is YEAR -> { - valueMap = mapOf("year" to filterCondition.year) - } - else -> { - throw PokerAnalyticsException.QueryValueMapUnexpectedValue + filterCondition.blinds.map { stringValues.add(it) } + filterCondition.hasDefaultCurrency.map { booleanValues.add(it) } } } } diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt index 3ac7f81b..e470a1b4 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt @@ -44,6 +44,7 @@ open class Filter : RealmObject() { inline fun queryOn(realm: Realm, queries: List): RealmResults { var realmQuery = realm.where() queries.forEach { + Timber.d(">>> sub Filter query: ${realmQuery.description}") realmQuery = it.queryWith(realmQuery) } Timber.d(">>> Filter query: ${realmQuery.description}") @@ -64,8 +65,8 @@ open class Filter : RealmObject() { var filterConditions: RealmList = RealmList() private set - fun createOrUpdateFilterConditions(filterConditionRows: ArrayList) { - val casted = arrayListOf() + fun createOrUpdateFilterConditions(filterConditionRows: ArrayList) { + val casted = arrayListOf() filterConditionRows .map { it.id @@ -95,7 +96,7 @@ open class Filter : RealmObject() { } } - fun contains(filterElementRow: FilterElementRow): Boolean { + fun contains(filterElementRow: QueryCondition): Boolean { val filtered = filterConditions.filter { it.filterName == filterElementRow.id } @@ -105,34 +106,16 @@ open class Filter : RealmObject() { return filterElementRow.contains(filtered) } - /** - * Set the saved value in the queryWith for the given [filterElementRow] - */ - fun setSavedValueForElement(filterElementRow: FilterElementRow) { - when (filterElementRow) { - is FilterElementRow.PastDays -> { - val values = getSavedValueForElement(filterElementRow) as Array<*> - if (values.isNotEmpty() && values.first() is Int) { - filterElementRow.lastDays = values.first() as Int - } - } - is FilterElementRow.DateFilterElementRow -> filterElementRow.dateValue = getSavedValueForElement(filterElementRow) as Date? ?: Date() - } - } - /** * Get the saved value for the given [filterElementRow] */ - private fun getSavedValueForElement(filterElementRow: FilterElementRow): Any? { + fun loadValueForElement(filterElementRow: QueryCondition) { val filtered = filterConditions.filter { it.filterName == filterElementRow.id } - if (filtered.isNotEmpty()) { - return filtered.first().getFilterConditionValue(filterElementRow) + return filterElementRow.updateValueMap(filtered.first()) } - - return null } inline fun results(): RealmResults { diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt index 96ada039..dd8c7e0c 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt @@ -4,8 +4,6 @@ import io.realm.RealmList import io.realm.RealmObject import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.filter.QueryCondition -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.* import java.util.* open class FilterCondition() : RealmObject() { @@ -15,38 +13,39 @@ open class FilterCondition() : RealmObject() { this.sectionName = sectionName } - constructor(filterElementRows: ArrayList) : this(filterElementRows.first().id, filterElementRows.first().filterSectionRow.name) { + constructor(filterElementRows: ArrayList) : this(filterElementRows.first().id, filterElementRows.first().filterSectionRow.name) { val row = filterElementRows.first() this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName when (row) { - is DateFilterElementRow -> { + is QueryCondition.asDateValue -> { this.dateValue = row.dateValue } - is Blind -> { + is QueryCondition.BLIND -> { //TODO refactor raz this.stringValues = RealmList().apply { this.addAll(filterElementRows.map { - (it as Blind).blind + (it as QueryCondition.BLIND).blind + }) } this.booleanValues = RealmList().apply { this.addAll(filterElementRows.map { - (it as Blind).hasDefaultCurrency + (it as QueryCondition.BLIND).hasDefaultCurrency }) } } - is StringFilterElementRow -> { + is QueryCondition.asListOfString -> { this.stringValues = RealmList().apply { this.addAll(filterElementRows.map { - (it as StringFilterElementRow).stringValue + (it as QueryCondition.asListOfString).stringValues.firstOrNull() }) } } - is NumericFilterElementRow -> { + is QueryCondition.asListOfDouble -> { this.numericValues = RealmList().apply { this.addAll(filterElementRows.map { - (it as NumericFilterElementRow).doubleValue + (it as QueryCondition.asListOfDouble).doubleValues.firstOrNull() }) } } @@ -80,45 +79,19 @@ open class FilterCondition() : RealmObject() { get() = dateValue ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - val values: Array + val intValues: Array get() = numericValues?.map { + println("test double: $it") it.toInt() }?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - val value: Double - get() = numericValues?.first() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - - - val leftValue: Double + val doubleValue: Double get() = numericValues?.first() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing + val intValue: Int + get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - val rightValue: Double - get() = numericValues?.last() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - - - val dayOfWeek: Int - get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - - - val month: Int - get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - - - val year: Int - get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing - - - /** - * Return the value associated with the given [filterElementRow] - */ - fun getFilterConditionValue(filterElementRow: FilterElementRow): Any? { - return when (filterElementRow) { - is DateFilterElementRow -> date - is PastDays -> values - else -> throw PokerAnalyticsException.FilterElementTypeMissing(filterElementRow) - } - } - + val doubleValues: Array + get() = numericValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt index c6092dd4..bf7e3c8f 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt @@ -253,12 +253,10 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep if (!computedResults.isEmpty) { // Set date data conditions.forEach { condition -> - condition.valueMap?.get("year")?.let { year -> - calendar.set(Calendar.YEAR, year as Int) - } - condition.valueMap?.get("month")?.let { month -> - calendar.set(Calendar.MONTH, month as Int) - } + when (condition) { + is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.intValue) + is QueryCondition.MONTH -> calendar.set(Calendar.YEAR, condition.intValue) + } } monthlyReports[calendar.time] = computedResults @@ -281,9 +279,9 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep if (!computedResults.isEmpty) { // Set date data conditions.forEach { condition -> - condition.valueMap?.get("year")?.let { year -> - calendar.set(Calendar.YEAR, year as Int) - } + when (condition) { + is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.intValue) + } } yearlyReports[calendar.time] = computedResults } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt index fda6e770..c3615d7a 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt @@ -11,6 +11,7 @@ import androidx.recyclerview.widget.LinearLayoutManager import kotlinx.android.synthetic.main.fragment_filter_details.* import kotlinx.android.synthetic.main.fragment_filter_details.view.* import net.pokeranalytics.android.R +import net.pokeranalytics.android.model.filter.QueryCondition import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.ui.activity.FilterDetailsActivity import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity @@ -45,7 +46,7 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresent private var primaryKey: String? = null private var filterMenu: Menu? = null private var filterCategoryRow: FilterCategoryRow? = null - private val selectedRows = ArrayList() + private val selectedRows = ArrayList() private var isUpdating = false private var shouldOpenKeyboard = true @@ -70,29 +71,19 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresent Timber.d("Row: $row") when (row) { - is FilterElementRow.DateFilterElementRow -> DateTimePickerManager.create(requireContext(), row, this, row.dateValue, onlyDate = !row.showTime, onlyTime = row.showTime) - is FilterElementRow.PastDays -> { - val pastDays = if (row.lastDays > 0) row.lastDays.toString() else "" - val data = row.editingDescriptors(mapOf("pastDays" to pastDays)) - BottomSheetFragment.create(fragmentManager, row, this, data, true) - } - is FilterElementRow.LastGames -> { - val lastGames = if (row.lastGames > 0) row.lastGames.toString() else "" - val data = row.editingDescriptors(mapOf("lastGames" to lastGames)) - BottomSheetFragment.create(fragmentManager, row, this, data, true) - } - is FilterElementRow.LastSessions -> { - val lastSessions = if (row.lastSessions > 0) row.lastSessions.toString() else "" - val data = row.editingDescriptors(mapOf("lastSessions" to lastSessions)) - BottomSheetFragment.create(fragmentManager, row, this, data, true) - } - is FilterElementRow.DurationFilterElement -> { + is QueryCondition.DateQuery -> DateTimePickerManager.create(requireContext(), row, this, row.dateValue, onlyDate = !row.showTime, onlyTime = row.showTime) + is QueryCondition.SingleValueQueryCondition -> { + val valueAsString = if (row.intValue > 0) row.intValue.toString() else "" + val data = row.editingDescriptors(mapOf("valueAsString" to valueAsString)) + BottomSheetFragment.create(fragmentManager, row, this, data, true) + } + is QueryCondition.Duration-> { val hours = if (row.minutes / 60 > 0) (row.minutes / 60).toString() else "" val minutes = if (row.minutes % 60 > 0) (row.minutes % 60).toString() else "" val data = row.editingDescriptors(mapOf("hours" to hours, "minutes" to minutes)) BottomSheetFragment.create(fragmentManager, row, this, data, true) } - is FilterElementRow.AmountFilterElement -> { + is QueryCondition.Amount -> { val amount = if (row.amount > 0) row.amount.toString() else "" val data = row.editingDescriptors(mapOf("amount" to amount)) BottomSheetFragment.create(fragmentManager, row, this, data, true) @@ -105,12 +96,10 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresent override fun stringForRow(row: RowRepresentable): String { return when (row) { - is FilterElementRow.PastDays -> if (row.lastDays > 0) row.lastDays.toString() else NULL_TEXT - is FilterElementRow.LastGames -> if (row.lastGames > 0) row.lastGames.toString() else NULL_TEXT - is FilterElementRow.LastSessions -> if (row.lastSessions > 0) row.lastSessions.toString() else NULL_TEXT - is FilterElementRow.DateFilterElementRow -> if (row.showTime) row.dateValue.shortTime() else row.dateValue.shortDate() - is FilterElementRow.AmountFilterElement -> if (row.amount > 0) row.amount.toString() else NULL_TEXT - is FilterElementRow.DurationFilterElement -> row.minutes.toMinutes(requireContext()) + is QueryCondition.SingleValueQueryCondition -> if (row.intValue > 0) row.intValue.toString() else NULL_TEXT + is QueryCondition.DateQuery -> if (row.showTime) row.dateValue.shortTime() else row.dateValue.shortDate() + is QueryCondition.Amount -> if (row.amount > 0) row.amount.toString() else NULL_TEXT + is QueryCondition.Duration -> row.minutes.toMinutes(requireContext()) else -> super.stringForRow(row) } } @@ -124,12 +113,9 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresent Timber.d("onRowValueChanged: $row $value") when (row) { - is FilterElementRow.DateFilterElementRow -> row.dateValue = if (value != null && value is Date) value else Date() - is FilterElementRow.PastDays -> row.lastDays = if (value != null && value is String) value.toInt() else 0 - is FilterElementRow.LastGames -> row.lastGames = if (value != null && value is String) value.toInt() else 0 - is FilterElementRow.LastSessions -> row.lastSessions = if (value != null && value is String) value.toInt() else 0 - is FilterElementRow.AmountFilterElement -> row.amount = if (value != null && value is String) value.toDouble() else 0.0 - is FilterElementRow.DurationFilterElement -> { + is QueryCondition.DateQuery -> row.dateValue = if (value != null && value is Date) value else Date() + is QueryCondition.SingleValueQueryCondition -> row.intValue = if (value != null && value is String) value.toInt() else 0 + is QueryCondition.Duration -> { if (value is ArrayList<*>) { val hours = try { (value[0] as String? ?: "0").toInt() @@ -201,8 +187,8 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresent this.rows.addAll(it.filterElements) this.rows.forEach { element -> - if (element is FilterElementRow && currentFilter?.contains(element) == true) { - currentFilter?.setSavedValueForElement(element) + if (element is QueryCondition && currentFilter?.contains(element) == true) { + currentFilter?.loadValueForElement(element) this.selectedRows.add(element) } } @@ -230,7 +216,7 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresent rowRepresentableAdapter.refreshRow(it) } } - selectedRows.add(row) + selectedRows.add(row as QueryCondition) } } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt index c50c6f0f..6ba208a4 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt @@ -3,8 +3,7 @@ package net.pokeranalytics.android.ui.view.rowrepresentable import android.content.Context import android.text.InputType import net.pokeranalytics.android.R -import net.pokeranalytics.android.exceptions.PokerAnalyticsException -import net.pokeranalytics.android.model.interfaces.Manageable +import net.pokeranalytics.android.model.filter.QueryCondition import net.pokeranalytics.android.model.realm.FilterCondition import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetType import net.pokeranalytics.android.ui.view.RowRepresentable @@ -13,379 +12,124 @@ import net.pokeranalytics.android.ui.view.RowViewType import java.text.DateFormatSymbols import java.util.* -sealed class FilterElementRow : RowRepresentable { - interface Duration { - var minutes: Int - } - - interface Operator - interface MoreOperator : Operator - interface LessOperator : Operator - - open class BoolFilterElementRow : FilterElementRow() - - open class DateFilterElementRow(var dateValue: Date = Date(), var showTime: Boolean = false) : FilterElementRow() - open class NumericFilterElementRow(open val doubleValue: Double = 0.0) : FilterElementRow() - open class StringFilterElementRow(val stringValue: String = "") : FilterElementRow() - - // Subclasses - open class SingleValueFilterElementRow(open val intValue: Int) : NumericFilterElementRow() { - override val doubleValue: Double - get() { - return intValue.toDouble() - } - } - - open class DataFilterElementRow(data: Manageable) : StringFilterElementRow(data.id) { - val objectId: String = data.id - val name: String = (data as RowRepresentable).getDisplayName() +interface FilterElementRow : RowRepresentable { + fun contains(filterConditions: List): Boolean { + return when (this) { + is QueryCondition.StaticDataQueryCondition -> filterConditions.any { + it.intValues.contains(this.intValues.first()) + } + is QueryCondition.QueryDataCondition<*>-> filterConditions.any { + it.ids.contains(this.dataObject?.id) + } + else -> true + } } - open class StaticDataFilterElementRow(val row: RowRepresentable, val objectId: Int) : NumericFilterElementRow(objectId.toDouble()) { - - override val resId: Int? = row.resId - val name: String = row.getDisplayName() - - fun getDataLocalizedTitle(context: Context): String { - return row.localizedTitle(context) - } - } - - open class DurationFilterElement : NumericFilterElementRow(), Duration { - override var minutes: Int = 0 - override val doubleValue: Double - get() { - return minutes.toDouble() - } - } - - open class AmountFilterElement : NumericFilterElementRow() { - var amount: Double = 0.0 - override val doubleValue: Double - get() { - return amount - } - } - - object Cash : BoolFilterElementRow() - object Tournament : BoolFilterElementRow() - object Live : BoolFilterElementRow() - object Online : BoolFilterElementRow() - object Today : BoolFilterElementRow() - object Yesterday : BoolFilterElementRow() - object TodayAndYesterday : BoolFilterElementRow() - object CurrentWeek : BoolFilterElementRow() - object CurrentMonth : BoolFilterElementRow() - object CurrentYear : BoolFilterElementRow() - object Weekday : BoolFilterElementRow() - object Weekend : BoolFilterElementRow() - object From : DateFilterElementRow() - object To : DateFilterElementRow() - - object FromTime : DateFilterElementRow(showTime = true) - object ToTime : DateFilterElementRow(showTime = true) - - - // Data classes - holding value - object ResultMoreThan : AmountFilterElement(), MoreOperator - - object ResultLessThan : AmountFilterElement(), LessOperator - object DurationMoreThan : DurationFilterElement(), MoreOperator - object DurationLessThan : DurationFilterElement(), LessOperator - object ReBuyMoreThan : AmountFilterElement(), MoreOperator - object ReBuyLessThan : AmountFilterElement(), LessOperator - - - data class Year(val year: Int) : SingleValueFilterElementRow(year) - data class Month(val month: Int) : SingleValueFilterElementRow(month) - data class Day(val day: Int) : SingleValueFilterElementRow(day) - - data class Blind(val blind: String, val hasDefaultCurrency: Boolean) : StringFilterElementRow(blind) - - //TODO: Refactor? - data class PastDays(var lastDays: Int = 0) : SingleValueFilterElementRow(lastDays) { - override val intValue: Int - get() { - return lastDays - } - } - - data class LastGames(var lastGames: Int) : SingleValueFilterElementRow(lastGames) { - override val intValue: Int - get() { - return lastGames - } - } - - data class LastSessions(var lastSessions: Int) : SingleValueFilterElementRow(lastSessions) { - override val intValue: Int - get() { - return lastSessions - } - } - - data class Limit(val limit: net.pokeranalytics.android.model.Limit) : StaticDataFilterElementRow(limit, limit.ordinal) - data class TableSize(val tableSize: net.pokeranalytics.android.model.TableSize) : StaticDataFilterElementRow(tableSize, tableSize.numberOfPlayer) - - data class Bankroll(val bankroll: Manageable) : DataFilterElementRow(bankroll) - data class Game(val game: Manageable) : DataFilterElementRow(game) - data class Location(val location: Manageable) : DataFilterElementRow(location) - data class TournamentName(val tournamentName: Manageable) : DataFilterElementRow(tournamentName) - data class AllTournamentFeature(val tournamentFeature: Manageable) : DataFilterElementRow(tournamentFeature) - data class AnyTournamentFeature(val tournamentFeature: Manageable) : DataFilterElementRow(tournamentFeature) - - lateinit var filterSectionRow: FilterSectionRow - - val id: String = this.criteria.name - - private val criteria: QueryCriteria - get() { - return when (this) { - is Cash -> QueryCriteria.CASH - is Tournament -> QueryCriteria.TOURNAMENT - is Blind -> QueryCriteria.BLIND - is From -> QueryCriteria.STARTED_FROM_DATE - is To -> QueryCriteria.ENDED_TO_DATE - is FromTime -> QueryCriteria.STARTED_FROM_TIME - is ToTime -> QueryCriteria.ENDED_TO_TIME - is Month -> QueryCriteria.MONTH - is Day -> QueryCriteria.DAY_OF_WEEK - is Year -> QueryCriteria.YEAR - is Live -> QueryCriteria.LIVE - is Online -> QueryCriteria.ONLINE - is Weekday -> QueryCriteria.WEEK_DAY - is Weekend -> QueryCriteria.WEEK_END - is Today -> QueryCriteria.TODAY - is Yesterday -> QueryCriteria.YESTERDAY - is TodayAndYesterday -> QueryCriteria.TODAY_AND_YESTERDAY - is CurrentWeek -> QueryCriteria.THIS_WEEK - is CurrentMonth -> QueryCriteria.THIS_MONTH - is CurrentYear -> QueryCriteria.THIS_YEAR - is PastDays -> QueryCriteria.PAST_DAYS - is Limit -> QueryCriteria.LIMIT - is TableSize -> QueryCriteria.TABLE_SIZE - is Game -> QueryCriteria.GAME - is Bankroll -> QueryCriteria.BANKROLL - is Location -> QueryCriteria.LOCATION - is TournamentName -> QueryCriteria.TOURNAMENT_NAME - is AnyTournamentFeature -> QueryCriteria.ANY_TOURNAMENT_FEATURES - is AllTournamentFeature -> QueryCriteria.ALL_TOURNAMENT_FEATURES - is ResultMoreThan -> QueryCriteria.MORE_THAN_NET_RESULT - is ResultLessThan -> QueryCriteria.LESS_THAN_NET_RESULT - is DurationMoreThan -> QueryCriteria.MORE_THAN_DURATION - is DurationLessThan -> QueryCriteria.LESS_THAN_DURATION - - //TODO: Check the conditions - is LastGames -> QueryCriteria.LAST_GAMES - is LastSessions -> QueryCriteria.LAST_SESSIONS - is ReBuyMoreThan -> QueryCriteria.MIN_RE_BUY - is ReBuyLessThan -> QueryCriteria.MAX_RE_BUY - - else -> throw PokerAnalyticsException.UnknownQueryTypeForRow(this) - } - } - - fun contains(filterConditions: List): Boolean { - return when (this) { - is SingleValueFilterElementRow -> filterConditions.any { - it.values.contains(this.intValue) - } - is DataFilterElementRow -> filterConditions.any { - it.ids.contains(this.objectId) - } - else -> true - } - } - - - override val resId: Int? - get() { - return when (this) { - is Cash -> R.string.cash_game - is Tournament -> R.string.tournament - is Today -> R.string.today - is Yesterday -> R.string.yesterday - is TodayAndYesterday -> R.string.yesterday_and_today - is CurrentWeek -> R.string.current_week - is CurrentMonth -> R.string.current_month - is CurrentYear -> R.string.current_year - is From, FromTime -> R.string.from - is To, ToTime -> R.string.to - is Live -> R.string.live - is Online -> R.string.online - is Weekday -> R.string.week_days - is Weekend -> R.string.weekend - is PastDays -> R.string.period_in_days - is LastGames -> R.string.last_records - is LastSessions -> R.string.last_sessions - is ReBuyMoreThan -> R.string.minimum - is ReBuyLessThan -> R.string.maximum - is MoreOperator -> R.string.more_than - is LessOperator -> R.string.less_than - else -> null - } - } - - override val viewType: Int - get() { - return when (this) { - is PastDays, is From, is To, is FromTime, is ToTime, is LastGames, is LastSessions, is ReBuyMoreThan, is ReBuyLessThan, - is DurationMoreThan, is DurationLessThan -> RowViewType.TITLE_VALUE_CHECK.ordinal - else -> RowViewType.TITLE_CHECK.ordinal - } - } - - override val bottomSheetType: BottomSheetType - get() { - return when (this) { - is PastDays, is LastGames, is LastSessions, is ReBuyMoreThan, is ReBuyLessThan -> BottomSheetType.EDIT_TEXT - is DurationMoreThan, is DurationLessThan -> BottomSheetType.DOUBLE_EDIT_TEXT - else -> BottomSheetType.NONE - } - } - - override fun editingDescriptors(map: Map): ArrayList? { - return when (this) { - is PastDays -> { - val pastDays: String? by map - arrayListOf( - RowRepresentableEditDescriptor(pastDays, R.string.period_in_days, inputType = InputType.TYPE_CLASS_NUMBER) - ) - } - is LastGames -> { - val lastGames: String? by map - arrayListOf( - RowRepresentableEditDescriptor(lastGames, R.string.last_records, inputType = InputType.TYPE_CLASS_NUMBER) - ) - } - is LastSessions -> { - val lastSessions: String? by map - arrayListOf( - RowRepresentableEditDescriptor(lastSessions, R.string.last_sessions, inputType = InputType.TYPE_CLASS_NUMBER) - ) - } - - //TODO: Refactor that - is AmountFilterElement -> { - val amount: String? by map - arrayListOf( - RowRepresentableEditDescriptor(amount, R.string.amount, inputType = InputType.TYPE_CLASS_NUMBER) - ) - } - - is DurationFilterElement -> { - val hours: String? by map - val minutes: String? by map - arrayListOf( - RowRepresentableEditDescriptor(hours, R.string.hour, inputType = InputType.TYPE_CLASS_NUMBER), - RowRepresentableEditDescriptor(minutes, R.string.minute, inputType = InputType.TYPE_CLASS_NUMBER) - ) - } - else -> super.editingDescriptors(map) - } - } + override val resId: Int? + get() { + return when (this) { + is QueryCondition.CASH -> R.string.cash_game + is QueryCondition.TOURNAMENT -> R.string.tournament + is QueryCondition.TODAY -> R.string.today + is QueryCondition.YESTERDAY -> R.string.yesterday + is QueryCondition.TODAY_AND_YESTERDAY -> R.string.yesterday_and_today + is QueryCondition.THIS_WEEK -> R.string.current_week + is QueryCondition.THIS_MONTH -> R.string.current_month + is QueryCondition.THIS_YEAR -> R.string.current_year + is QueryCondition.STARTED_FROM_TIME, is QueryCondition.STARTED_FROM_DATE -> R.string.from + is QueryCondition.ENDED_TO_DATE, is QueryCondition.ENDED_TO_TIME-> R.string.to + is QueryCondition.LIVE -> R.string.live + is QueryCondition.ONLINE -> R.string.online + is QueryCondition.WEEK_DAY -> R.string.week_days + is QueryCondition.WEEK_END -> R.string.weekend + is QueryCondition.PAST_DAYS -> R.string.period_in_days + is QueryCondition.LAST_GAMES -> R.string.last_records + is QueryCondition.LAST_SESSIONS -> R.string.last_sessions + is QueryCondition.MIN_RE_BUY -> R.string.minimum + is QueryCondition.MAX_RE_BUY -> R.string.maximum + is QueryCondition.More -> R.string.more_than + is QueryCondition.Less -> R.string.less_than + else -> null + } + } + + override val viewType: Int + get() { + return when (this) { + is QueryCondition.PAST_DAYS, is QueryCondition.STARTED_FROM_DATE, is QueryCondition.ENDED_TO_DATE, is QueryCondition.STARTED_FROM_TIME, is QueryCondition.ENDED_TO_TIME, is QueryCondition.LAST_GAMES, is QueryCondition.LAST_SESSIONS, is QueryCondition.MAX_RE_BUY, is QueryCondition.MIN_RE_BUY, + is QueryCondition.MORE_THAN_DURATION, is QueryCondition.LESS_THAN_DURATION-> RowViewType.TITLE_VALUE_CHECK.ordinal + else -> RowViewType.TITLE_CHECK.ordinal + } + } + + override val bottomSheetType: BottomSheetType + get() { + return when (this) { + is QueryCondition.PAST_DAYS, is QueryCondition.LAST_GAMES, is QueryCondition.LAST_SESSIONS, is QueryCondition.MAX_RE_BUY, is QueryCondition.MIN_RE_BUY-> BottomSheetType.EDIT_TEXT + is QueryCondition.MORE_THAN_DURATION, is QueryCondition.LESS_THAN_DURATION-> BottomSheetType.DOUBLE_EDIT_TEXT + else -> BottomSheetType.NONE + } + } + + override fun editingDescriptors(map: Map): ArrayList? { + return when (this) { + is QueryCondition.SingleValueQueryCondition -> { + val valueAsString: String? by map + arrayListOf( + RowRepresentableEditDescriptor(valueAsString, this.resId, inputType = InputType.TYPE_CLASS_NUMBER) + ) + } + //TODO: Refactor that + is QueryCondition.Amount -> { + val amount: String? by map + arrayListOf( + RowRepresentableEditDescriptor(amount, R.string.amount, inputType = InputType.TYPE_CLASS_NUMBER) + ) + } + is QueryCondition.Duration -> { + val hours: String? by map + val minutes: String? by map + arrayListOf( + RowRepresentableEditDescriptor(hours, R.string.hour, inputType = InputType.TYPE_CLASS_NUMBER), + RowRepresentableEditDescriptor(minutes, R.string.minute, inputType = InputType.TYPE_CLASS_NUMBER) + ) + } + else -> super.editingDescriptors(map) + } + } - override fun getDisplayName(): String { - return when (this) { - is SingleValueFilterElementRow -> { - when (this) { - is Day -> DateFormatSymbols.getInstance(Locale.getDefault()).weekdays[this.intValue] - is Month -> DateFormatSymbols.getInstance(Locale.getDefault()).months[this.intValue] - else -> "${this.intValue}" - } - } - is DataFilterElementRow -> this.name - is StaticDataFilterElementRow -> this.name - is Blind -> this.blind + 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() - } - } - - override fun localizedTitle(context: Context): String { - return when (this) { - is StaticDataFilterElementRow -> this.getDataLocalizedTitle(context) - else -> super.localizedTitle(context) - } - } - - val sectionToExclude: List? - get() { - val excluded = arrayListOf() - if (!this.filterSectionRow.allowMultiSelection) { - excluded.add(this.filterSectionRow) - } - this.filterSectionRow.exclusiveWith?.let { exclusives -> - excluded.addAll(exclusives) - } - - if (excluded.size > 0) { - return excluded - } - return null - } - - - private enum class QueryCriteria { - LIVE, - CASH, - ONLINE, - TOURNAMENT, - BANKROLL, - GAME, - TOURNAMENT_NAME, - ANY_TOURNAMENT_FEATURES, - ALL_TOURNAMENT_FEATURES, - LOCATION, - LIMIT, - TABLE_SIZE, - TOURNAMENT_TYPE, - BLIND, - LAST_GAMES, - LAST_SESSIONS, - MORE_NUMBER_OF_TABLE, - LESS_NUMBER_OF_TABLE, - BETWEEN_NUMBER_OF_TABLE, - MORE_THAN_NET_RESULT, - LESS_THAN_NET_RESULT, - MORE_THAN_BUY_IN, - LESS_THAN_BUY_IN, - MORE_THAN_CASH_OUT, - LESS_THAN_CASH_OUT, - MORE_THAN_TIPS, - LESS_THAN_TIPS, - MORE_THAN_NUMBER_OF_PLAYER, - LESS_THAN_NUMBER_OF_PLAYER, - BETWEEN_NUMBER_OF_PLAYER, - MORE_THAN_TOURNAMENT_FEE, - LESS_THAN_TOURNAMENT_FEE, - BETWEEN_TOURNAMENT_FEE, - MIN_RE_BUY, - MAX_RE_BUY, - - // Dates - STARTED_FROM_DATE, - STARTED_TO_DATE, - ENDED_FROM_DATE, - ENDED_TO_DATE, - DAY_OF_WEEK, - MONTH, - YEAR, - WEEK_DAY, - WEEK_END, - TODAY, - YESTERDAY, - TODAY_AND_YESTERDAY, - THIS_WEEK, - THIS_MONTH, - THIS_YEAR, - PAST_DAYS, - MORE_THAN_DURATION, - LESS_THAN_DURATION, - STARTED_FROM_TIME, - ENDED_TO_TIME, - - COMMENT, - - ; + } } + + var filterSectionRow: FilterSectionRow + + val sectionToExclude: List? + get() { + val excluded = arrayListOf() + if (!this.filterSectionRow.allowMultiSelection) { + excluded.add(this.filterSectionRow) + } + this.filterSectionRow.exclusiveWith?.let { exclusives -> + excluded.addAll(exclusives) + } + + if (excluded.size > 0) { + return excluded + } + return null + } } \ No newline at end of file diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt index f64bc0ba..bd4b92a4 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt @@ -4,7 +4,9 @@ import io.realm.Realm import io.realm.Sort import io.realm.kotlin.where import net.pokeranalytics.android.R +import net.pokeranalytics.android.model.Criteria import net.pokeranalytics.android.model.LiveData +import net.pokeranalytics.android.model.filter.QueryCondition import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowViewType @@ -66,51 +68,25 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { when (this@FilterSectionRow) { // General - CASH_TOURNAMENT -> arrayListOf(Cash, Tournament) - LIVE_ONLINE -> arrayListOf(Live, Online) - GAME -> { - val games = arrayListOf() - val realm = Realm.getDefaultInstance() - LiveData.GAME.items(realm).forEach { - val game = Game(it as net.pokeranalytics.android.model.realm.Game) - games.add(game) - } - realm.close() - games - } - LIMIT_TYPE -> { - val limits = arrayListOf() - net.pokeranalytics.android.model.Limit.values().forEach { - limits.add(Limit(it)) - } - limits - } - TABLE_SIZE -> { - val tableSizes = arrayListOf() - val realm = Realm.getDefaultInstance() - val distinctTableSizes = - realm.where().distinct("tableSize").findAll().sort("tableSize", Sort.ASCENDING) - distinctTableSizes.forEach { session -> - session.tableSize?.let { tableSize -> - tableSizes.add(TableSize(net.pokeranalytics.android.model.TableSize(tableSize))) - } - } - realm.close() - tableSizes - } - + CASH_TOURNAMENT -> arrayListOf(QueryCondition.CASH, QueryCondition.TOURNAMENT) + LIVE_ONLINE -> arrayListOf(QueryCondition.LIVE, QueryCondition.ONLINE) + GAME -> Criteria.Games.queryConditions + LIMIT_TYPE -> Criteria.Limits.queryConditions + TABLE_SIZE -> Criteria.TableSizes.queryConditions // Date DYNAMIC_DATE -> arrayListOf( - Today, - Yesterday, - TodayAndYesterday, - CurrentWeek, - CurrentMonth, - CurrentYear + QueryCondition.TODAY, + QueryCondition.YESTERDAY, + QueryCondition.TODAY_AND_YESTERDAY, + QueryCondition.THIS_WEEK, + QueryCondition.THIS_MONTH, + QueryCondition.THIS_YEAR ) - FIXED_DATE -> arrayListOf(From, To) - DURATION -> arrayListOf(PastDays(0)) - YEAR -> { + 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 -> { val years = arrayListOf() val realm = Realm.getDefaultInstance() val distinctYears = @@ -123,7 +99,6 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { realm.close() years } - WEEKDAYS_OR_WEEKEND -> arrayListOf(Weekday, Weekend) DAY_OF_WEEK -> { val daysOfWeek = arrayListOf() DateFormatSymbols.getInstance(Locale.getDefault()).weekdays.forEachIndexed { index, day -> @@ -141,25 +116,24 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { } } months - } + }*/ // Duration - SESSION_DURATION -> arrayListOf( - DurationMoreThan as FilterElementRow, - DurationLessThan as FilterElementRow - ) + SESSION_DURATION -> arrayListOf(QueryCondition.MORE_THAN_DURATION(), QueryCondition.LESS_THAN_DURATION() as QueryCondition) + /* RANGE -> { val fromTime = FromTime fromTime.dateValue = Date().startOfDay() val toTime = ToTime toTime.dateValue = Date().endOfDay() arrayListOf(fromTime, toTime) - } + }*/ // Sessions - SESSIONS -> arrayListOf(LastGames(0), LastSessions(0)) + SESSIONS -> arrayListOf(QueryCondition.LAST_GAMES(), QueryCondition.LAST_SESSIONS()) // Cash + /* BLIND -> { val blinds = arrayListOf() val realm = Realm.getDefaultInstance() @@ -170,10 +144,10 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { } realm.close() blinds - } + }*/ CASH_RE_BUY_COUNT -> arrayListOf( - ReBuyMoreThan as FilterElementRow, - ReBuyLessThan as FilterElementRow + QueryCondition.MAX_RE_BUY(), + QueryCondition.MIN_RE_BUY() ) // Tournament @@ -194,7 +168,7 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { MULTI_PLAYER -> arrayListOf() VALUE -> arrayListOf() - + else -> arrayListOf() }.apply { this.forEach { it.filterSectionRow = this@FilterSectionRow