add the custom field filtering management

dev
Razmig Sarkissian 7 years ago
parent e2e8ea7903
commit 7454eca00b
  1. 12
      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/RealmFilterInstrumentedUnitTest.kt
  4. 50
      app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt
  5. 34
      app/src/main/java/net/pokeranalytics/android/model/Criteria.kt
  6. 20
      app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt
  7. 6
      app/src/main/java/net/pokeranalytics/android/model/realm/CustomField.kt
  8. 8
      app/src/main/java/net/pokeranalytics/android/model/realm/CustomFieldEntry.kt
  9. 10
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  10. 2
      app/src/main/java/net/pokeranalytics/android/ui/fragment/BankrollFragment.kt
  11. 76
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt
  12. 164
      app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt

@ -47,7 +47,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
listOfValues = arrayListOf(s1.blinds!!)
}
blind.filterSectionRow = FilterSectionRow.BLIND
blind.filterSectionRow = FilterSectionRow.Blind
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueBy(filterElement)
@ -97,8 +97,8 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
listOfValues = arrayListOf(s2.blinds!!)
}
blind1.filterSectionRow = FilterSectionRow.BLIND
blind2.filterSectionRow = FilterSectionRow.BLIND
blind1.filterSectionRow = FilterSectionRow.Blind
blind2.filterSectionRow = FilterSectionRow.Blind
val filterElements = FilterCondition(filterElementRows = arrayListOf(blind1, blind2))
filter.updateValueBy(filterElements)
@ -146,7 +146,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
listOfValues = arrayListOf(s3.blinds!!)
}
blind.filterSectionRow = FilterSectionRow.BLIND
blind.filterSectionRow = FilterSectionRow.Blind
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
filter.updateValueBy(filterElement)
@ -197,8 +197,8 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
listOfValues = arrayListOf(s2.blinds!!)
}
blind1.filterSectionRow = FilterSectionRow.BLIND
blind2.filterSectionRow = FilterSectionRow.BLIND
blind1.filterSectionRow = FilterSectionRow.Blind
blind2.filterSectionRow = FilterSectionRow.Blind
val filterElement = FilterCondition(filterElementRows = arrayListOf(blind1, blind2))
filter.updateValueBy(filterElement)

@ -35,7 +35,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = s1.startDate
val filterElementRow = QueryCondition.AnyDayOfWeek().apply { listOfValues = arrayListOf(cal.get(Calendar.DAY_OF_WEEK)) }
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
filterElementRow.filterSectionRow = FilterSectionRow.DynamicDate
val filterElement = FilterCondition(arrayListOf(filterElementRow))
filter.updateValueBy(filterElement)
@ -64,7 +64,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = s1.startDate
val filterElementRow = QueryCondition.AnyMonthOfYear().apply { listOfValues = arrayListOf(cal.get(Calendar.MONTH)) }
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
filterElementRow.filterSectionRow = FilterSectionRow.DynamicDate
val filterElement = FilterCondition(arrayListOf(filterElementRow))
filter.updateValueBy(filterElement)
@ -92,7 +92,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyYear()
cal.time = s1.startDate
val filterElementRow = QueryCondition.AnyYear().apply { listOfValues = arrayListOf(cal.get(Calendar.YEAR)) }
filterElementRow.filterSectionRow = FilterSectionRow.DYNAMIC_DATE
filterElementRow.filterSectionRow = FilterSectionRow.DynamicDate
val filterElement = FilterCondition(arrayListOf(filterElementRow))
filter.updateValueBy(filterElement)
@ -386,7 +386,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.StartedFromDate()
val filterElementRow = QueryCondition.StartedFromDate().apply { singleValue = s2.startDate!!}
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -414,7 +414,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.StartedToDate()
val filterElementRow = QueryCondition.StartedToDate().apply { singleValue = s1.startDate!! }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -443,7 +443,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.EndedFromDate()
val filterElementRow = QueryCondition.EndedFromDate().apply { singleValue = s2.endDate() }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -472,7 +472,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.EndedToDate()
val filterElementRow = QueryCondition.EndedToDate().apply { singleValue = s1.endDate() }
filterElementRow.filterSectionRow = FilterSectionRow.FIXED_DATE
filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))

@ -24,7 +24,7 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
filter.name = "testSaveLoadCashFilter"
val filterElement = QueryCondition.IsCash
filterElement.filterSectionRow = FilterSectionRow.CASH_TOURNAMENT
filterElement.filterSectionRow = FilterSectionRow.CashOrTournament
filter.createOrUpdateFilterConditions(arrayListOf(filterElement))
val useCount = filter.countBy(FilterCategoryRow.GENERAL)

