From 85ef1f4efca58a6132d7560d9b317a9af5a49649 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 15 Apr 2019 11:11:14 +0200 Subject: [PATCH 1/3] example of report launching in fragment --- .../pokeranalytics/android/calculus/Report.kt | 4 + .../android/ui/fragment/CalendarFragment.kt | 80 ++++++++++++++++++- 2 files changed, 82 insertions(+), 2 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt index e97d56f9..745af09d 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt @@ -136,6 +136,8 @@ class ComputableGroup(name: String, conditions: List, stats: Lis this._sessionSets = null } + val isEmpty: Boolean = this._computables?.isEmpty() ?: true + } class ComputedResults(group: ComputableGroup) { @@ -258,6 +260,8 @@ class ComputedResults(group: ComputableGroup) { return entries } + val isEmpty: Boolean = this.group.comparedComputables?.isEmpty ?: true + } class Point(val x: Double, val y: Double, val data: Any) { 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 b05d036f..0f21d694 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 @@ -5,11 +5,20 @@ import android.view.LayoutInflater import android.view.View import android.view.ViewGroup import androidx.recyclerview.widget.LinearLayoutManager +import io.realm.Realm import kotlinx.android.synthetic.main.fragment_stats.* +import kotlinx.coroutines.* import net.pokeranalytics.android.R -import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment +import net.pokeranalytics.android.calculus.Calculator +import net.pokeranalytics.android.calculus.Report +import net.pokeranalytics.android.calculus.Stat +import net.pokeranalytics.android.model.comparison.Comparator +import net.pokeranalytics.android.model.filter.QueryCondition +import net.pokeranalytics.android.ui.fragment.components.SessionObserverFragment +import java.util.* +import kotlin.coroutines.CoroutineContext -class CalendarFragment : PokerAnalyticsFragment() { +class CalendarFragment : SessionObserverFragment(), CoroutineScope { companion object { @@ -44,8 +53,75 @@ class CalendarFragment : PokerAnalyticsFragment() { */ private fun initData() { + val comparator = Comparator.MONTH // returns all months + + val conditions = comparator.queryConditions + + conditions.forEach { + + val realm = getRealm() + Calculator.computeStatsWithComparators(realm, conditions = listOf(it), options = Calculator.Options()) + + } + + + } + override val coroutineContext: CoroutineContext + get() = Dispatchers.Main + + + private fun launchStatComputation() { + + val comparator = Comparator.MONTH // returns all months + +// val conditions = comparator.queryConditions + val conditions = listOf(QueryCondition.CASH, QueryCondition.TOURNAMENT) + + conditions.forEach { + + val realm = getRealm() + + + + GlobalScope.launch(coroutineContext) { + + var r = Report() + val test = GlobalScope.async { + val s = Date() + + val realm = Realm.getDefaultInstance() + + val report = Calculator.computeStatsWithComparators(realm, conditions = listOf(it), options = Calculator.Options()) + report.results.firstOrNull()?.let { + + + val isEmpty = it.isEmpty + val statValue = it.computedStat(Stat.NETRESULT)?.value + } + +// r = createSessionGroupsAndStartCompute(realm) +// report = r + realm.close() + + + } + test.await() + + if (!isDetached) { +// showResults(r) + } + } + + } + + + } + + + + /** * Init UI */ From e67e5e452dbcffe170322d039c0a3da6ca3c85d3 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 15 Apr 2019 12:42:39 +0200 Subject: [PATCH 2/3] Fixing test build --- .../PerfsInstrumentedUnitTest.kt | 6 +-- .../unitTests/StatsInstrumentedUnitTest.kt | 51 +++++++------------ 2 files changed, 21 insertions(+), 36 deletions(-) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt index fe5aff41..8cfd42ac 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt @@ -3,11 +3,11 @@ package net.pokeranalytics.android.performanceTests import android.content.Context import androidx.test.core.app.ApplicationProvider import androidx.test.ext.junit.runners.AndroidJUnit4 -import net.pokeranalytics.android.components.RealmInstrumentedUnitTest import net.pokeranalytics.android.calculus.Calculator import net.pokeranalytics.android.calculus.ComputableGroup import net.pokeranalytics.android.calculus.ComputedResults import net.pokeranalytics.android.calculus.Stat +import net.pokeranalytics.android.components.RealmInstrumentedUnitTest import net.pokeranalytics.android.model.realm.ComputableResult import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.SessionSet @@ -54,12 +54,12 @@ class PerfsInstrumentedUnitTest : RealmInstrumentedUnitTest() { Timber.d("sets: ${sets.size}") val stats: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION) - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) Timber.d("*** ended in ${System.currentTimeMillis() - start} milliseconds") val sum = results.computedStat(Stat.NETRESULT) 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 347d0576..f7dac0f4 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt @@ -120,14 +120,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { println(">>>>>> rated net = ${it.ratedNet} ") } - val sets = realm.where(SessionSet::class.java).findAll() val stats: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION) - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) val delta = 0.01 val sum = results.computedStat(Stat.NETRESULT) @@ -263,15 +262,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { } - val computableResults = realm.where(ComputableResult::class.java).findAll() - val sets = realm.where(SessionSet::class.java).findAll() val stats: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION) - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) val delta = 0.01 val duration = results.computedStat(Stat.DURATION) @@ -332,15 +329,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { realm.commitTransaction() - val computableResults = realm.where(ComputableResult::class.java).findAll() - val sets = realm.where(SessionSet::class.java).findAll() val stats: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION) - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) val delta = 0.01 val duration = results.computedStat(Stat.DURATION) @@ -417,15 +412,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { realm.commitTransaction() - val computableResults = realm.where(ComputableResult::class.java).findAll() - val sets = realm.where(SessionSet::class.java).findAll() val stats: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION) - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) val delta = 0.01 val duration = results.computedStat(Stat.DURATION) @@ -439,12 +432,10 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { s1.deleteFromRealm() } - val computableResults2 = realm.where(ComputableResult::class.java).findAll() - val sets2 = realm.where(SessionSet::class.java).findAll() val stats2: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group2 = ComputableGroup("test", computableResults2, sets2, stats2) + val group2 = ComputableGroup("test", listOf(), stats2) - val results2: ComputedResults = Calculator.compute(group2, options) + val results2: ComputedResults = Calculator.compute(realm, group2, options) val duration2 = results2.computedStat(Stat.DURATION) if (duration2 != null) { @@ -566,15 +557,13 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { s1.endDate = null } - val computableResults = realm.where(ComputableResult::class.java).findAll() - val sets = realm.where(SessionSet::class.java).findAll() val stats: List = listOf(Stat.NETRESULT, Stat.AVERAGE) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() // options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION) - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) val delta = 0.01 val duration = results.computedStat(Stat.DURATION) @@ -623,9 +612,9 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { val computableResults = realm.where(ComputableResult::class.java).findAll() val sets = realm.where(SessionSet::class.java).findAll() val stats: List = listOf(Stat.NETRESULT) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) val netResult = results.computedStat(Stat.NETRESULT) Assert.assertEquals(250.0, netResult?.value) @@ -658,12 +647,10 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { } - val computableResults = realm.where(ComputableResult::class.java).findAll() - val sets = realm.where(SessionSet::class.java).findAll() val stats: List = listOf(Stat.NETRESULT) - val group = ComputableGroup("test", computableResults, sets, stats) + val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() - val results: ComputedResults = Calculator.compute(group, options) + val results: ComputedResults = Calculator.compute(realm, group, options) val netResult = results.computedStat(Stat.NETRESULT) Assert.assertEquals(250.0, netResult?.value) @@ -679,10 +666,8 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { } } - val updatedComputableResults = realm.where(ComputableResult::class.java).findAll() - val updatedSets = realm.where(SessionSet::class.java).findAll() - val updatedGroup = ComputableGroup("test", updatedComputableResults, updatedSets, stats) - val updatedResults: ComputedResults = Calculator.compute(updatedGroup, options) + val updatedGroup = ComputableGroup("test", listOf(), stats) + val updatedResults: ComputedResults = Calculator.compute(realm, updatedGroup, options) val updatedNetResult = updatedResults.computedStat(Stat.NETRESULT) Assert.assertEquals(650.0, updatedNetResult?.value) From 7afea99f58db87af4bdc09c0e57e2b688f9c7f74 Mon Sep 17 00:00:00 2001 From: Laurent Date: Mon, 15 Apr 2019 14:31:47 +0200 Subject: [PATCH 3/3] fixes issue with method when no comparators are given --- .../net/pokeranalytics/android/calculus/Calculator.kt | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) 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 fb435fd5..f7f42459 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt @@ -73,11 +73,17 @@ class Calculator { allConditions.addAll(conditions) allConditions.addAll(comparatorConditions) - val group = ComputableGroup(allConditions.name(), conditions) + val group = ComputableGroup(allConditions.name(), allConditions) computableGroups.add(group) } - return Calculator.computeGroups(realm, computableGroups, options) + + if (computableGroups.size == 0) { + val group = ComputableGroup(conditions.name(), conditions) + computableGroups.add(group) + } + + return this.computeGroups(realm, computableGroups, options) } fun computeStatsWithFilters(realm: Realm, filters: List, options: Options): Report {