Merge branch 'dev' of gitlab.com:stax-river/poker-analytics into dev

# Conflicts:
#	app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
#	app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt
feature/top10
Aurelien Hubert 7 years ago
commit 5b776cb04e
  1. 20
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt
  2. 36
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt
  3. 10
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/ExceptionFilterInstrumentedTest.kt
  4. 8
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt
  5. 74
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt
  6. 2
      app/src/main/java/net/pokeranalytics/android/PokerAnalyticsApplication.kt
  7. 4
      app/src/main/java/net/pokeranalytics/android/exceptions/Exceptions.kt
  8. 14
      app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt
  9. 72
      app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt
  10. 48
      app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt
  11. 6
      app/src/main/java/net/pokeranalytics/android/model/realm/ComputableResult.kt
  12. 30
      app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
  13. 161
      app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt
  14. 159
      app/src/main/java/net/pokeranalytics/android/model/realm/FilterElement.kt
  15. 8
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  16. 6
      app/src/main/java/net/pokeranalytics/android/model/realm/SessionSet.kt
  17. 2
      app/src/main/java/net/pokeranalytics/android/ui/adapter/RowRepresentableDataSource.kt
  18. 2
      app/src/main/java/net/pokeranalytics/android/ui/fragment/DataListFragment.kt
  19. 2
      app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt
  20. 58
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt

@ -1,10 +1,10 @@
package net.pokeranalytics.android.unitTests.filter package net.pokeranalytics.android.unitTests.filter
import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
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.Filter
import net.pokeranalytics.android.model.realm.FilterElement import net.pokeranalytics.android.model.realm.FilterCondition
import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.Session
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
@ -42,10 +42,10 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.BLINDS val filter = QueryCondition.BLINDS
val blind = FilterElementRow.Blind(0.5, 1.0, null) val blind = FilterElementRow.Blind(0.5, 1.0, null)
blind.filterSectionRow = FilterSectionRow.BLINDS blind.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind)) val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
@ -86,11 +86,11 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.BLINDS val filter = QueryCondition.BLINDS
val blind = FilterElementRow.Blind(null, 1.0, null) val blind = FilterElementRow.Blind(null, 1.0, null)
blind.filterSectionRow = FilterSectionRow.BLINDS blind.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind)) val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -129,11 +129,11 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.BLINDS val filter = QueryCondition.BLINDS
val blind = FilterElementRow.Blind(1.0, 2.0, "AUD") val blind = FilterElementRow.Blind(1.0, 2.0, "AUD")
blind.filterSectionRow = FilterSectionRow.BLINDS blind.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind)) val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -172,13 +172,13 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.BLINDS val filter = QueryCondition.BLINDS
val blind1 = FilterElementRow.Blind(1.0, 2.0, null) val blind1 = FilterElementRow.Blind(1.0, 2.0, null)
blind1.filterSectionRow = FilterSectionRow.BLINDS blind1.filterSectionRow = FilterSectionRow.BLINDS
val blind2 = FilterElementRow.Blind(0.5, 1.0, null) val blind2 = FilterElementRow.Blind(0.5, 1.0, null)
blind2.filterSectionRow = FilterSectionRow.BLINDS blind2.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind1, blind2)) val filterElement = FilterCondition(filterElementRows = arrayListOf(blind1, blind2))
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))

@ -2,9 +2,9 @@ package net.pokeranalytics.android.unitTests.filter
import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.ext.junit.runners.AndroidJUnit4
import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.Filter
import net.pokeranalytics.android.model.realm.FilterElement import net.pokeranalytics.android.model.realm.FilterCondition
import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.Session
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
@ -29,12 +29,12 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.DAY_OF_WEEK val filter = QueryCondition.DAY_OF_WEEK
cal.time = s1.startDate cal.time = s1.startDate
val filterElementRow = FilterElementRow.Day(cal.get(Calendar.DAY_OF_WEEK)) val filterElementRow = FilterElementRow.Day(cal.get(Calendar.DAY_OF_WEEK))
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
val filterElement = FilterElement(filterElementRow) val filterElement = FilterCondition(filterElementRow)
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -58,12 +58,12 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.MONTH val filter = QueryCondition.MONTH
cal.time = s1.startDate cal.time = s1.startDate
val filterElementRow = FilterElementRow.Month(cal.get(Calendar.MONTH)) val filterElementRow = FilterElementRow.Month(cal.get(Calendar.MONTH))
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
val filterElement = FilterElement(filterElementRow) val filterElement = FilterCondition(filterElementRow)
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -87,11 +87,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.YEAR val filter = QueryCondition.YEAR
cal.time = s1.startDate cal.time = s1.startDate
val filterElementRow = FilterElementRow.Year(cal.get(Calendar.YEAR)) val filterElementRow = FilterElementRow.Year(cal.get(Calendar.YEAR))
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
val filterElement = FilterElement(filterElementRow) val filterElement = FilterCondition(filterElementRow)
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -117,7 +117,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.WEEK_END)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryCondition.WEEK_END))
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
sessions[0]?.run { sessions[0]?.run {
@ -142,7 +142,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.WEEK_DAY)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryCondition.WEEK_DAY))
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
sessions[0]?.run { sessions[0]?.run {
@ -165,10 +165,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s2 = Session.testInstance(100.0, true, cal.time, 1) val s2 = Session.testInstance(100.0, true, cal.time, 1)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.STARTED_FROM_DATE val filter = QueryCondition.STARTED_FROM_DATE
val filterElementRow = FilterElementRow.From(s2.startDate!!) val filterElementRow = FilterElementRow.From(s2.startDate!!)
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow)) filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -193,10 +193,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.STARTED_TO_DATE val filter = QueryCondition.STARTED_TO_DATE
val filterElementRow = FilterElementRow.From(s1.startDate!!) val filterElementRow = FilterElementRow.From(s1.startDate!!)
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow)) filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -222,10 +222,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.ENDED_FROM_DATE val filter = QueryCondition.ENDED_FROM_DATE
val filterElementRow = FilterElementRow.From(s2.endDate()) val filterElementRow = FilterElementRow.From(s2.endDate())
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow)) filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -251,10 +251,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.ENDED_TO_DATE val filter = QueryCondition.ENDED_TO_DATE
val filterElementRow = FilterElementRow.From(s1.endDate()) val filterElementRow = FilterElementRow.From(s1.endDate())
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow)) filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))

