staxriver
/
poker-analytics
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

filter clean up

Browse Source
feature/top10
Razmig Sarkissian 7 years ago
parent b720ba8a91
commit c41b937933
14 changed files with 344 additions and 341 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 8
      app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt
  2. 18
      app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt
  3. 38
      app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt
  4. 30
      app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt
  5. 12
      app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt
  6. 77
      app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
  7. 17
      app/src/main/java/net/pokeranalytics/android/model/filter/FilterEntityDataSource.kt
  8. 314
      app/src/main/java/net/pokeranalytics/android/model/filter/FilterType.kt
  9. 8
      app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt
  10. 31
      app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt
  11. 28
      app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
  12. 41
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  13. 5
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt
  14. 2
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt

8
app/src/androidTest/java/net/pokeranalytics/android/RealmInstrumentedUnitTest.kt
Unescape View File

@ -32,16 +32,14 @@ open class RealmInstrumentedUnitTest {
val testConfig = RealmConfiguration.Builder().inMemory().name("test-realm").build() val testConfig = RealmConfiguration.Builder().inMemory().name("test-realm").build()
Realm.setDefaultConfiguration(testConfig) Realm.setDefaultConfiguration(testConfig)
this.mockRealm = Realm.getDefaultInstance() this.mockRealm = Realm.getDefaultInstance()
this.mockRealm.beginTransaction()
this.mockRealm.executeTransaction {
this.mockRealm.deleteAll() this.mockRealm.deleteAll()
} this.mockRealm.commitTransaction()
} }
@After @After
@Throws(Exception::class) @Throws(Exception::class)
public fun tearDown() { fun tearDown() {
this.mockRealm.close() this.mockRealm.close()
} }

18
app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt
Unescape View File

@ -1,8 +1,8 @@
package net.pokeranalytics.android.filter package net.pokeranalytics.android.filter
import net.pokeranalytics.android.model.filter.FilterManager
import net.pokeranalytics.android.model.filter.FilterType import net.pokeranalytics.android.model.filter.FilterType
import net.pokeranalytics.android.model.realm.Bankroll import net.pokeranalytics.android.model.realm.Bankroll
import net.pokeranalytics.android.model.realm.Filter
import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.Session
import org.junit.Assert import org.junit.Assert
import org.junit.Test import org.junit.Test
@ -44,9 +44,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
"code" to null "code" to null
))) )))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -91,9 +91,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
"code" to null "code" to null
))) )))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -138,9 +138,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
"code" to "AUD" "code" to "AUD"
))) )))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -191,9 +191,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
"code" to null "code" to null
))) )))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )

38
app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt
Unescape View File

@ -2,7 +2,7 @@ package net.pokeranalytics.android.filter
import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.ext.junit.runners.AndroidJUnit4
import net.pokeranalytics.android.model.filter.FilterType 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 net.pokeranalytics.android.model.realm.Session
import org.junit.Assert import org.junit.Assert
import org.junit.Test import org.junit.Test
@ -29,9 +29,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = s1.startDate cal.time = s1.startDate
filter.valueMap = mapOf("dayOfWeek" to cal.get(Calendar.DAY_OF_WEEK)) filter.valueMap = mapOf("dayOfWeek" to cal.get(Calendar.DAY_OF_WEEK))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -58,9 +58,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = s1.startDate cal.time = s1.startDate
filter.valueMap = mapOf("month" to cal.get(Calendar.MONTH)) filter.valueMap = mapOf("month" to cal.get(Calendar.MONTH))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -87,9 +87,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = s1.startDate cal.time = s1.startDate
filter.valueMap = mapOf("year" to cal.get(Calendar.YEAR)) filter.valueMap = mapOf("year" to cal.get(Calendar.YEAR))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -113,9 +113,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(FilterType.WEEK_END) arrayListOf(FilterType.WEEK_END)
) )
@ -138,9 +138,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(FilterType.WEEK_DAY) arrayListOf(FilterType.WEEK_DAY)
) )
@ -168,9 +168,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.STARTED_FROM_DATE val filter = FilterType.STARTED_FROM_DATE
filter.valueMap = mapOf("date" to s2.startDate) filter.valueMap = mapOf("date" to s2.startDate)
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -198,9 +198,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.STARTED_TO_DATE val filter = FilterType.STARTED_TO_DATE
filter.valueMap = mapOf("date" to s1.startDate) filter.valueMap = mapOf("date" to s1.startDate)
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -229,9 +229,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.ENDED_FROM_DATE val filter = FilterType.ENDED_FROM_DATE
filter.valueMap = mapOf("date" to s2.endDate) filter.valueMap = mapOf("date" to s2.endDate)
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -260,9 +260,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.ENDED_TO_DATE val filter = FilterType.ENDED_TO_DATE
filter.valueMap = mapOf("date" to s1.endDate) filter.valueMap = mapOf("date" to s1.endDate)
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )

