[Dynamic Dashboard] Fix issue of not updating the orders count in some scenarios

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/dashboard/data/ObserveSiteOrdersState.kt

@@ -4,37 +4,36 @@ import com.woocommerce.android.R
 import com.woocommerce.android.model.DashboardWidget
 import com.woocommerce.android.tools.SelectedSite
 import com.woocommerce.android.util.CoroutineDispatchers
+import com.woocommerce.android.util.observeEvents
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.transformLatest
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.flow.onStart
+import org.wordpress.android.fluxc.Dispatcher
+import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.store.WCOrderStore
 import org.wordpress.android.fluxc.store.WCOrderStore.HasOrdersResult
+import org.wordpress.android.fluxc.store.WCOrderStore.OnOrderStatusOptionsChanged
 import javax.inject.Inject
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class ObserveSiteOrdersState @Inject constructor(
     private val selectedSite: SelectedSite,
     private val orderStore: WCOrderStore,
-    private val coroutineDispatchers: CoroutineDispatchers
+    private val coroutineDispatchers: CoroutineDispatchers,
+    private val dispatcher: Dispatcher
 ) {
     operator fun invoke() = selectedSite.observe()
         .filterNotNull()
-        .flatMapLatest { orderStore.observeOrderCountForSite(it) }
-        .map { count -> count != 0 }
-        .distinctUntilChanged()
-        .transformLatest { hasOrders ->
-            if (!hasOrders) {
-                // This means either the store doesn't have orders, or no orders are cached yet
-                // Use other approaches to determine if the store has orders
-                emit(getHasOrdersFromOrderStatusOptions() ?: fetchHasOrdersFromApi())
-            } else {
-                emit(true)
-            }
-        }.map { hasOrders ->
+        .flatMapLatest { observeHasOrdersFromOrdersStatusOptions(it) }
+        .map {
+            // Fallback to fetching from API if we can't infer the value from the order status options
+            it ?: fetchHasOrdersFromApi()
+        }
+        .map { hasOrders ->
             if (hasOrders) {
                 DashboardWidget.Status.Available
             } else {
@@ -44,13 +43,17 @@ class ObserveSiteOrdersState @Inject constructor(
             }
         }
 
-    private suspend fun getHasOrdersFromOrderStatusOptions() = withContext(coroutineDispatchers.io) {
-        orderStore.getOrderStatusOptionsForSite(selectedSite.get())
-            .filter { it.statusKey != "checkout-draft" }
-            .takeIf { it.isNotEmpty() }
-            ?.sumOf { it.statusCount }
-            ?.let { it != 0 }
-    }
+    private fun observeHasOrdersFromOrdersStatusOptions(site: SiteModel) =
+        dispatcher.observeEvents<OnOrderStatusOptionsChanged>()
+            .onStart { emit(OnOrderStatusOptionsChanged(0)) }
+            .map {
+                orderStore.getOrderStatusOptionsForSite(site)
+                    .filter { it.statusKey != "checkout-draft" }
+                    .takeIf { it.isNotEmpty() }
+                    ?.any { it.statusCount > 0 }
+            }
+            .distinctUntilChanged()
+            .flowOn(coroutineDispatchers.io)
 
     private suspend fun fetchHasOrdersFromApi(): Boolean {
         return orderStore.fetchHasOrders(selectedSite.get(), null).let {

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/main/ObserveProcessingOrdersCount.kt

@@ -1,38 +1,52 @@
 package com.woocommerce.android.ui.main
 
-import com.woocommerce.android.analytics.AnalyticsEvent
-import com.woocommerce.android.analytics.AnalyticsTracker
+import com.woocommerce.android.OnChangedException
 import com.woocommerce.android.extensions.NotificationReceivedEvent
 import com.woocommerce.android.notifications.NotificationChannelType
 import com.woocommerce.android.tools.SelectedSite
+import com.woocommerce.android.util.CoroutineDispatchers
 import com.woocommerce.android.util.WooLog
+import com.woocommerce.android.util.dispatchAndAwait
 import com.woocommerce.android.util.observeEvents
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.emitAll
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.transformLatest
+import kotlinx.coroutines.withContext
 import org.greenrobot.eventbus.EventBus
 import org.wordpress.android.fluxc.Dispatcher
 import org.wordpress.android.fluxc.action.WCOrderAction
+import org.wordpress.android.fluxc.generated.WCOrderActionBuilder
 import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.order.CoreOrderStatus
 import org.wordpress.android.fluxc.store.WCOrderStore
+import org.wordpress.android.fluxc.store.WCOrderStore.FetchOrderStatusOptionsPayload
 import org.wordpress.android.fluxc.store.WCOrderStore.OnOrderChanged
 import org.wordpress.android.fluxc.store.WCOrderStore.OnOrderStatusOptionsChanged
-import org.wordpress.android.fluxc.store.WCOrderStore.OrdersCountResult.Failure
-import org.wordpress.android.fluxc.store.WCOrderStore.OrdersCountResult.Success
 import javax.inject.Inject
 
 class ObserveProcessingOrdersCount @Inject constructor(
     private val dispatcher: Dispatcher,
     private val wcOrderStore: WCOrderStore,
-    private val selectedSite: SelectedSite
+    private val selectedSite: SelectedSite,
+    private val dispatchers: CoroutineDispatchers
 ) {
-    @OptIn(ExperimentalCoroutinesApi::class)
+    companion object {
+        // A debounce duration to avoid fetching the value multiple times when there are multiple simultaneous events
+        private const val DEBOUNCE_DURATION_MS = 200L
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
     operator fun invoke(): Flow<Int?> = selectedSite.observe().transformLatest { site ->
         if (site == null) {
             emit(null)
@@ -42,18 +56,12 @@ class ObserveProcessingOrdersCount @Inject constructor(
         // Start with the cached value
         emit(getCachedValue(site))
 
-        // emit updated value
-        fetchOrdersCount(site)?.let { emit(it) }
-
         // Observe value changes
         coroutineScope {
-            dispatcher.observeEvents<OnOrderStatusOptionsChanged>()
-                .onEach {
-                    emit(getCachedValue(site))
-                }
-                .launchIn(this)
-
             merge(
+                wcOrderStore.observeOrderCountForSite(site)
+                    .drop(1)
+                    .distinctUntilChanged(),
                 dispatcher.observeEvents<OnOrderChanged>()
                     .filter {
                         @Suppress("DEPRECATION")
@@ -70,35 +78,42 @@ class ObserveProcessingOrdersCount @Inject constructor(
                         WooLog.d(WooLog.T.ORDERS, "New order notification received, re-check unfilled orders count")
                     }
             )
+                .debounce(DEBOUNCE_DURATION_MS)
                 .onEach {
-                    fetchOrdersCount(site)?.let { emit(it) }
+                    // Fetch value from API, the value will be emitted when OnOrderStatusOptionsChanged event
+                    // is received below
+                    fetchOrderStatusOptions(site)
                 }
                 .launchIn(this)
+
+            emitAll(
+                dispatcher.observeEvents<OnOrderStatusOptionsChanged>()
+                    .map { getCachedValue(site) }
+            )
         }
     }
 
-    private fun getCachedValue(site: SiteModel): Int? =
+    private suspend fun getCachedValue(site: SiteModel): Int? = withContext(dispatchers.io) {
         wcOrderStore.getOrderStatusForSiteAndKey(site, CoreOrderStatus.PROCESSING.value)?.statusCount
+    }
 
-    private suspend fun fetchOrdersCount(site: SiteModel): Int? {
-        return wcOrderStore.fetchOrdersCount(site, CoreOrderStatus.PROCESSING.value).let {
-            when (it) {
-                is Success -> {
-                    AnalyticsTracker.track(
-                        AnalyticsEvent.UNFULFILLED_ORDERS_LOADED,
-                        mapOf(AnalyticsTracker.KEY_HAS_UNFULFILLED_ORDERS to it.count)
-                    )
-                    it.count
-                }
+    private suspend fun fetchOrderStatusOptions(site: SiteModel): Result<Unit> {
+        val event: OnOrderStatusOptionsChanged = dispatcher.dispatchAndAwait(
+            WCOrderActionBuilder.newFetchOrderStatusOptionsAction(
+                FetchOrderStatusOptionsPayload(site)
+            )
+        )
 
-                is Failure -> {
-                    WooLog.e(
-                        WooLog.T.ORDERS,
-                        "Error fetching a count of orders waiting to be fulfilled: ${it.error.message}"
-                    )
-                    null
-                }
+        return when {
+            event.isError -> {
+                WooLog.e(
+                    WooLog.T.ORDERS,
+                    "Error fetching order status options: ${event.error.message}"
+                )
+                Result.failure(OnChangedException(event.error))
             }
+
+            else -> Result.success(Unit)
         }
     }
 }

WooCommerce/src/test/kotlin/com/woocommerce/android/FakeDispatcher.kt

@@ -4,7 +4,7 @@ import org.greenrobot.eventbus.Subscribe
 import org.wordpress.android.fluxc.Dispatcher
 import org.wordpress.android.fluxc.annotations.action.Action
 
-class FakeDispatcher : Dispatcher() {
+class FakeDispatcher(private val dispatchCallback: Dispatcher.(action: Action<*>) -> Unit = {}) : Dispatcher() {
     private val listeners = mutableListOf<Any>()
 
     @Synchronized
@@ -31,7 +31,7 @@ class FakeDispatcher : Dispatcher() {
         }
     }
 
-    override fun dispatch(action: Action<*>?) {
-        // NO-OP
+    override fun dispatch(action: Action<*>) {
+        dispatchCallback(action)
     }
 }