@ -110,7 +110,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyBankroll()
val filterElementRow = QueryCondition.AnyBankroll().apply { setObject(b1) }
filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
filterElementRow.filterSectionRow = FilterSectionRow.Bankroll
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -141,10 +141,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyBankroll()
val filterElementRow = QueryCondition.AnyBankroll().apply { setObject(b1) }
filterElementRow.filterSectionRow = FilterSectionRow.BANKROLL
filterElementRow.filterSectionRow = FilterSectionRow.Bankroll
val filterElementRow2 = QueryCondition.AnyBankroll().apply { setObject(b2) }
filterElementRow2.filterSectionRow = FilterSectionRow.BANKROLL
filterElementRow2.filterSectionRow = FilterSectionRow.Bankroll
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -197,9 +197,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
val filterElementRow = QueryCondition.AnyGame().apply { setObject(g2) }
filterElementRow.filterSectionRow = FilterSectionRow.GAME
filterElementRow.filterSectionRow = FilterSectionRow.Game
val filterElementRow2 = QueryCondition.AnyGame().apply { setObject(g3) }
filterElementRow2.filterSectionRow = FilterSectionRow.GAME
filterElementRow2.filterSectionRow = FilterSectionRow.Game
val filterCondition = FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))
val queryCondition = filterCondition.queryCondition
val sessions = Filter.queryOn<Session>(realm, Query(queryCondition))
@ -225,7 +225,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyLocation()
val filterElementRow = QueryCondition.AnyLocation().apply { setObject(l1) }
filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
filterElementRow.filterSectionRow = FilterSectionRow.Location
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -257,9 +257,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyLocation()
val filterElementRow = QueryCondition.AnyLocation().apply { setObject(l1) }
filterElementRow.filterSectionRow = FilterSectionRow.LOCATION
filterElementRow.filterSectionRow = FilterSectionRow.Location
val filterElementRow2 = QueryCondition.AnyLocation().apply { setObject(l3) }
filterElementRow2.filterSectionRow = FilterSectionRow.LOCATION
filterElementRow2.filterSectionRow = FilterSectionRow.Location
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
@ -287,7 +287,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyTournamentName()
val filterElementRow = QueryCondition.AnyTournamentName().apply { setObject(t1) }
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
filterElementRow.filterSectionRow = FilterSectionRow.TournamentName
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -318,9 +318,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyTournamentName()
val filterElementRow = QueryCondition.AnyTournamentName().apply { setObject(t1) }
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
filterElementRow.filterSectionRow = FilterSectionRow.TournamentName
val filterElementRow2 = QueryCondition.AnyTournamentName().apply { setObject(t2) }
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_NAME
filterElementRow.filterSectionRow = FilterSectionRow.TournamentName
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -354,11 +354,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AllTournamentFeature()
val filterElementRow = QueryCondition.AllTournamentFeature().apply { setObject(t1) }
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow.filterSectionRow = FilterSectionRow.TournamentFeature
val filterElementRow2 = QueryCondition.AllTournamentFeature().apply { setObject(t2) }
filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow2.filterSectionRow = FilterSectionRow.TournamentFeature
val filterElementRow3 = QueryCondition.AllTournamentFeature().apply { setObject(t4) }
filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow3.filterSectionRow = FilterSectionRow.TournamentFeature
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -389,13 +389,13 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyTournamentFeature()
val filterElementRow = QueryCondition.AnyTournamentFeature().apply { setObject(t1) }
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow.filterSectionRow = FilterSectionRow.TournamentFeature
val filterElementRow2 = QueryCondition.AnyTournamentFeature().apply { setObject(t2) }
filterElementRow2.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow2.filterSectionRow = FilterSectionRow.TournamentFeature
val filterElementRow3 = QueryCondition.AnyTournamentFeature().apply { setObject(t3) }
filterElementRow3.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow3.filterSectionRow = FilterSectionRow.TournamentFeature
val filterElementRow4 = QueryCondition.AnyTournamentFeature().apply { setObject(t4) }
filterElementRow4.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow4.filterSectionRow = FilterSectionRow.TournamentFeature
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -423,7 +423,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyTournamentFeature()
val filterElementRow = QueryCondition.AnyTournamentFeature().apply { setObject(t2) }
filterElementRow.filterSectionRow = FilterSectionRow.TOURNAMENT_FEATURE
filterElementRow.filterSectionRow = FilterSectionRow.TournamentFeature
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -448,9 +448,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.AnyTableSize()
val filterElementRow = QueryCondition.AnyTableSize().apply { listOfValues = arrayListOf(2) }
filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
filterElementRow.filterSectionRow = FilterSectionRow.TableSize
val filterElementRow2 = QueryCondition.AnyTableSize().apply { listOfValues = arrayListOf(4) }
filterElementRow.filterSectionRow = FilterSectionRow.TABLE_SIZE
filterElementRow.filterSectionRow = FilterSectionRow.TableSize
filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -475,7 +475,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.NetAmountWon()
val filterElementRow = QueryCondition.more<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(204.0) }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filterElementRow.filterSectionRow = FilterSectionRow.Value
filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filterElementRow))
@ -500,7 +500,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filter = QueryCondition.NetAmountWon()
val filterElementRow = QueryCondition.less<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(540.0) }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filterElementRow.filterSectionRow = FilterSectionRow.Value
filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
val sessions = Filter.queryOn<Session>(realm, Query(filter))
@ -525,12 +525,12 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val filterMore = QueryCondition.NetAmountWon()
val filterElementRow = QueryCondition.more<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(200.0) }
filterElementRow.filterSectionRow = FilterSectionRow.VALUE
filterElementRow.filterSectionRow = FilterSectionRow.Value
filterMore.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
val filterLess = QueryCondition.NetAmountWon()
val filterElementRow2 = QueryCondition.less<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(400.0) }
filterElementRow2.filterSectionRow = FilterSectionRow.VALUE
filterElementRow2.filterSectionRow = FilterSectionRow.Value
filterLess.updateValueBy(FilterCondition(arrayListOf(filterElementRow2)))
val sessions = Filter.queryOn<Session>(realm, Query(filterMore, filterLess))