30
app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt
Unescape View File

@ -3,7 +3,7 @@ package net.pokeranalytics.android.filter
import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.ext.junit.runners.AndroidJUnit4
import net.pokeranalytics.android.exceptions.FilterValueMapException import net.pokeranalytics.android.exceptions.FilterValueMapException
import net.pokeranalytics.android.model.filter.FilterType 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 net.pokeranalytics.android.model.realm.Session
import org.junit.Test import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
@ -12,25 +12,15 @@ import java.util.*
@RunWith(AndroidJUnit4::class) @RunWith(AndroidJUnit4::class)
class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() { 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) @Test(expected = FilterValueMapException::class)
fun testValueKeyFilterException() { fun testValueKeyFilterException() {
val filter = FilterType.STARTED_FROM_DATE val filter = FilterType.STARTED_FROM_DATE
filter.valueMap = mapOf("bob" to Date()) filter.valueMap = mapOf("bob" to Date())
val realm = this.mockRealm val realm = this.mockRealm
FilterManager().filter( Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
} }
@ -45,10 +35,20 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
))) )))
val realm = this.mockRealm val realm = this.mockRealm
FilterManager().filter( Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
} }
@Test(expected = FilterValueMapException::class)
fun testXFilterException() {
val realm = this.mockRealm
Filter.queryOn(
realm,
Session,
arrayListOf(FilterType.BLINDS)
)
}
} }

12
app/src/androidTest/java/net/pokeranalytics/android/filter/RealmFilterInstrumentedUnitTest.kt
Unescape View File

