@shaykec/app-agent 1.0.4 → 1.0.6

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/data/local/BudgetEntity.kt

@@ -0,0 +1,54 @@
+package com.appship.finance.data.local
+
+import androidx.compose.ui.graphics.Color
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.finance.data.Budget
+import com.appship.finance.data.BudgetPeriod
+import java.time.LocalDate
+import java.time.ZoneOffset
+
+/**
+ * Room entity for Budget persistence.
+ */
+@Entity(tableName = "budgets")
+data class BudgetEntity(
+    @PrimaryKey val id: String,
+    val category: String = "",
+    val categoryIcon: String = "label",
+    val categoryColorValue: Long = 0,
+    val limit: Double = 0.0,
+    val spent: Double = 0.0,
+    val period: String = "MONTHLY",
+    val startDate: Long = System.currentTimeMillis(),
+    val isRecurring: Boolean = true,
+    val notifications: Boolean = true
+) {
+    fun toBudget(): Budget = Budget(
+        id = id,
+        category = category,
+        categoryIcon = categoryIcon,
+        categoryColor = Color(categoryColorValue),
+        limit = limit,
+        spent = spent,
+        period = BudgetPeriod.values().find { it.name == period } ?: BudgetPeriod.MONTHLY,
+        startDate = LocalDate.ofEpochDay(startDate / (24 * 60 * 60 * 1000)),
+        isRecurring = isRecurring,
+        notifications = notifications
+    )
+
+    companion object {
+        fun fromBudget(budget: Budget): BudgetEntity = BudgetEntity(
+            id = budget.id,
+            category = budget.category,
+            categoryIcon = budget.categoryIcon,
+            categoryColorValue = budget.categoryColor.value.toLong(),
+            limit = budget.limit,
+            spent = budget.spent,
+            period = budget.period.name,
+            startDate = budget.startDate.toEpochDay() * 24 * 60 * 60 * 1000,
+            isRecurring = budget.isRecurring,
+            notifications = budget.notifications
+        )
+    }
+}

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/data/local/CategoryEntity.kt

@@ -0,0 +1,33 @@
+package com.appship.finance.data.local
+
+import androidx.compose.ui.graphics.Color
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.finance.data.Category
+
+/**
+ * Room entity for Category persistence.
+ */
+@Entity(tableName = "categories")
+data class CategoryEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val icon: String = "tag",
+    val colorValue: Long = 0
+) {
+    fun toCategory(): Category = Category(
+        id = id,
+        name = name,
+        icon = icon,
+        color = Color(colorValue)
+    )
+
+    companion object {
+        fun fromCategory(category: Category): CategoryEntity = CategoryEntity(
+            id = category.id,
+            name = category.name,
+            icon = category.icon,
+            colorValue = category.color.value.toLong()
+        )
+    }
+}

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/data/local/GoalEntity.kt

@@ -0,0 +1,59 @@
+package com.appship.finance.data.local
+
+import androidx.compose.ui.graphics.Color
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.finance.data.Goal
+import java.time.LocalDate
+import java.time.ZoneOffset
+
+/**
+ * Room entity for Goal persistence.
+ */
+@Entity(tableName = "goals")
+data class GoalEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val targetAmount: Double = 0.0,
+    val currentAmount: Double = 0.0,
+    val deadline: Long? = null,
+    val icon: String = "flag",
+    val colorValue: Long = 0,
+    val notes: String? = null,
+    val linkedAccountId: String? = null,
+    val createdAt: Long = System.currentTimeMillis(),
+    val autoSave: Boolean = false,
+    val autoSaveAmount: Double? = null
+) {
+    fun toGoal(): Goal = Goal(
+        id = id,
+        name = name,
+        targetAmount = targetAmount,
+        currentAmount = currentAmount,
+        deadline = deadline?.let { LocalDate.ofEpochDay(it / (24 * 60 * 60 * 1000)) },
+        icon = icon,
+        color = Color(colorValue),
+        notes = notes,
+        linkedAccountId = linkedAccountId,
+        createdAt = LocalDate.ofEpochDay(createdAt / (24 * 60 * 60 * 1000)),
+        autoSave = autoSave,
+        autoSaveAmount = autoSaveAmount
+    )
+
+    companion object {
+        fun fromGoal(goal: Goal): GoalEntity = GoalEntity(
+            id = goal.id,
+            name = goal.name,
+            targetAmount = goal.targetAmount,
+            currentAmount = goal.currentAmount,
+            deadline = goal.deadline?.toEpochDay()?.let { it * 24 * 60 * 60 * 1000 },
+            icon = goal.icon,
+            colorValue = goal.color.value.toLong(),
+            notes = goal.notes,
+            linkedAccountId = goal.linkedAccountId,
+            createdAt = goal.createdAt.toEpochDay() * 24 * 60 * 60 * 1000,
+            autoSave = goal.autoSave,
+            autoSaveAmount = goal.autoSaveAmount
+        )
+    }
+}

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/data/local/InsightEntity.kt

