Update SEQUENCE and UID handling; tests

Author: rfc2822

lib/src/main/kotlin/at/bitfire/synctools/mapping/calendar/AndroidEventProcessor.kt

@@ -10,6 +10,7 @@ import android.content.Entity
 import android.provider.CalendarContract
 import android.provider.CalendarContract.Events
 import android.provider.CalendarContract.ExtendedProperties
+import androidx.annotation.VisibleForTesting
 import at.bitfire.synctools.icalendar.AssociatedEvents
 import at.bitfire.synctools.mapping.calendar.processor.AccessLevelProcessor
 import at.bitfire.synctools.mapping.calendar.processor.AndroidEventFieldProcessor
@@ -23,7 +24,6 @@ import at.bitfire.synctools.mapping.calendar.processor.EndTimeProcessor
 import at.bitfire.synctools.mapping.calendar.processor.LocationProcessor
 import at.bitfire.synctools.mapping.calendar.processor.OrganizerProcessor
 import at.bitfire.synctools.mapping.calendar.processor.OriginalInstanceTimeProcessor
-import at.bitfire.synctools.mapping.calendar.processor.ProdIdGenerator
 import at.bitfire.synctools.mapping.calendar.processor.RecurrenceFieldsProcessor
 import at.bitfire.synctools.mapping.calendar.processor.RemindersProcessor
 import at.bitfire.synctools.mapping.calendar.processor.SequenceProcessor
