[Woo POS][Coupons] Refactor WooPosProductsDataSource to Introduce WooPosBaseDataSource for Improved Maintainability

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/home/items/WooPosItemsViewModel.kt

@@ -11,6 +11,8 @@ import com.woocommerce.android.ui.woopos.featureflags.WooPosIsProductsSearchEnab
 import com.woocommerce.android.ui.woopos.home.ChildToParentEvent
 import com.woocommerce.android.ui.woopos.home.WooPosChildrenToParentEventSender
 import com.woocommerce.android.ui.woopos.home.items.WooPosItemNavigationData.VariableProductData
+import com.woocommerce.android.ui.woopos.home.items.common.FetchOptions
+import com.woocommerce.android.ui.woopos.home.items.common.FetchResult
 import com.woocommerce.android.ui.woopos.home.items.navigation.WooPosItemsNavigator
 import com.woocommerce.android.ui.woopos.home.items.navigation.WooPosItemsNavigator.WooPosItemsScreenNavigationEvent
 import com.woocommerce.android.ui.woopos.home.items.navigation.WooPosItemsNavigator.WooPosItemsScreenNavigationEvent.NavigateToVariationsScreen
@@ -197,18 +199,20 @@ class WooPosItemsViewModel @Inject constructor(
                 WooPosItemsViewState.Loading(withCart = withCart)
             }
 
