feature/top10
Laurent 7 years ago
commit 01ded1158b
  1. 4
      app/src/androidTest/java/net/pokeranalytics/android/performanceTests/PerfsInstrumentedUnitTest.kt
  2. 22
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt
  3. 8
      app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
  4. 36
      app/src/main/java/net/pokeranalytics/android/calculus/Report.kt
  5. 10
      app/src/main/java/net/pokeranalytics/android/calculus/Stat.kt
  6. 8
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  7. 2
      app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt
  8. 10
      app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarDetailsFragment.kt
  9. 8
      app/src/main/java/net/pokeranalytics/android/ui/fragment/CalendarFragment.kt
  10. 4
      app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt
  11. 32
      app/src/main/java/net/pokeranalytics/android/ui/fragment/ReportsFragment.kt
  12. 2
      app/src/main/java/net/pokeranalytics/android/ui/fragment/StatisticDetailsFragment.kt
  13. 26
      app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt
  14. 2
      app/src/main/java/net/pokeranalytics/android/ui/view/SessionRowView.kt
  15. 2
      app/src/main/java/net/pokeranalytics/android/ui/view/TransactionRowView.kt
  16. 20
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/ReportRow.kt
  17. 16
      app/src/main/res/layout/fragment_calendar_details.xml
  18. 2
      app/src/test/java/net/pokeranalytics/android/ExampleUnitTest.kt

@ -53,7 +53,7 @@ class PerfsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
Timber.d("computableResults: ${computableResults.size}") Timber.d("computableResults: ${computableResults.size}")
Timber.d("sets: ${sets.size}") Timber.d("sets: ${sets.size}")
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE) val stats: List<Stat> = listOf(Stat.NET_RESULT, Stat.AVERAGE)
val group = ComputableGroup("test", listOf(), stats) val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options() val options = Calculator.Options()
@ -62,7 +62,7 @@ class PerfsInstrumentedUnitTest : RealmInstrumentedUnitTest() {
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
Timber.d("*** ended in ${System.currentTimeMillis() - start} milliseconds") Timber.d("*** ended in ${System.currentTimeMillis() - start} milliseconds")
val sum = results.computedStat(Stat.NETRESULT) val sum = results.computedStat(Stat.NET_RESULT)
Timber.d("*** NET RESULT: ${sum?.value}") Timber.d("*** NET RESULT: ${sum?.value}")
val average = results.computedStat(Stat.AVERAGE) val average = results.computedStat(Stat.AVERAGE)

@ -81,7 +81,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val delta = 0.01 val delta = 0.01
val sum = results.computedStat(Stat.NETRESULT) val sum = results.computedStat(Stat.NET_RESULT)
if (sum != null) { if (sum != null) {
assertEquals(200.0, sum.value, delta) assertEquals(200.0, sum.value, delta)
} else { } else {
@ -250,7 +250,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
} }
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE) val stats: List<Stat> = listOf(Stat.NET_RESULT, Stat.AVERAGE)
val group = ComputableGroup("test", listOf(), stats) val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options() val options = Calculator.Options()
@ -317,7 +317,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE) val stats: List<Stat> = listOf(Stat.NET_RESULT, Stat.AVERAGE)
val group = ComputableGroup("test", listOf(), stats) val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options() val options = Calculator.Options()
@ -400,7 +400,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE) val stats: List<Stat> = listOf(Stat.NET_RESULT, Stat.AVERAGE)
val group = ComputableGroup("test", listOf(), stats) val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options() val options = Calculator.Options()
@ -420,7 +420,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
s1.deleteFromRealm() s1.deleteFromRealm()
} }
val stats2: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE) val stats2: List<Stat> = listOf(Stat.NET_RESULT, Stat.AVERAGE)
val group2 = ComputableGroup("test", listOf(), stats2) val group2 = ComputableGroup("test", listOf(), stats2)
val results2: ComputedResults = Calculator.compute(realm, group2, options) val results2: ComputedResults = Calculator.compute(realm, group2, options)
@ -545,7 +545,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
s1.endDate = null s1.endDate = null
} }
val stats: List<Stat> = listOf(Stat.NETRESULT, Stat.AVERAGE) val stats: List<Stat> = listOf(Stat.NET_RESULT, Stat.AVERAGE)
val group = ComputableGroup("test", listOf(), stats) val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options() val options = Calculator.Options()
@ -597,12 +597,12 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
} }
val stats: List<Stat> = listOf(Stat.NETRESULT) val stats: List<Stat> = listOf(Stat.NET_RESULT)
val group = ComputableGroup("test", listOf(), stats) val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options() val options = Calculator.Options()
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val netResult = results.computedStat(Stat.NETRESULT) val netResult = results.computedStat(Stat.NET_RESULT)
assertEquals(250.0, netResult?.value) assertEquals(250.0, netResult?.value)
} }
@ -633,12 +633,12 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
} }
val stats: List<Stat> = listOf(Stat.NETRESULT) val stats: List<Stat> = listOf(Stat.NET_RESULT)
val group = ComputableGroup("test", listOf(), stats) val group = ComputableGroup("test", listOf(), stats)
val options = Calculator.Options() val options = Calculator.Options()
val results: ComputedResults = Calculator.compute(realm, group, options) val results: ComputedResults = Calculator.compute(realm, group, options)
val netResult = results.computedStat(Stat.NETRESULT) val netResult = results.computedStat(Stat.NET_RESULT)
assertEquals(250.0, netResult?.value) assertEquals(250.0, netResult?.value)
println("currency set rate real test starts here") println("currency set rate real test starts here")
@ -654,7 +654,7 @@ class StatsInstrumentedUnitTest : SessionInstrumentedUnitTest() {
val updatedGroup = ComputableGroup("test", listOf(), stats) val updatedGroup = ComputableGroup("test", listOf(), stats)
val updatedResults: ComputedResults = Calculator.compute(realm, updatedGroup, options) val updatedResults: ComputedResults = Calculator.compute(realm, updatedGroup, options)
val updatedNetResult = updatedResults.computedStat(Stat.NETRESULT) val updatedNetResult = updatedResults.computedStat(Stat.NET_RESULT)
assertEquals(650.0, updatedNetResult?.value) assertEquals(650.0, updatedNetResult?.value)
} }

