Added test with rates for bankroll report

app/src/androidTest/java/net/pokeranalytics/android/unitTests/BankrollInstrumentedUnitTest.kt

@@ -5,10 +5,8 @@ import io.realm.Realm
 import net.pokeranalytics.android.calculus.bankroll.BankrollCalculator
 import net.pokeranalytics.android.calculus.bankroll.BankrollReportSetup
 import net.pokeranalytics.android.components.SessionInstrumentedUnitTest
-import net.pokeranalytics.android.model.realm.Bankroll
-import net.pokeranalytics.android.model.realm.Session
-import net.pokeranalytics.android.model.realm.Transaction
-import net.pokeranalytics.android.model.realm.TransactionType
+import net.pokeranalytics.android.model.realm.*
+import net.pokeranalytics.android.model.realm.Currency
 import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -75,8 +73,50 @@ class BankrollInstrumentedUnitTest : SessionInstrumentedUnitTest() {
 			val report2 = BankrollCalculator.computeReport(brSetup2)
 			Assert.assertEquals(2000.0, report2.total, EPSILON)
 
+			val brSetupAll = BankrollReportSetup()
+			val reportAll = BankrollCalculator.computeReport(brSetupAll)
+			Assert.assertEquals(2400.0, reportAll.total, EPSILON)
+
 		}
 
 	}
 
+
+	@Test
+	fun testReportWithRate() {
+
+		val realm = mockRealm
+
+		var br1: Bankroll? = null
+		realm.executeTransaction {
+
+			this.createDefaultTransactionTypes(realm)
+
+			val c1 = realm.createObject(Currency::class.java, UUID.randomUUID().toString())
+			c1.rate = 10.0
+
+			br1 = realm.createObject(Bankroll::class.java, "1")
+			br1?.currency = c1
+			br1?.initialValue = 100.0
+
+			val t1 = realm.createObject(Transaction::class.java, UUID.randomUUID().toString())
+			t1.amount = 100.0
+			t1.type = TransactionType.getByValue(TransactionType.Value.BONUS, realm)
+			br1?.transactions?.add(t1)
+
+			val s1 = newSessionInstance(realm)
+			s1.bankroll = br1
+			s1.result?.cashout = 200.0
+
+		}
+
+		val brSetup1 = BankrollReportSetup(br1)
+		val report1 = BankrollCalculator.computeReport(brSetup1)
+		Assert.assertEquals(400.0, report1.total, EPSILON)
+
+		val brSetupAll = BankrollReportSetup()
+		val reportAll = BankrollCalculator.computeReport(brSetupAll)
+		Assert.assertEquals(4000.0, reportAll.total, EPSILON)
+
+	}
 }

app/src/main/java/net/pokeranalytics/android/calculus/bankroll/BankrollCalculator.kt

