diff --git a/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt index 45faaaef..b5be8a04 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt @@ -32,16 +32,14 @@ open class RealmInstrumentedUnitTest { val testConfig = RealmConfiguration.Builder().inMemory().name("test-realm").build() Realm.setDefaultConfiguration(testConfig) this.mockRealm = Realm.getDefaultInstance() - - this.mockRealm.executeTransaction { - this.mockRealm.deleteAll() - } - + this.mockRealm.beginTransaction() + this.mockRealm.deleteAll() + this.mockRealm.commitTransaction() } @After @Throws(Exception::class) - public fun tearDown() { + fun tearDown() { this.mockRealm.close() } diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt index b4d27bde..cfd3ce64 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt @@ -1,8 +1,8 @@ package net.pokeranalytics.android.filter -import net.pokeranalytics.android.model.filter.FilterManager import net.pokeranalytics.android.model.filter.FilterType import net.pokeranalytics.android.model.realm.Bankroll +import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.Session import org.junit.Assert import org.junit.Test @@ -44,9 +44,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { "code" to null ))) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -91,9 +91,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { "code" to null ))) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -138,9 +138,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { "code" to "AUD" ))) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -191,9 +191,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() { "code" to null ))) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt index 7f611d41..ca6f2f21 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt @@ -2,7 +2,7 @@ package net.pokeranalytics.android.filter import androidx.test.ext.junit.runners.AndroidJUnit4 import net.pokeranalytics.android.model.filter.FilterType -import net.pokeranalytics.android.model.filter.FilterManager +import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.Session import org.junit.Assert import org.junit.Test @@ -29,9 +29,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { cal.time = s1.startDate filter.valueMap = mapOf("dayOfWeek" to cal.get(Calendar.DAY_OF_WEEK)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -58,9 +58,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { cal.time = s1.startDate filter.valueMap = mapOf("month" to cal.get(Calendar.MONTH)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -87,9 +87,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { cal.time = s1.startDate filter.valueMap = mapOf("year" to cal.get(Calendar.YEAR)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -113,9 +113,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, cal.time) realm.commitTransaction() - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(FilterType.WEEK_END) ) @@ -138,9 +138,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, cal.time) realm.commitTransaction() - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(FilterType.WEEK_DAY) ) @@ -168,9 +168,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.STARTED_FROM_DATE filter.valueMap = mapOf("date" to s2.startDate) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -198,9 +198,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.STARTED_TO_DATE filter.valueMap = mapOf("date" to s1.startDate) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -229,9 +229,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.ENDED_FROM_DATE filter.valueMap = mapOf("date" to s2.endDate) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -260,9 +260,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.ENDED_TO_DATE filter.valueMap = mapOf("date" to s1.endDate) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt index b2976510..1e9aeeea 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt @@ -3,7 +3,7 @@ package net.pokeranalytics.android.filter import androidx.test.ext.junit.runners.AndroidJUnit4 import net.pokeranalytics.android.exceptions.FilterValueMapException import net.pokeranalytics.android.model.filter.FilterType -import net.pokeranalytics.android.model.filter.FilterManager +import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.Session import org.junit.Test import org.junit.runner.RunWith @@ -12,25 +12,15 @@ import java.util.* @RunWith(AndroidJUnit4::class) class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() { - @Test(expected = FilterValueMapException::class) - fun testFilterException() { - val realm = this.mockRealm - FilterManager().filter( - realm, - Session::class.java, - arrayListOf(FilterType.BLINDS) - ) - } - @Test(expected = FilterValueMapException::class) fun testValueKeyFilterException() { val filter = FilterType.STARTED_FROM_DATE filter.valueMap = mapOf("bob" to Date()) val realm = this.mockRealm - FilterManager().filter( + Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) } @@ -45,10 +35,20 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() { ))) val realm = this.mockRealm - FilterManager().filter( + Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) } + + @Test(expected = FilterValueMapException::class) + fun testXFilterException() { + val realm = this.mockRealm + Filter.queryOn( + realm, + Session, + arrayListOf(FilterType.BLINDS) + ) + } } \ No newline at end of file diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt index a287d9f5..712cc6ad 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt @@ -48,20 +48,14 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { 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 - } - ) + val sessions = foundFilter.queryOn(Session) Assert.assertEquals(1, sessions.size) sessions[0]?.run { Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type) + } ?: run { + Assert.fail() } } ?: run { Assert.fail() diff --git a/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt index e3d9896c..86513d6f 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt @@ -2,7 +2,6 @@ package net.pokeranalytics.android.filter import androidx.test.ext.junit.runners.AndroidJUnit4 import io.realm.RealmList -import net.pokeranalytics.android.model.filter.FilterManager import net.pokeranalytics.android.model.filter.FilterType import net.pokeranalytics.android.model.realm.* import org.junit.Assert @@ -23,9 +22,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1) realm.commitTransaction() - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(FilterType.CASH) ) @@ -45,9 +44,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1) realm.commitTransaction() - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(FilterType.TOURNAMENT) ) @@ -72,9 +71,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1, b2) realm.commitTransaction() - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(FilterType.LIVE) ) @@ -98,9 +97,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { Session.testInstance(100.0, true, Date(), 1, b2) realm.commitTransaction() - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(FilterType.ONLINE) ) @@ -125,9 +124,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.BANKROLL filter.valueMap = mapOf("ids" to arrayOf(b1.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -158,9 +157,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.BANKROLL filter.valueMap = mapOf("ids" to arrayOf(b1.id, b2.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -186,9 +185,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.GAME filter.valueMap = mapOf("ids" to arrayOf(g2.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -219,9 +218,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.GAME filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -247,9 +246,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.LOCATION filter.valueMap = mapOf("ids" to arrayOf(l1.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -280,9 +279,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.LOCATION filter.valueMap = mapOf("ids" to arrayOf(l1.id, l3.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -308,9 +307,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.TOURNAMENT_NAME filter.valueMap = mapOf("ids" to arrayOf(t1.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -341,9 +340,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.TOURNAMENT_NAME filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -377,9 +376,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.ALL_TOURNAMENT_FEATURES filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -410,9 +409,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.ANY_TOURNAMENT_FEATURES filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -440,9 +439,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.ANY_TOURNAMENT_FEATURES filter.valueMap = mapOf("ids" to arrayOf(t2.id)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -467,9 +466,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.TABLE_SIZE filter.valueMap = mapOf("values" to arrayOf(2,4)) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -494,9 +493,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.MORE_THAN_NET_RESULT filter.valueMap = mapOf("value" to 204.0) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -521,9 +520,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filter = FilterType.LESS_THAN_NET_RESULT filter.valueMap = mapOf("value" to 540.0) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filter) ) @@ -551,9 +550,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() { val filterLess = FilterType.LESS_THAN_NET_RESULT filterLess.valueMap = mapOf("value" to 400.0) - val sessions = FilterManager().filter( + val sessions = Filter.queryOn( realm, - Session::class.java, + Session, arrayListOf(filterMore, filterLess) ) diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/FilterEntityDataSource.kt similarity index 72% rename from app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt rename to app/src/main/java/net/pokeranalytics/android/model/filter/FilterEntityDataSource.kt index aa6510af..ce8e0a2a 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/FilterEntityDataSource.kt @@ -1,10 +1,6 @@ package net.pokeranalytics.android.model.filter -import io.realm.Realm import io.realm.RealmObject -import io.realm.RealmQuery -import io.realm.RealmResults -import net.pokeranalytics.android.model.filter.interfaces.Filterable /** * We want to be able to store filters in the database: @@ -32,15 +28,12 @@ import net.pokeranalytics.android.model.filter.interfaces.Filterable * */ -class FilterManager { - fun filter(realm:Realm, relatedEntity: Class, queries:List): RealmResults<*> { - var realmQuery : RealmQuery = realm.where(relatedEntity) - queries.forEach { - realmQuery = (it.filter(realmQuery)) - } - return realmQuery.findAll() - } +interface FilterEntityDataSource { + val relatedEntity: Class + fun fieldNameForQueryType(filterType: FilterType) : String? + } + // //fun MutableList.filter(filter: FilterComponent) : List { // diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/FilterType.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/FilterType.kt index 4a32f51c..f7e8bdf4 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/FilterType.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/filter/FilterType.kt @@ -3,43 +3,68 @@ package net.pokeranalytics.android.model.filter import io.realm.RealmObject import io.realm.RealmQuery import net.pokeranalytics.android.exceptions.FilterValueMapException -import net.pokeranalytics.android.model.filter.interfaces.Filterable import net.pokeranalytics.android.model.realm.FilterComponent import net.pokeranalytics.android.model.realm.Session import java.util.* -enum class FilterType(private var fieldName:String? = null, private var subType:SubType? = null): Filterable { +/** + * We want to be able to store filters in the database: + * - filters can be a combination of sub filters + * - filters can be applied to different type of objects: Sessions, Hands, Transactions... + * - filters can be applied to a list of different type of objects (feed) + * + * A filter is described by the following: + * - a data type: Session, Hands... + * - a field: table size of a Session + * - an operator: equal, >=, <... + * - a value: an id, a number, a date... + * + * We can decide to have a collection of [operator, value] for a field + * + * Combination: + * - multiple datatype filters should be handled as 'OR' + * - multiple field filters should be handled as 'AND' + * - multiple '=' filters as 'OR' + * - multiple 'Greater than', 'less than' as 'AND' + * - multiple values as 'OR' + * + * Also: + * A filter should be able to be converted into a Realm query + * + */ + +enum class FilterType(private var subType:SubType? = null) { LIVE, CASH, ONLINE, TOURNAMENT, - BANKROLL("bankroll.id"), - GAME("game.id"), - TOURNAMENT_NAME("tournamentName.id"), + BANKROLL, + GAME, + TOURNAMENT_NAME, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES, - LOCATION("location.id"), - LIMIT("limit"), - TABLE_SIZE("tableSize"), - TOURNAMENT_TYPE("tournamentType"), + LOCATION, + LIMIT, + TABLE_SIZE, + TOURNAMENT_TYPE, BLINDS, - MORE_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.MORE), - LESS_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.LESS), - BETWEEN_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.BETWEEN), - MORE_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.MORE), - LESS_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.LESS), - MORE_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.MORE), - LESS_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.LESS), - MORE_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.MORE), - LESS_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.LESS), - MORE_THAN_TIPS(Field.TIPS.fieldName, SubType.MORE), - LESS_THAN_TIPS(Field.TIPS.fieldName, SubType.LESS), - MORE_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.MORE), - LESS_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.LESS), - BETWEEN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.BETWEEN), - MORE_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.MORE), - LESS_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.LESS), - BETWEEN_TOURNAMENT_FEE(Field.TOURNAMENT_FEE.fieldName, SubType.BETWEEN), + MORE_NUMBER_OF_TABLE(SubType.MORE), + LESS_NUMBER_OF_TABLE(SubType.LESS), + BETWEEN_NUMBER_OF_TABLE(SubType.BETWEEN), + MORE_THAN_NET_RESULT(SubType.MORE), + LESS_THAN_NET_RESULT(SubType.LESS), + MORE_THAN_BUY_IN(SubType.MORE), + LESS_THAN_BUY_IN(SubType.LESS), + MORE_THAN_CASH_OUT(SubType.MORE), + LESS_THAN_CASH_OUT(SubType.LESS), + MORE_THAN_TIPS(SubType.MORE), + LESS_THAN_TIPS(SubType.LESS), + MORE_THAN_NUMBER_OF_PLAYER(SubType.MORE), + LESS_THAN_NUMBER_OF_PLAYER(SubType.LESS), + BETWEEN_NUMBER_OF_PLAYER(SubType.BETWEEN), + MORE_THAN_TOURNAMENT_FEE(SubType.MORE), + LESS_THAN_TOURNAMENT_FEE(SubType.LESS), + BETWEEN_TOURNAMENT_FEE(SubType.BETWEEN), // Dates STARTED_FROM_DATE, @@ -52,42 +77,21 @@ enum class FilterType(private var fieldName:String? = null, private var subType: WEEK_DAY, WEEK_END, + CURRENCY, + CURRENCY_CODE, + BIG_BLIND, + SMALL_BLIND, + COMMENT, + ; - enum class SubType { + private enum class SubType { BETWEEN, MORE, LESS; } - private enum class Field(var fieldName:String) { - LIVE("bankroll.live"), - CASH("type"), - CURRENCY("bankroll.currency"), - CURRENCY_CODE("bankroll.currency.code"), - BIG_BLIND("cgBigBlind"), - SMALL_BLIND("cgSmallBlind"), - COMMENT("comment"), - TOURNAMENT_FEATURES("tournamentFeatures.id"), - NET_RESULT("computableResults.ratedNet"), - BUY_IN("result.buyin"), - CASH_OUT("result.cashout"), - TIPS("result.tips"), - NUMBER_OF_TABLE("numberOfTable"), - NUMBER_OF_PLAYER("tournamentNumberOfPlayers"), - TOURNAMENT_FEE("tournamentEntryFee"), - START_DATE("startDate"), - END_DATE("endDate"), - DAY("dayOfWeek"), - MONTH("month"), - YEAR("year"), - - ; - } - - override var valueMap : Map? = null - - override val filterValuesExpectedKeys : Array? + private val filterValuesExpectedKeys : Array? get() { this.subType?.let { return when (it) { @@ -107,66 +111,17 @@ enum class FilterType(private var fieldName:String? = null, private var subType: } } - override fun filter(realmQuery: RealmQuery): RealmQuery { + fun filter(realmQuery: RealmQuery, filterEntityDataSource: FilterEntityDataSource): RealmQuery { + when { + this == BLINDS -> { + val smallBlindFieldName = filterEntityDataSource.fieldNameForQueryType(SMALL_BLIND) + val bigBlindFieldName = filterEntityDataSource.fieldNameForQueryType(BIG_BLIND) + val currencyCodeFieldName = filterEntityDataSource.fieldNameForQueryType(CURRENCY_CODE) + smallBlindFieldName ?: throw FilterValueMapException("fieldName is missing") + bigBlindFieldName ?: throw FilterValueMapException("fieldName is missing") + currencyCodeFieldName ?: throw FilterValueMapException("fieldName is missing") - this.subType?.let {subType -> - this.fieldName?.let { - return when (subType) { - SubType.LESS -> { - val value: Double by filterValues - println("filter test less") - realmQuery.lessThanOrEqualTo(it, value) - } - SubType.MORE -> { - println("filter test more") - val value: Double by filterValues - realmQuery.greaterThanOrEqualTo(it, value) - } - SubType.BETWEEN -> { - val leftValue: Double by filterValues - val rightValue: Double by filterValues - realmQuery.between(it, leftValue, rightValue) - } - } - } ?: run { - throw FilterValueMapException("fieldName is missing") - } - } - - return when (this) { - LIVE -> realmQuery.equalTo(Field.LIVE.fieldName, true) - CASH -> realmQuery.equalTo(Field.CASH.fieldName, Session.Type.CASH_GAME.ordinal) - ONLINE -> LIVE.filter(realmQuery.not()) - TOURNAMENT -> CASH.filter(realmQuery.not()) - ALL_TOURNAMENT_FEATURES -> { - val ids : Array by filterValues - ids.forEach { - realmQuery.equalTo(Field.TOURNAMENT_FEATURES.fieldName, it) - } - realmQuery - } - ANY_TOURNAMENT_FEATURES -> { - val ids : Array by filterValues - realmQuery.`in`(Field.TOURNAMENT_FEATURES.fieldName, ids) - } - BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { - val ids : Array by filterValues - this.fieldName?.let { - realmQuery.`in`(it, ids) - } ?: run { - throw FilterValueMapException("fieldName is missing") - } - } - LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { - val values : Array? by filterValues - this.fieldName?.let { - realmQuery.`in`(it, values) - } ?: run { - throw FilterValueMapException("fieldName is missing") - } - } - BLINDS -> { - val blinds : Array> by filterValues + val blinds: Array> by valueMap val expectedSubKeys = arrayOf("sb", "bb", "code") blinds.forEachIndexed { index, subMap -> val missingKeys = subMap.keys.filter { !expectedSubKeys.contains(it) } @@ -174,27 +129,27 @@ enum class FilterType(private var fieldName:String? = null, private var subType: throw FilterValueMapException("subValueMap does not contain $missingKeys") } - val sb : Double? by subMap - val bb : Double? by subMap - val code : String? by subMap + val sb: Double? by subMap + val bb: Double? by subMap + val code: String? by subMap realmQuery .beginGroup() sb?.let { realmQuery - .equalTo(Field.SMALL_BLIND.fieldName, sb) + .equalTo(smallBlindFieldName, sb) .and() } realmQuery - .equalTo(Field.BIG_BLIND.fieldName, bb) + .equalTo(bigBlindFieldName, bb) .and() code?.let { - realmQuery.equalTo(Field.CURRENCY_CODE.fieldName, code) + realmQuery.equalTo(currencyCodeFieldName, code) } ?: run { - realmQuery.isNull(Field.CURRENCY_CODE.fieldName) + realmQuery.isNull(currencyCodeFieldName) } realmQuery.endGroup() @@ -203,94 +158,155 @@ enum class FilterType(private var fieldName:String? = null, private var subType: realmQuery.or() } } - realmQuery - } - STARTED_FROM_DATE -> { - val date : Date by filterValues - realmQuery.greaterThanOrEqualTo(Field.START_DATE.fieldName, date) - } - STARTED_TO_DATE -> { - val date : Date by filterValues - realmQuery.lessThanOrEqualTo(Field.START_DATE.fieldName, date) - } - ENDED_FROM_DATE -> { - val date : Date by filterValues - realmQuery.greaterThanOrEqualTo(Field.END_DATE.fieldName, date) - } - ENDED_TO_DATE -> { - val date : Date by filterValues - realmQuery.lessThanOrEqualTo(Field.END_DATE.fieldName, date) - } - DAY_OF_WEEK -> { - val dayOfWeek : Int by filterValues - realmQuery.equalTo(Field.DAY.fieldName, dayOfWeek) - } - MONTH -> { - val month: Int by filterValues - realmQuery.equalTo(Field.MONTH.fieldName, month) - } - YEAR -> { - val year: Int by filterValues - realmQuery.equalTo(Field.YEAR.fieldName, year) + return realmQuery } - WEEK_END -> { - realmQuery.`in`(Field.DAY.fieldName, arrayOf(Calendar.SATURDAY,Calendar.SUNDAY)) - } - WEEK_DAY -> WEEK_END.filter(realmQuery.not()) + this == ONLINE -> return LIVE.filter(realmQuery.not(), filterEntityDataSource) + this == TOURNAMENT -> return CASH.filter(realmQuery.not(), filterEntityDataSource) + this == WEEK_DAY -> return WEEK_END.filter(realmQuery.not(), filterEntityDataSource) else -> { - throw FilterValueMapException("filter type not handled") + val fieldName = filterEntityDataSource.fieldNameForQueryType(this) + fieldName ?: throw FilterValueMapException("fieldName is missing") + + this.subType?.let { subType -> + return when (subType) { + SubType.LESS -> { + val value: Double by valueMap + realmQuery.lessThanOrEqualTo(fieldName, value) + } + SubType.MORE -> { + val value: Double by valueMap + realmQuery.greaterThanOrEqualTo(fieldName, value) + } + SubType.BETWEEN -> { + val leftValue: Double by valueMap + val rightValue: Double by valueMap + realmQuery.between(fieldName, leftValue, rightValue) + } + } + } + + return when (this) { + LIVE -> realmQuery.equalTo(fieldName, true) + CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) + ALL_TOURNAMENT_FEATURES -> { + val ids: Array by valueMap + ids.forEach { + realmQuery.equalTo(fieldName, it) + } + realmQuery + } + ANY_TOURNAMENT_FEATURES -> { + val ids: Array by valueMap + realmQuery.`in`(fieldName, ids) + } + BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { + val ids: Array by valueMap + realmQuery.`in`(fieldName, ids) + } + LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { + val values: Array? by valueMap + realmQuery.`in`(fieldName, values) + } + STARTED_FROM_DATE -> { + val date: Date by valueMap + realmQuery.greaterThanOrEqualTo(fieldName, date) + } + STARTED_TO_DATE -> { + val date: Date by valueMap + realmQuery.lessThanOrEqualTo(fieldName, date) + } + ENDED_FROM_DATE -> { + val date: Date by valueMap + realmQuery.greaterThanOrEqualTo(fieldName, date) + } + ENDED_TO_DATE -> { + val date: Date by valueMap + realmQuery.lessThanOrEqualTo(fieldName, date) + } + DAY_OF_WEEK -> { + val dayOfWeek: Int by valueMap + realmQuery.equalTo(fieldName, dayOfWeek) + } + MONTH -> { + val month: Int by valueMap + realmQuery.equalTo(fieldName, month) + } + YEAR -> { + val year: Int by valueMap + realmQuery.equalTo(fieldName, year) + } + WEEK_END -> { + realmQuery.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY)) + } + else -> { + throw FilterValueMapException("filter type not handled") + } + } } } + } - override fun setValueFrom(filterComponent: FilterComponent) { + fun setValueFrom(filterComponent: FilterComponent) { if (filterValuesExpectedKeys == null) { return } this.subType?.let { subType -> - this.fieldName?.let { - return when (subType) { - SubType.LESS, SubType.MORE -> { - filterValues = mapOf("value" to filterComponent.value) - } - SubType.BETWEEN -> { - filterValues = mapOf( - "leftValue" to filterComponent.leftValue, - "rightValue" to filterComponent.rightValue - ) - } + valueMap = when (subType) { + SubType.LESS, SubType.MORE -> { + mapOf("value" to filterComponent.value) + } + SubType.BETWEEN -> { + mapOf( + "leftValue" to filterComponent.leftValue, + "rightValue" to filterComponent.rightValue + ) } - } ?: run { - throw FilterValueMapException("fieldName is missing") } } when (this) { ALL_TOURNAMENT_FEATURES, ANY_TOURNAMENT_FEATURES, BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { - filterValues = mapOf("ids" to filterComponent.ids) + valueMap = mapOf("ids" to filterComponent.ids) } LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { - filterValues = mapOf("values" to filterComponent.values) + valueMap = mapOf("values" to filterComponent.values) } BLINDS -> { - filterValues = mapOf("blinds" to filterComponent.blinds) + valueMap = mapOf("blinds" to filterComponent.blinds) } STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> { - filterValues = mapOf("date" to filterComponent.date) + valueMap = mapOf("date" to filterComponent.date) } DAY_OF_WEEK -> { - filterValues = mapOf("dayOfWeek" to filterComponent.dayOfWeek) + valueMap = mapOf("dayOfWeek" to filterComponent.dayOfWeek) } MONTH -> { - filterValues = mapOf("month" to filterComponent.month) + valueMap = mapOf("month" to filterComponent.month) } YEAR -> { - filterValues = mapOf("year" to filterComponent.year) + valueMap = mapOf("year" to filterComponent.year) } else -> { throw FilterValueMapException("filter type not handled") } } } + + var valueMap : Map? = null + get() { + this.filterValuesExpectedKeys?.let { valueMapExceptedKeys -> + field?.let { map -> + val missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) } + if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) { + throw FilterValueMapException("valueMap does not contain $missingKeys") + } + } ?: run { + throw FilterValueMapException("valueMap null not expected") + } + } + return field + } + } \ No newline at end of file diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt deleted file mode 100644 index 509ee118..00000000 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt +++ /dev/null @@ -1,8 +0,0 @@ -package net.pokeranalytics.android.model.filter.interfaces - -import io.realm.RealmObject -import io.realm.RealmQuery - -interface Filterable : ValueFilterable { - fun filter(realmQuery: RealmQuery): RealmQuery -} diff --git a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt b/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt deleted file mode 100644 index f49f6f2a..00000000 --- a/app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt +++ /dev/null @@ -1,31 +0,0 @@ -package net.pokeranalytics.android.model.filter.interfaces - -import net.pokeranalytics.android.exceptions.FilterValueMapException -import net.pokeranalytics.android.model.realm.FilterComponent - -interface ValueFilterable { - - var valueMap: Map? - - var filterValues : Map? - get() { - this.filterValuesExpectedKeys?.let { valueMapExceptedKeys -> - valueMap?.let { map -> - var missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) } - if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) { - throw FilterValueMapException("valueMap does not contain ${missingKeys}") - } - } ?: run { - throw FilterValueMapException("valueMap null not expected") - } - } - return this.valueMap - } - set(value) { - valueMap = value - } - - val filterValuesExpectedKeys : Array? - - fun setValueFrom(filterComponent: FilterComponent) -} \ No newline at end of file diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt index e3a6522c..4567c982 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt @@ -2,17 +2,25 @@ package net.pokeranalytics.android.model.realm import io.realm.* import io.realm.annotations.PrimaryKey -import net.pokeranalytics.android.model.filter.interfaces.Filterable +import net.pokeranalytics.android.model.filter.FilterEntityDataSource +import net.pokeranalytics.android.model.filter.FilterType import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow import java.util.* -//import net.pokeranalytics.android.FilterComponent - - open class Filter : RealmObject() { + companion object { + fun queryOn(realm: Realm, entity: FilterEntityDataSource, queries:List): RealmResults<*> { + var realmQuery : RealmQuery = realm.where(entity.relatedEntity) + queries.forEach { + realmQuery = (it.filter(realmQuery, entity)) + } + return realmQuery.findAll() + } + } + @PrimaryKey var id = UUID.randomUUID().toString() @@ -67,12 +75,14 @@ open class Filter : RealmObject() { return filterElementRow.contains(filtered) } - fun filter(realm: Realm, relatedEntity: Class, queries:List): RealmResults<*> { - var realmQuery : RealmQuery = realm.where(relatedEntity) - queries.forEach { - realmQuery = (it.filter(realmQuery)) + fun queryOn(entity: FilterEntityDataSource) : RealmResults<*> { + var realmQuery : RealmQuery = realm.where(entity.relatedEntity) + this.components.map { + it.filterType + }.forEach { + realmQuery = (it.filter(realmQuery, entity)) } + return realmQuery.findAll() } - } diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt index 1690abaf..2d403971 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt @@ -20,6 +20,9 @@ import net.pokeranalytics.android.model.TableSize import net.pokeranalytics.android.model.TournamentType import net.pokeranalytics.android.model.extensions.SessionState import net.pokeranalytics.android.model.extensions.getState +import net.pokeranalytics.android.model.filter.FilterEntityDataSource +import net.pokeranalytics.android.model.filter.FilterType +import net.pokeranalytics.android.model.filter.FilterType.* import net.pokeranalytics.android.model.filter.interfaces.TimeFilterable import net.pokeranalytics.android.model.interfaces.Manageable import net.pokeranalytics.android.model.interfaces.Timed @@ -47,11 +50,10 @@ open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource TOURNAMENT } - companion object { + companion object : FilterEntityDataSource { fun newInstance(realm: Realm, isTournament: Boolean, bankroll: Bankroll? = null): Session { val session = Session() session.result = Result() - if (bankroll != null) { session.bankroll = bankroll } else { @@ -60,6 +62,41 @@ open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource session.type = if (isTournament) Session.Type.TOURNAMENT.ordinal else Session.Type.CASH_GAME.ordinal return realm.copyToRealm(session) } + + override val relatedEntity: Class = Session::class.java + + override fun fieldNameForQueryType(filterType: FilterType): String? { + return when (filterType) { + LIVE -> "bankroll.live" + CASH -> "type" + BANKROLL -> "bankroll.id" + GAME -> "game.id" + TOURNAMENT_NAME -> "tournamentName.id" + ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> "tournamentFeatures.id" + LOCATION -> "location.id" + LIMIT -> "limit" + TABLE_SIZE -> "tableSize" + TOURNAMENT_TYPE -> "tournamentType" + CURRENCY -> "bankroll.currency" + CURRENCY_CODE -> "bankroll.currency.code" + BIG_BLIND -> "cgBigBlind" + SMALL_BLIND -> "cgSmallBlind" + COMMENT -> "comment" + BETWEEN_NUMBER_OF_TABLE, MORE_NUMBER_OF_TABLE, LESS_NUMBER_OF_TABLE -> "numberOfTable" + MORE_THAN_NET_RESULT, LESS_THAN_NET_RESULT -> "computableResults.ratedNet" + MORE_THAN_BUY_IN, LESS_THAN_BUY_IN -> "result.buyin" + MORE_THAN_CASH_OUT, LESS_THAN_CASH_OUT -> "result.cashout" + MORE_THAN_TIPS, LESS_THAN_TIPS -> "result.tips" + MORE_THAN_NUMBER_OF_PLAYER, LESS_THAN_NUMBER_OF_PLAYER, BETWEEN_NUMBER_OF_PLAYER -> "tournamentNumberOfPlayers" + MORE_THAN_TOURNAMENT_FEE, LESS_THAN_TOURNAMENT_FEE, BETWEEN_TOURNAMENT_FEE -> "tournamentEntryFee" + STARTED_FROM_DATE, STARTED_TO_DATE -> "startDate" + ENDED_FROM_DATE, ENDED_TO_DATE -> "endDate" + DAY_OF_WEEK, WEEK_END -> "dayOfWeek" + MONTH -> "month" + YEAR -> "year" + else -> null + } + } } @PrimaryKey diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt index 32910b55..35cecdf6 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt @@ -1,15 +1,12 @@ package net.pokeranalytics.android.ui.view.rowrepresentable -import io.realm.Realm 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.FilterComponent import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowViewType -import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow.* -import java.lang.Exception + import java.util.* sealed class FilterElementRow : RowRepresentable { diff --git a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt index ff365799..1696bdac 100644 --- a/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt +++ b/app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt @@ -5,7 +5,6 @@ import net.pokeranalytics.android.model.LiveData import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowViewType import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.* -import java.lang.Exception enum class FilterSectionRow(override val resId: Int?): RowRepresentable { CASH_TOURNAMENT(net.pokeranalytics.android.R.string.cash_or_tournament), @@ -119,7 +118,6 @@ enum class FilterSectionRow(override val resId: Int?): RowRepresentable { VALUE -> arrayListOf() - else -> throw Exception("unknown filtersection") //TODO create exception }.apply { this.forEach { it.filterSectionRow = this@FilterSectionRow