refactor QueryCondition enum to sealedclass

feature/top10
Razmig Sarkissian 7 years ago
parent 346cece99d
commit 02c73ba487
  1. 8
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt
  2. 14
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt
  3. 2
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/ExceptionFilterInstrumentedTest.kt
  4. 4
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt
  5. 32
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt
  6. 184
      app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt
  7. 8
      app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
  8. 2
      app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt
  9. 44
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  10. 155
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt

@ -42,7 +42,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.BLIND val filter = QueryCondition.BLIND()
val blind = FilterElementRow.Blind(s1.blinds!!, true) val blind = FilterElementRow.Blind(s1.blinds!!, true)
blind.filterSectionRow = FilterSectionRow.BLIND blind.filterSectionRow = FilterSectionRow.BLIND
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind)) val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
@ -86,7 +86,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.BLIND val filter = QueryCondition.BLIND()
val blind1 = FilterElementRow.Blind(s1.blinds!!, true) val blind1 = FilterElementRow.Blind(s1.blinds!!, true)
val blind2 = FilterElementRow.Blind(s2.blinds!!, true) val blind2 = FilterElementRow.Blind(s2.blinds!!, true)
blind1.filterSectionRow = FilterSectionRow.BLIND blind1.filterSectionRow = FilterSectionRow.BLIND
@ -132,7 +132,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.BLIND val filter = QueryCondition.BLIND()
val blind = FilterElementRow.Blind(s3.blinds!!, false) val blind = FilterElementRow.Blind(s3.blinds!!, false)
blind.filterSectionRow = FilterSectionRow.BLIND blind.filterSectionRow = FilterSectionRow.BLIND
@ -175,7 +175,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.BLIND val filter = QueryCondition.BLIND()
val blind1 = FilterElementRow.Blind(s1.blinds!!, false) val blind1 = FilterElementRow.Blind(s1.blinds!!, false)
blind1.filterSectionRow = FilterSectionRow.BLIND blind1.filterSectionRow = FilterSectionRow.BLIND

@ -30,7 +30,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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))
@ -59,7 +59,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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))
@ -88,7 +88,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time) Session.testInstance(100.0, true, cal.time)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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
@ -383,7 +383,7 @@ 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 = QueryCondition.STARTED_FROM_DATE val filter = QueryCondition.STARTED_FROM_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s2.startDate!!} val filterElementRow = FilterElementRow.From.apply { dateValue = s2.startDate!!}
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -411,7 +411,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.STARTED_TO_DATE val filter = QueryCondition.STARTED_TO_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s1.startDate!! } val filterElementRow = FilterElementRow.From.apply { dateValue = s1.startDate!! }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -440,7 +440,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.ENDED_FROM_DATE val filter = QueryCondition.ENDED_FROM_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s2.endDate() } val filterElementRow = FilterElementRow.From.apply { dateValue = s2.endDate() }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -469,7 +469,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.ENDED_TO_DATE val filter = QueryCondition.ENDED_TO_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s1.endDate() } val filterElementRow = FilterElementRow.From.apply { dateValue = s1.endDate() }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))