@@ -17,12 +17,23 @@ class BankrollCalculator {
 
 			val report = BankrollReport(setup)
 			val bankrolls: List<Bankroll> = if (setup.bankroll != null) listOf(setup.bankroll) else realm.where(Bankroll::class.java).findAll()
-			report.initial = bankrolls.sumByDouble { it.initialValue }
+
+			var initialValue = 0.0
+			var transactionNet = 0.0
+
+			bankrolls.forEach { bankroll ->
+
+				val rate = if (setup.virtualBankroll) bankroll.rate else 1.0
+
+				initialValue += bankroll.initialValue * rate
+				transactionNet += bankroll.transactions.sumByDouble { it.amount } * rate
+			}
+
+			report.transactionsNet = transactionNet
+			report.initial = initialValue
 
 			val queryConditions = setup.queryConditions
 			val transactions = Filter.queryOn<Transaction>(realm, queryConditions)
-
-			val transactionsNet = transactions.sum("amount")
 			report.addDatedItems(transactions)
 
 			transactions.forEach {
@@ -32,16 +43,22 @@ class BankrollCalculator {
 			val sessions = Filter.queryOn<Session>(realm, queryConditions)
 			report.addDatedItems(sessions)
 
-			val options = Calculator.Options(stats = listOf(Stat.NET_RESULT, Stat.HOURLY_RATE, Stat.STANDARD_DEVIATION_HOURLY))
-			val group  = ComputableGroup(conditions = queryConditions)
-			val result = Calculator.compute(realm, group, options)
-			result.computedStat(Stat.NET_RESULT)?.let {
-				report.netResult = it.value
-			}
+			if (setup.virtualBankroll) {
+
+				val options = Calculator.Options(stats = listOf(Stat.NET_RESULT, Stat.HOURLY_RATE, Stat.STANDARD_DEVIATION_HOURLY))
+				val group  = ComputableGroup(conditions = queryConditions)
+				val result = Calculator.compute(realm, group, options)
+				result.computedStat(Stat.NET_RESULT)?.let {
+					report.netResult = it.value
+				}
+				this.computeRiskOfRuin(report, result)
 
-			report.transactionsNet = transactionsNet.toDouble()
+			} else {
 
-			this.computeRiskOfRuin(report, result)
+				val results = Filter.queryOn<Result>(realm, queryConditions)
+				report.netResult = results.sum("net").toDouble()
+
+			}
 
 			val depositType = TransactionType.getByValue(TransactionType.Value.DEPOSIT, realm)
 			report.transactionBuckets[depositType.id]?.let {  bucket ->

app/src/main/java/net/pokeranalytics/android/calculus/bankroll/BankrollReport.kt

@@ -146,7 +146,7 @@ class BankrollReport(setup: BankrollReportSetup) {
  * A class describing the parameters required to launch a bankroll report
  *
  */
-class BankrollReportSetup(val bankroll: Bankroll?, val from: Date? = null, val to: Date? = null) {
+class BankrollReportSetup(val bankroll: Bankroll? = null, val from: Date? = null, val to: Date? = null) {
 
 	val virtualBankroll: Boolean
 		get() {
@@ -178,6 +178,7 @@ class BankrollReportSetup(val bankroll: Bankroll?, val from: Date? = null, val t
 }
 
 class TransactionBucket(useRate: Boolean = false) {
+
 	var transactions: MutableList<Transaction> = mutableListOf()
 		private set
 	var total: Double = 0.0

app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt

@@ -7,6 +7,7 @@ import net.pokeranalytics.android.model.realm.ComputableResult
 import net.pokeranalytics.android.model.realm.Session
 import net.pokeranalytics.android.model.realm.SessionSet
 import net.pokeranalytics.android.model.realm.Transaction
+import net.pokeranalytics.android.model.realm.Result
 
 /**
  * We want to be able to store filters in the database:
@@ -65,6 +66,7 @@ class FilterHelper {
 				ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryCondition)
 				SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryCondition)
 				Transaction::class.java -> Transaction.fieldNameForQueryType(queryCondition)
+				Result::class.java -> Result.fieldNameForQueryType(queryCondition)
 				else -> {
 					throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}")
 				}

app/src/main/java/net/pokeranalytics/android/model/realm/Bankroll.kt

@@ -32,6 +32,11 @@ open class Bankroll() : RealmObject(), NameManageable, RowRepresentable {
     // The initial value of the bankroll
     var initialValue: Double = 0.0
 
+    val rate: Double
+        get() {
+            return this.currency?.rate ?: 1.0
+        }
+
     override fun getDisplayName(): String {
         return this.name
     }

app/src/main/java/net/pokeranalytics/android/model/realm/Result.kt

@@ -6,10 +6,22 @@ import io.realm.RealmResults
 import io.realm.annotations.Ignore
 import io.realm.annotations.LinkingObjects
 import io.realm.annotations.RealmClass
+import net.pokeranalytics.android.model.filter.Filterable
+import net.pokeranalytics.android.model.filter.QueryCondition
 
 @RealmClass
-open class Result : RealmObject() {
+open class Result : RealmObject(), Filterable {
 
+	companion object {
+
+		fun fieldNameForQueryType(queryCondition: Class < out QueryCondition>): String? {
+			Session.fieldNameForQueryType(queryCondition)?.let {
+				return "sessions.$it"
+			}
+			return null
+		}
+
+	}
 	/**
 	 * The buyin amount
  	 */