add categories as predefined filters

Author: Razeeman

core/src/main/java/com/example/util/simpletimetracker/core/interactor/ActivityFilterViewDataInteractor.kt

@@ -2,24 +2,29 @@ package com.example.util.simpletimetracker.core.interactor
 
 import com.example.util.simpletimetracker.core.mapper.ActivityFilterViewDataMapper
 import com.example.util.simpletimetracker.domain.activityFilter.interactor.ActivityFilterInteractor
-import com.example.util.simpletimetracker.domain.prefs.interactor.PrefsInteractor
-import com.example.util.simpletimetracker.domain.category.interactor.RecordTypeCategoryInteractor
+import com.example.util.simpletimetracker.domain.activityFilter.interactor.PredefinedFilterInteractor
 import com.example.util.simpletimetracker.domain.activityFilter.model.ActivityFilter
+import com.example.util.simpletimetracker.domain.activityFilter.model.PredefinedFilter
+import com.example.util.simpletimetracker.domain.category.interactor.RecordTypeCategoryInteractor
+import com.example.util.simpletimetracker.domain.prefs.interactor.PrefsInteractor
 import com.example.util.simpletimetracker.domain.recordType.model.RecordType
 import com.example.util.simpletimetracker.feature_base_adapter.ViewHolderType
 import javax.inject.Inject
 
 class ActivityFilterViewDataInteractor @Inject constructor(
     private val prefsInteractor: PrefsInteractor,
     private val activityFilterInteractor: ActivityFilterInteractor,
+    private val predefinedFilterInteractor: PredefinedFilterInteractor,
     private val recordTypeCategoryInteractor: RecordTypeCategoryInteractor,
     private val activityFilterViewDataMapper: ActivityFilterViewDataMapper,
 ) {
 
     suspend fun getFilter(): Filter {
         return if (prefsInteractor.getShowActivityFilters()) {
-            val activityFilters = activityFilterInteractor.getAll()
-            Filter.ApplyFilter(activityFilters)
+            Filter.ApplyFilter(
+                userFilters = activityFilterInteractor.getAll(),
+                predefinedFilters = predefinedFilterInteractor.getAll(),
+            )
         } else {
             Filter.NoFilter
         }
@@ -36,18 +41,28 @@ class ActivityFilterViewDataInteractor @Inject constructor(
                 emptyList()
             }
             is Filter.ApplyFilter -> {
+                val filtersSize = filter.userFilters.size + filter.predefinedFilters.size
+
                 val result = mutableListOf<ViewHolderType>()
                 if (!isFiltersCollapsed) {
-                    result += filter.activityFilters.map {
-                        activityFilterViewDataMapper.map(
+                    result += filter.predefinedFilters.map {
+                        activityFilterViewDataMapper.mapFiltered(
                             filter = it,
                             isDarkTheme = isDarkTheme,
+                            selected = it.selected,
+                        )
+                    }
+                    result += filter.userFilters.map {
+                        activityFilterViewDataMapper.mapFiltered(
+                            filter = it,
+                            isDarkTheme = isDarkTheme,
+                            selected = it.selected,
                         )
                     }
                 }
                 // Show collapse button if there are several filters,
                 // or if they are collapsed, just in case (collapse and then remove all but one).
-                if (filter.activityFilters.size > 1 || isFiltersCollapsed) {
+                if (filtersSize > 1 || isFiltersCollapsed) {
                     result += activityFilterViewDataMapper.mapToActivityFilterToggleItem(
                         isFiltersCollapsed = isFiltersCollapsed,
                         isDarkTheme = isDarkTheme,
@@ -67,18 +82,30 @@ class ActivityFilterViewDataInteractor @Inject constructor(
         list: List<RecordType>,
         filter: Filter,
     ): List<RecordType> {
-        return if (filter is Filter.ApplyFilter && filter.activityFilters.any { it.selected }) {
-            val selectedTypes = getSelectedTypeIds(filter.activityFilters)
+        if (filter !is Filter.ApplyFilter) return list
+
+        val hasAnySelectedFilters = filter.userFilters.any { it.selected } ||
+            filter.predefinedFilters.any { it.selected }
+
+        return if (hasAnySelectedFilters) {
+            val selectedTypes = getSelectedTypeIds(filter)
             list.filter { it.id in selectedTypes }
         } else {
             list
         }
     }
 
-    private suspend fun getSelectedTypeIds(filters: List<ActivityFilter>): List<Long> {
-        val selectedFilters = filters.filter { it.selected }
+    private suspend fun getSelectedTypeIds(
+        filter: Filter.ApplyFilter,
+    ): List<Long> {
+        val selectedFilters = filter.userFilters.filter { it.selected }
+        val predefinedSelectedFilters = filter.predefinedFilters.filter { it.selected }
 
-        if (selectedFilters.isEmpty()) return emptyList()
+        if (selectedFilters.isEmpty() &&
+            predefinedSelectedFilters.isEmpty()
+        ) {
+            return emptyList()
+        }
 
         val activityIds: List<Long> = selectedFilters
             .filter { it.type is ActivityFilter.Type.Activity }
@@ -90,25 +117,32 @@ class ActivityFilterViewDataInteractor @Inject constructor(
             .map { it.selectedIds }
             .flatten()
             .takeUnless { it.isEmpty() }
-            ?.let { tagIds ->
-                val recordTypeCategories = recordTypeCategoryInteractor.getAll()
-                    .groupBy { it.categoryId }
-                    .mapValues { (_, value) -> value.map { it.recordTypeId } }
-                tagIds.mapNotNull { tagId -> recordTypeCategories[tagId] }.flatten()
-            }
+            ?.let { getTypeIdsFromCategories(it) }
             .orEmpty()
 
-        return when {
-            fromCategoryIds.isEmpty() -> activityIds
-            activityIds.isEmpty() -> fromCategoryIds
-            else -> activityIds + fromCategoryIds
-        }
+        val fromPredefinedFilters: List<Long> = predefinedSelectedFilters
+            .map { it.categoryId }
+            .takeUnless { it.isEmpty() }
+            ?.let { getTypeIdsFromCategories(it) }
+            .orEmpty()
+
+        return (activityIds + fromCategoryIds + fromPredefinedFilters).distinct()
+    }
+
+    private suspend fun getTypeIdsFromCategories(
+        tagIds: List<Long>,
+    ): List<Long> {
+        val recordTypeCategories = recordTypeCategoryInteractor.getAll()
+            .groupBy { it.categoryId }
+            .mapValues { (_, value) -> value.map { it.recordTypeId } }
+        return tagIds.mapNotNull { tagId -> recordTypeCategories[tagId] }.flatten()
     }
 
     sealed interface Filter {
-        object NoFilter : Filter
+        data object NoFilter : Filter
         data class ApplyFilter(
-            val activityFilters: List<ActivityFilter>,
+            val userFilters: List<ActivityFilter>,
+            val predefinedFilters: List<PredefinedFilter>,
         ) : Filter
     }
 }

core/src/main/java/com/example/util/simpletimetracker/core/mapper/ActivityFilterViewDataMapper.kt

@@ -3,6 +3,9 @@ package com.example.util.simpletimetracker.core.mapper
 import com.example.util.simpletimetracker.core.R
 import com.example.util.simpletimetracker.core.repo.ResourceRepo
 import com.example.util.simpletimetracker.domain.activityFilter.model.ActivityFilter
+import com.example.util.simpletimetracker.domain.activityFilter.model.ActivityFilterType
+import com.example.util.simpletimetracker.domain.activityFilter.model.PredefinedFilter
+import com.example.util.simpletimetracker.domain.color.model.AppColor
 import com.example.util.simpletimetracker.feature_base_adapter.activityFilter.ActivityFilterAddViewData
 import com.example.util.simpletimetracker.feature_base_adapter.activityFilter.ActivityFilterViewData
 import javax.inject.Inject
@@ -12,36 +15,47 @@ class ActivityFilterViewDataMapper @Inject constructor(
     private val resourceRepo: ResourceRepo,
 ) {
 
-    fun map(
+    fun mapFiltered(
         filter: ActivityFilter,
         isDarkTheme: Boolean,
+        selected: Boolean,
     ): ActivityFilterViewData {
-        return mapFiltered(
-            filter = filter,
-            isDarkTheme = isDarkTheme,
-            selected = filter.selected,
+        return ActivityFilterViewData(
+            id = filter.id,
+            name = filter.name,
+            iconColor = mapFilterIconColor(
+                selected = selected,
+                isDarkTheme = isDarkTheme,
+            ),
+            color = mapFilterColor(
+                selected = selected,
+                color = filter.color,
+                isDarkTheme = isDarkTheme,
+            ),
+            selected = selected,
+            type = ActivityFilterType.Default,
         )
     }
 
     fun mapFiltered(
-        filter: ActivityFilter,
+        filter: PredefinedFilter,
         isDarkTheme: Boolean,
         selected: Boolean,
     ): ActivityFilterViewData {
         return ActivityFilterViewData(
-            id = filter.id,
+            id = filter.categoryId,
             name = filter.name,
-            iconColor = if (selected) {
-                colorMapper.toIconColor(isDarkTheme)
-            } else {
-                colorMapper.toFilteredIconColor(isDarkTheme)
-            },
-            color = if (selected) {
-                colorMapper.mapToColorInt(filter.color, isDarkTheme)
-            } else {
-                colorMapper.toFilteredColor(isDarkTheme)
-            },
+            iconColor = mapFilterIconColor(
+                selected = selected,
+                isDarkTheme = isDarkTheme,
+            ),
+            color = mapFilterColor(
+                selected = selected,
+                color = filter.color,
+                isDarkTheme = isDarkTheme,
+            ),
             selected = selected,
+            type = ActivityFilterType.Predefined,
         )
     }
 
@@ -70,4 +84,27 @@ class ActivityFilterViewDataMapper @Inject constructor(
             color = colorMapper.toInactiveColor(isDarkTheme),
         )
     }
+
+    private fun mapFilterIconColor(
+        selected: Boolean,
+        isDarkTheme: Boolean,
+    ): Int {
+        return if (selected) {
+            colorMapper.toIconColor(isDarkTheme)
+        } else {
+            colorMapper.toFilteredIconColor(isDarkTheme)
+        }
+    }
+
+    private fun mapFilterColor(
+        selected: Boolean,
+        color: AppColor,
+        isDarkTheme: Boolean,
+    ): Int {
+        return if (selected) {
+            colorMapper.mapToColorInt(color, isDarkTheme)
+        } else {
+            colorMapper.toFilteredColor(isDarkTheme)
+        }
+    }
 }

data_local/src/main/java/com/example/util/simpletimetracker/data_local/backup/BackupPrefsRepo.kt

@@ -55,8 +55,10 @@ import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Compani
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_REPEAT_BUTTON_TYPE
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_RETROACTIVE_TRACKING_MODE
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_REVERSE_ORDER_IN_CALENDAR
+import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_SELECTED_PREDEFINED_FILTERS
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_SHOW_ACTIVITY_FILTERS
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_SHOW_CALENDAR_BUTTON_ON_RECORDS_TAB
+import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_SHOW_CATEGORIES_AS_PREDEFINED_FILTERS
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_SHOW_COMMENT_INPUT
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_SHOW_COMMENT_INPUT_EXCLUDE_ACTIVITIES
 import com.example.util.simpletimetracker.data_local.prefs.PrefsRepoImpl.Companion.KEY_SHOW_GOALS_SEPARATELY
@@ -183,13 +185,15 @@ class BackupPrefsRepo @Inject constructor(
             PrefsProcessor(KEY_DAYS_IN_CALENDAR, ::daysInCalendar),
             PrefsProcessor(KEY_SHOW_ACTIVITY_FILTERS, ::showActivityFilters),
             PrefsProcessor(KEY_IS_ACTIVITY_FILTERS_COLLAPSED, ::isActivityFiltersCollapsed),
+            PrefsProcessor(KEY_ALLOW_MULTIPLE_ACTIVITY_FILTERS, ::allowMultipleActivityFilters),
+            PrefsProcessor(KEY_SHOW_CATEGORIES_AS_PREDEFINED_FILTERS, ::showCategoriesAsPredefinedFilters),
+            PrefsProcessor(KEY_SELECTED_PREDEFINED_FILTERS, ::selectedPredefinedFilters),
             PrefsProcessor(KEY_ENABLE_REPEAT_BUTTON, ::enableRepeatButton),
             PrefsProcessor(KEY_ENABLE_POMODORO_MODE, ::enablePomodoroMode),
             PrefsProcessor(KEY_POMODORO_FOCUS_TIME, ::pomodoroFocusTime),
             PrefsProcessor(KEY_POMODORO_BREAK_TIME, ::pomodoroBreakTime),
             PrefsProcessor(KEY_POMODORO_LONG_BREAK_TIME, ::pomodoroLongBreakTime),
             PrefsProcessor(KEY_POMODORO_PERIODS_UNTIL_LONG_BREAK, ::pomodoroPeriodsUntilLongBreak),
-            PrefsProcessor(KEY_ALLOW_MULTIPLE_ACTIVITY_FILTERS, ::allowMultipleActivityFilters),
             PrefsProcessor(KEY_SHOW_GOALS_SEPARATELY, ::showGoalsSeparately),
             PrefsProcessor(KEY_ALLOW_MULTITASKING, ::allowMultitasking),
             PrefsProcessor(KEY_SHOW_NOTIFICATIONS, ::showNotifications),

data_local/src/main/java/com/example/util/simpletimetracker/data_local/prefs/PrefsRepoImpl.kt

@@ -189,6 +189,18 @@ class PrefsRepoImpl @Inject constructor(
         KEY_IS_ACTIVITY_FILTERS_COLLAPSED, false,
     )
 
+    override var allowMultipleActivityFilters: Boolean by prefs.delegate(
+        KEY_ALLOW_MULTIPLE_ACTIVITY_FILTERS, true,
+    )
+
+    override var showCategoriesAsPredefinedFilters: Boolean by prefs.delegate(
+        KEY_SHOW_CATEGORIES_AS_PREDEFINED_FILTERS, false
+    )
+
+    override var selectedPredefinedFilters: Set<String> by prefs.delegate(
+        KEY_SELECTED_PREDEFINED_FILTERS, emptySet()
+    )
+
     override var enableRepeatButton: Boolean by prefs.delegate(
         KEY_ENABLE_REPEAT_BUTTON, false,
     )
@@ -217,10 +229,6 @@ class PrefsRepoImpl @Inject constructor(
         KEY_POMODORO_PERIODS_UNTIL_LONG_BREAK, POMODORO_DEFAULT_UNTIL_LONG_BREAK,
     )
 
-    override var allowMultipleActivityFilters: Boolean by prefs.delegate(
-        KEY_ALLOW_MULTIPLE_ACTIVITY_FILTERS, true,
-    )
-
     override var showGoalsSeparately: Boolean by prefs.delegate(
         KEY_SHOW_GOALS_SEPARATELY, false,
     )
@@ -650,6 +658,8 @@ class PrefsRepoImpl @Inject constructor(
         const val KEY_POMODORO_LONG_BREAK_TIME = "pomodoroLongBreakTime"
         const val KEY_POMODORO_PERIODS_UNTIL_LONG_BREAK = "pomodoroPeriodsUntilLongBreak"
         const val KEY_ALLOW_MULTIPLE_ACTIVITY_FILTERS = "allowMultipleActivityFilters"
+        const val KEY_SHOW_CATEGORIES_AS_PREDEFINED_FILTERS = "showCategoriesAsPredefinedFilters"
+        const val KEY_SELECTED_PREDEFINED_FILTERS = "selectedPredefinedFilters"
         const val KEY_SHOW_GOALS_SEPARATELY = "showGoalsSeparately"
         const val KEY_ALLOW_MULTITASKING = "allowMultitasking"
         const val KEY_SHOW_NOTIFICATIONS = "showNotifications"

domain/src/main/java/com/example/util/simpletimetracker/domain/activityFilter/interactor/ActivityFilterInteractor.kt

@@ -29,8 +29,8 @@ class ActivityFilterInteractor @Inject constructor(
         activityFilterRepo.changeSelected(id, selected)
     }
 
-    suspend fun changeSelectedAll(selected: Boolean) {
-        activityFilterRepo.changeSelectedAll(selected)
+    suspend fun disableAll() {
+        activityFilterRepo.changeSelectedAll(selected = false)
     }
 
     suspend fun remove(id: Long) {

domain/src/main/java/com/example/util/simpletimetracker/domain/activityFilter/interactor/ChangeSelectedActivityFilterMediator.kt

@@ -1,21 +1,32 @@
 package com.example.util.simpletimetracker.domain.activityFilter.interactor
 
+import com.example.util.simpletimetracker.domain.activityFilter.model.ActivityFilterType
 import com.example.util.simpletimetracker.domain.prefs.interactor.PrefsInteractor
 import javax.inject.Inject
 
 class ChangeSelectedActivityFilterMediator @Inject constructor(
     private val prefsInteractor: PrefsInteractor,
     private val activityFilterInteractor: ActivityFilterInteractor,
+    private val predefinedFilterInteractor: PredefinedFilterInteractor,
 ) {
 
     suspend fun onFilterClicked(
         id: Long,
+        type: ActivityFilterType,
         selected: Boolean,
     ) {
         val newValue = !selected
         if (newValue && !prefsInteractor.getAllowMultipleActivityFilters()) {
-            activityFilterInteractor.changeSelectedAll(selected = false)
+            activityFilterInteractor.disableAll()
+            predefinedFilterInteractor.disableAll()
+        }
+        when (type) {
+            is ActivityFilterType.Default -> {
+                activityFilterInteractor.changeSelected(id, newValue)
+            }
+            is ActivityFilterType.Predefined-> {
+                predefinedFilterInteractor.changeSelected(id, newValue)
+            }
         }
-        activityFilterInteractor.changeSelected(id, newValue)
     }
 }