Feat/Track order of events in story

core/domain/build.gradle.kts

@@ -33,6 +33,7 @@ dependencies {
 
     testImplementation(Libraries.junit.api)
     testImplementation(Libraries.junit.engine)
+    testImplementation(Libraries.junit.params)
 
     testFixturesApi( Libraries.junit.api)
     testFixturesApi( Libraries.junit.engine)

core/domain/src/main/kotlin/storyevent/StoryEvent.kt

@@ -1,6 +1,7 @@
 package com.soyle.stories.domain.storyevent
 
 import com.soyle.stories.domain.character.Character
+import com.soyle.stories.domain.entities.Entity
 import com.soyle.stories.domain.location.Location
 import com.soyle.stories.domain.project.Project
 import com.soyle.stories.domain.storyevent.events.StoryEventChange
@@ -11,18 +12,18 @@ import com.soyle.stories.domain.validation.NonBlankString
 import java.util.*
 
 class StoryEvent(
-    val id: Id,
+    override val id: Id,
     val name: NonBlankString,
-    val time: Long,
+    val time: ULong,
     val projectId: Project.Id,
     val previousStoryEventId: Id?,
     val nextStoryEventId: Id?,
     val linkedLocationId: Location.Id?,
     val includedCharacterIds: List<Character.Id>
-) {
+) : Entity<StoryEvent.Id> {
 
     companion object {
-        fun create(name: NonBlankString, time: Long, projectId: Project.Id): StoryEventUpdate<StoryEventCreated> {
+        internal fun create(name: NonBlankString, time: ULong, projectId: Project.Id): StoryEventUpdate<StoryEventCreated> {
             val storyEvent = StoryEvent(Id(), name, time, projectId, null, null, null, listOf())
             val change = StoryEventCreated(storyEvent.id, name.value, time, projectId)
             return Successful(storyEvent, change)
@@ -41,11 +42,9 @@ class StoryEvent(
             )
     }
 
-    constructor(name: NonBlankString, projectId: Project.Id) : this(Id(), name, 0L, projectId, null, null, null, emptyList())
-
     private fun copy(
         name: NonBlankString = this.name,
-        time: Long = this.time,
+        time: ULong = this.time,
         previousStoryEventId: Id? = this.previousStoryEventId,
         nextStoryEventId: Id? = this.nextStoryEventId,
         linkedLocationId: Location.Id? = this.linkedLocationId,
@@ -57,7 +56,7 @@ class StoryEvent(
         if (newName == name) return noUpdate()
         return Successful(copy(name = newName), StoryEventRenamed(id, newName.value))
     }
-    fun withTime(newTime: Long): StoryEventUpdate<StoryEventRescheduled> {
+    internal fun withTime(newTime: ULong): StoryEventUpdate<StoryEventRescheduled> {
         if (newTime == time) return noUpdate()
         return Successful(copy(time = newTime), StoryEventRescheduled(id, newTime, time))
     }

core/domain/src/main/kotlin/storyevent/StoryEventRepository.kt

@@ -0,0 +1,10 @@
+package com.soyle.stories.domain.storyevent
+
+import com.soyle.stories.domain.project.Project
+
+/**
+ * Read-only repository to retrieve story events
+ */
+interface StoryEventRepository {
+    suspend fun listStoryEventsInProject(projectId: Project.Id): List<StoryEvent>
+}

core/domain/src/main/kotlin/storyevent/StoryEventTimeService.kt

@@ -0,0 +1,82 @@
+package com.soyle.stories.domain.storyevent
+
+import com.soyle.stories.domain.project.Project
+import com.soyle.stories.domain.storyevent.events.StoryEventRescheduled
+import com.soyle.stories.domain.validation.EntitySet
+import com.soyle.stories.domain.validation.NonBlankString
+import com.soyle.stories.domain.validation.entitySetOf
+import com.soyle.stories.domain.validation.toEntitySet
+import kotlin.math.abs
+
+class StoryEventTimeService(
+    private val storyEventRepository: StoryEventRepository
+) {
+
+    suspend fun createStoryEvent(
+        name: NonBlankString,
+        time: Long,
+        projectId: Project.Id
+    ): List<StoryEventUpdate<*>> {
+        if (time < 0) {
+            val creation = StoryEvent.create(name, 0u, projectId)
+            return normalizeAllStoryEventsAboveZero(creation.storyEvent, time).plus(creation)
+        }
+        return listOf(StoryEvent.create(name, time.toULong(), projectId))
+    }
+
+    suspend fun rescheduleStoryEvent(
+        storyEvent: StoryEvent,
+        newTime: Long
+    ): List<StoryEventUpdate<StoryEventRescheduled>> {
+        return if (newTime < 0) normalizeAllStoryEventsAboveZero(storyEvent, newTime)
+        else listOf(storyEvent.withTime(newTime.coerceAtLeast(0).toULong()))
+    }
+
+    suspend fun adjustStoryEventTimesBy(
+        storyEvents: EntitySet<StoryEvent>,
+        amount: Long
+    ): List<StoryEventUpdate<StoryEventRescheduled>> {
+        if (storyEvents.isEmpty()) return emptyList()
+        val projectId = storyEvents.assertPartOfSameProject()
+
+        if (storyEvents.any { it.time.toLong() + amount < 0 }) {
+            return normalizeAllStoryEventsAboveZero(projectId, storyEvents, amount)
+        } else {
+            return storyEvents.map { it.withTime(it.time + amount.toULong()) }
+        }
+    }
+
+    private suspend fun normalizeAllStoryEventsAboveZero(
+        storyEvent: StoryEvent,
+        negativeTime: Long
+    ): List<StoryEventUpdate<StoryEventRescheduled>> {
+        return normalizeAllStoryEventsAboveZero(
+            storyEvent.projectId,
+            entitySetOf(storyEvent),
+            negativeTime - storyEvent.time.toLong()
+        )
+    }
+
+    private suspend fun normalizeAllStoryEventsAboveZero(
+        projectId: Project.Id,
+        storyEvents: EntitySet<StoryEvent>,
+        adjustment: Long
+    ): List<StoryEventUpdate<StoryEventRescheduled>> {
+        val normalizedAdjustment = abs(storyEvents.minOf { it.time.toLong() + adjustment })
+        return storyEventRepository.listStoryEventsInProject(projectId)
+            .map {
+                if (storyEvents.containsEntityWithId(it.id)) {
+                    it.withTime((it.time.toLong() + adjustment + normalizedAdjustment).toULong())
+                } else {
+                    it.withTime(it.time + normalizedAdjustment.toULong())
+                }
+            }
+    }
+
+    private fun Collection<StoryEvent>.assertPartOfSameProject(): Project.Id {
+        val projectId = first().projectId
+        assert(all { it.projectId == projectId })
+        return projectId
+    }
+
+}

core/domain/src/main/kotlin/storyevent/events/StoryEventCreated.kt

@@ -6,6 +6,6 @@ import com.soyle.stories.domain.storyevent.StoryEvent
 class StoryEventCreated(
     override val storyEventId: StoryEvent.Id,
     val name: String,
-    val time: Long,
+    val time: ULong,
     val projectId: Project.Id
 ) : StoryEventChange()

core/domain/src/main/kotlin/storyevent/events/StoryEventRescheduled.kt

@@ -2,4 +2,4 @@ package com.soyle.stories.domain.storyevent.events
 
 import com.soyle.stories.domain.storyevent.StoryEvent
 
-data class StoryEventRescheduled(override val storyEventId: StoryEvent.Id, val newTime: Long, val originalTime: Long) : StoryEventChange()
+data class StoryEventRescheduled(override val storyEventId: StoryEvent.Id, val newTime: ULong, val originalTime: ULong) : StoryEventChange()

core/domain/src/main/kotlin/time/Timeline.kt

@@ -0,0 +1,11 @@
+package com.soyle.stories.domain.time
+
+import com.soyle.stories.domain.storyevent.StoryEvent
+import com.soyle.stories.domain.time.changes.TimelineUpdate
+import com.soyle.stories.domain.time.changes.UnSuccessful
+
+class Timeline {
+    fun withEvent(eventId: StoryEvent.Id): TimelineUpdate<*> {
+        return UnSuccessful(this)
+    }
+}

core/domain/src/main/kotlin/time/changes/Successful.kt

@@ -0,0 +1,12 @@
+package com.soyle.stories.domain.time.changes
+
+import com.soyle.stories.domain.time.Timeline
+
+typealias SuccessfulTimelineUpdate<E> = Successful<E>
+
+class Successful<E : TimelineChange>(
+    override val timeline: Timeline,
+    val change: E
+) : TimelineUpdate<E>() {
+    operator fun component2() = change
+}

core/domain/src/main/kotlin/time/changes/TimelineChange.kt

@@ -0,0 +1,7 @@
+package com.soyle.stories.domain.time.changes
+
+import com.soyle.stories.domain.project.Project
+
+abstract class TimelineChange {
+    abstract val projectId: Project.Id
+}

core/domain/src/main/kotlin/time/changes/TimelineUpdate.kt

@@ -0,0 +1,9 @@
+package com.soyle.stories.domain.time.changes
+
+import com.soyle.stories.domain.time.Timeline
+
+sealed class TimelineUpdate<out E : TimelineChange>() {
+
+    abstract val timeline: Timeline
+    operator fun component1() = timeline
+}

core/domain/src/main/kotlin/time/changes/UnSuccessful.kt

@@ -0,0 +1,7 @@
+package com.soyle.stories.domain.time.changes
+
+import com.soyle.stories.domain.time.Timeline
+
+typealias UnSuccessfulTimelineUpdate = UnSuccessful
+
+class UnSuccessful(override val timeline: Timeline) : TimelineUpdate<Nothing>()