impl Abteilung

shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Abteilung.kt

@@ -1,25 +0,0 @@
-package at.mocode.shared.entitaeten
-
-import at.mocode.shared.serializers.KotlinInstantSerializer
-import at.mocode.shared.serializers.UuidSerializer
-import com.benasher44.uuid.Uuid
-import kotlinx.datetime.Clock
-import kotlinx.datetime.Instant
-import kotlinx.serialization.Serializable
-
-
-@Serializable
-data class Abteilung(
-    @Serializable(with = UuidSerializer::class)
-    val id: Uuid,
-    @Serializable(with = UuidSerializer::class)
-    val bewerbId: Uuid,
-    val bezeichnung: String, // z.B. "R1", "R2/RS2 u. höher"
-    val beginnZeit: String, // TIME als String, z.B. "09:00" oder "anschließend"
-    val istFixeBeginnZeit: Boolean = false,
-    @Serializable(with = KotlinInstantSerializer::class)
-    val createdAt: Instant = Clock.System.now(),
-    @Serializable(with = KotlinInstantSerializer::class)
-    var updatedAt: Instant = Clock.System.now()
-)
-

shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Bewerb.kt

@@ -1,41 +0,0 @@
-package at.mocode.shared.entitaeten
-
-import at.mocode.shared.enums.BewerbStatus
-import at.mocode.shared.enums.Sparte
-import at.mocode.shared.serializers.BigDecimalSerializer
-import at.mocode.shared.serializers.KotlinInstantSerializer
-import at.mocode.shared.serializers.UuidSerializer
-import com.benasher44.uuid.Uuid
-import com.ionspin.kotlin.bignum.decimal.BigDecimal
-import kotlinx.datetime.Instant
-import kotlinx.datetime.LocalDate
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class Bewerb(
-    @Serializable(with = UuidSerializer::class)
-    val id: Uuid,
-    @Serializable(with = UuidSerializer::class)
-    var turnierId: Uuid,
-    var nummer: Int,
-    var bezeichnung: String,
-    var klasse: String,
-    var datum: LocalDate,
-    var sparte: Sparte,
-    var richtverfahren: String?,
-    var beginnZeit: String, // TIME als String (z.B. "09:00" oder "anschließend")
-    var istFixeBeginnZeit: Boolean = false,
-    var laufzeitProStarter: Int?, // Dauer pro Starter in Minuten
-    var maxStarter: Int?,
-    @Serializable(with = BigDecimalSerializer::class)
-    var nenngeld: BigDecimal?,
-    var sonderpruefungReferenz: SonderpruefungReferenz?,
-    var cupReferenz: List<CupReferenz> = emptyList(),
-    var status: BewerbStatus = BewerbStatus.GEPLANT,
-    var details: String?,
-    var einteilung: String?,
-    @Serializable(with = KotlinInstantSerializer::class)
-    val createdAt: Instant,
-    @Serializable(with = KotlinInstantSerializer::class)
-    var updatedAt: Instant
-)

shared/src/commonMain/kotlin/at/mocode/shared/enums/Enums.kt

