fix issue with realm sort, feed sessions & transactions sorting after adding filter

fix issue with customfield unit test
add a default name for filter & query
add countableUsage interface to filter

app/src/main/java/net/pokeranalytics/android/PokerAnalyticsApplication.kt

@@ -11,9 +11,7 @@ import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import net.pokeranalytics.android.model.migrations.Patcher
 import net.pokeranalytics.android.model.migrations.PokerAnalyticsMigration
-import net.pokeranalytics.android.model.realm.ComputableResult
 import net.pokeranalytics.android.model.realm.Session
-import net.pokeranalytics.android.model.realm.SessionSet
 import net.pokeranalytics.android.model.utils.Seed
 import net.pokeranalytics.android.util.FakeDataManager
 import net.pokeranalytics.android.util.PokerAnalyticsLogs
@@ -42,13 +40,11 @@ class PokerAnalyticsApplication : Application() {
 			.build()
 		Realm.setDefaultConfiguration(realmConfiguration)
 
-		val realm = Realm.getDefaultInstance()
+//		val realm = Realm.getDefaultInstance()
-		realm.executeTransaction {
+//		realm.executeTransaction {
-			realm.where(Session::class.java).findAll().deleteAllFromRealm()
+//			realm.where(Session::class.java).findAll().deleteAllFromRealm()
-			realm.where(ComputableResult::class.java).findAll().deleteAllFromRealm()
+//		}
-			realm.where(SessionSet::class.java).findAll().deleteAllFromRealm()
+//		realm.close()
-		}
-		realm.close()
 
 		// Set up Crashlytics, disabled for debug builds
 		val crashlyticsKit = Crashlytics.Builder()

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

@@ -4,6 +4,7 @@ import android.content.Context
 import io.realm.RealmQuery
 import io.realm.kotlin.where
 import net.pokeranalytics.android.R
+import net.pokeranalytics.android.util.NULL_TEXT
 
 fun List<Query>.mapFirstCondition() : List<QueryCondition> {
 	return this.map { it.conditions.first() }
@@ -41,6 +42,14 @@ class Query {
 		this._conditions.addAll(queryConditions)
 	}
 
+    val defaultName: String
+        get() {
+            return when (this._conditions.size) {
+                0 -> NULL_TEXT
+                else -> this._conditions.joinToString("") { it.id.joinToString("") }
+            }
+        }
+
 	fun getName(context: Context): String {
 		return when (this._conditions.size) {
 			0 -> context.getString(R.string.all_sessions) // @todo should be dependant of the underlying type, ie. Session, Transaction...

app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt

@@ -11,129 +11,132 @@ class PokerAnalyticsMigration : RealmMigration {
 
 	override fun migrate(realm: DynamicRealm, oldVersion: Long, newVersion: Long) {
 
-		// DynamicRealm exposes an editable schema
+        // DynamicRealm exposes an editable schema
-		val schema = realm.schema
+        val schema = realm.schema
-
+
-		var currentVersion = oldVersion.toInt()
+        var currentVersion = oldVersion.toInt()
-		Timber.d("*** migrate from $oldVersion to $newVersion")
+        Timber.d("*** migrate from $oldVersion to $newVersion")
-
+
-		// Migrate to version 1
+        // Migrate to version 1
-		if (currentVersion == 0) {
+        if (currentVersion == 0) {
-			Timber.d("*** Running migration 1")
+            Timber.d("*** Running migration 1")
-
+
-			schema.get("Filter")?.addField("entityType", Int::class.java)?.setNullable("entityType", true)
+            schema.get("Filter")?.addField("entityType", Int::class.java)?.setNullable("entityType", true)
-			schema.get("FilterElement")?.let {
+            schema.get("FilterElement")?.let {
-				it.setNullable("filterName", true)
+                it.setNullable("filterName", true)
-				it.setNullable("sectionName", true)
+                it.setNullable("sectionName", true)
-			}
+            }
-			schema.get("FilterElementBlind")?.renameField("code", "currencyCode")
+            schema.get("FilterElementBlind")?.renameField("code", "currencyCode")
-			currentVersion++
+            currentVersion++
-		}
+        }
-
+
-		// Migrate to version 2
+        // Migrate to version 2
-		if (currentVersion == 1) {
+        if (currentVersion == 1) {
-			Timber.d("*** Running migration ${currentVersion + 1}")
+            Timber.d("*** Running migration ${currentVersion + 1}")
-			schema.rename("FilterElement", "FilterCondition")
+            schema.rename("FilterElement", "FilterCondition")
-
+
-			schema.get("Filter")?.renameField("filterElements", "filterConditions")
+            schema.get("Filter")?.renameField("filterElements", "filterConditions")
-
+
-			schema.get("SessionSet")?.let {
+            schema.get("SessionSet")?.let {
-				it.addField("id", String::class.java).setRequired("id", true)
+                it.addField("id", String::class.java).setRequired("id", true)
-				it.addPrimaryKey("id")
+                it.addPrimaryKey("id")
-			}
+            }
-			currentVersion++
+            currentVersion++
-		}
+        }
-
+
-		// Migrate to version 3
+        // Migrate to version 3
-		if (currentVersion == 2) {
+        if (currentVersion == 2) {
-			Timber.d("*** Running migration ${currentVersion + 1}")
+            Timber.d("*** Running migration ${currentVersion + 1}")
-			schema.rename("Report", "ReportSetup")
+            schema.rename("Report", "ReportSetup")
-
+
-			schema.get("Filter")?.removeField("entityType")
+            schema.get("Filter")?.removeField("entityType")
-
+
-			schema.get("Session")?.let {
-				it.addField("blinds", String::class.java).transform {
-
-				}
-			}
-
-			schema.get("FilterCondition")?.let {
-				it.removeField("blindValues")
-				it.removeField("numericValues")
-
-				it.addField("operator", Integer::class.java)
-				it.addField("intValue", Integer::class.java)
-				it.addRealmListField("intValues", Integer::class.java)
-				it.addField("doubleValue", Double::class.java).setNullable("doubleValue", true)
-				it.addRealmListField("doubleValues", Double::class.java)
-				if (it.isRequired("doubleValues")) {
-					it.setRequired("doubleValues", false)
-				}
-				it.addField("stringValue", String::class.java)
-			}
-
-			schema.get("ComputableResult")?.removeField("sessionSet")
-
-			schema.get("Bankroll")?.addField("initialValue", Double::class.java)
-
-			currentVersion++
-		}
-
-		// Migrate to version 4
-		if (currentVersion == 3) {
-			Timber.d("*** Running migration ${currentVersion + 1}")
-
-			schema.get("Result")?.addField("numberOfRebuy", Double::class.java)?.setNullable("numberOfRebuy", true)
-			currentVersion++
-		}
-
-		// Migrate to version 5
-		if (currentVersion == 4) {
-			Timber.d("*** Running migration ${currentVersion + 1}")
-			schema.get("Bankroll")?.removeField("transactions")
-			currentVersion++
-		}
-
-		// Migrate to version 6
-		if (currentVersion == 5) {
-			Timber.d("*** Running migration ${currentVersion + 1}")
-			schema.get("Transaction")?.let {
-				it.addField("dayOfWeek", Integer::class.java)
-				it.addField("month", Integer::class.java)
-				it.addField("year", Integer::class.java)
-				it.addField("dayOfMonth", Integer::class.java)
-			}
-			schema.create("CustomFieldEntry")?.let {
-				it.addField("id", String::class.java).setRequired("id", true)
-				it.addField("value", String::class.java).setNullable("value", false)
-				it.addField("order", Integer::class.java).setNullable("order", false)
-				it.addField("customField", CustomField::class.java).setNullable("customField", false)
-			}
-			schema.get("CustomField")?.let {
-				it.addField("type", Integer::class.java).setNullable("type", false)
-				it.addField("duplicateValue", Boolean::class.java)
-				it.addField("sortCondition", Integer::class.java)
-				it.addRealmListField("entries", CustomFieldEntry::class.java)
-			}
-			schema.get("ReportSetup")?.let {
-				it.addRealmListField("statIds", Int::class.java)
-				it.addRealmListField("criteriaIds", Int::class.java)
-				it.removeField("filters")
-				schema.get("Filter")?.let { filterSchema ->
-					it.addRealmObjectField("filter", filterSchema)
-				}
-			}
             schema.get("Session")?.let {
-                it.addField("startDateHourMinuteComponent", Double::class.java).setNullable("startDateHourMinuteComponent", true)
+                it.addField("blinds", String::class.java).transform {
-                it.addField("endDateHourMinuteComponent", Double::class.java).setNullable("endDateHourMinuteComponent", true)
+
-	            it.addRealmListField("customFieldEntries", CustomFieldEntry::class.java)
+                }
             }
 
-            schema.get("Filter")?.addField("filterableTypeOrdinal", Integer::class.java)
+            schema.get("FilterCondition")?.let {
+                it.removeField("blindValues")
+                it.removeField("numericValues")
+
+                it.addField("operator", Integer::class.java)
+                it.addField("intValue", Integer::class.java)
+                it.addRealmListField("intValues", Integer::class.java)
+                it.addField("doubleValue", Double::class.java).setNullable("doubleValue", true)
+                it.addRealmListField("doubleValues", Double::class.java)
+                if (it.isRequired("doubleValues")) {
+                    it.setRequired("doubleValues", false)
+                }
+                it.addField("stringValue", String::class.java)
+            }
+
+            schema.get("ComputableResult")?.removeField("sessionSet")
+
+            schema.get("Bankroll")?.addField("initialValue", Double::class.java)
 
             currentVersion++
-		}
+        }
-	}
+
+        // Migrate to version 4
+        if (currentVersion == 3) {
+            Timber.d("*** Running migration ${currentVersion + 1}")
+
+            schema.get("Result")?.addField("numberOfRebuy", Double::class.java)?.setNullable("numberOfRebuy", true)
+            currentVersion++
+        }
+
+        // Migrate to version 5
+        if (currentVersion == 4) {
+            Timber.d("*** Running migration ${currentVersion + 1}")
+            schema.get("Bankroll")?.removeField("transactions")
+            currentVersion++
+        }
+
+        // Migrate to version 6
+        if (currentVersion == 5) {
+            Timber.d("*** Running migration ${currentVersion + 1}")
+            schema.get("Transaction")?.let {
+                it.addField("dayOfWeek", Integer::class.java)
+                it.addField("month", Integer::class.java)
+                it.addField("year", Integer::class.java)
+                it.addField("dayOfMonth", Integer::class.java)
+            }
+            schema.create("CustomFieldEntry")?.let {
+                it.addField("id", String::class.java).setRequired("id", true)
+                it.addField("value", String::class.java).setNullable("value", false)
+                it.addField("order", Integer::class.java).setNullable("order", false)
+                it.addField("customField", CustomField::class.java).setNullable("customField", false)
+            }
+            schema.get("CustomField")?.let {
+                it.addField("type", Integer::class.java).setNullable("type", false)
+                it.addField("duplicateValue", Boolean::class.java)
+                it.addField("sortCondition", Integer::class.java)
+                it.addRealmListField("entries", CustomFieldEntry::class.java)
+            }
+            schema.get("ReportSetup")?.let {
+                it.addRealmListField("statIds", Int::class.java)
+                it.addRealmListField("criteriaIds", Int::class.java)
+                it.removeField("filters")
+                schema.get("Filter")?.let { filterSchema ->
+                    it.addRealmObjectField("filter", filterSchema)
+                }
+            }
+            schema.get("Session")?.let {
+                it.addField("startDateHourMinuteComponent", Double::class.java)
+                    .setNullable("startDateHourMinuteComponent", true)
+                it.addField("endDateHourMinuteComponent", Double::class.java)
+                    .setNullable("endDateHourMinuteComponent", true)
+                it.addRealmListField("customFieldEntries", CustomFieldEntry::class.java)
+            }
+
+            schema.get("Filter")?.addField("filterableTypeOrdinal", Integer::class.java)
+            schema.get("Filter")?.addField("useCount", Int::class.java)
+            schema.get("Filter")?.removeField("usageCount")
+            currentVersion++
+        }
+    }
 
 	override fun equals(other: Any?): Boolean {
 		return other is RealmMigration

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

@@ -8,15 +8,14 @@ import net.pokeranalytics.android.R
 import net.pokeranalytics.android.model.filter.Filterable
 import net.pokeranalytics.android.model.filter.Query
 import net.pokeranalytics.android.model.filter.QueryCondition
+import net.pokeranalytics.android.model.interfaces.CountableUsage
 import net.pokeranalytics.android.model.interfaces.Deletable
 import net.pokeranalytics.android.model.interfaces.DeleteValidityStatus
 import net.pokeranalytics.android.model.interfaces.Identifiable
 import net.pokeranalytics.android.ui.interfaces.FilterableType
 import net.pokeranalytics.android.ui.view.ImageDecorator
 import net.pokeranalytics.android.ui.view.RowRepresentable
-import net.pokeranalytics.android.ui.view.RowViewType
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
-import net.pokeranalytics.android.util.Preferences
 import java.util.*
 
 /**
@@ -24,14 +23,14 @@ import java.util.*
  * It contains a list of [FilterCondition] describing the complete query to launch
  * The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on
  */
-open class Filter : RealmObject(), RowRepresentable, Identifiable, Deletable, ImageDecorator {
+open class Filter : RealmObject(), RowRepresentable, Identifiable, Deletable, CountableUsage, ImageDecorator {
 
 	companion object {
 
 		// Create a new instance
-		fun newInstance(realm: Realm, filterableType: Int): Filter {
+		fun newInstance(realm: Realm, filterableType:Int): Filter {
 			val filter = Filter()
-			filter.filterableTypeOrdinal = filterableType
+            filter.filterableTypeOrdinal = filterableType
 			return filter
 			//return realm.copyToRealm(filter)
 		}
@@ -41,26 +40,32 @@ open class Filter : RealmObject(), RowRepresentable, Identifiable, Deletable, Im
 			return realm.where<Filter>().equalTo("id", filterId).findFirst()
 		}
 
-		inline fun <reified T : Filterable> queryOn(realm: Realm, query: Query, sortField: String? = null): RealmResults<T> {
+	    inline fun <reified T : Filterable> queryOn(realm: Realm, query: Query, sortField: String? = null): RealmResults<T> {
-			val realmQuery = realm.where<T>()
+		    val realmQuery = realm.where<T>()
-			sortField?.let {
+		    sortField?.let {
-				return query.queryWith(realmQuery).sort(it).findAll()
+                return query.queryWith(realmQuery).sort(it).findAll()
-			} ?: run {
+		    } ?: run {
-				return query.queryWith(realmQuery).findAll()
+                return query.queryWith(realmQuery).findAll()
-			}
+            }
-		}
+	    }
 
 		fun sortedByUsage(realm: Realm): RealmResults<Filter> {
 			return realm.where(Filter::class.java).findAll().sort("usageCount")
 		}
 
-	}
+    }
 
 	@PrimaryKey
-	override var id = UUID.randomUUID().toString()
+    override var id = UUID.randomUUID().toString()
 
 	// the queryWith name
 	var name: String = ""
+        get() {
+            if (field.isEmpty()) {
+                return this.query.defaultName
+            }
+            return field
+        }
 
 	// the number of use of the queryWith,
 	// for MutableRealmInteger, see https://realm.io/docs/java/latest/#counters
@@ -69,121 +74,112 @@ open class Filter : RealmObject(), RowRepresentable, Identifiable, Deletable, Im
 	var filterConditions: RealmList<FilterCondition> = RealmList()
 		private set
 
-	private var filterableTypeOrdinal: Int? = null
+    private var filterableTypeOrdinal: Int? = null
-
+
-	override val viewType: Int
+    val filterableType: FilterableType
-		get() = RowViewType.TITLE_VALUE_ACTION.ordinal
+        get() {
-	override val imageRes: Int?
+            this.filterableTypeOrdinal?.let {
-		get() = R.drawable.ic_outline_settings
+                return FilterableType.values()[it]
-	override val imageTint: Int?
+            }
-		get() = R.color.green
+            return FilterableType.ALL
-	override val imageClickable: Boolean?
+        }
-		get() = true
-
-	val filterableType: FilterableType
-		get() {
-			this.filterableTypeOrdinal?.let {
-				return FilterableType.values()[it]
-			}
-			return FilterableType.ALL
-		}
 
 	fun createOrUpdateFilterConditions(filterConditionRows: ArrayList<QueryCondition>) {
-		println("list of querys saving: ${filterConditionRows.map { it.id }}")
+        println("list of querys saving: ${filterConditionRows.map { it.id }}")
-		println("list of querys previous: ${this.filterConditions.map { it.queryCondition.id }}")
+        println("list of querys previous: ${this.filterConditions.map { it.queryCondition.id }}")
-		filterConditionRows
+        filterConditionRows
 			.map {
 				it.groupId
 			}
 			.distinct()
-			.forEach { groupId ->
+			.forEach { groupId->
 				filterConditionRows
 					.filter {
 						it.groupId == groupId
 					}
 					.apply {
 
-						println("list of querys: ${this.map { it.id }}")
+                        println("list of querys: ${this.map { it.id }}")
-						val casted = arrayListOf<QueryCondition>()
+                        val casted = arrayListOf<QueryCondition>()
-						casted.addAll(this)
+                        casted.addAll(this)
-						val newFilterCondition = FilterCondition(casted)
+                        val newFilterCondition = FilterCondition(casted)
-						val previousCondition = filterConditions.filter {
+                        val previousCondition = filterConditions.filter {
-							it.filterName == newFilterCondition.filterName && it.operator == newFilterCondition.operator
+                            it.filterName == newFilterCondition.filterName && it.operator == newFilterCondition.operator
-						}
+                        }
-						filterConditions.removeAll(previousCondition)
+                        filterConditions.removeAll(previousCondition)
-						filterConditions.add(newFilterCondition)
+                        filterConditions.add(newFilterCondition)
-					}
+                    }
 			}
 	}
 
-	fun remove(filterCategoryRow: FilterCategoryRow) {
+    fun remove(filterCategoryRow: FilterCategoryRow) {
-		val sections = filterCategoryRow.filterSectionRows.map { it.name }
+        val sections = filterCategoryRow.filterSectionRows.map { it.name }
-		val savedSections = filterConditions.filter { sections.contains(it.sectionName) }
+        val savedSections = filterConditions.filter { sections.contains(it.sectionName) }
-		this.filterConditions.removeAll(savedSections)
+        this.filterConditions.removeAll(savedSections)
-	}
+    }
 
 	fun countBy(filterCategoryRow: FilterCategoryRow): Int {
 		val sections = filterCategoryRow.filterSectionRows.map { it.name }
-		println("list of sections $sections")
+        println("list of sections $sections")
-		val savedSections = filterConditions.filter { sections.contains(it.sectionName) }.flatMap { it.queryCondition.id }
+        val savedSections = filterConditions.filter { sections.contains(it.sectionName) }.flatMap { it.queryCondition.id }
-		println("list of savedSections $savedSections")
+        println("list of savedSections $savedSections")
-		return savedSections.size
+        return savedSections.size
 	}
 
 	fun contains(filterElementRow: QueryCondition): Boolean {
-		println("list of saved queries ${filterConditions.map { it.queryCondition.id }}")
+        println("list of saved queries ${filterConditions.map { it.queryCondition.id }}")
-		println("list of contains ${filterElementRow.id}")
+        println("list of contains ${filterElementRow.id}")
-		val contained = filterConditions.flatMap { it.queryCondition.id }.contains(filterElementRow.id.first())
+		val contained = filterConditions.flatMap{ it.queryCondition.id }.contains(filterElementRow.id.first())
-		println("list of : $contained")
+        println("list of : $contained")
-		return contained
+        return contained
 	}
 
 	/**
 	 * Get the saved value for the given [filterElementRow]
 	 */
-	fun loadValueForElement(filterElementRow: QueryCondition) {
+    fun loadValueForElement(filterElementRow: QueryCondition) {
 		val filtered = filterConditions.filter {
 			it.queryCondition.id == filterElementRow.id
 		}
 		if (filtered.isNotEmpty()) {
-			return filterElementRow.updateValueBy(filtered.first())
+            return filterElementRow.updateValueBy(filtered.first())
 		}
 	}
 
 	inline fun <reified T : Filterable> results(firstField: String? = null, secondField: String? = null): RealmResults<T> {
 
-		val realmQuery = realm.where<T>()
+        val realmQuery = realm.where<T>()
 
-		if (firstField != null && secondField != null) {
+        if (firstField != null && secondField != null) {
-			return this.query.queryWith(realmQuery).distinct(firstField, secondField).findAll()
+            return this.query.queryWith(realmQuery).distinct(firstField, secondField).findAll()
-		}
+        }
 
-		if (firstField != null) {
+        if (firstField != null) {
-			return this.query.queryWith(realmQuery).distinct(firstField).findAll()
+            return this.query.queryWith(realmQuery).distinct(firstField).findAll()
-		}
+        }
 
-		return this.query.queryWith(realmQuery).findAll()
+        return this.query.queryWith(realmQuery).findAll()
-	}
+    }
 
-	val query: Query
+    val query: Query
-		get() {
+        get() {
-			val query = Query()
+            val query = Query()
-			this.filterConditions.forEach {
+            this.filterConditions.forEach {
-				query.add(it.queryCondition)
+                query.add(it.queryCondition)
-			}
+            }
-			return query
+            return query
-		}
+        }
 
-	override fun getDisplayName(context: Context): String {
+    override fun getDisplayName(context: Context): String {
-		if (name.isNotEmpty()) return name
+        if (name.isNotEmpty()) return name
-		return this.query.getName(context)
+        return this.query.getName(context)
-	}
+    }
 
-	override fun isValidForDelete(context: Context, realm: Realm): Boolean {
+	override fun isValidForDelete(realm: Realm): Boolean {
-		return id != Preferences.getActiveFilterId(context)
+		return true
 	}
 
 	override fun getFailedDeleteMessage(status: DeleteValidityStatus): Int {
-		return R.string.filter_currently_selected
+		return R.string.relationship_error
 	}
 }

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

@@ -6,7 +6,6 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import androidx.core.view.isVisible
 import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.LinearLayoutManager
 import io.realm.RealmResults
@@ -103,21 +102,18 @@ class DataListFragment : DeletableItemFragment(), LiveRowRepresentableDataSource
 		return if (viewType != -1) viewType else RowViewType.DATA.ordinal
 	}
 
+	override fun indexForRow(row: RowRepresentable): Int {
+		return this.items.indexOf(row as Identifiable)
+	}
+
 	override fun onRowSelected(position: Int, row: RowRepresentable, fromAction: Boolean) {
 
 		when (this.dataType) {
 			LiveData.FILTER -> {
-				if (fromAction) {
+				val intent = Intent()
-					// Open filter params
+				intent.putExtra(FiltersActivity.IntentKey.FILTER_ID.keyName, (row as Filter).id)
-					val filter = row as Filter
+				activity?.setResult(Activity.RESULT_OK, intent)
-					FiltersActivity.newInstanceForResult(fragment = this, filterId = filter.id, currentFilterable = filter.filterableType)
+				activity?.finish()
-				} else {
-					// Select filter
-					val intent = Intent()
-					intent.putExtra(FiltersActivity.IntentKey.FILTER_ID.keyName, (row as Filter).id)
-					activity?.setResult(Activity.RESULT_OK, intent)
-					activity?.finish()
-				}
 			}
 			else -> {
 				val identifier = (row as Identifiable).id

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

@@ -195,14 +195,16 @@ class FeedFragment : FilterableFragment(), RowRepresentableDelegate {
         }
 
         // Sessions
-        this.realmSessions = sessionFilter?.results() ?: run { getRealm().where<Session>().findAll() }.sort("startDate", Sort.DESCENDING)
+        this.realmSessions = sessionFilter?.results() ?: run { getRealm().where<Session>().findAll() }
+        this.realmSessions = this.realmSessions.sort("startDate", Sort.DESCENDING)
         this.realmSessions.addChangeListener { _, _ ->
             this.feedSessionAdapter.refreshData()
             this.feedSessionAdapter.notifyDataSetChanged()
         }
 
         val pendingSessions = sessionFilter?.let {  getRealm().where<Session>().alwaysFalse().findAll() } ?: run { getRealm().where<Session>().isNull("year").isNull("month").findAll().sort("startDate", Sort.DESCENDING) }
-        val distinctDateSessions = sessionFilter?.results("year", "month") ?: run { getRealm().where<Session>().distinct("year", "month").findAll() }.sort("startDate", Sort.DESCENDING)
+        var distinctDateSessions = sessionFilter?.results("year", "month") ?: run { getRealm().where<Session>().distinct("year", "month").findAll() }
+        distinctDateSessions = distinctDateSessions.sort("startDate", Sort.DESCENDING)
         this.feedSessionAdapter = FeedSessionRowRepresentableAdapter(this, realmSessions, pendingSessions, distinctDateSessions)
     }
 
@@ -216,13 +218,15 @@ class FeedFragment : FilterableFragment(), RowRepresentableDelegate {
         }
 
         // Transactions
-        this.realmTransactions = transactionFilter?.results() ?: run { getRealm().where<Transaction>().findAll()}.sort("date", Sort.DESCENDING)
+        this.realmTransactions = transactionFilter?.results() ?: run { getRealm().where<Transaction>().findAll()}
+        this.realmTransactions = this.realmTransactions.sort("date", Sort.DESCENDING)
         this.realmTransactions.addChangeListener { _, _ ->
             this.feedTransactionAdapter.refreshData()
             this.feedTransactionAdapter.notifyDataSetChanged()
         }
 
-        val distinctDateTransactions = transactionFilter?.results("year", "month") ?: run { getRealm().where<Transaction>().distinct("year", "month").findAll() }.sort("date", Sort.DESCENDING)
+        var distinctDateTransactions = transactionFilter?.results("year", "month") ?: run { getRealm().where<Transaction>().distinct("year", "month").findAll() }
+        distinctDateTransactions = distinctDateTransactions.sort("date", Sort.DESCENDING)
         this.feedTransactionAdapter = FeedTransactionRowRepresentableAdapter(this, realmTransactions, distinctDateTransactions)
 
     }

app/src/main/java/net/pokeranalytics/android/ui/interfaces/FilterHandler.kt

@@ -36,6 +36,18 @@ interface FilterHandler {
     fun saveFilter(context: Context, filterId:String) {
         Preferences.setActiveFilterId(filterId, context)
 
+
+        println("<<<< save filter")
+        val realm = Realm.getDefaultInstance()
+        realm.beginTransaction()
+        currentFilter(context, realm)?.let {
+            println("<<<< old ${it.useCount}")
+            it.useCount++
+            println("<<<< new ${it.useCount}")
+        }
+        realm.commitTransaction()
+        realm.close()
+
         // Send broadcast
         val intent = Intent()
         intent.action = INTENT_FILTER_UPDATE_FILTER_UI

app/src/main/java/net/pokeranalytics/android/util/extensions/RealmExtensions.kt

@@ -7,6 +7,7 @@ import io.realm.Sort
 import io.realm.kotlin.where
 import net.pokeranalytics.android.model.interfaces.CountableUsage
 import net.pokeranalytics.android.model.interfaces.NameManageable
+import net.pokeranalytics.android.model.realm.Filter
 import net.pokeranalytics.android.model.realm.Session
 import net.pokeranalytics.android.model.realm.TournamentFeature
 import net.pokeranalytics.android.model.realm.Transaction
@@ -29,24 +30,30 @@ inline fun <reified T: NameManageable> Realm.getOrCreate(name: String) : T {
 /**
  * Returns all entities of the [clazz] sorted with their default sorting
  */
-fun <T : RealmModel> Realm.sorted(clazz: Class<T>) : RealmResults<T> {
+fun < T : RealmModel> Realm.sorted(clazz: Class<T>) : RealmResults<T> {
+    val items = this.where(clazz).findAll()
+    var sortField = arrayOf("name")
+    var resultSort = arrayOf(Sort.ASCENDING)
 
-	if (clazz is CountableUsage) {
+    when (items.firstOrNull()) {
-		this.updateUsageCount(clazz)
+        is Transaction -> {
-	}
+            println("<<<< is transaction")
-
+            sortField = arrayOf("date")
-	val sortField = when (clazz) {
+            resultSort = arrayOf(Sort.DESCENDING)
-		is CountableUsage -> "useCount"
+        }
-		is Transaction -> "date"
+        is Filter -> {
-		else -> "name"
+            println("<<<< is filter")
-	}
+            sortField = arrayOf("useCount", "name")
-	val resultSort = when (clazz) {
+            resultSort = arrayOf(Sort.DESCENDING, Sort.ASCENDING)
-		is CountableUsage -> Sort.DESCENDING
+        }
-		is Transaction -> Sort.DESCENDING
+        is CountableUsage -> {
-		else -> Sort.ASCENDING
+            println("<<<< is countable")
-	}
+            this.updateUsageCount(clazz)
-
+            sortField = arrayOf("useCount")
-	return this.where(clazz).findAll().sort(sortField, resultSort)
+            resultSort = arrayOf(Sort.DESCENDING)
+        }
+    }
+    return items.sort(sortField, resultSort)
 }
 
 /**