refactor & documentation: documentation for necessary places, and small refactoring

Author: f-arslan

app/src/main/java/com/patika/getir_lite/data/ProductRepository.kt

@@ -1,21 +1,85 @@
 package com.patika.getir_lite.data
 
 import com.patika.getir_lite.model.BaseResponse
-import com.patika.getir_lite.model.BasketWithProducts
+import com.patika.getir_lite.data.local.model.BasketWithProducts
+import com.patika.getir_lite.data.local.model.StatusEntity
 import com.patika.getir_lite.model.CountType
+import com.patika.getir_lite.model.ProductType
 import com.patika.getir_lite.model.Order
 import com.patika.getir_lite.model.ProductWithCount
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.StateFlow
 
+/**
+ * Defines the interface for handling product and order data operations. Implementations of this interface
+ * should manage data fetching, caching, and business logic associated with product management in the application.
+ */
 interface ProductRepository {
-    val dataSyncResult: StateFlow<List<DataSyncResult>>
+
+    /**
+     * Retrieves a flow of all products filtered by [ProductType.PRODUCT].
+     *
+     * @return A [Flow] emitting a list of [ProductWithCount] reflecting the current state of available products.
+     */
     fun getProductsAsFlow(): Flow<List<ProductWithCount>>
-    suspend fun syncWithRemote(): BaseResponse<Unit>
+
+    /**
+     * Initiates a fetch for product data from remote sources, typically involving network requests to an API.
+     * This method should handle synchronization of local data with remote data.
+     *
+     * @return A [BaseResponse] indicating the success or failure of the fetch operation.
+     */
+    suspend fun fetchDataFromRemote(): BaseResponse<Unit>
+
+    /**
+     * Retrieves a flow of suggested products, often used for displaying recommendations or promotions.
+     *
+     * @return A [Flow] emitting a list of [ProductWithCount] reflecting the current state of suggested products.
+     */
     fun getSuggestedProductsAsFlow(): Flow<List<ProductWithCount>>
+
+    /**
+     * Retrieves a flow of the current active basket or order, providing continuous updates as the basket's state changes.
+     *
+     * @return A [Flow] emitting an [Order] representing the active basket, or null if no basket is active.
+     */
     fun getBasketAsFlow(): Flow<Order?>
+
+    /**
+     * Retrieves a flow of the current basket along with detailed product information contained within it.
+     * This is particularly useful for checkout screens where detailed information about each item in the basket is required.
+     *
+     * @return A [Flow] emitting a [BasketWithProducts] representing the active basket with its associated products, or null if no basket is active.
+     */
     fun getBasketWithProductsAsFlow(): Flow<BasketWithProducts?>
+
+    /**
+     * Retrieves a flow of a specific product by its ID, providing continuous updates as the product's details or state changes.
+     *
+     * @param productId The unique identifier of the product to fetch.
+     * @return A [Flow] emitting [ProductWithCount] for the specified product, or null if the product does not exist.
+     */
     fun getProductAsFlow(productId: Long): Flow<ProductWithCount?>
-    suspend fun updateItemCount(productId: Long, countType: CountType)
+
+    /**
+     * Updates the item count for a specific product in an active basket, handling either increment or decrement operations.
+     * This method is intended to facilitate immediate updates to basket contents based on user actions.
+     *
+     * @param productId The product ID whose count will be updated.
+     * @param countType The type of count update to perform (add one or subtract one).
+     * @return A [Result] encapsulating the success or failure of the update operation.
+     */
+    suspend fun updateItemCount(productId: Long, countType: CountType): Result<Unit>
+
+    /**
+     * Clears all items from the active basket, typically invoked when a user cancels the basket or completes an order.
+     * This operation may also trigger updates to associated data such as inventory levels or user profiles.
+     *
+     * @return A [Boolean] indicating whether the basket was successfully cleared.
+     */
     suspend fun clearBasket(): Boolean
+
+    /**
+     * Get the current status of the database
+     */
+    suspend fun getStatus(): List<StatusEntity?>
 }

app/src/main/java/com/patika/getir_lite/data/local/ProductDatabase.kt

@@ -6,10 +6,17 @@ import androidx.room.TypeConverters
 import com.patika.getir_lite.data.local.model.ItemEntity
 import com.patika.getir_lite.data.local.model.ProductEntity
 import com.patika.getir_lite.data.local.model.OrderEntity
+import com.patika.getir_lite.data.local.model.StatusEntity
 import com.patika.getir_lite.util.BigDecimalConverter
 
+/**
+ * This class defines the Room database setup including the entities involved and the database version.
+ * It also specifies a type converter to handle specific data types that Room cannot handle natively.
+ *
+ * @property productDto Provides access to [ProductDao], which contains methods for accessing and manipulating product-related data stored in the database.
+ */
 @Database(
-    entities = [OrderEntity::class, ProductEntity::class, ItemEntity::class],
+    entities = [OrderEntity::class, ProductEntity::class, ItemEntity::class, StatusEntity::class],
     version = 1,
     exportSchema = false
 )

