fix issue with filter selection accross fragment

add unit test for transaction type

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/TransactionFilterInstrumentedUnitTest.kt

@@ -0,0 +1,57 @@
+package net.pokeranalytics.android.unitTests.filter
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import io.realm.RealmList
+import io.realm.RealmResults
+import net.pokeranalytics.android.R
+import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
+import net.pokeranalytics.android.model.filter.Query
+import net.pokeranalytics.android.model.filter.QueryCondition
+import net.pokeranalytics.android.model.realm.*
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.*
+
+@RunWith(AndroidJUnit4::class)
+class TransactionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
+
+    @Test
+    fun testTransactionTypeFilter() {
+        val context = InstrumentationRegistry.getInstrumentation().context
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        TransactionType.Value.values().forEachIndexed { index, value ->
+            val type = TransactionType()
+            val name = "test"
+            type.name = name
+            type.additive = value.additive
+            type.kind = index
+            type.lock = true
+            realm.insertOrUpdate(type)
+        }
+
+        val t1: Transaction = realm.createObject(Transaction::class.java, "1")
+        t1.type = TransactionType.getByValue(TransactionType.Value.DEPOSIT, realm)
+        val t2: Transaction = realm.createObject(Transaction::class.java, "2")
+        t2.type = TransactionType.getByValue(TransactionType.Value.WITHDRAWAL, realm)
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        t1.bankroll = b1
+
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        t2.bankroll = b2
+
+        realm.commitTransaction()
+
+        val transactions = Filter.queryOn<Transaction>(realm, Query(QueryCondition.AnyTransactionType(t1.type!!)))
+
+        Assert.assertEquals(1, transactions.size)
+        transactions[0]?.run {
+            Assert.assertEquals(t1.type!!.id, (this).type!!.id)
+        }
+    }
+}

app/src/main/java/net/pokeranalytics/android/PokerAnalyticsApplication.kt

@@ -55,7 +55,7 @@ class PokerAnalyticsApplication : Application() {
 
 		if (BuildConfig.DEBUG) {
 			Timber.d("UserPreferences.defaultCurrency: ${UserDefaults.currency.symbol}")
-//			this.createFakeSessions()
+			this.createFakeSessions()
 		}
 
 

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

@@ -68,7 +68,7 @@ class Query {
             }
 		}
 
-        //println("<<<<<< ${realmQuery.description}")
+       // println("<<<<<< ${realmQuery.description}")
         val queryLast = this.conditions.filter {
             it is QueryCondition.Last
         }.firstOrNull()

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

@@ -495,12 +495,21 @@ sealed class QueryCondition : FilterElementRow {
         }
     }
 