@ -48,20 +48,14 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val newRealm = this.mockRealm val newRealm = this.mockRealm
newRealm.beginTransaction()
newRealm.where(Filter::class.java).equalTo("name", "testSaveLoadCashFilter").findFirst()?.let { foundFilter -> newRealm.where(Filter::class.java).equalTo("name", "testSaveLoadCashFilter").findFirst()?.let { foundFilter ->
val loadedFilter = newRealm.copyFromRealm(foundFilter) val sessions = foundFilter.queryOn(Session)
val sessions = loadedFilter.filter(
realm,
Session::class.java,
loadedFilter.components.map {
it.filterType
}
)
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
sessions[0]?.run { sessions[0]?.run {
Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type) Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type)
} ?: run {
Assert.fail()
} }
} ?: run { } ?: run {
Assert.fail() Assert.fail()

77
app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
Unescape View File

@ -2,7 +2,6 @@ package net.pokeranalytics.android.filter
import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.ext.junit.runners.AndroidJUnit4
import io.realm.RealmList import io.realm.RealmList
import net.pokeranalytics.android.model.filter.FilterManager
import net.pokeranalytics.android.model.filter.FilterType import net.pokeranalytics.android.model.filter.FilterType
import net.pokeranalytics.android.model.realm.* import net.pokeranalytics.android.model.realm.*
import org.junit.Assert import org.junit.Assert
@ -23,9 +22,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, Date(), 1) Session.testInstance(100.0, true, Date(), 1)
realm.commitTransaction() realm.commitTransaction()
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(FilterType.CASH) arrayListOf(FilterType.CASH)
) )
@ -45,9 +44,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, Date(), 1) Session.testInstance(100.0, true, Date(), 1)
realm.commitTransaction() realm.commitTransaction()
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(FilterType.TOURNAMENT) arrayListOf(FilterType.TOURNAMENT)
) )
@ -72,9 +71,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, Date(), 1, b2) Session.testInstance(100.0, true, Date(), 1, b2)
realm.commitTransaction() realm.commitTransaction()
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(FilterType.LIVE) arrayListOf(FilterType.LIVE)
) )
@ -98,9 +97,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, Date(), 1, b2) Session.testInstance(100.0, true, Date(), 1, b2)
realm.commitTransaction() realm.commitTransaction()
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(FilterType.ONLINE) arrayListOf(FilterType.ONLINE)
) )
@ -125,9 +124,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.BANKROLL val filter = FilterType.BANKROLL
filter.valueMap = mapOf("ids" to arrayOf(b1.id)) filter.valueMap = mapOf("ids" to arrayOf(b1.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -158,9 +157,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.BANKROLL val filter = FilterType.BANKROLL
filter.valueMap = mapOf("ids" to arrayOf(b1.id, b2.id)) filter.valueMap = mapOf("ids" to arrayOf(b1.id, b2.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -186,9 +185,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.GAME val filter = FilterType.GAME
filter.valueMap = mapOf("ids" to arrayOf(g2.id)) filter.valueMap = mapOf("ids" to arrayOf(g2.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -219,9 +218,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.GAME val filter = FilterType.GAME
filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id)) filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -247,9 +246,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.LOCATION val filter = FilterType.LOCATION
filter.valueMap = mapOf("ids" to arrayOf(l1.id)) filter.valueMap = mapOf("ids" to arrayOf(l1.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -280,9 +279,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.LOCATION val filter = FilterType.LOCATION
filter.valueMap = mapOf("ids" to arrayOf(l1.id, l3.id)) filter.valueMap = mapOf("ids" to arrayOf(l1.id, l3.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -308,9 +307,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.TOURNAMENT_NAME val filter = FilterType.TOURNAMENT_NAME
filter.valueMap = mapOf("ids" to arrayOf(t1.id)) filter.valueMap = mapOf("ids" to arrayOf(t1.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -341,9 +340,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.TOURNAMENT_NAME val filter = FilterType.TOURNAMENT_NAME
filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id)) filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -377,9 +376,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.ALL_TOURNAMENT_FEATURES val filter = FilterType.ALL_TOURNAMENT_FEATURES
filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id)) filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -410,9 +409,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.ANY_TOURNAMENT_FEATURES val filter = FilterType.ANY_TOURNAMENT_FEATURES
filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id)) filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -440,9 +439,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.ANY_TOURNAMENT_FEATURES val filter = FilterType.ANY_TOURNAMENT_FEATURES
filter.valueMap = mapOf("ids" to arrayOf(t2.id)) filter.valueMap = mapOf("ids" to arrayOf(t2.id))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -467,9 +466,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.TABLE_SIZE val filter = FilterType.TABLE_SIZE
filter.valueMap = mapOf("values" to arrayOf(2,4)) filter.valueMap = mapOf("values" to arrayOf(2,4))
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -494,9 +493,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.MORE_THAN_NET_RESULT val filter = FilterType.MORE_THAN_NET_RESULT
filter.valueMap = mapOf("value" to 204.0) filter.valueMap = mapOf("value" to 204.0)
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -521,9 +520,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = FilterType.LESS_THAN_NET_RESULT val filter = FilterType.LESS_THAN_NET_RESULT
filter.valueMap = mapOf("value" to 540.0) filter.valueMap = mapOf("value" to 540.0)
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filter) arrayListOf(filter)
) )
@ -551,9 +550,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filterLess = FilterType.LESS_THAN_NET_RESULT val filterLess = FilterType.LESS_THAN_NET_RESULT
filterLess.valueMap = mapOf("value" to 400.0) filterLess.valueMap = mapOf("value" to 400.0)
val sessions = FilterManager().filter( val sessions = Filter.queryOn(
realm, realm,
Session::class.java, Session,
arrayListOf(filterMore, filterLess) arrayListOf(filterMore, filterLess)
) )

17
app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt → app/src/main/java/net/pokeranalytics/android/model/filter/FilterEntityDataSource.kt
Unescape View File

@ -1,10 +1,6 @@
package net.pokeranalytics.android.model.filter package net.pokeranalytics.android.model.filter
import io.realm.Realm
import io.realm.RealmObject 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: * 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 { interface FilterEntityDataSource {
fun filter(realm:Realm, relatedEntity: Class<out RealmObject>, queries:List<Filterable>): RealmResults<*> { val relatedEntity: Class<out RealmObject>
var realmQuery : RealmQuery<out RealmObject> = realm.where(relatedEntity) fun fieldNameForQueryType(filterType: FilterType) : String?
queries.forEach {
realmQuery = (it.filter(realmQuery))
}
return realmQuery.findAll()
}
} }
// //
//fun MutableList<Filterable>.filter(filter: FilterComponent) : List<Filterable> { //fun MutableList<Filterable>.filter(filter: FilterComponent) : List<Filterable> {
// //

314
app/src/main/java/net/pokeranalytics/android/model/filter/FilterType.kt
Unescape View File

@ -3,43 +3,68 @@ package net.pokeranalytics.android.model.filter
import io.realm.RealmObject import io.realm.RealmObject
import io.realm.RealmQuery import io.realm.RealmQuery
import net.pokeranalytics.android.exceptions.FilterValueMapException 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.FilterComponent
import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.Session
import java.util.* 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, LIVE,
CASH, CASH,
ONLINE, ONLINE,
TOURNAMENT, TOURNAMENT,
BANKROLL("bankroll.id"), BANKROLL,
GAME("game.id"), GAME,
TOURNAMENT_NAME("tournamentName.id"), TOURNAMENT_NAME,
ANY_TOURNAMENT_FEATURES, ANY_TOURNAMENT_FEATURES,
ALL_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES,
LOCATION("location.id"), LOCATION,
LIMIT("limit"), LIMIT,
TABLE_SIZE("tableSize"), TABLE_SIZE,
TOURNAMENT_TYPE("tournamentType"), TOURNAMENT_TYPE,
BLINDS, BLINDS,
MORE_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.MORE), MORE_NUMBER_OF_TABLE(SubType.MORE),
LESS_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.LESS), LESS_NUMBER_OF_TABLE(SubType.LESS),
BETWEEN_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.BETWEEN), BETWEEN_NUMBER_OF_TABLE(SubType.BETWEEN),
MORE_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.MORE), MORE_THAN_NET_RESULT(SubType.MORE),
LESS_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.LESS), LESS_THAN_NET_RESULT(SubType.LESS),
MORE_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.MORE), MORE_THAN_BUY_IN(SubType.MORE),
LESS_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.LESS), LESS_THAN_BUY_IN(SubType.LESS),
MORE_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.MORE), MORE_THAN_CASH_OUT(SubType.MORE),
LESS_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.LESS), LESS_THAN_CASH_OUT(SubType.LESS),
MORE_THAN_TIPS(Field.TIPS.fieldName, SubType.MORE), MORE_THAN_TIPS(SubType.MORE),
LESS_THAN_TIPS(Field.TIPS.fieldName, SubType.LESS), LESS_THAN_TIPS(SubType.LESS),
MORE_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.MORE), MORE_THAN_NUMBER_OF_PLAYER(SubType.MORE),
LESS_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.LESS), LESS_THAN_NUMBER_OF_PLAYER(SubType.LESS),
BETWEEN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.BETWEEN), BETWEEN_NUMBER_OF_PLAYER(SubType.BETWEEN),
MORE_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.MORE), MORE_THAN_TOURNAMENT_FEE(SubType.MORE),
LESS_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.LESS), LESS_THAN_TOURNAMENT_FEE(SubType.LESS),
BETWEEN_TOURNAMENT_FEE(Field.TOURNAMENT_FEE.fieldName, SubType.BETWEEN), BETWEEN_TOURNAMENT_FEE(SubType.BETWEEN),
// Dates // Dates
STARTED_FROM_DATE, STARTED_FROM_DATE,
@ -52,42 +77,21 @@ enum class FilterType(private var fieldName:String? = null, private var subType:
WEEK_DAY, WEEK_DAY,
WEEK_END, WEEK_END,
CURRENCY,
CURRENCY_CODE,
BIG_BLIND,
SMALL_BLIND,
COMMENT,
; ;
enum class SubType { private enum class SubType {
BETWEEN, BETWEEN,
MORE, MORE,
LESS; LESS;
} }
private enum class Field(var fieldName:String) { private val filterValuesExpectedKeys : Array<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<String, Any?>? = null
override val filterValuesExpectedKeys : Array<String>?
get() { get() {
this.subType?.let { this.subType?.let {
return when (it) { return when (it) {
@ -107,66 +111,17 @@ enum class FilterType(private var fieldName:String? = null, private var subType:
} }
} }
override fun filter(realmQuery: RealmQuery<out RealmObject>): RealmQuery<out RealmObject> { fun filter(realmQuery: RealmQuery<out RealmObject>, filterEntityDataSource: FilterEntityDataSource): RealmQuery<out RealmObject> {
when {
this.subType?.let {subType -> this == BLINDS -> {
this.fieldName?.let { val smallBlindFieldName = filterEntityDataSource.fieldNameForQueryType(SMALL_BLIND)
return when (subType) { val bigBlindFieldName = filterEntityDataSource.fieldNameForQueryType(BIG_BLIND)
SubType.LESS -> { val currencyCodeFieldName = filterEntityDataSource.fieldNameForQueryType(CURRENCY_CODE)
val value: Double by filterValues smallBlindFieldName ?: throw FilterValueMapException("fieldName is missing")
println("filter test less") bigBlindFieldName ?: throw FilterValueMapException("fieldName is missing")
realmQuery.lessThanOrEqualTo(it, value) currencyCodeFieldName ?: throw FilterValueMapException("fieldName is missing")
}
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) { val blinds: Array<Map<String, Any?>> by valueMap
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<String> by filterValues
ids.forEach {
realmQuery.equalTo(Field.TOURNAMENT_FEATURES.fieldName, it)
}
realmQuery
}
ANY_TOURNAMENT_FEATURES -> {
val ids : Array<String> by filterValues
realmQuery.`in`(Field.TOURNAMENT_FEATURES.fieldName, ids)
}
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
val ids : Array<String> by filterValues
this.fieldName?.let {
realmQuery.`in`(it, ids)
} ?: run {
throw FilterValueMapException("fieldName is missing")
}
}
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
val values : Array<Int?>? by filterValues
this.fieldName?.let {
realmQuery.`in`(it, values)
} ?: run {
throw FilterValueMapException("fieldName is missing")
}
}
BLINDS -> {
val blinds : Array<Map<String,Any?>> by filterValues
val expectedSubKeys = arrayOf("sb", "bb", "code") val expectedSubKeys = arrayOf("sb", "bb", "code")
blinds.forEachIndexed { index, subMap -> blinds.forEachIndexed { index, subMap ->
val missingKeys = subMap.keys.filter { !expectedSubKeys.contains(it) } val missingKeys = subMap.keys.filter { !expectedSubKeys.contains(it) }
@ -183,18 +138,18 @@ enum class FilterType(private var fieldName:String? = null, private var subType:
sb?.let { sb?.let {
realmQuery realmQuery
.equalTo(Field.SMALL_BLIND.fieldName, sb) .equalTo(smallBlindFieldName, sb)
.and() .and()
} }
realmQuery realmQuery
.equalTo(Field.BIG_BLIND.fieldName, bb) .equalTo(bigBlindFieldName, bb)
.and() .and()
code?.let { code?.let {
realmQuery.equalTo(Field.CURRENCY_CODE.fieldName, code) realmQuery.equalTo(currencyCodeFieldName, code)
} ?: run { } ?: run {
realmQuery.isNull(Field.CURRENCY_CODE.fieldName) realmQuery.isNull(currencyCodeFieldName)
} }
realmQuery.endGroup() realmQuery.endGroup()
@ -203,94 +158,155 @@ enum class FilterType(private var fieldName:String? = null, private var subType:
realmQuery.or() realmQuery.or()
} }
} }
return realmQuery
}
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 -> {
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<String> by valueMap
ids.forEach {
realmQuery.equalTo(fieldName, it)
}
realmQuery realmQuery
} }
ANY_TOURNAMENT_FEATURES -> {
val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
val values: Array<Int?>? by valueMap
realmQuery.`in`(fieldName, values)
}
STARTED_FROM_DATE -> { STARTED_FROM_DATE -> {
val date : Date by filterValues val date: Date by valueMap
realmQuery.greaterThanOrEqualTo(Field.START_DATE.fieldName, date) realmQuery.greaterThanOrEqualTo(fieldName, date)
} }
STARTED_TO_DATE -> { STARTED_TO_DATE -> {
val date : Date by filterValues val date: Date by valueMap
realmQuery.lessThanOrEqualTo(Field.START_DATE.fieldName, date) realmQuery.lessThanOrEqualTo(fieldName, date)
} }
ENDED_FROM_DATE -> { ENDED_FROM_DATE -> {
val date : Date by filterValues val date: Date by valueMap
realmQuery.greaterThanOrEqualTo(Field.END_DATE.fieldName, date) realmQuery.greaterThanOrEqualTo(fieldName, date)
} }
ENDED_TO_DATE -> { ENDED_TO_DATE -> {
val date : Date by filterValues val date: Date by valueMap
realmQuery.lessThanOrEqualTo(Field.END_DATE.fieldName, date) realmQuery.lessThanOrEqualTo(fieldName, date)
} }
DAY_OF_WEEK -> { DAY_OF_WEEK -> {
val dayOfWeek : Int by filterValues val dayOfWeek: Int by valueMap
realmQuery.equalTo(Field.DAY.fieldName, dayOfWeek) realmQuery.equalTo(fieldName, dayOfWeek)
} }
MONTH -> { MONTH -> {
val month: Int by filterValues val month: Int by valueMap
realmQuery.equalTo(Field.MONTH.fieldName, month) realmQuery.equalTo(fieldName, month)
} }
YEAR -> { YEAR -> {
val year: Int by filterValues val year: Int by valueMap
realmQuery.equalTo(Field.YEAR.fieldName, year) realmQuery.equalTo(fieldName, year)
} }
WEEK_END -> { WEEK_END -> {
realmQuery.`in`(Field.DAY.fieldName, arrayOf(Calendar.SATURDAY,Calendar.SUNDAY)) realmQuery.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY))
} }
WEEK_DAY -> WEEK_END.filter(realmQuery.not())
else -> { else -> {
throw FilterValueMapException("filter type not handled") throw FilterValueMapException("filter type not handled")
} }
} }
} }
}
override fun setValueFrom(filterComponent: FilterComponent) { }
fun setValueFrom(filterComponent: FilterComponent) {
if (filterValuesExpectedKeys == null) { if (filterValuesExpectedKeys == null) {
return return
} }
this.subType?.let { subType -> this.subType?.let { subType ->
this.fieldName?.let { valueMap = when (subType) {
return when (subType) {
SubType.LESS, SubType.MORE -> { SubType.LESS, SubType.MORE -> {
filterValues = mapOf("value" to filterComponent.value) mapOf("value" to filterComponent.value)
} }
SubType.BETWEEN -> { SubType.BETWEEN -> {
filterValues = mapOf( mapOf(
"leftValue" to filterComponent.leftValue, "leftValue" to filterComponent.leftValue,
"rightValue" to filterComponent.rightValue "rightValue" to filterComponent.rightValue
) )
} }
} }
} ?: run {
throw FilterValueMapException("fieldName is missing")
}
} }
when (this) { when (this) {
ALL_TOURNAMENT_FEATURES, ANY_TOURNAMENT_FEATURES, BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { 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 -> { LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
filterValues = mapOf("values" to filterComponent.values) valueMap = mapOf("values" to filterComponent.values)
} }
BLINDS -> { 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 -> { 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 -> { DAY_OF_WEEK -> {
filterValues = mapOf("dayOfWeek" to filterComponent.dayOfWeek) valueMap = mapOf("dayOfWeek" to filterComponent.dayOfWeek)
} }
MONTH -> { MONTH -> {
filterValues = mapOf("month" to filterComponent.month) valueMap = mapOf("month" to filterComponent.month)
} }
YEAR -> { YEAR -> {
filterValues = mapOf("year" to filterComponent.year) valueMap = mapOf("year" to filterComponent.year)
} }
else -> { else -> {
throw FilterValueMapException("filter type not handled") throw FilterValueMapException("filter type not handled")
} }
} }
} }
var valueMap : Map<String, Any?>? = 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
}
} }

