remove warning and clean up files

feature/top10
Razmig Sarkissian 7 years ago
parent 1381887dfd
commit 032c2aa7ae
  1. 76
      app/src/androidTest/java/net/pokeranalytics/android/filter/DateFilterInstrumentedUnitTest.kt
  2. 17
      app/src/androidTest/java/net/pokeranalytics/android/filter/ExceptionFilterInstrumentedTest.kt
  3. 57
      app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
  4. 76
      app/src/main/java/net/pokeranalytics/android/model/filter/DateFilterable.kt
  5. 193
      app/src/main/java/net/pokeranalytics/android/model/filter/FilterComponent.kt
  6. 40
      app/src/main/java/net/pokeranalytics/android/model/filter/Filterable.kt
  7. 108
      app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt
  8. 7
      app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/Filterable.kt
  9. 20
      app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/TimeFilterable.kt
  10. 28
      app/src/main/java/net/pokeranalytics/android/model/filter/interfaces/ValueFilterable.kt
  11. 5
      app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
  12. 19
      app/src/main/java/net/pokeranalytics/android/ui/fragment/HistoryFragment.kt

@ -1,7 +1,6 @@
package net.pokeranalytics.android.filter
import androidx.test.ext.junit.runners.AndroidJUnit4
import io.realm.RealmResults
import net.pokeranalytics.android.model.filter.DateFilterable
import net.pokeranalytics.android.model.filter.FilterManager
import net.pokeranalytics.android.model.realm.Session
@ -23,10 +22,10 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = Date() // sets calendar time/date
val s1 = Session.testInstance(100.0, false, cal.time)
cal.add(Calendar.DAY_OF_MONTH, 1) // adds one hour
val s2 = Session.testInstance(100.0, true, cal.time)
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
var filter = DateFilterable.DAY_OF_WEEK
val filter = DateFilterable.DAY_OF_WEEK
cal.time = s1.startDate
filter.valueMap = mapOf("dayOfWeek" to cal.get(Calendar.DAY_OF_WEEK))
@ -34,11 +33,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s1.id, this.id)
Assert.assertEquals(s1.id, (this as Session).id)
}
}
@ -51,10 +50,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = Date()
val s1 = Session.testInstance(100.0, false, cal.time)
cal.add(Calendar.MONTH, 1)
val s2 = Session.testInstance(100.0, true, cal.time)
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
var filter = DateFilterable.MONTH
val filter = DateFilterable.MONTH
cal.time = s1.startDate
filter.valueMap = mapOf("month" to cal.get(Calendar.MONTH))
@ -62,11 +62,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s1.id, this.id)
Assert.assertEquals(s1.id, (this as Session).id)
}
}
@ -79,10 +79,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.time = Date()
val s1 = Session.testInstance(100.0, false, cal.time)
cal.add(Calendar.YEAR, 1)
val s2 = Session.testInstance(100.0, true, cal.time)
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
var filter = DateFilterable.YEAR
val filter = DateFilterable.YEAR
cal.time = s1.startDate
filter.valueMap = mapOf("year" to cal.get(Calendar.YEAR))
@ -90,11 +91,11 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s1.id, this.id)
Assert.assertEquals(s1.id, (this as Session).id)
}
}
@ -109,17 +110,18 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY)
val s1 = Session.testInstance(100.0, false, cal.time)
cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY)
val s2 = Session.testInstance(100.0, true, cal.time)
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(DateFilterable.WEEK_END)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s1.id, this.id)
Assert.assertEquals(s1.id, (this as Session).id)
}
}
@ -133,17 +135,18 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY)
val s1 = Session.testInstance(100.0, false, cal.time)
cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY)
val s2 = Session.testInstance(100.0, true, cal.time)
Session.testInstance(100.0, true, cal.time)
realm.commitTransaction()
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(DateFilterable.WEEK_DAY)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s1.id, this.id)
Assert.assertEquals(s1.id, (this as Session).id)
}
}
@ -155,24 +158,25 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val cal = Calendar.getInstance() // creates calendar
cal.time = Date() // sets calendar time/date
val s1 = Session.testInstance(100.0, false, cal.time, 1)
Session.testInstance(100.0, false, cal.time, 1)
cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
val s2 = Session.testInstance(100.0, true, cal.time, 1)
realm.commitTransaction()
var filter = DateFilterable.STARTED_FROM_DATE
val filter = DateFilterable.STARTED_FROM_DATE
filter.valueMap = mapOf("date" to s2.startDate)
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s2.id, this.id)
Assert.assertEquals(s2.id, (this as Session).id)
}
}
@ -187,22 +191,22 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s1 = Session.testInstance(100.0, false, cal.time, 1)
cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
val s2 = Session.testInstance(100.0, true, cal.time, 1)
Session.testInstance(100.0, true, cal.time, 1)
realm.commitTransaction()
var filter = DateFilterable.STARTED_TO_DATE
val filter = DateFilterable.STARTED_TO_DATE
filter.valueMap = mapOf("date" to s1.startDate)
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s1.id, this.id)
Assert.assertEquals(s1.id, (this as Session).id)
}
}
@ -214,25 +218,26 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val cal = Calendar.getInstance() // creates calendar
cal.time = Date() // sets calendar time/date
val s1 = Session.testInstance(100.0, false, cal.time, 1)
Session.testInstance(100.0, false, cal.time, 1)
cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
val s2 = Session.testInstance(100.0, true, cal.time, 1)
realm.commitTransaction()
var filter = DateFilterable.ENDED_FROM_DATE
val filter = DateFilterable.ENDED_FROM_DATE
filter.valueMap = mapOf("date" to s2.endDate)
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s2.id, this.id)
Assert.assertEquals(s2.id, (this as Session).id)
}
}
@ -247,22 +252,23 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val s1 = Session.testInstance(100.0, false, cal.time, 1)
cal.add(Calendar.HOUR_OF_DAY, 2) // adds one hour
val s2 = Session.testInstance(100.0, true, cal.time, 1)
Session.testInstance(100.0, true, cal.time, 1)
realm.commitTransaction()
var filter = DateFilterable.ENDED_TO_DATE
val filter = DateFilterable.ENDED_TO_DATE
filter.valueMap = mapOf("date" to s1.endDate)
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(s1.id, this.id)
Assert.assertEquals(s1.id, (this as Session).id)
}
}
}

