add filter realm save / load test

app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt

@@ -0,0 +1,70 @@
+package net.pokeranalytics.android.filter
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import net.pokeranalytics.android.model.filter.FilterType
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategory
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElement
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSection
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.*
+
+@RunWith(AndroidJUnit4::class)
+class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
+
+    @Test
+    fun testSaveLoadCashFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val filter = Filter()
+        filter.name = "testSaveLoadCashFilter"
+
+        val filterElement = FilterElement.Cash
+        filterElement.filterSection = FilterSection.CASH_TOURNAMENT
+        filter.componentsFrom(arrayListOf(filterElement))
+
+        val useCount = filter.countBy(FilterCategory.GENERAL)
+        Assert.assertEquals(1, useCount)
+
+        val isCash = filter.contains(filterElement)
+        Assert.assertEquals(true, isCash)
+
+        val filterComponent = filter.components.first()
+
+        filterComponent?.let {
+            Assert.assertEquals(FilterType.CASH, FilterType.valueOf(it.filterName))
+        } ?: run {
+            Assert.fail()
+        }
+
+        Session.testInstance(100.0, false, Date(), 1)
+        Session.testInstance(100.0, true, Date(), 1)
+
+        realm.copyToRealm(filter)
+        realm.commitTransaction()
+
+        val newRealm = this.mockRealm
+        newRealm.beginTransaction()
+        newRealm.where(Filter::class.java).equalTo("name", "testSaveLoadCashFilter").findFirst()?.let { foundFilter ->
+            val loadedFilter = newRealm.copyFromRealm(foundFilter)
+            val sessions = loadedFilter.filter(
+                realm,
+                Session::class.java,
+                loadedFilter.components.map {
+                    it.filterType
+                }
+            )
+
+            Assert.assertEquals(1, sessions.size)
+            sessions[0]?.run {
+                Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type)
+            }
+        } ?: run {
+            Assert.fail()
+        }
+    }
+}

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

@@ -244,6 +244,10 @@ enum class FilterType(private var fieldName:String? = null, private var subType:
     }
 
     override fun setValueFrom(filterComponent: FilterComponent) {
+        if (filterValuesExpectedKeys == null) {
+            return
+        }
+
         this.subType?.let { subType ->
             this.fieldName?.let {
                 return when (subType) {

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

@@ -1,9 +1,8 @@
 package net.pokeranalytics.android.model.realm
 
-import io.realm.MutableRealmInteger
-import io.realm.RealmList
-import io.realm.RealmObject
+import io.realm.*
 import io.realm.annotations.PrimaryKey
+import net.pokeranalytics.android.model.filter.interfaces.Filterable
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategory
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElement
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSection
@@ -25,6 +24,7 @@ open class Filter : RealmObject() {
     val usageCount: MutableRealmInteger = MutableRealmInteger.valueOf(0)
 
     var components: RealmList<FilterComponent> = RealmList()
+        private set
 
     fun componentsFrom(filterElements: ArrayList<FilterElement>) {
         components.clear()
@@ -50,43 +50,29 @@ open class Filter : RealmObject() {
             }
     }
 
-    fun numberOfElementIn(filterCategory: FilterCategory) : Int {
+    fun countBy(filterCategory: FilterCategory) : Int {
         val sections = FilterSection.filterSectionsFor(filterCategory)
         return components.count {
             sections.contains(FilterSection.valueOf(it.sectionName))
         }
     }
 
-    fun isFilterElementExists(filterElement:FilterElement) : Boolean {
-
+    fun contains(filterElement:FilterElement) : Boolean {
         val filtered = components.filter {
-            it.filterType == filterElement.filterType
+            it.filterName == filterElement.filterName
         }
-
         if (filtered.isEmpty()) {
             return false
         }
+        return filterElement.contains(filtered)
+    }
 
-        return when (filterElement) {
-            is FilterElement.Game -> filtered.filter {
-                it.ids?.contains(filterElement.game.id) ?: false
-            }.isNotEmpty()
-            is FilterElement.Year -> TODO()
-            is FilterElement.Month -> TODO()
-            is FilterElement.Day -> TODO()
-            is FilterElement.Limit -> TODO()
-            is FilterElement.TableSize -> TODO()
-            is FilterElement.Bankroll -> TODO()
-            is FilterElement.Location -> TODO()
-            is FilterElement.TournamentName -> TODO()
-            is FilterElement.TournamentFeature -> TODO()
-
-            is FilterElement.From -> TODO()
-            is FilterElement.To -> TODO()
-            is FilterElement.PastDays -> TODO()
-
-
-            else -> return true
+    fun filter(realm: Realm, relatedEntity: Class<out RealmObject>, queries:List<Filterable>): RealmResults<*> {
+        var realmQuery : RealmQuery<out RealmObject> = realm.where(relatedEntity)
+        queries.forEach {
+            realmQuery = (it.filter(realmQuery))
         }
+        return realmQuery.findAll()
     }
+
 }

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

@@ -11,7 +11,7 @@ import kotlin.collections.ArrayList
 
 open class FilterComponent(var filterName : String = "", var sectionName: String = "") : RealmObject() {
 
-    constructor(filterElements: ArrayList<FilterElement>) : this(filterElements.first().filterType.name, filterElements.first().filterSection.name) {
+    constructor(filterElements: ArrayList<FilterElement>) : this(filterElements.first().filterName, filterElements.first().sectionName) {
         this.ids = when (FilterType.valueOf(this.filterName)) {
             FilterType.GAME -> {
                 RealmList<String>().apply {
@@ -35,7 +35,7 @@ open class FilterComponent(var filterName : String = "", var sectionName: String
         }
     }
 
-    constructor(filterElement:FilterElement) : this(filterElement.filterType.name, filterElement.filterSection.name) {
+    constructor(filterElement:FilterElement) : this(filterElement.filterName, filterElement.sectionName) {
         when (filterElement) {
             is From -> date = filterElement.date
             is To -> date = filterElement.date

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterRow.kt

@@ -5,11 +5,14 @@ import net.pokeranalytics.android.R
 import net.pokeranalytics.android.exceptions.FilterValueMapException
 import net.pokeranalytics.android.model.LiveData
 import net.pokeranalytics.android.model.filter.FilterType
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.model.realm.FilterComponent
 import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.RowViewType
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSection.*
 import java.lang.Exception
 import java.util.*
+import kotlin.collections.ArrayList
 
 sealed class FilterElement : RowRepresentable {
 	companion object {
@@ -113,7 +116,10 @@ sealed class FilterElement : RowRepresentable {
 
 	lateinit var filterSection: FilterSection
 
-	val filterType : FilterType
+	val filterName : String = this.filterType.name
+	val sectionName : String = this.filterSection.name
+
+	private val filterType : FilterType
 		get() {
 			return when (this) {
 				is Cash -> FilterType.CASH
@@ -148,6 +154,28 @@ sealed class FilterElement : RowRepresentable {
 			}
 		}
 
+	fun contains(filterComponents: List<FilterComponent>) : Boolean {
+		return when (this) {
+			is Game -> filterComponents.any {
+				it.ids?.contains(this.game.id) ?: false
+			}
+			is From -> TODO()
+			is To -> TODO()
+			is Year -> TODO()
+			is Month -> TODO()
+			is Day -> TODO()
+			is PastDays -> TODO()
+			is Limit -> TODO()
+			is TableSize -> TODO()
+			is Bankroll -> TODO()
+			is Location -> TODO()
+			is TournamentName -> TODO()
+			is TournamentFeature -> TODO()
+			else -> return true
+		}
+	}
+
+
 	override val resId: Int?
 		get() {
 			return when (this) {