Minor adjustments

apps/coordinator/src/test/kotlin/no/iktdev/mediaprocessing/coordinator/tasksV2/listeners/ConvertWorkTaskListenerTest.kt

@@ -24,6 +24,6 @@ class ConvertWorkTaskListenerTest {
         val content = Files.MultipleLanguageBased.databaseJsonToEvents().filter { it.eventType in listOf( Events.WorkExtractPerformed, Events.ProcessStarted, Events.WorkConvertCreated, Events.WorkConvertPerformed) }
         assertThat(listener).isNotNull()
         val success = content.map { listener.shouldIProcessAndHandleEvent(it, content) to it }
-        assertThat(success.filter { it.first }.size).isGreaterThan(2)
+        assertThat(success.filter { it.first }.size).isGreaterThan(3)
     }
 }

shared/common/src/test/kotlin/no/iktdev/mediaprocessing/shared/common/DatabaseDeserializerTest.kt

@@ -1,6 +1,9 @@
 package no.iktdev.mediaprocessing.shared.common
 
 import no.iktdev.mediaprocessing.shared.common.contract.Events
+import no.iktdev.mediaprocessing.shared.common.contract.data.EpisodeInfo
+import no.iktdev.mediaprocessing.shared.common.contract.data.MediaMetadataReceivedEvent
+import no.iktdev.mediaprocessing.shared.common.contract.data.MediaOutInformationConstructedEvent
 import no.iktdev.mediaprocessing.shared.common.contract.data.StartEventData
 import no.iktdev.mediaprocessing.shared.common.contract.jsonToEvent
 import org.assertj.core.api.Assertions.assertThat
@@ -18,5 +21,80 @@ class DatabaseDeserializerTest {
         assertThat(result.eventType).isEqualTo(Events.ProcessStarted)
     }
 
+    @Test
+    fun validateMediaInfo() {
+        //language=json
+        val data = """
+            {
+                "metadata": {
+                    "derivedFromEventId": "c2ec1424-3d8f-444c-ad85-ce04e6c583fd",
+                    "eventId": "0b164f37-fa23-4b43-a31e-edfa56325eb2",
+                    "referenceId": "920e67cc-1f07-43f0-b121-e5ae87195122",
+                    "status": "Success",
+                    "created": "2025-02-24T00:39:16.057643776",
+                    "source": "MediaOutInformationTaskListener"
+                },
+                "eventType": "ReadOutNameAndType",
+                "data": {
+                    "info": {
+                        "type": "serie",
+                        "title": "The Potato",
+                        "episode": 1,
+                        "season": 2,
+                        "episodeTitle": "",
+                        "fullName": "The Bit potato"
+                    }
+                }
+            }
+        """.trimIndent()
+        val result = data.jsonToEvent("event:media-read-out-name-and-type:performed")
+        assertThat(result.data!!.javaClass).hasSameClassAs(MediaOutInformationConstructedEvent::class.java)
+        assertThat(result.eventType).isNotNull()
+        val serieInfo = (result as  MediaOutInformationConstructedEvent).data?.toValueObject()
+        assertThat(serieInfo).isNotNull()
+        assertThat(serieInfo!!.javaClass).hasSameClassAs(EpisodeInfo::class.java)
+    }
+
+    @Test
+    fun validateMetadataRead() {
+        //language=json
+        val data = """
+            {
+                "metadata": {
+                    "derivedFromEventId": "855b6de0-38f1-4ac9-9397-1ca7fc83fa4d",
+                    "eventId": "c2ec1424-3d8f-444c-ad85-ce04e6c583fd",
+                    "referenceId": "920e67cc-1f07-43f0-b121-e5ae87195122",
+                    "status": "Success",
+                    "created": "2025-02-24T00:39:15.674278",
+                    "source": "metadataApp"
+                },
+                "eventType": "EventMediaMetadataSearchPerformed",
+                "data": {
+                    "title": "Cabbage",
+                    "altTitle": [
+                        "Cabbage man"
+                    ],
+                    "cover": "https://cabbageman.co",
+                    "banner": null,
+                    "type": "serie",
+                    "summary": [
+                        {
+                            "summary": "Forced to becoma a cabbage farmer after getting their passport confiscated",
+                            "language": "eng"
+                        }
+                    ],
+                    "genres": [
+                        "Drama",
+                        "Mystery"
+                    ],
+                    "source": "yt"
+                }
+            }
+        """.trimIndent()
+        val result = data.jsonToEvent("event:media-metadata-search:performed")
+        assertThat(result.data!!.javaClass).hasSameClassAs(MediaMetadataReceivedEvent::class.java)
+        assertThat(result.eventType).isNotNull()
+        assertThat(result.data).isNotNull()
+    }
 
 }

shared/eventi/src/main/kotlin/no/iktdev/eventi/implementations/EventListenerImpl.kt

@@ -48,6 +48,16 @@ abstract class EventListenerImpl<T: EventImpl, E: EventsManagerImpl<T>> {
         return false
     }
 
+    open fun havProducedDerivedEventOnIncomingEvent(incomingEvent: T, events: List<T>): Boolean {
+        val eventId = incomingEvent.eventId()
+        val producedEventsByListener = events.filter { it.eventType == produceEvent }
+        val consumedEvent = producedEventsByListener.find { it.metadata.derivedFromEventId == eventId }
+        if (consumedEvent != null) {
+            return true
+        }
+        return false
+    }
+
 
     open fun haveProducedExpectedMessageBasedOnEvent(incomingEvent: T, events: List<T>): Boolean {
         val eventsProducedByListener = events.filter { it.eventType == produceEvent }
@@ -70,14 +80,18 @@ abstract class EventListenerImpl<T: EventImpl, E: EventsManagerImpl<T>> {
         if (haveListenerProduced)
             return false
 
-        if (haveProducedExpectedMessageBasedOnEvent(incomingEvent, events))
-            return false
-
         if (events.any { it.eventType == produceEvent } && !canProduceMultipleEvents()) {
             return false
         }
 
-        //val isDerived = events.any { it.metadata.derivedFromEventId == incomingEvent.metadata.eventId } // && incomingEvent.eventType == produceEvent
+        if (!havProducedDerivedEventOnIncomingEvent(incomingEvent, events) && canProduceMultipleEvents()) {
+            return true
+        }
+
+        if (haveProducedExpectedMessageBasedOnEvent(incomingEvent, events))
+            return false
+
+
         return true
     }