|
|
|
|
@ -3,43 +3,68 @@ package net.pokeranalytics.android.model.filter |
|
|
|
|
import io.realm.RealmObject |
|
|
|
|
import io.realm.RealmQuery |
|
|
|
|
import net.pokeranalytics.android.exceptions.FilterValueMapException |
|
|
|
|
import net.pokeranalytics.android.model.filter.interfaces.Filterable |
|
|
|
|
import net.pokeranalytics.android.model.realm.FilterComponent |
|
|
|
|
import net.pokeranalytics.android.model.realm.Session |
|
|
|
|
import java.util.* |
|
|
|
|
|
|
|
|
|
enum class FilterType(private var fieldName:String? = null, private var subType:SubType? = null): Filterable { |
|
|
|
|
/** |
|
|
|
|
* We want to be able to store filters in the database: |
|
|
|
|
* - filters can be a combination of sub filters |
|
|
|
|
* - filters can be applied to different type of objects: Sessions, Hands, Transactions... |
|
|
|
|
* - filters can be applied to a list of different type of objects (feed) |
|
|
|
|
* |
|
|
|
|
* A filter is described by the following: |
|
|
|
|
* - a data type: Session, Hands... |
|
|
|
|
* - a field: table size of a Session |
|
|
|
|
* - an operator: equal, >=, <... |
|
|
|
|
* - a value: an id, a number, a date... |
|
|
|
|
* |
|
|
|
|
* We can decide to have a collection of [operator, value] for a field |
|
|
|
|
* |
|
|
|
|
* Combination: |
|
|
|
|
* - multiple datatype filters should be handled as 'OR' |
|
|
|
|
* - multiple field filters should be handled as 'AND' |
|
|
|
|
* - multiple '=' filters as 'OR' |
|
|
|
|
* - multiple 'Greater than', 'less than' as 'AND' |
|
|
|
|
* - multiple values as 'OR' |
|
|
|
|
* |
|
|
|
|
* Also: |
|
|
|
|
* A filter should be able to be converted into a Realm query |
|
|
|
|
* |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
enum class FilterType(private var subType:SubType? = null) { |
|
|
|
|
LIVE, |
|
|
|
|
CASH, |
|
|
|
|
ONLINE, |
|
|
|
|
TOURNAMENT, |
|
|
|
|
BANKROLL("bankroll.id"), |
|
|
|
|
GAME("game.id"), |
|
|
|
|
TOURNAMENT_NAME("tournamentName.id"), |
|
|
|
|
BANKROLL, |
|
|
|
|
GAME, |
|
|
|
|
TOURNAMENT_NAME, |
|
|
|
|
ANY_TOURNAMENT_FEATURES, |
|
|
|
|
ALL_TOURNAMENT_FEATURES, |
|
|
|
|
LOCATION("location.id"), |
|
|
|
|
LIMIT("limit"), |
|
|
|
|
TABLE_SIZE("tableSize"), |
|
|
|
|
TOURNAMENT_TYPE("tournamentType"), |
|
|
|
|
LOCATION, |
|
|
|
|
LIMIT, |
|
|
|
|
TABLE_SIZE, |
|
|
|
|
TOURNAMENT_TYPE, |
|
|
|
|
BLINDS, |
|
|
|
|
MORE_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.MORE), |
|
|
|
|
LESS_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.LESS), |
|
|
|
|
BETWEEN_NUMBER_OF_TABLE(Field.NUMBER_OF_TABLE.fieldName, SubType.BETWEEN), |
|
|
|
|
MORE_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.MORE), |
|
|
|
|
LESS_THAN_NET_RESULT(Field.NET_RESULT.fieldName, SubType.LESS), |
|
|
|
|
MORE_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.MORE), |
|
|
|
|
LESS_THAN_BUY_IN(Field.BUY_IN.fieldName, SubType.LESS), |
|
|
|
|
MORE_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.MORE), |
|
|
|
|
LESS_THAN_CASH_OUT(Field.CASH_OUT.fieldName, SubType.LESS), |
|
|
|
|
MORE_THAN_TIPS(Field.TIPS.fieldName, SubType.MORE), |
|
|
|
|
LESS_THAN_TIPS(Field.TIPS.fieldName, SubType.LESS), |
|
|
|
|
MORE_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.MORE), |
|
|
|
|
LESS_THAN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.LESS), |
|
|
|
|
BETWEEN_NUMBER_OF_PLAYER(Field.NUMBER_OF_PLAYER.fieldName, SubType.BETWEEN), |
|
|
|
|
MORE_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.MORE), |
|
|
|
|
LESS_THAN_TOURNAMENT_FEE(Field.NET_RESULT.fieldName, SubType.LESS), |
|
|
|
|
BETWEEN_TOURNAMENT_FEE(Field.TOURNAMENT_FEE.fieldName, SubType.BETWEEN), |
|
|
|
|
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), |
|
|
|
|
|
|
|
|
|
// Dates |
|
|
|
|
STARTED_FROM_DATE, |
|
|
|
|
@ -52,42 +77,21 @@ enum class FilterType(private var fieldName:String? = null, private var subType: |
|
|
|
|
WEEK_DAY, |
|
|
|
|
WEEK_END, |
|
|
|
|
|
|
|
|
|
CURRENCY, |
|
|
|
|
CURRENCY_CODE, |
|
|
|
|
BIG_BLIND, |
|
|
|
|
SMALL_BLIND, |
|
|
|
|
COMMENT, |
|
|
|
|
|
|
|
|
|
; |
|
|
|
|
|
|
|
|
|
enum class SubType { |
|
|
|
|
private enum class SubType { |
|
|
|
|
BETWEEN, |
|
|
|
|
MORE, |
|
|
|
|
LESS; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
private enum class Field(var fieldName:String) { |
|
|
|
|
LIVE("bankroll.live"), |
|
|
|
|
CASH("type"), |
|
|
|
|
CURRENCY("bankroll.currency"), |
|
|
|
|
CURRENCY_CODE("bankroll.currency.code"), |
|
|
|
|
BIG_BLIND("cgBigBlind"), |
|
|
|
|
SMALL_BLIND("cgSmallBlind"), |
|
|
|
|
COMMENT("comment"), |
|
|
|
|
TOURNAMENT_FEATURES("tournamentFeatures.id"), |
|
|
|
|
NET_RESULT("computableResults.ratedNet"), |
|
|
|
|
BUY_IN("result.buyin"), |
|
|
|
|
CASH_OUT("result.cashout"), |
|
|
|
|
TIPS("result.tips"), |
|
|
|
|
NUMBER_OF_TABLE("numberOfTable"), |
|
|
|
|
NUMBER_OF_PLAYER("tournamentNumberOfPlayers"), |
|
|
|
|
TOURNAMENT_FEE("tournamentEntryFee"), |
|
|
|
|
START_DATE("startDate"), |
|
|
|
|
END_DATE("endDate"), |
|
|
|
|
DAY("dayOfWeek"), |
|
|
|
|
MONTH("month"), |
|
|
|
|
YEAR("year"), |
|
|
|
|
|
|
|
|
|
; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
override var valueMap : Map<String, Any?>? = null |
|
|
|
|
|
|
|
|
|
override val filterValuesExpectedKeys : Array<String>? |
|
|
|
|
private val filterValuesExpectedKeys : Array<String>? |
|
|
|
|
get() { |
|
|
|
|
this.subType?.let { |
|
|
|
|
return when (it) { |
|
|
|
|
@ -107,66 +111,17 @@ enum class FilterType(private var fieldName:String? = null, private var subType: |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
override fun filter(realmQuery: RealmQuery<out RealmObject>): RealmQuery<out RealmObject> { |
|
|
|
|
fun filter(realmQuery: RealmQuery<out RealmObject>, filterEntityDataSource: FilterEntityDataSource): RealmQuery<out RealmObject> { |
|
|
|
|
when { |
|
|
|
|
this == BLINDS -> { |
|
|
|
|
val smallBlindFieldName = filterEntityDataSource.fieldNameForQueryType(SMALL_BLIND) |
|
|
|
|
val bigBlindFieldName = filterEntityDataSource.fieldNameForQueryType(BIG_BLIND) |
|
|
|
|
val currencyCodeFieldName = filterEntityDataSource.fieldNameForQueryType(CURRENCY_CODE) |
|
|
|
|
smallBlindFieldName ?: throw FilterValueMapException("fieldName is missing") |
|
|
|
|
bigBlindFieldName ?: throw FilterValueMapException("fieldName is missing") |
|
|
|
|
currencyCodeFieldName ?: throw FilterValueMapException("fieldName is missing") |
|
|
|
|
|
|
|
|
|
this.subType?.let {subType -> |
|
|
|
|
this.fieldName?.let { |
|
|
|
|
return when (subType) { |
|
|
|
|
SubType.LESS -> { |
|
|
|
|
val value: Double by filterValues |
|
|
|
|
println("filter test less") |
|
|
|
|
realmQuery.lessThanOrEqualTo(it, value) |
|
|
|
|
} |
|
|
|
|
SubType.MORE -> { |
|
|
|
|
println("filter test more") |
|
|
|
|
val value: Double by filterValues |
|
|
|
|
realmQuery.greaterThanOrEqualTo(it, value) |
|
|
|
|
} |
|
|
|
|
SubType.BETWEEN -> { |
|
|
|
|
val leftValue: Double by filterValues |
|
|
|
|
val rightValue: Double by filterValues |
|
|
|
|
realmQuery.between(it, leftValue, rightValue) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} ?: run { |
|
|
|
|
throw FilterValueMapException("fieldName is missing") |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return when (this) { |
|
|
|
|
LIVE -> realmQuery.equalTo(Field.LIVE.fieldName, true) |
|
|
|
|
CASH -> realmQuery.equalTo(Field.CASH.fieldName, Session.Type.CASH_GAME.ordinal) |
|
|
|
|
ONLINE -> LIVE.filter(realmQuery.not()) |
|
|
|
|
TOURNAMENT -> CASH.filter(realmQuery.not()) |
|
|
|
|
ALL_TOURNAMENT_FEATURES -> { |
|
|
|
|
val ids : Array<String> by filterValues |
|
|
|
|
ids.forEach { |
|
|
|
|
realmQuery.equalTo(Field.TOURNAMENT_FEATURES.fieldName, it) |
|
|
|
|
} |
|
|
|
|
realmQuery |
|
|
|
|
} |
|
|
|
|
ANY_TOURNAMENT_FEATURES -> { |
|
|
|
|
val ids : Array<String> by filterValues |
|
|
|
|
realmQuery.`in`(Field.TOURNAMENT_FEATURES.fieldName, ids) |
|
|
|
|
} |
|
|
|
|
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { |
|
|
|
|
val ids : Array<String> by filterValues |
|
|
|
|
this.fieldName?.let { |
|
|
|
|
realmQuery.`in`(it, ids) |
|
|
|
|
} ?: run { |
|
|
|
|
throw FilterValueMapException("fieldName is missing") |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { |
|
|
|
|
val values : Array<Int?>? by filterValues |
|
|
|
|
this.fieldName?.let { |
|
|
|
|
realmQuery.`in`(it, values) |
|
|
|
|
} ?: run { |
|
|
|
|
throw FilterValueMapException("fieldName is missing") |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
BLINDS -> { |
|
|
|
|
val blinds : Array<Map<String,Any?>> by filterValues |
|
|
|
|
val blinds: Array<Map<String, Any?>> by valueMap |
|
|
|
|
val expectedSubKeys = arrayOf("sb", "bb", "code") |
|
|
|
|
blinds.forEachIndexed { index, subMap -> |
|
|
|
|
val missingKeys = subMap.keys.filter { !expectedSubKeys.contains(it) } |
|
|
|
|
@ -174,27 +129,27 @@ enum class FilterType(private var fieldName:String? = null, private var subType: |
|
|
|
|
throw FilterValueMapException("subValueMap does not contain $missingKeys") |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
val sb : Double? by subMap |
|
|
|
|
val bb : Double? by subMap |
|
|
|
|
val code : String? by subMap |
|
|
|
|
val sb: Double? by subMap |
|
|
|
|
val bb: Double? by subMap |
|
|
|
|
val code: String? by subMap |
|
|
|
|
|
|
|
|
|
realmQuery |
|
|
|
|
.beginGroup() |
|
|
|
|
|
|
|
|
|
sb?.let { |
|
|
|
|
realmQuery |
|
|
|
|
.equalTo(Field.SMALL_BLIND.fieldName, sb) |
|
|
|
|
.equalTo(smallBlindFieldName, sb) |
|
|
|
|
.and() |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
realmQuery |
|
|
|
|
.equalTo(Field.BIG_BLIND.fieldName, bb) |
|
|
|
|
.equalTo(bigBlindFieldName, bb) |
|
|
|
|
.and() |
|
|
|
|
|
|
|
|
|
code?.let { |
|
|
|
|
realmQuery.equalTo(Field.CURRENCY_CODE.fieldName, code) |
|
|
|
|
realmQuery.equalTo(currencyCodeFieldName, code) |
|
|
|
|
} ?: run { |
|
|
|
|
realmQuery.isNull(Field.CURRENCY_CODE.fieldName) |
|
|
|
|
realmQuery.isNull(currencyCodeFieldName) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
realmQuery.endGroup() |
|
|
|
|
@ -203,94 +158,155 @@ enum class FilterType(private var fieldName:String? = null, private var subType: |
|
|
|
|
realmQuery.or() |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
realmQuery |
|
|
|
|
} |
|
|
|
|
STARTED_FROM_DATE -> { |
|
|
|
|
val date : Date by filterValues |
|
|
|
|
realmQuery.greaterThanOrEqualTo(Field.START_DATE.fieldName, date) |
|
|
|
|
} |
|
|
|
|
STARTED_TO_DATE -> { |
|
|
|
|
val date : Date by filterValues |
|
|
|
|
realmQuery.lessThanOrEqualTo(Field.START_DATE.fieldName, date) |
|
|
|
|
} |
|
|
|
|
ENDED_FROM_DATE -> { |
|
|
|
|
val date : Date by filterValues |
|
|
|
|
realmQuery.greaterThanOrEqualTo(Field.END_DATE.fieldName, date) |
|
|
|
|
} |
|
|
|
|
ENDED_TO_DATE -> { |
|
|
|
|
val date : Date by filterValues |
|
|
|
|
realmQuery.lessThanOrEqualTo(Field.END_DATE.fieldName, date) |
|
|
|
|
} |
|
|
|
|
DAY_OF_WEEK -> { |
|
|
|
|
val dayOfWeek : Int by filterValues |
|
|
|
|
realmQuery.equalTo(Field.DAY.fieldName, dayOfWeek) |
|
|
|
|
} |
|
|
|
|
MONTH -> { |
|
|
|
|
val month: Int by filterValues |
|
|
|
|
realmQuery.equalTo(Field.MONTH.fieldName, month) |
|
|
|
|
} |
|
|
|
|
YEAR -> { |
|
|
|
|
val year: Int by filterValues |
|
|
|
|
realmQuery.equalTo(Field.YEAR.fieldName, year) |
|
|
|
|
return realmQuery |
|
|
|
|
} |
|
|
|
|
WEEK_END -> { |
|
|
|
|
realmQuery.`in`(Field.DAY.fieldName, arrayOf(Calendar.SATURDAY,Calendar.SUNDAY)) |
|
|
|
|
} |
|
|
|
|
WEEK_DAY -> WEEK_END.filter(realmQuery.not()) |
|
|
|
|
this == ONLINE -> return LIVE.filter(realmQuery.not(), filterEntityDataSource) |
|
|
|
|
this == TOURNAMENT -> return CASH.filter(realmQuery.not(), filterEntityDataSource) |
|
|
|
|
this == WEEK_DAY -> return WEEK_END.filter(realmQuery.not(), filterEntityDataSource) |
|
|
|
|
else -> { |
|
|
|
|
throw FilterValueMapException("filter type not handled") |
|
|
|
|
val fieldName = filterEntityDataSource.fieldNameForQueryType(this) |
|
|
|
|
fieldName ?: throw FilterValueMapException("fieldName is missing") |
|
|
|
|
|
|
|
|
|
this.subType?.let { subType -> |
|
|
|
|
return when (subType) { |
|
|
|
|
SubType.LESS -> { |
|
|
|
|
val value: Double by valueMap |
|
|
|
|
realmQuery.lessThanOrEqualTo(fieldName, value) |
|
|
|
|
} |
|
|
|
|
SubType.MORE -> { |
|
|
|
|
val value: Double by valueMap |
|
|
|
|
realmQuery.greaterThanOrEqualTo(fieldName, value) |
|
|
|
|
} |
|
|
|
|
SubType.BETWEEN -> { |
|
|
|
|
val leftValue: Double by valueMap |
|
|
|
|
val rightValue: Double by valueMap |
|
|
|
|
realmQuery.between(fieldName, leftValue, rightValue) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return when (this) { |
|
|
|
|
LIVE -> realmQuery.equalTo(fieldName, true) |
|
|
|
|
CASH -> realmQuery.equalTo(fieldName, Session.Type.CASH_GAME.ordinal) |
|
|
|
|
ALL_TOURNAMENT_FEATURES -> { |
|
|
|
|
val ids: Array<String> by valueMap |
|
|
|
|
ids.forEach { |
|
|
|
|
realmQuery.equalTo(fieldName, it) |
|
|
|
|
} |
|
|
|
|
realmQuery |
|
|
|
|
} |
|
|
|
|
ANY_TOURNAMENT_FEATURES -> { |
|
|
|
|
val ids: Array<String> by valueMap |
|
|
|
|
realmQuery.`in`(fieldName, ids) |
|
|
|
|
} |
|
|
|
|
BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { |
|
|
|
|
val ids: Array<String> by valueMap |
|
|
|
|
realmQuery.`in`(fieldName, ids) |
|
|
|
|
} |
|
|
|
|
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { |
|
|
|
|
val values: Array<Int?>? by valueMap |
|
|
|
|
realmQuery.`in`(fieldName, values) |
|
|
|
|
} |
|
|
|
|
STARTED_FROM_DATE -> { |
|
|
|
|
val date: Date by valueMap |
|
|
|
|
realmQuery.greaterThanOrEqualTo(fieldName, date) |
|
|
|
|
} |
|
|
|
|
STARTED_TO_DATE -> { |
|
|
|
|
val date: Date by valueMap |
|
|
|
|
realmQuery.lessThanOrEqualTo(fieldName, date) |
|
|
|
|
} |
|
|
|
|
ENDED_FROM_DATE -> { |
|
|
|
|
val date: Date by valueMap |
|
|
|
|
realmQuery.greaterThanOrEqualTo(fieldName, date) |
|
|
|
|
} |
|
|
|
|
ENDED_TO_DATE -> { |
|
|
|
|
val date: Date by valueMap |
|
|
|
|
realmQuery.lessThanOrEqualTo(fieldName, date) |
|
|
|
|
} |
|
|
|
|
DAY_OF_WEEK -> { |
|
|
|
|
val dayOfWeek: Int by valueMap |
|
|
|
|
realmQuery.equalTo(fieldName, dayOfWeek) |
|
|
|
|
} |
|
|
|
|
MONTH -> { |
|
|
|
|
val month: Int by valueMap |
|
|
|
|
realmQuery.equalTo(fieldName, month) |
|
|
|
|
} |
|
|
|
|
YEAR -> { |
|
|
|
|
val year: Int by valueMap |
|
|
|
|
realmQuery.equalTo(fieldName, year) |
|
|
|
|
} |
|
|
|
|
WEEK_END -> { |
|
|
|
|
realmQuery.`in`(fieldName, arrayOf(Calendar.SATURDAY, Calendar.SUNDAY)) |
|
|
|
|
} |
|
|
|
|
else -> { |
|
|
|
|
throw FilterValueMapException("filter type not handled") |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
override fun setValueFrom(filterComponent: FilterComponent) { |
|
|
|
|
fun setValueFrom(filterComponent: FilterComponent) { |
|
|
|
|
if (filterValuesExpectedKeys == null) { |
|
|
|
|
return |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
this.subType?.let { subType -> |
|
|
|
|
this.fieldName?.let { |
|
|
|
|
return when (subType) { |
|
|
|
|
SubType.LESS, SubType.MORE -> { |
|
|
|
|
filterValues = mapOf("value" to filterComponent.value) |
|
|
|
|
} |
|
|
|
|
SubType.BETWEEN -> { |
|
|
|
|
filterValues = mapOf( |
|
|
|
|
"leftValue" to filterComponent.leftValue, |
|
|
|
|
"rightValue" to filterComponent.rightValue |
|
|
|
|
) |
|
|
|
|
} |
|
|
|
|
valueMap = when (subType) { |
|
|
|
|
SubType.LESS, SubType.MORE -> { |
|
|
|
|
mapOf("value" to filterComponent.value) |
|
|
|
|
} |
|
|
|
|
SubType.BETWEEN -> { |
|
|
|
|
mapOf( |
|
|
|
|
"leftValue" to filterComponent.leftValue, |
|
|
|
|
"rightValue" to filterComponent.rightValue |
|
|
|
|
) |
|
|
|
|
} |
|
|
|
|
} ?: run { |
|
|
|
|
throw FilterValueMapException("fieldName is missing") |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
when (this) { |
|
|
|
|
ALL_TOURNAMENT_FEATURES, ANY_TOURNAMENT_FEATURES, BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> { |
|
|
|
|
filterValues = mapOf("ids" to filterComponent.ids) |
|
|
|
|
valueMap = mapOf("ids" to filterComponent.ids) |
|
|
|
|
} |
|
|
|
|
LIMIT, TOURNAMENT_TYPE, TABLE_SIZE -> { |
|
|
|
|
filterValues = mapOf("values" to filterComponent.values) |
|
|
|
|
valueMap = mapOf("values" to filterComponent.values) |
|
|
|
|
} |
|
|
|
|
BLINDS -> { |
|
|
|
|
filterValues = mapOf("blinds" to filterComponent.blinds) |
|
|
|
|
valueMap = mapOf("blinds" to filterComponent.blinds) |
|
|
|
|
} |
|
|
|
|
STARTED_FROM_DATE, STARTED_TO_DATE, ENDED_FROM_DATE, ENDED_TO_DATE -> { |
|
|
|
|
filterValues = mapOf("date" to filterComponent.date) |
|
|
|
|
valueMap = mapOf("date" to filterComponent.date) |
|
|
|
|
} |
|
|
|
|
DAY_OF_WEEK -> { |
|
|
|
|
filterValues = mapOf("dayOfWeek" to filterComponent.dayOfWeek) |
|
|
|
|
valueMap = mapOf("dayOfWeek" to filterComponent.dayOfWeek) |
|
|
|
|
} |
|
|
|
|
MONTH -> { |
|
|
|
|
filterValues = mapOf("month" to filterComponent.month) |
|
|
|
|
valueMap = mapOf("month" to filterComponent.month) |
|
|
|
|
} |
|
|
|
|
YEAR -> { |
|
|
|
|
filterValues = mapOf("year" to filterComponent.year) |
|
|
|
|
valueMap = mapOf("year" to filterComponent.year) |
|
|
|
|
} |
|
|
|
|
else -> { |
|
|
|
|
throw FilterValueMapException("filter type not handled") |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
var valueMap : Map<String, Any?>? = null |
|
|
|
|
get() { |
|
|
|
|
this.filterValuesExpectedKeys?.let { valueMapExceptedKeys -> |
|
|
|
|
field?.let { map -> |
|
|
|
|
val missingKeys = map.keys.filter { !valueMapExceptedKeys.contains(it) } |
|
|
|
|
if (map.keys.size == valueMapExceptedKeys.size && missingKeys.isNotEmpty()) { |
|
|
|
|
throw FilterValueMapException("valueMap does not contain $missingKeys") |
|
|
|
|
} |
|
|
|
|
} ?: run { |
|
|
|
|
throw FilterValueMapException("valueMap null not expected") |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return field |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
} |
Razmig Sarkissian
7 years ago