From 0e5877e8f378b0f4202000b8aa7f06e5db805196 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Sat, 20 Apr 2019 10:31:49 +0200 Subject: [PATCH] fix unit tests clean up queryCondition interfaces --- .../unitTests/StatsInstrumentedUnitTest.kt | 4 +- .../filter/BlindFilterInstrumentedTest.kt | 23 +- .../filter/DateFilterInstrumentedUnitTest.kt | 49 +++-- .../filter/RealmFilterInstrumentedUnitTest.kt | 6 +- .../SessionFilterInstrumentedUnitTest.kt | 92 ++++---- .../pokeranalytics/android/model/Criteria.kt | 70 +++---- .../android/model/comparison/Comparator.kt | 23 +- .../android/model/filter/QueryCondition.kt | 197 +++++++++--------- .../android/model/realm/FilterCondition.kt | 4 + .../android/model/realm/Session.kt | 52 ++--- .../ui/fragment/CalendarDetailsFragment.kt | 12 +- .../android/ui/fragment/CalendarFragment.kt | 28 +-- .../android/ui/fragment/StatisticsFragment.kt | 4 +- .../view/rowrepresentable/FilterElementRow.kt | 46 ++-- .../view/rowrepresentable/FilterSectionRow.kt | 46 ++-- 15 files changed, 316 insertions(+), 340 deletions(-) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt index 202ee39d..5e0049df 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt @@ -724,7 +724,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() { } - val group = ComputableGroup("test", listOf(QueryCondition.CASH)) + val group = ComputableGroup("test", listOf(QueryCondition.IsCash)) val options = Calculator.Options() options.displayedStats = listOf(Stat.DURATION) @@ -769,7 +769,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() { } - val group = ComputableGroup("test", listOf(QueryCondition.CASH)) + val group = ComputableGroup("test", listOf(QueryCondition.IsCash)) val options = Calculator.Options() options.displayedStats = listOf(Stat.DURATION) 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 8e223f53..94ff6f5f 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 @@ -6,7 +6,6 @@ import net.pokeranalytics.android.model.realm.Bankroll import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.FilterCondition import net.pokeranalytics.android.model.realm.Session -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow import org.junit.Assert import org.junit.Test @@ -41,9 +40,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLIND() + val filter = QueryCondition.AnyBlind() - val blind = QueryCondition.BLIND().apply { + val blind = QueryCondition.AnyBlind().apply { listOfValues = arrayListOf(s1.blinds!!) } @@ -88,12 +87,12 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLIND() + val filter = QueryCondition.AnyBlind() - val blind1 = QueryCondition.BLIND().apply { + val blind1 = QueryCondition.AnyBlind().apply { listOfValues = arrayListOf(s1.blinds!!) } - val blind2 = QueryCondition.BLIND().apply { + val blind2 = QueryCondition.AnyBlind().apply { listOfValues = arrayListOf(s2.blinds!!) } @@ -140,9 +139,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.BLIND() + val filter = QueryCondition.AnyBlind() - val blind = QueryCondition.BLIND().apply { + val blind = QueryCondition.AnyBlind().apply { listOfValues = arrayListOf(s3.blinds!!) } @@ -150,7 +149,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) - + println("<<<< ${filter.listOfValues}") val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) @@ -188,12 +187,12 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { - val filter = QueryCondition.BLIND() + val filter = QueryCondition.AnyBlind() - val blind1 = QueryCondition.BLIND().apply { + val blind1 = QueryCondition.AnyBlind().apply { listOfValues = arrayListOf(s1.blinds!!) } - val blind2 = QueryCondition.BLIND().apply { + val blind2 = QueryCondition.AnyBlind().apply { listOfValues = arrayListOf(s2.blinds!!) } 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 1847fba8..6f273150 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 @@ -6,7 +6,6 @@ import net.pokeranalytics.android.model.filter.QueryCondition import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.FilterCondition import net.pokeranalytics.android.model.realm.Session -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow import net.pokeranalytics.android.util.extensions.startOfDay import org.junit.Assert @@ -30,10 +29,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, cal.time) realm.commitTransaction() - val filter = QueryCondition.DAY_OF_WEEK() + val filter = QueryCondition.AnyDayOfWeek() cal.time = s1.startDate - val filterElementRow = QueryCondition.DAY_OF_WEEK().apply { listOfValues = arrayListOf(cal.get(Calendar.DAY_OF_WEEK)) } + val filterElementRow = QueryCondition.AnyDayOfWeek().apply { listOfValues = arrayListOf(cal.get(Calendar.DAY_OF_WEEK)) } filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) @@ -59,9 +58,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, cal.time) realm.commitTransaction() - val filter = QueryCondition.MONTH() + val filter = QueryCondition.AnyMonthOfYear() cal.time = s1.startDate - val filterElementRow = QueryCondition.MONTH().apply { listOfValues = arrayListOf(cal.get(Calendar.MONTH)) } + val filterElementRow = QueryCondition.AnyMonthOfYear().apply { listOfValues = arrayListOf(cal.get(Calendar.MONTH)) } filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE val filterElement = FilterCondition(arrayListOf(filterElementRow)) @@ -88,9 +87,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, cal.time) realm.commitTransaction() - val filter = QueryCondition.YEAR() + val filter = QueryCondition.AnyYear() cal.time = s1.startDate - val filterElementRow = QueryCondition.YEAR().apply { listOfValues = arrayListOf(cal.get(Calendar.YEAR)) } + val filterElementRow = QueryCondition.AnyYear().apply { listOfValues = arrayListOf(cal.get(Calendar.YEAR)) } filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE val filterElement = FilterCondition(arrayListOf(filterElementRow)) filter.updateValueMap(filterElement) @@ -118,7 +117,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, cal.time) realm.commitTransaction() - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.WEEK_END)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsWeekEnd)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -143,7 +142,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.WEEK_DAY)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsWeekDay)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -168,7 +167,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 2) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.TODAY)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsToday)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -193,7 +192,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 2) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.TODAY)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsToday)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -221,7 +220,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 3) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.YESTERDAY)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.WasYesterday)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -248,7 +247,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 3) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.YESTERDAY)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.WasYesterday)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -275,7 +274,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 3) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.TODAY_AND_YESTERDAY)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.WasTodayAndYesterday)) Assert.assertEquals(2, sessions.size) Assert.assertTrue(sessions.containsAll(arrayListOf(s1,s2))) @@ -306,7 +305,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 5) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.THIS_YEAR)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.DuringThisYear)) Assert.assertEquals(3, sessions.size) Assert.assertTrue(sessions.containsAll(arrayListOf(s1,s2, s3))) @@ -338,7 +337,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 5) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.THIS_MONTH)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.DuringThisMonth)) Assert.assertEquals(2, sessions.size) Assert.assertTrue(sessions.containsAll(arrayListOf(s1,s2))) @@ -362,7 +361,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Assert.assertTrue(realm.where(Session::class.java).findAll().count() == 2) - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.THIS_WEEK)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.DuringThisWeek)) Assert.assertEquals(1, sessions.size) Assert.assertTrue(sessions.containsAll(arrayListOf(s1))) @@ -383,8 +382,8 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val s2 = Session.testInstance(100.0, true, cal.time, 1) realm.commitTransaction() - val filter = QueryCondition.STARTED_FROM_DATE() - val filterElementRow = QueryCondition.STARTED_FROM_DATE().apply { singleValue = s2.startDate!!} + val filter = QueryCondition.StartedFromDate() + val filterElementRow = QueryCondition.StartedFromDate().apply { singleValue = s2.startDate!!} filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -411,8 +410,8 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.STARTED_TO_DATE() - val filterElementRow = QueryCondition.STARTED_TO_DATE().apply { singleValue = s1.startDate!! } + val filter = QueryCondition.StartedToDate() + val filterElementRow = QueryCondition.StartedToDate().apply { singleValue = s1.startDate!! } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -440,8 +439,8 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.ENDED_FROM_DATE() - val filterElementRow = QueryCondition.ENDED_FROM_DATE().apply { singleValue = s2.endDate() } + val filter = QueryCondition.EndedFromDate() + val filterElementRow = QueryCondition.EndedFromDate().apply { singleValue = s2.endDate() } filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -469,8 +468,8 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { realm.commitTransaction() - val filter = QueryCondition.ENDED_TO_DATE() - val filterElementRow = QueryCondition.ENDED_TO_DATE().apply { singleValue = s1.endDate() } + val filter = QueryCondition.EndedToDate() + val filterElementRow = QueryCondition.EndedToDate().apply { singleValue = 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 9e55a620..ac1c3186 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 @@ -2,12 +2,10 @@ package net.pokeranalytics.android.unitTests.filter import androidx.test.ext.junit.runners.AndroidJUnit4 import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest -import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.filter.QueryCondition import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow import org.junit.Assert import org.junit.Test @@ -25,7 +23,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = Filter() filter.name = "testSaveLoadCashFilter" - val filterElement = QueryCondition.CASH + val filterElement = QueryCondition.IsCash filterElement.filterSectionRow = FilterSectionRow.CASH_TOURNAMENT filter.createOrUpdateFilterConditions(arrayListOf(filterElement)) @@ -38,7 +36,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filterComponent = filter.filterConditions.first() filterComponent?.let { - Assert.assertTrue(it.queryCondition is QueryCondition.CASH) + Assert.assertTrue(it.queryCondition is QueryCondition.IsCash) } ?: run { Assert.fail() } 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 6f10b323..dfeec61d 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 @@ -3,10 +3,8 @@ package net.pokeranalytics.android.unitTests.filter import androidx.test.ext.junit.runners.AndroidJUnit4 import io.realm.RealmList import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest -import net.pokeranalytics.android.model.TableSize import net.pokeranalytics.android.model.filter.QueryCondition import net.pokeranalytics.android.model.realm.* -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow import org.junit.Assert import org.junit.Test @@ -26,7 +24,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1) realm.commitTransaction() - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.CASH)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsCash)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -44,7 +42,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1) realm.commitTransaction() - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.TOURNAMENT)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsTournament)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -67,7 +65,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1, b2) realm.commitTransaction() - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.LIVE)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsLive)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).bankroll?.run { @@ -89,7 +87,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1, b2) realm.commitTransaction() - val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.ONLINE)) + val sessions = Filter.queryOn(realm, arrayListOf(QueryCondition.IsOnline)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).bankroll?.run { @@ -109,8 +107,8 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(bankroll = b2) realm.commitTransaction() - val filter = QueryCondition.BANKROLL() - val filterElementRow = QueryCondition.BANKROLL().apply { setObject(b1) } + val filter = QueryCondition.AnyBankroll() + val filterElementRow = QueryCondition.AnyBankroll().apply { setObject(b1) } filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -140,11 +138,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(bankroll = b3) realm.commitTransaction() - val filter = QueryCondition.BANKROLL() - val filterElementRow = QueryCondition.BANKROLL().apply { setObject(b1) } + val filter = QueryCondition.AnyBankroll() + val filterElementRow = QueryCondition.AnyBankroll().apply { setObject(b1) } filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL - val filterElementRow2 = QueryCondition.BANKROLL().apply { setObject(b2) } + val filterElementRow2 = QueryCondition.AnyBankroll().apply { setObject(b2) } filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -169,8 +167,8 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(game = g2) realm.commitTransaction() - val filter = QueryCondition.GAME() - val filterElementRow = QueryCondition.GAME().apply { setObject(g2) } + val filter = QueryCondition.AnyGame() + val filterElementRow = QueryCondition.AnyGame().apply { setObject(g2) } filterElementRow.filterSectionRow = FilterSectionRow.GAME filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -200,9 +198,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(game = g3) realm.commitTransaction() - val filterElementRow = QueryCondition.GAME().apply { setObject(g2) } + val filterElementRow = QueryCondition.AnyGame().apply { setObject(g2) } filterElementRow.filterSectionRow = FilterSectionRow.GAME - val filterElementRow2 = QueryCondition.GAME().apply { setObject(g3) } + val filterElementRow2 = QueryCondition.AnyGame().apply { setObject(g3) } filterElementRow2.filterSectionRow = FilterSectionRow.GAME val filterCondition = FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)) val queryCondition = filterCondition.queryCondition @@ -227,8 +225,8 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(location = l2) realm.commitTransaction() - val filter = QueryCondition.LOCATION() - val filterElementRow = QueryCondition.LOCATION().apply { setObject(l1) } + val filter = QueryCondition.AnyLocation() + val filterElementRow = QueryCondition.AnyLocation().apply { setObject(l1) } filterElementRow.filterSectionRow = FilterSectionRow.LOCATION filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -258,11 +256,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(location = l3) realm.commitTransaction() - val filter = QueryCondition.LOCATION() + val filter = QueryCondition.AnyLocation() - val filterElementRow = QueryCondition.LOCATION().apply { setObject(l1) } + val filterElementRow = QueryCondition.AnyLocation().apply { setObject(l1) } filterElementRow.filterSectionRow = FilterSectionRow.LOCATION - val filterElementRow2 = QueryCondition.LOCATION().apply { setObject(l3) } + val filterElementRow2 = QueryCondition.AnyLocation().apply { setObject(l3) } filterElementRow2.filterSectionRow = FilterSectionRow.LOCATION filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -288,9 +286,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(tournamentName = t2) realm.commitTransaction() - val filter = QueryCondition.TOURNAMENT_NAME() + val filter = QueryCondition.AnyTournamentName() - val filterElementRow = QueryCondition.TOURNAMENT_NAME().apply { setObject(t1) } + val filterElementRow = QueryCondition.AnyTournamentName().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -320,10 +318,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(tournamentName = t3) realm.commitTransaction() - val filter = QueryCondition.TOURNAMENT_NAME() - val filterElementRow = QueryCondition.TOURNAMENT_NAME().apply { setObject(t1) } + val filter = QueryCondition.AnyTournamentName() + val filterElementRow = QueryCondition.AnyTournamentName().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME - val filterElementRow2 = QueryCondition.TOURNAMENT_NAME().apply { setObject(t2) } + val filterElementRow2 = QueryCondition.AnyTournamentName().apply { setObject(t2) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -356,12 +354,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(tournamentFeatures = RealmList(t1)) realm.commitTransaction() - val filter = QueryCondition.ALL_TOURNAMENT_FEATURES() - val filterElementRow = QueryCondition.ALL_TOURNAMENT_FEATURES().apply { setObject(t1) } + val filter = QueryCondition.AllTournamentFeature() + val filterElementRow = QueryCondition.AllTournamentFeature().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow2 = QueryCondition.ALL_TOURNAMENT_FEATURES().apply { setObject(t2) } + val filterElementRow2 = QueryCondition.AllTournamentFeature().apply { setObject(t2) } filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow3 = QueryCondition.ALL_TOURNAMENT_FEATURES().apply { setObject(t4) } + val filterElementRow3 = QueryCondition.AllTournamentFeature().apply { setObject(t4) } filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3))) @@ -391,14 +389,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(tournamentFeatures = RealmList(t1)) realm.commitTransaction() - val filter = QueryCondition.ANY_TOURNAMENT_FEATURES() - val filterElementRow = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t1) } + val filter = QueryCondition.AnyTournamentFeature() + val filterElementRow = QueryCondition.AnyTournamentFeature().apply { setObject(t1) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow2 = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t2) } + val filterElementRow2 = QueryCondition.AnyTournamentFeature().apply { setObject(t2) } filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow3 = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t3) } + val filterElementRow3 = QueryCondition.AnyTournamentFeature().apply { setObject(t3) } filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE - val filterElementRow4 = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t4) } + val filterElementRow4 = QueryCondition.AnyTournamentFeature().apply { setObject(t4) } filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4))) @@ -425,8 +423,8 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(tournamentFeatures = RealmList(t1)) realm.commitTransaction() - val filter = QueryCondition.ANY_TOURNAMENT_FEATURES() - val filterElementRow = QueryCondition.ANY_TOURNAMENT_FEATURES().apply { setObject(t2) } + val filter = QueryCondition.AnyTournamentFeature() + val filterElementRow = QueryCondition.AnyTournamentFeature().apply { setObject(t2) } filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) @@ -450,10 +448,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(tableSize = 10) realm.commitTransaction() - val filter = QueryCondition.TABLE_SIZE() - val filterElementRow = QueryCondition.TABLE_SIZE().apply { listOfValues = arrayListOf(2) } + val filter = QueryCondition.AnyTableSize() + val filterElementRow = QueryCondition.AnyTableSize().apply { listOfValues = arrayListOf(2) } filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE - val filterElementRow2 = QueryCondition.TABLE_SIZE().apply { listOfValues = arrayListOf(4) } + val filterElementRow2 = QueryCondition.AnyTableSize().apply { listOfValues = arrayListOf(4) } filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) @@ -477,8 +475,8 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val s2 = Session.testInstance(netResult = 570.0) realm.commitTransaction() - val filter = QueryCondition.MORE_THAN_NET_RESULT() - val filterElementRow = QueryCondition.MORE_THAN_NET_RESULT().apply { this.amount = 204.0 } + val filter = QueryCondition.MoreNetResult() + val filterElementRow = QueryCondition.MoreNetResult().apply { this.amount = 204.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -502,8 +500,8 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(netResult = 570.0) realm.commitTransaction() - val filter = QueryCondition.LESS_THAN_NET_RESULT() - val filterElementRow = QueryCondition.LESS_THAN_NET_RESULT().apply { this.amount = 540.0 } + val filter = QueryCondition.LessNetResult() + val filterElementRow = QueryCondition.LessNetResult().apply { this.amount = 540.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) @@ -527,13 +525,13 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(netResult = 570.0) realm.commitTransaction() - val filterMore = QueryCondition.MORE_THAN_NET_RESULT() - val filterElementRow = QueryCondition.MORE_THAN_NET_RESULT().apply { this.amount = 200.0 } + val filterMore = QueryCondition.MoreNetResult() + val filterElementRow = QueryCondition.MoreNetResult().apply { this.amount = 200.0 } filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterMore.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) - val filterLess = QueryCondition.LESS_THAN_NET_RESULT() - val filterElementRow2 = QueryCondition.LESS_THAN_NET_RESULT().apply { this.amount = 400.0 } + val filterLess = QueryCondition.LessNetResult() + val filterElementRow2 = QueryCondition.LessNetResult().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 44e10bb0..ce8aaba8 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/Criteria.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/Criteria.kt @@ -5,10 +5,10 @@ import io.realm.Sort import io.realm.kotlin.where import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.filter.QueryCondition -import net.pokeranalytics.android.model.interfaces.Identifiable import net.pokeranalytics.android.model.interfaces.NameManageable import net.pokeranalytics.android.model.realm.* import java.util.* +import kotlin.collections.ArrayList sealed class Criteria { abstract class RealmCriteria : Criteria() { @@ -23,40 +23,42 @@ sealed class Criteria { } } - abstract class StaticCriteria : Criteria() { - inline fun comparison(): List { + abstract class ListCriteria : Criteria() { + inline fun , reified S:Any> comparison(): List { QueryCondition.distinct()?.let { val values = it.mapNotNull { session -> when (this) { - is Limits -> session.limit - is TournamentTypes -> session.tournamentType - is TableSizes -> session.tableSize - //is TournamentFees -> session.tournamentEntryFee + is Limits -> if (session.limit is S) { session.limit as S } else throw PokerAnalyticsException.QueryValueMapUnexpectedValue + is TournamentTypes -> if (session.tournamentType is S) { session.tournamentType as S } else throw PokerAnalyticsException.QueryValueMapUnexpectedValue + is TableSizes -> if (session.tableSize is S) { session.tableSize as S } else throw PokerAnalyticsException.QueryValueMapUnexpectedValue + is TournamentFees -> if (session.tournamentEntryFee is S) { session.tournamentEntryFee as S } else throw PokerAnalyticsException.QueryValueMapUnexpectedValue + is Blinds -> if (session.blinds is S) { session.blinds as S } else throw PokerAnalyticsException.QueryValueMapUnexpectedValue else -> null } } - return compare(values) + return compareList(values = values) } return listOf() } } + object Bankrolls: RealmCriteria() object Games: RealmCriteria() object TournamentNames: RealmCriteria() object Locations: RealmCriteria() object TournamentFeatures: RealmCriteria() - object Limits: StaticCriteria() - object TableSizes: StaticCriteria() - object TournamentTypes: StaticCriteria() - object monthOfYear: SimpleCriteria(List(12) { index -> QueryCondition.MONTH().apply { listOfValues = arrayListOf(index)} }) - object dayOfWeek: SimpleCriteria(List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { listOfValues = arrayListOf(index + 1) } }) - object SessionType: SimpleCriteria(listOf(QueryCondition.CASH, QueryCondition.TOURNAMENT)) - object BankrollType: SimpleCriteria(listOf(QueryCondition.LIVE, QueryCondition.ONLINE)) - object dayPeriod: SimpleCriteria(listOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END)) - object Year: Criteria() - object Blinds: Criteria() - //object TournamentFees: StaticCriteria() + object Limits: ListCriteria() + object TableSizes: ListCriteria() + object TournamentTypes: ListCriteria() + object MonthsOfYear: SimpleCriteria(List(12) { index -> QueryCondition.AnyMonthOfYear().apply { listOfValues = arrayListOf(index)} }) + object DaysOfWeek: SimpleCriteria(List(7) { index -> QueryCondition.AnyDayOfWeek().apply { listOfValues = arrayListOf(index + 1) } }) + object SessionTypes: SimpleCriteria(listOf(QueryCondition.IsCash, QueryCondition.IsTournament)) + object BankrollTypes: SimpleCriteria(listOf(QueryCondition.IsLive, QueryCondition.IsOnline)) + object DayPeriods: SimpleCriteria(listOf(QueryCondition.IsWeekDay, QueryCondition.IsWeekEnd)) + object Years: Criteria() + object Blinds: ListCriteria() + object TournamentFees: ListCriteria() val queryConditions: List get() { @@ -67,18 +69,19 @@ sealed class Criteria { is TournamentNames-> comparison() is Locations -> comparison() is SimpleCriteria -> comparison() - is Limits -> comparison() - is TournamentTypes -> comparison() - is TableSizes -> comparison() - is Year -> { - val years = arrayListOf() + is Limits -> comparison() + is TournamentTypes -> comparison() + is TableSizes -> comparison() + is TournamentFees -> comparison() + is Years -> { + val years = arrayListOf() val calendar = Calendar.getInstance() calendar.time = Date() val yearNow = calendar.get(Calendar.YEAR) val realm = Realm.getDefaultInstance() realm.where().sort("year", Sort.ASCENDING).findFirst()?.year?.let { for (index in 0..(yearNow - it)) { - years.add(QueryCondition.YEAR().apply { + years.add(QueryCondition.AnyYear().apply { listOfValues = arrayListOf(yearNow - index) }) } @@ -86,20 +89,7 @@ sealed class Criteria { realm.close() years } - is Blinds -> { - val blinds = arrayListOf() - val realm = Realm.getDefaultInstance() - val query = realm.where().distinct("blinds").findAll().sort("cgSmallBlind", Sort.ASCENDING) - query.map { - it.blinds?.let { stake -> - blinds.add(QueryCondition.BLIND().apply { - listOfValues = arrayListOf(stake) - }) - } - } - realm.close() - blinds - } + is Blinds -> comparison() else -> throw PokerAnalyticsException.QueryTypeUnhandled } } @@ -117,7 +107,7 @@ sealed class Criteria { return objects } - inline fun < reified S : QueryCondition.StaticDataQueryCondition > compare(values:List): List { + inline fun < reified S : QueryCondition.ListOfValueQueryCondition, T:Any > compareList(values:List): List { val objects = arrayListOf() values.forEach { objects.add((S::class.java.newInstance()).apply { 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 6e0d8010..975b250f 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 @@ -5,7 +5,6 @@ import io.realm.Sort import io.realm.kotlin.where import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.Criteria -import net.pokeranalytics.android.model.filter.Filterable import net.pokeranalytics.android.model.filter.QueryCondition import net.pokeranalytics.android.model.realm.* import java.util.* @@ -36,25 +35,25 @@ enum class Comparator { get() { return when (this) { TOURNAMENT_ENTRY_FEE -> { - val fees = arrayListOf() + val fees = arrayListOf() val realm = Realm.getDefaultInstance() - val fieldName = Session.fieldNameForQueryType(QueryCondition.BETWEEN_TOURNAMENT_FEE::class.java)!! + val fieldName = Session.fieldNameForQueryType(QueryCondition.BetweenTournamentFee::class.java)!! realm.where().distinct(fieldName).findAll().sort(fieldName, Sort.ASCENDING).map { it.tournamentEntryFee?.let { fee -> - fees.add(QueryCondition.BETWEEN_TOURNAMENT_FEE().apply { between(fee, fee) }) + fees.add(QueryCondition.BetweenTournamentFee().apply { between(fee, fee) }) } } realm.close() fees } - MONTH_OF_YEAR -> Criteria.monthOfYear.queryConditions - DAY_OF_WEEK -> Criteria.dayOfWeek.queryConditions - YEAR -> Criteria.Year.queryConditions - DAY_PERIOD -> Criteria.dayPeriod.queryConditions - CASH -> listOf(QueryCondition.CASH) - TOURNAMENT -> listOf(QueryCondition.TOURNAMENT) - LIVE -> listOf(QueryCondition.LIVE) - ONLINE -> listOf(QueryCondition.ONLINE) + MONTH_OF_YEAR -> Criteria.MonthsOfYear.queryConditions + DAY_OF_WEEK -> Criteria.DaysOfWeek.queryConditions + YEAR -> Criteria.Years.queryConditions + DAY_PERIOD -> Criteria.DayPeriods.queryConditions + CASH -> listOf(QueryCondition.IsCash) + TOURNAMENT -> listOf(QueryCondition.IsTournament) + LIVE -> listOf(QueryCondition.IsLive) + ONLINE -> listOf(QueryCondition.IsOnline) BLIND -> Criteria.Blinds.queryConditions BANKROLL -> Criteria.Bankrolls.queryConditions GAME -> Criteria.Games.queryConditions 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 65a390c6..9cb8ae53 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 @@ -12,7 +12,6 @@ import net.pokeranalytics.android.model.TournamentType import net.pokeranalytics.android.model.interfaces.Identifiable import net.pokeranalytics.android.model.interfaces.NameManageable import net.pokeranalytics.android.model.realm.* -import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow import net.pokeranalytics.android.util.NULL_TEXT @@ -41,8 +40,6 @@ inline fun List.queryWith(query: RealmQ /** * Enum describing the way a query should be handled * Some queries requires a value to be checked upon through equals, in, more, less, between - * To handle that, the enum has a public [valueMap] variable - * A new type should also set the expected numericValues required in the [filterValuesExpectedKeys] */ sealed class QueryCondition : FilterElementRow { @@ -56,11 +53,11 @@ sealed class QueryCondition : FilterElementRow { inline fun getInstance(): QueryCondition { return when (T::class.java) { - Bankroll::class.java -> BANKROLL() - Game::class.java -> GAME() - Location::class.java -> LOCATION() - TournamentName::class.java -> TOURNAMENT_NAME() - TournamentFeature::class.java -> ANY_TOURNAMENT_FEATURES() + AnyBankroll::class.java -> AnyBankroll() + Game::class.java -> AnyGame() + Location::class.java -> AnyLocation() + TournamentName::class.java -> AnyTournamentName() + TournamentFeature::class.java -> AnyTournamentFeature() else -> throw PokerAnalyticsException.QueryTypeUnhandled } } @@ -129,7 +126,7 @@ sealed class QueryCondition : FilterElementRow { return when (this) { is StaticDataQueryCondition -> label() is QueryDataCondition<*> -> label() - is BLIND -> label() + is AnyBlind -> label() else -> baseId } } @@ -138,12 +135,9 @@ sealed class QueryCondition : FilterElementRow { abstract class QueryDataCondition < T: NameManageable > : QueryCondition(), ListOfString { fun setObject(dataObject: T) { - this.dataObject = dataObject this.listOfValues.add(dataObject.id) } - var dataObject: NameManageable? = null - override var listOfValues = ArrayList() abstract val entity : Class @@ -161,7 +155,7 @@ sealed class QueryCondition : FilterElementRow { return completeLabel } - fun labelForValue(realm:Realm, value:String): String { + private fun labelForValue(realm:Realm, value:String): String { val query = realm.where(entity) return query.equalTo("id", value).findFirst()?.name ?: NULL_TEXT } @@ -171,10 +165,9 @@ sealed class QueryCondition : FilterElementRow { override var singleValue: Int = 0 } - abstract class StaticDataQueryCondition : QueryCondition(), ListOfInt { - var data : RowRepresentable? = null - override var listOfValues = ArrayList() - abstract fun labelForValue(value:Int): String + abstract class ListOfValueQueryCondition < T: Any > : QueryCondition(), ListOfValues { + override var listOfValues = ArrayList() + abstract fun labelForValue(value:T): String fun label(): String { return when (listOfValues.size) { @@ -185,6 +178,10 @@ sealed class QueryCondition : FilterElementRow { } } + abstract class StaticDataQueryCondition : ListOfValueQueryCondition() { + override var listOfValues = ArrayList() + } + open class OperationQueryCondition : QueryCondition() open class DurationOperationQueryCondition : OperationQueryCondition(), Duration { @@ -215,122 +212,120 @@ sealed class QueryCondition : FilterElementRow { override val showTime: Boolean = true } - object LIVE : QueryCondition() - object CASH : QueryCondition() - object ONLINE : QueryCondition() - object TOURNAMENT: QueryCondition() - class BANKROLL: QueryDataCondition() { override val entity: Class = Bankroll::class.java } - class GAME: QueryDataCondition() { override val entity: Class = Game::class.java } - class TOURNAMENT_NAME: QueryDataCondition() { override val entity: Class = TournamentName::class.java } - class ANY_TOURNAMENT_FEATURES: QueryDataCondition() { override val entity: Class = TournamentFeature::class.java } - class ALL_TOURNAMENT_FEATURES: QueryDataCondition() { override val entity: Class = TournamentFeature::class.java } - class LOCATION: QueryDataCondition() { override val entity: Class = Location::class.java } - - class LIMIT: StaticDataQueryCondition() { + object IsLive : QueryCondition() + object IsCash : QueryCondition() + object IsOnline : QueryCondition() + object IsTournament : QueryCondition() + class AnyBankroll: QueryDataCondition() { override val entity: Class = Bankroll::class.java } + class AnyGame: QueryDataCondition() { override val entity: Class = Game::class.java } + class AnyTournamentName: QueryDataCondition() { override val entity: Class = TournamentName::class.java } + class AnyTournamentFeature: QueryDataCondition() { override val entity: Class = TournamentFeature::class.java } + class AllTournamentFeature: QueryDataCondition() { override val entity: Class = TournamentFeature::class.java } + class AnyLocation: QueryDataCondition() { override val entity: Class = Location::class.java } + + class AnyLimit: StaticDataQueryCondition() { override fun labelForValue(value: Int): String { return Limit.values()[value].getDisplayName() } } - class TABLE_SIZE: StaticDataQueryCondition() { + class AnyTableSize: StaticDataQueryCondition() { override fun labelForValue(value: Int): String { return TableSize(value).getDisplayName() } } - class TOURNAMENT_TYPE: StaticDataQueryCondition() { + class AnyTournamentType: StaticDataQueryCondition() { override fun labelForValue(value: Int): String { return TournamentType.values()[value].getDisplayName() } } - class BLIND: QueryCondition(), ListOfString { + class AnyBlind: ListOfValueQueryCondition() { override var listOfValues = ArrayList() - - fun label(): String { - val completeLabel = when (listOfValues.size) { - 0 -> return NULL_TEXT - 1,2 -> { - return listOfValues.map { it }.joinToString(", ") - } - else -> "${listOfValues.size} $baseId" - } - return completeLabel - } + override fun labelForValue(value:String): String { return value } } - class LAST_GAMES: SingleValueQueryCondition() - class LAST_SESSIONS: SingleValueQueryCondition() + class LastGame: SingleValueQueryCondition() + class LastSession: SingleValueQueryCondition() + - class MORE_NUMBER_OF_TABLE: OperationQueryCondition(), More - class LESS_NUMBER_OF_TABLE: OperationQueryCondition(), Less - class BETWEEN_NUMBER_OF_TABLE: BetweenQueryCondition(), Between + class MoreNumberOfTable: OperationQueryCondition(), More + class LessNumberOfTable: OperationQueryCondition(), Less + class BetweenNumberOfTable: BetweenQueryCondition(), Between - class MORE_THAN_NET_RESULT: AmountOperationQueryCondition(), More - class LESS_THAN_NET_RESULT: AmountOperationQueryCondition(), Less + class MoreNetResult: AmountOperationQueryCondition(), More + class LessNetResult: AmountOperationQueryCondition(), Less - class MORE_THAN_BUY_IN: AmountOperationQueryCondition(), More - class LESS_THAN_BUY_IN: AmountOperationQueryCondition(), Less + class MoreBuyIn: AmountOperationQueryCondition(), More + class LessBuyIn: AmountOperationQueryCondition(), Less - class MORE_THAN_CASH_OUT: AmountOperationQueryCondition(), More - class LESS_THAN_CASH_OUT: AmountOperationQueryCondition(), Less + class MoreCashOut: AmountOperationQueryCondition(), More + class LessCashOut: AmountOperationQueryCondition(), Less - class MORE_THAN_TIPS: AmountOperationQueryCondition(), More - class LESS_THAN_TIPS: AmountOperationQueryCondition(), Less + class MoreTips: AmountOperationQueryCondition(), More + class LessTips: AmountOperationQueryCondition(), Less - class MORE_THAN_NUMBER_OF_PLAYER: OperationQueryCondition(), More - class LESS_THAN_NUMBER_OF_PLAYER: OperationQueryCondition(), Less - class BETWEEN_NUMBER_OF_PLAYER: BetweenQueryCondition(), Between + class MoreNumberOfPlayer: OperationQueryCondition(), More + class LessNumberOfPlayer: OperationQueryCondition(), Less + class BetweenNumberOfPlayer: BetweenQueryCondition(), Between - class MORE_THAN_TOURNAMENT_FEE: OperationQueryCondition(), More - class LESS_THAN_TOURNAMENT_FEE: OperationQueryCondition(), Less - class BETWEEN_TOURNAMENT_FEE: BetweenQueryCondition(), BetweenRightExclusive { + class MoreTournamentFee: OperationQueryCondition(), More + class LessTournamentFee: OperationQueryCondition(), Less + class BetweenTournamentFee: BetweenQueryCondition(), BetweenRightExclusive { fun between(leftValue:Double, rightValue:Double) { listOfValues = arrayListOf(leftValue, rightValue) } } - class MIN_RE_BUY: AmountOperationQueryCondition(), More - class MAX_RE_BUY: AmountOperationQueryCondition(), Less + class MoreRebuy: AmountOperationQueryCondition(), More + class LessRebuy: AmountOperationQueryCondition(), Less - class STARTED_FROM_DATE: DateQuery() - class STARTED_TO_DATE: DateQuery(), Less - class ENDED_FROM_DATE: DateQuery() - class ENDED_TO_DATE: DateQuery(), Less + class StartedFromDate: DateQuery() + class StartedToDate: DateQuery(), Less + class EndedFromDate: DateQuery() + class EndedToDate: DateQuery(), Less - class DAY_OF_WEEK: StaticDataQueryCondition() { + class AnyDayOfWeek: StaticDataQueryCondition() { override fun labelForValue(value: Int): String { return DateFormatSymbols.getInstance(Locale.getDefault()).weekdays[value] } } - class MONTH: StaticDataQueryCondition() { + class AnyMonthOfYear: StaticDataQueryCondition() { override fun labelForValue(value: Int): String { return DateFormatSymbols.getInstance(Locale.getDefault()).months[value] } } - class YEAR: StaticDataQueryCondition() { + class AnyYear: StaticDataQueryCondition() { override fun labelForValue(value: Int): String { return "$value" } } - object WEEK_DAY: QueryCondition() - object WEEK_END: QueryCondition() - object TODAY: QueryCondition() - object YESTERDAY: QueryCondition() - object TODAY_AND_YESTERDAY: QueryCondition() - object THIS_WEEK: QueryCondition() - object THIS_MONTH: QueryCondition() - object THIS_YEAR: QueryCondition() - class PAST_DAYS: SingleValueQueryCondition() - class MORE_THAN_DURATION: DurationOperationQueryCondition(), More - class LESS_THAN_DURATION: DurationOperationQueryCondition(), Less - class STARTED_FROM_TIME: TimeQuery() - class ENDED_TO_TIME: TimeQuery(), Less - - class COMMENT: QueryCondition() + object IsWeekDay: QueryCondition() + object IsWeekEnd: QueryCondition() + object IsToday: QueryCondition() + object WasYesterday: QueryCondition() + object WasTodayAndYesterday: QueryCondition() + object DuringThisWeek: QueryCondition() + object DuringThisMonth: QueryCondition() + object DuringThisYear: QueryCondition() + + object TournamentFee: ListOfValueQueryCondition() { + override fun labelForValue(value: Double): String { + return "$value" + } + } + + class PastDay: SingleValueQueryCondition() + class MoreDuration: DurationOperationQueryCondition(), More + class LessDuration: DurationOperationQueryCondition(), Less + class StartedFromTime: TimeQuery() + class EndedToTime: TimeQuery(), Less + + class HasComment: QueryCondition() /** * main method of the enum @@ -350,16 +345,17 @@ sealed class QueryCondition : FilterElementRow { 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 -> { + IsLive, IsOnline -> realmQuery.equalTo(fieldName, this == IsLive) + IsCash -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) + IsTournament -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal) + is AllTournamentFeature -> { listOfValues.forEach { realmQuery.equalTo(fieldName, it) } realmQuery } - is BLIND -> realmQuery.`in`(fieldName, listOfValues.toTypedArray()) + is AnyBlind -> realmQuery.`in`(fieldName, listOfValues.toTypedArray()) + is TournamentFee -> realmQuery.`in`(fieldName, listOfValues.toTypedArray()) is QueryDataCondition<*> -> realmQuery.`in`(fieldName, listOfValues.toTypedArray()) is StaticDataQueryCondition -> realmQuery.`in`(fieldName, listOfValues.toTypedArray()) is DateQuery -> { @@ -370,45 +366,45 @@ sealed class QueryCondition : FilterElementRow { } } is SingleValueQueryCondition -> realmQuery.equalTo(fieldName, singleValue) - WEEK_END, WEEK_DAY -> { + IsWeekEnd, IsWeekDay -> { var query = realmQuery - if (this == WEEK_DAY) { + if (this == IsWeekDay) { query = realmQuery.not() } query.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY)) } - TODAY -> { + IsToday -> { val startDate = Date() realmQuery.between(fieldName, startDate.startOfDay(), startDate.endOfDay()) } - TODAY_AND_YESTERDAY-> { + WasTodayAndYesterday-> { val startDate = Date() val calendar = Calendar.getInstance() calendar.time = startDate calendar.add(Calendar.HOUR_OF_DAY, -24) realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) } - YESTERDAY -> { + WasYesterday -> { val calendar = Calendar.getInstance() calendar.time = Date() calendar.add(Calendar.HOUR_OF_DAY, -24) realmQuery.between(fieldName, calendar.time.startOfDay(), calendar.time.endOfDay()) } - THIS_WEEK -> { + DuringThisWeek -> { val startDate = Date() val calendar = Calendar.getInstance() calendar.time = startDate calendar.set(Calendar.DAY_OF_WEEK_IN_MONTH, Calendar.SUNDAY) realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) } - THIS_MONTH -> { + DuringThisMonth -> { val startDate = Date() val calendar = Calendar.getInstance() calendar.time = startDate calendar.set(Calendar.DAY_OF_MONTH, 1) realmQuery.between(fieldName, calendar.time.startOfDay(), startDate.endOfDay()) } - THIS_YEAR -> { + DuringThisYear -> { val startDate = Date() val calendar = Calendar.getInstance() calendar.time = startDate @@ -429,6 +425,9 @@ sealed class QueryCondition : FilterElementRow { is SingleDate -> singleValue = filterCondition.getValue() is SingleInt -> singleValue = filterCondition.getValue() is SingleDouble -> singleValue = filterCondition.getValue() + //TODO POURQUOI ? + is AnyBlind -> listOfValues = filterCondition.getValues() + is StaticDataQueryCondition -> listOfValues = filterCondition.getValues() } } 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 7498cbb0..bd58a593 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 @@ -25,6 +25,9 @@ open class FilterCondition() : RealmObject() { is QueryCondition.ListOfDouble -> this.setValues(filterElementRows.flatMap { (it as QueryCondition.ListOfDouble).listOfValues }) is QueryCondition.ListOfInt -> this.setValues(filterElementRows.flatMap { (it as QueryCondition.ListOfInt).listOfValues }) is QueryCondition.ListOfString -> this.setValues(filterElementRows.flatMap { (it as QueryCondition.ListOfString).listOfValues }) + //TODO POURQUOI ? + is QueryCondition.StaticDataQueryCondition -> this.setValues(filterElementRows.flatMap { (it as QueryCondition.StaticDataQueryCondition).listOfValues }) + is QueryCondition.AnyBlind -> this.setValues(filterElementRows.flatMap { (it as QueryCondition.AnyBlind).listOfValues }) } } @@ -46,6 +49,7 @@ open class FilterCondition() : RealmObject() { var stringValue: String? = null inline fun getValues(): ArrayList < T > { + println("<<<< r $stringValues") return when (T::class) { Int::class -> ArrayList().apply { intValues?.map { add(it as T) } } Double::class -> ArrayList().apply { doubleValues?.map { add(it as T) } } diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt index 0b1e53bb..1d72ae2a 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt @@ -67,31 +67,31 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat fun fieldNameForQueryType(queryCondition: Class < out QueryCondition >): String? { return when (queryCondition) { - LIVE::class.java, ONLINE::class.java -> "bankroll.live" - CASH::class.java, TOURNAMENT::class.java -> "type" - BANKROLL::class.java -> "bankroll.id" - GAME::class.java -> "game.id" - TOURNAMENT_NAME::class.java -> "tournamentName.id" - ANY_TOURNAMENT_FEATURES::class.java, ALL_TOURNAMENT_FEATURES::class.java -> "tournamentFeatures.id" - LOCATION::class.java -> "location.id" - LIMIT::class.java -> "limit" - TABLE_SIZE::class.java -> "tableSize" - TOURNAMENT_TYPE::class.java -> "tournamentType" - BLIND::class.java -> "blinds" - COMMENT::class.java -> "comment" - BETWEEN_NUMBER_OF_TABLE::class.java, MORE_NUMBER_OF_TABLE::class.java, LESS_NUMBER_OF_TABLE::class.java -> "numberOfTable" - MORE_THAN_NET_RESULT::class.java, LESS_THAN_NET_RESULT::class.java -> "computableResults.ratedNet" - MORE_THAN_BUY_IN::class.java, LESS_THAN_BUY_IN::class.java -> "result.buyin" - MORE_THAN_CASH_OUT::class.java, LESS_THAN_CASH_OUT::class.java -> "result.cashout" - MORE_THAN_TIPS::class.java, LESS_THAN_TIPS::class.java -> "result.tips" - MORE_THAN_NUMBER_OF_PLAYER::class.java, LESS_THAN_NUMBER_OF_PLAYER::class.java, BETWEEN_NUMBER_OF_PLAYER::class.java -> "tournamentNumberOfPlayers" - MORE_THAN_TOURNAMENT_FEE::class.java, LESS_THAN_TOURNAMENT_FEE::class.java, BETWEEN_TOURNAMENT_FEE::class.java -> "tournamentEntryFee" - STARTED_FROM_DATE::class.java, STARTED_TO_DATE::class.java -> "startDate" - ENDED_FROM_DATE::class.java, ENDED_TO_DATE::class.java -> "endDate" - DAY_OF_WEEK::class.java, WEEK_END::class.java, WEEK_DAY::class.java -> "dayOfWeek" - MONTH::class.java -> "month" - YEAR::class.java -> "year" - TODAY::class.java, YESTERDAY::class.java, TODAY_AND_YESTERDAY::class.java, THIS_YEAR::class.java, THIS_MONTH::class.java, THIS_WEEK::class.java -> "startDate" + IsLive::class.java, IsOnline::class.java -> "bankroll.live" + IsCash::class.java, IsTournament::class.java -> "type" + AnyBankroll::class.java -> "bankroll.id" + AnyGame::class.java -> "game.id" + AnyTournamentName::class.java -> "tournamentName.id" + AnyTournamentFeature::class.java, AllTournamentFeature::class.java -> "tournamentFeatures.id" + AnyLocation::class.java -> "location.id" + AnyLimit::class.java -> "limit" + AnyTableSize::class.java -> "tableSize" + AnyTournamentType::class.java -> "tournamentType" + AnyBlind::class.java -> "blinds" + HasComment::class.java -> "comment" + BetweenNumberOfTable::class.java, MoreNumberOfTable::class.java, LessNumberOfTable::class.java -> "numberOfTable" + MoreNetResult::class.java, LessNetResult::class.java -> "computableResults.ratedNet" + MoreBuyIn::class.java, LessBuyIn::class.java -> "result.buyin" + MoreCashOut::class.java, LessCashOut::class.java -> "result.cashout" + MoreTips::class.java, LessTips::class.java -> "result.tips" + MoreNumberOfPlayer::class.java, LessNumberOfPlayer::class.java, BetweenNumberOfPlayer::class.java -> "tournamentNumberOfPlayers" + TournamentFee::class.java, MoreTournamentFee::class.java, LessTournamentFee::class.java, BetweenTournamentFee::class.java -> "tournamentEntryFee" + StartedFromDate::class.java, StartedToDate::class.java -> "startDate" + EndedFromDate::class.java, EndedToDate::class.java -> "endDate" + AnyDayOfWeek::class.java, IsWeekEnd::class.java, IsWeekDay::class.java -> "dayOfWeek" + AnyMonthOfYear::class.java -> "month" + AnyYear::class.java -> "year" + IsToday::class.java, WasYesterday::class.java, WasTodayAndYesterday::class.java, DuringThisYear::class.java, DuringThisMonth::class.java, DuringThisWeek::class.java -> "startDate" else -> null } } @@ -306,7 +306,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat */ val bbNet: BB get() { - val bb = this.cgBigBlind; + val bb = this.cgBigBlind val result = this.result if (bb != null && result != null) { return result.net / bb diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarDetailsFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarDetailsFragment.kt index 7d277cfc..11c66e02 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarDetailsFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarDetailsFragment.kt @@ -98,8 +98,8 @@ class CalendarDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresentable override fun onTabSelected(tab: TabLayout.Tab) { when (tab.position) { 0 -> sessionTypeCondition = null - 1 -> sessionTypeCondition = QueryCondition.CASH - 2 -> sessionTypeCondition = QueryCondition.TOURNAMENT + 1 -> sessionTypeCondition = QueryCondition.IsCash + 2 -> sessionTypeCondition = QueryCondition.IsTournament } launchStatComputation() } @@ -134,8 +134,8 @@ class CalendarDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresentable sessionTypeCondition?.let { when (it) { - QueryCondition.CASH -> tabs.getTabAt(1)?.select() - QueryCondition.TOURNAMENT -> tabs.getTabAt(2)?.select() + QueryCondition.IsCash -> tabs.getTabAt(1)?.select() + QueryCondition.IsTournament -> tabs.getTabAt(2)?.select() else -> tabs.getTabAt(0)?.select() } } @@ -166,8 +166,8 @@ class CalendarDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresentable removeAll(Comparator.TOURNAMENT.queryConditions) when (sessionTypeCondition) { - QueryCondition.CASH -> addAll(Comparator.CASH.queryConditions) - QueryCondition.TOURNAMENT -> addAll(Comparator.TOURNAMENT.queryConditions) + QueryCondition.IsCash -> addAll(Comparator.CASH.queryConditions) + QueryCondition.IsTournament -> addAll(Comparator.TOURNAMENT.queryConditions) } } 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 0d374730..76aeaf7e 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 @@ -164,21 +164,21 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep } filterSessionCash.setOnCheckedChangeListener { _, isChecked -> if (isChecked) { - sessionTypeCondition = QueryCondition.CASH + sessionTypeCondition = QueryCondition.IsCash filterSessionAll.isChecked = false filterSessionTournament.isChecked = false launchStatComputation() - } else if (sessionTypeCondition == QueryCondition.CASH) { + } else if (sessionTypeCondition == QueryCondition.IsCash) { filterSessionCash.isChecked = true } } filterSessionTournament.setOnCheckedChangeListener { _, isChecked -> if (isChecked) { - sessionTypeCondition = QueryCondition.TOURNAMENT + sessionTypeCondition = QueryCondition.IsTournament filterSessionAll.isChecked = false filterSessionCash.isChecked = false launchStatComputation() - } else if (sessionTypeCondition == QueryCondition.TOURNAMENT) { + } else if (sessionTypeCondition == QueryCondition.IsTournament) { filterSessionTournament.isChecked = true } } @@ -238,13 +238,13 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep val requiredStats: List = listOf(Stat.LOCATIONS_PLAYED, Stat.LONGEST_STREAKS, Stat.DAYS_PLAYED, Stat.STANDARD_DEVIATION_HOURLY ) val options = Calculator.Options(evolutionValues = Calculator.Options.EvolutionValues.STANDARD, stats = requiredStats) - // Compute data per YEAR and MONTH + // Compute data per AnyYear and AnyMonthOfYear println(">>>> ${Comparator.MONTH_OF_YEAR.queryConditions.map { it.id }}") val monthConditions = when (sessionTypeCondition) { - QueryCondition.CASH -> listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR, Comparator.CASH).combined() - QueryCondition.TOURNAMENT -> listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR, Comparator.TOURNAMENT).combined() + QueryCondition.IsCash -> listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR, Comparator.CASH).combined() + QueryCondition.IsTournament -> listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR, Comparator.TOURNAMENT).combined() else -> listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR).combined() } @@ -256,8 +256,8 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep // Set date data conditions.forEach { condition -> when (condition) { - is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.listOfValues.first()) - is QueryCondition.MONTH -> calendar.set(Calendar.MONTH, condition.listOfValues.first()) + is QueryCondition.AnyYear -> calendar.set(Calendar.YEAR, condition.listOfValues.first()) + is QueryCondition.AnyMonthOfYear -> calendar.set(Calendar.MONTH, condition.listOfValues.first()) } } @@ -268,10 +268,10 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep calendar.time = Date().startOfYear() - // Compute data per YEAR + // Compute data per AnyYear val yearConditions = when (sessionTypeCondition) { - QueryCondition.CASH -> listOf(Comparator.YEAR, Comparator.CASH).combined() - QueryCondition.TOURNAMENT -> listOf(Comparator.YEAR, Comparator.TOURNAMENT).combined() + QueryCondition.IsCash -> listOf(Comparator.YEAR, Comparator.CASH).combined() + QueryCondition.IsTournament -> listOf(Comparator.YEAR, Comparator.TOURNAMENT).combined() else -> listOf(Comparator.YEAR).combined() } @@ -282,7 +282,7 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep // Set date data conditions.forEach { condition -> when (condition) { - is QueryCondition.YEAR -> calendar.set(Calendar.YEAR, condition.listOfValues.first()) + is QueryCondition.AnyYear -> calendar.set(Calendar.YEAR, condition.listOfValues.first()) } } yearlyReports[calendar.time] = computedResults @@ -297,7 +297,7 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep // Logs /* - Timber.d("========== YEAR x MONTH") + Timber.d("========== AnyYear x AnyMonthOfYear") sortedMonthlyReports.keys.forEach { Timber.d("$it => ${sortedMonthlyReports[it]?.computedStat(Stat.NET_RESULT)?.value}") } diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/StatisticsFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/StatisticsFragment.kt index 285f76f5..37b5d8c9 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/StatisticsFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/StatisticsFragment.kt @@ -132,10 +132,10 @@ class StatisticsFragment : TableReportFragment() { Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN ) - val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.CASH), cgStats) + val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.IsCash), cgStats) val tStats: List = listOf(Stat.NET_RESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN) - val tSessionGroup = ComputableGroup(stringTournament, listOf(QueryCondition.TOURNAMENT), tStats) + val tSessionGroup = ComputableGroup(stringTournament, listOf(QueryCondition.IsTournament), tStats) Timber.d(">>>>> Start computations...") 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 013e1b34..b89079fa 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 @@ -13,25 +13,25 @@ interface FilterElementRow : RowRepresentable { 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.IsCash -> R.string.cash_game + is QueryCondition.IsTournament -> R.string.tournament + is QueryCondition.IsToday -> R.string.today + is QueryCondition.WasYesterday -> R.string.yesterday + is QueryCondition.WasTodayAndYesterday -> R.string.yesterday_and_today + is QueryCondition.DuringThisWeek -> R.string.current_week + is QueryCondition.DuringThisMonth -> R.string.current_month + is QueryCondition.DuringThisYear -> R.string.current_year + is QueryCondition.StartedFromTime, is QueryCondition.StartedFromDate -> R.string.from + is QueryCondition.EndedToDate, is QueryCondition.EndedToTime-> R.string.to + is QueryCondition.IsLive -> R.string.live + is QueryCondition.IsOnline -> R.string.online + is QueryCondition.IsWeekDay -> R.string.week_days + is QueryCondition.IsWeekEnd -> R.string.weekend + is QueryCondition.PastDay -> R.string.period_in_days + is QueryCondition.LastGame -> R.string.last_records + is QueryCondition.LastSession -> R.string.last_sessions + is QueryCondition.MoreRebuy -> R.string.minimum + is QueryCondition.LessRebuy -> R.string.maximum is QueryCondition.More -> R.string.more_than is QueryCondition.Less -> R.string.less_than else -> null @@ -41,8 +41,8 @@ interface FilterElementRow : RowRepresentable { 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 + is QueryCondition.PastDay, is QueryCondition.StartedFromDate, is QueryCondition.EndedToDate, is QueryCondition.StartedFromTime, is QueryCondition.EndedToTime, is QueryCondition.LastGame, is QueryCondition.LastSession, is QueryCondition.LessRebuy, is QueryCondition.MoreRebuy, + is QueryCondition.MoreDuration, is QueryCondition.LessDuration-> RowViewType.TITLE_VALUE_CHECK.ordinal else -> RowViewType.TITLE_CHECK.ordinal } } @@ -50,8 +50,8 @@ interface FilterElementRow : RowRepresentable { 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 + is QueryCondition.PastDay, is QueryCondition.LastGame, is QueryCondition.LastSession, is QueryCondition.LessRebuy, is QueryCondition.MoreRebuy-> BottomSheetType.EDIT_TEXT + is QueryCondition.MoreDuration, is QueryCondition.LessDuration-> BottomSheetType.DOUBLE_EDIT_TEXT else -> BottomSheetType.NONE } } 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 2bd511e4..7e6e5fd9 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 @@ -1,20 +1,10 @@ package net.pokeranalytics.android.ui.view.rowrepresentable -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 -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.* -import net.pokeranalytics.android.util.extensions.endOfDay -import net.pokeranalytics.android.util.extensions.startOfDay -import java.text.DateFormatSymbols -import java.util.* enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { CASH_TOURNAMENT(net.pokeranalytics.android.R.string.cash_or_tournament), @@ -68,29 +58,29 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { when (this@FilterSectionRow) { // General - CASH_TOURNAMENT -> Criteria.SessionType.queryConditions - LIVE_ONLINE -> Criteria.BankrollType.queryConditions + CASH_TOURNAMENT -> Criteria.SessionTypes.queryConditions + LIVE_ONLINE -> Criteria.BankrollTypes.queryConditions GAME -> Criteria.Games.queryConditions LIMIT_TYPE -> Criteria.Limits.queryConditions TABLE_SIZE -> Criteria.TableSizes.queryConditions // Date DYNAMIC_DATE -> arrayListOf( - QueryCondition.TODAY, - QueryCondition.YESTERDAY, - QueryCondition.TODAY_AND_YESTERDAY, - QueryCondition.THIS_WEEK, - QueryCondition.THIS_MONTH, - QueryCondition.THIS_YEAR + QueryCondition.IsToday, + QueryCondition.WasYesterday, + QueryCondition.WasTodayAndYesterday, + QueryCondition.DuringThisWeek, + QueryCondition.DuringThisMonth, + QueryCondition.DuringThisYear ) - FIXED_DATE -> arrayListOf(QueryCondition.STARTED_FROM_DATE(), QueryCondition.ENDED_TO_DATE()) - DURATION -> arrayListOf(QueryCondition.PAST_DAYS()) - WEEKDAYS_OR_WEEKEND -> arrayListOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END) - YEAR -> Criteria.Year.queryConditions - DAY_OF_WEEK -> Criteria.dayOfWeek.queryConditions - MONTH_OF_YEAR -> Criteria.monthOfYear.queryConditions + FIXED_DATE -> arrayListOf(QueryCondition.StartedFromDate(), QueryCondition.EndedToDate()) + DURATION -> arrayListOf(QueryCondition.PastDay()) + WEEKDAYS_OR_WEEKEND -> arrayListOf(QueryCondition.IsWeekDay, QueryCondition.IsWeekEnd) + YEAR -> Criteria.Years.queryConditions + DAY_OF_WEEK -> Criteria.DaysOfWeek.queryConditions + MONTH_OF_YEAR -> Criteria.MonthsOfYear.queryConditions // Duration - SESSION_DURATION -> arrayListOf(QueryCondition.MORE_THAN_DURATION(), QueryCondition.LESS_THAN_DURATION() as QueryCondition) + SESSION_DURATION -> arrayListOf(QueryCondition.MoreDuration(), QueryCondition.LessDuration() as QueryCondition) /* RANGE -> { val fromTime = FromTime @@ -101,13 +91,13 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable { }*/ // Sessions - SESSIONS -> arrayListOf(QueryCondition.LAST_GAMES(), QueryCondition.LAST_SESSIONS()) + SESSIONS -> arrayListOf(QueryCondition.LastGame(), QueryCondition.LastSession()) // Cash BLIND -> Criteria.Blinds.queryConditions CASH_RE_BUY_COUNT -> arrayListOf( - QueryCondition.MAX_RE_BUY(), - QueryCondition.MIN_RE_BUY() as QueryCondition + QueryCondition.LessRebuy(), + QueryCondition.MoreRebuy() as QueryCondition ) // Tournament