From bdd1ac92c59acacc81a47043490af0465214fd99 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 16:58:57 +0200 Subject: [PATCH 01/10] Fixing most tests --- app/build.gradle | 9 +- .../filter/BlindFilterInstrumentedTest.kt | 31 ++--- .../filter/DateFilterInstrumentedUnitTest.kt | 63 +++------- .../filter/ExceptionFilterInstrumentedTest.kt | 7 +- .../filter/RealmFilterInstrumentedUnitTest.kt | 2 +- .../SessionFilterInstrumentedUnitTest.kt | 114 +++--------------- .../android/calculus/Calculator.kt | 19 +-- .../android/model/filter/Filterable.kt | 23 ++-- .../android/model/filter/QueryType.kt | 14 ++- .../android/model/realm/ComputableResult.kt | 13 +- .../android/model/realm/Filter.kt | 26 +--- .../android/model/realm/Session.kt | 10 +- .../android/model/realm/SessionSet.kt | 3 +- 13 files changed, 103 insertions(+), 231 deletions(-) diff --git a/app/build.gradle b/app/build.gradle index 2d45b169..8b4b7320 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -47,7 +47,12 @@ android { dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) + + // Kotlin implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version" + implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1' + implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1" + implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version" // Android implementation 'androidx.appcompat:appcompat:1.0.2' @@ -72,10 +77,6 @@ dependencies { // Crashlytics implementation 'com.crashlytics.sdk.android:crashlytics:2.9.9' - // Kotlin - implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1' - implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1" - // Logs implementation 'com.jakewharton.timber:timber:4.7.1' 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 76f7c100..010ff3bb 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 @@ -2,7 +2,10 @@ package net.pokeranalytics.android.unitTests.filter import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest import net.pokeranalytics.android.model.filter.QueryType -import net.pokeranalytics.android.model.realm.* +import net.pokeranalytics.android.model.realm.Bankroll +import net.pokeranalytics.android.model.realm.Filter +import net.pokeranalytics.android.model.realm.FilterElement +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 @@ -45,11 +48,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterElement(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + + + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(2, sessions.size) sessions.map { @@ -92,11 +93,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterElement(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(2, sessions.size) sessions.map { @@ -139,11 +136,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterElement(filterElementRows = arrayListOf(blind)) filter.updateValueMap(filterElement) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions.map { @@ -188,11 +181,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterElement(filterElementRows = arrayListOf(blind1, blind2)) filter.updateValueMap(filterElement) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(2, sessions.size) sessions.map { 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 72cb5304..e83c16f0 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 @@ -37,11 +37,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterElement(filterElementRow) filter.updateValueMap(filterElement) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -70,11 +66,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterElement(filterElementRow) filter.updateValueMap(filterElement) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -102,11 +94,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filterElement = FilterElement(filterElementRow) filter.updateValueMap(filterElement) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -128,11 +116,8 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, cal.time) realm.commitTransaction() - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(QueryType.WEEK_END) - ) + + val sessions = Filter.queryOn(realm, arrayListOf(QueryType.WEEK_END)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -145,19 +130,19 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val realm = this.mockRealm realm.beginTransaction() + val cal = Calendar.getInstance() cal.time = Date() + cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY) val s1 = Session.testInstance(100.0, false, cal.time) + cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY) - Session.testInstance(100.0, true, cal.time) + realm.commitTransaction() - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(QueryType.WEEK_DAY) - ) + + val sessions = Filter.queryOn(realm, arrayListOf(QueryType.WEEK_DAY)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -185,12 +170,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterElement(filterElementRow)) - - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -218,11 +198,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterElement(filterElementRow)) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -251,11 +227,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterElement(filterElementRow)) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -284,12 +256,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filter.updateValueMap(FilterElement(filterElementRow)) - - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/ExceptionFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/ExceptionFilterInstrumentedTest.kt index 443af000..1d08c36a 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/ExceptionFilterInstrumentedTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/ExceptionFilterInstrumentedTest.kt @@ -20,11 +20,8 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() { filter.updateValueMap(filterElement) val realm = this.mockRealm - Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + Filter.queryOn(realm, arrayListOf(filter)) + } @Test(expected = PokerAnalyticsException.FilterElementUnknownName::class) 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 0b68f9e2..6e2fdd72 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 @@ -51,7 +51,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val newRealm = this.mockRealm newRealm.where(Filter::class.java).equalTo("name", "testSaveLoadCashFilter").findFirst()?.let { foundFilter -> - val sessions = foundFilter.results() + val sessions = foundFilter.results() Assert.assertEquals(1, sessions.size) sessions[0]?.run { 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 66e119d1..3569e364 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 @@ -26,11 +26,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1) realm.commitTransaction() - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(QueryType.CASH) - ) + val sessions = Filter.queryOn(realm, arrayListOf(QueryType.CASH)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -48,11 +44,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1) realm.commitTransaction() - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(QueryType.TOURNAMENT) - ) + val sessions = Filter.queryOn(realm, arrayListOf(QueryType.TOURNAMENT)) Assert.assertEquals(1, sessions.size) sessions[0]?.run { @@ -75,11 +67,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1, b2) realm.commitTransaction() - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(QueryType.LIVE) - ) + val sessions = Filter.queryOn(realm, arrayListOf(QueryType.LIVE)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).bankroll?.run { @@ -101,11 +89,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1, b2) realm.commitTransaction() - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(QueryType.ONLINE) - ) + val sessions = Filter.queryOn(realm, arrayListOf(QueryType.ONLINE)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).bankroll?.run { @@ -130,11 +114,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).bankroll?.run { @@ -168,11 +148,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(6, sessions.size) @@ -198,11 +174,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.GAME filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).game?.run { @@ -236,11 +208,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow2.filterSectionRow = FilterSectionRow.GAME filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(6, sessions.size) @@ -266,11 +234,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.LOCATION filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).location?.run { @@ -305,11 +269,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(6, sessions.size) @@ -336,11 +296,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).tournamentName?.run { @@ -373,11 +329,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(6, sessions.size) @@ -415,11 +367,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(1, sessions.size) (sessions[0] as Session).run { @@ -456,11 +404,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(8, sessions.size) } @@ -488,11 +432,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) val result = arrayListOf(s1.id, s2.id, s3.id, s4.id) @@ -519,11 +459,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(2, sessions.size) @@ -548,11 +484,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.VALUE filter.updateValueMap(FilterElement(filterElementRow)) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(2, sessions.size) @@ -577,11 +509,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow.filterSectionRow = FilterSectionRow.VALUE filter.updateValueMap(FilterElement(filterElementRow)) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filter) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filter)) Assert.assertEquals(3, sessions.size) @@ -611,11 +539,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { filterElementRow2.filterSectionRow = FilterSectionRow.VALUE filterLess.updateValueMap(FilterElement(filterElementRow2)) - val sessions = Filter.queryOn( - realm, - Session, - arrayListOf(filterMore, filterLess) - ) + val sessions = Filter.queryOn(realm, arrayListOf(filterMore, filterLess)) Assert.assertEquals(1, sessions.size) diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt index 734fd022..7791b77e 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt @@ -64,8 +64,8 @@ class Calculator { var computableGroups: MutableList = mutableListOf() filters.forEach { filter -> - val results = filter.realm.where(ComputableResult::class.java).findAll() - val sets = filter.realm.where(SessionSet::class.java).findAll() + val results = filter.results() + val sets = filter.results() val group = ComputableGroup(filter.name, results, sets) computableGroups.add(group) @@ -104,21 +104,6 @@ class Calculator { return computedResults } -// fun compute(sessionGroup: ComputableGroup, options: Options): ComputedResults { -// -// var sum: Double = sessionGroup.computables.sum("ratedNet").toDouble() -// val results: ComputedResults = ComputedResults(sessionGroup) -// -// results.addStats( -// setOf( -// ComputedStat(NETRESULT, sum) -// ) -// ) -// -// return results -// } - - /** * Computes stats for a SessionSet */ diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt index afa66436..addc9e66 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt @@ -1,6 +1,7 @@ package net.pokeranalytics.android.model.filter import io.realm.RealmModel +import net.pokeranalytics.android.model.realm.ComputableResult import net.pokeranalytics.android.model.realm.Session /** @@ -37,11 +38,11 @@ class UnmanagedFilterField(message: String) : Exception(message) { * Companion-level Interface to indicate an RealmObject class can be filtered and to provide all the fieldNames (eg: parameter's path) needed to be query on. */ interface Filterable : RealmModel { - /** - * return the path of the parameter used in the [QueryType] related to this entity - */ - fun fieldNameForQueryType(queryType: QueryType) : String? + /** + * return the path of the parameter used in the [QueryType] related to this entity + */ +// fun fieldNameForQueryType(queryType: QueryType) : String? } @@ -49,13 +50,19 @@ class FilterHelper { companion object { - inline fun fieldNameForQueryType(queryType: QueryType) : String? { - when (T::class) { - is Session -> { + inline fun fieldNameForQueryType(queryType: QueryType): String? { + val clazz = T::class.java + + return when (clazz) { + Session::class.java -> { Session.fieldNameForQueryType(queryType) } + ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryType) +// is SessionSet -> SessionSet.fieldNameForQueryType(queryType) + else -> { + throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}") + } } - throw UnmanagedFilterField("Filterable type fields are not defined") } } diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt index 208760c1..1f22c794 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt @@ -5,6 +5,8 @@ import io.realm.RealmQuery import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.realm.FilterElement import net.pokeranalytics.android.model.realm.FilterElementBlind +import net.pokeranalytics.android.model.realm.Session +import timber.log.Timber import java.util.* @@ -140,6 +142,7 @@ enum class QueryType(var subType:SubType? = null) { val fieldName = FilterHelper.fieldNameForQueryType(this) fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown + Timber.d(">>>> fi = ${fieldName}") this.subType?.let { subType -> return when (subType) { @@ -161,7 +164,8 @@ enum class QueryType(var subType:SubType? = null) { return when (this) { LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE) - CASH, TOURNAMENT -> realmQuery.equalTo(fieldName, this.ordinal) + CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) + TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal) ALL_TOURNAMENT_FEATURES -> { val ids: Array by valueMap ids.forEach { @@ -210,9 +214,11 @@ enum class QueryType(var subType:SubType? = null) { realmQuery.equalTo(fieldName, year) } WEEK_END, WEEK_DAY -> { - var query = realmQuery.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY)) - if (this == WEEK_DAY) { query.not() } - query + var query = realmQuery + if (this == WEEK_DAY) { + query = realmQuery.not() + } + query.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY)) } else -> { throw PokerAnalyticsException.QueryTypeUnhandled diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/ComputableResult.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/ComputableResult.kt index 36e33f9c..c84a1796 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/ComputableResult.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/ComputableResult.kt @@ -2,8 +2,10 @@ package net.pokeranalytics.android.model.realm import io.realm.RealmObject import net.pokeranalytics.android.calculus.interfaces.Computable +import net.pokeranalytics.android.model.filter.Filterable +import net.pokeranalytics.android.model.filter.QueryType -open class ComputableResult : RealmObject(), Computable { +open class ComputableResult : RealmObject(), Computable, Filterable { override var ratedNet: Double = 0.0 @@ -52,4 +54,13 @@ open class ComputableResult : RealmObject(), Computable { BB_PER100HANDS("bbPer100Hands") } + companion object : Filterable { + + fun fieldNameForQueryType(queryType: QueryType): String? { + return "session." + Session.fieldNameForQueryType(queryType) + } + + } + + } 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 07d73637..28085548 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 @@ -2,15 +2,15 @@ package net.pokeranalytics.android.model.realm import io.realm.* import io.realm.annotations.PrimaryKey -import net.pokeranalytics.android.exceptions.PokerAnalyticsException - import io.realm.kotlin.where +import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.filter.Filterable import net.pokeranalytics.android.model.filter.QueryType 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.jetbrains.annotations.TestOnly +import timber.log.Timber import java.util.* /** @@ -18,7 +18,7 @@ import java.util.* * It contains a list of [FilterElement] describing the complete query to launch * The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on */ -open class Filter(entity:Filterable) : RealmObject() { +open class Filter(entity: Filterable) : RealmObject() { constructor() : this(entity = Session) @@ -44,23 +44,6 @@ open class Filter(entity:Filterable) : RealmObject() { } } - val relatedEntity: Class < out RealmObject > - get() { - return when (this) { - SESSION -> Session::class.java -// else -> throw FilterUnhandledEntityException("this entity is not filterable") - } - } - - - val filterable : Filterable - get() { - return when (this) { - SESSION -> Session.Companion -// else -> throw FilterUnhandledEntityException("this entity is not filterable") - } - } - } companion object { @@ -68,8 +51,9 @@ open class Filter(entity:Filterable) : RealmObject() { inline fun queryOn(realm: Realm, queries: List): RealmResults { var realmQuery = realm.where() queries.forEach { - realmQuery = (it.filter(realmQuery)) + realmQuery = it.filter(realmQuery) } + Timber.d(">>>>> query = ${realmQuery.description}") return realmQuery.findAll() } } 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 2dce8655..5a48b42c 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 @@ -41,7 +41,7 @@ import java.util.Currency import kotlin.collections.ArrayList open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDataSource, RowRepresentable, Timed, - TimeFilterable { + TimeFilterable, Filterable { enum class Type { CASH_GAME, @@ -61,10 +61,10 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat return realm.copyToRealm(session) } - override fun fieldNameForQueryType(queryType: QueryType): String? { + fun fieldNameForQueryType(queryType: QueryType): String? { return when (queryType) { - LIVE -> "bankroll.live" - CASH -> "type" + LIVE, ONLINE -> "bankroll.live" + CASH, TOURNAMENT -> "type" BANKROLL -> "bankroll.id" GAME -> "game.id" TOURNAMENT_NAME -> "tournamentName.id" @@ -87,7 +87,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat MORE_THAN_TOURNAMENT_FEE, LESS_THAN_TOURNAMENT_FEE, BETWEEN_TOURNAMENT_FEE -> "tournamentEntryFee" STARTED_FROM_DATE, STARTED_TO_DATE -> "startDate" ENDED_FROM_DATE, ENDED_TO_DATE -> "endDate" - DAY_OF_WEEK, WEEK_END -> "dayOfWeek" + DAY_OF_WEEK, WEEK_END, WEEK_DAY -> "dayOfWeek" MONTH -> "month" YEAR -> "year" else -> null diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt index 1a52cf08..ea29f835 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt @@ -5,11 +5,12 @@ import io.realm.RealmObject import io.realm.RealmResults import io.realm.annotations.Ignore import io.realm.annotations.LinkingObjects +import net.pokeranalytics.android.model.filter.Filterable import net.pokeranalytics.android.model.interfaces.Timed import java.util.* -open class SessionSet : RealmObject(), Timed { +open class SessionSet : RealmObject(), Timed, Filterable { var startDate: Date = Date() set(value) { From 37e6c980085fd14ed10a50fda937744a0224c500 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 17:27:20 +0200 Subject: [PATCH 02/10] cleanup --- .../android/model/filter/Filterable.kt | 3 +- .../android/model/filter/QueryType.kt | 2 - .../android/model/realm/Filter.kt | 49 ++++++------------- .../android/model/realm/SessionSet.kt | 15 ++++-- 4 files changed, 26 insertions(+), 43 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt index addc9e66..5714cb00 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt @@ -3,6 +3,7 @@ package net.pokeranalytics.android.model.filter import io.realm.RealmModel import net.pokeranalytics.android.model.realm.ComputableResult import net.pokeranalytics.android.model.realm.Session +import net.pokeranalytics.android.model.realm.SessionSet /** * We want to be able to store filters in the database: @@ -58,7 +59,7 @@ class FilterHelper { Session.fieldNameForQueryType(queryType) } ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryType) -// is SessionSet -> SessionSet.fieldNameForQueryType(queryType) + SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryType) else -> { throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}") } diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt index 1f22c794..8ecfa3d4 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt @@ -6,7 +6,6 @@ import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.model.realm.FilterElement import net.pokeranalytics.android.model.realm.FilterElementBlind import net.pokeranalytics.android.model.realm.Session -import timber.log.Timber import java.util.* @@ -142,7 +141,6 @@ enum class QueryType(var subType:SubType? = null) { val fieldName = FilterHelper.fieldNameForQueryType(this) fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown - Timber.d(">>>> fi = ${fieldName}") this.subType?.let { subType -> return when (subType) { 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 28085548..64e21021 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 @@ -10,7 +10,6 @@ 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.jetbrains.annotations.TestOnly -import timber.log.Timber import java.util.* /** @@ -18,44 +17,13 @@ import java.util.* * It contains a list of [FilterElement] describing the complete query to launch * The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on */ -open class Filter(entity: Filterable) : RealmObject() { +open class Filter : RealmObject() { - constructor() : this(entity = Session) + private var entityType : Int? = Entity.SESSION.ordinal - private var entityType : Int? = FilterableClass.filterableClass(entity = entity).ordinal - private val filterableClass : FilterableClass? - get() { - entityType?.let { - return FilterableClass.values()[it] - } - return null - } - - private enum class FilterableClass { + private enum class Entity { SESSION, ; - - companion object { - fun filterableClass(entity: Filterable): FilterableClass { - return when (entity) { - is Session.Companion -> SESSION - else -> throw PokerAnalyticsException.FilterUnhandledEntity - } - } - } - - } - - companion object { - @TestOnly - inline fun queryOn(realm: Realm, queries: List): RealmResults { - var realmQuery = realm.where() - queries.forEach { - realmQuery = it.filter(realmQuery) - } - Timber.d(">>>>> query = ${realmQuery.description}") - return realmQuery.findAll() - } } @PrimaryKey @@ -71,6 +39,17 @@ open class Filter(entity: Filterable) : RealmObject() { var filterElements: RealmList = RealmList() private set + companion object { + @TestOnly + inline fun queryOn(realm: Realm, queries: List): RealmResults { + var realmQuery = realm.where() + queries.forEach { + realmQuery = it.filter(realmQuery) + } + return realmQuery.findAll() + } + } + fun createOrUpdateFilterElements(filterElementRows: ArrayList) { filterElements.clear() filterElementRows diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt index ea29f835..416d7e01 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt @@ -6,6 +6,7 @@ import io.realm.RealmResults import io.realm.annotations.Ignore import io.realm.annotations.LinkingObjects import net.pokeranalytics.android.model.filter.Filterable +import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.interfaces.Timed import java.util.* @@ -48,12 +49,16 @@ open class SessionSet : RealmObject(), Timed, Filterable { */ override var netDuration: Long = 0L - companion object { + companion object : Filterable { - fun newInstance(realm: Realm) : SessionSet { - val sessionSet: SessionSet = realm.createObject(SessionSet::class.java) - return realm.copyToRealm(sessionSet) - } + fun newInstance(realm: Realm) : SessionSet { + val sessionSet: SessionSet = realm.createObject(SessionSet::class.java) + return realm.copyToRealm(sessionSet) + } + + fun fieldNameForQueryType(queryType: QueryType): String? { + return "sessions." + Session.fieldNameForQueryType(queryType) + } } From eb50f5380614d721ce3f1140e3cadd4ffb9a19f9 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 17:28:15 +0200 Subject: [PATCH 03/10] cleanup --- .../main/java/net/pokeranalytics/android/model/realm/Filter.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 64e21021..a880712a 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 @@ -94,7 +94,7 @@ open class Filter : RealmObject() { } inline fun results(): RealmResults { - var realmQuery : RealmQuery = realm.where() + var realmQuery = realm.where() this.filterElements.map { it.queryType }.forEach { From 0b8a7b05b2354c3fd43292259796ea6853ae6b83 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 17:37:40 +0200 Subject: [PATCH 04/10] Put maximum limit of use in July --- .../android/ui/fragment/HistoryFragment.kt | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/app/src/main/java/net/pokeranalytics/android/ui/fragment/HistoryFragment.kt b/app/src/main/java/net/pokeranalytics/android/ui/fragment/HistoryFragment.kt index 83ba73b6..6379eae1 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/fragment/HistoryFragment.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/fragment/HistoryFragment.kt @@ -4,6 +4,7 @@ import android.os.Bundle import android.view.LayoutInflater import android.view.View import android.view.ViewGroup +import android.widget.Toast import androidx.core.view.isVisible import io.realm.RealmResults import io.realm.Sort @@ -20,6 +21,7 @@ import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.SmoothScrollLinearLayoutManager import net.pokeranalytics.android.util.Preferences +import java.text.SimpleDateFormat import java.util.* class HistoryFragment : PokerAnalyticsFragment(), LiveRowRepresentableDataSource, RowRepresentableDelegate { @@ -67,12 +69,27 @@ class HistoryFragment : PokerAnalyticsFragment(), LiveRowRepresentableDataSource disclaimerContainer.isVisible = Preferences.shouldShowDisclaimer(requireContext()) + val sdf = SimpleDateFormat("dd/M/yyyy hh:mm") + val betaLimitDate = sdf.parse("17/7/2019 10:00") + newCashGame.setOnClickListener { + + if (Date().after(betaLimitDate)) { + this.showEndOfBetaMessage() + return@setOnClickListener + } + SessionActivity.newInstance(requireContext(), false) newSessionCreated = true } newTournament.setOnClickListener { + + if (Date().after(betaLimitDate)) { + this.showEndOfBetaMessage() + return@setOnClickListener + } + SessionActivity.newInstance(requireContext(), true) newSessionCreated = true } @@ -84,6 +101,11 @@ class HistoryFragment : PokerAnalyticsFragment(), LiveRowRepresentableDataSource } + private fun showEndOfBetaMessage() { + Toast.makeText(context, "Beta has ended. Please update with the Google Play version", Toast.LENGTH_LONG).show() + + } + /** * Init data */ From 84d3bbf869bfbb5ef7caa1a65d21af0025215394 Mon Sep 17 00:00:00 2001 From: Razmig Sarkissian Date: Mon, 8 Apr 2019 18:09:39 +0200 Subject: [PATCH 05/10] update query subtype handling on the inline filter method --- .../android/model/filter/QueryType.kt | 40 +++++++------------ 1 file changed, 14 insertions(+), 26 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt index 1f22c794..99193403 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt @@ -144,21 +144,19 @@ enum class QueryType(var subType:SubType? = null) { fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown Timber.d(">>>> fi = ${fieldName}") - this.subType?.let { subType -> - return when (subType) { - SubType.LESS -> { - val value: Double by valueMap - realmQuery.lessThanOrEqualTo(fieldName, value) - } - SubType.MORE -> { - val value: Double by valueMap - realmQuery.greaterThanOrEqualTo(fieldName, value) - } - SubType.BETWEEN -> { - val leftValue: Double by valueMap - val rightValue: Double by valueMap - realmQuery.between(fieldName, leftValue, rightValue) - } + when (subType) { + SubType.LESS -> { + val value: Double by valueMap + return realmQuery.lessThanOrEqualTo(fieldName, value) + } + SubType.MORE -> { + val value: Double by valueMap + return realmQuery.greaterThanOrEqualTo(fieldName, value) + } + SubType.BETWEEN -> { + val leftValue: Double by valueMap + val rightValue: Double by valueMap + return realmQuery.between(fieldName, leftValue, rightValue) } } @@ -235,17 +233,7 @@ enum class QueryType(var subType:SubType? = null) { } this.subType?.let { subType -> - valueMap = when (subType) { - SubType.LESS, SubType.MORE -> { - mapOf("value" to filterElement.value) - } - SubType.BETWEEN -> { - mapOf( - "leftValue" to filterElement.leftValue, - "rightValue" to filterElement.rightValue - ) - } - } + valueMap = mapOf("value" to filterElement.value) return } From 275f6d3fa1a845d2fa78b36b2fa48dc4880dd5a4 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 18:16:11 +0200 Subject: [PATCH 06/10] Fix build issue --- .../android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 6e2fdd72..e96171cb 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 @@ -22,7 +22,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val realm = this.mockRealm realm.beginTransaction() - val filter = Filter(entity = Session) + val filter = Filter() filter.name = "testSaveLoadCashFilter" val filterElement = FilterElementRow.Cash From b1a30658b1deaffc4a3613f197017c9d0e4c3a58 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 18:31:10 +0200 Subject: [PATCH 07/10] Fixing favorite session test --- .../android/components/RealmInstrumentedUnitTest.kt | 3 ++- .../android/unitTests/FavoriteSessionUnitTest.kt | 3 +++ .../android/model/utils/FavoriteSessionFinder.kt | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/components/RealmInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/components/RealmInstrumentedUnitTest.kt index 7df48545..d44ea94d 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/components/RealmInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/components/RealmInstrumentedUnitTest.kt @@ -15,9 +15,10 @@ open class RealmInstrumentedUnitTest { companion object { - fun newSessionInstance(realm: Realm) : Session { + fun newSessionInstance(realm: Realm, isCashGame: Boolean = true) : Session { val session = realm.createObject(Session::class.java, UUID.randomUUID().toString()) session.startDate = Date() + session.type = if (isCashGame) Session.Type.CASH_GAME.ordinal else Session.Type.TOURNAMENT.ordinal session.result = realm.createObject(Result::class.java) return session } diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/FavoriteSessionUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/FavoriteSessionUnitTest.kt index c3f4f1f5..2a23d062 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/FavoriteSessionUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/FavoriteSessionUnitTest.kt @@ -31,8 +31,11 @@ class FavoriteSessionUnitTest : RealmInstrumentedUnitTest() { s3.endDate = Date() s1.cgBigBlind = 4.0 + s1.cgSmallBlind = 2.0 s2.cgBigBlind = 4.0 + s2.cgSmallBlind = 2.0 s3.cgBigBlind = 1.0 + s3.cgSmallBlind = 1.0 realm.insert(s1) realm.insert(s2) diff --git a/app/src/main/java/net/pokeranalytics/android/model/utils/FavoriteSessionFinder.kt b/app/src/main/java/net/pokeranalytics/android/model/utils/FavoriteSessionFinder.kt index 743b1a49..f4b3d9bc 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/utils/FavoriteSessionFinder.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/utils/FavoriteSessionFinder.kt @@ -124,7 +124,7 @@ class FavoriteSessionFinder { } val sortedCounters = counters.values.sortedBy { it.counter } - return sortedCounters.firstOrNull()?.session + return sortedCounters.lastOrNull()?.session } } From 9ad85781a7bfc9eddf61df31c41a0b3ee4e00dfe Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 18:52:31 +0200 Subject: [PATCH 08/10] refactoring --- .../android/model/filter/QueryType.kt | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt index 40a66fb3..3c1a793b 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/QueryType.kt @@ -73,6 +73,22 @@ enum class QueryType(var subType:SubType? = null) { LESS; } + 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 + } + private set + private val filterValuesExpectedKeys : Array? get() { this.subType?.let { @@ -263,21 +279,5 @@ enum class QueryType(var subType:SubType? = null) { } } - 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 - } - private set - } \ No newline at end of file From 090fb5de66d77b5cb6640405dc644e305402ff79 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 18:54:42 +0200 Subject: [PATCH 09/10] more refactoring --- .../net/pokeranalytics/android/model/filter/Filterable.kt | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt index 5714cb00..d1d30e73 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt @@ -55,9 +55,7 @@ class FilterHelper { val clazz = T::class.java return when (clazz) { - Session::class.java -> { - Session.fieldNameForQueryType(queryType) - } + Session::class.java -> Session.fieldNameForQueryType(queryType) ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryType) SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryType) else -> { From 43d32bcecc5a4506ce1727d6eca7da56022faa1e Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 8 Apr 2019 18:56:31 +0200 Subject: [PATCH 10/10] code cleanup --- .../net/pokeranalytics/android/model/filter/Filterable.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt index d1d30e73..32dd7cd7 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt @@ -52,9 +52,8 @@ class FilterHelper { companion object { inline fun fieldNameForQueryType(queryType: QueryType): String? { - val clazz = T::class.java - return when (clazz) { + return when (T::class.java) { Session::class.java -> Session.fieldNameForQueryType(queryType) ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryType) SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryType) @@ -62,6 +61,7 @@ class FilterHelper { throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}") } } + } }