@@ -0,0 +1,47 @@
+package com.appship.finance.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.finance.data.InsightType
+import com.appship.finance.data.SpendingInsight
+import java.time.LocalDateTime
+import java.time.ZoneOffset
+
+/**
+ * Room entity for Insight persistence.
+ */
+@Entity(tableName = "insights")
+data class InsightEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val message: String = "",
+    val type: String = "",
+    val category: String? = null,
+    val amount: Double? = null,
+    val percentChange: Double? = null,
+    val date: Long = System.currentTimeMillis()
+) {
+    fun toInsight(): SpendingInsight = SpendingInsight(
+        id = id,
+        title = title,
+        message = message,
+        type = InsightType.values().find { it.name == type } ?: InsightType.INFO,
+        category = category,
+        amount = amount,
+        percentChange = percentChange,
+        date = LocalDateTime.ofEpochSecond(date / 1000, 0, ZoneOffset.UTC)
+    )
+
+    companion object {
+        fun fromInsight(insight: SpendingInsight): InsightEntity = InsightEntity(
+            id = insight.id,
+            title = insight.title,
+            message = insight.message,
+            type = insight.type.name,
+            category = insight.category,
+            amount = insight.amount,
+            percentChange = insight.percentChange,
+            date = insight.date.toEpochSecond(ZoneOffset.UTC) * 1000
+        )
+    }
+}

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/data/local/LocalStorageProvider.kt

