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. 116
      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
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.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.ui.view.rowrepresentable.FilterElementRow
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
@ -42,10 +42,10 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryType.BLINDS
val filter = QueryCondition.BLINDS
val blind = FilterElementRow.Blind(0.5, 1.0, null)
blind.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueMap(filterElement)
@ -86,11 +86,11 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryType.BLINDS
val filter = QueryCondition.BLINDS
val blind = FilterElementRow.Blind(null, 1.0, null)
blind.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -129,11 +129,11 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryType.BLINDS
val filter = QueryCondition.BLINDS
val blind = FilterElementRow.Blind(1.0, 2.0, "AUD")
blind.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind))
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -172,13 +172,13 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryType.BLINDS
val filter = QueryCondition.BLINDS
val blind1 = FilterElementRow.Blind(1.0, 2.0, null)
blind1.filterSectionRow = FilterSectionRow.BLINDS
val blind2 = FilterElementRow.Blind(0.5, 1.0, null)
blind2.filterSectionRow = FilterSectionRow.BLINDS
val filterElement = FilterElement(filterElementRows = arrayListOf(blind1, blind2))
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind1, blind2))
filter.updateValueMap(filterElement)
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 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.FilterElement
import net.pokeranalytics.android.model.realm.FilterCondition
import net.pokeranalytics.android.model.realm.Session
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterElementRow
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
@ -29,12 +29,12 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val filter = QueryType.DAY_OF_WEEK
val filter = QueryCondition.DAY_OF_WEEK
cal.time = s1.startDate
val filterElementRow = FilterElementRow.Day(cal.get(Calendar.DAY_OF_WEEK))
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
val filterElement = FilterElement(filterElementRow)
val filterElement = FilterCondition(filterElementRow)
filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -58,12 +58,12 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val filter = QueryType.MONTH
val filter = QueryCondition.MONTH
cal.time = s1.startDate
val filterElementRow = FilterElementRow.Month(cal.get(Calendar.MONTH))
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
val filterElement = FilterElement(filterElementRow)
val filterElement = FilterCondition(filterElementRow)
filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -87,11 +87,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val filter = QueryType.YEAR
val filter = QueryCondition.YEAR
cal.time = s1.startDate
val filterElementRow = FilterElementRow.Year(cal.get(Calendar.YEAR))
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
val filterElement = FilterElement(filterElementRow)
val filterElement = FilterCondition(filterElementRow)
filter.updateValueMap(filterElement)
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -117,7 +117,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time)
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)
sessions[0]?.run {
@ -142,7 +142,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
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)
sessions[0]?.run {
@ -165,10 +165,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s2 = Session.testInstance(100.0, true, cal.time, 1)
realm.commitTransaction()
val filter = QueryType.STARTED_FROM_DATE
val filter = QueryCondition.STARTED_FROM_DATE
val filterElementRow = FilterElementRow.From(s2.startDate!!)
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow))
filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -193,10 +193,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryType.STARTED_TO_DATE
val filter = QueryCondition.STARTED_TO_DATE
val filterElementRow = FilterElementRow.From(s1.startDate!!)
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow))
filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -222,10 +222,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryType.ENDED_FROM_DATE
val filter = QueryCondition.ENDED_FROM_DATE
val filterElementRow = FilterElementRow.From(s2.endDate())
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow))
filter.updateValueMap(FilterCondition(filterElementRow))
val sessions = Filter.queryOn<Session>(realm, arrayListOf(filter))
@ -251,10 +251,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryType.ENDED_TO_DATE
val filter = QueryCondition.ENDED_TO_DATE
val filterElementRow = FilterElementRow.From(s1.endDate())
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterElement(filterElementRow))
filter.updateValueMap(FilterCondition(filterElementRow))
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 net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
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.FilterElement
import net.pokeranalytics.android.model.realm.FilterCondition
import net.pokeranalytics.android.model.realm.Session
import org.junit.Test
import org.junit.runner.RunWith
@ -15,8 +15,8 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
@Test(expected = PokerAnalyticsException.FilterElementExpectedValueMissing::class)
fun testValueKeyFilterException() {
val filter = QueryType.STARTED_FROM_DATE
val filterElement = FilterElement()
val filter = QueryCondition.STARTED_FROM_DATE
val filterElement = FilterCondition()
filter.updateValueMap(filterElement)
val realm = this.mockRealm
@ -26,6 +26,6 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
@Test(expected = PokerAnalyticsException.FilterElementUnknownName::class)
fun testFilterException() {
FilterElement().queryType
FilterCondition().queryCondition
}
}