@ -155,7 +155,7 @@ class Calculator {
*/ */
fun computeGroups(realm: Realm, groups: List<ComputableGroup>, options: Options): Report { fun computeGroups(realm: Realm, groups: List<ComputableGroup>, options: Options): Report {
val report = Report() val report = Report(options)
groups.forEach { group -> groups.forEach { group ->
val s = Date() val s = Date()
@ -201,7 +201,7 @@ class Calculator {
} }
val sum = computables.sum(ComputableResult.Field.RATED_NET.identifier).toDouble() val sum = computables.sum(ComputableResult.Field.RATED_NET.identifier).toDouble()
results.addStat(NETRESULT, sum) results.addStat(NET_RESULT, sum)
val totalHands = computables.sum(ComputableResult.Field.ESTIMATED_HANDS.identifier).toDouble() val totalHands = computables.sum(ComputableResult.Field.ESTIMATED_HANDS.identifier).toDouble()
results.addStat(HANDS_PLAYED, totalHands) results.addStat(HANDS_PLAYED, totalHands)
@ -298,7 +298,7 @@ class Calculator {
val session = val session =
computable.session ?: throw IllegalStateException("Computing lone ComputableResult") computable.session ?: throw IllegalStateException("Computing lone ComputableResult")
results.addEvolutionValue(tSum, stat = NETRESULT, data = session) results.addEvolutionValue(tSum, stat = NET_RESULT, data = session)
results.addEvolutionValue(tSum / index, stat = AVERAGE, data = session) results.addEvolutionValue(tSum / index, stat = AVERAGE, data = session)
results.addEvolutionValue(index.toDouble(), stat = NUMBER_OF_GAMES, data = session) results.addEvolutionValue(index.toDouble(), stat = NUMBER_OF_GAMES, data = session)
results.addEvolutionValue(tBBSum / tBBSessionCount, stat = AVERAGE_NET_BB, data = session) results.addEvolutionValue(tBBSum / tBBSessionCount, stat = AVERAGE_NET_BB, data = session)
@ -400,7 +400,7 @@ class Calculator {
} }
Options.EvolutionValues.TIMED -> { Options.EvolutionValues.TIMED -> {
results.addEvolutionValue(tRatedNetSum, tHourlyDuration, NETRESULT, sessionSet) results.addEvolutionValue(tRatedNetSum, tHourlyDuration, NET_RESULT, sessionSet)
results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet) results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet)
results.addEvolutionValue( results.addEvolutionValue(
tIndex.toDouble(), tIndex.toDouble(),

@ -14,15 +14,15 @@ import net.pokeranalytics.android.model.realm.SessionSet
/** /**
* The class returned after performing calculation in the Calculator object * The class returned after performing calculation in the Calculator object
*/ */
class Report() { class Report(var options: Calculator.Options) {
private var _results: MutableList<ComputedResults> = mutableListOf() private var _results: MutableList<ComputedResults> = mutableListOf()
val results: List<ComputedResults> = this._results val results: List<ComputedResults> = this._results
// private var groups: MutableList<ComputableGroup> = mutableListOf() // private var groups: MutableList<ComputableGroup> = mutableListOf()
// //
// var options: Calculator.Options = options
// //
// fun addGroup(group: ComputableGroup) { // fun addGroup(group: ComputableGroup) {
// this.groups.add(group) // this.groups.add(group)
@ -48,25 +48,33 @@ class Report() {
return entries return entries
} }
fun barEntries(stat: Stat): List<Entry> { fun barEntries(stat: Stat? = null): List<Entry> {
val entries = mutableListOf<Entry>() val entries = mutableListOf<Entry>()
val statToUse = stat ?: options.displayedStats.firstOrNull()
this._results.forEachIndexed { index, results ->
val cs = results.computedStat(stat) statToUse?.let {
cs?.let { computedStat -> this._results.forEachIndexed { index, results ->
val barEntry = BarEntry(index.toFloat(), computedStat.value.toFloat(), results) val cs = results.computedStat(it)
entries.add(barEntry) cs?.let { computedStat ->
val barEntry = BarEntry(index.toFloat(), computedStat.value.toFloat(), results)
entries.add(barEntry)
}
} }
} }
return entries return entries
} }
fun multiLineEntries(stat: Stat): List<List<Entry>> { fun multiLineEntries(): List<List<Entry>> {
val entries = mutableListOf<List<Entry>>() val entries = mutableListOf<List<Entry>>()
this._results.forEach { result ->
val entryList = result.singleLineEntries(stat) options.displayedStats.forEach { stat ->
entries.add(entryList) this._results.forEach { result ->
val entryList = result.singleLineEntries(stat)
entries.add(entryList)
}
} }
return entries return entries
} }
@ -216,7 +224,7 @@ class ComputedResults(group: ComputableGroup) : StatEntry {
val previousValue = previousComputedStat.secondValue ?: previousComputedStat.value val previousValue = previousComputedStat.secondValue ?: previousComputedStat.value
when (computedStat.stat) { when (computedStat.stat) {
Stat.NETRESULT, Stat.DURATION, Stat.BB_NET_RESULT -> { Stat.NET_RESULT, Stat.DURATION, Stat.BB_NET_RESULT -> {
computedStat.secondValue = previousValue + computedStat.value computedStat.secondValue = previousValue + computedStat.value
} }
} }

@ -55,7 +55,7 @@ enum class AggregationType {
*/ */
enum class Stat : RowRepresentable { enum class Stat : RowRepresentable {
NETRESULT, NET_RESULT,
BB_NET_RESULT, BB_NET_RESULT,
HOURLY_RATE, HOURLY_RATE,
AVERAGE, AVERAGE,
@ -115,7 +115,7 @@ enum class Stat : RowRepresentable {
override val resId: Int? override val resId: Int?
get() { get() {
return when (this) { return when (this) {
NETRESULT -> R.string.net_result NET_RESULT -> R.string.net_result
BB_NET_RESULT -> R.string.total_net_result_bb_ BB_NET_RESULT -> R.string.total_net_result_bb_
HOURLY_RATE -> R.string.average_hour_rate HOURLY_RATE -> R.string.average_hour_rate
AVERAGE -> R.string.average AVERAGE -> R.string.average
@ -155,7 +155,7 @@ enum class Stat : RowRepresentable {
when (this) { when (this) {
// Amounts + red/green // Amounts + red/green
NETRESULT, HOURLY_RATE, AVERAGE, MAXIMUM_NETRESULT, MINIMUM_NETRESULT -> { NET_RESULT, HOURLY_RATE, AVERAGE, MAXIMUM_NETRESULT, MINIMUM_NETRESULT -> {
val color = if (value >= this.threshold) R.color.green else R.color.red val color = if (value >= this.threshold) R.color.green else R.color.red
return TextFormat(value.toCurrency(currency), color) return TextFormat(value.toCurrency(currency), color)
} }
@ -201,7 +201,7 @@ enum class Stat : RowRepresentable {
HOURLY_RATE_BB, AVERAGE_NET_BB, ROI, WIN_RATIO, HOURLY_RATE -> R.string.average HOURLY_RATE_BB, AVERAGE_NET_BB, ROI, WIN_RATIO, HOURLY_RATE -> R.string.average
NUMBER_OF_SETS -> R.string.number_of_sessions NUMBER_OF_SETS -> R.string.number_of_sessions
NUMBER_OF_GAMES -> R.string.number_of_records NUMBER_OF_GAMES -> R.string.number_of_records
NETRESULT, DURATION -> R.string.total NET_RESULT, DURATION -> R.string.total
STANDARD_DEVIATION -> R.string.net_result STANDARD_DEVIATION -> R.string.net_result
STANDARD_DEVIATION_HOURLY -> R.string.hour_rate_without_pauses STANDARD_DEVIATION_HOURLY -> R.string.hour_rate_without_pauses
STANDARD_DEVIATION_BB_PER_100_HANDS -> R.string.net_result_bb_per_100_hands STANDARD_DEVIATION_BB_PER_100_HANDS -> R.string.net_result_bb_per_100_hands
@ -225,7 +225,7 @@ enum class Stat : RowRepresentable {
val aggregationTypes: List<AggregationType> val aggregationTypes: List<AggregationType>
get() { get() {
return when (this) { return when (this) {
NETRESULT -> listOf(AggregationType.SESSION, AggregationType.MONTH, AggregationType.YEAR, AggregationType.DURATION) NET_RESULT -> listOf(AggregationType.SESSION, AggregationType.MONTH, AggregationType.YEAR, AggregationType.DURATION)
NUMBER_OF_GAMES, NUMBER_OF_SETS -> listOf(AggregationType.MONTH, AggregationType.YEAR) NUMBER_OF_GAMES, NUMBER_OF_SETS -> listOf(AggregationType.MONTH, AggregationType.YEAR)
else -> listOf(AggregationType.SESSION, AggregationType.MONTH, AggregationType.YEAR) else -> listOf(AggregationType.SESSION, AggregationType.MONTH, AggregationType.YEAR)
} }

@ -583,7 +583,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
CustomizableRowRepresentable( CustomizableRowRepresentable(
RowViewType.HEADER_TITLE_AMOUNT_BIG, RowViewType.HEADER_TITLE_AMOUNT_BIG,
title = getFormattedDuration(), title = getFormattedDuration(),
computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, currency = currency) computedStat = ComputedStat(Stat.NET_RESULT, result?.net ?: 0.0, currency = currency)
) )
) )
rows.add(SeparatorRow()) rows.add(SeparatorRow())
@ -593,7 +593,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
CustomizableRowRepresentable( CustomizableRowRepresentable(
RowViewType.HEADER_TITLE_AMOUNT_BIG, RowViewType.HEADER_TITLE_AMOUNT_BIG,
resId = R.string.pause, resId = R.string.pause,
computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, currency = currency) computedStat = ComputedStat(Stat.NET_RESULT, result?.net ?: 0.0, currency = currency)
) )
) )
rows.add(SeparatorRow()) rows.add(SeparatorRow())
@ -603,7 +603,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
CustomizableRowRepresentable( CustomizableRowRepresentable(
RowViewType.HEADER_TITLE_AMOUNT_BIG, RowViewType.HEADER_TITLE_AMOUNT_BIG,
title = getFormattedDuration(), title = getFormattedDuration(),
computedStat = ComputedStat(Stat.NETRESULT, result?.net ?: 0.0, currency = currency) computedStat = ComputedStat(Stat.NET_RESULT, result?.net ?: 0.0, currency = currency)
) )
) )
rows.add( rows.add(
@ -926,7 +926,7 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
this.result?.let { result -> this.result?.let { result ->
val value: Double? = when (stat) { val value: Double? = when (stat) {
Stat.NETRESULT, Stat.AVERAGE, Stat.STANDARD_DEVIATION -> result.net Stat.NET_RESULT, Stat.AVERAGE, Stat.STANDARD_DEVIATION -> result.net
Stat.NUMBER_OF_GAMES, Stat.NUMBER_OF_SETS -> 1.0 Stat.NUMBER_OF_GAMES, Stat.NUMBER_OF_SETS -> 1.0
Stat.AVERAGE_BUYIN -> result.buyin Stat.AVERAGE_BUYIN -> result.buyin
Stat.ROI -> { Stat.ROI -> {

@ -120,7 +120,7 @@ open class SessionSet() : RealmObject(), Timed, Filterable {
override fun formattedValue(stat: Stat, context: Context) : TextFormat { override fun formattedValue(stat: Stat, context: Context) : TextFormat {
return when (stat) { return when (stat) {
Stat.NETRESULT, Stat.AVERAGE -> stat.format(this.ratedNet, currency = null, context = context) Stat.NET_RESULT, Stat.AVERAGE -> stat.format(this.ratedNet, currency = null, context = context)
Stat.DURATION, Stat.AVERAGE_DURATION -> stat.format(this.netDuration.toDouble(), currency = null, context = context) Stat.DURATION, Stat.AVERAGE_DURATION -> stat.format(this.netDuration.toDouble(), currency = null, context = context)
Stat.HOURLY_RATE -> stat.format(this.hourlyRate, currency = null, context = context) Stat.HOURLY_RATE -> stat.format(this.hourlyRate, currency = null, context = context)
Stat.HANDS_PLAYED -> stat.format(this.estimatedHands, currency = null, context = context) Stat.HANDS_PLAYED -> stat.format(this.estimatedHands, currency = null, context = context)

@ -52,7 +52,7 @@ class CalendarDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresentable
private var sessionTypeCondition: QueryCondition? = null private var sessionTypeCondition: QueryCondition? = null
private var rowRepresentables: ArrayList<RowRepresentable> = ArrayList() private var rowRepresentables: ArrayList<RowRepresentable> = ArrayList()
//private var stat: Stat = Stat.NETRESULT //private var stat: Stat = Stat.NET_RESULT
//private var entries: List<Entry> = ArrayList() //private var entries: List<Entry> = ArrayList()
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? { override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
@ -183,14 +183,14 @@ class CalendarDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresentable
rowRepresentables.clear() rowRepresentables.clear()
rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.net_result)) rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.net_result))
rowRepresentables.add(GraphRow(report, Stat.NETRESULT)) rowRepresentables.add(GraphRow(report, Stat.NET_RESULT))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.NETRESULT), it.computedStat(Stat.HOURLY_RATE))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.NET_RESULT), it.computedStat(Stat.HOURLY_RATE)))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.LOCATIONS_PLAYED), it.computedStat(Stat.LONGEST_STREAKS))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.LOCATIONS_PLAYED), it.computedStat(Stat.LONGEST_STREAKS)))
rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.distribution)) rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.distribution))
rowRepresentables.add(GraphRow(report, Stat.NETRESULT)) rowRepresentables.add(GraphRow(report, Stat.NET_RESULT))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.WIN_RATIO), it.computedStat(Stat.MAXIMUM_NETRESULT))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.WIN_RATIO), it.computedStat(Stat.MAXIMUM_NETRESULT)))
rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.volume)) rowRepresentables.add(CustomizableRowRepresentable(RowViewType.HEADER_TITLE, resId = R.string.volume))
rowRepresentables.add(GraphRow(report, Stat.NETRESULT)) rowRepresentables.add(GraphRow(report, Stat.NET_RESULT))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.DURATION), it.computedStat(Stat.AVERAGE_DURATION))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.DURATION), it.computedStat(Stat.AVERAGE_DURATION)))
rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.DAYS_PLAYED), it.computedStat(Stat.MAXIMUM_DURATION))) rowRepresentables.add(StatDoubleRow(it.computedStat(Stat.DAYS_PLAYED), it.computedStat(Stat.MAXIMUM_DURATION)))
} }