@ -1,7 +1,6 @@
package net.pokeranalytics.android.filter
import androidx.test.ext.junit.runners.AndroidJUnit4
import io.realm.RealmResults
import net.pokeranalytics.android.exceptions.FilterValueMapException
import net.pokeranalytics.android.model.filter.DateFilterable
import net.pokeranalytics.android.model.filter.FilterManager
@ -17,29 +16,29 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
@Test(expected = FilterValueMapException::class)
fun testFilterException() {
val realm = this.mockRealm
val sessions = FilterManager().filter(
FilterManager().filter(
realm,
Session::class.java,
arrayListOf(SessionFilterable.BLINDS)
) as RealmResults<Session>
)
}
@Test(expected = FilterValueMapException::class)
fun testValueKeyFilterException() {
var filter = DateFilterable.STARTED_FROM_DATE
val filter = DateFilterable.STARTED_FROM_DATE
filter.valueMap = mapOf("bob" to Date())
val realm = this.mockRealm
val sessions = FilterManager().filter(
FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
}
@Test(expected = FilterValueMapException::class)
fun testSubValueKeyFilterException() {
var filter = SessionFilterable.BLINDS
val filter = SessionFilterable.BLINDS
filter.valueMap = mapOf("map" to arrayOf(mapOf(
"bob" to 0.5,
"bb" to 1.0,
@ -47,10 +46,10 @@ class ExceptionFilterInstrumentedTest: BaseFilterInstrumentedUnitTest() {
)))
val realm = this.mockRealm
val sessions = FilterManager().filter(
FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
}
}

@ -1,7 +1,6 @@
package net.pokeranalytics.android.filter
import androidx.test.ext.junit.runners.AndroidJUnit4
import io.realm.RealmResults
import net.pokeranalytics.android.model.filter.FilterManager
import net.pokeranalytics.android.model.filter.SessionFilterable
import net.pokeranalytics.android.model.realm.Bankroll
@ -20,19 +19,19 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val realm = this.mockRealm
realm.beginTransaction()
val s1 = Session.testInstance(100.0, false, Date(), 1)
val s2 = Session.testInstance(100.0, true, Date(), 1)
Session.testInstance(100.0, false, Date(), 1)
Session.testInstance(100.0, true, Date(), 1)
realm.commitTransaction()
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(SessionFilterable.CASH)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(Session.Type.CASH_GAME.ordinal, this.type)
Assert.assertEquals(Session.Type.CASH_GAME.ordinal, (this as Session).type)
}
}
@ -42,19 +41,19 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
val realm = this.mockRealm
realm.beginTransaction()
val s1 = Session.testInstance(100.0, false, Date(), 1)
val s2 = Session.testInstance(100.0, true, Date(), 1)
Session.testInstance(100.0, false, Date(), 1)
Session.testInstance(100.0, true, Date(), 1)
realm.commitTransaction()
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(SessionFilterable.TOURNAMENT)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.run {
Assert.assertEquals(Session.Type.TOURNAMENT.ordinal, this.type)
Assert.assertEquals(Session.Type.TOURNAMENT.ordinal, (this as Session).type)
}
}
@ -69,18 +68,18 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
b1.live = true
b2.live = false
val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
val s2 = Session.testInstance(100.0, true, Date(), 1, b2)
Session.testInstance(100.0, false, Date(), 1, b1)
Session.testInstance(100.0, true, Date(), 1, b2)
realm.commitTransaction()
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(SessionFilterable.LIVE)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.bankroll?.run {
(sessions[0] as Session).bankroll?.run {
Assert.assertEquals(true, this.live)
}
}
@ -95,18 +94,18 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
b1.live = false
b2.live = true
val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
val s2 = Session.testInstance(100.0, true, Date(), 1, b2)
Session.testInstance(100.0, false, Date(), 1, b1)
Session.testInstance(100.0, true, Date(), 1, b2)
realm.commitTransaction()
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(SessionFilterable.ONLINE)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions[0]?.bankroll?.run {
(sessions[0] as Session).bankroll?.run {
Assert.assertEquals(false, this.live)
}
}
@ -139,7 +138,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
var filter = SessionFilterable.BLINDS
val filter = SessionFilterable.BLINDS
filter.valueMap = mapOf("map" to arrayOf(mapOf(
"sb" to 0.5,
"bb" to 1.0,
@ -150,11 +149,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(2, sessions.size)
sessions.map {
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains(it.id))
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
}
}
@ -186,7 +185,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
var filter = SessionFilterable.BLINDS
val filter = SessionFilterable.BLINDS
filter.valueMap = mapOf("map" to arrayOf(mapOf(
"sb" to null,
"bb" to 1.0,
@ -197,11 +196,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(2, sessions.size)
sessions.map {
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains(it.id))
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
}
}
@ -233,7 +232,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
var filter = SessionFilterable.BLINDS
val filter = SessionFilterable.BLINDS
filter.valueMap = mapOf("map" to arrayOf(mapOf(
"sb" to 1.0,
"bb" to 2.0,
@ -244,11 +243,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(1, sessions.size)
sessions.map {
Assert.assertEquals(s3.id, it.id)
Assert.assertEquals(s3.id, (it as Session).id)
}
}
@ -280,7 +279,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm.commitTransaction()
var filter = SessionFilterable.BLINDS
val filter = SessionFilterable.BLINDS
filter.valueMap = mapOf("map" to arrayOf(
mapOf(
"sb" to 1.0,
@ -297,11 +296,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
realm,
Session::class.java,
arrayListOf(filter)
) as RealmResults<Session>
)
Assert.assertEquals(2, sessions.size)
sessions.map {
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains(it.id))
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
}
}
}

@ -0,0 +1,76 @@
package net.pokeranalytics.android.model.filter
import io.realm.RealmQuery
import net.pokeranalytics.android.model.filter.interfaces.Filterable
import java.util.*
enum class DateFilterable : Filterable {
STARTED_FROM_DATE,
STARTED_TO_DATE,
ENDED_FROM_DATE,
ENDED_TO_DATE,
DAY_OF_WEEK,
MONTH,
YEAR,
WEEK_DAY,
WEEK_END,
;
private enum class Field(var fieldName:String) {
START_DATE("startDate"),
END_DATE("endDate"),
DAY("dayOfWeek"),
MONTH("month"),
YEAR("year"),
}
override var valueMap : Map<String, Any?>? = null
override val filterValuesExceptedKeys : Array<String>?
get() {
return when (this) {
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")
else -> null
}
}
override fun filter(realmQuery: RealmQuery<*>): RealmQuery<*> {
return when (this) {
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)
}
WEEK_END -> {
realmQuery.`in`(Field.DAY.fieldName, arrayOf(Calendar.SATURDAY,Calendar.SUNDAY))
}
WEEK_DAY -> WEEK_END.filter(realmQuery.not())
}
}
}

