add tournament final position filter

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt

@@ -573,4 +573,44 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             Assert.assertTrue(result.contains((it as Session).id))
         }
     }
+
+    @Test
+    fun testTournamentFinalPosition() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val s1 = Session.testInstance(netResult = 200.0, isTournament = true)
+        s1.result!!.tournamentFinalPosition = 5
+
+        val s2 = Session.testInstance(netResult = 50.0, isTournament = true)
+        s2.result!!.tournamentFinalPosition = 15
+
+        val s3 = Session.testInstance(netResult = 500.0, isTournament = true)
+        s3.result!!.tournamentFinalPosition = 2
+
+        val s4 = Session.testInstance(netResult = 570.0, isTournament = true)
+        s4.result!!.tournamentFinalPosition = 1
+        realm.commitTransaction()
+
+        val filterLess = QueryCondition.TournamentFinalPosition(QueryCondition.Operator.LESS, finalPosition = 1)
+        var sessions = Filter.queryOn<Session>(realm, arrayListOf(filterLess))
+
+        Assert.assertEquals(1, sessions.size)
+
+        var result = arrayListOf(s4.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+
+
+        val filterMore = QueryCondition.TournamentFinalPosition(QueryCondition.Operator.MORE, finalPosition = 10)
+        sessions = Filter.queryOn<Session>(realm, arrayListOf(filterMore))
+
+        Assert.assertEquals(1, sessions.size)
+
+        result = arrayListOf(s2.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+
+    }
 }

app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt

@@ -333,7 +333,14 @@ sealed class QueryCondition : FilterElementRow {
     class NumberOfRebuy(): ListOfDouble() {
         constructor(operator: Operator, numberOfRebuy: Double) : this() {
             this.operator = operator
-            listOfValues = arrayListOf(numberOfRebuy)
+            this.listOfValues = arrayListOf(numberOfRebuy)
+        }
+    }
+
+    open class TournamentFinalPosition(): ListOfInt() {
+        constructor(operator: Operator, finalPosition: Int) : this() {
+            this.operator = operator
+            this.listOfValues = arrayListOf(finalPosition)
         }
     }
 
@@ -341,7 +348,7 @@ sealed class QueryCondition : FilterElementRow {
     class NetAmountWon: NetAmount()
     class NetAmountLost: NetAmount() { override var sign: Int = -1 }
 
-    class NumberOfPlayer: ListOfInt()
+    class TournamentNumberOfPlayer: ListOfInt()
 
     class StartedFromDate: DateQuery() { override var operator = Operator.MORE }
     class StartedToDate: DateQuery() { override var operator = Operator.LESS }

app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt

@@ -79,7 +79,8 @@ open class Session : RealmObject(), Savable, Editable, StaticRowRepresentableDat
                 NumberOfTable::class.java -> "numberOfTable"
                 NetAmount::class.java -> "computableResults.ratedNet"
                 NumberOfRebuy::class.java -> "result.numberOfRebuy"
-                NumberOfPlayer::class.java -> "result.tournamentNumberOfPlayers"
+                TournamentNumberOfPlayer::class.java -> "result.tournamentNumberOfPlayers"
+                TournamentFinalPosition::class.java -> "result.tournamentFinalPosition"
                 TournamentFee::class.java -> "tournamentEntryFee"
                 StartedFromDate::class.java, StartedToDate::class.java -> "startDate"
                 EndedFromDate::class.java, EndedToDate::class.java -> "endDate"

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterCategoryRow.kt

@@ -61,8 +61,9 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In
 					TOURNAMENT_TYPE,
                     TOURNAMENT_NAME,
                     TOURNAMENT_FEATURE,
-                    ENTRY_FEE,
-                    NUMBER_OF_PLAYERS
+                    TOURNAMENT_ENTRY_FEE,
+                    TOURNAMENT_NUMBER_OF_PLAYER,
+                    TOURNAMENT_FINAL_POSITION
 				)
 				ONLINE -> arrayListOf(
 					MULTI_TABLING

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterSectionRow.kt

@@ -3,7 +3,6 @@ package net.pokeranalytics.android.ui.view.rowrepresentable
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.model.Criteria
 import net.pokeranalytics.android.model.filter.QueryCondition
-import net.pokeranalytics.android.model.filter.QueryCondition.NumberOfTable.*
 import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.RowViewType
 
@@ -29,10 +28,10 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 	TOURNAMENT_NAME(R.string.tournament_name),
 	TOURNAMENT_FEATURE(R.string.tournament_feature),
 	COMPLETION_PERCENTAGE(R.string.tournament_completion_percentage_interval),
-	PLACE(R.string.final_position),
-	PLAYERS_COUNT(R.string.players_count),
+	TOURNAMENT_FINAL_POSITION(R.string.final_position),
+	TOURNAMENT_NUMBER_OF_PLAYER(R.string.players_count),
 	TOURNAMENT_RE_BUY_COUNT(R.string.rebuy_count),
-	ENTRY_FEE(R.string.buyin),
+	TOURNAMENT_ENTRY_FEE(R.string.buyin),
 	MULTI_TABLING(R.string.number_of_tables),
 	VALUE(R.string.value),
 	LOCATION(R.string.locations),
@@ -94,16 +93,15 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 						// Tournament
 						TOURNAMENT_TYPE -> Criteria.TournamentTypes.queryConditions
 //						COMPLETION_PERCENTAGE ->  arrayListOf()
-						//PLACE -> QueryCondition.moreOrLess<QueryCondition.TournamentFinalPosition>()
-						PLAYERS_COUNT -> QueryCondition.moreOrLess<QueryCondition.NumberOfPlayer>()
-						ENTRY_FEE -> Criteria.TournamentFees.queryConditions
-
+						TOURNAMENT_FINAL_POSITION -> QueryCondition.moreOrLess<QueryCondition.TournamentFinalPosition>()
+						TOURNAMENT_NUMBER_OF_PLAYER -> QueryCondition.moreOrLess<QueryCondition.TournamentNumberOfPlayer>()
+						TOURNAMENT_ENTRY_FEE -> Criteria.TournamentFees.queryConditions
 						TOURNAMENT_NAME -> Criteria.TournamentNames.queryConditions
 						TOURNAMENT_FEATURE -> Criteria.TournamentFeatures.queryConditions
 						LOCATION -> Criteria.Locations.queryConditions
 						BANKROLL -> Criteria.Bankrolls.queryConditions
 						MULTI_TABLING -> QueryCondition.moreOrLess<QueryCondition.NumberOfTable>()
-						NUMBER_OF_PLAYERS -> QueryCondition.moreOrLess<QueryCondition.NumberOfPlayer>()
+						//NUMBER_OF_PLAYERS -> QueryCondition.moreOrLess<QueryCondition.TournamentNumberOfPlayer>()
                         NUMBER_OF_REBUY -> QueryCondition.moreOrLess<QueryCondition.NumberOfRebuy>()
 //						MULTI_PLAYER -> arrayListOf()