@ -15,7 +15,7 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
@Test(expected = PokerAnalyticsException.FilterElementExpectedValueMissing::class) @Test(expected = PokerAnalyticsException.FilterElementExpectedValueMissing::class)
fun testValueKeyFilterException() { fun testValueKeyFilterException() {
val filter = QueryCondition.STARTED_FROM_DATE val filter = QueryCondition.STARTED_FROM_DATE()
val filterElement = FilterCondition() val filterElement = FilterCondition()
filter.updateValueMap(filterElement) filter.updateValueMap(filterElement)

@ -38,7 +38,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filterComponent = filter.filterConditions.first() val filterComponent = filter.filterConditions.first()
filterComponent?.let { filterComponent?.let {
Assert.assertEquals(QueryCondition.CASH, QueryCondition.valueOf(it.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName)) Assert.assertTrue(it.queryCondition is QueryCondition.CASH)
} ?: run { } ?: run {
Assert.fail() Assert.fail()
} }
@ -55,7 +55,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Assert.assertEquals(1, sessions.size) Assert.assertEquals(1, sessions.size)
sessions[0]?.run { sessions[0]?.run {
Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type) Assert.assertEquals(Session.Type.CASH_GAME.ordinal, this.type)
} ?: run { } ?: run {
Assert.fail() Assert.fail()
} }

@ -109,7 +109,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(bankroll = b2) Session.testInstance(bankroll = b2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -140,7 +140,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(bankroll = b3) Session.testInstance(bankroll = b3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.BANKROLL val filter = QueryCondition.BANKROLL()
val filterElementRow = FilterElementRow.Bankroll(b1) val filterElementRow = FilterElementRow.Bankroll(b1)
filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
@ -169,7 +169,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(game = g2) Session.testInstance(game = g2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -200,7 +200,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(game = g3) Session.testInstance(game = g3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.GAME val filter = QueryCondition.GAME()
val filterElementRow = FilterElementRow.Game(g2) val filterElementRow = FilterElementRow.Game(g2)
filterElementRow.filterSectionRow = FilterSectionRow.GAME filterElementRow.filterSectionRow = FilterSectionRow.GAME
@ -229,7 +229,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(location = l2) Session.testInstance(location = l2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -260,7 +260,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(location = l3) Session.testInstance(location = l3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.LOCATION val filter = QueryCondition.LOCATION()
val filterElementRow = FilterElementRow.Location(l1) val filterElementRow = FilterElementRow.Location(l1)
filterElementRow.filterSectionRow = FilterSectionRow.LOCATION filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
@ -290,7 +290,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentName = t2) Session.testInstance(tournamentName = t2)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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
@ -322,7 +322,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentName = t3) Session.testInstance(tournamentName = t3)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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)
@ -358,7 +358,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1)) Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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)
@ -393,7 +393,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1)) Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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)
@ -427,7 +427,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1)) Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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(FilterCondition(filterElementRows = arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -452,7 +452,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tableSize = 10) Session.testInstance(tableSize = 10)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.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))
@ -479,7 +479,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s2 = Session.testInstance(netResult = 570.0) val s2 = Session.testInstance(netResult = 570.0)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.MORE_THAN_NET_RESULT val filter = QueryCondition.MORE_THAN_NET_RESULT()
val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 204.0 } val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 204.0 }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -504,7 +504,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(netResult = 570.0) Session.testInstance(netResult = 570.0)
realm.commitTransaction() realm.commitTransaction()
val filter = QueryCondition.LESS_THAN_NET_RESULT val filter = QueryCondition.LESS_THAN_NET_RESULT()
val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 540.0 } val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 540.0 }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -529,12 +529,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(netResult = 570.0) Session.testInstance(netResult = 570.0)
realm.commitTransaction() realm.commitTransaction()
val filterMore = QueryCondition.MORE_THAN_NET_RESULT val filterMore = QueryCondition.MORE_THAN_NET_RESULT()
val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 200.0 } val filterElementRow = FilterElementRow.ResultMoreThan.apply { this.amount = 200.0 }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filterMore.updateValueMap(FilterCondition(arrayListOf(filterElementRow))) filterMore.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
val filterLess = QueryCondition.LESS_THAN_NET_RESULT val filterLess = QueryCondition.LESS_THAN_NET_RESULT()
val filterElementRow2 = FilterElementRow.ResultMoreThan.apply { this.amount = 400.0 } val filterElementRow2 = FilterElementRow.ResultMoreThan.apply { this.amount = 400.0 }
filterElementRow2.filterSectionRow = FilterSectionRow.VALUE filterElementRow2.filterSectionRow = FilterSectionRow.VALUE
filterLess.updateValueMap(FilterCondition(arrayListOf(filterElementRow2))) filterLess.updateValueMap(FilterCondition(arrayListOf(filterElementRow2)))

