Merge pull request #14915 from woocommerce/fix/pos-historical-orders-show-refunds-net-payment

[POS Orders] Fetch refunds remotely if not stored locally

Author: toupper

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/common/data/WooPosGetOrderRefundsByOrderId.kt

@@ -0,0 +1,38 @@
+package com.woocommerce.android.ui.woopos.common.data
+
+import com.woocommerce.android.model.Order
+import com.woocommerce.android.model.Refund
+import com.woocommerce.android.model.toAppModel
+import com.woocommerce.android.tools.SelectedSite
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.wordpress.android.fluxc.store.WCRefundStore
+import java.math.BigDecimal
+import javax.inject.Inject
+
+class WooPosRetrieveOrderRefunds @Inject constructor(
+    private val refundStore: WCRefundStore,
+    private val selectedSite: SelectedSite
+) {
+    suspend operator fun invoke(order: Order): Result<List<Refund>> =
+        withContext(Dispatchers.IO) {
+            if (order.refundTotal.compareTo(BigDecimal.ZERO) == 0) {
+                return@withContext Result.success(emptyList())
+            }
+
+            val site = selectedSite.get()
+
+            var refundModels = refundStore.getAllRefunds(site, order.id)
+            if (refundModels.isEmpty()) {
+                val fetchResult = refundStore.fetchAllRefunds(site, order.id)
+                if (fetchResult.isError) {
+                    return@withContext Result.failure(
+                        Exception("Failed to fetch refunds: ${fetchResult.error.message}")
+                    )
+                }
+                refundModels = fetchResult.model ?: emptyList()
+            }
+
+            Result.success(refundModels.map { it.toAppModel() })
+        }
+}

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/common/data/WooPosRetrieveOrderRefunds.kt

@@ -2,8 +2,13 @@ package com.woocommerce.android.ui.woopos.orders
 
 import com.woocommerce.android.model.Order
 import com.woocommerce.android.model.OrderMapper
+import com.woocommerce.android.model.Refund
 import com.woocommerce.android.tools.SelectedSite
+import com.woocommerce.android.ui.woopos.common.data.WooPosRetrieveOrderRefunds
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.withContext
@@ -16,21 +21,27 @@ import java.util.concurrent.atomic.AtomicInteger
 import javax.inject.Inject
 
 sealed class LoadOrdersResult {
-    data class SuccessCache(val orders: List<Order>) : LoadOrdersResult()
-    data class SuccessRemote(val orders: List<Order>) : LoadOrdersResult()
+    data class SuccessCache(val ordersWithRefunds: Map<Order, RefundFetchResult>) : LoadOrdersResult()
+    data class SuccessRemote(val ordersWithRefunds: Map<Order, RefundFetchResult>) : LoadOrdersResult()
     data class Error(val message: String) : LoadOrdersResult()
 }
 
 sealed class SearchOrdersResult {
-    data class Success(val orders: List<Order>) : SearchOrdersResult()
+    data class Success(val ordersWithRefunds: Map<Order, RefundFetchResult>) : SearchOrdersResult()
     data class Error(val message: String) : SearchOrdersResult()
 }
 
+sealed class RefundFetchResult {
+    data class Success(val refunds: List<Refund>) : RefundFetchResult()
+    object Error : RefundFetchResult()
+}
+
 class WooPosOrdersDataSource @Inject constructor(
     private val restClient: OrderRestClient,
     private val selectedSite: SelectedSite,
     private val orderMapper: OrderMapper,
-    private val ordersCache: WooPosOrdersInMemoryCache
+    private val ordersCache: WooPosOrdersInMemoryCache,
+    private val retrieveOrderRefunds: WooPosRetrieveOrderRefunds
 ) {
     private val canLoadMore = AtomicBoolean(false)
     private val page = AtomicInteger(1)
@@ -45,12 +56,16 @@ class WooPosOrdersDataSource @Inject constructor(
 
     fun loadOrders(): Flow<LoadOrdersResult> = flow {
         val cached = ordersCache.getAll()
-        if (cached.isNotEmpty()) emit(LoadOrdersResult.SuccessCache(cached))
+        if (cached.isNotEmpty()) {
+            val cachedWithRefunds = fetchRefundsForOrders(cached)
+            emit(LoadOrdersResult.SuccessCache(cachedWithRefunds))
+        }
 
         val result = loadFirstPage()
-        result.onSuccess {
-            ordersCache.setAll(it)
-            emit(LoadOrdersResult.SuccessRemote(it))
+        result.onSuccess { orders ->
+            ordersCache.setAll(orders)
+            val ordersWithRefunds = fetchRefundsForOrders(orders)
+            emit(LoadOrdersResult.SuccessRemote(ordersWithRefunds))
         }.onFailure {
             emit(LoadOrdersResult.Error(it.message ?: UNKNOWN_ERROR))
         }
@@ -59,13 +74,20 @@ class WooPosOrdersDataSource @Inject constructor(
     suspend fun searchOrders(searchQuery: String): SearchOrdersResult {
         val result = loadFirstPage(searchQuery)
         return result.fold(
-            onSuccess = { SearchOrdersResult.Success(it) },
+            onSuccess = { orders ->
+                val ordersWithRefunds = fetchRefundsForOrders(orders)
+                SearchOrdersResult.Success(ordersWithRefunds)
+            },
             onFailure = { SearchOrdersResult.Error(it.message ?: UNKNOWN_ERROR) }
         )
     }
 
-    suspend fun loadMore(searchQuery: String? = null): Result<List<Order>> =
-        withContext(Dispatchers.IO) { loadNextPage(searchQuery) }
+    suspend fun loadMore(searchQuery: String? = null): Result<Map<Order, RefundFetchResult>> =
+        withContext(Dispatchers.IO) {
+            loadNextPage(searchQuery).map { orders ->
+                fetchRefundsForOrders(orders)
+            }
+        }
 
     suspend fun refreshOrderById(orderId: Long): Result<Order> {
         val site = selectedSite.get()
@@ -135,4 +157,16 @@ class WooPosOrdersDataSource @Inject constructor(
 
     private fun WCOrderStore.OrderError.toThrowable(): Throwable =
         Throwable("[$type] $message")
+
+    private suspend fun fetchRefundsForOrders(orders: List<Order>): Map<Order, RefundFetchResult> =
+        coroutineScope {
+            orders.map { order ->
+                async {
+                    retrieveOrderRefunds(order).fold(
+                        onSuccess = { refunds -> order to RefundFetchResult.Success(refunds) },
+                        onFailure = { order to RefundFetchResult.Error }
+                    )
+                }
+            }.awaitAll().toMap()
+        }
 }

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/woopos/orders/WooPosOrdersDataSource.kt

@@ -14,7 +14,8 @@ sealed class OrderDetailsViewState {
     @Immutable
     data class Lazy(
         override val orderId: Long,
-        val order: Order
+        val order: Order,
+        val refundResult: RefundFetchResult
     ) : OrderDetailsViewState()
 
     @Immutable