-    class StartedFromTime: TimeQuery() {
+    class StartedFromTime(): TimeQuery() {
         override var operator = Operator.MORE
+        constructor(date:Date): this() {
+            singleValue = date
+        }
+
+
     }
 
-    class EndedToTime: TimeQuery() {
+    class EndedToTime(): TimeQuery() {
         override var operator = Operator.LESS
+        constructor(date:Date): this() {
+            singleValue = date
+        }
+
     }
 
     interface CustomFieldRelated {

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

@@ -174,8 +174,18 @@ class FeedFragment : FilterableFragment(), RowRepresentableDelegate {
 
         val sdf = SimpleDateFormat("dd/M/yyyy hh:mm", Locale.getDefault())
 		betaLimitDate = sdf.parse("17/7/2019 10:00")
-
         val filter : Filter? = this.currentFilter(this.requireContext(), getRealm())
+        this.loadSessions(filter)
+        this.loadTransactions(filter)
+        val viewManager = SmoothScrollLinearLayoutManager(requireContext())
+        recyclerView.apply {
+            setHasFixedSize(true)
+            layoutManager = viewManager
+            adapter = feedSessionAdapter
+        }
+    }
+
+    private fun loadSessions(filter : Filter? = null) {
         val sessionFilter: Filter? = filter?.let {
             if (it.filterableType == FilterableType.SESSION) {
                 it
@@ -184,6 +194,19 @@ class FeedFragment : FilterableFragment(), RowRepresentableDelegate {
             }
         }
 
+        // Sessions
+        this.realmSessions = sessionFilter?.results() ?: run { getRealm().where<Session>().findAll() }.sort("startDate", Sort.DESCENDING)
+        this.realmSessions.addChangeListener { _, _ ->
+            this.feedSessionAdapter.refreshData()
+            this.feedSessionAdapter.notifyDataSetChanged()
+        }
+
+        val pendingSessions = sessionFilter?.let {  getRealm().where<Session>().alwaysFalse().findAll() } ?: run { getRealm().where<Session>().isNull("year").isNull("month").findAll().sort("startDate", Sort.DESCENDING) }
+        val distinctDateSessions = sessionFilter?.results("year", "month") ?: run { getRealm().where<Session>().distinct("year", "month").findAll() }.sort("startDate", Sort.DESCENDING)
+        this.feedSessionAdapter = FeedSessionRowRepresentableAdapter(this, realmSessions, pendingSessions, distinctDateSessions)
+    }
+
+    private fun loadTransactions(filter : Filter? = null) {
         val transactionFilter: Filter? = filter?.let {
             if (it.filterableType == FilterableType.TRANSACTION) {
                 it
@@ -192,35 +215,17 @@ class FeedFragment : FilterableFragment(), RowRepresentableDelegate {
             }
         }
 
-		// Sessions
+        // Transactions
-		this.realmSessions = sessionFilter?.results() ?: run { getRealm().where<Session>().findAll() }.sort("startDate", Sort.DESCENDING)
+        this.realmTransactions = transactionFilter?.results() ?: run { getRealm().where<Transaction>().findAll()}.sort("date", Sort.DESCENDING)
-        this.realmSessions.addChangeListener { _, _ ->
+        this.realmTransactions.addChangeListener { _, _ ->
-			this.feedSessionAdapter.refreshData()
+            this.feedTransactionAdapter.refreshData()
-			this.feedSessionAdapter.notifyDataSetChanged()
+            this.feedTransactionAdapter.notifyDataSetChanged()
-		}
+        }
-
-
-		val pendingSessions = sessionFilter?.let {  getRealm().where<Session>().alwaysFalse().findAll() } ?: run { getRealm().where<Session>().isNull("year").isNull("month").findAll().sort("startDate", Sort.DESCENDING) }
-		val distinctDateSessions = sessionFilter?.results("year", "month") ?: run { getRealm().where<Session>().distinct("year", "month").findAll() }.sort("startDate", Sort.DESCENDING)
-		this.feedSessionAdapter = FeedSessionRowRepresentableAdapter(this, realmSessions, pendingSessions, distinctDateSessions)
-
-		// Transactions
-		this.realmTransactions = transactionFilter?.results() ?: run { getRealm().where<Transaction>().findAll()}.sort("date", Sort.DESCENDING)
-		this.realmTransactions.addChangeListener { _, _ ->
-			this.feedTransactionAdapter.refreshData()
-			this.feedTransactionAdapter.notifyDataSetChanged()
-		}
 
-		val distinctDateTransactions = transactionFilter?.results("year", "month") ?: run { getRealm().where<Transaction>().distinct("year", "month").findAll() }.sort("date", Sort.DESCENDING)
+        val distinctDateTransactions = transactionFilter?.results("year", "month") ?: run { getRealm().where<Transaction>().distinct("year", "month").findAll() }.sort("date", Sort.DESCENDING)
-		this.feedTransactionAdapter = FeedTransactionRowRepresentableAdapter(this, realmTransactions, distinctDateTransactions)
+        this.feedTransactionAdapter = FeedTransactionRowRepresentableAdapter(this, realmTransactions, distinctDateTransactions)
 
-		val viewManager = SmoothScrollLinearLayoutManager(requireContext())
+    }
-		recyclerView.apply {
-			setHasFixedSize(true)
-			layoutManager = viewManager
-			adapter = feedSessionAdapter
-		}
-	}
 
 	/**
 	 * Create a new cash game
@@ -282,11 +287,26 @@ class FeedFragment : FilterableFragment(), RowRepresentableDelegate {
     }
 
     override fun applyFilter() {
-        initData()
+        val filter: Filter? = this.currentFilter(this.requireContext(), getRealm())
+        this.loadSessions(filter)
+        this.loadTransactions(filter)
+        filter?.let {
+            if (it.filterableType == FilterableType.SESSION) {
+                recyclerView.adapter = feedSessionAdapter
+            } else {
+                recyclerView.adapter = feedTransactionAdapter
+            }
+        }
     }
 
     override fun removeFilter() {
-        initData()
+        this.loadSessions()
+        this.loadTransactions()
+        if (currentFilterable== FilterableType.SESSION) {
+            recyclerView.adapter = feedSessionAdapter
+        } else {
+            recyclerView.adapter = feedTransactionAdapter
+        }
     }
 
     override var currentFilterable: FilterableType = FilterableType.SESSION

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

@@ -161,7 +161,9 @@ class StatisticsFragment : FilterableFragment(), FilterHandler {
 	 */
 	private fun createSessionGroupsAndStartCompute(realm: Realm): Report {
 
-		val filter: Filter? = this.currentFilter(this.requireContext(), realm)
+		val filter: Filter? = this.currentFilter(this.requireContext(), realm)?.let {
+            if (it.filterableType == currentFilterable) { it } else { null }
+        }
 
 		val allStats: List<Stat> = listOf(
 			Stat.NET_RESULT,