-            productsDataSource.loadSimpleProducts(forceRefreshProducts = forceRefreshProducts).collect { result ->
+            productsDataSource.fetchData(
+                fetchOptions = FetchOptions(forceRefresh = forceRefreshProducts),
+            ).collect { result ->
                 when (result) {
-                    is WooPosProductsDataSource.ProductsResult.Cached -> {
-                        if (result.products.isNotEmpty()) {
-                            _viewState.value = result.products.toContentState()
+                    is FetchResult.Cached -> {
+                        if (result.data.isNotEmpty()) {
+                            _viewState.value = result.data.toContentState()
                         }
                     }
 
-                    is WooPosProductsDataSource.ProductsResult.Remote -> {
+                    is FetchResult.Remote -> {
                         _viewState.value = when {
-                            result.productsResult.isSuccess -> {
-                                val products = result.productsResult.getOrThrow()
+                            result.result.isSuccess -> {
+                                val products = result.result.getOrThrow()
                                 if (products.isNotEmpty()) {
                                     products.toContentState(
                                         paginationState = if (loadMoreProductsJob?.isActive == true) {

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/home/items/common/FetchDataSource.kt

@@ -0,0 +1,9 @@
+package com.woocommerce.android.ui.woopos.home.items.common
+
+import kotlinx.coroutines.flow.Flow
+
+interface FetchDataSource<T> {
+    fun fetchData(
+        fetchOptions: FetchOptions
+    ): Flow<FetchResult<T>>
+}

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/home/items/common/FetchOptions.kt

@@ -0,0 +1,6 @@
+package com.woocommerce.android.ui.woopos.home.items.common
+
+data class FetchOptions(
+    val productId: Long? = null,
+    val forceRefresh: Boolean = false,
+)

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/home/items/common/FetchResult.kt

@@ -0,0 +1,6 @@
+package com.woocommerce.android.ui.woopos.home.items.common
+
+sealed class FetchResult<T> {
+    data class Cached<T>(val data: List<T>) : FetchResult<T>()
+    data class Remote<T>(val result: Result<List<T>>) : FetchResult<T>()
+}

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/home/items/common/WooPosBaseDataSource.kt

@@ -0,0 +1,39 @@
+package com.woocommerce.android.ui.woopos.home.items.common
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+
+abstract class WooPosBaseDataSource<T> : FetchDataSource<T> {
+
+    protected abstract suspend fun fetchFromCache(fetchOptions: FetchOptions): List<T>
+    protected abstract suspend fun fetchFromRemote(
+        fetchOptions: FetchOptions,
+    ): Result<List<T>>
+    protected abstract suspend fun updateCache(fetchOptions: FetchOptions, data: List<T>)
+
+    override fun fetchData(
+        fetchOptions: FetchOptions
+    ): Flow<FetchResult<T>> = flow {
+        if (fetchOptions.forceRefresh) {
+            updateCache(fetchOptions, data = emptyList())
+        }
+
+        val cachedData = fetchFromCache(fetchOptions)
+        emit(FetchResult.Cached(cachedData))
+
+        val remoteResult = fetchFromRemote(fetchOptions)
+        if (remoteResult.isSuccess) {
+            val remoteData = remoteResult.getOrThrow()
+            updateCache(fetchOptions = fetchOptions, data = remoteData)
+            emit(FetchResult.Remote(Result.success(remoteData)))
+        } else {
+            emit(
+                FetchResult.Remote(
+                    Result.failure(remoteResult.exceptionOrNull() ?: Exception("Unknown error"))
+                )
+            )
+        }
+    }.flowOn(Dispatchers.IO)
+}

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/home/items/products/WooPosProductsDataSource.kt

@@ -3,13 +3,11 @@ package com.woocommerce.android.ui.woopos.home.items.products
 import com.woocommerce.android.model.Product
 import com.woocommerce.android.ui.products.ProductStatus
 import com.woocommerce.android.ui.products.selector.ProductListHandler
+import com.woocommerce.android.ui.woopos.home.items.common.FetchOptions
+import com.woocommerce.android.ui.woopos.home.items.common.WooPosBaseDataSource
 import com.woocommerce.android.util.WooLog
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
@@ -20,46 +18,13 @@ import javax.inject.Singleton
 @Singleton
 class WooPosProductsDataSource @Inject constructor(
     private val handler: ProductListHandler,
-) {
+) : WooPosBaseDataSource<Product>() {
     private var productCache: List<Product> = emptyList()
     private val cacheMutex = Mutex()
 
     val hasMorePages: Boolean
         get() = handler.canLoadMore.get()
 
-    fun loadSimpleProducts(forceRefreshProducts: Boolean): Flow<ProductsResult> = flow {
-        if (forceRefreshProducts) {
-            updateProductCache(emptyList())
-        }
-
-        emit(ProductsResult.Cached(productCache))
-
-        val result = handler.loadFromCacheAndFetch(
-            forceRefresh = forceRefreshProducts,
-            searchType = ProductListHandler.SearchType.DEFAULT,
-            includeType = listOf(WCProductStore.IncludeType.Simple, WCProductStore.IncludeType.Variable),
-            filters = mapOf(
-                WCProductStore.ProductFilterOption.STATUS to ProductStatus.PUBLISH.value,
-                WCProductStore.ProductFilterOption.DOWNLOADABLE to WCProductStore.DownloadableOptions.FALSE.toString(),
-            )
-        )
-
-        if (result.isSuccess) {
-            val remoteProducts = handler.productsFlow.first()
-            updateProductCache(remoteProducts)
-            emit(ProductsResult.Remote(Result.success(productCache)))
-        } else {
-            result.logFailure()
-            emit(
-                ProductsResult.Remote(
-                    Result.failure(
-                        result.exceptionOrNull() ?: Exception("Unknown error")
-                    )
-                )
-            )
-        }
-    }.flowOn(Dispatchers.IO).take(2)
-
     suspend fun loadMore(): Result<List<Product>> = withContext(Dispatchers.IO) {
         val result = handler.loadMore(
             includeTypes = listOf(WCProductStore.IncludeType.Simple, WCProductStore.IncludeType.Variable),
@@ -88,4 +53,29 @@ class WooPosProductsDataSource @Inject constructor(
         data class Cached(val products: List<Product>) : ProductsResult()
         data class Remote(val productsResult: Result<List<Product>>) : ProductsResult()
     }
+
+    override suspend fun fetchFromCache(fetchOptions: FetchOptions): List<Product> {
+        return productCache
+    }
+
+    override suspend fun fetchFromRemote(fetchOptions: FetchOptions): Result<List<Product>> {
+        val result = handler.loadFromCacheAndFetch(
+            forceRefresh = true,
+            includeType = listOf(WCProductStore.IncludeType.Simple, WCProductStore.IncludeType.Variable),
+            searchType = ProductListHandler.SearchType.DEFAULT,
+            filters = mapOf(
+                WCProductStore.ProductFilterOption.STATUS to ProductStatus.PUBLISH.value,
+                WCProductStore.ProductFilterOption.DOWNLOADABLE to WCProductStore.DownloadableOptions.FALSE.toString(),
+            )
+        )
+        return if (result.isSuccess) {
+            Result.success(handler.productsFlow.first())
+        } else {
+            Result.failure(result.exceptionOrNull() ?: Exception("Unknown error while fetching products"))
+        }
+    }
+
+    override suspend fun updateCache(fetchOptions: FetchOptions, data: List<Product>) {
+        updateProductCache(data)
+    }
 }

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/splash/WooPosSplashViewModel.kt

@@ -2,6 +2,8 @@ package com.woocommerce.android.ui.woopos.splash
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.woocommerce.android.ui.woopos.home.items.common.FetchOptions
+import com.woocommerce.android.ui.woopos.home.items.common.FetchResult
 import com.woocommerce.android.ui.woopos.home.items.products.WooPosProductsDataSource
 import com.woocommerce.android.ui.woopos.util.analytics.WooPosAnalyticsEvent.Event.Loaded
 import com.woocommerce.android.ui.woopos.util.analytics.WooPosAnalyticsTracker
@@ -23,11 +25,13 @@ class WooPosSplashViewModel @Inject constructor(
 
     init {
         viewModelScope.launch {
-            productsDataSource.loadSimpleProducts(forceRefreshProducts = true)
+            productsDataSource.fetchData(
+                fetchOptions = FetchOptions(forceRefresh = true)
+            )
                 .collect { result ->
                     when (result) {
-                        is WooPosProductsDataSource.ProductsResult.Cached -> {}
-                        is WooPosProductsDataSource.ProductsResult.Remote -> {
+                        is FetchResult.Cached -> {}
+                        is FetchResult.Remote -> {
                             _state.value = WooPosSplashState.Loaded
                             trackPosLoaded()
                         }