@@ -0,0 +1,326 @@
+package com.appship.finance.data.local
+
+import android.content.Context
+import com.appship.finance.AppConfig
+import com.appship.finance.data.*
+import com.appship.finance.data.DataRepository
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import java.time.LocalDate
+import java.time.ZoneOffset
+import java.util.Date
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores finance data in a local SQLite database.
+ * Pre-seeds default categories from AppConfig on first launch.
+ *
+ * Call [initialize] with an Android Context before using.
+ */
+class LocalStorageProvider private constructor(
+    private val dao: AppDao,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    private val _accounts = MutableStateFlow<List<Account>>(emptyList())
+    override val accounts: StateFlow<List<Account>> = _accounts.asStateFlow()
+
+    private val _transactions = MutableStateFlow<List<Transaction>>(emptyList())
+    override val transactions: StateFlow<List<Transaction>> = _transactions.asStateFlow()
+
+    private val _budgets = MutableStateFlow<List<Budget>>(emptyList())
+    override val budgets: StateFlow<List<Budget>> = _budgets.asStateFlow()
+
+    private val _goals = MutableStateFlow<List<Goal>>(emptyList())
+    override val goals: StateFlow<List<Goal>> = _goals.asStateFlow()
+
+    private val _categories = MutableStateFlow<List<Category>>(emptyList())
+    override val categories: StateFlow<List<Category>> = _categories.asStateFlow()
+
+    private val _bills = MutableStateFlow<List<Bill>>(emptyList())
+    override val bills: StateFlow<List<Bill>> = _bills.asStateFlow()
+
+    private val _insights = MutableStateFlow<List<SpendingInsight>>(emptyList())
+    override val insights: StateFlow<List<SpendingInsight>> = _insights.asStateFlow()
+
+    // Computed properties
+    override val totalBalance: Double
+        get() = _accounts.value.sumOf { it.balance }
+
+    override val monthlyIncome: Double
+        get() {
+            val now = LocalDate.now()
+            val startOfMonth = now.withDayOfMonth(1)
+            val startMillis = startOfMonth.toEpochDay() * 24 * 60 * 60 * 1000
+            val endMillis = System.currentTimeMillis()
+            return _transactions.value
+                .filter { it.type == TransactionType.INCOME && it.date.toEpochSecond(ZoneOffset.UTC) * 1000 >= startMillis && it.date.toEpochSecond(ZoneOffset.UTC) * 1000 <= endMillis }
+                .sumOf { it.amount }
+        }
+
+    override val monthlyExpenses: Double
+        get() {
+            val now = LocalDate.now()
+            val startOfMonth = now.withDayOfMonth(1)
+            val startMillis = startOfMonth.toEpochDay() * 24 * 60 * 60 * 1000
+            val endMillis = System.currentTimeMillis()
+            return _transactions.value
+                .filter { it.type == TransactionType.EXPENSE && it.date.toEpochSecond(ZoneOffset.UTC) * 1000 >= startMillis && it.date.toEpochSecond(ZoneOffset.UTC) * 1000 <= endMillis }
+                .sumOf { it.amount }
+        }
+
+    fun loadData() {
+        scope.launch {
+            // Seed categories on first launch
+            if (dao.categoryCount() == 0) {
+                seedDefaultCategories()
+            }
+            refreshAll()
+        }
+    }
+
+    // Account operations
+    override fun getAccounts(): List<Account> = _accounts.value
+    override fun getAccount(id: String): Account? = _accounts.value.find { it.id == id }
+
+    // Transaction operations
+    override fun getTransactions(): List<Transaction> = _transactions.value
+    override fun getTransactions(accountId: String): List<Transaction> = _transactions.value.filter { it.accountId == accountId }
+    override fun createTransaction(transaction: Transaction) {
+        scope.launch {
+            dao.insertTransaction(TransactionEntity.fromTransaction(transaction))
+            refreshTransactions()
+            updateAccountBalance(transaction.accountId)
+        }
+    }
+    override fun updateTransaction(transaction: Transaction) {
+        scope.launch {
+            val oldTransaction = dao.getTransactionById(transaction.id)
+            dao.updateTransaction(TransactionEntity.fromTransaction(transaction))
+            refreshTransactions()
+            oldTransaction?.let { updateAccountBalance(it.accountId) }
+            updateAccountBalance(transaction.accountId)
+        }
+    }
+    override fun deleteTransaction(id: String) {
+        scope.launch {
+            val transaction = dao.getTransactionById(id)
+            transaction?.let {
+                dao.deleteTransaction(it)
+                refreshTransactions()
+                updateAccountBalance(it.accountId)
+            }
+        }
+    }
+
+    // Budget operations
+    override fun getBudgets(): List<Budget> = _budgets.value
+    override fun getBudget(id: String): Budget? = _budgets.value.find { it.id == id }
+    override fun createBudget(budget: Budget) {
+        scope.launch {
+            dao.insertBudget(BudgetEntity.fromBudget(budget))
+            refreshBudgets()
+        }
+    }
+    override fun updateBudget(budget: Budget) {
+        scope.launch {
+            dao.updateBudget(BudgetEntity.fromBudget(budget))
+            refreshBudgets()
+        }
+    }
+    override fun deleteBudget(id: String) {
+        scope.launch {
+            dao.getBudgetById(id)?.let {
+                dao.deleteBudget(it)
+                refreshBudgets()
+            }
+        }
+    }
+
+    // Goal operations
+    override fun getGoals(): List<Goal> = _goals.value
+    override fun getGoal(id: String): Goal? = _goals.value.find { it.id == id }
+    override fun createGoal(goal: Goal) {
+        scope.launch {
+            dao.insertGoal(GoalEntity.fromGoal(goal))
+            refreshGoals()
+        }
+    }
+    override fun updateGoal(goal: Goal) {
+        scope.launch {
+            dao.updateGoal(GoalEntity.fromGoal(goal))
+            refreshGoals()
+        }
+    }
+    override fun deleteGoal(id: String) {
+        scope.launch {
+            dao.getGoalById(id)?.let {
+                dao.deleteGoal(it)
+                refreshGoals()
+            }
+        }
+    }
+
+    // Category operations
+    override fun getCategories(): List<Category> = _categories.value
+    override fun getCategory(id: String): Category? = _categories.value.find { it.id == id }
+
+    // Query operations
+    override fun getTransactionsByCategory(categoryId: String): List<Transaction> {
+        return _transactions.value.filter { it.category == categoryId }
+    }
+    override fun getTransactionsByDateRange(start: Date, end: Date): List<Transaction> {
+        val startMillis = start.time
+        val endMillis = end.time
+        return _transactions.value.filter {
+            val transMillis = it.date.toEpochSecond(ZoneOffset.UTC) * 1000
+            transMillis >= startMillis && transMillis <= endMillis
+        }
+    }
+
+    // Analytics operations
+    override fun getBalance(): Double = totalBalance
+    override fun getTotalIncome(): Double = _transactions.value.filter { it.type == TransactionType.INCOME }.sumOf { it.amount }
+    override fun getTotalExpenses(): Double = _transactions.value.filter { it.type == TransactionType.EXPENSE }.sumOf { it.amount }
+    override fun getBudgetProgress(budgetId: String): Double {
+        val budget = _budgets.value.find { it.id == budgetId } ?: return 0.0
+        return budget.progress
+    }
+    override fun getGoalProgress(goalId: String): Double {
+        val goal = _goals.value.find { it.id == goalId } ?: return 0.0
+        return goal.progress
+    }
+
+    // Reset
+    override fun reset() {
+        scope.launch {
+            // Delete all entities
+            dao.getAllAccounts().forEach { dao.deleteAccount(it) }
+            dao.getAllTransactions().forEach { dao.deleteTransaction(it) }
+            dao.getAllBudgets().forEach { dao.deleteBudget(it) }
+            dao.getAllGoals().forEach { dao.deleteGoal(it) }
+            dao.getAllBills().forEach { dao.deleteBill(it) }
+            dao.getAllCategories().forEach { dao.deleteCategory(it) }
+            dao.getAllInsights().forEach { dao.deleteInsight(it) }
+            seedDefaultCategories()
+            refreshAll()
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private suspend fun refreshAll() {
+        refreshAccounts()
+        refreshTransactions()
+        refreshBudgets()
+        refreshGoals()
+        refreshBills()
+        refreshCategories()
+        refreshInsights()
+    }
+
+    private suspend fun refreshAccounts() {
+        _accounts.value = dao.getAllAccounts().map { it.toAccount() }
+    }
+
+    private suspend fun refreshTransactions() {
+        _transactions.value = dao.getAllTransactions().map { it.toTransaction() }
+    }
+
+    private suspend fun refreshBudgets() {
+        _budgets.value = dao.getAllBudgets().map { it.toBudget() }
+    }
+
+    private suspend fun refreshGoals() {
+        _goals.value = dao.getAllGoals().map { it.toGoal() }
+    }
+
+    private suspend fun refreshBills() {
+        _bills.value = dao.getAllBills().map { it.toBill() }
+    }
+
+    private suspend fun refreshCategories() {
+        _categories.value = dao.getAllCategories().map { it.toCategory() }
+    }
+
+    private suspend fun refreshInsights() {
+        _insights.value = dao.getAllInsights().map { it.toInsight() }
+    }
+
+    private suspend fun seedDefaultCategories() {
+        val entities = mutableListOf<CategoryEntity>()
+        var index = 0
+        for (cat in AppConfig.expenseCategories) {
+            entities.add(
+                CategoryEntity(
+                    id = "cat-expense-$index",
+                    name = cat.name,
+                    icon = cat.icon,
+                    colorValue = cat.color.value.toLong()
+                )
+            )
+            index++
+        }
+        for (cat in AppConfig.incomeCategories) {
+            entities.add(
+                CategoryEntity(
+                    id = "cat-income-$index",
+                    name = cat.name,
+                    icon = cat.icon,
+                    colorValue = cat.color.value.toLong()
+                )
+            )
+            index++
+        }
+        dao.insertCategories(entities)
+    }
+
+    private suspend fun updateAccountBalance(accountId: String) {
+        val accountEntity = dao.getAccountById(accountId) ?: return
+        val accountTransactions = dao.getTransactionsByAccount(accountId)
+        var balance: Double = 0.0
+        for (transactionEntity in accountTransactions) {
+            val transaction = transactionEntity.toTransaction()
+            when (transaction.type) {
+                TransactionType.INCOME -> balance += transaction.amount
+                TransactionType.EXPENSE -> balance -= transaction.amount
+                TransactionType.TRANSFER -> { /* Handle transfer logic if needed */ }
+            }
+        }
+        val updatedAccount = accountEntity.copy(balance = balance, lastUpdated = System.currentTimeMillis())
+        dao.updateAccount(updatedAccount)
+        refreshAccounts()
+    }
+
+    companion object {
+        @Volatile
+        private var INSTANCE: LocalStorageProvider? = null
+
+        /**
+         * Initialize with Android context. Call from Application.onCreate().
+         */
+        fun initialize(context: Context) {
+            if (INSTANCE == null) {
+                synchronized(this) {
+                    if (INSTANCE == null) {
+                        val db = AppDatabase.getInstance(context)
+                        INSTANCE = LocalStorageProvider(db.appDao()).also {
+                            it.loadData()
+                        }
+                    }
+                }
+            }
+        }
+
+        /**
+         * Returns the singleton instance. Must call [initialize] first.
+         */
+        fun getInstance(): LocalStorageProvider {
+            return INSTANCE ?: error(
+                "LocalStorageProvider not initialized. Call LocalStorageProvider.initialize(context) first."
+            )
+        }
+    }
+}

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/data/local/TransactionEntity.kt

@@ -0,0 +1,66 @@
+package com.appship.finance.data.local
+
+import androidx.compose.ui.graphics.Color
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.finance.data.Transaction
+import com.appship.finance.data.TransactionType
+import java.time.LocalDateTime
+import java.time.ZoneOffset
+
+/**
+ * Room entity for Transaction persistence.
+ */
+@Entity(tableName = "transactions")
+data class TransactionEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val amount: Double = 0.0,
+    val type: String = "",
+    val category: String = "",
+    val categoryIcon: String = "label",
+    val categoryColorValue: Long = 0,
+    val date: Long = System.currentTimeMillis(),
+    val accountId: String = "",
+    val merchant: String? = null,
+    val notes: String? = null,
+    val location: String? = null,
+    val isRecurring: Boolean = false,
+    val attachmentUrl: String? = null
+) {
+    fun toTransaction(): Transaction = Transaction(
+        id = id,
+        title = title,
+        amount = amount,
+        type = TransactionType.values().find { it.name == type } ?: TransactionType.EXPENSE,
+        category = category,
+        categoryIcon = categoryIcon,
+        categoryColor = Color(categoryColorValue),
+        date = LocalDateTime.ofEpochSecond(date / 1000, 0, ZoneOffset.UTC),
+        accountId = accountId,
+        merchant = merchant,
+        notes = notes,
+        location = location,
+        isRecurring = isRecurring,
+        attachmentUrl = attachmentUrl
+    )
+
+    companion object {
+        fun fromTransaction(transaction: Transaction): TransactionEntity = TransactionEntity(
+            id = transaction.id,
+            title = transaction.title,
+            amount = transaction.amount,
+            type = transaction.type.name,
+            category = transaction.category,
+            categoryIcon = transaction.categoryIcon,
+            categoryColorValue = transaction.categoryColor.value.toLong(),
+            date = transaction.date.toEpochSecond(ZoneOffset.UTC) * 1000,
+            accountId = transaction.accountId,
+            merchant = transaction.merchant,
+            notes = transaction.notes,
+            location = transaction.location,
+            isRecurring = transaction.isRecurring,
+            attachmentUrl = transaction.attachmentUrl
+        )
+    }
+}

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/features/budgets/BudgetsScreen.kt

@@ -23,12 +23,13 @@ import androidx.compose.ui.unit.sp
 import com.appship.finance.AppConfig
 import com.appship.finance.data.Budget
 import com.appship.finance.features.home.formatCurrency
-import com.appship.finance.mock.MockDataProvider
+import com.appship.finance.data.DataSourceResolver
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun BudgetsScreen() {
-    val budgets by MockDataProvider.budgets.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val budgets by repository.budgets.collectAsState()
     val totalBudget = budgets.sumOf { it.limit }
     val totalSpent = budgets.sumOf { it.spent }
     
@@ -68,8 +69,19 @@ fun BudgetsScreen() {
                 Text("Categories", fontWeight = FontWeight.Bold, fontSize = 18.sp)
             }
             
-            itemsIndexed(budgets) { index, budget ->
-                BudgetCard(budget = budget, testTag = "budgets_budget_${index}_card")
+            if (budgets.isEmpty()) {
+                item {
+                    com.appship.finance.core.components.EmptyStateView(
+                        config = com.appship.finance.core.components.EmptyStatePresets.noItems(
+                            message = "No budgets set up yet",
+                            onAdd = { }
+                        )
+                    )
+                }
+            } else {
+                itemsIndexed(budgets) { index, budget ->
+                    BudgetCard(budget = budget, testTag = "budgets_budget_${index}_card")
+                }
             }
         }
     }

package/templates/android/FinanceTemplate/app/src/main/kotlin/com/appship/finance/features/goals/GoalsScreen.kt

@@ -25,12 +25,13 @@ import androidx.compose.ui.unit.sp
 import com.appship.finance.AppConfig
 import com.appship.finance.data.Goal
 import com.appship.finance.features.home.formatCurrency
-import com.appship.finance.mock.MockDataProvider
+import com.appship.finance.data.DataSourceResolver
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun GoalsScreen(onGoalClick: (String) -> Unit) {
-    val goals by MockDataProvider.goals.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val goals by repository.goals.collectAsState()
     val totalSaved = goals.sumOf { it.currentAmount }
     val totalTarget = goals.sumOf { it.targetAmount }
     
@@ -70,12 +71,23 @@ fun GoalsScreen(onGoalClick: (String) -> Unit) {
                 Text("Your Goals", fontWeight = FontWeight.Bold, fontSize = 18.sp)
             }
             
-            itemsIndexed(goals) { index, goal ->
-                GoalCard(
-                    goal = goal,
-                    onClick = { onGoalClick(goal.id) },
-                    testTag = "goals_goal_${index}_card"
-                )
+            if (goals.isEmpty()) {
+                item {
+                    com.appship.finance.core.components.EmptyStateView(
+                        config = com.appship.finance.core.components.EmptyStatePresets.noItems(
+                            message = "No goals set up yet",
+                            onAdd = { }
+                        )
+                    )
+                }
+            } else {
+                itemsIndexed(goals) { index, goal ->
+                    GoalCard(
+                        goal = goal,
+                        onClick = { onGoalClick(goal.id) },
+                        testTag = "goals_goal_${index}_card"
+                    )
+                }
             }
         }
     }
@@ -220,7 +232,8 @@ fun GoalCard(goal: Goal, onClick: () -> Unit, testTag: String) {
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun GoalDetailScreen(goalId: String, onBack: () -> Unit) {
-    val goals by MockDataProvider.goals.collectAsState()
+    val repository = remember { DataSourceResolver.repository }
+    val goals by repository.goals.collectAsState()
     val goal = goals.find { it.id == goalId } ?: return
     var addAmount by remember { mutableStateOf("") }