Compare commits
26
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2c3e909515 | ||
|
|
ec060056dd | ||
|
|
8e99c46f3e | ||
|
|
1e83000696 | ||
|
|
05887d2ed0 | ||
|
|
028d8d0e1e | ||
|
|
30af150197 | ||
|
|
041f8ec2f7 | ||
|
|
10208a332e | ||
|
|
0a36a6d287 | ||
|
|
d5079f0618 | ||
|
|
3ed56b8596 | ||
|
|
3f4bf65b1a | ||
|
|
026970501e | ||
|
|
46882d154e | ||
|
|
e5d9b4965b | ||
|
|
c6901c9c63 | ||
|
|
8754f046f2 | ||
|
|
bb075d052e | ||
|
|
5c05563785 | ||
|
|
88c64d5786 | ||
|
|
d86a09b744 | ||
|
|
f314761e45 | ||
|
|
46818cd0ae | ||
|
|
240ed5237a | ||
|
|
deb2fd4482 |
No files matched your search
@@ -5,6 +5,7 @@ import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.content.Context
|
||||
import android.net.Uri
|
||||
import android.os.Build
|
||||
import android.util.Log
|
||||
import androidx.core.app.NotificationCompat
|
||||
@@ -25,17 +26,29 @@ import de.jeanlucmakiola.calendula.R
|
||||
import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
|
||||
import de.jeanlucmakiola.calendula.data.ics.IcsExporter
|
||||
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.calendula.domain.backup.backupTargets
|
||||
import de.jeanlucmakiola.calendula.domain.backup.planBackupFiles
|
||||
import de.jeanlucmakiola.calendula.domain.backup.latestHeldElsewhere
|
||||
import de.jeanlucmakiola.calendula.domain.backup.latestLedgerKey
|
||||
import de.jeanlucmakiola.calendula.domain.backup.replacedLatestCopies
|
||||
import de.jeanlucmakiola.calendula.domain.backup.withLedgerEntry
|
||||
import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
|
||||
import de.jeanlucmakiola.floret.android.hasPermission
|
||||
import kotlinx.coroutines.NonCancellable
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import kotlinx.coroutines.withContext
|
||||
import java.time.LocalDateTime
|
||||
import java.util.concurrent.TimeUnit
|
||||
import kotlin.coroutines.cancellation.CancellationException
|
||||
import kotlin.time.Clock
|
||||
|
||||
/**
|
||||
* Schedules and runs the automatic periodic `.ics` backup of local calendars
|
||||
* (issue #8). One-way export only — it mirrors the manual "Back up" into a
|
||||
* user-chosen folder on an interval; it is not a sync. Stays INTERNET-free:
|
||||
* everything is local provider reads + a local file write.
|
||||
* Schedules and runs the automatic periodic `.ics` backup (issue #8) of the
|
||||
* calendars the user picked (#147). One-way export only — it mirrors the manual
|
||||
* "Back up" into a user-chosen folder on an interval; it is not a sync. Stays
|
||||
* INTERNET-free: everything is local provider reads + local file writes.
|
||||
*/
|
||||
object BackupScheduler {
|
||||
|
||||
@@ -47,8 +60,8 @@ object BackupScheduler {
|
||||
* periodic request when backup is on and a folder is set, otherwise cancel
|
||||
* it. WorkManager persists the request across reboots on its own.
|
||||
*
|
||||
* The first run is delayed by one interval so it never overlaps an immediate
|
||||
* [runNow] (two simultaneous writes would race and leave a "(1)" duplicate).
|
||||
* The first run is delayed by one interval so it doesn't follow an immediate
|
||||
* [runNow] with a near-identical copy.
|
||||
*/
|
||||
fun apply(context: Context, enabled: Boolean, intervalMinutes: Long, hasFolder: Boolean) {
|
||||
val workManager = WorkManager.getInstance(context)
|
||||
@@ -86,8 +99,9 @@ object BackupScheduler {
|
||||
}
|
||||
|
||||
/**
|
||||
* Exports the local calendars to `calendula-backup.ics` in the configured folder,
|
||||
* overwriting the previous file. Pulls its collaborators through a Hilt
|
||||
* Exports the selected calendars into the configured folder — one dated file
|
||||
* per calendar, or one combined file (#411) — then prunes each series down to
|
||||
* the retention count. Pulls its collaborators through a Hilt
|
||||
* [EntryPoint] so it works under WorkManager's default (no-arg) worker factory —
|
||||
* no custom factory / Application wiring needed. Records the outcome for the
|
||||
* settings status line, and notifies after repeated failures.
|
||||
@@ -108,25 +122,124 @@ class BackupWorker(
|
||||
override suspend fun doWork(): Result {
|
||||
val deps = EntryPointAccessors.fromApplication(applicationContext, Deps::class.java)
|
||||
val prefs = deps.settingsPrefs()
|
||||
// Respect the toggle even for already-queued work: if backup was turned
|
||||
// off, no-op (and don't retry) so a lingering run can't revive itself.
|
||||
if (!prefs.autoBackupEnabled.first()) return Result.success()
|
||||
val folder = prefs.autoBackupFolderUri.first()
|
||||
?: return Result.failure() // nothing to write to — leave scheduling to settings
|
||||
val now = System.currentTimeMillis()
|
||||
return try {
|
||||
val events = deps.repository().exportEvents()
|
||||
val content = IcsWriter().writeCalendar(events, Clock.System.now())
|
||||
deps.exporter().writeToFolder(folder.toUri(), BACKUP_FILE_NAME, content)
|
||||
prefs.recordAutoBackupRun(success = true, atMillis = now)
|
||||
Result.success()
|
||||
} catch (e: Exception) {
|
||||
prefs.recordAutoBackupRun(success = false, atMillis = now)
|
||||
if (prefs.autoBackupStatus.first().consecutiveFailures >= FAILURE_NOTIFY_THRESHOLD) {
|
||||
notifyFailure(applicationContext)
|
||||
// The periodic and the immediate run are separate unique works; one at
|
||||
// a time, or each would overwrite the other's ledger.
|
||||
val outcome = runLock.withLock {
|
||||
// Respect the toggle even for already-queued work, so a lingering
|
||||
// run can't revive itself.
|
||||
if (!prefs.autoBackupEnabled.first()) return Result.success()
|
||||
val folder = prefs.autoBackupFolderUri.first() ?: return Result.failure()
|
||||
try {
|
||||
runBackup(deps, prefs, folder.toUri())
|
||||
} catch (e: CancellationException) {
|
||||
throw e
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Automatic backup failed", e)
|
||||
RunOutcome.Failed
|
||||
}
|
||||
Log.w(TAG, "Automatic backup failed", e)
|
||||
Result.retry()
|
||||
}
|
||||
if (outcome == RunOutcome.NothingSelected) return Result.success()
|
||||
val success = outcome == RunOutcome.Written
|
||||
prefs.recordAutoBackupRun(success = success, atMillis = now)
|
||||
if (!success && prefs.autoBackupStatus.first().consecutiveFailures >= FAILURE_NOTIFY_THRESHOLD) {
|
||||
notifyFailure(applicationContext)
|
||||
}
|
||||
// Only a run that wrote nothing retries: a retry rewrites every series.
|
||||
return if (outcome == RunOutcome.Failed) Result.retry() else Result.success()
|
||||
}
|
||||
|
||||
private enum class RunOutcome { Written, PartlyFailed, Failed, NothingSelected }
|
||||
|
||||
/** Writes each series and prunes it only once its new file has landed. */
|
||||
private suspend fun runBackup(deps: Deps, prefs: SettingsPrefs, folder: Uri): RunOutcome {
|
||||
val repository = deps.repository()
|
||||
val exporter = deps.exporter()
|
||||
if (!applicationContext.hasPermission(Manifest.permission.READ_CALENDAR)) return RunOutcome.Failed
|
||||
val all = repository.calendars().first()
|
||||
val selection = prefs.autoBackupSelection.first()
|
||||
val targets = backupTargets(all.filter(selection::selects), combined = prefs.autoBackupCombined.first())
|
||||
if (targets.isEmpty()) return RunOutcome.NothingSelected
|
||||
prefs.adoptLegacyBackupFile()
|
||||
val listing = exporter.listFolder(folder)
|
||||
val ledger = prefs.autoBackupLedger.first()
|
||||
// A listing still loading can't tell a gone file from a late one.
|
||||
val existing = if (listing.complete) listing.files.keys else listing.files.keys + ledger.values.flatten()
|
||||
val plans = planBackupFiles(
|
||||
targets = targets,
|
||||
ledger = ledger,
|
||||
existing = existing,
|
||||
at = LocalDateTime.now(),
|
||||
keep = prefs.autoBackupKeep.first(),
|
||||
)
|
||||
val stamp = Clock.System.now()
|
||||
val liveKeys = all.map { it.id.toString() }.toSet()
|
||||
suspend fun record(key: String, files: List<String>) =
|
||||
prefs.updateAutoBackupLedger(folder.toString()) { withLedgerEntry(it, key, files, liveKeys) }
|
||||
var written = 0
|
||||
val landedLatest = mutableSetOf<String>()
|
||||
for (plan in plans) {
|
||||
val target = plan.target
|
||||
val bytes = try {
|
||||
IcsWriter()
|
||||
.writeCalendar(repository.exportEvents(target.calendarIds), stamp, target.calendarName)
|
||||
.toByteArray(Charsets.UTF_8)
|
||||
} catch (e: CancellationException) {
|
||||
throw e
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Reading one series failed", e)
|
||||
continue
|
||||
}
|
||||
// Not cancellable once a file exists: it must reach the ledger, or
|
||||
// nothing would ever prune it.
|
||||
withContext(NonCancellable) {
|
||||
try {
|
||||
val name = exporter.writeToFolder(folder, listing, plan.fileName, bytes)
|
||||
record(target.key, plan.prune + plan.keep + name)
|
||||
val undeleted = exporter.deleteFromFolder(listing, plan.prune)
|
||||
record(target.key, plan.prune.filter { it in undeleted } + plan.keep + name)
|
||||
written++
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Backup of one series failed", e)
|
||||
}
|
||||
// Best-effort: the stable copy never holds up the dated backup,
|
||||
// its pruning or the run's status. An old copy goes only once the
|
||||
// new one has landed, so a series is never left without one.
|
||||
try {
|
||||
val latest = plan.latestName ?: return@withContext
|
||||
val latestKey = latestLedgerKey(target.key)
|
||||
val landed = exporter.writeToFolder(folder, listing, latest, bytes)
|
||||
// A provider that renamed it leaves a copy to clean up next
|
||||
// run; the intended name stays ours only if it already was.
|
||||
val ownsLatest = landed == latest || latest in ledger[latestKey].orEmpty()
|
||||
val current = listOfNotNull(landed, latest.takeIf { ownsLatest })
|
||||
// A hand-off stays on record only until its new owner claimed it.
|
||||
suspend fun recordLatest(stale: List<String>) = prefs.updateAutoBackupLedger(folder.toString()) {
|
||||
val pending = plan.handOff - it.latestHeldElsewhere(target.key)
|
||||
withLedgerEntry(it, latestKey, stale + pending + current, liveKeys)
|
||||
}
|
||||
recordLatest(plan.staleLatest)
|
||||
if (landed == latest) landedLatest += target.key
|
||||
val staleLeft = exporter.deleteFromFolder(listing, plan.staleLatest)
|
||||
recordLatest(plan.staleLatest.filter { it in staleLeft })
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Stable copy of one series failed", e)
|
||||
}
|
||||
}
|
||||
}
|
||||
// A layout switch retires the other layout's copies once every new one is there.
|
||||
if (landedLatest.size == plans.size) {
|
||||
replacedLatestCopies(targets, prefs.autoBackupLedger.first(), existing).forEach { (key, names) ->
|
||||
withContext(NonCancellable) {
|
||||
val left = exporter.deleteFromFolder(listing, names)
|
||||
record(latestLedgerKey(key), names.filter { it in left })
|
||||
}
|
||||
}
|
||||
}
|
||||
return when (written) {
|
||||
plans.size -> RunOutcome.Written
|
||||
0 -> RunOutcome.Failed
|
||||
else -> RunOutcome.PartlyFailed
|
||||
}
|
||||
}
|
||||
|
||||
@@ -165,10 +278,10 @@ class BackupWorker(
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val BACKUP_FILE_NAME = "calendula-backup.ics"
|
||||
private const val FAILURE_NOTIFY_THRESHOLD = 2
|
||||
private const val CHANNEL_ID = "backup"
|
||||
private const val NOTIFICATION_ID = 2
|
||||
private const val TAG = "BackupWorker"
|
||||
private val runLock = Mutex()
|
||||
}
|
||||
}
|
||||
+110
-53
@@ -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
|
||||
@@ -90,15 +93,15 @@ interface CalendarDataSource {
|
||||
fun publishedEventColors(calendarId: Long): List<EventColorOption>
|
||||
|
||||
/**
|
||||
* Every master/one-off event of the writable local calendars, mapped for a
|
||||
* whole-calendar `.ics` backup. Modified-occurrence and cancelled-exception
|
||||
* rows are excluded (see [EventExportProjection]). When [calendarIds] is
|
||||
* given, only those calendars are exported (still intersected with the
|
||||
* eligible set); `null` exports every eligible calendar.
|
||||
* [allDayReminderTimeMinutes]: needed to write all-day reminders as whole-day
|
||||
* lead times rather than raw provider offsets (see [toIcsEvent]).
|
||||
* 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 exportableEvents(calendarIds: Set<Long>?, allDayReminderTimeMinutes: Int): List<IcsEvent>
|
||||
fun calendarRows(calendarIds: Set<Long>, allDayReminderTimeMinutes: Int): CalendarRows
|
||||
|
||||
/**
|
||||
* The non-empty `Events.UID_2445` values present in [calendarId] — used to
|
||||
@@ -776,47 +779,94 @@ class AndroidCalendarDataSource @Inject constructor(
|
||||
?: emptyList()
|
||||
}
|
||||
|
||||
override fun exportableEvents(
|
||||
calendarIds: Set<Long>?,
|
||||
allDayReminderTimeMinutes: Int,
|
||||
): List<IcsEvent> {
|
||||
// Only the local calendars the app owns and can write — synced calendars
|
||||
// already have a backup (their server). Exclude the managed special-dates
|
||||
// mirror calendars: their events are derived from contacts, not authored
|
||||
// here, and re-materialise from the contact sync — backing them up would
|
||||
// just duplicate them on restore. A non-null [calendarIds] narrows the
|
||||
// export to the user's chosen subset. Map id → display name for the
|
||||
// X-CALENDULA-CALENDAR tag a restore uses to fan back out.
|
||||
val names = calendars()
|
||||
.filter {
|
||||
it.isLocal && it.canModifyContents && !it.isManaged &&
|
||||
(calendarIds == null || it.id in calendarIds)
|
||||
}
|
||||
.associate { it.id to it.displayName }
|
||||
if (names.isEmpty()) return emptyList()
|
||||
override fun calendarRows(calendarIds: Set<Long>, 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(",")
|
||||
return resolver.query(
|
||||
val selection = "${CalendarContract.Events.CALENDAR_ID} IN (${calendars.keys.joinToString(",")}) AND " +
|
||||
"${CalendarContract.Events.DELETED} = 0"
|
||||
val series = mutableListOf<MasterRow>()
|
||||
val overrides = mutableListOf<OverrideRow>()
|
||||
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),
|
||||
selection,
|
||||
null,
|
||||
null,
|
||||
)?.use { c -> c.mapRows { getLong(0) } }.orEmpty()
|
||||
val reminders = resolver.reminderMinutesByEvent(eventIds, alertsOnly = false)
|
||||
resolver.query(
|
||||
CalendarContract.Events.CONTENT_URI,
|
||||
EventExportProjection.COLUMNS,
|
||||
// Skip soft-deleted rows and exception rows (modified occurrences /
|
||||
// cancellations) — v1 exports masters + one-offs only.
|
||||
"${CalendarContract.Events.CALENDAR_ID} IN ($idList) AND " +
|
||||
"${CalendarContract.Events.DELETED} = 0 AND " +
|
||||
"${CalendarContract.Events.ORIGINAL_ID} IS NULL",
|
||||
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 = queryReminders(eventId).map { it.minutes },
|
||||
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<String> = resolver.query(
|
||||
@@ -865,18 +915,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
|
||||
}
|
||||
|
||||
@@ -61,18 +61,41 @@ interface CalendarRepository {
|
||||
suspend fun setCalendarsVisible(ids: Collection<Long>, visible: Boolean)
|
||||
|
||||
/**
|
||||
* Every event of the writable local calendars, ready to serialise into a
|
||||
* whole-calendar `.ics` backup (see [CalendarDataSource.exportableEvents]).
|
||||
* [calendarIds] narrows the export to a chosen subset; `null` exports all.
|
||||
* Every event of [calendarIds], ready to serialise into an `.ics` backup
|
||||
* (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<Long>? = null): List<IcsEvent>
|
||||
suspend fun exportEvents(calendarIds: Set<Long>): List<IcsEvent>
|
||||
|
||||
/**
|
||||
* 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<ParsedIcsEvent>): IcsImportSummary
|
||||
suspend fun importEvents(
|
||||
targetCalendarId: Long,
|
||||
events: List<ParsedIcsEvent>,
|
||||
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
|
||||
|
||||
+57
-7
@@ -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<Long>?) =
|
||||
withContext(io) { dataSource.exportableEvents(calendarIds, allDayReminderTimeMinutes()) }
|
||||
override suspend fun exportEvents(calendarIds: Set<Long>) = 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<ParsedIcsEvent>,
|
||||
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<String, MutableList<Instant>>()
|
||||
// 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 <T> Flow<Unit>.reQuery(block: suspend () -> T): Flow<T> = 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<String>): 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<String, List<Instant>>): 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 })
|
||||
}
|
||||
@@ -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) }
|
||||
|
||||
@@ -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<String> {
|
||||
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 `<zone>;<stamps>` 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<String> {
|
||||
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""")
|
||||
|
||||
@@ -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<String> = 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
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
package de.jeanlucmakiola.calendula.data.calendar
|
||||
|
||||
import android.content.ContentResolver
|
||||
import android.provider.CalendarContract
|
||||
|
||||
/** Ids per `IN (…)` list: they go into the SQL literally, which SQLite bounds. */
|
||||
private const val EVENT_ID_BATCH = 50
|
||||
|
||||
/**
|
||||
* Reminder minutes of [eventIds], keyed by event, a batched query at a time
|
||||
* rather than one per event. [alertsOnly] keeps just the notification ones.
|
||||
*/
|
||||
internal fun ContentResolver.reminderMinutesByEvent(
|
||||
eventIds: Collection<Long>,
|
||||
alertsOnly: Boolean,
|
||||
): Map<Long, List<Int>> {
|
||||
if (eventIds.isEmpty()) return emptyMap()
|
||||
val out = mutableMapOf<Long, MutableList<Int>>()
|
||||
val method = if (alertsOnly) {
|
||||
"${CalendarContract.Reminders.METHOD} = ${CalendarContract.Reminders.METHOD_ALERT} AND "
|
||||
} else {
|
||||
""
|
||||
}
|
||||
eventIds.distinct().chunked(EVENT_ID_BATCH).forEach { batch ->
|
||||
query(
|
||||
CalendarContract.Reminders.CONTENT_URI,
|
||||
arrayOf(CalendarContract.Reminders.EVENT_ID, CalendarContract.Reminders.MINUTES),
|
||||
"$method${CalendarContract.Reminders.EVENT_ID} IN (${batch.joinToString(",")})",
|
||||
null,
|
||||
null,
|
||||
)?.use { c ->
|
||||
while (c.moveToNext()) out.getOrPut(c.getLong(0)) { mutableListOf() } += c.getInt(1)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -5,6 +5,10 @@ import android.net.Uri
|
||||
import androidx.core.content.FileProvider
|
||||
import androidx.documentfile.provider.DocumentFile
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.floret.android.TreeListing
|
||||
import de.jeanlucmakiola.floret.android.deleteTreeFiles
|
||||
import de.jeanlucmakiola.floret.android.listTreeFiles
|
||||
import de.jeanlucmakiola.floret.android.writeTreeFile
|
||||
import java.io.File
|
||||
import java.io.IOException
|
||||
import javax.inject.Inject
|
||||
@@ -29,34 +33,27 @@ class IcsExporter @Inject constructor(
|
||||
} ?: throw IOException("Could not open output stream for export (scheme=${uri.scheme})")
|
||||
}
|
||||
|
||||
/**
|
||||
* Write [content] to [fileName] inside the persisted SAF tree [folder],
|
||||
* overwriting it if it already exists (the automatic-backup destination).
|
||||
* Requires a persisted write grant on [folder]. Throws on failure.
|
||||
*/
|
||||
fun writeToFolder(folder: Uri, fileName: String, content: String) {
|
||||
/** The files in the persisted SAF tree [folder], the automatic-backup destination. Throws when unusable. */
|
||||
fun listFolder(folder: Uri): TreeListing {
|
||||
writableFolder(folder)
|
||||
return context.contentResolver.listTreeFiles(folder)
|
||||
}
|
||||
|
||||
/** Write the `.ics` [bytes] as [fileName] into [folder]; returns the name the file ended up with. */
|
||||
fun writeToFolder(folder: Uri, listing: TreeListing, fileName: String, bytes: ByteArray): String =
|
||||
context.contentResolver.writeTreeFile(folder, listing, fileName, MIME_CALENDAR, bytes)
|
||||
|
||||
/** Delete [names] from the listed folder; returns the ones that didn't go. */
|
||||
fun deleteFromFolder(listing: TreeListing, names: Collection<String>): Set<String> =
|
||||
context.contentResolver.deleteTreeFiles(listing, names)
|
||||
|
||||
private fun writableFolder(folder: Uri): DocumentFile {
|
||||
val dir = DocumentFile.fromTreeUri(context, folder)
|
||||
?: throw IOException("Backup folder is not accessible")
|
||||
if (!dir.exists() || !dir.canWrite()) {
|
||||
throw IOException("Backup folder is missing or not writable")
|
||||
}
|
||||
// Reuse the canonical file if present and clean up any "name (1).ics"
|
||||
// duplicates SAF may have created if two runs ever raced — so we always
|
||||
// converge on a single overwritten file.
|
||||
val base = fileName.substringBeforeLast('.')
|
||||
val ext = fileName.substringAfterLast('.', "")
|
||||
var target: DocumentFile? = null
|
||||
for (child in dir.listFiles()) {
|
||||
val name = child.name ?: continue
|
||||
when {
|
||||
name == fileName -> target = child
|
||||
name.startsWith("$base (") && name.endsWith(".$ext") -> child.delete()
|
||||
}
|
||||
}
|
||||
val file = target
|
||||
?: dir.createFile(MIME_CALENDAR, fileName)
|
||||
?: throw IOException("Could not create backup file in the chosen folder")
|
||||
writeDocument(file.uri, content)
|
||||
return dir
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -81,7 +81,7 @@ class CalendarPrefs @Inject constructor(
|
||||
}
|
||||
|
||||
/** A comma-joined id set; non-numeric tokens are dropped, and an empty set removes the key. */
|
||||
private fun idSetPref(name: String): Pref<Set<Long>> = nullableStringPref(name).map(
|
||||
internal fun idSetPref(name: String): Pref<Set<Long>> = nullableStringPref(name).map(
|
||||
{ stored -> stored.orEmpty().split(',').mapNotNull { it.trim().toLongOrNull() }.toSet() },
|
||||
{ ids -> if (ids.isEmpty()) null else ids.sorted().joinToString(",") },
|
||||
)
|
||||
@@ -1,9 +1,20 @@
|
||||
package de.jeanlucmakiola.calendula.data.prefs
|
||||
|
||||
import androidx.datastore.core.DataStore
|
||||
import androidx.datastore.preferences.core.MutablePreferences
|
||||
import androidx.datastore.preferences.core.Preferences
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.domain.EventFormField
|
||||
import de.jeanlucmakiola.calendula.domain.FontRole
|
||||
import de.jeanlucmakiola.calendula.domain.backup.BackupSelection
|
||||
import de.jeanlucmakiola.calendula.domain.backup.COMBINED_SERIES
|
||||
import de.jeanlucmakiola.calendula.domain.backup.DEFAULT_BACKUP_KEEP
|
||||
import de.jeanlucmakiola.calendula.domain.backup.LEGACY_BACKUP_FILE
|
||||
import de.jeanlucmakiola.calendula.domain.backup.latestLedgerKey
|
||||
import de.jeanlucmakiola.calendula.domain.backup.normalizeBackupKeep
|
||||
import de.jeanlucmakiola.calendula.domain.backup.BackupLedger
|
||||
import de.jeanlucmakiola.calendula.domain.backup.parseBackupLedger
|
||||
import de.jeanlucmakiola.calendula.domain.backup.persistBackupLedger
|
||||
import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
|
||||
import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
|
||||
import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
|
||||
@@ -29,6 +40,7 @@ import de.jeanlucmakiola.floret.prefs.enumPref
|
||||
import de.jeanlucmakiola.floret.prefs.get
|
||||
import de.jeanlucmakiola.floret.prefs.intPref
|
||||
import de.jeanlucmakiola.floret.prefs.longPref
|
||||
import de.jeanlucmakiola.floret.prefs.nullableBooleanPref
|
||||
import de.jeanlucmakiola.floret.prefs.nullableLongPref
|
||||
import de.jeanlucmakiola.floret.prefs.nullableStringPref
|
||||
import de.jeanlucmakiola.floret.prefs.set
|
||||
@@ -180,6 +192,10 @@ class SettingsPrefs @Inject constructor(
|
||||
val autoBackupIntervalMinutes: Flow<Long> = prefs.flow(SettingsKeys.autoBackupIntervalMinutes)
|
||||
val autoBackupFolderUri: Flow<String?> = prefs.flow(SettingsKeys.autoBackupFolderUri)
|
||||
val autoBackupStatus: Flow<BackupStatus> = prefs.snapshot { it.autoBackupStatus }
|
||||
val autoBackupSelection: Flow<BackupSelection> = prefs.snapshot { it.autoBackupSelection }
|
||||
val autoBackupCombined: Flow<Boolean> = prefs.snapshot { it.autoBackupCombined }
|
||||
val autoBackupKeep: Flow<Int> = prefs.flow(SettingsKeys.autoBackupKeep)
|
||||
val autoBackupLedger: Flow<BackupLedger> = prefs.flow(SettingsKeys.autoBackupLedger)
|
||||
val specialDatesEnabled: Flow<Boolean> = prefs.flow(SettingsKeys.specialDatesEnabled)
|
||||
val specialDatesTypes: Flow<Set<SpecialDateType>> = prefs.snapshot { it.specialDatesTypes }
|
||||
val specialDatesCalendars: Flow<Map<SpecialDateType, Long>> = prefs.snapshot { it.specialDatesCalendars }
|
||||
@@ -329,7 +345,56 @@ class SettingsPrefs @Inject constructor(
|
||||
suspend fun setAutoBackupIntervalMinutes(minutes: Long) =
|
||||
prefs.set(SettingsKeys.autoBackupIntervalMinutes, minutes)
|
||||
|
||||
suspend fun setAutoBackupFolderUri(uri: String?) = prefs.set(SettingsKeys.autoBackupFolderUri, uri)
|
||||
/**
|
||||
* Also pins the file layout the first time it is written: an install that
|
||||
* already had a folder before #411 keeps its single combined file, a new
|
||||
* one starts on one file per calendar (see [Preferences.autoBackupCombined]).
|
||||
*/
|
||||
suspend fun setAutoBackupFolderUri(uri: String?) {
|
||||
prefs.edit {
|
||||
it.pinBackupLayout()
|
||||
// The ledger says which files in the old folder are ours; in a new
|
||||
// one a file of the same name may be the user's.
|
||||
if (it[SettingsKeys.autoBackupFolderUri] != uri) it[SettingsKeys.autoBackupLedger] = emptyMap()
|
||||
it[SettingsKeys.autoBackupFolderUri] = uri
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun setAutoBackupCombined(combined: Boolean) {
|
||||
prefs.edit {
|
||||
it.pinBackupLayout()
|
||||
it[SettingsKeys.autoBackupCombinedStored] = combined
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun setAutoBackupKeep(keep: Int) = prefs.set(SettingsKeys.autoBackupKeep, keep)
|
||||
|
||||
/**
|
||||
* Atomic, so a run's ledger writes never undo one made meanwhile (pinning
|
||||
* the layout). Dropped when the folder is no longer [folder]: a run still
|
||||
* finishing must not carry the old folder's names into the new one's ledger.
|
||||
*/
|
||||
suspend fun updateAutoBackupLedger(folder: String, transform: (BackupLedger) -> BackupLedger) {
|
||||
prefs.edit {
|
||||
if (it[SettingsKeys.autoBackupFolderUri] == folder) {
|
||||
it[SettingsKeys.autoBackupLedger] = transform(it[SettingsKeys.autoBackupLedger])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Record a pre-#411 install's old file as its combined series' stable copy (see [pinBackupLayout]). */
|
||||
suspend fun adoptLegacyBackupFile() {
|
||||
prefs.edit { if (it.autoBackupLegacyInstall) it.adoptLegacyBackupFile() }
|
||||
}
|
||||
|
||||
/** Switch [calendar] in or out of the automatic backup (#147). */
|
||||
suspend fun setAutoBackupCalendar(calendar: CalendarSource, included: Boolean) {
|
||||
prefs.edit {
|
||||
val next = it.autoBackupSelection.with(calendar, included)
|
||||
it[SettingsKeys.autoBackupIncluded] = next.included
|
||||
it[SettingsKeys.autoBackupExcluded] = next.excluded
|
||||
}
|
||||
}
|
||||
|
||||
/** Record an automatic run's outcome; resets the failure streak on success. */
|
||||
suspend fun recordAutoBackupRun(success: Boolean, atMillis: Long) {
|
||||
@@ -700,6 +765,27 @@ object SettingsKeys {
|
||||
val autoBackupLastSuccess: Pref<Boolean> = booleanPref("auto_backup_last_success", true)
|
||||
val autoBackupFailures: Pref<Int> = intPref("auto_backup_failures", 0)
|
||||
|
||||
/**
|
||||
* The automatic backup's calendar choice as deviations from the default
|
||||
* (#147), read together as [Preferences.autoBackupSelection].
|
||||
*/
|
||||
val autoBackupIncluded: Pref<Set<Long>> = idSetPref("auto_backup_included_calendars")
|
||||
val autoBackupExcluded: Pref<Set<Long>> = idSetPref("auto_backup_excluded_calendars")
|
||||
|
||||
/**
|
||||
* Whether the automatic backup writes one combined file instead of one per
|
||||
* calendar (#411). Unset until first pinned; read as [Preferences.autoBackupCombined].
|
||||
*/
|
||||
val autoBackupCombinedStored: Pref<Boolean?> = nullableBooleanPref("auto_backup_combined")
|
||||
|
||||
/** How many files of each backup series to keep (#411). */
|
||||
val autoBackupKeep: Pref<Int> =
|
||||
intPref("auto_backup_keep", DEFAULT_BACKUP_KEEP).coerced(::normalizeBackupKeep)
|
||||
|
||||
/** The files the automatic backup wrote, per series; the only ones it ever prunes (#411). */
|
||||
val autoBackupLedger: Pref<BackupLedger> =
|
||||
nullableStringPref("auto_backup_files").map(::parseBackupLedger, ::persistBackupLedger)
|
||||
|
||||
/** Master switch for the contact special-dates mirror (issue #15). Opt-in. */
|
||||
val specialDatesEnabled: Pref<Boolean> = booleanPref("special_dates_enabled", false)
|
||||
|
||||
@@ -749,6 +835,42 @@ val Preferences.autoBackupStatus: BackupStatus
|
||||
consecutiveFailures = this[SettingsKeys.autoBackupFailures],
|
||||
)
|
||||
|
||||
val Preferences.autoBackupSelection: BackupSelection
|
||||
get() = BackupSelection(
|
||||
included = this[SettingsKeys.autoBackupIncluded],
|
||||
excluded = this[SettingsKeys.autoBackupExcluded],
|
||||
)
|
||||
|
||||
/**
|
||||
* Unset means an install from before #411: one that already had a backup
|
||||
* folder keeps the single file it was writing, anything else gets per-calendar
|
||||
* files. Choosing a folder pins the answer (see [SettingsPrefs.setAutoBackupFolderUri]).
|
||||
*/
|
||||
val Preferences.autoBackupCombined: Boolean
|
||||
get() = this[SettingsKeys.autoBackupCombinedStored] ?: autoBackupLegacyInstall
|
||||
|
||||
/**
|
||||
* Store the layout the install is on, if it's still derived. Pinning forgets
|
||||
* it was a pre-#411 install, so its old file is recorded as the combined
|
||||
* series' own stable copy at the same time.
|
||||
*/
|
||||
private fun MutablePreferences.pinBackupLayout() {
|
||||
if (this[SettingsKeys.autoBackupCombinedStored] != null) return
|
||||
val legacy = autoBackupLegacyInstall
|
||||
if (legacy) adoptLegacyBackupFile()
|
||||
this[SettingsKeys.autoBackupCombinedStored] = legacy
|
||||
}
|
||||
|
||||
private fun MutablePreferences.adoptLegacyBackupFile() {
|
||||
val key = latestLedgerKey(COMBINED_SERIES)
|
||||
val ledger = this[SettingsKeys.autoBackupLedger]
|
||||
this[SettingsKeys.autoBackupLedger] = ledger + (key to (ledger[key].orEmpty() + LEGACY_BACKUP_FILE).distinct())
|
||||
}
|
||||
|
||||
/** An install that set up automatic backup before #411 and hasn't been pinned since. */
|
||||
val Preferences.autoBackupLegacyInstall: Boolean
|
||||
get() = this[SettingsKeys.autoBackupCombinedStored] == null && this[SettingsKeys.autoBackupFolderUri] != null
|
||||
|
||||
val Preferences.specialDatesTypes: Set<SpecialDateType>
|
||||
get() = SettingsKeys.specialDateTypeEnabled.filterValues { this[it] }.keys
|
||||
|
||||
|
||||
+3
-29
@@ -4,6 +4,7 @@ import android.content.Context
|
||||
import android.provider.CalendarContract
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import de.jeanlucmakiola.calendula.data.calendar.instancesUri
|
||||
import de.jeanlucmakiola.calendula.data.calendar.reminderMinutesByEvent
|
||||
import de.jeanlucmakiola.calendula.domain.reminders.ReminderEventInstance
|
||||
import javax.inject.Inject
|
||||
import javax.inject.Singleton
|
||||
@@ -72,28 +73,8 @@ class ProviderReminderInstanceSource @Inject constructor(
|
||||
} ?: emptyList()
|
||||
}
|
||||
|
||||
override fun reminderMinutes(eventIds: Collection<Long>): Map<Long, List<Int>> {
|
||||
if (eventIds.isEmpty()) return emptyMap()
|
||||
val out = mutableMapOf<Long, MutableList<Int>>()
|
||||
// Batched: the ids go into the selection literally, and an unbounded
|
||||
// `IN (...)` would grow the SQL past what SQLite takes.
|
||||
eventIds.distinct().chunked(EVENT_ID_BATCH).forEach { batch ->
|
||||
context.contentResolver.query(
|
||||
CalendarContract.Reminders.CONTENT_URI,
|
||||
REMINDER_PROJECTION,
|
||||
"${CalendarContract.Reminders.METHOD} = " +
|
||||
"${CalendarContract.Reminders.METHOD_ALERT} AND " +
|
||||
"${CalendarContract.Reminders.EVENT_ID} IN (${batch.joinToString(",")})",
|
||||
null,
|
||||
null,
|
||||
)?.use { c ->
|
||||
while (c.moveToNext()) {
|
||||
out.getOrPut(c.getLong(0)) { mutableListOf() } += c.getInt(1)
|
||||
}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
override fun reminderMinutes(eventIds: Collection<Long>): Map<Long, List<Int>> =
|
||||
context.contentResolver.reminderMinutesByEvent(eventIds, alertsOnly = true)
|
||||
|
||||
override fun longestReminderMinutes(): Int = context.contentResolver.query(
|
||||
CalendarContract.Reminders.CONTENT_URI,
|
||||
@@ -105,8 +86,6 @@ class ProviderReminderInstanceSource @Inject constructor(
|
||||
)?.use { c -> if (c.moveToFirst()) c.getInt(0) else 0 } ?: 0
|
||||
|
||||
private companion object {
|
||||
const val EVENT_ID_BATCH = 50
|
||||
|
||||
val OCCURRENCE_PROJECTION = arrayOf(
|
||||
CalendarContract.Instances.EVENT_ID,
|
||||
CalendarContract.Instances.CALENDAR_ID,
|
||||
@@ -116,10 +95,5 @@ class ProviderReminderInstanceSource @Inject constructor(
|
||||
CalendarContract.Instances.EVENT_LOCATION,
|
||||
CalendarContract.Instances.ALL_DAY,
|
||||
)
|
||||
|
||||
val REMINDER_PROJECTION = arrayOf(
|
||||
CalendarContract.Reminders.EVENT_ID,
|
||||
CalendarContract.Reminders.MINUTES,
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,279 @@
|
||||
package de.jeanlucmakiola.calendula.domain.backup
|
||||
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.domain.isNotSynced
|
||||
import de.jeanlucmakiola.floret.android.safeFileName
|
||||
import java.time.LocalDateTime
|
||||
import java.time.format.DateTimeFormatter
|
||||
|
||||
/**
|
||||
* Whether this calendar can be backed up at all. Any calendar the provider
|
||||
* holds can be *read* (#147), whatever its visibility or access level. Left out:
|
||||
* the managed special-dates mirrors, rebuilt from contacts so a restore would
|
||||
* only duplicate them, and calendars whose events aren't synced to the device.
|
||||
*/
|
||||
val CalendarSource.isBackupCandidate: Boolean
|
||||
get() = !isManaged && !isNotSynced
|
||||
|
||||
/**
|
||||
* Whether a backup includes this calendar until the user says otherwise: the
|
||||
* app's own writable local calendars, which have no other copy anywhere. Synced
|
||||
* calendars already live on their server, so they are opt-in.
|
||||
*/
|
||||
val CalendarSource.isBackedUpByDefault: Boolean
|
||||
get() = isLocal && canModifyContents && !isManaged
|
||||
|
||||
/**
|
||||
* Which calendars the automatic backup covers, stored as deviations from
|
||||
* [isBackedUpByDefault] so a calendar created later still follows the default:
|
||||
* [included] opts a calendar in, [excluded] opts one out.
|
||||
*/
|
||||
data class BackupSelection(
|
||||
val included: Set<Long> = emptySet(),
|
||||
val excluded: Set<Long> = emptySet(),
|
||||
) {
|
||||
fun selects(calendar: CalendarSource): Boolean = when {
|
||||
!calendar.isBackupCandidate -> false
|
||||
calendar.id in included -> true
|
||||
calendar.id in excluded -> false
|
||||
else -> calendar.isBackedUpByDefault
|
||||
}
|
||||
|
||||
/** The selection with [calendar] switched [on]; a choice matching the default leaves no trace. */
|
||||
fun with(calendar: CalendarSource, on: Boolean): BackupSelection {
|
||||
val id = calendar.id
|
||||
val default = calendar.isBackedUpByDefault
|
||||
return BackupSelection(
|
||||
included = if (on && !default) included + id else included - id,
|
||||
excluded = if (!on && default) excluded + id else excluded - id,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** One backup file series: the calendars it holds and the name its files start with. */
|
||||
data class BackupTarget(
|
||||
/** Stable identity of the series in the [BackupLedger]: the calendar id, or [COMBINED_SERIES]. */
|
||||
val key: String,
|
||||
val calendarIds: Set<Long>,
|
||||
val baseName: String,
|
||||
/** The calendar name written into the file, or null for a combined file. */
|
||||
val calendarName: String?,
|
||||
)
|
||||
|
||||
/** What one run writes and which earlier files it removes afterwards. */
|
||||
data class BackupFilePlan(
|
||||
val target: BackupTarget,
|
||||
val fileName: String,
|
||||
/** Earlier files of this series that stay, oldest first. */
|
||||
val keep: List<String>,
|
||||
/** Earlier files of this series beyond the retention count, oldest first. */
|
||||
val prune: List<String>,
|
||||
/**
|
||||
* The stable, undated copy overwritten every run (`<base>.ics`), for tools
|
||||
* that follow one path. Null when a file of that name is in the folder but
|
||||
* isn't one this backup wrote: the user's own file is never overwritten.
|
||||
*/
|
||||
val latestName: String?,
|
||||
/** This series' earlier stable copies under a name it no longer uses (a rename), to delete. */
|
||||
val staleLatest: List<String> = emptyList(),
|
||||
/**
|
||||
* Stable copies this series held that another series of the run now takes
|
||||
* over: kept on record until that series has claimed them.
|
||||
*/
|
||||
val handOff: List<String> = emptyList(),
|
||||
)
|
||||
|
||||
/**
|
||||
* The files the automatic backup has written, per series key, oldest first.
|
||||
* Pruning only ever deletes names recorded here, so a series is its files, not
|
||||
* whatever currently matches a calendar's name: renames, same-named calendars
|
||||
* and the user's own files in the folder can't pull in the wrong ones. A
|
||||
* series' stable copy is recorded apart, under [latestLedgerKey].
|
||||
*/
|
||||
typealias BackupLedger = Map<String, List<String>>
|
||||
|
||||
const val COMBINED_SERIES = "combined"
|
||||
|
||||
/** The combined file's series name; also the fixed name used before #411. */
|
||||
const val COMBINED_BACKUP_BASE = "calendula-backup"
|
||||
|
||||
/**
|
||||
* The single file every automatic backup overwrote before #411: the combined
|
||||
* series' stable copy now, so an old setup keeps its path.
|
||||
*/
|
||||
val LEGACY_BACKUP_FILE: String = latestFileName(COMBINED_BACKUP_BASE)
|
||||
|
||||
private const val LATEST_PREFIX = "latest-"
|
||||
|
||||
/** Where the ledger records the stable copy of the series [key]. */
|
||||
fun latestLedgerKey(key: String): String = "$LATEST_PREFIX$key"
|
||||
|
||||
/** The retention choices the settings offer, newest kept first. */
|
||||
val BACKUP_KEEP_OPTIONS: List<Int> = listOf(1, 2, 3, 5, 7, 10)
|
||||
|
||||
const val DEFAULT_BACKUP_KEEP = 3
|
||||
|
||||
/** Room for the id suffix and the stamp within a file system's 255-byte name limit. */
|
||||
private const val MAX_BASE_BYTES = 120
|
||||
private const val ICS_EXTENSION = ".ics"
|
||||
private const val STAMP_PATTERN = "yyyy-MM-dd_HH-mm-ss"
|
||||
private val STAMP_FORMAT: DateTimeFormatter = DateTimeFormatter.ofPattern(STAMP_PATTERN)
|
||||
|
||||
/**
|
||||
* The file series the automatic backup writes: one combined file, or one per
|
||||
* calendar named after it. Calendars whose names clash case-insensitively (a
|
||||
* local and a synced "Personal") take their id as a suffix until every name in
|
||||
* the run is distinct, so no two series write the same file.
|
||||
*/
|
||||
fun backupTargets(calendars: List<CalendarSource>, combined: Boolean): List<BackupTarget> {
|
||||
if (calendars.isEmpty()) return emptyList()
|
||||
if (combined) {
|
||||
return listOf(
|
||||
BackupTarget(COMBINED_SERIES, calendars.map { it.id }.toSet(), COMBINED_BACKUP_BASE, calendarName = null),
|
||||
)
|
||||
}
|
||||
val bases = calendars.associateTo(LinkedHashMap()) {
|
||||
it.id to safeFileName(it.displayName, MAX_BASE_BYTES, fallback = "calendar")
|
||||
}
|
||||
while (true) {
|
||||
val counts = bases.values.groupingBy { it.lowercase() }.eachCount()
|
||||
val clashing = bases.filterValues {
|
||||
counts.getValue(it.lowercase()) > 1 || it.equals(COMBINED_BACKUP_BASE, ignoreCase = true)
|
||||
}
|
||||
if (clashing.isEmpty()) break
|
||||
clashing.forEach { (id, base) -> bases[id] = "$base-$id" }
|
||||
}
|
||||
return calendars.map { calendar ->
|
||||
BackupTarget(
|
||||
key = calendar.id.toString(),
|
||||
calendarIds = setOf(calendar.id),
|
||||
baseName = bases.getValue(calendar.id),
|
||||
calendarName = calendar.displayName,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** `Work_2026-11-13_14-30-05.ics`: the series name and the local time of the run. */
|
||||
fun backupFileName(baseName: String, at: LocalDateTime): String =
|
||||
"${baseName}_${at.format(STAMP_FORMAT)}$ICS_EXTENSION"
|
||||
|
||||
/**
|
||||
* Plan one run: a new dated file per target, and which of the series' recorded
|
||||
* files ([ledger]) fall out of the newest [keep], the new one included. Recorded
|
||||
* files no longer in the folder ([existing]) are forgotten. Each target also
|
||||
* gets its stable copy, which retention never touches. A stable name is only
|
||||
* written when the file is absent or this series owns it — or a series of this
|
||||
* run that is moving off it (a rename hand-off).
|
||||
*/
|
||||
fun planBackupFiles(
|
||||
targets: List<BackupTarget>,
|
||||
ledger: BackupLedger,
|
||||
existing: Set<String>,
|
||||
at: LocalDateTime,
|
||||
keep: Int,
|
||||
): List<BackupFilePlan> {
|
||||
val retain = keep.coerceAtLeast(1)
|
||||
val runKeys = targets.map { it.key }.toSet()
|
||||
val owners = ledger.filterKeys { it.startsWith(LATEST_PREFIX) }
|
||||
.flatMap { (key, names) -> names.map { it to key.removePrefix(LATEST_PREFIX) } }
|
||||
.toMap()
|
||||
val currentLatest = targets.map { latestFileName(it.baseName) }.toSet()
|
||||
return targets.map { target ->
|
||||
val fileName = backupFileName(target.baseName, at)
|
||||
val latest = latestFileName(target.baseName)
|
||||
val earlier = ledger[target.key].orEmpty()
|
||||
.filter { it in existing && it != fileName && it != latest }
|
||||
.distinct()
|
||||
val kept = earlier.takeLast(retain - 1)
|
||||
val owner = owners[latest]
|
||||
val writable = latest !in existing || (owner != null && owner in runKeys)
|
||||
BackupFilePlan(
|
||||
target = target,
|
||||
fileName = fileName,
|
||||
keep = kept,
|
||||
prune = earlier.dropLast(kept.size),
|
||||
latestName = latest.takeIf { writable },
|
||||
staleLatest = ledger[latestLedgerKey(target.key)].orEmpty()
|
||||
.filter { it in existing && it != latest && it !in currentLatest },
|
||||
handOff = ledger[latestLedgerKey(target.key)].orEmpty()
|
||||
.filter { it in existing && it != latest && it in currentLatest },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stable copies the current layout replaced, per ledger key: a calendar's own
|
||||
* copy once the combined file holds it, or the combined copy once each calendar
|
||||
* has its own. Left in place they would keep serving old data under a path
|
||||
* something may follow. A calendar taken out of the backup keeps its copy.
|
||||
*/
|
||||
fun replacedLatestCopies(
|
||||
targets: List<BackupTarget>,
|
||||
ledger: BackupLedger,
|
||||
existing: Set<String>,
|
||||
): Map<String, List<String>> {
|
||||
val runKeys = targets.map { it.key }.toSet()
|
||||
val covered = targets.flatMap { it.calendarIds }.map { it.toString() }.toSet()
|
||||
val currentLatest = targets.map { latestFileName(it.baseName) }.toSet()
|
||||
val combinedRun = COMBINED_SERIES in runKeys
|
||||
return ledger.filterKeys { it.startsWith(LATEST_PREFIX) }
|
||||
.mapKeys { it.key.removePrefix(LATEST_PREFIX) }
|
||||
.filterKeys { key ->
|
||||
key !in runKeys && (if (key == COMBINED_SERIES) !combinedRun else combinedRun && key in covered)
|
||||
}
|
||||
.mapValues { (_, names) -> names.filter { it in existing && it !in currentLatest } }
|
||||
.filterValues { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
/**
|
||||
* The ledger with [key]'s files set to [files] (empty drops the entry). Entries
|
||||
* of deleted calendars go ([liveKeys]); their files stay, unrecorded. Others
|
||||
* stay, so a calendar taken out of the backup still has its files pruned if it
|
||||
* is put back.
|
||||
*/
|
||||
fun withLedgerEntry(
|
||||
previous: BackupLedger,
|
||||
key: String,
|
||||
files: List<String>,
|
||||
liveKeys: Set<String>,
|
||||
): BackupLedger {
|
||||
val next = previous.filterKeys { entry ->
|
||||
val series = entry.removePrefix(LATEST_PREFIX)
|
||||
series in liveKeys || series == COMBINED_SERIES
|
||||
}.toMutableMap()
|
||||
next[key] = files.distinct()
|
||||
// A stable copy has one owner: claiming it takes it off any other series.
|
||||
if (key.startsWith(LATEST_PREFIX)) {
|
||||
next.keys.filter { it != key && it.startsWith(LATEST_PREFIX) }.forEach { other ->
|
||||
next[other] = next.getValue(other) - files.toSet()
|
||||
}
|
||||
}
|
||||
return next.filterValues { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
/** Stable copies recorded under any series but [key] — a hand-off that has already been claimed. */
|
||||
fun BackupLedger.latestHeldElsewhere(key: String): Set<String> =
|
||||
filterKeys { it.startsWith(LATEST_PREFIX) && it != latestLedgerKey(key) }.values.flatten().toSet()
|
||||
|
||||
/** `Work.ics`: the series' stable copy. */
|
||||
fun latestFileName(baseName: String): String = "$baseName$ICS_EXTENSION"
|
||||
|
||||
private const val LEDGER_ENTRY_SEP = "|"
|
||||
private const val LEDGER_KEY_SEP = "/"
|
||||
|
||||
/** Stores the ledger; both separators are characters no name this app writes can hold. */
|
||||
fun persistBackupLedger(ledger: BackupLedger): String? =
|
||||
ledger.filterValues { it.isNotEmpty() }.takeIf { it.isNotEmpty() }
|
||||
?.entries?.sortedBy { it.key }
|
||||
?.joinToString(LEDGER_ENTRY_SEP) { (key, names) -> (listOf(key) + names).joinToString(LEDGER_KEY_SEP) }
|
||||
|
||||
fun parseBackupLedger(stored: String?): BackupLedger =
|
||||
stored?.split(LEDGER_ENTRY_SEP).orEmpty().mapNotNull { entry ->
|
||||
val parts = entry.split(LEDGER_KEY_SEP)
|
||||
val names = parts.drop(1).filter { it.isNotEmpty() }
|
||||
parts.first().takeIf { it.isNotEmpty() && names.isNotEmpty() }?.let { it to names }
|
||||
}.toMap()
|
||||
|
||||
/** Closest offered retention count to [stored], so a stray value still shows a row. */
|
||||
fun normalizeBackupKeep(stored: Int): Int =
|
||||
BACKUP_KEEP_OPTIONS.minBy { kotlin.math.abs(it - stored) }
|
||||
@@ -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<ParsedIcsEvent> {
|
||||
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(),
|
||||
)
|
||||
@@ -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<MasterRow>,
|
||||
val overrides: List<OverrideRow>,
|
||||
)
|
||||
|
||||
/**
|
||||
* [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<IcsEvent> {
|
||||
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<Long, MutableList<String>>()
|
||||
val detached = mutableListOf<Pair<Long, IcsEvent>>()
|
||||
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())
|
||||
}
|
||||
}
|
||||
@@ -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<String> = 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
|
||||
|
||||
@@ -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<String> = 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<String> = 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<Int>()
|
||||
val exDateLines = mutableListOf<IcsContentLine>()
|
||||
val rDateLines = mutableListOf<IcsContentLine>()
|
||||
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<IcsContentLine>, start: IcsDateTime): List<String> {
|
||||
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
|
||||
|
||||
@@ -25,12 +25,14 @@ const val ICS_PROD_ID: String = "-//Jean-Luc Makiola//Calendula//EN"
|
||||
*/
|
||||
class IcsWriter(private val prodId: String = ICS_PROD_ID) {
|
||||
|
||||
fun writeCalendar(events: List<IcsEvent>, dtStamp: Instant): String {
|
||||
/** [calendarName], when given, names the whole file (`X-WR-CALNAME`), as a one-calendar backup does. */
|
||||
fun writeCalendar(events: List<IcsEvent>, dtStamp: Instant, calendarName: String? = null): String {
|
||||
val lines = buildList {
|
||||
add("BEGIN:VCALENDAR")
|
||||
add("VERSION:2.0")
|
||||
add("PRODID:$prodId")
|
||||
add("CALSCALE:GREGORIAN")
|
||||
calendarName?.takeIf { it.isNotBlank() }?.let { add("X-WR-CALNAME:${escapeText(it)}") }
|
||||
events.forEach { appendEvent(it, dtStamp) }
|
||||
add("END:VCALENDAR")
|
||||
}
|
||||
@@ -45,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)}") }
|
||||
@@ -54,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)
|
||||
}
|
||||
@@ -66,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()}")
|
||||
@@ -83,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<String>.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
|
||||
@@ -90,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<String>.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:"
|
||||
|
||||
@@ -13,12 +13,12 @@ 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
|
||||
import androidx.compose.material3.AlertDialog
|
||||
import androidx.compose.material3.Button
|
||||
import androidx.compose.material3.Checkbox
|
||||
import androidx.compose.material3.CircularProgressIndicator
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.SnackbarHost
|
||||
@@ -49,11 +49,13 @@ import de.jeanlucmakiola.calendula.R
|
||||
import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
|
||||
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
|
||||
import de.jeanlucmakiola.calendula.domain.backup.BACKUP_KEEP_OPTIONS
|
||||
import de.jeanlucmakiola.calendula.domain.backup.BackupSelection
|
||||
import de.jeanlucmakiola.calendula.domain.backup.isBackedUpByDefault
|
||||
import de.jeanlucmakiola.calendula.ui.common.CalendarCheckGroups
|
||||
import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
|
||||
import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
|
||||
import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
|
||||
import de.jeanlucmakiola.calendula.ui.common.orUnnamed
|
||||
import de.jeanlucmakiola.floret.components.CollapsingScaffold
|
||||
import de.jeanlucmakiola.floret.components.DialogAmountField
|
||||
import de.jeanlucmakiola.floret.components.DialogUnitDropdown
|
||||
@@ -61,8 +63,9 @@ import de.jeanlucmakiola.floret.components.FullScreenPicker
|
||||
import de.jeanlucmakiola.floret.components.GroupedHint
|
||||
import de.jeanlucmakiola.floret.components.GroupedRow
|
||||
import de.jeanlucmakiola.floret.components.GroupedSectionHeader
|
||||
import de.jeanlucmakiola.floret.components.GroupedSwitchRow
|
||||
import de.jeanlucmakiola.floret.components.OptionPicker
|
||||
import de.jeanlucmakiola.floret.components.Position
|
||||
import de.jeanlucmakiola.floret.components.positionOf
|
||||
import de.jeanlucmakiola.floret.locale.relativeTimeAgo
|
||||
import java.time.LocalDate
|
||||
|
||||
@@ -75,7 +78,7 @@ private val RESTORE_MIME_TYPES = arrayOf(
|
||||
)
|
||||
|
||||
/**
|
||||
* Backup & restore (#69): `.ics` export and restore for local calendars, with
|
||||
* Backup & restore (#69): `.ics` export and restore, with
|
||||
* optional automatic backup. Shares [CalendarsViewModel] with the manager.
|
||||
*
|
||||
* A full-screen destination hoisted in `CalendarHost`; [onBack] pops it,
|
||||
@@ -87,19 +90,26 @@ 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()
|
||||
|
||||
val context = LocalContext.current
|
||||
val snackbarHostState = remember { SnackbarHostState() }
|
||||
|
||||
// Exports everything eligible (null); the per-calendar selector owns its
|
||||
// own launcher.
|
||||
// The one-calendar shortcut; the per-calendar selector owns its own launcher.
|
||||
var shortcutExportId by rememberSaveable { mutableStateOf<Long?>(null) }
|
||||
val createBackup = rememberLauncherForActivityResult(
|
||||
contract = ActivityResultContracts.CreateDocument("text/calendar"),
|
||||
) { uri -> uri?.let { viewModel.exportBackup(it, null) } }
|
||||
) { uri ->
|
||||
val id = shortcutExportId
|
||||
if (uri != null && id != null) viewModel.exportBackup(uri, setOf(id))
|
||||
shortcutExportId = null
|
||||
}
|
||||
var showExportPicker by rememberSaveable { mutableStateOf(false) }
|
||||
|
||||
// Restore runs the picked file through the normal .ics import flow.
|
||||
@@ -112,6 +122,9 @@ fun BackupScreen(
|
||||
contract = ActivityResultContracts.OpenDocumentTree(),
|
||||
) { uri -> uri?.let(viewModel::setAutoBackupFolder) }
|
||||
var showInterval by remember { mutableStateOf(false) }
|
||||
var showBackupCalendars by rememberSaveable { mutableStateOf(false) }
|
||||
var selectionBefore by remember { mutableStateOf<BackupSelection?>(null) }
|
||||
var showKeep by rememberSaveable { mutableStateOf(false) }
|
||||
|
||||
val backupFailedText = stringResource(R.string.calendars_backup_failed)
|
||||
LaunchedEffect(backupResult) {
|
||||
@@ -149,19 +162,47 @@ 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) } },
|
||||
onPickFolder = { runCatching { pickFolder.launch(null) } },
|
||||
onExportAll = {
|
||||
onExportOnly = {
|
||||
shortcutExportId = s.exportable.singleOrNull()?.id
|
||||
runCatching { createBackup.launch(defaultBackupName()) }
|
||||
},
|
||||
onExportPick = { showExportPicker = true },
|
||||
onEditInterval = { showInterval = true },
|
||||
onEditCalendars = {
|
||||
selectionBefore = autoBackup.selection
|
||||
showBackupCalendars = true
|
||||
},
|
||||
onEditKeep = { showKeep = true },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// 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 ->
|
||||
@@ -172,6 +213,34 @@ fun BackupScreen(
|
||||
onDismiss = { showExportPicker = false },
|
||||
)
|
||||
}
|
||||
if (showBackupCalendars) {
|
||||
AutoBackupCalendarPicker(
|
||||
calendars = ready.exportable,
|
||||
selection = autoBackup.selection,
|
||||
onCheckedChange = viewModel::setAutoBackupCalendar,
|
||||
onDismiss = {
|
||||
showBackupCalendars = false
|
||||
viewModel.autoBackupCalendarsChosen(selectionBefore ?: autoBackup.selection)
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
if (showKeep) {
|
||||
OptionPicker(
|
||||
title = stringResource(R.string.calendars_auto_backup_keep),
|
||||
header = {
|
||||
GroupedHint(
|
||||
stringResource(R.string.calendars_auto_backup_keep_hint),
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
)
|
||||
},
|
||||
predictiveBack = true,
|
||||
options = BACKUP_KEEP_OPTIONS,
|
||||
selected = autoBackup.keep,
|
||||
label = { backupKeepLabel(it) },
|
||||
onSelect = viewModel::setAutoBackupKeep,
|
||||
onDismiss = { showKeep = false },
|
||||
)
|
||||
}
|
||||
if (showInterval) {
|
||||
BackupIntervalDialog(
|
||||
@@ -197,7 +266,7 @@ private fun BackupLoading() {
|
||||
private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.ics"
|
||||
|
||||
/**
|
||||
* The working screen: export (when there are local calendars to export), restore,
|
||||
* The working screen: export (when any calendar can be backed up), restore,
|
||||
* and the automatic-backup block. Restore is always on screen — when nothing can
|
||||
* receive the events it says so and routes to the calendar manager rather than
|
||||
* disappearing, which is what #304 reported as an invisible button.
|
||||
@@ -206,13 +275,18 @@ private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.i
|
||||
private fun BackupContent(
|
||||
exportable: List<CalendarSource>,
|
||||
canImport: Boolean,
|
||||
canCopy: Boolean,
|
||||
copyRun: CopyRunState,
|
||||
onCopy: () -> Unit,
|
||||
autoBackup: AutoBackupUiState,
|
||||
viewModel: CalendarsViewModel,
|
||||
onRestore: () -> Unit,
|
||||
onPickFolder: () -> Unit,
|
||||
onExportAll: () -> Unit,
|
||||
onExportOnly: () -> Unit,
|
||||
onExportPick: () -> Unit,
|
||||
onEditInterval: () -> Unit,
|
||||
onEditCalendars: () -> Unit,
|
||||
onEditKeep: () -> Unit,
|
||||
) {
|
||||
val manageCalendars = LocalManageCalendars.current
|
||||
// Restore never depends on export eligibility, and never disappears: when no
|
||||
@@ -229,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
|
||||
}
|
||||
|
||||
@@ -242,7 +317,7 @@ private fun BackupContent(
|
||||
position = Position.Top,
|
||||
leading = { LeadingAvatar(Icons.Default.FileDownload) },
|
||||
// A single exportable calendar skips the selector.
|
||||
onClick = if (exportable.size == 1) onExportAll else onExportPick,
|
||||
onClick = if (exportable.size == 1) onExportOnly else onExportPick,
|
||||
)
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.calendars_restore_action),
|
||||
@@ -251,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),
|
||||
@@ -272,22 +349,76 @@ private fun BackupContent(
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.calendars_auto_backup_interval),
|
||||
summary = backupIntervalLabel(autoBackup.intervalMinutes),
|
||||
position = Position.Bottom,
|
||||
position = Position.Middle,
|
||||
onClick = onEditInterval,
|
||||
)
|
||||
GroupedHint(backupStatusText(autoBackup.status), style = MaterialTheme.typography.bodySmall)
|
||||
val selectedCount = exportable.count(autoBackup.selection::selects)
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.calendars_auto_backup_calendars),
|
||||
summary = if (selectedCount == 0) {
|
||||
stringResource(R.string.calendars_auto_backup_calendars_none)
|
||||
} else {
|
||||
pluralStringResource(R.plurals.calendars_auto_backup_calendars_count, selectedCount, selectedCount)
|
||||
},
|
||||
position = Position.Middle,
|
||||
onClick = onEditCalendars,
|
||||
)
|
||||
GroupedSwitchRow(
|
||||
title = stringResource(R.string.calendars_auto_backup_combined),
|
||||
summary = stringResource(
|
||||
if (autoBackup.combined) {
|
||||
R.string.calendars_auto_backup_combined_on
|
||||
} else {
|
||||
R.string.calendars_auto_backup_combined_off
|
||||
},
|
||||
),
|
||||
checked = autoBackup.combined,
|
||||
onCheckedChange = viewModel::setAutoBackupCombined,
|
||||
position = Position.Middle,
|
||||
)
|
||||
GroupedRow(
|
||||
title = stringResource(R.string.calendars_auto_backup_keep),
|
||||
summary = backupKeepLabel(autoBackup.keep),
|
||||
position = Position.Bottom,
|
||||
onClick = onEditKeep,
|
||||
)
|
||||
GroupedHint(
|
||||
if (selectedCount == 0) {
|
||||
stringResource(R.string.calendars_auto_backup_nothing_selected)
|
||||
} else {
|
||||
backupStatusText(autoBackup.status)
|
||||
},
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@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 local calendars to include in a one-time `.ics` export. Defaults
|
||||
* to all selected; the Export action opens the SAF save dialog and hands back
|
||||
* 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
|
||||
* the picked file with the chosen calendar ids.
|
||||
*/
|
||||
@Composable
|
||||
private fun ExportCalendarPicker(
|
||||
calendars: List<CalendarSource>,
|
||||
onExport: (Uri, Set<Long>?) -> Unit,
|
||||
onExport: (Uri, Set<Long>) -> Unit,
|
||||
onDismiss: () -> Unit,
|
||||
) {
|
||||
// Deliberately not keyed on [calendars]: that list is observer-driven, so
|
||||
@@ -298,7 +429,8 @@ private fun ExportCalendarPicker(
|
||||
restore = { it.toSet() },
|
||||
),
|
||||
) {
|
||||
mutableStateOf(calendars.map { it.id }.toSet())
|
||||
val defaults = calendars.filter { it.isBackedUpByDefault }.ifEmpty { calendars }
|
||||
mutableStateOf(defaults.map { it.id }.toSet())
|
||||
}
|
||||
val createBackup = rememberLauncherForActivityResult(
|
||||
contract = ActivityResultContracts.CreateDocument("text/calendar"),
|
||||
@@ -315,29 +447,16 @@ private fun ExportCalendarPicker(
|
||||
predictiveBack = true,
|
||||
) {
|
||||
GroupedHint(stringResource(R.string.calendars_export_hint), style = MaterialTheme.typography.bodySmall)
|
||||
calendars.forEachIndexed { index, calendar ->
|
||||
val isSelected = calendar.id in selected
|
||||
GroupedRow(
|
||||
title = calendar.displayName.orUnnamed(),
|
||||
summary = calendar.description,
|
||||
position = positionOf(index, calendars.size),
|
||||
leading = { CalendarColorChip(calendar.color) },
|
||||
trailing = {
|
||||
Checkbox(
|
||||
checked = isSelected,
|
||||
onCheckedChange = { checked ->
|
||||
selected = if (checked) selected + calendar.id else selected - calendar.id
|
||||
},
|
||||
)
|
||||
},
|
||||
onClick = {
|
||||
selected = if (isSelected) selected - calendar.id else selected + calendar.id
|
||||
},
|
||||
)
|
||||
}
|
||||
CalendarCheckGroups(
|
||||
calendars = calendars,
|
||||
isChecked = { it.id in selected },
|
||||
onCheckedChange = { calendar, checked ->
|
||||
selected = if (checked) selected + calendar.id else selected - calendar.id
|
||||
},
|
||||
)
|
||||
Button(
|
||||
onClick = {
|
||||
runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
|
||||
runCatching { createBackup.launch(defaultBackupName()) }
|
||||
},
|
||||
enabled = selected.isNotEmpty(),
|
||||
modifier = Modifier
|
||||
@@ -349,6 +468,39 @@ private fun ExportCalendarPicker(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Choose which calendars the automatic backup covers (#147). Each tick is saved
|
||||
* at once, as a deviation from the default, so there is nothing to confirm.
|
||||
*/
|
||||
@Composable
|
||||
private fun AutoBackupCalendarPicker(
|
||||
calendars: List<CalendarSource>,
|
||||
selection: BackupSelection,
|
||||
onCheckedChange: (CalendarSource, Boolean) -> Unit,
|
||||
onDismiss: () -> Unit,
|
||||
) {
|
||||
FullScreenPicker(
|
||||
title = stringResource(R.string.calendars_auto_backup_calendars),
|
||||
onDismiss = onDismiss,
|
||||
predictiveBack = true,
|
||||
) {
|
||||
GroupedHint(
|
||||
stringResource(R.string.calendars_auto_backup_calendars_hint),
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
)
|
||||
CalendarCheckGroups(
|
||||
calendars = calendars,
|
||||
isChecked = selection::selects,
|
||||
onCheckedChange = onCheckedChange,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** "Only the latest" / "The latest 3". */
|
||||
@Composable
|
||||
private fun backupKeepLabel(keep: Int): String =
|
||||
pluralStringResource(R.plurals.calendars_auto_backup_keep_count, keep, keep)
|
||||
|
||||
/** Readable name of the persisted backup folder, resolved from its tree Uri. */
|
||||
@Composable
|
||||
private fun rememberFolderName(uriString: String?): String? {
|
||||
|
||||
@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.ui.calendars
|
||||
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.domain.FailureReason
|
||||
import de.jeanlucmakiola.calendula.domain.backup.isBackupCandidate
|
||||
import de.jeanlucmakiola.calendula.domain.calendarListFailure
|
||||
import de.jeanlucmakiola.calendula.domain.isEventTarget
|
||||
|
||||
@@ -23,31 +24,52 @@ sealed interface BackupUiState {
|
||||
data class Ready(
|
||||
val exportable: List<CalendarSource>,
|
||||
val canImport: Boolean,
|
||||
/** Some calendar can be copied into a different one (#325). */
|
||||
val canCopy: Boolean = false,
|
||||
) : BackupUiState
|
||||
}
|
||||
|
||||
/**
|
||||
* What the screen can offer for this calendar list.
|
||||
*
|
||||
* Export covers the app's own local calendars; managed special-dates mirrors are
|
||||
* rebuilt from contacts, so they are excluded. Restore can target anything the
|
||||
* import picker offers ([isEventTarget]).
|
||||
* Export can read any calendar (#147) — the local ones are only its default;
|
||||
* managed special-dates mirrors are rebuilt from contacts, so they are excluded
|
||||
* ([isBackupCandidate]). Restore can target anything the import picker offers
|
||||
* ([isEventTarget]).
|
||||
*
|
||||
* A failure is raised only when *neither* is possible — deliberately not
|
||||
* [calendarListFailure] on its own, which would call an all-hidden device a
|
||||
* failure while its local calendars are still perfectly exportable. When both
|
||||
* halves are dead the list itself usually says why (no calendars, everything
|
||||
* switched off); [FailureReason.NoImportTarget] covers the remaining case, where
|
||||
* calendars exist and are visible but every one of them is read-only, managed or
|
||||
* not synced to the device.
|
||||
* failure while its calendars are still perfectly exportable. Since export
|
||||
* reads hidden and read-only calendars too, both halves are dead only when there
|
||||
* is no calendar at all, or every one is managed or not synced to the device
|
||||
* ([FailureReason.NoImportTarget] unless the list itself says why).
|
||||
*/
|
||||
fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
|
||||
val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
|
||||
val exportable = calendars.filter { it.isBackupCandidate }
|
||||
val canImport = calendars.any { it.isEventTarget }
|
||||
if (exportable.isEmpty() && !canImport) {
|
||||
return BackupUiState.Failure(
|
||||
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<CalendarSource>): List<CalendarSource> {
|
||||
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<CalendarSource>, sourceId: Long?): List<CalendarSource> =
|
||||
calendars.filter { it.isEventTarget && it.id != sourceId }
|
||||
@@ -14,10 +14,14 @@ import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
|
||||
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.domain.FailureReason
|
||||
import de.jeanlucmakiola.calendula.domain.backup.BackupSelection
|
||||
import de.jeanlucmakiola.calendula.domain.backup.DEFAULT_BACKUP_KEEP
|
||||
import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
|
||||
import de.jeanlucmakiola.floret.android.stateWhileSubscribed
|
||||
import de.jeanlucmakiola.floret.di.IoDispatcher
|
||||
import kotlinx.coroutines.CoroutineDispatcher
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.joinAll
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
@@ -73,12 +77,19 @@ class CalendarsViewModel @Inject constructor(
|
||||
|
||||
/** Automatic-backup settings + last-run status, for the Backup section UI. */
|
||||
val autoBackup: StateFlow<AutoBackupUiState> = combine(
|
||||
settingsPrefs.autoBackupEnabled,
|
||||
settingsPrefs.autoBackupIntervalMinutes,
|
||||
settingsPrefs.autoBackupFolderUri,
|
||||
settingsPrefs.autoBackupStatus,
|
||||
) { enabled, interval, folder, status ->
|
||||
AutoBackupUiState(enabled, interval, folder, status)
|
||||
combine(
|
||||
settingsPrefs.autoBackupEnabled,
|
||||
settingsPrefs.autoBackupIntervalMinutes,
|
||||
settingsPrefs.autoBackupFolderUri,
|
||||
settingsPrefs.autoBackupStatus,
|
||||
) { enabled, interval, folder, status ->
|
||||
AutoBackupUiState(enabled, interval, folder, status)
|
||||
},
|
||||
settingsPrefs.autoBackupSelection,
|
||||
settingsPrefs.autoBackupCombined,
|
||||
settingsPrefs.autoBackupKeep,
|
||||
) { base, selection, combined, keep ->
|
||||
base.copy(selection = selection, combined = combined, keep = keep)
|
||||
}
|
||||
.flowOn(io)
|
||||
.stateWhileSubscribed(
|
||||
@@ -115,18 +126,22 @@ class CalendarsViewModel @Inject constructor(
|
||||
fun consumeBackupResult() { _backupResult.value = null }
|
||||
|
||||
/**
|
||||
* Serialise every event of the writable local calendars into the chosen SAF
|
||||
* document [uri] as one `VCALENDAR`. Result (event count, or failure) lands
|
||||
* Serialise every event of [calendarIds] into the chosen SAF document [uri]
|
||||
* as one `VCALENDAR`. Result (event count, or failure) lands
|
||||
* in [backupResult] for a one-shot message.
|
||||
*/
|
||||
fun exportBackup(uri: Uri, calendarIds: Set<Long>? = null) {
|
||||
fun exportBackup(uri: Uri, calendarIds: Set<Long>) {
|
||||
viewModelScope.launch {
|
||||
_backupResult.value = try {
|
||||
val count = withContext(io) {
|
||||
val events = repository.exportEvents(calendarIds)
|
||||
// A one-calendar file is named after it, as the automatic backup's are.
|
||||
val name = calendarIds.singleOrNull()?.let { id ->
|
||||
repository.calendars().first().firstOrNull { it.id == id }?.displayName
|
||||
}
|
||||
icsExporter.writeDocument(
|
||||
uri = uri,
|
||||
content = IcsWriter().writeCalendar(events, Clock.System.now()),
|
||||
content = IcsWriter().writeCalendar(events, Clock.System.now(), name),
|
||||
)
|
||||
events.size
|
||||
}
|
||||
@@ -204,6 +219,49 @@ class CalendarsViewModel @Inject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
/** Selection writes since the calendar picker opened; the run after it waits for them. */
|
||||
private val selectionWrites = mutableListOf<Job>()
|
||||
|
||||
fun setAutoBackupCalendar(calendar: CalendarSource, included: Boolean) {
|
||||
selectionWrites += viewModelScope.launch { settingsPrefs.setAutoBackupCalendar(calendar, included) }
|
||||
}
|
||||
|
||||
fun setAutoBackupCombined(combined: Boolean) {
|
||||
viewModelScope.launch {
|
||||
if (settingsPrefs.autoBackupCombined.first() == combined) return@launch
|
||||
settingsPrefs.setAutoBackupCombined(combined)
|
||||
runBackupIfActive()
|
||||
}
|
||||
}
|
||||
|
||||
fun setAutoBackupKeep(keep: Int) {
|
||||
viewModelScope.launch {
|
||||
if (settingsPrefs.autoBackupKeep.first() == keep) return@launch
|
||||
settingsPrefs.setAutoBackupKeep(keep)
|
||||
runBackupIfActive()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* After the calendar choice is closed, back up what is now selected rather
|
||||
* than at the next interval — only if it changed, since every run rotates
|
||||
* an older backup out.
|
||||
*/
|
||||
fun autoBackupCalendarsChosen(before: BackupSelection) {
|
||||
val pending = selectionWrites.toList()
|
||||
selectionWrites.clear()
|
||||
viewModelScope.launch {
|
||||
pending.joinAll()
|
||||
if (settingsPrefs.autoBackupSelection.first() != before) runBackupIfActive()
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun runBackupIfActive() {
|
||||
if (settingsPrefs.autoBackupEnabled.first() && settingsPrefs.autoBackupFolderUri.first() != null) {
|
||||
BackupScheduler.runNow(context)
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun reschedule() {
|
||||
BackupScheduler.apply(
|
||||
context = context,
|
||||
@@ -232,6 +290,9 @@ data class AutoBackupUiState(
|
||||
val intervalMinutes: Long = SettingsPrefs.DEFAULT_BACKUP_INTERVAL,
|
||||
val folderUri: String? = null,
|
||||
val status: BackupStatus = BackupStatus(lastRun = 0L, lastSuccess = true, consecutiveFailures = 0),
|
||||
val selection: BackupSelection = BackupSelection(),
|
||||
val combined: Boolean = false,
|
||||
val keep: Int = DEFAULT_BACKUP_KEEP,
|
||||
)
|
||||
|
||||
/** Outcome of a whole-calendar backup, surfaced once to the screen. */
|
||||
|
||||
@@ -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>): CalendarSource? {
|
||||
val held = remember(id) { mutableStateOf<CalendarSource?>(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,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<CopyCalendars> =
|
||||
repository.calendars()
|
||||
.map<List<CalendarSource>, CopyCalendars> { CopyCalendars.Ready(it) }
|
||||
.catch { emit(CopyCalendars.Failure) }
|
||||
.stateWhileSubscribed(scope = viewModelScope, initialValue = CopyCalendars.Loading)
|
||||
|
||||
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 (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<CalendarSource>) : 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
|
||||
}
|
||||
@@ -15,6 +15,7 @@ import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
|
||||
import androidx.compose.material.icons.filled.Cloud
|
||||
import androidx.compose.material.icons.filled.PhoneAndroid
|
||||
import androidx.compose.material.icons.filled.VisibilityOff
|
||||
import androidx.compose.material3.Checkbox
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.runtime.Composable
|
||||
@@ -55,28 +56,13 @@ fun ColumnScope.CalendarPickerGroups(
|
||||
onSelect: (Long) -> Unit,
|
||||
onManageCalendars: (() -> Unit)? = null,
|
||||
) {
|
||||
val local = remember(calendars) { calendars.filter { it.isLocal } }
|
||||
val syncedGroups = remember(calendars) {
|
||||
calendars.filterNot { it.isLocal }.groupByAccount()
|
||||
}
|
||||
|
||||
if (local.isNotEmpty()) {
|
||||
CalendarPickerGroup(
|
||||
title = stringResource(R.string.calendars_local_header),
|
||||
leading = { LeadingAvatar(Icons.Default.PhoneAndroid) },
|
||||
calendars = local,
|
||||
selectedId = selectedId,
|
||||
onSelect = onSelect,
|
||||
)
|
||||
}
|
||||
syncedGroups.forEachIndexed { index, group ->
|
||||
if (local.isNotEmpty() || index > 0) Spacer(Modifier.height(16.dp))
|
||||
CalendarPickerGroup(
|
||||
title = accountGroupTitle(group),
|
||||
leading = { SourceLogo(group.accountType) },
|
||||
calendars = group.calendars,
|
||||
selectedId = selectedId,
|
||||
onSelect = onSelect,
|
||||
CalendarAccountSections(calendars) { calendar, position ->
|
||||
GroupedRow(
|
||||
title = calendar.displayName.orUnnamed(),
|
||||
position = position,
|
||||
checked = calendar.id == selectedId,
|
||||
leading = { CalendarColorChip(calendar.color) },
|
||||
onClick = { onSelect(calendar.id) },
|
||||
)
|
||||
}
|
||||
if (onManageCalendars != null) {
|
||||
@@ -98,14 +84,68 @@ fun ColumnScope.CalendarPickerGroups(
|
||||
}
|
||||
}
|
||||
|
||||
/** One account's category header (avatar + name) atop its selectable calendars. */
|
||||
/**
|
||||
* A multi-select take on [CalendarPickerGroups]: the same sections, with a
|
||||
* checkbox per calendar instead of a single check.
|
||||
*/
|
||||
@Composable
|
||||
private fun CalendarPickerGroup(
|
||||
fun ColumnScope.CalendarCheckGroups(
|
||||
calendars: List<CalendarSource>,
|
||||
isChecked: (CalendarSource) -> Boolean,
|
||||
onCheckedChange: (CalendarSource, Boolean) -> Unit,
|
||||
) {
|
||||
CalendarAccountSections(calendars) { calendar, position ->
|
||||
val checked = isChecked(calendar)
|
||||
GroupedRow(
|
||||
title = calendar.displayName.orUnnamed(),
|
||||
summary = calendar.description,
|
||||
position = position,
|
||||
leading = { CalendarColorChip(calendar.color) },
|
||||
trailing = {
|
||||
Checkbox(checked = checked, onCheckedChange = { onCheckedChange(calendar, it) })
|
||||
},
|
||||
onClick = { onCheckedChange(calendar, !checked) },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** The app's own calendars, then one section per synced account, each under its category header. */
|
||||
@Composable
|
||||
private fun CalendarAccountSections(
|
||||
calendars: List<CalendarSource>,
|
||||
row: @Composable (CalendarSource, Position) -> Unit,
|
||||
) {
|
||||
val local = remember(calendars) { calendars.filter { it.isLocal } }
|
||||
val syncedGroups = remember(calendars) {
|
||||
calendars.filterNot { it.isLocal }.groupByAccount()
|
||||
}
|
||||
|
||||
if (local.isNotEmpty()) {
|
||||
CalendarAccountSection(
|
||||
title = stringResource(R.string.calendars_local_header),
|
||||
leading = { LeadingAvatar(Icons.Default.PhoneAndroid) },
|
||||
calendars = local,
|
||||
row = row,
|
||||
)
|
||||
}
|
||||
syncedGroups.forEachIndexed { index, group ->
|
||||
if (local.isNotEmpty() || index > 0) Spacer(Modifier.height(16.dp))
|
||||
CalendarAccountSection(
|
||||
title = accountGroupTitle(group),
|
||||
leading = { SourceLogo(group.accountType) },
|
||||
calendars = group.calendars,
|
||||
row = row,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** One account's category header (avatar + name) atop its calendars. */
|
||||
@Composable
|
||||
private fun CalendarAccountSection(
|
||||
title: String,
|
||||
leading: @Composable () -> Unit,
|
||||
calendars: List<CalendarSource>,
|
||||
selectedId: Long?,
|
||||
onSelect: (Long) -> Unit,
|
||||
row: @Composable (CalendarSource, Position) -> Unit,
|
||||
) {
|
||||
GroupedRow(
|
||||
title = title,
|
||||
@@ -113,13 +153,7 @@ private fun CalendarPickerGroup(
|
||||
leading = leading,
|
||||
)
|
||||
calendars.forEachIndexed { index, calendar ->
|
||||
GroupedRow(
|
||||
title = calendar.displayName.orUnnamed(),
|
||||
position = if (index == calendars.lastIndex) Position.Bottom else Position.Middle,
|
||||
checked = calendar.id == selectedId,
|
||||
leading = { CalendarColorChip(calendar.color) },
|
||||
onClick = { onSelect(calendar.id) },
|
||||
)
|
||||
row(calendar, if (index == calendars.lastIndex) Position.Bottom else Position.Middle)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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<ResultNote> = 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<ResultNote> = 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))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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),
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -15,6 +15,7 @@ import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
|
||||
import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
|
||||
import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.domain.backup.isBackedUpByDefault
|
||||
import de.jeanlucmakiola.calendula.domain.hasVisibilitySwitch
|
||||
import de.jeanlucmakiola.calendula.domain.orderedForManager
|
||||
import de.jeanlucmakiola.calendula.ui.common.CalendarView
|
||||
@@ -483,7 +484,7 @@ private fun List<CalendarSource>.allHidden(): Boolean =
|
||||
* A read-only subscription is not a backup, so it does not count.
|
||||
*/
|
||||
private fun List<CalendarSource>.backupApplies(): Boolean {
|
||||
val exportable = any { it.isLocal && it.canModifyContents && !it.isManaged }
|
||||
val exportable = any { it.isBackedUpByDefault }
|
||||
val syncedTarget = any { !it.isLocal && it.canModifyContents }
|
||||
return exportable && !syncedTarget
|
||||
}
|
||||
@@ -880,7 +880,7 @@
|
||||
<string name="calendars_write_error">Couldn\'t save the change.</string>
|
||||
<!-- Backup (whole-calendar .ics export) -->
|
||||
<string name="calendars_backup_header">Backup</string>
|
||||
<string name="calendars_backup_hint">Local calendars aren\'t synced anywhere, so export them to an .ics file to keep a copy.</string>
|
||||
<string name="calendars_backup_hint">Export calendars to an .ics file to keep a copy. Local calendars aren\'t synced anywhere, so they need it most.</string>
|
||||
<string name="calendars_backup_action">Export as .ics file</string>
|
||||
<string name="calendars_export_title">Export calendars</string>
|
||||
<string name="calendars_export_hint">Choose which calendars to include in the .ics file.</string>
|
||||
@@ -889,13 +889,55 @@
|
||||
<string name="calendars_restore_action">Restore from .ics file</string>
|
||||
<string name="calendars_restore_hint">Import events from a backup or another calendar app.</string>
|
||||
<string name="calendars_restore_unavailable">No calendar can take the imported events yet.</string>
|
||||
<string name="calendars_copy_action">Copy events</string>
|
||||
<string name="calendars_copy_summary">Copy one calendar\'s events into another, for example to move off Google.</string>
|
||||
<string name="calendars_copy_hint">The original calendar stays as it is. Guests and invitations you declined are left out.</string>
|
||||
<string name="calendars_copy_from">From</string>
|
||||
<string name="calendars_copy_to">To</string>
|
||||
<string name="calendars_copy_choose">Choose a calendar</string>
|
||||
<string name="calendars_copy_from_title">Copy from</string>
|
||||
<string name="calendars_copy_to_title">Copy into</string>
|
||||
<string name="calendars_copy_start">Copy</string>
|
||||
<string name="calendars_copy_more">Copy more</string>
|
||||
<string name="calendars_copy_reading">Reading events…</string>
|
||||
<plurals name="calendars_copy_progress">
|
||||
<item quantity="one">%1$d of %2$d event</item>
|
||||
<item quantity="other">%1$d of %2$d events</item>
|
||||
</plurals>
|
||||
<string name="calendars_copy_done">Copy complete</string>
|
||||
<string name="calendars_copy_stopped_title">Copy stopped</string>
|
||||
<string name="calendars_copy_partial">Copy finished, some events couldn\'t be added</string>
|
||||
<string name="calendars_copy_none">No calendar can be copied into another one right now.</string>
|
||||
<string name="calendars_copy_cancelled">Copy cancelled. Run it again to finish: events that were already copied are skipped.</string>
|
||||
<string name="calendars_copy_failed">Couldn\'t copy the events.</string>
|
||||
<plurals name="calendars_copy_stopped">
|
||||
<item quantity="one">The target calendar stopped accepting events part way through. %d event was never copied.</item>
|
||||
<item quantity="other">The target calendar stopped accepting events part way through. %d events were never copied.</item>
|
||||
</plurals>
|
||||
<string name="calendars_auto_backup">Automatic backup</string>
|
||||
<string name="calendars_auto_backup_hint">Periodically export your local calendars to a folder as an .ics file.</string>
|
||||
<string name="calendars_auto_backup_hint">Periodically export your calendars to a folder as .ics files.</string>
|
||||
<string name="calendars_auto_backup_folder">Backup folder</string>
|
||||
<string name="calendars_auto_backup_folder_unset">Tap to choose a folder</string>
|
||||
<string name="calendars_auto_backup_interval">Interval</string>
|
||||
<string name="calendars_auto_backup_every">Every %1$s</string>
|
||||
<string name="calendars_auto_backup_interval_min">Minimum 30 minutes.</string>
|
||||
<string name="calendars_auto_backup_calendars">Calendars</string>
|
||||
<plurals name="calendars_auto_backup_calendars_count">
|
||||
<item quantity="one">%d calendar</item>
|
||||
<item quantity="other">%d calendars</item>
|
||||
</plurals>
|
||||
<string name="calendars_auto_backup_calendars_none">No calendar selected</string>
|
||||
<string name="calendars_auto_backup_nothing_selected">No calendar is selected, so nothing is backed up.</string>
|
||||
<string name="calendars_auto_backup_calendars_hint">Local calendars are backed up unless you turn them off. Synced calendars already live on their server, so add them here only if you want a copy in the backup folder too.</string>
|
||||
<string name="calendars_auto_backup_combined">Single file</string>
|
||||
<string name="calendars_auto_backup_combined_on">All calendars in one file</string>
|
||||
<string name="calendars_auto_backup_combined_off">One file per calendar, named after it</string>
|
||||
<string name="calendars_auto_backup_keep">Backups to keep</string>
|
||||
<plurals name="calendars_auto_backup_keep_count">
|
||||
<item quantity="one">Only the latest</item>
|
||||
<item quantity="other">The latest %d</item>
|
||||
</plurals>
|
||||
<string name="calendars_auto_backup_keep_hint">Counted per file: with one file per calendar, each calendar keeps this many dated copies, plus one undated copy of the latest backup unless a file of yours already has that name. Older backups Calendula wrote are deleted after each run; a calendar you stop backing up keeps its last files, and nothing else in the folder is touched.</string>
|
||||
<string name="calendars_auto_backup_status_never">No automatic backup yet</string>
|
||||
<string name="calendars_auto_backup_status_ok">Last backup: %1$s</string>
|
||||
<string name="calendars_auto_backup_status_failed">Last backup failed: %1$s</string>
|
||||
|
||||
+145
-4
@@ -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,19 +953,153 @@ class CalendarRepositoryImplTest {
|
||||
|
||||
repo.exportEvents(calendarIds = setOf(1L, 4L))
|
||||
|
||||
assertThat(fake.lastExportableEventsCalendarIds).containsExactly(1L, 4L)
|
||||
assertThat(fake.lastCalendarRowsIds).containsExactly(1L, 4L)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `exportEvents defaults to null so every eligible calendar is exported`(
|
||||
fun `exportEvents reads synced calendars when asked for them`(
|
||||
@TempDir tempDir: Path,
|
||||
) = runTest {
|
||||
val fake = FakeCalendarDataSource()
|
||||
val repo = testRepository(fake, tempDir, Dispatchers.Unconfined)
|
||||
|
||||
repo.exportEvents()
|
||||
repo.exportEvents(calendarIds = setOf(2L))
|
||||
|
||||
assertThat(fake.lastExportableEventsCalendarIds).isNull()
|
||||
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<Pair<Int, Int>>()
|
||||
|
||||
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") =
|
||||
|
||||
+7
-9
@@ -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<SearchCandidate> = { _ -> emptyList() }
|
||||
var eventDetailResult: (Long) -> EventDetail? = { null }
|
||||
var publishedEventColorsResult: (Long) -> List<EventColorOption> = { emptyList() }
|
||||
var exportableEventsResult: List<IcsEvent> = emptyList()
|
||||
/** The [calendarIds] the last [exportableEvents] call received (null = all). */
|
||||
var lastExportableEventsCalendarIds: Set<Long>? = null
|
||||
var calendarRowsResult: CalendarRows = CalendarRows(emptyList(), emptyList())
|
||||
/** The [calendarIds] the last [calendarRows] call received. */
|
||||
var lastCalendarRowsIds: Set<Long>? = null
|
||||
/** UIDs the target calendar already holds, for import dedup. */
|
||||
var existingUidsResult: Set<String> = 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<EventColorOption> =
|
||||
publishedEventColorsResult(calendarId)
|
||||
override fun exportableEvents(
|
||||
calendarIds: Set<Long>?,
|
||||
allDayReminderTimeMinutes: Int,
|
||||
): List<IcsEvent> {
|
||||
lastExportableEventsCalendarIds = calendarIds
|
||||
return exportableEventsResult
|
||||
override fun calendarRows(calendarIds: Set<Long>, allDayReminderTimeMinutes: Int): CalendarRows {
|
||||
lastCalendarRowsIds = calendarIds
|
||||
return calendarRowsResult
|
||||
}
|
||||
|
||||
override fun existingUids(calendarId: Long): Set<String> = existingUidsResult
|
||||
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
+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 = 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)
|
||||
}
|
||||
}
|
||||
@@ -7,6 +7,7 @@ import de.jeanlucmakiola.floret.reminders.ReminderOverride
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.datastore.preferences.core.stringPreferencesKey
|
||||
import com.google.common.truth.Truth.assertThat
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import de.jeanlucmakiola.calendula.domain.EventFormField
|
||||
import de.jeanlucmakiola.calendula.domain.FontRole
|
||||
import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
|
||||
@@ -705,4 +706,85 @@ class SettingsPrefsTest {
|
||||
prefs.recordSpecialDatesRun(2000L, null)
|
||||
assertThat(prefs.specialDatesStatus.first()).isEqualTo(SpecialDatesStatus(2000L, null))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a fresh install backs up one file per calendar, keeping three`(@TempDir tempDir: Path) = runTest {
|
||||
val prefs = testSettings(tempDir)
|
||||
prefs.setAutoBackupFolderUri("content://tree/a")
|
||||
assertThat(prefs.autoBackupCombined.first()).isFalse()
|
||||
assertThat(prefs.autoBackupKeep.first()).isEqualTo(3)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an install that had a backup folder before 411 keeps its single file`(@TempDir tempDir: Path) = runTest {
|
||||
val store = testDataStore(tempDir, "test_settings")
|
||||
val prefs = SettingsPrefs(store)
|
||||
store.updateData { p ->
|
||||
val m = p.toMutablePreferences()
|
||||
m[stringPreferencesKey("auto_backup_folder_uri")] = "content://tree/old"
|
||||
m
|
||||
}
|
||||
assertThat(prefs.autoBackupCombined.first()).isTrue()
|
||||
|
||||
|
||||
// Picking another folder pins the layout instead of flipping it, and
|
||||
// keeps the old file recognised as this install's own.
|
||||
prefs.setAutoBackupFolderUri("content://tree/new")
|
||||
assertThat(prefs.autoBackupCombined.first()).isTrue()
|
||||
// A new folder starts a new ledger: the old file there isn't known to be ours.
|
||||
assertThat(prefs.autoBackupLedger.first()).isEmpty()
|
||||
|
||||
prefs.setAutoBackupCombined(false)
|
||||
assertThat(prefs.autoBackupCombined.first()).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `backup calendar choices are stored as deviations from the default`(@TempDir tempDir: Path) = runTest {
|
||||
val prefs = testSettings(tempDir)
|
||||
val local = backupCalendar(1L, local = true)
|
||||
val synced = backupCalendar(2L, local = false)
|
||||
|
||||
prefs.setAutoBackupCalendar(synced, true)
|
||||
prefs.setAutoBackupCalendar(local, false)
|
||||
val selection = prefs.autoBackupSelection.first()
|
||||
assertThat(selection.included).containsExactly(2L)
|
||||
assertThat(selection.excluded).containsExactly(1L)
|
||||
|
||||
prefs.setAutoBackupCalendar(local, true)
|
||||
assertThat(prefs.autoBackupSelection.first().excluded).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a stray retention count snaps to an offered one`(@TempDir tempDir: Path) = runTest {
|
||||
val prefs = testSettings(tempDir)
|
||||
prefs.setAutoBackupKeep(4)
|
||||
assertThat(prefs.autoBackupKeep.first()).isIn(listOf(3, 5))
|
||||
prefs.setAutoBackupKeep(99)
|
||||
assertThat(prefs.autoBackupKeep.first()).isEqualTo(10)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a pre-411 install adopts its old file when the layout is pinned in place`(@TempDir tempDir: Path) = runTest {
|
||||
val store = testDataStore(tempDir, "test_settings")
|
||||
val prefs = SettingsPrefs(store)
|
||||
store.updateData { p ->
|
||||
val m = p.toMutablePreferences()
|
||||
m[stringPreferencesKey("auto_backup_folder_uri")] = "content://tree/old"
|
||||
m
|
||||
}
|
||||
prefs.setAutoBackupCombined(false)
|
||||
assertThat(prefs.autoBackupLedger.first())
|
||||
.containsExactly("latest-combined", listOf("calendula-backup.ics"))
|
||||
}
|
||||
|
||||
private fun backupCalendar(id: Long, local: Boolean) = CalendarSource(
|
||||
id = id,
|
||||
displayName = "C$id",
|
||||
accountName = "a",
|
||||
accountType = if (local) "LOCAL" else "com.google",
|
||||
color = 0,
|
||||
isVisibleInSystem = true,
|
||||
canModifyContents = true,
|
||||
isLocal = local,
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
package de.jeanlucmakiola.calendula.domain.backup
|
||||
|
||||
import com.google.common.truth.Truth.assertThat
|
||||
import de.jeanlucmakiola.calendula.domain.CalendarSource
|
||||
import org.junit.jupiter.api.Test
|
||||
import java.time.LocalDateTime
|
||||
|
||||
class BackupPlanTest {
|
||||
|
||||
private fun cal(
|
||||
id: Long,
|
||||
name: String = "Calendar $id",
|
||||
local: Boolean = false,
|
||||
writable: Boolean = true,
|
||||
managed: Boolean = false,
|
||||
syncs: Boolean = true,
|
||||
) = CalendarSource(
|
||||
id = id,
|
||||
displayName = name,
|
||||
accountName = "acc",
|
||||
accountType = if (local) "LOCAL" else "bitfire.at.davdroid",
|
||||
color = 0,
|
||||
isVisibleInSystem = true,
|
||||
canModifyContents = writable,
|
||||
isLocal = local,
|
||||
isManaged = managed,
|
||||
syncsEvents = syncs,
|
||||
)
|
||||
|
||||
private val at = LocalDateTime.of(2026, 11, 13, 14, 30, 5)
|
||||
|
||||
@Test
|
||||
fun `local calendars are selected by default, synced ones are opt-in`() {
|
||||
val selection = BackupSelection()
|
||||
assertThat(selection.selects(cal(1L, local = true))).isTrue()
|
||||
assertThat(selection.selects(cal(2L))).isFalse()
|
||||
assertThat(selection.selects(cal(3L, writable = false))).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `managed and unsynced calendars are never backed up`() {
|
||||
val selection = BackupSelection(included = setOf(1L, 2L))
|
||||
assertThat(selection.selects(cal(1L, local = true, managed = true))).isFalse()
|
||||
assertThat(selection.selects(cal(2L, syncs = false))).isFalse()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `toggling back to the default leaves no trace`() {
|
||||
val synced = cal(2L)
|
||||
val local = cal(1L, local = true)
|
||||
val chosen = BackupSelection().with(synced, true).with(local, false)
|
||||
assertThat(chosen).isEqualTo(BackupSelection(included = setOf(2L), excluded = setOf(1L)))
|
||||
assertThat(chosen.with(synced, false).with(local, true)).isEqualTo(BackupSelection())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `one target per calendar, clashing names told apart by id`() {
|
||||
val targets = backupTargets(
|
||||
listOf(cal(1L, "Personal", local = true), cal(2L, "personal"), cal(3L, "Work")),
|
||||
combined = false,
|
||||
)
|
||||
assertThat(targets.map { it.baseName }).containsExactly("Personal-1", "personal-2", "Work").inOrder()
|
||||
assertThat(targets.map { it.calendarName }).containsExactly("Personal", "personal", "Work").inOrder()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a calendar named like the combined file doesn't share its series`() {
|
||||
val target = backupTargets(listOf(cal(4L, COMBINED_BACKUP_BASE)), combined = false).single()
|
||||
assertThat(target.baseName).isEqualTo("$COMBINED_BACKUP_BASE-4")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `combined mode is one target holding every calendar`() {
|
||||
val target = backupTargets(listOf(cal(1L), cal(2L)), combined = true).single()
|
||||
assertThat(target.key).isEqualTo(COMBINED_SERIES)
|
||||
assertThat(target.calendarIds).containsExactly(1L, 2L)
|
||||
assertThat(target.baseName).isEqualTo(COMBINED_BACKUP_BASE)
|
||||
assertThat(target.calendarName).isNull()
|
||||
assertThat(backupTargets(emptyList(), combined = true)).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `the new file carries the date and time of the run`() {
|
||||
assertThat(backupFileName("Work", at)).isEqualTo("Work_2026-11-13_14-30-05.ics")
|
||||
}
|
||||
|
||||
private val work = BackupTarget("1", setOf(1L), "Work", "Work")
|
||||
|
||||
@Test
|
||||
fun `pruning keeps the newest recorded files and nothing else`() {
|
||||
val ledger = mapOf("1" to listOf("Work_a.ics", "Work_b.ics", "Work_c.ics"))
|
||||
val existing = setOf("Work_a.ics", "Work_b.ics", "Work_c.ics", "Work_2026-11-01_09-00-00.ics", "Work notes.ics")
|
||||
val plan = planBackupFiles(listOf(work), ledger, existing, at, keep = 3).single()
|
||||
assertThat(plan.fileName).isEqualTo("Work_2026-11-13_14-30-05.ics")
|
||||
assertThat(plan.keep).containsExactly("Work_b.ics", "Work_c.ics").inOrder()
|
||||
assertThat(plan.prune).containsExactly("Work_a.ics")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `keeping one replaces every earlier file`() {
|
||||
val ledger = mapOf("1" to listOf("Work_a.ics", "Work_b.ics"))
|
||||
val plan = planBackupFiles(listOf(work), ledger, setOf("Work_a.ics", "Work_b.ics"), at, keep = 1).single()
|
||||
assertThat(plan.keep).isEmpty()
|
||||
assertThat(plan.prune).containsExactly("Work_a.ics", "Work_b.ics").inOrder()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `files gone from the folder are forgotten, not counted`() {
|
||||
val ledger = mapOf("1" to listOf("Work_a.ics", "Work_b.ics"))
|
||||
val plan = planBackupFiles(listOf(work), ledger, setOf("Work_b.ics"), at, keep = 2).single()
|
||||
assertThat(plan.keep).containsExactly("Work_b.ics")
|
||||
assertThat(plan.prune).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a same-named calendar never prunes another calendar's files`() {
|
||||
// Local "Work" (id 1) was backed up; the user now backs up a synced "Work" (id 9) instead.
|
||||
val ledger = mapOf("1" to listOf("Work_a.ics"))
|
||||
val synced = backupTargets(listOf(cal(9L, "Work")), combined = false).single()
|
||||
val plan = planBackupFiles(listOf(synced), ledger, setOf("Work_a.ics"), at, keep = 1).single()
|
||||
assertThat(plan.prune).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a rerun in the same second never prunes the file it writes`() {
|
||||
val name = "Work_2026-11-13_14-30-05.ics"
|
||||
val plan = planBackupFiles(listOf(work), mapOf("1" to listOf(name)), setOf(name), at, keep = 1).single()
|
||||
assertThat(plan.prune).isEmpty()
|
||||
}
|
||||
|
||||
private val combined = BackupTarget(COMBINED_SERIES, setOf(1L, 2L), COMBINED_BACKUP_BASE, null)
|
||||
|
||||
@Test
|
||||
fun `the pre-411 file is the combined stable copy only for the install that wrote it`() {
|
||||
val adopted = mapOf(latestLedgerKey(COMBINED_SERIES) to listOf(LEGACY_BACKUP_FILE))
|
||||
val owned = planBackupFiles(listOf(combined), adopted, setOf(LEGACY_BACKUP_FILE), at, 1)
|
||||
assertThat(owned.single().latestName).isEqualTo(LEGACY_BACKUP_FILE)
|
||||
assertThat(owned.single().prune).isEmpty()
|
||||
|
||||
val foreign = planBackupFiles(listOf(combined), emptyMap(), setOf(LEGACY_BACKUP_FILE), at, 1)
|
||||
assertThat(foreign.single().latestName).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a stable name recorded as a dated file by an earlier build is never pruned`() {
|
||||
val ledger = mapOf(COMBINED_SERIES to listOf(LEGACY_BACKUP_FILE, "calendula-backup_a.ics"))
|
||||
val plan = planBackupFiles(
|
||||
listOf(combined), ledger, setOf(LEGACY_BACKUP_FILE, "calendula-backup_a.ics"), at, 1,
|
||||
).single()
|
||||
assertThat(plan.prune).containsExactly("calendula-backup_a.ics")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `per-calendar series leave the legacy combined file alone`() {
|
||||
val plan = planBackupFiles(listOf(work), emptyMap(), setOf(LEGACY_BACKUP_FILE), at, keep = 1).single()
|
||||
assertThat(plan.prune).isEmpty()
|
||||
assertThat(plan.staleLatest).isEmpty()
|
||||
assertThat(plan.latestName).isEqualTo("Work.ics")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `the stable copy is never pruned and never overwrites the user's own file`() {
|
||||
val ours = planBackupFiles(
|
||||
listOf(work),
|
||||
mapOf("1" to listOf("Work_a.ics"), latestLedgerKey("1") to listOf("Work.ics")),
|
||||
setOf("Work_a.ics", "Work.ics"),
|
||||
at,
|
||||
keep = 1,
|
||||
).single()
|
||||
assertThat(ours.latestName).isEqualTo("Work.ics")
|
||||
assertThat(ours.prune).containsExactly("Work_a.ics")
|
||||
|
||||
val foreign = planBackupFiles(listOf(work), emptyMap(), setOf("Work.ics"), at, keep = 1).single()
|
||||
assertThat(foreign.latestName).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a renamed calendar replaces its old stable copy`() {
|
||||
val job = BackupTarget("1", setOf(1L), "Job", "Job")
|
||||
val plan = planBackupFiles(
|
||||
listOf(job),
|
||||
mapOf(latestLedgerKey("1") to listOf("Work.ics")),
|
||||
setOf("Work.ics"),
|
||||
at,
|
||||
keep = 3,
|
||||
).single()
|
||||
assertThat(plan.latestName).isEqualTo("Job.ics")
|
||||
assertThat(plan.staleLatest).containsExactly("Work.ics")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a stable copy is handed over to the calendar that takes its name in the same run`() {
|
||||
// Calendar 1 was "Work", is now "Job"; calendar 2 is now called "Work".
|
||||
val ledger = mapOf(latestLedgerKey("1") to listOf("Work.ics"))
|
||||
val plans = planBackupFiles(
|
||||
listOf(BackupTarget("1", setOf(1L), "Job", "Job"), BackupTarget("2", setOf(2L), "Work", "Work")),
|
||||
ledger,
|
||||
setOf("Work.ics"),
|
||||
at,
|
||||
keep = 1,
|
||||
)
|
||||
assertThat(plans[0].staleLatest).isEmpty()
|
||||
assertThat(plans[0].handOff).containsExactly("Work.ics")
|
||||
assertThat(plans[1].latestName).isEqualTo("Work.ics")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a deselected calendar's stable copy is not taken over by a same-named one`() {
|
||||
// Calendar 3 "Personal" is out of the backup; calendar 9, also "Personal", is in.
|
||||
val ledger = mapOf(latestLedgerKey("3") to listOf("Personal.ics"))
|
||||
val plan = planBackupFiles(
|
||||
listOf(BackupTarget("9", setOf(9L), "Personal", "Personal")), ledger, setOf("Personal.ics"), at, 1,
|
||||
).single()
|
||||
assertThat(plan.latestName).isNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a layout switch replaces the other layout's stable copies, a deselected calendar keeps its own`() {
|
||||
val ledger = mapOf(
|
||||
latestLedgerKey("1") to listOf("Work.ics"),
|
||||
latestLedgerKey("5") to listOf("Old.ics"),
|
||||
latestLedgerKey(COMBINED_SERIES) to listOf(LEGACY_BACKUP_FILE),
|
||||
)
|
||||
val existing = setOf("Work.ics", "Old.ics", LEGACY_BACKUP_FILE)
|
||||
assertThat(replacedLatestCopies(listOf(combined), ledger, existing))
|
||||
.containsExactly("1", listOf("Work.ics"))
|
||||
assertThat(replacedLatestCopies(listOf(work), ledger, existing))
|
||||
.containsExactly(COMBINED_SERIES, listOf(LEGACY_BACKUP_FILE))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a ledger entry is set, emptied away, and dropped with its calendar`() {
|
||||
val previous = mapOf(
|
||||
"1" to listOf("Work_a.ics"),
|
||||
latestLedgerKey("7") to listOf("Gone.ics"),
|
||||
latestLedgerKey(COMBINED_SERIES) to listOf(LEGACY_BACKUP_FILE),
|
||||
)
|
||||
val next = withLedgerEntry(previous, "1", listOf("Work_a.ics", "Work_b.ics", "Work_b.ics"), setOf("1"))
|
||||
assertThat(next).containsExactly(
|
||||
"1", listOf("Work_a.ics", "Work_b.ics"),
|
||||
latestLedgerKey(COMBINED_SERIES), listOf(LEGACY_BACKUP_FILE),
|
||||
)
|
||||
assertThat(withLedgerEntry(next, "1", emptyList(), setOf("1")).keys)
|
||||
.containsExactly(latestLedgerKey(COMBINED_SERIES))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `the ledger round-trips through storage`() {
|
||||
val ledger = mapOf("3" to listOf("Work_b.ics", "Work_a (1).ics"), COMBINED_SERIES to listOf("calendula-backup_x.ics"))
|
||||
assertThat(parseBackupLedger(persistBackupLedger(ledger))).isEqualTo(ledger)
|
||||
assertThat(persistBackupLedger(emptyMap())).isNull()
|
||||
assertThat(parseBackupLedger("garbage|/x|4/")).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `retention snaps to the offered choices`() {
|
||||
assertThat(normalizeBackupKeep(0)).isEqualTo(1)
|
||||
assertThat(normalizeBackupKeep(3)).isEqualTo(3)
|
||||
assertThat(normalizeBackupKeep(50)).isEqualTo(10)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a suffixed name that meets a real one is told apart again`() {
|
||||
val targets = backupTargets(
|
||||
listOf(cal(5L, "Work"), cal(6L, "Work"), cal(9L, "Work-5")),
|
||||
combined = false,
|
||||
)
|
||||
assertThat(targets.map { it.baseName }).containsExactly("Work-5-5", "Work-6", "Work-5-9").inOrder()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `claiming a stable copy takes it off its previous owner`() {
|
||||
val previous = mapOf(latestLedgerKey("1") to listOf("Work.ics", "Job.ics"))
|
||||
val next = withLedgerEntry(previous, latestLedgerKey("2"), listOf("Work.ics"), setOf("1", "2"))
|
||||
assertThat(next).containsExactly(
|
||||
latestLedgerKey("1"), listOf("Job.ics"),
|
||||
latestLedgerKey("2"), listOf("Work.ics"),
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a claimed hand-off shows as held elsewhere`() {
|
||||
val ledger = mapOf(latestLedgerKey("1") to listOf("Job.ics"), latestLedgerKey("2") to listOf("Work.ics"), "2" to listOf("Work_a.ics"))
|
||||
assertThat(ledger.latestHeldElsewhere("1")).containsExactly("Work.ics")
|
||||
assertThat(ledger.latestHeldElsewhere("2")).containsExactly("Job.ics")
|
||||
}
|
||||
}
|
||||
@@ -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<String> = emptyList(),
|
||||
reminders: List<Int> = 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<MasterRow>, overrides: List<OverrideRow>) =
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -45,10 +45,10 @@ class BackupUiStateTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a synced writable calendar can receive a restore`() {
|
||||
fun `a synced writable calendar can receive a restore and be backed up`() {
|
||||
val state = ready(backupUiState(listOf(cal(1L))))
|
||||
assertThat(state.canImport).isTrue()
|
||||
assertThat(state.exportable).isEmpty()
|
||||
assertThat(state.exportable.map { it.id }).containsExactly(1L)
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -62,16 +62,18 @@ class BackupUiStateTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a read-only subscription is no import target either`() {
|
||||
assertThat(failure(backupUiState(listOf(cal(1L, writable = false)))))
|
||||
.isEqualTo(FailureReason.NoImportTarget)
|
||||
fun `a read-only subscription is no import target but can be backed up`() {
|
||||
// #147: export only reads, so a subscription is fair game.
|
||||
val state = ready(backupUiState(listOf(cal(1L, writable = false))))
|
||||
assertThat(state.canImport).isFalse()
|
||||
assertThat(state.exportable).hasSize(1)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `everything switched off is reported as hidden, not as a missing target`() {
|
||||
// The remedy differs: a visibility switch fixes this one.
|
||||
assertThat(failure(backupUiState(listOf(cal(1L, visible = false)))))
|
||||
.isEqualTo(FailureReason.AllCalendarsHidden)
|
||||
fun `a switched-off synced calendar still backs up`() {
|
||||
val state = ready(backupUiState(listOf(cal(1L, visible = false))))
|
||||
assertThat(state.canImport).isFalse()
|
||||
assertThat(state.exportable).hasSize(1)
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -92,7 +94,51 @@ class BackupUiStateTest {
|
||||
@Test
|
||||
fun `a local calendar alongside a synced one offers both halves`() {
|
||||
val state = ready(backupUiState(listOf(cal(1L, local = true), cal(2L))))
|
||||
assertThat(state.exportable.map { it.id }).containsExactly(1L)
|
||||
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))
|
||||
}
|
||||
}
|
||||
+79
-9
@@ -462,15 +462,85 @@ after the event — so `toIcsEvent` decodes it back through
|
||||
`fromProviderAllDayMinutes` first, and the importing device re-encodes it against
|
||||
its own setting.
|
||||
|
||||
**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.
|
||||
**Backups read any calendar; restores still write only into targets.**
|
||||
`CalendarDataSource.calendarEvents` reads the events of whatever calendar ids it
|
||||
is given — local, synced or read-only — and leaves the choice to its callers:
|
||||
export and the automatic backup offer every calendar but the managed mirrors
|
||||
(#147), defaulting to the writable local ones (`domain/backup/BackupPlan.kt`). A
|
||||
restore runs through the normal import, whose targets stay `isEventTarget`. The
|
||||
automatic backup writes one `<calendar name>_<date>_<time>.ics` series per
|
||||
calendar, or one `calendula-backup_…` series in combined mode (#411), and prunes
|
||||
each series to the retention count after its new file has landed. Pruning only
|
||||
deletes names recorded in a per-series ledger of files the backup wrote
|
||||
(`auto_backup_files`, keyed by calendar id, reset when the folder changes),
|
||||
never whatever happens to match a
|
||||
name, so renames, same-named calendars and the user's own files are safe.
|
||||
Each series also keeps a stable undated copy (`<calendar name>.ics`, or
|
||||
`calendula-backup.ics` combined) overwritten every run, so sync tools and
|
||||
subscriptions can follow one path. Retention never touches it, and it is only
|
||||
written over a file the series itself (or a series renaming away from that name
|
||||
in the same run) recorded. A renamed calendar's old copy is deleted once the new
|
||||
one has landed, and so is a copy the layout switch replaced (per-calendar ↔ combined); a calendar taken out
|
||||
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 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 `<zone>;<stamps>` 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
|
||||
|
||||
+1
-1
Submodule floret-kit updated: a039ab5bd4...f5b51922cf.
Reference in new issue
Block a user