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

app/src/main/java/net/pokeranalytics/android/model/Criteria.kt

@@ -120,7 +120,7 @@ sealed class Criteria {
             val objects = arrayListOf<S>()
             values.forEach {
                 objects.add((S::class.java.newInstance()).apply {
-                    intValues.add(it)
+                    intValues = arrayListOf(it)
                 })
             }
             return objects

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

@@ -45,12 +45,16 @@ inline fun <reified T : Filterable> List<QueryCondition>.queryWith(query: RealmQ
 
 sealed class QueryCondition : FilterElementRow {
 
+    interface Valuable <T : ArrayList<T>> {
+        var values: ArrayList<T>?
+    }
+
     interface asListOfDouble { var doubleValues : ArrayList<Double> }
     interface asListOfBoolean { var booleanValues : ArrayList<Boolean> }
     interface asListOfString { var stringValues : ArrayList<String> }
     interface asDateValue {
         var dateValue: Date
-        var showTime: Boolean
+        val showTime: Boolean
     }
 
     interface asListOfInt : asListOfDouble {
@@ -61,13 +65,13 @@ sealed class QueryCondition : FilterElementRow {
 
     interface asIntValue : asListOfInt {
         var intValue: Int
-            get() { return intValues.first() }
+            get() { return intValues.firstOrNull() ?: 0 }
             set(value) { intValues = arrayListOf(value) }
     }
 
     interface asDoubleValue : asListOfDouble {
         var doubleValue : Double
-            get() { return doubleValues.first() }
+            get() { return doubleValues.firstOrNull() ?: 0.0 }
             set(value) { doubleValues = arrayListOf(value) }
     }
 
@@ -93,7 +97,15 @@ sealed class QueryCondition : FilterElementRow {
     interface BetweenLeftExclusive : Between
     interface BetweenRightExclusive : Between
 
-    val id: String get() { return this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName }
+    val baseId = this::class.simpleName ?: throw PokerAnalyticsException.FilterElementUnknownName
+
+    val id: List<String> get() {
+        return when (this) {
+            is QueryDataCondition<*> -> this.stringValues.map { "$baseId+$it" }
+            is StaticDataQueryCondition -> this.intValues.map { "$baseId+$it" }
+            else -> listOf(baseId)
+        }
+    }
 
     override var filterSectionRow: FilterSectionRow = FilterSectionRow.CASH_TOURNAMENT
 
@@ -183,7 +195,7 @@ sealed class QueryCondition : FilterElementRow {
             get() {
                 if (intValues.size > 1) {
                     return "multiple"
-                } else {
+                } else if (intValues.size > 0) {
                     return Limit.values()[intValues.first()].longName
                 }
                 return "todo"
@@ -255,11 +267,11 @@ sealed class QueryCondition : FilterElementRow {
     // Dates
     open class DateQuery: QueryCondition(), asDateValue {
         override var dateValue: Date = Date()
-        override var showTime: Boolean = false
+        override val showTime: Boolean = false
     }
 
     open class TimeQuery: DateQuery() {
-        override var showTime: Boolean = true
+        override val showTime: Boolean = true
     }
 
     class STARTED_FROM_DATE: DateQuery()

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

@@ -66,22 +66,26 @@ open class Filter : RealmObject() {
 		private set
 
 	fun createOrUpdateFilterConditions(filterConditionRows: ArrayList<QueryCondition>) {
-        val casted = arrayListOf<QueryCondition>()
+        println("list of querys saving: ${filterConditionRows.map { it.id }}")
+        println("list of querys previous: ${this.filterConditions.map { it.queryCondition.id }}")
         filterConditionRows
 			.map {
-				it.id
+				it.filterSectionRow
 			}
 			.distinct()
 			.forEach { filterName->
 				filterConditionRows
 					.filter {
-						it.id == filterName
+						it.filterSectionRow == filterName
 					}
 					.apply {
+
+                        println("list of querys: ${this.map { it.id }}")
+                        val casted = arrayListOf<QueryCondition>()
                         casted.addAll(this)
                         val newFilterCondition = FilterCondition(casted)
                         val previousCondition = filterConditions.filter {
-                            it.sectionName == newFilterCondition.filterName
+                            it.filterName == newFilterCondition.filterName
                         }
                         filterConditions.removeAll(previousCondition)
                         filterConditions.add(newFilterCondition)
@@ -90,20 +94,19 @@ open class Filter : RealmObject() {
 	}
 
 	fun countBy(filterCategoryRow: FilterCategoryRow): Int {
-		val sections = filterCategoryRow.filterSectionRows
+		val sections = filterCategoryRow.filterSectionRows.map { it.name }
-		return filterConditions.count {
+        println("list of sections $sections")
-			sections.contains(FilterSectionRow.valueOf(it.sectionName ?: throw PokerAnalyticsException.FilterElementUnknownSectionName))
+        val savedSections = filterConditions.filter { sections.contains(it.sectionName) }.flatMap { it.queryCondition.id }
-		}
+        println("list of savedSections $savedSections")
+        return savedSections.size
 	}
 
 	fun contains(filterElementRow: QueryCondition): Boolean {
-		val filtered = filterConditions.filter {
+        println("list of saved queries ${filterConditions.map { it.queryCondition.id }}")
-			it.filterName == filterElementRow.id
+        println("list of contains ${filterElementRow.id}")
-		}
+		val contained = filterConditions.flatMap{ it.queryCondition.id }.contains(filterElementRow.id.first())
-		if (filtered.isEmpty()) {
+        println("list of : $contained")
-			return false
+        return contained
-		}
-		return filterElementRow.contains(filtered)
 	}
 
 	/**
@@ -111,7 +114,7 @@ open class Filter : RealmObject() {
 	 */
     fun loadValueForElement(filterElementRow: QueryCondition) {
 		val filtered = filterConditions.filter {
-			it.filterName == filterElementRow.id
+			it.queryCondition == filterElementRow.id
 		}
 		if (filtered.isNotEmpty()) {
             return filterElementRow.updateValueMap(filtered.first())

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

@@ -13,7 +13,7 @@ open class FilterCondition() : RealmObject() {
         this.sectionName = sectionName
     }
 
-    constructor(filterElementRows: ArrayList<QueryCondition>) : this(filterElementRows.first().id, filterElementRows.first().filterSectionRow.name) {
+    constructor(filterElementRows: ArrayList<QueryCondition>) : this(filterElementRows.first().baseId, filterElementRows.first().filterSectionRow.name) {
         val row = filterElementRows.first()
         this.filterName ?: throw PokerAnalyticsException.FilterElementUnknownName
 

app/src/main/java/net/pokeranalytics/android/ui/fragment/FilterDetailsFragment.kt

@@ -220,6 +220,8 @@ open class  FilterDetailsFragment : PokerAnalyticsFragment(), StaticRowRepresent
 			}
 		}
 
+        println("list of selected rows : $selectedRows")
+
 		// Update UI
 		rowRepresentableAdapter.refreshRow(row)
 	}

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

@@ -68,8 +68,8 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 					when (this@FilterSectionRow) {
 
 						// General
-						CASH_TOURNAMENT -> arrayListOf(QueryCondition.CASH, QueryCondition.TOURNAMENT)
+						CASH_TOURNAMENT -> Criteria.SessionType.queryConditions
-						LIVE_ONLINE -> arrayListOf(QueryCondition.LIVE, QueryCondition.ONLINE)
+						LIVE_ONLINE -> Criteria.BankrollType.queryConditions
 						GAME -> Criteria.Games.queryConditions
 						LIMIT_TYPE -> Criteria.Limits.queryConditions
                         TABLE_SIZE -> Criteria.TableSizes.queryConditions
@@ -151,7 +151,7 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 						)
 
 						// Tournament
-						TOURNAMENT_TYPE -> arrayListOf()
+						TOURNAMENT_TYPE -> Criteria.TournamentTypes.queryConditions
 						COMPLETION_PERCENTAGE -> arrayListOf()
 						PLACE -> arrayListOf()
 						PLAYERS_COUNT -> arrayListOf()
@@ -159,10 +159,10 @@ enum class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 						BUY_IN -> arrayListOf()
 
 
-						TOURNAMENT_NAME -> arrayListOf()
+						TOURNAMENT_NAME -> Criteria.TournamentNames.queryConditions
-						TOURNAMENT_FEATURE -> arrayListOf()
+						TOURNAMENT_FEATURE -> Criteria.TournamentFeatures.queryConditions
-						LOCATION -> arrayListOf()
+						LOCATION -> Criteria.Locations.queryConditions
-						BANKROLL -> arrayListOf()
+						BANKROLL -> Criteria.Bankrolls.queryConditions
 						MULTI_TABLING -> arrayListOf()
 						NUMBER_OF_PLAYERS -> arrayListOf()
 						MULTI_PLAYER -> arrayListOf()