8
app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt
Unescape View File

@ -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<out RealmObject>): RealmQuery<out RealmObject>
}

31
app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt
Unescape View File

@ -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<String, Any?>?
var filterValues : Map<String, Any?>?
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<String>?
fun setValueFrom(filterComponent: FilterComponent)
}

28
app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
Unescape View File

@ -2,17 +2,25 @@ package net.pokeranalytics.android.model.realm
import io.realm.* import io.realm.*
import io.realm.annotations.PrimaryKey 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.FilterCategoryRow
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
import java.util.* import java.util.*
//import net.pokeranalytics.android.FilterComponent
open class Filter : RealmObject() { open class Filter : RealmObject() {
companion object {
fun queryOn(realm: Realm, entity: FilterEntityDataSource, queries:List<FilterType>): RealmResults<*> {
var realmQuery : RealmQuery<out RealmObject> = realm.where(entity.relatedEntity)
queries.forEach {
realmQuery = (it.filter(realmQuery, entity))
}
return realmQuery.findAll()
}
}
@PrimaryKey @PrimaryKey
var id = UUID.randomUUID().toString() var id = UUID.randomUUID().toString()
@ -67,12 +75,14 @@ open class Filter : RealmObject() {
return filterElementRow.contains(filtered) return filterElementRow.contains(filtered)
} }
fun filter(realm: Realm, relatedEntity: Class<out RealmObject>, queries:List<Filterable>): RealmResults<*> { fun queryOn(entity: FilterEntityDataSource) : RealmResults<*> {
var realmQuery : RealmQuery<out RealmObject> = realm.where(relatedEntity) var realmQuery : RealmQuery<out RealmObject> = realm.where(entity.relatedEntity)
queries.forEach { this.components.map {
realmQuery = (it.filter(realmQuery)) it.filterType
}.forEach {
realmQuery = (it.filter(realmQuery, entity))
} }
return realmQuery.findAll() return realmQuery.findAll()
} }
} }