@ -3,9 +3,9 @@ package net.pokeranalytics.android.unitTests.filter
import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.ext.junit.runners.AndroidJUnit4
import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.Filter
import net.pokeranalytics.android.model.realm.FilterElement import net.pokeranalytics.android.model.realm.FilterCondition
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
@ -15,8 +15,8 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
@Test(expected = PokerAnalyticsException.FilterElementExpectedValueMissing::class) @Test(expected = PokerAnalyticsException.FilterElementExpectedValueMissing::class)
fun testValueKeyFilterException() { fun testValueKeyFilterException() {
val filter = QueryType.STARTED_FROM_DATE val filter = QueryCondition.STARTED_FROM_DATE
val filterElement = FilterElement() val filterElement = FilterCondition()
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)
val realm = this.mockRealm val realm = this.mockRealm
@ -26,6 +26,6 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
@Test(expected = PokerAnalyticsException.FilterElementUnknownName::class) @Test(expected = PokerAnalyticsException.FilterElementUnknownName::class)
fun testFilterException() { fun testFilterException() {
FilterElement().queryType FilterCondition().queryCondition
} }
} }

@ -3,7 +3,7 @@ package net.pokeranalytics.android.unitTests.filter
import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.ext.junit.runners.AndroidJUnit4
import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.realm.Filter import net.pokeranalytics.android.model.realm.Filter
import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.Session
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
@ -27,7 +27,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filterElement = FilterElementRow.Cash val filterElement = FilterElementRow.Cash
filterElement.filterSectionRow = FilterSectionRow.CASH_TOURNAMENT filterElement.filterSectionRow = FilterSectionRow.CASH_TOURNAMENT
filter.createOrUpdateFilterElements(arrayListOf(filterElement)) filter.createOrUpdateFilterConditions(arrayListOf(filterElement))
val useCount = filter.countBy(FilterCategoryRow.GENERAL) val useCount = filter.countBy(FilterCategoryRow.GENERAL)
Assert.assertEquals(1, useCount) Assert.assertEquals(1, useCount)
@ -35,10 +35,10 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val isCash = filter.contains(filterElement) val isCash = filter.contains(filterElement)
Assert.assertEquals(true, isCash) Assert.assertEquals(true, isCash)
val filterComponent = filter.filterElements.first() val filterComponent = filter.filterConditions.first()
filterComponent?.let { filterComponent?.let {
Assert.assertEquals(QueryType.CASH, QueryType.valueOf(it.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName)) Assert.assertEquals(QueryCondition.CASH, QueryCondition.valueOf(it.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName))
} ?: run { } ?: run {
Assert.fail() Assert.fail()
} }