@ -1,198 +1,5 @@
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.realm.Session
import java.time.DayOfWeek
import java.util.*
enum class FilterComponent {
}
interface TimeFilterable {
var dayOfWeek : Int?
var month : Int?
var year : Int?
fun updateTimeParameter(startDate:Date?) {
startDate?.let {
val cal = Calendar.getInstance()
cal.time = it
dayOfWeek = cal.get(Calendar.DAY_OF_WEEK)
month = cal.get(Calendar.MONTH)
year = cal.get(Calendar.YEAR)
}
}
}
enum class DateFilterable(var fieldName:String? = null) : Filterable {
STARTED_FROM_DATE,
STARTED_TO_DATE,
ENDED_FROM_DATE,
ENDED_TO_DATE,
DAY_OF_WEEK("dayOfWeek"),
MONTH("month"),
YEAR("year"),
WEEK_DAY,
WEEK_END,
;
private enum class Field(var fieldName:String) {
START_DATE("startDate"),
END_DATE("endDate"),
}
override var valueMap : Map<String, Any?>? = null
override val filterValuesExceptedKeys : Array<String>?
get() {
return when (this) {
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")
else -> null
}
}
override fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject> {
return when (this) {
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(this.fieldName, dayOfWeek)
}
MONTH -> {
val month: Int by filterValues
realmQuery.equalTo(this.fieldName, month)
}
YEAR -> {
val year: Int by filterValues
realmQuery.equalTo(this.fieldName, year)
}
WEEK_END -> {
realmQuery.equalTo(DAY_OF_WEEK.fieldName, Calendar.SATURDAY).or().equalTo(DAY_OF_WEEK.fieldName, Calendar.SUNDAY)
}
WEEK_DAY -> WEEK_END.filter(realmQuery.not())
} as RealmQuery<out RealmObject>
}
}
enum class SessionFilterable(var fieldName:String? = null) : Filterable {
LIVE("bankroll.live"),
CASH("type"),
ONLINE,
TOURNAMENT,
BANKROLL("bankroll.id"),
GAME("game.id"),
LIMIT("limit"),
TABLE_SIZE("tableSize"),
LOCATION("location.id"),
NUMBER_OF_TABLE("numberOfTable"),
COMMENT("comment"),
TOURNAMENT_TYPE("tournamentType"),
TOURNAMENT_NAME("tournamentName.id"),
TOURNAMENT_FEATURES("tournamentFeature.id"),
TOURNAMENT_NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
TOURNAMENT_ENTRY_FEE("tournamentEntryFee"),
RESULT_BUY_IN("result.buyin"),
RESULT_CASHED_OUT("result.cashout"),
RESULT_NET("result.ratedNet"),
RESULT_TIPS("result.tips"),
BLINDS,
;
private enum class Field(var fieldName:String) {
START_DATE("startDate"),
END_DATE("endDate"),
CURRENCY("bankroll.currency"),
CURRENCY_CODE("bankroll.currency.code"),
BIG_BLIND("cgBigBlind"),
SMALL_BLIND("cgSmallBlind");
}
override var valueMap : Map<String, Any?>? = null
override val filterValuesExceptedKeys : Array<String>?
get() {
return when (this) {
BANKROLL -> arrayOf("ids")
BLINDS -> arrayOf("map")
else -> null
}
}
override fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject> {
return when (this) {
LIVE -> realmQuery.equalTo(this.fieldName, true)
CASH -> realmQuery.equalTo(this.fieldName, Session.Type.CASH_GAME.ordinal)
ONLINE -> LIVE.filter(realmQuery.not())
TOURNAMENT -> CASH.filter(realmQuery.not())
BANKROLL -> {
val ids : Array<String> by filterValues
realmQuery.`in`(this.fieldName, ids)
}
BLINDS -> {
val map : Array<Map<String,Any?>> by filterValues
var finalQuery = realmQuery
val expectedSubKeys = arrayOf("sb", "bb", "code") as Array<String>
map.forEachIndexed { index, subMap ->
var missingKeys = subMap.keys.filter { !expectedSubKeys.contains(it) }
if (subMap.keys.size == expectedSubKeys.size && missingKeys.isNotEmpty()) {
throw FilterValueMapException("subValueMap does not contain ${missingKeys}")
}
val sb : Double? by subMap
val bb : Double? by subMap
val code : String? by subMap
finalQuery
.beginGroup()
sb?.let {
finalQuery
.equalTo(Field.SMALL_BLIND.fieldName, sb)
.and()
}
finalQuery
.equalTo(Field.BIG_BLIND.fieldName, bb)
.and()
code?.let {
finalQuery.equalTo(Field.CURRENCY_CODE.fieldName, code)
} ?: run {
finalQuery.isNull(Field.CURRENCY_CODE.fieldName)
}
finalQuery.endGroup()
if (index < map.size - 1) {
finalQuery.or()
}
}
finalQuery
}
else -> realmQuery
} as RealmQuery<out RealmObject>
}
}