41
app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
Unescape View File

@ -20,6 +20,9 @@ import net.pokeranalytics.android.model.TableSize
import net.pokeranalytics.android.model.TournamentType import net.pokeranalytics.android.model.TournamentType
import net.pokeranalytics.android.model.extensions.SessionState import net.pokeranalytics.android.model.extensions.SessionState
import net.pokeranalytics.android.model.extensions.getState 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.filter.interfaces.TimeFilterable
import net.pokeranalytics.android.model.interfaces.Manageable import net.pokeranalytics.android.model.interfaces.Manageable
import net.pokeranalytics.android.model.interfaces.Timed import net.pokeranalytics.android.model.interfaces.Timed
@ -47,11 +50,10 @@ open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource
TOURNAMENT TOURNAMENT
} }
companion object { companion object : FilterEntityDataSource {
fun newInstance(realm: Realm, isTournament: Boolean, bankroll: Bankroll? = null): Session { fun newInstance(realm: Realm, isTournament: Boolean, bankroll: Bankroll? = null): Session {
val session = Session() val session = Session()
session.result = Result() session.result = Result()
if (bankroll != null) { if (bankroll != null) {
session.bankroll = bankroll session.bankroll = bankroll
} else { } 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 session.type = if (isTournament) Session.Type.TOURNAMENT.ordinal else Session.Type.CASH_GAME.ordinal
return realm.copyToRealm(session) return realm.copyToRealm(session)
} }
override val relatedEntity: Class<out RealmObject> = 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 @PrimaryKey

5
app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt
Unescape View File

@ -1,15 +1,12 @@
package net.pokeranalytics.android.ui.view.rowrepresentable package net.pokeranalytics.android.ui.view.rowrepresentable
import io.realm.Realm
import net.pokeranalytics.android.R import net.pokeranalytics.android.R
import net.pokeranalytics.android.exceptions.FilterValueMapException import net.pokeranalytics.android.exceptions.FilterValueMapException
import net.pokeranalytics.android.model.LiveData
import net.pokeranalytics.android.model.filter.FilterType import net.pokeranalytics.android.model.filter.FilterType
import net.pokeranalytics.android.model.realm.FilterComponent import net.pokeranalytics.android.model.realm.FilterComponent
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
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow.*
import java.lang.Exception
import java.util.* import java.util.*
sealed class FilterElementRow : RowRepresentable { sealed class FilterElementRow : RowRepresentable {

2
app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt
Unescape View File

@ -5,7 +5,6 @@ import net.pokeranalytics.android.model.LiveData
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
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.* import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.*
import java.lang.Exception
enum class FilterSectionRow(override val resId: Int?): RowRepresentable { enum class FilterSectionRow(override val resId: Int?): RowRepresentable {
CASH_TOURNAMENT(net.pokeranalytics.android.R.string.cash_or_tournament), CASH_TOURNAMENT(net.pokeranalytics.android.R.string.cash_or_tournament),
@ -119,7 +118,6 @@ enum class FilterSectionRow(override val resId: Int?): RowRepresentable {
VALUE -> arrayListOf() VALUE -> arrayListOf()
else -> throw Exception("unknown filtersection") //TODO create exception
}.apply { }.apply {
this.forEach { this.forEach {
it.filterSectionRow = this@FilterSectionRow it.filterSectionRow = this@FilterSectionRow

Write Preview
Loading…
Cancel
Save