@ -4,7 +4,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
import io.realm.RealmList import io.realm.RealmList
import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
import net.pokeranalytics.android.model.TableSize import net.pokeranalytics.android.model.TableSize
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.realm.* import net.pokeranalytics.android.model.realm.*
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
@ -26,7 +26,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, Date(), 1) Session.testInstance(100.0, true, Date(), 1)
realm.commitTransaction() realm.commitTransaction()
val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.CASH)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryCondition.CASH))
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
sessions[0]?.run { sessions[0]?.run {
@ -44,7 +44,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, Date(), 1) Session.testInstance(100.0, true, Date(), 1)
realm.commitTransaction() realm.commitTransaction()
val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryType.TOURNAMENT)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryCondition.TOURNAMENT))
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
sessions[0]?.run { sessions[0]?.run {
@ -67,7 +67,7 @@ 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 = Filter.queryOn<Session>(realm, arrayListOf(QueryType.LIVE)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryCondition.LIVE))
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
(sessions[0] as Session).bankroll?.run { (sessions[0] as Session).bankroll?.run {
@ -89,7 +89,7 @@ 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 = Filter.queryOn<Session>(realm, arrayListOf(QueryType.ONLINE)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(QueryCondition.ONLINE))
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
(sessions[0] as Session).bankroll?.run { (sessions[0] as Session).bankroll?.run {
@ -109,10 +109,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(bankroll = b2) Session.testInstance(bankroll = b2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.BANKROLL val filter = QueryCondition.BANKROLL
val filterElementRow = FilterElementRow.Bankroll(b1) val filterElementRow = FilterElementRow.Bankroll(b1)
filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -140,13 +140,13 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(bankroll = b3) Session.testInstance(bankroll = b3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.BANKROLL val filter = QueryCondition.BANKROLL
val filterElementRow = FilterElementRow.Bankroll(b1) val filterElementRow = FilterElementRow.Bankroll(b1)
filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
val filterElementRow2 = FilterElementRow.Bankroll(b2) val filterElementRow2 = FilterElementRow.Bankroll(b2)
filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -169,10 +169,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(game = g2) Session.testInstance(game = g2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.GAME val filter = QueryCondition.GAME
val filterElementRow = FilterElementRow.Game(g2) val filterElementRow = FilterElementRow.Game(g2)
filterElementRow.filterSectionRow = FilterSectionRow.GAME filterElementRow.filterSectionRow = FilterSectionRow.GAME
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -200,13 +200,13 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(game = g3) Session.testInstance(game = g3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.GAME val filter = QueryCondition.GAME
val filterElementRow = FilterElementRow.Game(g2) val filterElementRow = FilterElementRow.Game(g2)
filterElementRow.filterSectionRow = FilterSectionRow.GAME filterElementRow.filterSectionRow = FilterSectionRow.GAME
val filterElementRow2 = FilterElementRow.Game(g3) val filterElementRow2 = FilterElementRow.Game(g3)
filterElementRow2.filterSectionRow = FilterSectionRow.GAME filterElementRow2.filterSectionRow = FilterSectionRow.GAME
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -229,10 +229,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(location = l2) Session.testInstance(location = l2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.LOCATION val filter = QueryCondition.LOCATION
val filterElementRow = FilterElementRow.Location(l1) val filterElementRow = FilterElementRow.Location(l1)
filterElementRow.filterSectionRow = FilterSectionRow.LOCATION filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -260,14 +260,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(location = l3) Session.testInstance(location = l3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.LOCATION val filter = QueryCondition.LOCATION
val filterElementRow = FilterElementRow.Location(l1) val filterElementRow = FilterElementRow.Location(l1)
filterElementRow.filterSectionRow = FilterSectionRow.LOCATION filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
val filterElementRow2 = FilterElementRow.Location(l3) val filterElementRow2 = FilterElementRow.Location(l3)
filterElementRow2.filterSectionRow = FilterSectionRow.LOCATION filterElementRow2.filterSectionRow = FilterSectionRow.LOCATION
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -290,11 +290,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentName = t2) Session.testInstance(tournamentName = t2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.TOURNAMENT_NAME val filter = QueryCondition.TOURNAMENT_NAME
val filterElementRow = FilterElementRow.TournamentName(t1) val filterElementRow = FilterElementRow.TournamentName(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -322,12 +322,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentName = t3) Session.testInstance(tournamentName = t3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.TOURNAMENT_NAME val filter = QueryCondition.TOURNAMENT_NAME
val filterElementRow = FilterElementRow.TournamentName(t1) val filterElementRow = FilterElementRow.TournamentName(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
val filterElementRow2 = FilterElementRow.TournamentName(t2) val filterElementRow2 = FilterElementRow.TournamentName(t2)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -358,14 +358,14 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1)) Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.ALL_TOURNAMENT_FEATURES val filter = QueryCondition.ALL_TOURNAMENT_FEATURES
val filterElementRow = FilterElementRow.AllTournamentFeature(t1) val filterElementRow = FilterElementRow.AllTournamentFeature(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
val filterElementRow2 = FilterElementRow.AllTournamentFeature(t2) val filterElementRow2 = FilterElementRow.AllTournamentFeature(t2)
filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
val filterElementRow3 = FilterElementRow.AllTournamentFeature(t4) val filterElementRow3 = FilterElementRow.AllTournamentFeature(t4)
filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -393,7 +393,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1)) Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.ANY_TOURNAMENT_FEATURES val filter = QueryCondition.ANY_TOURNAMENT_FEATURES
val filterElementRow = FilterElementRow.AnyTournamentFeature(t1) val filterElementRow = FilterElementRow.AnyTournamentFeature(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
val filterElementRow2 = FilterElementRow.AnyTournamentFeature(t2) val filterElementRow2 = FilterElementRow.AnyTournamentFeature(t2)
@ -402,7 +402,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
val filterElementRow4 = FilterElementRow.AnyTournamentFeature(t4) val filterElementRow4 = FilterElementRow.AnyTournamentFeature(t4)
filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -427,10 +427,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1)) Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.ANY_TOURNAMENT_FEATURES val filter = QueryCondition.ANY_TOURNAMENT_FEATURES
val filterElementRow = FilterElementRow.AnyTournamentFeature(t2) val filterElementRow = FilterElementRow.AnyTournamentFeature(t2)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -452,12 +452,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tableSize = 10) Session.testInstance(tableSize = 10)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.TABLE_SIZE val filter = QueryCondition.TABLE_SIZE
val filterElementRow = FilterElementRow.TableSize(TableSize(2)) val filterElementRow = FilterElementRow.TableSize(TableSize(2))
filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
val filterElementRow2 = FilterElementRow.TableSize(TableSize(4)) val filterElementRow2 = FilterElementRow.TableSize(TableSize(4))
filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
filter.updateValueMap(FilterElement(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -479,10 +479,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s2 = Session.testInstance(netResult = 570.0) val s2 = Session.testInstance(netResult = 570.0)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.MORE_THAN_NET_RESULT val filter = QueryCondition.MORE_THAN_NET_RESULT
val filterElementRow = FilterElementRow.ResultMoreThan(204.0) val filterElementRow = FilterElementRow.ResultMoreThan(204.0)
filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filter.updateValueMap(FilterElement(filterElementRow)) filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -504,10 +504,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(netResult = 570.0) Session.testInstance(netResult = 570.0)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryType.LESS_THAN_NET_RESULT val filter = QueryCondition.LESS_THAN_NET_RESULT
val filterElementRow = FilterElementRow.ResultLessThan(540.0) val filterElementRow = FilterElementRow.ResultLessThan(540.0)
filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filter.updateValueMap(FilterElement(filterElementRow)) filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -529,15 +529,15 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(netResult = 570.0) Session.testInstance(netResult = 570.0)
realm.commitTransaction() realm.commitTransaction()
val filterMore = QueryType.MORE_THAN_NET_RESULT val filterMore = QueryCondition.MORE_THAN_NET_RESULT
val filterElementRow = FilterElementRow.ResultMoreThan(200.0) val filterElementRow = FilterElementRow.ResultMoreThan(200.0)
filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filterMore.updateValueMap(FilterElement(filterElementRow)) filterMore.updateValueMap(FilterCondition(filterElementRow))
val filterLess = QueryType.LESS_THAN_NET_RESULT val filterLess = QueryCondition.LESS_THAN_NET_RESULT
val filterElementRow2 = FilterElementRow.ResultLessThan(400.0) val filterElementRow2 = FilterElementRow.ResultLessThan(400.0)
filterElementRow2.filterSectionRow = FilterSectionRow.VALUE filterElementRow2.filterSectionRow = FilterSectionRow.VALUE
filterLess.updateValueMap(FilterElement(filterElementRow2)) filterLess.updateValueMap(FilterCondition(filterElementRow2))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filterMore, filterLess)) val sessions = Filter.queryOn<Session>(realm, arrayListOf(filterMore, filterLess))

@ -27,7 +27,7 @@ class PokerAnalyticsApplication : Application() {
Realm.init(this) Realm.init(this)
val realmConfiguration = RealmConfiguration.Builder() val realmConfiguration = RealmConfiguration.Builder()
.name(Realm.DEFAULT_REALM_NAME) .name(Realm.DEFAULT_REALM_NAME)
.schemaVersion(0) .schemaVersion(2)
.migration(PokerAnalyticsMigration()) .migration(PokerAnalyticsMigration())
.initialData(Seed(this)) .initialData(Seed(this))
.build() .build()

@ -9,8 +9,8 @@ class RowRepresentableEditDescriptorException(message: String) : Exception(messa
class ConfigurationException(message: String) : Exception(message) class ConfigurationException(message: String) : Exception(message)
sealed class PokerAnalyticsException(message: String) : Exception(message) { sealed class PokerAnalyticsException(message: String) : Exception(message) {
object FilterElementUnknownName : PokerAnalyticsException(message = "No filterElement name was found to identify the queryType") object FilterElementUnknownName : PokerAnalyticsException(message = "No filterElement name was found to identify the queryCondition")
object FilterElementUnknownSectionName: PokerAnalyticsException(message = "No filterElement section name was found to identify the queryType") object FilterElementUnknownSectionName: PokerAnalyticsException(message = "No filterElement section name was found to identify the queryCondition")
object FilterMissingEntity: PokerAnalyticsException(message = "This filter has no entity initialized") object FilterMissingEntity: PokerAnalyticsException(message = "This filter has no entity initialized")
object FilterUnhandledEntity : PokerAnalyticsException(message = "This entity is not filterable") object FilterUnhandledEntity : PokerAnalyticsException(message = "This entity is not filterable")
object QueryValueMapUnknown: PokerAnalyticsException(message = "fieldName is missing") object QueryValueMapUnknown: PokerAnalyticsException(message = "fieldName is missing")

@ -41,9 +41,9 @@ class UnmanagedFilterField(message: String) : Exception(message) {
interface Filterable : RealmModel { interface Filterable : RealmModel {
/** /**
* return the path of the parameter used in the [QueryType] related to this entity * return the path of the parameter used in the [QueryCondition] related to this entity
*/ */
// fun fieldNameForQueryType(queryType: QueryType) : String? // fun fieldNameForQueryType(queryCondition: QueryCondition) : String?
} }
@ -51,12 +51,12 @@ class FilterHelper {
companion object { companion object {
inline fun <reified T : Filterable> fieldNameForQueryType(queryType: QueryType): String? { inline fun <reified T : Filterable> fieldNameForQueryType(queryCondition: QueryCondition): String? {
return when (T::class.java) { return when (T::class.java) {
Session::class.java -> Session.fieldNameForQueryType(queryType) Session::class.java -> Session.fieldNameForQueryType(queryCondition)
ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryType) ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryCondition)
SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryType) SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryCondition)
else -> { else -> {
throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}") throw UnmanagedFilterField("Filterable type fields are not defined for class ${T::class}")
} }
@ -69,7 +69,7 @@ class FilterHelper {
} }
// //
//fun MutableList<Filterable>.filter(filter: FilterElement) : List<Filterable> { //fun MutableList<Filterable>.filter(filter: FilterCondition) : List<Filterable> {
// //
// return this.filter { f -> // return this.filter { f ->
// return@filter true // return@filter true

@ -3,7 +3,7 @@ package net.pokeranalytics.android.model.filter
import io.realm.RealmList import io.realm.RealmList
import io.realm.RealmQuery import io.realm.RealmQuery
import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.realm.FilterElement import net.pokeranalytics.android.model.realm.FilterCondition
import net.pokeranalytics.android.model.realm.FilterElementBlind import net.pokeranalytics.android.model.realm.FilterElementBlind
import net.pokeranalytics.android.model.realm.Session import net.pokeranalytics.android.model.realm.Session
import java.util.* import java.util.*
@ -15,7 +15,7 @@ import java.util.*
* To handle that, the enum has a public [valueMap] variable * To handle that, the enum has a public [valueMap] variable
* A new type should also set the expected numericValues required in the [filterValuesExpectedKeys] * A new type should also set the expected numericValues required in the [filterValuesExpectedKeys]
*/ */
enum class QueryType(var subType:SubType? = null) { enum class QueryCondition(var operator: Operator? = null) {
LIVE, LIVE,
CASH, CASH,
ONLINE, ONLINE,
@ -30,23 +30,23 @@ enum class QueryType(var subType:SubType? = null) {
TABLE_SIZE, TABLE_SIZE,
TOURNAMENT_TYPE, TOURNAMENT_TYPE,
BLINDS, BLINDS,
MORE_NUMBER_OF_TABLE(SubType.MORE), MORE_NUMBER_OF_TABLE(Operator.MORE),
LESS_NUMBER_OF_TABLE(SubType.LESS), LESS_NUMBER_OF_TABLE(Operator.LESS),
BETWEEN_NUMBER_OF_TABLE(SubType.BETWEEN), BETWEEN_NUMBER_OF_TABLE(Operator.BETWEEN),
MORE_THAN_NET_RESULT(SubType.MORE), MORE_THAN_NET_RESULT(Operator.MORE),
LESS_THAN_NET_RESULT(SubType.LESS), LESS_THAN_NET_RESULT(Operator.LESS),
MORE_THAN_BUY_IN(SubType.MORE), MORE_THAN_BUY_IN(Operator.MORE),
LESS_THAN_BUY_IN(SubType.LESS), LESS_THAN_BUY_IN(Operator.LESS),
MORE_THAN_CASH_OUT(SubType.MORE), MORE_THAN_CASH_OUT(Operator.MORE),
LESS_THAN_CASH_OUT(SubType.LESS), LESS_THAN_CASH_OUT(Operator.LESS),
MORE_THAN_TIPS(SubType.MORE), MORE_THAN_TIPS(Operator.MORE),
LESS_THAN_TIPS(SubType.LESS), LESS_THAN_TIPS(Operator.LESS),
MORE_THAN_NUMBER_OF_PLAYER(SubType.MORE), MORE_THAN_NUMBER_OF_PLAYER(Operator.MORE),
LESS_THAN_NUMBER_OF_PLAYER(SubType.LESS), LESS_THAN_NUMBER_OF_PLAYER(Operator.LESS),
BETWEEN_NUMBER_OF_PLAYER(SubType.BETWEEN), BETWEEN_NUMBER_OF_PLAYER(Operator.BETWEEN),
MORE_THAN_TOURNAMENT_FEE(SubType.MORE), MORE_THAN_TOURNAMENT_FEE(Operator.MORE),
LESS_THAN_TOURNAMENT_FEE(SubType.LESS), LESS_THAN_TOURNAMENT_FEE(Operator.LESS),
BETWEEN_TOURNAMENT_FEE(SubType.BETWEEN), BETWEEN_TOURNAMENT_FEE(Operator.BETWEEN),
// Dates // Dates
STARTED_FROM_DATE, STARTED_FROM_DATE,
@ -67,7 +67,7 @@ enum class QueryType(var subType:SubType? = null) {
; ;
enum class SubType { enum class Operator {
BETWEEN, BETWEEN,
MORE, MORE,
LESS; LESS;
@ -91,9 +91,9 @@ enum class QueryType(var subType:SubType? = null) {
private val filterValuesExpectedKeys : Array<String>? private val filterValuesExpectedKeys : Array<String>?
get() { get() {
this.subType?.let { this.operator?.let {
return when (it) { return when (it) {
SubType.BETWEEN -> arrayOf("leftValue", "rightValue") Operator.BETWEEN -> arrayOf("leftValue", "rightValue")
else -> arrayOf("value") else -> arrayOf("value")
} }
} }
@ -158,16 +158,16 @@ enum class QueryType(var subType:SubType? = null) {
val fieldName = FilterHelper.fieldNameForQueryType<T>(this) val fieldName = FilterHelper.fieldNameForQueryType<T>(this)
fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown fieldName ?: throw PokerAnalyticsException.QueryValueMapUnknown
when (subType) { when (operator) {
SubType.LESS -> { Operator.LESS -> {
val value: Double by valueMap val value: Double by valueMap
return realmQuery.lessThanOrEqualTo(fieldName, value) return realmQuery.lessThanOrEqualTo(fieldName, value)
} }
SubType.MORE -> { Operator.MORE -> {
val value: Double by valueMap val value: Double by valueMap
return realmQuery.greaterThanOrEqualTo(fieldName, value) return realmQuery.greaterThanOrEqualTo(fieldName, value)
} }
SubType.BETWEEN -> { Operator.BETWEEN -> {
val leftValue: Double by valueMap val leftValue: Double by valueMap
val rightValue: Double by valueMap val rightValue: Double by valueMap
return realmQuery.between(fieldName, leftValue, rightValue) return realmQuery.between(fieldName, leftValue, rightValue)
@ -241,37 +241,37 @@ enum class QueryType(var subType:SubType? = null) {
} }
fun updateValueMap(filterElement: FilterElement) { fun updateValueMap(filterCondition: FilterCondition) {
if (filterValuesExpectedKeys == null) { if (filterValuesExpectedKeys == null) {
return return
} }
this.subType?.let { subType -> this.operator?.let { subType ->
valueMap = mapOf("value" to filterElement.value) valueMap = mapOf("value" to filterCondition.value)
return return
} }
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 -> {
valueMap = mapOf("ids" to filterElement.ids) valueMap = mapOf("ids" to filterCondition.ids)
} }
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
valueMap = mapOf("values" to filterElement.values) valueMap = mapOf("values" to filterCondition.values)
} }
BLINDS -> { BLINDS -> {
valueMap = mapOf("blinds" to filterElement.blinds) valueMap = mapOf("blinds" to filterCondition.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 -> {
valueMap = mapOf("date" to filterElement.date) valueMap = mapOf("date" to filterCondition.date)
} }
DAY_OF_WEEK -> { DAY_OF_WEEK -> {
valueMap = mapOf("dayOfWeek" to filterElement.dayOfWeek) valueMap = mapOf("dayOfWeek" to filterCondition.dayOfWeek)
} }
MONTH -> { MONTH -> {
valueMap = mapOf("month" to filterElement.month) valueMap = mapOf("month" to filterCondition.month)
} }
YEAR -> { YEAR -> {
valueMap = mapOf("year" to filterElement.year) valueMap = mapOf("year" to filterCondition.year)
} }
else -> { else -> {
throw PokerAnalyticsException.QueryValueMapUnexpectedValue throw PokerAnalyticsException.QueryValueMapUnexpectedValue

@ -15,41 +15,33 @@ class PokerAnalyticsMigration : RealmMigration {
var currentVersion = oldVersion.toInt() var currentVersion = oldVersion.toInt()
Timber.d("*** migrate from $oldVersion to $newVersion") Timber.d("*** migrate from $oldVersion to $newVersion")
// Migrate to version 1: Add a new class. // Migrate to version 1
// Example:
// public Person extends RealmObject {
// private String name;
// private int age;
// // getters and setters left out for brevity
// }
/*
if (currentVersion == 0) { if (currentVersion == 0) {
Timber.d("*** Running migration 1") Timber.d("*** Running migration 1")
schema.get("Session")!!
.addField("isUpdating", Boolean::class.java) schema.get("Filter")?.let {
it.addField("entityType", Int::class.java).setNullable("entityType", true)
}
schema.get("FilterElement")?.let {
it.setNullable("filterName", true)
it.setNullable("sectionName", true)
}
schema.get("FilterElementBlind")?.let {
it.renameField("code", "currencyCode")
}
currentVersion++ currentVersion++
} }
*/
// Migrate to version 2
// Migrate to version 2: Add a primary key + object references
// Example:
// public Person extends RealmObject {
// private String name;
// @PrimaryKey
// private int age;
// private Dog favoriteDog;
// private RealmList<Dog> dogs;
// // getters and setters left out for brevity
// }
/*
if (currentVersion == 1) { if (currentVersion == 1) {
schema.get("Person")!! Timber.d("*** Running migration ${currentVersion + 1}")
.addField("id", Long::class.javaPrimitiveType!!, FieldAttribute.PRIMARY_KEY)
.addRealmObjectField("favoriteDog", schema.get("Dog")!!) schema.rename("FilterElement", "FilterCondition")
.addRealmListField("dogs", schema.get("Dog")!!) schema.get("Filter")?.let {
it.renameField("filterElements", "filterConditions")
}
currentVersion++ currentVersion++
} }
*/
} }

@ -3,7 +3,7 @@ package net.pokeranalytics.android.model.realm
import io.realm.RealmObject import io.realm.RealmObject
import net.pokeranalytics.android.calculus.interfaces.Computable import net.pokeranalytics.android.calculus.interfaces.Computable
import net.pokeranalytics.android.model.filter.Filterable import net.pokeranalytics.android.model.filter.Filterable
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
open class ComputableResult : RealmObject(), Computable, Filterable { open class ComputableResult : RealmObject(), Computable, Filterable {
@ -56,8 +56,8 @@ open class ComputableResult : RealmObject(), Computable, Filterable {
companion object : Filterable { companion object : Filterable {
fun fieldNameForQueryType(queryType: QueryType): String? { fun fieldNameForQueryType(queryCondition: QueryCondition): String? {
return "session." + Session.fieldNameForQueryType(queryType) return "session." + Session.fieldNameForQueryType(queryCondition)
} }
} }

@ -1,11 +1,12 @@
package net.pokeranalytics.android.model.realm package net.pokeranalytics.android.model.realm
import com.google.android.libraries.places.internal.it
import io.realm.* import io.realm.*
import io.realm.annotations.PrimaryKey import io.realm.annotations.PrimaryKey
import io.realm.kotlin.where import io.realm.kotlin.where
import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.filter.Filterable import net.pokeranalytics.android.model.filter.Filterable
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
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
@ -14,7 +15,7 @@ import java.util.*
/** /**
* A [Filter] is the top level representation of the filtering system * A [Filter] is the top level representation of the filtering system
* It contains a list of [FilterElement] describing the complete query to launch * It contains a list of [FilterCondition] describing the complete query to launch
* The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on * The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on
*/ */
open class Filter : RealmObject() { open class Filter : RealmObject() {
@ -40,7 +41,7 @@ open class Filter : RealmObject() {
} }
@TestOnly @TestOnly
inline fun <reified T : Filterable> queryOn(realm: Realm, queries: List<QueryType>): RealmResults<T> { inline fun <reified T : Filterable> queryOn(realm: Realm, queries: List<QueryCondition>): RealmResults<T> {
var realmQuery = realm.where<T>() var realmQuery = realm.where<T>()
queries.forEach { queries.forEach {
realmQuery = it.filter<T>(realmQuery) realmQuery = it.filter<T>(realmQuery)
@ -59,29 +60,29 @@ open class Filter : RealmObject() {
// for MutableRealmInteger, see https://realm.io/docs/java/latest/#counters // for MutableRealmInteger, see https://realm.io/docs/java/latest/#counters
val usageCount: MutableRealmInteger = MutableRealmInteger.valueOf(0) val usageCount: MutableRealmInteger = MutableRealmInteger.valueOf(0)
var filterElements: RealmList<FilterElement> = RealmList() var filterConditions: RealmList<FilterCondition> = RealmList()
private set private set
fun createOrUpdateFilterElements(filterElementRows: ArrayList<FilterElementRow>) { fun createOrUpdateFilterConditions(filterConditionRows: ArrayList<FilterElementRow>) {
filterElements.clear() filterConditions.clear()
filterElementRows filterConditionRows
.map { .map {
it.filterSectionRow it.filterSectionRow
} }
.distinct() .distinct()
.forEach { section -> .forEach { section ->
filterElementRows filterConditionRows
.filter { .filter {
it.filterSectionRow == section it.filterSectionRow == section
} }
.apply { .apply {
if (this.size == 1) { if (this.size == 1) {
filterElements.add(FilterElement(this.first())) filterConditions.add(FilterCondition(this.first()))
} else { } else {
val casted = arrayListOf<FilterElementRow>() val casted = arrayListOf<FilterElementRow>()
casted.addAll(this) casted.addAll(this)
filterElements.add(FilterElement(casted)) filterConditions.add(FilterCondition(casted))
} }
} }
@ -90,16 +91,15 @@ open class Filter : RealmObject() {
fun countBy(filterCategoryRow: FilterCategoryRow) : Int { fun countBy(filterCategoryRow: FilterCategoryRow) : Int {
val sections = filterCategoryRow.filterSectionRows val sections = filterCategoryRow.filterSectionRows
return filterElements.count { return filterConditions.count {
sections.contains(FilterSectionRow.valueOf(it.sectionName ?: throw PokerAnalyticsException.FilterElementUnknownSectionName)) sections.contains(FilterSectionRow.valueOf(it.sectionName ?: throw PokerAnalyticsException.FilterElementUnknownSectionName))
} }
} }
fun contains(filterElementRow:FilterElementRow) : Boolean { fun contains(filterElementRow:FilterElementRow) : Boolean {
val filtered = filterElements.filter { val filtered = filterConditions.filter {
it.filterName == filterElementRow.filterName it.filterName == filterElementRow.filterName
} }
if (filtered.isEmpty()) { if (filtered.isEmpty()) {
return false return false
} }
@ -108,8 +108,8 @@ open class Filter : RealmObject() {
inline fun <reified T : Filterable> results(): RealmResults<T> { inline fun <reified T : Filterable> results(): RealmResults<T> {
var realmQuery = realm.where<T>() var realmQuery = realm.where<T>()
this.filterElements.map { this.filterConditions.map {
it.queryType it.queryCondition
}.forEach { }.forEach {
realmQuery = it.filter(realmQuery) realmQuery = it.filter(realmQuery)
} }

@ -0,0 +1,161 @@
package net.pokeranalytics.android.model.realm
import io.realm.RealmList
import io.realm.RealmObject
import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.filter.QueryType
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.*
import java.util.*
open class FilterCondition() : RealmObject() {
private constructor(filterName:String, sectionName:String) : this() {
this.filterName = filterName
this.sectionName = sectionName
}
constructor(filterElementRows: ArrayList<FilterElementRow>) : this(filterElementRows.first().filterName, filterElementRows.first().filterSectionRow.name) {
val filterName : String = this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName
this.stringValues = when (QueryCondition.valueOf(filterName)) {
QueryCondition.GAME, QueryCondition.BANKROLL, QueryCondition.TOURNAMENT_NAME, QueryCondition.ALL_TOURNAMENT_FEATURES, QueryCondition.ANY_TOURNAMENT_FEATURES, QueryCondition.LOCATION -> {
RealmList<String>().apply {
this.addAll(filterElementRows.map {
(it as DataFilterElementRow).id
})
}
}
QueryCondition.LIMIT, QueryCondition.TABLE_SIZE -> {
RealmList<String>().apply {
this.addAll(filterElementRows.map {
(it as StaticDataFilterElementRow).id
})
}
}
else -> null
}
this.numericValues = when (QueryCondition.valueOf(filterName)) {
QueryCondition.LIMIT -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as FilterElementRow.Limit).limit.ordinal.toDouble()
})
}
}
QueryCondition.TABLE_SIZE -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as FilterElementRow.TableSize).tableSize.numberOfPlayer.toDouble()
})
}
}
QueryCondition.YEAR, QueryCondition.MONTH, QueryCondition.DAY_OF_WEEK -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as SingleValueFilterElementRow).value.toDouble()
})
}
}
QueryCondition.LESS_THAN_NET_RESULT -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as ResultLessThan).value
})
}
}
QueryCondition.MORE_THAN_NET_RESULT -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as ResultMoreThan).value
})
}
}
else -> null
}
this.blindValues = when (QueryCondition.valueOf(filterName)) {
QueryCondition.BLINDS -> {
RealmList<FilterElementBlind>().apply {
this.addAll(filterElementRows.map {
FilterElementBlind((it as FilterElementRow.Blind).sb, it.bb, it.code)
})
}
}
else -> null
}
}
constructor(filterElementRow: FilterElementRow) : this(arrayListOf(filterElementRow)) {
when (filterElementRow) {
is From -> dateValue = filterElementRow.date
is To -> dateValue = filterElementRow.date
}
}
var filterName: String? = null
var sectionName: String? = null
val queryCondition : QueryCondition
get() = QueryCondition.valueOf(this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName)
.apply {
this.updateValueMap(this@FilterCondition)
}
private var numericValues: RealmList<Double>? = null
private var dateValue: Date? = null
private var stringValues: RealmList<String>? = null
private var blindValues: RealmList<FilterElementBlind>? = null
val ids: Array<String>
get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val blinds: RealmList<FilterElementBlind>
get() {
blindValues?.let {
if (it.isNotEmpty()) {
return it
} else {
throw PokerAnalyticsException.FilterElementExpectedValueMissing
}
}
throw PokerAnalyticsException.FilterElementExpectedValueMissing
}
val date: Date
get() = dateValue ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val values: Array<Int>
get() = numericValues?.map {
it.toInt()
}?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val value: Double
get() = numericValues?.first() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val leftValue: Double
get() = numericValues?.first() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val rightValue: Double
get() = numericValues?.last() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val dayOfWeek: Int
get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val month: Int
get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val year: Int
get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
}

@ -1,159 +0,0 @@
package net.pokeranalytics.android.model.realm
import io.realm.RealmList
import io.realm.RealmObject
import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.filter.QueryType
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow.*
import java.util.*
open class FilterElement() : RealmObject() {
private constructor(filterName: String, sectionName: String) : this() {
this.filterName = filterName
this.sectionName = sectionName
}
constructor(filterElementRows: ArrayList<FilterElementRow>) : this(filterElementRows.first().filterName, filterElementRows.first().filterSectionRow.name) {
val filterName: String = this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName
this.stringValues = when (QueryType.valueOf(filterName)) {
QueryType.GAME, QueryType.BANKROLL, QueryType.TOURNAMENT_NAME, QueryType.ALL_TOURNAMENT_FEATURES, QueryType.ANY_TOURNAMENT_FEATURES, QueryType.LOCATION -> {
RealmList<String>().apply {
this.addAll(filterElementRows.map {
(it as DataFilterElementRow).id
})
}
}
QueryType.LIMIT, QueryType.TABLE_SIZE -> {
RealmList<String>().apply {
this.addAll(filterElementRows.map {
(it as StaticDataFilterElementRow).id
})
}
}
else -> null
}
this.numericValues = when (QueryType.valueOf(filterName)) {
QueryType.LIMIT -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as FilterElementRow.Limit).limit.ordinal.toDouble()
})
}
}
QueryType.TABLE_SIZE -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as FilterElementRow.TableSize).tableSize.numberOfPlayer.toDouble()
})
}
}
QueryType.YEAR, QueryType.MONTH, QueryType.DAY_OF_WEEK -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as SingleValueFilterElementRow).value.toDouble()
})
}
}
QueryType.LESS_THAN_NET_RESULT -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as ResultLessThan).value
})
}
}
QueryType.MORE_THAN_NET_RESULT -> {
RealmList<Double>().apply {
this.addAll(filterElementRows.map {
(it as ResultMoreThan).value
})
}
}
else -> null
}
this.blindValues = when (QueryType.valueOf(filterName)) {
QueryType.BLINDS -> {
RealmList<FilterElementBlind>().apply {
this.addAll(filterElementRows.map {
FilterElementBlind((it as FilterElementRow.Blind).sb, it.bb, it.code)
})
}
}
else -> null
}
}
constructor(filterElementRow: FilterElementRow) : this(arrayListOf(filterElementRow)) {
when (filterElementRow) {
is From -> dateValue = filterElementRow.date
is To -> dateValue = filterElementRow.date
}
}
var filterName: String? = null
var sectionName: String? = null
val queryType: QueryType
get() = QueryType.valueOf(this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName)
.apply {
this.updateValueMap(this@FilterElement)
}
private var numericValues: RealmList<Double>? = null
private var dateValue: Date? = null
private var stringValues: RealmList<String>? = null
private var blindValues: RealmList<FilterElementBlind>? = null
val ids: Array<String>
get() = stringValues?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val blinds: RealmList<FilterElementBlind>
get() {
blindValues?.let {
if (it.isNotEmpty()) {
return it
} else {
throw PokerAnalyticsException.FilterElementExpectedValueMissing
}
}
throw PokerAnalyticsException.FilterElementExpectedValueMissing
}
val date: Date
get() = dateValue ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val values: Array<Int>
get() = numericValues?.map {
it.toInt()
}?.toTypedArray() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val value: Double
get() = numericValues?.first() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val leftValue: Double
get() = numericValues?.first() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val rightValue: Double
get() = numericValues?.last() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val dayOfWeek: Int
get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val month: Int
get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
val year: Int
get() = numericValues?.first()?.toInt() ?: throw PokerAnalyticsException.FilterElementExpectedValueMissing
}

@ -21,8 +21,8 @@ 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.Filterable import net.pokeranalytics.android.model.filter.Filterable
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.filter.QueryType.* import net.pokeranalytics.android.model.filter.QueryCondition.*
import net.pokeranalytics.android.model.interfaces.* import net.pokeranalytics.android.model.interfaces.*
import net.pokeranalytics.android.model.utils.SessionSetManager import net.pokeranalytics.android.model.utils.SessionSetManager
import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource
@ -61,8 +61,8 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
return realm.copyToRealm(session) return realm.copyToRealm(session)
} }
fun fieldNameForQueryType(queryType: QueryType): String? { fun fieldNameForQueryType(queryCondition: QueryCondition): String? {
return when (queryType) { return when (queryCondition) {
LIVE, ONLINE -> "bankroll.live" LIVE, ONLINE -> "bankroll.live"
CASH, TOURNAMENT -> "type" CASH, TOURNAMENT -> "type"
BANKROLL -> "bankroll.id" BANKROLL -> "bankroll.id"

@ -6,7 +6,7 @@ import io.realm.RealmResults
import io.realm.annotations.Ignore import io.realm.annotations.Ignore
import io.realm.annotations.LinkingObjects import io.realm.annotations.LinkingObjects
import net.pokeranalytics.android.model.filter.Filterable import net.pokeranalytics.android.model.filter.Filterable
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.interfaces.Timed import net.pokeranalytics.android.model.interfaces.Timed
import java.util.* import java.util.*
@ -56,8 +56,8 @@ open class SessionSet : RealmObject(), Timed, Filterable {
return realm.copyToRealm(sessionSet) return realm.copyToRealm(sessionSet)
} }
fun fieldNameForQueryType(queryType: QueryType): String? { fun fieldNameForQueryType(queryCondition: QueryCondition): String? {
return "sessions." + Session.fieldNameForQueryType(queryType) return "sessions." + Session.fieldNameForQueryType(queryCondition)
} }
} }

@ -102,7 +102,7 @@ class UnmanagedRowRepresentableException(message: String) : Exception(message) {
* - string * - string
* - booleans * - booleans
* - actionIcon * - actionIcon
* to display the appropriate numericValues in graphical filterElements, such as labels, textfields, switchs... * to display the appropriate numericValues in graphical filterConditions, such as labels, textfields, switchs...
*/ */
interface DisplayableDataSource { interface DisplayableDataSource {

@ -182,7 +182,7 @@ class DataListFragment : PokerAnalyticsFragment(), LiveRowRepresentableDataSourc
*/ */
private fun showUndoSnackBar() { private fun showUndoSnackBar() {
val message = String.format(getString(R.string.data_deleted), this.dataType.localizedTitle(requireContext())) val message = String.format(getString(R.string.data_deleted), this.dataType.localizedTitle(requireContext()))
val snackBar = Snackbar.make(constraintLayout, message, Snackbar.LENGTH_LONG) val snackBar = Snackbar.make(constraintLayout, message, Snackbar.LENGTH_INDEFINITE)
snackBar.setAction(R.string.cancel) { snackBar.setAction(R.string.cancel) {
getRealm().executeTransaction { realm -> getRealm().executeTransaction { realm ->
deletedItem?.let { deletedItem?.let {

@ -175,7 +175,7 @@ open class FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresenta
val realm = getRealm() val realm = getRealm()
realm.beginTransaction() realm.beginTransaction()
currentFilter?.createOrUpdateFilterElements(selectedRows) currentFilter?.createOrUpdateFilterConditions(selectedRows)
realm.commitTransaction() realm.commitTransaction()
finishActivityWithResult(currentFilter?.id) finishActivityWithResult(currentFilter?.id)

@ -3,9 +3,9 @@ package net.pokeranalytics.android.ui.view.rowrepresentable
import android.content.Context import android.content.Context
import net.pokeranalytics.android.R import net.pokeranalytics.android.R
import net.pokeranalytics.android.exceptions.PokerAnalyticsException import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.filter.QueryType import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.interfaces.Manageable import net.pokeranalytics.android.model.interfaces.Manageable
import net.pokeranalytics.android.model.realm.FilterElement import net.pokeranalytics.android.model.realm.FilterCondition
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 java.util.* import java.util.*
@ -62,26 +62,26 @@ sealed class FilterElementRow : RowRepresentable {
lateinit var filterSectionRow: FilterSectionRow lateinit var filterSectionRow: FilterSectionRow
val filterName: String = this.queryType.name val filterName: String = this.queryCondition.name
private val queryType: QueryType private val queryCondition: QueryCondition
get() { get() {
return when (this) { return when (this) {
is Cash -> QueryType.CASH is Cash -> QueryCondition.CASH
is Tournament -> QueryType.TOURNAMENT is Tournament -> QueryCondition.TOURNAMENT
is Blind -> QueryType.BLINDS is Blind -> QueryCondition.BLINDS
is From -> QueryType.STARTED_FROM_DATE is From -> QueryCondition.STARTED_FROM_DATE
is To -> QueryType.ENDED_TO_DATE is To -> QueryCondition.ENDED_TO_DATE
is Month -> QueryType.MONTH is Month -> QueryCondition.MONTH
is Day -> QueryType.DAY_OF_WEEK is Day -> QueryCondition.DAY_OF_WEEK
is Year -> QueryType.YEAR is Year -> QueryCondition.YEAR
is Live -> QueryType.LIVE is Live -> QueryCondition.LIVE
is Online -> QueryType.ONLINE is Online -> QueryCondition.ONLINE
is Weekday -> QueryType.WEEK_DAY is Weekday -> QueryCondition.WEEK_DAY
is Weekend -> QueryType.WEEK_END is Weekend -> QueryCondition.WEEK_END
/* /*
is Today -> QueryType. is Today -> QueryCondition.
is Yesterday -> R.string.yesterday is Yesterday -> R.string.yesterday
is TodayAndYesterday -> R.string.yesterday_and_today is TodayAndYesterday -> R.string.yesterday_and_today
is CurrentWeek -> R.string.current_week is CurrentWeek -> R.string.current_week
@ -90,23 +90,23 @@ sealed class FilterElementRow : RowRepresentable {
is PastDays -> R.string.period_in_days is PastDays -> R.string.period_in_days
*/ */
is Limit -> QueryType.LIMIT is Limit -> QueryCondition.LIMIT
is TableSize -> QueryType.TABLE_SIZE is TableSize -> QueryCondition.TABLE_SIZE
is Game -> QueryType.GAME is Game -> QueryCondition.GAME
is Bankroll -> QueryType.BANKROLL is Bankroll -> QueryCondition.BANKROLL
is Location -> QueryType.LOCATION is Location -> QueryCondition.LOCATION
is TournamentName -> QueryType.TOURNAMENT_NAME is TournamentName -> QueryCondition.TOURNAMENT_NAME
is AnyTournamentFeature -> QueryType.ANY_TOURNAMENT_FEATURES is AnyTournamentFeature -> QueryCondition.ANY_TOURNAMENT_FEATURES
is AllTournamentFeature -> QueryType.ALL_TOURNAMENT_FEATURES is AllTournamentFeature -> QueryCondition.ALL_TOURNAMENT_FEATURES
is ResultMoreThan -> QueryType.MORE_THAN_NET_RESULT is ResultMoreThan -> QueryCondition.MORE_THAN_NET_RESULT
is ResultLessThan -> QueryType.LESS_THAN_NET_RESULT is ResultLessThan -> QueryCondition.LESS_THAN_NET_RESULT
else -> throw PokerAnalyticsException.UnknownQueryTypeForRow(this) else -> throw PokerAnalyticsException.UnknownQueryTypeForRow(this)
} }
} }
fun contains(filterElements: List<FilterElement>): Boolean { fun contains(filterConditions: List<FilterCondition>): Boolean {
return when (this) { return when (this) {
is DataFilterElementRow -> filterElements.any { is DataFilterElementRow -> filterConditions.any {
it.ids.contains(this.id) it.ids.contains(this.id)
} }
is StaticDataFilterElementRow ->filterElements.any { is StaticDataFilterElementRow ->filterElements.any {

Loading…
Cancel
Save