fix: sync the correct timestamp in repeating event exceptions (#766)

* Fix: move only the selected occurrence of a repeating event

* docs: update changelog entries

* Fix: sync the correct timestamp in repeating event exceptions

* Fix: fix detekt issues in EventsHelper.kt

* docs: update changelog

* Fix: sync the correct timestamp in repeating event exceptions (rework)

* Fix: EventsHelper, do not add wrong repetition exceptions, use proper repetition exception db update method

* docs: fix changelog entry

* docs: fix changelog

* Fix: CalDAVHelper, sync correct original instance time

* Fix: EventsHelper, schedule next event reminder after updating repetition exceptions

* Fix: CalDAVHelper, do not sync original event exceptions if the event occurrence is not specified

Refs: #641

Author: RiccardoCampo

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed drag and drop copying events instead of moving them ([#706])
 - Fixed crash when editing events with attendees ([#34])
 - Fixed event edits being silently discarded on back press ([#49])
+- Fixed syncing exceptions to repeating events ([#641])
 
 ## [1.6.1] - 2025-09-01
 ### Changed
@@ -144,6 +145,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#603]: https://github.com/FossifyOrg/Calendar/issues/603
 [#613]: https://github.com/FossifyOrg/Calendar/issues/613
 [#682]: https://github.com/FossifyOrg/Calendar/issues/682
+[#641]: https://github.com/FossifyOrg/Calendar/issues/641
 [#706]: https://github.com/FossifyOrg/Calendar/issues/706
 [#729]: https://github.com/FossifyOrg/Calendar/issues/729
 [#732]: https://github.com/FossifyOrg/Calendar/issues/732

app/src/main/kotlin/org/fossify/calendar/helpers/CalDAVHelper.kt

@@ -408,9 +408,9 @@ class CalDAVHelper(val context: Context) {
     }
 
     @SuppressLint("MissingPermission")
-    fun insertCalDAVEvent(event: Event) {
+    fun insertCalDAVEvent(event: Event, originalInstanceTime: Long? = null) {
         val uri = Events.CONTENT_URI
-        val values = fillEventContentValues(event)
+        val values = fillEventContentValues(event, originalInstanceTime)
         val newUri = context.contentResolver.insert(uri, values)
 
         val calendarId = event.getCalDAVCalendarId()
@@ -485,7 +485,7 @@ class CalDAVHelper(val context: Context) {
         )
     }
 
-    private fun fillEventContentValues(event: Event): ContentValues {
+    private fun fillEventContentValues(event: Event, originalInstanceTime: Long? = null): ContentValues {
         val calendarId = event.getCalDAVCalendarId()
         return ContentValues().apply {
             put(Events.CALENDAR_ID, calendarId)
@@ -519,14 +519,14 @@ class CalDAVHelper(val context: Context) {
             }
 
             val parentEventId = event.parentId
-            if (parentEventId != 0L) {
+            if (parentEventId != 0L && originalInstanceTime != null) {
                 val parentEvent = context.eventsDB.getEventWithId(parentEventId) ?: return@apply
                 val isParentAllDay = parentEvent.getIsAllDay()
                 // original instance time must be in UTC when the parent is an all-day event
-                val originalInstanceTS = if (isParentAllDay && !event.getIsAllDay()) {
-                    Formatter.getShiftedUtcTS(event.startTS)
+                val originalInstanceTS = if (isParentAllDay) {
+                    Formatter.getShiftedUtcTS(originalInstanceTime)
                 } else {
-                    event.startTS
+                    originalInstanceTime
                 }
                 put(Events.ORIGINAL_ID, parentEvent.getCalDAVEventId())
                 put(Events.ORIGINAL_INSTANCE_TIME, originalInstanceTS * 1000L)

app/src/main/kotlin/org/fossify/calendar/helpers/EventsHelper.kt

@@ -111,45 +111,32 @@ class EventsHelper(val context: Context) {
         }
     }
 
-    fun insertEvent(event: Event, addToCalDAV: Boolean, showToasts: Boolean, enableEventType: Boolean = true, callback: ((id: Long) -> Unit)? = null) {
+    fun insertEvent(event: Event, addToCalDAV: Boolean, showToasts: Boolean, enableEventType: Boolean = true, eventOccurrenceTS: Long? = null, callback: ((id: Long) -> Unit)? = null) {
         if (event.startTS > event.endTS) {
             callback?.invoke(0)
             return
         }
 
-        maybeUpdateParentExceptions(event)
         event.id = eventsDB.insertOrUpdate(event)
         ensureEventTypeVisibility(event, enableEventType)
         context.updateWidgets()
         context.scheduleNextEventReminder(event, showToasts)
 
         if (addToCalDAV && config.caldavSync && event.source != SOURCE_SIMPLE_CALENDAR && event.source != SOURCE_IMPORTED_ICS) {
-            context.calDAVHelper.insertCalDAVEvent(event)
+            context.calDAVHelper.insertCalDAVEvent(event, eventOccurrenceTS)
         }
 
         callback?.invoke(event.id!!)
     }
 
     fun insertTask(task: Event, showToasts: Boolean, enableEventType: Boolean = true, callback: () -> Unit) {
-        maybeUpdateParentExceptions(task)
         task.id = eventsDB.insertOrUpdate(task)
         ensureEventTypeVisibility(task, enableEventType)
         context.updateWidgets()
         context.scheduleNextEventReminder(task, showToasts)
         callback()
     }
 
-    private fun maybeUpdateParentExceptions(event: Event) {
-        // if the event is an exception from another event, update the parent event's exceptions list
-        val parentEventId = event.parentId
-        if (parentEventId != 0L) {
-            val parentEvent = eventsDB.getEventOrTaskWithId(parentEventId) ?: return
-            val startDayCode = Formatter.getDayCodeFromTS(event.startTS)
-            parentEvent.addRepetitionException(startDayCode)
-            eventsDB.updateEventRepetitionExceptions(parentEvent.repetitionExceptions.toString(), parentEventId)
-        }
-    }
-
     fun insertEvents(events: ArrayList<Event>, addToCalDAV: Boolean) {
         try {
             for (event in events) {
@@ -198,7 +185,8 @@ class EventsHelper(val context: Context) {
         ensureBackgroundThread {
             val originalEvent = eventsDB.getEventOrTaskWithId(event.id!!) ?: return@ensureBackgroundThread
             originalEvent.addRepetitionException(Formatter.getDayCodeFromTS(eventOccurrenceTS))
-            updateEvent(originalEvent, updateAtCalDAV = !originalEvent.isTask(), showToasts = false)
+            eventsDB.updateEventRepetitionExceptions(originalEvent.repetitionExceptions.toString(), originalEvent.id!!)
+            context.scheduleNextEventReminder(originalEvent, false)
 
             event.apply {
                 parentId = id!!.toLong()
@@ -210,7 +198,11 @@ class EventsHelper(val context: Context) {
             if (event.isTask()) {
                 insertTask(event, showToasts = showToasts, callback = callback)
             } else {
-                insertEvent(event, addToCalDAV = true, showToasts = showToasts) {
+                insertEvent(
+                    event, addToCalDAV = true,
+                    showToasts = showToasts,
+                    eventOccurrenceTS = eventOccurrenceTS
+                ) {
                     callback()
                 }
             }