2230cde071
Adds 4 new StateFlow members to IDataManager + DataManager + InMemoryDataManager + FixtureDataManager: - contractorDetail: Map<Int, Contractor> — cached detail fetches - documentDetail: Map<Int, Document> - taskCompletions: Map<Int, List<TaskCompletionResponse>> - contractorsByResidence: Map<Int, List<ContractorSummary>> APILayer now writes to these on successful detail/per-residence fetches: - getTaskCompletions -> setTaskCompletions - getDocument -> setDocumentDetail - getContractor -> setContractorDetail - getContractorsByResidence -> setContractorsForResidence Fixture populated() seeds contractorDetail + contractorsByResidence. Populated taskCompletions is empty (Fixtures doesn't define any completions yet). Foundation for P1 — VMs can now derive every read-state from DataManager reactively instead of owning independent MutableStateFlow fields. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
1042 lines
41 KiB
Kotlin
1042 lines
41 KiB
Kotlin
package com.tt.honeyDue.data
|
|
|
|
import com.tt.honeyDue.models.*
|
|
import com.tt.honeyDue.storage.TokenManager
|
|
import com.tt.honeyDue.storage.ThemeStorageManager
|
|
import kotlinx.coroutines.flow.MutableStateFlow
|
|
import kotlinx.coroutines.flow.StateFlow
|
|
import kotlinx.coroutines.flow.asStateFlow
|
|
import kotlinx.serialization.encodeToString
|
|
import kotlinx.serialization.json.Json
|
|
import kotlin.time.Clock
|
|
import kotlin.time.ExperimentalTime
|
|
|
|
/**
|
|
* Unified DataManager - Single Source of Truth for all app data.
|
|
*
|
|
* Core Principles:
|
|
* 1. All data is cached here - no other caches exist
|
|
* 2. Every API response updates DataManager immediately
|
|
* 3. All screens observe DataManager StateFlows directly
|
|
* 4. Auth token and theme preferences are persisted via platform-specific managers
|
|
*
|
|
* Disk Persistence (survives app restart):
|
|
* - Current user, auth token (via TokenManager), theme (via ThemeStorageManager)
|
|
* - Lookup/reference data: categories, priorities, frequencies, specialties, residence types, task templates
|
|
* - ETag values for conditional fetching, onboarding completion flag
|
|
*
|
|
* In-memory only (re-fetched on app launch via prefetchAllData):
|
|
* - Residences, tasks, documents, contractors
|
|
* - Subscription status, summaries, upgrade triggers, feature benefits, promotions
|
|
*
|
|
* Data Flow:
|
|
* User Action → API Call → Server Response → DataManager Updated → All Screens React
|
|
*/
|
|
object DataManager : IDataManager {
|
|
|
|
// ==================== CACHE CONFIGURATION ====================
|
|
|
|
/**
|
|
* Default cache timeout in milliseconds.
|
|
* Data older than this will be refreshed from the API.
|
|
* Default: 1 hour (3600000ms)
|
|
*/
|
|
const val CACHE_TIMEOUT_MS: Long = 60 * 60 * 1000L // 1 hour
|
|
|
|
/**
|
|
* Per-entity cache TTLs for data with different freshness requirements.
|
|
*/
|
|
object CacheTTL {
|
|
/** Lookups (categories, priorities, frequencies) — rarely change */
|
|
const val LOOKUPS_MS: Long = 24 * 60 * 60 * 1000L // 24 hours
|
|
/** Entity data (residences, tasks, documents, contractors) */
|
|
const val ENTITIES_MS: Long = 60 * 60 * 1000L // 1 hour
|
|
/** Subscription status — needs frequent refresh */
|
|
const val SUBSCRIPTION_MS: Long = 30 * 60 * 1000L // 30 minutes
|
|
}
|
|
|
|
// Cache timestamps for each data type (epoch milliseconds)
|
|
var residencesCacheTime: Long = 0L
|
|
private set
|
|
var myResidencesCacheTime: Long = 0L
|
|
private set
|
|
var tasksCacheTime: Long = 0L
|
|
private set
|
|
var tasksByResidenceCacheTime: MutableMap<Int, Long> = mutableMapOf()
|
|
private set
|
|
var contractorsCacheTime: Long = 0L
|
|
private set
|
|
var documentsCacheTime: Long = 0L
|
|
private set
|
|
var summaryCacheTime: Long = 0L
|
|
private set
|
|
|
|
/**
|
|
* Check if cache for a given timestamp is still valid (not expired).
|
|
* @param cacheTime Epoch milliseconds when the cache was last set.
|
|
* @param ttlMs Optional TTL override. Defaults to CACHE_TIMEOUT_MS (1 hour).
|
|
* Use CacheTTL.LOOKUPS_MS for lookups, CacheTTL.SUBSCRIPTION_MS for subscription.
|
|
*/
|
|
@OptIn(ExperimentalTime::class)
|
|
fun isCacheValid(cacheTime: Long, ttlMs: Long = CACHE_TIMEOUT_MS): Boolean {
|
|
if (cacheTime == 0L) return false
|
|
val now = Clock.System.now().toEpochMilliseconds()
|
|
return (now - cacheTime) < ttlMs
|
|
}
|
|
|
|
/**
|
|
* Get current timestamp in milliseconds
|
|
*/
|
|
@OptIn(ExperimentalTime::class)
|
|
private fun currentTimeMs(): Long = Clock.System.now().toEpochMilliseconds()
|
|
|
|
// Platform-specific persistence managers (initialized at app start)
|
|
private var tokenManager: TokenManager? = null
|
|
private var themeManager: ThemeStorageManager? = null
|
|
private var persistenceManager: PersistenceManager? = null
|
|
|
|
private val json = Json {
|
|
ignoreUnknownKeys = true
|
|
isLenient = true
|
|
encodeDefaults = true
|
|
}
|
|
|
|
// ==================== AUTHENTICATION ====================
|
|
|
|
private val _authToken = MutableStateFlow<String?>(null)
|
|
val authToken: StateFlow<String?> = _authToken.asStateFlow()
|
|
|
|
private val _currentUser = MutableStateFlow<User?>(null)
|
|
override val currentUser: StateFlow<User?> = _currentUser.asStateFlow()
|
|
|
|
// ==================== APP PREFERENCES ====================
|
|
|
|
private val _themeId = MutableStateFlow("default")
|
|
val themeId: StateFlow<String> = _themeId.asStateFlow()
|
|
|
|
// ==================== ONBOARDING ====================
|
|
|
|
private val _hasCompletedOnboarding = MutableStateFlow(false)
|
|
val hasCompletedOnboarding: StateFlow<Boolean> = _hasCompletedOnboarding.asStateFlow()
|
|
|
|
// ==================== RESIDENCES ====================
|
|
|
|
private val _residences = MutableStateFlow<List<Residence>>(emptyList())
|
|
override val residences: StateFlow<List<Residence>> = _residences.asStateFlow()
|
|
|
|
private val _myResidences = MutableStateFlow<MyResidencesResponse?>(null)
|
|
override val myResidences: StateFlow<MyResidencesResponse?> = _myResidences.asStateFlow()
|
|
|
|
private val _totalSummary = MutableStateFlow<TotalSummary?>(null)
|
|
override val totalSummary: StateFlow<TotalSummary?> = _totalSummary.asStateFlow()
|
|
|
|
private val _residenceSummaries = MutableStateFlow<Map<Int, ResidenceSummaryResponse>>(emptyMap())
|
|
override val residenceSummaries: StateFlow<Map<Int, ResidenceSummaryResponse>> = _residenceSummaries.asStateFlow()
|
|
|
|
// ==================== TASKS ====================
|
|
|
|
private val _allTasks = MutableStateFlow<TaskColumnsResponse?>(null)
|
|
override val allTasks: StateFlow<TaskColumnsResponse?> = _allTasks.asStateFlow()
|
|
|
|
private val _tasksByResidence = MutableStateFlow<Map<Int, TaskColumnsResponse>>(emptyMap())
|
|
override val tasksByResidence: StateFlow<Map<Int, TaskColumnsResponse>> = _tasksByResidence.asStateFlow()
|
|
|
|
private val _taskCompletions = MutableStateFlow<Map<Int, List<com.tt.honeyDue.models.TaskCompletionResponse>>>(emptyMap())
|
|
override val taskCompletions: StateFlow<Map<Int, List<com.tt.honeyDue.models.TaskCompletionResponse>>> = _taskCompletions.asStateFlow()
|
|
|
|
// ==================== DOCUMENTS ====================
|
|
|
|
private val _documents = MutableStateFlow<List<Document>>(emptyList())
|
|
override val documents: StateFlow<List<Document>> = _documents.asStateFlow()
|
|
|
|
private val _documentsByResidence = MutableStateFlow<Map<Int, List<Document>>>(emptyMap())
|
|
override val documentsByResidence: StateFlow<Map<Int, List<Document>>> = _documentsByResidence.asStateFlow()
|
|
|
|
private val _documentDetail = MutableStateFlow<Map<Int, Document>>(emptyMap())
|
|
override val documentDetail: StateFlow<Map<Int, Document>> = _documentDetail.asStateFlow()
|
|
|
|
// ==================== CONTRACTORS ====================
|
|
// Stores ContractorSummary for list views (lighter weight than full Contractor)
|
|
|
|
private val _contractors = MutableStateFlow<List<ContractorSummary>>(emptyList())
|
|
override val contractors: StateFlow<List<ContractorSummary>> = _contractors.asStateFlow()
|
|
|
|
private val _contractorsByResidence = MutableStateFlow<Map<Int, List<ContractorSummary>>>(emptyMap())
|
|
override val contractorsByResidence: StateFlow<Map<Int, List<ContractorSummary>>> = _contractorsByResidence.asStateFlow()
|
|
|
|
private val _contractorDetail = MutableStateFlow<Map<Int, com.tt.honeyDue.models.Contractor>>(emptyMap())
|
|
override val contractorDetail: StateFlow<Map<Int, com.tt.honeyDue.models.Contractor>> = _contractorDetail.asStateFlow()
|
|
|
|
// ==================== SUBSCRIPTION ====================
|
|
|
|
private val _subscription = MutableStateFlow<SubscriptionStatus?>(null)
|
|
override val subscription: StateFlow<SubscriptionStatus?> = _subscription.asStateFlow()
|
|
|
|
private val _upgradeTriggers = MutableStateFlow<Map<String, UpgradeTriggerData>>(emptyMap())
|
|
override val upgradeTriggers: StateFlow<Map<String, UpgradeTriggerData>> = _upgradeTriggers.asStateFlow()
|
|
|
|
private val _featureBenefits = MutableStateFlow<List<FeatureBenefit>>(emptyList())
|
|
override val featureBenefits: StateFlow<List<FeatureBenefit>> = _featureBenefits.asStateFlow()
|
|
|
|
private val _promotions = MutableStateFlow<List<Promotion>>(emptyList())
|
|
override val promotions: StateFlow<List<Promotion>> = _promotions.asStateFlow()
|
|
|
|
// ==================== LOOKUPS (Reference Data) ====================
|
|
|
|
// List-based for dropdowns/pickers
|
|
private val _residenceTypes = MutableStateFlow<List<ResidenceType>>(emptyList())
|
|
override val residenceTypes: StateFlow<List<ResidenceType>> = _residenceTypes.asStateFlow()
|
|
|
|
private val _taskFrequencies = MutableStateFlow<List<TaskFrequency>>(emptyList())
|
|
override val taskFrequencies: StateFlow<List<TaskFrequency>> = _taskFrequencies.asStateFlow()
|
|
|
|
private val _taskPriorities = MutableStateFlow<List<TaskPriority>>(emptyList())
|
|
override val taskPriorities: StateFlow<List<TaskPriority>> = _taskPriorities.asStateFlow()
|
|
|
|
private val _taskCategories = MutableStateFlow<List<TaskCategory>>(emptyList())
|
|
override val taskCategories: StateFlow<List<TaskCategory>> = _taskCategories.asStateFlow()
|
|
|
|
private val _contractorSpecialties = MutableStateFlow<List<ContractorSpecialty>>(emptyList())
|
|
override val contractorSpecialties: StateFlow<List<ContractorSpecialty>> = _contractorSpecialties.asStateFlow()
|
|
|
|
// ==================== TASK TEMPLATES ====================
|
|
|
|
private val _taskTemplates = MutableStateFlow<List<TaskTemplate>>(emptyList())
|
|
override val taskTemplates: StateFlow<List<TaskTemplate>> = _taskTemplates.asStateFlow()
|
|
|
|
private val _taskTemplatesGrouped = MutableStateFlow<TaskTemplatesGroupedResponse?>(null)
|
|
override val taskTemplatesGrouped: StateFlow<TaskTemplatesGroupedResponse?> = _taskTemplatesGrouped.asStateFlow()
|
|
|
|
// Map-based for O(1) ID resolution
|
|
private val _residenceTypesMap = MutableStateFlow<Map<Int, ResidenceType>>(emptyMap())
|
|
val residenceTypesMap: StateFlow<Map<Int, ResidenceType>> = _residenceTypesMap.asStateFlow()
|
|
|
|
private val _taskFrequenciesMap = MutableStateFlow<Map<Int, TaskFrequency>>(emptyMap())
|
|
val taskFrequenciesMap: StateFlow<Map<Int, TaskFrequency>> = _taskFrequenciesMap.asStateFlow()
|
|
|
|
private val _taskPrioritiesMap = MutableStateFlow<Map<Int, TaskPriority>>(emptyMap())
|
|
val taskPrioritiesMap: StateFlow<Map<Int, TaskPriority>> = _taskPrioritiesMap.asStateFlow()
|
|
|
|
private val _taskCategoriesMap = MutableStateFlow<Map<Int, TaskCategory>>(emptyMap())
|
|
val taskCategoriesMap: StateFlow<Map<Int, TaskCategory>> = _taskCategoriesMap.asStateFlow()
|
|
|
|
private val _contractorSpecialtiesMap = MutableStateFlow<Map<Int, ContractorSpecialty>>(emptyMap())
|
|
val contractorSpecialtiesMap: StateFlow<Map<Int, ContractorSpecialty>> = _contractorSpecialtiesMap.asStateFlow()
|
|
|
|
// ==================== STATE METADATA ====================
|
|
|
|
private val _isInitialized = MutableStateFlow(false)
|
|
val isInitialized: StateFlow<Boolean> = _isInitialized.asStateFlow()
|
|
|
|
private val _lookupsInitialized = MutableStateFlow(false)
|
|
val lookupsInitialized: StateFlow<Boolean> = _lookupsInitialized.asStateFlow()
|
|
|
|
private val _lastSyncTime = MutableStateFlow(0L)
|
|
val lastSyncTime: StateFlow<Long> = _lastSyncTime.asStateFlow()
|
|
|
|
// ==================== SEEDED DATA ETAG ====================
|
|
|
|
private val _seededDataETag = MutableStateFlow<String?>(null)
|
|
val seededDataETag: StateFlow<String?> = _seededDataETag.asStateFlow()
|
|
|
|
// ==================== INITIALIZATION ====================
|
|
|
|
/**
|
|
* Initialize DataManager with platform-specific managers.
|
|
* Call this once at app startup.
|
|
*/
|
|
fun initialize(
|
|
tokenMgr: TokenManager,
|
|
themeMgr: ThemeStorageManager,
|
|
persistenceMgr: PersistenceManager
|
|
) {
|
|
tokenManager = tokenMgr
|
|
themeManager = themeMgr
|
|
persistenceManager = persistenceMgr
|
|
|
|
// Load auth token from secure storage
|
|
_authToken.value = tokenMgr.getToken()
|
|
|
|
// Load theme preference
|
|
_themeId.value = themeMgr.getThemeId() ?: "default"
|
|
|
|
// Load cached data from disk
|
|
loadFromDisk()
|
|
|
|
_isInitialized.value = true
|
|
}
|
|
|
|
/**
|
|
* Check if user is authenticated (has valid token)
|
|
*/
|
|
fun isAuthenticated(): Boolean = _authToken.value != null
|
|
|
|
// ==================== O(1) LOOKUP HELPERS ====================
|
|
|
|
override fun getResidenceType(id: Int?): ResidenceType? = id?.let { _residenceTypesMap.value[it] }
|
|
override fun getTaskFrequency(id: Int?): TaskFrequency? = id?.let { _taskFrequenciesMap.value[it] }
|
|
override fun getTaskPriority(id: Int?): TaskPriority? = id?.let { _taskPrioritiesMap.value[it] }
|
|
override fun getTaskCategory(id: Int?): TaskCategory? = id?.let { _taskCategoriesMap.value[it] }
|
|
override fun getContractorSpecialty(id: Int?): ContractorSpecialty? = id?.let { _contractorSpecialtiesMap.value[it] }
|
|
|
|
// ==================== AUTH UPDATE METHODS ====================
|
|
|
|
fun setAuthToken(token: String?) {
|
|
_authToken.value = token
|
|
if (token != null) {
|
|
tokenManager?.saveToken(token)
|
|
} else {
|
|
tokenManager?.clearToken()
|
|
}
|
|
}
|
|
|
|
fun setCurrentUser(user: User?) {
|
|
_currentUser.value = user
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== THEME UPDATE METHODS ====================
|
|
|
|
fun setThemeId(id: String) {
|
|
_themeId.value = id
|
|
themeManager?.saveThemeId(id)
|
|
}
|
|
|
|
// ==================== ONBOARDING UPDATE METHODS ====================
|
|
|
|
fun setHasCompletedOnboarding(completed: Boolean) {
|
|
_hasCompletedOnboarding.value = completed
|
|
persistenceManager?.save(KEY_HAS_COMPLETED_ONBOARDING, completed.toString())
|
|
}
|
|
|
|
// ==================== RESIDENCE UPDATE METHODS ====================
|
|
|
|
fun setResidences(residences: List<Residence>) {
|
|
_residences.value = residences
|
|
residencesCacheTime = currentTimeMs()
|
|
updateLastSyncTime()
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setMyResidences(response: MyResidencesResponse) {
|
|
_myResidences.value = response
|
|
myResidencesCacheTime = currentTimeMs()
|
|
summaryCacheTime = currentTimeMs()
|
|
updateLastSyncTime()
|
|
// Calculate summary from cached kanban data (API no longer returns summary stats)
|
|
// This ensures summary is always up-to-date when residence view is shown
|
|
refreshSummaryFromKanban()
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setTotalSummary(summary: TotalSummary) {
|
|
_totalSummary.value = summary
|
|
summaryCacheTime = currentTimeMs()
|
|
persistToDisk()
|
|
}
|
|
|
|
/**
|
|
* Calculate TotalSummary from cached kanban data.
|
|
* This allows the client to compute summary stats without waiting for API responses
|
|
* after CRUD operations (API now returns empty summaries for performance).
|
|
*
|
|
* Columns from API: overdue_tasks, in_progress_tasks, due_soon_tasks, upcoming_tasks, completed_tasks, cancelled_tasks
|
|
*/
|
|
fun calculateSummaryFromKanban(): TotalSummary {
|
|
val kanban = _allTasks.value ?: return _totalSummary.value ?: TotalSummary()
|
|
val residenceCount = _myResidences.value?.residences?.size ?: _residences.value.size
|
|
|
|
var overdueCount = 0
|
|
var inProgressCount = 0
|
|
var dueSoonCount = 0
|
|
var upcomingCount = 0
|
|
var completedCount = 0
|
|
|
|
for (column in kanban.columns) {
|
|
when (column.name) {
|
|
"overdue_tasks" -> overdueCount = column.count
|
|
"in_progress_tasks" -> inProgressCount = column.count
|
|
"due_soon_tasks" -> dueSoonCount = column.count
|
|
"upcoming_tasks" -> upcomingCount = column.count
|
|
"completed_tasks" -> completedCount = column.count
|
|
// cancelled_tasks is not counted in totals
|
|
}
|
|
}
|
|
|
|
// totalTasks = all non-cancelled tasks
|
|
val totalTasks = overdueCount + inProgressCount + dueSoonCount + upcomingCount + completedCount
|
|
// totalPending = not completed (i.e., still needs attention)
|
|
val totalPending = overdueCount + inProgressCount + dueSoonCount + upcomingCount
|
|
|
|
return TotalSummary(
|
|
totalResidences = residenceCount,
|
|
totalTasks = totalTasks,
|
|
totalPending = totalPending,
|
|
totalOverdue = overdueCount,
|
|
// due_soon_tasks column = tasks due within threshold (default 30 days)
|
|
// upcoming_tasks column = tasks with dates beyond threshold OR no due date
|
|
// Both "Due This Week" and "Next 30 Days" use due_soon since it represents the 30-day window
|
|
tasksDueNextWeek = dueSoonCount,
|
|
tasksDueNextMonth = dueSoonCount
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Update totalSummary from cached kanban data.
|
|
* Call this after task CRUD operations to keep summary in sync without API call.
|
|
*/
|
|
fun refreshSummaryFromKanban() {
|
|
val calculatedSummary = calculateSummaryFromKanban()
|
|
_totalSummary.value = calculatedSummary
|
|
}
|
|
|
|
fun setResidenceSummary(residenceId: Int, summary: ResidenceSummaryResponse) {
|
|
_residenceSummaries.value = _residenceSummaries.value + (residenceId to summary)
|
|
persistToDisk()
|
|
}
|
|
|
|
/**
|
|
* Add a new residence to the cache.
|
|
* Caches affected: _residences, _myResidences
|
|
* Invalidation trigger: createResidence API success
|
|
*/
|
|
fun addResidence(residence: Residence) {
|
|
_residences.value = _residences.value + residence
|
|
// Also append to myResidences if it has been loaded
|
|
_myResidences.value?.let { myRes ->
|
|
_myResidences.value = myRes.copy(residences = myRes.residences + residence)
|
|
}
|
|
updateLastSyncTime()
|
|
persistToDisk()
|
|
}
|
|
|
|
fun updateResidence(residence: Residence) {
|
|
_residences.value = _residences.value.map {
|
|
if (it.id == residence.id) residence else it
|
|
}
|
|
// Also update myResidences if present (used by getResidence cache lookup)
|
|
_myResidences.value?.let { myRes ->
|
|
val updatedResidences = myRes.residences.map {
|
|
if (it.id == residence.id) residence else it
|
|
}
|
|
_myResidences.value = myRes.copy(residences = updatedResidences)
|
|
}
|
|
persistToDisk()
|
|
}
|
|
|
|
fun removeResidence(residenceId: Int) {
|
|
_residences.value = _residences.value.filter { it.id != residenceId }
|
|
_tasksByResidence.value = _tasksByResidence.value - residenceId
|
|
_documentsByResidence.value = _documentsByResidence.value - residenceId
|
|
_residenceSummaries.value = _residenceSummaries.value - residenceId
|
|
|
|
// Also update myResidences so the list view updates immediately
|
|
_myResidences.value?.let { current ->
|
|
_myResidences.value = current.copy(
|
|
residences = current.residences.filter { it.id != residenceId }
|
|
)
|
|
}
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== CACHE INVALIDATION ====================
|
|
|
|
/** Invalidate the tasks cache so the next loadTasks() fetches fresh from API. */
|
|
fun invalidateTasksCache() {
|
|
tasksCacheTime = 0L
|
|
}
|
|
|
|
// ==================== TASK UPDATE METHODS ====================
|
|
|
|
fun setAllTasks(response: TaskColumnsResponse) {
|
|
_allTasks.value = response
|
|
tasksCacheTime = currentTimeMs()
|
|
updateLastSyncTime()
|
|
// Refresh summary from kanban data (API no longer returns summary stats)
|
|
refreshSummaryFromKanban()
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setTasksForResidence(residenceId: Int, response: TaskColumnsResponse) {
|
|
_tasksByResidence.value = _tasksByResidence.value + (residenceId to response)
|
|
tasksByResidenceCacheTime[residenceId] = currentTimeMs()
|
|
persistToDisk()
|
|
}
|
|
|
|
/** Populate the per-task completion cache (used by TaskViewModel's derived flow). */
|
|
fun setTaskCompletions(taskId: Int, completions: List<com.tt.honeyDue.models.TaskCompletionResponse>) {
|
|
_taskCompletions.value = _taskCompletions.value + (taskId to completions)
|
|
}
|
|
|
|
/**
|
|
* Filter cached allTasks by residence ID to avoid separate API call.
|
|
* Returns null if allTasks not cached.
|
|
* This enables client-side filtering when we already have all tasks loaded.
|
|
*/
|
|
fun getTasksForResidence(residenceId: Int): TaskColumnsResponse? {
|
|
val allTasksData = _allTasks.value ?: return null
|
|
|
|
// Filter each column's tasks by residence ID
|
|
val filteredColumns = allTasksData.columns.map { column ->
|
|
column.copy(
|
|
tasks = column.tasks.filter { it.residenceId == residenceId },
|
|
count = column.tasks.count { it.residenceId == residenceId }
|
|
)
|
|
}
|
|
|
|
return TaskColumnsResponse(
|
|
columns = filteredColumns,
|
|
daysThreshold = allTasksData.daysThreshold,
|
|
residenceId = residenceId.toString()
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Update a single task - moves it to the correct kanban column based on kanban_column field.
|
|
* This is called after task completion, status change, etc.
|
|
* Also refreshes the summary from the updated kanban data.
|
|
*/
|
|
fun updateTask(task: TaskResponse) {
|
|
// Update in allTasks
|
|
_allTasks.value?.let { current ->
|
|
val targetColumn = task.kanbanColumn ?: "upcoming_tasks"
|
|
val newColumns = current.columns.map { column ->
|
|
// Remove task from this column if present
|
|
val filteredTasks = column.tasks.filter { it.id != task.id }
|
|
// Add task if this is the target column
|
|
val updatedTasks = if (column.name == targetColumn) {
|
|
filteredTasks + task
|
|
} else {
|
|
filteredTasks
|
|
}
|
|
column.copy(tasks = updatedTasks, count = updatedTasks.size)
|
|
}
|
|
_allTasks.value = current.copy(columns = newColumns)
|
|
}
|
|
|
|
// Update in tasksByResidence if this task's residence is cached
|
|
task.residenceId?.let { residenceId ->
|
|
_tasksByResidence.value[residenceId]?.let { current ->
|
|
val targetColumn = task.kanbanColumn ?: "upcoming_tasks"
|
|
val newColumns = current.columns.map { column ->
|
|
val filteredTasks = column.tasks.filter { it.id != task.id }
|
|
val updatedTasks = if (column.name == targetColumn) {
|
|
filteredTasks + task
|
|
} else {
|
|
filteredTasks
|
|
}
|
|
column.copy(tasks = updatedTasks, count = updatedTasks.size)
|
|
}
|
|
_tasksByResidence.value = _tasksByResidence.value + (residenceId to current.copy(columns = newColumns))
|
|
}
|
|
}
|
|
|
|
// Refresh summary from updated kanban data (API no longer returns summaries for CRUD)
|
|
refreshSummaryFromKanban()
|
|
persistToDisk()
|
|
}
|
|
|
|
fun removeTask(taskId: Int) {
|
|
// Remove from allTasks
|
|
_allTasks.value?.let { current ->
|
|
val newColumns = current.columns.map { column ->
|
|
val filteredTasks = column.tasks.filter { it.id != taskId }
|
|
column.copy(tasks = filteredTasks, count = filteredTasks.size)
|
|
}
|
|
_allTasks.value = current.copy(columns = newColumns)
|
|
}
|
|
|
|
// Remove from all residence task caches
|
|
_tasksByResidence.value = _tasksByResidence.value.mapValues { (_, tasks) ->
|
|
val newColumns = tasks.columns.map { column ->
|
|
val filteredTasks = column.tasks.filter { it.id != taskId }
|
|
column.copy(tasks = filteredTasks, count = filteredTasks.size)
|
|
}
|
|
tasks.copy(columns = newColumns)
|
|
}
|
|
|
|
// Refresh summary from updated kanban data (API no longer returns summaries for CRUD)
|
|
refreshSummaryFromKanban()
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== DOCUMENT UPDATE METHODS ====================
|
|
|
|
fun setDocuments(documents: List<Document>) {
|
|
_documents.value = documents
|
|
documentsCacheTime = currentTimeMs()
|
|
updateLastSyncTime()
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setDocumentsForResidence(residenceId: Int, documents: List<Document>) {
|
|
_documentsByResidence.value = _documentsByResidence.value + (residenceId to documents)
|
|
persistToDisk()
|
|
}
|
|
|
|
/** Populate the per-document detail cache (used by DocumentViewModel's derived flow). */
|
|
fun setDocumentDetail(document: Document) {
|
|
val id = document.id ?: return
|
|
_documentDetail.value = _documentDetail.value + (id to document)
|
|
}
|
|
|
|
/**
|
|
* Add a new document to the cache.
|
|
* Caches affected: _documents, _documentsByResidence[residenceId]
|
|
* Invalidation trigger: createDocument API success
|
|
*/
|
|
fun addDocument(document: Document) {
|
|
_documents.value = _documents.value + document
|
|
// Also add to residence-specific cache if it exists
|
|
val residenceId = document.residenceId ?: document.residence
|
|
_documentsByResidence.value[residenceId]?.let { existing ->
|
|
_documentsByResidence.value = _documentsByResidence.value + (residenceId to (existing + document))
|
|
}
|
|
persistToDisk()
|
|
}
|
|
|
|
/**
|
|
* Update an existing document in the cache.
|
|
* Caches affected: _documents, _documentsByResidence (all maps containing the document)
|
|
* Invalidation trigger: updateDocument / uploadDocumentImage / deleteDocumentImage API success
|
|
*/
|
|
fun updateDocument(document: Document) {
|
|
_documents.value = _documents.value.map {
|
|
if (it.id == document.id) document else it
|
|
}
|
|
// Also update in residence-specific caches
|
|
_documentsByResidence.value = _documentsByResidence.value.mapValues { (_, docs) ->
|
|
docs.map { if (it.id == document.id) document else it }
|
|
}
|
|
persistToDisk()
|
|
}
|
|
|
|
fun removeDocument(documentId: Int) {
|
|
_documents.value = _documents.value.filter { it.id != documentId }
|
|
// Also remove from residence-specific caches
|
|
_documentsByResidence.value = _documentsByResidence.value.mapValues { (_, docs) ->
|
|
docs.filter { it.id != documentId }
|
|
}
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== CONTRACTOR UPDATE METHODS ====================
|
|
|
|
fun setContractors(contractors: List<ContractorSummary>) {
|
|
_contractors.value = contractors
|
|
contractorsCacheTime = currentTimeMs()
|
|
updateLastSyncTime()
|
|
persistToDisk()
|
|
}
|
|
|
|
/** Populate the per-residence contractor cache. */
|
|
fun setContractorsForResidence(residenceId: Int, contractors: List<ContractorSummary>) {
|
|
_contractorsByResidence.value = _contractorsByResidence.value + (residenceId to contractors)
|
|
}
|
|
|
|
/** Populate the per-contractor detail cache (used by ContractorViewModel's derived flow). */
|
|
fun setContractorDetail(contractor: com.tt.honeyDue.models.Contractor) {
|
|
_contractorDetail.value = _contractorDetail.value + (contractor.id to contractor)
|
|
}
|
|
|
|
fun addContractor(contractor: ContractorSummary) {
|
|
_contractors.value = _contractors.value + contractor
|
|
persistToDisk()
|
|
}
|
|
|
|
/** Add a full Contractor (converts to summary for storage) */
|
|
fun addContractor(contractor: Contractor) {
|
|
_contractors.value = _contractors.value + contractor.toSummary()
|
|
persistToDisk()
|
|
}
|
|
|
|
fun updateContractor(contractor: ContractorSummary) {
|
|
_contractors.value = _contractors.value.map {
|
|
if (it.id == contractor.id) contractor else it
|
|
}
|
|
persistToDisk()
|
|
}
|
|
|
|
/** Update from a full Contractor (converts to summary for storage) */
|
|
fun updateContractor(contractor: Contractor) {
|
|
val summary = contractor.toSummary()
|
|
_contractors.value = _contractors.value.map {
|
|
if (it.id == summary.id) summary else it
|
|
}
|
|
persistToDisk()
|
|
}
|
|
|
|
fun removeContractor(contractorId: Int) {
|
|
_contractors.value = _contractors.value.filter { it.id != contractorId }
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== SUBSCRIPTION UPDATE METHODS ====================
|
|
|
|
fun setSubscription(subscription: SubscriptionStatus?) {
|
|
_subscription.value = subscription
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setUpgradeTriggers(triggers: Map<String, UpgradeTriggerData>) {
|
|
_upgradeTriggers.value = triggers
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setFeatureBenefits(benefits: List<FeatureBenefit>) {
|
|
_featureBenefits.value = benefits
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setPromotions(promos: List<Promotion>) {
|
|
_promotions.value = promos
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== LOOKUP UPDATE METHODS ====================
|
|
|
|
fun setResidenceTypes(types: List<ResidenceType>) {
|
|
_residenceTypes.value = types
|
|
_residenceTypesMap.value = types.associateBy { it.id }
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setTaskFrequencies(frequencies: List<TaskFrequency>) {
|
|
_taskFrequencies.value = frequencies
|
|
_taskFrequenciesMap.value = frequencies.associateBy { it.id }
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setTaskPriorities(priorities: List<TaskPriority>) {
|
|
_taskPriorities.value = priorities
|
|
_taskPrioritiesMap.value = priorities.associateBy { it.id }
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setTaskCategories(categories: List<TaskCategory>) {
|
|
_taskCategories.value = categories
|
|
_taskCategoriesMap.value = categories.associateBy { it.id }
|
|
persistToDisk()
|
|
}
|
|
|
|
fun setContractorSpecialties(specialties: List<ContractorSpecialty>) {
|
|
_contractorSpecialties.value = specialties
|
|
_contractorSpecialtiesMap.value = specialties.associateBy { it.id }
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== TASK TEMPLATE UPDATE METHODS ====================
|
|
|
|
fun setTaskTemplates(templates: List<TaskTemplate>) {
|
|
_taskTemplates.value = templates
|
|
// Don't persist - these are fetched fresh from API
|
|
}
|
|
|
|
fun setTaskTemplatesGrouped(response: TaskTemplatesGroupedResponse) {
|
|
_taskTemplatesGrouped.value = response
|
|
// Also extract flat list from grouped response
|
|
val flatList = response.categories.flatMap { it.templates }
|
|
_taskTemplates.value = flatList
|
|
// Don't persist - these are fetched fresh from API
|
|
}
|
|
|
|
/**
|
|
* Search task templates by query string (local search)
|
|
*/
|
|
fun searchTaskTemplates(query: String): List<TaskTemplate> {
|
|
if (query.length < 2) return emptyList()
|
|
val lowercaseQuery = query.lowercase()
|
|
return _taskTemplates.value.filter { template ->
|
|
template.title.lowercase().contains(lowercaseQuery) ||
|
|
template.description.lowercase().contains(lowercaseQuery) ||
|
|
template.tags.any { it.lowercase().contains(lowercaseQuery) }
|
|
}.take(10)
|
|
}
|
|
|
|
fun setAllLookups(staticData: StaticDataResponse) {
|
|
setResidenceTypes(staticData.residenceTypes)
|
|
setTaskFrequencies(staticData.taskFrequencies)
|
|
setTaskPriorities(staticData.taskPriorities)
|
|
setTaskCategories(staticData.taskCategories)
|
|
setContractorSpecialties(staticData.contractorSpecialties)
|
|
_lookupsInitialized.value = true
|
|
}
|
|
|
|
/**
|
|
* Set all lookups from unified seeded data response.
|
|
* Also stores the ETag for future conditional requests.
|
|
* Persists lookup data to disk for faster app startup.
|
|
*/
|
|
fun setAllLookupsFromSeededData(seededData: SeededDataResponse, etag: String?) {
|
|
setResidenceTypes(seededData.residenceTypes)
|
|
setTaskFrequencies(seededData.taskFrequencies)
|
|
setTaskPriorities(seededData.taskPriorities)
|
|
setTaskCategories(seededData.taskCategories)
|
|
setContractorSpecialties(seededData.contractorSpecialties)
|
|
setTaskTemplatesGrouped(seededData.taskTemplates)
|
|
setSeededDataETag(etag)
|
|
_lookupsInitialized.value = true
|
|
// Persist lookups to disk for faster startup
|
|
persistLookupsToDisk()
|
|
}
|
|
|
|
/**
|
|
* Set the ETag for seeded data. Used for conditional requests.
|
|
*/
|
|
fun setSeededDataETag(etag: String?) {
|
|
_seededDataETag.value = etag
|
|
if (etag != null) {
|
|
persistenceManager?.save(KEY_SEEDED_DATA_ETAG, etag)
|
|
} else {
|
|
persistenceManager?.remove(KEY_SEEDED_DATA_ETAG)
|
|
}
|
|
}
|
|
|
|
fun markLookupsInitialized() {
|
|
_lookupsInitialized.value = true
|
|
}
|
|
|
|
// ==================== CLEAR METHODS ====================
|
|
|
|
/**
|
|
* Clear all data - called on logout
|
|
*/
|
|
fun clear() {
|
|
// Clear auth
|
|
_authToken.value = null
|
|
_currentUser.value = null
|
|
tokenManager?.clearToken()
|
|
|
|
// Clear user data
|
|
_residences.value = emptyList()
|
|
_myResidences.value = null
|
|
_totalSummary.value = null
|
|
_residenceSummaries.value = emptyMap()
|
|
_allTasks.value = null
|
|
_tasksByResidence.value = emptyMap()
|
|
_documents.value = emptyList()
|
|
_documentsByResidence.value = emptyMap()
|
|
_contractors.value = emptyList()
|
|
|
|
// Clear subscription
|
|
_subscription.value = null
|
|
_upgradeTriggers.value = emptyMap()
|
|
_featureBenefits.value = emptyList()
|
|
_promotions.value = emptyList()
|
|
|
|
// Clear lookups
|
|
_residenceTypes.value = emptyList()
|
|
_residenceTypesMap.value = emptyMap()
|
|
_taskFrequencies.value = emptyList()
|
|
_taskFrequenciesMap.value = emptyMap()
|
|
_taskPriorities.value = emptyList()
|
|
_taskPrioritiesMap.value = emptyMap()
|
|
_taskCategories.value = emptyList()
|
|
_taskCategoriesMap.value = emptyMap()
|
|
_contractorSpecialties.value = emptyList()
|
|
_contractorSpecialtiesMap.value = emptyMap()
|
|
_taskTemplates.value = emptyList()
|
|
_taskTemplatesGrouped.value = null
|
|
_lookupsInitialized.value = false
|
|
_seededDataETag.value = null
|
|
|
|
// Clear cache timestamps
|
|
residencesCacheTime = 0L
|
|
myResidencesCacheTime = 0L
|
|
tasksCacheTime = 0L
|
|
tasksByResidenceCacheTime.clear()
|
|
contractorsCacheTime = 0L
|
|
documentsCacheTime = 0L
|
|
summaryCacheTime = 0L
|
|
|
|
// Clear metadata
|
|
_lastSyncTime.value = 0L
|
|
|
|
// Clear persistent storage (except theme)
|
|
persistenceManager?.clear()
|
|
}
|
|
|
|
/**
|
|
* Clear only user-specific data (keep lookups and preferences)
|
|
*/
|
|
fun clearUserData() {
|
|
_currentUser.value = null
|
|
_residences.value = emptyList()
|
|
_myResidences.value = null
|
|
_totalSummary.value = null
|
|
_residenceSummaries.value = emptyMap()
|
|
_allTasks.value = null
|
|
_tasksByResidence.value = emptyMap()
|
|
_documents.value = emptyList()
|
|
_documentsByResidence.value = emptyMap()
|
|
_contractors.value = emptyList()
|
|
_subscription.value = null
|
|
_upgradeTriggers.value = emptyMap()
|
|
_featureBenefits.value = emptyList()
|
|
_promotions.value = emptyList()
|
|
|
|
// Clear cache timestamps
|
|
residencesCacheTime = 0L
|
|
myResidencesCacheTime = 0L
|
|
tasksCacheTime = 0L
|
|
tasksByResidenceCacheTime.clear()
|
|
contractorsCacheTime = 0L
|
|
documentsCacheTime = 0L
|
|
summaryCacheTime = 0L
|
|
|
|
persistToDisk()
|
|
}
|
|
|
|
// ==================== PERSISTENCE ====================
|
|
|
|
@OptIn(ExperimentalTime::class)
|
|
private fun updateLastSyncTime() {
|
|
_lastSyncTime.value = Clock.System.now().toEpochMilliseconds()
|
|
}
|
|
|
|
/**
|
|
* Persist current state to disk.
|
|
* Persists user data and lookup data for faster app startup.
|
|
*/
|
|
private fun persistToDisk() {
|
|
val manager = persistenceManager ?: return
|
|
|
|
try {
|
|
_currentUser.value?.let {
|
|
manager.save(KEY_CURRENT_USER, json.encodeToString(it))
|
|
}
|
|
} catch (e: Exception) {
|
|
println("DataManager: Error persisting user to disk: ${e.message}")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Persist lookup data to disk separately (called less frequently).
|
|
*/
|
|
private fun persistLookupsToDisk() {
|
|
val manager = persistenceManager ?: return
|
|
|
|
try {
|
|
if (_residenceTypes.value.isNotEmpty()) {
|
|
manager.save(KEY_RESIDENCE_TYPES, json.encodeToString(_residenceTypes.value))
|
|
}
|
|
if (_taskFrequencies.value.isNotEmpty()) {
|
|
manager.save(KEY_TASK_FREQUENCIES, json.encodeToString(_taskFrequencies.value))
|
|
}
|
|
if (_taskPriorities.value.isNotEmpty()) {
|
|
manager.save(KEY_TASK_PRIORITIES, json.encodeToString(_taskPriorities.value))
|
|
}
|
|
if (_taskCategories.value.isNotEmpty()) {
|
|
manager.save(KEY_TASK_CATEGORIES, json.encodeToString(_taskCategories.value))
|
|
}
|
|
if (_contractorSpecialties.value.isNotEmpty()) {
|
|
manager.save(KEY_CONTRACTOR_SPECIALTIES, json.encodeToString(_contractorSpecialties.value))
|
|
}
|
|
_taskTemplatesGrouped.value?.let {
|
|
manager.save(KEY_TASK_TEMPLATES_GROUPED, json.encodeToString(it))
|
|
}
|
|
println("DataManager: Lookup data persisted to disk")
|
|
} catch (e: Exception) {
|
|
println("DataManager: Error persisting lookups to disk: ${e.message}")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load cached state from disk.
|
|
* Loads user data and lookup data for faster app startup.
|
|
*/
|
|
private fun loadFromDisk() {
|
|
val manager = persistenceManager ?: return
|
|
|
|
try {
|
|
// Load user data
|
|
manager.load(KEY_CURRENT_USER)?.let { data ->
|
|
_currentUser.value = json.decodeFromString<User>(data)
|
|
}
|
|
|
|
// Load onboarding completion flag
|
|
manager.load(KEY_HAS_COMPLETED_ONBOARDING)?.let { data ->
|
|
_hasCompletedOnboarding.value = data.toBooleanStrictOrNull() ?: false
|
|
}
|
|
|
|
// Load seeded data ETag for conditional requests
|
|
manager.load(KEY_SEEDED_DATA_ETAG)?.let { data ->
|
|
_seededDataETag.value = data
|
|
}
|
|
|
|
// Load lookup data
|
|
loadLookupsFromDisk()
|
|
} catch (e: Exception) {
|
|
println("DataManager: Error loading from disk: ${e.message}")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load lookup data from disk.
|
|
* If lookups are successfully loaded, mark as initialized.
|
|
*/
|
|
private fun loadLookupsFromDisk() {
|
|
val manager = persistenceManager ?: return
|
|
var lookupsLoaded = false
|
|
|
|
try {
|
|
manager.load(KEY_RESIDENCE_TYPES)?.let { data ->
|
|
val types = json.decodeFromString<List<ResidenceType>>(data)
|
|
_residenceTypes.value = types
|
|
_residenceTypesMap.value = types.associateBy { it.id }
|
|
lookupsLoaded = true
|
|
}
|
|
|
|
manager.load(KEY_TASK_FREQUENCIES)?.let { data ->
|
|
val frequencies = json.decodeFromString<List<TaskFrequency>>(data)
|
|
_taskFrequencies.value = frequencies
|
|
_taskFrequenciesMap.value = frequencies.associateBy { it.id }
|
|
}
|
|
|
|
manager.load(KEY_TASK_PRIORITIES)?.let { data ->
|
|
val priorities = json.decodeFromString<List<TaskPriority>>(data)
|
|
_taskPriorities.value = priorities
|
|
_taskPrioritiesMap.value = priorities.associateBy { it.id }
|
|
}
|
|
|
|
manager.load(KEY_TASK_CATEGORIES)?.let { data ->
|
|
val categories = json.decodeFromString<List<TaskCategory>>(data)
|
|
_taskCategories.value = categories
|
|
_taskCategoriesMap.value = categories.associateBy { it.id }
|
|
}
|
|
|
|
manager.load(KEY_CONTRACTOR_SPECIALTIES)?.let { data ->
|
|
val specialties = json.decodeFromString<List<ContractorSpecialty>>(data)
|
|
_contractorSpecialties.value = specialties
|
|
_contractorSpecialtiesMap.value = specialties.associateBy { it.id }
|
|
}
|
|
|
|
manager.load(KEY_TASK_TEMPLATES_GROUPED)?.let { data ->
|
|
val grouped = json.decodeFromString<TaskTemplatesGroupedResponse>(data)
|
|
_taskTemplatesGrouped.value = grouped
|
|
_taskTemplates.value = grouped.categories.flatMap { it.templates }
|
|
}
|
|
|
|
// Mark lookups as initialized if we loaded any data
|
|
if (lookupsLoaded) {
|
|
_lookupsInitialized.value = true
|
|
println("DataManager: Lookup data loaded from disk")
|
|
}
|
|
} catch (e: Exception) {
|
|
println("DataManager: Error loading lookups from disk: ${e.message}")
|
|
}
|
|
}
|
|
|
|
// ==================== PERSISTENCE KEYS ====================
|
|
|
|
private const val KEY_CURRENT_USER = "dm_current_user"
|
|
private const val KEY_HAS_COMPLETED_ONBOARDING = "dm_has_completed_onboarding"
|
|
private const val KEY_SEEDED_DATA_ETAG = "dm_seeded_data_etag"
|
|
private const val KEY_RESIDENCE_TYPES = "dm_residence_types"
|
|
private const val KEY_TASK_FREQUENCIES = "dm_task_frequencies"
|
|
private const val KEY_TASK_PRIORITIES = "dm_task_priorities"
|
|
private const val KEY_TASK_CATEGORIES = "dm_task_categories"
|
|
private const val KEY_CONTRACTOR_SPECIALTIES = "dm_contractor_specialties"
|
|
private const val KEY_TASK_TEMPLATES_GROUPED = "dm_task_templates_grouped"
|
|
}
|