@@ -15,6 +15,8 @@ enum class BewerbStatus { GEPLANT, OFFEN_FUER_NENNUNG, GESCHLOSSEN_FUER_NENNUNG,
 @Serializable
 enum class Bedingungstyp { LIZENZ_REITER, LIZENZ_FAHRER, ALTER_PFERD, ALTER_REITER, RASSE_PFERD, GESCHLECHT_PFERD, GESCHLECHT_REITER, STARTKARTE, SONSTIGES }
 @Serializable
+enum class BeginnzeitTyp { FIX_UM, NACH_BEWERB, CA_UM, ANSCHLIESSEND }
+@Serializable
 enum class Operator { GLEICH, UNGLEICH, MINDESTENS, MAXIMAL, ZWISCHEN, IN_LISTE, NICHT_IN_LISTE }
 @Serializable
 enum class FunktionaerRolle { RICHTER, PARCOURSBAUER, PARCOURSBAU_ASSISTENT, TECHN_DELEGIERTER, TURNIERBEAUFTRAGTER, STEWARD, ZEITNEHMER, SCHREIBER, VERANSTALTER_KONTAKT, TURNIERLEITER, HELFER, SONSTIGE }

shared/src/commonMain/kotlin/at/mocode/shared/model/Abteilung.kt

@@ -0,0 +1,62 @@
+package at.mocode.shared.model
+
+import at.mocode.shared.enums.BeginnzeitTyp
+import at.mocode.shared.serializers.BigDecimalSerializer
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.KotlinLocalTimeSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import com.ionspin.kotlin.bignum.decimal.BigDecimal
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalTime
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class Abteilung(
+    @Serializable(with = UuidSerializer::class)
+    val id: Uuid = uuid4(),
+    @Serializable(with = UuidSerializer::class)
+    val bewerbId: Uuid, // Gehört zu diesem Hauptbewerb
+
+    var abteilungsKennzeichen: String, // z.B. "1", "A", "R1", oder generiert "Abt1"
+    var bezeichnungIntern: String?,    // Zur Unterscheidung im Admin, z.B. "R1 Reiter", "Lizenzfrei", "Pony LK3"
+    var bezeichnungAufStartliste: String?, // Wie es auf der Start/Ergebnisliste erscheinen soll
+
+    // Kriterien für diese Abteilung (aus SUDO "Teilen nach:")
+    var teilungsKriteriumLizenz: String? = null, // z.B. "R1", "R2+R3", "lizenzfrei" (kann komplex sein)
+    var teilungsKriteriumPferdealter: String? = null,
+    var teilungsKriteriumAltersklasseReiter: String? = null,
+    var teilungsKriteriumAnzahlMin: Int? = null, // Mindestanzahl für diese Teilung
+    var teilungsKriteriumAnzahlMax: Int? = null, // Maximale Anzahl für diese Teilung
+    var teilungsKriteriumFreiText: String? = null, // Für "freie Angabe"
+
+    // Überschreibt ggf. Werte vom Hauptbewerb
+    @Serializable(with = BigDecimalSerializer::class)
+    var startgeld: BigDecimal? = null,
+    var dotierungen: List<DotierungsAbstufung> = emptyList(),
+    @Serializable(with = UuidSerializer::class)
+    var platzId: Uuid?, // FK zum Austragungsplatz (kann vom Hauptbewerb abweichen)
+    var datum: LocalDate?,
+    var beginnzeitTyp: BeginnzeitTyp = BeginnzeitTyp.ANSCHLIESSEND,
+    @Serializable(with = KotlinLocalTimeSerializer::class)
+    var beginnzeitFix: LocalTime? = null,
+    @Serializable(with = UuidSerializer::class)
+    var beginnNachAbteilungId: Uuid?, // Reihenfolge der Abteilungen
+    var beginnzeitCa: LocalTime? = null,
+    var dauerProStartGeschaetztSek: Int? = null,
+    var umbauzeitNachAbteilungMin: Int? = null,
+    var besichtigungszeitVorAbteilungMin: Int? = null,
+    var stechzeitZusaetzlichMin: Int? = null,
+
+    var anzahlStarter: Int = 0, // Wird später befüllt
+    var istAktiv: Boolean = true, // Kann diese Abteilung genannt werden?
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/Artikel.kt

@@ -1,4 +1,4 @@
-package at.mocode.shared.entitaeten
+package at.mocode.shared.model
 
 import at.mocode.shared.serializers.BigDecimalSerializer
 import at.mocode.shared.serializers.KotlinInstantSerializer

shared/src/commonMain/kotlin/at/mocode/shared/model/Bewerb.kt

@@ -0,0 +1,100 @@
+package at.mocode.shared.model
+
+import at.mocode.shared.enums.BeginnzeitTyp
+import at.mocode.shared.enums.Sparte
+import at.mocode.shared.serializers.*
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import com.ionspin.kotlin.bignum.decimal.BigDecimal
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalTime
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class Bewerb(
+    @Serializable(with = UuidSerializer::class)
+    val id: Uuid = uuid4(),
+    @Serializable(with = UuidSerializer::class)
+    val turnierId: Uuid,
+
+    // Allgemeine Infos
+    var nummer: String,                     // Offizielle Nummer aus Ausschreibung, z.B. "12"
+    var bezeichnungOffiziell: String,       // z.B. "Dressurprüfung Kl. L", "Standardspringprüfung 115cm"
+    var internerName: String?,              // Für Listen, falls abweichend/kürzer
+    var sparte: Sparte,
+    var klasse: String?,                    // z.B. "L", "115cm", "Reiterpass"
+    var kategorieOetoDesBewerbs: String?, // ÖTO Kategorie, z.B. "CDN-C Neu". Kann vom Turnier abweichen/spezifischer sein.
+    // Wird für die Gültigkeit von Regeln/Lizenzen herangezogen.
+    var teilnahmebedingungenText: String? = null, // Freitext für spezielle Teilnahmebedingungen
+
+    // Detail-Informationen (aus den Tabs deines alten Programms)
+    var maxPferdeProReiter: Int? = null,
+    var pferdealterAnforderung: String? = null, // z.B. "4-jährig", "alle", "5-6j."
+    var zusatzTextZeile1: String? = null,       // Für Cup-Namen, Sponsoren etc. auf Ergebnislisten
+    var zusatzTextZeile2: String? = null,
+    var zusatzTextZeile3: String? = null,
+    var logoBewerbUrl: String? = null,
+    var parcoursskizzeUrl: String? = null,
+
+    // Bewertung & Aufgabe
+    var pruefungsArtDetailName: String?, // Beschreibung der Prüfung aus SUDO "Prüfung" Dropdown
+    @Serializable(with = UuidSerializer::class)
+    var pruefungsaufgabeId: Uuid?,         // FK zu Pruefungsaufgabe.id (bes. für Dressur)
+    @Serializable(with = UuidSerializer::class)
+    var richtverfahrenId: Uuid?,           // FK zu Richtverfahren.id
+    var anzahlRichterGeplant: Int? = 1,
+    var paraGradeAnforderung: String? = null,
+    var istManuellKalkuliert: Boolean = false, // Für Ergebnisberechnung
+
+    // Geldpreis/Dotierung
+    var istDotiert: Boolean = false,
+    @Serializable(with = BigDecimalSerializer::class)
+    var startgeldStandard: BigDecimal? = null, // Standard-Startgeld für diesen Bewerb
+    @Serializable(with = BigDecimalSerializer::class)
+    var startgeldKaderreiter: BigDecimal? = null,
+    var auszahlungsModusGeldpreis: String? = null,
+    var hatGeldpreisFuerKaderreiter: Boolean = false,
+    @Serializable(with = UuidSerializer::class)
+    var geldpreisVorlageId: Uuid?, // FK zu einer GeldpreisVorlagen-Tabelle (optional für später)
+    var dotierungenManuell: List<DotierungsAbstufung> = emptyList(),
+
+    // Ort/Zeit (Default-Werte, können pro Abteilung überschrieben werden)
+    @Serializable(with = UuidSerializer::class)
+    var standardPlatzId: Uuid?, // FK zum Default-Austragungsplatz
+    @Serializable(with = KotlinLocalDateSerializer::class)
+    var standardDatum: LocalDate?,
+    var standardBeginnzeitTyp: BeginnzeitTyp = BeginnzeitTyp.ANSCHLIESSEND, // neuer Enum Wert
+    @Serializable(with = KotlinLocalTimeSerializer::class)
+    var standardBeginnzeitFix: LocalTime? = null,
+    @Serializable(with = UuidSerializer::class)
+    var standardBeginnNachBewerbId: Uuid?,
+    @Serializable(with = KotlinLocalTimeSerializer::class)
+    var standardBeginnzeitCa: LocalTime? = null,
+    var standardDauerProStartGeschaetztSek: Int? = 120,
+    var standardUmbauzeitNachBewerbMin: Int? = 10,
+    var standardBesichtigungszeitVorBewerbMin: Int? = 10,
+    var standardStechzeitZusaetzlichMin: Int? = 0,
+
+    // ÖTO/ZNS Spezifika
+    var oepsBewerbsartCodeZns: String? = null,
+    var oepsAltersklasseCodeZns: String? = null,
+    var oepsPferderassenCodeZns: String? = null,
+
+    // Steuerung
+    var notizenIntern: String? = null,
+    var istStartlisteFinal: Boolean = false,
+    var istErgebnislisteFinal: Boolean = false,
+    var erfordertAbteilungsAuswahlFuerNennung: Boolean = true, // Standardmäßig ja, außer es gibt nur eine Default-Abteilung
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)
+
+// Enum BeginnzeitTypEnum um ANSCHLIESSEND erweitern
+
+// ANSCHLIESSEND wäre der Standard, wenn keine explizite Zeit oder "nach Bewerb X" angegeben ist.

shared/src/commonMain/kotlin/at/mocode/shared/model/DotierungsAbstufung.kt

@@ -0,0 +1,14 @@
+package at.mocode.shared.model
+
+import at.mocode.shared.serializers.BigDecimalSerializer
+import com.ionspin.kotlin.bignum.decimal.BigDecimal
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class DotierungsAbstufung(
+    val platz: Int,         // Für welchen Platz gilt dieser Geldpreis (z.B. 1, 2, 3)
+    @Serializable(with = BigDecimalSerializer::class)
+    val betrag: BigDecimal,
+    val beschreibung: String? = null // z.B. "Ehrenpreis zusätzlich"
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/MeisterschaftReferenz.kt

@@ -1,4 +1,4 @@
-package at.mocode.shared.entitaeten
+package at.mocode.shared.model
 
 import at.mocode.shared.serializers.UuidSerializer
 import com.benasher44.uuid.Uuid

shared/src/commonMain/kotlin/at/mocode/shared/model/Platz.kt

@@ -1,4 +1,4 @@
-package at.mocode.shared.entitaeten
+package at.mocode.shared.model
 
 import at.mocode.shared.enums.PlatzTyp
 import at.mocode.shared.serializers.UuidSerializer

shared/src/commonMain/kotlin/at/mocode/shared/model/Pruefungsaufgabe.kt

@@ -4,6 +4,7 @@ import at.mocode.shared.enums.Sparte
 import at.mocode.shared.serializers.KotlinInstantSerializer
 import at.mocode.shared.serializers.UuidSerializer
 import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import kotlinx.serialization.Serializable
@@ -11,7 +12,7 @@ import kotlinx.serialization.Serializable
 @Serializable
 data class Pruefungsaufgabe(
     @Serializable(with = UuidSerializer::class)
-    val id: Uuid,
+    val id: Uuid = uuid4(),
     var kuerzel: String, // Eindeutiges Kürzel, z.B. "A1", "LF3", "FEI GP PSG"
     var nameLang: String, // Vollständiger Name, z.B. "Dressuraufgabe A1 (GM, 20x40m)"
     var kategorieText: String?, // Übergeordnete Kategorie, z.B. "Dressuraufgaben Klasse A", "FEI Grand Prix Serie"

shared/src/commonMain/kotlin/at/mocode/shared/model/Richtverfahren.kt

@@ -0,0 +1,32 @@
+package at.mocode.shared.model
+
+import at.mocode.shared.enums.Sparte
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Richtverfahren(
+    @Serializable(with = UuidSerializer::class)
+    val id: Uuid = uuid4(),
+    var code: String, // Eindeutiger Code, z.B. "A", "A2_OETO204", "C_ZEIT", "STIL_A_IDEALZEIT"
+    var bezeichnung: String, // z.B. "Standardspringprüfung nach Fehlern und Zeit (§204 A2)", "Stilspringprüfung Kl. A mit Idealzeit"
+    var sparte: Sparte,
+    var basisRegelnBeschreibungKurz: String?, // Kurze Beschreibung oder Hauptmerkmal
+    var oetoParagraphVerweis: String?, // z.B. "ÖTO §204 A2", "ÖTO §104"
+    var hatStechen: Boolean = false,
+    var artDesStechens: String? = null, // z.B. "nach Fehlern/Zeit", "nur Fehler"
+    // Weitere strukturierte Regeln könnten hier folgen, z.B. für Fehlerpunkte, Zeitberechnung.
+    // Für V1 könnten viele Regeln noch in der Anwendungslogik sein, basierend auf dem `code`.
+    // Beispiel für strukturierte Fehler:
+    // var fehlerdefinitionen: Map<String, Double> = emptyMap(), // z.B. "HINDERNIS" -> 4.0
+    var istAktiv: Boolean = true,
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/Turnier.kt

@@ -1,7 +1,12 @@
-package at.mocode.shared.entitaeten
+package at.mocode.shared.model
 
+import at.mocode.shared.model.Artikel
 import at.mocode.shared.enums.NennungsArt
-import at.mocode.shared.serializers.*
+import at.mocode.shared.serializers.BigDecimalSerializer
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.KotlinLocalDateSerializer
+import at.mocode.shared.serializers.KotlinLocalDateTimeSerializer
+import at.mocode.shared.serializers.UuidSerializer
 import com.benasher44.uuid.Uuid
 import com.benasher44.uuid.uuid4
 import com.ionspin.kotlin.bignum.decimal.BigDecimal

shared/src/commonMain/kotlin/at/mocode/shared/model/Veranstaltung.kt

@@ -1,4 +1,4 @@
-package at.mocode.shared.entitaeten
+package at.mocode.shared.model
 
 import at.mocode.shared.enums.VeranstalterTyp
 import at.mocode.shared.serializers.KotlinInstantSerializer

shared/src/commonMain/kotlin/at/mocode/shared/serializers/Serialization.kt

@@ -6,6 +6,7 @@ import com.ionspin.kotlin.bignum.decimal.BigDecimal
 import kotlinx.datetime.Instant
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
@@ -42,3 +43,9 @@ object KotlinLocalDateTimeSerializer : KSerializer<LocalDateTime> {
     override fun serialize(encoder: Encoder, value: LocalDateTime) = encoder.encodeString(value.toString())
     override fun deserialize(decoder: Decoder): LocalDateTime = LocalDateTime.parse(decoder.decodeString())
 }
+
+object KotlinLocalTimeSerializer : KSerializer<LocalTime> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("LocalTime", PrimitiveKind.STRING)
+    override fun serialize(encoder: Encoder, value: LocalTime) = encoder.encodeString(value.toString())
+    override fun deserialize(decoder: Decoder): LocalTime = LocalTime.parse(decoder.decodeString())
+}

shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/ArtikelTest.kt

@@ -1,5 +1,6 @@
 package at.mocode.shared.entitaeten
 
+import at.mocode.shared.model.Artikel
 import com.benasher44.uuid.uuid4
 import com.ionspin.kotlin.bignum.decimal.BigDecimal
 import kotlinx.datetime.Clock

shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/BewerbTest.kt

@@ -1,387 +0,0 @@
-package at.mocode.shared.entitaeten
-
-import at.mocode.shared.enums.BewerbStatus
-import at.mocode.shared.enums.Sparte
-import com.benasher44.uuid.uuid4
-import com.ionspin.kotlin.bignum.decimal.BigDecimal
-import kotlinx.datetime.Clock
-import kotlinx.datetime.LocalDate
-import kotlinx.serialization.json.Json
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertTrue
-
-class BewerbTest {
-
-    @Test
-    fun testCreateBewerb() {
-        // Create a Bewerb with minimal required parameters
-        val id = uuid4()
-        val turnierId = uuid4()
-        val datum = LocalDate(2023, 6, 1)
-        val now = Clock.System.now()
-
-        val bewerb = Bewerb(
-            id = id,
-            turnierId = turnierId,
-            nummer = 1,
-            bezeichnung = "Test Bewerb",
-            klasse = "A",
-            datum = datum,
-            sparte = Sparte.DRESSUR,
-            richtverfahren = null,
-            beginnZeit = "09:00",
-            istFixeBeginnZeit = false,
-            laufzeitProStarter = null,
-            maxStarter = null,
-            nenngeld = null,
-            sonderpruefungReferenz = null,
-            cupReferenz = emptyList(),
-            status = BewerbStatus.GEPLANT,
-            details = null,
-            einteilung = null,
-            createdAt = now,
-            updatedAt = now
-        )
-
-        // Verify required fields
-        assertEquals(id, bewerb.id)
-        assertEquals(turnierId, bewerb.turnierId)
-        assertEquals(1, bewerb.nummer)
-        assertEquals("Test Bewerb", bewerb.bezeichnung)
-        assertEquals("A", bewerb.klasse)
-        assertEquals(datum, bewerb.datum)
-        assertEquals(Sparte.DRESSUR, bewerb.sparte)
-        assertEquals("09:00", bewerb.beginnZeit)
-        assertEquals(false, bewerb.istFixeBeginnZeit)
-        assertEquals(BewerbStatus.GEPLANT, bewerb.status)
-        assertEquals(now, bewerb.createdAt)
-        assertEquals(now, bewerb.updatedAt)
-
-        // Verify default values
-        assertEquals(null, bewerb.richtverfahren)
-        assertEquals(null, bewerb.laufzeitProStarter)
-        assertEquals(null, bewerb.maxStarter)
-        assertEquals(null, bewerb.nenngeld)
-        assertEquals(null, bewerb.sonderpruefungReferenz)
-        assertTrue(bewerb.cupReferenz.isEmpty())
-        assertEquals(null, bewerb.details)
-        assertEquals(null, bewerb.einteilung)
-    }
-
-    @Test
-    fun testCreateBewerbWithAllParameters() {
-        // Create a Bewerb with all parameters
-        val id = uuid4()
-        val turnierId = uuid4()
-        val datum = LocalDate(2023, 7, 15)
-        val now = Clock.System.now()
-
-        // Create some test objects for lists
-        val cupId = uuid4()
-        val cupReferenz = CupReferenz(
-            cupId = cupId,
-            name = "Test Cup",
-            betrifftBewerbNummern = listOf(1, 2, 3),
-            berechnungsstrategie = "Standard",
-            reglementUrl = null
-        )
-
-        val sonderpruefungId = uuid4()
-        val sonderpruefungReferenz = SonderpruefungReferenz(
-            cupId = sonderpruefungId,
-            name = "Test Sonderprüfung",
-            betrifftBewerbNummern = listOf(1),
-            berechnungsstrategie = "Standard",
-            reglementUrl = null
-        )
-
-        val bewerb = Bewerb(
-            id = id,
-            turnierId = turnierId,
-            nummer = 2,
-            bezeichnung = "Vollständiger Bewerb",
-            klasse = "L",
-            datum = datum,
-            sparte = Sparte.SPRINGEN,
-            richtverfahren = "Standard",
-            beginnZeit = "10:30",
-            istFixeBeginnZeit = true,
-            laufzeitProStarter = 5,
-            maxStarter = 30,
-            nenngeld = BigDecimal.parseString("25.00"),
-            sonderpruefungReferenz = sonderpruefungReferenz,
-            cupReferenz = listOf(cupReferenz),
-            status = BewerbStatus.OFFEN_FUER_NENNUNG,
-            details = "Detaillierte Beschreibung",
-            einteilung = "Einteilung nach Startnummern",
-            createdAt = now,
-            updatedAt = now
-        )
-
-        // Verify all fields
-        assertEquals(id, bewerb.id)
-        assertEquals(turnierId, bewerb.turnierId)
-        assertEquals(2, bewerb.nummer)
-        assertEquals("Vollständiger Bewerb", bewerb.bezeichnung)
-        assertEquals("L", bewerb.klasse)
-        assertEquals(datum, bewerb.datum)
-        assertEquals(Sparte.SPRINGEN, bewerb.sparte)
-        assertEquals("Standard", bewerb.richtverfahren)
-        assertEquals("10:30", bewerb.beginnZeit)
-        assertEquals(true, bewerb.istFixeBeginnZeit)
-        assertEquals(5, bewerb.laufzeitProStarter)
-        assertEquals(30, bewerb.maxStarter)
-        assertEquals(BigDecimal.parseString("25.00"), bewerb.nenngeld)
-        assertNotNull(bewerb.sonderpruefungReferenz)
-        assertEquals(sonderpruefungId, bewerb.sonderpruefungReferenz?.cupId)
-        assertEquals("Test Sonderprüfung", bewerb.sonderpruefungReferenz?.name)
-        assertEquals(1, bewerb.cupReferenz.size)
-        assertEquals(cupId, bewerb.cupReferenz[0].cupId)
-        assertEquals("Test Cup", bewerb.cupReferenz[0].name)
-        assertEquals(BewerbStatus.OFFEN_FUER_NENNUNG, bewerb.status)
-        assertEquals("Detaillierte Beschreibung", bewerb.details)
-        assertEquals("Einteilung nach Startnummern", bewerb.einteilung)
-        assertEquals(now, bewerb.createdAt)
-        assertEquals(now, bewerb.updatedAt)
-    }
-
-    @Test
-    fun testModifyBewerb() {
-        // Create a Bewerb
-        val id = uuid4()
-        val turnierId = uuid4()
-        val datum = LocalDate(2023, 8, 1)
-        val now = Clock.System.now()
-
-        val bewerb = Bewerb(
-            id = id,
-            turnierId = turnierId,
-            nummer = 3,
-            bezeichnung = "Original Bewerb",
-            klasse = "M",
-            datum = datum,
-            sparte = Sparte.DRESSUR,
-            richtverfahren = null,
-            beginnZeit = "11:00",
-            istFixeBeginnZeit = false,
-            laufzeitProStarter = null,
-            maxStarter = null,
-            nenngeld = null,
-            sonderpruefungReferenz = null,
-            cupReferenz = emptyList(),
-            status = BewerbStatus.GEPLANT,
-            details = null,
-            einteilung = null,
-            createdAt = now,
-            updatedAt = now
-        )
-
-        val originalUpdatedAt = bewerb.updatedAt
-        val newTurnierId = uuid4()
-        val newDatum = LocalDate(2023, 9, 1)
-        val cupId = uuid4()
-        val cupReferenz = CupReferenz(
-            cupId = cupId,
-            name = "Neuer Cup",
-            betrifftBewerbNummern = listOf(3),
-            berechnungsstrategie = "Standard",
-            reglementUrl = null
-        )
-
-        // Modify properties
-        bewerb.turnierId = newTurnierId
-        bewerb.nummer = 4
-        bewerb.bezeichnung = "Geänderter Bewerb"
-        bewerb.klasse = "S"
-        bewerb.datum = newDatum
-        bewerb.sparte = Sparte.SPRINGEN
-        bewerb.richtverfahren = "Neues Verfahren"
-        bewerb.beginnZeit = "12:00"
-        bewerb.istFixeBeginnZeit = true
-        bewerb.laufzeitProStarter = 6
-        bewerb.maxStarter = 25
-        bewerb.nenngeld = BigDecimal.parseString("30.00")
-        bewerb.cupReferenz = listOf(cupReferenz)
-        bewerb.status = BewerbStatus.OFFEN_FUER_NENNUNG
-        bewerb.details = "Neue Details"
-        bewerb.einteilung = "Neue Einteilung"
-        bewerb.updatedAt = Clock.System.now()
-
-        // Verify modifications
-        assertEquals(newTurnierId, bewerb.turnierId)
-        assertEquals(4, bewerb.nummer)
-        assertEquals("Geänderter Bewerb", bewerb.bezeichnung)
-        assertEquals("S", bewerb.klasse)
-        assertEquals(newDatum, bewerb.datum)
-        assertEquals(Sparte.SPRINGEN, bewerb.sparte)
-        assertEquals("Neues Verfahren", bewerb.richtverfahren)
-        assertEquals("12:00", bewerb.beginnZeit)
-        assertEquals(true, bewerb.istFixeBeginnZeit)
-        assertEquals(6, bewerb.laufzeitProStarter)
-        assertEquals(25, bewerb.maxStarter)
-        assertEquals(BigDecimal.parseString("30.00"), bewerb.nenngeld)
-        assertEquals(1, bewerb.cupReferenz.size)
-        assertEquals(cupId, bewerb.cupReferenz[0].cupId)
-        assertEquals("Neuer Cup", bewerb.cupReferenz[0].name)
-        assertEquals(BewerbStatus.OFFEN_FUER_NENNUNG, bewerb.status)
-        assertEquals("Neue Details", bewerb.details)
-        assertEquals("Neue Einteilung", bewerb.einteilung)
-        // Skip updatedAt verification for wasmJs compatibility
-        // The updatedAt field is properly set, but comparison in wasmJs environment is problematic
-    }
-
-    @Test
-    fun testSerializationDeserialization() {
-        // Create a simplified Bewerb for serialization testing
-        val id = uuid4()
-        val turnierId = uuid4()
-        val datum = LocalDate(2023, 10, 1)
-        val now = Clock.System.now()
-
-        val bewerb = Bewerb(
-            id = id,
-            turnierId = turnierId,
-            nummer = 5,
-            bezeichnung = "Serialisierter Bewerb",
-            klasse = "A",
-            datum = datum,
-            sparte = Sparte.FAHREN,
-            richtverfahren = "Test Verfahren",
-            beginnZeit = "13:00",
-            istFixeBeginnZeit = true,
-            laufzeitProStarter = 7,
-            maxStarter = 20,
-            nenngeld = BigDecimal.parseString("35.00"),
-            sonderpruefungReferenz = null,
-            cupReferenz = emptyList(),
-            status = BewerbStatus.GESCHLOSSEN_FUER_NENNUNG,
-            details = "Serialisierungs-Details",
-            einteilung = null,
-            createdAt = now,
-            updatedAt = now
-        )
-
-        // Serialize to JSON
-        val json = Json {
-            prettyPrint = true
-            encodeDefaults = true
-        }
-        val jsonString = json.encodeToString(bewerb)
-
-        // Verify JSON contains expected fields
-        assertTrue(jsonString.contains("\"id\""), "JSON should contain id field")
-        assertTrue(jsonString.contains(id.toString()), "JSON should contain id value")
-        assertTrue(jsonString.contains("\"turnierId\""), "JSON should contain turnierId field")
-        assertTrue(jsonString.contains(turnierId.toString()), "JSON should contain turnierId value")
-        assertTrue(jsonString.contains("\"nummer\""), "JSON should contain nummer field")
-        assertTrue(jsonString.contains("5"), "JSON should contain nummer value")
-        assertTrue(jsonString.contains("\"bezeichnung\""), "JSON should contain bezeichnung field")
-        assertTrue(jsonString.contains("\"Serialisierter Bewerb\""), "JSON should contain bezeichnung value")
-        assertTrue(jsonString.contains("\"klasse\""), "JSON should contain klasse field")
-        assertTrue(jsonString.contains("\"A\""), "JSON should contain klasse value")
-        assertTrue(jsonString.contains("\"datum\""), "JSON should contain datum field")
-        assertTrue(jsonString.contains("\"2023-10-01\""), "JSON should contain datum value")
-        assertTrue(jsonString.contains("\"sparte\""), "JSON should contain sparte field")
-        assertTrue(jsonString.contains("\"FAHREN\""), "JSON should contain sparte value")
-        assertTrue(jsonString.contains("\"beginnZeit\""), "JSON should contain beginnZeit field")
-        assertTrue(jsonString.contains("\"13:00\""), "JSON should contain beginnZeit value")
-        assertTrue(jsonString.contains("\"nenngeld\""), "JSON should contain nenngeld field")
-        assertTrue(jsonString.contains("35"), "JSON should contain nenngeld value")
-        assertTrue(jsonString.contains("\"status\""), "JSON should contain status field")
-        assertTrue(jsonString.contains("\"GESCHLOSSEN_FUER_NENNUNG\""), "JSON should contain status value")
-
-        // Deserialize from JSON
-        val deserializedBewerb = json.decodeFromString<Bewerb>(jsonString)
-
-        // Verify deserialized object matches original
-        assertEquals(bewerb.id, deserializedBewerb.id)
-        assertEquals(bewerb.turnierId, deserializedBewerb.turnierId)
-        assertEquals(bewerb.nummer, deserializedBewerb.nummer)
-        assertEquals(bewerb.bezeichnung, deserializedBewerb.bezeichnung)
-        assertEquals(bewerb.klasse, deserializedBewerb.klasse)
-        assertEquals(bewerb.datum, deserializedBewerb.datum)
-        assertEquals(bewerb.sparte, deserializedBewerb.sparte)
-        assertEquals(bewerb.richtverfahren, deserializedBewerb.richtverfahren)
-        assertEquals(bewerb.beginnZeit, deserializedBewerb.beginnZeit)
-        assertEquals(bewerb.istFixeBeginnZeit, deserializedBewerb.istFixeBeginnZeit)
-        assertEquals(bewerb.laufzeitProStarter, deserializedBewerb.laufzeitProStarter)
-        assertEquals(bewerb.maxStarter, deserializedBewerb.maxStarter)
-        assertEquals(bewerb.nenngeld, deserializedBewerb.nenngeld)
-        assertEquals(bewerb.sonderpruefungReferenz, deserializedBewerb.sonderpruefungReferenz)
-        assertEquals(bewerb.cupReferenz, deserializedBewerb.cupReferenz)
-        assertEquals(bewerb.status, deserializedBewerb.status)
-        assertEquals(bewerb.details, deserializedBewerb.details)
-        assertEquals(bewerb.einteilung, deserializedBewerb.einteilung)
-        assertEquals(bewerb.createdAt, deserializedBewerb.createdAt)
-        assertEquals(bewerb.updatedAt, deserializedBewerb.updatedAt)
-    }
-
-    @Test
-    fun testCopyBewerb() {
-        // Create a Bewerb
-        val id = uuid4()
-        val turnierId = uuid4()
-        val datum = LocalDate(2023, 11, 1)
-        val now = Clock.System.now()
-
-        val original = Bewerb(
-            id = id,
-            turnierId = turnierId,
-            nummer = 6,
-            bezeichnung = "Original Bewerb",
-            klasse = "S",
-            datum = datum,
-            sparte = Sparte.VIELSEITIGKEIT,
-            richtverfahren = "Original Verfahren",
-            beginnZeit = "14:00",
-            istFixeBeginnZeit = false,
-            laufzeitProStarter = 8,
-            maxStarter = 15,
-            nenngeld = BigDecimal.parseString("40.00"),
-            sonderpruefungReferenz = null,
-            cupReferenz = emptyList(),
-            status = BewerbStatus.GEPLANT,
-            details = "Original Details",
-            einteilung = "Original Einteilung",
-            createdAt = now,
-            updatedAt = now
-        )
-
-        val newTurnierId = uuid4()
-        val newDatum = LocalDate(2023, 12, 1)
-
-        // Create a copy with some modified properties
-        val copy = original.copy(
-            turnierId = newTurnierId,
-            bezeichnung = "Kopierter Bewerb",
-            datum = newDatum,
-            nenngeld = BigDecimal.parseString("45.00")
-        )
-
-        // Verify copied properties
-        assertEquals(original.id, copy.id)
-        assertEquals(original.nummer, copy.nummer)
-        assertEquals(original.klasse, copy.klasse)
-        assertEquals(original.sparte, copy.sparte)
-        assertEquals(original.richtverfahren, copy.richtverfahren)
-        assertEquals(original.beginnZeit, copy.beginnZeit)
-        assertEquals(original.istFixeBeginnZeit, copy.istFixeBeginnZeit)
-        assertEquals(original.laufzeitProStarter, copy.laufzeitProStarter)
-        assertEquals(original.maxStarter, copy.maxStarter)
-        assertEquals(original.sonderpruefungReferenz, copy.sonderpruefungReferenz)
-        assertEquals(original.cupReferenz, copy.cupReferenz)
-        assertEquals(original.status, copy.status)
-        assertEquals(original.details, copy.details)
-        assertEquals(original.einteilung, copy.einteilung)
-        assertEquals(original.createdAt, copy.createdAt)
-        assertEquals(original.updatedAt, copy.updatedAt)
-
-        // Verify modified properties
-        assertEquals(newTurnierId, copy.turnierId)
-        assertEquals("Kopierter Bewerb", copy.bezeichnung)
-        assertEquals(newDatum, copy.datum)
-        assertEquals(BigDecimal.parseString("45.00"), copy.nenngeld)
-    }
-}

shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/MeisterschaftReferenzTest.kt

@@ -1,5 +1,6 @@
 package at.mocode.shared.entitaeten
 
+import at.mocode.shared.model.MeisterschaftReferenz
 import com.benasher44.uuid.uuid4
 import kotlinx.serialization.json.Json
 import kotlin.test.Test

shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/PlatzTest.kt

@@ -1,6 +1,7 @@
 package at.mocode.shared.entitaeten
 
 import at.mocode.shared.enums.PlatzTyp
+import at.mocode.shared.model.Platz
 import com.benasher44.uuid.uuid4
 import kotlinx.serialization.json.Json
 import kotlin.test.Test

shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/TurnierTest.kt

@@ -2,6 +2,10 @@ package at.mocode.shared.entitaeten
 
 import at.mocode.shared.enums.NennungsArt
 import at.mocode.shared.enums.PlatzTyp
+import at.mocode.shared.model.Artikel
+import at.mocode.shared.model.MeisterschaftReferenz
+import at.mocode.shared.model.Platz
+import at.mocode.shared.model.Turnier
 import com.benasher44.uuid.uuid4
 import com.ionspin.kotlin.bignum.decimal.BigDecimal
 import kotlinx.datetime.Clock
@@ -94,8 +98,10 @@ class TurnierTest {
 
         // Create some test objects for lists
         val nennungsArt = listOf(NennungsArt.OEPS_ZNS, NennungsArt.EIGENES_ONLINE)
-        val austragungsplatz = Platz(name = "Hauptplatz", dimension = "60x20m", boden = "Sand", typ = PlatzTyp.AUSTRAGUNG)
+        val austragungsplatz =
-        val vorbereitungsplatz = Platz(name = "Abreiteplatz", dimension = "40x20m", boden = "Sand", typ = PlatzTyp.VORBEREITUNG)
+            Platz(name = "Hauptplatz", dimension = "60x20m", boden = "Sand", typ = PlatzTyp.AUSTRAGUNG)
+        val vorbereitungsplatz =
+            Platz(name = "Abreiteplatz", dimension = "40x20m", boden = "Sand", typ = PlatzTyp.VORBEREITUNG)
         val richterIds = listOf(uuid4(), uuid4())
         val parcoursbauerIds = listOf(uuid4())
         val parcoursAssistentIds = listOf(uuid4())
@@ -218,9 +224,11 @@ class TurnierTest {
 
         // Create some test objects for lists
         val nennungsArt = listOf(NennungsArt.DIREKT_VERANSTALTER_EMAIL)
-        val austragungsplatz = Platz(name = "Neuer Hauptplatz", dimension = "70x30m", boden = "Gras", typ = PlatzTyp.AUSTRAGUNG)
+        val austragungsplatz =
+            Platz(name = "Neuer Hauptplatz", dimension = "70x30m", boden = "Gras", typ = PlatzTyp.AUSTRAGUNG)
         val richterIds = listOf(uuid4())
-        val artikel = Artikel(bezeichnung = "Neue Startgebühr", preis = BigDecimal.parseString("30.00"), einheit = "Start")
+        val artikel =
+            Artikel(bezeichnung = "Neue Startgebühr", preis = BigDecimal.parseString("30.00"), einheit = "Start")
 
         // Modify properties
         turnier.veranstaltungId = newVeranstaltungId

shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/VeranstaltungTest.kt

@@ -1,6 +1,7 @@
 package at.mocode.shared.entitaeten
 
 import at.mocode.shared.enums.VeranstalterTyp
+import at.mocode.shared.model.Veranstaltung
 import com.benasher44.uuid.uuid4
 import kotlinx.datetime.Clock
 import kotlinx.datetime.LocalDate