@ -3,7 +3,7 @@ package net.pokeranalytics.android.unitTests.filter
import androidx.test.ext.junit.runners.AndroidJUnit4
import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
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.Session
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
@ -27,7 +27,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filterElement = FilterElementRow.Cash
filterElement.filterSectionRow = FilterSectionRow.CASH_TOURNAMENT
filter.createOrUpdateFilterElements(arrayListOf(filterElement))
filter.createOrUpdateFilterConditions(arrayListOf(filterElement))
val useCount = filter.countBy(FilterCategoryRow.GENERAL)
Assert.assertEquals(1, useCount)
@ -35,10 +35,10 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val isCash = filter.contains(filterElement)
Assert.assertEquals(true, isCash)
val filterComponent = filter.filterElements.first()
val filterComponent = filter.filterConditions.first()
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 {
Assert.fail()
}

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

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

@ -9,8 +9,8 @@ class RowRepresentableEditDescriptorException(message: String) : Exception(messa
class ConfigurationException(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 FilterElementUnknownSectionName: PokerAnalyticsException(message = "No filterElement section 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 queryCondition")
object FilterMissingEntity: PokerAnalyticsException(message = "This filter has no entity initialized")
object FilterUnhandledEntity : PokerAnalyticsException(message = "This entity is not filterable")
object QueryValueMapUnknown: PokerAnalyticsException(message = "fieldName is missing")

@ -41,9 +41,9 @@ class UnmanagedFilterField(message: String) : Exception(message) {
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 {
inline fun <reified T : Filterable> fieldNameForQueryType(queryType: QueryType): String? {
inline fun <reified T : Filterable> fieldNameForQueryType(queryCondition: QueryCondition): String? {
return when (T::class.java) {
Session::class.java -> Session.fieldNameForQueryType(queryType)
ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryType)
SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryType)
Session::class.java -> Session.fieldNameForQueryType(queryCondition)
ComputableResult::class.java -> ComputableResult.fieldNameForQueryType(queryCondition)
SessionSet::class.java -> SessionSet.fieldNameForQueryType(queryCondition)
else -> {
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@filter true

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

@ -15,41 +15,33 @@ class PokerAnalyticsMigration : RealmMigration {
var currentVersion = oldVersion.toInt()
Timber.d("*** migrate from $oldVersion to $newVersion")
// Migrate to version 1: Add a new class.
// Example:
// public Person extends RealmObject {
// private String name;
// private int age;
// // getters and setters left out for brevity
// }
/*
// Migrate to version 1
if (currentVersion == 0) {
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++
}
*/
// 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
// }
/*
// Migrate to version 2
if (currentVersion == 1) {
schema.get("Person")!!
.addField("id", Long::class.javaPrimitiveType!!, FieldAttribute.PRIMARY_KEY)
.addRealmObjectField("favoriteDog", schema.get("Dog")!!)
.addRealmListField("dogs", schema.get("Dog")!!)
Timber.d("*** Running migration ${currentVersion + 1}")
schema.rename("FilterElement", "FilterCondition")
schema.get("Filter")?.let {
it.renameField("filterElements", "filterConditions")
}
currentVersion++
}
*/
}

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

@ -1,11 +1,12 @@
package net.pokeranalytics.android.model.realm
import com.google.android.libraries.places.internal.it
import io.realm.*
import io.realm.annotations.PrimaryKey
import io.realm.kotlin.where
import net.pokeranalytics.android.exceptions.PokerAnalyticsException
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.FilterElementRow
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
* 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
*/
open class Filter : RealmObject() {
@ -39,15 +40,15 @@ open class Filter : RealmObject() {
return realm.where<Filter>().equalTo("id", filterId).findFirst()
}
@TestOnly
inline fun <reified T : Filterable> queryOn(realm: Realm, queries: List<QueryType>): RealmResults<T> {
var realmQuery = realm.where<T>()
queries.forEach {
realmQuery = it.filter<T>(realmQuery)
}
return realmQuery.findAll()
}
}
@TestOnly
inline fun <reified T : Filterable> queryOn(realm: Realm, queries: List<QueryCondition>): RealmResults<T> {
var realmQuery = realm.where<T>()
queries.forEach {
realmQuery = it.filter<T>(realmQuery)
}
return realmQuery.findAll()
}
}
@PrimaryKey
var id = UUID.randomUUID().toString()
@ -59,60 +60,59 @@ open class Filter : RealmObject() {
// for MutableRealmInteger, see https://realm.io/docs/java/latest/#counters
val usageCount: MutableRealmInteger = MutableRealmInteger.valueOf(0)
var filterElements: RealmList<FilterElement> = RealmList()
private set
fun createOrUpdateFilterElements(filterElementRows: ArrayList<FilterElementRow>) {
filterElements.clear()
filterElementRows
.map {
it.filterSectionRow
}
.distinct()
.forEach { section ->
filterElementRows
.filter {
it.filterSectionRow == section
}
.apply {
if (this.size == 1) {
filterElements.add(FilterElement(this.first()))
} else {
val casted = arrayListOf<FilterElementRow>()
casted.addAll(this)
filterElements.add(FilterElement(casted))
}
var filterConditions: RealmList<FilterCondition> = RealmList()
private set
fun createOrUpdateFilterConditions(filterConditionRows: ArrayList<FilterElementRow>) {
filterConditions.clear()
filterConditionRows
.map {
it.filterSectionRow
}
.distinct()
.forEach { section ->
filterConditionRows
.filter {
it.filterSectionRow == section
}
.apply {
if (this.size == 1) {
filterConditions.add(FilterCondition(this.first()))
} else {
val casted = arrayListOf<FilterElementRow>()
casted.addAll(this)
filterConditions.add(FilterCondition(casted))
}
}
}
}
fun countBy(filterCategoryRow: FilterCategoryRow): Int {
val sections = filterCategoryRow.filterSectionRows
return filterElements.count {
sections.contains(FilterSectionRow.valueOf(it.sectionName ?: throw PokerAnalyticsException.FilterElementUnknownSectionName))
}
}
fun contains(filterElementRow: FilterElementRow): Boolean {
val filtered = filterElements.filter {
it.filterName == filterElementRow.filterName
}
if (filtered.isEmpty()) {
return false
}
return filterElementRow.contains(filtered)
}
fun countBy(filterCategoryRow: FilterCategoryRow) : Int {
val sections = filterCategoryRow.filterSectionRows
return filterConditions.count {
sections.contains(FilterSectionRow.valueOf(it.sectionName ?: throw PokerAnalyticsException.FilterElementUnknownSectionName))
}
}
fun contains(filterElementRow:FilterElementRow) : Boolean {
val filtered = filterConditions.filter {
it.filterName == filterElementRow.filterName
}
if (filtered.isEmpty()) {
return false
}
return filterElementRow.contains(filtered)
}
inline fun <reified T : Filterable> results(): RealmResults<T> {
var realmQuery = realm.where<T>()
this.filterElements.map {
it.queryType
}.forEach {
realmQuery = it.filter(realmQuery)
}
var realmQuery = realm.where<T>()
this.filterConditions.map {
it.queryCondition
}.forEach {
realmQuery = it.filter(realmQuery)
}
return realmQuery.findAll()
}

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

@ -6,7 +6,7 @@ import io.realm.RealmResults
import io.realm.annotations.Ignore
import io.realm.annotations.LinkingObjects
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 java.util.*
@ -56,8 +56,8 @@ open class SessionSet : RealmObject(), Timed, Filterable {
return realm.copyToRealm(sessionSet)
}
fun fieldNameForQueryType(queryType: QueryType): String? {
return "sessions." + Session.fieldNameForQueryType(queryType)
fun fieldNameForQueryType(queryCondition: QueryCondition): String? {
return "sessions." + Session.fieldNameForQueryType(queryCondition)
}
}

@ -102,7 +102,7 @@ class UnmanagedRowRepresentableException(message: String) : Exception(message) {
* - string
* - booleans
* - 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 {

@ -182,7 +182,7 @@ class DataListFragment : PokerAnalyticsFragment(), LiveRowRepresentableDataSourc
*/
private fun showUndoSnackBar() {
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) {
getRealm().executeTransaction { realm ->
deletedItem?.let {

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

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

Loading…
Cancel
Save