diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt index 7fda7d75..6f94bbf6 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt @@ -30,6 +30,9 @@ import de.jeanlucmakiola.calendula.domain.Reminder import de.jeanlucmakiola.calendula.domain.SearchCandidate import de.jeanlucmakiola.calendula.domain.contacts.MANAGED_UID_PREFIX import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType +import de.jeanlucmakiola.calendula.domain.ics.CalendarRows +import de.jeanlucmakiola.calendula.domain.ics.OverrideRow +import de.jeanlucmakiola.calendula.domain.ics.MasterRow import de.jeanlucmakiola.calendula.domain.ics.IcsEvent import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent import de.jeanlucmakiola.calendula.domain.ics.semanticReminderMinutes @@ -91,15 +94,15 @@ interface CalendarDataSource { fun publishedEventColors(calendarId: Long): List /** - * Every master/one-off event of [calendarIds], whatever kind of calendar - * they are (local, synced, read-only), mapped to [IcsEvent]s. A plain read: - * which calendars may be read for what is the caller's call. Modified- - * occurrence and cancelled-exception rows are excluded (see - * [EventExportProjection]). [allDayReminderTimeMinutes]: needed to write - * all-day reminders as whole-day lead times rather than raw provider + * Every event row of [calendarIds], whatever kind of calendar they are + * (local, synced, read-only): the masters/one-offs and the modified and + * cancelled exception rows, each with the keys that link it to its series + * and tagged with its calendar's name. A plain read: which calendars may be + * read for what is the caller's call. [allDayReminderTimeMinutes]: needed to + * write all-day reminders as whole-day lead times rather than raw provider * offsets (see [toIcsEvent]). */ - fun calendarEvents(calendarIds: Set, allDayReminderTimeMinutes: Int): List + fun calendarRows(calendarIds: Set, allDayReminderTimeMinutes: Int): CalendarRows /** * The non-empty `Events.UID_2445` values present in [calendarId] — used to @@ -777,24 +780,67 @@ class AndroidCalendarDataSource @Inject constructor( ?: emptyList() } - override fun calendarEvents( - calendarIds: Set, - allDayReminderTimeMinutes: Int, - ): List { - if (calendarIds.isEmpty()) return emptyList() - // Id → display name for the X-CALENDULA-CALENDAR tag a restore uses to - // fan back out; an id that no longer exists drops out here. - val names = calendars() - .filter { it.id in calendarIds } - .associate { it.id to it.displayName } - if (names.isEmpty()) return emptyList() + override fun calendarRows(calendarIds: Set, allDayReminderTimeMinutes: Int): CalendarRows { + if (calendarIds.isEmpty()) return CalendarRows(emptyList(), emptyList()) + // The name tags each event for a combined backup's restore to fan back + // out; an id that no longer exists drops out here. + val calendars = calendars().filter { it.id in calendarIds }.associateBy { it.id } + if (calendars.isEmpty()) return CalendarRows(emptyList(), emptyList()) - val idList = names.keys.joinToString(",") - // Masters + one-offs only: no soft-deleted or exception rows. - val selection = "${CalendarContract.Events.CALENDAR_ID} IN ($idList) AND " + - "${CalendarContract.Events.DELETED} = 0 AND " + - "${CalendarContract.Events.ORIGINAL_ID} IS NULL AND " + - "${CalendarContract.Events.ORIGINAL_SYNC_ID} IS NULL" + val selection = "${CalendarContract.Events.CALENDAR_ID} IN (${calendars.keys.joinToString(",")}) AND " + + "${CalendarContract.Events.DELETED} = 0" + val series = mutableListOf() + val overrides = mutableListOf() + forEachExportRow(selection, allDayReminderTimeMinutes) { event -> + val calendarId = getLong(EventExportProjection.IDX_CALENDAR_ID) + val calendar = calendars[calendarId] + // An adapter may stamp the calendar colour on every row; a palette key means it was chosen. + val color = getIntOrNull(EventExportProjection.IDX_EVENT_COLOR)?.takeIf { + it != calendar?.color || !getString(EventExportProjection.IDX_EVENT_COLOR_KEY).isNullOrEmpty() + } + val mapped = event(calendar?.displayName).copy(color = color) + val selfStatus = getIntOrNull(EventExportProjection.IDX_SELF_ATTENDEE_STATUS) + val declined = selfStatus == CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED + val originalId = getLongOrNull(EventExportProjection.IDX_ORIGINAL_ID) + val originalSyncId = getString(EventExportProjection.IDX_ORIGINAL_SYNC_ID)?.takeIf { it.isNotEmpty() } + // Without a link the provider shows the row as an event of its own. + if (originalId == null && originalSyncId == null) { + series += MasterRow( + eventId = getLong(EventExportProjection.IDX_ID), + calendarId = calendarId, + syncId = getString(EventExportProjection.IDX_SYNC_ID)?.takeIf { it.isNotEmpty() }, + event = mapped, + declined = declined, + ) + } else { + // An exception without its occurrence time can't name what it replaces. + val originalInstance = getLongOrNull(EventExportProjection.IDX_ORIGINAL_INSTANCE_TIME) + ?: return@forEachExportRow + overrides += OverrideRow( + calendarId = calendarId, + originalId = originalId, + originalSyncId = originalSyncId, + originalInstance = originalInstance.toKotlinInstantFromEpochMillis(), + event = mapped, + declined = declined, + accepted = selfStatus == CalendarContract.Attendees.ATTENDEE_STATUS_ACCEPTED || + selfStatus == CalendarContract.Attendees.ATTENDEE_STATUS_TENTATIVE, + ) + } + } + return CalendarRows(series, overrides) + } + + /** + * Hand each Events row matching [selection], oldest first, to [row] with a + * mapper to [IcsEvent] that takes the calendar name to tag it with. + * Reminders are read in one batched pass ahead of the rows. + */ + private fun forEachExportRow( + selection: String, + allDayReminderTimeMinutes: Int, + row: ColumnReader.(event: (calendarName: String?) -> IcsEvent) -> Unit, + ) { val eventIds = resolver.query( CalendarContract.Events.CONTENT_URI, arrayOf(CalendarContract.Events._ID), @@ -803,23 +849,25 @@ class AndroidCalendarDataSource @Inject constructor( null, )?.use { c -> c.mapRows { getLong(0) } }.orEmpty() val reminders = resolver.reminderMinutesByEvent(eventIds, alertsOnly = false) - return resolver.query( + resolver.query( CalendarContract.Events.CONTENT_URI, EventExportProjection.COLUMNS, selection, null, CalendarContract.Events.DTSTART + " ASC", )?.use { c -> - c.mapRows { - val eventId = getLong(EventExportProjection.IDX_ID) - val calendarId = getLong(EventExportProjection.IDX_CALENDAR_ID) - toIcsEvent( - reminderMinutes = reminders[eventId].orEmpty(), - calendarName = names[calendarId], - allDayReminderTimeMinutes = allDayReminderTimeMinutes, - ) + val reader = CursorColumnReader(c) + while (c.moveToNext()) { + val eventId = reader.getLong(EventExportProjection.IDX_ID) + reader.row { calendarName -> + reader.toIcsEvent( + reminderMinutes = reminders[eventId].orEmpty(), + calendarName = calendarName, + allDayReminderTimeMinutes = allDayReminderTimeMinutes, + ) + } } - } ?: emptyList() + } } override fun existingUids(calendarId: Long): Set = resolver.query( @@ -868,18 +916,25 @@ class AndroidCalendarDataSource @Inject constructor( } else { null } - event.semanticReminderMinutes().forEach { minutes -> - val providerMinutes = if (reminderDate != null) { - toProviderAllDayMinutes( - semanticMinutes = minutes, - startDate = reminderDate, - zone = zone, - timeOfDayMinutes = allDayReminderTimeMinutes, - ) - } else { - minutes + // All or nothing: a row whose reminders failed would count as not added + // and still be there. + try { + event.semanticReminderMinutes().forEach { minutes -> + val providerMinutes = if (reminderDate != null) { + toProviderAllDayMinutes( + semanticMinutes = minutes, + startDate = reminderDate, + zone = zone, + timeOfDayMinutes = allDayReminderTimeMinutes, + ) + } else { + minutes + } + insertReminderRow(eventId, providerMinutes) } - insertReminderRow(eventId, providerMinutes) + } catch (t: Throwable) { + runCatching { resolver.delete(eventUri(eventId), null, null) } + throw t } return eventId } diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt index 45f08aa8..850832bc 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt @@ -62,17 +62,40 @@ interface CalendarRepository { /** * Every event of [calendarIds], ready to serialise into an `.ics` backup - * (see [CalendarDataSource.calendarEvents]). Any calendar can be read, - * synced and read-only ones included (#147). + * (see [CalendarDataSource.calendarRows]). Any calendar can be read, + * synced and read-only ones included (#147). Exception rows come out + * flattened ([de.jeanlucmakiola.calendula.domain.ics.flattenOverrides]), + * so a restore keeps moved and deleted occurrences of a series. */ suspend fun exportEvents(calendarIds: Set): List /** * Bulk-import parsed `.ics` [events] into [targetCalendarId]. Events whose * UID already exists in the target are skipped (idempotent restore); the - * rest are inserted. See [CalendarDataSource.insertImportedEvent]. + * rest are inserted, as is a standalone occurrence whose series is already + * there ([ParsedIcsEvent.overrideOf]). See [CalendarDataSource.insertImportedEvent]. + * [onProgress] gets the count of events handled so far before each event + * after the first and once more when all were handled; it may throw to stop + * the import between events. */ - suspend fun importEvents(targetCalendarId: Long, events: List): IcsImportSummary + suspend fun importEvents( + targetCalendarId: Long, + events: List, + onProgress: (done: Int) -> Unit = {}, + ): IcsImportSummary + + /** + * Copy every event of [sourceCalendarId] into [targetCalendarId] (#325), + * exceptions included (see + * [de.jeanlucmakiola.calendula.domain.ics.planCalendarCopy]). The source is only read. Runs + * through [importEvents], so a re-run skips what an earlier one copied. + * [onProgress] gets (done, total) once the source is read and after each event. + */ + suspend fun copyEvents( + sourceCalendarId: Long, + targetCalendarId: Long, + onProgress: (done: Int, total: Int) -> Unit = { _, _ -> }, + ): IcsImportSummary /** Create a new event from a validated form; returns the new `Events._ID`. */ suspend fun createEvent(form: EventForm): Long diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt index 0f9c9bc4..fcaef6fc 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt @@ -14,6 +14,8 @@ import de.jeanlucmakiola.calendula.domain.EventInstance import de.jeanlucmakiola.calendula.domain.SearchCandidate import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent +import de.jeanlucmakiola.calendula.domain.ics.flattenOverrides +import de.jeanlucmakiola.calendula.domain.ics.planCalendarCopy import kotlinx.coroutines.CoroutineDispatcher import kotlinx.coroutines.channels.BufferOverflow import kotlinx.coroutines.flow.Flow @@ -30,6 +32,8 @@ import kotlinx.coroutines.flow.onStart import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.currentCoroutineContext +import kotlinx.coroutines.ensureActive import kotlinx.coroutines.withContext import java.util.concurrent.atomic.AtomicLong import kotlin.time.Instant @@ -247,12 +251,33 @@ class CalendarRepositoryImpl @Inject constructor( } } - override suspend fun exportEvents(calendarIds: Set) = - withContext(io) { dataSource.calendarEvents(calendarIds, allDayReminderTimeMinutes()) } + override suspend fun exportEvents(calendarIds: Set) = withContext(io) { + flattenOverrides(dataSource.calendarRows(calendarIds, allDayReminderTimeMinutes()), ::formatExdateStamp) + } + + override suspend fun copyEvents( + sourceCalendarId: Long, + targetCalendarId: Long, + onProgress: (done: Int, total: Int) -> Unit, + ): IcsImportSummary { + val events = withContext(io) { + planCalendarCopy( + dataSource.calendarRows(setOf(sourceCalendarId), allDayReminderTimeMinutes()), + ::formatExdateStamp, + ) + } + onProgress(0, events.size) + val context = currentCoroutineContext() + return importEvents(targetCalendarId, events) { done -> + if (done < events.size) context.ensureActive() + onProgress(done, events.size) + } + } override suspend fun importEvents( targetCalendarId: Long, events: List, + onProgress: (done: Int) -> Unit, ): IcsImportSummary = write { val existing = dataSource.existingUids(targetCalendarId) // Both are per-calendar, not per-event: looking them up once keeps a @@ -265,15 +290,21 @@ class CalendarRepositoryImpl @Inject constructor( var skipped = 0 var failed = 0 var notAttempted = 0 - for ((index, event) in events.withIndex()) { + // Occurrences whose standalone copy didn't land, by series UID: the series + // keeps them instead of excluding them for good. + val unexcluded = mutableMapOf>() + // Standalone occurrences ahead of the series they were cut from, however the file is ordered. + val ordered = events.sortedBy { it.overrideOf == null } + for ((index, event) in ordered.withIndex()) { + if (index > 0) onProgress(index) // A known UID means the event is already in this calendar — skip, // keeping a restore idempotent (no overwrite this pass). - if (event.uid != null && event.uid in existing) { + if (event.isAlreadyIn(existing)) { skipped++ continue } try { - dataSource.insertImportedEvent(event, targetCalendarId, allDayMinutes, palette) + dataSource.insertImportedEvent(event.keeping(unexcluded), targetCalendarId, allDayMinutes, palette) imported++ } catch (e: CancellationException) { throw e @@ -283,8 +314,8 @@ class CalendarRepositoryImpl @Inject constructor( Log.w(TAG, "Import stopped: the calendar is no longer writable", e) // A known UID would have been skipped whatever happened, so it is // no part of what a retry still has to import. - val remaining = events.drop(index) - val duplicates = remaining.count { it.uid?.let { uid -> uid in existing } == true } + val remaining = ordered.drop(index) + val duplicates = remaining.count { it.isAlreadyIn(existing) } skipped += duplicates notAttempted = remaining.size - duplicates break @@ -293,9 +324,13 @@ class CalendarRepositoryImpl @Inject constructor( // rest of the file — foreign exports do carry rows it rejects // outright (a malformed RRULE throws straight out of insert). failed++ + if (event.overrideOf != null && event.overrideAt != null) { + unexcluded.getOrPut(event.overrideOf) { mutableListOf() } += event.overrideAt + } Log.w(TAG, "Skipped an unimportable event", e) } } + if (notAttempted == 0) onProgress(events.size) IcsImportSummary( imported = imported, skippedDuplicate = skipped, @@ -376,3 +411,18 @@ class CalendarRepositoryImpl @Inject constructor( private fun Flow.reQuery(block: suspend () -> T): Flow = flow { collect { emit(block()) } } + +/** + * Whether [existing] UIDs already hold this event: its own UID, or — for a + * standalone occurrence of a backed-up or copied series — the series, which + * there carries the override itself. + */ +private fun ParsedIcsEvent.isAlreadyIn(existing: Set): Boolean = + (uid != null && uid in existing) || (overrideOf != null && overrideOf in existing) + +/** This series without the exclusions of [unexcluded] occurrences whose standalone copy failed. */ +private fun ParsedIcsEvent.keeping(unexcluded: Map>): ParsedIcsEvent { + val kept = uid?.let(unexcluded::get) ?: return this + val stamps = kept.map { formatExdateStamp(it.toEpochMilliseconds(), isAllDay) }.toSet() + return copy(exDates = exDates.filterNot { it in stamps }) +} diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt index 1317e9c6..328b1215 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt @@ -684,7 +684,7 @@ private const val TZID_PREFIX = "TZID=" * are UTC: the provider stores an all-day DTSTART at UTC midnight, so its date * reads off the UTC calendar day. */ -private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String = +internal fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String = formatExdateStamp( local = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC).toLocalDateTime(), isAllDay = isAllDay, @@ -851,10 +851,12 @@ internal fun buildImportedEventValues( put(CalendarContract.Events.TITLE, event.summary.trim()) put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0) put(CalendarContract.Events.DTSTART, startMillis) - if (event.recurrenceRule == null) { + if (event.recurrenceRule == null && event.recurrenceDates.isEmpty()) { put(CalendarContract.Events.DTEND, endMillis) } else { - put(CalendarContract.Events.RRULE, event.recurrenceRule) + event.recurrenceRule?.let { put(CalendarContract.Events.RRULE, it) } + event.recurrenceDates.takeIf { it.isNotEmpty() } + ?.let { put(CalendarContract.Events.RDATE, it.joinToString(",")) } put( CalendarContract.Events.DURATION, importDuration(startMillis, endMillis, event.isAllDay), @@ -866,6 +868,9 @@ internal fun buildImportedEventValues( // timed rows keep the event's own zone. put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId) put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue()) + if (event.accessLevel != AccessLevel.Default) { + put(CalendarContract.Events.ACCESS_LEVEL, event.accessLevel.toProviderValue()) + } put(CalendarContract.Events.STATUS, event.status.forNewEvent().toProviderStatus()) event.location?.trim()?.takeIf { it.isNotEmpty() } ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) } diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapper.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapper.kt index 1657e5b4..4dec9b9a 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapper.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapper.kt @@ -1,9 +1,13 @@ package de.jeanlucmakiola.calendula.data.calendar import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis +import de.jeanlucmakiola.calendula.domain.AccessLevel import de.jeanlucmakiola.calendula.domain.ics.IcsEvent import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid +import java.time.Instant +import java.time.LocalDate import java.time.ZoneId +import java.time.format.DateTimeFormatter /** * Map one Events row (read through [EventExportProjection]) into an [IcsEvent] @@ -28,6 +32,8 @@ internal fun ColumnReader.toIcsEvent( val dtStart = getLong(EventExportProjection.IDX_DTSTART) val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() } val isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0 + val timezone = getString(EventExportProjection.IDX_EVENT_TIMEZONE) + val rdates = exportRecurrenceDates(getString(EventExportProjection.IDX_RDATE), isAllDay, timezone, dtStart) // Unclamped: the writer renders DTEND as stored. val end = endMillis(dtStart, EventExportProjection.IDX_DTEND, EventExportProjection.IDX_DURATION) @@ -38,17 +44,12 @@ internal fun ColumnReader.toIcsEvent( start = dtStart.toKotlinInstantFromEpochMillis(), end = end.toKotlinInstantFromEpochMillis(), isAllDay = isAllDay, - zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() } - ?: "UTC", + zoneId = timezone?.takeIf { it.isNotBlank() } ?: "UTC", recurrenceRule = rrule, - exDates = if (rrule == null) { + exDates = if (rrule == null && rdates.isEmpty()) { emptyList() } else { - exportExDates( - getString(EventExportProjection.IDX_EXDATE), - isAllDay, - getString(EventExportProjection.IDX_EVENT_TIMEZONE), - ) + exportExDates(getString(EventExportProjection.IDX_EXDATE), isAllDay, timezone, dtStart) }, location = getString(EventExportProjection.IDX_LOCATION), description = getString(EventExportProjection.IDX_DESCRIPTION), @@ -63,6 +64,8 @@ internal fun ColumnReader.toIcsEvent( status = eventStatus(EventExportProjection.IDX_STATUS), availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)), calendarName = calendarName, + recurrenceDates = rdates, + accessLevel = getIntOrNull(EventExportProjection.IDX_ACCESS_LEVEL)?.let(::mapAccessLevel) ?: AccessLevel.Default, ) } @@ -94,16 +97,53 @@ internal fun exportExDates( exdate: String?, isAllDay: Boolean, eventTimezone: String? = null, + seriesStartMillis: Long? = null, ): List { if (exdate.isNullOrBlank()) return emptyList() - val zone = exdateListZone(exdate, eventTimezone) - return exdateStamps(exdate) - .map { stamp -> - if (isAllDay) { - stamp.substringBefore('T') - } else { - canonicalExdateStamp(stamp, isAllDay = false, listZone = zone) ?: stamp + // Several properties are stored one per line, each with its own zone prefix. + return exdate.lines().filter { it.isNotBlank() }.flatMap { line -> + val zone = exdateListZone(line, eventTimezone) + exdateStamps(line).mapNotNull { stamp -> + when { + isAllDay -> stamp.substringBefore('T') + // A bare day on a timed series means the occurrence at the series' time of day. + seriesStartMillis != null && BARE_DAY.matches(stamp) -> atSeriesTime(stamp, seriesStartMillis, zone) + else -> canonicalExdateStamp(stamp, isAllDay = false, listZone = zone) ?: stamp } } + } + .filter { (if (isAllDay) BARE_DAY else UTC_STAMP).matches(it) } .distinct() } + +/** + * The row's `RDATE` in the same shape [exportExDates] gives `EXDATE` — the list + * shares its `;` form. A `PERIOD` entry (`start/end`) keeps only its + * start: the occurrence then runs the series' own length. Anything that still + * isn't a date or a UTC stamp is dropped, since a file can't name it. + */ +internal fun exportRecurrenceDates( + rdate: String?, + isAllDay: Boolean, + eventTimezone: String? = null, + seriesStartMillis: Long? = null, +): List { + if (rdate.isNullOrBlank()) return emptyList() + // The zone prefix may hold a '/' of its own (Europe/Berlin), so only the stamps lose their period end. + val starts = rdate.lines().joinToString("\n") { line -> + val stamps = line.withoutExdateParameters() + line.dropLast(stamps.length) + stamps.split(',').joinToString(",") { it.substringBefore('/') } + } + return exportExDates(starts, isAllDay, eventTimezone, seriesStartMillis) +} + +/** [day] (`yyyyMMdd`) at the wall-clock time the series starts at in [zone], as a UTC stamp. */ +private fun atSeriesTime(day: String, seriesStartMillis: Long, zone: ZoneId): String? { + val date = runCatching { LocalDate.parse(day, DateTimeFormatter.BASIC_ISO_DATE) }.getOrNull() ?: return null + val time = Instant.ofEpochMilli(seriesStartMillis).atZone(zone).toLocalTime() + return formatExdateStamp(date.atTime(time).atZone(zone).toInstant().toEpochMilli(), isAllDay = false) +} + +private val BARE_DAY = Regex("""\d{8}""") +private val UTC_STAMP = Regex("""\d{8}T\d{6}Z""") + diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt index 5775d1a4..eeed00d7 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt @@ -152,14 +152,13 @@ internal object EventDetailProjection { } /** - * Master/one-off Events rows for a whole-calendar backup. Unlike + * Every Events row of a whole-calendar backup or copy. Unlike * [EventDetailProjection] this reads `UID_2445` (to keep a row's identity across * backups) and `DURATION` (recurring rows carry it instead of DTEND), plus - * `EXDATE` so a series exports the occurrences deleted from it. Modified- - * occurrence and cancelled-exception rows are filtered out by the query - * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides aren't exported — a - * documented v1 limit (import skips them too). EXDATE is unaffected by that - * filter: it lives on the master row, not on an exception of its own. + * `EXDATE` so a series exports the occurrences deleted from it. Exception rows + * are read too and told apart by their series-link columns; see + * [de.jeanlucmakiola.calendula.domain.ics.flattenOverrides] for how they are + * written out. */ internal object EventExportProjection { val COLUMNS: Array = arrayOf( @@ -178,6 +177,15 @@ internal object EventExportProjection { CalendarContract.Events.STATUS, CalendarContract.Events.AVAILABILITY, CalendarContract.Events.CALENDAR_ID, + CalendarContract.Events.EVENT_COLOR, + CalendarContract.Events._SYNC_ID, + CalendarContract.Events.ORIGINAL_ID, + CalendarContract.Events.ORIGINAL_SYNC_ID, + CalendarContract.Events.ORIGINAL_INSTANCE_TIME, + CalendarContract.Events.RDATE, + CalendarContract.Events.ACCESS_LEVEL, + CalendarContract.Events.EVENT_COLOR_KEY, + CalendarContract.Events.SELF_ATTENDEE_STATUS, ) const val IDX_ID = 0 @@ -195,6 +203,15 @@ internal object EventExportProjection { const val IDX_STATUS = 12 const val IDX_AVAILABILITY = 13 const val IDX_CALENDAR_ID = 14 + const val IDX_EVENT_COLOR = 15 + const val IDX_SYNC_ID = 16 + const val IDX_ORIGINAL_ID = 17 + const val IDX_ORIGINAL_SYNC_ID = 18 + const val IDX_ORIGINAL_INSTANCE_TIME = 19 + const val IDX_RDATE = 20 + const val IDX_ACCESS_LEVEL = 21 + const val IDX_EVENT_COLOR_KEY = 22 + const val IDX_SELF_ATTENDEE_STATUS = 23 } /** diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/CalendarCopy.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/CalendarCopy.kt new file mode 100644 index 00000000..13046a57 --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/CalendarCopy.kt @@ -0,0 +1,74 @@ +package de.jeanlucmakiola.calendula.domain.ics + +import de.jeanlucmakiola.calendula.domain.EventStatus +import kotlin.time.Duration.Companion.days + +/** + * The events a calendar copy (#325) inserts into its target, in the shape + * `importEvents` takes: the source's rows flattened as [flattenOverrides] does + * for a backup, minus cancelled series and one-offs, which would arrive live + * (an insert can't be cancelled), and declined invitations and occurrences. Attendees and organizer are never read. + * + * Idempotent per snapshot: `importEvents` skips a UID the target already holds, + * and an [IcsEvent.overrideOf] occurrence whose series it holds, so a re-run + * keeps the earlier copy of an occurrence changed since rather than adding a + * second one beside it. + */ +fun planCalendarCopy( + rows: CalendarRows, + exdateStamp: (occurrenceMillis: Long, isAllDay: Boolean) -> String, +): List { + val declinedSeries = rows.series.filter { it.declined } + val declinedIds = declinedSeries.map { it.eventId }.toSet() + val declinedSyncIds = declinedSeries.filter { it.syncId != null }.map { it.calendarId to it.syncId }.toSet() + fun OverrideRow.ofDeclinedSeries() = + originalId in declinedIds || (originalSyncId != null && (calendarId to originalSyncId) in declinedSyncIds) + val live = CalendarRows( + series = rows.series.filterNot { it.event.status == EventStatus.Cancelled }, + // A declined occurrence is as good as deleted here, and so is one of a + // declined series the user didn't accept on its own. + overrides = rows.overrides.map { + if (it.declined || (it.ofDeclinedSeries() && !it.accepted)) { + it.copy(event = it.event.copy(status = EventStatus.Cancelled)) + } else { + it + } + }, + ) + // A declined series still hands its accepted occurrences on before it goes. + // The flattened series follow the standalone occurrences, one per row in order. + val flat = flattenOverrides(live, exdateStamp) + val standalone = flat.size - live.series.size + return flat.filterIndexed { i, _ -> i < standalone || live.series[i - standalone].eventId !in declinedIds } + .map { it.toParsedIcsEvent() } +} + +/** + * [IcsEvent] read back as if [IcsWriter] had written it and [IcsParser] had read + * it, without the text in between. Unlike that round trip it keeps a one-off's + * own time zone (the writer pins it to UTC) and the event's colour (not part of + * the file format). + */ +fun IcsEvent.toParsedIcsEvent(): ParsedIcsEvent = ParsedIcsEvent( + uid = uid, + summary = summary, + start = start, + // RFC 5545 §3.6.1: an all-day event lasts at least its one day; zero-length + // it expands into no instance at all. + end = if (isAllDay && end <= start) start + 1.days else end, + isAllDay = isAllDay, + zoneId = zoneId, + recurrenceRule = recurrenceRule?.takeIf { it.isNotBlank() }?.removePrefix("RRULE:"), + recurrenceDates = recurrenceDates.filter { it.isNotBlank() }.distinct(), + location = location, + description = description, + // The writer emits only lead times; a negative one would be an alarm after the start. + reminderMinutes = reminderMinutes.filter { it >= 0 }.distinct(), + status = status, + availability = availability, + accessLevel = accessLevel, + color = color, + overrideOf = overrideOf, + overrideAt = overrideAt, + exDates = if (recurs) exDates.filter { it.isNotBlank() }.distinct() else emptyList(), +) diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/CalendarRows.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/CalendarRows.kt new file mode 100644 index 00000000..2258e6ce --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/CalendarRows.kt @@ -0,0 +1,99 @@ +package de.jeanlucmakiola.calendula.domain.ics + +import de.jeanlucmakiola.calendula.domain.EventStatus +import kotlin.time.Instant + +/** + * A master or one-off Events row of a calendar being backed up or copied, with + * the provider keys its exception rows point back through. + */ +data class MasterRow( + val eventId: Long, + val calendarId: Long, + val syncId: String?, + val event: IcsEvent, + /** The user declined this invitation. */ + val declined: Boolean = false, +) + +/** + * An exception row: a modified or cancelled occurrence of the series named by + * [originalId] / [originalSyncId] in [calendarId], standing in for the + * occurrence that would have started at [originalInstance]. + */ +data class OverrideRow( + val calendarId: Long, + val originalId: Long?, + val originalSyncId: String?, + val originalInstance: Instant, + val event: IcsEvent, + /** The user declined this occurrence. */ + val declined: Boolean = false, + /** The user accepted (or tentatively accepted) this occurrence on its own. */ + val accepted: Boolean = false, +) { + val isCancelled: Boolean get() = event.status == EventStatus.Cancelled +} + +/** Every event row a backup or copy reads: series/one-offs and their exception rows. */ +data class CalendarRows( + val series: List, + val overrides: List, +) + +/** + * [rows] as plain events with no exception rows left, the shape both a backup + * file and a copied calendar need: neither can hold an exception row, since one + * only attaches to its series through a `_sync_id` (and an `.ics` restore skips + * `RECURRENCE-ID` overrides). + * + * Every override excludes its occurrence from the series (`EXDATE`), and a + * modified one comes along as a standalone event at its own times, marked + * [IcsEvent.overrideOf] its series — what Calendula itself writes for "only this + * event" on an unsynced series. Its UID is derived from the series' UID and the + * occurrence, so it is the same on every run. Overrides whose series isn't + * among the rows are left out; the provider doesn't show them either. + * + * Standalone occurrences come first; `importEvents` enforces that order for + * any file, so an import cut short leaves at worst an occurrence missing its + * series, never a series missing an occurrence. + * + * [exdateStamp] formats an occurrence as an `EXDATE` entry in the provider's + * shape, the same one Calendula's own exclusions use. A cancelled series' + * modified occurrences stay cancelled. + */ +fun flattenOverrides( + rows: CalendarRows, + exdateStamp: (occurrenceMillis: Long, isAllDay: Boolean) -> String, +): List { + val byId = rows.series.associateBy { it.eventId } + // Sync ids are only unique within an account, so the link is per calendar. + val bySyncId = rows.series.filter { it.syncId != null }.associateBy { it.calendarId to it.syncId } + val excluded = mutableMapOf>() + val detached = mutableListOf>() + for (override in rows.overrides) { + val parent = override.originalId?.let(byId::get)?.takeIf { it.calendarId == override.calendarId } + ?: override.originalSyncId?.let { bySyncId[override.calendarId to it] } + ?: continue + // An exception to a one-off overrides nothing a plain event could carry. + if (!parent.event.recurs) continue + val occurrence = override.originalInstance.toEpochMilliseconds() + excluded.getOrPut(parent.eventId) { mutableListOf() } += exdateStamp(occurrence, parent.event.isAllDay) + if (override.isCancelled || parent.event.status == EventStatus.Cancelled) continue + detached += override.calendarId to override.event.copy( + uid = "$occurrence-${parent.event.uid}", + recurrenceRule = null, + recurrenceDates = emptyList(), + exDates = emptyList(), + overrideOf = parent.event.uid, + overrideAt = override.originalInstance, + ) + } + // Two exception rows for one occurrence would derive the same UID; the same + // series in two calendars legitimately does. + return detached.distinctBy { (calendarId, event) -> calendarId to event.uid }.map { it.second } + + rows.series.map { s -> + val extra = excluded[s.eventId].orEmpty() + if (extra.isEmpty()) s.event else s.event.copy(exDates = (s.event.exDates + extra).distinct()) + } +} diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsEvent.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsEvent.kt index 19da17bb..bf708821 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsEvent.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsEvent.kt @@ -1,5 +1,6 @@ package de.jeanlucmakiola.calendula.domain.ics +import de.jeanlucmakiola.calendula.domain.AccessLevel import de.jeanlucmakiola.calendula.domain.Availability import de.jeanlucmakiola.calendula.domain.EventStatus import kotlin.time.Instant @@ -36,8 +37,25 @@ data class IcsEvent( val availability: Availability = Availability.Busy, /** Source calendar name, emitted as `X-CALENDULA-CALENDAR` so a combined backup can fan back out. */ val calendarName: String? = null, + /** Extra occurrences (`RDATE`), in the same shape as [exDates]. */ + val recurrenceDates: List = emptyList(), + /** Carried by a calendar copy, not written to a file. */ + val accessLevel: AccessLevel = AccessLevel.Default, + /** The event's own colour, null when it shows its calendar's; carried by a calendar copy, not written to a file. */ + val color: Int? = null, + /** + * For a modified occurrence written out on its own ([flattenOverrides]): the + * UID of the series it replaces an occurrence of, as `X-CALENDULA-OVERRIDE-OF`. + */ + val overrideOf: String? = null, + /** The occurrence of [overrideOf] this event replaces, as `X-CALENDULA-OVERRIDE-AT`. */ + val overrideAt: Instant? = null, ) +/** Whether this is a series: by rule, or by listed dates alone. */ +val IcsEvent.recurs: Boolean + get() = !recurrenceRule.isNullOrBlank() || recurrenceDates.isNotEmpty() + /** * The UID to export for a provider event. A row that already carries a UID * (`Events.UID_2445`) keeps it; otherwise we synthesise a **stable** one from diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt index 75d40206..757e2290 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt @@ -1,5 +1,6 @@ package de.jeanlucmakiola.calendula.domain.ics +import de.jeanlucmakiola.calendula.domain.AccessLevel import de.jeanlucmakiola.calendula.domain.Availability import de.jeanlucmakiola.calendula.domain.EventStatus import de.jeanlucmakiola.calendula.domain.zoneOrNull @@ -45,6 +46,17 @@ data class ParsedIcsEvent( val exDates: List = emptyList(), /** True when this came from a `VTODO` rather than a `VEVENT`. */ val isTask: Boolean = false, + /** + * The UID of the series this standalone occurrence replaces one occurrence + * of (`X-CALENDULA-OVERRIDE-OF`). An import skips it where that series + * already is, since the series there carries its own override. + */ + val overrideOf: String? = null, + /** The occurrence of [overrideOf] this event replaces (`X-CALENDULA-OVERRIDE-AT`). */ + val overrideAt: Instant? = null, + /** Extra occurrences (`RDATE`), in the same shape as [exDates]. */ + val recurrenceDates: List = emptyList(), + val accessLevel: AccessLevel = AccessLevel.Default, ) /** @@ -212,7 +224,10 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault var calendarColor: Int? = null val reminders = mutableListOf() val exDateLines = mutableListOf() + val rDateLines = mutableListOf() var skipAsOverride = false + var overrideOf: String? = null + var overrideAt: Instant? = null var i = 0 while (i < body.size) { @@ -233,6 +248,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault "DURATION" -> duration = line.value.trim() "RRULE" -> rrule = line.value.trim().ifEmpty { null } "EXDATE" -> exDateLines.add(line) + "RDATE" -> rDateLines.add(line) "LOCATION" -> location = unescapeText(line.value).ifEmpty { null } "DESCRIPTION" -> description = unescapeText(line.value).ifEmpty { null } "STATUS" -> status = mapIcsStatus(line.value) @@ -241,6 +257,8 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault else Availability.Busy "RECURRENCE-ID" -> skipAsOverride = true "ATTENDEE" -> warnings.add(IcsParseWarning.AttendeesIgnored) + "X-CALENDULA-OVERRIDE-OF" -> overrideOf = unescapeText(line.value).trim().ifEmpty { null } + "X-CALENDULA-OVERRIDE-AT" -> overrideAt = parseBasicDateTime(line.value.trim())?.toInstant(TimeZone.UTC) "X-CALENDULA-CALENDAR" -> calendarName = unescapeText(line.value).trim().ifEmpty { calendarName } // Fossify names the source calendar per event; it never writes @@ -279,6 +297,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault val recurrence = sanitizeRrule(rrule) if (recurrence.repaired) warnings.add(IcsParseWarning.RecurrenceRuleRepaired) val end = resolveEnd(start, dtEnd, duration) + val recurrenceDates = normalizeExDates(rDateLines, start) return ParsedIcsEvent( uid = uid, summary = summary, @@ -294,12 +313,15 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault availability = availability, calendarName = calendarName ?: category, color = eventColor ?: calendarColor, - exDates = if (recurrence.rule == null) { + exDates = if (recurrence.rule == null && recurrenceDates.isEmpty()) { emptyList() } else { normalizeExDates(exDateLines, start) }, + recurrenceDates = recurrenceDates, isTask = isTask, + overrideOf = overrideOf, + overrideAt = overrideAt, ) } @@ -334,13 +356,16 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault * still means the day it spells out; resolving it to an instant first and * reading *that* back in UTC would roll a midnight east of UTC onto the day * before and exclude an occurrence that doesn't exist. + * + * `RDATE` shares the value form and is read here too. */ private fun normalizeExDates(lines: List, start: IcsDateTime): List { if (lines.isEmpty()) return emptyList() val startZone = zoneOrNull(start.zoneId) ?: deviceZone val startTime = start.instant.toLocalDateTime(startZone).time return lines - .flatMap { line -> line.value.split(',').map { line to it.trim() } } + // An RDATE PERIOD (`start/end`) counts by its start. + .flatMap { line -> line.value.split(',').map { line to it.trim().substringBefore('/') } } .mapNotNull { (line, token) -> when { token.isEmpty() -> null diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriter.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriter.kt index 250e2df5..1cf5e806 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriter.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriter.kt @@ -47,6 +47,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) { appendTimes(event) event.recurrenceRule?.takeIf { it.isNotBlank() } ?.let { add("RRULE:${it.removePrefix("RRULE:")}") } + appendRecurrenceDates(event) appendExDates(event) event.location?.takeIf { it.isNotBlank() } ?.let { add("LOCATION:${escapeText(it)}") } @@ -56,6 +57,9 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) { add("TRANSP:${transpValue(event.availability)}") event.calendarName?.takeIf { it.isNotBlank() } ?.let { add("X-CALENDULA-CALENDAR:${escapeText(it)}") } + event.overrideOf?.takeIf { it.isNotBlank() } + ?.let { add("X-CALENDULA-OVERRIDE-OF:${escapeText(it)}") } + event.overrideAt?.let { add("X-CALENDULA-OVERRIDE-AT:${it.toUtcBasic()}") } event.reminderMinutes.filter { it >= 0 }.distinct().forEach { minutes -> appendAlarm(minutes, event.summary) } @@ -68,7 +72,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) { add("DTEND;VALUE=DATE:${event.end.toLocalDateTime(TimeZone.UTC).date.toBasic()}") } // Recurring: anchor to wall-clock in the event's own zone. - event.recurrenceRule?.isNotBlank() == true -> { + event.recurs -> { val zone = zoneOrNull(event.zoneId) if (zone != null) { add("DTSTART;TZID=${event.zoneId}:${event.start.toLocalDateTime(zone).toBasic()}") @@ -85,6 +89,14 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) { } } + /** Extra occurrences: the same UTC stamps / `VALUE=DATE` days as [appendExDates]. */ + private fun MutableList.appendRecurrenceDates(event: IcsEvent) { + val stamps = event.recurrenceDates.filter { it.isNotBlank() }.distinct() + if (stamps.isEmpty()) return + val prefix = if (event.isAllDay) "RDATE;VALUE=DATE:" else "RDATE:" + add(prefix + stamps.joinToString(",")) + } + /** * The series' deleted occurrences. RFC 5545 ties `EXDATE`'s value type to * `DTSTART`'s, so an all-day series needs the explicit `VALUE=DATE` — without @@ -92,7 +104,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) { * recurring event: an exclusion names an occurrence, and a one-off has none. */ private fun MutableList.appendExDates(event: IcsEvent) { - if (event.recurrenceRule.isNullOrBlank()) return + if (!event.recurs) return val stamps = event.exDates.filter { it.isNotBlank() }.distinct() if (stamps.isEmpty()) return val prefix = if (event.isAllDay) "EXDATE;VALUE=DATE:" else "EXDATE:" diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt index 0c738b42..67f31445 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt @@ -13,6 +13,7 @@ import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.width import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.ContentCopy import androidx.compose.material.icons.filled.FileDownload import androidx.compose.material.icons.filled.FileUpload import androidx.compose.material.icons.filled.Schedule @@ -89,8 +90,11 @@ fun BackupScreen( onImport: (Uri) -> Unit, visible: Boolean = true, viewModel: CalendarsViewModel = hiltViewModel(), + copyViewModel: CopyEventsViewModel = hiltViewModel(), ) { val state by viewModel.backupState.collectAsStateWithLifecycle() + val copyRun by copyViewModel.run.collectAsStateWithLifecycle() + var showCopy by rememberSaveable { mutableStateOf(false) } val backupResult by viewModel.backupResult.collectAsStateWithLifecycle() val autoBackup by viewModel.autoBackup.collectAsStateWithLifecycle() @@ -158,6 +162,9 @@ fun BackupScreen( is BackupUiState.Ready -> BackupContent( exportable = s.exportable, canImport = s.canImport, + canCopy = s.canCopy, + copyRun = copyRun, + onCopy = { showCopy = true }, autoBackup = autoBackup, viewModel = viewModel, onRestore = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } }, @@ -177,6 +184,25 @@ fun BackupScreen( } } + // Not gated on Ready: a running copy keeps its progress and Cancel whatever the list does. + if (showCopy) { + val calendars by copyViewModel.calendars.collectAsStateWithLifecycle() + val selection by copyViewModel.selection.collectAsStateWithLifecycle() + CopyEventsScreen( + calendars = calendars, + selection = selection, + run = copyRun, + onSelectSource = copyViewModel::setSource, + onSelectTarget = copyViewModel::setTarget, + onStart = copyViewModel::start, + onCancel = copyViewModel::cancel, + onClearFinished = copyViewModel::clearFinished, + onDismiss = { + showCopy = false + copyViewModel.clearFinished() + }, + ) + } // Gated on Ready rather than resetting the flag when the state leaves it: // flipping it here would be a write during composition. (state as? BackupUiState.Ready)?.let { ready -> @@ -249,6 +275,9 @@ private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.i private fun BackupContent( exportable: List, canImport: Boolean, + canCopy: Boolean, + copyRun: CopyRunState, + onCopy: () -> Unit, autoBackup: AutoBackupUiState, viewModel: CalendarsViewModel, onRestore: () -> Unit, @@ -274,10 +303,11 @@ private fun BackupContent( GroupedHint(restoreSummary, style = MaterialTheme.typography.bodySmall) GroupedRow( title = stringResource(R.string.calendars_restore_action), - position = Position.Alone, + position = if (copyRun != CopyRunState.Idle) Position.Top else Position.Alone, leading = { LeadingAvatar(Icons.Default.FileUpload) }, onClick = onRestoreClick, ) + if (copyRun != CopyRunState.Idle) CopyEventsRow(copyRun, Position.Bottom, onCopy) return } @@ -296,6 +326,8 @@ private fun BackupContent( leading = { LeadingAvatar(Icons.Default.FileUpload) }, onClick = onRestoreClick, ) + // A running or finished copy keeps its row, the way back to its sheet. + if (canCopy || copyRun != CopyRunState.Idle) CopyEventsRow(copyRun, Position.Middle, onCopy) GroupedRow( title = stringResource(R.string.calendars_auto_backup), summary = stringResource(R.string.calendars_auto_backup_hint), @@ -361,6 +393,23 @@ private fun BackupContent( } } +@Composable +private fun CopyEventsRow(copyRun: CopyRunState, position: Position, onClick: () -> Unit) { + GroupedRow( + title = stringResource(R.string.calendars_copy_action), + summary = when (copyRun) { + is CopyRunState.Running -> copyProgressText(copyRun) + is CopyRunState.Done -> stringResource(copyRun.titleRes) + CopyRunState.Cancelled -> stringResource(R.string.calendars_copy_cancelled) + CopyRunState.Failed -> stringResource(R.string.calendars_copy_failed) + CopyRunState.Idle -> stringResource(R.string.calendars_copy_summary) + }, + position = position, + leading = { LeadingAvatar(Icons.Default.ContentCopy) }, + onClick = onClick, + ) +} + /** * Choose which calendars to include in a one-time `.ics` export. Starts on the * calendars a backup covers by default, or on all of them when none is; the Export action opens the SAF save dialog and hands back diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiState.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiState.kt index 13daf24b..55a70958 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiState.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiState.kt @@ -24,6 +24,8 @@ sealed interface BackupUiState { data class Ready( val exportable: List, val canImport: Boolean, + /** Some calendar can be copied into a different one (#325). */ + val canCopy: Boolean = false, ) : BackupUiState } @@ -50,5 +52,24 @@ fun backupUiState(calendars: List): BackupUiState { calendarListFailure(calendars) ?: FailureReason.NoImportTarget, ) } - return BackupUiState.Ready(exportable = exportable, canImport = canImport) + return BackupUiState.Ready( + exportable = exportable, + canImport = canImport, + canCopy = copySources(calendars).isNotEmpty(), + ) } + +/** + * Calendars a copy can read from: any a backup can (#325), synced and read-only + * ones included, as long as some other calendar can take their events. + */ +fun copySources(calendars: List): List { + val targets = calendars.filter { it.isEventTarget } + val onlyTarget = targets.singleOrNull()?.id + if (targets.isEmpty()) return emptyList() + return calendars.filter { it.isBackupCandidate && it.id != onlyTarget } +} + +/** Calendars a copy from [sourceId] can write into: the import targets, minus the source itself. */ +fun copyTargets(calendars: List, sourceId: Long?): List = + calendars.filter { it.isEventTarget && it.id != sourceId } diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CopyEventsScreen.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CopyEventsScreen.kt new file mode 100644 index 00000000..546059ca --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CopyEventsScreen.kt @@ -0,0 +1,386 @@ +package de.jeanlucmakiola.calendula.ui.calendars + +import androidx.compose.foundation.BorderStroke +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.outlined.Info +import androidx.compose.material.icons.rounded.ArrowDownward +import androidx.compose.material3.Button +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi +import androidx.compose.material3.Icon +import androidx.compose.material3.LinearWavyProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.TextButton +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.pluralStringResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import de.jeanlucmakiola.calendula.R +import de.jeanlucmakiola.calendula.domain.CalendarSource +import de.jeanlucmakiola.calendula.domain.FailureReason +import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip +import de.jeanlucmakiola.calendula.ui.common.CalendarFailure +import de.jeanlucmakiola.calendula.ui.common.CalendarPickerGroups +import de.jeanlucmakiola.calendula.ui.common.ImportSummaryStats +import de.jeanlucmakiola.calendula.ui.common.ResultBadge +import de.jeanlucmakiola.calendula.ui.common.ResultMessage +import de.jeanlucmakiola.calendula.ui.common.importSummaryNotes +import de.jeanlucmakiola.floret.components.OnboardingPrimaryButton +import de.jeanlucmakiola.floret.components.ResultBadge as FloretResultBadge +import de.jeanlucmakiola.calendula.ui.common.orUnnamed +import de.jeanlucmakiola.floret.components.FullScreenPicker +import de.jeanlucmakiola.floret.components.GroupedHint +import de.jeanlucmakiola.floret.components.GroupedListInset +import de.jeanlucmakiola.floret.components.IconInfoCard + +/** + * Copy every event of one calendar into another (#325), in the import flow's + * steps: pick the source, pick the target and copy, watch it run, see the result. + * The run lives in [CopyEventsViewModel], so the screen can be closed and + * reopened mid-copy. + */ +@Composable +fun CopyEventsScreen( + calendars: CopyCalendars, + selection: CopySelection, + run: CopyRunState, + onSelectSource: (Long) -> Unit, + onSelectTarget: (Long) -> Unit, + onStart: () -> Unit, + onCancel: () -> Unit, + onClearFinished: () -> Unit, + onDismiss: () -> Unit, +) { + val list = (calendars as? CopyCalendars.Ready)?.calendars.orEmpty() + val sources = remember(list) { copySources(list) } + val source = sources.firstOrNull { it.id == selection.sourceId } + val targets = remember(list, source?.id) { copyTargets(list, source?.id) } + val target = targets.firstOrNull { it.id == selection.targetId } + var step by rememberSaveable { mutableStateOf(CopyStep.Source) } + val idle = run == CopyRunState.Idle + // The run's ends, held once seen so a calendar gone or a list reloading mid-run doesn't blank them. + val runSource = rememberLastSeen(selection.sourceId, list) + val runTarget = rememberLastSeen(selection.targetId, list) + // A source that stopped qualifying sends the target step back to the start. + // Keyed on the chosen id too: right after a pick the selection may not have arrived yet. + LaunchedEffect(step, selection.sourceId, source, calendars) { + val gone = selection.sourceId != null && source == null && calendars is CopyCalendars.Ready + if (step == CopyStep.Target && gone) step = CopyStep.Source + } + + FullScreenPicker( + title = stringResource( + when { + !idle -> R.string.calendars_copy_action + step == CopyStep.Source -> R.string.calendars_copy_from_title + else -> R.string.calendars_copy_to_title + }, + ), + onDismiss = { if (idle && step == CopyStep.Target) step = CopyStep.Source else onDismiss() }, + // The target step's back only steps back, so it mustn't preview closing the screen. + predictiveBack = !(idle && step == CopyStep.Target), + scrollable = idle, + actions = { + if (idle && step == CopyStep.Target) { + Button( + onClick = onStart, + enabled = source != null && target != null, + modifier = Modifier.padding(end = 12.dp), + ) { + Text(stringResource(R.string.calendars_copy_start)) + } + } + }, + ) { + if (!idle) { + val copyMore = { + onClearFinished() + step = CopyStep.Source + } + CopyRun( + run = run, + source = runSource, + target = runTarget, + onCancel = onCancel, + // A retry only where the picker would still offer both ends; otherwise pick again. + onRetry = if (source != null && target != null) onStart else copyMore, + onCopyMore = copyMore, + onClose = onDismiss, + ) + return@FullScreenPicker + } + when (calendars) { + CopyCalendars.Loading -> { + Box(Modifier.fillMaxWidth().padding(32.dp), contentAlignment = Alignment.Center) { + CircularProgressIndicator() + } + return@FullScreenPicker + } + CopyCalendars.Failure -> { + CalendarFailure(reason = FailureReason.ProviderUnavailable, onRetry = onDismiss) + return@FullScreenPicker + } + is CopyCalendars.Ready -> Unit + } + if (sources.isEmpty()) { + GroupedHint(stringResource(R.string.calendars_copy_none)) + return@FullScreenPicker + } + when (step) { + CopyStep.Source -> { + IconInfoCard( + icon = Icons.Outlined.Info, + iconContentDescription = null, + modifier = Modifier.padding(horizontal = GroupedListInset), + ) { + Text(stringResource(R.string.calendars_copy_hint), style = MaterialTheme.typography.bodyMedium) + } + Spacer(Modifier.height(16.dp)) + CalendarPickerGroups( + calendars = sources, + selectedId = source?.id, + onSelect = { + onSelectSource(it) + step = CopyStep.Target + }, + ) + } + CopyStep.Target -> { + CopyRouteCard(source, target, Modifier.padding(horizontal = GroupedListInset)) + Spacer(Modifier.height(16.dp)) + CalendarPickerGroups( + calendars = targets, + selectedId = target?.id, + onSelect = onSelectTarget, + ) + } + } + } +} + +private enum class CopyStep { Source, Target } + +/** Progress while the copy runs, then its outcome; both under the route it took. */ +@Composable +private fun ColumnScope.CopyRun( + run: CopyRunState, + source: CalendarSource?, + target: CalendarSource?, + onCancel: () -> Unit, + onRetry: () -> Unit, + onCopyMore: () -> Unit, + onClose: () -> Unit, +) { + // Centred where it fits, scrolling where it doesn't (landscape, large fonts). + BoxWithConstraints(Modifier.fillMaxWidth().weight(1f)) { + Column( + Modifier + .fillMaxWidth() + .verticalScroll(rememberScrollState()) + .heightIn(min = maxHeight) + .padding(horizontal = GroupedListInset) + .padding(top = 8.dp, bottom = 24.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.SpaceBetween, + ) { + CopyRouteCard(source, target, pickable = false) + Column(Modifier.fillMaxWidth().padding(vertical = 24.dp), horizontalAlignment = Alignment.CenterHorizontally) { + when (run) { + is CopyRunState.Running -> CopyProgress(run) + is CopyRunState.Done -> CopyDone(run) + CopyRunState.Cancelled -> { + FloretResultBadge( + Icons.Default.Close, + MaterialTheme.colorScheme.secondaryContainer, + MaterialTheme.colorScheme.onSecondaryContainer, + ) + ResultMessage(stringResource(R.string.calendars_copy_cancelled)) + } + CopyRunState.Failed -> { + ResultBadge(error = true) + ResultMessage(stringResource(R.string.calendars_copy_failed)) + } + CopyRunState.Idle -> Unit + } + } + when (run) { + is CopyRunState.Running -> TextButton(onClick = onCancel, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.dialog_cancel)) + } + is CopyRunState.Done -> CopyEndButtons( + primary = stringResource(R.string.import_close), + onPrimary = onClose, + secondary = stringResource(R.string.calendars_copy_more), + onSecondary = onCopyMore, + ) + CopyRunState.Cancelled, CopyRunState.Failed -> CopyEndButtons( + primary = stringResource(R.string.state_retry), + onPrimary = onRetry, + secondary = stringResource(R.string.import_close), + onSecondary = onClose, + ) + CopyRunState.Idle -> Unit + } + } + } +} + +/** The calendar with [id] in [list], or the last one seen under that id while it is missing. */ +@Composable +private fun rememberLastSeen(id: Long?, list: List): CalendarSource? { + val held = remember(id) { mutableStateOf(null) } + list.firstOrNull { it.id == id }?.let { held.value = it } + return held.value +} + +@OptIn(ExperimentalMaterial3ExpressiveApi::class) +@Composable +private fun CopyProgress(run: CopyRunState.Running) { + val total = run.total + if (total == null || total == 0) { + LinearWavyProgressIndicator(modifier = Modifier.fillMaxWidth()) + } else { + LinearWavyProgressIndicator(progress = { run.done.toFloat() / total }, modifier = Modifier.fillMaxWidth()) + } + Spacer(Modifier.height(16.dp)) + Text( + text = copyProgressText(run), + style = MaterialTheme.typography.titleMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) +} + +/** "Reading events…" until the source is read, then "120 of 2,400 events". */ +@Composable +fun copyProgressText(run: CopyRunState.Running): String { + val total = run.total ?: return stringResource(R.string.calendars_copy_reading) + return pluralStringResource(R.plurals.calendars_copy_progress, total, run.done, total) +} + +@Composable +private fun CopyDone(run: CopyRunState.Done) { + val summary = run.summary + // As on the import: only a run the target cut short reads as an error. + ResultBadge(error = run.stopped) + ResultMessage( + title = stringResource(run.titleRes), + notes = importSummaryNotes( + summary, + stoppedNote = if (run.stopped) { + pluralStringResource(R.plurals.calendars_copy_stopped, summary.notAttempted, summary.notAttempted) + } else { + null + }, + ), + ) + Spacer(Modifier.height(24.dp)) + ImportSummaryStats(summary) +} + +/** The way on ([secondary], e.g. Copy more) above the way out (Close). */ +@Composable +private fun CopyEndButtons(primary: String, onPrimary: () -> Unit, secondary: String, onSecondary: () -> Unit) { + Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(4.dp)) { + OnboardingPrimaryButton(text = primary, onClick = onPrimary) + TextButton(onClick = onSecondary, modifier = Modifier.fillMaxWidth()) { Text(secondary) } + } +} + +/** + * Where the events come from and go to, with an arrow between. A missing end + * reads "Choose a calendar" while [pickable], or as unnamed on the run screens. + */ +@Composable +private fun CopyRouteCard( + source: CalendarSource?, + target: CalendarSource?, + modifier: Modifier = Modifier, + pickable: Boolean = true, +) { + Surface( + modifier = modifier.fillMaxWidth(), + shape = RoundedCornerShape(24.dp), + color = MaterialTheme.colorScheme.surfaceContainerHigh, + ) { + Column(Modifier.padding(16.dp)) { + CopyRouteEnd(stringResource(R.string.calendars_copy_from), source, pickable) + Box(Modifier.width(40.dp).padding(vertical = 4.dp), contentAlignment = Alignment.Center) { + Surface(shape = CircleShape, color = MaterialTheme.colorScheme.primaryContainer) { + Icon( + Icons.Rounded.ArrowDownward, + contentDescription = null, + tint = MaterialTheme.colorScheme.onPrimaryContainer, + modifier = Modifier.padding(6.dp).size(20.dp), + ) + } + } + CopyRouteEnd(stringResource(R.string.calendars_copy_to), target, pickable) + } + } +} + +@Composable +private fun CopyRouteEnd(label: String, calendar: CalendarSource?, pickable: Boolean) { + Row(verticalAlignment = Alignment.CenterVertically) { + if (calendar != null) { + CalendarColorChip(calendar.color) + } else { + Surface( + modifier = Modifier.size(40.dp), + shape = CircleShape, + color = MaterialTheme.colorScheme.surfaceContainerHigh, + border = BorderStroke(1.dp, MaterialTheme.colorScheme.outlineVariant), + ) {} + } + Spacer(Modifier.width(16.dp)) + Column { + Text(label, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + Text( + calendar?.displayName?.orUnnamed() + ?: if (pickable) stringResource(R.string.calendars_copy_choose) else "".orUnnamed(), + style = MaterialTheme.typography.titleMedium, + color = if (calendar != null) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + if (calendar != null) { + Text( + if (calendar.isLocal) stringResource(R.string.calendars_local_header) else calendar.accountName, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + } + } +} diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CopyEventsViewModel.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CopyEventsViewModel.kt new file mode 100644 index 00000000..d94fe9c4 --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CopyEventsViewModel.kt @@ -0,0 +1,150 @@ +package de.jeanlucmakiola.calendula.ui.calendars + +import android.util.Log +import androidx.annotation.StringRes +import androidx.lifecycle.SavedStateHandle +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import dagger.hilt.android.lifecycle.HiltViewModel +import de.jeanlucmakiola.calendula.R +import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository +import de.jeanlucmakiola.calendula.domain.CalendarSource +import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary +import de.jeanlucmakiola.floret.android.stateWhileSubscribed +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.catch +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.launch +import kotlin.coroutines.cancellation.CancellationException +import javax.inject.Inject + +/** + * Copy events from one calendar into another (#325). Scoped to the activity, so + * a copy keeps running across rotation and while the Backup screen is closed; + * finishing the activity or losing the process stops it like [cancel] does, + * and a re-run picks up where it ended. + */ +@HiltViewModel +class CopyEventsViewModel @Inject constructor( + private val repository: CalendarRepository, + private val savedState: SavedStateHandle, +) : ViewModel() { + + val calendars: StateFlow = + repository.calendars() + .map, CopyCalendars> { CopyCalendars.Ready(it) } + .catch { emit(CopyCalendars.Failure) } + .stateWhileSubscribed(scope = viewModelScope, initialValue = CopyCalendars.Loading) + + val selection: StateFlow = combine( + savedState.getStateFlow(KEY_SOURCE, null), + savedState.getStateFlow(KEY_TARGET, null), + ) { source, target -> CopySelection(source, target) } + .stateIn(viewModelScope, SharingStarted.Eagerly, CopySelection()) + + private val _run = MutableStateFlow(CopyRunState.Idle) + val run: StateFlow = _run.asStateFlow() + + private var job: Job? = null + + private val busy: Boolean get() = job?.isCompleted == false + + private fun current() = CopySelection(savedState[KEY_SOURCE], savedState[KEY_TARGET]) + + private fun select(selection: CopySelection) { + savedState[KEY_SOURCE] = selection.sourceId + savedState[KEY_TARGET] = selection.targetId + } + + fun setSource(id: Long) { + if (busy) return + select(current().withSource(id)) + clearFinished() + } + + fun setTarget(id: Long) { + if (busy) return + select(current().copy(targetId = id)) + clearFinished() + } + + fun start() { + val source = current().sourceId ?: return + val target = current().targetId ?: return + if (busy) return + _run.value = CopyRunState.Running(done = 0, total = null) + job = viewModelScope.launch { + try { + val summary = repository.copyEvents(source, target) { done, total -> + if (done == 0 || done == total || done % (total / 200).coerceAtLeast(1) == 0) { + _run.value = CopyRunState.Running(done, total) + } + } + _run.value = CopyRunState.Done(summary) + } catch (e: CancellationException) { + _run.value = CopyRunState.Cancelled + throw e + } catch (e: Exception) { + Log.w(TAG, "Copy events failed", e) + _run.value = CopyRunState.Failed + } + } + } + + fun cancel() { + job?.cancel() + } + + /** Back to idle once a finished run's outcome has been seen. */ + fun clearFinished() { + if (!busy) _run.value = CopyRunState.Idle + } + + private companion object { + const val KEY_SOURCE = "copy_source" + const val KEY_TARGET = "copy_target" + const val TAG = "CopyEvents" + } +} + +/** The calendars a copy runs between. */ +data class CopySelection(val sourceId: Long? = null, val targetId: Long? = null) { + /** A target equal to the new source is dropped: a calendar is never copied into itself. */ + fun withSource(id: Long): CopySelection = + CopySelection(sourceId = id, targetId = targetId?.takeIf { it != id }) +} + +/** The calendar list the copy screen picks from. */ +sealed interface CopyCalendars { + data object Loading : CopyCalendars + data object Failure : CopyCalendars + data class Ready(val calendars: List) : CopyCalendars +} + +sealed interface CopyRunState { + data object Idle : CopyRunState + + /** [total] is null while the source calendar is still being read. */ + data class Running(val done: Int, val total: Int?) : CopyRunState + + data class Done(val summary: IcsImportSummary) : CopyRunState { + /** The target stopped taking events part way, so some were never tried. */ + val stopped: Boolean get() = summary.notAttempted > 0 + + /** How the run ended, the same words on the row and on the result screen. */ + @get:StringRes + val titleRes: Int get() = when { + stopped -> R.string.calendars_copy_stopped_title + summary.failed > 0 -> R.string.calendars_copy_partial + else -> R.string.calendars_copy_done + } + } + data object Cancelled : CopyRunState + data object Failed : CopyRunState +} diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ResultSummary.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ResultSummary.kt new file mode 100644 index 00000000..0c9d5375 --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ResultSummary.kt @@ -0,0 +1,135 @@ +package de.jeanlucmakiola.calendula.ui.common + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.RowScope +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.height +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Check +import androidx.compose.material.icons.filled.PriorityHigh +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.res.pluralStringResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.clearAndSetSemantics +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import de.jeanlucmakiola.calendula.R +import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary +import de.jeanlucmakiola.floret.components.ResultBadge as FloretResultBadge + +/** floret's [FloretResultBadge] as a check on success, or an exclamation mark in the error colours. */ +@Composable +fun ResultBadge(error: Boolean) { + val scheme = MaterialTheme.colorScheme + if (error) { + FloretResultBadge(Icons.Default.PriorityHigh, scheme.errorContainer, scheme.onErrorContainer) + } else { + FloretResultBadge(Icons.Default.Check, scheme.primaryContainer, scheme.onPrimaryContainer) + } +} + +/** A result screen's headline under its badge, then its notes; an error note takes the error colour. */ +@Composable +fun ResultMessage(title: String, notes: List = emptyList()) { + Spacer(Modifier.height(24.dp)) + Text( + title, + style = MaterialTheme.typography.headlineSmall, + color = MaterialTheme.colorScheme.onSurface, + textAlign = TextAlign.Center, + ) + notes.forEach { note -> + Spacer(Modifier.height(8.dp)) + Text( + note.text, + style = MaterialTheme.typography.bodyMedium, + color = if (note.error) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant, + textAlign = TextAlign.Center, + ) + } +} + +data class ResultNote(val text: String, val error: Boolean = false) + +/** The notes an import summary carries: failures, skipped duplicates, then [stoppedNote] when part was never tried. */ +@Composable +fun importSummaryNotes(summary: IcsImportSummary, stoppedNote: String?): List = buildList { + if (summary.failed > 0) add(ResultNote(stringResource(R.string.import_done_failed_note))) + if (summary.skippedDuplicate > 0) add(ResultNote(stringResource(R.string.import_done_dedup_note))) + if (stoppedNote != null) add(ResultNote(stoppedNote, error = true)) +} + +/** Added / skipped / failed as big-number tiles, the latter two only when non-zero. */ +@Composable +fun ImportSummaryStats(summary: IcsImportSummary, modifier: Modifier = Modifier) { + Row(modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) { + ResultStatCard( + count = summary.imported, + label = stringResource(R.string.import_done_added_label), + contentDescription = pluralStringResource(R.plurals.import_done_imported, summary.imported, summary.imported), + container = MaterialTheme.colorScheme.secondaryContainer, + onContainer = MaterialTheme.colorScheme.onSecondaryContainer, + ) + if (summary.skippedDuplicate > 0) { + ResultStatCard( + count = summary.skippedDuplicate, + label = stringResource(R.string.import_done_skipped_label), + contentDescription = pluralStringResource( + R.plurals.import_done_skipped, + summary.skippedDuplicate, + summary.skippedDuplicate, + ), + container = MaterialTheme.colorScheme.surfaceContainerHighest, + onContainer = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + if (summary.failed > 0) { + ResultStatCard( + count = summary.failed, + label = stringResource(R.string.import_done_failed_label), + contentDescription = pluralStringResource(R.plurals.import_done_failed, summary.failed, summary.failed), + container = MaterialTheme.colorScheme.errorContainer, + onContainer = MaterialTheme.colorScheme.onErrorContainer, + ) + } + } +} + +/** A big-number tonal tile summarising one outcome. */ +@Composable +private fun RowScope.ResultStatCard( + count: Int, + label: String, + contentDescription: String, + container: Color, + onContainer: Color, +) { + Surface( + modifier = Modifier + .weight(1f) + .clearAndSetSemantics { this.contentDescription = contentDescription }, + shape = RoundedCornerShape(24.dp), + color = container, + ) { + Column( + Modifier.padding(vertical = 20.dp, horizontal = 12.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(2.dp), + ) { + Text(count.toString(), style = MaterialTheme.typography.displaySmall, color = onContainer) + Text(label, style = MaterialTheme.typography.labelLarge, color = onContainer.copy(alpha = 0.85f)) + } + } +} diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt index 9fd95c6c..3a957985 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt @@ -1,15 +1,9 @@ package de.jeanlucmakiola.calendula.ui.imports import android.net.Uri -import androidx.compose.animation.core.Animatable -import androidx.compose.animation.core.Spring -import androidx.compose.animation.core.spring -import androidx.compose.foundation.background import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.RowScope import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth @@ -17,13 +11,9 @@ import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.rememberScrollState -import androidx.compose.foundation.shape.CircleShape -import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.Check import androidx.compose.material.icons.filled.Close -import androidx.compose.material.icons.filled.PriorityHigh import androidx.compose.material3.Button import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.ExperimentalMaterial3Api @@ -31,34 +21,31 @@ import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Scaffold -import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.material3.TopAppBar import androidx.compose.material3.TopAppBarDefaults import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue +import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.remember import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier -import androidx.compose.ui.draw.clip -import androidx.compose.ui.graphics.Color -import androidx.compose.ui.graphics.graphicsLayer -import androidx.compose.ui.semantics.clearAndSetSemantics -import androidx.compose.ui.semantics.contentDescription -import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.res.pluralStringResource import androidx.compose.ui.res.stringResource import androidx.compose.ui.unit.dp import androidx.hilt.navigation.compose.hiltViewModel import androidx.lifecycle.compose.collectAsStateWithLifecycle +import de.jeanlucmakiola.floret.components.OnboardingPrimaryButton import de.jeanlucmakiola.calendula.R import de.jeanlucmakiola.calendula.domain.EventForm import de.jeanlucmakiola.calendula.domain.ics.IcsParseWarning import de.jeanlucmakiola.calendula.ui.common.CalendarPickerGroups +import de.jeanlucmakiola.calendula.ui.common.ImportSummaryStats +import de.jeanlucmakiola.calendula.ui.common.ResultBadge +import de.jeanlucmakiola.calendula.ui.common.ResultMessage +import de.jeanlucmakiola.calendula.ui.common.importSummaryNotes import de.jeanlucmakiola.floret.identity.predictiveBack /** @@ -211,18 +198,6 @@ private fun ManyContent( @Composable private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) { - // A little expressive pop on the success badge — springs in on first show. - val badgeScale = remember { Animatable(0.7f) } - LaunchedEffect(Unit) { - badgeScale.animateTo( - targetValue = 1f, - animationSpec = spring( - dampingRatio = Spring.DampingRatioMediumBouncy, - stiffness = Spring.StiffnessLow, - ), - ) - } - // Part of the file never reached the calendar, so the screen doesn't get to // read as a plain success. val stopped = state.summary.notAttempted > 0 @@ -232,160 +207,28 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) { horizontalAlignment = Alignment.CenterHorizontally, ) { Spacer(Modifier.weight(1f)) - Box( - Modifier - .size(112.dp) - .graphicsLayer { - scaleX = badgeScale.value - scaleY = badgeScale.value - } - .clip(CircleShape) - .background( - if (stopped) { - MaterialTheme.colorScheme.errorContainer - } else { - MaterialTheme.colorScheme.primaryContainer - }, - ), - contentAlignment = Alignment.Center, - ) { - Icon( - if (stopped) Icons.Default.PriorityHigh else Icons.Default.Check, - contentDescription = null, - tint = if (stopped) { - MaterialTheme.colorScheme.onErrorContainer - } else { - MaterialTheme.colorScheme.onPrimaryContainer - }, - modifier = Modifier.size(56.dp), - ) - } - Spacer(Modifier.height(24.dp)) - Text( - stringResource( + ResultBadge(error = stopped) + ResultMessage( + title = stringResource( if (stopped) R.string.import_done_stopped_title else R.string.import_done_title, ), - style = MaterialTheme.typography.headlineSmall, - color = MaterialTheme.colorScheme.onSurface, + // The counts cover the part of the file that was tried, so say how much never was. + notes = importSummaryNotes( + state.summary, + stoppedNote = if (stopped) { + pluralStringResource(R.plurals.import_done_stopped, state.summary.notAttempted, state.summary.notAttempted) + } else { + null + }, + ), ) - if (state.summary.failed > 0) { - Spacer(Modifier.height(8.dp)) - Text( - stringResource(R.string.import_done_failed_note), - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - textAlign = TextAlign.Center, - ) - } - if (state.summary.skippedDuplicate > 0) { - Spacer(Modifier.height(8.dp)) - Text( - stringResource(R.string.import_done_dedup_note), - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - textAlign = TextAlign.Center, - ) - } - // The one note that isn't about individual events: the counts below cover - // the part of the file that was tried, so say how much never was. - if (stopped) { - Spacer(Modifier.height(8.dp)) - Text( - pluralStringResource( - R.plurals.import_done_stopped, - state.summary.notAttempted, - state.summary.notAttempted, - ), - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.error, - textAlign = TextAlign.Center, - ) - } Spacer(Modifier.height(24.dp)) - Row( - Modifier.fillMaxWidth(), - horizontalArrangement = Arrangement.spacedBy(12.dp), - ) { - ImportStatCard( - count = state.summary.imported, - label = stringResource(R.string.import_done_added_label), - contentDescription = pluralStringResource( - R.plurals.import_done_imported, - state.summary.imported, - state.summary.imported, - ), - container = MaterialTheme.colorScheme.secondaryContainer, - onContainer = MaterialTheme.colorScheme.onSecondaryContainer, - ) - if (state.summary.skippedDuplicate > 0) { - ImportStatCard( - count = state.summary.skippedDuplicate, - label = stringResource(R.string.import_done_skipped_label), - contentDescription = pluralStringResource( - R.plurals.import_done_skipped, - state.summary.skippedDuplicate, - state.summary.skippedDuplicate, - ), - container = MaterialTheme.colorScheme.surfaceContainerHighest, - onContainer = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - if (state.summary.failed > 0) { - ImportStatCard( - count = state.summary.failed, - label = stringResource(R.string.import_done_failed_label), - contentDescription = pluralStringResource( - R.plurals.import_done_failed, - state.summary.failed, - state.summary.failed, - ), - container = MaterialTheme.colorScheme.errorContainer, - onContainer = MaterialTheme.colorScheme.onErrorContainer, - ) - } - } + ImportSummaryStats(state.summary) Spacer(Modifier.weight(1f)) - Button( + OnboardingPrimaryButton( + text = stringResource(R.string.import_close), onClick = onClose, - modifier = Modifier.fillMaxWidth(), - ) { - Text(stringResource(R.string.import_close)) - } - } -} - -/** A big-number tonal tile summarising one import outcome (added / skipped / failed). */ -@Composable -private fun RowScope.ImportStatCard( - count: Int, - label: String, - contentDescription: String, - container: Color, - onContainer: Color, -) { - Surface( - modifier = Modifier - .weight(1f) - .clearAndSetSemantics { this.contentDescription = contentDescription }, - shape = RoundedCornerShape(24.dp), - color = container, - ) { - Column( - Modifier.padding(vertical = 20.dp, horizontal = 12.dp), - horizontalAlignment = Alignment.CenterHorizontally, - verticalArrangement = Arrangement.spacedBy(2.dp), - ) { - Text( - count.toString(), - style = MaterialTheme.typography.displaySmall, - color = onContainer, - ) - Text( - label, - style = MaterialTheme.typography.labelLarge, - color = onContainer.copy(alpha = 0.85f), - ) - } + ) } } diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index b9f2e03f..51178f8d 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -963,6 +963,31 @@ Restore from .ics file Import events from a backup or another calendar app. No calendar can take the imported events yet. + Copy events + Copy one calendar\'s events into another, for example to move off Google. + The original calendar stays as it is. Guests and invitations you declined are left out. + From + To + Choose a calendar + Copy from + Copy into + Copy + Copy more + Reading events… + + %1$d of %2$d event + %1$d of %2$d events + + Copy complete + Copy stopped + Copy finished, some events couldn\'t be added + No calendar can be copied into another one right now. + Copy cancelled. Run it again to finish: events that were already copied are skipped. + Couldn\'t copy the events. + + The target calendar stopped accepting events part way through. %d event was never copied. + The target calendar stopped accepting events part way through. %d events were never copied. + Automatic backup Periodically export your calendars to a folder as .ics files. Backup folder diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt index 119cfc65..a951a2a4 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt @@ -8,6 +8,13 @@ import de.jeanlucmakiola.calendula.domain.EventForm import de.jeanlucmakiola.calendula.domain.EventInstance import de.jeanlucmakiola.calendula.domain.FormTime import de.jeanlucmakiola.calendula.domain.SearchCandidate +import de.jeanlucmakiola.calendula.domain.EventStatus +import de.jeanlucmakiola.calendula.domain.ics.CalendarRows +import de.jeanlucmakiola.calendula.domain.ics.IcsEvent +import de.jeanlucmakiola.calendula.domain.ics.IcsParser +import de.jeanlucmakiola.calendula.domain.ics.IcsWriter +import de.jeanlucmakiola.calendula.domain.ics.OverrideRow +import de.jeanlucmakiola.calendula.domain.ics.MasterRow import de.jeanlucmakiola.calendula.testEvent import de.jeanlucmakiola.calendula.testPrefs import de.jeanlucmakiola.calendula.testRepository @@ -946,7 +953,7 @@ class CalendarRepositoryImplTest { repo.exportEvents(calendarIds = setOf(1L, 4L)) - assertThat(fake.lastCalendarEventsIds).containsExactly(1L, 4L) + assertThat(fake.lastCalendarRowsIds).containsExactly(1L, 4L) } @Test @@ -958,7 +965,141 @@ class CalendarRepositoryImplTest { repo.exportEvents(calendarIds = setOf(2L)) - assertThat(fake.lastCalendarEventsIds).containsExactly(2L) + assertThat(fake.lastCalendarRowsIds).containsExactly(2L) + } + + @Test + fun `copyEvents reports progress and skips what an earlier run copied`( + @TempDir tempDir: Path, + ) = runTest { + fun icsEvent(uid: String) = IcsEvent( + uid = uid, + summary = uid, + start = Instant.fromEpochMilliseconds(1_000_000_000L), + end = Instant.fromEpochMilliseconds(1_000_003_600L), + isAllDay = false, + zoneId = "UTC", + ) + val fake = FakeCalendarDataSource().apply { + existingUidsResult = setOf("a") + calendarRowsResult = CalendarRows( + series = listOf(MasterRow(1, 1, null, icsEvent("a")), MasterRow(2, 1, null, icsEvent("b"))), + overrides = emptyList(), + ) + } + val repo = testRepository(fake, tempDir, Dispatchers.Unconfined) + val progress = mutableListOf>() + + val summary = repo.copyEvents(sourceCalendarId = 1L, targetCalendarId = 3L) { done, total -> + progress += done to total + } + + assertThat(summary.imported).isEqualTo(1) + assertThat(summary.skippedDuplicate).isEqualTo(1) + assertThat(fake.importedEvents.map { it.first.uid to it.second }).containsExactly("b" to 3L) + assertThat(progress.first()).isEqualTo(0 to 2) + assertThat(progress.last()).isEqualTo(2 to 2) + } + + @Test + fun `a backup restores a series' moved and deleted occurrences, and skips them where the series is`( + @TempDir tempDir: Path, + ) = runTest { + val start = Instant.parse("2026-01-05T09:00:00Z") + fun at(week: Int) = Instant.fromEpochMilliseconds(start.toEpochMilliseconds() + week * 7 * 86_400_000L) + fun event(at: Instant, status: EventStatus = EventStatus.Confirmed, rrule: String? = null) = IcsEvent( + uid = "s@x", + summary = "Standup", + start = at, + end = Instant.fromEpochMilliseconds(at.toEpochMilliseconds() + 3_600_000L), + isAllDay = false, + zoneId = "Europe/Berlin", + recurrenceRule = rrule, + status = status, + ) + val moved = Instant.fromEpochMilliseconds(at(1).toEpochMilliseconds() + 3_600_000L) + val source = FakeCalendarDataSource().apply { + calendarRowsResult = CalendarRows( + series = listOf(MasterRow(1, 1, "sync-1", event(start, rrule = "FREQ=WEEKLY"))), + overrides = listOf( + OverrideRow(1, null, "sync-1", at(1), event(moved)), + OverrideRow(1, null, "sync-1", at(2), event(at(2), EventStatus.Cancelled)), + ), + ) + } + val file = IcsWriter().writeCalendar( + testRepository(source, tempDir.resolve("a"), Dispatchers.Unconfined).exportEvents(setOf(1L)), + start, + ) + val parsed = IcsParser().parse(file).events + + val empty = FakeCalendarDataSource() + testRepository(empty, tempDir.resolve("b"), Dispatchers.Unconfined).importEvents(3L, parsed) + val (detached, series) = empty.importedEvents.map { it.first } + assertThat(detached.start).isEqualTo(moved) + assertThat(detached.recurrenceRule).isNull() + assertThat(series.exDates).containsExactly("20260112T090000Z", "20260119T090000Z") + + val original = FakeCalendarDataSource().apply { existingUidsResult = setOf("s@x") } + val summary = testRepository(original, tempDir.resolve("c"), Dispatchers.Unconfined).importEvents(3L, parsed) + assertThat(original.importedEvents).isEmpty() + assertThat(summary.skippedDuplicate).isEqualTo(2) + } + + @Test + fun `a series keeps an occurrence whose standalone copy didn't land`( + @TempDir tempDir: Path, + ) = runTest { + val fake = FakeCalendarDataSource().apply { failingImportSummaries += "moved" } + val repo = testRepository(fake, tempDir, Dispatchers.Unconfined) + val at = Instant.parse("2026-01-12T09:00:00Z") + + val summary = repo.importEvents( + 3L, + listOf( + parsedEvent("1-s", summary = "moved").copy(overrideOf = "s", overrideAt = at), + parsedEvent("s").copy(recurrenceRule = "FREQ=WEEKLY", exDates = listOf("20260112T090000Z", "20260119T090000Z")), + ), + ) + + assertThat(summary.failed).isEqualTo(1) + assertThat(fake.importedEvents.single().first.exDates).containsExactly("20260119T090000Z") + } + + @Test + fun `a standalone occurrence listed after its series still goes first`( + @TempDir tempDir: Path, + ) = runTest { + val fake = FakeCalendarDataSource() + val repo = testRepository(fake, tempDir, Dispatchers.Unconfined) + + repo.importEvents(3L, listOf(parsedEvent("s"), parsedEvent("1-s").copy(overrideOf = "s"))) + + assertThat(fake.importedEvents.map { it.first.uid }).containsExactly("1-s", "s").inOrder() + } + + @Test + fun `a backup keeps an RDATE-only series and its exceptions`( + @TempDir tempDir: Path, + ) = runTest { + val start = Instant.parse("2026-01-05T09:00:00Z") + val other = Instant.parse("2026-01-12T09:00:00Z") + val event = IcsEvent( + "s", "S", start, Instant.parse("2026-01-05T10:00:00Z"), false, "UTC", + recurrenceDates = listOf("20260112T090000Z", "20260119T090000Z"), + ) + val fake = FakeCalendarDataSource().apply { + calendarRowsResult = CalendarRows( + listOf(MasterRow(1, 1, null, event)), + listOf(OverrideRow(1, 1, null, other, event.copy(recurrenceDates = emptyList(), status = EventStatus.Cancelled))), + ) + } + + val exported = testRepository(fake, tempDir, Dispatchers.Unconfined).exportEvents(setOf(1L)) + val restored = IcsParser().parse(IcsWriter().writeCalendar(exported, start)).events.single() + + assertThat(restored.recurrenceDates).containsExactly("20260112T090000Z", "20260119T090000Z") + assertThat(restored.exDates).containsExactly("20260112T090000Z") } private fun parsedEvent(uid: String?, summary: String = "E") = diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt index 3921fca1..794dcb03 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt @@ -8,6 +8,7 @@ import de.jeanlucmakiola.calendula.domain.EventForm import de.jeanlucmakiola.calendula.domain.EventInstance import de.jeanlucmakiola.calendula.domain.SearchCandidate import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType +import de.jeanlucmakiola.calendula.domain.ics.CalendarRows import de.jeanlucmakiola.calendula.domain.ics.IcsEvent import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent import java.time.ZoneId @@ -23,9 +24,9 @@ internal class FakeCalendarDataSource : CalendarDataSource { var searchResult: (String) -> List = { _ -> emptyList() } var eventDetailResult: (Long) -> EventDetail? = { null } var publishedEventColorsResult: (Long) -> List = { emptyList() } - var calendarEventsResult: List = emptyList() - /** The [calendarIds] the last [calendarEvents] call received. */ - var lastCalendarEventsIds: Set? = null + var calendarRowsResult: CalendarRows = CalendarRows(emptyList(), emptyList()) + /** The [calendarIds] the last [calendarRows] call received. */ + var lastCalendarRowsIds: Set? = null /** UIDs the target calendar already holds, for import dedup. */ var existingUidsResult: Set = emptySet() /** Set to make the next write call throw. */ @@ -81,12 +82,9 @@ internal class FakeCalendarDataSource : CalendarDataSource { eventDetailResult(eventId) override fun publishedEventColors(calendarId: Long): List = publishedEventColorsResult(calendarId) - override fun calendarEvents( - calendarIds: Set, - allDayReminderTimeMinutes: Int, - ): List { - lastCalendarEventsIds = calendarIds - return calendarEventsResult + override fun calendarRows(calendarIds: Set, allDayReminderTimeMinutes: Int): CalendarRows { + lastCalendarRowsIds = calendarIds + return calendarRowsResult } override fun existingUids(calendarId: Long): Set = existingUidsResult diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapperTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapperTest.kt index 6045ef4d..a6096aa3 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapperTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapperTest.kt @@ -294,4 +294,39 @@ class IcsExportMapperTest { assertThat(event.exDates).isEmpty() } + + @Test + fun `a zoned RDATE list is written as UTC stamps, a period by its start`() { + assertThat(exportRecurrenceDates("Europe/Berlin;20260110T100000,20260111T100000/PT1H", isAllDay = false)) + .containsExactly("20260110T090000Z", "20260111T090000Z").inOrder() + } + + @Test + fun `an all-day RDATE keeps its days, junk is dropped`() { + assertThat(exportRecurrenceDates("20260110T000000Z,20260111,garbage", isAllDay = true)) + .containsExactly("20260110", "20260111").inOrder() + } + + @Test + fun `an RDATE stored over several lines keeps every line's dates`() { + assertThat(exportRecurrenceDates("Europe/Berlin;20260110T100000\nAmerica/New_York;20260112T090000", isAllDay = false)) + .containsExactly("20260110T090000Z", "20260112T140000Z").inOrder() + } + + @Test + fun `an EXDATE stored over several lines keeps every line, unreadable stamps go`() { + assertThat(exportExDates("Europe/Berlin;20260110T100000\nEurope/Berlin;20260117T100000,junk", isAllDay = false)) + .containsExactly("20260110T090000Z", "20260117T090000Z").inOrder() + } + + @Test + fun `a bare day on a timed series is read at the series' time of day`() { + val tenBerlin = java.time.ZonedDateTime.of(2026, 1, 5, 10, 0, 0, 0, java.time.ZoneId.of("Europe/Berlin")) + .toInstant().toEpochMilli() + + assertThat(exportExDates("20260112", isAllDay = false, "Europe/Berlin", tenBerlin)) + .containsExactly("20260112T090000Z") + assertThat(exportRecurrenceDates("20260712", isAllDay = false, "Europe/Berlin", tenBerlin)) + .containsExactly("20260712T080000Z") + } } diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/ImportedEventValuesTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/ImportedEventValuesTest.kt index e84e6580..49b39cf8 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/ImportedEventValuesTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/ImportedEventValuesTest.kt @@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.data.calendar import android.provider.CalendarContract import com.google.common.truth.Truth.assertThat +import de.jeanlucmakiola.calendula.domain.AccessLevel import de.jeanlucmakiola.calendula.domain.EventColorOption import de.jeanlucmakiola.calendula.domain.EventStatus import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent @@ -123,4 +124,21 @@ class ImportedEventValuesTest { assertThat(v[CalendarContract.Events.DURATION]).isEqualTo("P900S") assertThat(v[CalendarContract.Events.ALL_DAY]).isEqualTo(0) } + + @Test + fun `a copied RDATE-only series recurs by its dates`() { + val v = values(allDay().copy(recurrenceDates = listOf("20260820"), exDates = listOf("20260820"))) + assertThat(v).doesNotContainKey(CalendarContract.Events.DTEND) + assertThat(v).doesNotContainKey(CalendarContract.Events.RRULE) + assertThat(v[CalendarContract.Events.RDATE]).isEqualTo("20260820") + assertThat(v[CalendarContract.Events.EXDATE]).isEqualTo("20260820") + assertThat(v[CalendarContract.Events.DURATION]).isEqualTo("P1D") + } + + @Test + fun `a private event stays private, a default one leaves the calendar's say`() { + assertThat(values(allDay().copy(accessLevel = AccessLevel.Private))[CalendarContract.Events.ACCESS_LEVEL]) + .isEqualTo(CalendarContract.Events.ACCESS_PRIVATE) + assertThat(values(allDay())).doesNotContainKey(CalendarContract.Events.ACCESS_LEVEL) + } } diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/CalendarRowsTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/CalendarRowsTest.kt new file mode 100644 index 00000000..4c763dbc --- /dev/null +++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/CalendarRowsTest.kt @@ -0,0 +1,287 @@ +package de.jeanlucmakiola.calendula.domain.ics + +import com.google.common.truth.Truth.assertThat +import de.jeanlucmakiola.calendula.data.calendar.formatExdateStamp +import de.jeanlucmakiola.calendula.domain.EventStatus +import org.junit.jupiter.api.Test +import kotlin.time.Instant + +/** How a calendar's exception rows are written out for a backup (#147) or a copy (#325). */ +class CalendarRowsTest { + + private val start = Instant.parse("2026-01-05T09:00:00Z") + private val week = 7 * 24 * 3_600_000L + + private fun event( + uid: String, + rrule: String? = null, + allDay: Boolean = false, + at: Instant = start, + status: EventStatus = EventStatus.Confirmed, + exDates: List = emptyList(), + reminders: List = emptyList(), + color: Int? = null, + ) = IcsEvent( + uid = uid, + summary = uid, + start = at, + end = Instant.fromEpochMilliseconds(at.toEpochMilliseconds() + 3_600_000L), + isAllDay = allDay, + zoneId = "Europe/Berlin", + recurrenceRule = rrule, + exDates = exDates, + reminderMinutes = reminders, + status = status, + color = color, + calendarName = "Work", + ) + + private fun occurrence(n: Int) = Instant.fromEpochMilliseconds(start.toEpochMilliseconds() + n * week) + + private fun series(uid: String, rrule: String? = "FREQ=WEEKLY", id: Long = 1, calendar: Long = 1, syncId: String? = null, status: EventStatus = EventStatus.Confirmed) = + MasterRow(id, calendar, syncId, event(uid, rrule = rrule, status = status)) + + private fun flatten(series: List, overrides: List) = + flattenOverrides(CalendarRows(series, overrides), ::formatExdateStamp) + + @Test + fun `a cancelled occurrence becomes an EXDATE on the series`() { + val flat = flatten( + listOf(MasterRow(1, 1, "sync-1", event("s", rrule = "FREQ=WEEKLY", exDates = listOf("20260112T080000Z")))), + listOf(OverrideRow(1, null, "sync-1", occurrence(2), event("s", at = occurrence(2), status = EventStatus.Cancelled))), + ) + + assertThat(flat.single().exDates).containsExactly("20260112T080000Z", "20260119T090000Z").inOrder() + } + + @Test + fun `a modified occurrence is excluded from the series and written on its own, first`() { + val moved = Instant.fromEpochMilliseconds(occurrence(1).toEpochMilliseconds() + 3_600_000L) + val flat = flatten( + listOf(series("s")), + listOf(OverrideRow(1, 1, null, occurrence(1), event("s", rrule = "FREQ=WEEKLY", at = moved))), + ) + + assertThat(flat).hasSize(2) + val detached = flat[0] + assertThat(detached.uid).isEqualTo("${occurrence(1).toEpochMilliseconds()}-s") + assertThat(detached.overrideOf).isEqualTo("s") + assertThat(detached.recurrenceRule).isNull() + assertThat(detached.start).isEqualTo(moved) + assertThat(detached.calendarName).isEqualTo("Work") + assertThat(flat[1].exDates).containsExactly("20260112T090000Z") + } + + @Test + fun `an all-day series excludes the occurrence by its day`() { + val day = Instant.parse("2026-01-05T00:00:00Z") + val flat = flatten( + listOf(MasterRow(1, 1, null, event("s", rrule = "FREQ=DAILY", allDay = true, at = day))), + listOf(OverrideRow(1, 1, null, Instant.parse("2026-01-07T00:00:00Z"), event("s", allDay = true, status = EventStatus.Cancelled))), + ) + + assertThat(flat.single().exDates).containsExactly("20260107") + } + + @Test + fun `exceptions without their series are left out`() { + val flat = flatten( + emptyList(), + listOf( + OverrideRow(1, 5, null, occurrence(1), event("x")), + OverrideRow(1, 5, null, occurrence(2), event("y", status = EventStatus.Cancelled)), + ), + ) + + assertThat(flat).isEmpty() + } + + @Test + fun `a sync id links an exception only within its own calendar`() { + val flat = flatten( + listOf(series("a", calendar = 1, syncId = "same"), series("b", id = 2, calendar = 2, syncId = "same")), + listOf(OverrideRow(2, null, "same", occurrence(1), event("x", status = EventStatus.Cancelled))), + ) + + assertThat(flat.first { it.uid == "a" }.exDates).isEmpty() + assertThat(flat.first { it.uid == "b" }.exDates).containsExactly("20260112T090000Z") + } + + @Test + fun `an exception to a one-off is ignored`() { + val flat = flatten( + listOf(series("o", rrule = null)), + listOf(OverrideRow(1, 1, null, occurrence(0), event("x"))), + ) + + assertThat(flat.map { it.uid }).containsExactly("o") + } + + @Test + fun `an RDATE-only series keeps its dates and takes its exceptions`() { + val flat = flatten( + listOf(MasterRow(1, 1, null, event("s").copy(recurrenceDates = listOf("20260112T090000Z")))), + listOf(OverrideRow(1, 1, null, occurrence(1), event("s", status = EventStatus.Cancelled))), + ) + + assertThat(flat.single().recurrenceDates).containsExactly("20260112T090000Z") + assertThat(flat.single().exDates).containsExactly("20260112T090000Z") + } + + @Test + fun `two exception rows for one occurrence are written once`() { + val flat = flatten( + listOf(series("s")), + listOf(OverrideRow(1, 1, null, occurrence(1), event("x")), OverrideRow(1, 1, null, occurrence(1), event("y"))), + ) + + assertThat(flat.map { it.summary }).containsExactly("x", "s").inOrder() + } + + @Test + fun `the output is stable, so a re-run dedups every event`() { + val rows = CalendarRows(listOf(series("s")), listOf(OverrideRow(1, 1, null, occurrence(1), event("x")))) + + assertThat(flattenOverrides(rows, ::formatExdateStamp).map { it.uid }) + .isEqualTo(flattenOverrides(rows, ::formatExdateStamp).map { it.uid }) + } + + @Test + fun `a backup keeps a cancelled series, a copy leaves it out with its exceptions`() { + val rows = CalendarRows( + listOf(series("s", status = EventStatus.Cancelled)), + listOf(OverrideRow(1, 1, null, occurrence(1), event("x"))), + ) + + assertThat(flattenOverrides(rows, ::formatExdateStamp).map { it.uid }).contains("s") + assertThat(planCalendarCopy(rows, ::formatExdateStamp)).isEmpty() + } + + @Test + fun `a copy keeps the zone, colour and override link`() { + val rows = CalendarRows( + listOf(MasterRow(1, 1, null, event("s", rrule = "FREQ=WEEKLY", reminders = listOf(10, -5, 10), color = 0xFF112233.toInt()))), + listOf(OverrideRow(1, 1, null, occurrence(1), event("x"))), + ) + + val (detached, copied) = planCalendarCopy(rows, ::formatExdateStamp) + assertThat(detached.overrideOf).isEqualTo("s") + assertThat(copied.zoneId).isEqualTo("Europe/Berlin") + assertThat(copied.color).isEqualTo(0xFF112233.toInt()) + assertThat(copied.reminderMinutes).containsExactly(10) + } + + @Test + fun `a zero-length all-day event lasts its day`() { + val day = Instant.parse("2026-01-05T00:00:00Z") + val parsed = event("a", allDay = true, at = day).copy(end = day).toParsedIcsEvent() + + assertThat(parsed.end).isEqualTo(Instant.parse("2026-01-06T00:00:00Z")) + } + + @Test + fun `the override link survives the file`() { + val text = IcsWriter().writeCalendar(listOf(event("d").copy(overrideOf = "s;1", overrideAt = occurrence(1))), start) + + val parsed = IcsParser().parse(text).events.single() + assertThat(parsed.overrideOf).isEqualTo("s;1") + assertThat(parsed.overrideAt).isEqualTo(occurrence(1)) + } + + @Test + fun `a cancelled series' moved occurrence isn't brought back`() { + val flat = flatten( + listOf(series("s", status = EventStatus.Cancelled)), + listOf(OverrideRow(1, 1, null, occurrence(1), event("x"))), + ) + + assertThat(flat.map { it.uid }).containsExactly("s") + } + + @Test + fun `the same series in two calendars keeps each calendar's moved occurrence`() { + val flat = flatten( + listOf(series("s", id = 1, calendar = 1), series("s", id = 2, calendar = 2)), + listOf( + OverrideRow(1, 1, null, occurrence(1), event("x")), + OverrideRow(2, 2, null, occurrence(1), event("x")), + ), + ) + + assertThat(flat.count { it.overrideOf == "s" }).isEqualTo(2) + } + + @Test + fun `a copy leaves declined invitations out but keeps an occurrence accepted on its own`() { + val rows = CalendarRows( + listOf(series("d").copy(declined = true), series("k", id = 2)), + listOf( + OverrideRow(1, 1, null, occurrence(1), event("accepted"), accepted = true), + OverrideRow(1, 1, null, occurrence(2), event("moved by the organizer")), + ), + ) + + val plan = planCalendarCopy(rows, ::formatExdateStamp) + assertThat(plan.map { it.summary }).containsExactly("accepted", "k") + } + + @Test + fun `a copy treats a declined occurrence as deleted`() { + val rows = CalendarRows( + listOf(series("s")), + listOf(OverrideRow(1, 1, null, occurrence(1), event("x"), declined = true)), + ) + + val plan = planCalendarCopy(rows, ::formatExdateStamp) + assertThat(plan.map { it.uid }).containsExactly("s") + assertThat(plan.single().exDates).containsExactly("20260112T090000Z") + } + + @Test + fun `RDATE and its exclusions survive the file`() { + val timed = event("t").copy( + recurrenceDates = listOf("20260112T090000Z", "20260120T090000Z"), + exDates = listOf("20260112T090000Z"), + ) + val day = Instant.parse("2026-01-05T00:00:00Z") + val allDay = event("a", allDay = true, at = day).copy( + end = Instant.parse("2026-01-06T00:00:00Z"), + recurrenceDates = listOf("20260110"), + exDates = listOf("20260110"), + ) + val text = IcsWriter().writeCalendar(listOf(timed, allDay), start) + + assertThat(text).contains("RDATE;VALUE=DATE:20260110") + assertThat(text).contains("DTSTART;TZID=Europe/Berlin:20260105T100000") + val (t, a) = IcsParser().parse(text).events + assertThat(t.recurrenceDates).containsExactly("20260112T090000Z", "20260120T090000Z") + assertThat(t.exDates).containsExactly("20260112T090000Z") + assertThat(a.recurrenceDates).containsExactly("20260110") + assertThat(a.exDates).containsExactly("20260110") + } + + @Test + fun `a foreign RDATE is read in its own zone, a period by its start`() { + val text = """ + BEGIN:VCALENDAR + BEGIN:VEVENT + UID:f + DTSTART;TZID=Europe/Berlin:20260105T100000 + DTEND;TZID=Europe/Berlin:20260105T110000 + RDATE;TZID=America/New_York:20260110T090000 + RDATE;VALUE=PERIOD:20260111T090000Z/PT1H + END:VEVENT + END:VCALENDAR + """.trimIndent().replace("\n", "\r\n") + + assertThat(IcsParser().parse(text).events.single().recurrenceDates) + .containsExactly("20260110T140000Z", "20260111T090000Z") + } + + @Test + fun `a declined row takes no other row with its UID along`() { + val rows = CalendarRows(listOf(series("u").copy(declined = true), series("u", id = 2)), emptyList()) + + assertThat(planCalendarCopy(rows, ::formatExdateStamp)).hasSize(1) + } +} diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiStateTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiStateTest.kt index 196125ca..c2e8f031 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiStateTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiStateTest.kt @@ -97,4 +97,48 @@ class BackupUiStateTest { assertThat(state.exportable.map { it.id }).containsExactly(1L, 2L) assertThat(state.canImport).isTrue() } + + @Test + fun `a read-only calendar can be copied into a writable one`() { + val readOnly = cal(1, writable = false) + val local = cal(2, local = true) + + val state = ready(backupUiState(listOf(readOnly, local))) + + assertThat(state.canCopy).isTrue() + assertThat(copySources(listOf(readOnly, local)).map { it.id }).containsExactly(1L) + assertThat(copyTargets(listOf(readOnly, local), 1L).map { it.id }).containsExactly(2L) + } + + @Test + fun `a single writable calendar has nothing to copy into`() { + val only = cal(1, local = true) + + assertThat(ready(backupUiState(listOf(only))).canCopy).isFalse() + assertThat(copyTargets(listOf(only), 1L)).isEmpty() + } + + @Test + fun `the only writable calendar is not offered as a source`() { + val local = cal(1, local = true) + val holidays = cal(2, writable = false) + + assertThat(copySources(listOf(local, holidays)).map { it.id }).containsExactly(2L) + } + + @Test + fun `a copy never targets a managed or switched-off calendar`() { + val source = cal(1) + val calendars = listOf(source, cal(2, managed = true), cal(3, visible = false)) + + assertThat(copyTargets(calendars, source.id)).isEmpty() + } + + @Test + fun `choosing the target as source drops it`() { + assertThat(CopySelection(sourceId = 1, targetId = 2).withSource(2)) + .isEqualTo(CopySelection(sourceId = 2, targetId = null)) + assertThat(CopySelection(sourceId = 1, targetId = 2).withSource(3)) + .isEqualTo(CopySelection(sourceId = 3, targetId = 2)) + } } diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 22b4e6cc..851535ed 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -586,15 +586,62 @@ of the backup keeps its last one. The pre-#411 fixed `calendula-backup.ics` is the combined series' stable copy for the install that wrote it, and an install that already had a folder stays on the combined layout. -**A backup carries the series' deleted occurrences.** `EXDATE` lives on the -master row, so the export query's `ORIGINAL_ID IS NULL` filter — which does drop -`RECURRENCE-ID` overrides — never hid it; it simply wasn't read. It is now part -of `EventExportProjection`, and `IcsWriter` marks an all-day series' exclusions -`VALUE=DATE`, because RFC 5545 ties `EXDATE`'s value type to `DTSTART`'s and a -bare day code without it reads as a malformed DATE-TIME. Sync adapters disagree -on whether an all-day exclusion is `yyyyMMdd` or a padded midnight stamp, so -`exportExDates` drops the time part on the way out. Without this, an in-app -backup→restore resurrected every occurrence the user had deleted. +**A backup carries the series' deleted and moved occurrences.** `EXDATE` lives on +the master row and is part of `EventExportProjection`; `IcsWriter` marks an +all-day series' exclusions `VALUE=DATE`, because RFC 5545 ties `EXDATE`'s value +type to `DTSTART`'s and a bare day code without it reads as a malformed +DATE-TIME. Sync adapters disagree on whether an all-day exclusion is `yyyyMMdd` +or a padded midnight stamp, so `exportExDates` drops the time part on the way +out. + +A synced calendar records a deleted or moved occurrence as an *exception row* +(`ORIGINAL_ID` / `ORIGINAL_SYNC_ID` = the series, `ORIGINAL_INSTANCE_TIME` = the +occurrence) instead, and neither a backup file nor a copied calendar can hold +one: an `.ics` restore skips `RECURRENCE-ID` overrides, and an inserted row has +no `_sync_id` for an exception to attach through. `CalendarDataSource.calendarRows` +therefore reads every row, exceptions included, and `flattenOverrides` — the one +place this mapping lives, shared by the backup (`exportEvents`) and Copy events +(#325, `planCalendarCopy`) — writes them the way Calendula writes "only this +event" on an unsynced series: every exception adds its occurrence to the +series' `EXDATE`, and a modified one becomes a standalone event at its own +times. Its UID is derived from the series UID and the occurrence, so it is the +same in every backup, and it carries the series UID as `X-CALENDULA-OVERRIDE-OF`. +`importEvents` skips such an occurrence wherever its series already is — that +series there has the override itself — so restoring into the calendar a backup +came from adds nothing twice, while a restore into an empty one gets both. The +standalone event also names its occurrence (`X-CALENDULA-OVERRIDE-AT`); if it +fails to insert, the series is inserted without that exclusion, so the +occurrence stays at its original time rather than vanishing for good. The +import inserts every such event ahead of the series, whatever order the file +lists them in. +Exceptions whose series isn't among the rows are left out, a cancelled +series' moved occurrences stay cancelled, and sync ids link only within their +own calendar. Backups made before this carry no exceptions and restore exactly +as before. + +**`RDATE` travels like `EXDATE` (#515).** A series can repeat by listed dates +alone. The provider stores `RDATE` in the same `;` form as +`EXDATE`, so `exportRecurrenceDates` resolves it the same way to UTC stamps (or +bare days for an all-day series), line by line where several `RDATE`s were +stored; a `PERIOD` entry keeps its start, and a bare day on a timed series +becomes the occurrence at the series' time of day, so the copy (which never +goes through the parser) and a file get the same stamps. `IcsWriter` +writes it as `RDATE:` / `RDATE;VALUE=DATE:`, anchors such a series to its zone +like an RRULE series, and writes its `EXDATE` too; `IcsParser` reads `RDATE` +through the same normalisation as `EXDATE`, so a foreign `TZID` or floating +value lands on the right instant. Older backups wrote such a series as a single +event and still restore as one. + +**Copying a calendar.** Backup & restore → Copy events (#325) runs the source's +flattened rows straight into `importEvents`, so the UID dedup makes a re-run skip +what landed before. It skips the `.ics` text: the writer pins a timed one-off to +UTC and carries no colour or visibility; the direct mapping keeps them. +Attendees and organizer are never read, and cancelled events and declined +invitations are left out (an insert can't be cancelled; it would arrive live, and +a declined occurrence counts as deleted, as does one of a declined series the +user didn't accept on its own). A re-run is idempotent per +snapshot: a series already in the target keeps its overrides, so an occurrence +changed since keeps its earlier copy rather than gaining a second one. That re-encode is sampled where the reminder will actually *fire*, not at `DTSTART` (`importedAllDayReminderDate`). An imported series' `DTSTART` is only an