@ -4,9 +4,7 @@ import io.realm.Realm
import io.realm.RealmObject
import io.realm.RealmQuery
import io.realm.RealmResults
import net.pokeranalytics.android.exceptions.FilterValueMapException
import net.pokeranalytics.android.model.LiveData
import net.pokeranalytics.android.model.realm.*
import net.pokeranalytics.android.model.filter.interfaces.Filterable
/**
* We want to be able to store filters in the database:
@ -34,45 +32,11 @@ import net.pokeranalytics.android.model.realm.*
*
*/
interface Filterable : ValueFilterable {
fun filter(realmQuery: RealmQuery<*>): RealmQuery<out RealmObject>
}
interface ValueFilterable {
var valueMap: Map<String, Any?>?
var filterValues : Map<String, Any?>?
get() {
this.filterValuesExceptedKeys?.let { valueMapExceptedKeys ->
valueMap?.let { map ->
var 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 this.valueMap
}
set(value) {
valueMap = value
}
val filterValuesExceptedKeys : Array<String>?
}
class FilterManager {
fun test(realmResults: RealmResults<RealmObject>) {
realmResults.where().greaterThan("test", 5).findAll()
}
fun filter(realm:Realm, relatedEntity: Class<out RealmObject>, queries:List<Filterable>): RealmResults<*> {
var realmQuery = realm.where(relatedEntity)
queries.forEach {
realmQuery = it.filter(realmQuery).and()
realmQuery = (it.filter(realmQuery) as RealmQuery<out RealmObject>).and()
}
return realmQuery.findAll()
}

@ -0,0 +1,108 @@
package net.pokeranalytics.android.model.filter
import io.realm.RealmQuery
import net.pokeranalytics.android.exceptions.FilterValueMapException
import net.pokeranalytics.android.model.filter.interfaces.Filterable
import net.pokeranalytics.android.model.realm.Session
enum class SessionFilterable: Filterable {
LIVE,
CASH,
ONLINE,
TOURNAMENT,
BANKROLL,
BLINDS,
;
private enum class Field(var fieldName:String) {
LIVE("bankroll.live"),
CASH("type"),
BANKROLL("bankroll.id"),
START_DATE("startDate"),
END_DATE("endDate"),
CURRENCY("bankroll.currency"),
CURRENCY_CODE("bankroll.currency.code"),
BIG_BLIND("cgBigBlind"),
SMALL_BLIND("cgSmallBlind"),
GAME("game.id"),
LIMIT("limit"),
TABLE_SIZE("tableSize"),
LOCATION("location.id"),
NUMBER_OF_TABLE("numberOfTable"),
COMMENT("comment"),
TOURNAMENT_TYPE("tournamentType"),
TOURNAMENT_NAME("tournamentName.id"),
TOURNAMENT_FEATURES("tournamentFeature.id"),
TOURNAMENT_NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
TOURNAMENT_ENTRY_FEE("tournamentEntryFee"),
RESULT_BUY_IN("result.buyin"),
RESULT_CASHED_OUT("result.cashout"),
RESULT_NET("result.ratedNet"),
RESULT_TIPS("result.tips"),
;
}
override var valueMap : Map<String, Any?>? = null
override val filterValuesExceptedKeys : Array<String>?
get() {
return when (this) {
BANKROLL -> arrayOf("ids")
BLINDS -> arrayOf("map")
else -> null
}
}
override fun filter(realmQuery: RealmQuery<*>): RealmQuery<*> {
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())
BANKROLL -> {
val ids : Array<String> by filterValues
realmQuery.`in`(Field.BANKROLL.fieldName, ids)
}
BLINDS -> {
val map : Array<Map<String,Any?>> by filterValues
val expectedSubKeys = arrayOf("sb", "bb", "code")
map.forEachIndexed { index, subMap ->
val missingKeys = subMap.keys.filter { !expectedSubKeys.contains(it) }
if (subMap.keys.size == expectedSubKeys.size && missingKeys.isNotEmpty()) {
throw FilterValueMapException("subValueMap does not contain $missingKeys")
}
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)
.and()
}
realmQuery
.equalTo(Field.BIG_BLIND.fieldName, bb)
.and()
code?.let {
realmQuery.equalTo(Field.CURRENCY_CODE.fieldName, code)
} ?: run {
realmQuery.isNull(Field.CURRENCY_CODE.fieldName)
}
realmQuery.endGroup()
if (index < map.size - 1) {
realmQuery.or()
}
}
realmQuery
}
}
}
}

