@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/AppDao.kt

@@ -0,0 +1,138 @@
+package com.appship.family.data.local
+
+import androidx.room.*
+
+/**
+ * Room DAO for FamilyMember, Chore, Reward, CalendarEvent, Milestone, Photo, and LocationUpdate CRUD operations.
+ */
+@Dao
+interface AppDao {
+
+    // — FamilyMembers —
+
+    @Query("SELECT * FROM family_members ORDER BY name ASC")
+    suspend fun getAllMembers(): List<FamilyMemberEntity>
+
+    @Query("SELECT * FROM family_members WHERE id = :id LIMIT 1")
+    suspend fun getMemberById(id: String): FamilyMemberEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertMember(member: FamilyMemberEntity)
+
+    @Update
+    suspend fun updateMember(member: FamilyMemberEntity)
+
+    @Delete
+    suspend fun deleteMember(member: FamilyMemberEntity)
+
+    // — Chores —
+
+    @Query("SELECT * FROM chores ORDER BY createdAtMillis DESC")
+    suspend fun getAllChores(): List<ChoreEntity>
+
+    @Query("SELECT * FROM chores WHERE id = :id LIMIT 1")
+    suspend fun getChoreById(id: String): ChoreEntity?
+
+    @Query("SELECT * FROM chores WHERE assignedTo = :memberId ORDER BY createdAtMillis DESC")
+    suspend fun getChoresByMember(memberId: String): List<ChoreEntity>
+
+    @Query("SELECT * FROM chores WHERE isCompleted = 0 ORDER BY createdAtMillis DESC")
+    suspend fun getPendingChores(): List<ChoreEntity>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertChore(chore: ChoreEntity)
+
+    @Update
+    suspend fun updateChore(chore: ChoreEntity)
+
+    @Delete
+    suspend fun deleteChore(chore: ChoreEntity)
+
+    // — Rewards —
+
+    @Query("SELECT * FROM rewards ORDER BY createdAtMillis DESC")
+    suspend fun getAllRewards(): List<RewardEntity>
+
+    @Query("SELECT * FROM rewards WHERE id = :id LIMIT 1")
+    suspend fun getRewardById(id: String): RewardEntity?
+
+    @Query("SELECT * FROM rewards WHERE isRedeemed = 0 ORDER BY createdAtMillis DESC")
+    suspend fun getAvailableRewards(): List<RewardEntity>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertReward(reward: RewardEntity)
+
+    @Update
+    suspend fun updateReward(reward: RewardEntity)
+
+    @Delete
+    suspend fun deleteReward(reward: RewardEntity)
+
+    // — CalendarEvents —
+
+    @Query("SELECT * FROM calendar_events ORDER BY dateMillis ASC")
+    suspend fun getAllEvents(): List<CalendarEventEntity>
+
+    @Query("SELECT * FROM calendar_events WHERE id = :id LIMIT 1")
+    suspend fun getEventById(id: String): CalendarEventEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertEvent(event: CalendarEventEntity)
+
+    @Update
+    suspend fun updateEvent(event: CalendarEventEntity)
+
+    @Delete
+    suspend fun deleteEvent(event: CalendarEventEntity)
+
+    // — Milestones —
+
+    @Query("SELECT * FROM milestones ORDER BY dateMillis DESC")
+    suspend fun getAllMilestones(): List<MilestoneEntity>
+
+    @Query("SELECT * FROM milestones WHERE id = :id LIMIT 1")
+    suspend fun getMilestoneById(id: String): MilestoneEntity?
+
+    @Query("SELECT * FROM milestones WHERE memberId = :memberId ORDER BY dateMillis DESC")
+    suspend fun getMilestonesByMember(memberId: String): List<MilestoneEntity>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertMilestone(milestone: MilestoneEntity)
+
+    @Update
+    suspend fun updateMilestone(milestone: MilestoneEntity)
+
+    @Delete
+    suspend fun deleteMilestone(milestone: MilestoneEntity)
+
+    // — Photos —
+
+    @Query("SELECT * FROM photos ORDER BY uploadedAtMillis DESC")
+    suspend fun getAllPhotos(): List<PhotoEntity>
+
+    @Query("SELECT * FROM photos WHERE id = :id LIMIT 1")
+    suspend fun getPhotoById(id: String): PhotoEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertPhoto(photo: PhotoEntity)
+
+    @Update
+    suspend fun updatePhoto(photo: PhotoEntity)
+
+    @Delete
+    suspend fun deletePhoto(photo: PhotoEntity)
+
+    // — LocationUpdates —
+
+    @Query("SELECT * FROM location_updates ORDER BY timestampMillis DESC")
+    suspend fun getAllLocationUpdates(): List<LocationUpdateEntity>
+
+    @Query("SELECT * FROM location_updates WHERE id = :id LIMIT 1")
+    suspend fun getLocationUpdateById(id: String): LocationUpdateEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertLocationUpdate(location: LocationUpdateEntity)
+
+    @Delete
+    suspend fun deleteLocationUpdate(location: LocationUpdateEntity)
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/AppDatabase.kt

@@ -0,0 +1,42 @@
+package com.appship.family.data.local
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+
+/**
+ * Room database for local storage.
+ * Holds FamilyMemberEntity, ChoreEntity, RewardEntity, CalendarEventEntity, MilestoneEntity, PhotoEntity, and LocationUpdateEntity tables.
+ */
+@Database(
+    entities = [
+        FamilyMemberEntity::class,
+        ChoreEntity::class,
+        RewardEntity::class,
+        CalendarEventEntity::class,
+        MilestoneEntity::class,
+        PhotoEntity::class,
+        LocationUpdateEntity::class
+    ],
+    version = 1,
+    exportSchema = false
+)
+abstract class AppDatabase : RoomDatabase() {
+    abstract fun appDao(): AppDao
+
+    companion object {
+        @Volatile
+        private var INSTANCE: AppDatabase? = null
+
+        fun getInstance(context: Context): AppDatabase {
+            return INSTANCE ?: synchronized(this) {
+                INSTANCE ?: Room.databaseBuilder(
+                    context.applicationContext,
+                    AppDatabase::class.java,
+                    "family_database"
+                ).build().also { INSTANCE = it }
+            }
+        }
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/CalendarEventEntity.kt

@@ -0,0 +1,55 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.CalendarEvent
+import com.appship.family.data.CalendarEventType
+import com.google.gson.Gson
+import java.util.Date
+
+/**
+ * Room entity for CalendarEvent persistence.
+ */
+@Entity(tableName = "calendar_events")
+data class CalendarEventEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val dateMillis: Long = System.currentTimeMillis(),
+    val membersJson: String = "[]",
+    val type: String = "FAMILY",
+    val description: String? = null,
+    val location: String? = null,
+    val createdAtMillis: Long = System.currentTimeMillis()
+) {
+    fun toCalendarEvent(): CalendarEvent = CalendarEvent(
+        id = id,
+        title = title,
+        date = Date(dateMillis),
+        members = parseJsonArray(membersJson),
+        type = CalendarEventType.valueOf(type),
+        description = description,
+        location = location,
+        createdAt = Date(createdAtMillis)
+    )
+
+    private fun parseJsonArray(json: String): List<String> {
+        return try {
+            Gson().fromJson(json, Array<String>::class.java)?.toList() ?: emptyList()
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    companion object {
+        fun fromCalendarEvent(event: CalendarEvent): CalendarEventEntity = CalendarEventEntity(
+            id = event.id,
+            title = event.title,
+            dateMillis = event.date.time,
+            membersJson = Gson().toJson(event.members),
+            type = event.type.name,
+            description = event.description,
+            location = event.location,
+            createdAtMillis = event.createdAt.time
+        )
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/ChoreEntity.kt

@@ -0,0 +1,58 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.Chore
+import com.appship.family.data.ChoreFrequency
+import java.util.Date
+
+/**
+ * Room entity for Chore persistence.
+ */
+@Entity(tableName = "chores")
+data class ChoreEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val description: String? = null,
+    val assignedTo: String? = null,
+    val points: Int = 0,
+    val frequency: String = "",
+    val isCompleted: Boolean = false,
+    val dueDateMillis: Long? = null,
+    val completedAtMillis: Long? = null,
+    val completedBy: String? = null,
+    val createdAtMillis: Long = System.currentTimeMillis(),
+    val requiresApproval: Boolean = false
+) {
+    fun toChore(): Chore = Chore(
+        id = id,
+        title = title,
+        description = description,
+        assignedTo = assignedTo,
+        points = points,
+        frequency = ChoreFrequency.values().find { it.name == frequency } ?: ChoreFrequency.ONE_TIME,
+        isCompleted = isCompleted,
+        dueDate = dueDateMillis?.let { Date(it) },
+        completedAt = completedAtMillis?.let { Date(it) },
+        completedBy = completedBy,
+        createdAt = Date(createdAtMillis),
+        requiresApproval = requiresApproval
+    )
+
+    companion object {
+        fun fromChore(chore: Chore): ChoreEntity = ChoreEntity(
+            id = chore.id,
+            title = chore.title,
+            description = chore.description,
+            assignedTo = chore.assignedTo,
+            points = chore.points,
+            frequency = chore.frequency.name,
+            isCompleted = chore.isCompleted,
+            dueDateMillis = chore.dueDate?.time,
+            completedAtMillis = chore.completedAt?.time,
+            completedBy = chore.completedBy,
+            createdAtMillis = chore.createdAt.time,
+            requiresApproval = chore.requiresApproval
+        )
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/FamilyMemberEntity.kt

@@ -0,0 +1,52 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.FamilyMember
+import com.appship.family.data.MemberRole
+import com.google.gson.Gson
+import java.util.Date
+
+/**
+ * Room entity for FamilyMember persistence.
+ */
+@Entity(tableName = "family_members")
+data class FamilyMemberEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val avatarURL: String? = null,
+    val role: String = "",
+    val points: Int = 0,
+    val choresJson: String = "[]",
+    val createdAtMillis: Long = System.currentTimeMillis()
+) {
+    fun toFamilyMember(): FamilyMember = FamilyMember(
+        id = id,
+        name = name,
+        avatarURL = avatarURL,
+        role = MemberRole.values().find { it.name == role } ?: MemberRole.CHILD,
+        points = points,
+        chores = parseJsonArray(choresJson),
+        createdAt = Date(createdAtMillis)
+    )
+
+    private fun parseJsonArray(json: String): List<String> {
+        return try {
+            Gson().fromJson(json, Array<String>::class.java)?.toList() ?: emptyList()
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    companion object {
+        fun fromFamilyMember(member: FamilyMember): FamilyMemberEntity = FamilyMemberEntity(
+            id = member.id,
+            name = member.name,
+            avatarURL = member.avatarURL,
+            role = member.role.name,
+            points = member.points,
+            choresJson = Gson().toJson(member.chores),
+            createdAtMillis = member.createdAt.time
+        )
+    }
+}

package/templates/android/FamilyTemplate/app/src/main/java/com/appship/family/data/local/LocalStorageProvider.kt

@@ -0,0 +1,301 @@
+package com.appship.family.data.local
+
+import android.content.Context
+import com.appship.family.data.*
+import com.appship.family.data.DataRepository
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import java.util.Calendar
+import java.util.Date
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores family members, chores, rewards, calendar events, milestones, photos, and location updates in a local SQLite database.
+ *
+ * Call [initialize] with an Android Context before using.
+ */
+class LocalStorageProvider private constructor(
+    private val dao: AppDao,
+    private val context: Context,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    private val _members = MutableStateFlow<List<FamilyMember>>(emptyList())
+    override val members: StateFlow<List<FamilyMember>> = _members.asStateFlow()
+
+    override val chores: List<Chore>
+        get() = runBlocking {
+            dao.getAllChores().map { it.toChore() }
+        }
+
+    override val rewards: List<Reward>
+        get() = runBlocking {
+            dao.getAllRewards().map { it.toReward() }
+        }
+
+    override val calendarEvents: List<CalendarEvent>
+        get() = runBlocking {
+            dao.getAllEvents().map { it.toCalendarEvent() }
+        }
+
+    override val milestones: List<Milestone>
+        get() = runBlocking {
+            dao.getAllMilestones().map { it.toMilestone() }
+        }
+
+    override val photos: List<Photo>
+        get() = runBlocking {
+            dao.getAllPhotos().map { it.toPhoto() }
+        }
+
+    override val locationUpdates: List<LocationUpdate>
+        get() = runBlocking {
+            dao.getAllLocationUpdates().map { it.toLocationUpdate() }
+        }
+
+    override fun createMember(member: FamilyMember) {
+        scope.launch {
+            dao.insertMember(FamilyMemberEntity.fromFamilyMember(member))
+            refreshMembers()
+        }
+    }
+
+    override fun updateMember(member: FamilyMember) {
+        scope.launch {
+            dao.updateMember(FamilyMemberEntity.fromFamilyMember(member))
+            refreshMembers()
+        }
+    }
+
+    override fun deleteMember(member: FamilyMember) {
+        scope.launch {
+            dao.deleteMember(FamilyMemberEntity.fromFamilyMember(member))
+            refreshMembers()
+        }
+    }
+
+    override fun memberById(id: String): FamilyMember? {
+        return runBlocking {
+            dao.getMemberById(id)?.toFamilyMember()
+        }
+    }
+
+    override fun createChore(chore: Chore) {
+        scope.launch {
+            dao.insertChore(ChoreEntity.fromChore(chore))
+        }
+    }
+
+    override fun updateChore(chore: Chore) {
+        scope.launch {
+            dao.updateChore(ChoreEntity.fromChore(chore))
+        }
+    }
+
+    override fun deleteChore(chore: Chore) {
+        scope.launch {
+            dao.deleteChore(ChoreEntity.fromChore(chore))
+        }
+    }
+
+    override fun completeChore(chore: Chore, memberId: String) {
+        scope.launch {
+            val updated = chore.copy(
+                isCompleted = true,
+                completedAt = Date(),
+                completedBy = memberId
+            )
+            dao.updateChore(ChoreEntity.fromChore(updated))
+
+            // Award points
+            memberById(memberId)?.let { member ->
+                updateMember(member.copy(points = member.points + chore.points))
+            }
+        }
+    }
+
+    override fun choresForMember(memberId: String): List<Chore> {
+        return runBlocking {
+            dao.getChoresByMember(memberId).map { it.toChore() }
+        }
+    }
+
+    override fun pendingChores(): List<Chore> {
+        return runBlocking {
+            dao.getPendingChores().map { it.toChore() }
+        }
+    }
+
+    override fun createReward(reward: Reward) {
+        scope.launch {
+            dao.insertReward(RewardEntity.fromReward(reward))
+        }
+    }
+
+    override fun updateReward(reward: Reward) {
+        scope.launch {
+            dao.updateReward(RewardEntity.fromReward(reward))
+        }
+    }
+
+    override fun deleteReward(reward: Reward) {
+        scope.launch {
+            dao.deleteReward(RewardEntity.fromReward(reward))
+        }
+    }
+
+    override fun redeemReward(reward: Reward, memberId: String): Boolean {
+        return runBlocking {
+            val member = memberById(memberId) ?: return@runBlocking false
+            if (member.points < reward.pointsCost || reward.isRedeemed) return@runBlocking false
+
+            val updatedReward = reward.copy(
+                isRedeemed = true,
+                redeemedBy = memberId,
+                redeemedAt = Date()
+            )
+            dao.updateReward(RewardEntity.fromReward(updatedReward))
+
+            updateMember(member.copy(points = member.points - reward.pointsCost))
+            true
+        }
+    }
+
+    override fun availableRewards(): List<Reward> {
+        return runBlocking {
+            dao.getAvailableRewards().map { it.toReward() }
+        }
+    }
+
+    override fun createEvent(event: CalendarEvent) {
+        scope.launch {
+            dao.insertEvent(CalendarEventEntity.fromCalendarEvent(event))
+        }
+    }
+
+    override fun updateEvent(event: CalendarEvent) {
+        scope.launch {
+            dao.updateEvent(CalendarEventEntity.fromCalendarEvent(event))
+        }
+    }
+
+    override fun deleteEvent(event: CalendarEvent) {
+        scope.launch {
+            dao.deleteEvent(CalendarEventEntity.fromCalendarEvent(event))
+        }
+    }
+
+    override fun eventsForDate(date: Date): List<CalendarEvent> {
+        return runBlocking {
+            val calendar = Calendar.getInstance()
+            calendar.time = date
+            val dayOfYear = calendar.get(Calendar.DAY_OF_YEAR)
+            val year = calendar.get(Calendar.YEAR)
+
+            dao.getAllEvents().map { it.toCalendarEvent() }.filter {
+                val eventCalendar = Calendar.getInstance()
+                eventCalendar.time = it.date
+                eventCalendar.get(Calendar.DAY_OF_YEAR) == dayOfYear &&
+                        eventCalendar.get(Calendar.YEAR) == year
+            }
+        }
+    }
+
+    override fun createMilestone(milestone: Milestone) {
+        scope.launch {
+            dao.insertMilestone(MilestoneEntity.fromMilestone(milestone))
+        }
+    }
+
+    override fun updateMilestone(milestone: Milestone) {
+        scope.launch {
+            dao.updateMilestone(MilestoneEntity.fromMilestone(milestone))
+        }
+    }
+
+    override fun deleteMilestone(milestone: Milestone) {
+        scope.launch {
+            dao.deleteMilestone(MilestoneEntity.fromMilestone(milestone))
+        }
+    }
+
+    override fun milestonesForMember(memberId: String): List<Milestone> {
+        return runBlocking {
+            dao.getMilestonesByMember(memberId).map { it.toMilestone() }
+        }
+    }
+
+    override fun createPhoto(photo: Photo) {
+        scope.launch {
+            dao.insertPhoto(PhotoEntity.fromPhoto(photo))
+        }
+    }
+
+    override fun updatePhoto(photo: Photo) {
+        scope.launch {
+            dao.updatePhoto(PhotoEntity.fromPhoto(photo))
+        }
+    }
+
+    override fun deletePhoto(photo: Photo) {
+        scope.launch {
+            dao.deletePhoto(PhotoEntity.fromPhoto(photo))
+        }
+    }
+
+    override fun reset() {
+        scope.launch {
+            // Clear all data
+            dao.getAllMembers().forEach { dao.deleteMember(it) }
+            dao.getAllChores().forEach { dao.deleteChore(it) }
+            dao.getAllRewards().forEach { dao.deleteReward(it) }
+            dao.getAllEvents().forEach { dao.deleteEvent(it) }
+            dao.getAllMilestones().forEach { dao.deleteMilestone(it) }
+            dao.getAllPhotos().forEach { dao.deletePhoto(it) }
+            dao.getAllLocationUpdates().forEach { dao.deleteLocationUpdate(it) }
+            refreshMembers()
+        }
+    }
+
+    fun loadData() {
+        scope.launch {
+            refreshMembers()
+        }
+    }
+
+    private suspend fun refreshMembers() {
+        _members.value = dao.getAllMembers().map { it.toFamilyMember() }
+    }
+
+    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(), context).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/FamilyTemplate/app/src/main/java/com/appship/family/data/local/LocationUpdateEntity.kt

@@ -0,0 +1,39 @@
+package com.appship.family.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.family.data.LocationUpdate
+import java.util.Date
+
+/**
+ * Room entity for LocationUpdate persistence.
+ */
+@Entity(tableName = "location_updates")
+data class LocationUpdateEntity(
+    @PrimaryKey val id: String,
+    val memberId: String = "",
+    val latitude: Double = 0.0,
+    val longitude: Double = 0.0,
+    val timestampMillis: Long = System.currentTimeMillis(),
+    val address: String? = null
+) {
+    fun toLocationUpdate(): LocationUpdate = LocationUpdate(
+        id = id,
+        memberId = memberId,
+        latitude = latitude,
+        longitude = longitude,
+        timestamp = Date(timestampMillis),
+        address = address
+    )
+
+    companion object {
+        fun fromLocationUpdate(location: LocationUpdate): LocationUpdateEntity = LocationUpdateEntity(
+            id = location.id,
+            memberId = location.memberId,
+            latitude = location.latitude,
+            longitude = location.longitude,
+            timestampMillis = location.timestamp.time,
+            address = location.address
+        )
+    }
+}