@ -68,7 +68,7 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep
private var sessionTypeCondition: QueryCondition? = null private var sessionTypeCondition: QueryCondition? = null
private var currentTimeFilter: TimeFilter = TimeFilter.MONTH private var currentTimeFilter: TimeFilter = TimeFilter.MONTH
private var currentStat = Stat.NETRESULT private var currentStat = Stat.NET_RESULT
// Life Cycle // Life Cycle
@ -132,7 +132,7 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep
tabs.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener { tabs.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener {
override fun onTabSelected(tab: TabLayout.Tab) { override fun onTabSelected(tab: TabLayout.Tab) {
when (tab.position) { when (tab.position) {
0 -> currentStat = Stat.NETRESULT 0 -> currentStat = Stat.NET_RESULT
1 -> currentStat = Stat.HOURLY_RATE 1 -> currentStat = Stat.HOURLY_RATE
2 -> currentStat = Stat.NUMBER_OF_GAMES 2 -> currentStat = Stat.NUMBER_OF_GAMES
3 -> currentStat = Stat.WIN_RATIO 3 -> currentStat = Stat.WIN_RATIO
@ -299,12 +299,12 @@ class CalendarFragment : SessionObserverFragment(), CoroutineScope, StaticRowRep
/* /*
Timber.d("========== YEAR x MONTH") Timber.d("========== YEAR x MONTH")
sortedMonthlyReports.keys.forEach { sortedMonthlyReports.keys.forEach {
Timber.d("$it => ${sortedMonthlyReports[it]?.computedStat(Stat.NETRESULT)?.value}") Timber.d("$it => ${sortedMonthlyReports[it]?.computedStat(Stat.NET_RESULT)?.value}")
} }
Timber.d("========== YEARLY") Timber.d("========== YEARLY")
sortedYearlyReports.keys.forEach { sortedYearlyReports.keys.forEach {
Timber.d("$it => ${sortedYearlyReports[it]?.computedStat(Stat.NETRESULT)?.value}") Timber.d("$it => ${sortedYearlyReports[it]?.computedStat(Stat.NET_RESULT)?.value}")
} }
*/ */

@ -54,7 +54,7 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener, Co
private lateinit var legendView: LegendView private lateinit var legendView: LegendView
private lateinit var chartView: BarLineChartBase<*> private lateinit var chartView: BarLineChartBase<*>
private var stat: Stat = Stat.NETRESULT private var stat: Stat = Stat.NET_RESULT
private var reports: MutableMap<AggregationType, Report> = hashMapOf() private var reports: MutableMap<AggregationType, Report> = hashMapOf()
private var aggregationTypes: List<AggregationType> = listOf() private var aggregationTypes: List<AggregationType> = listOf()
private var displayAggregationChoices: Boolean = true private var displayAggregationChoices: Boolean = true
@ -76,7 +76,7 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener, Co
* Set data * Set data
*/ */
fun setData(stat: Stat, group: ComputableGroup, report: Report, displayAggregationChoices: Boolean = true) { fun setData(stat: Stat, group: ComputableGroup, report: Report, displayAggregationChoices: Boolean = true) {
this.stat = stat this.stat = report.options.displayedStats.first()
this.computableGroup = group this.computableGroup = group
this.aggregationTypes = stat.aggregationTypes this.aggregationTypes = stat.aggregationTypes

@ -5,8 +5,14 @@ import android.view.LayoutInflater
import android.view.View import android.view.View
import android.view.ViewGroup import android.view.ViewGroup
import androidx.recyclerview.widget.LinearLayoutManager import androidx.recyclerview.widget.LinearLayoutManager
import io.realm.Realm
import kotlinx.android.synthetic.main.fragment_stats.* import kotlinx.android.synthetic.main.fragment_stats.*
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import net.pokeranalytics.android.R import net.pokeranalytics.android.R
import net.pokeranalytics.android.calculus.Calculator
import net.pokeranalytics.android.calculus.Stat
import net.pokeranalytics.android.model.comparison.Comparator
import net.pokeranalytics.android.ui.adapter.RowRepresentableAdapter import net.pokeranalytics.android.ui.adapter.RowRepresentableAdapter
import net.pokeranalytics.android.ui.adapter.RowRepresentableDelegate import net.pokeranalytics.android.ui.adapter.RowRepresentableDelegate
import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource
@ -14,6 +20,8 @@ import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment
import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowRepresentable
import net.pokeranalytics.android.ui.view.rowrepresentable.ReportRow import net.pokeranalytics.android.ui.view.rowrepresentable.ReportRow
import timber.log.Timber import timber.log.Timber
import java.util.*
import kotlin.collections.ArrayList
class ReportsFragment : PokerAnalyticsFragment(), StaticRowRepresentableDataSource, RowRepresentableDelegate { class ReportsFragment : PokerAnalyticsFragment(), StaticRowRepresentableDataSource, RowRepresentableDelegate {
@ -61,6 +69,7 @@ class ReportsFragment : PokerAnalyticsFragment(), StaticRowRepresentableDataSour
super.onRowSelected(position, row, fromAction) super.onRowSelected(position, row, fromAction)
Timber.d("row: $row") Timber.d("row: $row")
when (row) { when (row) {
ReportRow.DAY_OF_WEEKS -> { ReportRow.DAY_OF_WEEKS -> {
//TODO: Open ComparisonChartActivity with correct data //TODO: Open ComparisonChartActivity with correct data
//TODO: Calcul report before or after //TODO: Calcul report before or after
@ -93,5 +102,28 @@ class ReportsFragment : PokerAnalyticsFragment(), StaticRowRepresentableDataSour
} }
} }
private fun launchComputation(comparators: List<Comparator>) {
GlobalScope.launch {
val startDate = Date()
val realm = Realm.getDefaultInstance()
val requiredStats: List<Stat> = listOf(Stat.NET_RESULT)
val options = Calculator.Options(evolutionValues = Calculator.Options.EvolutionValues.STANDARD, stats = requiredStats)
val report = Calculator.computeStatsWithComparators(realm, comparators = comparators, options = options)
}
}
} }

@ -25,7 +25,7 @@ class StatisticDetailsFragment : PokerAnalyticsFragment() {
private lateinit var parentActivity: PokerAnalyticsActivity private lateinit var parentActivity: PokerAnalyticsActivity
private var stat: Stat = Stat.NETRESULT private var stat: Stat = Stat.NET_RESULT
private var entries: List<Entry> = ArrayList() private var entries: List<Entry> = ArrayList()
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? { override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {

@ -137,14 +137,12 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
GlobalScope.launch(coroutineContext) { GlobalScope.launch(coroutineContext) {
var r = Report()
val test = GlobalScope.async { val test = GlobalScope.async {
val s = Date() val s = Date()
Timber.d(">>> start...") Timber.d(">>> start...")
val realm = Realm.getDefaultInstance() val realm = Realm.getDefaultInstance()
r = createSessionGroupsAndStartCompute(realm) report = createSessionGroupsAndStartCompute(realm)
report = r
realm.close() realm.close()
val e = Date() val e = Date()
@ -155,7 +153,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
test.await() test.await()
if (!isDetached) { if (!isDetached) {
showResults(r) showResults()
} }
} }
@ -164,7 +162,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
private fun createSessionGroupsAndStartCompute(realm: Realm): Report { private fun createSessionGroupsAndStartCompute(realm: Realm): Report {
val allStats: List<Stat> = listOf( val allStats: List<Stat> = listOf(
Stat.NETRESULT, Stat.NET_RESULT,
Stat.HOURLY_RATE, Stat.HOURLY_RATE,
Stat.AVERAGE, Stat.AVERAGE,
Stat.NUMBER_OF_SETS, Stat.NUMBER_OF_SETS,
@ -173,7 +171,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
) )
val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats) val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats)
val cgStats: List<Stat> = listOf( val cgStats: List<Stat> = listOf(
Stat.NETRESULT, Stat.NET_RESULT,
Stat.HOURLY_RATE, Stat.HOURLY_RATE,
Stat.NET_BB_PER_100_HANDS, Stat.NET_BB_PER_100_HANDS,
Stat.HOURLY_RATE_BB, Stat.HOURLY_RATE_BB,
@ -185,7 +183,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
) )
val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.CASH), cgStats) val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.CASH), cgStats)
val tStats: List<Stat> = val tStats: List<Stat> =
listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN) 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.TOURNAMENT), tStats)
Timber.d(">>>>> Start computations...") Timber.d(">>>>> Start computations...")
@ -198,9 +196,11 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
} }
private fun showResults(report: Report) { private fun showResults() {
this.rowRepresentables = this.convertReportIntoRepresentables(report) report?.let {
statsAdapter.notifyDataSetChanged() this.rowRepresentables = this.convertReportIntoRepresentables(it)
statsAdapter.notifyDataSetChanged()
}
} }
private fun convertReportIntoRepresentables(report: Report): ArrayList<RowRepresentable> { private fun convertReportIntoRepresentables(report: Report): ArrayList<RowRepresentable> {
@ -239,7 +239,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
GlobalScope.launch(coroutineContext) { GlobalScope.launch(coroutineContext) {
var report = Report() var report: Report? = null
val test = GlobalScope.async { val test = GlobalScope.async {
val s = Date() val s = Date()
Timber.d(">>> start...") Timber.d(">>> start...")
@ -259,7 +259,9 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
test.await() test.await()
if (!isDetached) { if (!isDetached) {
StatisticDetailsActivity.newInstance(requireContext(), stat, computableGroup, report) report?.let {
StatisticDetailsActivity.newInstance(requireContext(), stat, computableGroup, it)
}
} }
} }

@ -149,7 +149,7 @@ class SessionRowView : FrameLayout {
rowHistorySession.infoTitle.isVisible = false rowHistorySession.infoTitle.isVisible = false
val result = session.result?.net ?: 0.0 val result = session.result?.net ?: 0.0
val formattedStat = ComputedStat(Stat.NETRESULT, result, currency = session.currency).format(context) val formattedStat = ComputedStat(Stat.NET_RESULT, result, currency = session.currency).format(context)
rowHistorySession.gameResult.setTextFormat(formattedStat, context) rowHistorySession.gameResult.setTextFormat(formattedStat, context)
} }

@ -63,7 +63,7 @@ class TransactionRowView : FrameLayout {
rowTransaction.transactionSubtitle.text = subtitle rowTransaction.transactionSubtitle.text = subtitle
// Amount // Amount
val formattedStat = ComputedStat(Stat.NETRESULT, transaction.amount).format(context) val formattedStat = ComputedStat(Stat.NET_RESULT, transaction.amount).format(context)
rowTransaction.transactionAmount.setTextFormat(formattedStat, context) rowTransaction.transactionAmount.setTextFormat(formattedStat, context)
} }

@ -1,6 +1,7 @@
package net.pokeranalytics.android.ui.view.rowrepresentable package net.pokeranalytics.android.ui.view.rowrepresentable
import net.pokeranalytics.android.R import net.pokeranalytics.android.R
import net.pokeranalytics.android.model.comparison.Comparator
import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowRepresentable
import net.pokeranalytics.android.ui.view.RowViewType import net.pokeranalytics.android.ui.view.RowViewType
@ -15,7 +16,7 @@ enum class ReportRow : RowRepresentable {
LOCATIONS, LOCATIONS,
NUMBER_OF_TABLES, NUMBER_OF_TABLES,
TOURNAMENT_TYPES, TOURNAMENT_TYPES,
VARIANT; GAME;
companion object { companion object {
@ -40,9 +41,24 @@ enum class ReportRow : RowRepresentable {
LOCATIONS -> R.string.locations LOCATIONS -> R.string.locations
NUMBER_OF_TABLES -> R.string.number_of_tables NUMBER_OF_TABLES -> R.string.number_of_tables
TOURNAMENT_TYPES -> R.string.tournament_type_complete TOURNAMENT_TYPES -> R.string.tournament_type_complete
VARIANT -> R.string.variant GAME -> R.string.game
} }
} }
override val viewType: Int = RowViewType.TITLE_ARROW.ordinal override val viewType: Int = RowViewType.TITLE_ARROW.ordinal
val comparators: List<Comparator>
get() {
return when (this) {
BLINDS -> listOf(Comparator.BLIND)
BUY_IN -> listOf(Comparator.TOURNAMENT_ENTRY_FEE)
DAY_OF_WEEKS -> listOf(Comparator.DAY_OF_WEEK)
GENERAL -> listOf(Comparator.CASH, Comparator.LIVE)
LOCATIONS -> listOf(Comparator.LOCATION)
NUMBER_OF_TABLES -> listOf() //TODO
TOURNAMENT_TYPES -> listOf(Comparator.TOURNAMENT_TYPE)
GAME -> listOf(Comparator.GAME)
}
}
} }

@ -64,10 +64,24 @@
app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent" app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent" app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="@+id/recyclerView" app:layout_constraintTop_toBottomOf="@+id/appBar"
tools:alpha="1" tools:alpha="1"
tools:visibility="visible" /> tools:visibility="visible" />
<androidx.appcompat.widget.AppCompatTextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="8dp"
android:layout_marginEnd="8dp"
android:fontFamily="@font/roboto"
android:text="@string/no_data_found"
android:textSize="18sp"
android:visibility="gone"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="@+id/recyclerView"
app:layout_constraintTop_toBottomOf="@+id/appBar" />
<androidx.recyclerview.widget.RecyclerView <androidx.recyclerview.widget.RecyclerView
android:id="@+id/recyclerView" android:id="@+id/recyclerView"
android:layout_width="0dp" android:layout_width="0dp"

@ -39,7 +39,7 @@ class ExampleUnitTest : RealmUnitTest() {
// //
// val results: ComputedResults = Calculator.compute(group, Calculator.Options()) // val results: ComputedResults = Calculator.compute(group, Calculator.Options())
// //
// val sum = results.computedStat(Stat.NETRESULT) // val sum = results.computedStat(Stat.NET_RESULT)
// if (sum != null) { // if (sum != null) {
// assert(sum.value == 0.0) { "sum is ${sum.value}" } // assert(sum.value == 0.0) { "sum is ${sum.value}" }
// } else { // } else {

Loading…
Cancel
Save