[WOOMOB-1722] - Properly clean the Bookings table for Today/Upcoming tabs' first page load

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/bookings/BookingsRepository.kt

@@ -24,7 +24,7 @@ class BookingsRepository @Inject constructor(
         page: Int,
         perPage: Int,
         query: String? = null,
-        filters: BookingFilters? = null,
+        filters: BookingFilters = BookingFilters.EMPTY,
         order: BookingsOrderOption
     ): Result<FetchResult> {
         val result = bookingsStore.fetchBookings(

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/bookings/list/BookingListFiltersBuilder.kt

@@ -1,38 +1,19 @@
 package com.woocommerce.android.ui.bookings.list
 
+import org.wordpress.android.fluxc.network.rest.wpcom.wc.bookings.BookingsDateRangePresets
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.bookings.BookingsFilterOption
 import java.time.Clock
-import java.time.LocalDate
-import java.time.LocalTime
-import java.time.ZoneOffset
 import javax.inject.Inject
 
 class BookingListFiltersBuilder @Inject constructor(
     private val clock: Clock
 ) {
     /**
      * Returns a [BookingsFilterOption.DateRange] based on the selected [BookingListTab].
-     *
-     * We use UTC for the API calls, as the API stores the dates without timezone information, which means that
-     * when comparing dates, they are treated as UTC times.
-     * See p1759398245019489-slack-C09FHQNQERG
      */
-    fun BookingListTab.asDateRangeFilter(): BookingsFilterOption.DateRange? {
-        fun todayAtMidnight() = LocalDate.now(clock).atTime(LocalTime.MIDNIGHT).atOffset(ZoneOffset.UTC).toInstant()
-        fun todayAtEndOfDay() = LocalDate.now(clock).atTime(LocalTime.MAX).atOffset(ZoneOffset.UTC).toInstant()
-
-        return when (this) {
-            BookingListTab.Today -> BookingsFilterOption.DateRange(
-                before = todayAtEndOfDay(),
-                after = todayAtMidnight()
-            )
-
-            BookingListTab.Upcoming -> BookingsFilterOption.DateRange(
-                before = null,
-                after = todayAtEndOfDay()
-            )
-
-            BookingListTab.All -> null
-        }
+    fun BookingListTab.asDateRangeFilter(): BookingsFilterOption.DateRange? = when (this) {
+        BookingListTab.Today -> BookingsDateRangePresets.today(clock)
+        BookingListTab.Upcoming -> BookingsDateRangePresets.upcoming(clock)
+        BookingListTab.All -> null
     }
 }

WooCommerce/src/main/kotlin/com/woocommerce/android/ui/bookings/list/BookingListHandler.kt

@@ -32,7 +32,7 @@ class BookingListHandler @Inject constructor(
     private val canLoadMore = AtomicBoolean(false)
 
     private val searchQuery = MutableStateFlow<String?>(null)
-    private val filters = MutableStateFlow<BookingFilters?>(null)
+    private val filters = MutableStateFlow(BookingFilters.EMPTY)
     private val sortBy = MutableStateFlow(BookingListSortOption.NewestToOldest)
 
     private val searchResults = MutableStateFlow(emptyList<Booking>())
@@ -57,7 +57,7 @@ class BookingListHandler @Inject constructor(
 
     suspend fun loadBookings(
         searchQuery: String? = null,
-        filters: BookingFilters? = null,
+        filters: BookingFilters = BookingFilters.EMPTY,
         sortBy: BookingListSortOption
     ): Result<Unit> = mutex.withLock {
         // Reset pagination attributes

libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/bookings/BookingsDateRangePresets.kt

@@ -0,0 +1,47 @@
+package org.wordpress.android.fluxc.network.rest.wpcom.wc.bookings
+
+import java.time.Clock
+import java.time.Instant
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.ZoneOffset
+
+/**
+ * Factory for canonical booking date range presets used across app and data layers.
+ *
+ * Notes about time zone:
+ * The WC Bookings API stores dates without timezone information. To ensure
+ * consistent comparisons and filtering on both client and server, we construct
+ * ranges in UTC.
+ * See p1759398245019489-slack-C09FHQNQERG
+ */
+object BookingsDateRangePresets {
+    /**
+     * Returns a DateRange that spans the current day in UTC, inclusive of the
+     * full day when interpreted by the API (midnight to end-of-day).
+     */
+    fun today(clock: Clock): BookingsFilterOption.DateRange {
+        val start = LocalDate.now(clock)
+            .atTime(LocalTime.MIDNIGHT)
+            .atOffset(ZoneOffset.UTC)
+            .toInstant()
+        val end = getEndOfToday(clock)
+        return BookingsFilterOption.DateRange(before = end, after = start)
+    }
+
+    /**
+     * Returns a DateRange that includes bookings strictly after the end of the
+     * current day in UTC (i.e., upcoming bookings from tomorrow onwards).
+     */
+    fun upcoming(clock: Clock): BookingsFilterOption.DateRange {
+        val endOfToday = getEndOfToday(clock)
+        return BookingsFilterOption.DateRange(before = null, after = endOfToday)
+    }
+
+    private fun getEndOfToday(clock: Clock): Instant {
+        return LocalDate.now(clock)
+            .atTime(LocalTime.MAX)
+            .atOffset(ZoneOffset.UTC)
+            .toInstant()
+    }
+}

libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/bookings/BookingsStore.kt

@@ -15,6 +15,7 @@ import org.wordpress.android.fluxc.store.WCOrderStore
 import org.wordpress.android.fluxc.tools.CoroutineEngine
 import org.wordpress.android.fluxc.utils.HeadersParser
 import org.wordpress.android.util.AppLog
+import java.time.Clock
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -26,13 +27,14 @@ class BookingsStore @Inject internal constructor(
     private val bookingDtoMapper: BookingDtoMapper,
     private val headersParser: HeadersParser,
     private val coroutineEngine: CoroutineEngine,
+    private val clock: Clock,
 ) {
     suspend fun fetchBookings(
         site: SiteModel,
         perPage: Int = BookingsRestClient.DEFAULT_PER_PAGE,
         page: Int = 1,
         query: String? = null,
-        filters: BookingFilters?,
+        filters: BookingFilters,
         order: BookingsOrderOption
     ): WooResult<BookingsFetchResult> {
         return coroutineEngine.withDefaultContext(AppLog.T.API, this, "fetchBookings") {
@@ -54,9 +56,28 @@ class BookingsStore @Inject internal constructor(
                             )
                         }
                     }
-                    if (page == 1 && filters == BookingFilters.EMPTY && query.isNullOrEmpty()) {
-                        // Clear existing bookings and insert new ones when fetching the first page
-                        bookingsDao.replaceAllForSite(site.localId(), entities)
+                    // Clear existing bookings when fetching the first page.
+                    // If filters are applied, only clear entries that match the applied filters,
+                    // otherwise (no filters) clear all entries for the site.
+                    if (page == 1 && query.isNullOrEmpty()) {
+                        when {
+                            filters == BookingFilters.EMPTY -> {
+                                bookingsDao.replaceAllForSite(site.localId(), entities)
+                            }
+
+                            filters.dateRange != null && filters.isTodayOrUpcoming -> {
+                                bookingsDao.cleanAndUpsertBookings(
+                                    site.localId(),
+                                    filters.dateRange,
+                                    entities
+                                )
+                            }
+
+                            else -> {
+                                // For any other filters, avoid deletions to prevent removing unrelated cached items
+                                bookingsDao.insertOrReplace(entities)
+                            }
+                        }
                     } else {
                         bookingsDao.insertOrReplace(entities)
                     }
@@ -77,6 +98,13 @@ class BookingsStore @Inject internal constructor(
         }
     }
 
+    private val BookingFilters.isTodayOrUpcoming: Boolean
+        get() {
+            val today = BookingsDateRangePresets.today(clock)
+            val upcoming = BookingsDateRangePresets.upcoming(clock)
+            return (dateRange == today || dateRange == upcoming) && enabledFiltersCount == 1
+        }
+
     fun observeBookings(
         site: SiteModel,
         limit: Int? = null,

libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/persistence/dao/BookingsDao.kt

@@ -8,6 +8,7 @@ import androidx.room.Transaction
 import kotlinx.coroutines.flow.Flow
 import org.wordpress.android.fluxc.model.LocalOrRemoteId.LocalId
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.bookings.BookingFilters
+import org.wordpress.android.fluxc.network.rest.wpcom.wc.bookings.BookingsFilterOption
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.bookings.BookingsOrderOption
 import org.wordpress.android.fluxc.persistence.entity.BookingEntity
 import org.wordpress.android.fluxc.persistence.entity.BookingResourceEntity
@@ -70,6 +71,55 @@ interface BookingsDao {
         insertOrReplace(entities)
     }
 
+    @Suppress("LongParameterList")
+    @Query(
+        """
+            DELETE FROM Bookings
+            WHERE localSiteId = :localSiteId
+            AND (:startDateBefore IS NULL OR start <= :startDateBefore)
+            AND (:startDateAfter IS NULL OR start >= :startDateAfter)
+            AND ((:idsSize = 0) OR id NOT IN (:ids))
+        """
+    )
+    suspend fun deleteForSiteWithDateRangeFilter(
+        localSiteId: LocalId,
+        startDateBefore: Long?,
+        startDateAfter: Long?,
+        ids: List<Long>,
+        idsSize: Int,
+    )
+
+    private suspend fun deleteForSiteWithDateRangeFilter(
+        localSiteId: LocalId,
+        dateRange: BookingsFilterOption.DateRange,
+        ids: List<Long>
+    ) {
+        deleteForSiteWithDateRangeFilter(
+            localSiteId = localSiteId,
+            startDateBefore = dateRange.before?.epochSecond,
+            startDateAfter = dateRange.after?.epochSecond,
+            ids = ids,
+            idsSize = ids.size,
+        )
+    }
+
+    /**
+     * Delete Booking entities that are not present in the new list and then insert the new entities
+     */
+    @Transaction
+    suspend fun cleanAndUpsertBookings(
+        localSiteId: LocalId,
+        dateRange: BookingsFilterOption.DateRange,
+        entities: List<BookingEntity>,
+    ) {
+        deleteForSiteWithDateRangeFilter(
+            localSiteId = localSiteId,
+            dateRange = dateRange,
+            ids = entities.map { it.id.value },
+        )
+        insertOrReplace(entities)
+    }
+
     fun observeBookings(
         localSiteId: LocalId,
         limit: Int? = null,