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

feature/top10
Aurelien Hubert 7 years ago
commit d3826e6e61
  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. 10
      app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
  7. 184
      app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt
  8. 8
      app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt
  9. 2
      app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt
  10. 44
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  11. 155
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt

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

@ -30,7 +30,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val filter = QueryCondition.DAY_OF_WEEK
val filter = QueryCondition.DAY_OF_WEEK()
cal.time = s1.startDate
val filterElementRow = FilterElementRow.Day(cal.get(Calendar.DAY_OF_WEEK))
@ -59,7 +59,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val filter = QueryCondition.MONTH
val filter = QueryCondition.MONTH()
cal.time = s1.startDate
val filterElementRow = FilterElementRow.Month(cal.get(Calendar.MONTH))
@ -88,7 +88,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val filter = QueryCondition.YEAR
val filter = QueryCondition.YEAR()
cal.time = s1.startDate
val filterElementRow = FilterElementRow.Year(cal.get(Calendar.YEAR))
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
@ -383,7 +383,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s2 = Session.testInstance(100.0, true, cal.time, 1)
realm.commitTransaction()
val filter = QueryCondition.STARTED_FROM_DATE
val filter = QueryCondition.STARTED_FROM_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s2.startDate!!}
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -411,7 +411,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryCondition.STARTED_TO_DATE
val filter = QueryCondition.STARTED_TO_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s1.startDate!! }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -440,7 +440,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryCondition.ENDED_FROM_DATE
val filter = QueryCondition.ENDED_FROM_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s2.endDate() }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -469,7 +469,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filter = QueryCondition.ENDED_TO_DATE
val filter = QueryCondition.ENDED_TO_DATE()
val filterElementRow = FilterElementRow.From.apply { dateValue = s1.endDate() }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))

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

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

@ -109,7 +109,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(bankroll = b2)
realm.commitTransaction()
val filter = QueryCondition.BANKROLL
val filter = QueryCondition.BANKROLL()
val filterElementRow = FilterElementRow.Bankroll(b1)
filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -140,7 +140,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(bankroll = b3)
realm.commitTransaction()
val filter = QueryCondition.BANKROLL
val filter = QueryCondition.BANKROLL()
val filterElementRow = FilterElementRow.Bankroll(b1)
filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
@ -169,7 +169,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(game = g2)
realm.commitTransaction()
val filter = QueryCondition.GAME
val filter = QueryCondition.GAME()
val filterElementRow = FilterElementRow.Game(g2)
filterElementRow.filterSectionRow = FilterSectionRow.GAME
filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -200,7 +200,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(game = g3)
realm.commitTransaction()
val filter = QueryCondition.GAME
val filter = QueryCondition.GAME()
val filterElementRow = FilterElementRow.Game(g2)
filterElementRow.filterSectionRow = FilterSectionRow.GAME
@ -229,7 +229,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(location = l2)
realm.commitTransaction()
val filter = QueryCondition.LOCATION
val filter = QueryCondition.LOCATION()
val filterElementRow = FilterElementRow.Location(l1)
filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -260,7 +260,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(location = l3)
realm.commitTransaction()
val filter = QueryCondition.LOCATION
val filter = QueryCondition.LOCATION()
val filterElementRow = FilterElementRow.Location(l1)
filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
@ -290,7 +290,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentName = t2)
realm.commitTransaction()
val filter = QueryCondition.TOURNAMENT_NAME
val filter = QueryCondition.TOURNAMENT_NAME()
val filterElementRow = FilterElementRow.TournamentName(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
@ -322,7 +322,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentName = t3)
realm.commitTransaction()
val filter = QueryCondition.TOURNAMENT_NAME
val filter = QueryCondition.TOURNAMENT_NAME()
val filterElementRow = FilterElementRow.TournamentName(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
val filterElementRow2 = FilterElementRow.TournamentName(t2)
@ -358,7 +358,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction()
val filter = QueryCondition.ALL_TOURNAMENT_FEATURES
val filter = QueryCondition.ALL_TOURNAMENT_FEATURES()
val filterElementRow = FilterElementRow.AllTournamentFeature(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
val filterElementRow2 = FilterElementRow.AllTournamentFeature(t2)
@ -393,7 +393,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction()
val filter = QueryCondition.ANY_TOURNAMENT_FEATURES
val filter = QueryCondition.ANY_TOURNAMENT_FEATURES()
val filterElementRow = FilterElementRow.AnyTournamentFeature(t1)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
val filterElementRow2 = FilterElementRow.AnyTournamentFeature(t2)
@ -427,7 +427,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tournamentFeatures = RealmList(t1))
realm.commitTransaction()
val filter = QueryCondition.ANY_TOURNAMENT_FEATURES
val filter = QueryCondition.ANY_TOURNAMENT_FEATURES()
val filterElementRow = FilterElementRow.AnyTournamentFeature(t2)
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filter.updateValueMap(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
@ -452,7 +452,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(tableSize = 10)
realm.commitTransaction()
val filter = QueryCondition.TABLE_SIZE
val filter = QueryCondition.TABLE_SIZE()
val filterElementRow = FilterElementRow.TableSize(TableSize(2))
filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
val filterElementRow2 = FilterElementRow.TableSize(TableSize(4))
@ -479,7 +479,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s2 = Session.testInstance(netResult = 570.0)
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 }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -504,7 +504,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(netResult = 570.0)
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 }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filter.updateValueMap(FilterCondition(arrayListOf(filterElementRow)))
@ -529,12 +529,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
Session.testInstance(netResult = 570.0)
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 }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE
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 }
filterElementRow2.filterSectionRow = FilterSectionRow.VALUE
filterLess.updateValueMap(FilterCondition(arrayListOf(filterElementRow2)))