@ -18,68 +18,20 @@ fun List<QueryCondition>.name() : String {
* 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 QueryCondition(var operator: Operator? = null) {
LIVE,
CASH,
ONLINE,
TOURNAMENT,
BANKROLL,
GAME,
TOURNAMENT_NAME,
ANY_TOURNAMENT_FEATURES,
ALL_TOURNAMENT_FEATURES,
LOCATION,
LIMIT,
TABLE_SIZE,
TOURNAMENT_TYPE,
BLIND,
LAST_GAMES,
LAST_SESSIONS,
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),
MIN_RE_BUY(Operator.MORE),
MAX_RE_BUY(Operator.LESS),
// Dates sealed class QueryCondition(var operator: Operator? = null) {
STARTED_FROM_DATE,
STARTED_TO_DATE,
ENDED_FROM_DATE,
ENDED_TO_DATE,
DAY_OF_WEEK,
MONTH,
YEAR,
WEEK_DAY,
WEEK_END,
TODAY,
YESTERDAY,
TODAY_AND_YESTERDAY,
THIS_WEEK,
THIS_MONTH,
THIS_YEAR,
PAST_DAYS,
MORE_THAN_DURATION(Operator.MORE),
LESS_THAN_DURATION(Operator.LESS),
STARTED_FROM_TIME,
ENDED_TO_TIME,
COMMENT, abstract class QueryDataCondition : QueryCondition()
; companion object {
fun valueOf(name:String) : QueryCondition {
val kClass = Class.forName("${QueryCondition::class.qualifiedName}$$name").kotlin
val instance = kClass.objectInstance ?: kClass.java.newInstance()
return instance as QueryCondition
}
}
val name: String = this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName
enum class Operator { enum class Operator {
BETWEEN, BETWEEN,
@ -87,6 +39,67 @@ enum class QueryCondition(var operator: Operator? = null) {
LESS; LESS;
} }
object LIVE : QueryCondition()
object CASH : QueryCondition()
object ONLINE : QueryCondition()
object TOURNAMENT: QueryCondition()
class BANKROLL: QueryDataCondition()
class GAME: QueryCondition()
class TOURNAMENT_NAME: QueryCondition()
class ANY_TOURNAMENT_FEATURES: QueryCondition()
class ALL_TOURNAMENT_FEATURES: QueryCondition()
class LOCATION: QueryCondition()
class LIMIT: QueryCondition()
class TABLE_SIZE: QueryCondition()
class TOURNAMENT_TYPE: QueryCondition()
class BLIND: QueryCondition()
class LAST_GAMES: QueryCondition()
class LAST_SESSIONS: QueryCondition()
class MORE_NUMBER_OF_TABLE: QueryCondition(Operator.MORE)
class LESS_NUMBER_OF_TABLE: QueryCondition(Operator.LESS)
class BETWEEN_NUMBER_OF_TABLE: QueryCondition(Operator.BETWEEN)
class MORE_THAN_NET_RESULT: QueryCondition(Operator.MORE)
class LESS_THAN_NET_RESULT: QueryCondition(Operator.LESS)
class MORE_THAN_BUY_IN: QueryCondition(Operator.MORE)
class LESS_THAN_BUY_IN: QueryCondition(Operator.LESS)
class MORE_THAN_CASH_OUT: QueryCondition(Operator.MORE)
class LESS_THAN_CASH_OUT: QueryCondition(Operator.LESS)
class MORE_THAN_TIPS: QueryCondition(Operator.MORE)
class LESS_THAN_TIPS: QueryCondition(Operator.LESS)
class MORE_THAN_NUMBER_OF_PLAYER: QueryCondition(Operator.MORE)
class LESS_THAN_NUMBER_OF_PLAYER: QueryCondition(Operator.LESS)
class BETWEEN_NUMBER_OF_PLAYER: QueryCondition(Operator.BETWEEN)
class MORE_THAN_TOURNAMENT_FEE: QueryCondition(Operator.MORE)
class LESS_THAN_TOURNAMENT_FEE: QueryCondition(Operator.LESS)
class BETWEEN_TOURNAMENT_FEE: QueryCondition(Operator.BETWEEN)
class MIN_RE_BUY: QueryCondition(Operator.MORE)
class MAX_RE_BUY: QueryCondition(Operator.LESS)
// Dates
class STARTED_FROM_DATE: QueryCondition()
class STARTED_TO_DATE: QueryCondition()
class ENDED_FROM_DATE: QueryCondition()
class ENDED_TO_DATE: QueryCondition()
class DAY_OF_WEEK: QueryCondition()
class MONTH: QueryCondition()
class YEAR: QueryCondition()
object WEEK_DAY: QueryCondition()
object WEEK_END: QueryCondition()
object TODAY: QueryCondition()
object YESTERDAY: QueryCondition()
object TODAY_AND_YESTERDAY: QueryCondition()
object THIS_WEEK: QueryCondition()
object THIS_MONTH: QueryCondition()
object THIS_YEAR: QueryCondition()
class PAST_DAYS: QueryCondition()
class MORE_THAN_DURATION: QueryCondition(Operator.MORE)
class LESS_THAN_DURATION: QueryCondition(Operator.LESS)
class STARTED_FROM_TIME: QueryCondition()
class ENDED_TO_TIME: QueryCondition()
class COMMENT: QueryCondition()
var valueMap : Map<String, Any?>? = null var valueMap : Map<String, Any?>? = null
get() { get() {
this.filterValuesExpectedKeys?.let { valueMapExceptedKeys -> this.filterValuesExpectedKeys?.let { valueMapExceptedKeys ->
@ -112,13 +125,13 @@ enum class QueryCondition(var operator: Operator? = null) {
} }
} }
return when (this) { return when (this) {
BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES, TOURNAMENT_NAME -> arrayOf("ids") is BANKROLL, is GAME, is LOCATION, is ANY_TOURNAMENT_FEATURES, is ALL_TOURNAMENT_FEATURES, is TOURNAMENT_NAME -> arrayOf("ids")
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> arrayOf("values") is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> arrayOf("values")
BLIND -> arrayOf("blinds", "hasDefaultCurrency") is BLIND -> arrayOf("blinds", "hasDefaultCurrency")
STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date") is STARTED_FROM_DATE, is STARTED_TO_DATE, is ENDED_FROM_DATE, is ENDED_TO_DATE -> arrayOf("date")
DAY_OF_WEEK -> arrayOf("dayOfWeek") is DAY_OF_WEEK -> arrayOf("dayOfWeek")
MONTH -> arrayOf("month") is MONTH -> arrayOf("month")
YEAR -> arrayOf("year") is YEAR -> arrayOf("year")
else -> null else -> null
} }
} }
@ -150,18 +163,18 @@ enum class QueryCondition(var operator: Operator? = null) {
LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE) LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE)
CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal)
TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal) TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal)
ALL_TOURNAMENT_FEATURES -> { is ALL_TOURNAMENT_FEATURES -> {
val ids: Array<String> by valueMap val ids: Array<String> by valueMap
ids.forEach { ids.forEach {
realmQuery.equalTo(fieldName, it) realmQuery.equalTo(fieldName, it)
} }
realmQuery realmQuery
} }
ANY_TOURNAMENT_FEATURES -> { is ANY_TOURNAMENT_FEATURES -> {
val ids: Array<String> by valueMap val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids) realmQuery.`in`(fieldName, ids)
} }
BLIND -> { is BLIND -> {
val blinds: Array<String> by valueMap val blinds: Array<String> by valueMap
val hasDefaultCurrency: Array<Boolean> by valueMap val hasDefaultCurrency: Array<Boolean> by valueMap
//realmQuery.`in`(fieldName, blinds) //realmQuery.`in`(fieldName, blinds)
@ -182,39 +195,39 @@ enum class QueryCondition(var operator: Operator? = null) {
} }
realmQuery realmQuery
} }
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { is BANKROLL, is GAME, is LOCATION, is TOURNAMENT_NAME -> {
val ids: Array<String> by valueMap val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids) realmQuery.`in`(fieldName, ids)
} }
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> {
val values: Array<Int?>? by valueMap val values: Array<Int?>? by valueMap
realmQuery.`in`(fieldName, values) realmQuery.`in`(fieldName, values)
} }
STARTED_FROM_DATE -> { is STARTED_FROM_DATE -> {
val date: Date by valueMap val date: Date by valueMap
realmQuery.greaterThanOrEqualTo(fieldName, date) realmQuery.greaterThanOrEqualTo(fieldName, date)
} }
STARTED_TO_DATE -> { is STARTED_TO_DATE -> {
val date: Date by valueMap val date: Date by valueMap
realmQuery.lessThanOrEqualTo(fieldName, date) realmQuery.lessThanOrEqualTo(fieldName, date)
} }
ENDED_FROM_DATE -> { is ENDED_FROM_DATE -> {
val date: Date by valueMap val date: Date by valueMap
realmQuery.greaterThanOrEqualTo(fieldName, date) realmQuery.greaterThanOrEqualTo(fieldName, date)
} }
ENDED_TO_DATE -> { is ENDED_TO_DATE -> {
val date: Date by valueMap val date: Date by valueMap
realmQuery.lessThanOrEqualTo(fieldName, date) realmQuery.lessThanOrEqualTo(fieldName, date)
} }
DAY_OF_WEEK -> { is DAY_OF_WEEK -> {
val dayOfWeek: Int by valueMap val dayOfWeek: Int by valueMap
realmQuery.equalTo(fieldName, dayOfWeek) realmQuery.equalTo(fieldName, dayOfWeek)
} }
MONTH -> { is MONTH -> {
val month: Int by valueMap val month: Int by valueMap
realmQuery.equalTo(fieldName, month) realmQuery.equalTo(fieldName, month)
} }
YEAR -> { is YEAR -> {
val year: Int by valueMap val year: Int by valueMap
realmQuery.equalTo(fieldName, year) realmQuery.equalTo(fieldName, year)
} }
@ -280,27 +293,28 @@ enum class QueryCondition(var operator: Operator? = null) {
} }
when (this) { when (this) {
ALL_TOURNAMENT_FEATURES, ANY_TOURNAMENT_FEATURES, BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { is BANKROLL -> valueMap = mapOf("ids" to filterCondition.ids)
is ALL_TOURNAMENT_FEATURES, is ANY_TOURNAMENT_FEATURES, is GAME, is LOCATION, is TOURNAMENT_NAME -> {
valueMap = mapOf("ids" to filterCondition.ids) valueMap = mapOf("ids" to filterCondition.ids)
} }
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> {
valueMap = mapOf("values" to filterCondition.values) valueMap = mapOf("values" to filterCondition.values)
} }
BLIND -> { is BLIND -> {
valueMap = mapOf( valueMap = mapOf(
"blinds" to filterCondition.blinds, "blinds" to filterCondition.blinds,
"hasDefaultCurrency" to filterCondition.hasDefaultCurrency) "hasDefaultCurrency" to filterCondition.hasDefaultCurrency)
} }
STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> { is STARTED_FROM_DATE, is STARTED_TO_DATE, is ENDED_FROM_DATE, is ENDED_TO_DATE -> {
valueMap = mapOf("date" to filterCondition.date) valueMap = mapOf("date" to filterCondition.date)
} }
DAY_OF_WEEK -> { is DAY_OF_WEEK -> {
valueMap = mapOf("dayOfWeek" to filterCondition.dayOfWeek) valueMap = mapOf("dayOfWeek" to filterCondition.dayOfWeek)
} }
MONTH -> { is MONTH -> {
valueMap = mapOf("month" to filterCondition.month) valueMap = mapOf("month" to filterCondition.month)
} }
YEAR -> { is YEAR -> {
valueMap = mapOf("year" to filterCondition.year) valueMap = mapOf("year" to filterCondition.year)
} }
else -> { else -> {

@ -68,13 +68,13 @@ open class Filter : RealmObject() {
val casted = arrayListOf<FilterElementRow>() val casted = arrayListOf<FilterElementRow>()
filterConditionRows filterConditionRows
.map { .map {
it.filterName it.id
} }
.distinct() .distinct()
.forEach { filterName-> .forEach { filterName->
filterConditionRows filterConditionRows
.filter { .filter {
it.filterName == filterName it.id == filterName
} }
.apply { .apply {
casted.addAll(this) casted.addAll(this)
@ -97,7 +97,7 @@ open class Filter : RealmObject() {
fun contains(filterElementRow: FilterElementRow): Boolean { fun contains(filterElementRow: FilterElementRow): Boolean {
val filtered = filterConditions.filter { val filtered = filterConditions.filter {
it.filterName == filterElementRow.filterName it.filterName == filterElementRow.id
} }
if (filtered.isEmpty()) { if (filtered.isEmpty()) {
return false return false
@ -125,7 +125,7 @@ open class Filter : RealmObject() {
*/ */
private fun getSavedValueForElement(filterElementRow: FilterElementRow): Any? { private fun getSavedValueForElement(filterElementRow: FilterElementRow): Any? {
val filtered = filterConditions.filter { val filtered = filterConditions.filter {
it.filterName == filterElementRow.filterName it.filterName == filterElementRow.id
} }
if (filtered.isNotEmpty()) { if (filtered.isNotEmpty()) {

@ -15,7 +15,7 @@ open class FilterCondition() : RealmObject() {
this.sectionName = sectionName this.sectionName = sectionName
} }
constructor(filterElementRows: ArrayList<FilterElementRow>) : this(filterElementRows.first().filterName, filterElementRows.first().filterSectionRow.name) { constructor(filterElementRows: ArrayList<FilterElementRow>) : this(filterElementRows.first().id, filterElementRows.first().filterSectionRow.name) {
val row = filterElementRows.first() val row = filterElementRows.first()
this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName

@ -66,28 +66,28 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
return when (queryCondition) { return when (queryCondition) {
LIVE, ONLINE -> "bankroll.live" LIVE, ONLINE -> "bankroll.live"
CASH, TOURNAMENT -> "type" CASH, TOURNAMENT -> "type"
BANKROLL -> "bankroll.id" is BANKROLL -> "bankroll.id"
GAME -> "game.id" is GAME -> "game.id"
TOURNAMENT_NAME -> "tournamentName.id" is TOURNAMENT_NAME -> "tournamentName.id"
ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> "tournamentFeatures.id" is ANY_TOURNAMENT_FEATURES, is ALL_TOURNAMENT_FEATURES -> "tournamentFeatures.id"
LOCATION -> "location.id" is LOCATION -> "location.id"
LIMIT -> "limit" is LIMIT -> "limit"
TABLE_SIZE -> "tableSize" is TABLE_SIZE -> "tableSize"
TOURNAMENT_TYPE -> "tournamentType" is TOURNAMENT_TYPE -> "tournamentType"
BLIND -> "blind" is BLIND -> "blinds"
COMMENT -> "comment" is COMMENT -> "comment"
BETWEEN_NUMBER_OF_TABLE, MORE_NUMBER_OF_TABLE, LESS_NUMBER_OF_TABLE -> "numberOfTable" is BETWEEN_NUMBER_OF_TABLE, is MORE_NUMBER_OF_TABLE, is LESS_NUMBER_OF_TABLE -> "numberOfTable"
MORE_THAN_NET_RESULT, LESS_THAN_NET_RESULT -> "computableResults.ratedNet" is MORE_THAN_NET_RESULT, is LESS_THAN_NET_RESULT -> "computableResults.ratedNet"
MORE_THAN_BUY_IN, LESS_THAN_BUY_IN -> "result.buyin" is MORE_THAN_BUY_IN, is LESS_THAN_BUY_IN -> "result.buyin"
MORE_THAN_CASH_OUT, LESS_THAN_CASH_OUT -> "result.cashout" is MORE_THAN_CASH_OUT, is LESS_THAN_CASH_OUT -> "result.cashout"
MORE_THAN_TIPS, LESS_THAN_TIPS -> "result.tips" is MORE_THAN_TIPS, is LESS_THAN_TIPS -> "result.tips"
MORE_THAN_NUMBER_OF_PLAYER, LESS_THAN_NUMBER_OF_PLAYER, BETWEEN_NUMBER_OF_PLAYER -> "tournamentNumberOfPlayers" is MORE_THAN_NUMBER_OF_PLAYER, is LESS_THAN_NUMBER_OF_PLAYER, is BETWEEN_NUMBER_OF_PLAYER -> "tournamentNumberOfPlayers"
MORE_THAN_TOURNAMENT_FEE, LESS_THAN_TOURNAMENT_FEE, BETWEEN_TOURNAMENT_FEE -> "tournamentEntryFee" is MORE_THAN_TOURNAMENT_FEE, is LESS_THAN_TOURNAMENT_FEE, is BETWEEN_TOURNAMENT_FEE -> "tournamentEntryFee"
STARTED_FROM_DATE, STARTED_TO_DATE -> "startDate" is STARTED_FROM_DATE, is STARTED_TO_DATE -> "startDate"
ENDED_FROM_DATE, ENDED_TO_DATE -> "endDate" is ENDED_FROM_DATE, is ENDED_TO_DATE -> "endDate"
DAY_OF_WEEK, WEEK_END, WEEK_DAY -> "dayOfWeek" is DAY_OF_WEEK, is WEEK_END, is WEEK_DAY -> "dayOfWeek"
MONTH -> "month" is MONTH -> "month"
YEAR -> "year" is YEAR -> "year"
TODAY, YESTERDAY, TODAY_AND_YESTERDAY, THIS_YEAR, THIS_MONTH, THIS_WEEK -> "startDate" TODAY, YESTERDAY, TODAY_AND_YESTERDAY, THIS_YEAR, THIS_MONTH, THIS_WEEK -> "startDate"
else -> null else -> null
} }

@ -4,20 +4,16 @@ import android.content.Context
import android.text.InputType import android.text.InputType
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.QueryCondition
import net.pokeranalytics.android.model.interfaces.Manageable import net.pokeranalytics.android.model.interfaces.Manageable
import net.pokeranalytics.android.model.realm.FilterCondition import net.pokeranalytics.android.model.realm.FilterCondition
import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetType import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetType
import net.pokeranalytics.android.ui.view.RowRepresentable import net.pokeranalytics.android.ui.view.RowRepresentable
import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor
import net.pokeranalytics.android.ui.view.RowViewType import net.pokeranalytics.android.ui.view.RowViewType
import net.pokeranalytics.android.util.Preferences
import net.pokeranalytics.android.util.UserDefaults
import java.text.DateFormatSymbols import java.text.DateFormatSymbols
import java.util.* import java.util.*
sealed class FilterElementRow : RowRepresentable { sealed class FilterElementRow : RowRepresentable {
interface Duration { interface Duration {
var minutes: Int var minutes: Int
} }
@ -27,6 +23,7 @@ sealed class FilterElementRow : RowRepresentable {
interface LessOperator : Operator interface LessOperator : Operator
open class BoolFilterElementRow : FilterElementRow() open class BoolFilterElementRow : FilterElementRow()
open class DateFilterElementRow(var dateValue: Date = Date(), var showTime: Boolean = false) : FilterElementRow() open class DateFilterElementRow(var dateValue: Date = Date(), var showTime: Boolean = false) : FilterElementRow()
open class NumericFilterElementRow(open val doubleValue: Double = 0.0) : FilterElementRow() open class NumericFilterElementRow(open val doubleValue: Double = 0.0) : FilterElementRow()
open class StringFilterElementRow(val stringValue: String = "") : FilterElementRow() open class StringFilterElementRow(val stringValue: String = "") : FilterElementRow()
@ -40,11 +37,11 @@ sealed class FilterElementRow : RowRepresentable {
} }
open class DataFilterElementRow(data: Manageable) : StringFilterElementRow(data.id) { open class DataFilterElementRow(data: Manageable) : StringFilterElementRow(data.id) {
val id: String = data.id val objectId: String = data.id
val name: String = (data as RowRepresentable).getDisplayName() val name: String = (data as RowRepresentable).getDisplayName()
} }
open class StaticDataFilterElementRow(val row: RowRepresentable, val id: Int) : NumericFilterElementRow(id.toDouble()) { open class StaticDataFilterElementRow(val row: RowRepresentable, val objectId: Int) : NumericFilterElementRow(objectId.toDouble()) {
override val resId: Int? = row.resId override val resId: Int? = row.resId
val name: String = row.getDisplayName() val name: String = row.getDisplayName()
@ -139,50 +136,50 @@ sealed class FilterElementRow : RowRepresentable {
lateinit var filterSectionRow: FilterSectionRow lateinit var filterSectionRow: FilterSectionRow
val filterName: String = this.queryCondition.name val id: String = this.criteria.name
private val queryCondition: QueryCondition private val criteria: QueryCriteria
get() { get() {
return when (this) { return when (this) {
is Cash -> QueryCondition.CASH is Cash -> QueryCriteria.CASH
is Tournament -> QueryCondition.TOURNAMENT is Tournament -> QueryCriteria.TOURNAMENT
is Blind -> QueryCondition.BLIND is Blind -> QueryCriteria.BLIND
is From -> QueryCondition.STARTED_FROM_DATE is From -> QueryCriteria.STARTED_FROM_DATE
is To -> QueryCondition.ENDED_TO_DATE is To -> QueryCriteria.ENDED_TO_DATE
is FromTime -> QueryCondition.STARTED_FROM_TIME is FromTime -> QueryCriteria.STARTED_FROM_TIME
is ToTime -> QueryCondition.ENDED_TO_TIME is ToTime -> QueryCriteria.ENDED_TO_TIME
is Month -> QueryCondition.MONTH is Month -> QueryCriteria.MONTH
is Day -> QueryCondition.DAY_OF_WEEK is Day -> QueryCriteria.DAY_OF_WEEK
is Year -> QueryCondition.YEAR is Year -> QueryCriteria.YEAR
is Live -> QueryCondition.LIVE is Live -> QueryCriteria.LIVE
is Online -> QueryCondition.ONLINE is Online -> QueryCriteria.ONLINE
is Weekday -> QueryCondition.WEEK_DAY is Weekday -> QueryCriteria.WEEK_DAY
is Weekend -> QueryCondition.WEEK_END is Weekend -> QueryCriteria.WEEK_END
is Today -> QueryCondition.TODAY is Today -> QueryCriteria.TODAY
is Yesterday -> QueryCondition.YESTERDAY is Yesterday -> QueryCriteria.YESTERDAY
is TodayAndYesterday -> QueryCondition.TODAY_AND_YESTERDAY is TodayAndYesterday -> QueryCriteria.TODAY_AND_YESTERDAY
is CurrentWeek -> QueryCondition.THIS_WEEK is CurrentWeek -> QueryCriteria.THIS_WEEK
is CurrentMonth -> QueryCondition.THIS_MONTH is CurrentMonth -> QueryCriteria.THIS_MONTH
is CurrentYear -> QueryCondition.THIS_YEAR is CurrentYear -> QueryCriteria.THIS_YEAR
is PastDays -> QueryCondition.PAST_DAYS is PastDays -> QueryCriteria.PAST_DAYS
is Limit -> QueryCondition.LIMIT is Limit -> QueryCriteria.LIMIT
is TableSize -> QueryCondition.TABLE_SIZE is TableSize -> QueryCriteria.TABLE_SIZE
is Game -> QueryCondition.GAME is Game -> QueryCriteria.GAME
is Bankroll -> QueryCondition.BANKROLL is Bankroll -> QueryCriteria.BANKROLL
is Location -> QueryCondition.LOCATION is Location -> QueryCriteria.LOCATION
is TournamentName -> QueryCondition.TOURNAMENT_NAME is TournamentName -> QueryCriteria.TOURNAMENT_NAME
is AnyTournamentFeature -> QueryCondition.ANY_TOURNAMENT_FEATURES is AnyTournamentFeature -> QueryCriteria.ANY_TOURNAMENT_FEATURES
is AllTournamentFeature -> QueryCondition.ALL_TOURNAMENT_FEATURES is AllTournamentFeature -> QueryCriteria.ALL_TOURNAMENT_FEATURES
is ResultMoreThan -> QueryCondition.MORE_THAN_NET_RESULT is ResultMoreThan -> QueryCriteria.MORE_THAN_NET_RESULT
is ResultLessThan -> QueryCondition.LESS_THAN_NET_RESULT is ResultLessThan -> QueryCriteria.LESS_THAN_NET_RESULT
is DurationMoreThan -> QueryCondition.MORE_THAN_DURATION is DurationMoreThan -> QueryCriteria.MORE_THAN_DURATION
is DurationLessThan -> QueryCondition.LESS_THAN_DURATION is DurationLessThan -> QueryCriteria.LESS_THAN_DURATION
//TODO: Check the conditions //TODO: Check the conditions
is LastGames -> QueryCondition.LAST_GAMES is LastGames -> QueryCriteria.LAST_GAMES
is LastSessions -> QueryCondition.LAST_SESSIONS is LastSessions -> QueryCriteria.LAST_SESSIONS
is ReBuyMoreThan -> QueryCondition.MIN_RE_BUY is ReBuyMoreThan -> QueryCriteria.MIN_RE_BUY
is ReBuyLessThan -> QueryCondition.MAX_RE_BUY is ReBuyLessThan -> QueryCriteria.MAX_RE_BUY
else -> throw PokerAnalyticsException.UnknownQueryTypeForRow(this) else -> throw PokerAnalyticsException.UnknownQueryTypeForRow(this)
} }
@ -194,7 +191,7 @@ sealed class FilterElementRow : RowRepresentable {
it.values.contains(this.intValue) it.values.contains(this.intValue)
} }
is DataFilterElementRow -> filterConditions.any { is DataFilterElementRow -> filterConditions.any {
it.ids.contains(this.id) it.ids.contains(this.objectId)
} }
else -> true else -> true
} }
@ -327,4 +324,68 @@ sealed class FilterElementRow : RowRepresentable {
return null return null
} }
private enum class QueryCriteria {
LIVE,
CASH,
ONLINE,
TOURNAMENT,
BANKROLL,
GAME,
TOURNAMENT_NAME,
ANY_TOURNAMENT_FEATURES,
ALL_TOURNAMENT_FEATURES,
LOCATION,
LIMIT,
TABLE_SIZE,
TOURNAMENT_TYPE,
BLIND,
LAST_GAMES,
LAST_SESSIONS,
MORE_NUMBER_OF_TABLE,
LESS_NUMBER_OF_TABLE,
BETWEEN_NUMBER_OF_TABLE,
MORE_THAN_NET_RESULT,
LESS_THAN_NET_RESULT,
MORE_THAN_BUY_IN,
LESS_THAN_BUY_IN,
MORE_THAN_CASH_OUT,
LESS_THAN_CASH_OUT,
MORE_THAN_TIPS,
LESS_THAN_TIPS,
MORE_THAN_NUMBER_OF_PLAYER,
LESS_THAN_NUMBER_OF_PLAYER,
BETWEEN_NUMBER_OF_PLAYER,
MORE_THAN_TOURNAMENT_FEE,
LESS_THAN_TOURNAMENT_FEE,
BETWEEN_TOURNAMENT_FEE,
MIN_RE_BUY,
MAX_RE_BUY,
// Dates
STARTED_FROM_DATE,
STARTED_TO_DATE,
ENDED_FROM_DATE,
ENDED_TO_DATE,
DAY_OF_WEEK,
MONTH,
YEAR,
WEEK_DAY,
WEEK_END,
TODAY,
YESTERDAY,
TODAY_AND_YESTERDAY,
THIS_WEEK,
THIS_MONTH,
THIS_YEAR,
PAST_DAYS,
MORE_THAN_DURATION,
LESS_THAN_DURATION,
STARTED_FROM_TIME,
ENDED_TO_TIME,
COMMENT,
;
}
} }
Loading…
Cancel
Save