Merge branch 'dev' of gitlab.com:stax-river/poker-analytics into dev

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<Stat> = 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)

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<Stat> = 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<Stat> = 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<Stat> = 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<Stat> = 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<Stat> = 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<Stat> = 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<Stat> = 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<Stat> = 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 updatedGroup = ComputableGroup("test", listOf(), stats)
-		val updatedSets = realm.where(SessionSet::class.java).findAll()
+		val updatedResults: ComputedResults = Calculator.compute(realm, updatedGroup, options)
-		val updatedGroup = ComputableGroup("test", updatedComputableResults, updatedSets, stats)
-		val updatedResults: ComputedResults = Calculator.compute(updatedGroup, options)
 		val updatedNetResult = updatedResults.computedStat(Stat.NETRESULT)
 		Assert.assertEquals(650.0, updatedNetResult?.value)
 

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<Filter>, options: Options): Report {

app/src/main/java/net/pokeranalytics/android/calculus/Report.kt

@@ -136,6 +136,8 @@ class ComputableGroup(name: String, conditions: List<QueryCondition>, 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) {

app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt

@@ -5,14 +5,23 @@ 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_calendar.*
 import kotlinx.android.synthetic.main.fragment_stats.recyclerView
+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 net.pokeranalytics.android.ui.view.CalendarTabs
+import java.util.*
+import kotlin.coroutines.CoroutineContext
 
 
-class CalendarFragment : PokerAnalyticsFragment() {
+class CalendarFragment : SessionObserverFragment(), CoroutineScope {
 
     companion object {
 
@@ -46,8 +55,76 @@ class CalendarFragment : PokerAnalyticsFragment() {
      * Init data
      */
     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
 	 */