@ -16,6 +16,7 @@ import net.pokeranalytics.android.model.Criteria.TournamentFees.comparison
import net.pokeranalytics.android.model.Criteria.TournamentNames.comparison
import net.pokeranalytics.android.model.Criteria.TournamentTypes.comparison
import net.pokeranalytics.android.model.Criteria.TransactionTypes.comparison
import net.pokeranalytics.android.model.filter.FilterHelper
import net.pokeranalytics.android.model.filter.Query
import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.interfaces.NameManageable
@ -60,6 +61,16 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
abstract class RealmCriteria(uniqueIdentifier: Int) : Criteria(uniqueIdentifier) {
inline fun <reified T : NameManageable> comparison(): List<Query> {
if (this is ListCustomFields) {
val objects = mutableListOf<QueryCondition.CustomFieldListQuery>()
val realm = Realm.getDefaultInstance()
realm.where<CustomFieldEntry>().equalTo("customField.id", this.customField.id).findAll().forEach {
objects.add(QueryCondition.CustomFieldListQuery(it))
}
objects.sorted()
realm.close()
return objects.map { Query(it) }
}
return compare<QueryCondition.QueryDataCondition<NameManageable>, T>()
}
}
@ -72,6 +83,24 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
abstract class ListCriteria(uniqueIdentifier: Int) : Criteria(uniqueIdentifier) {
inline fun <reified T : QueryCondition.ListOfValues<S>, reified S : Comparable<S>> comparison(): List<Query> {
if (this is ValueCustomFields) {
val realm = Realm.getDefaultInstance()
val distincts = realm.where<CustomFieldEntry>().equalTo("customField.id", this.customField.id).distinct("value").findAll().sort("value", Sort.ASCENDING)
realm.close()
val objects = mutableListOf<QueryCondition.CustomFieldNumberQuery>()
distincts.distinct().forEach {
val condition: QueryCondition.CustomFieldNumberQuery = QueryCondition.CustomFieldNumberQuery().apply {
this.customFieldId = this@ListCriteria.customField.id
listOfValues = arrayListOf(it.value.toDouble())
}
objects.add(condition)
objects.sorted()
return objects.map { Query(it) }
}
}
QueryCondition.distinct<Session, T, S>()?.let {
val values = it.mapNotNull { session ->
when (this) {
@ -126,6 +155,8 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
object TournamentFees : ListCriteria(18)
object Cash : SimpleCriteria(listOf(QueryCondition.IsCash), 19)
object Tournament : SimpleCriteria(listOf(QueryCondition.IsTournament), 20)
data class ListCustomFields(var customField: CustomField) : RealmCriteria(21)
data class ValueCustomFields(var customField: CustomField) : ListCriteria(22)
val queries: List<Query>
get() {
@ -199,6 +230,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
years
}
is Blinds -> comparison<QueryCondition.AnyBlind, String>()
is ListCustomFields -> comparison<CustomFieldEntry>()
else -> throw PokerAnalyticsException.QueryTypeUnhandled
}
}
@ -223,6 +255,8 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
AllMonthsUpToNow -> R.string.month
Blinds -> R.string.blind
TournamentFees -> R.string.entry_fees
is ListCustomFields -> this.customField.resId
is ValueCustomFields -> this.customField.resId
else -> null
}
}

@ -223,7 +223,7 @@ sealed class QueryCondition : FilterElementRow {
return baseId
}
override var filterSectionRow: FilterSectionRow = FilterSectionRow.CASH_TOURNAMENT
override var filterSectionRow: FilterSectionRow = FilterSectionRow.CashOrTournament
abstract class QueryDataCondition < T: NameManageable > : ListOfString() {
fun setObject(dataObject: T) {
@ -389,6 +389,7 @@ sealed class QueryCondition : FilterElementRow {
val prefix = this.resId?.let {
context.getString(it) + " "
} ?: ""
//TODO add a int helper to display 1st, 2nd, 3rd, 4th, etc.
return prefix + value.toString()
}
}
@ -492,6 +493,23 @@ sealed class QueryCondition : FilterElementRow {
}
}
interface CustomFieldQuery {
var customFieldId : String?
}
class CustomFieldNumberQuery : ListOfDouble(), CustomFieldQuery {
override var customFieldId : String? = null
}
class CustomFieldListQuery() : QueryDataCondition<CustomFieldEntry>(), CustomFieldQuery {
override var entity: Class<CustomFieldEntry> = CustomFieldEntry::class.java
override var customFieldId : String? = null
constructor(customFieldEntry: CustomFieldEntry): this() {
this.setObject(customFieldEntry)
this.customFieldId = customFieldEntry.customField?.id
}
}
/**
* main method of the enum
* providing a base RealmQuery [realmQuery], the method is able to attached the corresponding query and returns the newly formed [RealmQuery]

@ -72,6 +72,12 @@ open class CustomField : RealmObject(), NameManageable, StaticRowRepresentableDa
private var rowRepresentation: List<RowRepresentable> = mutableListOf()
//helper
val isListType: Boolean
get() { return this.type == Type.LIST.uniqueIdentifier }
override fun localizedTitle(context: Context): String {
return this.name
}

@ -11,6 +11,7 @@ import net.pokeranalytics.android.R
import net.pokeranalytics.android.exceptions.ModelException
import net.pokeranalytics.android.model.interfaces.DeleteValidityStatus
import net.pokeranalytics.android.model.interfaces.Manageable
import net.pokeranalytics.android.model.interfaces.NameManageable
import net.pokeranalytics.android.model.interfaces.SaveValidityStatus
import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetType
import net.pokeranalytics.android.ui.view.RowRepresentable
@ -22,15 +23,16 @@ import java.util.*
import java.util.Currency
open class CustomFieldEntry : RealmObject(), Manageable, RowRepresentable {
@PrimaryKey
open class CustomFieldEntry : RealmObject(), NameManageable, RowRepresentable {
@PrimaryKey
override var id = UUID.randomUUID().toString()
var order: Int = 0
var customField: CustomField? = null
var value: String = ""
override var name: String = value
get() { return value }
@Ignore
var isMovable: Boolean = false

@ -778,32 +778,32 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
SessionRow.BANKROLL -> row.editingDescriptors(
mapOf(
"defaultValue" to this.bankroll,
"data" to realm.sorted<Bankroll>() // LiveData.BANKROLL.items(realm)
"data" to realm.sorted<Bankroll>() // LiveData.Bankroll.items(realm)
)
)
SessionRow.GAME -> row.editingDescriptors(
mapOf(
"limit" to this.limit,
"defaultValue" to this.game,
"data" to realm.sorted<Game>() //LiveData.GAME.items(realm)
"data" to realm.sorted<Game>() //LiveData.Game.items(realm)
)
)
SessionRow.LOCATION -> row.editingDescriptors(
mapOf(
"defaultValue" to this.location,
"data" to realm.sorted<Location>() // LiveData.LOCATION.items(realm)
"data" to realm.sorted<Location>() // LiveData.Location.items(realm)
)
)
SessionRow.TOURNAMENT_FEATURE -> row.editingDescriptors(
mapOf(
"defaultValue" to this.tournamentFeatures,
"data" to realm.sorted<TournamentFeature>() //LiveData.TOURNAMENT_FEATURE.items(realm)
"data" to realm.sorted<TournamentFeature>() //LiveData.TournamentFeature.items(realm)
)
)
SessionRow.TOURNAMENT_NAME -> row.editingDescriptors(
mapOf(
"defaultValue" to this.tournamentName,
"data" to realm.sorted<TournamentName>() //LiveData.TOURNAMENT_NAME.items(realm)
"data" to realm.sorted<TournamentName>() //LiveData.TournamentName.items(realm)
)
)
SessionRow.TOURNAMENT_TYPE -> row.editingDescriptors(

@ -163,7 +163,7 @@ class BankrollFragment : DeletableItemFragment(), StaticRowRepresentableDataSour
Timber.d("initData: ${System.currentTimeMillis() - startDate.time}ms")
// val bankrolls = LiveData.BANKROLL.items(getRealm()) as RealmResults<Bankroll>
// val bankrolls = LiveData.Bankroll.items(getRealm()) as RealmResults<Bankroll>
bankrolls.forEach { bankroll ->
val bankrollReportSetup = BankrollReportSetup(bankroll)

@ -3,20 +3,18 @@ package net.pokeranalytics.android.ui.view.rowrepresentable
import io.realm.Realm
import net.pokeranalytics.android.R
import net.pokeranalytics.android.model.LiveData
import net.pokeranalytics.android.model.filter.Filterable
import net.pokeranalytics.android.model.realm.Filter
import net.pokeranalytics.android.model.realm.Session
import net.pokeranalytics.android.model.realm.Transaction
import net.pokeranalytics.android.model.realm.CustomField
import net.pokeranalytics.android.ui.interfaces.FilterableType
import net.pokeranalytics.android.ui.view.RowRepresentable
import net.pokeranalytics.android.ui.view.RowViewType
import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow.*
import net.pokeranalytics.android.util.sorted
enum class FilterCategoryRow(override val resId: Int?, override val viewType: Int = RowViewType.TITLE_VALUE_ARROW.ordinal) : RowRepresentable {
GENERAL(R.string.general),
DATE(R.string.date),
TIME_FRAME(R.string.duration),
//SESSIONS(R.string.sessions),
//Sessions(R.string.sessions),
CASH(R.string.cash),
TOURNAMENT(R.string.tournament),
ONLINE(R.string.online),
@ -25,6 +23,7 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In
LOCATIONS(R.string.locations),
BANKROLLS(R.string.bankrolls),
//PLAYERS(R.string.players),
CUSTOM_FIELDS(R.string.custom_fields),
;
companion object {
@ -73,53 +72,62 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In
get() {
return when (this) {
GENERAL -> arrayListOf(
CASH_TOURNAMENT,
LIVE_ONLINE,
GAME,
LIMIT_TYPE,
TABLE_SIZE
CashOrTournament,
LiveOrOnline,
Game,
LimitType,
TableSize
)
DATE -> arrayListOf(
DYNAMIC_DATE,
FIXED_DATE,
DURATION,
YEAR,
WEEKDAYS_OR_WEEKEND,
DAY_OF_WEEK,
MONTH_OF_YEAR
DynamicDate,
FixedDate,
Duration,
Year,
WeekdayOrWeekend,
DayOfWeek,
MonthOfYear
)
TIME_FRAME -> arrayListOf(
SESSION_DURATION,
TIME_FRAME_RANGE
SessionDuration,
TimeFrameRange
)
//SESSIONS -> arrayListOf(FilterSectionRow.SESSIONS)
//Sessions -> arrayListOf(FilterSectionRow.Sessions)
BANKROLLS -> arrayListOf(
BANKROLL
Bankroll
)
CASH -> arrayListOf(
BLIND
Blind
)
TOURNAMENT -> arrayListOf(
TOURNAMENT_TYPE,
TOURNAMENT_NAME,
TOURNAMENT_FEATURE,
TOURNAMENT_ENTRY_FEE,
TOURNAMENT_NUMBER_OF_PLAYER,
TOURNAMENT_FINAL_POSITION
TournamentType,
TournamentName,
TournamentFeature,
TournamentEntryFee,
TournamentNumberOfPlayer,
TournamentFinalPosition
)
ONLINE -> arrayListOf(
MULTI_TABLING
MultiTabling
)
LOCATIONS -> arrayListOf(
LOCATION
Location
)
//PLAYERS -> arrayListOf(MULTI_PLAYER)
//PLAYERS -> arrayListOf(MultiPlayer)
RESULT -> arrayListOf(
VALUE,
NUMBER_OF_REBUY
Value,
NumberOfRebuy
)
TRANSACTION_TYPES -> arrayListOf(FilterSectionRow.TRANSACTION_TYPES)
CUSTOM_FIELDS -> {
val realm = Realm.getDefaultInstance()
val sections = realm.sorted(CustomField::class.java).map {
CustomField(it)
}
realm.close()
sections
}
TRANSACTION_TYPES -> arrayListOf(TransactionType)
}
}
}

@ -1,47 +1,52 @@
package net.pokeranalytics.android.ui.view.rowrepresentable
import net.pokeranalytics.android.R
import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.Criteria
import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.filter.mapFirstCondition
import net.pokeranalytics.android.model.realm.CustomField
import net.pokeranalytics.android.ui.view.RowRepresentable
import net.pokeranalytics.android.ui.view.RowViewType
enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
CASH_TOURNAMENT(R.string.cash_or_tournament),
LIVE_ONLINE(R.string.live_or_online),
GAME(R.string.games),
LIMIT_TYPE(R.string.limits),
TABLE_SIZE(R.string.table_sizes),
DYNAMIC_DATE(R.string.dynamic_date),
FIXED_DATE(R.string.fixed_date),
DURATION(R.string.duration),
YEAR(R.string.year),
WEEKDAYS_OR_WEEKEND(R.string.weekdays_or_weekend),
DAY_OF_WEEK(R.string.day_of_the_week),
MONTH_OF_YEAR(R.string.month_of_the_year),
SESSION_DURATION(R.string.session_duration),
TIME_FRAME_RANGE(R.string.hour_slot),
SESSIONS(R.string.sessions),
BLIND(R.string.blinds),
CASH_RE_BUY_COUNT(R.string.rebuy_count),
TOURNAMENT_TYPE(R.string.tournament_types),
TOURNAMENT_NAME(R.string.tournament_name),
TOURNAMENT_FEATURE(R.string.tournament_feature),
COMPLETION_PERCENTAGE(R.string.tournament_completion_percentage_interval),
TOURNAMENT_FINAL_POSITION(R.string.final_position),
TOURNAMENT_NUMBER_OF_PLAYER(R.string.players_count),
TOURNAMENT_RE_BUY_COUNT(R.string.rebuy_count),
TOURNAMENT_ENTRY_FEE(R.string.buyin),
MULTI_TABLING(R.string.number_of_tables),
VALUE(R.string.value),
LOCATION(R.string.locations),
BANKROLL(R.string.bankrolls),
NUMBER_OF_PLAYERS(R.string.number_of_players),
MULTI_PLAYER(R.string.multiplayer),
NUMBER_OF_REBUY(R.string.number_of_buyins),
TRANSACTION_TYPES(R.string.operation_types),
;
sealed class FilterSectionRow(override val resId: Int?) : RowRepresentable {
object CashOrTournament: FilterSectionRow(R.string.cash_or_tournament)
object LiveOrOnline: FilterSectionRow(R.string.live_or_online)
object Game: FilterSectionRow(R.string.games)
object LimitType: FilterSectionRow(R.string.limits)
object TableSize: FilterSectionRow(R.string.table_sizes)
object DynamicDate: FilterSectionRow(R.string.dynamic_date)
object FixedDate: FilterSectionRow(R.string.fixed_date)
object Duration: FilterSectionRow(R.string.duration)
object Year: FilterSectionRow(R.string.year)
object WeekdayOrWeekend: FilterSectionRow(R.string.weekdays_or_weekend)
object DayOfWeek: FilterSectionRow(R.string.day_of_the_week)
object MonthOfYear: FilterSectionRow(R.string.month_of_the_year)
object SessionDuration: FilterSectionRow(R.string.session_duration)
object TimeFrameRange: FilterSectionRow(R.string.hour_slot)
object Sessions: FilterSectionRow(R.string.sessions)
object Blind: FilterSectionRow(R.string.blinds)
object CashRebuyCount: FilterSectionRow(R.string.rebuy_count)
object TournamentType: FilterSectionRow(R.string.tournament_types)
object TournamentName: FilterSectionRow(R.string.tournament_name)
object TournamentFeature: FilterSectionRow(R.string.tournament_feature)
object CompletionPercentage: FilterSectionRow(R.string.tournament_completion_percentage_interval)
object TournamentFinalPosition: FilterSectionRow(R.string.final_position)
object TournamentNumberOfPlayer: FilterSectionRow(R.string.players_count)
object TournamentRebuyCount: FilterSectionRow(R.string.rebuy_count)
object TournamentEntryFee: FilterSectionRow(R.string.buyin)
object MultiTabling: FilterSectionRow(R.string.number_of_tables)
object Value: FilterSectionRow(R.string.value)
object Location: FilterSectionRow(R.string.locations)
object Bankroll: FilterSectionRow(R.string.bankrolls)
object NumberOfPlayers: FilterSectionRow(R.string.number_of_players)
object MultiPlayer: FilterSectionRow(R.string.multiplayer)
object NumberOfRebuy: FilterSectionRow(R.string.number_of_buyins)
object TransactionType: FilterSectionRow(R.string.operation_types)
data class CustomField(var customField:net.pokeranalytics.android.model.realm.CustomField): FilterSectionRow(customField.resId) {
override val name = this.customField::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName
}
private enum class SelectionType {
SINGLE,
@ -50,7 +55,9 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
override val viewType: Int = RowViewType.HEADER_TITLE.ordinal
val allowMultiSelection: Boolean
open val name = this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName
val allowMultiSelection: Boolean
get() = (this.selectionType == SelectionType.MULTIPLE)
val filterElements: List<RowRepresentable>
@ -61,13 +68,13 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
when (this@FilterSectionRow) {
// General
CASH_TOURNAMENT -> Criteria.SessionTypes.queryConditions.mapFirstCondition()
LIVE_ONLINE -> Criteria.BankrollTypes.queryConditions.mapFirstCondition()
GAME -> Criteria.Games.queryConditions.mapFirstCondition()
LIMIT_TYPE -> Criteria.Limits.queryConditions.mapFirstCondition()
TABLE_SIZE -> Criteria.TableSizes.queryConditions.mapFirstCondition()
CashOrTournament -> Criteria.SessionTypes.queryConditions.mapFirstCondition()
LiveOrOnline -> Criteria.BankrollTypes.queryConditions.mapFirstCondition()
Game -> Criteria.Games.queryConditions.mapFirstCondition()
LimitType -> Criteria.Limits.queryConditions.mapFirstCondition()
TableSize -> Criteria.TableSizes.queryConditions.mapFirstCondition()
// Date
DYNAMIC_DATE -> arrayListOf(
DynamicDate -> arrayListOf(
QueryCondition.IsToday,
QueryCondition.WasYesterday,
QueryCondition.WasTodayAndYesterday,
@ -75,45 +82,56 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
QueryCondition.DuringThisMonth,
QueryCondition.DuringThisYear
)
FIXED_DATE -> arrayListOf(QueryCondition.StartedFromDate(), QueryCondition.EndedToDate())
DURATION -> arrayListOf(QueryCondition.PastDay())
WEEKDAYS_OR_WEEKEND -> arrayListOf(QueryCondition.IsWeekDay, QueryCondition.IsWeekEnd)
YEAR -> Criteria.Years.queryConditions.mapFirstCondition()
DAY_OF_WEEK -> Criteria.DaysOfWeek.queryConditions.mapFirstCondition()
MONTH_OF_YEAR -> Criteria.MonthsOfYear.queryConditions.mapFirstCondition()
FixedDate -> arrayListOf(QueryCondition.StartedFromDate(), QueryCondition.EndedToDate())
Duration -> arrayListOf(QueryCondition.PastDay())
WeekdayOrWeekend -> arrayListOf(QueryCondition.IsWeekDay, QueryCondition.IsWeekEnd)
Year -> Criteria.Years.queryConditions.mapFirstCondition()
DayOfWeek -> Criteria.DaysOfWeek.queryConditions.mapFirstCondition()
MonthOfYear -> Criteria.MonthsOfYear.queryConditions.mapFirstCondition()
// Duration
SESSION_DURATION -> QueryCondition.moreOrLess<QueryCondition.Duration>()
TIME_FRAME_RANGE -> arrayListOf(QueryCondition.StartedFromTime(), QueryCondition.EndedToTime())
SessionDuration -> QueryCondition.moreOrLess<QueryCondition.Duration>()
TimeFrameRange -> arrayListOf(QueryCondition.StartedFromTime(), QueryCondition.EndedToTime())
// Sessions
//SESSIONS -> arrayListOf(QueryCondition.LastGame(), QueryCondition.LastSession())
//Sessions -> arrayListOf(QueryCondition.LastGame(), QueryCondition.LastSession())
// Cash
BLIND -> Criteria.Blinds.queryConditions.mapFirstCondition()
// CASH_RE_BUY_COUNT -> QueryCondition.moreOrLess<QueryCondition.Rebuy>()
Blind -> Criteria.Blinds.queryConditions.mapFirstCondition()
// CashRebuyCount -> QueryCondition.moreOrLess<QueryCondition.Rebuy>()
// Tournament
TOURNAMENT_TYPE -> Criteria.TournamentTypes.queryConditions.mapFirstCondition()
// COMPLETION_PERCENTAGE -> arrayListOf()
TOURNAMENT_FINAL_POSITION -> QueryCondition.moreOrLess<QueryCondition.TournamentFinalPosition>()
TOURNAMENT_NUMBER_OF_PLAYER -> QueryCondition.moreOrLess<QueryCondition.TournamentNumberOfPlayer>()
TOURNAMENT_ENTRY_FEE -> Criteria.TournamentFees.queryConditions.mapFirstCondition()
TOURNAMENT_NAME -> Criteria.TournamentNames.queryConditions.mapFirstCondition()
TOURNAMENT_FEATURE -> Criteria.TournamentFeatures.queryConditions.mapFirstCondition()
LOCATION -> Criteria.Locations.queryConditions.mapFirstCondition()
BANKROLL -> Criteria.Bankrolls.queryConditions.mapFirstCondition()
MULTI_TABLING -> QueryCondition.moreOrLess<QueryCondition.NumberOfTable>()
//NUMBER_OF_PLAYERS -> QueryCondition.moreOrLess<QueryCondition.TournamentNumberOfPlayer>()
NUMBER_OF_REBUY -> QueryCondition.moreOrLess<QueryCondition.NumberOfRebuy>()
// MULTI_PLAYER -> arrayListOf()
VALUE -> arrayListOf<QueryCondition>().apply {
TournamentType -> Criteria.TournamentTypes.queryConditions.mapFirstCondition()
// CompletionPercentage -> arrayListOf()
TournamentFinalPosition -> QueryCondition.moreOrLess<QueryCondition.TournamentFinalPosition>()
TournamentNumberOfPlayer -> QueryCondition.moreOrLess<QueryCondition.TournamentNumberOfPlayer>()
TournamentEntryFee -> Criteria.TournamentFees.queryConditions.mapFirstCondition()
TournamentName -> Criteria.TournamentNames.queryConditions.mapFirstCondition()
TournamentFeature -> Criteria.TournamentFeatures.queryConditions.mapFirstCondition()
Location -> Criteria.Locations.queryConditions.mapFirstCondition()
Bankroll -> Criteria.Bankrolls.queryConditions.mapFirstCondition()
MultiTabling -> QueryCondition.moreOrLess<QueryCondition.NumberOfTable>()
//NumberOfPlayers -> QueryCondition.moreOrLess<QueryCondition.TournamentNumberOfPlayer>()
NumberOfRebuy -> QueryCondition.moreOrLess<QueryCondition.NumberOfRebuy>()
// MultiPlayer -> arrayListOf()
Value -> arrayListOf<QueryCondition>().apply {
addAll(QueryCondition.moreOrLess<QueryCondition.NetAmountWon>())
addAll(QueryCondition.moreOrLess<QueryCondition.NetAmountLost>())
}
TRANSACTION_TYPES -> Criteria.TransactionTypes.queryConditions.mapFirstCondition()
TransactionType -> Criteria.TransactionTypes.queryConditions.mapFirstCondition()
is CustomField -> {
if (this@FilterSectionRow.customField.isListType) {
Criteria.ListCustomFields(this@FilterSectionRow.customField).queryConditions.mapFirstCondition()
} else {
QueryCondition.moreOrLess<QueryCondition.CustomFieldNumberQuery>().apply {
this.forEach {
it.customFieldId = this@FilterSectionRow.customField.id
}
}
}
}
else -> arrayListOf()
}.apply {
this.forEach {
@ -134,7 +152,7 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
private val selectionType: SelectionType
get() {
return when (this) {
CASH_TOURNAMENT, DYNAMIC_DATE, LIVE_ONLINE, SESSIONS -> SelectionType.SINGLE
CashOrTournament, DynamicDate, LiveOrOnline, Sessions -> SelectionType.SINGLE
else -> SelectionType.MULTIPLE
}
}
@ -142,8 +160,8 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
val exclusiveWith: List<FilterSectionRow>?
get() {
return when (this) {
DYNAMIC_DATE -> arrayListOf(FIXED_DATE)
FIXED_DATE -> arrayListOf(DYNAMIC_DATE)
DynamicDate -> arrayListOf(FixedDate)
FixedDate -> arrayListOf(DynamicDate)
else -> null
}
}

Loading…
Cancel
Save