fix(#325): review round 1 - visibility and RDATE copied, cancel only stops a copy, sources need a target
This commit is contained in:
1 parent
e5d9b4965b
commit
46882d154e
17 files changed
+200
-60
No files matched your search
@@ -867,10 +867,11 @@ class AndroidCalendarDataSource @Inject constructor(
|
||||
null,
|
||||
CalendarContract.Events.DTSTART + " ASC",
|
||||
)?.use { c ->
|
||||
c.mapRows {
|
||||
val eventId = getLong(EventExportProjection.IDX_ID)
|
||||
row { calendarName ->
|
||||
toIcsEvent(
|
||||
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,
|
||||
|
||||
@@ -71,8 +71,8 @@ interface CalendarRepository {
|
||||
* 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].
|
||||
* [onProgress] gets the count of events handled so far after each one; a
|
||||
* cancelled caller stops the import between events.
|
||||
* [onProgress] gets the count of events handled so far after each one, and
|
||||
* may throw to stop the import between events.
|
||||
*/
|
||||
suspend fun importEvents(
|
||||
targetCalendarId: Long,
|
||||
|
||||
+11
-3
@@ -259,10 +259,19 @@ class CalendarRepositoryImpl @Inject constructor(
|
||||
onProgress: (done: Int, total: Int) -> Unit,
|
||||
): IcsImportSummary {
|
||||
val events = withContext(io) {
|
||||
planCalendarCopy(dataSource.calendarCopyRows(sourceCalendarId, allDayReminderTimeMinutes()))
|
||||
planCalendarCopy(
|
||||
dataSource.calendarCopyRows(sourceCalendarId, allDayReminderTimeMinutes()),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
}
|
||||
onProgress(0, events.size)
|
||||
return importEvents(targetCalendarId, events) { done -> onProgress(done, events.size) }
|
||||
// Checked between events, so cancelling stops the copy; a plain import
|
||||
// keeps running to the end of its file.
|
||||
val context = currentCoroutineContext()
|
||||
return importEvents(targetCalendarId, events) { done ->
|
||||
context.ensureActive()
|
||||
onProgress(done, events.size)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun importEvents(
|
||||
@@ -282,7 +291,6 @@ class CalendarRepositoryImpl @Inject constructor(
|
||||
var failed = 0
|
||||
var notAttempted = 0
|
||||
for ((index, event) in events.withIndex()) {
|
||||
currentCoroutineContext().ensureActive()
|
||||
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).
|
||||
|
||||
@@ -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,11 @@ 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 == null) {
|
||||
put(CalendarContract.Events.DTEND, endMillis)
|
||||
} else {
|
||||
put(CalendarContract.Events.RRULE, event.recurrenceRule)
|
||||
event.recurrenceRule?.let { put(CalendarContract.Events.RRULE, it) }
|
||||
event.recurrenceDates?.let { put(CalendarContract.Events.RDATE, it) }
|
||||
put(
|
||||
CalendarContract.Events.DURATION,
|
||||
importDuration(startMillis, endMillis, event.isAllDay),
|
||||
@@ -866,6 +867,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) }
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
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.ZoneId
|
||||
@@ -27,6 +28,7 @@ internal fun ColumnReader.toIcsEvent(
|
||||
val eventId = getLong(EventExportProjection.IDX_ID)
|
||||
val dtStart = getLong(EventExportProjection.IDX_DTSTART)
|
||||
val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() }
|
||||
val rdate = getString(EventExportProjection.IDX_RDATE)?.takeIf { it.isNotBlank() }
|
||||
val isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0
|
||||
|
||||
// Unclamped: the writer renders DTEND as stored.
|
||||
@@ -41,7 +43,7 @@ internal fun ColumnReader.toIcsEvent(
|
||||
zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() }
|
||||
?: "UTC",
|
||||
recurrenceRule = rrule,
|
||||
exDates = if (rrule == null) {
|
||||
exDates = if (rrule == null && rdate == null) {
|
||||
emptyList()
|
||||
} else {
|
||||
exportExDates(
|
||||
@@ -63,6 +65,8 @@ internal fun ColumnReader.toIcsEvent(
|
||||
status = eventStatus(EventExportProjection.IDX_STATUS),
|
||||
availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
|
||||
calendarName = calendarName,
|
||||
recurrenceDates = rdate,
|
||||
accessLevel = getIntOrNull(EventExportProjection.IDX_ACCESS_LEVEL)?.let(::mapAccessLevel) ?: AccessLevel.Default,
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -161,7 +161,7 @@ internal object EventDetailProjection {
|
||||
* 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. A
|
||||
* calendar copy (#325) reads the exception rows too, through the trailing
|
||||
* colour and series-link columns.
|
||||
* colour, series-link, RDATE and access-level columns.
|
||||
*/
|
||||
internal object EventExportProjection {
|
||||
val COLUMNS: Array<String> = arrayOf(
|
||||
@@ -185,6 +185,8 @@ internal object EventExportProjection {
|
||||
CalendarContract.Events.ORIGINAL_ID,
|
||||
CalendarContract.Events.ORIGINAL_SYNC_ID,
|
||||
CalendarContract.Events.ORIGINAL_INSTANCE_TIME,
|
||||
CalendarContract.Events.RDATE,
|
||||
CalendarContract.Events.ACCESS_LEVEL,
|
||||
)
|
||||
|
||||
const val IDX_ID = 0
|
||||
@@ -207,6 +209,8 @@ internal object EventExportProjection {
|
||||
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
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
package de.jeanlucmakiola.calendula.domain.ics
|
||||
|
||||
import de.jeanlucmakiola.calendula.domain.EventStatus
|
||||
import kotlinx.datetime.TimeZone
|
||||
import kotlinx.datetime.toLocalDateTime
|
||||
import kotlin.time.Duration.Companion.days
|
||||
import kotlin.time.Instant
|
||||
|
||||
@@ -52,24 +50,34 @@ data class CalendarCopyRows(
|
||||
* any other event.
|
||||
*
|
||||
* Standalone occurrences come first: a run cut short then leaves at worst an
|
||||
* occurrence missing its series, never a series missing an occurrence.
|
||||
* Attendees and organizer are not part of either input; the copy is the
|
||||
* user's own event.
|
||||
* occurrence missing its series, never a series missing an occurrence. A UID
|
||||
* that comes up twice is planned once, as a re-run would dedup it anyway.
|
||||
* Attendees and organizer are not part of either input.
|
||||
*
|
||||
* Idempotent per snapshot only: a series already in the target is skipped
|
||||
* whole, so an occurrence changed in the source after an earlier run arrives
|
||||
* as a standalone event next to the copied series' original one.
|
||||
*
|
||||
* [exdateStamp] formats an occurrence as an `EXDATE` entry in the provider's
|
||||
* shape, the same one Calendula's own exclusions use.
|
||||
*/
|
||||
fun planCalendarCopy(rows: CalendarCopyRows): List<ParsedIcsEvent> {
|
||||
fun planCalendarCopy(
|
||||
rows: CalendarCopyRows,
|
||||
exdateStamp: (occurrenceMillis: Long, isAllDay: Boolean) -> String,
|
||||
): List<ParsedIcsEvent> {
|
||||
val (series, exceptions) = rows
|
||||
val byId = series.associateBy { it.eventId }
|
||||
val bySyncId = series.filter { !it.syncId.isNullOrEmpty() }.associateBy { it.syncId }
|
||||
val bySyncId = series.filter { it.syncId != null }.associateBy { it.syncId }
|
||||
val excluded = mutableMapOf<Long, MutableList<String>>()
|
||||
val detached = mutableListOf<ParsedIcsEvent>()
|
||||
for (exception in exceptions) {
|
||||
val parent = exception.originalId?.let(byId::get)
|
||||
?: exception.originalSyncId?.takeIf { it.isNotEmpty() }?.let(bySyncId::get)
|
||||
?: exception.originalSyncId?.let(bySyncId::get)
|
||||
if (parent != null) {
|
||||
// An exception to a one-off overrides nothing a copy could carry.
|
||||
if (parent.event.recurrenceRule.isNullOrBlank()) continue
|
||||
if (!parent.event.recurs) continue
|
||||
excluded.getOrPut(parent.eventId) { mutableListOf() } +=
|
||||
exdateStamp(exception.originalInstance, parent.event.isAllDay)
|
||||
exdateStamp(exception.originalInstance.toEpochMilliseconds(), parent.event.isAllDay)
|
||||
}
|
||||
if (exception.isCancelled) continue
|
||||
val baseUid = parent?.event?.uid ?: exception.event.uid
|
||||
@@ -77,15 +85,15 @@ fun planCalendarCopy(rows: CalendarCopyRows): List<ParsedIcsEvent> {
|
||||
.copy(
|
||||
uid = "${exception.originalInstance.toEpochMilliseconds()}-$baseUid",
|
||||
recurrenceRule = null,
|
||||
exDates = emptyList(),
|
||||
recurrenceDates = null,
|
||||
)
|
||||
.toParsedIcsEvent(exception.color)
|
||||
}
|
||||
return detached + series.map { s ->
|
||||
return (detached + series.map { s ->
|
||||
val extra = excluded[s.eventId].orEmpty()
|
||||
val event = if (extra.isEmpty()) s.event else s.event.copy(exDates = (s.event.exDates + extra).distinct())
|
||||
event.toParsedIcsEvent(s.color)
|
||||
}
|
||||
}).distinctBy { it.uid }
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -104,16 +112,14 @@ fun IcsEvent.toParsedIcsEvent(color: Int? = null): ParsedIcsEvent = ParsedIcsEve
|
||||
isAllDay = isAllDay,
|
||||
zoneId = zoneId,
|
||||
recurrenceRule = recurrenceRule?.takeIf { it.isNotBlank() }?.removePrefix("RRULE:"),
|
||||
recurrenceDates = recurrenceDates?.takeIf { it.isNotBlank() },
|
||||
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,
|
||||
exDates = if (recurrenceRule.isNullOrBlank()) emptyList() else exDates.filter { it.isNotBlank() }.distinct(),
|
||||
exDates = if (recurs) exDates.filter { it.isNotBlank() }.distinct() else emptyList(),
|
||||
)
|
||||
|
||||
/** An occurrence as an `EXDATE` entry in the provider's shape: the UTC day for an all-day series, else a UTC stamp. */
|
||||
internal fun exdateStamp(occurrence: Instant, isAllDay: Boolean): String =
|
||||
if (isAllDay) occurrence.toLocalDateTime(TimeZone.UTC).date.toBasic() else occurrence.toUtcBasic()
|
||||
@@ -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,16 @@ 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,
|
||||
/** The provider's raw `RDATE`; carried by a calendar copy, not written to a file. */
|
||||
val recurrenceDates: String? = null,
|
||||
/** Carried by a calendar copy, not written to a file. */
|
||||
val accessLevel: AccessLevel = AccessLevel.Default,
|
||||
)
|
||||
|
||||
/** Whether this is a series: by rule, or by listed dates alone. */
|
||||
val IcsEvent.recurs: Boolean
|
||||
get() = !recurrenceRule.isNullOrBlank() || !recurrenceDates.isNullOrBlank()
|
||||
|
||||
/**
|
||||
* 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
|
||||
|
||||
@@ -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,9 @@ data class ParsedIcsEvent(
|
||||
val exDates: List<String> = emptyList(),
|
||||
/** True when this came from a `VTODO` rather than a `VEVENT`. */
|
||||
val isTask: Boolean = false,
|
||||
/** The provider's raw `RDATE`, only set by a calendar copy. */
|
||||
val recurrenceDates: String? = null,
|
||||
val accessLevel: AccessLevel = AccessLevel.Default,
|
||||
)
|
||||
|
||||
/**
|
||||
|
||||
@@ -326,8 +326,13 @@ private fun BackupContent(
|
||||
if (canCopy) {
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.calendars_copy_action),
|
||||
summary = (copyRun as? CopyRunState.Running)?.let { copyProgressText(it) }
|
||||
?: stringResource(R.string.calendars_copy_summary),
|
||||
summary = when (copyRun) {
|
||||
is CopyRunState.Running -> copyProgressText(copyRun)
|
||||
is CopyRunState.Done -> stringResource(R.string.calendars_copy_done)
|
||||
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.Middle,
|
||||
leading = { LeadingAvatar(Icons.Default.ContentCopy) },
|
||||
onClick = onCopy,
|
||||
|
||||
@@ -55,13 +55,19 @@ fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
|
||||
return BackupUiState.Ready(
|
||||
exportable = exportable,
|
||||
canImport = canImport,
|
||||
canCopy = exportable.any { copyTargets(calendars, it.id).isNotEmpty() },
|
||||
canCopy = copySources(calendars).isNotEmpty(),
|
||||
)
|
||||
}
|
||||
|
||||
/** Calendars a copy can read from: any a backup can (#325), synced and read-only ones included. */
|
||||
fun copySources(calendars: List<CalendarSource>): List<CalendarSource> =
|
||||
calendars.filter { it.isBackupCandidate }
|
||||
/**
|
||||
* 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<CalendarSource>): List<CalendarSource> {
|
||||
val targets = calendars.filter { it.isEventTarget }
|
||||
if (targets.isEmpty()) return emptyList()
|
||||
return calendars.filter { source -> source.isBackupCandidate && targets.any { it.id != source.id } }
|
||||
}
|
||||
|
||||
/** Calendars a copy from [sourceId] can write into: the import targets, minus the source itself. */
|
||||
fun copyTargets(calendars: List<CalendarSource>, sourceId: Long?): List<CalendarSource> =
|
||||
|
||||
@@ -38,7 +38,7 @@ import de.jeanlucmakiola.floret.components.Position
|
||||
*/
|
||||
@Composable
|
||||
fun CopyEventsSheet(
|
||||
calendars: List<CalendarSource>,
|
||||
calendars: List<CalendarSource>?,
|
||||
selection: CopySelection,
|
||||
run: CopyRunState,
|
||||
onSelectSource: (Long) -> Unit,
|
||||
@@ -47,9 +47,9 @@ fun CopyEventsSheet(
|
||||
onCancel: () -> Unit,
|
||||
onDismiss: () -> Unit,
|
||||
) {
|
||||
val sources = copySources(calendars)
|
||||
val sources = calendars?.let(::copySources).orEmpty()
|
||||
val source = sources.firstOrNull { it.id == selection.sourceId }
|
||||
val targets = copyTargets(calendars, source?.id)
|
||||
val targets = calendars?.let { copyTargets(it, source?.id) }.orEmpty()
|
||||
val target = targets.firstOrNull { it.id == selection.targetId }
|
||||
val running = run is CopyRunState.Running
|
||||
var picking by rememberSaveable { mutableStateOf<CopyEnd?>(null) }
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package de.jeanlucmakiola.calendula.ui.calendars
|
||||
|
||||
import androidx.lifecycle.SavedStateHandle
|
||||
import androidx.lifecycle.ViewModel
|
||||
import androidx.lifecycle.viewModelScope
|
||||
import dagger.hilt.android.lifecycle.HiltViewModel
|
||||
@@ -13,53 +14,71 @@ 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.flowOn
|
||||
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). Lives as long as the
|
||||
* activity, so a long copy keeps running across rotation and when the Backup
|
||||
* screen is closed; [cancel] stops it between events.
|
||||
* 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,
|
||||
@IoDispatcher io: CoroutineDispatcher,
|
||||
) : ViewModel() {
|
||||
|
||||
val calendars: StateFlow<List<CalendarSource>> =
|
||||
/** Null until the first read. */
|
||||
val calendars: StateFlow<List<CalendarSource>?> =
|
||||
repository.calendars()
|
||||
.catch { emit(emptyList()) }
|
||||
.flowOn(io)
|
||||
.stateWhileSubscribed(scope = viewModelScope, initialValue = emptyList())
|
||||
.stateWhileSubscribed(scope = viewModelScope, initialValue = null)
|
||||
|
||||
private val _selection = MutableStateFlow(CopySelection())
|
||||
val selection: StateFlow<CopySelection> = _selection.asStateFlow()
|
||||
val selection: StateFlow<CopySelection> = combine(
|
||||
savedState.getStateFlow<Long?>(KEY_SOURCE, null),
|
||||
savedState.getStateFlow<Long?>(KEY_TARGET, null),
|
||||
) { source, target -> CopySelection(source, target) }
|
||||
.stateIn(viewModelScope, SharingStarted.Eagerly, CopySelection())
|
||||
|
||||
private val _run = MutableStateFlow<CopyRunState>(CopyRunState.Idle)
|
||||
val run: StateFlow<CopyRunState> = _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 (job?.isActive == true) return
|
||||
_selection.value = _selection.value.withSource(id)
|
||||
if (busy) return
|
||||
select(current().withSource(id))
|
||||
clearFinished()
|
||||
}
|
||||
|
||||
fun setTarget(id: Long) {
|
||||
if (job?.isActive == true) return
|
||||
_selection.value = _selection.value.copy(targetId = id)
|
||||
if (busy) return
|
||||
select(current().copy(targetId = id))
|
||||
clearFinished()
|
||||
}
|
||||
|
||||
fun start() {
|
||||
val source = _selection.value.sourceId ?: return
|
||||
val target = _selection.value.targetId ?: return
|
||||
if (job?.isActive == true) return
|
||||
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 {
|
||||
@@ -82,7 +101,12 @@ class CopyEventsViewModel @Inject constructor(
|
||||
|
||||
/** Back to idle once a finished run's outcome has been seen. */
|
||||
fun clearFinished() {
|
||||
if (job?.isActive != true) _run.value = CopyRunState.Idle
|
||||
if (!busy) _run.value = CopyRunState.Idle
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val KEY_SOURCE = "copy_source"
|
||||
const val KEY_TARGET = "copy_target"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+18
@@ -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 = "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)
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
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
|
||||
@@ -41,6 +42,7 @@ class CalendarCopyTest {
|
||||
series = listOf(CopySeries(1, null, event("a", reminders = listOf(10, -5, 10)), color = 0xFF112233.toInt())),
|
||||
exceptions = emptyList(),
|
||||
),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
|
||||
val copied = plan.single()
|
||||
@@ -64,6 +66,7 @@ class CalendarCopyTest {
|
||||
),
|
||||
),
|
||||
),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
|
||||
val series = plan.single()
|
||||
@@ -85,6 +88,7 @@ class CalendarCopyTest {
|
||||
),
|
||||
),
|
||||
),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
|
||||
assertThat(plan).hasSize(2)
|
||||
@@ -110,6 +114,7 @@ class CalendarCopyTest {
|
||||
),
|
||||
),
|
||||
),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
|
||||
assertThat(plan.single().exDates).containsExactly("20260107")
|
||||
@@ -125,6 +130,7 @@ class CalendarCopyTest {
|
||||
CopyException(5, null, occurrence(2), event("y", status = EventStatus.Cancelled)),
|
||||
),
|
||||
),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
|
||||
assertThat(plan.map { it.summary }).containsExactly("x")
|
||||
@@ -137,7 +143,7 @@ class CalendarCopyTest {
|
||||
exceptions = listOf(CopyException(1, null, occurrence(1), event("s"))),
|
||||
)
|
||||
|
||||
assertThat(planCalendarCopy(rows).map { it.uid }).isEqualTo(planCalendarCopy(rows).map { it.uid })
|
||||
assertThat(planCalendarCopy(rows, ::formatExdateStamp).map { it.uid }).isEqualTo(planCalendarCopy(rows, ::formatExdateStamp).map { it.uid })
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -147,4 +153,35 @@ class CalendarCopyTest {
|
||||
|
||||
assertThat(parsed.end).isEqualTo(Instant.parse("2026-01-06T00:00:00Z"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an RDATE-only series keeps its dates and takes its exceptions`() {
|
||||
val plan = planCalendarCopy(
|
||||
CalendarCopyRows(
|
||||
series = listOf(CopySeries(1, null, event("s").copy(recurrenceDates = "20260112T090000Z"))),
|
||||
exceptions = listOf(CopyException(1, null, occurrence(1), event("s", status = EventStatus.Cancelled))),
|
||||
),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
|
||||
val series = plan.single()
|
||||
assertThat(series.recurrenceDates).isEqualTo("20260112T090000Z")
|
||||
assertThat(series.exDates).containsExactly("20260112T090000Z")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a UID that comes up twice is planned once`() {
|
||||
val plan = planCalendarCopy(
|
||||
CalendarCopyRows(
|
||||
series = listOf(CopySeries(1, null, event("s", rrule = "FREQ=WEEKLY"))),
|
||||
exceptions = listOf(
|
||||
CopyException(1, null, occurrence(1), event("x")),
|
||||
CopyException(1, null, occurrence(1), event("y")),
|
||||
),
|
||||
),
|
||||
::formatExdateStamp,
|
||||
)
|
||||
|
||||
assertThat(plan.map { it.summary }).containsExactly("x", "s").inOrder()
|
||||
}
|
||||
}
|
||||
@@ -106,7 +106,7 @@ class BackupUiStateTest {
|
||||
val state = ready(backupUiState(listOf(readOnly, local)))
|
||||
|
||||
assertThat(state.canCopy).isTrue()
|
||||
assertThat(copySources(listOf(readOnly, local)).map { it.id }).containsExactly(1L, 2L)
|
||||
assertThat(copySources(listOf(readOnly, local)).map { it.id }).containsExactly(1L)
|
||||
assertThat(copyTargets(listOf(readOnly, local), 1L).map { it.id }).containsExactly(2L)
|
||||
}
|
||||
|
||||
@@ -118,6 +118,14 @@ class BackupUiStateTest {
|
||||
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)
|
||||
|
||||
@@ -505,8 +505,10 @@ overrides are written the way Calendula writes "only this event" on such a
|
||||
series: each exception adds its occurrence to the series' `EXDATE`, and a
|
||||
modified one becomes a standalone event with a UID derived from the series UID
|
||||
and the occurrence. The rows skip the `.ics` text: the writer pins a timed
|
||||
one-off to UTC and carries no colour, the direct mapping keeps both. Attendees
|
||||
and organizer are never read. The backup keeps excluding exceptions; a restore
|
||||
one-off to UTC and carries no colour, visibility or `RDATE`; the direct mapping
|
||||
keeps them. Attendees and organizer are never read. A re-run is idempotent per
|
||||
snapshot: a series already in the target is skipped whole, so an occurrence
|
||||
changed in the source since lands beside it rather than replacing it. The backup keeps excluding exceptions; a restore
|
||||
could not place a `RECURRENCE-ID` either.
|
||||
|
||||
That re-encode is sampled where the reminder will actually *fire*, not at
|
||||
|
||||
Reference in new issue
Block a user