@ -73,11 +73,17 @@ class Calculator {
allConditions.addAll(conditions)
allConditions.addAll(comparatorConditions)
val group = ComputableGroup(allConditions.name(), conditions)
val group = ComputableGroup(allConditions.name(), allConditions)
computableGroups.add(group)
}
return Calculator.computeGroups(realm, computableGroups, options)
if (computableGroups.size == 0) {
val group = ComputableGroup(conditions.name(), conditions)
computableGroups.add(group)
}
return this.computeGroups(realm, computableGroups, options)
}
fun computeStatsWithFilters(realm: Realm, filters: List<Filter>, options: Options): Report {

@ -18,68 +18,20 @@ fun List<QueryCondition>.name() : String {
* 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 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
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,
sealed class QueryCondition(var operator: Operator? = null) {
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 {
BETWEEN,
@ -87,6 +39,67 @@ enum class QueryCondition(var operator: Operator? = null) {
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
get() {
this.filterValuesExpectedKeys?.let { valueMapExceptedKeys ->
@ -112,13 +125,13 @@ enum class QueryCondition(var operator: Operator? = null) {
}
}
return when (this) {
BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES, TOURNAMENT_NAME -> arrayOf("ids")
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> arrayOf("values")
BLIND -> arrayOf("blinds", "hasDefaultCurrency")
STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> arrayOf("date")
DAY_OF_WEEK -> arrayOf("dayOfWeek")
MONTH -> arrayOf("month")
YEAR -> arrayOf("year")
is BANKROLL, is GAME, is LOCATION, is ANY_TOURNAMENT_FEATURES, is ALL_TOURNAMENT_FEATURES, is TOURNAMENT_NAME -> arrayOf("ids")
is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> arrayOf("values")
is BLIND -> arrayOf("blinds", "hasDefaultCurrency")
is STARTED_FROM_DATE, is STARTED_TO_DATE, is ENDED_FROM_DATE, is ENDED_TO_DATE -> arrayOf("date")
is DAY_OF_WEEK -> arrayOf("dayOfWeek")
is MONTH -> arrayOf("month")
is YEAR -> arrayOf("year")
else -> null
}
}
@ -150,18 +163,18 @@ enum class QueryCondition(var operator: Operator? = null) {
LIVE, ONLINE -> realmQuery.equalTo(fieldName, this == LIVE)
CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal)
TOURNAMENT -> realmQuery.equalTo(fieldName, Session.Type.TOURNAMENT.ordinal)
ALL_TOURNAMENT_FEATURES -> {
is ALL_TOURNAMENT_FEATURES -> {
val ids: Array<String> by valueMap
ids.forEach {
realmQuery.equalTo(fieldName, it)
}
realmQuery
}
ANY_TOURNAMENT_FEATURES -> {
is ANY_TOURNAMENT_FEATURES -> {
val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
BLIND -> {
is BLIND -> {
val blinds: Array<String> by valueMap
val hasDefaultCurrency: Array<Boolean> by valueMap
//realmQuery.`in`(fieldName, blinds)
@ -182,39 +195,39 @@ enum class QueryCondition(var operator: Operator? = null) {
}
realmQuery
}
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
is BANKROLL, is GAME, is LOCATION, is TOURNAMENT_NAME -> {
val ids: Array<String> by valueMap
realmQuery.`in`(fieldName, ids)
}
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> {
val values: Array<Int?>? by valueMap
realmQuery.`in`(fieldName, values)
}
STARTED_FROM_DATE -> {
is STARTED_FROM_DATE -> {
val date: Date by valueMap
realmQuery.greaterThanOrEqualTo(fieldName, date)
}
STARTED_TO_DATE -> {
is STARTED_TO_DATE -> {
val date: Date by valueMap
realmQuery.lessThanOrEqualTo(fieldName, date)
}
ENDED_FROM_DATE -> {
is ENDED_FROM_DATE -> {
val date: Date by valueMap
realmQuery.greaterThanOrEqualTo(fieldName, date)
}
ENDED_TO_DATE -> {
is ENDED_TO_DATE -> {
val date: Date by valueMap
realmQuery.lessThanOrEqualTo(fieldName, date)
}
DAY_OF_WEEK -> {
is DAY_OF_WEEK -> {
val dayOfWeek: Int by valueMap
realmQuery.equalTo(fieldName, dayOfWeek)
}
MONTH -> {
is MONTH -> {
val month: Int by valueMap
realmQuery.equalTo(fieldName, month)
}
YEAR -> {
is YEAR -> {
val year: Int by valueMap
realmQuery.equalTo(fieldName, year)
}
@ -280,27 +293,28 @@ enum class QueryCondition(var operator: Operator? = null) {
}
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)
}
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> {
is LIMIT, is TOURNAMENT_TYPE, is TABLE_SIZE -> {
valueMap = mapOf("values" to filterCondition.values)
}
BLIND -> {
is BLIND -> {
valueMap = mapOf(
"blinds" to filterCondition.blinds,
"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)
}
DAY_OF_WEEK -> {
is DAY_OF_WEEK -> {
valueMap = mapOf("dayOfWeek" to filterCondition.dayOfWeek)
}
MONTH -> {
is MONTH -> {
valueMap = mapOf("month" to filterCondition.month)
}
YEAR -> {
is YEAR -> {
valueMap = mapOf("year" to filterCondition.year)
}
else -> {

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

@ -15,7 +15,7 @@ open class FilterCondition() : RealmObject() {
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()
this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName

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

@ -4,20 +4,16 @@ import android.content.Context
import android.text.InputType
import net.pokeranalytics.android.R
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.realm.FilterCondition
import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetType
import net.pokeranalytics.android.ui.view.RowRepresentable
import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor
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.util.*
sealed class FilterElementRow : RowRepresentable {
interface Duration {
var minutes: Int
}
@ -27,6 +23,7 @@ sealed class FilterElementRow : RowRepresentable {
interface LessOperator : Operator
open class BoolFilterElementRow : 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 StringFilterElementRow(val stringValue: String = "") : FilterElementRow()
@ -40,11 +37,11 @@ sealed class FilterElementRow : RowRepresentable {
}
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()
}
}
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
val name: String = row.getDisplayName()
@ -139,50 +136,50 @@ sealed class FilterElementRow : RowRepresentable {
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() {
return when (this) {
is Cash -> QueryCondition.CASH
is Tournament -> QueryCondition.TOURNAMENT
is Blind -> QueryCondition.BLIND
is From -> QueryCondition.STARTED_FROM_DATE
is To -> QueryCondition.ENDED_TO_DATE
is FromTime -> QueryCondition.STARTED_FROM_TIME
is ToTime -> QueryCondition.ENDED_TO_TIME
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 -> QueryCondition.TODAY
is Yesterday -> QueryCondition.YESTERDAY
is TodayAndYesterday -> QueryCondition.TODAY_AND_YESTERDAY
is CurrentWeek -> QueryCondition.THIS_WEEK
is CurrentMonth -> QueryCondition.THIS_MONTH
is CurrentYear -> QueryCondition.THIS_YEAR
is PastDays -> QueryCondition.PAST_DAYS
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
is DurationMoreThan -> QueryCondition.MORE_THAN_DURATION
is DurationLessThan -> QueryCondition.LESS_THAN_DURATION
is Cash -> QueryCriteria.CASH
is Tournament -> QueryCriteria.TOURNAMENT
is Blind -> QueryCriteria.BLIND
is From -> QueryCriteria.STARTED_FROM_DATE
is To -> QueryCriteria.ENDED_TO_DATE
is FromTime -> QueryCriteria.STARTED_FROM_TIME
is ToTime -> QueryCriteria.ENDED_TO_TIME
is Month -> QueryCriteria.MONTH
is Day -> QueryCriteria.DAY_OF_WEEK
is Year -> QueryCriteria.YEAR
is Live -> QueryCriteria.LIVE
is Online -> QueryCriteria.ONLINE
is Weekday -> QueryCriteria.WEEK_DAY
is Weekend -> QueryCriteria.WEEK_END
is Today -> QueryCriteria.TODAY
is Yesterday -> QueryCriteria.YESTERDAY
is TodayAndYesterday -> QueryCriteria.TODAY_AND_YESTERDAY
is CurrentWeek -> QueryCriteria.THIS_WEEK
is CurrentMonth -> QueryCriteria.THIS_MONTH
is CurrentYear -> QueryCriteria.THIS_YEAR
is PastDays -> QueryCriteria.PAST_DAYS
is Limit -> QueryCriteria.LIMIT
is TableSize -> QueryCriteria.TABLE_SIZE
is Game -> QueryCriteria.GAME
is Bankroll -> QueryCriteria.BANKROLL
is Location -> QueryCriteria.LOCATION
is TournamentName -> QueryCriteria.TOURNAMENT_NAME
is AnyTournamentFeature -> QueryCriteria.ANY_TOURNAMENT_FEATURES
is AllTournamentFeature -> QueryCriteria.ALL_TOURNAMENT_FEATURES
is ResultMoreThan -> QueryCriteria.MORE_THAN_NET_RESULT
is ResultLessThan -> QueryCriteria.LESS_THAN_NET_RESULT
is DurationMoreThan -> QueryCriteria.MORE_THAN_DURATION
is DurationLessThan -> QueryCriteria.LESS_THAN_DURATION
//TODO: Check the conditions
is LastGames -> QueryCondition.LAST_GAMES
is LastSessions -> QueryCondition.LAST_SESSIONS
is ReBuyMoreThan -> QueryCondition.MIN_RE_BUY
is ReBuyLessThan -> QueryCondition.MAX_RE_BUY
is LastGames -> QueryCriteria.LAST_GAMES
is LastSessions -> QueryCriteria.LAST_SESSIONS
is ReBuyMoreThan -> QueryCriteria.MIN_RE_BUY
is ReBuyLessThan -> QueryCriteria.MAX_RE_BUY
else -> throw PokerAnalyticsException.UnknownQueryTypeForRow(this)
}
@ -194,7 +191,7 @@ sealed class FilterElementRow : RowRepresentable {
it.values.contains(this.intValue)
}
is DataFilterElementRow -> filterConditions.any {
it.ids.contains(this.id)
it.ids.contains(this.objectId)
}
else -> true
}
@ -327,4 +324,68 @@ sealed class FilterElementRow : RowRepresentable {
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