app/src/main/java/com/patika/getir_lite/model/BasketWithProducts.kt renamed to app/src/main/java/com/patika/getir_lite/data/local/model/BasketWithProducts.kt

@@ -1,10 +1,7 @@
-package com.patika.getir_lite.model
+package com.patika.getir_lite.data.local.model
 
 import androidx.room.Embedded
 import androidx.room.Relation
-import com.patika.getir_lite.data.local.model.ItemEntity
-import com.patika.getir_lite.data.local.model.ItemWithProduct
-import com.patika.getir_lite.data.local.model.OrderEntity
 
 data class BasketWithProducts(
     @Embedded val order: OrderEntity,

app/src/main/java/com/patika/getir_lite/data/local/model/ItemWithProduct.kt

@@ -20,5 +20,5 @@ fun ItemWithProduct.toProductWithCount() = ProductWithCount(
     attribute = product.attribute,
     imageURL = product.imageURL,
     count = item.count,
-    productType = product.productType
+    type = product.productType
 )

app/src/main/java/com/patika/getir_lite/data/remote/RemoteDataSource.kt

@@ -15,6 +15,14 @@ import kotlinx.coroutines.withContext
 import retrofit2.Response
 import javax.inject.Inject
 
+/**
+ * A data source for fetching product-related data from a remote server.
+ * This class implements the [RemoteRepository] interface, providing methods to fetch product and suggested product data
+ * and handling the conversion of network responses into application-specific response types.
+ *
+ * @property productApi The API service interface for making network requests.
+ * @property ioDispatcher A [CoroutineDispatcher] for running operations on a background thread, typically I/O operations like network requests.
+ */
 class RemoteDataSource @Inject constructor(
     private val productApi: ProductApi,
     @Dispatcher(IO) private val ioDispatcher: CoroutineDispatcher

app/src/main/java/com/patika/getir_lite/data/remote/RemoteRepository.kt

@@ -4,7 +4,23 @@ import com.patika.getir_lite.data.remote.model.ProductDto
 import com.patika.getir_lite.data.remote.model.SuggestedProductDto
 import com.patika.getir_lite.model.BaseResponse
 
+/**
+ * Interface defining the methods for fetching data from a remote server. Implementations should handle
+ * network interactions to retrieve product and suggested product data, returning it in a standardized response format.
+ */
 interface RemoteRepository {
+
+    /**
+     * Fetches a list of products from the remote server.
+     *
+     * @return A [BaseResponse] containing a list of [ProductDto] if the fetch is successful, encapsulating the data or error state.
+     */
     suspend fun getProductDtos(): BaseResponse<List<ProductDto>>
+
+    /**
+     * Fetches a list of suggested products from the remote server.
+     *
+     * @return A [BaseResponse] containing a list of [SuggestedProductDto] if the fetch is successful, encapsulating the data or error state.
+     */
     suspend fun getSuggestedProductDtos(): BaseResponse<List<SuggestedProductDto>>
 }

app/src/main/java/com/patika/getir_lite/fake/FakeProductDataSource.kt

@@ -1,6 +1,5 @@
 package com.patika.getir_lite.fake
 
-import com.patika.getir_lite.data.DataSyncResult
 import com.patika.getir_lite.data.ProductRepository
 import com.patika.getir_lite.data.local.model.ItemEntity
 import com.patika.getir_lite.data.local.model.ItemWithProduct
@@ -10,63 +9,53 @@ import com.patika.getir_lite.data.local.model.ProductEntity
 import com.patika.getir_lite.data.local.model.toDomainModel
 import com.patika.getir_lite.fake.data.fakeProductWithCounts
 import com.patika.getir_lite.model.BaseResponse
-import com.patika.getir_lite.model.BasketWithProducts
+import com.patika.getir_lite.data.local.model.BasketWithProducts
+import com.patika.getir_lite.data.local.model.StatusEntity
 import com.patika.getir_lite.model.CountType
 import com.patika.getir_lite.model.Order
 import com.patika.getir_lite.model.ProductType
 import com.patika.getir_lite.model.ProductWithCount
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.flow
 import java.math.BigDecimal
 
+/**
+ * A mock implementation of [ProductRepository] for use in tests or development environments.
+ * This class simulates the behavior of a real product repository by storing and managing in-memory lists of products and orders.
+ */
 class FakeProductDataSource : ProductRepository {
     private val localProducts = fakeProductWithCounts.toMutableList()
     val orders = mutableListOf<OrderEntity>()
     private val items = mutableListOf<ItemEntity>()
 
-    private val _dataSyncResult = MutableStateFlow<List<DataSyncResult>>(emptyList())
-    override val dataSyncResult: StateFlow<List<DataSyncResult>> = _dataSyncResult
-
-    override suspend fun syncWithRemote(): BaseResponse<Unit> {
+    override suspend fun fetchDataFromRemote(): BaseResponse<Unit> {
         return BaseResponse.Success(Unit)
     }
 
     override fun getProductsAsFlow(): Flow<List<ProductWithCount>> = flow {
-        emit(localProducts.filter { it.productType == ProductType.PRODUCT })
+        emit(localProducts.filter { it.type == ProductType.PRODUCT })
     }
 
     override fun getSuggestedProductsAsFlow(): Flow<List<ProductWithCount>> = flow {
-        emit(localProducts.filter { it.productType == ProductType.SUGGESTED_PRODUCT })
+        emit(localProducts.filter { it.type == ProductType.SUGGESTED_PRODUCT })
     }
 
     override fun getBasketAsFlow(): Flow<Order?> = flow {
         emit(orders.firstOrNull { it.orderStatus == OrderStatus.ON_BASKET }?.toDomainModel())
     }
 
-    fun ProductWithCount.toProductEntity(): ProductEntity {
-        return ProductEntity(
-            id = productId,
-            productId = "",
-            name = name,
-            price = price,
-            attribute = attribute ?: "",
-            imageURL = imageURL,
-            productType = productType,
-        )
-    }
-
     override fun getBasketWithProductsAsFlow(): Flow<BasketWithProducts?> = flow {
         val order = orders.firstOrNull { it.orderStatus == OrderStatus.ON_BASKET }
             ?: return@flow emit(null)
+
         val items = items.filter { it.orderId == order.id }
         val products = localProducts.filter { product ->
             items.any { it.productId == product.productId }
         }
+
         val itemWithProducts = items.map { item ->
             val product = products.find { it.productId == item.productId }
-                ?: throw Exception("Product not found")
+                ?: throw Exception("Product not found: ${item.productId}")
             ItemWithProduct(item, product.toProductEntity())
         }
         emit(BasketWithProducts(order, itemWithProducts))
@@ -96,22 +85,24 @@ class FakeProductDataSource : ProductRepository {
             items.add(item)
         }
 
-        val order = orders.find { it.id == orderId } ?: throw Exception("Order not found")
+        val order = orders.find { it.id == orderId } ?: throw Exception("Order not found: $orderId")
         val updatedOrder =
             order.copy(totalPrice = (order.totalPrice.toDouble() + price.toDouble()).toBigDecimal())
         val orderIndex = orders.indexOf(order)
         orders[orderIndex] = updatedOrder
 
         val product =
-            localProducts.find { it.productId == productId } ?: throw Exception("Product not found")
+            localProducts.find { it.productId == productId }
+                ?: throw Exception("Product not found $productId")
         val updatedProduct = product.copy(count = product.count + 1)
         val productIndex = localProducts.indexOf(product)
         localProducts[productIndex] = updatedProduct
     }
 
     private fun decrementItemCount(productId: Long, orderId: Long, price: BigDecimal) {
         val itemEntity =
-            getItemByProductAndOrder(productId, orderId) ?: throw Exception("Item not found")
+            getItemByProductAndOrder(productId, orderId)
+                ?: throw Exception("Item not found: productId=$productId, orderId=$orderId")
         val c = itemEntity.count - 1
         val updatedItem = itemEntity.copy(count = c)
         val index = items.indexOf(itemEntity)
@@ -121,7 +112,7 @@ class FakeProductDataSource : ProductRepository {
             items.removeAt(index)
         }
 
-        val order = orders.find { it.id == orderId } ?: throw Exception("Order not found")
+        val order = orders.find { it.id == orderId } ?: throw Exception("Order not found: $orderId")
         val updatedOrder =
             order.copy(totalPrice = (order.totalPrice.toDouble() - price.toDouble()).toBigDecimal())
         val orderIndex = orders.indexOf(order)
@@ -134,10 +125,10 @@ class FakeProductDataSource : ProductRepository {
         localProducts[productIndex] = updatedProduct
     }
 
-    override suspend fun updateItemCount(productId: Long, countType: CountType) {
+    override suspend fun updateItemCount(productId: Long, countType: CountType) = runCatching {
         val getActiveOrder = orders.firstOrNull { it.orderStatus == OrderStatus.ON_BASKET }
         val productPrice = localProducts.find { it.productId == productId }?.price
-            ?: throw Exception("Product not found")
+            ?: throw Exception("Product not found: $productId")
         val orderId = getActiveOrder?.id ?: run {
             val id = (0..100000).random().toLong()
             val orderEntity = OrderEntity(id = id, OrderStatus.ON_BASKET)
@@ -171,4 +162,20 @@ class FakeProductDataSource : ProductRepository {
 
         return true
     }
+
+    override suspend fun getStatus(): List<StatusEntity?> {
+        return emptyList()
+    }
+
+    private fun ProductWithCount.toProductEntity(): ProductEntity {
+        return ProductEntity(
+            id = productId,
+            productId = "",
+            name = name,
+            price = price,
+            attribute = attribute ?: "",
+            imageURL = imageURL,
+            productType = type,
+        )
+    }
 }