@@ -196,36 +196,43 @@ class AndroidEventProcessor(
      *
      * @return updated sequence (or *null* if sequence was not increased/modified)
      */
-    private fun increaseSequence(main: Entity): Int? {
+    @VisibleForTesting
+    internal fun increaseSequence(main: Entity): Int? {
         val mainValues = main.entityValues
+        val currentSeq = mainValues.getAsInteger(EventsContract.COLUMN_SEQUENCE)
 
-        val weAreOrganizer: Boolean by lazy {
-            mainValues.getAsInteger(Events.IS_ORGANIZER) == 1
-        }
-        val groupScheduled: Boolean by lazy {
-            main.subValues.any { it.uri == CalendarContract.Attendees.CONTENT_URI }
+        if (currentSeq == null) {
+            /* First upload, request to set to 0 in calendar provider after upload.
+            We can let it empty in the Entity because then no SEQUENCE property will be generated,
+            which is equal to SEQUENCE:0. */
+            return 0
         }
 
-        val currentSeq = mainValues.getAsInteger(EventsContract.COLUMN_SEQUENCE)
-        return when {
-            currentSeq == null -> {
-                /* First upload, request to set to 0 in calendar provider after upload.
-                We can let it empty in the Entity because then no SEQUENCE property will be generated,
-                which is equal to SEQUENCE:0. */
-                0
-            }
-            // currentSequence != null for the following branches
-            groupScheduled && weAreOrganizer -> {
+        val groupScheduled = main.subValues.any { it.uri == CalendarContract.Attendees.CONTENT_URI }
+        if (groupScheduled) {
+            val weAreOrganizer = mainValues.getAsInteger(Events.IS_ORGANIZER) == 1
+
+            return if (weAreOrganizer) {
                 /* Upload of a group-scheduled event and we are the organizer, so we increase the SEQUENCE.
                 We also have to store it into the Entity so that it the new value will be mapped. */
                 (currentSeq + 1).also { newSeq ->
                     mainValues.put(EventsContract.COLUMN_SEQUENCE, newSeq)
                 }
-            }
-            else -> {
-                /* Standard upload (either not group-scheduled or we are not the organizer). We don't
-                increase the SEQUENCE and so we don't have to modify the Entity, too. */
+            } else
+                /* Upload of a group-scheduled event and we are not the organizer, so we don't increase the SEQUENCE. */
                 null
+
+        } else /* not group-scheduled */  {
+            return if (currentSeq == 0) {
+                /* The event was uploaded once and has SEQUENCE of 0 (which is mapped to an empty SEQUENCE property).
+                We don't need to increase the SEQUENCE because the event is not group-scheduled. */
+                null
+            } else {
+                /* Upload of a non-group-scheduled event where a SEQUENCE > 0 is present. Increase by one after upload.
+                We also have to store it into the Entity so that it the new value will be mapped. */
+                (currentSeq + 1).also { newSeq ->
+                    mainValues.put(EventsContract.COLUMN_SEQUENCE, newSeq)
+                }
             }
         }
     }
@@ -239,7 +246,9 @@ class AndroidEventProcessor(
      * @return generated data object
      */
     private fun populateEvent(entity: Entity, main: Entity): VEvent {
-        val vEvent = VEvent()
+        // initialization adds DTSTAMP
+        val vEvent = VEvent(/* initialise = */ true)
+
         for (processor in fieldProcessors)
             processor.process(from = entity, main = main, to = vEvent)
         return vEvent

lib/src/main/kotlin/at/bitfire/synctools/mapping/calendar/ProdIdGenerator.kt

@@ -0,0 +1,36 @@
+/*
+ * This file is part of bitfireAT/synctools which is released under GPLv3.
+ * Copyright © All Contributors. See the LICENSE and AUTHOR files in the root directory for details.
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+package at.bitfire.synctools.mapping.calendar
+
+fun interface ProdIdGenerator {
+
+    /**
+     * Generates a `PRODID` string using additional package names.
+     *
+     * @param packages  package names that have modified/generated the iCalendar (like `com.example.app.calendar`; may be empty)
+     *
+     * @return the full `PRODID` string, with the package names and probably additional information added
+     * (like `MyApp/1.0 (com.example.app.calendar)`)
+     */
+    fun generateProdId(packages: List<String>): String
+
+}
+
+class DefaultProdIdGenerator(
+    private val baseId: String
+): ProdIdGenerator {
+
+    override fun generateProdId(packages: List<String>): String {
+        val builder = StringBuilder(baseId)
+        if (packages.isNotEmpty())
+            builder .append(" (")
+                .append(packages.joinToString(", "))
+                .append(")")
+        return builder.toString()
+    }
+
+}

lib/src/main/kotlin/at/bitfire/synctools/mapping/calendar/builder/UidBuilder.kt

@@ -13,7 +13,8 @@ import net.fortuna.ical4j.model.component.VEvent
 class UidBuilder: AndroidEntityBuilder {
 
     override fun build(from: VEvent, main: VEvent, to: Entity) {
-        // always take UID from main event because exceptions must have the same UID anyway
+        // Always take UID from main event because exceptions must have the same UID anyway.
+        // Note: RFC 5545 requires UID for VEVENTs, however the obsoleted RFC 2445 does not.
         to.entityValues.put(Events.UID_2445, main.uid?.value)
     }
 

lib/src/main/kotlin/at/bitfire/synctools/mapping/calendar/processor/ProdIdGenerator.kt

@@ -8,17 +8,17 @@ package at.bitfire.synctools.mapping.calendar.processor
 
 import android.content.Entity
 import android.provider.CalendarContract.Events
-import at.bitfire.synctools.exception.InvalidLocalResourceException
 import net.fortuna.ical4j.model.component.VEvent
 import net.fortuna.ical4j.model.property.Uid
 
 class UidProcessor(): AndroidEventFieldProcessor {
 
     override fun process(from: Entity, main: Entity, to: VEvent) {
+        // Should always be available because AndroidEventProcessor ensures there's a UID to be RFC 5545-compliant.
+        // However technically it can be null (and no UID is OK according to RFC 2445).
         val uid = main.entityValues.getAsString(Events.UID_2445)
-            ?: throw InvalidLocalResourceException("Main event doesn't have a UID")
-
-        to.properties += Uid(uid)
+        if (uid != null)
+            to.properties += Uid(uid)
     }
 
 }