mocode-software/meldestelle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

impl Abteilung

Browse Source
This commit is contained in:
Stefan Mogeritsch 2025-05-13 22:29:23 +02:00
parent 468b45aa56
commit 0cebc711cf
20 changed files with 246 additions and 464 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Abteilung.kt
View File

@ -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()
)

41
shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Bewerb.kt
View File

@ -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
)

2
shared/src/commonMain/kotlin/at/mocode/shared/enums/Enums.kt
View File

@ -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 }

62
shared/src/commonMain/kotlin/at/mocode/shared/model/Abteilung.kt Normal file
View File

@ -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()
)

2
shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Artikel.kt → shared/src/commonMain/kotlin/at/mocode/shared/model/Artikel.kt
View File

@ -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

100
shared/src/commonMain/kotlin/at/mocode/shared/model/Bewerb.kt Normal file
View File

@ -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.

14
shared/src/commonMain/kotlin/at/mocode/shared/model/DotierungsAbstufung.kt Normal file
View File

@ -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"
)

2
shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/MeisterschaftReferenz.kt → shared/src/commonMain/kotlin/at/mocode/shared/model/MeisterschaftReferenz.kt
View File

@ -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

2
shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Platz.kt → shared/src/commonMain/kotlin/at/mocode/shared/model/Platz.kt
View File

@ -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

3
shared/src/commonMain/kotlin/at/mocode/shared/model/Pruefungsaufgabe.kt
View File

@ -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"

32
shared/src/commonMain/kotlin/at/mocode/shared/model/Richtverfahren.kt Normal file
View File

@ -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()
)

9
shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Turnier.kt → shared/src/commonMain/kotlin/at/mocode/shared/model/Turnier.kt
View File

@ -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

2
shared/src/commonMain/kotlin/at/mocode/shared/entitaeten/Veranstaltung.kt → shared/src/commonMain/kotlin/at/mocode/shared/model/Veranstaltung.kt
View File

@ -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

7
shared/src/commonMain/kotlin/at/mocode/shared/serializers/Serialization.kt
View File

@ -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())
}

1
shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/ArtikelTest.kt
View File

@ -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

387
shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/BewerbTest.kt
View File

@ -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)
}
}

1
shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/MeisterschaftReferenzTest.kt
View File

@ -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

1
shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/PlatzTest.kt
View File

@ -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

16
shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/TurnierTest.kt
View File

@ -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 vorbereitungsplatz = Platz(name = "Abreiteplatz", dimension = "40x20m", boden = "Sand", typ = PlatzTyp.VORBEREITUNG)
val austragungsplatz =
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

1
shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/VeranstaltungTest.kt
View File

@ -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