@ -0,0 +1,7 @@
package net.pokeranalytics.android.model.filter.interfaces
import io.realm.RealmQuery
interface Filterable : ValueFilterable {
fun filter(realmQuery: RealmQuery<*>): RealmQuery<*>
}

@ -0,0 +1,20 @@
package net.pokeranalytics.android.model.filter.interfaces
import java.util.*
interface TimeFilterable {
var dayOfWeek : Int?
var month : Int?
var year : Int?
fun updateTimeParameter(startDate: Date?) {
startDate?.let {
val cal = Calendar.getInstance()
cal.time = it
dayOfWeek = cal.get(Calendar.DAY_OF_WEEK)
month = cal.get(Calendar.MONTH)
year = cal.get(Calendar.YEAR)
}
}
}

@ -0,0 +1,28 @@
package net.pokeranalytics.android.model.filter.interfaces
import net.pokeranalytics.android.exceptions.FilterValueMapException
interface ValueFilterable {
var valueMap: Map<String, Any?>?
var filterValues : Map<String, Any?>?
get() {
this.filterValuesExceptedKeys?.let { valueMapExceptedKeys ->
valueMap?.let { map ->
var 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 this.valueMap
}
set(value) {
valueMap = value
}
val filterValuesExceptedKeys : Array<String>?
}

@ -17,7 +17,7 @@ import net.pokeranalytics.android.model.TableSize
import net.pokeranalytics.android.model.TournamentType
import net.pokeranalytics.android.model.extensions.SessionState
import net.pokeranalytics.android.model.extensions.getState
import net.pokeranalytics.android.model.filter.TimeFilterable
import net.pokeranalytics.android.model.filter.interfaces.TimeFilterable
import net.pokeranalytics.android.model.interfaces.Manageable
import net.pokeranalytics.android.model.interfaces.Timed
import net.pokeranalytics.android.model.utils.SessionSetManager
@ -36,7 +36,8 @@ import java.util.*
import java.util.Currency
import kotlin.collections.ArrayList
open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource, RowRepresentable, Timed, TimeFilterable {
open class Session : RealmObject(), Manageable, StaticRowRepresentableDataSource, RowRepresentable, Timed,
TimeFilterable {
enum class Type {
CASH_GAME,

@ -5,7 +5,6 @@ import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.isVisible
import androidx.lifecycle.LiveData
import androidx.recyclerview.widget.DiffUtil
import io.realm.RealmResults
import io.realm.Sort
@ -14,11 +13,7 @@ import kotlinx.android.synthetic.main.fragment_history.*
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import net.pokeranalytics.android.R
import net.pokeranalytics.android.model.filter.FilterManager
import net.pokeranalytics.android.model.filter.Filterable
import net.pokeranalytics.android.model.filter.SessionFilterable
import net.pokeranalytics.android.model.interfaces.Manageable
import net.pokeranalytics.android.model.realm.Bankroll
import net.pokeranalytics.android.model.realm.Session
import net.pokeranalytics.android.ui.activity.SessionActivity
import net.pokeranalytics.android.ui.adapter.LiveRowRepresentableDataSource
@ -97,20 +92,6 @@ class HistoryFragment : PokerAnalyticsFragment(), LiveRowRepresentableDataSource
* Init data
*/
private fun initData() {
/*
var brs = (net.pokeranalytics.android.model.LiveData.BANKROLL.items(getRealm()) as RealmResults<Bankroll>).toArray().map{
(it as Bankroll).id
}
var br = SessionFilterable.BANKROLL
br.valueMap = mapOf("ids" to arrayOf(brs.last()))
realmSessions = FilterManager().filter(getRealm(), Session::class.java, arrayListOf<Filterable>(br))
.sort("creationDate", Sort.DESCENDING) as RealmResults<Session>
// realmSessions = FilterManager().filter(getRealm(), Session::class.java, arrayListOf<Filterable>(SessionFilterable.ONLINE, SessionFilterable.CASH)).sort("creationDate", Sort.DESCENDING) as RealmResults<Session>
*/
realmSessions = getRealm().where<Session>().findAll().sort("creationDate", Sort.DESCENDING)
val viewManager = SmoothScrollLinearLayoutManager(requireContext())

Loading…
Cancel
Save