@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/android/ShopTemplate/app/src/main/kotlin/com/appship/shop/data/local/AppDao.kt

@@ -0,0 +1,119 @@
+package com.appship.shop.data.local
+
+import androidx.room.*
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Room DAO for Category, Product, Order, Review, and Banner CRUD operations.
+ */
+@Dao
+interface AppDao {
+
+    // — Categories —
+
+    @Query("SELECT * FROM categories ORDER BY name ASC")
+    suspend fun getAllCategories(): List<CategoryEntity>
+
+    @Query("SELECT * FROM categories WHERE id = :id LIMIT 1")
+    suspend fun getCategoryById(id: String): CategoryEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertCategory(category: CategoryEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertCategories(categories: List<CategoryEntity>)
+
+    @Delete
+    suspend fun deleteCategory(category: CategoryEntity)
+
+    @Query("SELECT COUNT(*) FROM categories")
+    suspend fun categoryCount(): Int
+
+    // — Products —
+
+    @Query("SELECT * FROM products ORDER BY name ASC")
+    suspend fun getAllProducts(): List<ProductEntity>
+
+    @Query("SELECT * FROM products WHERE id = :id LIMIT 1")
+    suspend fun getProductById(id: String): ProductEntity?
+
+    @Query("SELECT * FROM products WHERE categoryId = :categoryId ORDER BY name ASC")
+    suspend fun getProductsByCategory(categoryId: String): List<ProductEntity>
+
+    @Query(
+        """SELECT * FROM products 
+           WHERE name LIKE '%' || :query || '%' 
+              OR description LIKE '%' || :query || '%'
+           ORDER BY name ASC"""
+    )
+    suspend fun searchProducts(query: String): List<ProductEntity>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertProduct(product: ProductEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertProducts(products: List<ProductEntity>)
+
+    @Update
+    suspend fun updateProduct(product: ProductEntity)
+
+    @Delete
+    suspend fun deleteProduct(product: ProductEntity)
+
+    // — Orders —
+
+    @Query("SELECT * FROM orders ORDER BY createdAt DESC")
+    suspend fun getAllOrders(): List<OrderEntity>
+
+    @Query("SELECT * FROM orders WHERE id = :id LIMIT 1")
+    suspend fun getOrderById(id: String): OrderEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertOrder(order: OrderEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertOrders(orders: List<OrderEntity>)
+
+    @Update
+    suspend fun updateOrder(order: OrderEntity)
+
+    @Delete
+    suspend fun deleteOrder(order: OrderEntity)
+
+    // — Reviews —
+
+    @Query("SELECT * FROM reviews ORDER BY createdAt DESC")
+    suspend fun getAllReviews(): List<ReviewEntity>
+
+    @Query("SELECT * FROM reviews WHERE productId = :productId ORDER BY createdAt DESC")
+    suspend fun getReviewsByProductId(productId: String): List<ReviewEntity>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertReview(review: ReviewEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertReviews(reviews: List<ReviewEntity>)
+
+    @Delete
+    suspend fun deleteReview(review: ReviewEntity)
+
+    // — Banners —
+
+    @Query("SELECT * FROM banners ORDER BY title ASC")
+    suspend fun getAllBanners(): List<BannerEntity>
+
+    @Query("SELECT * FROM banners WHERE id = :id LIMIT 1")
+    suspend fun getBannerById(id: String): BannerEntity?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertBanner(banner: BannerEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertBanners(banners: List<BannerEntity>)
+
+    @Update
+    suspend fun updateBanner(banner: BannerEntity)
+
+    @Delete
+    suspend fun deleteBanner(banner: BannerEntity)
+}

package/templates/android/ShopTemplate/app/src/main/kotlin/com/appship/shop/data/local/AppDatabase.kt

@@ -0,0 +1,40 @@
+package com.appship.shop.data.local
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+
+/**
+ * Room database for local storage.
+ * Holds CategoryEntity, ProductEntity, OrderEntity, ReviewEntity, and BannerEntity tables.
+ */
+@Database(
+    entities = [
+        CategoryEntity::class,
+        ProductEntity::class,
+        OrderEntity::class,
+        ReviewEntity::class,
+        BannerEntity::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,
+                    "shop_database"
+                ).build().also { INSTANCE = it }
+            }
+        }
+    }
+}

package/templates/android/ShopTemplate/app/src/main/kotlin/com/appship/shop/data/local/BannerEntity.kt

@@ -0,0 +1,45 @@
+package com.appship.shop.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.shop.data.models.Banner
+
+/**
+ * Room entity for Banner persistence.
+ */
+@Entity(tableName = "banners")
+data class BannerEntity(
+    @PrimaryKey val id: String,
+    val title: String = "",
+    val subtitle: String? = null,
+    val imageUrl: String = "",
+    val actionType: String = "NONE",
+    val actionValue: String = "",
+    val backgroundColor: String? = null
+) {
+    fun toBanner(): Banner {
+        return Banner(
+            id = id,
+            title = title,
+            subtitle = subtitle,
+            imageUrl = imageUrl,
+            actionType = com.appship.shop.data.models.BannerActionType.valueOf(actionType),
+            actionValue = actionValue,
+            backgroundColor = backgroundColor
+        )
+    }
+
+    companion object {
+        fun fromBanner(banner: Banner): BannerEntity {
+            return BannerEntity(
+                id = banner.id,
+                title = banner.title,
+                subtitle = banner.subtitle,
+                imageUrl = banner.imageUrl,
+                actionType = banner.actionType.name,
+                actionValue = banner.actionValue,
+                backgroundColor = banner.backgroundColor
+            )
+        }
+    }
+}

package/templates/android/ShopTemplate/app/src/main/kotlin/com/appship/shop/data/local/CategoryEntity.kt

@@ -0,0 +1,39 @@
+package com.appship.shop.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.shop.data.models.Category
+
+/**
+ * Room entity for Category persistence.
+ */
+@Entity(tableName = "categories")
+data class CategoryEntity(
+    @PrimaryKey val id: String,
+    val name: String = "",
+    val icon: String = "",
+    val image: String? = null,
+    val parentId: String? = null,
+    val productCount: Int? = null
+) {
+    fun toCategory(): Category = Category(
+        id = id,
+        name = name,
+        icon = icon,
+        image = image,
+        parentId = parentId,
+        subcategories = null,
+        productCount = productCount
+    )
+
+    companion object {
+        fun fromCategory(category: Category): CategoryEntity = CategoryEntity(
+            id = category.id,
+            name = category.name,
+            icon = category.icon,
+            image = category.image,
+            parentId = category.parentId,
+            productCount = category.productCount
+        )
+    }
+}

package/templates/android/ShopTemplate/app/src/main/kotlin/com/appship/shop/data/local/LocalStorageProvider.kt

@@ -0,0 +1,333 @@
+package com.appship.shop.data.local
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.appship.shop.AppConfig
+import com.appship.shop.data.DataRepository
+import com.appship.shop.data.local.*
+import com.appship.shop.data.models.*
+import com.appship.shop.mock.MockDataProvider
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Room-backed implementation of [DataRepository].
+ * Stores categories, products, orders, reviews, and banners in a local SQLite database.
+ * Pre-seeds default data from MockDataProvider on first launch.
+ *
+ * Call [initialize] with an Android Context before using.
+ */
+class LocalStorageProvider private constructor(
+    private val dao: AppDao,
+    private val prefs: SharedPreferences,
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+) : DataRepository {
+
+    private val _categories = MutableStateFlow<List<Category>>(emptyList())
+    override val categories: StateFlow<List<Category>> = _categories.asStateFlow()
+
+    private val _products = MutableStateFlow<List<Product>>(emptyList())
+    override val products: StateFlow<List<Product>> = _products.asStateFlow()
+
+    private val _banners = MutableStateFlow<List<Banner>>(emptyList())
+    override val banners: StateFlow<List<Banner>> = _banners.asStateFlow()
+
+    private val _favorites = MutableStateFlow<Set<String>>(emptySet())
+    override val favorites: StateFlow<Set<String>> = _favorites.asStateFlow()
+
+    private val _orders = MutableStateFlow<List<Order>>(emptyList())
+    override val orders: StateFlow<List<Order>> = _orders.asStateFlow()
+
+    override val shippingOptions: List<ShippingOption> = MockDataProvider.shippingOptions
+    override val storeLocations: List<StoreLocation> = MockDataProvider.storeLocations
+    override val sampleUser: User = MockDataProvider.sampleUser
+
+    fun loadData() {
+        scope.launch {
+            // Seed categories on first launch
+            if (dao.categoryCount() == 0) {
+                seedDefaultData()
+            }
+            refreshCategories()
+            refreshProducts()
+            refreshOrders()
+            refreshBanners()
+            loadFavorites()
+        }
+    }
+
+    override fun addCategory(category: Category) {
+        scope.launch {
+            dao.insertCategory(CategoryEntity.fromCategory(category))
+            refreshCategories()
+        }
+    }
+
+    override fun updateCategory(category: Category) {
+        scope.launch {
+            dao.insertCategory(CategoryEntity.fromCategory(category))
+            refreshCategories()
+        }
+    }
+
+    override fun deleteCategory(categoryId: String) {
+        scope.launch {
+            dao.getCategoryById(categoryId)?.let { dao.deleteCategory(it) }
+            refreshCategories()
+        }
+    }
+
+    override fun addProduct(product: Product) {
+        scope.launch {
+            dao.insertProduct(ProductEntity.fromProduct(product))
+            refreshProducts()
+            updateCategoryCounts()
+        }
+    }
+
+    override fun updateProduct(product: Product) {
+        scope.launch {
+            dao.updateProduct(ProductEntity.fromProduct(product))
+            refreshProducts()
+        }
+    }
+
+    override fun deleteProduct(productId: String) {
+        scope.launch {
+            dao.getProductById(productId)?.let { dao.deleteProduct(it) }
+            refreshProducts()
+            updateCategoryCounts()
+        }
+    }
+
+    override fun addBanner(banner: Banner) {
+        scope.launch {
+            dao.insertBanner(BannerEntity.fromBanner(banner))
+            refreshBanners()
+        }
+    }
+
+    override fun updateBanner(banner: Banner) {
+        scope.launch {
+            dao.updateBanner(BannerEntity.fromBanner(banner))
+            refreshBanners()
+        }
+    }
+
+    override fun deleteBanner(bannerId: String) {
+        scope.launch {
+            dao.getBannerById(bannerId)?.let { dao.deleteBanner(it) }
+            refreshBanners()
+        }
+    }
+
+    override fun addToFavorites(productId: String) {
+        scope.launch {
+            val currentFavorites = _favorites.value.toMutableSet()
+            currentFavorites.add(productId)
+            _favorites.value = currentFavorites
+            saveFavorites()
+        }
+    }
+
+    override fun removeFromFavorites(productId: String) {
+        scope.launch {
+            val currentFavorites = _favorites.value.toMutableSet()
+            currentFavorites.remove(productId)
+            _favorites.value = currentFavorites
+            saveFavorites()
+        }
+    }
+
+    override fun isFavorite(productId: String): Boolean {
+        return _favorites.value.contains(productId)
+    }
+
+    override fun addOrder(order: Order) {
+        scope.launch {
+            dao.insertOrder(OrderEntity.fromOrder(order))
+            refreshOrders()
+        }
+    }
+
+    override fun updateOrder(order: Order) {
+        scope.launch {
+            dao.updateOrder(OrderEntity.fromOrder(order))
+            refreshOrders()
+        }
+    }
+
+    override fun deleteOrder(orderId: String) {
+        scope.launch {
+            dao.getOrderById(orderId)?.let { dao.deleteOrder(it) }
+            refreshOrders()
+        }
+    }
+
+    override fun getOrder(orderId: String): Order? {
+        return runBlocking {
+            dao.getOrderById(orderId)?.toOrder(_products.value)
+        }
+    }
+
+    override fun reset() {
+        scope.launch {
+            // Delete all entities
+            dao.getAllCategories().forEach { dao.deleteCategory(it) }
+            dao.getAllProducts().forEach { dao.deleteProduct(it) }
+            dao.getAllOrders().forEach { dao.deleteOrder(it) }
+            dao.getAllReviews().forEach { dao.deleteReview(it) }
+            dao.getAllBanners().forEach { dao.deleteBanner(it) }
+
+            seedDefaultData()
+            _favorites.value = emptySet()
+            saveFavorites()
+
+            refreshCategories()
+            refreshProducts()
+            refreshOrders()
+            refreshBanners()
+        }
+    }
+
+    override fun getProduct(id: String): Product? {
+        return _products.value.firstOrNull { it.id == id }
+    }
+
+    override fun getProductsByCategory(categoryId: String): List<Product> {
+        return _products.value.filter { it.category.id == categoryId }
+    }
+
+    override fun searchProducts(query: String): List<Product> {
+        if (query.isBlank()) return _products.value
+        return runBlocking {
+            dao.searchProducts(query).mapNotNull { entity ->
+                _categories.value.firstOrNull { it.id == entity.categoryId }?.let {
+                    entity.toProduct(it)
+                }
+            }
+        }
+    }
+
+    override fun getFeaturedProducts(): List<Product> {
+        return _products.value.filter { (it.originalPrice ?: 0.0) > it.price }.take(10)
+    }
+
+    override fun getSaleProducts(): List<Product> {
+        return _products.value.filter { it.originalPrice != null && it.originalPrice!! > it.price }
+    }
+
+    override fun getReviews(productId: String): List<Review> {
+        return runBlocking {
+            dao.getReviewsByProductId(productId).map { it.toReview() }
+        }
+    }
+
+    // Note: DataRepository interface requires these helper methods but they're not in the interface
+    // They're implemented here for completeness
+    fun getAllReviews(): List<Review> {
+        return runBlocking {
+            dao.getAllReviews().map { it.toReview() }
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private suspend fun refreshCategories() {
+        _categories.value = dao.getAllCategories().map { it.toCategory() }
+    }
+
+    private suspend fun refreshProducts() {
+        val categoriesMap = _categories.value.associateBy { it.id }
+        _products.value = dao.getAllProducts().mapNotNull { entity ->
+            categoriesMap[entity.categoryId]?.let { entity.toProduct(it) }
+        }
+    }
+
+    private suspend fun refreshOrders() {
+        _orders.value = dao.getAllOrders().mapNotNull { it.toOrder(_products.value) }
+    }
+
+    private suspend fun refreshBanners() {
+        _banners.value = dao.getAllBanners().map { it.toBanner() }
+    }
+
+    private suspend fun seedDefaultData() {
+        // Seed categories
+        val categoryEntities = MockDataProvider.categories.value.map { CategoryEntity.fromCategory(it) }
+        dao.insertCategories(categoryEntities)
+
+        // Seed products (need categories first)
+        val categoriesMap = categoryEntities.associateBy { it.id }
+        val productEntities = MockDataProvider.products.value.map { product ->
+            ProductEntity.fromProduct(product)
+        }
+        dao.insertProducts(productEntities)
+
+        // Seed banners
+        val bannerEntities = MockDataProvider.banners.value.map { BannerEntity.fromBanner(it) }
+        dao.insertBanners(bannerEntities)
+    }
+
+    private fun loadFavorites() {
+        val favoritesJson = prefs.getString("favorites", null)
+        if (favoritesJson != null) {
+            try {
+                val gson = com.google.gson.Gson()
+                val type = object : com.google.gson.reflect.TypeToken<Set<String>>() {}.type
+                _favorites.value = gson.fromJson(favoritesJson, type) ?: emptySet()
+            } catch (_: Exception) {
+                _favorites.value = emptySet()
+            }
+        }
+    }
+
+    private fun saveFavorites() {
+        val gson = com.google.gson.Gson()
+        val json = gson.toJson(_favorites.value)
+        prefs.edit().putString("favorites", json).apply()
+    }
+
+    private suspend fun updateCategoryCounts() {
+        val categoriesMap = _categories.value.associateBy { it.id }
+        for (category in categoriesMap.values) {
+            val count = dao.getProductsByCategory(category.id).size
+            val updated = category.copy(productCount = count)
+            dao.insertCategory(CategoryEntity.fromCategory(updated))
+        }
+        refreshCategories()
+    }
+
+    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)
+                        val prefs = context.getSharedPreferences("shop_prefs", Context.MODE_PRIVATE)
+                        INSTANCE = LocalStorageProvider(db.appDao(), prefs).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/ShopTemplate/app/src/main/kotlin/com/appship/shop/data/local/OrderEntity.kt

@@ -0,0 +1,108 @@
+package com.appship.shop.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.appship.shop.data.models.Order
+import com.appship.shop.data.models.OrderStatus
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+/**
+ * Room entity for Order persistence.
+ * Stores complex nested data (items, addresses, payment method, timeline) as JSON strings.
+ */
+@Entity(tableName = "orders")
+data class OrderEntity(
+    @PrimaryKey val id: String,
+    val orderNumber: String = "",
+    val itemsJson: String = "[]",
+    val status: String = "PENDING",
+    val shippingAddressJson: String = "{}",
+    val billingAddressJson: String? = null,
+    val paymentMethodJson: String = "{}",
+    val subtotal: Double = 0.0,
+    val discount: Double = 0.0,
+    val shipping: Double = 0.0,
+    val tax: Double = 0.0,
+    val total: Double = 0.0,
+    val discountCode: String? = null,
+    val trackingNumber: String? = null,
+    val trackingUrl: String? = null,
+    val estimatedDelivery: Long? = null,
+    val createdAt: Long = System.currentTimeMillis(),
+    val updatedAt: Long = System.currentTimeMillis(),
+    val timelineJson: String? = null
+) {
+    fun toOrder(products: List<com.appship.shop.data.models.Product>): Order {
+        val gson = Gson()
+        
+        val itemsType = object : TypeToken<List<com.appship.shop.data.models.OrderItem>>() {}.type
+        val items: List<com.appship.shop.data.models.OrderItem> = gson.fromJson(itemsJson, itemsType) ?: emptyList()
+        
+        val shippingAddressType = object : TypeToken<com.appship.shop.data.models.Address>() {}.type
+        val shippingAddress: com.appship.shop.data.models.Address = gson.fromJson(shippingAddressJson, shippingAddressType)
+            ?: com.appship.shop.data.models.Address("", "", "", "", "", null, "", "", "", "", "", false)
+        
+        val billingAddress: com.appship.shop.data.models.Address? = billingAddressJson?.let {
+            gson.fromJson(it, shippingAddressType)
+        }
+        
+        val paymentMethodType = object : TypeToken<com.appship.shop.data.models.PaymentMethod>() {}.type
+        val paymentMethod: com.appship.shop.data.models.PaymentMethod = gson.fromJson(paymentMethodJson, paymentMethodType)
+            ?: com.appship.shop.data.models.PaymentMethod("", com.appship.shop.data.models.PaymentMethodType.CASH)
+        
+        val timeline: List<com.appship.shop.data.models.OrderTimelineEvent>? = timelineJson?.let {
+            val timelineType = object : TypeToken<List<com.appship.shop.data.models.OrderTimelineEvent>>() {}.type
+            gson.fromJson(it, timelineType)
+        }
+        
+        return Order(
+            id = id,
+            orderNumber = orderNumber,
+            items = items,
+            status = OrderStatus.valueOf(status),
+            shippingAddress = shippingAddress,
+            billingAddress = billingAddress,
+            paymentMethod = paymentMethod,
+            subtotal = subtotal,
+            discount = discount,
+            shipping = shipping,
+            tax = tax,
+            total = total,
+            discountCode = discountCode,
+            trackingNumber = trackingNumber,
+            trackingUrl = trackingUrl,
+            estimatedDelivery = estimatedDelivery,
+            createdAt = createdAt,
+            updatedAt = updatedAt,
+            timeline = timeline
+        )
+    }
+
+    companion object {
+        fun fromOrder(order: Order): OrderEntity {
+            val gson = Gson()
+            return OrderEntity(
+                id = order.id,
+                orderNumber = order.orderNumber,
+                itemsJson = gson.toJson(order.items),
+                status = order.status.name,
+                shippingAddressJson = gson.toJson(order.shippingAddress),
+                billingAddressJson = order.billingAddress?.let { gson.toJson(it) },
+                paymentMethodJson = gson.toJson(order.paymentMethod),
+                subtotal = order.subtotal,
+                discount = order.discount,
+                shipping = order.shipping,
+                tax = order.tax,
+                total = order.total,
+                discountCode = order.discountCode,
+                trackingNumber = order.trackingNumber,
+                trackingUrl = order.trackingUrl,
+                estimatedDelivery = order.estimatedDelivery,
+                createdAt = order.createdAt,
+                updatedAt = order.updatedAt,
+                timelineJson = order.timeline?.let { gson.toJson(it) }
+            )
+        }
+    }
+}