fix: recurring event next alert (#144)

williscool · web-flow · commit 0ad329f798c7 · 2026-01-01T22:59:41.000Z
* fix: recurring event next alert fixes #143 * fix: bug bot
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/calendar/EventRecord.kt b/android/app/src/main/java/com/github/quarck/calnotify/calendar/EventRecord.kt
@@ -169,10 +169,18 @@ fun EventRecord.nextAlarmTime(currentTime: Long): Long {
     return ret
 }
 
-fun EventRecord.getNextAlertTimeAfter(anchor: Long): Long? {
+/**
+ * Gets the next alert time after the given anchor time.
+ * 
+ * @param anchor The time to compare against (typically current time)
+ * @param instanceStartTime For recurring events, pass the instance's start time.
+ *                          If null, uses the master event's startTime (wrong for recurring!)
+ */
+fun EventRecord.getNextAlertTimeAfter(anchor: Long, instanceStartTime: Long? = null): Long? {
+    val effectiveStartTime = instanceStartTime ?: this.startTime
     val futureReminders = this
         .reminders
-        .map { this.startTime - it.millisecondsBefore }
+        .map { effectiveStartTime - it.millisecondsBefore }
         .filter { it > anchor }
     return futureReminders.maxOrNull()
 }
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/textutils/EventFormatter.kt b/android/app/src/main/java/com/github/quarck/calnotify/textutils/EventFormatter.kt
@@ -160,9 +160,11 @@ class EventFormatter(
         remindersEnabled: Boolean
     ): NextNotificationInfo? {
         // Get next GCal reminder if enabled
+        // Pass displayedStartTime for recurring events (master event's startTime would be wrong)
+        // Note: displayedStartTime handles instanceStartTime=0L fallback to startTime
         val nextGCalTime: Long? = if (displayNextGCalReminder) {
             val eventRecord = calendarProvider.getEvent(ctx, event.eventId)
-            eventRecord?.getNextAlertTimeAfter(currentTime)
+            eventRecord?.getNextAlertTimeAfter(currentTime, event.displayedStartTime)
         } else null
         
         // Get next app alert if enabled (show for muted events too - they still get alerts on silent channel)
@@ -193,9 +195,11 @@ class EventFormatter(
         val currentTime = clock.currentTimeMillis()
         
         // Find soonest GCal reminder across all events
+        // Pass displayedStartTime for recurring events (master event's startTime would be wrong)
+        // Note: displayedStartTime handles instanceStartTime=0L fallback to startTime
         val soonestGCalTime: Long? = if (displayNextGCalReminder) {
             events.mapNotNull { event ->
-                calendarProvider.getEvent(ctx, event.eventId)?.getNextAlertTimeAfter(currentTime)
+                calendarProvider.getEvent(ctx, event.eventId)?.getNextAlertTimeAfter(currentTime, event.displayedStartTime)
             }.minOrNull()
         } else null
         
diff --git a/android/app/src/test/java/com/github/quarck/calnotify/textutils/EventFormatterRobolectricTest.kt b/android/app/src/test/java/com/github/quarck/calnotify/textutils/EventFormatterRobolectricTest.kt
@@ -14,6 +14,8 @@ import com.github.quarck.calnotify.calendar.EventOrigin
 import com.github.quarck.calnotify.calendar.EventRecord
 import com.github.quarck.calnotify.calendar.EventReminderRecord
 import com.github.quarck.calnotify.calendar.EventStatus
+import com.github.quarck.calnotify.calendar.displayedStartTime
+import com.github.quarck.calnotify.calendar.getNextAlertTimeAfter
 import com.github.quarck.calnotify.reminders.ReminderStateInterface
 import com.github.quarck.calnotify.utils.CNPlusUnitTestClock
 import io.mockk.every
@@ -802,5 +804,153 @@ class EventFormatterRobolectricTest {
         assertEquals("1m", EventFormatter.formatDurationCompact(0))
         assertEquals("1m", EventFormatter.formatDurationCompact(30 * 1000L))  // 30 seconds
     }
+
+    // === Recurring event tests ===
+
+    @Test
+    fun `getNextAlertTimeAfter - recurring event uses instance start time not master start time`() {
+        // Simulate a recurring weekly meeting that started 6 months ago
+        val sixMonthsAgo = baseTime - 180 * Consts.DAY_IN_MILLISECONDS
+        val thisWeeksInstance = baseTime + 2 * Consts.HOUR_IN_MILLISECONDS
+        
+        // Master event (from CalendarProvider) has old start time
+        val masterEventRecord = createMockEventRecord(
+            eventId = 100L,
+            startTime = sixMonthsAgo,  // Master event started 6 months ago!
+            reminders = listOf(EventReminderRecord.minutes(60))  // 1 hour before
+        )
+        
+        // Without instance time: reminder would be 6 months ago (wrong!)
+        val wrongResult = masterEventRecord.getNextAlertTimeAfter(baseTime)
+        assertNull("Without instanceStartTime, recurring event reminder would be in past", wrongResult)
+        
+        // With instance time: reminder should be 1 hour before this week's instance
+        val correctResult = masterEventRecord.getNextAlertTimeAfter(baseTime, thisWeeksInstance)
+        assertNotNull("With instanceStartTime, should find future reminder", correctResult)
+        
+        val expectedReminderTime = thisWeeksInstance - Consts.HOUR_IN_MILLISECONDS
+        assertEquals("Reminder should be 1hr before instance start", expectedReminderTime, correctResult)
+    }
+
+    @Test
+    fun `formatNextNotificationIndicator - recurring event shows correct indicator`() {
+        val eventId = 500L
+        val sixMonthsAgo = baseTime - 180 * Consts.DAY_IN_MILLISECONDS
+        val thisWeeksInstance = baseTime + 2 * Consts.HOUR_IN_MILLISECONDS
+        
+        // Master event has old start time (simulating recurring event)
+        val mockCalendarProvider = mockk<CalendarProviderInterface>()
+        every { mockCalendarProvider.getEvent(any(), eq(eventId)) } returns createMockEventRecord(
+            eventId = eventId,
+            startTime = sixMonthsAgo,  // Master started 6 months ago
+            reminders = listOf(EventReminderRecord.minutes(60))  // 1 hour before
+        )
+        
+        val testFormatter = EventFormatter(
+            ctx = context,
+            clock = testClock,
+            calendarProvider = mockCalendarProvider
+        )
+        
+        // Create EventAlertRecord with THIS WEEK's instance time
+        val event = EventAlertRecord(
+            calendarId = 1L,
+            eventId = eventId,
+            isAllDay = false,
+            isRepeating = true,  // This is a recurring event!
+            alertTime = baseTime,
+            notificationId = eventId.toInt(),
+            title = "Weekly Team Meeting",
+            desc = "",
+            startTime = sixMonthsAgo,  // Master event start (old)
+            endTime = sixMonthsAgo + Consts.HOUR_IN_MILLISECONDS,
+            instanceStartTime = thisWeeksInstance,  // THIS WEEK's instance
+            instanceEndTime = thisWeeksInstance + Consts.HOUR_IN_MILLISECONDS,
+            location = "",
+            lastStatusChangeTime = baseTime,
+            snoozedUntil = 0L,
+            displayStatus = EventDisplayStatus.Hidden,
+            color = 0,
+            origin = EventOrigin.ProviderBroadcast,
+            timeFirstSeen = baseTime,
+            eventStatus = EventStatus.Confirmed,
+            attendanceStatus = AttendanceStatus.None,
+            flags = 0L
+        )
+        
+        val result = testFormatter.formatNextNotificationIndicator(
+            event = event,
+            displayNextGCalReminder = true,
+            displayNextAppAlert = false,
+            remindersEnabled = false
+        )
+        
+        // Should show indicator because reminder is 1hr before THIS WEEK's instance
+        assertNotNull("Recurring event should show GCal indicator using instance time", result)
+        assertTrue("Should contain calendar emoji", result!!.contains("📅"))
+        assertTrue("Should show 1h duration", result.contains("1h"))
+    }
+
+    @Test
+    fun `formatNextNotificationIndicator - zero instanceStartTime falls back via displayedStartTime`() {
+        val eventId = 600L
+        val futureStartTime = baseTime + 2 * Consts.HOUR_IN_MILLISECONDS
+        
+        // Master event with future start time
+        val mockCalendarProvider = mockk<CalendarProviderInterface>()
+        every { mockCalendarProvider.getEvent(any(), eq(eventId)) } returns createMockEventRecord(
+            eventId = eventId,
+            startTime = futureStartTime,
+            reminders = listOf(EventReminderRecord.minutes(60))  // 1 hour before
+        )
+        
+        val testFormatter = EventFormatter(
+            ctx = context,
+            clock = testClock,
+            calendarProvider = mockCalendarProvider
+        )
+        
+        // EventAlertRecord with instanceStartTime = 0L (not set)
+        // displayedStartTime property will fall back to startTime
+        val event = EventAlertRecord(
+            calendarId = 1L,
+            eventId = eventId,
+            isAllDay = false,
+            isRepeating = false,
+            alertTime = baseTime,
+            notificationId = eventId.toInt(),
+            title = "Test Event",
+            desc = "",
+            startTime = futureStartTime,
+            endTime = futureStartTime + Consts.HOUR_IN_MILLISECONDS,
+            instanceStartTime = 0L,  // NOT SET - should fall back to startTime
+            instanceEndTime = 0L,
+            location = "",
+            lastStatusChangeTime = baseTime,
+            snoozedUntil = 0L,
+            displayStatus = EventDisplayStatus.Hidden,
+            color = 0,
+            origin = EventOrigin.ProviderBroadcast,
+            timeFirstSeen = baseTime,
+            eventStatus = EventStatus.Confirmed,
+            attendanceStatus = AttendanceStatus.None,
+            flags = 0L
+        )
+        
+        // Verify displayedStartTime falls back correctly
+        assertEquals("displayedStartTime should fall back to startTime when instanceStartTime is 0", 
+            futureStartTime, event.displayedStartTime)
+        
+        val result = testFormatter.formatNextNotificationIndicator(
+            event = event,
+            displayNextGCalReminder = true,
+            displayNextAppAlert = false,
+            remindersEnabled = false
+        )
+        
+        // Should show indicator because displayedStartTime falls back to startTime
+        assertNotNull("Zero instanceStartTime should fall back to startTime via displayedStartTime", result)
+        assertTrue("Should contain calendar emoji", result!!.contains("📅"))
+    }
 }
 
